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