1 /* i2c-core.c - a device driver for the iic-bus interface */
2 /* ------------------------------------------------------------------------- */
3 /* Copyright (C) 1995-99 Simon G. Vogl
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18 /* ------------------------------------------------------------------------- */
20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
21 All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
22 SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
23 Jean Delvare <khali@linux-fr.org> */
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
30 #include <linux/init.h>
31 #include <linux/idr.h>
32 #include <linux/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <asm/uaccess.h>
41 static LIST_HEAD(adapters
);
42 static LIST_HEAD(drivers
);
43 static DEFINE_MUTEX(core_lists
);
44 static DEFINE_IDR(i2c_adapter_idr
);
46 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
48 /* ------------------------------------------------------------------------- */
50 static int i2c_device_match(struct device
*dev
, struct device_driver
*drv
)
52 struct i2c_client
*client
= to_i2c_client(dev
);
53 struct i2c_driver
*driver
= to_i2c_driver(drv
);
55 /* make legacy i2c drivers bypass driver model probing entirely;
56 * such drivers scan each i2c adapter/bus themselves.
58 if (!is_newstyle_driver(driver
))
61 /* new style drivers use the same kind of driver matching policy
62 * as platform devices or SPI: compare device and driver IDs.
64 return strcmp(client
->driver_name
, drv
->name
) == 0;
69 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
70 static int i2c_device_uevent(struct device
*dev
, char **envp
, int num_envp
,
71 char *buffer
, int buffer_size
)
73 struct i2c_client
*client
= to_i2c_client(dev
);
74 int i
= 0, length
= 0;
76 /* by definition, legacy drivers can't hotplug */
77 if (dev
->driver
|| !client
->driver_name
)
80 if (add_uevent_var(envp
, num_envp
, &i
, buffer
, buffer_size
, &length
,
81 "MODALIAS=%s", client
->driver_name
))
84 dev_dbg(dev
, "uevent\n");
89 #define i2c_device_uevent NULL
90 #endif /* CONFIG_HOTPLUG */
92 static int i2c_device_probe(struct device
*dev
)
94 struct i2c_client
*client
= to_i2c_client(dev
);
95 struct i2c_driver
*driver
= to_i2c_driver(dev
->driver
);
99 client
->driver
= driver
;
100 dev_dbg(dev
, "probe\n");
101 return driver
->probe(client
);
104 static int i2c_device_remove(struct device
*dev
)
106 struct i2c_client
*client
= to_i2c_client(dev
);
107 struct i2c_driver
*driver
;
113 driver
= to_i2c_driver(dev
->driver
);
114 if (driver
->remove
) {
115 dev_dbg(dev
, "remove\n");
116 status
= driver
->remove(client
);
122 client
->driver
= NULL
;
126 static void i2c_device_shutdown(struct device
*dev
)
128 struct i2c_driver
*driver
;
132 driver
= to_i2c_driver(dev
->driver
);
133 if (driver
->shutdown
)
134 driver
->shutdown(to_i2c_client(dev
));
137 static int i2c_device_suspend(struct device
* dev
, pm_message_t mesg
)
139 struct i2c_driver
*driver
;
143 driver
= to_i2c_driver(dev
->driver
);
144 if (!driver
->suspend
)
146 return driver
->suspend(to_i2c_client(dev
), mesg
);
149 static int i2c_device_resume(struct device
* dev
)
151 struct i2c_driver
*driver
;
155 driver
= to_i2c_driver(dev
->driver
);
158 return driver
->resume(to_i2c_client(dev
));
161 static void i2c_client_release(struct device
*dev
)
163 struct i2c_client
*client
= to_i2c_client(dev
);
164 complete(&client
->released
);
167 static void i2c_client_dev_release(struct device
*dev
)
169 kfree(to_i2c_client(dev
));
172 static ssize_t
show_client_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
174 struct i2c_client
*client
= to_i2c_client(dev
);
175 return sprintf(buf
, "%s\n", client
->name
);
178 static ssize_t
show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
180 struct i2c_client
*client
= to_i2c_client(dev
);
181 return client
->driver_name
182 ? sprintf(buf
, "%s\n", client
->driver_name
)
186 static struct device_attribute i2c_dev_attrs
[] = {
187 __ATTR(name
, S_IRUGO
, show_client_name
, NULL
),
188 /* modalias helps coldplug: modprobe $(cat .../modalias) */
189 __ATTR(modalias
, S_IRUGO
, show_modalias
, NULL
),
193 struct bus_type i2c_bus_type
= {
195 .dev_attrs
= i2c_dev_attrs
,
196 .match
= i2c_device_match
,
197 .uevent
= i2c_device_uevent
,
198 .probe
= i2c_device_probe
,
199 .remove
= i2c_device_remove
,
200 .shutdown
= i2c_device_shutdown
,
201 .suspend
= i2c_device_suspend
,
202 .resume
= i2c_device_resume
,
204 EXPORT_SYMBOL_GPL(i2c_bus_type
);
207 * i2c_new_device - instantiate an i2c device for use with a new style driver
208 * @adap: the adapter managing the device
209 * @info: describes one I2C device; bus_num is ignored
211 * Create a device to work with a new style i2c driver, where binding is
212 * handled through driver model probe()/remove() methods. This call is not
213 * appropriate for use by mainboad initialization logic, which usually runs
214 * during an arch_initcall() long before any i2c_adapter could exist.
216 * This returns the new i2c client, which may be saved for later use with
217 * i2c_unregister_device(); or NULL to indicate an error.
220 i2c_new_device(struct i2c_adapter
*adap
, struct i2c_board_info
const *info
)
222 struct i2c_client
*client
;
225 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
229 client
->adapter
= adap
;
231 client
->dev
.platform_data
= info
->platform_data
;
232 client
->flags
= info
->flags
;
233 client
->addr
= info
->addr
;
234 client
->irq
= info
->irq
;
236 strlcpy(client
->driver_name
, info
->driver_name
,
237 sizeof(client
->driver_name
));
238 strlcpy(client
->name
, info
->type
, sizeof(client
->name
));
240 /* a new style driver may be bound to this device when we
241 * return from this function, or any later moment (e.g. maybe
242 * hotplugging will load the driver module). and the device
243 * refcount model is the standard driver model one.
245 status
= i2c_attach_client(client
);
252 EXPORT_SYMBOL_GPL(i2c_new_device
);
256 * i2c_unregister_device - reverse effect of i2c_new_device()
257 * @client: value returned from i2c_new_device()
259 void i2c_unregister_device(struct i2c_client
*client
)
261 struct i2c_adapter
*adapter
= client
->adapter
;
262 struct i2c_driver
*driver
= client
->driver
;
264 if (driver
&& !is_newstyle_driver(driver
)) {
265 dev_err(&client
->dev
, "can't unregister devices "
266 "with legacy drivers\n");
271 mutex_lock(&adapter
->clist_lock
);
272 list_del(&client
->list
);
273 mutex_unlock(&adapter
->clist_lock
);
275 device_unregister(&client
->dev
);
277 EXPORT_SYMBOL_GPL(i2c_unregister_device
);
280 /* ------------------------------------------------------------------------- */
282 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
284 void i2c_adapter_dev_release(struct device
*dev
)
286 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
287 complete(&adap
->dev_released
);
289 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release
); /* exported to i2c-isa */
292 show_adapter_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
294 struct i2c_adapter
*adap
= to_i2c_adapter(dev
);
295 return sprintf(buf
, "%s\n", adap
->name
);
298 static struct device_attribute i2c_adapter_attrs
[] = {
299 __ATTR(name
, S_IRUGO
, show_adapter_name
, NULL
),
303 struct class i2c_adapter_class
= {
304 .owner
= THIS_MODULE
,
305 .name
= "i2c-adapter",
306 .dev_attrs
= i2c_adapter_attrs
,
308 EXPORT_SYMBOL_GPL(i2c_adapter_class
); /* exported to i2c-isa */
310 static void i2c_scan_static_board_info(struct i2c_adapter
*adapter
)
312 struct i2c_devinfo
*devinfo
;
314 mutex_lock(&__i2c_board_lock
);
315 list_for_each_entry(devinfo
, &__i2c_board_list
, list
) {
316 if (devinfo
->busnum
== adapter
->nr
317 && !i2c_new_device(adapter
,
318 &devinfo
->board_info
))
319 printk(KERN_ERR
"i2c-core: can't create i2c%d-%04x\n",
320 i2c_adapter_id(adapter
),
321 devinfo
->board_info
.addr
);
323 mutex_unlock(&__i2c_board_lock
);
326 static int i2c_register_adapter(struct i2c_adapter
*adap
)
329 struct list_head
*item
;
330 struct i2c_driver
*driver
;
332 mutex_init(&adap
->bus_lock
);
333 mutex_init(&adap
->clist_lock
);
334 INIT_LIST_HEAD(&adap
->clients
);
336 mutex_lock(&core_lists
);
337 list_add_tail(&adap
->list
, &adapters
);
339 /* Add the adapter to the driver core.
340 * If the parent pointer is not set up,
341 * we add this adapter to the host bus.
343 if (adap
->dev
.parent
== NULL
) {
344 adap
->dev
.parent
= &platform_bus
;
345 pr_debug("I2C adapter driver [%s] forgot to specify "
346 "physical device\n", adap
->name
);
348 sprintf(adap
->dev
.bus_id
, "i2c-%d", adap
->nr
);
349 adap
->dev
.release
= &i2c_adapter_dev_release
;
350 adap
->dev
.class = &i2c_adapter_class
;
351 res
= device_register(&adap
->dev
);
355 dev_dbg(&adap
->dev
, "adapter [%s] registered\n", adap
->name
);
357 /* create pre-declared device nodes for new-style drivers */
358 if (adap
->nr
< __i2c_first_dynamic_bus_num
)
359 i2c_scan_static_board_info(adap
);
361 /* let legacy drivers scan this bus for matching devices */
362 list_for_each(item
,&drivers
) {
363 driver
= list_entry(item
, struct i2c_driver
, list
);
364 if (driver
->attach_adapter
)
365 /* We ignore the return code; if it fails, too bad */
366 driver
->attach_adapter(adap
);
370 mutex_unlock(&core_lists
);
374 list_del(&adap
->list
);
375 idr_remove(&i2c_adapter_idr
, adap
->nr
);
380 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
381 * @adapter: the adapter to add
383 * This routine is used to declare an I2C adapter when its bus number
384 * doesn't matter. Examples: for I2C adapters dynamically added by
385 * USB links or PCI plugin cards.
387 * When this returns zero, a new bus number was allocated and stored
388 * in adap->nr, and the specified adapter became available for clients.
389 * Otherwise, a negative errno value is returned.
391 int i2c_add_adapter(struct i2c_adapter
*adapter
)
396 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
399 mutex_lock(&core_lists
);
400 /* "above" here means "above or equal to", sigh */
401 res
= idr_get_new_above(&i2c_adapter_idr
, adapter
,
402 __i2c_first_dynamic_bus_num
, &id
);
403 mutex_unlock(&core_lists
);
412 return i2c_register_adapter(adapter
);
414 EXPORT_SYMBOL(i2c_add_adapter
);
417 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
418 * @adap: the adapter to register (with adap->nr initialized)
420 * This routine is used to declare an I2C adapter when its bus number
421 * matters. Example: for I2C adapters from system-on-chip CPUs, or
422 * otherwise built in to the system's mainboard, and where i2c_board_info
423 * is used to properly configure I2C devices.
425 * If no devices have pre-been declared for this bus, then be sure to
426 * register the adapter before any dynamically allocated ones. Otherwise
427 * the required bus ID may not be available.
429 * When this returns zero, the specified adapter became available for
430 * clients using the bus number provided in adap->nr. Also, the table
431 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
432 * and the appropriate driver model device nodes are created. Otherwise, a
433 * negative errno value is returned.
435 int i2c_add_numbered_adapter(struct i2c_adapter
*adap
)
440 if (adap
->nr
& ~MAX_ID_MASK
)
444 if (idr_pre_get(&i2c_adapter_idr
, GFP_KERNEL
) == 0)
447 mutex_lock(&core_lists
);
448 /* "above" here means "above or equal to", sigh;
449 * we need the "equal to" result to force the result
451 status
= idr_get_new_above(&i2c_adapter_idr
, adap
, adap
->nr
, &id
);
452 if (status
== 0 && id
!= adap
->nr
) {
454 idr_remove(&i2c_adapter_idr
, id
);
456 mutex_unlock(&core_lists
);
457 if (status
== -EAGAIN
)
461 status
= i2c_register_adapter(adap
);
464 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter
);
466 int i2c_del_adapter(struct i2c_adapter
*adap
)
468 struct list_head
*item
, *_n
;
469 struct i2c_adapter
*adap_from_list
;
470 struct i2c_driver
*driver
;
471 struct i2c_client
*client
;
474 mutex_lock(&core_lists
);
476 /* First make sure that this adapter was ever added */
477 list_for_each_entry(adap_from_list
, &adapters
, list
) {
478 if (adap_from_list
== adap
)
481 if (adap_from_list
!= adap
) {
482 pr_debug("i2c-core: attempting to delete unregistered "
483 "adapter [%s]\n", adap
->name
);
488 list_for_each(item
,&drivers
) {
489 driver
= list_entry(item
, struct i2c_driver
, list
);
490 if (driver
->detach_adapter
)
491 if ((res
= driver
->detach_adapter(adap
))) {
492 dev_err(&adap
->dev
, "detach_adapter failed "
494 driver
->driver
.name
);
499 /* detach any active clients. This must be done first, because
500 * it can fail; in which case we give up. */
501 list_for_each_safe(item
, _n
, &adap
->clients
) {
502 struct i2c_driver
*driver
;
504 client
= list_entry(item
, struct i2c_client
, list
);
505 driver
= client
->driver
;
507 /* new style, follow standard driver model */
508 if (!driver
|| is_newstyle_driver(driver
)) {
509 i2c_unregister_device(client
);
513 /* legacy drivers create and remove clients themselves */
514 if ((res
= driver
->detach_client(client
))) {
515 dev_err(&adap
->dev
, "detach_client failed for client "
516 "[%s] at address 0x%02x\n", client
->name
,
522 /* clean up the sysfs representation */
523 init_completion(&adap
->dev_released
);
524 device_unregister(&adap
->dev
);
525 list_del(&adap
->list
);
527 /* wait for sysfs to drop all references */
528 wait_for_completion(&adap
->dev_released
);
531 idr_remove(&i2c_adapter_idr
, adap
->nr
);
533 dev_dbg(&adap
->dev
, "adapter [%s] unregistered\n", adap
->name
);
536 mutex_unlock(&core_lists
);
539 EXPORT_SYMBOL(i2c_del_adapter
);
542 /* ------------------------------------------------------------------------- */
545 * An i2c_driver is used with one or more i2c_client (device) nodes to access
546 * i2c slave chips, on a bus instance associated with some i2c_adapter. There
547 * are two models for binding the driver to its device: "new style" drivers
548 * follow the standard Linux driver model and just respond to probe() calls
549 * issued if the driver core sees they match(); "legacy" drivers create device
553 int i2c_register_driver(struct module
*owner
, struct i2c_driver
*driver
)
557 /* new style driver methods can't mix with legacy ones */
558 if (is_newstyle_driver(driver
)) {
559 if (driver
->attach_adapter
|| driver
->detach_adapter
560 || driver
->detach_client
) {
562 "i2c-core: driver [%s] is confused\n",
563 driver
->driver
.name
);
568 /* add the driver to the list of i2c drivers in the driver core */
569 driver
->driver
.owner
= owner
;
570 driver
->driver
.bus
= &i2c_bus_type
;
572 /* for new style drivers, when registration returns the driver core
573 * will have called probe() for all matching-but-unbound devices.
575 res
= driver_register(&driver
->driver
);
579 mutex_lock(&core_lists
);
581 list_add_tail(&driver
->list
,&drivers
);
582 pr_debug("i2c-core: driver [%s] registered\n", driver
->driver
.name
);
584 /* legacy drivers scan i2c busses directly */
585 if (driver
->attach_adapter
) {
586 struct i2c_adapter
*adapter
;
588 list_for_each_entry(adapter
, &adapters
, list
) {
589 driver
->attach_adapter(adapter
);
593 mutex_unlock(&core_lists
);
596 EXPORT_SYMBOL(i2c_register_driver
);
599 * i2c_del_driver - unregister I2C driver
600 * @driver: the driver being unregistered
602 int i2c_del_driver(struct i2c_driver
*driver
)
604 struct list_head
*item1
, *item2
, *_n
;
605 struct i2c_client
*client
;
606 struct i2c_adapter
*adap
;
610 mutex_lock(&core_lists
);
612 /* new-style driver? */
613 if (is_newstyle_driver(driver
))
616 /* Have a look at each adapter, if clients of this driver are still
617 * attached. If so, detach them to be able to kill the driver
620 list_for_each(item1
,&adapters
) {
621 adap
= list_entry(item1
, struct i2c_adapter
, list
);
622 if (driver
->detach_adapter
) {
623 if ((res
= driver
->detach_adapter(adap
))) {
624 dev_err(&adap
->dev
, "detach_adapter failed "
626 driver
->driver
.name
);
630 list_for_each_safe(item2
, _n
, &adap
->clients
) {
631 client
= list_entry(item2
, struct i2c_client
, list
);
632 if (client
->driver
!= driver
)
634 dev_dbg(&adap
->dev
, "detaching client [%s] "
635 "at 0x%02x\n", client
->name
,
637 if ((res
= driver
->detach_client(client
))) {
638 dev_err(&adap
->dev
, "detach_client "
639 "failed for client [%s] at "
640 "0x%02x\n", client
->name
,
649 driver_unregister(&driver
->driver
);
650 list_del(&driver
->list
);
651 pr_debug("i2c-core: driver [%s] unregistered\n", driver
->driver
.name
);
654 mutex_unlock(&core_lists
);
657 EXPORT_SYMBOL(i2c_del_driver
);
659 /* ------------------------------------------------------------------------- */
661 static int __i2c_check_addr(struct i2c_adapter
*adapter
, unsigned int addr
)
663 struct list_head
*item
;
664 struct i2c_client
*client
;
666 list_for_each(item
,&adapter
->clients
) {
667 client
= list_entry(item
, struct i2c_client
, list
);
668 if (client
->addr
== addr
)
674 int i2c_check_addr(struct i2c_adapter
*adapter
, int addr
)
678 mutex_lock(&adapter
->clist_lock
);
679 rval
= __i2c_check_addr(adapter
, addr
);
680 mutex_unlock(&adapter
->clist_lock
);
684 EXPORT_SYMBOL(i2c_check_addr
);
686 int i2c_attach_client(struct i2c_client
*client
)
688 struct i2c_adapter
*adapter
= client
->adapter
;
691 mutex_lock(&adapter
->clist_lock
);
692 if (__i2c_check_addr(client
->adapter
, client
->addr
)) {
696 list_add_tail(&client
->list
,&adapter
->clients
);
698 client
->usage_count
= 0;
700 client
->dev
.parent
= &client
->adapter
->dev
;
701 client
->dev
.bus
= &i2c_bus_type
;
704 client
->dev
.driver
= &client
->driver
->driver
;
706 if (client
->driver
&& !is_newstyle_driver(client
->driver
))
707 client
->dev
.release
= i2c_client_release
;
709 client
->dev
.release
= i2c_client_dev_release
;
711 snprintf(&client
->dev
.bus_id
[0], sizeof(client
->dev
.bus_id
),
712 "%d-%04x", i2c_adapter_id(adapter
), client
->addr
);
713 dev_dbg(&adapter
->dev
, "client [%s] registered with bus id %s\n",
714 client
->name
, client
->dev
.bus_id
);
715 res
= device_register(&client
->dev
);
718 mutex_unlock(&adapter
->clist_lock
);
720 if (adapter
->client_register
) {
721 if (adapter
->client_register(client
)) {
722 dev_dbg(&adapter
->dev
, "client_register "
723 "failed for client [%s] at 0x%02x\n",
724 client
->name
, client
->addr
);
731 list_del(&client
->list
);
732 dev_err(&adapter
->dev
, "Failed to attach i2c client %s at 0x%02x "
733 "(%d)\n", client
->name
, client
->addr
, res
);
735 mutex_unlock(&adapter
->clist_lock
);
738 EXPORT_SYMBOL(i2c_attach_client
);
740 int i2c_detach_client(struct i2c_client
*client
)
742 struct i2c_adapter
*adapter
= client
->adapter
;
745 if (client
->usage_count
> 0) {
746 dev_warn(&client
->dev
, "Client [%s] still busy, "
747 "can't detach\n", client
->name
);
751 if (adapter
->client_unregister
) {
752 res
= adapter
->client_unregister(client
);
754 dev_err(&client
->dev
,
755 "client_unregister [%s] failed, "
756 "client not detached\n", client
->name
);
761 mutex_lock(&adapter
->clist_lock
);
762 list_del(&client
->list
);
763 init_completion(&client
->released
);
764 device_unregister(&client
->dev
);
765 mutex_unlock(&adapter
->clist_lock
);
766 wait_for_completion(&client
->released
);
771 EXPORT_SYMBOL(i2c_detach_client
);
773 static int i2c_inc_use_client(struct i2c_client
*client
)
776 if (!try_module_get(client
->driver
->driver
.owner
))
778 if (!try_module_get(client
->adapter
->owner
)) {
779 module_put(client
->driver
->driver
.owner
);
786 static void i2c_dec_use_client(struct i2c_client
*client
)
788 module_put(client
->driver
->driver
.owner
);
789 module_put(client
->adapter
->owner
);
792 int i2c_use_client(struct i2c_client
*client
)
796 ret
= i2c_inc_use_client(client
);
800 client
->usage_count
++;
804 EXPORT_SYMBOL(i2c_use_client
);
806 int i2c_release_client(struct i2c_client
*client
)
808 if (!client
->usage_count
) {
809 pr_debug("i2c-core: %s used one too many times\n",
814 client
->usage_count
--;
815 i2c_dec_use_client(client
);
819 EXPORT_SYMBOL(i2c_release_client
);
821 void i2c_clients_command(struct i2c_adapter
*adap
, unsigned int cmd
, void *arg
)
823 struct list_head
*item
;
824 struct i2c_client
*client
;
826 mutex_lock(&adap
->clist_lock
);
827 list_for_each(item
,&adap
->clients
) {
828 client
= list_entry(item
, struct i2c_client
, list
);
829 if (!try_module_get(client
->driver
->driver
.owner
))
831 if (NULL
!= client
->driver
->command
) {
832 mutex_unlock(&adap
->clist_lock
);
833 client
->driver
->command(client
,cmd
,arg
);
834 mutex_lock(&adap
->clist_lock
);
836 module_put(client
->driver
->driver
.owner
);
838 mutex_unlock(&adap
->clist_lock
);
840 EXPORT_SYMBOL(i2c_clients_command
);
842 static int __init
i2c_init(void)
846 retval
= bus_register(&i2c_bus_type
);
849 return class_register(&i2c_adapter_class
);
852 static void __exit
i2c_exit(void)
854 class_unregister(&i2c_adapter_class
);
855 bus_unregister(&i2c_bus_type
);
858 subsys_initcall(i2c_init
);
859 module_exit(i2c_exit
);
861 /* ----------------------------------------------------
862 * the functional interface to the i2c busses.
863 * ----------------------------------------------------
866 int i2c_transfer(struct i2c_adapter
* adap
, struct i2c_msg
*msgs
, int num
)
870 if (adap
->algo
->master_xfer
) {
872 for (ret
= 0; ret
< num
; ret
++) {
873 dev_dbg(&adap
->dev
, "master_xfer[%d] %c, addr=0x%02x, "
874 "len=%d%s\n", ret
, (msgs
[ret
].flags
& I2C_M_RD
)
875 ? 'R' : 'W', msgs
[ret
].addr
, msgs
[ret
].len
,
876 (msgs
[ret
].flags
& I2C_M_RECV_LEN
) ? "+" : "");
880 mutex_lock_nested(&adap
->bus_lock
, adap
->level
);
881 ret
= adap
->algo
->master_xfer(adap
,msgs
,num
);
882 mutex_unlock(&adap
->bus_lock
);
886 dev_dbg(&adap
->dev
, "I2C level transfers not supported\n");
890 EXPORT_SYMBOL(i2c_transfer
);
892 int i2c_master_send(struct i2c_client
*client
,const char *buf
,int count
)
895 struct i2c_adapter
*adap
=client
->adapter
;
898 msg
.addr
= client
->addr
;
899 msg
.flags
= client
->flags
& I2C_M_TEN
;
901 msg
.buf
= (char *)buf
;
903 ret
= i2c_transfer(adap
, &msg
, 1);
905 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
906 transmitted, else error code. */
907 return (ret
== 1) ? count
: ret
;
909 EXPORT_SYMBOL(i2c_master_send
);
911 int i2c_master_recv(struct i2c_client
*client
, char *buf
,int count
)
913 struct i2c_adapter
*adap
=client
->adapter
;
917 msg
.addr
= client
->addr
;
918 msg
.flags
= client
->flags
& I2C_M_TEN
;
919 msg
.flags
|= I2C_M_RD
;
923 ret
= i2c_transfer(adap
, &msg
, 1);
925 /* If everything went ok (i.e. 1 msg transmitted), return #bytes
926 transmitted, else error code. */
927 return (ret
== 1) ? count
: ret
;
929 EXPORT_SYMBOL(i2c_master_recv
);
931 int i2c_control(struct i2c_client
*client
,
932 unsigned int cmd
, unsigned long arg
)
935 struct i2c_adapter
*adap
= client
->adapter
;
937 dev_dbg(&client
->adapter
->dev
, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd
, arg
);
946 if (adap
->algo
->algo_control
!=NULL
)
947 ret
= adap
->algo
->algo_control(adap
,cmd
,arg
);
951 EXPORT_SYMBOL(i2c_control
);
953 /* ----------------------------------------------------
954 * the i2c address scanning function
955 * Will not work for 10-bit addresses!
956 * ----------------------------------------------------
958 static int i2c_probe_address(struct i2c_adapter
*adapter
, int addr
, int kind
,
959 int (*found_proc
) (struct i2c_adapter
*, int, int))
963 /* Make sure the address is valid */
964 if (addr
< 0x03 || addr
> 0x77) {
965 dev_warn(&adapter
->dev
, "Invalid probe address 0x%02x\n",
970 /* Skip if already in use */
971 if (i2c_check_addr(adapter
, addr
))
974 /* Make sure there is something at this address, unless forced */
976 if (i2c_smbus_xfer(adapter
, addr
, 0, 0, 0,
977 I2C_SMBUS_QUICK
, NULL
) < 0)
980 /* prevent 24RF08 corruption */
981 if ((addr
& ~0x0f) == 0x50)
982 i2c_smbus_xfer(adapter
, addr
, 0, 0, 0,
983 I2C_SMBUS_QUICK
, NULL
);
986 /* Finally call the custom detection function */
987 err
= found_proc(adapter
, addr
, kind
);
988 /* -ENODEV can be returned if there is a chip at the given address
989 but it isn't supported by this chip driver. We catch it here as
990 this isn't an error. */
995 dev_warn(&adapter
->dev
, "Client creation failed at 0x%x (%d)\n",
1000 int i2c_probe(struct i2c_adapter
*adapter
,
1001 struct i2c_client_address_data
*address_data
,
1002 int (*found_proc
) (struct i2c_adapter
*, int, int))
1005 int adap_id
= i2c_adapter_id(adapter
);
1007 /* Force entries are done first, and are not affected by ignore
1009 if (address_data
->forces
) {
1010 unsigned short **forces
= address_data
->forces
;
1013 for (kind
= 0; forces
[kind
]; kind
++) {
1014 for (i
= 0; forces
[kind
][i
] != I2C_CLIENT_END
;
1016 if (forces
[kind
][i
] == adap_id
1017 || forces
[kind
][i
] == ANY_I2C_BUS
) {
1018 dev_dbg(&adapter
->dev
, "found force "
1019 "parameter for adapter %d, "
1020 "addr 0x%02x, kind %d\n",
1021 adap_id
, forces
[kind
][i
+ 1],
1023 err
= i2c_probe_address(adapter
,
1024 forces
[kind
][i
+ 1],
1033 /* Stop here if we can't use SMBUS_QUICK */
1034 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_QUICK
)) {
1035 if (address_data
->probe
[0] == I2C_CLIENT_END
1036 && address_data
->normal_i2c
[0] == I2C_CLIENT_END
)
1039 dev_warn(&adapter
->dev
, "SMBus Quick command not supported, "
1040 "can't probe for chips\n");
1044 /* Probe entries are done second, and are not affected by ignore
1046 for (i
= 0; address_data
->probe
[i
] != I2C_CLIENT_END
; i
+= 2) {
1047 if (address_data
->probe
[i
] == adap_id
1048 || address_data
->probe
[i
] == ANY_I2C_BUS
) {
1049 dev_dbg(&adapter
->dev
, "found probe parameter for "
1050 "adapter %d, addr 0x%02x\n", adap_id
,
1051 address_data
->probe
[i
+ 1]);
1052 err
= i2c_probe_address(adapter
,
1053 address_data
->probe
[i
+ 1],
1060 /* Normal entries are done last, unless shadowed by an ignore entry */
1061 for (i
= 0; address_data
->normal_i2c
[i
] != I2C_CLIENT_END
; i
+= 1) {
1065 for (j
= 0; address_data
->ignore
[j
] != I2C_CLIENT_END
;
1067 if ((address_data
->ignore
[j
] == adap_id
||
1068 address_data
->ignore
[j
] == ANY_I2C_BUS
)
1069 && address_data
->ignore
[j
+ 1]
1070 == address_data
->normal_i2c
[i
]) {
1071 dev_dbg(&adapter
->dev
, "found ignore "
1072 "parameter for adapter %d, "
1073 "addr 0x%02x\n", adap_id
,
1074 address_data
->ignore
[j
+ 1]);
1082 dev_dbg(&adapter
->dev
, "found normal entry for adapter %d, "
1083 "addr 0x%02x\n", adap_id
,
1084 address_data
->normal_i2c
[i
]);
1085 err
= i2c_probe_address(adapter
, address_data
->normal_i2c
[i
],
1093 EXPORT_SYMBOL(i2c_probe
);
1095 struct i2c_adapter
* i2c_get_adapter(int id
)
1097 struct i2c_adapter
*adapter
;
1099 mutex_lock(&core_lists
);
1100 adapter
= (struct i2c_adapter
*)idr_find(&i2c_adapter_idr
, id
);
1101 if (adapter
&& !try_module_get(adapter
->owner
))
1104 mutex_unlock(&core_lists
);
1107 EXPORT_SYMBOL(i2c_get_adapter
);
1109 void i2c_put_adapter(struct i2c_adapter
*adap
)
1111 module_put(adap
->owner
);
1113 EXPORT_SYMBOL(i2c_put_adapter
);
1115 /* The SMBus parts */
1117 #define POLY (0x1070U << 3)
1123 for(i
= 0; i
< 8; i
++) {
1128 return (u8
)(data
>> 8);
1131 /* Incremental CRC8 over count bytes in the array pointed to by p */
1132 static u8
i2c_smbus_pec(u8 crc
, u8
*p
, size_t count
)
1136 for(i
= 0; i
< count
; i
++)
1137 crc
= crc8((crc
^ p
[i
]) << 8);
1141 /* Assume a 7-bit address, which is reasonable for SMBus */
1142 static u8
i2c_smbus_msg_pec(u8 pec
, struct i2c_msg
*msg
)
1144 /* The address will be sent first */
1145 u8 addr
= (msg
->addr
<< 1) | !!(msg
->flags
& I2C_M_RD
);
1146 pec
= i2c_smbus_pec(pec
, &addr
, 1);
1148 /* The data buffer follows */
1149 return i2c_smbus_pec(pec
, msg
->buf
, msg
->len
);
1152 /* Used for write only transactions */
1153 static inline void i2c_smbus_add_pec(struct i2c_msg
*msg
)
1155 msg
->buf
[msg
->len
] = i2c_smbus_msg_pec(0, msg
);
1159 /* Return <0 on CRC error
1160 If there was a write before this read (most cases) we need to take the
1161 partial CRC from the write part into account.
1162 Note that this function does modify the message (we need to decrease the
1163 message length to hide the CRC byte from the caller). */
1164 static int i2c_smbus_check_pec(u8 cpec
, struct i2c_msg
*msg
)
1166 u8 rpec
= msg
->buf
[--msg
->len
];
1167 cpec
= i2c_smbus_msg_pec(cpec
, msg
);
1170 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1177 s32
i2c_smbus_write_quick(struct i2c_client
*client
, u8 value
)
1179 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1180 value
,0,I2C_SMBUS_QUICK
,NULL
);
1182 EXPORT_SYMBOL(i2c_smbus_write_quick
);
1184 s32
i2c_smbus_read_byte(struct i2c_client
*client
)
1186 union i2c_smbus_data data
;
1187 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1188 I2C_SMBUS_READ
,0,I2C_SMBUS_BYTE
, &data
))
1193 EXPORT_SYMBOL(i2c_smbus_read_byte
);
1195 s32
i2c_smbus_write_byte(struct i2c_client
*client
, u8 value
)
1197 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1198 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
1200 EXPORT_SYMBOL(i2c_smbus_write_byte
);
1202 s32
i2c_smbus_read_byte_data(struct i2c_client
*client
, u8 command
)
1204 union i2c_smbus_data data
;
1205 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1206 I2C_SMBUS_READ
,command
, I2C_SMBUS_BYTE_DATA
,&data
))
1211 EXPORT_SYMBOL(i2c_smbus_read_byte_data
);
1213 s32
i2c_smbus_write_byte_data(struct i2c_client
*client
, u8 command
, u8 value
)
1215 union i2c_smbus_data data
;
1217 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1218 I2C_SMBUS_WRITE
,command
,
1219 I2C_SMBUS_BYTE_DATA
,&data
);
1221 EXPORT_SYMBOL(i2c_smbus_write_byte_data
);
1223 s32
i2c_smbus_read_word_data(struct i2c_client
*client
, u8 command
)
1225 union i2c_smbus_data data
;
1226 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1227 I2C_SMBUS_READ
,command
, I2C_SMBUS_WORD_DATA
, &data
))
1232 EXPORT_SYMBOL(i2c_smbus_read_word_data
);
1234 s32
i2c_smbus_write_word_data(struct i2c_client
*client
, u8 command
, u16 value
)
1236 union i2c_smbus_data data
;
1238 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1239 I2C_SMBUS_WRITE
,command
,
1240 I2C_SMBUS_WORD_DATA
,&data
);
1242 EXPORT_SYMBOL(i2c_smbus_write_word_data
);
1244 s32
i2c_smbus_write_block_data(struct i2c_client
*client
, u8 command
,
1245 u8 length
, const u8
*values
)
1247 union i2c_smbus_data data
;
1249 if (length
> I2C_SMBUS_BLOCK_MAX
)
1250 length
= I2C_SMBUS_BLOCK_MAX
;
1251 data
.block
[0] = length
;
1252 memcpy(&data
.block
[1], values
, length
);
1253 return i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1254 I2C_SMBUS_WRITE
,command
,
1255 I2C_SMBUS_BLOCK_DATA
,&data
);
1257 EXPORT_SYMBOL(i2c_smbus_write_block_data
);
1259 /* Returns the number of read bytes */
1260 s32
i2c_smbus_read_i2c_block_data(struct i2c_client
*client
, u8 command
, u8
*values
)
1262 union i2c_smbus_data data
;
1264 if (i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
1265 I2C_SMBUS_READ
,command
,
1266 I2C_SMBUS_I2C_BLOCK_DATA
,&data
))
1269 memcpy(values
, &data
.block
[1], data
.block
[0]);
1270 return data
.block
[0];
1272 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data
);
1274 s32
i2c_smbus_write_i2c_block_data(struct i2c_client
*client
, u8 command
,
1275 u8 length
, const u8
*values
)
1277 union i2c_smbus_data data
;
1279 if (length
> I2C_SMBUS_BLOCK_MAX
)
1280 length
= I2C_SMBUS_BLOCK_MAX
;
1281 data
.block
[0] = length
;
1282 memcpy(data
.block
+ 1, values
, length
);
1283 return i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
1284 I2C_SMBUS_WRITE
, command
,
1285 I2C_SMBUS_I2C_BLOCK_DATA
, &data
);
1287 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data
);
1289 /* Simulate a SMBus command using the i2c protocol
1290 No checking of parameters is done! */
1291 static s32
i2c_smbus_xfer_emulated(struct i2c_adapter
* adapter
, u16 addr
,
1292 unsigned short flags
,
1293 char read_write
, u8 command
, int size
,
1294 union i2c_smbus_data
* data
)
1296 /* So we need to generate a series of msgs. In the case of writing, we
1297 need to use only one message; when reading, we need two. We initialize
1298 most things with sane defaults, to keep the code below somewhat
1300 unsigned char msgbuf0
[I2C_SMBUS_BLOCK_MAX
+3];
1301 unsigned char msgbuf1
[I2C_SMBUS_BLOCK_MAX
+2];
1302 int num
= read_write
== I2C_SMBUS_READ
?2:1;
1303 struct i2c_msg msg
[2] = { { addr
, flags
, 1, msgbuf0
},
1304 { addr
, flags
| I2C_M_RD
, 0, msgbuf1
}
1309 msgbuf0
[0] = command
;
1311 case I2C_SMBUS_QUICK
:
1313 /* Special case: The read/write field is used as data */
1314 msg
[0].flags
= flags
| (read_write
==I2C_SMBUS_READ
)?I2C_M_RD
:0;
1317 case I2C_SMBUS_BYTE
:
1318 if (read_write
== I2C_SMBUS_READ
) {
1319 /* Special case: only a read! */
1320 msg
[0].flags
= I2C_M_RD
| flags
;
1324 case I2C_SMBUS_BYTE_DATA
:
1325 if (read_write
== I2C_SMBUS_READ
)
1329 msgbuf0
[1] = data
->byte
;
1332 case I2C_SMBUS_WORD_DATA
:
1333 if (read_write
== I2C_SMBUS_READ
)
1337 msgbuf0
[1] = data
->word
& 0xff;
1338 msgbuf0
[2] = data
->word
>> 8;
1341 case I2C_SMBUS_PROC_CALL
:
1342 num
= 2; /* Special case */
1343 read_write
= I2C_SMBUS_READ
;
1346 msgbuf0
[1] = data
->word
& 0xff;
1347 msgbuf0
[2] = data
->word
>> 8;
1349 case I2C_SMBUS_BLOCK_DATA
:
1350 if (read_write
== I2C_SMBUS_READ
) {
1351 msg
[1].flags
|= I2C_M_RECV_LEN
;
1352 msg
[1].len
= 1; /* block length will be added by
1353 the underlying bus driver */
1355 msg
[0].len
= data
->block
[0] + 2;
1356 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 2) {
1357 dev_err(&adapter
->dev
, "smbus_access called with "
1358 "invalid block write size (%d)\n",
1362 for (i
= 1; i
< msg
[0].len
; i
++)
1363 msgbuf0
[i
] = data
->block
[i
-1];
1366 case I2C_SMBUS_BLOCK_PROC_CALL
:
1367 num
= 2; /* Another special case */
1368 read_write
= I2C_SMBUS_READ
;
1369 if (data
->block
[0] > I2C_SMBUS_BLOCK_MAX
) {
1370 dev_err(&adapter
->dev
, "%s called with invalid "
1371 "block proc call size (%d)\n", __FUNCTION__
,
1375 msg
[0].len
= data
->block
[0] + 2;
1376 for (i
= 1; i
< msg
[0].len
; i
++)
1377 msgbuf0
[i
] = data
->block
[i
-1];
1378 msg
[1].flags
|= I2C_M_RECV_LEN
;
1379 msg
[1].len
= 1; /* block length will be added by
1380 the underlying bus driver */
1382 case I2C_SMBUS_I2C_BLOCK_DATA
:
1383 if (read_write
== I2C_SMBUS_READ
) {
1384 msg
[1].len
= I2C_SMBUS_BLOCK_MAX
;
1386 msg
[0].len
= data
->block
[0] + 1;
1387 if (msg
[0].len
> I2C_SMBUS_BLOCK_MAX
+ 1) {
1388 dev_err(&adapter
->dev
, "i2c_smbus_xfer_emulated called with "
1389 "invalid block write size (%d)\n",
1393 for (i
= 1; i
<= data
->block
[0]; i
++)
1394 msgbuf0
[i
] = data
->block
[i
];
1398 dev_err(&adapter
->dev
, "smbus_access called with invalid size (%d)\n",
1403 i
= ((flags
& I2C_CLIENT_PEC
) && size
!= I2C_SMBUS_QUICK
1404 && size
!= I2C_SMBUS_I2C_BLOCK_DATA
);
1406 /* Compute PEC if first message is a write */
1407 if (!(msg
[0].flags
& I2C_M_RD
)) {
1408 if (num
== 1) /* Write only */
1409 i2c_smbus_add_pec(&msg
[0]);
1410 else /* Write followed by read */
1411 partial_pec
= i2c_smbus_msg_pec(0, &msg
[0]);
1413 /* Ask for PEC if last message is a read */
1414 if (msg
[num
-1].flags
& I2C_M_RD
)
1418 if (i2c_transfer(adapter
, msg
, num
) < 0)
1421 /* Check PEC if last message is a read */
1422 if (i
&& (msg
[num
-1].flags
& I2C_M_RD
)) {
1423 if (i2c_smbus_check_pec(partial_pec
, &msg
[num
-1]) < 0)
1427 if (read_write
== I2C_SMBUS_READ
)
1429 case I2C_SMBUS_BYTE
:
1430 data
->byte
= msgbuf0
[0];
1432 case I2C_SMBUS_BYTE_DATA
:
1433 data
->byte
= msgbuf1
[0];
1435 case I2C_SMBUS_WORD_DATA
:
1436 case I2C_SMBUS_PROC_CALL
:
1437 data
->word
= msgbuf1
[0] | (msgbuf1
[1] << 8);
1439 case I2C_SMBUS_I2C_BLOCK_DATA
:
1440 /* fixed at 32 for now */
1441 data
->block
[0] = I2C_SMBUS_BLOCK_MAX
;
1442 for (i
= 0; i
< I2C_SMBUS_BLOCK_MAX
; i
++)
1443 data
->block
[i
+1] = msgbuf1
[i
];
1445 case I2C_SMBUS_BLOCK_DATA
:
1446 case I2C_SMBUS_BLOCK_PROC_CALL
:
1447 for (i
= 0; i
< msgbuf1
[0] + 1; i
++)
1448 data
->block
[i
] = msgbuf1
[i
];
1455 s32
i2c_smbus_xfer(struct i2c_adapter
* adapter
, u16 addr
, unsigned short flags
,
1456 char read_write
, u8 command
, int size
,
1457 union i2c_smbus_data
* data
)
1461 flags
&= I2C_M_TEN
| I2C_CLIENT_PEC
;
1463 if (adapter
->algo
->smbus_xfer
) {
1464 mutex_lock(&adapter
->bus_lock
);
1465 res
= adapter
->algo
->smbus_xfer(adapter
,addr
,flags
,read_write
,
1467 mutex_unlock(&adapter
->bus_lock
);
1469 res
= i2c_smbus_xfer_emulated(adapter
,addr
,flags
,read_write
,
1474 EXPORT_SYMBOL(i2c_smbus_xfer
);
1476 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1477 MODULE_DESCRIPTION("I2C-Bus main module");
1478 MODULE_LICENSE("GPL");