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