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#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
47
48
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
77 if (of_driver_match_device(dev, drv))
78 return 1;
79
80 driver = to_i2c_driver(drv);
81
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
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
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
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
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
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
334
335
336
337
338
339
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
351
352static int i2c_check_client_addr_validity(const struct i2c_client *client)
353{
354 if (client->flags & I2C_CLIENT_TEN) {
355
356 if (client->addr > 0x3ff)
357 return -EINVAL;
358 } else {
359
360 if (client->addr == 0x00 || client->addr > 0x7f)
361 return -EINVAL;
362 }
363 return 0;
364}
365
366
367
368
369
370static int i2c_check_addr_validity(unsigned short addr)
371{
372
373
374
375
376
377
378
379
380
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
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
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
443
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
458
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
472
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
487
488
489
490
491
492
493
494
495
496
497
498
499
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
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
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#ifdef CONFIG_OF
541 client->dev.of_node = info->of_node;
542#endif
543
544 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
545 client->addr);
546 status = device_register(&client->dev);
547 if (status)
548 goto out_err;
549
550 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
551 client->name, dev_name(&client->dev));
552
553 return client;
554
555out_err:
556 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
557 "(%d)\n", client->name, client->addr, status);
558out_err_silent:
559 kfree(client);
560 return NULL;
561}
562EXPORT_SYMBOL_GPL(i2c_new_device);
563
564
565
566
567
568
569
570void i2c_unregister_device(struct i2c_client *client)
571{
572 device_unregister(&client->dev);
573}
574EXPORT_SYMBOL_GPL(i2c_unregister_device);
575
576
577static const struct i2c_device_id dummy_id[] = {
578 { "dummy", 0 },
579 { },
580};
581
582static int dummy_probe(struct i2c_client *client,
583 const struct i2c_device_id *id)
584{
585 return 0;
586}
587
588static int dummy_remove(struct i2c_client *client)
589{
590 return 0;
591}
592
593static struct i2c_driver dummy_driver = {
594 .driver.name = "dummy",
595 .probe = dummy_probe,
596 .remove = dummy_remove,
597 .id_table = dummy_id,
598};
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
619{
620 struct i2c_board_info info = {
621 I2C_BOARD_INFO("dummy", address),
622 };
623
624 return i2c_new_device(adapter, &info);
625}
626EXPORT_SYMBOL_GPL(i2c_new_dummy);
627
628
629
630
631
632static void i2c_adapter_dev_release(struct device *dev)
633{
634 struct i2c_adapter *adap = to_i2c_adapter(dev);
635 complete(&adap->dev_released);
636}
637
638
639
640
641
642
643
644
645
646
647
648static ssize_t
649i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
650 const char *buf, size_t count)
651{
652 struct i2c_adapter *adap = to_i2c_adapter(dev);
653 struct i2c_board_info info;
654 struct i2c_client *client;
655 char *blank, end;
656 int res;
657
658 memset(&info, 0, sizeof(struct i2c_board_info));
659
660 blank = strchr(buf, ' ');
661 if (!blank) {
662 dev_err(dev, "%s: Missing parameters\n", "new_device");
663 return -EINVAL;
664 }
665 if (blank - buf > I2C_NAME_SIZE - 1) {
666 dev_err(dev, "%s: Invalid device name\n", "new_device");
667 return -EINVAL;
668 }
669 memcpy(info.type, buf, blank - buf);
670
671
672 res = sscanf(++blank, "%hi%c", &info.addr, &end);
673 if (res < 1) {
674 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
675 return -EINVAL;
676 }
677 if (res > 1 && end != '\n') {
678 dev_err(dev, "%s: Extra parameters\n", "new_device");
679 return -EINVAL;
680 }
681
682 client = i2c_new_device(adap, &info);
683 if (!client)
684 return -EINVAL;
685
686
687 mutex_lock(&adap->userspace_clients_lock);
688 list_add_tail(&client->detected, &adap->userspace_clients);
689 mutex_unlock(&adap->userspace_clients_lock);
690 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
691 info.type, info.addr);
692
693 return count;
694}
695
696
697
698
699
700
701
702
703
704
705static ssize_t
706i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
707 const char *buf, size_t count)
708{
709 struct i2c_adapter *adap = to_i2c_adapter(dev);
710 struct i2c_client *client, *next;
711 unsigned short addr;
712 char end;
713 int res;
714
715
716 res = sscanf(buf, "%hi%c", &addr, &end);
717 if (res < 1) {
718 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
719 return -EINVAL;
720 }
721 if (res > 1 && end != '\n') {
722 dev_err(dev, "%s: Extra parameters\n", "delete_device");
723 return -EINVAL;
724 }
725
726
727 res = -ENOENT;
728 mutex_lock(&adap->userspace_clients_lock);
729 list_for_each_entry_safe(client, next, &adap->userspace_clients,
730 detected) {
731 if (client->addr == addr) {
732 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
733 "delete_device", client->name, client->addr);
734
735 list_del(&client->detected);
736 i2c_unregister_device(client);
737 res = count;
738 break;
739 }
740 }
741 mutex_unlock(&adap->userspace_clients_lock);
742
743 if (res < 0)
744 dev_err(dev, "%s: Can't find device in list\n",
745 "delete_device");
746 return res;
747}
748
749static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
750static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
751
752static struct attribute *i2c_adapter_attrs[] = {
753 &dev_attr_name.attr,
754 &dev_attr_new_device.attr,
755 &dev_attr_delete_device.attr,
756 NULL
757};
758
759static struct attribute_group i2c_adapter_attr_group = {
760 .attrs = i2c_adapter_attrs,
761};
762
763static const struct attribute_group *i2c_adapter_attr_groups[] = {
764 &i2c_adapter_attr_group,
765 NULL
766};
767
768struct device_type i2c_adapter_type = {
769 .groups = i2c_adapter_attr_groups,
770 .release = i2c_adapter_dev_release,
771};
772EXPORT_SYMBOL_GPL(i2c_adapter_type);
773
774#ifdef CONFIG_I2C_COMPAT
775static struct class_compat *i2c_adapter_compat_class;
776#endif
777
778static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
779{
780 struct i2c_devinfo *devinfo;
781
782 down_read(&__i2c_board_lock);
783 list_for_each_entry(devinfo, &__i2c_board_list, list) {
784 if (devinfo->busnum == adapter->nr
785 && !i2c_new_device(adapter,
786 &devinfo->board_info))
787 dev_err(&adapter->dev,
788 "Can't create device at 0x%02x\n",
789 devinfo->board_info.addr);
790 }
791 up_read(&__i2c_board_lock);
792}
793
794static int i2c_do_add_adapter(struct i2c_driver *driver,
795 struct i2c_adapter *adap)
796{
797
798 i2c_detect(adap, driver);
799
800
801 if (driver->attach_adapter) {
802
803 driver->attach_adapter(adap);
804 }
805 return 0;
806}
807
808static int __process_new_adapter(struct device_driver *d, void *data)
809{
810 return i2c_do_add_adapter(to_i2c_driver(d), data);
811}
812
813static int i2c_register_adapter(struct i2c_adapter *adap)
814{
815 int res = 0;
816
817
818 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
819 res = -EAGAIN;
820 goto out_list;
821 }
822
823
824 if (unlikely(adap->name[0] == '\0')) {
825 pr_err("i2c-core: Attempt to register an adapter with "
826 "no name!\n");
827 return -EINVAL;
828 }
829 if (unlikely(!adap->algo)) {
830 pr_err("i2c-core: Attempt to register adapter '%s' with "
831 "no algo!\n", adap->name);
832 return -EINVAL;
833 }
834
835 rt_mutex_init(&adap->bus_lock);
836 mutex_init(&adap->userspace_clients_lock);
837 INIT_LIST_HEAD(&adap->userspace_clients);
838
839
840 if (adap->timeout == 0)
841 adap->timeout = HZ;
842
843 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
844 adap->dev.bus = &i2c_bus_type;
845 adap->dev.type = &i2c_adapter_type;
846 res = device_register(&adap->dev);
847 if (res)
848 goto out_list;
849
850 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
851
852#ifdef CONFIG_I2C_COMPAT
853 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
854 adap->dev.parent);
855 if (res)
856 dev_warn(&adap->dev,
857 "Failed to create compatibility class link\n");
858#endif
859
860
861 if (adap->nr < __i2c_first_dynamic_bus_num)
862 i2c_scan_static_board_info(adap);
863
864
865 mutex_lock(&core_lock);
866 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
867 mutex_unlock(&core_lock);
868
869 return 0;
870
871out_list:
872 mutex_lock(&core_lock);
873 idr_remove(&i2c_adapter_idr, adap->nr);
874 mutex_unlock(&core_lock);
875 return res;
876}
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891int i2c_add_adapter(struct i2c_adapter *adapter)
892{
893 int id, res = 0;
894
895retry:
896 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
897 return -ENOMEM;
898
899 mutex_lock(&core_lock);
900
901 res = idr_get_new_above(&i2c_adapter_idr, adapter,
902 __i2c_first_dynamic_bus_num, &id);
903 mutex_unlock(&core_lock);
904
905 if (res < 0) {
906 if (res == -EAGAIN)
907 goto retry;
908 return res;
909 }
910
911 adapter->nr = id;
912 return i2c_register_adapter(adapter);
913}
914EXPORT_SYMBOL(i2c_add_adapter);
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936int i2c_add_numbered_adapter(struct i2c_adapter *adap)
937{
938 int id;
939 int status;
940
941 if (adap->nr & ~MAX_ID_MASK)
942 return -EINVAL;
943
944retry:
945 if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
946 return -ENOMEM;
947
948 mutex_lock(&core_lock);
949
950
951
952 status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
953 if (status == 0 && id != adap->nr) {
954 status = -EBUSY;
955 idr_remove(&i2c_adapter_idr, id);
956 }
957 mutex_unlock(&core_lock);
958 if (status == -EAGAIN)
959 goto retry;
960
961 if (status == 0)
962 status = i2c_register_adapter(adap);
963 return status;
964}
965EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
966
967static int i2c_do_del_adapter(struct i2c_driver *driver,
968 struct i2c_adapter *adapter)
969{
970 struct i2c_client *client, *_n;
971 int res;
972
973
974
975 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
976 if (client->adapter == adapter) {
977 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
978 client->name, client->addr);
979 list_del(&client->detected);
980 i2c_unregister_device(client);
981 }
982 }
983
984 if (!driver->detach_adapter)
985 return 0;
986 res = driver->detach_adapter(adapter);
987 if (res)
988 dev_err(&adapter->dev, "detach_adapter failed (%d) "
989 "for driver [%s]\n", res, driver->driver.name);
990 return res;
991}
992
993static int __unregister_client(struct device *dev, void *dummy)
994{
995 struct i2c_client *client = i2c_verify_client(dev);
996 if (client && strcmp(client->name, "dummy"))
997 i2c_unregister_device(client);
998 return 0;
999}
1000
1001static int __unregister_dummy(struct device *dev, void *dummy)
1002{
1003 struct i2c_client *client = i2c_verify_client(dev);
1004 if (client)
1005 i2c_unregister_device(client);
1006 return 0;
1007}
1008
1009static int __process_removed_adapter(struct device_driver *d, void *data)
1010{
1011 return i2c_do_del_adapter(to_i2c_driver(d), data);
1012}
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022int i2c_del_adapter(struct i2c_adapter *adap)
1023{
1024 int res = 0;
1025 struct i2c_adapter *found;
1026 struct i2c_client *client, *next;
1027
1028
1029 mutex_lock(&core_lock);
1030 found = idr_find(&i2c_adapter_idr, adap->nr);
1031 mutex_unlock(&core_lock);
1032 if (found != adap) {
1033 pr_debug("i2c-core: attempting to delete unregistered "
1034 "adapter [%s]\n", adap->name);
1035 return -EINVAL;
1036 }
1037
1038
1039 mutex_lock(&core_lock);
1040 res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1041 __process_removed_adapter);
1042 mutex_unlock(&core_lock);
1043 if (res)
1044 return res;
1045
1046
1047 mutex_lock(&adap->userspace_clients_lock);
1048 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1049 detected) {
1050 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1051 client->addr);
1052 list_del(&client->detected);
1053 i2c_unregister_device(client);
1054 }
1055 mutex_unlock(&adap->userspace_clients_lock);
1056
1057
1058
1059
1060
1061
1062 res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1063 res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1064
1065#ifdef CONFIG_I2C_COMPAT
1066 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1067 adap->dev.parent);
1068#endif
1069
1070
1071 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1072
1073
1074 init_completion(&adap->dev_released);
1075 device_unregister(&adap->dev);
1076
1077
1078 wait_for_completion(&adap->dev_released);
1079
1080
1081 mutex_lock(&core_lock);
1082 idr_remove(&i2c_adapter_idr, adap->nr);
1083 mutex_unlock(&core_lock);
1084
1085
1086
1087 memset(&adap->dev, 0, sizeof(adap->dev));
1088
1089 return 0;
1090}
1091EXPORT_SYMBOL(i2c_del_adapter);
1092
1093
1094
1095
1096static int __process_new_driver(struct device *dev, void *data)
1097{
1098 if (dev->type != &i2c_adapter_type)
1099 return 0;
1100 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1101}
1102
1103
1104
1105
1106
1107
1108int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1109{
1110 int res;
1111
1112
1113 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1114 return -EAGAIN;
1115
1116
1117 driver->driver.owner = owner;
1118 driver->driver.bus = &i2c_bus_type;
1119
1120
1121
1122
1123 res = driver_register(&driver->driver);
1124 if (res)
1125 return res;
1126
1127
1128 if (driver->suspend)
1129 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1130 driver->driver.name);
1131 if (driver->resume)
1132 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1133 driver->driver.name);
1134
1135 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1136
1137 INIT_LIST_HEAD(&driver->clients);
1138
1139 mutex_lock(&core_lock);
1140 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
1141 mutex_unlock(&core_lock);
1142
1143 return 0;
1144}
1145EXPORT_SYMBOL(i2c_register_driver);
1146
1147static int __process_removed_driver(struct device *dev, void *data)
1148{
1149 if (dev->type != &i2c_adapter_type)
1150 return 0;
1151 return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1152}
1153
1154
1155
1156
1157
1158
1159void i2c_del_driver(struct i2c_driver *driver)
1160{
1161 mutex_lock(&core_lock);
1162 bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_removed_driver);
1163 mutex_unlock(&core_lock);
1164
1165 driver_unregister(&driver->driver);
1166 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1167}
1168EXPORT_SYMBOL(i2c_del_driver);
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183struct i2c_client *i2c_use_client(struct i2c_client *client)
1184{
1185 if (client && get_device(&client->dev))
1186 return client;
1187 return NULL;
1188}
1189EXPORT_SYMBOL(i2c_use_client);
1190
1191
1192
1193
1194
1195
1196
1197void i2c_release_client(struct i2c_client *client)
1198{
1199 if (client)
1200 put_device(&client->dev);
1201}
1202EXPORT_SYMBOL(i2c_release_client);
1203
1204struct i2c_cmd_arg {
1205 unsigned cmd;
1206 void *arg;
1207};
1208
1209static int i2c_cmd(struct device *dev, void *_arg)
1210{
1211 struct i2c_client *client = i2c_verify_client(dev);
1212 struct i2c_cmd_arg *arg = _arg;
1213
1214 if (client && client->driver && client->driver->command)
1215 client->driver->command(client, arg->cmd, arg->arg);
1216 return 0;
1217}
1218
1219void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1220{
1221 struct i2c_cmd_arg cmd_arg;
1222
1223 cmd_arg.cmd = cmd;
1224 cmd_arg.arg = arg;
1225 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1226}
1227EXPORT_SYMBOL(i2c_clients_command);
1228
1229static int __init i2c_init(void)
1230{
1231 int retval;
1232
1233 retval = bus_register(&i2c_bus_type);
1234 if (retval)
1235 return retval;
1236#ifdef CONFIG_I2C_COMPAT
1237 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1238 if (!i2c_adapter_compat_class) {
1239 retval = -ENOMEM;
1240 goto bus_err;
1241 }
1242#endif
1243 retval = i2c_add_driver(&dummy_driver);
1244 if (retval)
1245 goto class_err;
1246 return 0;
1247
1248class_err:
1249#ifdef CONFIG_I2C_COMPAT
1250 class_compat_unregister(i2c_adapter_compat_class);
1251bus_err:
1252#endif
1253 bus_unregister(&i2c_bus_type);
1254 return retval;
1255}
1256
1257static void __exit i2c_exit(void)
1258{
1259 i2c_del_driver(&dummy_driver);
1260#ifdef CONFIG_I2C_COMPAT
1261 class_compat_unregister(i2c_adapter_compat_class);
1262#endif
1263 bus_unregister(&i2c_bus_type);
1264}
1265
1266
1267
1268
1269postcore_initcall(i2c_init);
1270module_exit(i2c_exit);
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1290{
1291 unsigned long orig_jiffies;
1292 int ret, try;
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311 if (adap->algo->master_xfer) {
1312#ifdef DEBUG
1313 for (ret = 0; ret < num; ret++) {
1314 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1315 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1316 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1317 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1318 }
1319#endif
1320
1321 if (in_atomic() || irqs_disabled()) {
1322 ret = i2c_trylock_adapter(adap);
1323 if (!ret)
1324
1325 return -EAGAIN;
1326 } else {
1327 i2c_lock_adapter(adap);
1328 }
1329
1330
1331 orig_jiffies = jiffies;
1332 for (ret = 0, try = 0; try <= adap->retries; try++) {
1333 ret = adap->algo->master_xfer(adap, msgs, num);
1334 if (ret != -EAGAIN)
1335 break;
1336 if (time_after(jiffies, orig_jiffies + adap->timeout))
1337 break;
1338 }
1339 i2c_unlock_adapter(adap);
1340
1341 return ret;
1342 } else {
1343 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1344 return -EOPNOTSUPP;
1345 }
1346}
1347EXPORT_SYMBOL(i2c_transfer);
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1358{
1359 int ret;
1360 struct i2c_adapter *adap = client->adapter;
1361 struct i2c_msg msg;
1362
1363 msg.addr = client->addr;
1364 msg.flags = client->flags & I2C_M_TEN;
1365 msg.len = count;
1366 msg.buf = (char *)buf;
1367
1368 ret = i2c_transfer(adap, &msg, 1);
1369
1370
1371
1372 return (ret == 1) ? count : ret;
1373}
1374EXPORT_SYMBOL(i2c_master_send);
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1385{
1386 struct i2c_adapter *adap = client->adapter;
1387 struct i2c_msg msg;
1388 int ret;
1389
1390 msg.addr = client->addr;
1391 msg.flags = client->flags & I2C_M_TEN;
1392 msg.flags |= I2C_M_RD;
1393 msg.len = count;
1394 msg.buf = buf;
1395
1396 ret = i2c_transfer(adap, &msg, 1);
1397
1398
1399
1400 return (ret == 1) ? count : ret;
1401}
1402EXPORT_SYMBOL(i2c_master_recv);
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1423{
1424 int err;
1425 union i2c_smbus_data dummy;
1426
1427#ifdef CONFIG_X86
1428 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1429 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1430 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1431 I2C_SMBUS_BYTE_DATA, &dummy);
1432 else
1433#endif
1434 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1435 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1436 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1437 I2C_SMBUS_QUICK, NULL);
1438 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1439 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1440 I2C_SMBUS_BYTE, &dummy);
1441 else {
1442 dev_warn(&adap->dev, "No suitable probing method supported\n");
1443 err = -EOPNOTSUPP;
1444 }
1445
1446 return err >= 0;
1447}
1448
1449static int i2c_detect_address(struct i2c_client *temp_client,
1450 struct i2c_driver *driver)
1451{
1452 struct i2c_board_info info;
1453 struct i2c_adapter *adapter = temp_client->adapter;
1454 int addr = temp_client->addr;
1455 int err;
1456
1457
1458 err = i2c_check_addr_validity(addr);
1459 if (err) {
1460 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1461 addr);
1462 return err;
1463 }
1464
1465
1466 if (i2c_check_addr_busy(adapter, addr))
1467 return 0;
1468
1469
1470 if (!i2c_default_probe(adapter, addr))
1471 return 0;
1472
1473
1474 memset(&info, 0, sizeof(struct i2c_board_info));
1475 info.addr = addr;
1476 err = driver->detect(temp_client, &info);
1477 if (err) {
1478
1479
1480 return err == -ENODEV ? 0 : err;
1481 }
1482
1483
1484 if (info.type[0] == '\0') {
1485 dev_err(&adapter->dev, "%s detection function provided "
1486 "no name for 0x%x\n", driver->driver.name,
1487 addr);
1488 } else {
1489 struct i2c_client *client;
1490
1491
1492 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1493 info.type, info.addr);
1494 client = i2c_new_device(adapter, &info);
1495 if (client)
1496 list_add_tail(&client->detected, &driver->clients);
1497 else
1498 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1499 info.type, info.addr);
1500 }
1501 return 0;
1502}
1503
1504static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1505{
1506 const unsigned short *address_list;
1507 struct i2c_client *temp_client;
1508 int i, err = 0;
1509 int adap_id = i2c_adapter_id(adapter);
1510
1511 address_list = driver->address_list;
1512 if (!driver->detect || !address_list)
1513 return 0;
1514
1515
1516 if (!(adapter->class & driver->class))
1517 return 0;
1518
1519
1520 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1521 if (!temp_client)
1522 return -ENOMEM;
1523 temp_client->adapter = adapter;
1524
1525 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1526 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1527 "addr 0x%02x\n", adap_id, address_list[i]);
1528 temp_client->addr = address_list[i];
1529 err = i2c_detect_address(temp_client, driver);
1530 if (unlikely(err))
1531 break;
1532 }
1533
1534 kfree(temp_client);
1535 return err;
1536}
1537
1538int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1539{
1540 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1541 I2C_SMBUS_QUICK, NULL) >= 0;
1542}
1543EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1544
1545struct i2c_client *
1546i2c_new_probed_device(struct i2c_adapter *adap,
1547 struct i2c_board_info *info,
1548 unsigned short const *addr_list,
1549 int (*probe)(struct i2c_adapter *, unsigned short addr))
1550{
1551 int i;
1552
1553 if (!probe)
1554 probe = i2c_default_probe;
1555
1556 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1557
1558 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1559 dev_warn(&adap->dev, "Invalid 7-bit address "
1560 "0x%02x\n", addr_list[i]);
1561 continue;
1562 }
1563
1564
1565 if (i2c_check_addr_busy(adap, addr_list[i])) {
1566 dev_dbg(&adap->dev, "Address 0x%02x already in "
1567 "use, not probing\n", addr_list[i]);
1568 continue;
1569 }
1570
1571
1572 if (probe(adap, addr_list[i]))
1573 break;
1574 }
1575
1576 if (addr_list[i] == I2C_CLIENT_END) {
1577 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1578 return NULL;
1579 }
1580
1581 info->addr = addr_list[i];
1582 return i2c_new_device(adap, info);
1583}
1584EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1585
1586struct i2c_adapter *i2c_get_adapter(int id)
1587{
1588 struct i2c_adapter *adapter;
1589
1590 mutex_lock(&core_lock);
1591 adapter = idr_find(&i2c_adapter_idr, id);
1592 if (adapter && !try_module_get(adapter->owner))
1593 adapter = NULL;
1594
1595 mutex_unlock(&core_lock);
1596 return adapter;
1597}
1598EXPORT_SYMBOL(i2c_get_adapter);
1599
1600void i2c_put_adapter(struct i2c_adapter *adap)
1601{
1602 module_put(adap->owner);
1603}
1604EXPORT_SYMBOL(i2c_put_adapter);
1605
1606
1607
1608#define POLY (0x1070U << 3)
1609static u8 crc8(u16 data)
1610{
1611 int i;
1612
1613 for (i = 0; i < 8; i++) {
1614 if (data & 0x8000)
1615 data = data ^ POLY;
1616 data = data << 1;
1617 }
1618 return (u8)(data >> 8);
1619}
1620
1621
1622static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1623{
1624 int i;
1625
1626 for (i = 0; i < count; i++)
1627 crc = crc8((crc ^ p[i]) << 8);
1628 return crc;
1629}
1630
1631
1632static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1633{
1634
1635 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1636 pec = i2c_smbus_pec(pec, &addr, 1);
1637
1638
1639 return i2c_smbus_pec(pec, msg->buf, msg->len);
1640}
1641
1642
1643static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1644{
1645 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1646 msg->len++;
1647}
1648
1649
1650
1651
1652
1653
1654static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1655{
1656 u8 rpec = msg->buf[--msg->len];
1657 cpec = i2c_smbus_msg_pec(cpec, msg);
1658
1659 if (rpec != cpec) {
1660 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1661 rpec, cpec);
1662 return -EBADMSG;
1663 }
1664 return 0;
1665}
1666
1667
1668
1669
1670
1671
1672
1673
1674s32 i2c_smbus_read_byte(const struct i2c_client *client)
1675{
1676 union i2c_smbus_data data;
1677 int status;
1678
1679 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1680 I2C_SMBUS_READ, 0,
1681 I2C_SMBUS_BYTE, &data);
1682 return (status < 0) ? status : data.byte;
1683}
1684EXPORT_SYMBOL(i2c_smbus_read_byte);
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1695{
1696 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1697 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1698}
1699EXPORT_SYMBOL(i2c_smbus_write_byte);
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1710{
1711 union i2c_smbus_data data;
1712 int status;
1713
1714 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1715 I2C_SMBUS_READ, command,
1716 I2C_SMBUS_BYTE_DATA, &data);
1717 return (status < 0) ? status : data.byte;
1718}
1719EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1731 u8 value)
1732{
1733 union i2c_smbus_data data;
1734 data.byte = value;
1735 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1736 I2C_SMBUS_WRITE, command,
1737 I2C_SMBUS_BYTE_DATA, &data);
1738}
1739EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1750{
1751 union i2c_smbus_data data;
1752 int status;
1753
1754 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1755 I2C_SMBUS_READ, command,
1756 I2C_SMBUS_WORD_DATA, &data);
1757 return (status < 0) ? status : data.word;
1758}
1759EXPORT_SYMBOL(i2c_smbus_read_word_data);
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1771 u16 value)
1772{
1773 union i2c_smbus_data data;
1774 data.word = value;
1775 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1776 I2C_SMBUS_WRITE, command,
1777 I2C_SMBUS_WORD_DATA, &data);
1778}
1779EXPORT_SYMBOL(i2c_smbus_write_word_data);
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1791 u16 value)
1792{
1793 union i2c_smbus_data data;
1794 int status;
1795 data.word = value;
1796
1797 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1798 I2C_SMBUS_WRITE, command,
1799 I2C_SMBUS_PROC_CALL, &data);
1800 return (status < 0) ? status : data.word;
1801}
1802EXPORT_SYMBOL(i2c_smbus_process_call);
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1820 u8 *values)
1821{
1822 union i2c_smbus_data data;
1823 int status;
1824
1825 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1826 I2C_SMBUS_READ, command,
1827 I2C_SMBUS_BLOCK_DATA, &data);
1828 if (status)
1829 return status;
1830
1831 memcpy(values, &data.block[1], data.block[0]);
1832 return data.block[0];
1833}
1834EXPORT_SYMBOL(i2c_smbus_read_block_data);
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1847 u8 length, const u8 *values)
1848{
1849 union i2c_smbus_data data;
1850
1851 if (length > I2C_SMBUS_BLOCK_MAX)
1852 length = I2C_SMBUS_BLOCK_MAX;
1853 data.block[0] = length;
1854 memcpy(&data.block[1], values, length);
1855 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1856 I2C_SMBUS_WRITE, command,
1857 I2C_SMBUS_BLOCK_DATA, &data);
1858}
1859EXPORT_SYMBOL(i2c_smbus_write_block_data);
1860
1861
1862s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1863 u8 length, u8 *values)
1864{
1865 union i2c_smbus_data data;
1866 int status;
1867
1868 if (length > I2C_SMBUS_BLOCK_MAX)
1869 length = I2C_SMBUS_BLOCK_MAX;
1870 data.block[0] = length;
1871 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1872 I2C_SMBUS_READ, command,
1873 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1874 if (status < 0)
1875 return status;
1876
1877 memcpy(values, &data.block[1], data.block[0]);
1878 return data.block[0];
1879}
1880EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1881
1882s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1883 u8 length, const u8 *values)
1884{
1885 union i2c_smbus_data data;
1886
1887 if (length > I2C_SMBUS_BLOCK_MAX)
1888 length = I2C_SMBUS_BLOCK_MAX;
1889 data.block[0] = length;
1890 memcpy(data.block + 1, values, length);
1891 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1892 I2C_SMBUS_WRITE, command,
1893 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1894}
1895EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1896
1897
1898
1899static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1900 unsigned short flags,
1901 char read_write, u8 command, int size,
1902 union i2c_smbus_data *data)
1903{
1904
1905
1906
1907
1908 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1909 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1910 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1911 struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1912 { addr, flags | I2C_M_RD, 0, msgbuf1 }
1913 };
1914 int i;
1915 u8 partial_pec = 0;
1916 int status;
1917
1918 msgbuf0[0] = command;
1919 switch (size) {
1920 case I2C_SMBUS_QUICK:
1921 msg[0].len = 0;
1922
1923 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1924 I2C_M_RD : 0);
1925 num = 1;
1926 break;
1927 case I2C_SMBUS_BYTE:
1928 if (read_write == I2C_SMBUS_READ) {
1929
1930 msg[0].flags = I2C_M_RD | flags;
1931 num = 1;
1932 }
1933 break;
1934 case I2C_SMBUS_BYTE_DATA:
1935 if (read_write == I2C_SMBUS_READ)
1936 msg[1].len = 1;
1937 else {
1938 msg[0].len = 2;
1939 msgbuf0[1] = data->byte;
1940 }
1941 break;
1942 case I2C_SMBUS_WORD_DATA:
1943 if (read_write == I2C_SMBUS_READ)
1944 msg[1].len = 2;
1945 else {
1946 msg[0].len = 3;
1947 msgbuf0[1] = data->word & 0xff;
1948 msgbuf0[2] = data->word >> 8;
1949 }
1950 break;
1951 case I2C_SMBUS_PROC_CALL:
1952 num = 2;
1953 read_write = I2C_SMBUS_READ;
1954 msg[0].len = 3;
1955 msg[1].len = 2;
1956 msgbuf0[1] = data->word & 0xff;
1957 msgbuf0[2] = data->word >> 8;
1958 break;
1959 case I2C_SMBUS_BLOCK_DATA:
1960 if (read_write == I2C_SMBUS_READ) {
1961 msg[1].flags |= I2C_M_RECV_LEN;
1962 msg[1].len = 1;
1963
1964 } else {
1965 msg[0].len = data->block[0] + 2;
1966 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1967 dev_err(&adapter->dev,
1968 "Invalid block write size %d\n",
1969 data->block[0]);
1970 return -EINVAL;
1971 }
1972 for (i = 1; i < msg[0].len; i++)
1973 msgbuf0[i] = data->block[i-1];
1974 }
1975 break;
1976 case I2C_SMBUS_BLOCK_PROC_CALL:
1977 num = 2;
1978 read_write = I2C_SMBUS_READ;
1979 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1980 dev_err(&adapter->dev,
1981 "Invalid block write size %d\n",
1982 data->block[0]);
1983 return -EINVAL;
1984 }
1985 msg[0].len = data->block[0] + 2;
1986 for (i = 1; i < msg[0].len; i++)
1987 msgbuf0[i] = data->block[i-1];
1988 msg[1].flags |= I2C_M_RECV_LEN;
1989 msg[1].len = 1;
1990
1991 break;
1992 case I2C_SMBUS_I2C_BLOCK_DATA:
1993 if (read_write == I2C_SMBUS_READ) {
1994 msg[1].len = data->block[0];
1995 } else {
1996 msg[0].len = data->block[0] + 1;
1997 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1998 dev_err(&adapter->dev,
1999 "Invalid block write size %d\n",
2000 data->block[0]);
2001 return -EINVAL;
2002 }
2003 for (i = 1; i <= data->block[0]; i++)
2004 msgbuf0[i] = data->block[i];
2005 }
2006 break;
2007 default:
2008 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2009 return -EOPNOTSUPP;
2010 }
2011
2012 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2013 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2014 if (i) {
2015
2016 if (!(msg[0].flags & I2C_M_RD)) {
2017 if (num == 1)
2018 i2c_smbus_add_pec(&msg[0]);
2019 else
2020 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2021 }
2022
2023 if (msg[num-1].flags & I2C_M_RD)
2024 msg[num-1].len++;
2025 }
2026
2027 status = i2c_transfer(adapter, msg, num);
2028 if (status < 0)
2029 return status;
2030
2031
2032 if (i && (msg[num-1].flags & I2C_M_RD)) {
2033 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2034 if (status < 0)
2035 return status;
2036 }
2037
2038 if (read_write == I2C_SMBUS_READ)
2039 switch (size) {
2040 case I2C_SMBUS_BYTE:
2041 data->byte = msgbuf0[0];
2042 break;
2043 case I2C_SMBUS_BYTE_DATA:
2044 data->byte = msgbuf1[0];
2045 break;
2046 case I2C_SMBUS_WORD_DATA:
2047 case I2C_SMBUS_PROC_CALL:
2048 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2049 break;
2050 case I2C_SMBUS_I2C_BLOCK_DATA:
2051 for (i = 0; i < data->block[0]; i++)
2052 data->block[i+1] = msgbuf1[i];
2053 break;
2054 case I2C_SMBUS_BLOCK_DATA:
2055 case I2C_SMBUS_BLOCK_PROC_CALL:
2056 for (i = 0; i < msgbuf1[0] + 1; i++)
2057 data->block[i] = msgbuf1[i];
2058 break;
2059 }
2060 return 0;
2061}
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2077 char read_write, u8 command, int protocol,
2078 union i2c_smbus_data *data)
2079{
2080 unsigned long orig_jiffies;
2081 int try;
2082 s32 res;
2083
2084 flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2085
2086 if (adapter->algo->smbus_xfer) {
2087 i2c_lock_adapter(adapter);
2088
2089
2090 orig_jiffies = jiffies;
2091 for (res = 0, try = 0; try <= adapter->retries; try++) {
2092 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2093 read_write, command,
2094 protocol, data);
2095 if (res != -EAGAIN)
2096 break;
2097 if (time_after(jiffies,
2098 orig_jiffies + adapter->timeout))
2099 break;
2100 }
2101 i2c_unlock_adapter(adapter);
2102 } else
2103 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2104 command, protocol, data);
2105
2106 return res;
2107}
2108EXPORT_SYMBOL(i2c_smbus_xfer);
2109
2110MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2111MODULE_DESCRIPTION("I2C-Bus main module");
2112MODULE_LICENSE("GPL");
2113