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 <asm/uaccess.h>
37 static LIST_HEAD(adapters);
38 static LIST_HEAD(drivers);
39 static DECLARE_MUTEX(core_lists);
40 static DEFINE_IDR(i2c_adapter_idr);
42 /* match always succeeds, as we want the probe() to tell if we really accept this match */
43 static int i2c_device_match(struct device *dev, struct device_driver *drv)
48 static int i2c_bus_suspend(struct device * dev, pm_message_t state)
52 if (dev->driver && dev->driver->suspend)
53 rc = dev->driver->suspend(dev, state);
57 static int i2c_bus_resume(struct device * dev)
61 if (dev->driver && dev->driver->resume)
62 rc = dev->driver->resume(dev);
66 struct bus_type i2c_bus_type = {
68 .match = i2c_device_match,
69 .suspend = i2c_bus_suspend,
70 .resume = i2c_bus_resume,
73 static int i2c_device_probe(struct device *dev)
78 static int i2c_device_remove(struct device *dev)
83 void i2c_adapter_dev_release(struct device *dev)
85 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
86 complete(&adap->dev_released);
89 struct device_driver i2c_adapter_driver = {
91 .name = "i2c_adapter",
93 .probe = i2c_device_probe,
94 .remove = i2c_device_remove,
97 static void i2c_adapter_class_dev_release(struct class_device *dev)
99 struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
100 complete(&adap->class_dev_released);
103 struct class i2c_adapter_class = {
104 .owner = THIS_MODULE,
105 .name = "i2c-adapter",
106 .release = &i2c_adapter_class_dev_release,
109 static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
111 struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
112 return sprintf(buf, "%s\n", adap->name);
114 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
117 static void i2c_client_release(struct device *dev)
119 struct i2c_client *client = to_i2c_client(dev);
120 complete(&client->released);
123 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
125 struct i2c_client *client = to_i2c_client(dev);
126 return sprintf(buf, "%s\n", client->name);
130 * We can't use the DEVICE_ATTR() macro here as we want the same filename for a
131 * different type of a device. So beware if the DEVICE_ATTR() macro ever
132 * changes, this definition will also have to change.
134 static struct device_attribute dev_attr_client_name = {
135 .attr = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE },
136 .show = &show_client_name,
140 /* ---------------------------------------------------
141 * registering functions
142 * ---------------------------------------------------
146 * i2c_add_adapter is called from within the algorithm layer,
147 * when a new hw adapter registers. A new device is register to be
148 * available for clients.
150 int i2c_add_adapter(struct i2c_adapter *adap)
153 struct list_head *item;
154 struct i2c_driver *driver;
158 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
163 res = idr_get_new(&i2c_adapter_idr, adap, &id);
170 adap->nr = id & MAX_ID_MASK;
171 init_MUTEX(&adap->bus_lock);
172 init_MUTEX(&adap->clist_lock);
173 list_add_tail(&adap->list,&adapters);
174 INIT_LIST_HEAD(&adap->clients);
176 /* Add the adapter to the driver core.
177 * If the parent pointer is not set up,
178 * we add this adapter to the host bus.
180 if (adap->dev.parent == NULL)
181 adap->dev.parent = &platform_bus;
182 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
183 adap->dev.driver = &i2c_adapter_driver;
184 adap->dev.release = &i2c_adapter_dev_release;
185 device_register(&adap->dev);
186 device_create_file(&adap->dev, &dev_attr_name);
188 /* Add this adapter to the i2c_adapter class */
189 memset(&adap->class_dev, 0x00, sizeof(struct class_device));
190 adap->class_dev.dev = &adap->dev;
191 adap->class_dev.class = &i2c_adapter_class;
192 strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
193 class_device_register(&adap->class_dev);
195 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
197 /* inform drivers of new adapters */
198 list_for_each(item,&drivers) {
199 driver = list_entry(item, struct i2c_driver, list);
200 if (driver->attach_adapter)
201 /* We ignore the return code; if it fails, too bad */
202 driver->attach_adapter(adap);
211 int i2c_del_adapter(struct i2c_adapter *adap)
213 struct list_head *item, *_n;
214 struct i2c_adapter *adap_from_list;
215 struct i2c_driver *driver;
216 struct i2c_client *client;
221 /* First make sure that this adapter was ever added */
222 list_for_each_entry(adap_from_list, &adapters, list) {
223 if (adap_from_list == adap)
226 if (adap_from_list != adap) {
227 pr_debug("i2c-core: attempting to delete unregistered "
228 "adapter [%s]\n", adap->name);
233 list_for_each(item,&drivers) {
234 driver = list_entry(item, struct i2c_driver, list);
235 if (driver->detach_adapter)
236 if ((res = driver->detach_adapter(adap))) {
237 dev_err(&adap->dev, "detach_adapter failed "
238 "for driver [%s]\n", driver->name);
243 /* detach any active clients. This must be done first, because
244 * it can fail; in which case we give up. */
245 list_for_each_safe(item, _n, &adap->clients) {
246 client = list_entry(item, struct i2c_client, list);
248 /* detaching devices is unconditional of the set notify
249 * flag, as _all_ clients that reside on the adapter
250 * must be deleted, as this would cause invalid states.
252 if ((res=client->driver->detach_client(client))) {
253 dev_err(&adap->dev, "detach_client failed for client "
254 "[%s] at address 0x%02x\n", client->name,
260 /* clean up the sysfs representation */
261 init_completion(&adap->dev_released);
262 init_completion(&adap->class_dev_released);
263 class_device_unregister(&adap->class_dev);
264 device_remove_file(&adap->dev, &dev_attr_name);
265 device_unregister(&adap->dev);
266 list_del(&adap->list);
268 /* wait for sysfs to drop all references */
269 wait_for_completion(&adap->dev_released);
270 wait_for_completion(&adap->class_dev_released);
272 /* free dynamically allocated bus id */
273 idr_remove(&i2c_adapter_idr, adap->nr);
275 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
284 * What follows is the "upwards" interface: commands for talking to clients,
285 * which implement the functions to access the physical information of the
289 int i2c_add_driver(struct i2c_driver *driver)
291 struct list_head *item;
292 struct i2c_adapter *adapter;
297 /* add the driver to the list of i2c drivers in the driver core */
298 driver->driver.owner = driver->owner;
299 driver->driver.name = driver->name;
300 driver->driver.bus = &i2c_bus_type;
301 driver->driver.probe = i2c_device_probe;
302 driver->driver.remove = i2c_device_remove;
304 res = driver_register(&driver->driver);
308 list_add_tail(&driver->list,&drivers);
309 pr_debug("i2c-core: driver [%s] registered\n", driver->name);
311 /* now look for instances of driver on our adapters */
312 if (driver->attach_adapter) {
313 list_for_each(item,&adapters) {
314 adapter = list_entry(item, struct i2c_adapter, list);
315 driver->attach_adapter(adapter);
324 int i2c_del_driver(struct i2c_driver *driver)
326 struct list_head *item1, *item2, *_n;
327 struct i2c_client *client;
328 struct i2c_adapter *adap;
334 /* Have a look at each adapter, if clients of this driver are still
335 * attached. If so, detach them to be able to kill the driver
338 * Removing clients does not depend on the notify flag, else
339 * invalid operation might (will!) result, when using stale client
342 list_for_each(item1,&adapters) {
343 adap = list_entry(item1, struct i2c_adapter, list);
344 if (driver->detach_adapter) {
345 if ((res = driver->detach_adapter(adap))) {
346 dev_err(&adap->dev, "detach_adapter failed "
347 "for driver [%s]\n", driver->name);
351 list_for_each_safe(item2, _n, &adap->clients) {
352 client = list_entry(item2, struct i2c_client, list);
353 if (client->driver != driver)
355 dev_dbg(&adap->dev, "detaching client [%s] "
356 "at 0x%02x\n", client->name,
358 if ((res = driver->detach_client(client))) {
359 dev_err(&adap->dev, "detach_client "
360 "failed for client [%s] at "
361 "0x%02x\n", client->name,
369 driver_unregister(&driver->driver);
370 list_del(&driver->list);
371 pr_debug("i2c-core: driver [%s] unregistered\n", driver->name);
378 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
380 struct list_head *item;
381 struct i2c_client *client;
383 list_for_each(item,&adapter->clients) {
384 client = list_entry(item, struct i2c_client, list);
385 if (client->addr == addr)
391 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
395 down(&adapter->clist_lock);
396 rval = __i2c_check_addr(adapter, addr);
397 up(&adapter->clist_lock);
402 int i2c_attach_client(struct i2c_client *client)
404 struct i2c_adapter *adapter = client->adapter;
406 down(&adapter->clist_lock);
407 if (__i2c_check_addr(client->adapter, client->addr)) {
408 up(&adapter->clist_lock);
411 list_add_tail(&client->list,&adapter->clients);
412 up(&adapter->clist_lock);
414 if (adapter->client_register) {
415 if (adapter->client_register(client)) {
416 dev_dbg(&adapter->dev, "client_register "
417 "failed for client [%s] at 0x%02x\n",
418 client->name, client->addr);
422 if (client->flags & I2C_CLIENT_ALLOW_USE)
423 client->usage_count = 0;
425 client->dev.parent = &client->adapter->dev;
426 client->dev.driver = &client->driver->driver;
427 client->dev.bus = &i2c_bus_type;
428 client->dev.release = &i2c_client_release;
430 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
431 "%d-%04x", i2c_adapter_id(adapter), client->addr);
432 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
433 client->name, client->dev.bus_id);
434 device_register(&client->dev);
435 device_create_file(&client->dev, &dev_attr_client_name);
441 int i2c_detach_client(struct i2c_client *client)
443 struct i2c_adapter *adapter = client->adapter;
446 if ((client->flags & I2C_CLIENT_ALLOW_USE)
447 && (client->usage_count > 0)) {
448 dev_warn(&client->dev, "Client [%s] still busy, "
449 "can't detach\n", client->name);
453 if (adapter->client_unregister) {
454 res = adapter->client_unregister(client);
456 dev_err(&client->dev,
457 "client_unregister [%s] failed, "
458 "client not detached\n", client->name);
463 down(&adapter->clist_lock);
464 list_del(&client->list);
465 init_completion(&client->released);
466 device_remove_file(&client->dev, &dev_attr_client_name);
467 device_unregister(&client->dev);
468 up(&adapter->clist_lock);
469 wait_for_completion(&client->released);
475 static int i2c_inc_use_client(struct i2c_client *client)
478 if (!try_module_get(client->driver->owner))
480 if (!try_module_get(client->adapter->owner)) {
481 module_put(client->driver->owner);
488 static void i2c_dec_use_client(struct i2c_client *client)
490 module_put(client->driver->owner);
491 module_put(client->adapter->owner);
494 int i2c_use_client(struct i2c_client *client)
498 ret = i2c_inc_use_client(client);
502 if (client->flags & I2C_CLIENT_ALLOW_USE) {
503 if (client->usage_count > 0)
506 client->usage_count++;
511 i2c_dec_use_client(client);
515 int i2c_release_client(struct i2c_client *client)
517 if(client->flags & I2C_CLIENT_ALLOW_USE) {
518 if(client->usage_count>0)
519 client->usage_count--;
521 pr_debug("i2c-core: %s used one too many times\n",
527 i2c_dec_use_client(client);
532 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
534 struct list_head *item;
535 struct i2c_client *client;
537 down(&adap->clist_lock);
538 list_for_each(item,&adap->clients) {
539 client = list_entry(item, struct i2c_client, list);
540 if (!try_module_get(client->driver->owner))
542 if (NULL != client->driver->command) {
543 up(&adap->clist_lock);
544 client->driver->command(client,cmd,arg);
545 down(&adap->clist_lock);
547 module_put(client->driver->owner);
549 up(&adap->clist_lock);
552 static int __init i2c_init(void)
556 retval = bus_register(&i2c_bus_type);
559 retval = driver_register(&i2c_adapter_driver);
562 return class_register(&i2c_adapter_class);
565 static void __exit i2c_exit(void)
567 class_unregister(&i2c_adapter_class);
568 driver_unregister(&i2c_adapter_driver);
569 bus_unregister(&i2c_bus_type);
572 subsys_initcall(i2c_init);
573 module_exit(i2c_exit);
575 /* ----------------------------------------------------
576 * the functional interface to the i2c busses.
577 * ----------------------------------------------------
580 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
584 if (adap->algo->master_xfer) {
586 for (ret = 0; ret < num; ret++) {
587 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
588 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
589 'R' : 'W', msgs[ret].addr, msgs[ret].len);
593 down(&adap->bus_lock);
594 ret = adap->algo->master_xfer(adap,msgs,num);
599 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
604 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
607 struct i2c_adapter *adap=client->adapter;
610 msg.addr = client->addr;
611 msg.flags = client->flags & I2C_M_TEN;
613 msg.buf = (char *)buf;
615 ret = i2c_transfer(adap, &msg, 1);
617 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
618 transmitted, else error code. */
619 return (ret == 1) ? count : ret;
622 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
624 struct i2c_adapter *adap=client->adapter;
628 msg.addr = client->addr;
629 msg.flags = client->flags & I2C_M_TEN;
630 msg.flags |= I2C_M_RD;
634 ret = i2c_transfer(adap, &msg, 1);
636 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
637 transmitted, else error code. */
638 return (ret == 1) ? count : ret;
642 int i2c_control(struct i2c_client *client,
643 unsigned int cmd, unsigned long arg)
646 struct i2c_adapter *adap = client->adapter;
648 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
657 if (adap->algo->algo_control!=NULL)
658 ret = adap->algo->algo_control(adap,cmd,arg);
663 /* ----------------------------------------------------
664 * the i2c address scanning function
665 * Will not work for 10-bit addresses!
666 * ----------------------------------------------------
668 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
669 int (*found_proc) (struct i2c_adapter *, int, int))
673 /* Make sure the address is valid */
674 if (addr < 0x03 || addr > 0x77) {
675 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
680 /* Skip if already in use */
681 if (i2c_check_addr(adapter, addr))
684 /* Make sure there is something at this address, unless forced */
686 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
687 I2C_SMBUS_QUICK, NULL) < 0)
690 /* prevent 24RF08 corruption */
691 if ((addr & ~0x0f) == 0x50)
692 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
693 I2C_SMBUS_QUICK, NULL);
696 /* Finally call the custom detection function */
697 err = found_proc(adapter, addr, kind);
699 /* -ENODEV can be returned if there is a chip at the given address
700 but it isn't supported by this chip driver. We catch it here as
701 this isn't an error. */
702 return (err == -ENODEV) ? 0 : err;
705 int i2c_probe(struct i2c_adapter *adapter,
706 struct i2c_client_address_data *address_data,
707 int (*found_proc) (struct i2c_adapter *, int, int))
710 int adap_id = i2c_adapter_id(adapter);
712 /* Force entries are done first, and are not affected by ignore
714 if (address_data->forces) {
715 unsigned short **forces = address_data->forces;
718 for (kind = 0; forces[kind]; kind++) {
719 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
721 if (forces[kind][i] == adap_id
722 || forces[kind][i] == ANY_I2C_BUS) {
723 dev_dbg(&adapter->dev, "found force "
724 "parameter for adapter %d, "
725 "addr 0x%02x, kind %d\n",
726 adap_id, forces[kind][i + 1],
728 err = i2c_probe_address(adapter,
738 /* Stop here if we can't use SMBUS_QUICK */
739 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
740 if (address_data->probe[0] == I2C_CLIENT_END
741 && address_data->normal_i2c[0] == I2C_CLIENT_END)
744 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
745 "can't probe for chips\n");
749 /* Probe entries are done second, and are not affected by ignore
751 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
752 if (address_data->probe[i] == adap_id
753 || address_data->probe[i] == ANY_I2C_BUS) {
754 dev_dbg(&adapter->dev, "found probe parameter for "
755 "adapter %d, addr 0x%02x\n", adap_id,
756 address_data->probe[i + 1]);
757 err = i2c_probe_address(adapter,
758 address_data->probe[i + 1],
765 /* Normal entries are done last, unless shadowed by an ignore entry */
766 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
770 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
772 if ((address_data->ignore[j] == adap_id ||
773 address_data->ignore[j] == ANY_I2C_BUS)
774 && address_data->ignore[j + 1]
775 == address_data->normal_i2c[i]) {
776 dev_dbg(&adapter->dev, "found ignore "
777 "parameter for adapter %d, "
778 "addr 0x%02x\n", adap_id,
779 address_data->ignore[j + 1]);
787 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
788 "addr 0x%02x\n", adap_id,
789 address_data->normal_i2c[i]);
790 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
799 struct i2c_adapter* i2c_get_adapter(int id)
801 struct i2c_adapter *adapter;
804 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
805 if (adapter && !try_module_get(adapter->owner))
812 void i2c_put_adapter(struct i2c_adapter *adap)
814 module_put(adap->owner);
817 /* The SMBus parts */
819 #define POLY (0x1070U << 3)
825 for(i = 0; i < 8; i++) {
830 return (u8)(data >> 8);
833 /* Incremental CRC8 over count bytes in the array pointed to by p */
834 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
838 for(i = 0; i < count; i++)
839 crc = crc8((crc ^ p[i]) << 8);
843 /* Assume a 7-bit address, which is reasonable for SMBus */
844 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
846 /* The address will be sent first */
847 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
848 pec = i2c_smbus_pec(pec, &addr, 1);
850 /* The data buffer follows */
851 return i2c_smbus_pec(pec, msg->buf, msg->len);
854 /* Used for write only transactions */
855 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
857 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
861 /* Return <0 on CRC error
862 If there was a write before this read (most cases) we need to take the
863 partial CRC from the write part into account.
864 Note that this function does modify the message (we need to decrease the
865 message length to hide the CRC byte from the caller). */
866 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
868 u8 rpec = msg->buf[--msg->len];
869 cpec = i2c_smbus_msg_pec(cpec, msg);
872 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
879 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
881 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
882 value,0,I2C_SMBUS_QUICK,NULL);
885 s32 i2c_smbus_read_byte(struct i2c_client *client)
887 union i2c_smbus_data data;
888 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
889 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
892 return 0x0FF & data.byte;
895 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
897 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
898 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
901 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
903 union i2c_smbus_data data;
904 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
905 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
908 return 0x0FF & data.byte;
911 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
913 union i2c_smbus_data data;
915 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
916 I2C_SMBUS_WRITE,command,
917 I2C_SMBUS_BYTE_DATA,&data);
920 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
922 union i2c_smbus_data data;
923 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
924 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
927 return 0x0FFFF & data.word;
930 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
932 union i2c_smbus_data data;
934 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
935 I2C_SMBUS_WRITE,command,
936 I2C_SMBUS_WORD_DATA,&data);
939 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
940 u8 length, u8 *values)
942 union i2c_smbus_data data;
944 if (length > I2C_SMBUS_BLOCK_MAX)
945 length = I2C_SMBUS_BLOCK_MAX;
946 for (i = 1; i <= length; i++)
947 data.block[i] = values[i-1];
948 data.block[0] = length;
949 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
950 I2C_SMBUS_WRITE,command,
951 I2C_SMBUS_BLOCK_DATA,&data);
954 /* Returns the number of read bytes */
955 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
957 union i2c_smbus_data data;
959 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
960 I2C_SMBUS_READ,command,
961 I2C_SMBUS_I2C_BLOCK_DATA,&data))
964 for (i = 1; i <= data.block[0]; i++)
965 values[i-1] = data.block[i];
966 return data.block[0];
970 /* Simulate a SMBus command using the i2c protocol
971 No checking of parameters is done! */
972 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
973 unsigned short flags,
974 char read_write, u8 command, int size,
975 union i2c_smbus_data * data)
977 /* So we need to generate a series of msgs. In the case of writing, we
978 need to use only one message; when reading, we need two. We initialize
979 most things with sane defaults, to keep the code below somewhat
981 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
982 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
983 int num = read_write == I2C_SMBUS_READ?2:1;
984 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
985 { addr, flags | I2C_M_RD, 0, msgbuf1 }
990 msgbuf0[0] = command;
992 case I2C_SMBUS_QUICK:
994 /* Special case: The read/write field is used as data */
995 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
999 if (read_write == I2C_SMBUS_READ) {
1000 /* Special case: only a read! */
1001 msg[0].flags = I2C_M_RD | flags;
1005 case I2C_SMBUS_BYTE_DATA:
1006 if (read_write == I2C_SMBUS_READ)
1010 msgbuf0[1] = data->byte;
1013 case I2C_SMBUS_WORD_DATA:
1014 if (read_write == I2C_SMBUS_READ)
1018 msgbuf0[1] = data->word & 0xff;
1019 msgbuf0[2] = (data->word >> 8) & 0xff;
1022 case I2C_SMBUS_PROC_CALL:
1023 num = 2; /* Special case */
1024 read_write = I2C_SMBUS_READ;
1027 msgbuf0[1] = data->word & 0xff;
1028 msgbuf0[2] = (data->word >> 8) & 0xff;
1030 case I2C_SMBUS_BLOCK_DATA:
1031 if (read_write == I2C_SMBUS_READ) {
1032 dev_err(&adapter->dev, "Block read not supported "
1033 "under I2C emulation!\n");
1036 msg[0].len = data->block[0] + 2;
1037 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1038 dev_err(&adapter->dev, "smbus_access called with "
1039 "invalid block write size (%d)\n",
1043 for (i = 1; i < msg[0].len; i++)
1044 msgbuf0[i] = data->block[i-1];
1047 case I2C_SMBUS_BLOCK_PROC_CALL:
1048 dev_dbg(&adapter->dev, "Block process call not supported "
1049 "under I2C emulation!\n");
1051 case I2C_SMBUS_I2C_BLOCK_DATA:
1052 if (read_write == I2C_SMBUS_READ) {
1053 msg[1].len = I2C_SMBUS_BLOCK_MAX;
1055 msg[0].len = data->block[0] + 1;
1056 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1057 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1058 "invalid block write size (%d)\n",
1062 for (i = 1; i <= data->block[0]; i++)
1063 msgbuf0[i] = data->block[i];
1067 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1072 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1073 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1075 /* Compute PEC if first message is a write */
1076 if (!(msg[0].flags & I2C_M_RD)) {
1077 if (num == 1) /* Write only */
1078 i2c_smbus_add_pec(&msg[0]);
1079 else /* Write followed by read */
1080 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1082 /* Ask for PEC if last message is a read */
1083 if (msg[num-1].flags & I2C_M_RD)
1087 if (i2c_transfer(adapter, msg, num) < 0)
1090 /* Check PEC if last message is a read */
1091 if (i && (msg[num-1].flags & I2C_M_RD)) {
1092 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1096 if (read_write == I2C_SMBUS_READ)
1098 case I2C_SMBUS_BYTE:
1099 data->byte = msgbuf0[0];
1101 case I2C_SMBUS_BYTE_DATA:
1102 data->byte = msgbuf1[0];
1104 case I2C_SMBUS_WORD_DATA:
1105 case I2C_SMBUS_PROC_CALL:
1106 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1108 case I2C_SMBUS_I2C_BLOCK_DATA:
1109 /* fixed at 32 for now */
1110 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1111 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1112 data->block[i+1] = msgbuf1[i];
1119 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1120 char read_write, u8 command, int size,
1121 union i2c_smbus_data * data)
1125 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1127 if (adapter->algo->smbus_xfer) {
1128 down(&adapter->bus_lock);
1129 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1131 up(&adapter->bus_lock);
1133 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1140 /* Next four are needed by i2c-isa */
1141 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1142 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1143 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1144 EXPORT_SYMBOL_GPL(i2c_bus_type);
1146 EXPORT_SYMBOL(i2c_add_adapter);
1147 EXPORT_SYMBOL(i2c_del_adapter);
1148 EXPORT_SYMBOL(i2c_add_driver);
1149 EXPORT_SYMBOL(i2c_del_driver);
1150 EXPORT_SYMBOL(i2c_attach_client);
1151 EXPORT_SYMBOL(i2c_detach_client);
1152 EXPORT_SYMBOL(i2c_use_client);
1153 EXPORT_SYMBOL(i2c_release_client);
1154 EXPORT_SYMBOL(i2c_clients_command);
1155 EXPORT_SYMBOL(i2c_check_addr);
1157 EXPORT_SYMBOL(i2c_master_send);
1158 EXPORT_SYMBOL(i2c_master_recv);
1159 EXPORT_SYMBOL(i2c_control);
1160 EXPORT_SYMBOL(i2c_transfer);
1161 EXPORT_SYMBOL(i2c_get_adapter);
1162 EXPORT_SYMBOL(i2c_put_adapter);
1163 EXPORT_SYMBOL(i2c_probe);
1165 EXPORT_SYMBOL(i2c_smbus_xfer);
1166 EXPORT_SYMBOL(i2c_smbus_write_quick);
1167 EXPORT_SYMBOL(i2c_smbus_read_byte);
1168 EXPORT_SYMBOL(i2c_smbus_write_byte);
1169 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1170 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1171 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1172 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1173 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1174 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1176 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1177 MODULE_DESCRIPTION("I2C-Bus main module");
1178 MODULE_LICENSE("GPL");