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