1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* ------------------------------------------------------------------------- */
20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
22 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23 Jean Delvare <khali@linux-fr.org> */
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <asm/uaccess.h>
39 static LIST_HEAD(adapters);
40 static LIST_HEAD(drivers);
41 static DEFINE_MUTEX(core_lists);
42 static DEFINE_IDR(i2c_adapter_idr);
45 /* ------------------------------------------------------------------------- */
47 /* match always succeeds, as we want the probe() to tell if we really accept this match */
48 static int i2c_device_match(struct device *dev, struct device_driver *drv)
53 static int i2c_device_probe(struct device *dev)
58 static int i2c_device_remove(struct device *dev)
63 static void i2c_device_shutdown(struct device *dev)
65 struct i2c_driver *driver;
69 driver = to_i2c_driver(dev->driver);
71 driver->shutdown(to_i2c_client(dev));
74 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
76 struct i2c_driver *driver;
80 driver = to_i2c_driver(dev->driver);
83 return driver->suspend(to_i2c_client(dev), mesg);
86 static int i2c_device_resume(struct device * dev)
88 struct i2c_driver *driver;
92 driver = to_i2c_driver(dev->driver);
95 return driver->resume(to_i2c_client(dev));
98 struct bus_type i2c_bus_type = {
100 .match = i2c_device_match,
101 .probe = i2c_device_probe,
102 .remove = i2c_device_remove,
103 .shutdown = i2c_device_shutdown,
104 .suspend = i2c_device_suspend,
105 .resume = i2c_device_resume,
108 /* ------------------------------------------------------------------------- */
110 void i2c_adapter_dev_release(struct device *dev)
112 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
113 complete(&adap->dev_released);
116 struct device_driver i2c_adapter_driver = {
117 .owner = THIS_MODULE,
118 .name = "i2c_adapter",
119 .bus = &i2c_bus_type,
122 /* ------------------------------------------------------------------------- */
124 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
126 static void i2c_adapter_class_dev_release(struct class_device *dev)
128 struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
129 complete(&adap->class_dev_released);
132 static ssize_t i2c_adapter_show_name(struct class_device *cdev, char *buf)
134 struct i2c_adapter *adap = class_dev_to_i2c_adapter(cdev);
135 return sprintf(buf, "%s\n", adap->name);
138 static struct class_device_attribute i2c_adapter_attrs[] = {
139 __ATTR(name, S_IRUGO, i2c_adapter_show_name, NULL),
143 struct class i2c_adapter_class = {
144 .owner = THIS_MODULE,
145 .name = "i2c-adapter",
146 .class_dev_attrs = i2c_adapter_attrs,
147 .release = &i2c_adapter_class_dev_release,
150 static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
152 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
153 return sprintf(buf, "%s\n", adap->name);
155 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
158 static void i2c_client_release(struct device *dev)
160 struct i2c_client *client = to_i2c_client(dev);
161 complete(&client->released);
164 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
166 struct i2c_client *client = to_i2c_client(dev);
167 return sprintf(buf, "%s\n", client->name);
171 * We can't use the DEVICE_ATTR() macro here, as we used the same name for
172 * an i2c adapter attribute (above).
174 static struct device_attribute dev_attr_client_name =
175 __ATTR(name, S_IRUGO, &show_client_name, NULL);
178 /* ---------------------------------------------------
179 * registering functions
180 * ---------------------------------------------------
184 * i2c_add_adapter is called from within the algorithm layer,
185 * when a new hw adapter registers. A new device is register to be
186 * available for clients.
188 int i2c_add_adapter(struct i2c_adapter *adap)
191 struct list_head *item;
192 struct i2c_driver *driver;
194 mutex_lock(&core_lists);
196 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
201 res = idr_get_new(&i2c_adapter_idr, adap, &id);
208 adap->nr = id & MAX_ID_MASK;
209 mutex_init(&adap->bus_lock);
210 mutex_init(&adap->clist_lock);
211 list_add_tail(&adap->list,&adapters);
212 INIT_LIST_HEAD(&adap->clients);
214 /* Add the adapter to the driver core.
215 * If the parent pointer is not set up,
216 * we add this adapter to the host bus.
218 if (adap->dev.parent == NULL) {
219 adap->dev.parent = &platform_bus;
220 printk(KERN_WARNING "**WARNING** I2C adapter driver [%s] "
221 "forgot to specify physical device; fix it!\n",
224 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
225 adap->dev.driver = &i2c_adapter_driver;
226 adap->dev.release = &i2c_adapter_dev_release;
227 res = device_register(&adap->dev);
230 res = device_create_file(&adap->dev, &dev_attr_name);
234 /* Add this adapter to the i2c_adapter class */
235 memset(&adap->class_dev, 0x00, sizeof(struct class_device));
236 adap->class_dev.dev = &adap->dev;
237 adap->class_dev.class = &i2c_adapter_class;
238 strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
239 res = class_device_register(&adap->class_dev);
241 goto out_remove_name;
243 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
245 /* inform drivers of new adapters */
246 list_for_each(item,&drivers) {
247 driver = list_entry(item, struct i2c_driver, list);
248 if (driver->attach_adapter)
249 /* We ignore the return code; if it fails, too bad */
250 driver->attach_adapter(adap);
254 mutex_unlock(&core_lists);
258 device_remove_file(&adap->dev, &dev_attr_name);
260 init_completion(&adap->dev_released); /* Needed? */
261 device_unregister(&adap->dev);
262 wait_for_completion(&adap->dev_released);
264 list_del(&adap->list);
265 idr_remove(&i2c_adapter_idr, adap->nr);
270 int i2c_del_adapter(struct i2c_adapter *adap)
272 struct list_head *item, *_n;
273 struct i2c_adapter *adap_from_list;
274 struct i2c_driver *driver;
275 struct i2c_client *client;
278 mutex_lock(&core_lists);
280 /* First make sure that this adapter was ever added */
281 list_for_each_entry(adap_from_list, &adapters, list) {
282 if (adap_from_list == adap)
285 if (adap_from_list != adap) {
286 pr_debug("i2c-core: attempting to delete unregistered "
287 "adapter [%s]\n", adap->name);
292 list_for_each(item,&drivers) {
293 driver = list_entry(item, struct i2c_driver, list);
294 if (driver->detach_adapter)
295 if ((res = driver->detach_adapter(adap))) {
296 dev_err(&adap->dev, "detach_adapter failed "
298 driver->driver.name);
303 /* detach any active clients. This must be done first, because
304 * it can fail; in which case we give up. */
305 list_for_each_safe(item, _n, &adap->clients) {
306 client = list_entry(item, struct i2c_client, list);
308 if ((res=client->driver->detach_client(client))) {
309 dev_err(&adap->dev, "detach_client failed for client "
310 "[%s] at address 0x%02x\n", client->name,
316 /* clean up the sysfs representation */
317 init_completion(&adap->dev_released);
318 init_completion(&adap->class_dev_released);
319 class_device_unregister(&adap->class_dev);
320 device_remove_file(&adap->dev, &dev_attr_name);
321 device_unregister(&adap->dev);
322 list_del(&adap->list);
324 /* wait for sysfs to drop all references */
325 wait_for_completion(&adap->dev_released);
326 wait_for_completion(&adap->class_dev_released);
328 /* free dynamically allocated bus id */
329 idr_remove(&i2c_adapter_idr, adap->nr);
331 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
334 mutex_unlock(&core_lists);
340 * What follows is the "upwards" interface: commands for talking to clients,
341 * which implement the functions to access the physical information of the
345 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
347 struct list_head *item;
348 struct i2c_adapter *adapter;
351 /* add the driver to the list of i2c drivers in the driver core */
352 driver->driver.owner = owner;
353 driver->driver.bus = &i2c_bus_type;
355 res = driver_register(&driver->driver);
359 mutex_lock(&core_lists);
361 list_add_tail(&driver->list,&drivers);
362 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
364 /* now look for instances of driver on our adapters */
365 if (driver->attach_adapter) {
366 list_for_each(item,&adapters) {
367 adapter = list_entry(item, struct i2c_adapter, list);
368 driver->attach_adapter(adapter);
372 mutex_unlock(&core_lists);
375 EXPORT_SYMBOL(i2c_register_driver);
377 int i2c_del_driver(struct i2c_driver *driver)
379 struct list_head *item1, *item2, *_n;
380 struct i2c_client *client;
381 struct i2c_adapter *adap;
385 mutex_lock(&core_lists);
387 /* Have a look at each adapter, if clients of this driver are still
388 * attached. If so, detach them to be able to kill the driver
391 list_for_each(item1,&adapters) {
392 adap = list_entry(item1, struct i2c_adapter, list);
393 if (driver->detach_adapter) {
394 if ((res = driver->detach_adapter(adap))) {
395 dev_err(&adap->dev, "detach_adapter failed "
397 driver->driver.name);
401 list_for_each_safe(item2, _n, &adap->clients) {
402 client = list_entry(item2, struct i2c_client, list);
403 if (client->driver != driver)
405 dev_dbg(&adap->dev, "detaching client [%s] "
406 "at 0x%02x\n", client->name,
408 if ((res = driver->detach_client(client))) {
409 dev_err(&adap->dev, "detach_client "
410 "failed for client [%s] at "
411 "0x%02x\n", client->name,
419 driver_unregister(&driver->driver);
420 list_del(&driver->list);
421 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
424 mutex_unlock(&core_lists);
428 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
430 struct list_head *item;
431 struct i2c_client *client;
433 list_for_each(item,&adapter->clients) {
434 client = list_entry(item, struct i2c_client, list);
435 if (client->addr == addr)
441 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
445 mutex_lock(&adapter->clist_lock);
446 rval = __i2c_check_addr(adapter, addr);
447 mutex_unlock(&adapter->clist_lock);
452 int i2c_attach_client(struct i2c_client *client)
454 struct i2c_adapter *adapter = client->adapter;
457 mutex_lock(&adapter->clist_lock);
458 if (__i2c_check_addr(client->adapter, client->addr)) {
462 list_add_tail(&client->list,&adapter->clients);
464 client->usage_count = 0;
466 client->dev.parent = &client->adapter->dev;
467 client->dev.driver = &client->driver->driver;
468 client->dev.bus = &i2c_bus_type;
469 client->dev.release = &i2c_client_release;
471 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
472 "%d-%04x", i2c_adapter_id(adapter), client->addr);
473 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
474 client->name, client->dev.bus_id);
475 res = device_register(&client->dev);
478 res = device_create_file(&client->dev, &dev_attr_client_name);
481 mutex_unlock(&adapter->clist_lock);
483 if (adapter->client_register) {
484 if (adapter->client_register(client)) {
485 dev_dbg(&adapter->dev, "client_register "
486 "failed for client [%s] at 0x%02x\n",
487 client->name, client->addr);
494 init_completion(&client->released); /* Needed? */
495 device_unregister(&client->dev);
496 wait_for_completion(&client->released);
498 list_del(&client->list);
499 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
500 "(%d)\n", client->name, client->addr, res);
502 mutex_unlock(&adapter->clist_lock);
507 int i2c_detach_client(struct i2c_client *client)
509 struct i2c_adapter *adapter = client->adapter;
512 if (client->usage_count > 0) {
513 dev_warn(&client->dev, "Client [%s] still busy, "
514 "can't detach\n", client->name);
518 if (adapter->client_unregister) {
519 res = adapter->client_unregister(client);
521 dev_err(&client->dev,
522 "client_unregister [%s] failed, "
523 "client not detached\n", client->name);
528 mutex_lock(&adapter->clist_lock);
529 list_del(&client->list);
530 init_completion(&client->released);
531 device_remove_file(&client->dev, &dev_attr_client_name);
532 device_unregister(&client->dev);
533 mutex_unlock(&adapter->clist_lock);
534 wait_for_completion(&client->released);
540 static int i2c_inc_use_client(struct i2c_client *client)
543 if (!try_module_get(client->driver->driver.owner))
545 if (!try_module_get(client->adapter->owner)) {
546 module_put(client->driver->driver.owner);
553 static void i2c_dec_use_client(struct i2c_client *client)
555 module_put(client->driver->driver.owner);
556 module_put(client->adapter->owner);
559 int i2c_use_client(struct i2c_client *client)
563 ret = i2c_inc_use_client(client);
567 client->usage_count++;
572 int i2c_release_client(struct i2c_client *client)
574 if (!client->usage_count) {
575 pr_debug("i2c-core: %s used one too many times\n",
580 client->usage_count--;
581 i2c_dec_use_client(client);
586 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
588 struct list_head *item;
589 struct i2c_client *client;
591 mutex_lock(&adap->clist_lock);
592 list_for_each(item,&adap->clients) {
593 client = list_entry(item, struct i2c_client, list);
594 if (!try_module_get(client->driver->driver.owner))
596 if (NULL != client->driver->command) {
597 mutex_unlock(&adap->clist_lock);
598 client->driver->command(client,cmd,arg);
599 mutex_lock(&adap->clist_lock);
601 module_put(client->driver->driver.owner);
603 mutex_unlock(&adap->clist_lock);
606 static int __init i2c_init(void)
610 retval = bus_register(&i2c_bus_type);
613 retval = driver_register(&i2c_adapter_driver);
616 return class_register(&i2c_adapter_class);
619 static void __exit i2c_exit(void)
621 class_unregister(&i2c_adapter_class);
622 driver_unregister(&i2c_adapter_driver);
623 bus_unregister(&i2c_bus_type);
626 subsys_initcall(i2c_init);
627 module_exit(i2c_exit);
629 /* ----------------------------------------------------
630 * the functional interface to the i2c busses.
631 * ----------------------------------------------------
634 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
638 if (adap->algo->master_xfer) {
640 for (ret = 0; ret < num; ret++) {
641 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
642 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
643 'R' : 'W', msgs[ret].addr, msgs[ret].len);
647 mutex_lock_nested(&adap->bus_lock, adap->level);
648 ret = adap->algo->master_xfer(adap,msgs,num);
649 mutex_unlock(&adap->bus_lock);
653 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
658 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
661 struct i2c_adapter *adap=client->adapter;
664 msg.addr = client->addr;
665 msg.flags = client->flags & I2C_M_TEN;
667 msg.buf = (char *)buf;
669 ret = i2c_transfer(adap, &msg, 1);
671 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
672 transmitted, else error code. */
673 return (ret == 1) ? count : ret;
676 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
678 struct i2c_adapter *adap=client->adapter;
682 msg.addr = client->addr;
683 msg.flags = client->flags & I2C_M_TEN;
684 msg.flags |= I2C_M_RD;
688 ret = i2c_transfer(adap, &msg, 1);
690 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
691 transmitted, else error code. */
692 return (ret == 1) ? count : ret;
696 int i2c_control(struct i2c_client *client,
697 unsigned int cmd, unsigned long arg)
700 struct i2c_adapter *adap = client->adapter;
702 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
711 if (adap->algo->algo_control!=NULL)
712 ret = adap->algo->algo_control(adap,cmd,arg);
717 /* ----------------------------------------------------
718 * the i2c address scanning function
719 * Will not work for 10-bit addresses!
720 * ----------------------------------------------------
722 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
723 int (*found_proc) (struct i2c_adapter *, int, int))
727 /* Make sure the address is valid */
728 if (addr < 0x03 || addr > 0x77) {
729 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
734 /* Skip if already in use */
735 if (i2c_check_addr(adapter, addr))
738 /* Make sure there is something at this address, unless forced */
740 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
741 I2C_SMBUS_QUICK, NULL) < 0)
744 /* prevent 24RF08 corruption */
745 if ((addr & ~0x0f) == 0x50)
746 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
747 I2C_SMBUS_QUICK, NULL);
750 /* Finally call the custom detection function */
751 err = found_proc(adapter, addr, kind);
752 /* -ENODEV can be returned if there is a chip at the given address
753 but it isn't supported by this chip driver. We catch it here as
754 this isn't an error. */
759 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
764 int i2c_probe(struct i2c_adapter *adapter,
765 struct i2c_client_address_data *address_data,
766 int (*found_proc) (struct i2c_adapter *, int, int))
769 int adap_id = i2c_adapter_id(adapter);
771 /* Force entries are done first, and are not affected by ignore
773 if (address_data->forces) {
774 unsigned short **forces = address_data->forces;
777 for (kind = 0; forces[kind]; kind++) {
778 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
780 if (forces[kind][i] == adap_id
781 || forces[kind][i] == ANY_I2C_BUS) {
782 dev_dbg(&adapter->dev, "found force "
783 "parameter for adapter %d, "
784 "addr 0x%02x, kind %d\n",
785 adap_id, forces[kind][i + 1],
787 err = i2c_probe_address(adapter,
797 /* Stop here if we can't use SMBUS_QUICK */
798 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
799 if (address_data->probe[0] == I2C_CLIENT_END
800 && address_data->normal_i2c[0] == I2C_CLIENT_END)
803 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
804 "can't probe for chips\n");
808 /* Probe entries are done second, and are not affected by ignore
810 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
811 if (address_data->probe[i] == adap_id
812 || address_data->probe[i] == ANY_I2C_BUS) {
813 dev_dbg(&adapter->dev, "found probe parameter for "
814 "adapter %d, addr 0x%02x\n", adap_id,
815 address_data->probe[i + 1]);
816 err = i2c_probe_address(adapter,
817 address_data->probe[i + 1],
824 /* Normal entries are done last, unless shadowed by an ignore entry */
825 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
829 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
831 if ((address_data->ignore[j] == adap_id ||
832 address_data->ignore[j] == ANY_I2C_BUS)
833 && address_data->ignore[j + 1]
834 == address_data->normal_i2c[i]) {
835 dev_dbg(&adapter->dev, "found ignore "
836 "parameter for adapter %d, "
837 "addr 0x%02x\n", adap_id,
838 address_data->ignore[j + 1]);
846 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
847 "addr 0x%02x\n", adap_id,
848 address_data->normal_i2c[i]);
849 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
858 struct i2c_adapter* i2c_get_adapter(int id)
860 struct i2c_adapter *adapter;
862 mutex_lock(&core_lists);
863 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
864 if (adapter && !try_module_get(adapter->owner))
867 mutex_unlock(&core_lists);
871 void i2c_put_adapter(struct i2c_adapter *adap)
873 module_put(adap->owner);
876 /* The SMBus parts */
878 #define POLY (0x1070U << 3)
884 for(i = 0; i < 8; i++) {
889 return (u8)(data >> 8);
892 /* Incremental CRC8 over count bytes in the array pointed to by p */
893 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
897 for(i = 0; i < count; i++)
898 crc = crc8((crc ^ p[i]) << 8);
902 /* Assume a 7-bit address, which is reasonable for SMBus */
903 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
905 /* The address will be sent first */
906 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
907 pec = i2c_smbus_pec(pec, &addr, 1);
909 /* The data buffer follows */
910 return i2c_smbus_pec(pec, msg->buf, msg->len);
913 /* Used for write only transactions */
914 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
916 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
920 /* Return <0 on CRC error
921 If there was a write before this read (most cases) we need to take the
922 partial CRC from the write part into account.
923 Note that this function does modify the message (we need to decrease the
924 message length to hide the CRC byte from the caller). */
925 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
927 u8 rpec = msg->buf[--msg->len];
928 cpec = i2c_smbus_msg_pec(cpec, msg);
931 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
938 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
940 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
941 value,0,I2C_SMBUS_QUICK,NULL);
944 s32 i2c_smbus_read_byte(struct i2c_client *client)
946 union i2c_smbus_data data;
947 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
948 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
954 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
956 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
957 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
960 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
962 union i2c_smbus_data data;
963 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
964 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
970 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
972 union i2c_smbus_data data;
974 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
975 I2C_SMBUS_WRITE,command,
976 I2C_SMBUS_BYTE_DATA,&data);
979 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
981 union i2c_smbus_data data;
982 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
983 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
989 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
991 union i2c_smbus_data data;
993 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
994 I2C_SMBUS_WRITE,command,
995 I2C_SMBUS_WORD_DATA,&data);
998 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
999 u8 length, const u8 *values)
1001 union i2c_smbus_data data;
1003 if (length > I2C_SMBUS_BLOCK_MAX)
1004 length = I2C_SMBUS_BLOCK_MAX;
1005 data.block[0] = length;
1006 memcpy(&data.block[1], values, length);
1007 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1008 I2C_SMBUS_WRITE,command,
1009 I2C_SMBUS_BLOCK_DATA,&data);
1012 /* Returns the number of read bytes */
1013 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
1015 union i2c_smbus_data data;
1017 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1018 I2C_SMBUS_READ,command,
1019 I2C_SMBUS_I2C_BLOCK_DATA,&data))
1022 memcpy(values, &data.block[1], data.block[0]);
1023 return data.block[0];
1026 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1027 u8 length, const u8 *values)
1029 union i2c_smbus_data data;
1031 if (length > I2C_SMBUS_BLOCK_MAX)
1032 length = I2C_SMBUS_BLOCK_MAX;
1033 data.block[0] = length;
1034 memcpy(data.block + 1, values, length);
1035 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1036 I2C_SMBUS_WRITE, command,
1037 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1040 /* Simulate a SMBus command using the i2c protocol
1041 No checking of parameters is done! */
1042 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1043 unsigned short flags,
1044 char read_write, u8 command, int size,
1045 union i2c_smbus_data * data)
1047 /* So we need to generate a series of msgs. In the case of writing, we
1048 need to use only one message; when reading, we need two. We initialize
1049 most things with sane defaults, to keep the code below somewhat
1051 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1052 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1053 int num = read_write == I2C_SMBUS_READ?2:1;
1054 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1055 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1060 msgbuf0[0] = command;
1062 case I2C_SMBUS_QUICK:
1064 /* Special case: The read/write field is used as data */
1065 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1068 case I2C_SMBUS_BYTE:
1069 if (read_write == I2C_SMBUS_READ) {
1070 /* Special case: only a read! */
1071 msg[0].flags = I2C_M_RD | flags;
1075 case I2C_SMBUS_BYTE_DATA:
1076 if (read_write == I2C_SMBUS_READ)
1080 msgbuf0[1] = data->byte;
1083 case I2C_SMBUS_WORD_DATA:
1084 if (read_write == I2C_SMBUS_READ)
1088 msgbuf0[1] = data->word & 0xff;
1089 msgbuf0[2] = data->word >> 8;
1092 case I2C_SMBUS_PROC_CALL:
1093 num = 2; /* Special case */
1094 read_write = I2C_SMBUS_READ;
1097 msgbuf0[1] = data->word & 0xff;
1098 msgbuf0[2] = data->word >> 8;
1100 case I2C_SMBUS_BLOCK_DATA:
1101 if (read_write == I2C_SMBUS_READ) {
1102 dev_err(&adapter->dev, "Block read not supported "
1103 "under I2C emulation!\n");
1106 msg[0].len = data->block[0] + 2;
1107 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1108 dev_err(&adapter->dev, "smbus_access called with "
1109 "invalid block write size (%d)\n",
1113 for (i = 1; i < msg[0].len; i++)
1114 msgbuf0[i] = data->block[i-1];
1117 case I2C_SMBUS_BLOCK_PROC_CALL:
1118 dev_dbg(&adapter->dev, "Block process call not supported "
1119 "under I2C emulation!\n");
1121 case I2C_SMBUS_I2C_BLOCK_DATA:
1122 if (read_write == I2C_SMBUS_READ) {
1123 msg[1].len = I2C_SMBUS_BLOCK_MAX;
1125 msg[0].len = data->block[0] + 1;
1126 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1127 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1128 "invalid block write size (%d)\n",
1132 for (i = 1; i <= data->block[0]; i++)
1133 msgbuf0[i] = data->block[i];
1137 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1142 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1143 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1145 /* Compute PEC if first message is a write */
1146 if (!(msg[0].flags & I2C_M_RD)) {
1147 if (num == 1) /* Write only */
1148 i2c_smbus_add_pec(&msg[0]);
1149 else /* Write followed by read */
1150 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1152 /* Ask for PEC if last message is a read */
1153 if (msg[num-1].flags & I2C_M_RD)
1157 if (i2c_transfer(adapter, msg, num) < 0)
1160 /* Check PEC if last message is a read */
1161 if (i && (msg[num-1].flags & I2C_M_RD)) {
1162 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1166 if (read_write == I2C_SMBUS_READ)
1168 case I2C_SMBUS_BYTE:
1169 data->byte = msgbuf0[0];
1171 case I2C_SMBUS_BYTE_DATA:
1172 data->byte = msgbuf1[0];
1174 case I2C_SMBUS_WORD_DATA:
1175 case I2C_SMBUS_PROC_CALL:
1176 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1178 case I2C_SMBUS_I2C_BLOCK_DATA:
1179 /* fixed at 32 for now */
1180 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1181 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1182 data->block[i+1] = msgbuf1[i];
1189 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1190 char read_write, u8 command, int size,
1191 union i2c_smbus_data * data)
1195 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1197 if (adapter->algo->smbus_xfer) {
1198 mutex_lock(&adapter->bus_lock);
1199 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1201 mutex_unlock(&adapter->bus_lock);
1203 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1210 /* Next four are needed by i2c-isa */
1211 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1212 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1213 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1214 EXPORT_SYMBOL_GPL(i2c_bus_type);
1216 EXPORT_SYMBOL(i2c_add_adapter);
1217 EXPORT_SYMBOL(i2c_del_adapter);
1218 EXPORT_SYMBOL(i2c_del_driver);
1219 EXPORT_SYMBOL(i2c_attach_client);
1220 EXPORT_SYMBOL(i2c_detach_client);
1221 EXPORT_SYMBOL(i2c_use_client);
1222 EXPORT_SYMBOL(i2c_release_client);
1223 EXPORT_SYMBOL(i2c_clients_command);
1224 EXPORT_SYMBOL(i2c_check_addr);
1226 EXPORT_SYMBOL(i2c_master_send);
1227 EXPORT_SYMBOL(i2c_master_recv);
1228 EXPORT_SYMBOL(i2c_control);
1229 EXPORT_SYMBOL(i2c_transfer);
1230 EXPORT_SYMBOL(i2c_get_adapter);
1231 EXPORT_SYMBOL(i2c_put_adapter);
1232 EXPORT_SYMBOL(i2c_probe);
1234 EXPORT_SYMBOL(i2c_smbus_xfer);
1235 EXPORT_SYMBOL(i2c_smbus_write_quick);
1236 EXPORT_SYMBOL(i2c_smbus_read_byte);
1237 EXPORT_SYMBOL(i2c_smbus_write_byte);
1238 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1239 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1240 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1241 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1242 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1243 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1244 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1246 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1247 MODULE_DESCRIPTION("I2C-Bus main module");
1248 MODULE_LICENSE("GPL");