98fffa3a09f7fe5e716415c79963b7ac15587b9c
[cascardo/linux.git] / drivers / i2c / i2c-core.c
1 /* i2c-core.c - a device driver for the iic-bus interface                    */
2 /* ------------------------------------------------------------------------- */
3 /*   Copyright (C) 1995-99 Simon G. Vogl
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.                             */
14 /* ------------------------------------------------------------------------- */
15
16 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
17    All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
18    SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
19    Jean Delvare <jdelvare@suse.de>
20    Mux support by Rodolfo Giometti <giometti@enneenne.com> and
21    Michael Lawnick <michael.lawnick.ext@nsn.com>
22    OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de>
23    (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and
24    (c) 2013  Wolfram Sang <wsa@the-dreams.de>
25    I2C ACPI code Copyright (C) 2014 Intel Corp
26    Author: Lan Tianyu <tianyu.lan@intel.com>
27    I2C slave support (c) 2014 by Wolfram Sang <wsa@sang-engineering.com>
28  */
29
30 #define pr_fmt(fmt) "i2c-core: " fmt
31
32 #include <dt-bindings/i2c/i2c.h>
33 #include <asm/uaccess.h>
34 #include <linux/acpi.h>
35 #include <linux/clk/clk-conf.h>
36 #include <linux/completion.h>
37 #include <linux/delay.h>
38 #include <linux/err.h>
39 #include <linux/errno.h>
40 #include <linux/gpio.h>
41 #include <linux/hardirq.h>
42 #include <linux/i2c.h>
43 #include <linux/idr.h>
44 #include <linux/init.h>
45 #include <linux/irqflags.h>
46 #include <linux/jump_label.h>
47 #include <linux/kernel.h>
48 #include <linux/module.h>
49 #include <linux/mutex.h>
50 #include <linux/of_device.h>
51 #include <linux/of.h>
52 #include <linux/of_irq.h>
53 #include <linux/pm_domain.h>
54 #include <linux/pm_runtime.h>
55 #include <linux/pm_wakeirq.h>
56 #include <linux/property.h>
57 #include <linux/rwsem.h>
58 #include <linux/slab.h>
59
60 #include "i2c-core.h"
61
62 #define CREATE_TRACE_POINTS
63 #include <trace/events/i2c.h>
64
65 #define I2C_ADDR_OFFSET_TEN_BIT 0xa000
66 #define I2C_ADDR_OFFSET_SLAVE   0x1000
67
68 /* core_lock protects i2c_adapter_idr, and guarantees
69    that device detection, deletion of detected devices, and attach_adapter
70    calls are serialized */
71 static DEFINE_MUTEX(core_lock);
72 static DEFINE_IDR(i2c_adapter_idr);
73
74 static struct device_type i2c_client_type;
75 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
76
77 static struct static_key i2c_trace_msg = STATIC_KEY_INIT_FALSE;
78 static bool is_registered;
79
80 void i2c_transfer_trace_reg(void)
81 {
82         static_key_slow_inc(&i2c_trace_msg);
83 }
84
85 void i2c_transfer_trace_unreg(void)
86 {
87         static_key_slow_dec(&i2c_trace_msg);
88 }
89
90 #if defined(CONFIG_ACPI)
91 struct i2c_acpi_handler_data {
92         struct acpi_connection_info info;
93         struct i2c_adapter *adapter;
94 };
95
96 struct gsb_buffer {
97         u8      status;
98         u8      len;
99         union {
100                 u16     wdata;
101                 u8      bdata;
102                 u8      data[0];
103         };
104 } __packed;
105
106 struct i2c_acpi_lookup {
107         struct i2c_board_info *info;
108         acpi_handle adapter_handle;
109         acpi_handle device_handle;
110         acpi_handle search_handle;
111         u32 speed;
112         u32 min_speed;
113 };
114
115 static int i2c_acpi_fill_info(struct acpi_resource *ares, void *data)
116 {
117         struct i2c_acpi_lookup *lookup = data;
118         struct i2c_board_info *info = lookup->info;
119         struct acpi_resource_i2c_serialbus *sb;
120         acpi_status status;
121
122         if (info->addr || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
123                 return 1;
124
125         sb = &ares->data.i2c_serial_bus;
126         if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C)
127                 return 1;
128
129         status = acpi_get_handle(lookup->device_handle,
130                                  sb->resource_source.string_ptr,
131                                  &lookup->adapter_handle);
132         if (!ACPI_SUCCESS(status))
133                 return 1;
134
135         info->addr = sb->slave_address;
136         lookup->speed = sb->connection_speed;
137         if (sb->access_mode == ACPI_I2C_10BIT_MODE)
138                 info->flags |= I2C_CLIENT_TEN;
139
140         return 1;
141 }
142
143 static int i2c_acpi_do_lookup(struct acpi_device *adev,
144                               struct i2c_acpi_lookup *lookup)
145 {
146         struct i2c_board_info *info = lookup->info;
147         struct list_head resource_list;
148         int ret;
149
150         if (acpi_bus_get_status(adev) || !adev->status.present ||
151             acpi_device_enumerated(adev))
152                 return -EINVAL;
153
154         memset(info, 0, sizeof(*info));
155         lookup->device_handle = acpi_device_handle(adev);
156
157         /* Look up for I2cSerialBus resource */
158         INIT_LIST_HEAD(&resource_list);
159         ret = acpi_dev_get_resources(adev, &resource_list,
160                                      i2c_acpi_fill_info, lookup);
161         acpi_dev_free_resource_list(&resource_list);
162
163         if (ret < 0 || !info->addr)
164                 return -EINVAL;
165
166         return 0;
167 }
168
169 static int i2c_acpi_get_info(struct acpi_device *adev,
170                              struct i2c_board_info *info,
171                              struct i2c_adapter *adapter,
172                              acpi_handle *adapter_handle)
173 {
174         struct list_head resource_list;
175         struct resource_entry *entry;
176         struct i2c_acpi_lookup lookup;
177         int ret;
178
179         memset(&lookup, 0, sizeof(lookup));
180         lookup.info = info;
181
182         ret = i2c_acpi_do_lookup(adev, &lookup);
183         if (ret)
184                 return ret;
185
186         if (adapter) {
187                 /* The adapter must match the one in I2cSerialBus() connector */
188                 if (ACPI_HANDLE(&adapter->dev) != lookup.adapter_handle)
189                         return -ENODEV;
190         } else {
191                 struct acpi_device *adapter_adev;
192
193                 /* The adapter must be present */
194                 if (acpi_bus_get_device(lookup.adapter_handle, &adapter_adev))
195                         return -ENODEV;
196                 if (acpi_bus_get_status(adapter_adev) ||
197                     !adapter_adev->status.present)
198                         return -ENODEV;
199         }
200
201         info->fwnode = acpi_fwnode_handle(adev);
202         if (adapter_handle)
203                 *adapter_handle = lookup.adapter_handle;
204
205         /* Then fill IRQ number if any */
206         INIT_LIST_HEAD(&resource_list);
207         ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
208         if (ret < 0)
209                 return -EINVAL;
210
211         resource_list_for_each_entry(entry, &resource_list) {
212                 if (resource_type(entry->res) == IORESOURCE_IRQ) {
213                         info->irq = entry->res->start;
214                         break;
215                 }
216         }
217
218         acpi_dev_free_resource_list(&resource_list);
219
220         strlcpy(info->type, dev_name(&adev->dev), sizeof(info->type));
221
222         return 0;
223 }
224
225 static void i2c_acpi_register_device(struct i2c_adapter *adapter,
226                                      struct acpi_device *adev,
227                                      struct i2c_board_info *info)
228 {
229         adev->power.flags.ignore_parent = true;
230         acpi_device_set_enumerated(adev);
231
232         if (!i2c_new_device(adapter, info)) {
233                 adev->power.flags.ignore_parent = false;
234                 dev_err(&adapter->dev,
235                         "failed to add I2C device %s from ACPI\n",
236                         dev_name(&adev->dev));
237         }
238 }
239
240 static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
241                                        void *data, void **return_value)
242 {
243         struct i2c_adapter *adapter = data;
244         struct acpi_device *adev;
245         struct i2c_board_info info;
246
247         if (acpi_bus_get_device(handle, &adev))
248                 return AE_OK;
249
250         if (i2c_acpi_get_info(adev, &info, adapter, NULL))
251                 return AE_OK;
252
253         i2c_acpi_register_device(adapter, adev, &info);
254
255         return AE_OK;
256 }
257
258 #define I2C_ACPI_MAX_SCAN_DEPTH 32
259
260 /**
261  * i2c_acpi_register_devices - enumerate I2C slave devices behind adapter
262  * @adap: pointer to adapter
263  *
264  * Enumerate all I2C slave devices behind this adapter by walking the ACPI
265  * namespace. When a device is found it will be added to the Linux device
266  * model and bound to the corresponding ACPI handle.
267  */
268 static void i2c_acpi_register_devices(struct i2c_adapter *adap)
269 {
270         acpi_status status;
271
272         if (!has_acpi_companion(&adap->dev))
273                 return;
274
275         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
276                                      I2C_ACPI_MAX_SCAN_DEPTH,
277                                      i2c_acpi_add_device, NULL,
278                                      adap, NULL);
279         if (ACPI_FAILURE(status))
280                 dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
281 }
282
283 static acpi_status i2c_acpi_lookup_speed(acpi_handle handle, u32 level,
284                                            void *data, void **return_value)
285 {
286         struct i2c_acpi_lookup *lookup = data;
287         struct acpi_device *adev;
288
289         if (acpi_bus_get_device(handle, &adev))
290                 return AE_OK;
291
292         if (i2c_acpi_do_lookup(adev, lookup))
293                 return AE_OK;
294
295         if (lookup->search_handle != lookup->adapter_handle)
296                 return AE_OK;
297
298         if (lookup->speed <= lookup->min_speed)
299                 lookup->min_speed = lookup->speed;
300
301         return AE_OK;
302 }
303
304 /**
305  * i2c_acpi_find_bus_speed - find I2C bus speed from ACPI
306  * @dev: The device owning the bus
307  *
308  * Find the I2C bus speed by walking the ACPI namespace for all I2C slaves
309  * devices connected to this bus and use the speed of slowest device.
310  *
311  * Returns the speed in Hz or zero
312  */
313 u32 i2c_acpi_find_bus_speed(struct device *dev)
314 {
315         struct i2c_acpi_lookup lookup;
316         struct i2c_board_info dummy;
317         acpi_status status;
318
319         if (!has_acpi_companion(dev))
320                 return 0;
321
322         memset(&lookup, 0, sizeof(lookup));
323         lookup.search_handle = ACPI_HANDLE(dev);
324         lookup.min_speed = UINT_MAX;
325         lookup.info = &dummy;
326
327         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
328                                      I2C_ACPI_MAX_SCAN_DEPTH,
329                                      i2c_acpi_lookup_speed, NULL,
330                                      &lookup, NULL);
331
332         if (ACPI_FAILURE(status)) {
333                 dev_warn(dev, "unable to find I2C bus speed from ACPI\n");
334                 return 0;
335         }
336
337         return lookup.min_speed != UINT_MAX ? lookup.min_speed : 0;
338 }
339 EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
340
341 static int i2c_acpi_match_adapter(struct device *dev, void *data)
342 {
343         struct i2c_adapter *adapter = i2c_verify_adapter(dev);
344
345         if (!adapter)
346                 return 0;
347
348         return ACPI_HANDLE(dev) == (acpi_handle)data;
349 }
350
351 static int i2c_acpi_match_device(struct device *dev, void *data)
352 {
353         return ACPI_COMPANION(dev) == data;
354 }
355
356 static struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
357 {
358         struct device *dev;
359
360         dev = bus_find_device(&i2c_bus_type, NULL, handle,
361                               i2c_acpi_match_adapter);
362         return dev ? i2c_verify_adapter(dev) : NULL;
363 }
364
365 static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
366 {
367         struct device *dev;
368
369         dev = bus_find_device(&i2c_bus_type, NULL, adev, i2c_acpi_match_device);
370         return dev ? i2c_verify_client(dev) : NULL;
371 }
372
373 static int i2c_acpi_notify(struct notifier_block *nb, unsigned long value,
374                            void *arg)
375 {
376         struct acpi_device *adev = arg;
377         struct i2c_board_info info;
378         acpi_handle adapter_handle;
379         struct i2c_adapter *adapter;
380         struct i2c_client *client;
381
382         switch (value) {
383         case ACPI_RECONFIG_DEVICE_ADD:
384                 if (i2c_acpi_get_info(adev, &info, NULL, &adapter_handle))
385                         break;
386
387                 adapter = i2c_acpi_find_adapter_by_handle(adapter_handle);
388                 if (!adapter)
389                         break;
390
391                 i2c_acpi_register_device(adapter, adev, &info);
392                 break;
393         case ACPI_RECONFIG_DEVICE_REMOVE:
394                 if (!acpi_device_enumerated(adev))
395                         break;
396
397                 client = i2c_acpi_find_client_by_adev(adev);
398                 if (!client)
399                         break;
400
401                 i2c_unregister_device(client);
402                 put_device(&client->dev);
403                 break;
404         }
405
406         return NOTIFY_OK;
407 }
408
409 static struct notifier_block i2c_acpi_notifier = {
410         .notifier_call = i2c_acpi_notify,
411 };
412 #else /* CONFIG_ACPI */
413 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
414 extern struct notifier_block i2c_acpi_notifier;
415 #endif /* CONFIG_ACPI */
416
417 #ifdef CONFIG_ACPI_I2C_OPREGION
418 static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
419                 u8 cmd, u8 *data, u8 data_len)
420 {
421
422         struct i2c_msg msgs[2];
423         int ret;
424         u8 *buffer;
425
426         buffer = kzalloc(data_len, GFP_KERNEL);
427         if (!buffer)
428                 return AE_NO_MEMORY;
429
430         msgs[0].addr = client->addr;
431         msgs[0].flags = client->flags;
432         msgs[0].len = 1;
433         msgs[0].buf = &cmd;
434
435         msgs[1].addr = client->addr;
436         msgs[1].flags = client->flags | I2C_M_RD;
437         msgs[1].len = data_len;
438         msgs[1].buf = buffer;
439
440         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
441         if (ret < 0)
442                 dev_err(&client->adapter->dev, "i2c read failed\n");
443         else
444                 memcpy(data, buffer, data_len);
445
446         kfree(buffer);
447         return ret;
448 }
449
450 static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
451                 u8 cmd, u8 *data, u8 data_len)
452 {
453
454         struct i2c_msg msgs[1];
455         u8 *buffer;
456         int ret = AE_OK;
457
458         buffer = kzalloc(data_len + 1, GFP_KERNEL);
459         if (!buffer)
460                 return AE_NO_MEMORY;
461
462         buffer[0] = cmd;
463         memcpy(buffer + 1, data, data_len);
464
465         msgs[0].addr = client->addr;
466         msgs[0].flags = client->flags;
467         msgs[0].len = data_len + 1;
468         msgs[0].buf = buffer;
469
470         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
471         if (ret < 0)
472                 dev_err(&client->adapter->dev, "i2c write failed\n");
473
474         kfree(buffer);
475         return ret;
476 }
477
478 static acpi_status
479 i2c_acpi_space_handler(u32 function, acpi_physical_address command,
480                         u32 bits, u64 *value64,
481                         void *handler_context, void *region_context)
482 {
483         struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
484         struct i2c_acpi_handler_data *data = handler_context;
485         struct acpi_connection_info *info = &data->info;
486         struct acpi_resource_i2c_serialbus *sb;
487         struct i2c_adapter *adapter = data->adapter;
488         struct i2c_client *client;
489         struct acpi_resource *ares;
490         u32 accessor_type = function >> 16;
491         u8 action = function & ACPI_IO_MASK;
492         acpi_status ret;
493         int status;
494
495         ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
496         if (ACPI_FAILURE(ret))
497                 return ret;
498
499         client = kzalloc(sizeof(*client), GFP_KERNEL);
500         if (!client) {
501                 ret = AE_NO_MEMORY;
502                 goto err;
503         }
504
505         if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
506                 ret = AE_BAD_PARAMETER;
507                 goto err;
508         }
509
510         sb = &ares->data.i2c_serial_bus;
511         if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
512                 ret = AE_BAD_PARAMETER;
513                 goto err;
514         }
515
516         client->adapter = adapter;
517         client->addr = sb->slave_address;
518
519         if (sb->access_mode == ACPI_I2C_10BIT_MODE)
520                 client->flags |= I2C_CLIENT_TEN;
521
522         switch (accessor_type) {
523         case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
524                 if (action == ACPI_READ) {
525                         status = i2c_smbus_read_byte(client);
526                         if (status >= 0) {
527                                 gsb->bdata = status;
528                                 status = 0;
529                         }
530                 } else {
531                         status = i2c_smbus_write_byte(client, gsb->bdata);
532                 }
533                 break;
534
535         case ACPI_GSB_ACCESS_ATTRIB_BYTE:
536                 if (action == ACPI_READ) {
537                         status = i2c_smbus_read_byte_data(client, command);
538                         if (status >= 0) {
539                                 gsb->bdata = status;
540                                 status = 0;
541                         }
542                 } else {
543                         status = i2c_smbus_write_byte_data(client, command,
544                                         gsb->bdata);
545                 }
546                 break;
547
548         case ACPI_GSB_ACCESS_ATTRIB_WORD:
549                 if (action == ACPI_READ) {
550                         status = i2c_smbus_read_word_data(client, command);
551                         if (status >= 0) {
552                                 gsb->wdata = status;
553                                 status = 0;
554                         }
555                 } else {
556                         status = i2c_smbus_write_word_data(client, command,
557                                         gsb->wdata);
558                 }
559                 break;
560
561         case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
562                 if (action == ACPI_READ) {
563                         status = i2c_smbus_read_block_data(client, command,
564                                         gsb->data);
565                         if (status >= 0) {
566                                 gsb->len = status;
567                                 status = 0;
568                         }
569                 } else {
570                         status = i2c_smbus_write_block_data(client, command,
571                                         gsb->len, gsb->data);
572                 }
573                 break;
574
575         case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
576                 if (action == ACPI_READ) {
577                         status = acpi_gsb_i2c_read_bytes(client, command,
578                                         gsb->data, info->access_length);
579                         if (status > 0)
580                                 status = 0;
581                 } else {
582                         status = acpi_gsb_i2c_write_bytes(client, command,
583                                         gsb->data, info->access_length);
584                 }
585                 break;
586
587         default:
588                 dev_warn(&adapter->dev, "protocol 0x%02x not supported for client 0x%02x\n",
589                          accessor_type, client->addr);
590                 ret = AE_BAD_PARAMETER;
591                 goto err;
592         }
593
594         gsb->status = status;
595
596  err:
597         kfree(client);
598         ACPI_FREE(ares);
599         return ret;
600 }
601
602
603 static int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
604 {
605         acpi_handle handle;
606         struct i2c_acpi_handler_data *data;
607         acpi_status status;
608
609         if (!adapter->dev.parent)
610                 return -ENODEV;
611
612         handle = ACPI_HANDLE(adapter->dev.parent);
613
614         if (!handle)
615                 return -ENODEV;
616
617         data = kzalloc(sizeof(struct i2c_acpi_handler_data),
618                             GFP_KERNEL);
619         if (!data)
620                 return -ENOMEM;
621
622         data->adapter = adapter;
623         status = acpi_bus_attach_private_data(handle, (void *)data);
624         if (ACPI_FAILURE(status)) {
625                 kfree(data);
626                 return -ENOMEM;
627         }
628
629         status = acpi_install_address_space_handler(handle,
630                                 ACPI_ADR_SPACE_GSBUS,
631                                 &i2c_acpi_space_handler,
632                                 NULL,
633                                 data);
634         if (ACPI_FAILURE(status)) {
635                 dev_err(&adapter->dev, "Error installing i2c space handler\n");
636                 acpi_bus_detach_private_data(handle);
637                 kfree(data);
638                 return -ENOMEM;
639         }
640
641         acpi_walk_dep_device_list(handle);
642         return 0;
643 }
644
645 static void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
646 {
647         acpi_handle handle;
648         struct i2c_acpi_handler_data *data;
649         acpi_status status;
650
651         if (!adapter->dev.parent)
652                 return;
653
654         handle = ACPI_HANDLE(adapter->dev.parent);
655
656         if (!handle)
657                 return;
658
659         acpi_remove_address_space_handler(handle,
660                                 ACPI_ADR_SPACE_GSBUS,
661                                 &i2c_acpi_space_handler);
662
663         status = acpi_bus_get_private_data(handle, (void **)&data);
664         if (ACPI_SUCCESS(status))
665                 kfree(data);
666
667         acpi_bus_detach_private_data(handle);
668 }
669 #else /* CONFIG_ACPI_I2C_OPREGION */
670 static inline void i2c_acpi_remove_space_handler(struct i2c_adapter *adapter)
671 { }
672
673 static inline int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
674 { return 0; }
675 #endif /* CONFIG_ACPI_I2C_OPREGION */
676
677 /* ------------------------------------------------------------------------- */
678
679 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
680                                                 const struct i2c_client *client)
681 {
682         while (id->name[0]) {
683                 if (strcmp(client->name, id->name) == 0)
684                         return id;
685                 id++;
686         }
687         return NULL;
688 }
689
690 static int i2c_device_match(struct device *dev, struct device_driver *drv)
691 {
692         struct i2c_client       *client = i2c_verify_client(dev);
693         struct i2c_driver       *driver;
694
695         if (!client)
696                 return 0;
697
698         /* Attempt an OF style match */
699         if (of_driver_match_device(dev, drv))
700                 return 1;
701
702         /* Then ACPI style match */
703         if (acpi_driver_match_device(dev, drv))
704                 return 1;
705
706         driver = to_i2c_driver(drv);
707         /* match on an id table if there is one */
708         if (driver->id_table)
709                 return i2c_match_id(driver->id_table, client) != NULL;
710
711         return 0;
712 }
713
714 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
715 {
716         struct i2c_client *client = to_i2c_client(dev);
717         int rc;
718
719         rc = acpi_device_uevent_modalias(dev, env);
720         if (rc != -ENODEV)
721                 return rc;
722
723         return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
724 }
725
726 /* i2c bus recovery routines */
727 static int get_scl_gpio_value(struct i2c_adapter *adap)
728 {
729         return gpio_get_value(adap->bus_recovery_info->scl_gpio);
730 }
731
732 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
733 {
734         gpio_set_value(adap->bus_recovery_info->scl_gpio, val);
735 }
736
737 static int get_sda_gpio_value(struct i2c_adapter *adap)
738 {
739         return gpio_get_value(adap->bus_recovery_info->sda_gpio);
740 }
741
742 static int i2c_get_gpios_for_recovery(struct i2c_adapter *adap)
743 {
744         struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
745         struct device *dev = &adap->dev;
746         int ret = 0;
747
748         ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN |
749                         GPIOF_OUT_INIT_HIGH, "i2c-scl");
750         if (ret) {
751                 dev_warn(dev, "Can't get SCL gpio: %d\n", bri->scl_gpio);
752                 return ret;
753         }
754
755         if (bri->get_sda) {
756                 if (gpio_request_one(bri->sda_gpio, GPIOF_IN, "i2c-sda")) {
757                         /* work without SDA polling */
758                         dev_warn(dev, "Can't get SDA gpio: %d. Not using SDA polling\n",
759                                         bri->sda_gpio);
760                         bri->get_sda = NULL;
761                 }
762         }
763
764         return ret;
765 }
766
767 static void i2c_put_gpios_for_recovery(struct i2c_adapter *adap)
768 {
769         struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
770
771         if (bri->get_sda)
772                 gpio_free(bri->sda_gpio);
773
774         gpio_free(bri->scl_gpio);
775 }
776
777 /*
778  * We are generating clock pulses. ndelay() determines durating of clk pulses.
779  * We will generate clock with rate 100 KHz and so duration of both clock levels
780  * is: delay in ns = (10^6 / 100) / 2
781  */
782 #define RECOVERY_NDELAY         5000
783 #define RECOVERY_CLK_CNT        9
784
785 static int i2c_generic_recovery(struct i2c_adapter *adap)
786 {
787         struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
788         int i = 0, val = 1, ret = 0;
789
790         if (bri->prepare_recovery)
791                 bri->prepare_recovery(adap);
792
793         bri->set_scl(adap, val);
794         ndelay(RECOVERY_NDELAY);
795
796         /*
797          * By this time SCL is high, as we need to give 9 falling-rising edges
798          */
799         while (i++ < RECOVERY_CLK_CNT * 2) {
800                 if (val) {
801                         /* Break if SDA is high */
802                         if (bri->get_sda && bri->get_sda(adap))
803                                         break;
804                         /* SCL shouldn't be low here */
805                         if (!bri->get_scl(adap)) {
806                                 dev_err(&adap->dev,
807                                         "SCL is stuck low, exit recovery\n");
808                                 ret = -EBUSY;
809                                 break;
810                         }
811                 }
812
813                 val = !val;
814                 bri->set_scl(adap, val);
815                 ndelay(RECOVERY_NDELAY);
816         }
817
818         if (bri->unprepare_recovery)
819                 bri->unprepare_recovery(adap);
820
821         return ret;
822 }
823
824 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
825 {
826         return i2c_generic_recovery(adap);
827 }
828 EXPORT_SYMBOL_GPL(i2c_generic_scl_recovery);
829
830 int i2c_generic_gpio_recovery(struct i2c_adapter *adap)
831 {
832         int ret;
833
834         ret = i2c_get_gpios_for_recovery(adap);
835         if (ret)
836                 return ret;
837
838         ret = i2c_generic_recovery(adap);
839         i2c_put_gpios_for_recovery(adap);
840
841         return ret;
842 }
843 EXPORT_SYMBOL_GPL(i2c_generic_gpio_recovery);
844
845 int i2c_recover_bus(struct i2c_adapter *adap)
846 {
847         if (!adap->bus_recovery_info)
848                 return -EOPNOTSUPP;
849
850         dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
851         return adap->bus_recovery_info->recover_bus(adap);
852 }
853 EXPORT_SYMBOL_GPL(i2c_recover_bus);
854
855 static void i2c_init_recovery(struct i2c_adapter *adap)
856 {
857         struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
858         char *err_str;
859
860         if (!bri)
861                 return;
862
863         if (!bri->recover_bus) {
864                 err_str = "no recover_bus() found";
865                 goto err;
866         }
867
868         /* Generic GPIO recovery */
869         if (bri->recover_bus == i2c_generic_gpio_recovery) {
870                 if (!gpio_is_valid(bri->scl_gpio)) {
871                         err_str = "invalid SCL gpio";
872                         goto err;
873                 }
874
875                 if (gpio_is_valid(bri->sda_gpio))
876                         bri->get_sda = get_sda_gpio_value;
877                 else
878                         bri->get_sda = NULL;
879
880                 bri->get_scl = get_scl_gpio_value;
881                 bri->set_scl = set_scl_gpio_value;
882         } else if (bri->recover_bus == i2c_generic_scl_recovery) {
883                 /* Generic SCL recovery */
884                 if (!bri->set_scl || !bri->get_scl) {
885                         err_str = "no {get|set}_scl() found";
886                         goto err;
887                 }
888         }
889
890         return;
891  err:
892         dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
893         adap->bus_recovery_info = NULL;
894 }
895
896 static int i2c_device_probe(struct device *dev)
897 {
898         struct i2c_client       *client = i2c_verify_client(dev);
899         struct i2c_driver       *driver;
900         int status;
901
902         if (!client)
903                 return 0;
904
905         if (!client->irq) {
906                 int irq = -ENOENT;
907
908                 if (dev->of_node) {
909                         irq = of_irq_get_byname(dev->of_node, "irq");
910                         if (irq == -EINVAL || irq == -ENODATA)
911                                 irq = of_irq_get(dev->of_node, 0);
912                 } else if (ACPI_COMPANION(dev)) {
913                         irq = acpi_dev_gpio_irq_get(ACPI_COMPANION(dev), 0);
914                 }
915                 if (irq == -EPROBE_DEFER)
916                         return irq;
917                 if (irq < 0)
918                         irq = 0;
919
920                 client->irq = irq;
921         }
922
923         driver = to_i2c_driver(dev->driver);
924         if (!driver->probe || !driver->id_table)
925                 return -ENODEV;
926
927         if (client->flags & I2C_CLIENT_WAKE) {
928                 int wakeirq = -ENOENT;
929
930                 if (dev->of_node) {
931                         wakeirq = of_irq_get_byname(dev->of_node, "wakeup");
932                         if (wakeirq == -EPROBE_DEFER)
933                                 return wakeirq;
934                 }
935
936                 device_init_wakeup(&client->dev, true);
937
938                 if (wakeirq > 0 && wakeirq != client->irq)
939                         status = dev_pm_set_dedicated_wake_irq(dev, wakeirq);
940                 else if (client->irq > 0)
941                         status = dev_pm_set_wake_irq(dev, client->irq);
942                 else
943                         status = 0;
944
945                 if (status)
946                         dev_warn(&client->dev, "failed to set up wakeup irq\n");
947         }
948
949         dev_dbg(dev, "probe\n");
950
951         status = of_clk_set_defaults(dev->of_node, false);
952         if (status < 0)
953                 goto err_clear_wakeup_irq;
954
955         status = dev_pm_domain_attach(&client->dev, true);
956         if (status == -EPROBE_DEFER)
957                 goto err_clear_wakeup_irq;
958
959         status = driver->probe(client, i2c_match_id(driver->id_table, client));
960         if (status)
961                 goto err_detach_pm_domain;
962
963         return 0;
964
965 err_detach_pm_domain:
966         dev_pm_domain_detach(&client->dev, true);
967 err_clear_wakeup_irq:
968         dev_pm_clear_wake_irq(&client->dev);
969         device_init_wakeup(&client->dev, false);
970         return status;
971 }
972
973 static int i2c_device_remove(struct device *dev)
974 {
975         struct i2c_client       *client = i2c_verify_client(dev);
976         struct i2c_driver       *driver;
977         int status = 0;
978
979         if (!client || !dev->driver)
980                 return 0;
981
982         driver = to_i2c_driver(dev->driver);
983         if (driver->remove) {
984                 dev_dbg(dev, "remove\n");
985                 status = driver->remove(client);
986         }
987
988         dev_pm_domain_detach(&client->dev, true);
989
990         dev_pm_clear_wake_irq(&client->dev);
991         device_init_wakeup(&client->dev, false);
992
993         return status;
994 }
995
996 static void i2c_device_shutdown(struct device *dev)
997 {
998         struct i2c_client *client = i2c_verify_client(dev);
999         struct i2c_driver *driver;
1000
1001         if (!client || !dev->driver)
1002                 return;
1003         driver = to_i2c_driver(dev->driver);
1004         if (driver->shutdown)
1005                 driver->shutdown(client);
1006 }
1007
1008 static void i2c_client_dev_release(struct device *dev)
1009 {
1010         kfree(to_i2c_client(dev));
1011 }
1012
1013 static ssize_t
1014 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1015 {
1016         return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
1017                        to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
1018 }
1019 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1020
1021 static ssize_t
1022 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
1023 {
1024         struct i2c_client *client = to_i2c_client(dev);
1025         int len;
1026
1027         len = acpi_device_modalias(dev, buf, PAGE_SIZE -1);
1028         if (len != -ENODEV)
1029                 return len;
1030
1031         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
1032 }
1033 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
1034
1035 static struct attribute *i2c_dev_attrs[] = {
1036         &dev_attr_name.attr,
1037         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
1038         &dev_attr_modalias.attr,
1039         NULL
1040 };
1041 ATTRIBUTE_GROUPS(i2c_dev);
1042
1043 struct bus_type i2c_bus_type = {
1044         .name           = "i2c",
1045         .match          = i2c_device_match,
1046         .probe          = i2c_device_probe,
1047         .remove         = i2c_device_remove,
1048         .shutdown       = i2c_device_shutdown,
1049 };
1050 EXPORT_SYMBOL_GPL(i2c_bus_type);
1051
1052 static struct device_type i2c_client_type = {
1053         .groups         = i2c_dev_groups,
1054         .uevent         = i2c_device_uevent,
1055         .release        = i2c_client_dev_release,
1056 };
1057
1058
1059 /**
1060  * i2c_verify_client - return parameter as i2c_client, or NULL
1061  * @dev: device, probably from some driver model iterator
1062  *
1063  * When traversing the driver model tree, perhaps using driver model
1064  * iterators like @device_for_each_child(), you can't assume very much
1065  * about the nodes you find.  Use this function to avoid oopses caused
1066  * by wrongly treating some non-I2C device as an i2c_client.
1067  */
1068 struct i2c_client *i2c_verify_client(struct device *dev)
1069 {
1070         return (dev->type == &i2c_client_type)
1071                         ? to_i2c_client(dev)
1072                         : NULL;
1073 }
1074 EXPORT_SYMBOL(i2c_verify_client);
1075
1076
1077 /* Return a unique address which takes the flags of the client into account */
1078 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
1079 {
1080         unsigned short addr = client->addr;
1081
1082         /* For some client flags, add an arbitrary offset to avoid collisions */
1083         if (client->flags & I2C_CLIENT_TEN)
1084                 addr |= I2C_ADDR_OFFSET_TEN_BIT;
1085
1086         if (client->flags & I2C_CLIENT_SLAVE)
1087                 addr |= I2C_ADDR_OFFSET_SLAVE;
1088
1089         return addr;
1090 }
1091
1092 /* This is a permissive address validity check, I2C address map constraints
1093  * are purposely not enforced, except for the general call address. */
1094 static int i2c_check_addr_validity(unsigned addr, unsigned short flags)
1095 {
1096         if (flags & I2C_CLIENT_TEN) {
1097                 /* 10-bit address, all values are valid */
1098                 if (addr > 0x3ff)
1099                         return -EINVAL;
1100         } else {
1101                 /* 7-bit address, reject the general call address */
1102                 if (addr == 0x00 || addr > 0x7f)
1103                         return -EINVAL;
1104         }
1105         return 0;
1106 }
1107
1108 /* And this is a strict address validity check, used when probing. If a
1109  * device uses a reserved address, then it shouldn't be probed. 7-bit
1110  * addressing is assumed, 10-bit address devices are rare and should be
1111  * explicitly enumerated. */
1112 static int i2c_check_7bit_addr_validity_strict(unsigned short addr)
1113 {
1114         /*
1115          * Reserved addresses per I2C specification:
1116          *  0x00       General call address / START byte
1117          *  0x01       CBUS address
1118          *  0x02       Reserved for different bus format
1119          *  0x03       Reserved for future purposes
1120          *  0x04-0x07  Hs-mode master code
1121          *  0x78-0x7b  10-bit slave addressing
1122          *  0x7c-0x7f  Reserved for future purposes
1123          */
1124         if (addr < 0x08 || addr > 0x77)
1125                 return -EINVAL;
1126         return 0;
1127 }
1128
1129 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
1130 {
1131         struct i2c_client       *client = i2c_verify_client(dev);
1132         int                     addr = *(int *)addrp;
1133
1134         if (client && i2c_encode_flags_to_addr(client) == addr)
1135                 return -EBUSY;
1136         return 0;
1137 }
1138
1139 /* walk up mux tree */
1140 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
1141 {
1142         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1143         int result;
1144
1145         result = device_for_each_child(&adapter->dev, &addr,
1146                                         __i2c_check_addr_busy);
1147
1148         if (!result && parent)
1149                 result = i2c_check_mux_parents(parent, addr);
1150
1151         return result;
1152 }
1153
1154 /* recurse down mux tree */
1155 static int i2c_check_mux_children(struct device *dev, void *addrp)
1156 {
1157         int result;
1158
1159         if (dev->type == &i2c_adapter_type)
1160                 result = device_for_each_child(dev, addrp,
1161                                                 i2c_check_mux_children);
1162         else
1163                 result = __i2c_check_addr_busy(dev, addrp);
1164
1165         return result;
1166 }
1167
1168 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
1169 {
1170         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
1171         int result = 0;
1172
1173         if (parent)
1174                 result = i2c_check_mux_parents(parent, addr);
1175
1176         if (!result)
1177                 result = device_for_each_child(&adapter->dev, &addr,
1178                                                 i2c_check_mux_children);
1179
1180         return result;
1181 }
1182
1183 /**
1184  * i2c_adapter_lock_bus - Get exclusive access to an I2C bus segment
1185  * @adapter: Target I2C bus segment
1186  * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
1187  *      locks only this branch in the adapter tree
1188  */
1189 static void i2c_adapter_lock_bus(struct i2c_adapter *adapter,
1190                                  unsigned int flags)
1191 {
1192         rt_mutex_lock(&adapter->bus_lock);
1193 }
1194
1195 /**
1196  * i2c_adapter_trylock_bus - Try to get exclusive access to an I2C bus segment
1197  * @adapter: Target I2C bus segment
1198  * @flags: I2C_LOCK_ROOT_ADAPTER trylocks the root i2c adapter, I2C_LOCK_SEGMENT
1199  *      trylocks only this branch in the adapter tree
1200  */
1201 static int i2c_adapter_trylock_bus(struct i2c_adapter *adapter,
1202                                    unsigned int flags)
1203 {
1204         return rt_mutex_trylock(&adapter->bus_lock);
1205 }
1206
1207 /**
1208  * i2c_adapter_unlock_bus - Release exclusive access to an I2C bus segment
1209  * @adapter: Target I2C bus segment
1210  * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
1211  *      unlocks only this branch in the adapter tree
1212  */
1213 static void i2c_adapter_unlock_bus(struct i2c_adapter *adapter,
1214                                    unsigned int flags)
1215 {
1216         rt_mutex_unlock(&adapter->bus_lock);
1217 }
1218
1219 static void i2c_dev_set_name(struct i2c_adapter *adap,
1220                              struct i2c_client *client)
1221 {
1222         struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1223
1224         if (adev) {
1225                 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
1226                 return;
1227         }
1228
1229         dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
1230                      i2c_encode_flags_to_addr(client));
1231 }
1232
1233 /**
1234  * i2c_new_device - instantiate an i2c device
1235  * @adap: the adapter managing the device
1236  * @info: describes one I2C device; bus_num is ignored
1237  * Context: can sleep
1238  *
1239  * Create an i2c device. Binding is handled through driver model
1240  * probe()/remove() methods.  A driver may be bound to this device when we
1241  * return from this function, or any later moment (e.g. maybe hotplugging will
1242  * load the driver module).  This call is not appropriate for use by mainboard
1243  * initialization logic, which usually runs during an arch_initcall() long
1244  * before any i2c_adapter could exist.
1245  *
1246  * This returns the new i2c client, which may be saved for later use with
1247  * i2c_unregister_device(); or NULL to indicate an error.
1248  */
1249 struct i2c_client *
1250 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
1251 {
1252         struct i2c_client       *client;
1253         int                     status;
1254
1255         client = kzalloc(sizeof *client, GFP_KERNEL);
1256         if (!client)
1257                 return NULL;
1258
1259         client->adapter = adap;
1260
1261         client->dev.platform_data = info->platform_data;
1262
1263         if (info->archdata)
1264                 client->dev.archdata = *info->archdata;
1265
1266         client->flags = info->flags;
1267         client->addr = info->addr;
1268         client->irq = info->irq;
1269
1270         strlcpy(client->name, info->type, sizeof(client->name));
1271
1272         status = i2c_check_addr_validity(client->addr, client->flags);
1273         if (status) {
1274                 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
1275                         client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
1276                 goto out_err_silent;
1277         }
1278
1279         /* Check for address business */
1280         status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
1281         if (status)
1282                 goto out_err;
1283
1284         client->dev.parent = &client->adapter->dev;
1285         client->dev.bus = &i2c_bus_type;
1286         client->dev.type = &i2c_client_type;
1287         client->dev.of_node = info->of_node;
1288         client->dev.fwnode = info->fwnode;
1289
1290         i2c_dev_set_name(adap, client);
1291         status = device_register(&client->dev);
1292         if (status)
1293                 goto out_err;
1294
1295         dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1296                 client->name, dev_name(&client->dev));
1297
1298         return client;
1299
1300 out_err:
1301         dev_err(&adap->dev,
1302                 "Failed to register i2c client %s at 0x%02x (%d)\n",
1303                 client->name, client->addr, status);
1304 out_err_silent:
1305         kfree(client);
1306         return NULL;
1307 }
1308 EXPORT_SYMBOL_GPL(i2c_new_device);
1309
1310
1311 /**
1312  * i2c_unregister_device - reverse effect of i2c_new_device()
1313  * @client: value returned from i2c_new_device()
1314  * Context: can sleep
1315  */
1316 void i2c_unregister_device(struct i2c_client *client)
1317 {
1318         if (client->dev.of_node)
1319                 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1320         if (ACPI_COMPANION(&client->dev))
1321                 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1322         device_unregister(&client->dev);
1323 }
1324 EXPORT_SYMBOL_GPL(i2c_unregister_device);
1325
1326
1327 static const struct i2c_device_id dummy_id[] = {
1328         { "dummy", 0 },
1329         { },
1330 };
1331
1332 static int dummy_probe(struct i2c_client *client,
1333                        const struct i2c_device_id *id)
1334 {
1335         return 0;
1336 }
1337
1338 static int dummy_remove(struct i2c_client *client)
1339 {
1340         return 0;
1341 }
1342
1343 static struct i2c_driver dummy_driver = {
1344         .driver.name    = "dummy",
1345         .probe          = dummy_probe,
1346         .remove         = dummy_remove,
1347         .id_table       = dummy_id,
1348 };
1349
1350 /**
1351  * i2c_new_dummy - return a new i2c device bound to a dummy driver
1352  * @adapter: the adapter managing the device
1353  * @address: seven bit address to be used
1354  * Context: can sleep
1355  *
1356  * This returns an I2C client bound to the "dummy" driver, intended for use
1357  * with devices that consume multiple addresses.  Examples of such chips
1358  * include various EEPROMS (like 24c04 and 24c08 models).
1359  *
1360  * These dummy devices have two main uses.  First, most I2C and SMBus calls
1361  * except i2c_transfer() need a client handle; the dummy will be that handle.
1362  * And second, this prevents the specified address from being bound to a
1363  * different driver.
1364  *
1365  * This returns the new i2c client, which should be saved for later use with
1366  * i2c_unregister_device(); or NULL to indicate an error.
1367  */
1368 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
1369 {
1370         struct i2c_board_info info = {
1371                 I2C_BOARD_INFO("dummy", address),
1372         };
1373
1374         return i2c_new_device(adapter, &info);
1375 }
1376 EXPORT_SYMBOL_GPL(i2c_new_dummy);
1377
1378 /**
1379  * i2c_new_secondary_device - Helper to get the instantiated secondary address
1380  * and create the associated device
1381  * @client: Handle to the primary client
1382  * @name: Handle to specify which secondary address to get
1383  * @default_addr: Used as a fallback if no secondary address was specified
1384  * Context: can sleep
1385  *
1386  * I2C clients can be composed of multiple I2C slaves bound together in a single
1387  * component. The I2C client driver then binds to the master I2C slave and needs
1388  * to create I2C dummy clients to communicate with all the other slaves.
1389  *
1390  * This function creates and returns an I2C dummy client whose I2C address is
1391  * retrieved from the platform firmware based on the given slave name. If no
1392  * address is specified by the firmware default_addr is used.
1393  *
1394  * On DT-based platforms the address is retrieved from the "reg" property entry
1395  * cell whose "reg-names" value matches the slave name.
1396  *
1397  * This returns the new i2c client, which should be saved for later use with
1398  * i2c_unregister_device(); or NULL to indicate an error.
1399  */
1400 struct i2c_client *i2c_new_secondary_device(struct i2c_client *client,
1401                                                 const char *name,
1402                                                 u16 default_addr)
1403 {
1404         struct device_node *np = client->dev.of_node;
1405         u32 addr = default_addr;
1406         int i;
1407
1408         if (np) {
1409                 i = of_property_match_string(np, "reg-names", name);
1410                 if (i >= 0)
1411                         of_property_read_u32_index(np, "reg", i, &addr);
1412         }
1413
1414         dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1415         return i2c_new_dummy(client->adapter, addr);
1416 }
1417 EXPORT_SYMBOL_GPL(i2c_new_secondary_device);
1418
1419 /* ------------------------------------------------------------------------- */
1420
1421 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
1422
1423 static void i2c_adapter_dev_release(struct device *dev)
1424 {
1425         struct i2c_adapter *adap = to_i2c_adapter(dev);
1426         complete(&adap->dev_released);
1427 }
1428
1429 unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
1430 {
1431         unsigned int depth = 0;
1432
1433         while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
1434                 depth++;
1435
1436         WARN_ONCE(depth >= MAX_LOCKDEP_SUBCLASSES,
1437                   "adapter depth exceeds lockdep subclass limit\n");
1438
1439         return depth;
1440 }
1441 EXPORT_SYMBOL_GPL(i2c_adapter_depth);
1442
1443 /*
1444  * Let users instantiate I2C devices through sysfs. This can be used when
1445  * platform initialization code doesn't contain the proper data for
1446  * whatever reason. Also useful for drivers that do device detection and
1447  * detection fails, either because the device uses an unexpected address,
1448  * or this is a compatible device with different ID register values.
1449  *
1450  * Parameter checking may look overzealous, but we really don't want
1451  * the user to provide incorrect parameters.
1452  */
1453 static ssize_t
1454 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
1455                      const char *buf, size_t count)
1456 {
1457         struct i2c_adapter *adap = to_i2c_adapter(dev);
1458         struct i2c_board_info info;
1459         struct i2c_client *client;
1460         char *blank, end;
1461         int res;
1462
1463         memset(&info, 0, sizeof(struct i2c_board_info));
1464
1465         blank = strchr(buf, ' ');
1466         if (!blank) {
1467                 dev_err(dev, "%s: Missing parameters\n", "new_device");
1468                 return -EINVAL;
1469         }
1470         if (blank - buf > I2C_NAME_SIZE - 1) {
1471                 dev_err(dev, "%s: Invalid device name\n", "new_device");
1472                 return -EINVAL;
1473         }
1474         memcpy(info.type, buf, blank - buf);
1475
1476         /* Parse remaining parameters, reject extra parameters */
1477         res = sscanf(++blank, "%hi%c", &info.addr, &end);
1478         if (res < 1) {
1479                 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
1480                 return -EINVAL;
1481         }
1482         if (res > 1  && end != '\n') {
1483                 dev_err(dev, "%s: Extra parameters\n", "new_device");
1484                 return -EINVAL;
1485         }
1486
1487         if ((info.addr & I2C_ADDR_OFFSET_TEN_BIT) == I2C_ADDR_OFFSET_TEN_BIT) {
1488                 info.addr &= ~I2C_ADDR_OFFSET_TEN_BIT;
1489                 info.flags |= I2C_CLIENT_TEN;
1490         }
1491
1492         if (info.addr & I2C_ADDR_OFFSET_SLAVE) {
1493                 info.addr &= ~I2C_ADDR_OFFSET_SLAVE;
1494                 info.flags |= I2C_CLIENT_SLAVE;
1495         }
1496
1497         client = i2c_new_device(adap, &info);
1498         if (!client)
1499                 return -EINVAL;
1500
1501         /* Keep track of the added device */
1502         mutex_lock(&adap->userspace_clients_lock);
1503         list_add_tail(&client->detected, &adap->userspace_clients);
1504         mutex_unlock(&adap->userspace_clients_lock);
1505         dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
1506                  info.type, info.addr);
1507
1508         return count;
1509 }
1510 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
1511
1512 /*
1513  * And of course let the users delete the devices they instantiated, if
1514  * they got it wrong. This interface can only be used to delete devices
1515  * instantiated by i2c_sysfs_new_device above. This guarantees that we
1516  * don't delete devices to which some kernel code still has references.
1517  *
1518  * Parameter checking may look overzealous, but we really don't want
1519  * the user to delete the wrong device.
1520  */
1521 static ssize_t
1522 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
1523                         const char *buf, size_t count)
1524 {
1525         struct i2c_adapter *adap = to_i2c_adapter(dev);
1526         struct i2c_client *client, *next;
1527         unsigned short addr;
1528         char end;
1529         int res;
1530
1531         /* Parse parameters, reject extra parameters */
1532         res = sscanf(buf, "%hi%c", &addr, &end);
1533         if (res < 1) {
1534                 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
1535                 return -EINVAL;
1536         }
1537         if (res > 1  && end != '\n') {
1538                 dev_err(dev, "%s: Extra parameters\n", "delete_device");
1539                 return -EINVAL;
1540         }
1541
1542         /* Make sure the device was added through sysfs */
1543         res = -ENOENT;
1544         mutex_lock_nested(&adap->userspace_clients_lock,
1545                           i2c_adapter_depth(adap));
1546         list_for_each_entry_safe(client, next, &adap->userspace_clients,
1547                                  detected) {
1548                 if (i2c_encode_flags_to_addr(client) == addr) {
1549                         dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
1550                                  "delete_device", client->name, client->addr);
1551
1552                         list_del(&client->detected);
1553                         i2c_unregister_device(client);
1554                         res = count;
1555                         break;
1556                 }
1557         }
1558         mutex_unlock(&adap->userspace_clients_lock);
1559
1560         if (res < 0)
1561                 dev_err(dev, "%s: Can't find device in list\n",
1562                         "delete_device");
1563         return res;
1564 }
1565 static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
1566                                    i2c_sysfs_delete_device);
1567
1568 static struct attribute *i2c_adapter_attrs[] = {
1569         &dev_attr_name.attr,
1570         &dev_attr_new_device.attr,
1571         &dev_attr_delete_device.attr,
1572         NULL
1573 };
1574 ATTRIBUTE_GROUPS(i2c_adapter);
1575
1576 struct device_type i2c_adapter_type = {
1577         .groups         = i2c_adapter_groups,
1578         .release        = i2c_adapter_dev_release,
1579 };
1580 EXPORT_SYMBOL_GPL(i2c_adapter_type);
1581
1582 /**
1583  * i2c_verify_adapter - return parameter as i2c_adapter or NULL
1584  * @dev: device, probably from some driver model iterator
1585  *
1586  * When traversing the driver model tree, perhaps using driver model
1587  * iterators like @device_for_each_child(), you can't assume very much
1588  * about the nodes you find.  Use this function to avoid oopses caused
1589  * by wrongly treating some non-I2C device as an i2c_adapter.
1590  */
1591 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
1592 {
1593         return (dev->type == &i2c_adapter_type)
1594                         ? to_i2c_adapter(dev)
1595                         : NULL;
1596 }
1597 EXPORT_SYMBOL(i2c_verify_adapter);
1598
1599 #ifdef CONFIG_I2C_COMPAT
1600 static struct class_compat *i2c_adapter_compat_class;
1601 #endif
1602
1603 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
1604 {
1605         struct i2c_devinfo      *devinfo;
1606
1607         down_read(&__i2c_board_lock);
1608         list_for_each_entry(devinfo, &__i2c_board_list, list) {
1609                 if (devinfo->busnum == adapter->nr
1610                                 && !i2c_new_device(adapter,
1611                                                 &devinfo->board_info))
1612                         dev_err(&adapter->dev,
1613                                 "Can't create device at 0x%02x\n",
1614                                 devinfo->board_info.addr);
1615         }
1616         up_read(&__i2c_board_lock);
1617 }
1618
1619 /* OF support code */
1620
1621 #if IS_ENABLED(CONFIG_OF)
1622 static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap,
1623                                                  struct device_node *node)
1624 {
1625         struct i2c_client *result;
1626         struct i2c_board_info info = {};
1627         struct dev_archdata dev_ad = {};
1628         const __be32 *addr_be;
1629         u32 addr;
1630         int len;
1631
1632         dev_dbg(&adap->dev, "of_i2c: register %s\n", node->full_name);
1633
1634         if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
1635                 dev_err(&adap->dev, "of_i2c: modalias failure on %s\n",
1636                         node->full_name);
1637                 return ERR_PTR(-EINVAL);
1638         }
1639
1640         addr_be = of_get_property(node, "reg", &len);
1641         if (!addr_be || (len < sizeof(*addr_be))) {
1642                 dev_err(&adap->dev, "of_i2c: invalid reg on %s\n",
1643                         node->full_name);
1644                 return ERR_PTR(-EINVAL);
1645         }
1646
1647         addr = be32_to_cpup(addr_be);
1648         if (addr & I2C_TEN_BIT_ADDRESS) {
1649                 addr &= ~I2C_TEN_BIT_ADDRESS;
1650                 info.flags |= I2C_CLIENT_TEN;
1651         }
1652
1653         if (addr & I2C_OWN_SLAVE_ADDRESS) {
1654                 addr &= ~I2C_OWN_SLAVE_ADDRESS;
1655                 info.flags |= I2C_CLIENT_SLAVE;
1656         }
1657
1658         if (i2c_check_addr_validity(addr, info.flags)) {
1659                 dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s\n",
1660                         info.addr, node->full_name);
1661                 return ERR_PTR(-EINVAL);
1662         }
1663
1664         info.addr = addr;
1665         info.of_node = of_node_get(node);
1666         info.archdata = &dev_ad;
1667
1668         if (of_get_property(node, "wakeup-source", NULL))
1669                 info.flags |= I2C_CLIENT_WAKE;
1670
1671         result = i2c_new_device(adap, &info);
1672         if (result == NULL) {
1673                 dev_err(&adap->dev, "of_i2c: Failure registering %s\n",
1674                         node->full_name);
1675                 of_node_put(node);
1676                 return ERR_PTR(-EINVAL);
1677         }
1678         return result;
1679 }
1680
1681 static void of_i2c_register_devices(struct i2c_adapter *adap)
1682 {
1683         struct device_node *node;
1684
1685         /* Only register child devices if the adapter has a node pointer set */
1686         if (!adap->dev.of_node)
1687                 return;
1688
1689         dev_dbg(&adap->dev, "of_i2c: walking child nodes\n");
1690
1691         for_each_available_child_of_node(adap->dev.of_node, node) {
1692                 if (of_node_test_and_set_flag(node, OF_POPULATED))
1693                         continue;
1694                 of_i2c_register_device(adap, node);
1695         }
1696 }
1697
1698 static int of_dev_node_match(struct device *dev, void *data)
1699 {
1700         return dev->of_node == data;
1701 }
1702
1703 /* must call put_device() when done with returned i2c_client device */
1704 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1705 {
1706         struct device *dev;
1707         struct i2c_client *client;
1708
1709         dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1710         if (!dev)
1711                 return NULL;
1712
1713         client = i2c_verify_client(dev);
1714         if (!client)
1715                 put_device(dev);
1716
1717         return client;
1718 }
1719 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1720
1721 /* must call put_device() when done with returned i2c_adapter device */
1722 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1723 {
1724         struct device *dev;
1725         struct i2c_adapter *adapter;
1726
1727         dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1728         if (!dev)
1729                 return NULL;
1730
1731         adapter = i2c_verify_adapter(dev);
1732         if (!adapter)
1733                 put_device(dev);
1734
1735         return adapter;
1736 }
1737 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1738
1739 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1740 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1741 {
1742         struct i2c_adapter *adapter;
1743
1744         adapter = of_find_i2c_adapter_by_node(node);
1745         if (!adapter)
1746                 return NULL;
1747
1748         if (!try_module_get(adapter->owner)) {
1749                 put_device(&adapter->dev);
1750                 adapter = NULL;
1751         }
1752
1753         return adapter;
1754 }
1755 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1756 #else
1757 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1758 #endif /* CONFIG_OF */
1759
1760 static int i2c_do_add_adapter(struct i2c_driver *driver,
1761                               struct i2c_adapter *adap)
1762 {
1763         /* Detect supported devices on that bus, and instantiate them */
1764         i2c_detect(adap, driver);
1765
1766         /* Let legacy drivers scan this bus for matching devices */
1767         if (driver->attach_adapter) {
1768                 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1769                          driver->driver.name);
1770                 dev_warn(&adap->dev,
1771                          "Please use another way to instantiate your i2c_client\n");
1772                 /* We ignore the return code; if it fails, too bad */
1773                 driver->attach_adapter(adap);
1774         }
1775         return 0;
1776 }
1777
1778 static int __process_new_adapter(struct device_driver *d, void *data)
1779 {
1780         return i2c_do_add_adapter(to_i2c_driver(d), data);
1781 }
1782
1783 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1784         .lock_bus =    i2c_adapter_lock_bus,
1785         .trylock_bus = i2c_adapter_trylock_bus,
1786         .unlock_bus =  i2c_adapter_unlock_bus,
1787 };
1788
1789 static int i2c_register_adapter(struct i2c_adapter *adap)
1790 {
1791         int res = -EINVAL;
1792
1793         /* Can't register until after driver model init */
1794         if (WARN_ON(!is_registered)) {
1795                 res = -EAGAIN;
1796                 goto out_list;
1797         }
1798
1799         /* Sanity checks */
1800         if (WARN(!adap->name[0], "i2c adapter has no name"))
1801                 goto out_list;
1802
1803         if (!adap->algo) {
1804                 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1805                 goto out_list;
1806         }
1807
1808         if (!adap->lock_ops)
1809                 adap->lock_ops = &i2c_adapter_lock_ops;
1810
1811         rt_mutex_init(&adap->bus_lock);
1812         rt_mutex_init(&adap->mux_lock);
1813         mutex_init(&adap->userspace_clients_lock);
1814         INIT_LIST_HEAD(&adap->userspace_clients);
1815
1816         /* Set default timeout to 1 second if not already set */
1817         if (adap->timeout == 0)
1818                 adap->timeout = HZ;
1819
1820         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1821         adap->dev.bus = &i2c_bus_type;
1822         adap->dev.type = &i2c_adapter_type;
1823         res = device_register(&adap->dev);
1824         if (res) {
1825                 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1826                 goto out_list;
1827         }
1828
1829         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1830
1831         pm_runtime_no_callbacks(&adap->dev);
1832         pm_suspend_ignore_children(&adap->dev, true);
1833         pm_runtime_enable(&adap->dev);
1834
1835 #ifdef CONFIG_I2C_COMPAT
1836         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1837                                        adap->dev.parent);
1838         if (res)
1839                 dev_warn(&adap->dev,
1840                          "Failed to create compatibility class link\n");
1841 #endif
1842
1843         i2c_init_recovery(adap);
1844
1845         /* create pre-declared device nodes */
1846         of_i2c_register_devices(adap);
1847         i2c_acpi_register_devices(adap);
1848         i2c_acpi_install_space_handler(adap);
1849
1850         if (adap->nr < __i2c_first_dynamic_bus_num)
1851                 i2c_scan_static_board_info(adap);
1852
1853         /* Notify drivers */
1854         mutex_lock(&core_lock);
1855         bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1856         mutex_unlock(&core_lock);
1857
1858         return 0;
1859
1860 out_list:
1861         mutex_lock(&core_lock);
1862         idr_remove(&i2c_adapter_idr, adap->nr);
1863         mutex_unlock(&core_lock);
1864         return res;
1865 }
1866
1867 /**
1868  * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1869  * @adap: the adapter to register (with adap->nr initialized)
1870  * Context: can sleep
1871  *
1872  * See i2c_add_numbered_adapter() for details.
1873  */
1874 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1875 {
1876         int id;
1877
1878         mutex_lock(&core_lock);
1879         id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1880         mutex_unlock(&core_lock);
1881         if (WARN(id < 0, "couldn't get idr"))
1882                 return id == -ENOSPC ? -EBUSY : id;
1883
1884         return i2c_register_adapter(adap);
1885 }
1886
1887 /**
1888  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1889  * @adapter: the adapter to add
1890  * Context: can sleep
1891  *
1892  * This routine is used to declare an I2C adapter when its bus number
1893  * doesn't matter or when its bus number is specified by an dt alias.
1894  * Examples of bases when the bus number doesn't matter: I2C adapters
1895  * dynamically added by USB links or PCI plugin cards.
1896  *
1897  * When this returns zero, a new bus number was allocated and stored
1898  * in adap->nr, and the specified adapter became available for clients.
1899  * Otherwise, a negative errno value is returned.
1900  */
1901 int i2c_add_adapter(struct i2c_adapter *adapter)
1902 {
1903         struct device *dev = &adapter->dev;
1904         int id;
1905
1906         if (dev->of_node) {
1907                 id = of_alias_get_id(dev->of_node, "i2c");
1908                 if (id >= 0) {
1909                         adapter->nr = id;
1910                         return __i2c_add_numbered_adapter(adapter);
1911                 }
1912         }
1913
1914         mutex_lock(&core_lock);
1915         id = idr_alloc(&i2c_adapter_idr, adapter,
1916                        __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1917         mutex_unlock(&core_lock);
1918         if (WARN(id < 0, "couldn't get idr"))
1919                 return id;
1920
1921         adapter->nr = id;
1922
1923         return i2c_register_adapter(adapter);
1924 }
1925 EXPORT_SYMBOL(i2c_add_adapter);
1926
1927 /**
1928  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1929  * @adap: the adapter to register (with adap->nr initialized)
1930  * Context: can sleep
1931  *
1932  * This routine is used to declare an I2C adapter when its bus number
1933  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
1934  * or otherwise built in to the system's mainboard, and where i2c_board_info
1935  * is used to properly configure I2C devices.
1936  *
1937  * If the requested bus number is set to -1, then this function will behave
1938  * identically to i2c_add_adapter, and will dynamically assign a bus number.
1939  *
1940  * If no devices have pre-been declared for this bus, then be sure to
1941  * register the adapter before any dynamically allocated ones.  Otherwise
1942  * the required bus ID may not be available.
1943  *
1944  * When this returns zero, the specified adapter became available for
1945  * clients using the bus number provided in adap->nr.  Also, the table
1946  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1947  * and the appropriate driver model device nodes are created.  Otherwise, a
1948  * negative errno value is returned.
1949  */
1950 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1951 {
1952         if (adap->nr == -1) /* -1 means dynamically assign bus id */
1953                 return i2c_add_adapter(adap);
1954
1955         return __i2c_add_numbered_adapter(adap);
1956 }
1957 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1958
1959 static void i2c_do_del_adapter(struct i2c_driver *driver,
1960                               struct i2c_adapter *adapter)
1961 {
1962         struct i2c_client *client, *_n;
1963
1964         /* Remove the devices we created ourselves as the result of hardware
1965          * probing (using a driver's detect method) */
1966         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1967                 if (client->adapter == adapter) {
1968                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1969                                 client->name, client->addr);
1970                         list_del(&client->detected);
1971                         i2c_unregister_device(client);
1972                 }
1973         }
1974 }
1975
1976 static int __unregister_client(struct device *dev, void *dummy)
1977 {
1978         struct i2c_client *client = i2c_verify_client(dev);
1979         if (client && strcmp(client->name, "dummy"))
1980                 i2c_unregister_device(client);
1981         return 0;
1982 }
1983
1984 static int __unregister_dummy(struct device *dev, void *dummy)
1985 {
1986         struct i2c_client *client = i2c_verify_client(dev);
1987         if (client)
1988                 i2c_unregister_device(client);
1989         return 0;
1990 }
1991
1992 static int __process_removed_adapter(struct device_driver *d, void *data)
1993 {
1994         i2c_do_del_adapter(to_i2c_driver(d), data);
1995         return 0;
1996 }
1997
1998 /**
1999  * i2c_del_adapter - unregister I2C adapter
2000  * @adap: the adapter being unregistered
2001  * Context: can sleep
2002  *
2003  * This unregisters an I2C adapter which was previously registered
2004  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2005  */
2006 void i2c_del_adapter(struct i2c_adapter *adap)
2007 {
2008         struct i2c_adapter *found;
2009         struct i2c_client *client, *next;
2010
2011         /* First make sure that this adapter was ever added */
2012         mutex_lock(&core_lock);
2013         found = idr_find(&i2c_adapter_idr, adap->nr);
2014         mutex_unlock(&core_lock);
2015         if (found != adap) {
2016                 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2017                 return;
2018         }
2019
2020         i2c_acpi_remove_space_handler(adap);
2021         /* Tell drivers about this removal */
2022         mutex_lock(&core_lock);
2023         bus_for_each_drv(&i2c_bus_type, NULL, adap,
2024                                __process_removed_adapter);
2025         mutex_unlock(&core_lock);
2026
2027         /* Remove devices instantiated from sysfs */
2028         mutex_lock_nested(&adap->userspace_clients_lock,
2029                           i2c_adapter_depth(adap));
2030         list_for_each_entry_safe(client, next, &adap->userspace_clients,
2031                                  detected) {
2032                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2033                         client->addr);
2034                 list_del(&client->detected);
2035                 i2c_unregister_device(client);
2036         }
2037         mutex_unlock(&adap->userspace_clients_lock);
2038
2039         /* Detach any active clients. This can't fail, thus we do not
2040          * check the returned value. This is a two-pass process, because
2041          * we can't remove the dummy devices during the first pass: they
2042          * could have been instantiated by real devices wishing to clean
2043          * them up properly, so we give them a chance to do that first. */
2044         device_for_each_child(&adap->dev, NULL, __unregister_client);
2045         device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2046
2047 #ifdef CONFIG_I2C_COMPAT
2048         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2049                                  adap->dev.parent);
2050 #endif
2051
2052         /* device name is gone after device_unregister */
2053         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2054
2055         pm_runtime_disable(&adap->dev);
2056
2057         /* wait until all references to the device are gone
2058          *
2059          * FIXME: This is old code and should ideally be replaced by an
2060          * alternative which results in decoupling the lifetime of the struct
2061          * device from the i2c_adapter, like spi or netdev do. Any solution
2062          * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2063          */
2064         init_completion(&adap->dev_released);
2065         device_unregister(&adap->dev);
2066         wait_for_completion(&adap->dev_released);
2067
2068         /* free bus id */
2069         mutex_lock(&core_lock);
2070         idr_remove(&i2c_adapter_idr, adap->nr);
2071         mutex_unlock(&core_lock);
2072
2073         /* Clear the device structure in case this adapter is ever going to be
2074            added again */
2075         memset(&adap->dev, 0, sizeof(adap->dev));
2076 }
2077 EXPORT_SYMBOL(i2c_del_adapter);
2078
2079 /**
2080  * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2081  * @dev: The device to scan for I2C timing properties
2082  * @t: the i2c_timings struct to be filled with values
2083  * @use_defaults: bool to use sane defaults derived from the I2C specification
2084  *                when properties are not found, otherwise use 0
2085  *
2086  * Scan the device for the generic I2C properties describing timing parameters
2087  * for the signal and fill the given struct with the results. If a property was
2088  * not found and use_defaults was true, then maximum timings are assumed which
2089  * are derived from the I2C specification. If use_defaults is not used, the
2090  * results will be 0, so drivers can apply their own defaults later. The latter
2091  * is mainly intended for avoiding regressions of existing drivers which want
2092  * to switch to this function. New drivers almost always should use the defaults.
2093  */
2094
2095 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2096 {
2097         int ret;
2098
2099         memset(t, 0, sizeof(*t));
2100
2101         ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2102         if (ret && use_defaults)
2103                 t->bus_freq_hz = 100000;
2104
2105         ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2106         if (ret && use_defaults) {
2107                 if (t->bus_freq_hz <= 100000)
2108                         t->scl_rise_ns = 1000;
2109                 else if (t->bus_freq_hz <= 400000)
2110                         t->scl_rise_ns = 300;
2111                 else
2112                         t->scl_rise_ns = 120;
2113         }
2114
2115         ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2116         if (ret && use_defaults) {
2117                 if (t->bus_freq_hz <= 400000)
2118                         t->scl_fall_ns = 300;
2119                 else
2120                         t->scl_fall_ns = 120;
2121         }
2122
2123         device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2124
2125         ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2126         if (ret && use_defaults)
2127                 t->sda_fall_ns = t->scl_fall_ns;
2128 }
2129 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2130
2131 /* ------------------------------------------------------------------------- */
2132
2133 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2134 {
2135         int res;
2136
2137         mutex_lock(&core_lock);
2138         res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2139         mutex_unlock(&core_lock);
2140
2141         return res;
2142 }
2143 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2144
2145 static int __process_new_driver(struct device *dev, void *data)
2146 {
2147         if (dev->type != &i2c_adapter_type)
2148                 return 0;
2149         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2150 }
2151
2152 /*
2153  * An i2c_driver is used with one or more i2c_client (device) nodes to access
2154  * i2c slave chips, on a bus instance associated with some i2c_adapter.
2155  */
2156
2157 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2158 {
2159         int res;
2160
2161         /* Can't register until after driver model init */
2162         if (WARN_ON(!is_registered))
2163                 return -EAGAIN;
2164
2165         /* add the driver to the list of i2c drivers in the driver core */
2166         driver->driver.owner = owner;
2167         driver->driver.bus = &i2c_bus_type;
2168
2169         /* When registration returns, the driver core
2170          * will have called probe() for all matching-but-unbound devices.
2171          */
2172         res = driver_register(&driver->driver);
2173         if (res)
2174                 return res;
2175
2176         pr_debug("driver [%s] registered\n", driver->driver.name);
2177
2178         INIT_LIST_HEAD(&driver->clients);
2179         /* Walk the adapters that are already present */
2180         i2c_for_each_dev(driver, __process_new_driver);
2181
2182         return 0;
2183 }
2184 EXPORT_SYMBOL(i2c_register_driver);
2185
2186 static int __process_removed_driver(struct device *dev, void *data)
2187 {
2188         if (dev->type == &i2c_adapter_type)
2189                 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2190         return 0;
2191 }
2192
2193 /**
2194  * i2c_del_driver - unregister I2C driver
2195  * @driver: the driver being unregistered
2196  * Context: can sleep
2197  */
2198 void i2c_del_driver(struct i2c_driver *driver)
2199 {
2200         i2c_for_each_dev(driver, __process_removed_driver);
2201
2202         driver_unregister(&driver->driver);
2203         pr_debug("driver [%s] unregistered\n", driver->driver.name);
2204 }
2205 EXPORT_SYMBOL(i2c_del_driver);
2206
2207 /* ------------------------------------------------------------------------- */
2208
2209 /**
2210  * i2c_use_client - increments the reference count of the i2c client structure
2211  * @client: the client being referenced
2212  *
2213  * Each live reference to a client should be refcounted. The driver model does
2214  * that automatically as part of driver binding, so that most drivers don't
2215  * need to do this explicitly: they hold a reference until they're unbound
2216  * from the device.
2217  *
2218  * A pointer to the client with the incremented reference counter is returned.
2219  */
2220 struct i2c_client *i2c_use_client(struct i2c_client *client)
2221 {
2222         if (client && get_device(&client->dev))
2223                 return client;
2224         return NULL;
2225 }
2226 EXPORT_SYMBOL(i2c_use_client);
2227
2228 /**
2229  * i2c_release_client - release a use of the i2c client structure
2230  * @client: the client being no longer referenced
2231  *
2232  * Must be called when a user of a client is finished with it.
2233  */
2234 void i2c_release_client(struct i2c_client *client)
2235 {
2236         if (client)
2237                 put_device(&client->dev);
2238 }
2239 EXPORT_SYMBOL(i2c_release_client);
2240
2241 struct i2c_cmd_arg {
2242         unsigned        cmd;
2243         void            *arg;
2244 };
2245
2246 static int i2c_cmd(struct device *dev, void *_arg)
2247 {
2248         struct i2c_client       *client = i2c_verify_client(dev);
2249         struct i2c_cmd_arg      *arg = _arg;
2250         struct i2c_driver       *driver;
2251
2252         if (!client || !client->dev.driver)
2253                 return 0;
2254
2255         driver = to_i2c_driver(client->dev.driver);
2256         if (driver->command)
2257                 driver->command(client, arg->cmd, arg->arg);
2258         return 0;
2259 }
2260
2261 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2262 {
2263         struct i2c_cmd_arg      cmd_arg;
2264
2265         cmd_arg.cmd = cmd;
2266         cmd_arg.arg = arg;
2267         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2268 }
2269 EXPORT_SYMBOL(i2c_clients_command);
2270
2271 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2272 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2273                          void *arg)
2274 {
2275         struct of_reconfig_data *rd = arg;
2276         struct i2c_adapter *adap;
2277         struct i2c_client *client;
2278
2279         switch (of_reconfig_get_state_change(action, rd)) {
2280         case OF_RECONFIG_CHANGE_ADD:
2281                 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2282                 if (adap == NULL)
2283                         return NOTIFY_OK;       /* not for us */
2284
2285                 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2286                         put_device(&adap->dev);
2287                         return NOTIFY_OK;
2288                 }
2289
2290                 client = of_i2c_register_device(adap, rd->dn);
2291                 put_device(&adap->dev);
2292
2293                 if (IS_ERR(client)) {
2294                         dev_err(&adap->dev, "failed to create client for '%s'\n",
2295                                  rd->dn->full_name);
2296                         return notifier_from_errno(PTR_ERR(client));
2297                 }
2298                 break;
2299         case OF_RECONFIG_CHANGE_REMOVE:
2300                 /* already depopulated? */
2301                 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2302                         return NOTIFY_OK;
2303
2304                 /* find our device by node */
2305                 client = of_find_i2c_device_by_node(rd->dn);
2306                 if (client == NULL)
2307                         return NOTIFY_OK;       /* no? not meant for us */
2308
2309                 /* unregister takes one ref away */
2310                 i2c_unregister_device(client);
2311
2312                 /* and put the reference of the find */
2313                 put_device(&client->dev);
2314                 break;
2315         }
2316
2317         return NOTIFY_OK;
2318 }
2319 static struct notifier_block i2c_of_notifier = {
2320         .notifier_call = of_i2c_notify,
2321 };
2322 #else
2323 extern struct notifier_block i2c_of_notifier;
2324 #endif /* CONFIG_OF_DYNAMIC */
2325
2326 static int __init i2c_init(void)
2327 {
2328         int retval;
2329
2330         retval = of_alias_get_highest_id("i2c");
2331
2332         down_write(&__i2c_board_lock);
2333         if (retval >= __i2c_first_dynamic_bus_num)
2334                 __i2c_first_dynamic_bus_num = retval + 1;
2335         up_write(&__i2c_board_lock);
2336
2337         retval = bus_register(&i2c_bus_type);
2338         if (retval)
2339                 return retval;
2340
2341         is_registered = true;
2342
2343 #ifdef CONFIG_I2C_COMPAT
2344         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2345         if (!i2c_adapter_compat_class) {
2346                 retval = -ENOMEM;
2347                 goto bus_err;
2348         }
2349 #endif
2350         retval = i2c_add_driver(&dummy_driver);
2351         if (retval)
2352                 goto class_err;
2353
2354         if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2355                 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2356         if (IS_ENABLED(CONFIG_ACPI))
2357                 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2358
2359         return 0;
2360
2361 class_err:
2362 #ifdef CONFIG_I2C_COMPAT
2363         class_compat_unregister(i2c_adapter_compat_class);
2364 bus_err:
2365 #endif
2366         is_registered = false;
2367         bus_unregister(&i2c_bus_type);
2368         return retval;
2369 }
2370
2371 static void __exit i2c_exit(void)
2372 {
2373         if (IS_ENABLED(CONFIG_ACPI))
2374                 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2375         if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2376                 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2377         i2c_del_driver(&dummy_driver);
2378 #ifdef CONFIG_I2C_COMPAT
2379         class_compat_unregister(i2c_adapter_compat_class);
2380 #endif
2381         bus_unregister(&i2c_bus_type);
2382         tracepoint_synchronize_unregister();
2383 }
2384
2385 /* We must initialize early, because some subsystems register i2c drivers
2386  * in subsys_initcall() code, but are linked (and initialized) before i2c.
2387  */
2388 postcore_initcall(i2c_init);
2389 module_exit(i2c_exit);
2390
2391 /* ----------------------------------------------------
2392  * the functional interface to the i2c busses.
2393  * ----------------------------------------------------
2394  */
2395
2396 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2397 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2398
2399 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2400 {
2401         dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2402                             err_msg, msg->addr, msg->len,
2403                             msg->flags & I2C_M_RD ? "read" : "write");
2404         return -EOPNOTSUPP;
2405 }
2406
2407 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2408 {
2409         const struct i2c_adapter_quirks *q = adap->quirks;
2410         int max_num = q->max_num_msgs, i;
2411         bool do_len_check = true;
2412
2413         if (q->flags & I2C_AQ_COMB) {
2414                 max_num = 2;
2415
2416                 /* special checks for combined messages */
2417                 if (num == 2) {
2418                         if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2419                                 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2420
2421                         if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2422                                 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2423
2424                         if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2425                                 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2426
2427                         if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2428                                 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2429
2430                         if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2431                                 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2432
2433                         do_len_check = false;
2434                 }
2435         }
2436
2437         if (i2c_quirk_exceeded(num, max_num))
2438                 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2439
2440         for (i = 0; i < num; i++) {
2441                 u16 len = msgs[i].len;
2442
2443                 if (msgs[i].flags & I2C_M_RD) {
2444                         if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2445                                 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2446                 } else {
2447                         if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2448                                 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2449                 }
2450         }
2451
2452         return 0;
2453 }
2454
2455 /**
2456  * __i2c_transfer - unlocked flavor of i2c_transfer
2457  * @adap: Handle to I2C bus
2458  * @msgs: One or more messages to execute before STOP is issued to
2459  *      terminate the operation; each message begins with a START.
2460  * @num: Number of messages to be executed.
2461  *
2462  * Returns negative errno, else the number of messages executed.
2463  *
2464  * Adapter lock must be held when calling this function. No debug logging
2465  * takes place. adap->algo->master_xfer existence isn't checked.
2466  */
2467 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2468 {
2469         unsigned long orig_jiffies;
2470         int ret, try;
2471
2472         if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2473                 return -EOPNOTSUPP;
2474
2475         /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2476          * enabled.  This is an efficient way of keeping the for-loop from
2477          * being executed when not needed.
2478          */
2479         if (static_key_false(&i2c_trace_msg)) {
2480                 int i;
2481                 for (i = 0; i < num; i++)
2482                         if (msgs[i].flags & I2C_M_RD)
2483                                 trace_i2c_read(adap, &msgs[i], i);
2484                         else
2485                                 trace_i2c_write(adap, &msgs[i], i);
2486         }
2487
2488         /* Retry automatically on arbitration loss */
2489         orig_jiffies = jiffies;
2490         for (ret = 0, try = 0; try <= adap->retries; try++) {
2491                 ret = adap->algo->master_xfer(adap, msgs, num);
2492                 if (ret != -EAGAIN)
2493                         break;
2494                 if (time_after(jiffies, orig_jiffies + adap->timeout))
2495                         break;
2496         }
2497
2498         if (static_key_false(&i2c_trace_msg)) {
2499                 int i;
2500                 for (i = 0; i < ret; i++)
2501                         if (msgs[i].flags & I2C_M_RD)
2502                                 trace_i2c_reply(adap, &msgs[i], i);
2503                 trace_i2c_result(adap, i, ret);
2504         }
2505
2506         return ret;
2507 }
2508 EXPORT_SYMBOL(__i2c_transfer);
2509
2510 /**
2511  * i2c_transfer - execute a single or combined I2C message
2512  * @adap: Handle to I2C bus
2513  * @msgs: One or more messages to execute before STOP is issued to
2514  *      terminate the operation; each message begins with a START.
2515  * @num: Number of messages to be executed.
2516  *
2517  * Returns negative errno, else the number of messages executed.
2518  *
2519  * Note that there is no requirement that each message be sent to
2520  * the same slave address, although that is the most common model.
2521  */
2522 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2523 {
2524         int ret;
2525
2526         /* REVISIT the fault reporting model here is weak:
2527          *
2528          *  - When we get an error after receiving N bytes from a slave,
2529          *    there is no way to report "N".
2530          *
2531          *  - When we get a NAK after transmitting N bytes to a slave,
2532          *    there is no way to report "N" ... or to let the master
2533          *    continue executing the rest of this combined message, if
2534          *    that's the appropriate response.
2535          *
2536          *  - When for example "num" is two and we successfully complete
2537          *    the first message but get an error part way through the
2538          *    second, it's unclear whether that should be reported as
2539          *    one (discarding status on the second message) or errno
2540          *    (discarding status on the first one).
2541          */
2542
2543         if (adap->algo->master_xfer) {
2544 #ifdef DEBUG
2545                 for (ret = 0; ret < num; ret++) {
2546                         dev_dbg(&adap->dev,
2547                                 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2548                                 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2549                                 msgs[ret].addr, msgs[ret].len,
2550                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2551                 }
2552 #endif
2553
2554                 if (in_atomic() || irqs_disabled()) {
2555                         ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2556                         if (!ret)
2557                                 /* I2C activity is ongoing. */
2558                                 return -EAGAIN;
2559                 } else {
2560                         i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2561                 }
2562
2563                 ret = __i2c_transfer(adap, msgs, num);
2564                 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2565
2566                 return ret;
2567         } else {
2568                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2569                 return -EOPNOTSUPP;
2570         }
2571 }
2572 EXPORT_SYMBOL(i2c_transfer);
2573
2574 /**
2575  * i2c_master_send - issue a single I2C message in master transmit mode
2576  * @client: Handle to slave device
2577  * @buf: Data that will be written to the slave
2578  * @count: How many bytes to write, must be less than 64k since msg.len is u16
2579  *
2580  * Returns negative errno, or else the number of bytes written.
2581  */
2582 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2583 {
2584         int ret;
2585         struct i2c_adapter *adap = client->adapter;
2586         struct i2c_msg msg;
2587
2588         msg.addr = client->addr;
2589         msg.flags = client->flags & I2C_M_TEN;
2590         msg.len = count;
2591         msg.buf = (char *)buf;
2592
2593         ret = i2c_transfer(adap, &msg, 1);
2594
2595         /*
2596          * If everything went ok (i.e. 1 msg transmitted), return #bytes
2597          * transmitted, else error code.
2598          */
2599         return (ret == 1) ? count : ret;
2600 }
2601 EXPORT_SYMBOL(i2c_master_send);
2602
2603 /**
2604  * i2c_master_recv - issue a single I2C message in master receive mode
2605  * @client: Handle to slave device
2606  * @buf: Where to store data read from slave
2607  * @count: How many bytes to read, must be less than 64k since msg.len is u16
2608  *
2609  * Returns negative errno, or else the number of bytes read.
2610  */
2611 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2612 {
2613         struct i2c_adapter *adap = client->adapter;
2614         struct i2c_msg msg;
2615         int ret;
2616
2617         msg.addr = client->addr;
2618         msg.flags = client->flags & I2C_M_TEN;
2619         msg.flags |= I2C_M_RD;
2620         msg.len = count;
2621         msg.buf = buf;
2622
2623         ret = i2c_transfer(adap, &msg, 1);
2624
2625         /*
2626          * If everything went ok (i.e. 1 msg received), return #bytes received,
2627          * else error code.
2628          */
2629         return (ret == 1) ? count : ret;
2630 }
2631 EXPORT_SYMBOL(i2c_master_recv);
2632
2633 /* ----------------------------------------------------
2634  * the i2c address scanning function
2635  * Will not work for 10-bit addresses!
2636  * ----------------------------------------------------
2637  */
2638
2639 /*
2640  * Legacy default probe function, mostly relevant for SMBus. The default
2641  * probe method is a quick write, but it is known to corrupt the 24RF08
2642  * EEPROMs due to a state machine bug, and could also irreversibly
2643  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2644  * we use a short byte read instead. Also, some bus drivers don't implement
2645  * quick write, so we fallback to a byte read in that case too.
2646  * On x86, there is another special case for FSC hardware monitoring chips,
2647  * which want regular byte reads (address 0x73.) Fortunately, these are the
2648  * only known chips using this I2C address on PC hardware.
2649  * Returns 1 if probe succeeded, 0 if not.
2650  */
2651 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2652 {
2653         int err;
2654         union i2c_smbus_data dummy;
2655
2656 #ifdef CONFIG_X86
2657         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2658          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2659                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2660                                      I2C_SMBUS_BYTE_DATA, &dummy);
2661         else
2662 #endif
2663         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2664          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2665                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2666                                      I2C_SMBUS_QUICK, NULL);
2667         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2668                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2669                                      I2C_SMBUS_BYTE, &dummy);
2670         else {
2671                 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2672                          addr);
2673                 err = -EOPNOTSUPP;
2674         }
2675
2676         return err >= 0;
2677 }
2678
2679 static int i2c_detect_address(struct i2c_client *temp_client,
2680                               struct i2c_driver *driver)
2681 {
2682         struct i2c_board_info info;
2683         struct i2c_adapter *adapter = temp_client->adapter;
2684         int addr = temp_client->addr;
2685         int err;
2686
2687         /* Make sure the address is valid */
2688         err = i2c_check_7bit_addr_validity_strict(addr);
2689         if (err) {
2690                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2691                          addr);
2692                 return err;
2693         }
2694
2695         /* Skip if already in use (7 bit, no need to encode flags) */
2696         if (i2c_check_addr_busy(adapter, addr))
2697                 return 0;
2698
2699         /* Make sure there is something at this address */
2700         if (!i2c_default_probe(adapter, addr))
2701                 return 0;
2702
2703         /* Finally call the custom detection function */
2704         memset(&info, 0, sizeof(struct i2c_board_info));
2705         info.addr = addr;
2706         err = driver->detect(temp_client, &info);
2707         if (err) {
2708                 /* -ENODEV is returned if the detection fails. We catch it
2709                    here as this isn't an error. */
2710                 return err == -ENODEV ? 0 : err;
2711         }
2712
2713         /* Consistency check */
2714         if (info.type[0] == '\0') {
2715                 dev_err(&adapter->dev,
2716                         "%s detection function provided no name for 0x%x\n",
2717                         driver->driver.name, addr);
2718         } else {
2719                 struct i2c_client *client;
2720
2721                 /* Detection succeeded, instantiate the device */
2722                 if (adapter->class & I2C_CLASS_DEPRECATED)
2723                         dev_warn(&adapter->dev,
2724                                 "This adapter will soon drop class based instantiation of devices. "
2725                                 "Please make sure client 0x%02x gets instantiated by other means. "
2726                                 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2727                                 info.addr);
2728
2729                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2730                         info.type, info.addr);
2731                 client = i2c_new_device(adapter, &info);
2732                 if (client)
2733                         list_add_tail(&client->detected, &driver->clients);
2734                 else
2735                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2736                                 info.type, info.addr);
2737         }
2738         return 0;
2739 }
2740
2741 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2742 {
2743         const unsigned short *address_list;
2744         struct i2c_client *temp_client;
2745         int i, err = 0;
2746         int adap_id = i2c_adapter_id(adapter);
2747
2748         address_list = driver->address_list;
2749         if (!driver->detect || !address_list)
2750                 return 0;
2751
2752         /* Warn that the adapter lost class based instantiation */
2753         if (adapter->class == I2C_CLASS_DEPRECATED) {
2754                 dev_dbg(&adapter->dev,
2755                         "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2756                         "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2757                         driver->driver.name);
2758                 return 0;
2759         }
2760
2761         /* Stop here if the classes do not match */
2762         if (!(adapter->class & driver->class))
2763                 return 0;
2764
2765         /* Set up a temporary client to help detect callback */
2766         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2767         if (!temp_client)
2768                 return -ENOMEM;
2769         temp_client->adapter = adapter;
2770
2771         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2772                 dev_dbg(&adapter->dev,
2773                         "found normal entry for adapter %d, addr 0x%02x\n",
2774                         adap_id, address_list[i]);
2775                 temp_client->addr = address_list[i];
2776                 err = i2c_detect_address(temp_client, driver);
2777                 if (unlikely(err))
2778                         break;
2779         }
2780
2781         kfree(temp_client);
2782         return err;
2783 }
2784
2785 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2786 {
2787         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2788                               I2C_SMBUS_QUICK, NULL) >= 0;
2789 }
2790 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2791
2792 struct i2c_client *
2793 i2c_new_probed_device(struct i2c_adapter *adap,
2794                       struct i2c_board_info *info,
2795                       unsigned short const *addr_list,
2796                       int (*probe)(struct i2c_adapter *, unsigned short addr))
2797 {
2798         int i;
2799
2800         if (!probe)
2801                 probe = i2c_default_probe;
2802
2803         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2804                 /* Check address validity */
2805                 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2806                         dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2807                                  addr_list[i]);
2808                         continue;
2809                 }
2810
2811                 /* Check address availability (7 bit, no need to encode flags) */
2812                 if (i2c_check_addr_busy(adap, addr_list[i])) {
2813                         dev_dbg(&adap->dev,
2814                                 "Address 0x%02x already in use, not probing\n",
2815                                 addr_list[i]);
2816                         continue;
2817                 }
2818
2819                 /* Test address responsiveness */
2820                 if (probe(adap, addr_list[i]))
2821                         break;
2822         }
2823
2824         if (addr_list[i] == I2C_CLIENT_END) {
2825                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2826                 return NULL;
2827         }
2828
2829         info->addr = addr_list[i];
2830         return i2c_new_device(adap, info);
2831 }
2832 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2833
2834 struct i2c_adapter *i2c_get_adapter(int nr)
2835 {
2836         struct i2c_adapter *adapter;
2837
2838         mutex_lock(&core_lock);
2839         adapter = idr_find(&i2c_adapter_idr, nr);
2840         if (!adapter)
2841                 goto exit;
2842
2843         if (try_module_get(adapter->owner))
2844                 get_device(&adapter->dev);
2845         else
2846                 adapter = NULL;
2847
2848  exit:
2849         mutex_unlock(&core_lock);
2850         return adapter;
2851 }
2852 EXPORT_SYMBOL(i2c_get_adapter);
2853
2854 void i2c_put_adapter(struct i2c_adapter *adap)
2855 {
2856         if (!adap)
2857                 return;
2858
2859         put_device(&adap->dev);
2860         module_put(adap->owner);
2861 }
2862 EXPORT_SYMBOL(i2c_put_adapter);
2863
2864 /* The SMBus parts */
2865
2866 #define POLY    (0x1070U << 3)
2867 static u8 crc8(u16 data)
2868 {
2869         int i;
2870
2871         for (i = 0; i < 8; i++) {
2872                 if (data & 0x8000)
2873                         data = data ^ POLY;
2874                 data = data << 1;
2875         }
2876         return (u8)(data >> 8);
2877 }
2878
2879 /* Incremental CRC8 over count bytes in the array pointed to by p */
2880 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2881 {
2882         int i;
2883
2884         for (i = 0; i < count; i++)
2885                 crc = crc8((crc ^ p[i]) << 8);
2886         return crc;
2887 }
2888
2889 /* Assume a 7-bit address, which is reasonable for SMBus */
2890 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2891 {
2892         /* The address will be sent first */
2893         u8 addr = i2c_8bit_addr_from_msg(msg);
2894         pec = i2c_smbus_pec(pec, &addr, 1);
2895
2896         /* The data buffer follows */
2897         return i2c_smbus_pec(pec, msg->buf, msg->len);
2898 }
2899
2900 /* Used for write only transactions */
2901 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2902 {
2903         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2904         msg->len++;
2905 }
2906
2907 /* Return <0 on CRC error
2908    If there was a write before this read (most cases) we need to take the
2909    partial CRC from the write part into account.
2910    Note that this function does modify the message (we need to decrease the
2911    message length to hide the CRC byte from the caller). */
2912 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2913 {
2914         u8 rpec = msg->buf[--msg->len];
2915         cpec = i2c_smbus_msg_pec(cpec, msg);
2916
2917         if (rpec != cpec) {
2918                 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2919                         rpec, cpec);
2920                 return -EBADMSG;
2921         }
2922         return 0;
2923 }
2924
2925 /**
2926  * i2c_smbus_read_byte - SMBus "receive byte" protocol
2927  * @client: Handle to slave device
2928  *
2929  * This executes the SMBus "receive byte" protocol, returning negative errno
2930  * else the byte received from the device.
2931  */
2932 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2933 {
2934         union i2c_smbus_data data;
2935         int status;
2936
2937         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2938                                 I2C_SMBUS_READ, 0,
2939                                 I2C_SMBUS_BYTE, &data);
2940         return (status < 0) ? status : data.byte;
2941 }
2942 EXPORT_SYMBOL(i2c_smbus_read_byte);
2943
2944 /**
2945  * i2c_smbus_write_byte - SMBus "send byte" protocol
2946  * @client: Handle to slave device
2947  * @value: Byte to be sent
2948  *
2949  * This executes the SMBus "send byte" protocol, returning negative errno
2950  * else zero on success.
2951  */
2952 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2953 {
2954         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2955                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2956 }
2957 EXPORT_SYMBOL(i2c_smbus_write_byte);
2958
2959 /**
2960  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2961  * @client: Handle to slave device
2962  * @command: Byte interpreted by slave
2963  *
2964  * This executes the SMBus "read byte" protocol, returning negative errno
2965  * else a data byte received from the device.
2966  */
2967 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2968 {
2969         union i2c_smbus_data data;
2970         int status;
2971
2972         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2973                                 I2C_SMBUS_READ, command,
2974                                 I2C_SMBUS_BYTE_DATA, &data);
2975         return (status < 0) ? status : data.byte;
2976 }
2977 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2978
2979 /**
2980  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2981  * @client: Handle to slave device
2982  * @command: Byte interpreted by slave
2983  * @value: Byte being written
2984  *
2985  * This executes the SMBus "write byte" protocol, returning negative errno
2986  * else zero on success.
2987  */
2988 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2989                               u8 value)
2990 {
2991         union i2c_smbus_data data;
2992         data.byte = value;
2993         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2994                               I2C_SMBUS_WRITE, command,
2995                               I2C_SMBUS_BYTE_DATA, &data);
2996 }
2997 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
2998
2999 /**
3000  * i2c_smbus_read_word_data - SMBus "read word" protocol
3001  * @client: Handle to slave device
3002  * @command: Byte interpreted by slave
3003  *
3004  * This executes the SMBus "read word" protocol, returning negative errno
3005  * else a 16-bit unsigned "word" received from the device.
3006  */
3007 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3008 {
3009         union i2c_smbus_data data;
3010         int status;
3011
3012         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3013                                 I2C_SMBUS_READ, command,
3014                                 I2C_SMBUS_WORD_DATA, &data);
3015         return (status < 0) ? status : data.word;
3016 }
3017 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3018
3019 /**
3020  * i2c_smbus_write_word_data - SMBus "write word" protocol
3021  * @client: Handle to slave device
3022  * @command: Byte interpreted by slave
3023  * @value: 16-bit "word" being written
3024  *
3025  * This executes the SMBus "write word" protocol, returning negative errno
3026  * else zero on success.
3027  */
3028 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3029                               u16 value)
3030 {
3031         union i2c_smbus_data data;
3032         data.word = value;
3033         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3034                               I2C_SMBUS_WRITE, command,
3035                               I2C_SMBUS_WORD_DATA, &data);
3036 }
3037 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3038
3039 /**
3040  * i2c_smbus_read_block_data - SMBus "block read" protocol
3041  * @client: Handle to slave device
3042  * @command: Byte interpreted by slave
3043  * @values: Byte array into which data will be read; big enough to hold
3044  *      the data returned by the slave.  SMBus allows at most 32 bytes.
3045  *
3046  * This executes the SMBus "block read" protocol, returning negative errno
3047  * else the number of data bytes in the slave's response.
3048  *
3049  * Note that using this function requires that the client's adapter support
3050  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
3051  * support this; its emulation through I2C messaging relies on a specific
3052  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3053  */
3054 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3055                               u8 *values)
3056 {
3057         union i2c_smbus_data data;
3058         int status;
3059
3060         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3061                                 I2C_SMBUS_READ, command,
3062                                 I2C_SMBUS_BLOCK_DATA, &data);
3063         if (status)
3064                 return status;
3065
3066         memcpy(values, &data.block[1], data.block[0]);
3067         return data.block[0];
3068 }
3069 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3070
3071 /**
3072  * i2c_smbus_write_block_data - SMBus "block write" protocol
3073  * @client: Handle to slave device
3074  * @command: Byte interpreted by slave
3075  * @length: Size of data block; SMBus allows at most 32 bytes
3076  * @values: Byte array which will be written.
3077  *
3078  * This executes the SMBus "block write" protocol, returning negative errno
3079  * else zero on success.
3080  */
3081 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3082                                u8 length, const u8 *values)
3083 {
3084         union i2c_smbus_data data;
3085
3086         if (length > I2C_SMBUS_BLOCK_MAX)
3087                 length = I2C_SMBUS_BLOCK_MAX;
3088         data.block[0] = length;
3089         memcpy(&data.block[1], values, length);
3090         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3091                               I2C_SMBUS_WRITE, command,
3092                               I2C_SMBUS_BLOCK_DATA, &data);
3093 }
3094 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3095
3096 /* Returns the number of read bytes */
3097 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3098                                   u8 length, u8 *values)
3099 {
3100         union i2c_smbus_data data;
3101         int status;
3102
3103         if (length > I2C_SMBUS_BLOCK_MAX)
3104                 length = I2C_SMBUS_BLOCK_MAX;
3105         data.block[0] = length;
3106         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3107                                 I2C_SMBUS_READ, command,
3108                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3109         if (status < 0)
3110                 return status;
3111
3112         memcpy(values, &data.block[1], data.block[0]);
3113         return data.block[0];
3114 }
3115 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3116
3117 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3118                                    u8 length, const u8 *values)
3119 {
3120         union i2c_smbus_data data;
3121
3122         if (length > I2C_SMBUS_BLOCK_MAX)
3123                 length = I2C_SMBUS_BLOCK_MAX;
3124         data.block[0] = length;
3125         memcpy(data.block + 1, values, length);
3126         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3127                               I2C_SMBUS_WRITE, command,
3128                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
3129 }
3130 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3131
3132 /* Simulate a SMBus command using the i2c protocol
3133    No checking of parameters is done!  */
3134 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3135                                    unsigned short flags,
3136                                    char read_write, u8 command, int size,
3137                                    union i2c_smbus_data *data)
3138 {
3139         /* So we need to generate a series of msgs. In the case of writing, we
3140           need to use only one message; when reading, we need two. We initialize
3141           most things with sane defaults, to keep the code below somewhat
3142           simpler. */
3143         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3144         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3145         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3146         int i;
3147         u8 partial_pec = 0;
3148         int status;
3149         struct i2c_msg msg[2] = {
3150                 {
3151                         .addr = addr,
3152                         .flags = flags,
3153                         .len = 1,
3154                         .buf = msgbuf0,
3155                 }, {
3156                         .addr = addr,
3157                         .flags = flags | I2C_M_RD,
3158                         .len = 0,
3159                         .buf = msgbuf1,
3160                 },
3161         };
3162
3163         msgbuf0[0] = command;
3164         switch (size) {
3165         case I2C_SMBUS_QUICK:
3166                 msg[0].len = 0;
3167                 /* Special case: The read/write field is used as data */
3168                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3169                                         I2C_M_RD : 0);
3170                 num = 1;
3171                 break;
3172         case I2C_SMBUS_BYTE:
3173                 if (read_write == I2C_SMBUS_READ) {
3174                         /* Special case: only a read! */
3175                         msg[0].flags = I2C_M_RD | flags;
3176                         num = 1;
3177                 }
3178                 break;
3179         case I2C_SMBUS_BYTE_DATA:
3180                 if (read_write == I2C_SMBUS_READ)
3181                         msg[1].len = 1;
3182                 else {
3183                         msg[0].len = 2;
3184                         msgbuf0[1] = data->byte;
3185                 }
3186                 break;
3187         case I2C_SMBUS_WORD_DATA:
3188                 if (read_write == I2C_SMBUS_READ)
3189                         msg[1].len = 2;
3190                 else {
3191                         msg[0].len = 3;
3192                         msgbuf0[1] = data->word & 0xff;
3193                         msgbuf0[2] = data->word >> 8;
3194                 }
3195                 break;
3196         case I2C_SMBUS_PROC_CALL:
3197                 num = 2; /* Special case */
3198                 read_write = I2C_SMBUS_READ;
3199                 msg[0].len = 3;
3200                 msg[1].len = 2;
3201                 msgbuf0[1] = data->word & 0xff;
3202                 msgbuf0[2] = data->word >> 8;
3203                 break;
3204         case I2C_SMBUS_BLOCK_DATA:
3205                 if (read_write == I2C_SMBUS_READ) {
3206                         msg[1].flags |= I2C_M_RECV_LEN;
3207                         msg[1].len = 1; /* block length will be added by
3208                                            the underlying bus driver */
3209                 } else {
3210                         msg[0].len = data->block[0] + 2;
3211                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3212                                 dev_err(&adapter->dev,
3213                                         "Invalid block write size %d\n",
3214                                         data->block[0]);
3215                                 return -EINVAL;
3216                         }
3217                         for (i = 1; i < msg[0].len; i++)
3218                                 msgbuf0[i] = data->block[i-1];
3219                 }
3220                 break;
3221         case I2C_SMBUS_BLOCK_PROC_CALL:
3222                 num = 2; /* Another special case */
3223                 read_write = I2C_SMBUS_READ;
3224                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3225                         dev_err(&adapter->dev,
3226                                 "Invalid block write size %d\n",
3227                                 data->block[0]);
3228                         return -EINVAL;
3229                 }
3230                 msg[0].len = data->block[0] + 2;
3231                 for (i = 1; i < msg[0].len; i++)
3232                         msgbuf0[i] = data->block[i-1];
3233                 msg[1].flags |= I2C_M_RECV_LEN;
3234                 msg[1].len = 1; /* block length will be added by
3235                                    the underlying bus driver */
3236                 break;
3237         case I2C_SMBUS_I2C_BLOCK_DATA:
3238                 if (read_write == I2C_SMBUS_READ) {
3239                         msg[1].len = data->block[0];
3240                 } else {
3241                         msg[0].len = data->block[0] + 1;
3242                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3243                                 dev_err(&adapter->dev,
3244                                         "Invalid block write size %d\n",
3245                                         data->block[0]);
3246                                 return -EINVAL;
3247                         }
3248                         for (i = 1; i <= data->block[0]; i++)
3249                                 msgbuf0[i] = data->block[i];
3250                 }
3251                 break;
3252         default:
3253                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3254                 return -EOPNOTSUPP;
3255         }
3256
3257         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3258                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
3259         if (i) {
3260                 /* Compute PEC if first message is a write */
3261                 if (!(msg[0].flags & I2C_M_RD)) {
3262                         if (num == 1) /* Write only */
3263                                 i2c_smbus_add_pec(&msg[0]);
3264                         else /* Write followed by read */
3265                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3266                 }
3267                 /* Ask for PEC if last message is a read */
3268                 if (msg[num-1].flags & I2C_M_RD)
3269                         msg[num-1].len++;
3270         }
3271
3272         status = i2c_transfer(adapter, msg, num);
3273         if (status < 0)
3274                 return status;
3275
3276         /* Check PEC if last message is a read */
3277         if (i && (msg[num-1].flags & I2C_M_RD)) {
3278                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3279                 if (status < 0)
3280                         return status;
3281         }
3282
3283         if (read_write == I2C_SMBUS_READ)
3284                 switch (size) {
3285                 case I2C_SMBUS_BYTE:
3286                         data->byte = msgbuf0[0];
3287                         break;
3288                 case I2C_SMBUS_BYTE_DATA:
3289                         data->byte = msgbuf1[0];
3290                         break;
3291                 case I2C_SMBUS_WORD_DATA:
3292                 case I2C_SMBUS_PROC_CALL:
3293                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3294                         break;
3295                 case I2C_SMBUS_I2C_BLOCK_DATA:
3296                         for (i = 0; i < data->block[0]; i++)
3297                                 data->block[i+1] = msgbuf1[i];
3298                         break;
3299                 case I2C_SMBUS_BLOCK_DATA:
3300                 case I2C_SMBUS_BLOCK_PROC_CALL:
3301                         for (i = 0; i < msgbuf1[0] + 1; i++)
3302                                 data->block[i] = msgbuf1[i];
3303                         break;
3304                 }
3305         return 0;
3306 }
3307
3308 /**
3309  * i2c_smbus_xfer - execute SMBus protocol operations
3310  * @adapter: Handle to I2C bus
3311  * @addr: Address of SMBus slave on that bus
3312  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3313  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3314  * @command: Byte interpreted by slave, for protocols which use such bytes
3315  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3316  * @data: Data to be read or written
3317  *
3318  * This executes an SMBus protocol operation, and returns a negative
3319  * errno code else zero on success.
3320  */
3321 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3322                    char read_write, u8 command, int protocol,
3323                    union i2c_smbus_data *data)
3324 {
3325         unsigned long orig_jiffies;
3326         int try;
3327         s32 res;
3328
3329         /* If enabled, the following two tracepoints are conditional on
3330          * read_write and protocol.
3331          */
3332         trace_smbus_write(adapter, addr, flags, read_write,
3333                           command, protocol, data);
3334         trace_smbus_read(adapter, addr, flags, read_write,
3335                          command, protocol);
3336
3337         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3338
3339         if (adapter->algo->smbus_xfer) {
3340                 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3341
3342                 /* Retry automatically on arbitration loss */
3343                 orig_jiffies = jiffies;
3344                 for (res = 0, try = 0; try <= adapter->retries; try++) {
3345                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
3346                                                         read_write, command,
3347                                                         protocol, data);
3348                         if (res != -EAGAIN)
3349                                 break;
3350                         if (time_after(jiffies,
3351                                        orig_jiffies + adapter->timeout))
3352                                 break;
3353                 }
3354                 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3355
3356                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3357                         goto trace;
3358                 /*
3359                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3360                  * implement native support for the SMBus operation.
3361                  */
3362         }
3363
3364         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3365                                       command, protocol, data);
3366
3367 trace:
3368         /* If enabled, the reply tracepoint is conditional on read_write. */
3369         trace_smbus_reply(adapter, addr, flags, read_write,
3370                           command, protocol, data);
3371         trace_smbus_result(adapter, addr, flags, read_write,
3372                            command, protocol, res);
3373
3374         return res;
3375 }
3376 EXPORT_SYMBOL(i2c_smbus_xfer);
3377
3378 /**
3379  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3380  * @client: Handle to slave device
3381  * @command: Byte interpreted by slave
3382  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3383  * @values: Byte array into which data will be read; big enough to hold
3384  *      the data returned by the slave.  SMBus allows at most
3385  *      I2C_SMBUS_BLOCK_MAX bytes.
3386  *
3387  * This executes the SMBus "block read" protocol if supported by the adapter.
3388  * If block read is not supported, it emulates it using either word or byte
3389  * read protocols depending on availability.
3390  *
3391  * The addresses of the I2C slave device that are accessed with this function
3392  * must be mapped to a linear region, so that a block read will have the same
3393  * effect as a byte read. Before using this function you must double-check
3394  * if the I2C slave does support exchanging a block transfer with a byte
3395  * transfer.
3396  */
3397 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3398                                               u8 command, u8 length, u8 *values)
3399 {
3400         u8 i = 0;
3401         int status;
3402
3403         if (length > I2C_SMBUS_BLOCK_MAX)
3404                 length = I2C_SMBUS_BLOCK_MAX;
3405
3406         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3407                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3408
3409         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3410                 return -EOPNOTSUPP;
3411
3412         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3413                 while ((i + 2) <= length) {
3414                         status = i2c_smbus_read_word_data(client, command + i);
3415                         if (status < 0)
3416                                 return status;
3417                         values[i] = status & 0xff;
3418                         values[i + 1] = status >> 8;
3419                         i += 2;
3420                 }
3421         }
3422
3423         while (i < length) {
3424                 status = i2c_smbus_read_byte_data(client, command + i);
3425                 if (status < 0)
3426                         return status;
3427                 values[i] = status;
3428                 i++;
3429         }
3430
3431         return i;
3432 }
3433 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3434
3435 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3436 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3437 {
3438         int ret;
3439
3440         if (!client || !slave_cb) {
3441                 WARN(1, "insufficent data\n");
3442                 return -EINVAL;
3443         }
3444
3445         if (!(client->flags & I2C_CLIENT_SLAVE))
3446                 dev_warn(&client->dev, "%s: client slave flag not set. You might see address collisions\n",
3447                          __func__);
3448
3449         if (!(client->flags & I2C_CLIENT_TEN)) {
3450                 /* Enforce stricter address checking */