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 <asm/uaccess.h>
38 static LIST_HEAD(adapters);
39 static LIST_HEAD(drivers);
40 static DEFINE_MUTEX(core_lists);
41 static DEFINE_IDR(i2c_adapter_idr);
43 /* match always succeeds, as we want the probe() to tell if we really accept this match */
44 static int i2c_device_match(struct device *dev, struct device_driver *drv)
49 static int i2c_bus_suspend(struct device * dev, pm_message_t state)
53 if (dev->driver && dev->driver->suspend)
54 rc = dev->driver->suspend(dev, state);
58 static int i2c_bus_resume(struct device * dev)
62 if (dev->driver && dev->driver->resume)
63 rc = dev->driver->resume(dev);
67 static int i2c_device_probe(struct device *dev)
72 static int i2c_device_remove(struct device *dev)
77 struct bus_type i2c_bus_type = {
79 .match = i2c_device_match,
80 .probe = i2c_device_probe,
81 .remove = i2c_device_remove,
82 .suspend = i2c_bus_suspend,
83 .resume = i2c_bus_resume,
86 void i2c_adapter_dev_release(struct device *dev)
88 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
89 complete(&adap->dev_released);
92 struct device_driver i2c_adapter_driver = {
94 .name = "i2c_adapter",
98 static void i2c_adapter_class_dev_release(struct class_device *dev)
100 struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
101 complete(&adap->class_dev_released);
104 struct class i2c_adapter_class = {
105 .owner = THIS_MODULE,
106 .name = "i2c-adapter",
107 .release = &i2c_adapter_class_dev_release,
110 static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
112 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
113 return sprintf(buf, "%s\n", adap->name);
115 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
118 static void i2c_client_release(struct device *dev)
120 struct i2c_client *client = to_i2c_client(dev);
121 complete(&client->released);
124 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
126 struct i2c_client *client = to_i2c_client(dev);
127 return sprintf(buf, "%s\n", client->name);
131 * We can't use the DEVICE_ATTR() macro here, as we used the same name for
132 * an i2c adapter attribute (above).
134 static struct device_attribute dev_attr_client_name =
135 __ATTR(name, S_IRUGO, &show_client_name, NULL);
138 /* ---------------------------------------------------
139 * registering functions
140 * ---------------------------------------------------
144 * i2c_add_adapter is called from within the algorithm layer,
145 * when a new hw adapter registers. A new device is register to be
146 * available for clients.
148 int i2c_add_adapter(struct i2c_adapter *adap)
151 struct list_head *item;
152 struct i2c_driver *driver;
154 mutex_lock(&core_lists);
156 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
161 res = idr_get_new(&i2c_adapter_idr, adap, &id);
168 adap->nr = id & MAX_ID_MASK;
169 mutex_init(&adap->bus_lock);
170 mutex_init(&adap->clist_lock);
171 list_add_tail(&adap->list,&adapters);
172 INIT_LIST_HEAD(&adap->clients);
174 /* Add the adapter to the driver core.
175 * If the parent pointer is not set up,
176 * we add this adapter to the host bus.
178 if (adap->dev.parent == NULL)
179 adap->dev.parent = &platform_bus;
180 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
181 adap->dev.driver = &i2c_adapter_driver;
182 adap->dev.release = &i2c_adapter_dev_release;
183 res = device_register(&adap->dev);
186 res = device_create_file(&adap->dev, &dev_attr_name);
190 /* Add this adapter to the i2c_adapter class */
191 memset(&adap->class_dev, 0x00, sizeof(struct class_device));
192 adap->class_dev.dev = &adap->dev;
193 adap->class_dev.class = &i2c_adapter_class;
194 strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
195 res = class_device_register(&adap->class_dev);
197 goto out_remove_name;
199 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
201 /* inform drivers of new adapters */
202 list_for_each(item,&drivers) {
203 driver = list_entry(item, struct i2c_driver, list);
204 if (driver->attach_adapter)
205 /* We ignore the return code; if it fails, too bad */
206 driver->attach_adapter(adap);
210 mutex_unlock(&core_lists);
214 device_remove_file(&adap->dev, &dev_attr_name);
216 init_completion(&adap->dev_released); /* Needed? */
217 device_unregister(&adap->dev);
218 wait_for_completion(&adap->dev_released);
220 list_del(&adap->list);
221 idr_remove(&i2c_adapter_idr, adap->nr);
226 int i2c_del_adapter(struct i2c_adapter *adap)
228 struct list_head *item, *_n;
229 struct i2c_adapter *adap_from_list;
230 struct i2c_driver *driver;
231 struct i2c_client *client;
234 mutex_lock(&core_lists);
236 /* First make sure that this adapter was ever added */
237 list_for_each_entry(adap_from_list, &adapters, list) {
238 if (adap_from_list == adap)
241 if (adap_from_list != adap) {
242 pr_debug("i2c-core: attempting to delete unregistered "
243 "adapter [%s]\n", adap->name);
248 list_for_each(item,&drivers) {
249 driver = list_entry(item, struct i2c_driver, list);
250 if (driver->detach_adapter)
251 if ((res = driver->detach_adapter(adap))) {
252 dev_err(&adap->dev, "detach_adapter failed "
254 driver->driver.name);
259 /* detach any active clients. This must be done first, because
260 * it can fail; in which case we give up. */
261 list_for_each_safe(item, _n, &adap->clients) {
262 client = list_entry(item, struct i2c_client, list);
264 if ((res=client->driver->detach_client(client))) {
265 dev_err(&adap->dev, "detach_client failed for client "
266 "[%s] at address 0x%02x\n", client->name,
272 /* clean up the sysfs representation */
273 init_completion(&adap->dev_released);
274 init_completion(&adap->class_dev_released);
275 class_device_unregister(&adap->class_dev);
276 device_remove_file(&adap->dev, &dev_attr_name);
277 device_unregister(&adap->dev);
278 list_del(&adap->list);
280 /* wait for sysfs to drop all references */
281 wait_for_completion(&adap->dev_released);
282 wait_for_completion(&adap->class_dev_released);
284 /* free dynamically allocated bus id */
285 idr_remove(&i2c_adapter_idr, adap->nr);
287 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
290 mutex_unlock(&core_lists);
296 * What follows is the "upwards" interface: commands for talking to clients,
297 * which implement the functions to access the physical information of the
301 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
303 struct list_head *item;
304 struct i2c_adapter *adapter;
307 /* add the driver to the list of i2c drivers in the driver core */
308 driver->driver.owner = owner;
309 driver->driver.bus = &i2c_bus_type;
311 res = driver_register(&driver->driver);
315 mutex_lock(&core_lists);
317 list_add_tail(&driver->list,&drivers);
318 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
320 /* now look for instances of driver on our adapters */
321 if (driver->attach_adapter) {
322 list_for_each(item,&adapters) {
323 adapter = list_entry(item, struct i2c_adapter, list);
324 driver->attach_adapter(adapter);
328 mutex_unlock(&core_lists);
331 EXPORT_SYMBOL(i2c_register_driver);
333 int i2c_del_driver(struct i2c_driver *driver)
335 struct list_head *item1, *item2, *_n;
336 struct i2c_client *client;
337 struct i2c_adapter *adap;
341 mutex_lock(&core_lists);
343 /* Have a look at each adapter, if clients of this driver are still
344 * attached. If so, detach them to be able to kill the driver
347 list_for_each(item1,&adapters) {
348 adap = list_entry(item1, struct i2c_adapter, list);
349 if (driver->detach_adapter) {
350 if ((res = driver->detach_adapter(adap))) {
351 dev_err(&adap->dev, "detach_adapter failed "
353 driver->driver.name);
357 list_for_each_safe(item2, _n, &adap->clients) {
358 client = list_entry(item2, struct i2c_client, list);
359 if (client->driver != driver)
361 dev_dbg(&adap->dev, "detaching client [%s] "
362 "at 0x%02x\n", client->name,
364 if ((res = driver->detach_client(client))) {
365 dev_err(&adap->dev, "detach_client "
366 "failed for client [%s] at "
367 "0x%02x\n", client->name,
375 driver_unregister(&driver->driver);
376 list_del(&driver->list);
377 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
380 mutex_unlock(&core_lists);
384 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
386 struct list_head *item;
387 struct i2c_client *client;
389 list_for_each(item,&adapter->clients) {
390 client = list_entry(item, struct i2c_client, list);
391 if (client->addr == addr)
397 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
401 mutex_lock(&adapter->clist_lock);
402 rval = __i2c_check_addr(adapter, addr);
403 mutex_unlock(&adapter->clist_lock);
408 int i2c_attach_client(struct i2c_client *client)
410 struct i2c_adapter *adapter = client->adapter;
413 mutex_lock(&adapter->clist_lock);
414 if (__i2c_check_addr(client->adapter, client->addr)) {
418 list_add_tail(&client->list,&adapter->clients);
420 client->usage_count = 0;
422 client->dev.parent = &client->adapter->dev;
423 client->dev.driver = &client->driver->driver;
424 client->dev.bus = &i2c_bus_type;
425 client->dev.release = &i2c_client_release;
427 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
428 "%d-%04x", i2c_adapter_id(adapter), client->addr);
429 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
430 client->name, client->dev.bus_id);
431 res = device_register(&client->dev);
434 res = device_create_file(&client->dev, &dev_attr_client_name);
437 mutex_unlock(&adapter->clist_lock);
439 if (adapter->client_register) {
440 if (adapter->client_register(client)) {
441 dev_dbg(&adapter->dev, "client_register "
442 "failed for client [%s] at 0x%02x\n",
443 client->name, client->addr);
450 init_completion(&client->released); /* Needed? */
451 device_unregister(&client->dev);
452 wait_for_completion(&client->released);
454 list_del(&client->list);
455 dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
456 "(%d)\n", client->name, client->addr, res);
458 mutex_unlock(&adapter->clist_lock);
463 int i2c_detach_client(struct i2c_client *client)
465 struct i2c_adapter *adapter = client->adapter;
468 if (client->usage_count > 0) {
469 dev_warn(&client->dev, "Client [%s] still busy, "
470 "can't detach\n", client->name);
474 if (adapter->client_unregister) {
475 res = adapter->client_unregister(client);
477 dev_err(&client->dev,
478 "client_unregister [%s] failed, "
479 "client not detached\n", client->name);
484 mutex_lock(&adapter->clist_lock);
485 list_del(&client->list);
486 init_completion(&client->released);
487 device_remove_file(&client->dev, &dev_attr_client_name);
488 device_unregister(&client->dev);
489 mutex_unlock(&adapter->clist_lock);
490 wait_for_completion(&client->released);
496 static int i2c_inc_use_client(struct i2c_client *client)
499 if (!try_module_get(client->driver->driver.owner))
501 if (!try_module_get(client->adapter->owner)) {
502 module_put(client->driver->driver.owner);
509 static void i2c_dec_use_client(struct i2c_client *client)
511 module_put(client->driver->driver.owner);
512 module_put(client->adapter->owner);
515 int i2c_use_client(struct i2c_client *client)
519 ret = i2c_inc_use_client(client);
523 client->usage_count++;
528 int i2c_release_client(struct i2c_client *client)
530 if (!client->usage_count) {
531 pr_debug("i2c-core: %s used one too many times\n",
536 client->usage_count--;
537 i2c_dec_use_client(client);
542 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
544 struct list_head *item;
545 struct i2c_client *client;
547 mutex_lock(&adap->clist_lock);
548 list_for_each(item,&adap->clients) {
549 client = list_entry(item, struct i2c_client, list);
550 if (!try_module_get(client->driver->driver.owner))
552 if (NULL != client->driver->command) {
553 mutex_unlock(&adap->clist_lock);
554 client->driver->command(client,cmd,arg);
555 mutex_lock(&adap->clist_lock);
557 module_put(client->driver->driver.owner);
559 mutex_unlock(&adap->clist_lock);
562 static int __init i2c_init(void)
566 retval = bus_register(&i2c_bus_type);
569 retval = driver_register(&i2c_adapter_driver);
572 return class_register(&i2c_adapter_class);
575 static void __exit i2c_exit(void)
577 class_unregister(&i2c_adapter_class);
578 driver_unregister(&i2c_adapter_driver);
579 bus_unregister(&i2c_bus_type);
582 subsys_initcall(i2c_init);
583 module_exit(i2c_exit);
585 /* ----------------------------------------------------
586 * the functional interface to the i2c busses.
587 * ----------------------------------------------------
590 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
594 if (adap->algo->master_xfer) {
596 for (ret = 0; ret < num; ret++) {
597 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
598 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
599 'R' : 'W', msgs[ret].addr, msgs[ret].len);
603 mutex_lock_nested(&adap->bus_lock, adap->level);
604 ret = adap->algo->master_xfer(adap,msgs,num);
605 mutex_unlock(&adap->bus_lock);
609 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
614 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
617 struct i2c_adapter *adap=client->adapter;
620 msg.addr = client->addr;
621 msg.flags = client->flags & I2C_M_TEN;
623 msg.buf = (char *)buf;
625 ret = i2c_transfer(adap, &msg, 1);
627 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
628 transmitted, else error code. */
629 return (ret == 1) ? count : ret;
632 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
634 struct i2c_adapter *adap=client->adapter;
638 msg.addr = client->addr;
639 msg.flags = client->flags & I2C_M_TEN;
640 msg.flags |= I2C_M_RD;
644 ret = i2c_transfer(adap, &msg, 1);
646 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
647 transmitted, else error code. */
648 return (ret == 1) ? count : ret;
652 int i2c_control(struct i2c_client *client,
653 unsigned int cmd, unsigned long arg)
656 struct i2c_adapter *adap = client->adapter;
658 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
667 if (adap->algo->algo_control!=NULL)
668 ret = adap->algo->algo_control(adap,cmd,arg);
673 /* ----------------------------------------------------
674 * the i2c address scanning function
675 * Will not work for 10-bit addresses!
676 * ----------------------------------------------------
678 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
679 int (*found_proc) (struct i2c_adapter *, int, int))
683 /* Make sure the address is valid */
684 if (addr < 0x03 || addr > 0x77) {
685 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
690 /* Skip if already in use */
691 if (i2c_check_addr(adapter, addr))
694 /* Make sure there is something at this address, unless forced */
696 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
697 I2C_SMBUS_QUICK, NULL) < 0)
700 /* prevent 24RF08 corruption */
701 if ((addr & ~0x0f) == 0x50)
702 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
703 I2C_SMBUS_QUICK, NULL);
706 /* Finally call the custom detection function */
707 err = found_proc(adapter, addr, kind);
708 /* -ENODEV can be returned if there is a chip at the given address
709 but it isn't supported by this chip driver. We catch it here as
710 this isn't an error. */
715 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
720 int i2c_probe(struct i2c_adapter *adapter,
721 struct i2c_client_address_data *address_data,
722 int (*found_proc) (struct i2c_adapter *, int, int))
725 int adap_id = i2c_adapter_id(adapter);
727 /* Force entries are done first, and are not affected by ignore
729 if (address_data->forces) {
730 unsigned short **forces = address_data->forces;
733 for (kind = 0; forces[kind]; kind++) {
734 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
736 if (forces[kind][i] == adap_id
737 || forces[kind][i] == ANY_I2C_BUS) {
738 dev_dbg(&adapter->dev, "found force "
739 "parameter for adapter %d, "
740 "addr 0x%02x, kind %d\n",
741 adap_id, forces[kind][i + 1],
743 err = i2c_probe_address(adapter,
753 /* Stop here if we can't use SMBUS_QUICK */
754 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
755 if (address_data->probe[0] == I2C_CLIENT_END
756 && address_data->normal_i2c[0] == I2C_CLIENT_END)
759 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
760 "can't probe for chips\n");
764 /* Probe entries are done second, and are not affected by ignore
766 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
767 if (address_data->probe[i] == adap_id
768 || address_data->probe[i] == ANY_I2C_BUS) {
769 dev_dbg(&adapter->dev, "found probe parameter for "
770 "adapter %d, addr 0x%02x\n", adap_id,
771 address_data->probe[i + 1]);
772 err = i2c_probe_address(adapter,
773 address_data->probe[i + 1],
780 /* Normal entries are done last, unless shadowed by an ignore entry */
781 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
785 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
787 if ((address_data->ignore[j] == adap_id ||
788 address_data->ignore[j] == ANY_I2C_BUS)
789 && address_data->ignore[j + 1]
790 == address_data->normal_i2c[i]) {
791 dev_dbg(&adapter->dev, "found ignore "
792 "parameter for adapter %d, "
793 "addr 0x%02x\n", adap_id,
794 address_data->ignore[j + 1]);
802 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
803 "addr 0x%02x\n", adap_id,
804 address_data->normal_i2c[i]);
805 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
814 struct i2c_adapter* i2c_get_adapter(int id)
816 struct i2c_adapter *adapter;
818 mutex_lock(&core_lists);
819 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
820 if (adapter && !try_module_get(adapter->owner))
823 mutex_unlock(&core_lists);
827 void i2c_put_adapter(struct i2c_adapter *adap)
829 module_put(adap->owner);
832 /* The SMBus parts */
834 #define POLY (0x1070U << 3)
840 for(i = 0; i < 8; i++) {
845 return (u8)(data >> 8);
848 /* Incremental CRC8 over count bytes in the array pointed to by p */
849 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
853 for(i = 0; i < count; i++)
854 crc = crc8((crc ^ p[i]) << 8);
858 /* Assume a 7-bit address, which is reasonable for SMBus */
859 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
861 /* The address will be sent first */
862 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
863 pec = i2c_smbus_pec(pec, &addr, 1);
865 /* The data buffer follows */
866 return i2c_smbus_pec(pec, msg->buf, msg->len);
869 /* Used for write only transactions */
870 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
872 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
876 /* Return <0 on CRC error
877 If there was a write before this read (most cases) we need to take the
878 partial CRC from the write part into account.
879 Note that this function does modify the message (we need to decrease the
880 message length to hide the CRC byte from the caller). */
881 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
883 u8 rpec = msg->buf[--msg->len];
884 cpec = i2c_smbus_msg_pec(cpec, msg);
887 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
894 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
896 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
897 value,0,I2C_SMBUS_QUICK,NULL);
900 s32 i2c_smbus_read_byte(struct i2c_client *client)
902 union i2c_smbus_data data;
903 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
904 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
910 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
912 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
913 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
916 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
918 union i2c_smbus_data data;
919 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
920 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
926 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
928 union i2c_smbus_data data;
930 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
931 I2C_SMBUS_WRITE,command,
932 I2C_SMBUS_BYTE_DATA,&data);
935 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
937 union i2c_smbus_data data;
938 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
939 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
945 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
947 union i2c_smbus_data data;
949 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
950 I2C_SMBUS_WRITE,command,
951 I2C_SMBUS_WORD_DATA,&data);
954 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
955 u8 length, const u8 *values)
957 union i2c_smbus_data data;
959 if (length > I2C_SMBUS_BLOCK_MAX)
960 length = I2C_SMBUS_BLOCK_MAX;
961 data.block[0] = length;
962 memcpy(&data.block[1], values, length);
963 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
964 I2C_SMBUS_WRITE,command,
965 I2C_SMBUS_BLOCK_DATA,&data);
968 /* Returns the number of read bytes */
969 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
971 union i2c_smbus_data data;
973 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
974 I2C_SMBUS_READ,command,
975 I2C_SMBUS_I2C_BLOCK_DATA,&data))
978 memcpy(values, &data.block[1], data.block[0]);
979 return data.block[0];
982 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
983 u8 length, const u8 *values)
985 union i2c_smbus_data data;
987 if (length > I2C_SMBUS_BLOCK_MAX)
988 length = I2C_SMBUS_BLOCK_MAX;
989 data.block[0] = length;
990 memcpy(data.block + 1, values, length);
991 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
992 I2C_SMBUS_WRITE, command,
993 I2C_SMBUS_I2C_BLOCK_DATA, &data);
996 /* Simulate a SMBus command using the i2c protocol
997 No checking of parameters is done! */
998 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
999 unsigned short flags,
1000 char read_write, u8 command, int size,
1001 union i2c_smbus_data * data)
1003 /* So we need to generate a series of msgs. In the case of writing, we
1004 need to use only one message; when reading, we need two. We initialize
1005 most things with sane defaults, to keep the code below somewhat
1007 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1008 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1009 int num = read_write == I2C_SMBUS_READ?2:1;
1010 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1011 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1016 msgbuf0[0] = command;
1018 case I2C_SMBUS_QUICK:
1020 /* Special case: The read/write field is used as data */
1021 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1024 case I2C_SMBUS_BYTE:
1025 if (read_write == I2C_SMBUS_READ) {
1026 /* Special case: only a read! */
1027 msg[0].flags = I2C_M_RD | flags;
1031 case I2C_SMBUS_BYTE_DATA:
1032 if (read_write == I2C_SMBUS_READ)
1036 msgbuf0[1] = data->byte;
1039 case I2C_SMBUS_WORD_DATA:
1040 if (read_write == I2C_SMBUS_READ)
1044 msgbuf0[1] = data->word & 0xff;
1045 msgbuf0[2] = data->word >> 8;
1048 case I2C_SMBUS_PROC_CALL:
1049 num = 2; /* Special case */
1050 read_write = I2C_SMBUS_READ;
1053 msgbuf0[1] = data->word & 0xff;
1054 msgbuf0[2] = data->word >> 8;
1056 case I2C_SMBUS_BLOCK_DATA:
1057 if (read_write == I2C_SMBUS_READ) {
1058 dev_err(&adapter->dev, "Block read not supported "
1059 "under I2C emulation!\n");
1062 msg[0].len = data->block[0] + 2;
1063 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1064 dev_err(&adapter->dev, "smbus_access called with "
1065 "invalid block write size (%d)\n",
1069 for (i = 1; i < msg[0].len; i++)
1070 msgbuf0[i] = data->block[i-1];
1073 case I2C_SMBUS_BLOCK_PROC_CALL:
1074 dev_dbg(&adapter->dev, "Block process call not supported "
1075 "under I2C emulation!\n");
1077 case I2C_SMBUS_I2C_BLOCK_DATA:
1078 if (read_write == I2C_SMBUS_READ) {
1079 msg[1].len = I2C_SMBUS_BLOCK_MAX;
1081 msg[0].len = data->block[0] + 1;
1082 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1083 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1084 "invalid block write size (%d)\n",
1088 for (i = 1; i <= data->block[0]; i++)
1089 msgbuf0[i] = data->block[i];
1093 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1098 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1099 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1101 /* Compute PEC if first message is a write */
1102 if (!(msg[0].flags & I2C_M_RD)) {
1103 if (num == 1) /* Write only */
1104 i2c_smbus_add_pec(&msg[0]);
1105 else /* Write followed by read */
1106 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1108 /* Ask for PEC if last message is a read */
1109 if (msg[num-1].flags & I2C_M_RD)
1113 if (i2c_transfer(adapter, msg, num) < 0)
1116 /* Check PEC if last message is a read */
1117 if (i && (msg[num-1].flags & I2C_M_RD)) {
1118 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1122 if (read_write == I2C_SMBUS_READ)
1124 case I2C_SMBUS_BYTE:
1125 data->byte = msgbuf0[0];
1127 case I2C_SMBUS_BYTE_DATA:
1128 data->byte = msgbuf1[0];
1130 case I2C_SMBUS_WORD_DATA:
1131 case I2C_SMBUS_PROC_CALL:
1132 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1134 case I2C_SMBUS_I2C_BLOCK_DATA:
1135 /* fixed at 32 for now */
1136 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1137 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1138 data->block[i+1] = msgbuf1[i];
1145 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1146 char read_write, u8 command, int size,
1147 union i2c_smbus_data * data)
1151 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1153 if (adapter->algo->smbus_xfer) {
1154 mutex_lock(&adapter->bus_lock);
1155 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1157 mutex_unlock(&adapter->bus_lock);
1159 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1166 /* Next four are needed by i2c-isa */
1167 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1168 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1169 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1170 EXPORT_SYMBOL_GPL(i2c_bus_type);
1172 EXPORT_SYMBOL(i2c_add_adapter);
1173 EXPORT_SYMBOL(i2c_del_adapter);
1174 EXPORT_SYMBOL(i2c_del_driver);
1175 EXPORT_SYMBOL(i2c_attach_client);
1176 EXPORT_SYMBOL(i2c_detach_client);
1177 EXPORT_SYMBOL(i2c_use_client);
1178 EXPORT_SYMBOL(i2c_release_client);
1179 EXPORT_SYMBOL(i2c_clients_command);
1180 EXPORT_SYMBOL(i2c_check_addr);
1182 EXPORT_SYMBOL(i2c_master_send);
1183 EXPORT_SYMBOL(i2c_master_recv);
1184 EXPORT_SYMBOL(i2c_control);
1185 EXPORT_SYMBOL(i2c_transfer);
1186 EXPORT_SYMBOL(i2c_get_adapter);
1187 EXPORT_SYMBOL(i2c_put_adapter);
1188 EXPORT_SYMBOL(i2c_probe);
1190 EXPORT_SYMBOL(i2c_smbus_xfer);
1191 EXPORT_SYMBOL(i2c_smbus_write_quick);
1192 EXPORT_SYMBOL(i2c_smbus_read_byte);
1193 EXPORT_SYMBOL(i2c_smbus_write_byte);
1194 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1195 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1196 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1197 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1198 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1199 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1200 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1202 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1203 MODULE_DESCRIPTION("I2C-Bus main module");
1204 MODULE_LICENSE("GPL");