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 "
239 driver->driver.name);
244 /* detach any active clients. This must be done first, because
245 * it can fail; in which case we give up. */
246 list_for_each_safe(item, _n, &adap->clients) {
247 client = list_entry(item, struct i2c_client, list);
249 /* detaching devices is unconditional of the set notify
250 * flag, as _all_ clients that reside on the adapter
251 * must be deleted, as this would cause invalid states.
253 if ((res=client->driver->detach_client(client))) {
254 dev_err(&adap->dev, "detach_client failed for client "
255 "[%s] at address 0x%02x\n", client->name,
261 /* clean up the sysfs representation */
262 init_completion(&adap->dev_released);
263 init_completion(&adap->class_dev_released);
264 class_device_unregister(&adap->class_dev);
265 device_remove_file(&adap->dev, &dev_attr_name);
266 device_unregister(&adap->dev);
267 list_del(&adap->list);
269 /* wait for sysfs to drop all references */
270 wait_for_completion(&adap->dev_released);
271 wait_for_completion(&adap->class_dev_released);
273 /* free dynamically allocated bus id */
274 idr_remove(&i2c_adapter_idr, adap->nr);
276 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
285 * What follows is the "upwards" interface: commands for talking to clients,
286 * which implement the functions to access the physical information of the
290 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
292 struct list_head *item;
293 struct i2c_adapter *adapter;
298 /* add the driver to the list of i2c drivers in the driver core */
299 driver->driver.owner = owner;
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->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);
323 EXPORT_SYMBOL(i2c_register_driver);
325 int i2c_del_driver(struct i2c_driver *driver)
327 struct list_head *item1, *item2, *_n;
328 struct i2c_client *client;
329 struct i2c_adapter *adap;
335 /* Have a look at each adapter, if clients of this driver are still
336 * attached. If so, detach them to be able to kill the driver
339 * Removing clients does not depend on the notify flag, else
340 * invalid operation might (will!) result, when using stale client
343 list_for_each(item1,&adapters) {
344 adap = list_entry(item1, struct i2c_adapter, list);
345 if (driver->detach_adapter) {
346 if ((res = driver->detach_adapter(adap))) {
347 dev_err(&adap->dev, "detach_adapter failed "
349 driver->driver.name);
353 list_for_each_safe(item2, _n, &adap->clients) {
354 client = list_entry(item2, struct i2c_client, list);
355 if (client->driver != driver)
357 dev_dbg(&adap->dev, "detaching client [%s] "
358 "at 0x%02x\n", client->name,
360 if ((res = driver->detach_client(client))) {
361 dev_err(&adap->dev, "detach_client "
362 "failed for client [%s] at "
363 "0x%02x\n", client->name,
371 driver_unregister(&driver->driver);
372 list_del(&driver->list);
373 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
380 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
382 struct list_head *item;
383 struct i2c_client *client;
385 list_for_each(item,&adapter->clients) {
386 client = list_entry(item, struct i2c_client, list);
387 if (client->addr == addr)
393 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
397 down(&adapter->clist_lock);
398 rval = __i2c_check_addr(adapter, addr);
399 up(&adapter->clist_lock);
404 int i2c_attach_client(struct i2c_client *client)
406 struct i2c_adapter *adapter = client->adapter;
408 down(&adapter->clist_lock);
409 if (__i2c_check_addr(client->adapter, client->addr)) {
410 up(&adapter->clist_lock);
413 list_add_tail(&client->list,&adapter->clients);
414 up(&adapter->clist_lock);
416 if (adapter->client_register) {
417 if (adapter->client_register(client)) {
418 dev_dbg(&adapter->dev, "client_register "
419 "failed for client [%s] at 0x%02x\n",
420 client->name, client->addr);
424 client->usage_count = 0;
426 client->dev.parent = &client->adapter->dev;
427 client->dev.driver = &client->driver->driver;
428 client->dev.bus = &i2c_bus_type;
429 client->dev.release = &i2c_client_release;
431 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
432 "%d-%04x", i2c_adapter_id(adapter), client->addr);
433 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
434 client->name, client->dev.bus_id);
435 device_register(&client->dev);
436 device_create_file(&client->dev, &dev_attr_client_name);
442 int i2c_detach_client(struct i2c_client *client)
444 struct i2c_adapter *adapter = client->adapter;
447 if (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->driver.owner))
480 if (!try_module_get(client->adapter->owner)) {
481 module_put(client->driver->driver.owner);
488 static void i2c_dec_use_client(struct i2c_client *client)
490 module_put(client->driver->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 client->usage_count++;
507 int i2c_release_client(struct i2c_client *client)
509 if (!client->usage_count) {
510 pr_debug("i2c-core: %s used one too many times\n",
515 client->usage_count--;
516 i2c_dec_use_client(client);
521 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
523 struct list_head *item;
524 struct i2c_client *client;
526 down(&adap->clist_lock);
527 list_for_each(item,&adap->clients) {
528 client = list_entry(item, struct i2c_client, list);
529 if (!try_module_get(client->driver->driver.owner))
531 if (NULL != client->driver->command) {
532 up(&adap->clist_lock);
533 client->driver->command(client,cmd,arg);
534 down(&adap->clist_lock);
536 module_put(client->driver->driver.owner);
538 up(&adap->clist_lock);
541 static int __init i2c_init(void)
545 retval = bus_register(&i2c_bus_type);
548 retval = driver_register(&i2c_adapter_driver);
551 return class_register(&i2c_adapter_class);
554 static void __exit i2c_exit(void)
556 class_unregister(&i2c_adapter_class);
557 driver_unregister(&i2c_adapter_driver);
558 bus_unregister(&i2c_bus_type);
561 subsys_initcall(i2c_init);
562 module_exit(i2c_exit);
564 /* ----------------------------------------------------
565 * the functional interface to the i2c busses.
566 * ----------------------------------------------------
569 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
573 if (adap->algo->master_xfer) {
575 for (ret = 0; ret < num; ret++) {
576 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
577 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
578 'R' : 'W', msgs[ret].addr, msgs[ret].len);
582 down(&adap->bus_lock);
583 ret = adap->algo->master_xfer(adap,msgs,num);
588 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
593 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
596 struct i2c_adapter *adap=client->adapter;
599 msg.addr = client->addr;
600 msg.flags = client->flags & I2C_M_TEN;
602 msg.buf = (char *)buf;
604 ret = i2c_transfer(adap, &msg, 1);
606 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
607 transmitted, else error code. */
608 return (ret == 1) ? count : ret;
611 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
613 struct i2c_adapter *adap=client->adapter;
617 msg.addr = client->addr;
618 msg.flags = client->flags & I2C_M_TEN;
619 msg.flags |= I2C_M_RD;
623 ret = i2c_transfer(adap, &msg, 1);
625 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
626 transmitted, else error code. */
627 return (ret == 1) ? count : ret;
631 int i2c_control(struct i2c_client *client,
632 unsigned int cmd, unsigned long arg)
635 struct i2c_adapter *adap = client->adapter;
637 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
646 if (adap->algo->algo_control!=NULL)
647 ret = adap->algo->algo_control(adap,cmd,arg);
652 /* ----------------------------------------------------
653 * the i2c address scanning function
654 * Will not work for 10-bit addresses!
655 * ----------------------------------------------------
657 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
658 int (*found_proc) (struct i2c_adapter *, int, int))
662 /* Make sure the address is valid */
663 if (addr < 0x03 || addr > 0x77) {
664 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
669 /* Skip if already in use */
670 if (i2c_check_addr(adapter, addr))
673 /* Make sure there is something at this address, unless forced */
675 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
676 I2C_SMBUS_QUICK, NULL) < 0)
679 /* prevent 24RF08 corruption */
680 if ((addr & ~0x0f) == 0x50)
681 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
682 I2C_SMBUS_QUICK, NULL);
685 /* Finally call the custom detection function */
686 err = found_proc(adapter, addr, kind);
688 /* -ENODEV can be returned if there is a chip at the given address
689 but it isn't supported by this chip driver. We catch it here as
690 this isn't an error. */
691 return (err == -ENODEV) ? 0 : err;
694 int i2c_probe(struct i2c_adapter *adapter,
695 struct i2c_client_address_data *address_data,
696 int (*found_proc) (struct i2c_adapter *, int, int))
699 int adap_id = i2c_adapter_id(adapter);
701 /* Force entries are done first, and are not affected by ignore
703 if (address_data->forces) {
704 unsigned short **forces = address_data->forces;
707 for (kind = 0; forces[kind]; kind++) {
708 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
710 if (forces[kind][i] == adap_id
711 || forces[kind][i] == ANY_I2C_BUS) {
712 dev_dbg(&adapter->dev, "found force "
713 "parameter for adapter %d, "
714 "addr 0x%02x, kind %d\n",
715 adap_id, forces[kind][i + 1],
717 err = i2c_probe_address(adapter,
727 /* Stop here if we can't use SMBUS_QUICK */
728 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
729 if (address_data->probe[0] == I2C_CLIENT_END
730 && address_data->normal_i2c[0] == I2C_CLIENT_END)
733 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
734 "can't probe for chips\n");
738 /* Probe entries are done second, and are not affected by ignore
740 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
741 if (address_data->probe[i] == adap_id
742 || address_data->probe[i] == ANY_I2C_BUS) {
743 dev_dbg(&adapter->dev, "found probe parameter for "
744 "adapter %d, addr 0x%02x\n", adap_id,
745 address_data->probe[i + 1]);
746 err = i2c_probe_address(adapter,
747 address_data->probe[i + 1],
754 /* Normal entries are done last, unless shadowed by an ignore entry */
755 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
759 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
761 if ((address_data->ignore[j] == adap_id ||
762 address_data->ignore[j] == ANY_I2C_BUS)
763 && address_data->ignore[j + 1]
764 == address_data->normal_i2c[i]) {
765 dev_dbg(&adapter->dev, "found ignore "
766 "parameter for adapter %d, "
767 "addr 0x%02x\n", adap_id,
768 address_data->ignore[j + 1]);
776 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
777 "addr 0x%02x\n", adap_id,
778 address_data->normal_i2c[i]);
779 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
788 struct i2c_adapter* i2c_get_adapter(int id)
790 struct i2c_adapter *adapter;
793 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
794 if (adapter && !try_module_get(adapter->owner))
801 void i2c_put_adapter(struct i2c_adapter *adap)
803 module_put(adap->owner);
806 /* The SMBus parts */
808 #define POLY (0x1070U << 3)
814 for(i = 0; i < 8; i++) {
819 return (u8)(data >> 8);
822 /* Incremental CRC8 over count bytes in the array pointed to by p */
823 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
827 for(i = 0; i < count; i++)
828 crc = crc8((crc ^ p[i]) << 8);
832 /* Assume a 7-bit address, which is reasonable for SMBus */
833 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
835 /* The address will be sent first */
836 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
837 pec = i2c_smbus_pec(pec, &addr, 1);
839 /* The data buffer follows */
840 return i2c_smbus_pec(pec, msg->buf, msg->len);
843 /* Used for write only transactions */
844 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
846 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
850 /* Return <0 on CRC error
851 If there was a write before this read (most cases) we need to take the
852 partial CRC from the write part into account.
853 Note that this function does modify the message (we need to decrease the
854 message length to hide the CRC byte from the caller). */
855 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
857 u8 rpec = msg->buf[--msg->len];
858 cpec = i2c_smbus_msg_pec(cpec, msg);
861 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
868 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
870 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
871 value,0,I2C_SMBUS_QUICK,NULL);
874 s32 i2c_smbus_read_byte(struct i2c_client *client)
876 union i2c_smbus_data data;
877 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
878 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
881 return 0x0FF & data.byte;
884 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
886 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
887 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
890 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
892 union i2c_smbus_data data;
893 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
894 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
897 return 0x0FF & data.byte;
900 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
902 union i2c_smbus_data data;
904 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
905 I2C_SMBUS_WRITE,command,
906 I2C_SMBUS_BYTE_DATA,&data);
909 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
911 union i2c_smbus_data data;
912 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
913 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
916 return 0x0FFFF & data.word;
919 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
921 union i2c_smbus_data data;
923 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
924 I2C_SMBUS_WRITE,command,
925 I2C_SMBUS_WORD_DATA,&data);
928 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
929 u8 length, u8 *values)
931 union i2c_smbus_data data;
933 if (length > I2C_SMBUS_BLOCK_MAX)
934 length = I2C_SMBUS_BLOCK_MAX;
935 for (i = 1; i <= length; i++)
936 data.block[i] = values[i-1];
937 data.block[0] = length;
938 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
939 I2C_SMBUS_WRITE,command,
940 I2C_SMBUS_BLOCK_DATA,&data);
943 /* Returns the number of read bytes */
944 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
946 union i2c_smbus_data data;
948 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
949 I2C_SMBUS_READ,command,
950 I2C_SMBUS_I2C_BLOCK_DATA,&data))
953 for (i = 1; i <= data.block[0]; i++)
954 values[i-1] = data.block[i];
955 return data.block[0];
959 /* Simulate a SMBus command using the i2c protocol
960 No checking of parameters is done! */
961 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
962 unsigned short flags,
963 char read_write, u8 command, int size,
964 union i2c_smbus_data * data)
966 /* So we need to generate a series of msgs. In the case of writing, we
967 need to use only one message; when reading, we need two. We initialize
968 most things with sane defaults, to keep the code below somewhat
970 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
971 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
972 int num = read_write == I2C_SMBUS_READ?2:1;
973 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
974 { addr, flags | I2C_M_RD, 0, msgbuf1 }
979 msgbuf0[0] = command;
981 case I2C_SMBUS_QUICK:
983 /* Special case: The read/write field is used as data */
984 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
988 if (read_write == I2C_SMBUS_READ) {
989 /* Special case: only a read! */
990 msg[0].flags = I2C_M_RD | flags;
994 case I2C_SMBUS_BYTE_DATA:
995 if (read_write == I2C_SMBUS_READ)
999 msgbuf0[1] = data->byte;
1002 case I2C_SMBUS_WORD_DATA:
1003 if (read_write == I2C_SMBUS_READ)
1007 msgbuf0[1] = data->word & 0xff;
1008 msgbuf0[2] = (data->word >> 8) & 0xff;
1011 case I2C_SMBUS_PROC_CALL:
1012 num = 2; /* Special case */
1013 read_write = I2C_SMBUS_READ;
1016 msgbuf0[1] = data->word & 0xff;
1017 msgbuf0[2] = (data->word >> 8) & 0xff;
1019 case I2C_SMBUS_BLOCK_DATA:
1020 if (read_write == I2C_SMBUS_READ) {
1021 dev_err(&adapter->dev, "Block read not supported "
1022 "under I2C emulation!\n");
1025 msg[0].len = data->block[0] + 2;
1026 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1027 dev_err(&adapter->dev, "smbus_access called with "
1028 "invalid block write size (%d)\n",
1032 for (i = 1; i < msg[0].len; i++)
1033 msgbuf0[i] = data->block[i-1];
1036 case I2C_SMBUS_BLOCK_PROC_CALL:
1037 dev_dbg(&adapter->dev, "Block process call not supported "
1038 "under I2C emulation!\n");
1040 case I2C_SMBUS_I2C_BLOCK_DATA:
1041 if (read_write == I2C_SMBUS_READ) {
1042 msg[1].len = I2C_SMBUS_BLOCK_MAX;
1044 msg[0].len = data->block[0] + 1;
1045 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1046 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1047 "invalid block write size (%d)\n",
1051 for (i = 1; i <= data->block[0]; i++)
1052 msgbuf0[i] = data->block[i];
1056 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1061 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1062 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1064 /* Compute PEC if first message is a write */
1065 if (!(msg[0].flags & I2C_M_RD)) {
1066 if (num == 1) /* Write only */
1067 i2c_smbus_add_pec(&msg[0]);
1068 else /* Write followed by read */
1069 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1071 /* Ask for PEC if last message is a read */
1072 if (msg[num-1].flags & I2C_M_RD)
1076 if (i2c_transfer(adapter, msg, num) < 0)
1079 /* Check PEC if last message is a read */
1080 if (i && (msg[num-1].flags & I2C_M_RD)) {
1081 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1085 if (read_write == I2C_SMBUS_READ)
1087 case I2C_SMBUS_BYTE:
1088 data->byte = msgbuf0[0];
1090 case I2C_SMBUS_BYTE_DATA:
1091 data->byte = msgbuf1[0];
1093 case I2C_SMBUS_WORD_DATA:
1094 case I2C_SMBUS_PROC_CALL:
1095 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1097 case I2C_SMBUS_I2C_BLOCK_DATA:
1098 /* fixed at 32 for now */
1099 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1100 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1101 data->block[i+1] = msgbuf1[i];
1108 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1109 char read_write, u8 command, int size,
1110 union i2c_smbus_data * data)
1114 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1116 if (adapter->algo->smbus_xfer) {
1117 down(&adapter->bus_lock);
1118 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1120 up(&adapter->bus_lock);
1122 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1129 /* Next four are needed by i2c-isa */
1130 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1131 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1132 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1133 EXPORT_SYMBOL_GPL(i2c_bus_type);
1135 EXPORT_SYMBOL(i2c_add_adapter);
1136 EXPORT_SYMBOL(i2c_del_adapter);
1137 EXPORT_SYMBOL(i2c_del_driver);
1138 EXPORT_SYMBOL(i2c_attach_client);
1139 EXPORT_SYMBOL(i2c_detach_client);
1140 EXPORT_SYMBOL(i2c_use_client);
1141 EXPORT_SYMBOL(i2c_release_client);
1142 EXPORT_SYMBOL(i2c_clients_command);
1143 EXPORT_SYMBOL(i2c_check_addr);
1145 EXPORT_SYMBOL(i2c_master_send);
1146 EXPORT_SYMBOL(i2c_master_recv);
1147 EXPORT_SYMBOL(i2c_control);
1148 EXPORT_SYMBOL(i2c_transfer);
1149 EXPORT_SYMBOL(i2c_get_adapter);
1150 EXPORT_SYMBOL(i2c_put_adapter);
1151 EXPORT_SYMBOL(i2c_probe);
1153 EXPORT_SYMBOL(i2c_smbus_xfer);
1154 EXPORT_SYMBOL(i2c_smbus_write_quick);
1155 EXPORT_SYMBOL(i2c_smbus_read_byte);
1156 EXPORT_SYMBOL(i2c_smbus_write_byte);
1157 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1158 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1159 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1160 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1161 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1162 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1164 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1165 MODULE_DESCRIPTION("I2C-Bus main module");
1166 MODULE_LICENSE("GPL");