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