1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/delay.h>
33#include <linux/errno.h>
34#include <linux/gpio.h>
35#include <linux/slab.h>
36#include <linux/i2c.h>
37#include <linux/init.h>
38#include <linux/idr.h>
39#include <linux/mutex.h>
40#include <linux/of.h>
41#include <linux/of_device.h>
42#include <linux/of_irq.h>
43#include <linux/clk/clk-conf.h>
44#include <linux/completion.h>
45#include <linux/hardirq.h>
46#include <linux/irqflags.h>
47#include <linux/rwsem.h>
48#include <linux/pm_runtime.h>
49#include <linux/pm_domain.h>
50#include <linux/acpi.h>
51#include <linux/jump_label.h>
52#include <asm/uaccess.h>
53#include <linux/err.h>
54
55#include "i2c-core.h"
56
57#define CREATE_TRACE_POINTS
58#include <trace/events/i2c.h>
59
60
61
62
63static DEFINE_MUTEX(core_lock);
64static DEFINE_IDR(i2c_adapter_idr);
65
66static struct device_type i2c_client_type;
67static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
68
69static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
70
71void i2c_transfer_trace_reg(void)
72{
73 static_key_slow_inc(&i2c_trace_msg);
74}
75
76void i2c_transfer_trace_unreg(void)
77{
78 static_key_slow_dec(&i2c_trace_msg);
79}
80
81#if defined(CONFIG_ACPI)
82struct acpi_i2c_handler_data {
83 struct acpi_connection_info info;
84 struct i2c_adapter *adapter;
85};
86
87struct gsb_buffer {
88 u8 status;
89 u8 len;
90 union {
91 u16 wdata;
92 u8 bdata;
93 u8 data[0];
94 };
95} __packed;
96
97static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
98{
99 struct i2c_board_info *info = data;
100
101 if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
102 struct acpi_resource_i2c_serialbus *sb;
103
104 sb = &ares->data.i2c_serial_bus;
105 if (!info->addr && sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
106 info->addr = sb->slave_address;
107 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
108 info->flags |= I2C_CLIENT_TEN;
109 }
110 } else if (info->irq < 0) {
111 struct resource r;
112
113 if (acpi_dev_resource_interrupt(ares, 0, &r))
114 info->irq = r.start;
115 }
116
117
118 return 1;
119}
120
121static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
122 void *data, void **return_value)
123{
124 struct i2c_adapter *adapter = data;
125 struct list_head resource_list;
126 struct i2c_board_info info;
127 struct acpi_device *adev;
128 int ret;
129
130 if (acpi_bus_get_device(handle, &adev))
131 return AE_OK;
132 if (acpi_bus_get_status(adev) || !adev->status.present)
133 return AE_OK;
134
135 memset(&info, 0, sizeof(info));
136 info.fwnode = acpi_fwnode_handle(adev);
137 info.irq = -1;
138
139 INIT_LIST_HEAD(&resource_list);
140 ret = acpi_dev_get_resources(adev, &resource_list,
141 acpi_i2c_add_resource, &info);
142 acpi_dev_free_resource_list(&resource_list);
143
144 if (ret < 0 || !info.addr)
145 return AE_OK;
146
147 adev->power.flags.ignore_parent = true;
148 strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
149 if (!i2c_new_device(adapter, &info)) {
150 adev->power.flags.ignore_parent = false;
151 dev_err(&adapter->dev,
152 "failed to add I2C device %s from ACPI\n",
153 dev_name(&adev->dev));
154 }
155
156 return AE_OK;
157}
158
159
160
161
162
163
164
165
166
167static void acpi_i2c_register_devices(struct i2c_adapter *adap)
168{
169 acpi_handle handle;
170 acpi_status status;
171
172 if (!adap->dev.parent)
173 return;
174
175 handle = ACPI_HANDLE(adap->dev.parent);
176 if (!handle)
177 return;
178
179 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
180 acpi_i2c_add_device, NULL,
181 adap, NULL);
182 if (ACPI_FAILURE(status))
183 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
184}
185
186#else
187static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { }
188#endif
189
190#ifdef CONFIG_ACPI_I2C_OPREGION
191static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
192 u8 cmd, u8 *data, u8 data_len)
193{
194
195 struct i2c_msg msgs[2];
196 int ret;
197 u8 *buffer;
198
199 buffer = kzalloc(data_len, GFP_KERNEL);
200 if (!buffer)
201 return AE_NO_MEMORY;
202
203 msgs[0].addr = client->addr;
204 msgs[0].flags = client->flags;
205 msgs[0].len = 1;
206 msgs[0].buf = &cmd;
207
208 msgs[1].addr = client->addr;
209 msgs[1].flags = client->flags | I2C_M_RD;
210 msgs[1].len = data_len;
211 msgs[1].buf = buffer;
212
213 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
214 if (ret < 0)
215 dev_err(&client->adapter->dev, "i2c read failed\n");
216 else
217 memcpy(data, buffer, data_len);
218
219 kfree(buffer);
220 return ret;
221}
222
223static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
224 u8 cmd, u8 *data, u8 data_len)
225{
226
227 struct i2c_msg msgs[1];
228 u8 *buffer;
229 int ret = AE_OK;
230
231 buffer = kzalloc(data_len + 1, GFP_KERNEL);
232 if (!buffer)
233 return AE_NO_MEMORY;
234
235 buffer[0] = cmd;
236 memcpy(buffer + 1, data, data_len);
237
238 msgs[0].addr = client->addr;
239 msgs[0].flags = client->flags;
240 msgs[0].len = data_len + 1;
241 msgs[0].buf = buffer;
242
243 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
244 if (ret < 0)
245 dev_err(&client->adapter->dev, "i2c write failed\n");
246
247 kfree(buffer);
248 return ret;
249}
250
251static acpi_status
252acpi_i2c_space_handler(u32 function, acpi_physical_address command,
253 u32 bits, u64 *value64,
254 void *handler_context, void *region_context)
255{
256 struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
257 struct acpi_i2c_handler_data *data = handler_context;
258 struct acpi_connection_info *info = &data->info;
259 struct acpi_resource_i2c_serialbus *sb;
260 struct i2c_adapter *adapter = data->adapter;
261 struct i2c_client client;
262 struct acpi_resource *ares;
263 u32 accessor_type = function >> 16;
264 u8 action = function & ACPI_IO_MASK;
265 acpi_status ret;
266 int status;
267
268 ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
269 if (ACPI_FAILURE(ret))
270 return ret;
271
272 if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
273 ret = AE_BAD_PARAMETER;
274 goto err;
275 }
276
277 sb = &ares->data.i2c_serial_bus;
278 if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
279 ret = AE_BAD_PARAMETER;
280 goto err;
281 }
282
283 memset(&client, 0, sizeof(client));
284 client.adapter = adapter;
285 client.addr = sb->slave_address;
286 client.flags = 0;
287
288 if (sb->access_mode == ACPI_I2C_10BIT_MODE)
289 client.flags |= I2C_CLIENT_TEN;
290
291 switch (accessor_type) {
292 case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
293 if (action == ACPI_READ) {
294 status = i2c_smbus_read_byte(&client);
295 if (status >= 0) {
296 gsb->bdata = status;
297 status = 0;
298 }
299 } else {
300 status = i2c_smbus_write_byte(&client, gsb->bdata);
301 }
302 break;
303
304 case ACPI_GSB_ACCESS_ATTRIB_BYTE:
305 if (action == ACPI_READ) {
306 status = i2c_smbus_read_byte_data(&client, command);
307 if (status >= 0) {
308 gsb->bdata = status;
309 status = 0;
310 }
311 } else {
312 status = i2c_smbus_write_byte_data(&client, command,
313 gsb->bdata);
314 }
315 break;
316
317 case ACPI_GSB_ACCESS_ATTRIB_WORD:
318 if (action == ACPI_READ) {
319 status = i2c_smbus_read_word_data(&client, command);
320 if (status >= 0) {
321 gsb->wdata = status;
322 status = 0;
323 }
324 } else {
325 status = i2c_smbus_write_word_data(&client, command,
326 gsb->wdata);
327 }
328 break;
329
330 case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
331 if (action == ACPI_READ) {
332 status = i2c_smbus_read_block_data(&client, command,
333 gsb->data);
334 if (status >= 0) {
335 gsb->len = status;
336 status = 0;
337 }
338 } else {
339 status = i2c_smbus_write_block_data(&client, command,
340 gsb->len, gsb->data);
341 }
342 break;
343
344 case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
345 if (action == ACPI_READ) {
346 status = acpi_gsb_i2c_read_bytes(&client, command,
347 gsb->data, info->access_length);
348 if (status > 0)
349 status = 0;
350 } else {
351 status = acpi_gsb_i2c_write_bytes(&client, command,
352 gsb->data, info->access_length);
353 }
354 break;
355
356 default:
357 pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
358 ret = AE_BAD_PARAMETER;
359 goto err;
360 }
361
362 gsb->status = status;
363
364 err:
365 ACPI_FREE(ares);
366 return ret;
367}
368
369
370static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
371{
372 acpi_handle handle;
373 struct acpi_i2c_handler_data *data;
374 acpi_status status;
375
376 if (!adapter->dev.parent)
377 return -ENODEV;
378
379 handle = ACPI_HANDLE(adapter->dev.parent);
380
381 if (!handle)
382 return -ENODEV;
383
384 data = kzalloc(sizeof(struct acpi_i2c_handler_data),
385 GFP_KERNEL);
386 if (!data)
387 return -ENOMEM;
388
389 data->adapter = adapter;
390 status = acpi_bus_attach_private_data(handle, (void *)data);
391 if (ACPI_FAILURE(status)) {
392 kfree(data);
393 return -ENOMEM;
394 }
395
396 status = acpi_install_address_space_handler(handle,
397 ACPI_ADR_SPACE_GSBUS,
398 &acpi_i2c_space_handler,
399 NULL,
400 data);
401 if (ACPI_FAILURE(status)) {
402 dev_err(&adapter->dev, "Error installing i2c space handler\n");
403 acpi_bus_detach_private_data(handle);
404 kfree(data);
405 return -ENOMEM;
406 }
407
408 acpi_walk_dep_device_list(handle);
409 return 0;
410}
411
412static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
413{
414 acpi_handle handle;
415 struct acpi_i2c_handler_data *data;
416 acpi_status status;
417
418 if (!adapter->dev.parent)
419 return;
420
421 handle = ACPI_HANDLE(adapter->dev.parent);
422
423 if (!handle)
424 return;
425
426 acpi_remove_address_space_handler(handle,
427 ACPI_ADR_SPACE_GSBUS,
428 &acpi_i2c_space_handler);
429
430 status = acpi_bus_get_private_data(handle, (void **)&data);
431 if (ACPI_SUCCESS(status))
432 kfree(data);
433
434 acpi_bus_detach_private_data(handle);
435}
436#else
437static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
438{ }
439
440static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
441{ return 0; }
442#endif
443
444
445
446static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
447 const struct i2c_client *client)
448{
449 while (id->name[0]) {
450 if (strcmp(client->name, id->name) == 0)
451 return id;
452 id++;
453 }
454 return NULL;
455}
456
457static int i2c_device_match(struct device *dev, struct device_driver *drv)
458{
459 struct i2c_client *client = i2c_verify_client(dev);
460 struct i2c_driver *driver;
461
462 if (!client)
463 return 0;
464
465
466 if (of_driver_match_device(dev, drv))
467 return 1;
468
469
470 if (acpi_driver_match_device(dev, drv))
471 return 1;
472
473 driver = to_i2c_driver(drv);
474
475 if (driver->id_table)
476 return i2c_match_id(driver->id_table, client) != NULL;
477
478 return 0;
479}
480
481
482
483static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
484{
485 struct i2c_client *client = to_i2c_client(dev);
486 int rc;
487
488 rc = acpi_device_uevent_modalias(dev, env);
489 if (rc != -ENODEV)
490 return rc;
491
492 if (add_uevent_var(env, "MODALIAS=%s%s",
493 I2C_MODULE_PREFIX, client->name))
494 return -ENOMEM;
495 dev_dbg(dev, "uevent\n");
496 return 0;
497}
498
499
500static int get_scl_gpio_value(struct i2c_adapter *adap)
501{
502 return gpio_get_value(adap->bus_recovery_info->scl_gpio);
503}
504
505static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
506{
507 gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
508}
509
510static int get_sda_gpio_value(struct i2c_adapter *adap)
511{
512 return gpio_get_value(adap->bus_recovery_info->sda_gpio);
513}
514
515static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
516{
517 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
518 struct device *dev = &adap->dev;
519 int ret = 0;
520
521 ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
522 GPIOF_OUT_INIT_HIGH, "i2c-scl");
523 if (ret) {
524 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
525 return ret;
526 }
527
528 if (bri->get_sda) {
529 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
530
531 dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
532 bri->sda_gpio);
533 bri->get_sda = NULL;
534 }
535 }
536
537 return ret;
538}
539
540static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
541{
542 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
543
544 if (bri->get_sda)
545 gpio_free(bri->sda_gpio);
546
547 gpio_free(bri->scl_gpio);
548}
549
550
551
552
553
554
555#define RECOVERY_NDELAY 5000
556#define RECOVERY_CLK_CNT 9
557
558static int i2c_generic_recovery(struct i2c_adapter *adap)
559{
560 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
561 int i = 0, val = 1, ret = 0;
562
563 if (bri->prepare_recovery)
564 bri->prepare_recovery(adap);
565
566
567
568
569 while (i++ < RECOVERY_CLK_CNT * 2) {
570 if (val) {
571
572 if (bri->get_sda && bri->get_sda(adap))
573 break;
574
575 if (!bri->get_scl(adap)) {
576 dev_err(&adap->dev,
577 "SCL is stuck low, exit recovery\n");
578 ret = -EBUSY;
579 break;
580 }
581 }
582
583 val = !val;
584 bri->set_scl(adap, val);
585 ndelay(RECOVERY_NDELAY);
586 }
587
588 if (bri->unprepare_recovery)
589 bri->unprepare_recovery(adap);
590
591 return ret;
592}
593
594int i2c_generic_scl_recovery(struct i2c_adapter *adap)
595{
596 adap->bus_recovery_info->set_scl(adap, 1);
597 return i2c_generic_recovery(adap);
598}
599EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
600
601int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
602{
603 int ret;
604
605 ret = i2c_get_gpios_for_recovery(adap);
606 if (ret)
607 return ret;
608
609 ret = i2c_generic_recovery(adap);
610 i2c_put_gpios_for_recovery(adap);
611
612 return ret;
613}
614EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
615
616int i2c_recover_bus(struct i2c_adapter *adap)
617{
618 if (!adap->bus_recovery_info)
619 return -EOPNOTSUPP;
620
621 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
622 return adap->bus_recovery_info->recover_bus(adap);
623}
624EXPORT_SYMBOL_GPL(i2c_recover_bus);
625
626static int i2c_device_probe(struct device *dev)
627{
628 struct i2c_client *client = i2c_verify_client(dev);
629 struct i2c_driver *driver;
630 int status;
631
632 if (!client)
633 return 0;
634
635 if (!client->irq && dev->of_node) {
636 int irq = of_irq_get(dev->of_node, 0);
637
638 if (irq == -EPROBE_DEFER)
639 return irq;
640 if (irq < 0)
641 irq = 0;
642
643 client->irq = irq;
644 }
645
646 driver = to_i2c_driver(dev->driver);
647 if (!driver->probe || !driver->id_table)
648 return -ENODEV;
649
650 if (!device_can_wakeup(&client->dev))
651 device_init_wakeup(&client->dev,
652 client->flags & I2C_CLIENT_WAKE);
653 dev_dbg(dev, "probe\n");
654
655 status = of_clk_set_defaults(dev->of_node, false);
656 if (status < 0)
657 return status;
658
659 status = dev_pm_domain_attach(&client->dev, true);
660 if (status != -EPROBE_DEFER) {
661 status = driver->probe(client, i2c_match_id(driver->id_table,
662 client));
663 if (status)
664 dev_pm_domain_detach(&client->dev, true);
665 }
666
667 return status;
668}
669
670static int i2c_device_remove(struct device *dev)
671{
672 struct i2c_client *client = i2c_verify_client(dev);
673 struct i2c_driver *driver;
674 int status = 0;
675
676 if (!client || !dev->driver)
677 return 0;
678
679 driver = to_i2c_driver(dev->driver);
680 if (driver->remove) {
681 dev_dbg(dev, "remove\n");
682 status = driver->remove(client);
683 }
684
685 dev_pm_domain_detach(&client->dev, true);
686 return status;
687}
688
689static void i2c_device_shutdown(struct device *dev)
690{
691 struct i2c_client *client = i2c_verify_client(dev);
692 struct i2c_driver *driver;
693
694 if (!client || !dev->driver)
695 return;
696 driver = to_i2c_driver(dev->driver);
697 if (driver->shutdown)
698 driver->shutdown(client);
699}
700
701static void i2c_client_dev_release(struct device *dev)
702{
703 kfree(to_i2c_client(dev));
704}
705
706static ssize_t
707show_name(struct device *dev, struct device_attribute *attr, char *buf)
708{
709 return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
710 to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
711}
712static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
713
714static ssize_t
715show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
716{
717 struct i2c_client *client = to_i2c_client(dev);
718 int len;
719
720 len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
721 if (len != -ENODEV)
722 return len;
723
724 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
725}
726static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
727
728static struct attribute *i2c_dev_attrs[] = {
729 &dev_attr_name.attr,
730
731 &dev_attr_modalias.attr,
732 NULL
733};
734ATTRIBUTE_GROUPS(i2c_dev);
735
736struct bus_type i2c_bus_type = {
737 .name = "i2c",
738 .match = i2c_device_match,
739 .probe = i2c_device_probe,
740 .remove = i2c_device_remove,
741 .shutdown = i2c_device_shutdown,
742};
743EXPORT_SYMBOL_GPL(i2c_bus_type);
744
745static struct device_type i2c_client_type = {
746 .groups = i2c_dev_groups,
747 .uevent = i2c_device_uevent,
748 .release = i2c_client_dev_release,
749};
750
751
752
753
754
755
756
757
758
759
760
761struct i2c_client *i2c_verify_client(struct device *dev)
762{
763 return (dev->type == &i2c_client_type)
764 ? to_i2c_client(dev)
765 : NULL;
766}
767EXPORT_SYMBOL(i2c_verify_client);
768
769
770
771
772static int i2c_check_client_addr_validity(const struct i2c_client *client)
773{
774 if (client->flags & I2C_CLIENT_TEN) {
775
776 if (client->addr > 0x3ff)
777 return -EINVAL;
778 } else {
779
780 if (client->addr == 0x00 || client->addr > 0x7f)
781 return -EINVAL;
782 }
783 return 0;
784}
785
786
787
788
789
790static int i2c_check_addr_validity(unsigned short addr)
791{
792
793
794
795
796
797
798
799
800
801
802 if (addr < 0x08 || addr > 0x77)
803 return -EINVAL;
804 return 0;
805}
806
807static int __i2c_check_addr_busy(struct device *dev, void *addrp)
808{
809 struct i2c_client *client = i2c_verify_client(dev);
810 int addr = *(int *)addrp;
811
812 if (client && client->addr == addr)
813 return -EBUSY;
814 return 0;
815}
816
817
818static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
819{
820 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
821 int result;
822
823 result = device_for_each_child(&adapter->dev, &addr,
824 __i2c_check_addr_busy);
825
826 if (!result && parent)
827 result = i2c_check_mux_parents(parent, addr);
828
829 return result;
830}
831
832
833static int i2c_check_mux_children(struct device *dev, void *addrp)
834{
835 int result;
836
837 if (dev->type == &i2c_adapter_type)
838 result = device_for_each_child(dev, addrp,
839 i2c_check_mux_children);
840 else
841 result = __i2c_check_addr_busy(dev, addrp);
842
843 return result;
844}
845
846static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
847{
848 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
849 int result = 0;
850
851 if (parent)
852 result = i2c_check_mux_parents(parent, addr);
853
854 if (!result)
855 result = device_for_each_child(&adapter->dev, &addr,
856 i2c_check_mux_children);
857
858 return result;
859}
860
861
862
863
864
865void i2c_lock_adapter(struct i2c_adapter *adapter)
866{
867 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
868
869 if (parent)
870 i2c_lock_adapter(parent);
871 else
872 rt_mutex_lock(&adapter->bus_lock);
873}
874EXPORT_SYMBOL_GPL(i2c_lock_adapter);
875
876
877
878
879
880static int i2c_trylock_adapter(struct i2c_adapter *adapter)
881{
882 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
883
884 if (parent)
885 return i2c_trylock_adapter(parent);
886 else
887 return rt_mutex_trylock(&adapter->bus_lock);
888}
889
890
891
892
893
894void i2c_unlock_adapter(struct i2c_adapter *adapter)
895{
896 struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
897
898 if (parent)
899 i2c_unlock_adapter(parent);
900 else
901 rt_mutex_unlock(&adapter->bus_lock);
902}
903EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
904
905static void i2c_dev_set_name(struct i2c_adapter *adap,
906 struct i2c_client *client)
907{
908 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
909
910 if (adev) {
911 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
912 return;
913 }
914
915
916 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
917 client->addr | ((client->flags & I2C_CLIENT_TEN)
918 ? 0xa000 : 0));
919}
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937struct i2c_client *
938i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
939{
940 struct i2c_client *client;
941 int status;
942
943 client = kzalloc(sizeof *client, GFP_KERNEL);
944 if (!client)
945 return NULL;
946
947 client->adapter = adap;
948
949 client->dev.platform_data = info->platform_data;
950
951 if (info->archdata)
952 client->dev.archdata = *info->archdata;
953
954 client->flags = info->flags;
955 client->addr = info->addr;
956 client->irq = info->irq;
957
958 strlcpy(client->name, info->type, sizeof(client->name));
959
960
961 status = i2c_check_client_addr_validity(client);
962 if (status) {
963 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
964 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
965 goto out_err_silent;
966 }
967
968
969 status = i2c_check_addr_busy(adap, client->addr);
970 if (status)
971 goto out_err;
972
973 client->dev.parent = &client->adapter->dev;
974 client->dev.bus = &i2c_bus_type;
975 client->dev.type = &i2c_client_type;
976 client->dev.of_node = info->of_node;
977 client->dev.fwnode = info->fwnode;
978
979 i2c_dev_set_name(adap, client);
980 status = device_register(&client->dev);
981 if (status)
982 goto out_err;
983
984 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
985 client->name, dev_name(&client->dev));
986
987 return client;
988
989out_err:
990 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
991 "(%d)\n", client->name, client->addr, status);
992out_err_silent:
993 kfree(client);
994 return NULL;
995}
996EXPORT_SYMBOL_GPL(i2c_new_device);
997
998
999
1000
1001
1002
1003
1004void i2c_unregister_device(struct i2c_client *client)
1005{
1006 device_unregister(&client->dev);
1007}
1008EXPORT_SYMBOL_GPL(i2c_unregister_device);
1009
1010
1011static const struct i2c_device_id dummy_id[] = {
1012 { "dummy", 0 },
1013 { },
1014};
1015
1016static int dummy_probe(struct i2c_client *client,
1017 const struct i2c_device_id *id)
1018{
1019 return 0;
1020}
1021
1022static int dummy_remove(struct i2c_client *client)
1023{
1024 return 0;
1025}
1026
1027static struct i2c_driver dummy_driver = {
1028 .driver.name = "dummy",
1029 .probe = dummy_probe,
1030 .remove = dummy_remove,
1031 .id_table = dummy_id,
1032};
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1053{
1054 struct i2c_board_info info = {
1055 I2C_BOARD_INFO("dummy", address),
1056 };
1057
1058 return i2c_new_device(adapter, &info);
1059}
1060EXPORT_SYMBOL_GPL(i2c_new_dummy);
1061
1062
1063
1064
1065
1066static void i2c_adapter_dev_release(struct device *dev)
1067{
1068 struct i2c_adapter *adap = to_i2c_adapter(dev);
1069 complete(&adap->dev_released);
1070}
1071
1072
1073
1074
1075
1076
1077
1078static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1079{
1080 unsigned int depth = 0;
1081
1082 while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1083 depth++;
1084
1085 return depth;
1086}
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098static ssize_t
1099i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1100 const char *buf, size_t count)
1101{
1102 struct i2c_adapter *adap = to_i2c_adapter(dev);
1103 struct i2c_board_info info;
1104 struct i2c_client *client;
1105 char *blank, end;
1106 int res;
1107
1108 memset(&info, 0, sizeof(struct i2c_board_info));
1109
1110 blank = strchr(buf, ' ');
1111 if (!blank) {
1112 dev_err(dev, "%s: Missing parameters\n", "new_device");
1113 return -EINVAL;
1114 }
1115 if (blank - buf > I2C_NAME_SIZE - 1) {
1116 dev_err(dev, "%s: Invalid device name\n", "new_device");
1117 return -EINVAL;
1118 }
1119 memcpy(info.type, buf, blank - buf);
1120
1121
1122 res = sscanf(++blank, "%hi%c", &info.addr, &end);
1123 if (res < 1) {
1124 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1125 return -EINVAL;
1126 }
1127 if (res > 1 && end != '\n') {
1128 dev_err(dev, "%s: Extra parameters\n", "new_device");
1129 return -EINVAL;
1130 }
1131
1132 client = i2c_new_device(adap, &info);
1133 if (!client)
1134 return -EINVAL;
1135
1136
1137 mutex_lock(&adap->userspace_clients_lock);
1138 list_add_tail(&client->detected, &adap->userspace_clients);
1139 mutex_unlock(&adap->userspace_clients_lock);
1140 dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1141 info.type, info.addr);
1142
1143 return count;
1144}
1145static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156static ssize_t
1157i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1158 const char *buf, size_t count)
1159{
1160 struct i2c_adapter *adap = to_i2c_adapter(dev);
1161 struct i2c_client *client, *next;
1162 unsigned short addr;
1163 char end;
1164 int res;
1165
1166
1167 res = sscanf(buf, "%hi%c", &addr, &end);
1168 if (res < 1) {
1169 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1170 return -EINVAL;
1171 }
1172 if (res > 1 && end != '\n') {
1173 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1174 return -EINVAL;
1175 }
1176
1177
1178 res = -ENOENT;
1179 mutex_lock_nested(&adap->userspace_clients_lock,
1180 i2c_adapter_depth(adap));
1181 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1182 detected) {
1183 if (client->addr == addr) {
1184 dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1185 "delete_device", client->name, client->addr);
1186
1187 list_del(&client->detected);
1188 i2c_unregister_device(client);
1189 res = count;
1190 break;
1191 }
1192 }
1193 mutex_unlock(&adap->userspace_clients_lock);
1194
1195 if (res < 0)
1196 dev_err(dev, "%s: Can't find device in list\n",
1197 "delete_device");
1198 return res;
1199}
1200static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1201 i2c_sysfs_delete_device);
1202
1203static struct attribute *i2c_adapter_attrs[] = {
1204 &dev_attr_name.attr,
1205 &dev_attr_new_device.attr,
1206 &dev_attr_delete_device.attr,
1207 NULL
1208};
1209ATTRIBUTE_GROUPS(i2c_adapter);
1210
1211struct device_type i2c_adapter_type = {
1212 .groups = i2c_adapter_groups,
1213 .release = i2c_adapter_dev_release,
1214};
1215EXPORT_SYMBOL_GPL(i2c_adapter_type);
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1227{
1228 return (dev->type == &i2c_adapter_type)
1229 ? to_i2c_adapter(dev)
1230 : NULL;
1231}
1232EXPORT_SYMBOL(i2c_verify_adapter);
1233
1234#ifdef CONFIG_I2C_COMPAT
1235static struct class_compat *i2c_adapter_compat_class;
1236#endif
1237
1238static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1239{
1240 struct i2c_devinfo *devinfo;
1241
1242 down_read(&__i2c_board_lock);
1243 list_for_each_entry(devinfo, &__i2c_board_list, list) {
1244 if (devinfo->busnum == adapter->nr
1245 && !i2c_new_device(adapter,
1246 &devinfo->board_info))
1247 dev_err(&adapter->dev,
1248 "Can't create device at 0x%02x\n",
1249 devinfo->board_info.addr);
1250 }
1251 up_read(&__i2c_board_lock);
1252}
1253
1254
1255
1256#if IS_ENABLED(CONFIG_OF)
1257static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1258 struct device_node *node)
1259{
1260 struct i2c_client *result;
1261 struct i2c_board_info info = {};
1262 struct dev_archdata dev_ad = {};
1263 const __be32 *addr;
1264 int len;
1265
1266 dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1267
1268 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1269 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1270 node->full_name);
1271 return ERR_PTR(-EINVAL);
1272 }
1273
1274 addr = of_get_property(node, "reg", &len);
1275 if (!addr || (len < sizeof(int))) {
1276 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1277 node->full_name);
1278 return ERR_PTR(-EINVAL);
1279 }
1280
1281 info.addr = be32_to_cpup(addr);
1282 if (info.addr > (1 << 10) - 1) {
1283 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1284 info.addr, node->full_name);
1285 return ERR_PTR(-EINVAL);
1286 }
1287
1288 info.of_node = of_node_get(node);
1289 info.archdata = &dev_ad;
1290
1291 if (of_get_property(node, "wakeup-source", NULL))
1292 info.flags |= I2C_CLIENT_WAKE;
1293
1294 result = i2c_new_device(adap, &info);
1295 if (result == NULL) {
1296 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1297 node->full_name);
1298 of_node_put(node);
1299 return ERR_PTR(-EINVAL);
1300 }
1301 return result;
1302}
1303
1304static void of_i2c_register_devices(struct i2c_adapter *adap)
1305{
1306 struct device_node *node;
1307
1308
1309 if (!adap->dev.of_node)
1310 return;
1311
1312 dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1313
1314 for_each_available_child_of_node(adap->dev.of_node, node)
1315 of_i2c_register_device(adap, node);
1316}
1317
1318static int of_dev_node_match(struct device *dev, void *data)
1319{
1320 return dev->of_node == data;
1321}
1322
1323
1324struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1325{
1326 struct device *dev;
1327
1328 dev = bus_find_device(&i2c_bus_type, NULL, node,
1329 of_dev_node_match);
1330 if (!dev)
1331 return NULL;
1332
1333 return i2c_verify_client(dev);
1334}
1335EXPORT_SYMBOL(of_find_i2c_device_by_node);
1336
1337
1338struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1339{
1340 struct device *dev;
1341
1342 dev = bus_find_device(&i2c_bus_type, NULL, node,
1343 of_dev_node_match);
1344 if (!dev)
1345 return NULL;
1346
1347 return i2c_verify_adapter(dev);
1348}
1349EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1350#else
1351static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1352#endif
1353
1354static int i2c_do_add_adapter(struct i2c_driver *driver,
1355 struct i2c_adapter *adap)
1356{
1357
1358 i2c_detect(adap, driver);
1359
1360
1361 if (driver->attach_adapter) {
1362 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1363 driver->driver.name);
1364 dev_warn(&adap->dev, "Please use another way to instantiate "
1365 "your i2c_client\n");
1366
1367 driver->attach_adapter(adap);
1368 }
1369 return 0;
1370}
1371
1372static int __process_new_adapter(struct device_driver *d, void *data)
1373{
1374 return i2c_do_add_adapter(to_i2c_driver(d), data);
1375}
1376
1377static int i2c_register_adapter(struct i2c_adapter *adap)
1378{
1379 int res = 0;
1380
1381
1382 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
1383 res = -EAGAIN;
1384 goto out_list;
1385 }
1386
1387
1388 if (unlikely(adap->name[0] == '\0')) {
1389 pr_err("i2c-core: Attempt to register an adapter with "
1390 "no name!\n");
1391 return -EINVAL;
1392 }
1393 if (unlikely(!adap->algo)) {
1394 pr_err("i2c-core: Attempt to register adapter '%s' with "
1395 "no algo!\n", adap->name);
1396 return -EINVAL;
1397 }
1398
1399 rt_mutex_init(&adap->bus_lock);
1400 mutex_init(&adap->userspace_clients_lock);
1401 INIT_LIST_HEAD(&adap->userspace_clients);
1402
1403
1404 if (adap->timeout == 0)
1405 adap->timeout = HZ;
1406
1407 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1408 adap->dev.bus = &i2c_bus_type;
1409 adap->dev.type = &i2c_adapter_type;
1410 res = device_register(&adap->dev);
1411 if (res)
1412 goto out_list;
1413
1414 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1415
1416 pm_runtime_no_callbacks(&adap->dev);
1417
1418#ifdef CONFIG_I2C_COMPAT
1419 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1420 adap->dev.parent);
1421 if (res)
1422 dev_warn(&adap->dev,
1423 "Failed to create compatibility class link\n");
1424#endif
1425
1426
1427 if (adap->bus_recovery_info) {
1428 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1429
1430 if (!bri->recover_bus) {
1431 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1432 adap->bus_recovery_info = NULL;
1433 goto exit_recovery;
1434 }
1435
1436
1437 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1438 if (!gpio_is_valid(bri->scl_gpio)) {
1439 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1440 adap->bus_recovery_info = NULL;
1441 goto exit_recovery;
1442 }
1443
1444 if (gpio_is_valid(bri->sda_gpio))
1445 bri->get_sda = get_sda_gpio_value;
1446 else
1447 bri->get_sda = NULL;
1448
1449 bri->get_scl = get_scl_gpio_value;
1450 bri->set_scl = set_scl_gpio_value;
1451 } else if (!bri->set_scl || !bri->get_scl) {
1452
1453 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1454 adap->bus_recovery_info = NULL;
1455 }
1456 }
1457
1458exit_recovery:
1459
1460 of_i2c_register_devices(adap);
1461 acpi_i2c_register_devices(adap);
1462 acpi_i2c_install_space_handler(adap);
1463
1464 if (adap->nr < __i2c_first_dynamic_bus_num)
1465 i2c_scan_static_board_info(adap);
1466
1467
1468 mutex_lock(&core_lock);
1469 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1470 mutex_unlock(&core_lock);
1471
1472 return 0;
1473
1474out_list:
1475 mutex_lock(&core_lock);
1476 idr_remove(&i2c_adapter_idr, adap->nr);
1477 mutex_unlock(&core_lock);
1478 return res;
1479}
1480
1481
1482
1483
1484
1485
1486
1487
1488static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1489{
1490 int id;
1491
1492 mutex_lock(&core_lock);
1493 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1494 GFP_KERNEL);
1495 mutex_unlock(&core_lock);
1496 if (id < 0)
1497 return id == -ENOSPC ? -EBUSY : id;
1498
1499 return i2c_register_adapter(adap);
1500}
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516int i2c_add_adapter(struct i2c_adapter *adapter)
1517{
1518 struct device *dev = &adapter->dev;
1519 int id;
1520
1521 if (dev->of_node) {
1522 id = of_alias_get_id(dev->of_node, "i2c");
1523 if (id >= 0) {
1524 adapter->nr = id;
1525 return __i2c_add_numbered_adapter(adapter);
1526 }
1527 }
1528
1529 mutex_lock(&core_lock);
1530 id = idr_alloc(&i2c_adapter_idr, adapter,
1531 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1532 mutex_unlock(&core_lock);
1533 if (id < 0)
1534 return id;
1535
1536 adapter->nr = id;
1537
1538 return i2c_register_adapter(adapter);
1539}
1540EXPORT_SYMBOL(i2c_add_adapter);
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1566{
1567 if (adap->nr == -1)
1568 return i2c_add_adapter(adap);
1569
1570 return __i2c_add_numbered_adapter(adap);
1571}
1572EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1573
1574static void i2c_do_del_adapter(struct i2c_driver *driver,
1575 struct i2c_adapter *adapter)
1576{
1577 struct i2c_client *client, *_n;
1578
1579
1580
1581 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1582 if (client->adapter == adapter) {
1583 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1584 client->name, client->addr);
1585 list_del(&client->detected);
1586 i2c_unregister_device(client);
1587 }
1588 }
1589}
1590
1591static int __unregister_client(struct device *dev, void *dummy)
1592{
1593 struct i2c_client *client = i2c_verify_client(dev);
1594 if (client && strcmp(client->name, "dummy"))
1595 i2c_unregister_device(client);
1596 return 0;
1597}
1598
1599static int __unregister_dummy(struct device *dev, void *dummy)
1600{
1601 struct i2c_client *client = i2c_verify_client(dev);
1602 if (client)
1603 i2c_unregister_device(client);
1604 return 0;
1605}
1606
1607static int __process_removed_adapter(struct device_driver *d, void *data)
1608{
1609 i2c_do_del_adapter(to_i2c_driver(d), data);
1610 return 0;
1611}
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621void i2c_del_adapter(struct i2c_adapter *adap)
1622{
1623 struct i2c_adapter *found;
1624 struct i2c_client *client, *next;
1625
1626
1627 mutex_lock(&core_lock);
1628 found = idr_find(&i2c_adapter_idr, adap->nr);
1629 mutex_unlock(&core_lock);
1630 if (found != adap) {
1631 pr_debug("i2c-core: attempting to delete unregistered "
1632 "adapter [%s]\n", adap->name);
1633 return;
1634 }
1635
1636 acpi_i2c_remove_space_handler(adap);
1637
1638 mutex_lock(&core_lock);
1639 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1640 __process_removed_adapter);
1641 mutex_unlock(&core_lock);
1642
1643
1644 mutex_lock_nested(&adap->userspace_clients_lock,
1645 i2c_adapter_depth(adap));
1646 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1647 detected) {
1648 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1649 client->addr);
1650 list_del(&client->detected);
1651 i2c_unregister_device(client);
1652 }
1653 mutex_unlock(&adap->userspace_clients_lock);
1654
1655
1656
1657
1658
1659
1660 device_for_each_child(&adap->dev, NULL, __unregister_client);
1661 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1662
1663#ifdef CONFIG_I2C_COMPAT
1664 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1665 adap->dev.parent);
1666#endif
1667
1668
1669 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1670
1671
1672
1673
1674
1675
1676
1677
1678 init_completion(&adap->dev_released);
1679 device_unregister(&adap->dev);
1680 wait_for_completion(&adap->dev_released);
1681
1682
1683 mutex_lock(&core_lock);
1684 idr_remove(&i2c_adapter_idr, adap->nr);
1685 mutex_unlock(&core_lock);
1686
1687
1688
1689 memset(&adap->dev, 0, sizeof(adap->dev));
1690}
1691EXPORT_SYMBOL(i2c_del_adapter);
1692
1693
1694
1695int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1696{
1697 int res;
1698
1699 mutex_lock(&core_lock);
1700 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1701 mutex_unlock(&core_lock);
1702
1703 return res;
1704}
1705EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1706
1707static int __process_new_driver(struct device *dev, void *data)
1708{
1709 if (dev->type != &i2c_adapter_type)
1710 return 0;
1711 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1712}
1713
1714
1715
1716
1717
1718
1719int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1720{
1721 int res;
1722
1723
1724 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1725 return -EAGAIN;
1726
1727
1728 driver->driver.owner = owner;
1729 driver->driver.bus = &i2c_bus_type;
1730
1731
1732
1733
1734 res = driver_register(&driver->driver);
1735 if (res)
1736 return res;
1737
1738 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1739
1740 INIT_LIST_HEAD(&driver->clients);
1741
1742 i2c_for_each_dev(driver, __process_new_driver);
1743
1744 return 0;
1745}
1746EXPORT_SYMBOL(i2c_register_driver);
1747
1748static int __process_removed_driver(struct device *dev, void *data)
1749{
1750 if (dev->type == &i2c_adapter_type)
1751 i2c_do_del_adapter(data, to_i2c_adapter(dev));
1752 return 0;
1753}
1754
1755
1756
1757
1758
1759
1760void i2c_del_driver(struct i2c_driver *driver)
1761{
1762 i2c_for_each_dev(driver, __process_removed_driver);
1763
1764 driver_unregister(&driver->driver);
1765 pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1766}
1767EXPORT_SYMBOL(i2c_del_driver);
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782struct i2c_client *i2c_use_client(struct i2c_client *client)
1783{
1784 if (client && get_device(&client->dev))
1785 return client;
1786 return NULL;
1787}
1788EXPORT_SYMBOL(i2c_use_client);
1789
1790
1791
1792
1793
1794
1795
1796void i2c_release_client(struct i2c_client *client)
1797{
1798 if (client)
1799 put_device(&client->dev);
1800}
1801EXPORT_SYMBOL(i2c_release_client);
1802
1803struct i2c_cmd_arg {
1804 unsigned cmd;
1805 void *arg;
1806};
1807
1808static int i2c_cmd(struct device *dev, void *_arg)
1809{
1810 struct i2c_client *client = i2c_verify_client(dev);
1811 struct i2c_cmd_arg *arg = _arg;
1812 struct i2c_driver *driver;
1813
1814 if (!client || !client->dev.driver)
1815 return 0;
1816
1817 driver = to_i2c_driver(client->dev.driver);
1818 if (driver->command)
1819 driver->command(client, arg->cmd, arg->arg);
1820 return 0;
1821}
1822
1823void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1824{
1825 struct i2c_cmd_arg cmd_arg;
1826
1827 cmd_arg.cmd = cmd;
1828 cmd_arg.arg = arg;
1829 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1830}
1831EXPORT_SYMBOL(i2c_clients_command);
1832
1833#if IS_ENABLED(CONFIG_OF_DYNAMIC)
1834static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
1835 void *arg)
1836{
1837 struct of_reconfig_data *rd = arg;
1838 struct i2c_adapter *adap;
1839 struct i2c_client *client;
1840
1841 switch (of_reconfig_get_state_change(action, rd)) {
1842 case OF_RECONFIG_CHANGE_ADD:
1843 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
1844 if (adap == NULL)
1845 return NOTIFY_OK;
1846
1847 client = of_i2c_register_device(adap, rd->dn);
1848 put_device(&adap->dev);
1849
1850 if (IS_ERR(client)) {
1851 pr_err("%s: failed to create for '%s'\n",
1852 __func__, rd->dn->full_name);
1853 return notifier_from_errno(PTR_ERR(client));
1854 }
1855 break;
1856 case OF_RECONFIG_CHANGE_REMOVE:
1857
1858 client = of_find_i2c_device_by_node(rd->dn);
1859 if (client == NULL)
1860 return NOTIFY_OK;
1861
1862
1863 i2c_unregister_device(client);
1864
1865
1866 put_device(&client->dev);
1867 break;
1868 }
1869
1870 return NOTIFY_OK;
1871}
1872static struct notifier_block i2c_of_notifier = {
1873 .notifier_call = of_i2c_notify,
1874};
1875#else
1876extern struct notifier_block i2c_of_notifier;
1877#endif
1878
1879static int __init i2c_init(void)
1880{
1881 int retval;
1882
1883 retval = of_alias_get_highest_id("i2c");
1884
1885 down_write(&__i2c_board_lock);
1886 if (retval >= __i2c_first_dynamic_bus_num)
1887 __i2c_first_dynamic_bus_num = retval + 1;
1888 up_write(&__i2c_board_lock);
1889
1890 retval = bus_register(&i2c_bus_type);
1891 if (retval)
1892 return retval;
1893#ifdef CONFIG_I2C_COMPAT
1894 i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1895 if (!i2c_adapter_compat_class) {
1896 retval = -ENOMEM;
1897 goto bus_err;
1898 }
1899#endif
1900 retval = i2c_add_driver(&dummy_driver);
1901 if (retval)
1902 goto class_err;
1903
1904 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
1905 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
1906
1907 return 0;
1908
1909class_err:
1910#ifdef CONFIG_I2C_COMPAT
1911 class_compat_unregister(i2c_adapter_compat_class);
1912bus_err:
1913#endif
1914 bus_unregister(&i2c_bus_type);
1915 return retval;
1916}
1917
1918static void __exit i2c_exit(void)
1919{
1920 if (IS_ENABLED(CONFIG_OF_DYNAMIC))
1921 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
1922 i2c_del_driver(&dummy_driver);
1923#ifdef CONFIG_I2C_COMPAT
1924 class_compat_unregister(i2c_adapter_compat_class);
1925#endif
1926 bus_unregister(&i2c_bus_type);
1927 tracepoint_synchronize_unregister();
1928}
1929
1930
1931
1932
1933postcore_initcall(i2c_init);
1934module_exit(i2c_exit);
1935
1936
1937
1938
1939
1940
1941
1942#define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
1943
1944static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
1945{
1946 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
1947 err_msg, msg->addr, msg->len,
1948 msg->flags & I2C_M_RD ? "read" : "write");
1949 return -EOPNOTSUPP;
1950}
1951
1952static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1953{
1954 const struct i2c_adapter_quirks *q = adap->quirks;
1955 int max_num = q->max_num_msgs, i;
1956 bool do_len_check = true;
1957
1958 if (q->flags & I2C_AQ_COMB) {
1959 max_num = 2;
1960
1961
1962 if (num == 2) {
1963 if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
1964 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
1965
1966 if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
1967 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
1968
1969 if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
1970 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
1971
1972 if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
1973 return i2c_quirk_error(adap, &msgs[0], "msg too long");
1974
1975 if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
1976 return i2c_quirk_error(adap, &msgs[1], "msg too long");
1977
1978 do_len_check = false;
1979 }
1980 }
1981
1982 if (i2c_quirk_exceeded(num, max_num))
1983 return i2c_quirk_error(adap, &msgs[0], "too many messages");
1984
1985 for (i = 0; i < num; i++) {
1986 u16 len = msgs[i].len;
1987
1988 if (msgs[i].flags & I2C_M_RD) {
1989 if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
1990 return i2c_quirk_error(adap, &msgs[i], "msg too long");
1991 } else {
1992 if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
1993 return i2c_quirk_error(adap, &msgs[i], "msg too long");
1994 }
1995 }
1996
1997 return 0;
1998}
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2013{
2014 unsigned long orig_jiffies;
2015 int ret, try;
2016
2017 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2018 return -EOPNOTSUPP;
2019
2020
2021
2022
2023
2024 if (static_key_false(&i2c_trace_msg)) {
2025 int i;
2026 for (i = 0; i < num; i++)
2027 if (msgs[i].flags & I2C_M_RD)
2028 trace_i2c_read(adap, &msgs[i], i);
2029 else
2030 trace_i2c_write(adap, &msgs[i], i);
2031 }
2032
2033
2034 orig_jiffies = jiffies;
2035 for (ret = 0, try = 0; try <= adap->retries; try++) {
2036 ret = adap->algo->master_xfer(adap, msgs, num);
2037 if (ret != -EAGAIN)
2038 break;
2039 if (time_after(jiffies, orig_jiffies + adap->timeout))
2040 break;
2041 }
2042
2043 if (static_key_false(&i2c_trace_msg)) {
2044 int i;
2045 for (i = 0; i < ret; i++)
2046 if (msgs[i].flags & I2C_M_RD)
2047 trace_i2c_reply(adap, &msgs[i], i);
2048 trace_i2c_result(adap, i, ret);
2049 }
2050
2051 return ret;
2052}
2053EXPORT_SYMBOL(__i2c_transfer);
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2068{
2069 int ret;
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088 if (adap->algo->master_xfer) {
2089#ifdef DEBUG
2090 for (ret = 0; ret < num; ret++) {
2091 dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
2092 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
2093 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
2094 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2095 }
2096#endif
2097
2098 if (in_atomic() || irqs_disabled()) {
2099 ret = i2c_trylock_adapter(adap);
2100 if (!ret)
2101
2102 return -EAGAIN;
2103 } else {
2104 i2c_lock_adapter(adap);
2105 }
2106
2107 ret = __i2c_transfer(adap, msgs, num);
2108 i2c_unlock_adapter(adap);
2109
2110 return ret;
2111 } else {
2112 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2113 return -EOPNOTSUPP;
2114 }
2115}
2116EXPORT_SYMBOL(i2c_transfer);
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2127{
2128 int ret;
2129 struct i2c_adapter *adap = client->adapter;
2130 struct i2c_msg msg;
2131
2132 msg.addr = client->addr;
2133 msg.flags = client->flags & I2C_M_TEN;
2134 msg.len = count;
2135 msg.buf = (char *)buf;
2136
2137 ret = i2c_transfer(adap, &msg, 1);
2138
2139
2140
2141
2142
2143 return (ret == 1) ? count : ret;
2144}
2145EXPORT_SYMBOL(i2c_master_send);
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2156{
2157 struct i2c_adapter *adap = client->adapter;
2158 struct i2c_msg msg;
2159 int ret;
2160
2161 msg.addr = client->addr;
2162 msg.flags = client->flags & I2C_M_TEN;
2163 msg.flags |= I2C_M_RD;
2164 msg.len = count;
2165 msg.buf = buf;
2166
2167 ret = i2c_transfer(adap, &msg, 1);
2168
2169
2170
2171
2172
2173 return (ret == 1) ? count : ret;
2174}
2175EXPORT_SYMBOL(i2c_master_recv);
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2196{
2197 int err;
2198 union i2c_smbus_data dummy;
2199
2200#ifdef CONFIG_X86
2201 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2202 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2203 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2204 I2C_SMBUS_BYTE_DATA, &dummy);
2205 else
2206#endif
2207 if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2208 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2209 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2210 I2C_SMBUS_QUICK, NULL);
2211 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2212 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2213 I2C_SMBUS_BYTE, &dummy);
2214 else {
2215 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2216 addr);
2217 err = -EOPNOTSUPP;
2218 }
2219
2220 return err >= 0;
2221}
2222
2223static int i2c_detect_address(struct i2c_client *temp_client,
2224 struct i2c_driver *driver)
2225{
2226 struct i2c_board_info info;
2227 struct i2c_adapter *adapter = temp_client->adapter;
2228 int addr = temp_client->addr;
2229 int err;
2230
2231
2232 err = i2c_check_addr_validity(addr);
2233 if (err) {
2234 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2235 addr);
2236 return err;
2237 }
2238
2239
2240 if (i2c_check_addr_busy(adapter, addr))
2241 return 0;
2242
2243
2244 if (!i2c_default_probe(adapter, addr))
2245 return 0;
2246
2247
2248 memset(&info, 0, sizeof(struct i2c_board_info));
2249 info.addr = addr;
2250 err = driver->detect(temp_client, &info);
2251 if (err) {
2252
2253
2254 return err == -ENODEV ? 0 : err;
2255 }
2256
2257
2258 if (info.type[0] == '\0') {
2259 dev_err(&adapter->dev, "%s detection function provided "
2260 "no name for 0x%x\n", driver->driver.name,
2261 addr);
2262 } else {
2263 struct i2c_client *client;
2264
2265
2266 if (adapter->class & I2C_CLASS_DEPRECATED)
2267 dev_warn(&adapter->dev,
2268 "This adapter will soon drop class based instantiation of devices. "
2269 "Please make sure client 0x%02x gets instantiated by other means. "
2270 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2271 info.addr);
2272
2273 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2274 info.type, info.addr);
2275 client = i2c_new_device(adapter, &info);
2276 if (client)
2277 list_add_tail(&client->detected, &driver->clients);
2278 else
2279 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2280 info.type, info.addr);
2281 }
2282 return 0;
2283}
2284
2285static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2286{
2287 const unsigned short *address_list;
2288 struct i2c_client *temp_client;
2289 int i, err = 0;
2290 int adap_id = i2c_adapter_id(adapter);
2291
2292 address_list = driver->address_list;
2293 if (!driver->detect || !address_list)
2294 return 0;
2295
2296
2297 if (adapter->class == I2C_CLASS_DEPRECATED) {
2298 dev_dbg(&adapter->dev,
2299 "This adapter dropped support for I2C classes and "
2300 "won't auto-detect %s devices anymore. If you need it, check "
2301 "'Documentation/i2c/instantiating-devices' for alternatives.\n",
2302 driver->driver.name);
2303 return 0;
2304 }
2305
2306
2307 if (!(adapter->class & driver->class))
2308 return 0;
2309
2310
2311 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2312 if (!temp_client)
2313 return -ENOMEM;
2314 temp_client->adapter = adapter;
2315
2316 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2317 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
2318 "addr 0x%02x\n", adap_id, address_list[i]);
2319 temp_client->addr = address_list[i];
2320 err = i2c_detect_address(temp_client, driver);
2321 if (unlikely(err))
2322 break;
2323 }
2324
2325 kfree(temp_client);
2326 return err;
2327}
2328
2329int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2330{
2331 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2332 I2C_SMBUS_QUICK, NULL) >= 0;
2333}
2334EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2335
2336struct i2c_client *
2337i2c_new_probed_device(struct i2c_adapter *adap,
2338 struct i2c_board_info *info,
2339 unsigned short const *addr_list,
2340 int (*probe)(struct i2c_adapter *, unsigned short addr))
2341{
2342 int i;
2343
2344 if (!probe)
2345 probe = i2c_default_probe;
2346
2347 for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2348
2349 if (i2c_check_addr_validity(addr_list[i]) < 0) {
2350 dev_warn(&adap->dev, "Invalid 7-bit address "
2351 "0x%02x\n", addr_list[i]);
2352 continue;
2353 }
2354
2355
2356 if (i2c_check_addr_busy(adap, addr_list[i])) {
2357 dev_dbg(&adap->dev, "Address 0x%02x already in "
2358 "use, not probing\n", addr_list[i]);
2359 continue;
2360 }
2361
2362
2363 if (probe(adap, addr_list[i]))
2364 break;
2365 }
2366
2367 if (addr_list[i] == I2C_CLIENT_END) {
2368 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2369 return NULL;
2370 }
2371
2372 info->addr = addr_list[i];
2373 return i2c_new_device(adap, info);
2374}
2375EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2376
2377struct i2c_adapter *i2c_get_adapter(int nr)
2378{
2379 struct i2c_adapter *adapter;
2380
2381 mutex_lock(&core_lock);
2382 adapter = idr_find(&i2c_adapter_idr, nr);
2383 if (adapter && !try_module_get(adapter->owner))
2384 adapter = NULL;
2385
2386 mutex_unlock(&core_lock);
2387 return adapter;
2388}
2389EXPORT_SYMBOL(i2c_get_adapter);
2390
2391void i2c_put_adapter(struct i2c_adapter *adap)
2392{
2393 if (adap)
2394 module_put(adap->owner);
2395}
2396EXPORT_SYMBOL(i2c_put_adapter);
2397
2398
2399
2400#define POLY (0x1070U << 3)
2401static u8 crc8(u16 data)
2402{
2403 int i;
2404
2405 for (i = 0; i < 8; i++) {
2406 if (data & 0x8000)
2407 data = data ^ POLY;
2408 data = data << 1;
2409 }
2410 return (u8)(data >> 8);
2411}
2412
2413
2414static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2415{
2416 int i;
2417
2418 for (i = 0; i < count; i++)
2419 crc = crc8((crc ^ p[i]) << 8);
2420 return crc;
2421}
2422
2423
2424static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2425{
2426
2427 u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
2428 pec = i2c_smbus_pec(pec, &addr, 1);
2429
2430
2431 return i2c_smbus_pec(pec, msg->buf, msg->len);
2432}
2433
2434
2435static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2436{
2437 msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2438 msg->len++;
2439}
2440
2441
2442
2443
2444
2445
2446static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2447{
2448 u8 rpec = msg->buf[--msg->len];
2449 cpec = i2c_smbus_msg_pec(cpec, msg);
2450
2451 if (rpec != cpec) {
2452 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
2453 rpec, cpec);
2454 return -EBADMSG;
2455 }
2456 return 0;
2457}
2458
2459
2460
2461
2462
2463
2464
2465
2466s32 i2c_smbus_read_byte(const struct i2c_client *client)
2467{
2468 union i2c_smbus_data data;
2469 int status;
2470
2471 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2472 I2C_SMBUS_READ, 0,
2473 I2C_SMBUS_BYTE, &data);
2474 return (status < 0) ? status : data.byte;
2475}
2476EXPORT_SYMBOL(i2c_smbus_read_byte);
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2487{
2488 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2489 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2490}
2491EXPORT_SYMBOL(i2c_smbus_write_byte);
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2502{
2503 union i2c_smbus_data data;
2504 int status;
2505
2506 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2507 I2C_SMBUS_READ, command,
2508 I2C_SMBUS_BYTE_DATA, &data);
2509 return (status < 0) ? status : data.byte;
2510}
2511EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2523 u8 value)
2524{
2525 union i2c_smbus_data data;
2526 data.byte = value;
2527 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2528 I2C_SMBUS_WRITE, command,
2529 I2C_SMBUS_BYTE_DATA, &data);
2530}
2531EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
2542{
2543 union i2c_smbus_data data;
2544 int status;
2545
2546 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2547 I2C_SMBUS_READ, command,
2548 I2C_SMBUS_WORD_DATA, &data);
2549 return (status < 0) ? status : data.word;
2550}
2551EXPORT_SYMBOL(i2c_smbus_read_word_data);
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
2563 u16 value)
2564{
2565 union i2c_smbus_data data;
2566 data.word = value;
2567 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2568 I2C_SMBUS_WRITE, command,
2569 I2C_SMBUS_WORD_DATA, &data);
2570}
2571EXPORT_SYMBOL(i2c_smbus_write_word_data);
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
2589 u8 *values)
2590{
2591 union i2c_smbus_data data;
2592 int status;
2593
2594 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2595 I2C_SMBUS_READ, command,
2596 I2C_SMBUS_BLOCK_DATA, &data);
2597 if (status)
2598 return status;
2599
2600 memcpy(values, &data.block[1], data.block[0]);
2601 return data.block[0];
2602}
2603EXPORT_SYMBOL(i2c_smbus_read_block_data);
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
2616 u8 length, const u8 *values)
2617{
2618 union i2c_smbus_data data;
2619
2620 if (length > I2C_SMBUS_BLOCK_MAX)
2621 length = I2C_SMBUS_BLOCK_MAX;
2622 data.block[0] = length;
2623 memcpy(&data.block[1], values, length);
2624 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2625 I2C_SMBUS_WRITE, command,
2626 I2C_SMBUS_BLOCK_DATA, &data);
2627}
2628EXPORT_SYMBOL(i2c_smbus_write_block_data);
2629
2630
2631s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
2632 u8 length, u8 *values)
2633{
2634 union i2c_smbus_data data;
2635 int status;
2636
2637 if (length > I2C_SMBUS_BLOCK_MAX)
2638 length = I2C_SMBUS_BLOCK_MAX;
2639 data.block[0] = length;
2640 status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2641 I2C_SMBUS_READ, command,
2642 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2643 if (status < 0)
2644 return status;
2645
2646 memcpy(values, &data.block[1], data.block[0]);
2647 return data.block[0];
2648}
2649EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
2650
2651s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
2652 u8 length, const u8 *values)
2653{
2654 union i2c_smbus_data data;
2655
2656 if (length > I2C_SMBUS_BLOCK_MAX)
2657 length = I2C_SMBUS_BLOCK_MAX;
2658 data.block[0] = length;
2659 memcpy(data.block + 1, values, length);
2660 return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2661 I2C_SMBUS_WRITE, command,
2662 I2C_SMBUS_I2C_BLOCK_DATA, &data);
2663}
2664EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
2665
2666
2667
2668static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
2669 unsigned short flags,
2670 char read_write, u8 command, int size,
2671 union i2c_smbus_data *data)
2672{
2673
2674
2675
2676
2677 unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
2678 unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
2679 int num = read_write == I2C_SMBUS_READ ? 2 : 1;
2680 int i;
2681 u8 partial_pec = 0;
2682 int status;
2683 struct i2c_msg msg[2] = {
2684 {
2685 .addr = addr,
2686 .flags = flags,
2687 .len = 1,
2688 .buf = msgbuf0,
2689 }, {
2690 .addr = addr,
2691 .flags = flags | I2C_M_RD,
2692 .len = 0,
2693 .buf = msgbuf1,
2694 },
2695 };
2696
2697 msgbuf0[0] = command;
2698 switch (size) {
2699 case I2C_SMBUS_QUICK:
2700 msg[0].len = 0;
2701
2702 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2703 I2C_M_RD : 0);
2704 num = 1;
2705 break;
2706 case I2C_SMBUS_BYTE:
2707 if (read_write == I2C_SMBUS_READ) {
2708
2709 msg[0].flags = I2C_M_RD | flags;
2710 num = 1;
2711 }
2712 break;
2713 case I2C_SMBUS_BYTE_DATA:
2714 if (read_write == I2C_SMBUS_READ)
2715 msg[1].len = 1;
2716 else {
2717 msg[0].len = 2;
2718 msgbuf0[1] = data->byte;
2719 }
2720 break;
2721 case I2C_SMBUS_WORD_DATA:
2722 if (read_write == I2C_SMBUS_READ)
2723 msg[1].len = 2;
2724 else {
2725 msg[0].len = 3;
2726 msgbuf0[1] = data->word & 0xff;
2727 msgbuf0[2] = data->word >> 8;
2728 }
2729 break;
2730 case I2C_SMBUS_PROC_CALL:
2731 num = 2;
2732 read_write = I2C_SMBUS_READ;
2733 msg[0].len = 3;
2734 msg[1].len = 2;
2735 msgbuf0[1] = data->word & 0xff;
2736 msgbuf0[2] = data->word >> 8;
2737 break;
2738 case I2C_SMBUS_BLOCK_DATA:
2739 if (read_write == I2C_SMBUS_READ) {
2740 msg[1].flags |= I2C_M_RECV_LEN;
2741 msg[1].len = 1;
2742
2743 } else {
2744 msg[0].len = data->block[0] + 2;
2745 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2746 dev_err(&adapter->dev,
2747 "Invalid block write size %d\n",
2748 data->block[0]);
2749 return -EINVAL;
2750 }
2751 for (i = 1; i < msg[0].len; i++)
2752 msgbuf0[i] = data->block[i-1];
2753 }
2754 break;
2755 case I2C_SMBUS_BLOCK_PROC_CALL:
2756 num = 2;
2757 read_write = I2C_SMBUS_READ;
2758 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2759 dev_err(&adapter->dev,
2760 "Invalid block write size %d\n",
2761 data->block[0]);
2762 return -EINVAL;
2763 }
2764 msg[0].len = data->block[0] + 2;
2765 for (i = 1; i < msg[0].len; i++)
2766 msgbuf0[i] = data->block[i-1];
2767 msg[1].flags |= I2C_M_RECV_LEN;
2768 msg[1].len = 1;
2769
2770 break;
2771 case I2C_SMBUS_I2C_BLOCK_DATA:
2772 if (read_write == I2C_SMBUS_READ) {
2773 msg[1].len = data->block[0];
2774 } else {
2775 msg[0].len = data->block[0] + 1;
2776 if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2777 dev_err(&adapter->dev,
2778 "Invalid block write size %d\n",
2779 data->block[0]);
2780 return -EINVAL;
2781 }
2782 for (i = 1; i <= data->block[0]; i++)
2783 msgbuf0[i] = data->block[i];
2784 }
2785 break;
2786 default:
2787 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2788 return -EOPNOTSUPP;
2789 }
2790
2791 i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2792 && size != I2C_SMBUS_I2C_BLOCK_DATA);
2793 if (i) {
2794
2795 if (!(msg[0].flags & I2C_M_RD)) {
2796 if (num == 1)
2797 i2c_smbus_add_pec(&msg[0]);
2798 else
2799 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2800 }
2801
2802 if (msg[num-1].flags & I2C_M_RD)
2803 msg[num-1].len++;
2804 }
2805
2806 status = i2c_transfer(adapter, msg, num);
2807 if (status < 0)
2808 return status;
2809
2810
2811 if (i && (msg[num-1].flags & I2C_M_RD)) {
2812 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2813 if (status < 0)
2814 return status;
2815 }
2816
2817 if (read_write == I2C_SMBUS_READ)
2818 switch (size) {
2819 case I2C_SMBUS_BYTE:
2820 data->byte = msgbuf0[0];
2821 break;
2822 case I2C_SMBUS_BYTE_DATA:
2823 data->byte = msgbuf1[0];
2824 break;
2825 case I2C_SMBUS_WORD_DATA:
2826 case I2C_SMBUS_PROC_CALL:
2827 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2828 break;
2829 case I2C_SMBUS_I2C_BLOCK_DATA:
2830 for (i = 0; i < data->block[0]; i++)
2831 data->block[i+1] = msgbuf1[i];
2832 break;
2833 case I2C_SMBUS_BLOCK_DATA:
2834 case I2C_SMBUS_BLOCK_PROC_CALL:
2835 for (i = 0; i < msgbuf1[0] + 1; i++)
2836 data->block[i] = msgbuf1[i];
2837 break;
2838 }
2839 return 0;
2840}
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2856 char read_write, u8 command, int protocol,
2857 union i2c_smbus_data *data)
2858{
2859 unsigned long orig_jiffies;
2860 int try;
2861 s32 res;
2862
2863
2864
2865
2866 trace_smbus_write(adapter, addr, flags, read_write,
2867 command, protocol, data);
2868 trace_smbus_read(adapter, addr, flags, read_write,
2869 command, protocol);
2870
2871 flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2872
2873 if (adapter->algo->smbus_xfer) {
2874 i2c_lock_adapter(adapter);
2875
2876
2877 orig_jiffies = jiffies;
2878 for (res = 0, try = 0; try <= adapter->retries; try++) {
2879 res = adapter->algo->smbus_xfer(adapter, addr, flags,
2880 read_write, command,
2881 protocol, data);
2882 if (res != -EAGAIN)
2883 break;
2884 if (time_after(jiffies,
2885 orig_jiffies + adapter->timeout))
2886 break;
2887 }
2888 i2c_unlock_adapter(adapter);
2889
2890 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2891 goto trace;
2892
2893
2894
2895
2896 }
2897
2898 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2899 command, protocol, data);
2900
2901trace:
2902
2903 trace_smbus_reply(adapter, addr, flags, read_write,
2904 command, protocol, data);
2905 trace_smbus_result(adapter, addr, flags, read_write,
2906 command, protocol, res);
2907
2908 return res;
2909}
2910EXPORT_SYMBOL(i2c_smbus_xfer);
2911
2912#if IS_ENABLED(CONFIG_I2C_SLAVE)
2913int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
2914{
2915 int ret;
2916
2917 if (!client || !slave_cb)
2918 return -EINVAL;
2919
2920 if (!(client->flags & I2C_CLIENT_TEN)) {
2921
2922 ret = i2c_check_addr_validity(client->addr);
2923 if (ret)
2924 return ret;
2925 }
2926
2927 if (!client->adapter->algo->reg_slave)
2928 return -EOPNOTSUPP;
2929
2930 client->slave_cb = slave_cb;
2931
2932 i2c_lock_adapter(client->adapter);
2933 ret = client->adapter->algo->reg_slave(client);
2934 i2c_unlock_adapter(client->adapter);
2935
2936 if (ret)
2937 client->slave_cb = NULL;
2938
2939 return ret;
2940}
2941EXPORT_SYMBOL_GPL(i2c_slave_register);
2942
2943int i2c_slave_unregister(struct i2c_client *client)
2944{
2945 int ret;
2946
2947 if (!client->adapter->algo->unreg_slave)
2948 return -EOPNOTSUPP;
2949
2950 i2c_lock_adapter(client->adapter);
2951 ret = client->adapter->algo->unreg_slave(client);
2952 i2c_unlock_adapter(client->adapter);
2953
2954 if (ret == 0)
2955 client->slave_cb = NULL;
2956
2957 return ret;
2958}
2959EXPORT_SYMBOL_GPL(i2c_slave_unregister);
2960#endif
2961
2962MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2963MODULE_DESCRIPTION("I2C-Bus main module");
2964MODULE_LICENSE("GPL");
2965