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