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 want the same filename for a
132 * different type of a device. So beware if the DEVICE_ATTR() macro ever
133 * changes, this definition will also have to change.
135 static struct device_attribute dev_attr_client_name = {
136 .attr = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE },
137 .show = &show_client_name,
141 /* ---------------------------------------------------
142 * registering functions
143 * ---------------------------------------------------
147 * i2c_add_adapter is called from within the algorithm layer,
148 * when a new hw adapter registers. A new device is register to be
149 * available for clients.
151 int i2c_add_adapter(struct i2c_adapter *adap)
154 struct list_head *item;
155 struct i2c_driver *driver;
157 mutex_lock(&core_lists);
159 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
164 res = idr_get_new(&i2c_adapter_idr, adap, &id);
171 adap->nr = id & MAX_ID_MASK;
172 init_MUTEX(&adap->bus_lock);
173 init_MUTEX(&adap->clist_lock);
174 list_add_tail(&adap->list,&adapters);
175 INIT_LIST_HEAD(&adap->clients);
177 /* Add the adapter to the driver core.
178 * If the parent pointer is not set up,
179 * we add this adapter to the host bus.
181 if (adap->dev.parent == NULL)
182 adap->dev.parent = &platform_bus;
183 sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
184 adap->dev.driver = &i2c_adapter_driver;
185 adap->dev.release = &i2c_adapter_dev_release;
186 device_register(&adap->dev);
187 device_create_file(&adap->dev, &dev_attr_name);
189 /* Add this adapter to the i2c_adapter class */
190 memset(&adap->class_dev, 0x00, sizeof(struct class_device));
191 adap->class_dev.dev = &adap->dev;
192 adap->class_dev.class = &i2c_adapter_class;
193 strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
194 class_device_register(&adap->class_dev);
196 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
198 /* inform drivers of new adapters */
199 list_for_each(item,&drivers) {
200 driver = list_entry(item, struct i2c_driver, list);
201 if (driver->attach_adapter)
202 /* We ignore the return code; if it fails, too bad */
203 driver->attach_adapter(adap);
207 mutex_unlock(&core_lists);
212 int i2c_del_adapter(struct i2c_adapter *adap)
214 struct list_head *item, *_n;
215 struct i2c_adapter *adap_from_list;
216 struct i2c_driver *driver;
217 struct i2c_client *client;
220 mutex_lock(&core_lists);
222 /* First make sure that this adapter was ever added */
223 list_for_each_entry(adap_from_list, &adapters, list) {
224 if (adap_from_list == adap)
227 if (adap_from_list != adap) {
228 pr_debug("i2c-core: attempting to delete unregistered "
229 "adapter [%s]\n", adap->name);
234 list_for_each(item,&drivers) {
235 driver = list_entry(item, struct i2c_driver, list);
236 if (driver->detach_adapter)
237 if ((res = driver->detach_adapter(adap))) {
238 dev_err(&adap->dev, "detach_adapter failed "
240 driver->driver.name);
245 /* detach any active clients. This must be done first, because
246 * it can fail; in which case we give up. */
247 list_for_each_safe(item, _n, &adap->clients) {
248 client = list_entry(item, struct i2c_client, list);
250 if ((res=client->driver->detach_client(client))) {
251 dev_err(&adap->dev, "detach_client failed for client "
252 "[%s] at address 0x%02x\n", client->name,
258 /* clean up the sysfs representation */
259 init_completion(&adap->dev_released);
260 init_completion(&adap->class_dev_released);
261 class_device_unregister(&adap->class_dev);
262 device_remove_file(&adap->dev, &dev_attr_name);
263 device_unregister(&adap->dev);
264 list_del(&adap->list);
266 /* wait for sysfs to drop all references */
267 wait_for_completion(&adap->dev_released);
268 wait_for_completion(&adap->class_dev_released);
270 /* free dynamically allocated bus id */
271 idr_remove(&i2c_adapter_idr, adap->nr);
273 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
276 mutex_unlock(&core_lists);
282 * What follows is the "upwards" interface: commands for talking to clients,
283 * which implement the functions to access the physical information of the
287 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
289 struct list_head *item;
290 struct i2c_adapter *adapter;
293 mutex_lock(&core_lists);
295 /* add the driver to the list of i2c drivers in the driver core */
296 driver->driver.owner = owner;
297 driver->driver.bus = &i2c_bus_type;
299 res = driver_register(&driver->driver);
303 list_add_tail(&driver->list,&drivers);
304 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
306 /* now look for instances of driver on our adapters */
307 if (driver->attach_adapter) {
308 list_for_each(item,&adapters) {
309 adapter = list_entry(item, struct i2c_adapter, list);
310 driver->attach_adapter(adapter);
315 mutex_unlock(&core_lists);
318 EXPORT_SYMBOL(i2c_register_driver);
320 int i2c_del_driver(struct i2c_driver *driver)
322 struct list_head *item1, *item2, *_n;
323 struct i2c_client *client;
324 struct i2c_adapter *adap;
328 mutex_lock(&core_lists);
330 /* Have a look at each adapter, if clients of this driver are still
331 * attached. If so, detach them to be able to kill the driver
334 list_for_each(item1,&adapters) {
335 adap = list_entry(item1, struct i2c_adapter, list);
336 if (driver->detach_adapter) {
337 if ((res = driver->detach_adapter(adap))) {
338 dev_err(&adap->dev, "detach_adapter failed "
340 driver->driver.name);
344 list_for_each_safe(item2, _n, &adap->clients) {
345 client = list_entry(item2, struct i2c_client, list);
346 if (client->driver != driver)
348 dev_dbg(&adap->dev, "detaching client [%s] "
349 "at 0x%02x\n", client->name,
351 if ((res = driver->detach_client(client))) {
352 dev_err(&adap->dev, "detach_client "
353 "failed for client [%s] at "
354 "0x%02x\n", client->name,
362 driver_unregister(&driver->driver);
363 list_del(&driver->list);
364 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
367 mutex_unlock(&core_lists);
371 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
373 struct list_head *item;
374 struct i2c_client *client;
376 list_for_each(item,&adapter->clients) {
377 client = list_entry(item, struct i2c_client, list);
378 if (client->addr == addr)
384 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
388 down(&adapter->clist_lock);
389 rval = __i2c_check_addr(adapter, addr);
390 up(&adapter->clist_lock);
395 int i2c_attach_client(struct i2c_client *client)
397 struct i2c_adapter *adapter = client->adapter;
399 down(&adapter->clist_lock);
400 if (__i2c_check_addr(client->adapter, client->addr)) {
401 up(&adapter->clist_lock);
404 list_add_tail(&client->list,&adapter->clients);
405 up(&adapter->clist_lock);
407 if (adapter->client_register) {
408 if (adapter->client_register(client)) {
409 dev_dbg(&adapter->dev, "client_register "
410 "failed for client [%s] at 0x%02x\n",
411 client->name, client->addr);
415 client->usage_count = 0;
417 client->dev.parent = &client->adapter->dev;
418 client->dev.driver = &client->driver->driver;
419 client->dev.bus = &i2c_bus_type;
420 client->dev.release = &i2c_client_release;
422 snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
423 "%d-%04x", i2c_adapter_id(adapter), client->addr);
424 dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
425 client->name, client->dev.bus_id);
426 device_register(&client->dev);
427 device_create_file(&client->dev, &dev_attr_client_name);
433 int i2c_detach_client(struct i2c_client *client)
435 struct i2c_adapter *adapter = client->adapter;
438 if (client->usage_count > 0) {
439 dev_warn(&client->dev, "Client [%s] still busy, "
440 "can't detach\n", client->name);
444 if (adapter->client_unregister) {
445 res = adapter->client_unregister(client);
447 dev_err(&client->dev,
448 "client_unregister [%s] failed, "
449 "client not detached\n", client->name);
454 down(&adapter->clist_lock);
455 list_del(&client->list);
456 init_completion(&client->released);
457 device_remove_file(&client->dev, &dev_attr_client_name);
458 device_unregister(&client->dev);
459 up(&adapter->clist_lock);
460 wait_for_completion(&client->released);
466 static int i2c_inc_use_client(struct i2c_client *client)
469 if (!try_module_get(client->driver->driver.owner))
471 if (!try_module_get(client->adapter->owner)) {
472 module_put(client->driver->driver.owner);
479 static void i2c_dec_use_client(struct i2c_client *client)
481 module_put(client->driver->driver.owner);
482 module_put(client->adapter->owner);
485 int i2c_use_client(struct i2c_client *client)
489 ret = i2c_inc_use_client(client);
493 client->usage_count++;
498 int i2c_release_client(struct i2c_client *client)
500 if (!client->usage_count) {
501 pr_debug("i2c-core: %s used one too many times\n",
506 client->usage_count--;
507 i2c_dec_use_client(client);
512 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
514 struct list_head *item;
515 struct i2c_client *client;
517 down(&adap->clist_lock);
518 list_for_each(item,&adap->clients) {
519 client = list_entry(item, struct i2c_client, list);
520 if (!try_module_get(client->driver->driver.owner))
522 if (NULL != client->driver->command) {
523 up(&adap->clist_lock);
524 client->driver->command(client,cmd,arg);
525 down(&adap->clist_lock);
527 module_put(client->driver->driver.owner);
529 up(&adap->clist_lock);
532 static int __init i2c_init(void)
536 retval = bus_register(&i2c_bus_type);
539 retval = driver_register(&i2c_adapter_driver);
542 return class_register(&i2c_adapter_class);
545 static void __exit i2c_exit(void)
547 class_unregister(&i2c_adapter_class);
548 driver_unregister(&i2c_adapter_driver);
549 bus_unregister(&i2c_bus_type);
552 subsys_initcall(i2c_init);
553 module_exit(i2c_exit);
555 /* ----------------------------------------------------
556 * the functional interface to the i2c busses.
557 * ----------------------------------------------------
560 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
564 if (adap->algo->master_xfer) {
566 for (ret = 0; ret < num; ret++) {
567 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
568 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
569 'R' : 'W', msgs[ret].addr, msgs[ret].len);
573 down(&adap->bus_lock);
574 ret = adap->algo->master_xfer(adap,msgs,num);
579 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
584 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
587 struct i2c_adapter *adap=client->adapter;
590 msg.addr = client->addr;
591 msg.flags = client->flags & I2C_M_TEN;
593 msg.buf = (char *)buf;
595 ret = i2c_transfer(adap, &msg, 1);
597 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
598 transmitted, else error code. */
599 return (ret == 1) ? count : ret;
602 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
604 struct i2c_adapter *adap=client->adapter;
608 msg.addr = client->addr;
609 msg.flags = client->flags & I2C_M_TEN;
610 msg.flags |= I2C_M_RD;
614 ret = i2c_transfer(adap, &msg, 1);
616 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
617 transmitted, else error code. */
618 return (ret == 1) ? count : ret;
622 int i2c_control(struct i2c_client *client,
623 unsigned int cmd, unsigned long arg)
626 struct i2c_adapter *adap = client->adapter;
628 dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
637 if (adap->algo->algo_control!=NULL)
638 ret = adap->algo->algo_control(adap,cmd,arg);
643 /* ----------------------------------------------------
644 * the i2c address scanning function
645 * Will not work for 10-bit addresses!
646 * ----------------------------------------------------
648 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
649 int (*found_proc) (struct i2c_adapter *, int, int))
653 /* Make sure the address is valid */
654 if (addr < 0x03 || addr > 0x77) {
655 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
660 /* Skip if already in use */
661 if (i2c_check_addr(adapter, addr))
664 /* Make sure there is something at this address, unless forced */
666 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
667 I2C_SMBUS_QUICK, NULL) < 0)
670 /* prevent 24RF08 corruption */
671 if ((addr & ~0x0f) == 0x50)
672 i2c_smbus_xfer(adapter, addr, 0, 0, 0,
673 I2C_SMBUS_QUICK, NULL);
676 /* Finally call the custom detection function */
677 err = found_proc(adapter, addr, kind);
679 /* -ENODEV can be returned if there is a chip at the given address
680 but it isn't supported by this chip driver. We catch it here as
681 this isn't an error. */
682 return (err == -ENODEV) ? 0 : err;
685 int i2c_probe(struct i2c_adapter *adapter,
686 struct i2c_client_address_data *address_data,
687 int (*found_proc) (struct i2c_adapter *, int, int))
690 int adap_id = i2c_adapter_id(adapter);
692 /* Force entries are done first, and are not affected by ignore
694 if (address_data->forces) {
695 unsigned short **forces = address_data->forces;
698 for (kind = 0; forces[kind]; kind++) {
699 for (i = 0; forces[kind][i] != I2C_CLIENT_END;
701 if (forces[kind][i] == adap_id
702 || forces[kind][i] == ANY_I2C_BUS) {
703 dev_dbg(&adapter->dev, "found force "
704 "parameter for adapter %d, "
705 "addr 0x%02x, kind %d\n",
706 adap_id, forces[kind][i + 1],
708 err = i2c_probe_address(adapter,
718 /* Stop here if we can't use SMBUS_QUICK */
719 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
720 if (address_data->probe[0] == I2C_CLIENT_END
721 && address_data->normal_i2c[0] == I2C_CLIENT_END)
724 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
725 "can't probe for chips\n");
729 /* Probe entries are done second, and are not affected by ignore
731 for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
732 if (address_data->probe[i] == adap_id
733 || address_data->probe[i] == ANY_I2C_BUS) {
734 dev_dbg(&adapter->dev, "found probe parameter for "
735 "adapter %d, addr 0x%02x\n", adap_id,
736 address_data->probe[i + 1]);
737 err = i2c_probe_address(adapter,
738 address_data->probe[i + 1],
745 /* Normal entries are done last, unless shadowed by an ignore entry */
746 for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
750 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
752 if ((address_data->ignore[j] == adap_id ||
753 address_data->ignore[j] == ANY_I2C_BUS)
754 && address_data->ignore[j + 1]
755 == address_data->normal_i2c[i]) {
756 dev_dbg(&adapter->dev, "found ignore "
757 "parameter for adapter %d, "
758 "addr 0x%02x\n", adap_id,
759 address_data->ignore[j + 1]);
767 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
768 "addr 0x%02x\n", adap_id,
769 address_data->normal_i2c[i]);
770 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
779 struct i2c_adapter* i2c_get_adapter(int id)
781 struct i2c_adapter *adapter;
783 mutex_lock(&core_lists);
784 adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
785 if (adapter && !try_module_get(adapter->owner))
788 mutex_unlock(&core_lists);
792 void i2c_put_adapter(struct i2c_adapter *adap)
794 module_put(adap->owner);
797 /* The SMBus parts */
799 #define POLY (0x1070U << 3)
805 for(i = 0; i < 8; i++) {
810 return (u8)(data >> 8);
813 /* Incremental CRC8 over count bytes in the array pointed to by p */
814 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
818 for(i = 0; i < count; i++)
819 crc = crc8((crc ^ p[i]) << 8);
823 /* Assume a 7-bit address, which is reasonable for SMBus */
824 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
826 /* The address will be sent first */
827 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
828 pec = i2c_smbus_pec(pec, &addr, 1);
830 /* The data buffer follows */
831 return i2c_smbus_pec(pec, msg->buf, msg->len);
834 /* Used for write only transactions */
835 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
837 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
841 /* Return <0 on CRC error
842 If there was a write before this read (most cases) we need to take the
843 partial CRC from the write part into account.
844 Note that this function does modify the message (we need to decrease the
845 message length to hide the CRC byte from the caller). */
846 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
848 u8 rpec = msg->buf[--msg->len];
849 cpec = i2c_smbus_msg_pec(cpec, msg);
852 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
859 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
861 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
862 value,0,I2C_SMBUS_QUICK,NULL);
865 s32 i2c_smbus_read_byte(struct i2c_client *client)
867 union i2c_smbus_data data;
868 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
869 I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
872 return 0x0FF & data.byte;
875 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
877 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
878 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
881 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
883 union i2c_smbus_data data;
884 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
885 I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
888 return 0x0FF & data.byte;
891 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
893 union i2c_smbus_data data;
895 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
896 I2C_SMBUS_WRITE,command,
897 I2C_SMBUS_BYTE_DATA,&data);
900 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
902 union i2c_smbus_data data;
903 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
904 I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
907 return 0x0FFFF & data.word;
910 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
912 union i2c_smbus_data data;
914 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
915 I2C_SMBUS_WRITE,command,
916 I2C_SMBUS_WORD_DATA,&data);
919 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
920 u8 length, u8 *values)
922 union i2c_smbus_data data;
924 if (length > I2C_SMBUS_BLOCK_MAX)
925 length = I2C_SMBUS_BLOCK_MAX;
926 for (i = 1; i <= length; i++)
927 data.block[i] = values[i-1];
928 data.block[0] = length;
929 return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
930 I2C_SMBUS_WRITE,command,
931 I2C_SMBUS_BLOCK_DATA,&data);
934 /* Returns the number of read bytes */
935 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
937 union i2c_smbus_data data;
939 if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
940 I2C_SMBUS_READ,command,
941 I2C_SMBUS_I2C_BLOCK_DATA,&data))
944 for (i = 1; i <= data.block[0]; i++)
945 values[i-1] = data.block[i];
946 return data.block[0];
950 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
951 u8 length, u8 *values)
953 union i2c_smbus_data data;
955 if (length > I2C_SMBUS_BLOCK_MAX)
956 length = I2C_SMBUS_BLOCK_MAX;
957 data.block[0] = length;
958 memcpy(data.block + 1, values, length);
959 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
960 I2C_SMBUS_WRITE, command,
961 I2C_SMBUS_I2C_BLOCK_DATA, &data);
964 /* Simulate a SMBus command using the i2c protocol
965 No checking of parameters is done! */
966 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
967 unsigned short flags,
968 char read_write, u8 command, int size,
969 union i2c_smbus_data * data)
971 /* So we need to generate a series of msgs. In the case of writing, we
972 need to use only one message; when reading, we need two. We initialize
973 most things with sane defaults, to keep the code below somewhat
975 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
976 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
977 int num = read_write == I2C_SMBUS_READ?2:1;
978 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
979 { addr, flags | I2C_M_RD, 0, msgbuf1 }
984 msgbuf0[0] = command;
986 case I2C_SMBUS_QUICK:
988 /* Special case: The read/write field is used as data */
989 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
993 if (read_write == I2C_SMBUS_READ) {
994 /* Special case: only a read! */
995 msg[0].flags = I2C_M_RD | flags;
999 case I2C_SMBUS_BYTE_DATA:
1000 if (read_write == I2C_SMBUS_READ)
1004 msgbuf0[1] = data->byte;
1007 case I2C_SMBUS_WORD_DATA:
1008 if (read_write == I2C_SMBUS_READ)
1012 msgbuf0[1] = data->word & 0xff;
1013 msgbuf0[2] = (data->word >> 8) & 0xff;
1016 case I2C_SMBUS_PROC_CALL:
1017 num = 2; /* Special case */
1018 read_write = I2C_SMBUS_READ;
1021 msgbuf0[1] = data->word & 0xff;
1022 msgbuf0[2] = (data->word >> 8) & 0xff;
1024 case I2C_SMBUS_BLOCK_DATA:
1025 if (read_write == I2C_SMBUS_READ) {
1026 dev_err(&adapter->dev, "Block read not supported "
1027 "under I2C emulation!\n");
1030 msg[0].len = data->block[0] + 2;
1031 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1032 dev_err(&adapter->dev, "smbus_access called with "
1033 "invalid block write size (%d)\n",
1037 for (i = 1; i < msg[0].len; i++)
1038 msgbuf0[i] = data->block[i-1];
1041 case I2C_SMBUS_BLOCK_PROC_CALL:
1042 dev_dbg(&adapter->dev, "Block process call not supported "
1043 "under I2C emulation!\n");
1045 case I2C_SMBUS_I2C_BLOCK_DATA:
1046 if (read_write == I2C_SMBUS_READ) {
1047 msg[1].len = I2C_SMBUS_BLOCK_MAX;
1049 msg[0].len = data->block[0] + 1;
1050 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1051 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1052 "invalid block write size (%d)\n",
1056 for (i = 1; i <= data->block[0]; i++)
1057 msgbuf0[i] = data->block[i];
1061 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1066 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1067 && size != I2C_SMBUS_I2C_BLOCK_DATA);
1069 /* Compute PEC if first message is a write */
1070 if (!(msg[0].flags & I2C_M_RD)) {
1071 if (num == 1) /* Write only */
1072 i2c_smbus_add_pec(&msg[0]);
1073 else /* Write followed by read */
1074 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1076 /* Ask for PEC if last message is a read */
1077 if (msg[num-1].flags & I2C_M_RD)
1081 if (i2c_transfer(adapter, msg, num) < 0)
1084 /* Check PEC if last message is a read */
1085 if (i && (msg[num-1].flags & I2C_M_RD)) {
1086 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1090 if (read_write == I2C_SMBUS_READ)
1092 case I2C_SMBUS_BYTE:
1093 data->byte = msgbuf0[0];
1095 case I2C_SMBUS_BYTE_DATA:
1096 data->byte = msgbuf1[0];
1098 case I2C_SMBUS_WORD_DATA:
1099 case I2C_SMBUS_PROC_CALL:
1100 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1102 case I2C_SMBUS_I2C_BLOCK_DATA:
1103 /* fixed at 32 for now */
1104 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1105 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1106 data->block[i+1] = msgbuf1[i];
1113 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1114 char read_write, u8 command, int size,
1115 union i2c_smbus_data * data)
1119 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1121 if (adapter->algo->smbus_xfer) {
1122 down(&adapter->bus_lock);
1123 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1125 up(&adapter->bus_lock);
1127 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1134 /* Next four are needed by i2c-isa */
1135 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1136 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1137 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1138 EXPORT_SYMBOL_GPL(i2c_bus_type);
1140 EXPORT_SYMBOL(i2c_add_adapter);
1141 EXPORT_SYMBOL(i2c_del_adapter);
1142 EXPORT_SYMBOL(i2c_del_driver);
1143 EXPORT_SYMBOL(i2c_attach_client);
1144 EXPORT_SYMBOL(i2c_detach_client);
1145 EXPORT_SYMBOL(i2c_use_client);
1146 EXPORT_SYMBOL(i2c_release_client);
1147 EXPORT_SYMBOL(i2c_clients_command);
1148 EXPORT_SYMBOL(i2c_check_addr);
1150 EXPORT_SYMBOL(i2c_master_send);
1151 EXPORT_SYMBOL(i2c_master_recv);
1152 EXPORT_SYMBOL(i2c_control);
1153 EXPORT_SYMBOL(i2c_transfer);
1154 EXPORT_SYMBOL(i2c_get_adapter);
1155 EXPORT_SYMBOL(i2c_put_adapter);
1156 EXPORT_SYMBOL(i2c_probe);
1158 EXPORT_SYMBOL(i2c_smbus_xfer);
1159 EXPORT_SYMBOL(i2c_smbus_write_quick);
1160 EXPORT_SYMBOL(i2c_smbus_read_byte);
1161 EXPORT_SYMBOL(i2c_smbus_write_byte);
1162 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1163 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1164 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1165 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1166 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1167 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1168 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1170 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1171 MODULE_DESCRIPTION("I2C-Bus main module");
1172 MODULE_LICENSE("GPL");