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