i2c: convert to idr_alloc()
[~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., 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;
939
940         mutex_lock(&core_lock);
941         id = idr_alloc(&i2c_adapter_idr, adapter,
942                        __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
943         mutex_unlock(&core_lock);
944         if (id < 0)
945                 return id;
946
947         adapter->nr = id;
948
949         return i2c_register_adapter(adapter);
950 }
951 EXPORT_SYMBOL(i2c_add_adapter);
952
953 /**
954  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
955  * @adap: the adapter to register (with adap->nr initialized)
956  * Context: can sleep
957  *
958  * This routine is used to declare an I2C adapter when its bus number
959  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
960  * or otherwise built in to the system's mainboard, and where i2c_board_info
961  * is used to properly configure I2C devices.
962  *
963  * If the requested bus number is set to -1, then this function will behave
964  * identically to i2c_add_adapter, and will dynamically assign a bus number.
965  *
966  * If no devices have pre-been declared for this bus, then be sure to
967  * register the adapter before any dynamically allocated ones.  Otherwise
968  * the required bus ID may not be available.
969  *
970  * When this returns zero, the specified adapter became available for
971  * clients using the bus number provided in adap->nr.  Also, the table
972  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
973  * and the appropriate driver model device nodes are created.  Otherwise, a
974  * negative errno value is returned.
975  */
976 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
977 {
978         int     id;
979
980         if (adap->nr == -1) /* -1 means dynamically assign bus id */
981                 return i2c_add_adapter(adap);
982         if (adap->nr & ~MAX_IDR_MASK)
983                 return -EINVAL;
984
985         mutex_lock(&core_lock);
986         id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
987                        GFP_KERNEL);
988         mutex_unlock(&core_lock);
989         if (id < 0)
990                 return id == -ENOSPC ? -EBUSY : id;
991         return i2c_register_adapter(adap);
992 }
993 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
994
995 static int i2c_do_del_adapter(struct i2c_driver *driver,
996                               struct i2c_adapter *adapter)
997 {
998         struct i2c_client *client, *_n;
999         int res;
1000
1001         /* Remove the devices we created ourselves as the result of hardware
1002          * probing (using a driver's detect method) */
1003         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1004                 if (client->adapter == adapter) {
1005                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1006                                 client->name, client->addr);
1007                         list_del(&client->detected);
1008                         i2c_unregister_device(client);
1009                 }
1010         }
1011
1012         if (!driver->detach_adapter)
1013                 return 0;
1014         dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
1015                  driver->driver.name);
1016         res = driver->detach_adapter(adapter);
1017         if (res)
1018                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
1019                         "for driver [%s]\n", res, driver->driver.name);
1020         return res;
1021 }
1022
1023 static int __unregister_client(struct device *dev, void *dummy)
1024 {
1025         struct i2c_client *client = i2c_verify_client(dev);
1026         if (client && strcmp(client->name, "dummy"))
1027                 i2c_unregister_device(client);
1028         return 0;
1029 }
1030
1031 static int __unregister_dummy(struct device *dev, void *dummy)
1032 {
1033         struct i2c_client *client = i2c_verify_client(dev);
1034         if (client)
1035                 i2c_unregister_device(client);
1036         return 0;
1037 }
1038
1039 static int __process_removed_adapter(struct device_driver *d, void *data)
1040 {
1041         return i2c_do_del_adapter(to_i2c_driver(d), data);
1042 }
1043
1044 /**
1045  * i2c_del_adapter - unregister I2C adapter
1046  * @adap: the adapter being unregistered
1047  * Context: can sleep
1048  *
1049  * This unregisters an I2C adapter which was previously registered
1050  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1051  */
1052 int i2c_del_adapter(struct i2c_adapter *adap)
1053 {
1054         int res = 0;
1055         struct i2c_adapter *found;
1056         struct i2c_client *client, *next;
1057
1058         /* First make sure that this adapter was ever added */
1059         mutex_lock(&core_lock);
1060         found = idr_find(&i2c_adapter_idr, adap->nr);
1061         mutex_unlock(&core_lock);
1062         if (found != adap) {
1063                 pr_debug("i2c-core: attempting to delete unregistered "
1064                          "adapter [%s]\n", adap->name);
1065                 return -EINVAL;
1066         }
1067
1068         /* Tell drivers about this removal */
1069         mutex_lock(&core_lock);
1070         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1071                                __process_removed_adapter);
1072         mutex_unlock(&core_lock);
1073         if (res)
1074                 return res;
1075
1076         /* Remove devices instantiated from sysfs */
1077         mutex_lock_nested(&adap->userspace_clients_lock,
1078                           i2c_adapter_depth(adap));
1079         list_for_each_entry_safe(client, next, &adap->userspace_clients,
1080                                  detected) {
1081                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1082                         client->addr);
1083                 list_del(&client->detected);
1084                 i2c_unregister_device(client);
1085         }
1086         mutex_unlock(&adap->userspace_clients_lock);
1087
1088         /* Detach any active clients. This can't fail, thus we do not
1089          * check the returned value. This is a two-pass process, because
1090          * we can't remove the dummy devices during the first pass: they
1091          * could have been instantiated by real devices wishing to clean
1092          * them up properly, so we give them a chance to do that first. */
1093         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1094         res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1095
1096 #ifdef CONFIG_I2C_COMPAT
1097         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1098                                  adap->dev.parent);
1099 #endif
1100
1101         /* device name is gone after device_unregister */
1102         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1103
1104         /* clean up the sysfs representation */
1105         init_completion(&adap->dev_released);
1106         device_unregister(&adap->dev);
1107
1108         /* wait for sysfs to drop all references */
1109         wait_for_completion(&adap->dev_released);
1110
1111         /* free bus id */
1112         mutex_lock(&core_lock);
1113         idr_remove(&i2c_adapter_idr, adap->nr);
1114         mutex_unlock(&core_lock);
1115
1116         /* Clear the device structure in case this adapter is ever going to be
1117            added again */
1118         memset(&adap->dev, 0, sizeof(adap->dev));
1119
1120         return 0;
1121 }
1122 EXPORT_SYMBOL(i2c_del_adapter);
1123
1124
1125 /* ------------------------------------------------------------------------- */
1126
1127 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1128 {
1129         int res;
1130
1131         mutex_lock(&core_lock);
1132         res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1133         mutex_unlock(&core_lock);
1134
1135         return res;
1136 }
1137 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1138
1139 static int __process_new_driver(struct device *dev, void *data)
1140 {
1141         if (dev->type != &i2c_adapter_type)
1142                 return 0;
1143         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1144 }
1145
1146 /*
1147  * An i2c_driver is used with one or more i2c_client (device) nodes to access
1148  * i2c slave chips, on a bus instance associated with some i2c_adapter.
1149  */
1150
1151 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1152 {
1153         int res;
1154
1155         /* Can't register until after driver model init */
1156         if (unlikely(WARN_ON(!i2c_bus_type.p)))
1157                 return -EAGAIN;
1158
1159         /* add the driver to the list of i2c drivers in the driver core */
1160         driver->driver.owner = owner;
1161         driver->driver.bus = &i2c_bus_type;
1162
1163         /* When registration returns, the driver core
1164          * will have called probe() for all matching-but-unbound devices.
1165          */
1166         res = driver_register(&driver->driver);
1167         if (res)
1168                 return res;
1169
1170         /* Drivers should switch to dev_pm_ops instead. */
1171         if (driver->suspend)
1172                 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1173                         driver->driver.name);
1174         if (driver->resume)
1175                 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1176                         driver->driver.name);
1177
1178         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1179
1180         INIT_LIST_HEAD(&driver->clients);
1181         /* Walk the adapters that are already present */
1182         i2c_for_each_dev(driver, __process_new_driver);
1183
1184         return 0;
1185 }
1186 EXPORT_SYMBOL(i2c_register_driver);
1187
1188 static int __process_removed_driver(struct device *dev, void *data)
1189 {
1190         if (dev->type != &i2c_adapter_type)
1191                 return 0;
1192         return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1193 }
1194
1195 /**
1196  * i2c_del_driver - unregister I2C driver
1197  * @driver: the driver being unregistered
1198  * Context: can sleep
1199  */
1200 void i2c_del_driver(struct i2c_driver *driver)
1201 {
1202         i2c_for_each_dev(driver, __process_removed_driver);
1203
1204         driver_unregister(&driver->driver);
1205         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1206 }
1207 EXPORT_SYMBOL(i2c_del_driver);
1208
1209 /* ------------------------------------------------------------------------- */
1210
1211 /**
1212  * i2c_use_client - increments the reference count of the i2c client structure
1213  * @client: the client being referenced
1214  *
1215  * Each live reference to a client should be refcounted. The driver model does
1216  * that automatically as part of driver binding, so that most drivers don't
1217  * need to do this explicitly: they hold a reference until they're unbound
1218  * from the device.
1219  *
1220  * A pointer to the client with the incremented reference counter is returned.
1221  */
1222 struct i2c_client *i2c_use_client(struct i2c_client *client)
1223 {
1224         if (client && get_device(&client->dev))
1225                 return client;
1226         return NULL;
1227 }
1228 EXPORT_SYMBOL(i2c_use_client);
1229
1230 /**
1231  * i2c_release_client - release a use of the i2c client structure
1232  * @client: the client being no longer referenced
1233  *
1234  * Must be called when a user of a client is finished with it.
1235  */
1236 void i2c_release_client(struct i2c_client *client)
1237 {
1238         if (client)
1239                 put_device(&client->dev);
1240 }
1241 EXPORT_SYMBOL(i2c_release_client);
1242
1243 struct i2c_cmd_arg {
1244         unsigned        cmd;
1245         void            *arg;
1246 };
1247
1248 static int i2c_cmd(struct device *dev, void *_arg)
1249 {
1250         struct i2c_client       *client = i2c_verify_client(dev);
1251         struct i2c_cmd_arg      *arg = _arg;
1252
1253         if (client && client->driver && client->driver->command)
1254                 client->driver->command(client, arg->cmd, arg->arg);
1255         return 0;
1256 }
1257
1258 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1259 {
1260         struct i2c_cmd_arg      cmd_arg;
1261
1262         cmd_arg.cmd = cmd;
1263         cmd_arg.arg = arg;
1264         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1265 }
1266 EXPORT_SYMBOL(i2c_clients_command);
1267
1268 static int __init i2c_init(void)
1269 {
1270         int retval;
1271
1272         retval = bus_register(&i2c_bus_type);
1273         if (retval)
1274                 return retval;
1275 #ifdef CONFIG_I2C_COMPAT
1276         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1277         if (!i2c_adapter_compat_class) {
1278                 retval = -ENOMEM;
1279                 goto bus_err;
1280         }
1281 #endif
1282         retval = i2c_add_driver(&dummy_driver);
1283         if (retval)
1284                 goto class_err;
1285         return 0;
1286
1287 class_err:
1288 #ifdef CONFIG_I2C_COMPAT
1289         class_compat_unregister(i2c_adapter_compat_class);
1290 bus_err:
1291 #endif
1292         bus_unregister(&i2c_bus_type);
1293         return retval;
1294 }
1295
1296 static void __exit i2c_exit(void)
1297 {
1298         i2c_del_driver(&dummy_driver);
1299 #ifdef CONFIG_I2C_COMPAT
1300         class_compat_unregister(i2c_adapter_compat_class);
1301 #endif
1302         bus_unregister(&i2c_bus_type);
1303 }
1304
1305 /* We must initialize early, because some subsystems register i2c drivers
1306  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1307  */
1308 postcore_initcall(i2c_init);
1309 module_exit(i2c_exit);
1310
1311 /* ----------------------------------------------------
1312  * the functional interface to the i2c busses.
1313  * ----------------------------------------------------
1314  */
1315
1316 /**
1317  * __i2c_transfer - unlocked flavor of i2c_transfer
1318  * @adap: Handle to I2C bus
1319  * @msgs: One or more messages to execute before STOP is issued to
1320  *      terminate the operation; each message begins with a START.
1321  * @num: Number of messages to be executed.
1322  *
1323  * Returns negative errno, else the number of messages executed.
1324  *
1325  * Adapter lock must be held when calling this function. No debug logging
1326  * takes place. adap->algo->master_xfer existence isn't checked.
1327  */
1328 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1329 {
1330         unsigned long orig_jiffies;
1331         int ret, try;
1332
1333         /* Retry automatically on arbitration loss */
1334         orig_jiffies = jiffies;
1335         for (ret = 0, try = 0; try <= adap->retries; try++) {
1336                 ret = adap->algo->master_xfer(adap, msgs, num);
1337                 if (ret != -EAGAIN)
1338                         break;
1339                 if (time_after(jiffies, orig_jiffies + adap->timeout))
1340                         break;
1341         }
1342
1343         return ret;
1344 }
1345 EXPORT_SYMBOL(__i2c_transfer);
1346
1347 /**
1348  * i2c_transfer - execute a single or combined I2C message
1349  * @adap: Handle to I2C bus
1350  * @msgs: One or more messages to execute before STOP is issued to
1351  *      terminate the operation; each message begins with a START.
1352  * @num: Number of messages to be executed.
1353  *
1354  * Returns negative errno, else the number of messages executed.
1355  *
1356  * Note that there is no requirement that each message be sent to
1357  * the same slave address, although that is the most common model.
1358  */
1359 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1360 {
1361         int ret;
1362
1363         /* REVISIT the fault reporting model here is weak:
1364          *
1365          *  - When we get an error after receiving N bytes from a slave,
1366          *    there is no way to report "N".
1367          *
1368          *  - When we get a NAK after transmitting N bytes to a slave,
1369          *    there is no way to report "N" ... or to let the master
1370          *    continue executing the rest of this combined message, if
1371          *    that's the appropriate response.
1372          *
1373          *  - When for example "num" is two and we successfully complete
1374          *    the first message but get an error part way through the
1375          *    second, it's unclear whether that should be reported as
1376          *    one (discarding status on the second message) or errno
1377          *    (discarding status on the first one).
1378          */
1379
1380         if (adap->algo->master_xfer) {
1381 #ifdef DEBUG
1382                 for (ret = 0; ret < num; ret++) {
1383                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1384                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1385                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1386                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1387                 }
1388 #endif
1389
1390                 if (in_atomic() || irqs_disabled()) {
1391                         ret = i2c_trylock_adapter(adap);
1392                         if (!ret)
1393                                 /* I2C activity is ongoing. */
1394                                 return -EAGAIN;
1395                 } else {
1396                         i2c_lock_adapter(adap);
1397                 }
1398
1399                 ret = __i2c_transfer(adap, msgs, num);
1400                 i2c_unlock_adapter(adap);
1401
1402                 return ret;
1403         } else {
1404                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1405                 return -EOPNOTSUPP;
1406         }
1407 }
1408 EXPORT_SYMBOL(i2c_transfer);
1409
1410 /**
1411  * i2c_master_send - issue a single I2C message in master transmit mode
1412  * @client: Handle to slave device
1413  * @buf: Data that will be written to the slave
1414  * @count: How many bytes to write, must be less than 64k since msg.len is u16
1415  *
1416  * Returns negative errno, or else the number of bytes written.
1417  */
1418 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1419 {
1420         int ret;
1421         struct i2c_adapter *adap = client->adapter;
1422         struct i2c_msg msg;
1423
1424         msg.addr = client->addr;
1425         msg.flags = client->flags & I2C_M_TEN;
1426         msg.len = count;
1427         msg.buf = (char *)buf;
1428
1429         ret = i2c_transfer(adap, &msg, 1);
1430
1431         /*
1432          * If everything went ok (i.e. 1 msg transmitted), return #bytes
1433          * transmitted, else error code.
1434          */
1435         return (ret == 1) ? count : ret;
1436 }
1437 EXPORT_SYMBOL(i2c_master_send);
1438
1439 /**
1440  * i2c_master_recv - issue a single I2C message in master receive mode
1441  * @client: Handle to slave device
1442  * @buf: Where to store data read from slave
1443  * @count: How many bytes to read, must be less than 64k since msg.len is u16
1444  *
1445  * Returns negative errno, or else the number of bytes read.
1446  */
1447 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1448 {
1449         struct i2c_adapter *adap = client->adapter;
1450         struct i2c_msg msg;
1451         int ret;
1452
1453         msg.addr = client->addr;
1454         msg.flags = client->flags & I2C_M_TEN;
1455         msg.flags |= I2C_M_RD;
1456         msg.len = count;
1457         msg.buf = buf;
1458
1459         ret = i2c_transfer(adap, &msg, 1);
1460
1461         /*
1462          * If everything went ok (i.e. 1 msg received), return #bytes received,
1463          * else error code.
1464          */
1465         return (ret == 1) ? count : ret;
1466 }
1467 EXPORT_SYMBOL(i2c_master_recv);
1468
1469 /* ----------------------------------------------------
1470  * the i2c address scanning function
1471  * Will not work for 10-bit addresses!
1472  * ----------------------------------------------------
1473  */
1474
1475 /*
1476  * Legacy default probe function, mostly relevant for SMBus. The default
1477  * probe method is a quick write, but it is known to corrupt the 24RF08
1478  * EEPROMs due to a state machine bug, and could also irreversibly
1479  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1480  * we use a short byte read instead. Also, some bus drivers don't implement
1481  * quick write, so we fallback to a byte read in that case too.
1482  * On x86, there is another special case for FSC hardware monitoring chips,
1483  * which want regular byte reads (address 0x73.) Fortunately, these are the
1484  * only known chips using this I2C address on PC hardware.
1485  * Returns 1 if probe succeeded, 0 if not.
1486  */
1487 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1488 {
1489         int err;
1490         union i2c_smbus_data dummy;
1491
1492 #ifdef CONFIG_X86
1493         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1494          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1495                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1496                                      I2C_SMBUS_BYTE_DATA, &dummy);
1497         else
1498 #endif
1499         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1500          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1501                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1502                                      I2C_SMBUS_QUICK, NULL);
1503         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1504                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1505                                      I2C_SMBUS_BYTE, &dummy);
1506         else {
1507                 dev_warn(&adap->dev, "No suitable probing method supported\n");
1508                 err = -EOPNOTSUPP;
1509         }
1510
1511         return err >= 0;
1512 }
1513
1514 static int i2c_detect_address(struct i2c_client *temp_client,
1515                               struct i2c_driver *driver)
1516 {
1517         struct i2c_board_info info;
1518         struct i2c_adapter *adapter = temp_client->adapter;
1519         int addr = temp_client->addr;
1520         int err;
1521
1522         /* Make sure the address is valid */
1523         err = i2c_check_addr_validity(addr);
1524         if (err) {
1525                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1526                          addr);
1527                 return err;
1528         }
1529
1530         /* Skip if already in use */
1531         if (i2c_check_addr_busy(adapter, addr))
1532                 return 0;
1533
1534         /* Make sure there is something at this address */
1535         if (!i2c_default_probe(adapter, addr))
1536                 return 0;
1537
1538         /* Finally call the custom detection function */
1539         memset(&info, 0, sizeof(struct i2c_board_info));
1540         info.addr = addr;
1541         err = driver->detect(temp_client, &info);
1542         if (err) {
1543                 /* -ENODEV is returned if the detection fails. We catch it
1544                    here as this isn't an error. */
1545                 return err == -ENODEV ? 0 : err;
1546         }
1547
1548         /* Consistency check */
1549         if (info.type[0] == '\0') {
1550                 dev_err(&adapter->dev, "%s detection function provided "
1551                         "no name for 0x%x\n", driver->driver.name,
1552                         addr);
1553         } else {
1554                 struct i2c_client *client;
1555
1556                 /* Detection succeeded, instantiate the device */
1557                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1558                         info.type, info.addr);
1559                 client = i2c_new_device(adapter, &info);
1560                 if (client)
1561                         list_add_tail(&client->detected, &driver->clients);
1562                 else
1563                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1564                                 info.type, info.addr);
1565         }
1566         return 0;
1567 }
1568
1569 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1570 {
1571         const unsigned short *address_list;
1572         struct i2c_client *temp_client;
1573         int i, err = 0;
1574         int adap_id = i2c_adapter_id(adapter);
1575
1576         address_list = driver->address_list;
1577         if (!driver->detect || !address_list)
1578                 return 0;
1579
1580         /* Stop here if the classes do not match */
1581         if (!(adapter->class & driver->class))
1582                 return 0;
1583
1584         /* Set up a temporary client to help detect callback */
1585         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1586         if (!temp_client)
1587                 return -ENOMEM;
1588         temp_client->adapter = adapter;
1589
1590         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1591                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1592                         "addr 0x%02x\n", adap_id, address_list[i]);
1593                 temp_client->addr = address_list[i];
1594                 err = i2c_detect_address(temp_client, driver);
1595                 if (unlikely(err))
1596                         break;
1597         }
1598
1599         kfree(temp_client);
1600         return err;
1601 }
1602
1603 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1604 {
1605         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1606                               I2C_SMBUS_QUICK, NULL) >= 0;
1607 }
1608 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1609
1610 struct i2c_client *
1611 i2c_new_probed_device(struct i2c_adapter *adap,
1612                       struct i2c_board_info *info,
1613                       unsigned short const *addr_list,
1614                       int (*probe)(struct i2c_adapter *, unsigned short addr))
1615 {
1616         int i;
1617
1618         if (!probe)
1619                 probe = i2c_default_probe;
1620
1621         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1622                 /* Check address validity */
1623                 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1624                         dev_warn(&adap->dev, "Invalid 7-bit address "
1625                                  "0x%02x\n", addr_list[i]);
1626                         continue;
1627                 }
1628
1629                 /* Check address availability */
1630                 if (i2c_check_addr_busy(adap, addr_list[i])) {
1631                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1632                                 "use, not probing\n", addr_list[i]);
1633                         continue;
1634                 }
1635
1636                 /* Test address responsiveness */
1637                 if (probe(adap, addr_list[i]))
1638                         break;
1639         }
1640
1641         if (addr_list[i] == I2C_CLIENT_END) {
1642                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1643                 return NULL;
1644         }
1645
1646         info->addr = addr_list[i];
1647         return i2c_new_device(adap, info);
1648 }
1649 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1650
1651 struct i2c_adapter *i2c_get_adapter(int nr)
1652 {
1653         struct i2c_adapter *adapter;
1654
1655         mutex_lock(&core_lock);
1656         adapter = idr_find(&i2c_adapter_idr, nr);
1657         if (adapter && !try_module_get(adapter->owner))
1658                 adapter = NULL;
1659
1660         mutex_unlock(&core_lock);
1661         return adapter;
1662 }
1663 EXPORT_SYMBOL(i2c_get_adapter);
1664
1665 void i2c_put_adapter(struct i2c_adapter *adap)
1666 {
1667         module_put(adap->owner);
1668 }
1669 EXPORT_SYMBOL(i2c_put_adapter);
1670
1671 /* The SMBus parts */
1672
1673 #define POLY    (0x1070U << 3)
1674 static u8 crc8(u16 data)
1675 {
1676         int i;
1677
1678         for (i = 0; i < 8; i++) {
1679                 if (data & 0x8000)
1680                         data = data ^ POLY;
1681                 data = data << 1;
1682         }
1683         return (u8)(data >> 8);
1684 }
1685
1686 /* Incremental CRC8 over count bytes in the array pointed to by p */
1687 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1688 {
1689         int i;
1690
1691         for (i = 0; i < count; i++)
1692                 crc = crc8((crc ^ p[i]) << 8);
1693         return crc;
1694 }
1695
1696 /* Assume a 7-bit address, which is reasonable for SMBus */
1697 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1698 {
1699         /* The address will be sent first */
1700         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1701         pec = i2c_smbus_pec(pec, &addr, 1);
1702
1703         /* The data buffer follows */
1704         return i2c_smbus_pec(pec, msg->buf, msg->len);
1705 }
1706
1707 /* Used for write only transactions */
1708 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1709 {
1710         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1711         msg->len++;
1712 }
1713
1714 /* Return <0 on CRC error
1715    If there was a write before this read (most cases) we need to take the
1716    partial CRC from the write part into account.
1717    Note that this function does modify the message (we need to decrease the
1718    message length to hide the CRC byte from the caller). */
1719 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1720 {
1721         u8 rpec = msg->buf[--msg->len];
1722         cpec = i2c_smbus_msg_pec(cpec, msg);
1723
1724         if (rpec != cpec) {
1725                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1726                         rpec, cpec);
1727                 return -EBADMSG;
1728         }
1729         return 0;
1730 }
1731
1732 /**
1733  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1734  * @client: Handle to slave device
1735  *
1736  * This executes the SMBus "receive byte" protocol, returning negative errno
1737  * else the byte received from the device.
1738  */
1739 s32 i2c_smbus_read_byte(const struct i2c_client *client)
1740 {
1741         union i2c_smbus_data data;
1742         int status;
1743
1744         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1745                                 I2C_SMBUS_READ, 0,
1746                                 I2C_SMBUS_BYTE, &data);
1747         return (status < 0) ? status : data.byte;
1748 }
1749 EXPORT_SYMBOL(i2c_smbus_read_byte);
1750
1751 /**
1752  * i2c_smbus_write_byte - SMBus "send byte" protocol
1753  * @client: Handle to slave device
1754  * @value: Byte to be sent
1755  *
1756  * This executes the SMBus "send byte" protocol, returning negative errno
1757  * else zero on success.
1758  */
1759 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1760 {
1761         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1762                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1763 }
1764 EXPORT_SYMBOL(i2c_smbus_write_byte);
1765
1766 /**
1767  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1768  * @client: Handle to slave device
1769  * @command: Byte interpreted by slave
1770  *
1771  * This executes the SMBus "read byte" protocol, returning negative errno
1772  * else a data byte received from the device.
1773  */
1774 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1775 {
1776         union i2c_smbus_data data;
1777         int status;
1778
1779         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1780                                 I2C_SMBUS_READ, command,
1781                                 I2C_SMBUS_BYTE_DATA, &data);
1782         return (status < 0) ? status : data.byte;
1783 }
1784 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1785
1786 /**
1787  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1788  * @client: Handle to slave device
1789  * @command: Byte interpreted by slave
1790  * @value: Byte being written
1791  *
1792  * This executes the SMBus "write byte" protocol, returning negative errno
1793  * else zero on success.
1794  */
1795 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1796                               u8 value)
1797 {
1798         union i2c_smbus_data data;
1799         data.byte = value;
1800         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1801                               I2C_SMBUS_WRITE, command,
1802                               I2C_SMBUS_BYTE_DATA, &data);
1803 }
1804 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1805
1806 /**
1807  * i2c_smbus_read_word_data - SMBus "read word" protocol
1808  * @client: Handle to slave device
1809  * @command: Byte interpreted by slave
1810  *
1811  * This executes the SMBus "read word" protocol, returning negative errno
1812  * else a 16-bit unsigned "word" received from the device.
1813  */
1814 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
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_WORD_DATA, &data);
1822         return (status < 0) ? status : data.word;
1823 }
1824 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1825
1826 /**
1827  * i2c_smbus_write_word_data - SMBus "write word" protocol
1828  * @client: Handle to slave device
1829  * @command: Byte interpreted by slave
1830  * @value: 16-bit "word" being written
1831  *
1832  * This executes the SMBus "write word" protocol, returning negative errno
1833  * else zero on success.
1834  */
1835 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1836                               u16 value)
1837 {
1838         union i2c_smbus_data data;
1839         data.word = value;
1840         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1841                               I2C_SMBUS_WRITE, command,
1842                               I2C_SMBUS_WORD_DATA, &data);
1843 }
1844 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1845
1846 /**
1847  * i2c_smbus_read_block_data - SMBus "block read" protocol
1848  * @client: Handle to slave device
1849  * @command: Byte interpreted by slave
1850  * @values: Byte array into which data will be read; big enough to hold
1851  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1852  *
1853  * This executes the SMBus "block read" protocol, returning negative errno
1854  * else the number of data bytes in the slave's response.
1855  *
1856  * Note that using this function requires that the client's adapter support
1857  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1858  * support this; its emulation through I2C messaging relies on a specific
1859  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1860  */
1861 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1862                               u8 *values)
1863 {
1864         union i2c_smbus_data data;
1865         int status;
1866
1867         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1868                                 I2C_SMBUS_READ, command,
1869                                 I2C_SMBUS_BLOCK_DATA, &data);
1870         if (status)
1871                 return status;
1872
1873         memcpy(values, &data.block[1], data.block[0]);
1874         return data.block[0];
1875 }
1876 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1877
1878 /**
1879  * i2c_smbus_write_block_data - SMBus "block write" protocol
1880  * @client: Handle to slave device
1881  * @command: Byte interpreted by slave
1882  * @length: Size of data block; SMBus allows at most 32 bytes
1883  * @values: Byte array which will be written.
1884  *
1885  * This executes the SMBus "block write" protocol, returning negative errno
1886  * else zero on success.
1887  */
1888 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1889                                u8 length, const u8 *values)
1890 {
1891         union i2c_smbus_data data;
1892
1893         if (length > I2C_SMBUS_BLOCK_MAX)
1894                 length = I2C_SMBUS_BLOCK_MAX;
1895         data.block[0] = length;
1896         memcpy(&data.block[1], values, length);
1897         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1898                               I2C_SMBUS_WRITE, command,
1899                               I2C_SMBUS_BLOCK_DATA, &data);
1900 }
1901 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1902
1903 /* Returns the number of read bytes */
1904 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1905                                   u8 length, u8 *values)
1906 {
1907         union i2c_smbus_data data;
1908         int status;
1909
1910         if (length > I2C_SMBUS_BLOCK_MAX)
1911                 length = I2C_SMBUS_BLOCK_MAX;
1912         data.block[0] = length;
1913         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1914                                 I2C_SMBUS_READ, command,
1915                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1916         if (status < 0)
1917                 return status;
1918
1919         memcpy(values, &data.block[1], data.block[0]);
1920         return data.block[0];
1921 }
1922 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1923
1924 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1925                                    u8 length, const u8 *values)
1926 {
1927         union i2c_smbus_data data;
1928
1929         if (length > I2C_SMBUS_BLOCK_MAX)
1930                 length = I2C_SMBUS_BLOCK_MAX;
1931         data.block[0] = length;
1932         memcpy(data.block + 1, values, length);
1933         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1934                               I2C_SMBUS_WRITE, command,
1935                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1936 }
1937 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1938
1939 /* Simulate a SMBus command using the i2c protocol
1940    No checking of parameters is done!  */
1941 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1942                                    unsigned short flags,
1943                                    char read_write, u8 command, int size,
1944                                    union i2c_smbus_data *data)
1945 {
1946         /* So we need to generate a series of msgs. In the case of writing, we
1947           need to use only one message; when reading, we need two. We initialize
1948           most things with sane defaults, to keep the code below somewhat
1949           simpler. */
1950         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1951         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1952         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1953         int i;
1954         u8 partial_pec = 0;
1955         int status;
1956         struct i2c_msg msg[2] = {
1957                 {
1958                         .addr = addr,
1959                         .flags = flags,
1960                         .len = 1,
1961                         .buf = msgbuf0,
1962                 }, {
1963                         .addr = addr,
1964                         .flags = flags | I2C_M_RD,
1965                         .len = 0,
1966                         .buf = msgbuf1,
1967                 },
1968         };
1969
1970         msgbuf0[0] = command;
1971         switch (size) {
1972         case I2C_SMBUS_QUICK:
1973                 msg[0].len = 0;
1974                 /* Special case: The read/write field is used as data */
1975                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1976                                         I2C_M_RD : 0);
1977                 num = 1;
1978                 break;
1979         case I2C_SMBUS_BYTE:
1980                 if (read_write == I2C_SMBUS_READ) {
1981                         /* Special case: only a read! */
1982                         msg[0].flags = I2C_M_RD | flags;
1983                         num = 1;
1984                 }
1985                 break;
1986         case I2C_SMBUS_BYTE_DATA:
1987                 if (read_write == I2C_SMBUS_READ)
1988                         msg[1].len = 1;
1989                 else {
1990                         msg[0].len = 2;
1991                         msgbuf0[1] = data->byte;
1992                 }
1993                 break;
1994         case I2C_SMBUS_WORD_DATA:
1995                 if (read_write == I2C_SMBUS_READ)
1996                         msg[1].len = 2;
1997                 else {
1998                         msg[0].len = 3;
1999                         msgbuf0[1] = data->word & 0xff;
2000                         msgbuf0[2] = data->word >> 8;
2001                 }
2002                 break;
2003         case I2C_SMBUS_PROC_CALL:
2004                 num = 2; /* Special case */
2005                 read_write = I2C_SMBUS_READ;
2006                 msg[0].len = 3;
2007                 msg[1].len = 2;
2008                 msgbuf0[1] = data->word & 0xff;
2009                 msgbuf0[2] = data->word >> 8;
2010                 break;
2011         case I2C_SMBUS_BLOCK_DATA:
2012                 if (read_write == I2C_SMBUS_READ) {
2013                         msg[1].flags |= I2C_M_RECV_LEN;
2014                         msg[1].len = 1; /* block length will be added by
2015                                            the underlying bus driver */
2016                 } else {
2017                         msg[0].len = data->block[0] + 2;
2018                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2019                                 dev_err(&adapter->dev,
2020                                         "Invalid block write size %d\n",
2021                                         data->block[0]);
2022                                 return -EINVAL;
2023                         }
2024                         for (i = 1; i < msg[0].len; i++)
2025                                 msgbuf0[i] = data->block[i-1];
2026                 }
2027                 break;
2028         case I2C_SMBUS_BLOCK_PROC_CALL:
2029                 num = 2; /* Another special case */
2030                 read_write = I2C_SMBUS_READ;
2031                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2032                         dev_err(&adapter->dev,
2033                                 "Invalid block write size %d\n",
2034                                 data->block[0]);
2035                         return -EINVAL;
2036                 }
2037                 msg[0].len = data->block[0] + 2;
2038                 for (i = 1; i < msg[0].len; i++)
2039                         msgbuf0[i] = data->block[i-1];
2040                 msg[1].flags |= I2C_M_RECV_LEN;
2041                 msg[1].len = 1; /* block length will be added by
2042                                    the underlying bus driver */
2043                 break;
2044         case I2C_SMBUS_I2C_BLOCK_DATA:
2045                 if (read_write == I2C_SMBUS_READ) {
2046                         msg[1].len = data->block[0];
2047                 } else {
2048                         msg[0].len = data->block[0] + 1;
2049                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2050                                 dev_err(&adapter->dev,
2051                                         "Invalid block write size %d\n",
2052                                         data->block[0]);
2053                                 return -EINVAL;
2054                         }
2055                         for (i = 1; i <= data->block[0]; i++)
2056                                 msgbuf0[i] = data->block[i];
2057                 }
2058                 break;
2059         default:
2060                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2061                 return -EOPNOTSUPP;
2062         }
2063
2064         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2065                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
2066         if (i) {
2067                 /* Compute PEC if first message is a write */
2068                 if (!(msg[0].flags & I2C_M_RD)) {
2069                         if (num == 1) /* Write only */
2070                                 i2c_smbus_add_pec(&msg[0]);
2071                         else /* Write followed by read */
2072                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2073                 }
2074                 /* Ask for PEC if last message is a read */
2075                 if (msg[num-1].flags & I2C_M_RD)
2076                         msg[num-1].len++;
2077         }
2078
2079         status = i2c_transfer(adapter, msg, num);
2080         if (status < 0)
2081                 return status;
2082
2083         /* Check PEC if last message is a read */
2084         if (i && (msg[num-1].flags & I2C_M_RD)) {
2085                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2086                 if (status < 0)
2087                         return status;
2088         }
2089
2090         if (read_write == I2C_SMBUS_READ)
2091                 switch (size) {
2092                 case I2C_SMBUS_BYTE:
2093                         data->byte = msgbuf0[0];
2094                         break;
2095                 case I2C_SMBUS_BYTE_DATA:
2096                         data->byte = msgbuf1[0];
2097                         break;
2098                 case I2C_SMBUS_WORD_DATA:
2099                 case I2C_SMBUS_PROC_CALL:
2100                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2101                         break;
2102                 case I2C_SMBUS_I2C_BLOCK_DATA:
2103                         for (i = 0; i < data->block[0]; i++)
2104                                 data->block[i+1] = msgbuf1[i];
2105                         break;
2106                 case I2C_SMBUS_BLOCK_DATA:
2107                 case I2C_SMBUS_BLOCK_PROC_CALL:
2108                         for (i = 0; i < msgbuf1[0] + 1; i++)
2109                                 data->block[i] = msgbuf1[i];
2110                         break;
2111                 }
2112         return 0;
2113 }
2114
2115 /**
2116  * i2c_smbus_xfer - execute SMBus protocol operations
2117  * @adapter: Handle to I2C bus
2118  * @addr: Address of SMBus slave on that bus
2119  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2120  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2121  * @command: Byte interpreted by slave, for protocols which use such bytes
2122  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2123  * @data: Data to be read or written
2124  *
2125  * This executes an SMBus protocol operation, and returns a negative
2126  * errno code else zero on success.
2127  */
2128 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2129                    char read_write, u8 command, int protocol,
2130                    union i2c_smbus_data *data)
2131 {
2132         unsigned long orig_jiffies;
2133         int try;
2134         s32 res;
2135
2136         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2137
2138         if (adapter->algo->smbus_xfer) {
2139                 i2c_lock_adapter(adapter);
2140
2141                 /* Retry automatically on arbitration loss */
2142                 orig_jiffies = jiffies;
2143                 for (res = 0, try = 0; try <= adapter->retries; try++) {
2144                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
2145                                                         read_write, command,
2146                                                         protocol, data);
2147                         if (res != -EAGAIN)
2148                                 break;
2149                         if (time_after(jiffies,
2150                                        orig_jiffies + adapter->timeout))
2151                                 break;
2152                 }
2153                 i2c_unlock_adapter(adapter);
2154
2155                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2156                         return res;
2157                 /*
2158                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2159                  * implement native support for the SMBus operation.
2160                  */
2161         }
2162
2163         return i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2164                                        command, protocol, data);
2165 }
2166 EXPORT_SYMBOL(i2c_smbus_xfer);
2167
2168 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2169 MODULE_DESCRIPTION("I2C-Bus main module");
2170 MODULE_LICENSE("GPL");