1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/module.h>
29#include <linux/kernel.h>
30#include <linux/delay.h>
31#include <linux/errno.h>
32#include <linux/gpio.h>
33#include <linux/slab.h>
34#include <linux/i2c.h>
35#include <linux/init.h>
36#include <linux/idr.h>
37#include <linux/mutex.h>
38#include <linux/of_device.h>
39#include <linux/completion.h>
40#include <linux/hardirq.h>
41#include <linux/irqflags.h>
42#include <linux/rwsem.h>
43#include <linux/pm_runtime.h>
44#include <linux/acpi.h>
45#include <asm/uaccess.h>
46
47#include "i2c-core.h"
48
49
50
51
52
53static DEFINE_MUTEX(core_lock);
54static DEFINE_IDR(i2c_adapter_idr);
55
56static struct device_type i2c_client_type;
57static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
58
59
60
61static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
62 const struct i2c_client *client)
63{
64 while (id->name[0]) {
65 if (strcmp(client->name, id->name) == 0)
66 return id;
67 id++;
68 }
69 return NULL;
70}
71
72static int i2c_device_match(struct device *dev, struct device_driver *drv)
73{
74 struct i2c_client *client = i2c_verify_client(dev);
75 struct i2c_driver *driver;
76
77 if (!client)
78 return 0;
79
80
81 if (of_driver_match_device(dev, drv))
82 return 1;
83
84
85 if (acpi_driver_match_device(dev, drv))
86 return 1;
87
88 driver = to_i2c_driver(drv);
89
90 if (driver->id_table)
91 return i2c_match_id(driver->id_table, client) != NULL;
92
93 return 0;
94}
95
96
97
98static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
99{
100 struct i2c_client *client = to_i2c_client(dev);
101
102 if (add_uevent_var(env, "MODALIAS=%s%s",
103 I2C_MODULE_PREFIX, client->name))
104 return -ENOMEM;
105 dev_dbg(dev, "uevent\n");
106 return 0;
107}
108
109
110static int get_scl_gpio_value(struct i2c_adapter *adap)
111{
112 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
113}
114
115static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
116{
117 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
118}
119
120static int get_sda_gpio_value(struct i2c_adapter *adap)
121{
122 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
123}
124
125static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
126{
127 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
128 struct device *dev = &adap->dev;
129 int ret = 0;
130
131 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
132 GPIOF_OUT_INIT_HIGH, "i2c-scl");
133 if (ret) {
134 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
135 return ret;
136 }
137
138 if (bri->get_sda) {
139 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
140
141 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
142 bri->sda_gpio);
143 bri->get_sda = NULL;
144 }
145 }
146
147 return ret;
148}
149
150static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
151{
152 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
153
154 if (bri->get_sda)
155 gpio_free(bri->sda_gpio);
156
157 gpio_free(bri->scl_gpio);
158}
159
160
161
162
163
164
165#define RECOVERY_NDELAY 5000
166#define RECOVERY_CLK_CNT 9
167
168static int i2c_generic_recovery(struct i2c_adapter *adap)
169{
170 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
171 int i = 0, val = 1, ret = 0;
172
173 if (bri->prepare_recovery)
174 bri->prepare_recovery(bri);
175
176
177
178
179 while (i++ < RECOVERY_CLK_CNT * 2) {
180 if (val) {
181
182 if (bri->get_sda && bri->get_sda(adap))
183 break;
184
185 if (!bri->get_scl(adap)) {
186 dev_err(&adap->dev,
187 "SCL is stuck low, exit recovery\n");
188 ret = -EBUSY;
189 break;
190 }
191 }
192
193 val = !val;
194 bri->set_scl(adap, val);
195 ndelay(RECOVERY_NDELAY);
196 }
197
198 if (bri->unprepare_recovery)
199 bri->unprepare_recovery(bri);
200
201 return ret;
202}
203
204int i2c_generic_scl_recovery(struct i2c_adapter *adap)
205{
206 adap->bus_recovery_info->set_scl(adap, 1);
207 return i2c_generic_recovery(adap);
208}
209
210int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
211{
212 int ret;
213
214 ret = i2c_get_gpios_for_recovery(adap);
215 if (ret)
216 return ret;
217
218 ret = i2c_generic_recovery(adap);
219 i2c_put_gpios_for_recovery(adap);
220
221 return ret;
222}
223
224int i2c_recover_bus(struct i2c_adapter *adap)
225{
226 if (!adap->bus_recovery_info)
227 return -EOPNOTSUPP;
228
229 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
230 return adap->bus_recovery_info->recover_bus(adap);
231}
232
233static int i2c_device_probe(struct device *dev)
234{
235 struct i2c_client *client = i2c_verify_client(dev);
236 struct i2c_driver *driver;
237 int status;
238
239 if (!client)
240 return 0;
241
242 driver = to_i2c_driver(dev->driver);
243 if (!driver->probe || !driver->id_table)
244 return -ENODEV;
245 client->driver = driver;
246 if (!device_can_wakeup(&client->dev))
247 device_init_wakeup(&client->dev,
248 client->flags & I2C_CLIENT_WAKE);
249 dev_dbg(dev, "probe\n");
250
251 status = driver->probe(client, i2c_match_id(driver->id_table, client));
252 if (status) {
253 client->driver = NULL;
254 i2c_set_clientdata(client, NULL);
255 }
256 return status;
257}
258
259static int i2c_device_remove(struct device *dev)
260{
261 struct i2c_client *client = i2c_verify_client(dev);
262 struct i2c_driver *driver;
263 int status;
264
265 if (!client || !dev->driver)
266 return 0;
267
268 driver = to_i2c_driver(dev->driver);
269 if (driver->remove) {
270 dev_dbg(dev, "remove\n");
271 status = driver->remove(client);
272 } else {
273 dev->driver = NULL;
274 status = 0;
275 }
276 if (status == 0) {
277 client->driver = NULL;
278 i2c_set_clientdata(client, NULL);
279 }
280 return status;
281}
282
283static void i2c_device_shutdown(struct device *dev)
284{
285 struct i2c_client *client = i2c_verify_client(dev);
286 struct i2c_driver *driver;
287
288 if (!client || !dev->driver)
289 return;
290 driver = to_i2c_driver(dev->driver);
291 if (driver->shutdown)
292 driver->shutdown(client);
293}
294
295#ifdef CONFIG_PM_SLEEP
296static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
297{
298 struct i2c_client *client = i2c_verify_client(dev);
299 struct i2c_driver *driver;
300
301 if (!client || !dev->driver)
302 return 0;
303 driver = to_i2c_driver(dev->driver);
304 if (!driver->suspend)
305 return 0;
306 return driver->suspend(client, mesg);
307}
308
309static int i2c_legacy_resume(struct device *dev)
310{
311 struct i2c_client *client = i2c_verify_client(dev);
312 struct i2c_driver *driver;
313
314 if (!client || !dev->driver)
315 return 0;
316 driver = to_i2c_driver(dev->driver);
317 if (!driver->resume)
318 return 0;
319 return driver->resume(client);
320}
321
322static int i2c_device_pm_suspend(struct device *dev)
323{
324 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
325
326 if (pm)
327 return pm_generic_suspend(dev);
328 else
329 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
330}
331
332static int i2c_device_pm_resume(struct device *dev)
333{
334 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
335
336 if (pm)
337 return pm_generic_resume(dev);
338 else
339 return i2c_legacy_resume(dev);
340}
341
342static int i2c_device_pm_freeze(struct device *dev)
343{
344 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
345
346 if (pm)
347 return pm_generic_freeze(dev);
348 else
349 return i2c_legacy_suspend(dev, PMSG_FREEZE);
350}
351
352static int i2c_device_pm_thaw(struct device *dev)
353{
354 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
355
356 if (pm)
357 return pm_generic_thaw(dev);
358 else
359 return i2c_legacy_resume(dev);
360}
361
362static int i2c_device_pm_poweroff(struct device *dev)
363{
364 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
365
366 if (pm)
367 return pm_generic_poweroff(dev);
368 else
369 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
370}
371
372static int i2c_device_pm_restore(struct device *dev)
373{
374 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
375
376 if (pm)
377 return pm_generic_restore(dev);
378 else
379 return i2c_legacy_resume(dev);
380}
381#else
382#define i2c_device_pm_suspend NULL
383#define i2c_device_pm_resume NULL
384#define i2c_device_pm_freeze NULL
385#define i2c_device_pm_thaw NULL
386#define i2c_device_pm_poweroff NULL
387#define i2c_device_pm_restore NULL
388#endif
389
390static void i2c_client_dev_release(struct device *dev)
391{
392 kfree(to_i2c_client(dev));
393}
394
395static ssize_t
396show_name(struct device *dev, struct device_attribute *attr, char *buf)
397{
398 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
399 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
400}
401
402static ssize_t
403show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
404{
405 struct i2c_client *client = to_i2c_client(dev);
406 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
407}
408
409static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
410static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
411
412static struct attribute *i2c_dev_attrs[] = {
413 &dev_attr_name.attr,
414
415 &dev_attr_modalias.attr,
416 NULL
417};
418
419static struct attribute_group i2c_dev_attr_group = {
420 .attrs = i2c_dev_attrs,
421};
422
423static const struct attribute_group *i2c_dev_attr_groups[] = {
424 &i2c_dev_attr_group,
425 NULL
426};
427
428static const struct dev_pm_ops i2c_device_pm_ops = {
429 .suspend = i2c_device_pm_suspend,
430 .resume = i2c_device_pm_resume,
431 .freeze = i2c_device_pm_freeze,
432 .thaw = i2c_device_pm_thaw,
433 .poweroff = i2c_device_pm_poweroff,
434 .restore = i2c_device_pm_restore,
435 SET_RUNTIME_PM_OPS(
436 pm_generic_runtime_suspend,
437 pm_generic_runtime_resume,
438 pm_generic_runtime_idle
439 )
440};
441
442struct bus_type i2c_bus_type = {
443 .name = "i2c",
444 .match = i2c_device_match,
445 .probe = i2c_device_probe,
446 .remove = i2c_device_remove,
447 .shutdown = i2c_device_shutdown,
448 .pm = &i2c_device_pm_ops,
449};
450EXPORT_SYMBOL_GPL(i2c_bus_type);
451
452static struct device_type i2c_client_type = {
453 .groups = i2c_dev_attr_groups,
454 .uevent = i2c_device_uevent,
455 .release = i2c_client_dev_release,
456};
457
458
459
460
461
462
463
464
465
466
467
468struct i2c_client *i2c_verify_client(struct device *dev)
469{
470 return (dev->type == &i2c_client_type)
471 ? to_i2c_client(dev)
472 : NULL;
473}
474EXPORT_SYMBOL(i2c_verify_client);
475
476
477
478
479static int i2c_check_client_addr_validity(const struct i2c_client *client)
480{
481 if (client->flags & I2C_CLIENT_TEN) {
482
483 if (client->addr > 0x3ff)
484 return -EINVAL;
485 } else {
486
487 if (client->addr == 0x00 || client->addr > 0x7f)
488 return -EINVAL;
489 }
490 return 0;
491}
492
493
494
495
496
497static int i2c_check_addr_validity(unsigned short addr)
498{
499
500
501
502
503
504
505
506
507
508
509 if (addr < 0x08 || addr > 0x77)
510 return -EINVAL;
511 return 0;
512}
513
514static int __i2c_check_addr_busy(struct device *dev, void *addrp)
515{
516 struct i2c_client *client = i2c_verify_client(dev);
517 int addr = *(int *)addrp;
518
519 if (client && client->addr == addr)
520 return -EBUSY;
521 return 0;
522}
523
524
525static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
526{
527 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
528 int result;
529
530 result = device_for_each_child(&adapter->dev, &addr,
531 __i2c_check_addr_busy);
532
533 if (!result && parent)
534 result = i2c_check_mux_parents(parent, addr);
535
536 return result;
537}
538
539
540static int i2c_check_mux_children(struct device *dev, void *addrp)
541{
542 int result;
543
544 if (dev->type == &i2c_adapter_type)
545 result = device_for_each_child(dev, addrp,
546 i2c_check_mux_children);
547 else
548 result = __i2c_check_addr_busy(dev, addrp);
549
550 return result;
551}
552
553static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
554{
555 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
556 int result = 0;
557
558 if (parent)
559 result = i2c_check_mux_parents(parent, addr);
560
561 if (!result)
562 result = device_for_each_child(&adapter->dev, &addr,
563 i2c_check_mux_children);
564
565 return result;
566}
567
568
569
570
571
572void i2c_lock_adapter(struct i2c_adapter *adapter)
573{
574 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
575
576 if (parent)
577 i2c_lock_adapter(parent);
578 else
579 rt_mutex_lock(&adapter->bus_lock);
580}
581EXPORT_SYMBOL_GPL(i2c_lock_adapter);
582
583
584
585
586
587static int i2c_trylock_adapter(struct i2c_adapter *adapter)
588{
589 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
590
591 if (parent)
592 return i2c_trylock_adapter(parent);
593 else
594 return rt_mutex_trylock(&adapter->bus_lock);
595}
596
597
598
599
600
601void i2c_unlock_adapter(struct i2c_adapter *adapter)
602{
603 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
604
605 if (parent)
606 i2c_unlock_adapter(parent);
607 else
608 rt_mutex_unlock(&adapter->bus_lock);
609}
610EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628struct i2c_client *
629i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
630{
631 struct i2c_client *client;
632 int status;
633
634 client = kzalloc(sizeof *client, GFP_KERNEL);
635 if (!client)
636 return NULL;
637
638 client->adapter = adap;
639
640 client->dev.platform_data = info->platform_data;
641
642 if (info->archdata)
643 client->dev.archdata = *info->archdata;
644
645 client->flags = info->flags;
646 client->addr = info->addr;
647 client->irq = info->irq;
648
649 strlcpy(client->name, info->type, sizeof(client->name));
650
651
652 status = i2c_check_client_addr_validity(client);
653 if (status) {
654 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
655 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
656 goto out_err_silent;
657 }
658
659
660 status = i2c_check_addr_busy(adap, client->addr);
661 if (status)
662 goto out_err;
663
664 client->dev.parent = &client->adapter->dev;
665 client->dev.bus = &i2c_bus_type;
666 client->dev.type = &i2c_client_type;
667 client->dev.of_node = info->of_node;
668 ACPI_HANDLE_SET(&client->dev, info->acpi_node.handle);
669
670
671 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
672 client->addr | ((client->flags & I2C_CLIENT_TEN)
673 ? 0xa000 : 0));
674 status = device_register(&client->dev);
675 if (status)
676 goto out_err;
677
678 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
679 client->name, dev_name(&client->dev));
680
681 return client;
682
683out_err:
684 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
685 "(%d)\n", client->name, client->addr, status);
686out_err_silent:
687 kfree(client);
688 return NULL;
689}
690EXPORT_SYMBOL_GPL(i2c_new_device);
691
692
693
694
695
696
697
698void i2c_unregister_device(struct i2c_client *client)
699{
700 device_unregister(&client->dev);
701}
702EXPORT_SYMBOL_GPL(i2c_unregister_device);
703
704
705static const struct i2c_device_id dummy_id[] = {
706 { "dummy", 0 },
707 { },
708};
709
710static int dummy_probe(struct i2c_client *client,
711 const struct i2c_device_id *id)
712{
713 return 0;
714}
715
716static int dummy_remove(struct i2c_client *client)
717{
718 return 0;
719}
720
721static struct i2c_driver dummy_driver = {
722 .driver.name = "dummy",
723 .probe = dummy_probe,
724 .remove = dummy_remove,
725 .id_table = dummy_id,
726};
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
747{
748 struct i2c_board_info info = {
749 I2C_BOARD_INFO("dummy", address),
750 };
751
752 return i2c_new_device(adapter, &info);
753}
754EXPORT_SYMBOL_GPL(i2c_new_dummy);
755
756
757
758
759
760static void i2c_adapter_dev_release(struct device *dev)
761{
762 struct i2c_adapter *adap = to_i2c_adapter(dev);
763 complete(&adap->dev_released);
764}
765
766
767
768
769
770
771
772static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
773{
774 unsigned int depth = 0;
775
776 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
777 depth++;
778
779 return depth;
780}
781
782
783
784
785
786
787
788
789
790
791
792static ssize_t
793i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
794 const char *buf, size_t count)
795{
796 struct i2c_adapter *adap = to_i2c_adapter(dev);
797 struct i2c_board_info info;
798 struct i2c_client *client;
799 char *blank, end;
800 int res;
801
802 memset(&info, 0, sizeof(struct i2c_board_info));
803
804 blank = strchr(buf, ' ');
805 if (!blank) {
806 dev_err(dev, "%s: Missing parameters\n", "new_device");
807 return -EINVAL;
808 }
809 if (blank - buf > I2C_NAME_SIZE - 1) {
810 dev_err(dev, "%s: Invalid device name\n", "new_device");
811 return -EINVAL;
812 }
813 memcpy(info.type, buf, blank - buf);
814
815
816 res = sscanf(++blank, "%hi%c", &info.addr, &end);
817 if (res < 1) {
818 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
819 return -EINVAL;
820 }
821 if (res > 1 && end != '\n') {
822 dev_err(dev, "%s: Extra parameters\n", "new_device");
823 return -EINVAL;
824 }
825
826 client = i2c_new_device(adap, &info);
827 if (!client)
828 return -EINVAL;
829
830
831 mutex_lock(&adap->userspace_clients_lock);
832 list_add_tail(&client->detected, &adap->userspace_clients);
833 mutex_unlock(&adap->userspace_clients_lock);
834 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
835 info.type, info.addr);
836
837 return count;
838}
839
840
841
842
843
844
845
846
847
848
849static ssize_t
850i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
851 const char *buf, size_t count)
852{
853 struct i2c_adapter *adap = to_i2c_adapter(dev);
854 struct i2c_client *client, *next;
855 unsigned short addr;
856 char end;
857 int res;
858
859
860 res = sscanf(buf, "%hi%c", &addr, &end);
861 if (res < 1) {
862 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
863 return -EINVAL;
864 }
865 if (res > 1 && end != '\n') {
866 dev_err(dev, "%s: Extra parameters\n", "delete_device");
867 return -EINVAL;
868 }
869
870
871 res = -ENOENT;
872 mutex_lock_nested(&adap->userspace_clients_lock,
873 i2c_adapter_depth(adap));
874 list_for_each_entry_safe(client, next, &adap->userspace_clients,
875 detected) {
876 if (client->addr == addr) {
877 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
878 "delete_device", client->name, client->addr);
879
880 list_del(&client->detected);
881 i2c_unregister_device(client);
882 res = count;
883 break;
884 }
885 }
886 mutex_unlock(&adap->userspace_clients_lock);
887
888 if (res < 0)
889 dev_err(dev, "%s: Can't find device in list\n",
890 "delete_device");
891 return res;
892}
893
894static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
895static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
896 i2c_sysfs_delete_device);
897
898static struct attribute *i2c_adapter_attrs[] = {
899 &dev_attr_name.attr,
900 &dev_attr_new_device.attr,
901 &dev_attr_delete_device.attr,
902 NULL
903};
904
905static struct attribute_group i2c_adapter_attr_group = {
906 .attrs = i2c_adapter_attrs,
907};
908
909static const struct attribute_group *i2c_adapter_attr_groups[] = {
910 &i2c_adapter_attr_group,
911 NULL
912};
913
914struct device_type i2c_adapter_type = {
915 .groups = i2c_adapter_attr_groups,
916 .release = i2c_adapter_dev_release,
917};
918EXPORT_SYMBOL_GPL(i2c_adapter_type);
919
920
921
922
923
924
925
926
927
928
929struct i2c_adapter *i2c_verify_adapter(struct device *dev)
930{
931 return (dev->type == &i2c_adapter_type)
932 ? to_i2c_adapter(dev)
933 : NULL;
934}
935EXPORT_SYMBOL(i2c_verify_adapter);
936
937#ifdef CONFIG_I2C_COMPAT
938static struct class_compat *i2c_adapter_compat_class;
939#endif
940
941static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
942{
943 struct i2c_devinfo *devinfo;
944
945 down_read(&__i2c_board_lock);
946 list_for_each_entry(devinfo, &__i2c_board_list, list) {
947 if (devinfo->busnum == adapter->nr
948 && !i2c_new_device(adapter,
949 &devinfo->board_info))
950 dev_err(&adapter->dev,
951 "Can't create device at 0x%02x\n",
952 devinfo->board_info.addr);
953 }
954 up_read(&__i2c_board_lock);
955}
956
957static int i2c_do_add_adapter(struct i2c_driver *driver,
958 struct i2c_adapter *adap)
959{
960
961 i2c_detect(adap, driver);
962
963
964 if (driver->attach_adapter) {
965 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
966 driver->driver.name);
967 dev_warn(&adap->dev, "Please use another way to instantiate "
968 "your i2c_client\n");
969
970 driver->attach_adapter(adap);
971 }
972 return 0;
973}
974
975static int __process_new_adapter(struct device_driver *d, void *data)
976{
977 return i2c_do_add_adapter(to_i2c_driver(d), data);
978}
979
980static int i2c_register_adapter(struct i2c_adapter *adap)
981{
982 int res = 0;
983
984
985 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
986 res = -EAGAIN;
987 goto out_list;
988 }
989
990
991 if (unlikely(adap->name[0] == '\0')) {
992 pr_err("i2c-core: Attempt to register an adapter with "
993 "no name!\n");
994 return -EINVAL;
995 }
996 if (unlikely(!adap->algo)) {
997 pr_err("i2c-core: Attempt to register adapter '%s' with "
998 "no algo!\n", adap->name);
999 return -EINVAL;
1000 }
1001
1002 rt_mutex_init(&adap->bus_lock);
1003 mutex_init(&adap->userspace_clients_lock);
1004 INIT_LIST_HEAD(&adap->userspace_clients);
1005
1006
1007 if (adap->timeout == 0)
1008 adap->timeout = HZ;
1009
1010 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1011 adap->dev.bus = &i2c_bus_type;
1012 adap->dev.type = &i2c_adapter_type;
1013 res = device_register(&adap->dev);
1014 if (res)
1015 goto out_list;
1016
1017 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1018
1019#ifdef CONFIG_I2C_COMPAT
1020 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1021 adap->dev.parent);
1022 if (res)
1023 dev_warn(&adap->dev,
1024 "Failed to create compatibility class link\n");
1025#endif
1026
1027
1028 if (adap->bus_recovery_info) {
1029 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1030
1031 if (!bri->recover_bus) {
1032 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1033 adap->bus_recovery_info = NULL;
1034 goto exit_recovery;
1035 }
1036
1037
1038 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1039 if (!gpio_is_valid(bri->scl_gpio)) {
1040 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1041 adap->bus_recovery_info = NULL;
1042 goto exit_recovery;
1043 }
1044
1045 if (gpio_is_valid(bri->sda_gpio))
1046 bri->get_sda = get_sda_gpio_value;
1047 else
1048 bri->get_sda = NULL;
1049
1050 bri->get_scl = get_scl_gpio_value;
1051 bri->set_scl = set_scl_gpio_value;
1052 } else if (!bri->set_scl || !bri->get_scl) {
1053
1054 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1055 adap->bus_recovery_info = NULL;
1056 }
1057 }
1058
1059exit_recovery:
1060
1061 if (adap->nr < __i2c_first_dynamic_bus_num)
1062 i2c_scan_static_board_info(adap);
1063
1064
1065 mutex_lock(&core_lock);
1066 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1067 mutex_unlock(&core_lock);
1068
1069 return 0;
1070
1071out_list:
1072 mutex_lock(&core_lock);
1073 idr_remove(&i2c_adapter_idr, adap->nr);
1074 mutex_unlock(&core_lock);
1075 return res;
1076}
1077
1078
1079
1080
1081
1082
1083
1084
1085static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1086{
1087 int id;
1088
1089 mutex_lock(&core_lock);
1090 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1091 GFP_KERNEL);
1092 mutex_unlock(&core_lock);
1093 if (id < 0)
1094 return id == -ENOSPC ? -EBUSY : id;
1095
1096 return i2c_register_adapter(adap);
1097}
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113int i2c_add_adapter(struct i2c_adapter *adapter)
1114{
1115 struct device *dev = &adapter->dev;
1116 int id;
1117
1118 if (dev->of_node) {
1119 id = of_alias_get_id(dev->of_node, "i2c");
1120 if (id >= 0) {
1121 adapter->nr = id;
1122 return __i2c_add_numbered_adapter(adapter);
1123 }
1124 }
1125
1126 mutex_lock(&core_lock);
1127 id = idr_alloc(&i2c_adapter_idr, adapter,
1128 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1129 mutex_unlock(&core_lock);
1130 if (id < 0)
1131 return id;
1132
1133 adapter->nr = id;
1134
1135 return i2c_register_adapter(adapter);
1136}
1137EXPORT_SYMBOL(i2c_add_adapter);
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1163{
1164 if (adap->nr == -1)
1165 return i2c_add_adapter(adap);
1166
1167 return __i2c_add_numbered_adapter(adap);
1168}
1169EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1170
1171static void i2c_do_del_adapter(struct i2c_driver *driver,
1172 struct i2c_adapter *adapter)
1173{
1174 struct i2c_client *client, *_n;
1175
1176
1177
1178 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1179 if (client->adapter == adapter) {
1180 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1181 client->name, client->addr);
1182 list_del(&client->detected);
1183 i2c_unregister_device(client);
1184 }
1185 }
1186}
1187
1188static int __unregister_client(struct device *dev, void *dummy)
1189{
1190 struct i2c_client *client = i2c_verify_client(dev);
1191 if (client && strcmp(client->name, "dummy"))
1192 i2c_unregister_device(client);
1193 return 0;
1194}
1195
1196static int __unregister_dummy(struct device *dev, void *dummy)
1197{
1198 struct i2c_client *client = i2c_verify_client(dev);
1199 if (client)
1200 i2c_unregister_device(client);
1201 return 0;
1202}
1203
1204static int __process_removed_adapter(struct device_driver *d, void *data)
1205{
1206 i2c_do_del_adapter(to_i2c_driver(d), data);
1207 return 0;
1208}
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218void i2c_del_adapter(struct i2c_adapter *adap)
1219{
1220 struct i2c_adapter *found;
1221 struct i2c_client *client, *next;
1222
1223
1224 mutex_lock(&core_lock);
1225 found = idr_find(&i2c_adapter_idr, adap->nr);
1226 mutex_unlock(&core_lock);
1227 if (found != adap) {
1228 pr_debug("i2c-core: attempting to delete unregistered "
1229 "adapter [%s]\n", adap->name);
1230 return;
1231 }
1232
1233
1234 mutex_lock(&core_lock);
1235 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1236 __process_removed_adapter);
1237 mutex_unlock(&core_lock);
1238
1239
1240 mutex_lock_nested(&adap->userspace_clients_lock,
1241 i2c_adapter_depth(adap));
1242 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1243 detected) {
1244 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1245 client->addr);
1246 list_del(&client->detected);
1247 i2c_unregister_device(client);
1248 }
1249 mutex_unlock(&adap->userspace_clients_lock);
1250
1251
1252
1253
1254
1255
1256 device_for_each_child(&adap->dev, NULL, __unregister_client);
1257 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1258
1259#ifdef CONFIG_I2C_COMPAT
1260 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1261 adap->dev.parent);
1262#endif
1263
1264
1265 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1266
1267
1268 init_completion(&adap->dev_released);
1269 device_unregister(&adap->dev);
1270
1271
1272 wait_for_completion(&adap->dev_released);
1273
1274
1275 mutex_lock(&core_lock);
1276 idr_remove(&i2c_adapter_idr, adap->nr);
1277 mutex_unlock(&core_lock);
1278
1279
1280
1281 memset(&adap->dev, 0, sizeof(adap->dev));
1282}
1283EXPORT_SYMBOL(i2c_del_adapter);
1284
1285
1286
1287
1288int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1289{
1290 int res;
1291
1292 mutex_lock(&core_lock);
1293 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1294 mutex_unlock(&core_lock);
1295
1296 return res;
1297}
1298EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1299
1300static int __process_new_driver(struct device *dev, void *data)
1301{
1302 if (dev->type != &i2c_adapter_type)
1303 return 0;
1304 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1305}
1306
1307
1308
1309
1310
1311
1312int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1313{
1314 int res;
1315
1316
1317 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1318 return -EAGAIN;
1319
1320
1321 driver->driver.owner = owner;
1322 driver->driver.bus = &i2c_bus_type;
1323
1324
1325
1326
1327 res = driver_register(&driver->driver);
1328 if (res)
1329 return res;
1330
1331
1332 if (driver->suspend)
1333 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1334 driver->driver.name);
1335 if (driver->resume)
1336 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1337 driver->driver.name);
1338
1339 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1340
1341 INIT_LIST_HEAD(&driver->clients);
1342
1343 i2c_for_each_dev(driver, __process_new_driver);
1344
1345 return 0;
1346}
1347EXPORT_SYMBOL(i2c_register_driver);
1348
1349static int __process_removed_driver(struct device *dev, void *data)
1350{
1351 if (dev->type == &i2c_adapter_type)
1352 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1353 return 0;
1354}
1355
1356
1357
1358
1359
1360
1361void i2c_del_driver(struct i2c_driver *driver)
1362{
1363 i2c_for_each_dev(driver, __process_removed_driver);
1364
1365 driver_unregister(&driver->driver);
1366 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1367}
1368EXPORT_SYMBOL(i2c_del_driver);
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383struct i2c_client *i2c_use_client(struct i2c_client *client)
1384{
1385 if (client && get_device(&client->dev))
1386 return client;
1387 return NULL;
1388}
1389EXPORT_SYMBOL(i2c_use_client);
1390
1391
1392
1393
1394
1395
1396
1397void i2c_release_client(struct i2c_client *client)
1398{
1399 if (client)
1400 put_device(&client->dev);
1401}
1402EXPORT_SYMBOL(i2c_release_client);
1403
1404struct i2c_cmd_arg {
1405 unsigned cmd;
1406 void *arg;
1407};
1408
1409static int i2c_cmd(struct device *dev, void *_arg)
1410{
1411 struct i2c_client *client = i2c_verify_client(dev);
1412 struct i2c_cmd_arg *arg = _arg;
1413
1414 if (client && client->driver && client->driver->command)
1415 client->driver->command(client, arg->cmd, arg->arg);
1416 return 0;
1417}
1418
1419void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1420{
1421 struct i2c_cmd_arg cmd_arg;
1422
1423 cmd_arg.cmd = cmd;
1424 cmd_arg.arg = arg;
1425 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1426}
1427EXPORT_SYMBOL(i2c_clients_command);
1428
1429static int __init i2c_init(void)
1430{
1431 int retval;
1432
1433 retval = bus_register(&i2c_bus_type);
1434 if (retval)
1435 return retval;
1436#ifdef CONFIG_I2C_COMPAT
1437 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1438 if (!i2c_adapter_compat_class) {
1439 retval = -ENOMEM;
1440 goto bus_err;
1441 }
1442#endif
1443 retval = i2c_add_driver(&dummy_driver);
1444 if (retval)
1445 goto class_err;
1446 return 0;
1447
1448class_err:
1449#ifdef CONFIG_I2C_COMPAT
1450 class_compat_unregister(i2c_adapter_compat_class);
1451bus_err:
1452#endif
1453 bus_unregister(&i2c_bus_type);
1454 return retval;
1455}
1456
1457static void __exit i2c_exit(void)
1458{
1459 i2c_del_driver(&dummy_driver);
1460#ifdef CONFIG_I2C_COMPAT
1461 class_compat_unregister(i2c_adapter_compat_class);
1462#endif
1463 bus_unregister(&i2c_bus_type);
1464}
1465
1466
1467
1468
1469postcore_initcall(i2c_init);
1470module_exit(i2c_exit);
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1490{
1491 unsigned long orig_jiffies;
1492 int ret, try;
1493
1494
1495 orig_jiffies = jiffies;
1496 for (ret = 0, try = 0; try <= adap->retries; try++) {
1497 ret = adap->algo->master_xfer(adap, msgs, num);
1498 if (ret != -EAGAIN)
1499 break;
1500 if (time_after(jiffies, orig_jiffies + adap->timeout))
1501 break;
1502 }
1503
1504 return ret;
1505}
1506EXPORT_SYMBOL(__i2c_transfer);
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1521{
1522 int ret;
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541 if (adap->algo->master_xfer) {
1542#ifdef DEBUG
1543 for (ret = 0; ret < num; ret++) {
1544 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1545 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1546 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1547 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1548 }
1549#endif
1550
1551 if (in_atomic() || irqs_disabled()) {
1552 ret = i2c_trylock_adapter(adap);
1553 if (!ret)
1554
1555 return -EAGAIN;
1556 } else {
1557 i2c_lock_adapter(adap);
1558 }
1559
1560 ret = __i2c_transfer(adap, msgs, num);
1561 i2c_unlock_adapter(adap);
1562
1563 return ret;
1564 } else {
1565 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1566 return -EOPNOTSUPP;
1567 }
1568}
1569EXPORT_SYMBOL(i2c_transfer);
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1580{
1581 int ret;
1582 struct i2c_adapter *adap = client->adapter;
1583 struct i2c_msg msg;
1584
1585 msg.addr = client->addr;
1586 msg.flags = client->flags & I2C_M_TEN;
1587 msg.len = count;
1588 msg.buf = (char *)buf;
1589
1590 ret = i2c_transfer(adap, &msg, 1);
1591
1592
1593
1594
1595
1596 return (ret == 1) ? count : ret;
1597}
1598EXPORT_SYMBOL(i2c_master_send);
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1609{
1610 struct i2c_adapter *adap = client->adapter;
1611 struct i2c_msg msg;
1612 int ret;
1613
1614 msg.addr = client->addr;
1615 msg.flags = client->flags & I2C_M_TEN;
1616 msg.flags |= I2C_M_RD;
1617 msg.len = count;
1618 msg.buf = buf;
1619
1620 ret = i2c_transfer(adap, &msg, 1);
1621
1622
1623
1624
1625
1626 return (ret == 1) ? count : ret;
1627}
1628EXPORT_SYMBOL(i2c_master_recv);
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1649{
1650 int err;
1651 union i2c_smbus_data dummy;
1652
1653#ifdef CONFIG_X86
1654 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1655 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1656 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1657 I2C_SMBUS_BYTE_DATA, &dummy);
1658 else
1659#endif
1660 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1661 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1662 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1663 I2C_SMBUS_QUICK, NULL);
1664 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1665 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1666 I2C_SMBUS_BYTE, &dummy);
1667 else {
1668 dev_warn(&adap->dev, "No suitable probing method supported\n");
1669 err = -EOPNOTSUPP;
1670 }
1671
1672 return err >= 0;
1673}
1674
1675static int i2c_detect_address(struct i2c_client *temp_client,
1676 struct i2c_driver *driver)
1677{
1678 struct i2c_board_info info;
1679 struct i2c_adapter *adapter = temp_client->adapter;
1680 int addr = temp_client->addr;
1681 int err;
1682
1683
1684 err = i2c_check_addr_validity(addr);
1685 if (err) {
1686 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1687 addr);
1688 return err;
1689 }
1690
1691
1692 if (i2c_check_addr_busy(adapter, addr))
1693 return 0;
1694
1695
1696 if (!i2c_default_probe(adapter, addr))
1697 return 0;
1698
1699
1700 memset(&info, 0, sizeof(struct i2c_board_info));
1701 info.addr = addr;
1702 err = driver->detect(temp_client, &info);
1703 if (err) {
1704
1705
1706 return err == -ENODEV ? 0 : err;
1707 }
1708
1709
1710 if (info.type[0] == '\0') {
1711 dev_err(&adapter->dev, "%s detection function provided "
1712 "no name for 0x%x\n", driver->driver.name,
1713 addr);
1714 } else {
1715 struct i2c_client *client;
1716
1717
1718 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1719 info.type, info.addr);
1720 client = i2c_new_device(adapter, &info);
1721 if (client)
1722 list_add_tail(&client->detected, &driver->clients);
1723 else
1724 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1725 info.type, info.addr);
1726 }
1727 return 0;
1728}
1729
1730static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1731{
1732 const unsigned short *address_list;
1733 struct i2c_client *temp_client;
1734 int i, err = 0;
1735 int adap_id = i2c_adapter_id(adapter);
1736
1737 address_list = driver->address_list;
1738 if (!driver->detect || !address_list)
1739 return 0;
1740
1741
1742 if (!(adapter->class & driver->class))
1743 return 0;
1744
1745
1746 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1747 if (!temp_client)
1748 return -ENOMEM;
1749 temp_client->adapter = adapter;
1750
1751 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1752 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1753 "addr 0x%02x\n", adap_id, address_list[i]);
1754 temp_client->addr = address_list[i];
1755 err = i2c_detect_address(temp_client, driver);
1756 if (unlikely(err))
1757 break;
1758 }
1759
1760 kfree(temp_client);
1761 return err;
1762}
1763
1764int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1765{
1766 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1767 I2C_SMBUS_QUICK, NULL) >= 0;
1768}
1769EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1770
1771struct i2c_client *
1772i2c_new_probed_device(struct i2c_adapter *adap,
1773 struct i2c_board_info *info,
1774 unsigned short const *addr_list,
1775 int (*probe)(struct i2c_adapter *, unsigned short addr))
1776{
1777 int i;
1778
1779 if (!probe)
1780 probe = i2c_default_probe;
1781
1782 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1783
1784 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1785 dev_warn(&adap->dev, "Invalid 7-bit address "
1786 "0x%02x\n", addr_list[i]);
1787 continue;
1788 }
1789
1790
1791 if (i2c_check_addr_busy(adap, addr_list[i])) {
1792 dev_dbg(&adap->dev, "Address 0x%02x already in "
1793 "use, not probing\n", addr_list[i]);
1794 continue;
1795 }
1796
1797
1798 if (probe(adap, addr_list[i]))
1799 break;
1800 }
1801
1802 if (addr_list[i] == I2C_CLIENT_END) {
1803 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1804 return NULL;
1805 }
1806
1807 info->addr = addr_list[i];
1808 return i2c_new_device(adap, info);
1809}
1810EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1811
1812struct i2c_adapter *i2c_get_adapter(int nr)
1813{
1814 struct i2c_adapter *adapter;
1815
1816 mutex_lock(&core_lock);
1817 adapter = idr_find(&i2c_adapter_idr, nr);
1818 if (adapter && !try_module_get(adapter->owner))
1819 adapter = NULL;
1820
1821 mutex_unlock(&core_lock);
1822 return adapter;
1823}
1824EXPORT_SYMBOL(i2c_get_adapter);
1825
1826void i2c_put_adapter(struct i2c_adapter *adap)
1827{
1828 module_put(adap->owner);
1829}
1830EXPORT_SYMBOL(i2c_put_adapter);
1831
1832
1833
1834#define POLY (0x1070U << 3)
1835static u8 crc8(u16 data)
1836{
1837 int i;
1838
1839 for (i = 0; i < 8; i++) {
1840 if (data & 0x8000)
1841 data = data ^ POLY;
1842 data = data << 1;
1843 }
1844 return (u8)(data >> 8);
1845}
1846
1847
1848static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1849{
1850 int i;
1851
1852 for (i = 0; i < count; i++)
1853 crc = crc8((crc ^ p[i]) << 8);
1854 return crc;
1855}
1856
1857
1858static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1859{
1860
1861 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1862 pec = i2c_smbus_pec(pec, &addr, 1);
1863
1864
1865 return i2c_smbus_pec(pec, msg->buf, msg->len);
1866}
1867
1868
1869static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1870{
1871 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1872 msg->len++;
1873}
1874
1875
1876
1877
1878
1879
1880static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1881{
1882 u8 rpec = msg->buf[--msg->len];
1883 cpec = i2c_smbus_msg_pec(cpec, msg);
1884
1885 if (rpec != cpec) {
1886 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1887 rpec, cpec);
1888 return -EBADMSG;
1889 }
1890 return 0;
1891}
1892
1893
1894
1895
1896
1897
1898
1899
1900s32 i2c_smbus_read_byte(const struct i2c_client *client)
1901{
1902 union i2c_smbus_data data;
1903 int status;
1904
1905 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1906 I2C_SMBUS_READ, 0,
1907 I2C_SMBUS_BYTE, &data);
1908 return (status < 0) ? status : data.byte;
1909}
1910EXPORT_SYMBOL(i2c_smbus_read_byte);
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1921{
1922 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1923 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1924}
1925EXPORT_SYMBOL(i2c_smbus_write_byte);
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1936{
1937 union i2c_smbus_data data;
1938 int status;
1939
1940 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1941 I2C_SMBUS_READ, command,
1942 I2C_SMBUS_BYTE_DATA, &data);
1943 return (status < 0) ? status : data.byte;
1944}
1945EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1957 u8 value)
1958{
1959 union i2c_smbus_data data;
1960 data.byte = value;
1961 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1962 I2C_SMBUS_WRITE, command,
1963 I2C_SMBUS_BYTE_DATA, &data);
1964}
1965EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1976{
1977 union i2c_smbus_data data;
1978 int status;
1979
1980 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1981 I2C_SMBUS_READ, command,
1982 I2C_SMBUS_WORD_DATA, &data);
1983 return (status < 0) ? status : data.word;
1984}
1985EXPORT_SYMBOL(i2c_smbus_read_word_data);
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1997 u16 value)
1998{
1999 union i2c_smbus_data data;
2000 data.word = value;
2001 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2002 I2C_SMBUS_WRITE, command,
2003 I2C_SMBUS_WORD_DATA, &data);
2004}
2005EXPORT_SYMBOL(i2c_smbus_write_word_data);
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2023 u8 *values)
2024{
2025 union i2c_smbus_data data;
2026 int status;
2027
2028 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2029 I2C_SMBUS_READ, command,
2030 I2C_SMBUS_BLOCK_DATA, &data);
2031 if (status)
2032 return status;
2033
2034 memcpy(values, &data.block[1], data.block[0]);
2035 return data.block[0];
2036}
2037EXPORT_SYMBOL(i2c_smbus_read_block_data);
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2050 u8 length, const u8 *values)
2051{
2052 union i2c_smbus_data data;
2053
2054 if (length > I2C_SMBUS_BLOCK_MAX)
2055 length = I2C_SMBUS_BLOCK_MAX;
2056 data.block[0] = length;
2057 memcpy(&data.block[1], values, length);
2058 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2059 I2C_SMBUS_WRITE, command,
2060 I2C_SMBUS_BLOCK_DATA, &data);
2061}
2062EXPORT_SYMBOL(i2c_smbus_write_block_data);
2063
2064
2065s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2066 u8 length, u8 *values)
2067{
2068 union i2c_smbus_data data;
2069 int status;
2070
2071 if (length > I2C_SMBUS_BLOCK_MAX)
2072 length = I2C_SMBUS_BLOCK_MAX;
2073 data.block[0] = length;
2074 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2075 I2C_SMBUS_READ, command,
2076 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2077 if (status < 0)
2078 return status;
2079
2080 memcpy(values, &data.block[1], data.block[0]);
2081 return data.block[0];
2082}
2083EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2084
2085s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2086 u8 length, const u8 *values)
2087{
2088 union i2c_smbus_data data;
2089
2090 if (length > I2C_SMBUS_BLOCK_MAX)
2091 length = I2C_SMBUS_BLOCK_MAX;
2092 data.block[0] = length;
2093 memcpy(data.block + 1, values, length);
2094 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2095 I2C_SMBUS_WRITE, command,
2096 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2097}
2098EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2099
2100
2101
2102static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2103 unsigned short flags,
2104 char read_write, u8 command, int size,
2105 union i2c_smbus_data *data)
2106{
2107
2108
2109
2110
2111 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2112 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2113 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2114 int i;
2115 u8 partial_pec = 0;
2116 int status;
2117 struct i2c_msg msg[2] = {
2118 {
2119 .addr = addr,
2120 .flags = flags,
2121 .len = 1,
2122 .buf = msgbuf0,
2123 }, {
2124 .addr = addr,
2125 .flags = flags | I2C_M_RD,
2126 .len = 0,
2127 .buf = msgbuf1,
2128 },
2129 };
2130
2131 msgbuf0[0] = command;
2132 switch (size) {
2133 case I2C_SMBUS_QUICK:
2134 msg[0].len = 0;
2135
2136 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2137 I2C_M_RD : 0);
2138 num = 1;
2139 break;
2140 case I2C_SMBUS_BYTE:
2141 if (read_write == I2C_SMBUS_READ) {
2142
2143 msg[0].flags = I2C_M_RD | flags;
2144 num = 1;
2145 }
2146 break;
2147 case I2C_SMBUS_BYTE_DATA:
2148 if (read_write == I2C_SMBUS_READ)
2149 msg[1].len = 1;
2150 else {
2151 msg[0].len = 2;
2152 msgbuf0[1] = data->byte;
2153 }
2154 break;
2155 case I2C_SMBUS_WORD_DATA:
2156 if (read_write == I2C_SMBUS_READ)
2157 msg[1].len = 2;
2158 else {
2159 msg[0].len = 3;
2160 msgbuf0[1] = data->word & 0xff;
2161 msgbuf0[2] = data->word >> 8;
2162 }
2163 break;
2164 case I2C_SMBUS_PROC_CALL:
2165 num = 2;
2166 read_write = I2C_SMBUS_READ;
2167 msg[0].len = 3;
2168 msg[1].len = 2;
2169 msgbuf0[1] = data->word & 0xff;
2170 msgbuf0[2] = data->word >> 8;
2171 break;
2172 case I2C_SMBUS_BLOCK_DATA:
2173 if (read_write == I2C_SMBUS_READ) {
2174 msg[1].flags |= I2C_M_RECV_LEN;
2175 msg[1].len = 1;
2176
2177 } else {
2178 msg[0].len = data->block[0] + 2;
2179 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2180 dev_err(&adapter->dev,
2181 "Invalid block write size %d\n",
2182 data->block[0]);
2183 return -EINVAL;
2184 }
2185 for (i = 1; i < msg[0].len; i++)
2186 msgbuf0[i] = data->block[i-1];
2187 }
2188 break;
2189 case I2C_SMBUS_BLOCK_PROC_CALL:
2190 num = 2;
2191 read_write = I2C_SMBUS_READ;
2192 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2193 dev_err(&adapter->dev,
2194 "Invalid block write size %d\n",
2195 data->block[0]);
2196 return -EINVAL;
2197 }
2198 msg[0].len = data->block[0] + 2;
2199 for (i = 1; i < msg[0].len; i++)
2200 msgbuf0[i] = data->block[i-1];
2201 msg[1].flags |= I2C_M_RECV_LEN;
2202 msg[1].len = 1;
2203
2204 break;
2205 case I2C_SMBUS_I2C_BLOCK_DATA:
2206 if (read_write == I2C_SMBUS_READ) {
2207 msg[1].len = data->block[0];
2208 } else {
2209 msg[0].len = data->block[0] + 1;
2210 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2211 dev_err(&adapter->dev,
2212 "Invalid block write size %d\n",
2213 data->block[0]);
2214 return -EINVAL;
2215 }
2216 for (i = 1; i <= data->block[0]; i++)
2217 msgbuf0[i] = data->block[i];
2218 }
2219 break;
2220 default:
2221 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2222 return -EOPNOTSUPP;
2223 }
2224
2225 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2226 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2227 if (i) {
2228
2229 if (!(msg[0].flags & I2C_M_RD)) {
2230 if (num == 1)
2231 i2c_smbus_add_pec(&msg[0]);
2232 else
2233 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2234 }
2235
2236 if (msg[num-1].flags & I2C_M_RD)
2237 msg[num-1].len++;
2238 }
2239
2240 status = i2c_transfer(adapter, msg, num);
2241 if (status < 0)
2242 return status;
2243
2244
2245 if (i && (msg[num-1].flags & I2C_M_RD)) {
2246 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2247 if (status < 0)
2248 return status;
2249 }
2250
2251 if (read_write == I2C_SMBUS_READ)
2252 switch (size) {
2253 case I2C_SMBUS_BYTE:
2254 data->byte = msgbuf0[0];
2255 break;
2256 case I2C_SMBUS_BYTE_DATA:
2257 data->byte = msgbuf1[0];
2258 break;
2259 case I2C_SMBUS_WORD_DATA:
2260 case I2C_SMBUS_PROC_CALL:
2261 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2262 break;
2263 case I2C_SMBUS_I2C_BLOCK_DATA:
2264 for (i = 0; i < data->block[0]; i++)
2265 data->block[i+1] = msgbuf1[i];
2266 break;
2267 case I2C_SMBUS_BLOCK_DATA:
2268 case I2C_SMBUS_BLOCK_PROC_CALL:
2269 for (i = 0; i < msgbuf1[0] + 1; i++)
2270 data->block[i] = msgbuf1[i];
2271 break;
2272 }
2273 return 0;
2274}
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2290 char read_write, u8 command, int protocol,
2291 union i2c_smbus_data *data)
2292{
2293 unsigned long orig_jiffies;
2294 int try;
2295 s32 res;
2296
2297 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2298
2299 if (adapter->algo->smbus_xfer) {
2300 i2c_lock_adapter(adapter);
2301
2302
2303 orig_jiffies = jiffies;
2304 for (res = 0, try = 0; try <= adapter->retries; try++) {
2305 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2306 read_write, command,
2307 protocol, data);
2308 if (res != -EAGAIN)
2309 break;
2310 if (time_after(jiffies,
2311 orig_jiffies + adapter->timeout))
2312 break;
2313 }
2314 i2c_unlock_adapter(adapter);
2315
2316 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2317 return res;
2318
2319
2320
2321
2322 }
2323
2324 return i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2325 command, protocol, data);
2326}
2327EXPORT_SYMBOL(i2c_smbus_xfer);
2328
2329MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2330MODULE_DESCRIPTION("I2C-Bus main module");
2331MODULE_LICENSE("GPL");
2332