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