Merge git://git.infradead.org/mtd-2.6
[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/seq_file.h>
33 #include <linux/platform_device.h>
34 #include <linux/mutex.h>
35 #include <linux/completion.h>
36 #include <asm/uaccess.h>
37
38 #include "i2c-core.h"
39
40
41 static LIST_HEAD(adapters);
42 static LIST_HEAD(drivers);
43 static DEFINE_MUTEX(core_lists);
44 static DEFINE_IDR(i2c_adapter_idr);
45
46 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
47
48 /* ------------------------------------------------------------------------- */
49
50 static int i2c_device_match(struct device *dev, struct device_driver *drv)
51 {
52         struct i2c_client       *client = to_i2c_client(dev);
53         struct i2c_driver       *driver = to_i2c_driver(drv);
54
55         /* make legacy i2c drivers bypass driver model probing entirely;
56          * such drivers scan each i2c adapter/bus themselves.
57          */
58         if (!is_newstyle_driver(driver))
59                 return 0;
60
61         /* new style drivers use the same kind of driver matching policy
62          * as platform devices or SPI:  compare device and driver IDs.
63          */
64         return strcmp(client->driver_name, drv->name) == 0;
65 }
66
67 #ifdef  CONFIG_HOTPLUG
68
69 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
70 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
71 {
72         struct i2c_client       *client = to_i2c_client(dev);
73
74         /* by definition, legacy drivers can't hotplug */
75         if (dev->driver || !client->driver_name)
76                 return 0;
77
78         if (add_uevent_var(env, "MODALIAS=%s", client->driver_name))
79                 return -ENOMEM;
80         dev_dbg(dev, "uevent\n");
81         return 0;
82 }
83
84 #else
85 #define i2c_device_uevent       NULL
86 #endif  /* CONFIG_HOTPLUG */
87
88 static int i2c_device_probe(struct device *dev)
89 {
90         struct i2c_client       *client = to_i2c_client(dev);
91         struct i2c_driver       *driver = to_i2c_driver(dev->driver);
92
93         if (!driver->probe)
94                 return -ENODEV;
95         client->driver = driver;
96         dev_dbg(dev, "probe\n");
97         return driver->probe(client);
98 }
99
100 static int i2c_device_remove(struct device *dev)
101 {
102         struct i2c_client       *client = to_i2c_client(dev);
103         struct i2c_driver       *driver;
104         int                     status;
105
106         if (!dev->driver)
107                 return 0;
108
109         driver = to_i2c_driver(dev->driver);
110         if (driver->remove) {
111                 dev_dbg(dev, "remove\n");
112                 status = driver->remove(client);
113         } else {
114                 dev->driver = NULL;
115                 status = 0;
116         }
117         if (status == 0)
118                 client->driver = NULL;
119         return status;
120 }
121
122 static void i2c_device_shutdown(struct device *dev)
123 {
124         struct i2c_driver *driver;
125
126         if (!dev->driver)
127                 return;
128         driver = to_i2c_driver(dev->driver);
129         if (driver->shutdown)
130                 driver->shutdown(to_i2c_client(dev));
131 }
132
133 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
134 {
135         struct i2c_driver *driver;
136
137         if (!dev->driver)
138                 return 0;
139         driver = to_i2c_driver(dev->driver);
140         if (!driver->suspend)
141                 return 0;
142         return driver->suspend(to_i2c_client(dev), mesg);
143 }
144
145 static int i2c_device_resume(struct device * dev)
146 {
147         struct i2c_driver *driver;
148
149         if (!dev->driver)
150                 return 0;
151         driver = to_i2c_driver(dev->driver);
152         if (!driver->resume)
153                 return 0;
154         return driver->resume(to_i2c_client(dev));
155 }
156
157 static void i2c_client_release(struct device *dev)
158 {
159         struct i2c_client *client = to_i2c_client(dev);
160         complete(&client->released);
161 }
162
163 static void i2c_client_dev_release(struct device *dev)
164 {
165         kfree(to_i2c_client(dev));
166 }
167
168 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
169 {
170         struct i2c_client *client = to_i2c_client(dev);
171         return sprintf(buf, "%s\n", client->name);
172 }
173
174 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
175 {
176         struct i2c_client *client = to_i2c_client(dev);
177         return client->driver_name
178                 ? sprintf(buf, "%s\n", client->driver_name)
179                 : 0;
180 }
181
182 static struct device_attribute i2c_dev_attrs[] = {
183         __ATTR(name, S_IRUGO, show_client_name, NULL),
184         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
185         __ATTR(modalias, S_IRUGO, show_modalias, NULL),
186         { },
187 };
188
189 static struct bus_type i2c_bus_type = {
190         .name           = "i2c",
191         .dev_attrs      = i2c_dev_attrs,
192         .match          = i2c_device_match,
193         .uevent         = i2c_device_uevent,
194         .probe          = i2c_device_probe,
195         .remove         = i2c_device_remove,
196         .shutdown       = i2c_device_shutdown,
197         .suspend        = i2c_device_suspend,
198         .resume         = i2c_device_resume,
199 };
200
201 /**
202  * i2c_new_device - instantiate an i2c device for use with a new style driver
203  * @adap: the adapter managing the device
204  * @info: describes one I2C device; bus_num is ignored
205  * Context: can sleep
206  *
207  * Create a device to work with a new style i2c driver, where binding is
208  * handled through driver model probe()/remove() methods.  This call is not
209  * appropriate for use by mainboad initialization logic, which usually runs
210  * during an arch_initcall() long before any i2c_adapter could exist.
211  *
212  * This returns the new i2c client, which may be saved for later use with
213  * i2c_unregister_device(); or NULL to indicate an error.
214  */
215 struct i2c_client *
216 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
217 {
218         struct i2c_client       *client;
219         int                     status;
220
221         client = kzalloc(sizeof *client, GFP_KERNEL);
222         if (!client)
223                 return NULL;
224
225         client->adapter = adap;
226
227         client->dev.platform_data = info->platform_data;
228         device_init_wakeup(&client->dev, info->flags & I2C_CLIENT_WAKE);
229
230         client->flags = info->flags & ~I2C_CLIENT_WAKE;
231         client->addr = info->addr;
232         client->irq = info->irq;
233
234         strlcpy(client->driver_name, info->driver_name,
235                 sizeof(client->driver_name));
236         strlcpy(client->name, info->type, sizeof(client->name));
237
238         /* a new style driver may be bound to this device when we
239          * return from this function, or any later moment (e.g. maybe
240          * hotplugging will load the driver module).  and the device
241          * refcount model is the standard driver model one.
242          */
243         status = i2c_attach_client(client);
244         if (status < 0) {
245                 kfree(client);
246                 client = NULL;
247         }
248         return client;
249 }
250 EXPORT_SYMBOL_GPL(i2c_new_device);
251
252
253 /**
254  * i2c_unregister_device - reverse effect of i2c_new_device()
255  * @client: value returned from i2c_new_device()
256  * Context: can sleep
257  */
258 void i2c_unregister_device(struct i2c_client *client)
259 {
260         struct i2c_adapter      *adapter = client->adapter;
261         struct i2c_driver       *driver = client->driver;
262
263         if (driver && !is_newstyle_driver(driver)) {
264                 dev_err(&client->dev, "can't unregister devices "
265                         "with legacy drivers\n");
266                 WARN_ON(1);
267                 return;
268         }
269
270         mutex_lock(&adapter->clist_lock);
271         list_del(&client->list);
272         mutex_unlock(&adapter->clist_lock);
273
274         device_unregister(&client->dev);
275 }
276 EXPORT_SYMBOL_GPL(i2c_unregister_device);
277
278
279 /* ------------------------------------------------------------------------- */
280
281 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
282
283 static void i2c_adapter_dev_release(struct device *dev)
284 {
285         struct i2c_adapter *adap = to_i2c_adapter(dev);
286         complete(&adap->dev_released);
287 }
288
289 static ssize_t
290 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
291 {
292         struct i2c_adapter *adap = to_i2c_adapter(dev);
293         return sprintf(buf, "%s\n", adap->name);
294 }
295
296 static struct device_attribute i2c_adapter_attrs[] = {
297         __ATTR(name, S_IRUGO, show_adapter_name, NULL),
298         { },
299 };
300
301 static struct class i2c_adapter_class = {
302         .owner                  = THIS_MODULE,
303         .name                   = "i2c-adapter",
304         .dev_attrs              = i2c_adapter_attrs,
305 };
306
307 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
308 {
309         struct i2c_devinfo      *devinfo;
310
311         mutex_lock(&__i2c_board_lock);
312         list_for_each_entry(devinfo, &__i2c_board_list, list) {
313                 if (devinfo->busnum == adapter->nr
314                                 && !i2c_new_device(adapter,
315                                                 &devinfo->board_info))
316                         printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
317                                 i2c_adapter_id(adapter),
318                                 devinfo->board_info.addr);
319         }
320         mutex_unlock(&__i2c_board_lock);
321 }
322
323 static int i2c_register_adapter(struct i2c_adapter *adap)
324 {
325         int res = 0;
326         struct list_head   *item;
327         struct i2c_driver  *driver;
328
329         mutex_init(&adap->bus_lock);
330         mutex_init(&adap->clist_lock);
331         INIT_LIST_HEAD(&adap->clients);
332
333         mutex_lock(&core_lists);
334         list_add_tail(&adap->list, &adapters);
335
336         /* Add the adapter to the driver core.
337          * If the parent pointer is not set up,
338          * we add this adapter to the host bus.
339          */
340         if (adap->dev.parent == NULL) {
341                 adap->dev.parent = &platform_bus;
342                 pr_debug("I2C adapter driver [%s] forgot to specify "
343                          "physical device\n", adap->name);
344         }
345         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
346         adap->dev.release = &i2c_adapter_dev_release;
347         adap->dev.class = &i2c_adapter_class;
348         res = device_register(&adap->dev);
349         if (res)
350                 goto out_list;
351
352         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
353
354         /* create pre-declared device nodes for new-style drivers */
355         if (adap->nr < __i2c_first_dynamic_bus_num)
356                 i2c_scan_static_board_info(adap);
357
358         /* let legacy drivers scan this bus for matching devices */
359         list_for_each(item,&drivers) {
360                 driver = list_entry(item, struct i2c_driver, list);
361                 if (driver->attach_adapter)
362                         /* We ignore the return code; if it fails, too bad */
363                         driver->attach_adapter(adap);
364         }
365
366 out_unlock:
367         mutex_unlock(&core_lists);
368         return res;
369
370 out_list:
371         list_del(&adap->list);
372         idr_remove(&i2c_adapter_idr, adap->nr);
373         goto out_unlock;
374 }
375
376 /**
377  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
378  * @adapter: the adapter to add
379  * Context: can sleep
380  *
381  * This routine is used to declare an I2C adapter when its bus number
382  * doesn't matter.  Examples: for I2C adapters dynamically added by
383  * USB links or PCI plugin cards.
384  *
385  * When this returns zero, a new bus number was allocated and stored
386  * in adap->nr, and the specified adapter became available for clients.
387  * Otherwise, a negative errno value is returned.
388  */
389 int i2c_add_adapter(struct i2c_adapter *adapter)
390 {
391         int     id, res = 0;
392
393 retry:
394         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
395                 return -ENOMEM;
396
397         mutex_lock(&core_lists);
398         /* "above" here means "above or equal to", sigh */
399         res = idr_get_new_above(&i2c_adapter_idr, adapter,
400                                 __i2c_first_dynamic_bus_num, &id);
401         mutex_unlock(&core_lists);
402
403         if (res < 0) {
404                 if (res == -EAGAIN)
405                         goto retry;
406                 return res;
407         }
408
409         adapter->nr = id;
410         return i2c_register_adapter(adapter);
411 }
412 EXPORT_SYMBOL(i2c_add_adapter);
413
414 /**
415  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
416  * @adap: the adapter to register (with adap->nr initialized)
417  * Context: can sleep
418  *
419  * This routine is used to declare an I2C adapter when its bus number
420  * matters.  Example: for I2C adapters from system-on-chip CPUs, or
421  * otherwise built in to the system's mainboard, and where i2c_board_info
422  * is used to properly configure I2C devices.
423  *
424  * If no devices have pre-been declared for this bus, then be sure to
425  * register the adapter before any dynamically allocated ones.  Otherwise
426  * the required bus ID may not be available.
427  *
428  * When this returns zero, the specified adapter became available for
429  * clients using the bus number provided in adap->nr.  Also, the table
430  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
431  * and the appropriate driver model device nodes are created.  Otherwise, a
432  * negative errno value is returned.
433  */
434 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
435 {
436         int     id;
437         int     status;
438
439         if (adap->nr & ~MAX_ID_MASK)
440                 return -EINVAL;
441
442 retry:
443         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
444                 return -ENOMEM;
445
446         mutex_lock(&core_lists);
447         /* "above" here means "above or equal to", sigh;
448          * we need the "equal to" result to force the result
449          */
450         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
451         if (status == 0 && id != adap->nr) {
452                 status = -EBUSY;
453                 idr_remove(&i2c_adapter_idr, id);
454         }
455         mutex_unlock(&core_lists);
456         if (status == -EAGAIN)
457                 goto retry;
458
459         if (status == 0)
460                 status = i2c_register_adapter(adap);
461         return status;
462 }
463 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
464
465 /**
466  * i2c_del_adapter - unregister I2C adapter
467  * @adap: the adapter being unregistered
468  * Context: can sleep
469  *
470  * This unregisters an I2C adapter which was previously registered
471  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
472  */
473 int i2c_del_adapter(struct i2c_adapter *adap)
474 {
475         struct list_head  *item, *_n;
476         struct i2c_adapter *adap_from_list;
477         struct i2c_driver *driver;
478         struct i2c_client *client;
479         int res = 0;
480
481         mutex_lock(&core_lists);
482
483         /* First make sure that this adapter was ever added */
484         list_for_each_entry(adap_from_list, &adapters, list) {
485                 if (adap_from_list == adap)
486                         break;
487         }
488         if (adap_from_list != adap) {
489                 pr_debug("i2c-core: attempting to delete unregistered "
490                          "adapter [%s]\n", adap->name);
491                 res = -EINVAL;
492                 goto out_unlock;
493         }
494
495         list_for_each(item,&drivers) {
496                 driver = list_entry(item, struct i2c_driver, list);
497                 if (driver->detach_adapter)
498                         if ((res = driver->detach_adapter(adap))) {
499                                 dev_err(&adap->dev, "detach_adapter failed "
500                                         "for driver [%s]\n",
501                                         driver->driver.name);
502                                 goto out_unlock;
503                         }
504         }
505
506         /* detach any active clients. This must be done first, because
507          * it can fail; in which case we give up. */
508         list_for_each_safe(item, _n, &adap->clients) {
509                 struct i2c_driver       *driver;
510
511                 client = list_entry(item, struct i2c_client, list);
512                 driver = client->driver;
513
514                 /* new style, follow standard driver model */
515                 if (!driver || is_newstyle_driver(driver)) {
516                         i2c_unregister_device(client);
517                         continue;
518                 }
519
520                 /* legacy drivers create and remove clients themselves */
521                 if ((res = driver->detach_client(client))) {
522                         dev_err(&adap->dev, "detach_client failed for client "
523                                 "[%s] at address 0x%02x\n", client->name,
524                                 client->addr);
525                         goto out_unlock;
526                 }
527         }
528
529         /* clean up the sysfs representation */
530         init_completion(&adap->dev_released);
531         device_unregister(&adap->dev);
532         list_del(&adap->list);
533
534         /* wait for sysfs to drop all references */
535         wait_for_completion(&adap->dev_released);
536
537         /* free bus id */
538         idr_remove(&i2c_adapter_idr, adap->nr);
539
540         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
541
542  out_unlock:
543         mutex_unlock(&core_lists);
544         return res;
545 }
546 EXPORT_SYMBOL(i2c_del_adapter);
547
548
549 /* ------------------------------------------------------------------------- */
550
551 /*
552  * An i2c_driver is used with one or more i2c_client (device) nodes to access
553  * i2c slave chips, on a bus instance associated with some i2c_adapter.  There
554  * are two models for binding the driver to its device:  "new style" drivers
555  * follow the standard Linux driver model and just respond to probe() calls
556  * issued if the driver core sees they match(); "legacy" drivers create device
557  * nodes themselves.
558  */
559
560 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
561 {
562         int res;
563
564         /* new style driver methods can't mix with legacy ones */
565         if (is_newstyle_driver(driver)) {
566                 if (driver->attach_adapter || driver->detach_adapter
567                                 || driver->detach_client) {
568                         printk(KERN_WARNING
569                                         "i2c-core: driver [%s] is confused\n",
570                                         driver->driver.name);
571                         return -EINVAL;
572                 }
573         }
574
575         /* add the driver to the list of i2c drivers in the driver core */
576         driver->driver.owner = owner;
577         driver->driver.bus = &i2c_bus_type;
578
579         /* for new style drivers, when registration returns the driver core
580          * will have called probe() for all matching-but-unbound devices.
581          */
582         res = driver_register(&driver->driver);
583         if (res)
584                 return res;
585
586         mutex_lock(&core_lists);
587
588         list_add_tail(&driver->list,&drivers);
589         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
590
591         /* legacy drivers scan i2c busses directly */
592         if (driver->attach_adapter) {
593                 struct i2c_adapter *adapter;
594
595                 list_for_each_entry(adapter, &adapters, list) {
596                         driver->attach_adapter(adapter);
597                 }
598         }
599
600         mutex_unlock(&core_lists);
601         return 0;
602 }
603 EXPORT_SYMBOL(i2c_register_driver);
604
605 /**
606  * i2c_del_driver - unregister I2C driver
607  * @driver: the driver being unregistered
608  * Context: can sleep
609  */
610 void i2c_del_driver(struct i2c_driver *driver)
611 {
612         struct list_head   *item1, *item2, *_n;
613         struct i2c_client  *client;
614         struct i2c_adapter *adap;
615
616         mutex_lock(&core_lists);
617
618         /* new-style driver? */
619         if (is_newstyle_driver(driver))
620                 goto unregister;
621
622         /* Have a look at each adapter, if clients of this driver are still
623          * attached. If so, detach them to be able to kill the driver
624          * afterwards.
625          */
626         list_for_each(item1,&adapters) {
627                 adap = list_entry(item1, struct i2c_adapter, list);
628                 if (driver->detach_adapter) {
629                         if (driver->detach_adapter(adap)) {
630                                 dev_err(&adap->dev, "detach_adapter failed "
631                                         "for driver [%s]\n",
632                                         driver->driver.name);
633                         }
634                 } else {
635                         list_for_each_safe(item2, _n, &adap->clients) {
636                                 client = list_entry(item2, struct i2c_client, list);
637                                 if (client->driver != driver)
638                                         continue;
639                                 dev_dbg(&adap->dev, "detaching client [%s] "
640                                         "at 0x%02x\n", client->name,
641                                         client->addr);
642                                 if (driver->detach_client(client)) {
643                                         dev_err(&adap->dev, "detach_client "
644                                                 "failed for client [%s] at "
645                                                 "0x%02x\n", client->name,
646                                                 client->addr);
647                                 }
648                         }
649                 }
650         }
651
652  unregister:
653         driver_unregister(&driver->driver);
654         list_del(&driver->list);
655         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
656
657         mutex_unlock(&core_lists);
658 }
659 EXPORT_SYMBOL(i2c_del_driver);
660
661 /* ------------------------------------------------------------------------- */
662
663 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
664 {
665         struct list_head   *item;
666         struct i2c_client  *client;
667
668         list_for_each(item,&adapter->clients) {
669                 client = list_entry(item, struct i2c_client, list);
670                 if (client->addr == addr)
671                         return -EBUSY;
672         }
673         return 0;
674 }
675
676 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
677 {
678         int rval;
679
680         mutex_lock(&adapter->clist_lock);
681         rval = __i2c_check_addr(adapter, addr);
682         mutex_unlock(&adapter->clist_lock);
683
684         return rval;
685 }
686 EXPORT_SYMBOL(i2c_check_addr);
687
688 int i2c_attach_client(struct i2c_client *client)
689 {
690         struct i2c_adapter *adapter = client->adapter;
691         int res = 0;
692
693         mutex_lock(&adapter->clist_lock);
694         if (__i2c_check_addr(client->adapter, client->addr)) {
695                 res = -EBUSY;
696                 goto out_unlock;
697         }
698         list_add_tail(&client->list,&adapter->clients);
699
700         client->usage_count = 0;
701
702         client->dev.parent = &client->adapter->dev;
703         client->dev.bus = &i2c_bus_type;
704
705         if (client->driver)
706                 client->dev.driver = &client->driver->driver;
707
708         if (client->driver && !is_newstyle_driver(client->driver)) {
709                 client->dev.release = i2c_client_release;
710                 client->dev.uevent_suppress = 1;
711         } else
712                 client->dev.release = i2c_client_dev_release;
713
714         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
715                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
716         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
717                 client->name, client->dev.bus_id);
718         res = device_register(&client->dev);
719         if (res)
720                 goto out_list;
721         mutex_unlock(&adapter->clist_lock);
722
723         if (adapter->client_register)  {
724                 if (adapter->client_register(client)) {
725                         dev_dbg(&adapter->dev, "client_register "
726                                 "failed for client [%s] at 0x%02x\n",
727                                 client->name, client->addr);
728                 }
729         }
730
731         return 0;
732
733 out_list:
734         list_del(&client->list);
735         dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
736                 "(%d)\n", client->name, client->addr, res);
737 out_unlock:
738         mutex_unlock(&adapter->clist_lock);
739         return res;
740 }
741 EXPORT_SYMBOL(i2c_attach_client);
742
743 int i2c_detach_client(struct i2c_client *client)
744 {
745         struct i2c_adapter *adapter = client->adapter;
746         int res = 0;
747
748         if (client->usage_count > 0) {
749                 dev_warn(&client->dev, "Client [%s] still busy, "
750                          "can't detach\n", client->name);
751                 return -EBUSY;
752         }
753
754         if (adapter->client_unregister)  {
755                 res = adapter->client_unregister(client);
756                 if (res) {
757                         dev_err(&client->dev,
758                                 "client_unregister [%s] failed, "
759                                 "client not detached\n", client->name);
760                         goto out;
761                 }
762         }
763
764         mutex_lock(&adapter->clist_lock);
765         list_del(&client->list);
766         init_completion(&client->released);
767         device_unregister(&client->dev);
768         mutex_unlock(&adapter->clist_lock);
769         wait_for_completion(&client->released);
770
771  out:
772         return res;
773 }
774 EXPORT_SYMBOL(i2c_detach_client);
775
776 static int i2c_inc_use_client(struct i2c_client *client)
777 {
778
779         if (!try_module_get(client->driver->driver.owner))
780                 return -ENODEV;
781         if (!try_module_get(client->adapter->owner)) {
782                 module_put(client->driver->driver.owner);
783                 return -ENODEV;
784         }
785
786         return 0;
787 }
788
789 static void i2c_dec_use_client(struct i2c_client *client)
790 {
791         module_put(client->driver->driver.owner);
792         module_put(client->adapter->owner);
793 }
794
795 int i2c_use_client(struct i2c_client *client)
796 {
797         int ret;
798
799         ret = i2c_inc_use_client(client);
800         if (ret)
801                 return ret;
802
803         client->usage_count++;
804
805         return 0;
806 }
807 EXPORT_SYMBOL(i2c_use_client);
808
809 int i2c_release_client(struct i2c_client *client)
810 {
811         if (!client->usage_count) {
812                 pr_debug("i2c-core: %s used one too many times\n",
813                          __FUNCTION__);
814                 return -EPERM;
815         }
816
817         client->usage_count--;
818         i2c_dec_use_client(client);
819
820         return 0;
821 }
822 EXPORT_SYMBOL(i2c_release_client);
823
824 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
825 {
826         struct list_head  *item;
827         struct i2c_client *client;
828
829         mutex_lock(&adap->clist_lock);
830         list_for_each(item,&adap->clients) {
831                 client = list_entry(item, struct i2c_client, list);
832                 if (!try_module_get(client->driver->driver.owner))
833                         continue;
834                 if (NULL != client->driver->command) {
835                         mutex_unlock(&adap->clist_lock);
836                         client->driver->command(client,cmd,arg);
837                         mutex_lock(&adap->clist_lock);
838                 }
839                 module_put(client->driver->driver.owner);
840        }
841        mutex_unlock(&adap->clist_lock);
842 }
843 EXPORT_SYMBOL(i2c_clients_command);
844
845 static int __init i2c_init(void)
846 {
847         int retval;
848
849         retval = bus_register(&i2c_bus_type);
850         if (retval)
851                 return retval;
852         return class_register(&i2c_adapter_class);
853 }
854
855 static void __exit i2c_exit(void)
856 {
857         class_unregister(&i2c_adapter_class);
858         bus_unregister(&i2c_bus_type);
859 }
860
861 subsys_initcall(i2c_init);
862 module_exit(i2c_exit);
863
864 /* ----------------------------------------------------
865  * the functional interface to the i2c busses.
866  * ----------------------------------------------------
867  */
868
869 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
870 {
871         int ret;
872
873         if (adap->algo->master_xfer) {
874 #ifdef DEBUG
875                 for (ret = 0; ret < num; ret++) {
876                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
877                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
878                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
879                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
880                 }
881 #endif
882
883                 mutex_lock_nested(&adap->bus_lock, adap->level);
884                 ret = adap->algo->master_xfer(adap,msgs,num);
885                 mutex_unlock(&adap->bus_lock);
886
887                 return ret;
888         } else {
889                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
890                 return -ENOSYS;
891         }
892 }
893 EXPORT_SYMBOL(i2c_transfer);
894
895 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
896 {
897         int ret;
898         struct i2c_adapter *adap=client->adapter;
899         struct i2c_msg msg;
900
901         msg.addr = client->addr;
902         msg.flags = client->flags & I2C_M_TEN;
903         msg.len = count;
904         msg.buf = (char *)buf;
905
906         ret = i2c_transfer(adap, &msg, 1);
907
908         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
909            transmitted, else error code. */
910         return (ret == 1) ? count : ret;
911 }
912 EXPORT_SYMBOL(i2c_master_send);
913
914 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
915 {
916         struct i2c_adapter *adap=client->adapter;
917         struct i2c_msg msg;
918         int ret;
919
920         msg.addr = client->addr;
921         msg.flags = client->flags & I2C_M_TEN;
922         msg.flags |= I2C_M_RD;
923         msg.len = count;
924         msg.buf = buf;
925
926         ret = i2c_transfer(adap, &msg, 1);
927
928         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
929            transmitted, else error code. */
930         return (ret == 1) ? count : ret;
931 }
932 EXPORT_SYMBOL(i2c_master_recv);
933
934 /* ----------------------------------------------------
935  * the i2c address scanning function
936  * Will not work for 10-bit addresses!
937  * ----------------------------------------------------
938  */
939 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
940                              int (*found_proc) (struct i2c_adapter *, int, int))
941 {
942         int err;
943
944         /* Make sure the address is valid */
945         if (addr < 0x03 || addr > 0x77) {
946                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
947                          addr);
948                 return -EINVAL;
949         }
950
951         /* Skip if already in use */
952         if (i2c_check_addr(adapter, addr))
953                 return 0;
954
955         /* Make sure there is something at this address, unless forced */
956         if (kind < 0) {
957                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
958                                    I2C_SMBUS_QUICK, NULL) < 0)
959                         return 0;
960
961                 /* prevent 24RF08 corruption */
962                 if ((addr & ~0x0f) == 0x50)
963                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
964                                        I2C_SMBUS_QUICK, NULL);
965         }
966
967         /* Finally call the custom detection function */
968         err = found_proc(adapter, addr, kind);
969         /* -ENODEV can be returned if there is a chip at the given address
970            but it isn't supported by this chip driver. We catch it here as
971            this isn't an error. */
972         if (err == -ENODEV)
973                 err = 0;
974
975         if (err)
976                 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
977                          addr, err);
978         return err;
979 }
980
981 int i2c_probe(struct i2c_adapter *adapter,
982               struct i2c_client_address_data *address_data,
983               int (*found_proc) (struct i2c_adapter *, int, int))
984 {
985         int i, err;
986         int adap_id = i2c_adapter_id(adapter);
987
988         /* Force entries are done first, and are not affected by ignore
989            entries */
990         if (address_data->forces) {
991                 unsigned short **forces = address_data->forces;
992                 int kind;
993
994                 for (kind = 0; forces[kind]; kind++) {
995                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
996                              i += 2) {
997                                 if (forces[kind][i] == adap_id
998                                  || forces[kind][i] == ANY_I2C_BUS) {
999                                         dev_dbg(&adapter->dev, "found force "
1000                                                 "parameter for adapter %d, "
1001                                                 "addr 0x%02x, kind %d\n",
1002                                                 adap_id, forces[kind][i + 1],
1003                                                 kind);
1004                                         err = i2c_probe_address(adapter,
1005                                                 forces[kind][i + 1],
1006                                                 kind, found_proc);
1007                                         if (err)
1008                                                 return err;
1009                                 }
1010                         }
1011                 }
1012         }
1013
1014         /* Stop here if we can't use SMBUS_QUICK */
1015         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1016                 if (address_data->probe[0] == I2C_CLIENT_END
1017                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1018                         return 0;
1019
1020                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1021                          "can't probe for chips\n");
1022                 return -1;
1023         }
1024
1025         /* Probe entries are done second, and are not affected by ignore
1026            entries either */
1027         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1028                 if (address_data->probe[i] == adap_id
1029                  || address_data->probe[i] == ANY_I2C_BUS) {
1030                         dev_dbg(&adapter->dev, "found probe parameter for "
1031                                 "adapter %d, addr 0x%02x\n", adap_id,
1032                                 address_data->probe[i + 1]);
1033                         err = i2c_probe_address(adapter,
1034                                                 address_data->probe[i + 1],
1035                                                 -1, found_proc);
1036                         if (err)
1037                                 return err;
1038                 }
1039         }
1040
1041         /* Normal entries are done last, unless shadowed by an ignore entry */
1042         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1043                 int j, ignore;
1044
1045                 ignore = 0;
1046                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1047                      j += 2) {
1048                         if ((address_data->ignore[j] == adap_id ||
1049                              address_data->ignore[j] == ANY_I2C_BUS)
1050                          && address_data->ignore[j + 1]
1051                             == address_data->normal_i2c[i]) {
1052                                 dev_dbg(&adapter->dev, "found ignore "
1053                                         "parameter for adapter %d, "
1054                                         "addr 0x%02x\n", adap_id,
1055                                         address_data->ignore[j + 1]);
1056                                 ignore = 1;
1057                                 break;
1058                         }
1059                 }
1060                 if (ignore)
1061                         continue;
1062
1063                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1064                         "addr 0x%02x\n", adap_id,
1065                         address_data->normal_i2c[i]);
1066                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1067                                         -1, found_proc);
1068                 if (err)
1069                         return err;
1070         }
1071
1072         return 0;
1073 }
1074 EXPORT_SYMBOL(i2c_probe);
1075
1076 struct i2c_client *
1077 i2c_new_probed_device(struct i2c_adapter *adap,
1078                       struct i2c_board_info *info,
1079                       unsigned short const *addr_list)
1080 {
1081         int i;
1082
1083         /* Stop here if the bus doesn't support probing */
1084         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1085                 dev_err(&adap->dev, "Probing not supported\n");
1086                 return NULL;
1087         }
1088
1089         mutex_lock(&adap->clist_lock);
1090         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1091                 /* Check address validity */
1092                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1093                         dev_warn(&adap->dev, "Invalid 7-bit address "
1094                                  "0x%02x\n", addr_list[i]);
1095                         continue;
1096                 }
1097
1098                 /* Check address availability */
1099                 if (__i2c_check_addr(adap, addr_list[i])) {
1100                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1101                                 "use, not probing\n", addr_list[i]);
1102                         continue;
1103                 }
1104
1105                 /* Test address responsiveness
1106                    The default probe method is a quick write, but it is known
1107                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1108                    and could also irreversibly write-protect some EEPROMs, so
1109                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1110                    read instead. Also, some bus drivers don't implement
1111                    quick write, so we fallback to a byte read it that case
1112                    too. */
1113                 if ((addr_list[i] & ~0x07) == 0x30
1114                  || (addr_list[i] & ~0x0f) == 0x50
1115                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1116                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1117                                            I2C_SMBUS_READ, 0,
1118                                            I2C_SMBUS_BYTE, NULL) >= 0)
1119                                 break;
1120                 } else {
1121                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1122                                            I2C_SMBUS_WRITE, 0,
1123                                            I2C_SMBUS_QUICK, NULL) >= 0)
1124                                 break;
1125                 }
1126         }
1127         mutex_unlock(&adap->clist_lock);
1128
1129         if (addr_list[i] == I2C_CLIENT_END) {
1130                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1131                 return NULL;
1132         }
1133
1134         info->addr = addr_list[i];
1135         return i2c_new_device(adap, info);
1136 }
1137 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1138
1139 struct i2c_adapter* i2c_get_adapter(int id)
1140 {
1141         struct i2c_adapter *adapter;
1142
1143         mutex_lock(&core_lists);
1144         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1145         if (adapter && !try_module_get(adapter->owner))
1146                 adapter = NULL;
1147
1148         mutex_unlock(&core_lists);
1149         return adapter;
1150 }
1151 EXPORT_SYMBOL(i2c_get_adapter);
1152
1153 void i2c_put_adapter(struct i2c_adapter *adap)
1154 {
1155         module_put(adap->owner);
1156 }
1157 EXPORT_SYMBOL(i2c_put_adapter);
1158
1159 /* The SMBus parts */
1160
1161 #define POLY    (0x1070U << 3)
1162 static u8
1163 crc8(u16 data)
1164 {
1165         int i;
1166
1167         for(i = 0; i < 8; i++) {
1168                 if (data & 0x8000)
1169                         data = data ^ POLY;
1170                 data = data << 1;
1171         }
1172         return (u8)(data >> 8);
1173 }
1174
1175 /* Incremental CRC8 over count bytes in the array pointed to by p */
1176 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1177 {
1178         int i;
1179
1180         for(i = 0; i < count; i++)
1181                 crc = crc8((crc ^ p[i]) << 8);
1182         return crc;
1183 }
1184
1185 /* Assume a 7-bit address, which is reasonable for SMBus */
1186 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1187 {
1188         /* The address will be sent first */
1189         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1190         pec = i2c_smbus_pec(pec, &addr, 1);
1191
1192         /* The data buffer follows */
1193         return i2c_smbus_pec(pec, msg->buf, msg->len);
1194 }
1195
1196 /* Used for write only transactions */
1197 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1198 {
1199         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1200         msg->len++;
1201 }
1202
1203 /* Return <0 on CRC error
1204    If there was a write before this read (most cases) we need to take the
1205    partial CRC from the write part into account.
1206    Note that this function does modify the message (we need to decrease the
1207    message length to hide the CRC byte from the caller). */
1208 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1209 {
1210         u8 rpec = msg->buf[--msg->len];
1211         cpec = i2c_smbus_msg_pec(cpec, msg);
1212
1213         if (rpec != cpec) {
1214                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1215                         rpec, cpec);
1216                 return -1;
1217         }
1218         return 0;
1219 }
1220
1221 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1222 {
1223         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1224                               value,0,I2C_SMBUS_QUICK,NULL);
1225 }
1226 EXPORT_SYMBOL(i2c_smbus_write_quick);
1227
1228 s32 i2c_smbus_read_byte(struct i2c_client *client)
1229 {
1230         union i2c_smbus_data data;
1231         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1232                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1233                 return -1;
1234         else
1235                 return data.byte;
1236 }
1237 EXPORT_SYMBOL(i2c_smbus_read_byte);
1238
1239 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1240 {
1241         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1242                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1243 }
1244 EXPORT_SYMBOL(i2c_smbus_write_byte);
1245
1246 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1247 {
1248         union i2c_smbus_data data;
1249         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1250                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1251                 return -1;
1252         else
1253                 return data.byte;
1254 }
1255 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1256
1257 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1258 {
1259         union i2c_smbus_data data;
1260         data.byte = value;
1261         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1262                               I2C_SMBUS_WRITE,command,
1263                               I2C_SMBUS_BYTE_DATA,&data);
1264 }
1265 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1266
1267 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1268 {
1269         union i2c_smbus_data data;
1270         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1271                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1272                 return -1;
1273         else
1274                 return data.word;
1275 }
1276 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1277
1278 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1279 {
1280         union i2c_smbus_data data;
1281         data.word = value;
1282         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1283                               I2C_SMBUS_WRITE,command,
1284                               I2C_SMBUS_WORD_DATA,&data);
1285 }
1286 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1287
1288 /**
1289  * i2c_smbus_read_block_data - SMBus block read request
1290  * @client: Handle to slave device
1291  * @command: Command byte issued to let the slave know what data should
1292  *      be returned
1293  * @values: Byte array into which data will be read; big enough to hold
1294  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1295  *
1296  * Returns the number of bytes read in the slave's response, else a
1297  * negative number to indicate some kind of error.
1298  *
1299  * Note that using this function requires that the client's adapter support
1300  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1301  * support this; its emulation through I2C messaging relies on a specific
1302  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1303  */
1304 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1305                               u8 *values)
1306 {
1307         union i2c_smbus_data data;
1308
1309         if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1310                            I2C_SMBUS_READ, command,
1311                            I2C_SMBUS_BLOCK_DATA, &data))
1312                 return -1;
1313
1314         memcpy(values, &data.block[1], data.block[0]);
1315         return data.block[0];
1316 }
1317 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1318
1319 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1320                                u8 length, const u8 *values)
1321 {
1322         union i2c_smbus_data data;
1323
1324         if (length > I2C_SMBUS_BLOCK_MAX)
1325                 length = I2C_SMBUS_BLOCK_MAX;
1326         data.block[0] = length;
1327         memcpy(&data.block[1], values, length);
1328         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1329                               I2C_SMBUS_WRITE,command,
1330                               I2C_SMBUS_BLOCK_DATA,&data);
1331 }
1332 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1333
1334 /* Returns the number of read bytes */
1335 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1336                                   u8 length, u8 *values)
1337 {
1338         union i2c_smbus_data data;
1339
1340         if (length > I2C_SMBUS_BLOCK_MAX)
1341                 length = I2C_SMBUS_BLOCK_MAX;
1342         data.block[0] = length;
1343         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1344                               I2C_SMBUS_READ,command,
1345                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
1346                 return -1;
1347
1348         memcpy(values, &data.block[1], data.block[0]);
1349         return data.block[0];
1350 }
1351 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1352
1353 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1354                                    u8 length, const u8 *values)
1355 {
1356         union i2c_smbus_data data;
1357
1358         if (length > I2C_SMBUS_BLOCK_MAX)
1359                 length = I2C_SMBUS_BLOCK_MAX;
1360         data.block[0] = length;
1361         memcpy(data.block + 1, values, length);
1362         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1363                               I2C_SMBUS_WRITE, command,
1364                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1365 }
1366 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1367
1368 /* Simulate a SMBus command using the i2c protocol
1369    No checking of parameters is done!  */
1370 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1371                                    unsigned short flags,
1372                                    char read_write, u8 command, int size,
1373                                    union i2c_smbus_data * data)
1374 {
1375         /* So we need to generate a series of msgs. In the case of writing, we
1376           need to use only one message; when reading, we need two. We initialize
1377           most things with sane defaults, to keep the code below somewhat
1378           simpler. */
1379         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1380         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1381         int num = read_write == I2C_SMBUS_READ?2:1;
1382         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1383                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1384                                 };
1385         int i;
1386         u8 partial_pec = 0;
1387
1388         msgbuf0[0] = command;
1389         switch(size) {
1390         case I2C_SMBUS_QUICK:
1391                 msg[0].len = 0;
1392                 /* Special case: The read/write field is used as data */
1393                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1394                 num = 1;
1395                 break;
1396         case I2C_SMBUS_BYTE:
1397                 if (read_write == I2C_SMBUS_READ) {
1398                         /* Special case: only a read! */
1399                         msg[0].flags = I2C_M_RD | flags;
1400                         num = 1;
1401                 }
1402                 break;
1403         case I2C_SMBUS_BYTE_DATA:
1404                 if (read_write == I2C_SMBUS_READ)
1405                         msg[1].len = 1;
1406                 else {
1407                         msg[0].len = 2;
1408                         msgbuf0[1] = data->byte;
1409                 }
1410                 break;
1411         case I2C_SMBUS_WORD_DATA:
1412                 if (read_write == I2C_SMBUS_READ)
1413                         msg[1].len = 2;
1414                 else {
1415                         msg[0].len=3;
1416                         msgbuf0[1] = data->word & 0xff;
1417                         msgbuf0[2] = data->word >> 8;
1418                 }
1419                 break;
1420         case I2C_SMBUS_PROC_CALL:
1421                 num = 2; /* Special case */
1422                 read_write = I2C_SMBUS_READ;
1423                 msg[0].len = 3;
1424                 msg[1].len = 2;
1425                 msgbuf0[1] = data->word & 0xff;
1426                 msgbuf0[2] = data->word >> 8;
1427                 break;
1428         case I2C_SMBUS_BLOCK_DATA:
1429                 if (read_write == I2C_SMBUS_READ) {
1430                         msg[1].flags |= I2C_M_RECV_LEN;
1431                         msg[1].len = 1; /* block length will be added by
1432                                            the underlying bus driver */
1433                 } else {
1434                         msg[0].len = data->block[0] + 2;
1435                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1436                                 dev_err(&adapter->dev, "smbus_access called with "
1437                                        "invalid block write size (%d)\n",
1438                                        data->block[0]);
1439                                 return -1;
1440                         }
1441                         for (i = 1; i < msg[0].len; i++)
1442                                 msgbuf0[i] = data->block[i-1];
1443                 }
1444                 break;
1445         case I2C_SMBUS_BLOCK_PROC_CALL:
1446                 num = 2; /* Another special case */
1447                 read_write = I2C_SMBUS_READ;
1448                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1449                         dev_err(&adapter->dev, "%s called with invalid "
1450                                 "block proc call size (%d)\n", __FUNCTION__,
1451                                 data->block[0]);
1452                         return -1;
1453                 }
1454                 msg[0].len = data->block[0] + 2;
1455                 for (i = 1; i < msg[0].len; i++)
1456                         msgbuf0[i] = data->block[i-1];
1457                 msg[1].flags |= I2C_M_RECV_LEN;
1458                 msg[1].len = 1; /* block length will be added by
1459                                    the underlying bus driver */
1460                 break;
1461         case I2C_SMBUS_I2C_BLOCK_DATA:
1462                 if (read_write == I2C_SMBUS_READ) {
1463                         msg[1].len = data->block[0];
1464                 } else {
1465                         msg[0].len = data->block[0] + 1;
1466                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1467                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1468                                        "invalid block write size (%d)\n",
1469                                        data->block[0]);
1470                                 return -1;
1471                         }
1472                         for (i = 1; i <= data->block[0]; i++)
1473                                 msgbuf0[i] = data->block[i];
1474                 }
1475                 break;
1476         default:
1477                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1478                        size);
1479                 return -1;
1480         }
1481
1482         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1483                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1484         if (i) {
1485                 /* Compute PEC if first message is a write */
1486                 if (!(msg[0].flags & I2C_M_RD)) {
1487                         if (num == 1) /* Write only */
1488                                 i2c_smbus_add_pec(&msg[0]);
1489                         else /* Write followed by read */
1490                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1491                 }
1492                 /* Ask for PEC if last message is a read */
1493                 if (msg[num-1].flags & I2C_M_RD)
1494                         msg[num-1].len++;
1495         }
1496
1497         if (i2c_transfer(adapter, msg, num) < 0)
1498                 return -1;
1499
1500         /* Check PEC if last message is a read */
1501         if (i && (msg[num-1].flags & I2C_M_RD)) {
1502                 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1503                         return -1;
1504         }
1505
1506         if (read_write == I2C_SMBUS_READ)
1507                 switch(size) {
1508                         case I2C_SMBUS_BYTE:
1509                                 data->byte = msgbuf0[0];
1510                                 break;
1511                         case I2C_SMBUS_BYTE_DATA:
1512                                 data->byte = msgbuf1[0];
1513                                 break;
1514                         case I2C_SMBUS_WORD_DATA:
1515                         case I2C_SMBUS_PROC_CALL:
1516                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1517                                 break;
1518                         case I2C_SMBUS_I2C_BLOCK_DATA:
1519                                 for (i = 0; i < data->block[0]; i++)
1520                                         data->block[i+1] = msgbuf1[i];
1521                                 break;
1522                         case I2C_SMBUS_BLOCK_DATA:
1523                         case I2C_SMBUS_BLOCK_PROC_CALL:
1524                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1525                                         data->block[i] = msgbuf1[i];
1526                                 break;
1527                 }
1528         return 0;
1529 }
1530
1531
1532 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1533                    char read_write, u8 command, int size,
1534                    union i2c_smbus_data * data)
1535 {
1536         s32 res;
1537
1538         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1539
1540         if (adapter->algo->smbus_xfer) {
1541                 mutex_lock(&adapter->bus_lock);
1542                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1543                                                 command,size,data);
1544                 mutex_unlock(&adapter->bus_lock);
1545         } else
1546                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1547                                               command,size,data);
1548
1549         return res;
1550 }
1551 EXPORT_SYMBOL(i2c_smbus_xfer);
1552
1553 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1554 MODULE_DESCRIPTION("I2C-Bus main module");
1555 MODULE_LICENSE("GPL");