550853f79ae81dbba8399747423d87eb40bdd59d
[linux-2.6.git] / drivers / i2c / i2c-core.c
1 /* i2c-core.c - a device driver for the iic-bus interface                    */
2 /* ------------------------------------------------------------------------- */
3 /*   Copyright (C) 1995-99 Simon G. Vogl
4
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.
9
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.
14
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 /* ------------------------------------------------------------------------- */
19
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> */
24
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/platform_device.h>
33 #include <linux/mutex.h>
34 #include <linux/completion.h>
35 #include <linux/hardirq.h>
36 #include <linux/irqflags.h>
37 #include <asm/uaccess.h>
38
39 #include "i2c-core.h"
40
41
42 static DEFINE_MUTEX(core_lock);
43 static DEFINE_IDR(i2c_adapter_idr);
44
45 #define is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)
46
47 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
48
49 /* ------------------------------------------------------------------------- */
50
51 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
52                                                 const struct i2c_client *client)
53 {
54         while (id->name[0]) {
55                 if (strcmp(client->name, id->name) == 0)
56                         return id;
57                 id++;
58         }
59         return NULL;
60 }
61
62 static int i2c_device_match(struct device *dev, struct device_driver *drv)
63 {
64         struct i2c_client       *client = to_i2c_client(dev);
65         struct i2c_driver       *driver = to_i2c_driver(drv);
66
67         /* make legacy i2c drivers bypass driver model probing entirely;
68          * such drivers scan each i2c adapter/bus themselves.
69          */
70         if (!is_newstyle_driver(driver))
71                 return 0;
72
73         /* match on an id table if there is one */
74         if (driver->id_table)
75                 return i2c_match_id(driver->id_table, client) != NULL;
76
77         return 0;
78 }
79
80 #ifdef  CONFIG_HOTPLUG
81
82 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
83 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
84 {
85         struct i2c_client       *client = to_i2c_client(dev);
86
87         /* by definition, legacy drivers can't hotplug */
88         if (dev->driver)
89                 return 0;
90
91         if (add_uevent_var(env, "MODALIAS=%s%s",
92                            I2C_MODULE_PREFIX, client->name))
93                 return -ENOMEM;
94         dev_dbg(dev, "uevent\n");
95         return 0;
96 }
97
98 #else
99 #define i2c_device_uevent       NULL
100 #endif  /* CONFIG_HOTPLUG */
101
102 static int i2c_device_probe(struct device *dev)
103 {
104         struct i2c_client       *client = to_i2c_client(dev);
105         struct i2c_driver       *driver = to_i2c_driver(dev->driver);
106         int status;
107
108         if (!driver->probe || !driver->id_table)
109                 return -ENODEV;
110         client->driver = driver;
111         dev_dbg(dev, "probe\n");
112
113         status = driver->probe(client, i2c_match_id(driver->id_table, client));
114         if (status)
115                 client->driver = NULL;
116         return status;
117 }
118
119 static int i2c_device_remove(struct device *dev)
120 {
121         struct i2c_client       *client = to_i2c_client(dev);
122         struct i2c_driver       *driver;
123         int                     status;
124
125         if (!dev->driver)
126                 return 0;
127
128         driver = to_i2c_driver(dev->driver);
129         if (driver->remove) {
130                 dev_dbg(dev, "remove\n");
131                 status = driver->remove(client);
132         } else {
133                 dev->driver = NULL;
134                 status = 0;
135         }
136         if (status == 0)
137                 client->driver = NULL;
138         return status;
139 }
140
141 static void i2c_device_shutdown(struct device *dev)
142 {
143         struct i2c_driver *driver;
144
145         if (!dev->driver)
146                 return;
147         driver = to_i2c_driver(dev->driver);
148         if (driver->shutdown)
149                 driver->shutdown(to_i2c_client(dev));
150 }
151
152 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
153 {
154         struct i2c_driver *driver;
155
156         if (!dev->driver)
157                 return 0;
158         driver = to_i2c_driver(dev->driver);
159         if (!driver->suspend)
160                 return 0;
161         return driver->suspend(to_i2c_client(dev), mesg);
162 }
163
164 static int i2c_device_resume(struct device * dev)
165 {
166         struct i2c_driver *driver;
167
168         if (!dev->driver)
169                 return 0;
170         driver = to_i2c_driver(dev->driver);
171         if (!driver->resume)
172                 return 0;
173         return driver->resume(to_i2c_client(dev));
174 }
175
176 static void i2c_client_release(struct device *dev)
177 {
178         struct i2c_client *client = to_i2c_client(dev);
179         complete(&client->released);
180 }
181
182 static void i2c_client_dev_release(struct device *dev)
183 {
184         kfree(to_i2c_client(dev));
185 }
186
187 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
188 {
189         struct i2c_client *client = to_i2c_client(dev);
190         return sprintf(buf, "%s\n", client->name);
191 }
192
193 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
194 {
195         struct i2c_client *client = to_i2c_client(dev);
196         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
197 }
198
199 static struct device_attribute i2c_dev_attrs[] = {
200         __ATTR(name, S_IRUGO, show_client_name, NULL),
201         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
202         __ATTR(modalias, S_IRUGO, show_modalias, NULL),
203         { },
204 };
205
206 struct bus_type i2c_bus_type = {
207         .name           = "i2c",
208         .dev_attrs      = i2c_dev_attrs,
209         .match          = i2c_device_match,
210         .uevent         = i2c_device_uevent,
211         .probe          = i2c_device_probe,
212         .remove         = i2c_device_remove,
213         .shutdown       = i2c_device_shutdown,
214         .suspend        = i2c_device_suspend,
215         .resume         = i2c_device_resume,
216 };
217 EXPORT_SYMBOL_GPL(i2c_bus_type);
218
219
220 /**
221  * i2c_verify_client - return parameter as i2c_client, or NULL
222  * @dev: device, probably from some driver model iterator
223  *
224  * When traversing the driver model tree, perhaps using driver model
225  * iterators like @device_for_each_child(), you can't assume very much
226  * about the nodes you find.  Use this function to avoid oopses caused
227  * by wrongly treating some non-I2C device as an i2c_client.
228  */
229 struct i2c_client *i2c_verify_client(struct device *dev)
230 {
231         return (dev->bus == &i2c_bus_type)
232                         ? to_i2c_client(dev)
233                         : NULL;
234 }
235 EXPORT_SYMBOL(i2c_verify_client);
236
237
238 /**
239  * i2c_new_device - instantiate an i2c device for use with a new style driver
240  * @adap: the adapter managing the device
241  * @info: describes one I2C device; bus_num is ignored
242  * Context: can sleep
243  *
244  * Create a device to work with a new style i2c driver, where binding is
245  * handled through driver model probe()/remove() methods.  This call is not
246  * appropriate for use by mainboad initialization logic, which usually runs
247  * during an arch_initcall() long before any i2c_adapter could exist.
248  *
249  * This returns the new i2c client, which may be saved for later use with
250  * i2c_unregister_device(); or NULL to indicate an error.
251  */
252 struct i2c_client *
253 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
254 {
255         struct i2c_client       *client;
256         int                     status;
257
258         client = kzalloc(sizeof *client, GFP_KERNEL);
259         if (!client)
260                 return NULL;
261
262         client->adapter = adap;
263
264         client->dev.platform_data = info->platform_data;
265         device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
266
267         client->flags = info->flags & ~I2C_CLIENT_WAKE;
268         client->addr = info->addr;
269         client->irq = info->irq;
270
271         strlcpy(client->name, info->type, sizeof(client->name));
272
273         /* a new style driver may be bound to this device when we
274          * return from this function, or any later moment (e.g. maybe
275          * hotplugging will load the driver module).  and the device
276          * refcount model is the standard driver model one.
277          */
278         status = i2c_attach_client(client);
279         if (status < 0) {
280                 kfree(client);
281                 client = NULL;
282         }
283         return client;
284 }
285 EXPORT_SYMBOL_GPL(i2c_new_device);
286
287
288 /**
289  * i2c_unregister_device - reverse effect of i2c_new_device()
290  * @client: value returned from i2c_new_device()
291  * Context: can sleep
292  */
293 void i2c_unregister_device(struct i2c_client *client)
294 {
295         struct i2c_adapter      *adapter = client->adapter;
296         struct i2c_driver       *driver = client->driver;
297
298         if (driver && !is_newstyle_driver(driver)) {
299                 dev_err(&client->dev, "can't unregister devices "
300                         "with legacy drivers\n");
301                 WARN_ON(1);
302                 return;
303         }
304
305         if (adapter->client_unregister) {
306                 if (adapter->client_unregister(client)) {
307                         dev_warn(&client->dev,
308                                  "client_unregister [%s] failed\n",
309                                  client->name);
310                 }
311         }
312
313         mutex_lock(&adapter->clist_lock);
314         list_del(&client->list);
315         mutex_unlock(&adapter->clist_lock);
316
317         device_unregister(&client->dev);
318 }
319 EXPORT_SYMBOL_GPL(i2c_unregister_device);
320
321
322 static const struct i2c_device_id dummy_id[] = {
323         { "dummy", 0 },
324         { },
325 };
326
327 static int dummy_probe(struct i2c_client *client,
328                        const struct i2c_device_id *id)
329 {
330         return 0;
331 }
332
333 static int dummy_remove(struct i2c_client *client)
334 {
335         return 0;
336 }
337
338 static struct i2c_driver dummy_driver = {
339         .driver.name    = "dummy",
340         .probe          = dummy_probe,
341         .remove         = dummy_remove,
342         .id_table       = dummy_id,
343 };
344
345 /**
346  * i2c_new_dummy - return a new i2c device bound to a dummy driver
347  * @adapter: the adapter managing the device
348  * @address: seven bit address to be used
349  * Context: can sleep
350  *
351  * This returns an I2C client bound to the "dummy" driver, intended for use
352  * with devices that consume multiple addresses.  Examples of such chips
353  * include various EEPROMS (like 24c04 and 24c08 models).
354  *
355  * These dummy devices have two main uses.  First, most I2C and SMBus calls
356  * except i2c_transfer() need a client handle; the dummy will be that handle.
357  * And second, this prevents the specified address from being bound to a
358  * different driver.
359  *
360  * This returns the new i2c client, which should be saved for later use with
361  * i2c_unregister_device(); or NULL to indicate an error.
362  */
363 struct i2c_client *
364 i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
365 {
366         struct i2c_board_info info = {
367                 I2C_BOARD_INFO("dummy", address),
368         };
369
370         return i2c_new_device(adapter, &info);
371 }
372 EXPORT_SYMBOL_GPL(i2c_new_dummy);
373
374 /* ------------------------------------------------------------------------- */
375
376 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
377
378 static void i2c_adapter_dev_release(struct device *dev)
379 {
380         struct i2c_adapter *adap = to_i2c_adapter(dev);
381         complete(&adap->dev_released);
382 }
383
384 static ssize_t
385 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
386 {
387         struct i2c_adapter *adap = to_i2c_adapter(dev);
388         return sprintf(buf, "%s\n", adap->name);
389 }
390
391 static struct device_attribute i2c_adapter_attrs[] = {
392         __ATTR(name, S_IRUGO, show_adapter_name, NULL),
393         { },
394 };
395
396 static struct class i2c_adapter_class = {
397         .owner                  = THIS_MODULE,
398         .name                   = "i2c-adapter",
399         .dev_attrs              = i2c_adapter_attrs,
400 };
401
402 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
403 {
404         struct i2c_devinfo      *devinfo;
405
406         mutex_lock(&__i2c_board_lock);
407         list_for_each_entry(devinfo, &__i2c_board_list, list) {
408                 if (devinfo->busnum == adapter->nr
409                                 && !i2c_new_device(adapter,
410                                                 &devinfo->board_info))
411                         printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
412                                 i2c_adapter_id(adapter),
413                                 devinfo->board_info.addr);
414         }
415         mutex_unlock(&__i2c_board_lock);
416 }
417
418 static int i2c_do_add_adapter(struct device_driver *d, void *data)
419 {
420         struct i2c_driver *driver = to_i2c_driver(d);
421         struct i2c_adapter *adap = data;
422
423         /* Detect supported devices on that bus, and instantiate them */
424         i2c_detect(adap, driver);
425
426         /* Let legacy drivers scan this bus for matching devices */
427         if (driver->attach_adapter) {
428                 /* We ignore the return code; if it fails, too bad */
429                 driver->attach_adapter(adap);
430         }
431         return 0;
432 }
433
434 static int i2c_register_adapter(struct i2c_adapter *adap)
435 {
436         int res = 0, dummy;
437
438         mutex_init(&adap->bus_lock);
439         mutex_init(&adap->clist_lock);
440         INIT_LIST_HEAD(&adap->clients);
441
442         mutex_lock(&core_lock);
443
444         /* Add the adapter to the driver core.
445          * If the parent pointer is not set up,
446          * we add this adapter to the host bus.
447          */
448         if (adap->dev.parent == NULL) {
449                 adap->dev.parent = &platform_bus;
450                 pr_debug("I2C adapter driver [%s] forgot to specify "
451                          "physical device\n", adap->name);
452         }
453         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
454         adap->dev.release = &i2c_adapter_dev_release;
455         adap->dev.class = &i2c_adapter_class;
456         res = device_register(&adap->dev);
457         if (res)
458                 goto out_list;
459
460         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
461
462         /* create pre-declared device nodes for new-style drivers */
463         if (adap->nr < __i2c_first_dynamic_bus_num)
464                 i2c_scan_static_board_info(adap);
465
466         /* Notify drivers */
467         dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
468                                  i2c_do_add_adapter);
469
470 out_unlock:
471         mutex_unlock(&core_lock);
472         return res;
473
474 out_list:
475         idr_remove(&i2c_adapter_idr, adap->nr);
476         goto out_unlock;
477 }
478
479 /**
480  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
481  * @adapter: the adapter to add
482  * Context: can sleep
483  *
484  * This routine is used to declare an I2C adapter when its bus number
485  * doesn't matter.  Examples: for I2C adapters dynamically added by
486  * USB links or PCI plugin cards.
487  *
488  * When this returns zero, a new bus number was allocated and stored
489  * in adap->nr, and the specified adapter became available for clients.
490  * Otherwise, a negative errno value is returned.
491  */
492 int i2c_add_adapter(struct i2c_adapter *adapter)
493 {
494         int     id, res = 0;
495
496 retry:
497         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
498                 return -ENOMEM;
499
500         mutex_lock(&core_lock);
501         /* "above" here means "above or equal to", sigh */
502         res = idr_get_new_above(&i2c_adapter_idr, adapter,
503                                 __i2c_first_dynamic_bus_num, &id);
504         mutex_unlock(&core_lock);
505
506         if (res < 0) {
507                 if (res == -EAGAIN)
508                         goto retry;
509                 return res;
510         }
511
512         adapter->nr = id;
513         return i2c_register_adapter(adapter);
514 }
515 EXPORT_SYMBOL(i2c_add_adapter);
516
517 /**
518  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
519  * @adap: the adapter to register (with adap->nr initialized)
520  * Context: can sleep
521  *
522  * This routine is used to declare an I2C adapter when its bus number
523  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
524  * or otherwise built in to the system's mainboard, and where i2c_board_info
525  * is used to properly configure I2C devices.
526  *
527  * If no devices have pre-been declared for this bus, then be sure to
528  * register the adapter before any dynamically allocated ones.  Otherwise
529  * the required bus ID may not be available.
530  *
531  * When this returns zero, the specified adapter became available for
532  * clients using the bus number provided in adap->nr.  Also, the table
533  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
534  * and the appropriate driver model device nodes are created.  Otherwise, a
535  * negative errno value is returned.
536  */
537 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
538 {
539         int     id;
540         int     status;
541
542         if (adap->nr & ~MAX_ID_MASK)
543                 return -EINVAL;
544
545 retry:
546         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
547                 return -ENOMEM;
548
549         mutex_lock(&core_lock);
550         /* "above" here means "above or equal to", sigh;
551          * we need the "equal to" result to force the result
552          */
553         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
554         if (status == 0 && id != adap->nr) {
555                 status = -EBUSY;
556                 idr_remove(&i2c_adapter_idr, id);
557         }
558         mutex_unlock(&core_lock);
559         if (status == -EAGAIN)
560                 goto retry;
561
562         if (status == 0)
563                 status = i2c_register_adapter(adap);
564         return status;
565 }
566 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
567
568 static int i2c_do_del_adapter(struct device_driver *d, void *data)
569 {
570         struct i2c_driver *driver = to_i2c_driver(d);
571         struct i2c_adapter *adapter = data;
572         struct i2c_client *client, *_n;
573         int res;
574
575         /* Remove the devices we created ourselves */
576         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
577                 if (client->adapter == adapter) {
578                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
579                                 client->name, client->addr);
580                         list_del(&client->detected);
581                         i2c_unregister_device(client);
582                 }
583         }
584
585         if (!driver->detach_adapter)
586                 return 0;
587         res = driver->detach_adapter(adapter);
588         if (res)
589                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
590                         "for driver [%s]\n", res, driver->driver.name);
591         return res;
592 }
593
594 /**
595  * i2c_del_adapter - unregister I2C adapter
596  * @adap: the adapter being unregistered
597  * Context: can sleep
598  *
599  * This unregisters an I2C adapter which was previously registered
600  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
601  */
602 int i2c_del_adapter(struct i2c_adapter *adap)
603 {
604         struct i2c_client *client, *_n;
605         int res = 0;
606
607         mutex_lock(&core_lock);
608
609         /* First make sure that this adapter was ever added */
610         if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
611                 pr_debug("i2c-core: attempting to delete unregistered "
612                          "adapter [%s]\n", adap->name);
613                 res = -EINVAL;
614                 goto out_unlock;
615         }
616
617         /* Tell drivers about this removal */
618         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
619                                i2c_do_del_adapter);
620         if (res)
621                 goto out_unlock;
622
623         /* detach any active clients. This must be done first, because
624          * it can fail; in which case we give up. */
625         list_for_each_entry_safe(client, _n, &adap->clients, list) {
626                 struct i2c_driver       *driver;
627
628                 driver = client->driver;
629
630                 /* new style, follow standard driver model */
631                 if (!driver || is_newstyle_driver(driver)) {
632                         i2c_unregister_device(client);
633                         continue;
634                 }
635
636                 /* legacy drivers create and remove clients themselves */
637                 if ((res = driver->detach_client(client))) {
638                         dev_err(&adap->dev, "detach_client failed for client "
639                                 "[%s] at address 0x%02x\n", client->name,
640                                 client->addr);
641                         goto out_unlock;
642                 }
643         }
644
645         /* clean up the sysfs representation */
646         init_completion(&adap->dev_released);
647         device_unregister(&adap->dev);
648
649         /* wait for sysfs to drop all references */
650         wait_for_completion(&adap->dev_released);
651
652         /* free bus id */
653         idr_remove(&i2c_adapter_idr, adap->nr);
654
655         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
656
657         /* Clear the device structure in case this adapter is ever going to be
658            added again */
659         memset(&adap->dev, 0, sizeof(adap->dev));
660
661  out_unlock:
662         mutex_unlock(&core_lock);
663         return res;
664 }
665 EXPORT_SYMBOL(i2c_del_adapter);
666
667
668 /* ------------------------------------------------------------------------- */
669
670 static int __attach_adapter(struct device *dev, void *data)
671 {
672         struct i2c_adapter *adapter = to_i2c_adapter(dev);
673         struct i2c_driver *driver = data;
674
675         i2c_detect(adapter, driver);
676
677         /* Legacy drivers scan i2c busses directly */
678         if (driver->attach_adapter)
679                 driver->attach_adapter(adapter);
680
681         return 0;
682 }
683
684 /*
685  * An i2c_driver is used with one or more i2c_client (device) nodes to access
686  * i2c slave chips, on a bus instance associated with some i2c_adapter.  There
687  * are two models for binding the driver to its device:  "new style" drivers
688  * follow the standard Linux driver model and just respond to probe() calls
689  * issued if the driver core sees they match(); "legacy" drivers create device
690  * nodes themselves.
691  */
692
693 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
694 {
695         int res;
696
697         /* new style driver methods can't mix with legacy ones */
698         if (is_newstyle_driver(driver)) {
699                 if (driver->attach_adapter || driver->detach_adapter
700                                 || driver->detach_client) {
701                         printk(KERN_WARNING
702                                         "i2c-core: driver [%s] is confused\n",
703                                         driver->driver.name);
704                         return -EINVAL;
705                 }
706         }
707
708         /* add the driver to the list of i2c drivers in the driver core */
709         driver->driver.owner = owner;
710         driver->driver.bus = &i2c_bus_type;
711
712         /* for new style drivers, when registration returns the driver core
713          * will have called probe() for all matching-but-unbound devices.
714          */
715         res = driver_register(&driver->driver);
716         if (res)
717                 return res;
718
719         mutex_lock(&core_lock);
720
721         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
722
723         INIT_LIST_HEAD(&driver->clients);
724         /* Walk the adapters that are already present */
725         class_for_each_device(&i2c_adapter_class, NULL, driver,
726                               __attach_adapter);
727
728         mutex_unlock(&core_lock);
729         return 0;
730 }
731 EXPORT_SYMBOL(i2c_register_driver);
732
733 static int __detach_adapter(struct device *dev, void *data)
734 {
735         struct i2c_adapter *adapter = to_i2c_adapter(dev);
736         struct i2c_driver *driver = data;
737         struct i2c_client *client, *_n;
738
739         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
740                 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
741                         client->name, client->addr);
742                 list_del(&client->detected);
743                 i2c_unregister_device(client);
744         }
745
746         if (is_newstyle_driver(driver))
747                 return 0;
748
749         /* Have a look at each adapter, if clients of this driver are still
750          * attached. If so, detach them to be able to kill the driver
751          * afterwards.
752          */
753         if (driver->detach_adapter) {
754                 if (driver->detach_adapter(adapter))
755                         dev_err(&adapter->dev,
756                                 "detach_adapter failed for driver [%s]\n",
757                                 driver->driver.name);
758         } else {
759                 struct i2c_client *client, *_n;
760
761                 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
762                         if (client->driver != driver)
763                                 continue;
764                         dev_dbg(&adapter->dev,
765                                 "detaching client [%s] at 0x%02x\n",
766                                 client->name, client->addr);
767                         if (driver->detach_client(client))
768                                 dev_err(&adapter->dev, "detach_client "
769                                         "failed for client [%s] at 0x%02x\n",
770                                         client->name, client->addr);
771                 }
772         }
773
774         return 0;
775 }
776
777 /**
778  * i2c_del_driver - unregister I2C driver
779  * @driver: the driver being unregistered
780  * Context: can sleep
781  */
782 void i2c_del_driver(struct i2c_driver *driver)
783 {
784         mutex_lock(&core_lock);
785
786         class_for_each_device(&i2c_adapter_class, NULL, driver,
787                               __detach_adapter);
788
789         driver_unregister(&driver->driver);
790         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
791
792         mutex_unlock(&core_lock);
793 }
794 EXPORT_SYMBOL(i2c_del_driver);
795
796 /* ------------------------------------------------------------------------- */
797
798 static int __i2c_check_addr(struct device *dev, void *addrp)
799 {
800         struct i2c_client       *client = i2c_verify_client(dev);
801         int                     addr = *(int *)addrp;
802
803         if (client && client->addr == addr)
804                 return -EBUSY;
805         return 0;
806 }
807
808 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
809 {
810         return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
811 }
812
813 int i2c_attach_client(struct i2c_client *client)
814 {
815         struct i2c_adapter *adapter = client->adapter;
816         int res;
817
818         /* Check for address business */
819         res = i2c_check_addr(adapter, client->addr);
820         if (res)
821                 return res;
822
823         client->dev.parent = &client->adapter->dev;
824         client->dev.bus = &i2c_bus_type;
825
826         if (client->driver)
827                 client->dev.driver = &client->driver->driver;
828
829         if (client->driver && !is_newstyle_driver(client->driver)) {
830                 client->dev.release = i2c_client_release;
831                 client->dev.uevent_suppress = 1;
832         } else
833                 client->dev.release = i2c_client_dev_release;
834
835         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
836                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
837         res = device_register(&client->dev);
838         if (res)
839                 goto out_err;
840
841         mutex_lock(&adapter->clist_lock);
842         list_add_tail(&client->list, &adapter->clients);
843         mutex_unlock(&adapter->clist_lock);
844
845         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
846                 client->name, client->dev.bus_id);
847
848         if (adapter->client_register)  {
849                 if (adapter->client_register(client)) {
850                         dev_dbg(&adapter->dev, "client_register "
851                                 "failed for client [%s] at 0x%02x\n",
852                                 client->name, client->addr);
853                 }
854         }
855
856         return 0;
857
858 out_err:
859         dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
860                 "(%d)\n", client->name, client->addr, res);
861         return res;
862 }
863 EXPORT_SYMBOL(i2c_attach_client);
864
865 int i2c_detach_client(struct i2c_client *client)
866 {
867         struct i2c_adapter *adapter = client->adapter;
868         int res = 0;
869
870         if (adapter->client_unregister)  {
871                 res = adapter->client_unregister(client);
872                 if (res) {
873                         dev_err(&client->dev,
874                                 "client_unregister [%s] failed, "
875                                 "client not detached\n", client->name);
876                         goto out;
877                 }
878         }
879
880         mutex_lock(&adapter->clist_lock);
881         list_del(&client->list);
882         mutex_unlock(&adapter->clist_lock);
883
884         init_completion(&client->released);
885         device_unregister(&client->dev);
886         wait_for_completion(&client->released);
887
888  out:
889         return res;
890 }
891 EXPORT_SYMBOL(i2c_detach_client);
892
893 /**
894  * i2c_use_client - increments the reference count of the i2c client structure
895  * @client: the client being referenced
896  *
897  * Each live reference to a client should be refcounted. The driver model does
898  * that automatically as part of driver binding, so that most drivers don't
899  * need to do this explicitly: they hold a reference until they're unbound
900  * from the device.
901  *
902  * A pointer to the client with the incremented reference counter is returned.
903  */
904 struct i2c_client *i2c_use_client(struct i2c_client *client)
905 {
906         if (client && get_device(&client->dev))
907                 return client;
908         return NULL;
909 }
910 EXPORT_SYMBOL(i2c_use_client);
911
912 /**
913  * i2c_release_client - release a use of the i2c client structure
914  * @client: the client being no longer referenced
915  *
916  * Must be called when a user of a client is finished with it.
917  */
918 void i2c_release_client(struct i2c_client *client)
919 {
920         if (client)
921                 put_device(&client->dev);
922 }
923 EXPORT_SYMBOL(i2c_release_client);
924
925 struct i2c_cmd_arg {
926         unsigned        cmd;
927         void            *arg;
928 };
929
930 static int i2c_cmd(struct device *dev, void *_arg)
931 {
932         struct i2c_client       *client = i2c_verify_client(dev);
933         struct i2c_cmd_arg      *arg = _arg;
934
935         if (client && client->driver && client->driver->command)
936                 client->driver->command(client, arg->cmd, arg->arg);
937         return 0;
938 }
939
940 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
941 {
942         struct i2c_cmd_arg      cmd_arg;
943
944         cmd_arg.cmd = cmd;
945         cmd_arg.arg = arg;
946         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
947 }
948 EXPORT_SYMBOL(i2c_clients_command);
949
950 static int __init i2c_init(void)
951 {
952         int retval;
953
954         retval = bus_register(&i2c_bus_type);
955         if (retval)
956                 return retval;
957         retval = class_register(&i2c_adapter_class);
958         if (retval)
959                 goto bus_err;
960         retval = i2c_add_driver(&dummy_driver);
961         if (retval)
962                 goto class_err;
963         return 0;
964
965 class_err:
966         class_unregister(&i2c_adapter_class);
967 bus_err:
968         bus_unregister(&i2c_bus_type);
969         return retval;
970 }
971
972 static void __exit i2c_exit(void)
973 {
974         i2c_del_driver(&dummy_driver);
975         class_unregister(&i2c_adapter_class);
976         bus_unregister(&i2c_bus_type);
977 }
978
979 subsys_initcall(i2c_init);
980 module_exit(i2c_exit);
981
982 /* ----------------------------------------------------
983  * the functional interface to the i2c busses.
984  * ----------------------------------------------------
985  */
986
987 /**
988  * i2c_transfer - execute a single or combined I2C message
989  * @adap: Handle to I2C bus
990  * @msgs: One or more messages to execute before STOP is issued to
991  *      terminate the operation; each message begins with a START.
992  * @num: Number of messages to be executed.
993  *
994  * Returns negative errno, else the number of messages executed.
995  *
996  * Note that there is no requirement that each message be sent to
997  * the same slave address, although that is the most common model.
998  */
999 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
1000 {
1001         int ret;
1002
1003         /* REVISIT the fault reporting model here is weak:
1004          *
1005          *  - When we get an error after receiving N bytes from a slave,
1006          *    there is no way to report "N".
1007          *
1008          *  - When we get a NAK after transmitting N bytes to a slave,
1009          *    there is no way to report "N" ... or to let the master
1010          *    continue executing the rest of this combined message, if
1011          *    that's the appropriate response.
1012          *
1013          *  - When for example "num" is two and we successfully complete
1014          *    the first message but get an error part way through the
1015          *    second, it's unclear whether that should be reported as
1016          *    one (discarding status on the second message) or errno
1017          *    (discarding status on the first one).
1018          */
1019
1020         if (adap->algo->master_xfer) {
1021 #ifdef DEBUG
1022                 for (ret = 0; ret < num; ret++) {
1023                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1024                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1025                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1026                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1027                 }
1028 #endif
1029
1030                 if (in_atomic() || irqs_disabled()) {
1031                         ret = mutex_trylock(&adap->bus_lock);
1032                         if (!ret)
1033                                 /* I2C activity is ongoing. */
1034                                 return -EAGAIN;
1035                 } else {
1036                         mutex_lock_nested(&adap->bus_lock, adap->level);
1037                 }
1038
1039                 ret = adap->algo->master_xfer(adap,msgs,num);
1040                 mutex_unlock(&adap->bus_lock);
1041
1042                 return ret;
1043         } else {
1044                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1045                 return -EOPNOTSUPP;
1046         }
1047 }
1048 EXPORT_SYMBOL(i2c_transfer);
1049
1050 /**
1051  * i2c_master_send - issue a single I2C message in master transmit mode
1052  * @client: Handle to slave device
1053  * @buf: Data that will be written to the slave
1054  * @count: How many bytes to write
1055  *
1056  * Returns negative errno, or else the number of bytes written.
1057  */
1058 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1059 {
1060         int ret;
1061         struct i2c_adapter *adap=client->adapter;
1062         struct i2c_msg msg;
1063
1064         msg.addr = client->addr;
1065         msg.flags = client->flags & I2C_M_TEN;
1066         msg.len = count;
1067         msg.buf = (char *)buf;
1068
1069         ret = i2c_transfer(adap, &msg, 1);
1070
1071         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1072            transmitted, else error code. */
1073         return (ret == 1) ? count : ret;
1074 }
1075 EXPORT_SYMBOL(i2c_master_send);
1076
1077 /**
1078  * i2c_master_recv - issue a single I2C message in master receive mode
1079  * @client: Handle to slave device
1080  * @buf: Where to store data read from slave
1081  * @count: How many bytes to read
1082  *
1083  * Returns negative errno, or else the number of bytes read.
1084  */
1085 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1086 {
1087         struct i2c_adapter *adap=client->adapter;
1088         struct i2c_msg msg;
1089         int ret;
1090
1091         msg.addr = client->addr;
1092         msg.flags = client->flags & I2C_M_TEN;
1093         msg.flags |= I2C_M_RD;
1094         msg.len = count;
1095         msg.buf = buf;
1096
1097         ret = i2c_transfer(adap, &msg, 1);
1098
1099         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1100            transmitted, else error code. */
1101         return (ret == 1) ? count : ret;
1102 }
1103 EXPORT_SYMBOL(i2c_master_recv);
1104
1105 /* ----------------------------------------------------
1106  * the i2c address scanning function
1107  * Will not work for 10-bit addresses!
1108  * ----------------------------------------------------
1109  */
1110 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1111                              int (*found_proc) (struct i2c_adapter *, int, int))
1112 {
1113         int err;
1114
1115         /* Make sure the address is valid */
1116         if (addr < 0x03 || addr > 0x77) {
1117                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1118                          addr);
1119                 return -EINVAL;
1120         }
1121
1122         /* Skip if already in use */
1123         if (i2c_check_addr(adapter, addr))
1124                 return 0;
1125
1126         /* Make sure there is something at this address, unless forced */
1127         if (kind < 0) {
1128                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1129                                    I2C_SMBUS_QUICK, NULL) < 0)
1130                         return 0;
1131
1132                 /* prevent 24RF08 corruption */
1133                 if ((addr & ~0x0f) == 0x50)
1134                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1135                                        I2C_SMBUS_QUICK, NULL);
1136         }
1137
1138         /* Finally call the custom detection function */
1139         err = found_proc(adapter, addr, kind);
1140         /* -ENODEV can be returned if there is a chip at the given address
1141            but it isn't supported by this chip driver. We catch it here as
1142            this isn't an error. */
1143         if (err == -ENODEV)
1144                 err = 0;
1145
1146         if (err)
1147                 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1148                          addr, err);
1149         return err;
1150 }
1151
1152 int i2c_probe(struct i2c_adapter *adapter,
1153               const struct i2c_client_address_data *address_data,
1154               int (*found_proc) (struct i2c_adapter *, int, int))
1155 {
1156         int i, err;
1157         int adap_id = i2c_adapter_id(adapter);
1158
1159         /* Force entries are done first, and are not affected by ignore
1160            entries */
1161         if (address_data->forces) {
1162                 const unsigned short * const *forces = address_data->forces;
1163                 int kind;
1164
1165                 for (kind = 0; forces[kind]; kind++) {
1166                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1167                              i += 2) {
1168                                 if (forces[kind][i] == adap_id
1169                                  || forces[kind][i] == ANY_I2C_BUS) {
1170                                         dev_dbg(&adapter->dev, "found force "
1171                                                 "parameter for adapter %d, "
1172                                                 "addr 0x%02x, kind %d\n",
1173                                                 adap_id, forces[kind][i + 1],
1174                                                 kind);
1175                                         err = i2c_probe_address(adapter,
1176                                                 forces[kind][i + 1],
1177                                                 kind, found_proc);
1178                                         if (err)
1179                                                 return err;
1180                                 }
1181                         }
1182                 }
1183         }
1184
1185         /* Stop here if we can't use SMBUS_QUICK */
1186         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1187                 if (address_data->probe[0] == I2C_CLIENT_END
1188                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1189                         return 0;
1190
1191                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1192                          "can't probe for chips\n");
1193                 return -EOPNOTSUPP;
1194         }
1195
1196         /* Probe entries are done second, and are not affected by ignore
1197            entries either */
1198         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1199                 if (address_data->probe[i] == adap_id
1200                  || address_data->probe[i] == ANY_I2C_BUS) {
1201                         dev_dbg(&adapter->dev, "found probe parameter for "
1202                                 "adapter %d, addr 0x%02x\n", adap_id,
1203                                 address_data->probe[i + 1]);
1204                         err = i2c_probe_address(adapter,
1205                                                 address_data->probe[i + 1],
1206                                                 -1, found_proc);
1207                         if (err)
1208                                 return err;
1209                 }
1210         }
1211
1212         /* Normal entries are done last, unless shadowed by an ignore entry */
1213         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1214                 int j, ignore;
1215
1216                 ignore = 0;
1217                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1218                      j += 2) {
1219                         if ((address_data->ignore[j] == adap_id ||
1220                              address_data->ignore[j] == ANY_I2C_BUS)
1221                          && address_data->ignore[j + 1]
1222                             == address_data->normal_i2c[i]) {
1223                                 dev_dbg(&adapter->dev, "found ignore "
1224                                         "parameter for adapter %d, "
1225                                         "addr 0x%02x\n", adap_id,
1226                                         address_data->ignore[j + 1]);
1227                                 ignore = 1;
1228                                 break;
1229                         }
1230                 }
1231                 if (ignore)
1232                         continue;
1233
1234                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1235                         "addr 0x%02x\n", adap_id,
1236                         address_data->normal_i2c[i]);
1237                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1238                                         -1, found_proc);
1239                 if (err)
1240                         return err;
1241         }
1242
1243         return 0;
1244 }
1245 EXPORT_SYMBOL(i2c_probe);
1246
1247 /* Separate detection function for new-style drivers */
1248 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1249                               struct i2c_driver *driver)
1250 {
1251         struct i2c_board_info info;
1252         struct i2c_adapter *adapter = temp_client->adapter;
1253         int addr = temp_client->addr;
1254         int err;
1255
1256         /* Make sure the address is valid */
1257         if (addr < 0x03 || addr > 0x77) {
1258                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1259                          addr);
1260                 return -EINVAL;
1261         }
1262
1263         /* Skip if already in use */
1264         if (i2c_check_addr(adapter, addr))
1265                 return 0;
1266
1267         /* Make sure there is something at this address, unless forced */
1268         if (kind < 0) {
1269                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1270                                    I2C_SMBUS_QUICK, NULL) < 0)
1271                         return 0;
1272
1273                 /* prevent 24RF08 corruption */
1274                 if ((addr & ~0x0f) == 0x50)
1275                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1276                                        I2C_SMBUS_QUICK, NULL);
1277         }
1278
1279         /* Finally call the custom detection function */
1280         memset(&info, 0, sizeof(struct i2c_board_info));
1281         info.addr = addr;
1282         err = driver->detect(temp_client, kind, &info);
1283         if (err) {
1284                 /* -ENODEV is returned if the detection fails. We catch it
1285                    here as this isn't an error. */
1286                 return err == -ENODEV ? 0 : err;
1287         }
1288
1289         /* Consistency check */
1290         if (info.type[0] == '\0') {
1291                 dev_err(&adapter->dev, "%s detection function provided "
1292                         "no name for 0x%x\n", driver->driver.name,
1293                         addr);
1294         } else {
1295                 struct i2c_client *client;
1296
1297                 /* Detection succeeded, instantiate the device */
1298                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1299                         info.type, info.addr);
1300                 client = i2c_new_device(adapter, &info);
1301                 if (client)
1302                         list_add_tail(&client->detected, &driver->clients);
1303                 else
1304                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1305                                 info.type, info.addr);
1306         }
1307         return 0;
1308 }
1309
1310 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1311 {
1312         const struct i2c_client_address_data *address_data;
1313         struct i2c_client *temp_client;
1314         int i, err = 0;
1315         int adap_id = i2c_adapter_id(adapter);
1316
1317         address_data = driver->address_data;
1318         if (!driver->detect || !address_data)
1319                 return 0;
1320
1321         /* Set up a temporary client to help detect callback */
1322         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1323         if (!temp_client)
1324                 return -ENOMEM;
1325         temp_client->adapter = adapter;
1326
1327         /* Force entries are done first, and are not affected by ignore
1328            entries */
1329         if (address_data->forces) {
1330                 const unsigned short * const *forces = address_data->forces;
1331                 int kind;
1332
1333                 for (kind = 0; forces[kind]; kind++) {
1334                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1335                              i += 2) {
1336                                 if (forces[kind][i] == adap_id
1337                                  || forces[kind][i] == ANY_I2C_BUS) {
1338                                         dev_dbg(&adapter->dev, "found force "
1339                                                 "parameter for adapter %d, "
1340                                                 "addr 0x%02x, kind %d\n",
1341                                                 adap_id, forces[kind][i + 1],
1342                                                 kind);
1343                                         temp_client->addr = forces[kind][i + 1];
1344                                         err = i2c_detect_address(temp_client,
1345                                                 kind, driver);
1346                                         if (err)
1347                                                 goto exit_free;
1348                                 }
1349                         }
1350                 }
1351         }
1352
1353         /* Stop here if we can't use SMBUS_QUICK */
1354         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1355                 if (address_data->probe[0] == I2C_CLIENT_END
1356                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1357                         goto exit_free;
1358
1359                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1360                          "can't probe for chips\n");
1361                 err = -EOPNOTSUPP;
1362                 goto exit_free;
1363         }
1364
1365         /* Stop here if the classes do not match */
1366         if (!(adapter->class & driver->class))
1367                 goto exit_free;
1368
1369         /* Probe entries are done second, and are not affected by ignore
1370            entries either */
1371         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1372                 if (address_data->probe[i] == adap_id
1373                  || address_data->probe[i] == ANY_I2C_BUS) {
1374                         dev_dbg(&adapter->dev, "found probe parameter for "
1375                                 "adapter %d, addr 0x%02x\n", adap_id,
1376                                 address_data->probe[i + 1]);
1377                         temp_client->addr = address_data->probe[i + 1];
1378                         err = i2c_detect_address(temp_client, -1, driver);
1379                         if (err)
1380                                 goto exit_free;
1381                 }
1382         }
1383
1384         /* Normal entries are done last, unless shadowed by an ignore entry */
1385         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1386                 int j, ignore;
1387
1388                 ignore = 0;
1389                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1390                      j += 2) {
1391                         if ((address_data->ignore[j] == adap_id ||
1392                              address_data->ignore[j] == ANY_I2C_BUS)
1393                          && address_data->ignore[j + 1]
1394                             == address_data->normal_i2c[i]) {
1395                                 dev_dbg(&adapter->dev, "found ignore "
1396                                         "parameter for adapter %d, "
1397                                         "addr 0x%02x\n", adap_id,
1398                                         address_data->ignore[j + 1]);
1399                                 ignore = 1;
1400                                 break;
1401                         }
1402                 }
1403                 if (ignore)
1404                         continue;
1405
1406                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1407                         "addr 0x%02x\n", adap_id,
1408                         address_data->normal_i2c[i]);
1409                 temp_client->addr = address_data->normal_i2c[i];
1410                 err = i2c_detect_address(temp_client, -1, driver);
1411                 if (err)
1412                         goto exit_free;
1413         }
1414
1415  exit_free:
1416         kfree(temp_client);
1417         return err;
1418 }
1419
1420 struct i2c_client *
1421 i2c_new_probed_device(struct i2c_adapter *adap,
1422                       struct i2c_board_info *info,
1423                       unsigned short const *addr_list)
1424 {
1425         int i;
1426
1427         /* Stop here if the bus doesn't support probing */
1428         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1429                 dev_err(&adap->dev, "Probing not supported\n");
1430                 return NULL;
1431         }
1432
1433         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1434                 /* Check address validity */
1435                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1436                         dev_warn(&adap->dev, "Invalid 7-bit address "
1437                                  "0x%02x\n", addr_list[i]);
1438                         continue;
1439                 }
1440
1441                 /* Check address availability */
1442                 if (i2c_check_addr(adap, addr_list[i])) {
1443                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1444                                 "use, not probing\n", addr_list[i]);
1445                         continue;
1446                 }
1447
1448                 /* Test address responsiveness
1449                    The default probe method is a quick write, but it is known
1450                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1451                    and could also irreversibly write-protect some EEPROMs, so
1452                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1453                    read instead. Also, some bus drivers don't implement
1454                    quick write, so we fallback to a byte read it that case
1455                    too. */
1456                 if ((addr_list[i] & ~0x07) == 0x30
1457                  || (addr_list[i] & ~0x0f) == 0x50
1458                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1459                         union i2c_smbus_data data;
1460
1461                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1462                                            I2C_SMBUS_READ, 0,
1463                                            I2C_SMBUS_BYTE, &data) >= 0)
1464                                 break;
1465                 } else {
1466                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1467                                            I2C_SMBUS_WRITE, 0,
1468                                            I2C_SMBUS_QUICK, NULL) >= 0)
1469                                 break;
1470                 }
1471         }
1472
1473         if (addr_list[i] == I2C_CLIENT_END) {
1474                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1475                 return NULL;
1476         }
1477
1478         info->addr = addr_list[i];
1479         return i2c_new_device(adap, info);
1480 }
1481 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1482
1483 struct i2c_adapter* i2c_get_adapter(int id)
1484 {
1485         struct i2c_adapter *adapter;
1486
1487         mutex_lock(&core_lock);
1488         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1489         if (adapter && !try_module_get(adapter->owner))
1490                 adapter = NULL;
1491
1492         mutex_unlock(&core_lock);
1493         return adapter;
1494 }
1495 EXPORT_SYMBOL(i2c_get_adapter);
1496
1497 void i2c_put_adapter(struct i2c_adapter *adap)
1498 {
1499         module_put(adap->owner);
1500 }
1501 EXPORT_SYMBOL(i2c_put_adapter);
1502
1503 /* The SMBus parts */
1504
1505 #define POLY    (0x1070U << 3)
1506 static u8
1507 crc8(u16 data)
1508 {
1509         int i;
1510
1511         for(i = 0; i < 8; i++) {
1512                 if (data & 0x8000)
1513                         data = data ^ POLY;
1514                 data = data << 1;
1515         }
1516         return (u8)(data >> 8);
1517 }
1518
1519 /* Incremental CRC8 over count bytes in the array pointed to by p */
1520 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1521 {
1522         int i;
1523
1524         for(i = 0; i < count; i++)
1525                 crc = crc8((crc ^ p[i]) << 8);
1526         return crc;
1527 }
1528
1529 /* Assume a 7-bit address, which is reasonable for SMBus */
1530 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1531 {
1532         /* The address will be sent first */
1533         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1534         pec = i2c_smbus_pec(pec, &addr, 1);
1535
1536         /* The data buffer follows */
1537         return i2c_smbus_pec(pec, msg->buf, msg->len);
1538 }
1539
1540 /* Used for write only transactions */
1541 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1542 {
1543         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1544         msg->len++;
1545 }
1546
1547 /* Return <0 on CRC error
1548    If there was a write before this read (most cases) we need to take the
1549    partial CRC from the write part into account.
1550    Note that this function does modify the message (we need to decrease the
1551    message length to hide the CRC byte from the caller). */
1552 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1553 {
1554         u8 rpec = msg->buf[--msg->len];
1555         cpec = i2c_smbus_msg_pec(cpec, msg);
1556
1557         if (rpec != cpec) {
1558                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1559                         rpec, cpec);
1560                 return -EBADMSG;
1561         }
1562         return 0;
1563 }
1564
1565 /**
1566  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1567  * @client: Handle to slave device
1568  *
1569  * This executes the SMBus "receive byte" protocol, returning negative errno
1570  * else the byte received from the device.
1571  */
1572 s32 i2c_smbus_read_byte(struct i2c_client *client)
1573 {
1574         union i2c_smbus_data data;
1575         int status;
1576
1577         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1578                                 I2C_SMBUS_READ, 0,
1579                                 I2C_SMBUS_BYTE, &data);
1580         return (status < 0) ? status : data.byte;
1581 }
1582 EXPORT_SYMBOL(i2c_smbus_read_byte);
1583
1584 /**
1585  * i2c_smbus_write_byte - SMBus "send byte" protocol
1586  * @client: Handle to slave device
1587  * @value: Byte to be sent
1588  *
1589  * This executes the SMBus "send byte" protocol, returning negative errno
1590  * else zero on success.
1591  */
1592 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1593 {
1594         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1595                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1596 }
1597 EXPORT_SYMBOL(i2c_smbus_write_byte);
1598
1599 /**
1600  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1601  * @client: Handle to slave device
1602  * @command: Byte interpreted by slave
1603  *
1604  * This executes the SMBus "read byte" protocol, returning negative errno
1605  * else a data byte received from the device.
1606  */
1607 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1608 {
1609         union i2c_smbus_data data;
1610         int status;
1611
1612         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1613                                 I2C_SMBUS_READ, command,
1614                                 I2C_SMBUS_BYTE_DATA, &data);
1615         return (status < 0) ? status : data.byte;
1616 }
1617 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1618
1619 /**
1620  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1621  * @client: Handle to slave device
1622  * @command: Byte interpreted by slave
1623  * @value: Byte being written
1624  *
1625  * This executes the SMBus "write byte" protocol, returning negative errno
1626  * else zero on success.
1627  */
1628 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1629 {
1630         union i2c_smbus_data data;
1631         data.byte = value;
1632         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1633                               I2C_SMBUS_WRITE,command,
1634                               I2C_SMBUS_BYTE_DATA,&data);
1635 }
1636 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1637
1638 /**
1639  * i2c_smbus_read_word_data - SMBus "read word" protocol
1640  * @client: Handle to slave device
1641  * @command: Byte interpreted by slave
1642  *
1643  * This executes the SMBus "read word" protocol, returning negative errno
1644  * else a 16-bit unsigned "word" received from the device.
1645  */
1646 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1647 {
1648         union i2c_smbus_data data;
1649         int status;
1650
1651         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1652                                 I2C_SMBUS_READ, command,
1653                                 I2C_SMBUS_WORD_DATA, &data);
1654         return (status < 0) ? status : data.word;
1655 }
1656 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1657
1658 /**
1659  * i2c_smbus_write_word_data - SMBus "write word" protocol
1660  * @client: Handle to slave device
1661  * @command: Byte interpreted by slave
1662  * @value: 16-bit "word" being written
1663  *
1664  * This executes the SMBus "write word" protocol, returning negative errno
1665  * else zero on success.
1666  */
1667 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1668 {
1669         union i2c_smbus_data data;
1670         data.word = value;
1671         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1672                               I2C_SMBUS_WRITE,command,
1673                               I2C_SMBUS_WORD_DATA,&data);
1674 }
1675 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1676
1677 /**
1678  * i2c_smbus_read_block_data - SMBus "block read" protocol
1679  * @client: Handle to slave device
1680  * @command: Byte interpreted by slave
1681  * @values: Byte array into which data will be read; big enough to hold
1682  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1683  *
1684  * This executes the SMBus "block read" protocol, returning negative errno
1685  * else the number of data bytes in the slave's response.
1686  *
1687  * Note that using this function requires that the client's adapter support
1688  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1689  * support this; its emulation through I2C messaging relies on a specific
1690  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1691  */
1692 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1693                               u8 *values)
1694 {
1695         union i2c_smbus_data data;
1696         int status;
1697
1698         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1699                                 I2C_SMBUS_READ, command,
1700                                 I2C_SMBUS_BLOCK_DATA, &data);
1701         if (status)
1702                 return status;
1703
1704         memcpy(values, &data.block[1], data.block[0]);
1705         return data.block[0];
1706 }
1707 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1708
1709 /**
1710  * i2c_smbus_write_block_data - SMBus "block write" protocol
1711  * @client: Handle to slave device
1712  * @command: Byte interpreted by slave
1713  * @length: Size of data block; SMBus allows at most 32 bytes
1714  * @values: Byte array which will be written.
1715  *
1716  * This executes the SMBus "block write" protocol, returning negative errno
1717  * else zero on success.
1718  */
1719 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1720                                u8 length, const u8 *values)
1721 {
1722         union i2c_smbus_data data;
1723
1724         if (length > I2C_SMBUS_BLOCK_MAX)
1725                 length = I2C_SMBUS_BLOCK_MAX;
1726         data.block[0] = length;
1727         memcpy(&data.block[1], values, length);
1728         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1729                               I2C_SMBUS_WRITE,command,
1730                               I2C_SMBUS_BLOCK_DATA,&data);
1731 }
1732 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1733
1734 /* Returns the number of read bytes */
1735 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1736                                   u8 length, u8 *values)
1737 {
1738         union i2c_smbus_data data;
1739         int status;
1740
1741         if (length > I2C_SMBUS_BLOCK_MAX)
1742                 length = I2C_SMBUS_BLOCK_MAX;
1743         data.block[0] = length;
1744         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1745                                 I2C_SMBUS_READ, command,
1746                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1747         if (status < 0)
1748                 return status;
1749
1750         memcpy(values, &data.block[1], data.block[0]);
1751         return data.block[0];
1752 }
1753 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1754
1755 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1756                                    u8 length, const u8 *values)
1757 {
1758         union i2c_smbus_data data;
1759
1760         if (length > I2C_SMBUS_BLOCK_MAX)
1761                 length = I2C_SMBUS_BLOCK_MAX;
1762         data.block[0] = length;
1763         memcpy(data.block + 1, values, length);
1764         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1765                               I2C_SMBUS_WRITE, command,
1766                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1767 }
1768 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1769
1770 /* Simulate a SMBus command using the i2c protocol
1771    No checking of parameters is done!  */
1772 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1773                                    unsigned short flags,
1774                                    char read_write, u8 command, int size,
1775                                    union i2c_smbus_data * data)
1776 {
1777         /* So we need to generate a series of msgs. In the case of writing, we
1778           need to use only one message; when reading, we need two. We initialize
1779           most things with sane defaults, to keep the code below somewhat
1780           simpler. */
1781         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1782         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1783         int num = read_write == I2C_SMBUS_READ?2:1;
1784         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1785                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1786                                 };
1787         int i;
1788         u8 partial_pec = 0;
1789         int status;
1790
1791         msgbuf0[0] = command;
1792         switch(size) {
1793         case I2C_SMBUS_QUICK:
1794                 msg[0].len = 0;
1795                 /* Special case: The read/write field is used as data */
1796                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1797                 num = 1;
1798                 break;
1799         case I2C_SMBUS_BYTE:
1800                 if (read_write == I2C_SMBUS_READ) {
1801                         /* Special case: only a read! */
1802                         msg[0].flags = I2C_M_RD | flags;
1803                         num = 1;
1804                 }
1805                 break;
1806         case I2C_SMBUS_BYTE_DATA:
1807                 if (read_write == I2C_SMBUS_READ)
1808                         msg[1].len = 1;
1809                 else {
1810                         msg[0].len = 2;
1811                         msgbuf0[1] = data->byte;
1812                 }
1813                 break;
1814         case I2C_SMBUS_WORD_DATA:
1815                 if (read_write == I2C_SMBUS_READ)
1816                         msg[1].len = 2;
1817                 else {
1818                         msg[0].len=3;
1819                         msgbuf0[1] = data->word & 0xff;
1820                         msgbuf0[2] = data->word >> 8;
1821                 }
1822                 break;
1823         case I2C_SMBUS_PROC_CALL:
1824                 num = 2; /* Special case */
1825                 read_write = I2C_SMBUS_READ;
1826                 msg[0].len = 3;
1827                 msg[1].len = 2;
1828                 msgbuf0[1] = data->word & 0xff;
1829                 msgbuf0[2] = data->word >> 8;
1830                 break;
1831         case I2C_SMBUS_BLOCK_DATA:
1832                 if (read_write == I2C_SMBUS_READ) {
1833                         msg[1].flags |= I2C_M_RECV_LEN;
1834                         msg[1].len = 1; /* block length will be added by
1835                                            the underlying bus driver */
1836                 } else {
1837                         msg[0].len = data->block[0] + 2;
1838                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1839                                 dev_err(&adapter->dev,
1840                                         "Invalid block write size %d\n",
1841                                         data->block[0]);
1842                                 return -EINVAL;
1843                         }
1844                         for (i = 1; i < msg[0].len; i++)
1845                                 msgbuf0[i] = data->block[i-1];
1846                 }
1847                 break;
1848         case I2C_SMBUS_BLOCK_PROC_CALL:
1849                 num = 2; /* Another special case */
1850                 read_write = I2C_SMBUS_READ;
1851                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1852                         dev_err(&adapter->dev,
1853                                 "Invalid block write size %d\n",
1854                                 data->block[0]);
1855                         return -EINVAL;
1856                 }
1857                 msg[0].len = data->block[0] + 2;
1858                 for (i = 1; i < msg[0].len; i++)
1859                         msgbuf0[i] = data->block[i-1];
1860                 msg[1].flags |= I2C_M_RECV_LEN;
1861                 msg[1].len = 1; /* block length will be added by
1862                                    the underlying bus driver */
1863                 break;
1864         case I2C_SMBUS_I2C_BLOCK_DATA:
1865                 if (read_write == I2C_SMBUS_READ) {
1866                         msg[1].len = data->block[0];
1867                 } else {
1868                         msg[0].len = data->block[0] + 1;
1869                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1870                                 dev_err(&adapter->dev,
1871                                         "Invalid block write size %d\n",
1872                                         data->block[0]);
1873                                 return -EINVAL;
1874                         }
1875                         for (i = 1; i <= data->block[0]; i++)
1876                                 msgbuf0[i] = data->block[i];
1877                 }
1878                 break;
1879         default:
1880                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1881                 return -EOPNOTSUPP;
1882         }
1883
1884         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1885                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1886         if (i) {
1887                 /* Compute PEC if first message is a write */
1888                 if (!(msg[0].flags & I2C_M_RD)) {
1889                         if (num == 1) /* Write only */
1890                                 i2c_smbus_add_pec(&msg[0]);
1891                         else /* Write followed by read */
1892                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1893                 }
1894                 /* Ask for PEC if last message is a read */
1895                 if (msg[num-1].flags & I2C_M_RD)
1896                         msg[num-1].len++;
1897         }
1898
1899         status = i2c_transfer(adapter, msg, num);
1900         if (status < 0)
1901                 return status;
1902
1903         /* Check PEC if last message is a read */
1904         if (i && (msg[num-1].flags & I2C_M_RD)) {
1905                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1906                 if (status < 0)
1907                         return status;
1908         }
1909
1910         if (read_write == I2C_SMBUS_READ)
1911                 switch(size) {
1912                         case I2C_SMBUS_BYTE:
1913                                 data->byte = msgbuf0[0];
1914                                 break;
1915                         case I2C_SMBUS_BYTE_DATA:
1916                                 data->byte = msgbuf1[0];
1917                                 break;
1918                         case I2C_SMBUS_WORD_DATA:
1919                         case I2C_SMBUS_PROC_CALL:
1920                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1921                                 break;
1922                         case I2C_SMBUS_I2C_BLOCK_DATA:
1923                                 for (i = 0; i < data->block[0]; i++)
1924                                         data->block[i+1] = msgbuf1[i];
1925                                 break;
1926                         case I2C_SMBUS_BLOCK_DATA:
1927                         case I2C_SMBUS_BLOCK_PROC_CALL:
1928                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1929                                         data->block[i] = msgbuf1[i];
1930                                 break;
1931                 }
1932         return 0;
1933 }
1934
1935 /**
1936  * i2c_smbus_xfer - execute SMBus protocol operations
1937  * @adapter: Handle to I2C bus
1938  * @addr: Address of SMBus slave on that bus
1939  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1940  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1941  * @command: Byte interpreted by slave, for protocols which use such bytes
1942  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1943  * @data: Data to be read or written
1944  *
1945  * This executes an SMBus protocol operation, and returns a negative
1946  * errno code else zero on success.
1947  */
1948 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1949                    char read_write, u8 command, int protocol,
1950                    union i2c_smbus_data * data)
1951 {
1952         s32 res;
1953
1954         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1955
1956         if (adapter->algo->smbus_xfer) {
1957                 mutex_lock(&adapter->bus_lock);
1958                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1959                                                 command, protocol, data);
1960                 mutex_unlock(&adapter->bus_lock);
1961         } else
1962                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1963                                               command, protocol, data);
1964
1965         return res;
1966 }
1967 EXPORT_SYMBOL(i2c_smbus_xfer);
1968
1969 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1970 MODULE_DESCRIPTION("I2C-Bus main module");
1971 MODULE_LICENSE("GPL");