#include <linux/idr.h>
#include <linux/seq_file.h>
#include <linux/platform_device.h>
+#include <linux/mutex.h>
#include <asm/uaccess.h>
static LIST_HEAD(adapters);
static LIST_HEAD(drivers);
-static DECLARE_MUTEX(core_lists);
+static DEFINE_MUTEX(core_lists);
static DEFINE_IDR(i2c_adapter_idr);
/* match always succeeds, as we want the probe() to tell if we really accept this match */
return rc;
}
-struct bus_type i2c_bus_type = {
- .name = "i2c",
- .match = i2c_device_match,
- .suspend = i2c_bus_suspend,
- .resume = i2c_bus_resume,
-};
-
static int i2c_device_probe(struct device *dev)
{
return -ENODEV;
return 0;
}
+struct bus_type i2c_bus_type = {
+ .name = "i2c",
+ .match = i2c_device_match,
+ .probe = i2c_device_probe,
+ .remove = i2c_device_remove,
+ .suspend = i2c_bus_suspend,
+ .resume = i2c_bus_resume,
+};
+
void i2c_adapter_dev_release(struct device *dev)
{
struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
.owner = THIS_MODULE,
.name = "i2c_adapter",
.bus = &i2c_bus_type,
- .probe = i2c_device_probe,
- .remove = i2c_device_remove,
};
static void i2c_adapter_class_dev_release(struct class_device *dev)
struct list_head *item;
struct i2c_driver *driver;
- down(&core_lists);
+ mutex_lock(&core_lists);
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
res = -ENOMEM;
}
adap->nr = id & MAX_ID_MASK;
- init_MUTEX(&adap->bus_lock);
- init_MUTEX(&adap->clist_lock);
+ mutex_init(&adap->bus_lock);
+ mutex_init(&adap->clist_lock);
list_add_tail(&adap->list,&adapters);
INIT_LIST_HEAD(&adap->clients);
}
out_unlock:
- up(&core_lists);
+ mutex_unlock(&core_lists);
return res;
}
struct i2c_client *client;
int res = 0;
- down(&core_lists);
+ mutex_lock(&core_lists);
/* First make sure that this adapter was ever added */
list_for_each_entry(adap_from_list, &adapters, list) {
dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
out_unlock:
- up(&core_lists);
+ mutex_unlock(&core_lists);
return res;
}
{
struct list_head *item;
struct i2c_adapter *adapter;
- int res = 0;
-
- down(&core_lists);
+ int res;
/* add the driver to the list of i2c drivers in the driver core */
driver->driver.owner = owner;
driver->driver.bus = &i2c_bus_type;
- driver->driver.probe = i2c_device_probe;
- driver->driver.remove = i2c_device_remove;
res = driver_register(&driver->driver);
if (res)
- goto out_unlock;
+ return res;
+ mutex_lock(&core_lists);
+
list_add_tail(&driver->list,&drivers);
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
}
}
- out_unlock:
- up(&core_lists);
- return res;
+ mutex_unlock(&core_lists);
+ return 0;
}
EXPORT_SYMBOL(i2c_register_driver);
int res = 0;
- down(&core_lists);
+ mutex_lock(&core_lists);
/* Have a look at each adapter, if clients of this driver are still
* attached. If so, detach them to be able to kill the driver
pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
out_unlock:
- up(&core_lists);
+ mutex_unlock(&core_lists);
return 0;
}
{
int rval;
- down(&adapter->clist_lock);
+ mutex_lock(&adapter->clist_lock);
rval = __i2c_check_addr(adapter, addr);
- up(&adapter->clist_lock);
+ mutex_unlock(&adapter->clist_lock);
return rval;
}
{
struct i2c_adapter *adapter = client->adapter;
- down(&adapter->clist_lock);
+ mutex_lock(&adapter->clist_lock);
if (__i2c_check_addr(client->adapter, client->addr)) {
- up(&adapter->clist_lock);
+ mutex_unlock(&adapter->clist_lock);
return -EBUSY;
}
list_add_tail(&client->list,&adapter->clients);
- up(&adapter->clist_lock);
+ mutex_unlock(&adapter->clist_lock);
if (adapter->client_register) {
if (adapter->client_register(client)) {
}
}
- down(&adapter->clist_lock);
+ mutex_lock(&adapter->clist_lock);
list_del(&client->list);
init_completion(&client->released);
device_remove_file(&client->dev, &dev_attr_client_name);
device_unregister(&client->dev);
- up(&adapter->clist_lock);
+ mutex_unlock(&adapter->clist_lock);
wait_for_completion(&client->released);
out:
struct list_head *item;
struct i2c_client *client;
- down(&adap->clist_lock);
+ mutex_lock(&adap->clist_lock);
list_for_each(item,&adap->clients) {
client = list_entry(item, struct i2c_client, list);
if (!try_module_get(client->driver->driver.owner))
continue;
if (NULL != client->driver->command) {
- up(&adap->clist_lock);
+ mutex_unlock(&adap->clist_lock);
client->driver->command(client,cmd,arg);
- down(&adap->clist_lock);
+ mutex_lock(&adap->clist_lock);
}
module_put(client->driver->driver.owner);
}
- up(&adap->clist_lock);
+ mutex_unlock(&adap->clist_lock);
}
static int __init i2c_init(void)
}
#endif
- down(&adap->bus_lock);
+ mutex_lock(&adap->bus_lock);
ret = adap->algo->master_xfer(adap,msgs,num);
- up(&adap->bus_lock);
+ mutex_unlock(&adap->bus_lock);
return ret;
} else {
{
struct i2c_adapter *adapter;
- down(&core_lists);
+ mutex_lock(&core_lists);
adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
if (adapter && !try_module_get(adapter->owner))
adapter = NULL;
- up(&core_lists);
+ mutex_unlock(&core_lists);
return adapter;
}
}
s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
- u8 length, u8 *values)
+ u8 length, const u8 *values)
{
union i2c_smbus_data data;
- int i;
+
if (length > I2C_SMBUS_BLOCK_MAX)
length = I2C_SMBUS_BLOCK_MAX;
- for (i = 1; i <= length; i++)
- data.block[i] = values[i-1];
data.block[0] = length;
+ memcpy(&data.block[1], values, length);
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
I2C_SMBUS_WRITE,command,
I2C_SMBUS_BLOCK_DATA,&data);
s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
{
union i2c_smbus_data data;
- int i;
+
if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
I2C_SMBUS_READ,command,
I2C_SMBUS_I2C_BLOCK_DATA,&data))
return -1;
- else {
- for (i = 1; i <= data.block[0]; i++)
- values[i-1] = data.block[i];
- return data.block[0];
- }
+
+ memcpy(values, &data.block[1], data.block[0]);
+ return data.block[0];
+}
+
+s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
+ u8 length, const u8 *values)
+{
+ union i2c_smbus_data data;
+
+ if (length > I2C_SMBUS_BLOCK_MAX)
+ length = I2C_SMBUS_BLOCK_MAX;
+ data.block[0] = length;
+ memcpy(data.block + 1, values, length);
+ return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
+ I2C_SMBUS_WRITE, command,
+ I2C_SMBUS_I2C_BLOCK_DATA, &data);
}
/* Simulate a SMBus command using the i2c protocol
flags &= I2C_M_TEN | I2C_CLIENT_PEC;
if (adapter->algo->smbus_xfer) {
- down(&adapter->bus_lock);
+ mutex_lock(&adapter->bus_lock);
res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
command,size,data);
- up(&adapter->bus_lock);
+ mutex_unlock(&adapter->bus_lock);
} else
res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
command,size,data);
EXPORT_SYMBOL(i2c_smbus_write_word_data);
EXPORT_SYMBOL(i2c_smbus_write_block_data);
EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
+EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
MODULE_DESCRIPTION("I2C-Bus main module");
projects / linux-2.6-omap-h63xx.git / blobdiff