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