Merge tag 'tegra-for-4.8-i2c' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra...
[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 *bus, *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         bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus");
1692         if (!bus)
1693                 bus = of_node_get(adap->dev.of_node);
1694
1695         for_each_available_child_of_node(bus, node) {
1696                 if (of_node_test_and_set_flag(node, OF_POPULATED))
1697                         continue;
1698                 of_i2c_register_device(adap, node);
1699         }
1700
1701         of_node_put(bus);
1702 }
1703
1704 static int of_dev_node_match(struct device *dev, void *data)
1705 {
1706         return dev->of_node == data;
1707 }
1708
1709 /* must call put_device() when done with returned i2c_client device */
1710 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
1711 {
1712         struct device *dev;
1713         struct i2c_client *client;
1714
1715         dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1716         if (!dev)
1717                 return NULL;
1718
1719         client = i2c_verify_client(dev);
1720         if (!client)
1721                 put_device(dev);
1722
1723         return client;
1724 }
1725 EXPORT_SYMBOL(of_find_i2c_device_by_node);
1726
1727 /* must call put_device() when done with returned i2c_adapter device */
1728 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
1729 {
1730         struct device *dev;
1731         struct i2c_adapter *adapter;
1732
1733         dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
1734         if (!dev)
1735                 return NULL;
1736
1737         adapter = i2c_verify_adapter(dev);
1738         if (!adapter)
1739                 put_device(dev);
1740
1741         return adapter;
1742 }
1743 EXPORT_SYMBOL(of_find_i2c_adapter_by_node);
1744
1745 /* must call i2c_put_adapter() when done with returned i2c_adapter device */
1746 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
1747 {
1748         struct i2c_adapter *adapter;
1749
1750         adapter = of_find_i2c_adapter_by_node(node);
1751         if (!adapter)
1752                 return NULL;
1753
1754         if (!try_module_get(adapter->owner)) {
1755                 put_device(&adapter->dev);
1756                 adapter = NULL;
1757         }
1758
1759         return adapter;
1760 }
1761 EXPORT_SYMBOL(of_get_i2c_adapter_by_node);
1762 #else
1763 static void of_i2c_register_devices(struct i2c_adapter *adap) { }
1764 #endif /* CONFIG_OF */
1765
1766 static int i2c_do_add_adapter(struct i2c_driver *driver,
1767                               struct i2c_adapter *adap)
1768 {
1769         /* Detect supported devices on that bus, and instantiate them */
1770         i2c_detect(adap, driver);
1771
1772         /* Let legacy drivers scan this bus for matching devices */
1773         if (driver->attach_adapter) {
1774                 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
1775                          driver->driver.name);
1776                 dev_warn(&adap->dev,
1777                          "Please use another way to instantiate your i2c_client\n");
1778                 /* We ignore the return code; if it fails, too bad */
1779                 driver->attach_adapter(adap);
1780         }
1781         return 0;
1782 }
1783
1784 static int __process_new_adapter(struct device_driver *d, void *data)
1785 {
1786         return i2c_do_add_adapter(to_i2c_driver(d), data);
1787 }
1788
1789 static const struct i2c_lock_operations i2c_adapter_lock_ops = {
1790         .lock_bus =    i2c_adapter_lock_bus,
1791         .trylock_bus = i2c_adapter_trylock_bus,
1792         .unlock_bus =  i2c_adapter_unlock_bus,
1793 };
1794
1795 static int i2c_register_adapter(struct i2c_adapter *adap)
1796 {
1797         int res = -EINVAL;
1798
1799         /* Can't register until after driver model init */
1800         if (WARN_ON(!is_registered)) {
1801                 res = -EAGAIN;
1802                 goto out_list;
1803         }
1804
1805         /* Sanity checks */
1806         if (WARN(!adap->name[0], "i2c adapter has no name"))
1807                 goto out_list;
1808
1809         if (!adap->algo) {
1810                 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1811                 goto out_list;
1812         }
1813
1814         if (!adap->lock_ops)
1815                 adap->lock_ops = &i2c_adapter_lock_ops;
1816
1817         rt_mutex_init(&adap->bus_lock);
1818         rt_mutex_init(&adap->mux_lock);
1819         mutex_init(&adap->userspace_clients_lock);
1820         INIT_LIST_HEAD(&adap->userspace_clients);
1821
1822         /* Set default timeout to 1 second if not already set */
1823         if (adap->timeout == 0)
1824                 adap->timeout = HZ;
1825
1826         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1827         adap->dev.bus = &i2c_bus_type;
1828         adap->dev.type = &i2c_adapter_type;
1829         res = device_register(&adap->dev);
1830         if (res) {
1831                 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1832                 goto out_list;
1833         }
1834
1835         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1836
1837         pm_runtime_no_callbacks(&adap->dev);
1838         pm_suspend_ignore_children(&adap->dev, true);
1839         pm_runtime_enable(&adap->dev);
1840
1841 #ifdef CONFIG_I2C_COMPAT
1842         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1843                                        adap->dev.parent);
1844         if (res)
1845                 dev_warn(&adap->dev,
1846                          "Failed to create compatibility class link\n");
1847 #endif
1848
1849         i2c_init_recovery(adap);
1850
1851         /* create pre-declared device nodes */
1852         of_i2c_register_devices(adap);
1853         i2c_acpi_register_devices(adap);
1854         i2c_acpi_install_space_handler(adap);
1855
1856         if (adap->nr < __i2c_first_dynamic_bus_num)
1857                 i2c_scan_static_board_info(adap);
1858
1859         /* Notify drivers */
1860         mutex_lock(&core_lock);
1861         bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1862         mutex_unlock(&core_lock);
1863
1864         return 0;
1865
1866 out_list:
1867         mutex_lock(&core_lock);
1868         idr_remove(&i2c_adapter_idr, adap->nr);
1869         mutex_unlock(&core_lock);
1870         return res;
1871 }
1872
1873 /**
1874  * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1875  * @adap: the adapter to register (with adap->nr initialized)
1876  * Context: can sleep
1877  *
1878  * See i2c_add_numbered_adapter() for details.
1879  */
1880 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1881 {
1882         int id;
1883
1884         mutex_lock(&core_lock);
1885         id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1886         mutex_unlock(&core_lock);
1887         if (WARN(id < 0, "couldn't get idr"))
1888                 return id == -ENOSPC ? -EBUSY : id;
1889
1890         return i2c_register_adapter(adap);
1891 }
1892
1893 /**
1894  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1895  * @adapter: the adapter to add
1896  * Context: can sleep
1897  *
1898  * This routine is used to declare an I2C adapter when its bus number
1899  * doesn't matter or when its bus number is specified by an dt alias.
1900  * Examples of bases when the bus number doesn't matter: I2C adapters
1901  * dynamically added by USB links or PCI plugin cards.
1902  *
1903  * When this returns zero, a new bus number was allocated and stored
1904  * in adap->nr, and the specified adapter became available for clients.
1905  * Otherwise, a negative errno value is returned.
1906  */
1907 int i2c_add_adapter(struct i2c_adapter *adapter)
1908 {
1909         struct device *dev = &adapter->dev;
1910         int id;
1911
1912         if (dev->of_node) {
1913                 id = of_alias_get_id(dev->of_node, "i2c");
1914                 if (id >= 0) {
1915                         adapter->nr = id;
1916                         return __i2c_add_numbered_adapter(adapter);
1917                 }
1918         }
1919
1920         mutex_lock(&core_lock);
1921         id = idr_alloc(&i2c_adapter_idr, adapter,
1922                        __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1923         mutex_unlock(&core_lock);
1924         if (WARN(id < 0, "couldn't get idr"))
1925                 return id;
1926
1927         adapter->nr = id;
1928
1929         return i2c_register_adapter(adapter);
1930 }
1931 EXPORT_SYMBOL(i2c_add_adapter);
1932
1933 /**
1934  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1935  * @adap: the adapter to register (with adap->nr initialized)
1936  * Context: can sleep
1937  *
1938  * This routine is used to declare an I2C adapter when its bus number
1939  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
1940  * or otherwise built in to the system's mainboard, and where i2c_board_info
1941  * is used to properly configure I2C devices.
1942  *
1943  * If the requested bus number is set to -1, then this function will behave
1944  * identically to i2c_add_adapter, and will dynamically assign a bus number.
1945  *
1946  * If no devices have pre-been declared for this bus, then be sure to
1947  * register the adapter before any dynamically allocated ones.  Otherwise
1948  * the required bus ID may not be available.
1949  *
1950  * When this returns zero, the specified adapter became available for
1951  * clients using the bus number provided in adap->nr.  Also, the table
1952  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1953  * and the appropriate driver model device nodes are created.  Otherwise, a
1954  * negative errno value is returned.
1955  */
1956 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1957 {
1958         if (adap->nr == -1) /* -1 means dynamically assign bus id */
1959                 return i2c_add_adapter(adap);
1960
1961         return __i2c_add_numbered_adapter(adap);
1962 }
1963 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1964
1965 static void i2c_do_del_adapter(struct i2c_driver *driver,
1966                               struct i2c_adapter *adapter)
1967 {
1968         struct i2c_client *client, *_n;
1969
1970         /* Remove the devices we created ourselves as the result of hardware
1971          * probing (using a driver's detect method) */
1972         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1973                 if (client->adapter == adapter) {
1974                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1975                                 client->name, client->addr);
1976                         list_del(&client->detected);
1977                         i2c_unregister_device(client);
1978                 }
1979         }
1980 }
1981
1982 static int __unregister_client(struct device *dev, void *dummy)
1983 {
1984         struct i2c_client *client = i2c_verify_client(dev);
1985         if (client && strcmp(client->name, "dummy"))
1986                 i2c_unregister_device(client);
1987         return 0;
1988 }
1989
1990 static int __unregister_dummy(struct device *dev, void *dummy)
1991 {
1992         struct i2c_client *client = i2c_verify_client(dev);
1993         if (client)
1994                 i2c_unregister_device(client);
1995         return 0;
1996 }
1997
1998 static int __process_removed_adapter(struct device_driver *d, void *data)
1999 {
2000         i2c_do_del_adapter(to_i2c_driver(d), data);
2001         return 0;
2002 }
2003
2004 /**
2005  * i2c_del_adapter - unregister I2C adapter
2006  * @adap: the adapter being unregistered
2007  * Context: can sleep
2008  *
2009  * This unregisters an I2C adapter which was previously registered
2010  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
2011  */
2012 void i2c_del_adapter(struct i2c_adapter *adap)
2013 {
2014         struct i2c_adapter *found;
2015         struct i2c_client *client, *next;
2016
2017         /* First make sure that this adapter was ever added */
2018         mutex_lock(&core_lock);
2019         found = idr_find(&i2c_adapter_idr, adap->nr);
2020         mutex_unlock(&core_lock);
2021         if (found != adap) {
2022                 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
2023                 return;
2024         }
2025
2026         i2c_acpi_remove_space_handler(adap);
2027         /* Tell drivers about this removal */
2028         mutex_lock(&core_lock);
2029         bus_for_each_drv(&i2c_bus_type, NULL, adap,
2030                                __process_removed_adapter);
2031         mutex_unlock(&core_lock);
2032
2033         /* Remove devices instantiated from sysfs */
2034         mutex_lock_nested(&adap->userspace_clients_lock,
2035                           i2c_adapter_depth(adap));
2036         list_for_each_entry_safe(client, next, &adap->userspace_clients,
2037                                  detected) {
2038                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
2039                         client->addr);
2040                 list_del(&client->detected);
2041                 i2c_unregister_device(client);
2042         }
2043         mutex_unlock(&adap->userspace_clients_lock);
2044
2045         /* Detach any active clients. This can't fail, thus we do not
2046          * check the returned value. This is a two-pass process, because
2047          * we can't remove the dummy devices during the first pass: they
2048          * could have been instantiated by real devices wishing to clean
2049          * them up properly, so we give them a chance to do that first. */
2050         device_for_each_child(&adap->dev, NULL, __unregister_client);
2051         device_for_each_child(&adap->dev, NULL, __unregister_dummy);
2052
2053 #ifdef CONFIG_I2C_COMPAT
2054         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
2055                                  adap->dev.parent);
2056 #endif
2057
2058         /* device name is gone after device_unregister */
2059         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
2060
2061         pm_runtime_disable(&adap->dev);
2062
2063         /* wait until all references to the device are gone
2064          *
2065          * FIXME: This is old code and should ideally be replaced by an
2066          * alternative which results in decoupling the lifetime of the struct
2067          * device from the i2c_adapter, like spi or netdev do. Any solution
2068          * should be thoroughly tested with DEBUG_KOBJECT_RELEASE enabled!
2069          */
2070         init_completion(&adap->dev_released);
2071         device_unregister(&adap->dev);
2072         wait_for_completion(&adap->dev_released);
2073
2074         /* free bus id */
2075         mutex_lock(&core_lock);
2076         idr_remove(&i2c_adapter_idr, adap->nr);
2077         mutex_unlock(&core_lock);
2078
2079         /* Clear the device structure in case this adapter is ever going to be
2080            added again */
2081         memset(&adap->dev, 0, sizeof(adap->dev));
2082 }
2083 EXPORT_SYMBOL(i2c_del_adapter);
2084
2085 /**
2086  * i2c_parse_fw_timings - get I2C related timing parameters from firmware
2087  * @dev: The device to scan for I2C timing properties
2088  * @t: the i2c_timings struct to be filled with values
2089  * @use_defaults: bool to use sane defaults derived from the I2C specification
2090  *                when properties are not found, otherwise use 0
2091  *
2092  * Scan the device for the generic I2C properties describing timing parameters
2093  * for the signal and fill the given struct with the results. If a property was
2094  * not found and use_defaults was true, then maximum timings are assumed which
2095  * are derived from the I2C specification. If use_defaults is not used, the
2096  * results will be 0, so drivers can apply their own defaults later. The latter
2097  * is mainly intended for avoiding regressions of existing drivers which want
2098  * to switch to this function. New drivers almost always should use the defaults.
2099  */
2100
2101 void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults)
2102 {
2103         int ret;
2104
2105         memset(t, 0, sizeof(*t));
2106
2107         ret = device_property_read_u32(dev, "clock-frequency", &t->bus_freq_hz);
2108         if (ret && use_defaults)
2109                 t->bus_freq_hz = 100000;
2110
2111         ret = device_property_read_u32(dev, "i2c-scl-rising-time-ns", &t->scl_rise_ns);
2112         if (ret && use_defaults) {
2113                 if (t->bus_freq_hz <= 100000)
2114                         t->scl_rise_ns = 1000;
2115                 else if (t->bus_freq_hz <= 400000)
2116                         t->scl_rise_ns = 300;
2117                 else
2118                         t->scl_rise_ns = 120;
2119         }
2120
2121         ret = device_property_read_u32(dev, "i2c-scl-falling-time-ns", &t->scl_fall_ns);
2122         if (ret && use_defaults) {
2123                 if (t->bus_freq_hz <= 400000)
2124                         t->scl_fall_ns = 300;
2125                 else
2126                         t->scl_fall_ns = 120;
2127         }
2128
2129         device_property_read_u32(dev, "i2c-scl-internal-delay-ns", &t->scl_int_delay_ns);
2130
2131         ret = device_property_read_u32(dev, "i2c-sda-falling-time-ns", &t->sda_fall_ns);
2132         if (ret && use_defaults)
2133                 t->sda_fall_ns = t->scl_fall_ns;
2134 }
2135 EXPORT_SYMBOL_GPL(i2c_parse_fw_timings);
2136
2137 /* ------------------------------------------------------------------------- */
2138
2139 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
2140 {
2141         int res;
2142
2143         mutex_lock(&core_lock);
2144         res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
2145         mutex_unlock(&core_lock);
2146
2147         return res;
2148 }
2149 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
2150
2151 static int __process_new_driver(struct device *dev, void *data)
2152 {
2153         if (dev->type != &i2c_adapter_type)
2154                 return 0;
2155         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
2156 }
2157
2158 /*
2159  * An i2c_driver is used with one or more i2c_client (device) nodes to access
2160  * i2c slave chips, on a bus instance associated with some i2c_adapter.
2161  */
2162
2163 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
2164 {
2165         int res;
2166
2167         /* Can't register until after driver model init */
2168         if (WARN_ON(!is_registered))
2169                 return -EAGAIN;
2170
2171         /* add the driver to the list of i2c drivers in the driver core */
2172         driver->driver.owner = owner;
2173         driver->driver.bus = &i2c_bus_type;
2174
2175         /* When registration returns, the driver core
2176          * will have called probe() for all matching-but-unbound devices.
2177          */
2178         res = driver_register(&driver->driver);
2179         if (res)
2180                 return res;
2181
2182         pr_debug("driver [%s] registered\n", driver->driver.name);
2183
2184         INIT_LIST_HEAD(&driver->clients);
2185         /* Walk the adapters that are already present */
2186         i2c_for_each_dev(driver, __process_new_driver);
2187
2188         return 0;
2189 }
2190 EXPORT_SYMBOL(i2c_register_driver);
2191
2192 static int __process_removed_driver(struct device *dev, void *data)
2193 {
2194         if (dev->type == &i2c_adapter_type)
2195                 i2c_do_del_adapter(data, to_i2c_adapter(dev));
2196         return 0;
2197 }
2198
2199 /**
2200  * i2c_del_driver - unregister I2C driver
2201  * @driver: the driver being unregistered
2202  * Context: can sleep
2203  */
2204 void i2c_del_driver(struct i2c_driver *driver)
2205 {
2206         i2c_for_each_dev(driver, __process_removed_driver);
2207
2208         driver_unregister(&driver->driver);
2209         pr_debug("driver [%s] unregistered\n", driver->driver.name);
2210 }
2211 EXPORT_SYMBOL(i2c_del_driver);
2212
2213 /* ------------------------------------------------------------------------- */
2214
2215 /**
2216  * i2c_use_client - increments the reference count of the i2c client structure
2217  * @client: the client being referenced
2218  *
2219  * Each live reference to a client should be refcounted. The driver model does
2220  * that automatically as part of driver binding, so that most drivers don't
2221  * need to do this explicitly: they hold a reference until they're unbound
2222  * from the device.
2223  *
2224  * A pointer to the client with the incremented reference counter is returned.
2225  */
2226 struct i2c_client *i2c_use_client(struct i2c_client *client)
2227 {
2228         if (client && get_device(&client->dev))
2229                 return client;
2230         return NULL;
2231 }
2232 EXPORT_SYMBOL(i2c_use_client);
2233
2234 /**
2235  * i2c_release_client - release a use of the i2c client structure
2236  * @client: the client being no longer referenced
2237  *
2238  * Must be called when a user of a client is finished with it.
2239  */
2240 void i2c_release_client(struct i2c_client *client)
2241 {
2242         if (client)
2243                 put_device(&client->dev);
2244 }
2245 EXPORT_SYMBOL(i2c_release_client);
2246
2247 struct i2c_cmd_arg {
2248         unsigned        cmd;
2249         void            *arg;
2250 };
2251
2252 static int i2c_cmd(struct device *dev, void *_arg)
2253 {
2254         struct i2c_client       *client = i2c_verify_client(dev);
2255         struct i2c_cmd_arg      *arg = _arg;
2256         struct i2c_driver       *driver;
2257
2258         if (!client || !client->dev.driver)
2259                 return 0;
2260
2261         driver = to_i2c_driver(client->dev.driver);
2262         if (driver->command)
2263                 driver->command(client, arg->cmd, arg->arg);
2264         return 0;
2265 }
2266
2267 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2268 {
2269         struct i2c_cmd_arg      cmd_arg;
2270
2271         cmd_arg.cmd = cmd;
2272         cmd_arg.arg = arg;
2273         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2274 }
2275 EXPORT_SYMBOL(i2c_clients_command);
2276
2277 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
2278 static int of_i2c_notify(struct notifier_block *nb, unsigned long action,
2279                          void *arg)
2280 {
2281         struct of_reconfig_data *rd = arg;
2282         struct i2c_adapter *adap;
2283         struct i2c_client *client;
2284
2285         switch (of_reconfig_get_state_change(action, rd)) {
2286         case OF_RECONFIG_CHANGE_ADD:
2287                 adap = of_find_i2c_adapter_by_node(rd->dn->parent);
2288                 if (adap == NULL)
2289                         return NOTIFY_OK;       /* not for us */
2290
2291                 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
2292                         put_device(&adap->dev);
2293                         return NOTIFY_OK;
2294                 }
2295
2296                 client = of_i2c_register_device(adap, rd->dn);
2297                 put_device(&adap->dev);
2298
2299                 if (IS_ERR(client)) {
2300                         dev_err(&adap->dev, "failed to create client for '%s'\n",
2301                                  rd->dn->full_name);
2302                         return notifier_from_errno(PTR_ERR(client));
2303                 }
2304                 break;
2305         case OF_RECONFIG_CHANGE_REMOVE:
2306                 /* already depopulated? */
2307                 if (!of_node_check_flag(rd->dn, OF_POPULATED))
2308                         return NOTIFY_OK;
2309
2310                 /* find our device by node */
2311                 client = of_find_i2c_device_by_node(rd->dn);
2312                 if (client == NULL)
2313                         return NOTIFY_OK;       /* no? not meant for us */
2314
2315                 /* unregister takes one ref away */
2316                 i2c_unregister_device(client);
2317
2318                 /* and put the reference of the find */
2319                 put_device(&client->dev);
2320                 break;
2321         }
2322
2323         return NOTIFY_OK;
2324 }
2325 static struct notifier_block i2c_of_notifier = {
2326         .notifier_call = of_i2c_notify,
2327 };
2328 #else
2329 extern struct notifier_block i2c_of_notifier;
2330 #endif /* CONFIG_OF_DYNAMIC */
2331
2332 static int __init i2c_init(void)
2333 {
2334         int retval;
2335
2336         retval = of_alias_get_highest_id("i2c");
2337
2338         down_write(&__i2c_board_lock);
2339         if (retval >= __i2c_first_dynamic_bus_num)
2340                 __i2c_first_dynamic_bus_num = retval + 1;
2341         up_write(&__i2c_board_lock);
2342
2343         retval = bus_register(&i2c_bus_type);
2344         if (retval)
2345                 return retval;
2346
2347         is_registered = true;
2348
2349 #ifdef CONFIG_I2C_COMPAT
2350         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
2351         if (!i2c_adapter_compat_class) {
2352                 retval = -ENOMEM;
2353                 goto bus_err;
2354         }
2355 #endif
2356         retval = i2c_add_driver(&dummy_driver);
2357         if (retval)
2358                 goto class_err;
2359
2360         if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2361                 WARN_ON(of_reconfig_notifier_register(&i2c_of_notifier));
2362         if (IS_ENABLED(CONFIG_ACPI))
2363                 WARN_ON(acpi_reconfig_notifier_register(&i2c_acpi_notifier));
2364
2365         return 0;
2366
2367 class_err:
2368 #ifdef CONFIG_I2C_COMPAT
2369         class_compat_unregister(i2c_adapter_compat_class);
2370 bus_err:
2371 #endif
2372         is_registered = false;
2373         bus_unregister(&i2c_bus_type);
2374         return retval;
2375 }
2376
2377 static void __exit i2c_exit(void)
2378 {
2379         if (IS_ENABLED(CONFIG_ACPI))
2380                 WARN_ON(acpi_reconfig_notifier_unregister(&i2c_acpi_notifier));
2381         if (IS_ENABLED(CONFIG_OF_DYNAMIC))
2382                 WARN_ON(of_reconfig_notifier_unregister(&i2c_of_notifier));
2383         i2c_del_driver(&dummy_driver);
2384 #ifdef CONFIG_I2C_COMPAT
2385         class_compat_unregister(i2c_adapter_compat_class);
2386 #endif
2387         bus_unregister(&i2c_bus_type);
2388         tracepoint_synchronize_unregister();
2389 }
2390
2391 /* We must initialize early, because some subsystems register i2c drivers
2392  * in subsys_initcall() code, but are linked (and initialized) before i2c.
2393  */
2394 postcore_initcall(i2c_init);
2395 module_exit(i2c_exit);
2396
2397 /* ----------------------------------------------------
2398  * the functional interface to the i2c busses.
2399  * ----------------------------------------------------
2400  */
2401
2402 /* Check if val is exceeding the quirk IFF quirk is non 0 */
2403 #define i2c_quirk_exceeded(val, quirk) ((quirk) && ((val) > (quirk)))
2404
2405 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2406 {
2407         dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2408                             err_msg, msg->addr, msg->len,
2409                             msg->flags & I2C_M_RD ? "read" : "write");
2410         return -EOPNOTSUPP;
2411 }
2412
2413 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2414 {
2415         const struct i2c_adapter_quirks *q = adap->quirks;
2416         int max_num = q->max_num_msgs, i;
2417         bool do_len_check = true;
2418
2419         if (q->flags & I2C_AQ_COMB) {
2420                 max_num = 2;
2421
2422                 /* special checks for combined messages */
2423                 if (num == 2) {
2424                         if (q->flags & I2C_AQ_COMB_WRITE_FIRST && msgs[0].flags & I2C_M_RD)
2425                                 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2426
2427                         if (q->flags & I2C_AQ_COMB_READ_SECOND && !(msgs[1].flags & I2C_M_RD))
2428                                 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2429
2430                         if (q->flags & I2C_AQ_COMB_SAME_ADDR && msgs[0].addr != msgs[1].addr)
2431                                 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2432
2433                         if (i2c_quirk_exceeded(msgs[0].len, q->max_comb_1st_msg_len))
2434                                 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2435
2436                         if (i2c_quirk_exceeded(msgs[1].len, q->max_comb_2nd_msg_len))
2437                                 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2438
2439                         do_len_check = false;
2440                 }
2441         }
2442
2443         if (i2c_quirk_exceeded(num, max_num))
2444                 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2445
2446         for (i = 0; i < num; i++) {
2447                 u16 len = msgs[i].len;
2448
2449                 if (msgs[i].flags & I2C_M_RD) {
2450                         if (do_len_check && i2c_quirk_exceeded(len, q->max_read_len))
2451                                 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2452                 } else {
2453                         if (do_len_check && i2c_quirk_exceeded(len, q->max_write_len))
2454                                 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2455                 }
2456         }
2457
2458         return 0;
2459 }
2460
2461 /**
2462  * __i2c_transfer - unlocked flavor of i2c_transfer
2463  * @adap: Handle to I2C bus
2464  * @msgs: One or more messages to execute before STOP is issued to
2465  *      terminate the operation; each message begins with a START.
2466  * @num: Number of messages to be executed.
2467  *
2468  * Returns negative errno, else the number of messages executed.
2469  *
2470  * Adapter lock must be held when calling this function. No debug logging
2471  * takes place. adap->algo->master_xfer existence isn't checked.
2472  */
2473 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2474 {
2475         unsigned long orig_jiffies;
2476         int ret, try;
2477
2478         if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2479                 return -EOPNOTSUPP;
2480
2481         /* i2c_trace_msg gets enabled when tracepoint i2c_transfer gets
2482          * enabled.  This is an efficient way of keeping the for-loop from
2483          * being executed when not needed.
2484          */
2485         if (static_key_false(&i2c_trace_msg)) {
2486                 int i;
2487                 for (i = 0; i < num; i++)
2488                         if (msgs[i].flags & I2C_M_RD)
2489                                 trace_i2c_read(adap, &msgs[i], i);
2490                         else
2491                                 trace_i2c_write(adap, &msgs[i], i);
2492         }
2493
2494         /* Retry automatically on arbitration loss */
2495         orig_jiffies = jiffies;
2496         for (ret = 0, try = 0; try <= adap->retries; try++) {
2497                 ret = adap->algo->master_xfer(adap, msgs, num);
2498                 if (ret != -EAGAIN)
2499                         break;
2500                 if (time_after(jiffies, orig_jiffies + adap->timeout))
2501                         break;
2502         }
2503
2504         if (static_key_false(&i2c_trace_msg)) {
2505                 int i;
2506                 for (i = 0; i < ret; i++)
2507                         if (msgs[i].flags & I2C_M_RD)
2508                                 trace_i2c_reply(adap, &msgs[i], i);
2509                 trace_i2c_result(adap, i, ret);
2510         }
2511
2512         return ret;
2513 }
2514 EXPORT_SYMBOL(__i2c_transfer);
2515
2516 /**
2517  * i2c_transfer - execute a single or combined I2C message
2518  * @adap: Handle to I2C bus
2519  * @msgs: One or more messages to execute before STOP is issued to
2520  *      terminate the operation; each message begins with a START.
2521  * @num: Number of messages to be executed.
2522  *
2523  * Returns negative errno, else the number of messages executed.
2524  *
2525  * Note that there is no requirement that each message be sent to
2526  * the same slave address, although that is the most common model.
2527  */
2528 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2529 {
2530         int ret;
2531
2532         /* REVISIT the fault reporting model here is weak:
2533          *
2534          *  - When we get an error after receiving N bytes from a slave,
2535          *    there is no way to report "N".
2536          *
2537          *  - When we get a NAK after transmitting N bytes to a slave,
2538          *    there is no way to report "N" ... or to let the master
2539          *    continue executing the rest of this combined message, if
2540          *    that's the appropriate response.
2541          *
2542          *  - When for example "num" is two and we successfully complete
2543          *    the first message but get an error part way through the
2544          *    second, it's unclear whether that should be reported as
2545          *    one (discarding status on the second message) or errno
2546          *    (discarding status on the first one).
2547          */
2548
2549         if (adap->algo->master_xfer) {
2550 #ifdef DEBUG
2551                 for (ret = 0; ret < num; ret++) {
2552                         dev_dbg(&adap->dev,
2553                                 "master_xfer[%d] %c, addr=0x%02x, len=%d%s\n",
2554                                 ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W',
2555                                 msgs[ret].addr, msgs[ret].len,
2556                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
2557                 }
2558 #endif
2559
2560                 if (in_atomic() || irqs_disabled()) {
2561                         ret = i2c_trylock_bus(adap, I2C_LOCK_SEGMENT);
2562                         if (!ret)
2563                                 /* I2C activity is ongoing. */
2564                                 return -EAGAIN;
2565                 } else {
2566                         i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
2567                 }
2568
2569                 ret = __i2c_transfer(adap, msgs, num);
2570                 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2571
2572                 return ret;
2573         } else {
2574                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2575                 return -EOPNOTSUPP;
2576         }
2577 }
2578 EXPORT_SYMBOL(i2c_transfer);
2579
2580 /**
2581  * i2c_master_send - issue a single I2C message in master transmit mode
2582  * @client: Handle to slave device
2583  * @buf: Data that will be written to the slave
2584  * @count: How many bytes to write, must be less than 64k since msg.len is u16
2585  *
2586  * Returns negative errno, or else the number of bytes written.
2587  */
2588 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
2589 {
2590         int ret;
2591         struct i2c_adapter *adap = client->adapter;
2592         struct i2c_msg msg;
2593
2594         msg.addr = client->addr;
2595         msg.flags = client->flags & I2C_M_TEN;
2596         msg.len = count;
2597         msg.buf = (char *)buf;
2598
2599         ret = i2c_transfer(adap, &msg, 1);
2600
2601         /*
2602          * If everything went ok (i.e. 1 msg transmitted), return #bytes
2603          * transmitted, else error code.
2604          */
2605         return (ret == 1) ? count : ret;
2606 }
2607 EXPORT_SYMBOL(i2c_master_send);
2608
2609 /**
2610  * i2c_master_recv - issue a single I2C message in master receive mode
2611  * @client: Handle to slave device
2612  * @buf: Where to store data read from slave
2613  * @count: How many bytes to read, must be less than 64k since msg.len is u16
2614  *
2615  * Returns negative errno, or else the number of bytes read.
2616  */
2617 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
2618 {
2619         struct i2c_adapter *adap = client->adapter;
2620         struct i2c_msg msg;
2621         int ret;
2622
2623         msg.addr = client->addr;
2624         msg.flags = client->flags & I2C_M_TEN;
2625         msg.flags |= I2C_M_RD;
2626         msg.len = count;
2627         msg.buf = buf;
2628
2629         ret = i2c_transfer(adap, &msg, 1);
2630
2631         /*
2632          * If everything went ok (i.e. 1 msg received), return #bytes received,
2633          * else error code.
2634          */
2635         return (ret == 1) ? count : ret;
2636 }
2637 EXPORT_SYMBOL(i2c_master_recv);
2638
2639 /* ----------------------------------------------------
2640  * the i2c address scanning function
2641  * Will not work for 10-bit addresses!
2642  * ----------------------------------------------------
2643  */
2644
2645 /*
2646  * Legacy default probe function, mostly relevant for SMBus. The default
2647  * probe method is a quick write, but it is known to corrupt the 24RF08
2648  * EEPROMs due to a state machine bug, and could also irreversibly
2649  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
2650  * we use a short byte read instead. Also, some bus drivers don't implement
2651  * quick write, so we fallback to a byte read in that case too.
2652  * On x86, there is another special case for FSC hardware monitoring chips,
2653  * which want regular byte reads (address 0x73.) Fortunately, these are the
2654  * only known chips using this I2C address on PC hardware.
2655  * Returns 1 if probe succeeded, 0 if not.
2656  */
2657 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2658 {
2659         int err;
2660         union i2c_smbus_data dummy;
2661
2662 #ifdef CONFIG_X86
2663         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2664          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2665                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2666                                      I2C_SMBUS_BYTE_DATA, &dummy);
2667         else
2668 #endif
2669         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
2670          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2671                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2672                                      I2C_SMBUS_QUICK, NULL);
2673         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2674                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2675                                      I2C_SMBUS_BYTE, &dummy);
2676         else {
2677                 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2678                          addr);
2679                 err = -EOPNOTSUPP;
2680         }
2681
2682         return err >= 0;
2683 }
2684
2685 static int i2c_detect_address(struct i2c_client *temp_client,
2686                               struct i2c_driver *driver)
2687 {
2688         struct i2c_board_info info;
2689         struct i2c_adapter *adapter = temp_client->adapter;
2690         int addr = temp_client->addr;
2691         int err;
2692
2693         /* Make sure the address is valid */
2694         err = i2c_check_7bit_addr_validity_strict(addr);
2695         if (err) {
2696                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
2697                          addr);
2698                 return err;
2699         }
2700
2701         /* Skip if already in use (7 bit, no need to encode flags) */
2702         if (i2c_check_addr_busy(adapter, addr))
2703                 return 0;
2704
2705         /* Make sure there is something at this address */
2706         if (!i2c_default_probe(adapter, addr))
2707                 return 0;
2708
2709         /* Finally call the custom detection function */
2710         memset(&info, 0, sizeof(struct i2c_board_info));
2711         info.addr = addr;
2712         err = driver->detect(temp_client, &info);
2713         if (err) {
2714                 /* -ENODEV is returned if the detection fails. We catch it
2715                    here as this isn't an error. */
2716                 return err == -ENODEV ? 0 : err;
2717         }
2718
2719         /* Consistency check */
2720         if (info.type[0] == '\0') {
2721                 dev_err(&adapter->dev,
2722                         "%s detection function provided no name for 0x%x\n",
2723                         driver->driver.name, addr);
2724         } else {
2725                 struct i2c_client *client;
2726
2727                 /* Detection succeeded, instantiate the device */
2728                 if (adapter->class & I2C_CLASS_DEPRECATED)
2729                         dev_warn(&adapter->dev,
2730                                 "This adapter will soon drop class based instantiation of devices. "
2731                                 "Please make sure client 0x%02x gets instantiated by other means. "
2732                                 "Check 'Documentation/i2c/instantiating-devices' for details.\n",
2733                                 info.addr);
2734
2735                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
2736                         info.type, info.addr);
2737                 client = i2c_new_device(adapter, &info);
2738                 if (client)
2739                         list_add_tail(&client->detected, &driver->clients);
2740                 else
2741                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
2742                                 info.type, info.addr);
2743         }
2744         return 0;
2745 }
2746
2747 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
2748 {
2749         const unsigned short *address_list;
2750         struct i2c_client *temp_client;
2751         int i, err = 0;
2752         int adap_id = i2c_adapter_id(adapter);
2753
2754         address_list = driver->address_list;
2755         if (!driver->detect || !address_list)
2756                 return 0;
2757
2758         /* Warn that the adapter lost class based instantiation */
2759         if (adapter->class == I2C_CLASS_DEPRECATED) {
2760                 dev_dbg(&adapter->dev,
2761                         "This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
2762                         "If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
2763                         driver->driver.name);
2764                 return 0;
2765         }
2766
2767         /* Stop here if the classes do not match */
2768         if (!(adapter->class & driver->class))
2769                 return 0;
2770
2771         /* Set up a temporary client to help detect callback */
2772         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
2773         if (!temp_client)
2774                 return -ENOMEM;
2775         temp_client->adapter = adapter;
2776
2777         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
2778                 dev_dbg(&adapter->dev,
2779                         "found normal entry for adapter %d, addr 0x%02x\n",
2780                         adap_id, address_list[i]);
2781                 temp_client->addr = address_list[i];
2782                 err = i2c_detect_address(temp_client, driver);
2783                 if (unlikely(err))
2784                         break;
2785         }
2786
2787         kfree(temp_client);
2788         return err;
2789 }
2790
2791 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2792 {
2793         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2794                               I2C_SMBUS_QUICK, NULL) >= 0;
2795 }
2796 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
2797
2798 struct i2c_client *
2799 i2c_new_probed_device(struct i2c_adapter *adap,
2800                       struct i2c_board_info *info,
2801                       unsigned short const *addr_list,
2802                       int (*probe)(struct i2c_adapter *, unsigned short addr))
2803 {
2804         int i;
2805
2806         if (!probe)
2807                 probe = i2c_default_probe;
2808
2809         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
2810                 /* Check address validity */
2811                 if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
2812                         dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2813                                  addr_list[i]);
2814                         continue;
2815                 }
2816
2817                 /* Check address availability (7 bit, no need to encode flags) */
2818                 if (i2c_check_addr_busy(adap, addr_list[i])) {
2819                         dev_dbg(&adap->dev,
2820                                 "Address 0x%02x already in use, not probing\n",
2821                                 addr_list[i]);
2822                         continue;
2823                 }
2824
2825                 /* Test address responsiveness */
2826                 if (probe(adap, addr_list[i]))
2827                         break;
2828         }
2829
2830         if (addr_list[i] == I2C_CLIENT_END) {
2831                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2832                 return NULL;
2833         }
2834
2835         info->addr = addr_list[i];
2836         return i2c_new_device(adap, info);
2837 }
2838 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
2839
2840 struct i2c_adapter *i2c_get_adapter(int nr)
2841 {
2842         struct i2c_adapter *adapter;
2843
2844         mutex_lock(&core_lock);
2845         adapter = idr_find(&i2c_adapter_idr, nr);
2846         if (!adapter)
2847                 goto exit;
2848
2849         if (try_module_get(adapter->owner))
2850                 get_device(&adapter->dev);
2851         else
2852                 adapter = NULL;
2853
2854  exit:
2855         mutex_unlock(&core_lock);
2856         return adapter;
2857 }
2858 EXPORT_SYMBOL(i2c_get_adapter);
2859
2860 void i2c_put_adapter(struct i2c_adapter *adap)
2861 {
2862         if (!adap)
2863                 return;
2864
2865         put_device(&adap->dev);
2866         module_put(adap->owner);
2867 }
2868 EXPORT_SYMBOL(i2c_put_adapter);
2869
2870 /* The SMBus parts */
2871
2872 #define POLY    (0x1070U << 3)
2873 static u8 crc8(u16 data)
2874 {
2875         int i;
2876
2877         for (i = 0; i < 8; i++) {
2878                 if (data & 0x8000)
2879                         data = data ^ POLY;
2880                 data = data << 1;
2881         }
2882         return (u8)(data >> 8);
2883 }
2884
2885 /* Incremental CRC8 over count bytes in the array pointed to by p */
2886 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
2887 {
2888         int i;
2889
2890         for (i = 0; i < count; i++)
2891                 crc = crc8((crc ^ p[i]) << 8);
2892         return crc;
2893 }
2894
2895 /* Assume a 7-bit address, which is reasonable for SMBus */
2896 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
2897 {
2898         /* The address will be sent first */
2899         u8 addr = i2c_8bit_addr_from_msg(msg);
2900         pec = i2c_smbus_pec(pec, &addr, 1);
2901
2902         /* The data buffer follows */
2903         return i2c_smbus_pec(pec, msg->buf, msg->len);
2904 }
2905
2906 /* Used for write only transactions */
2907 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
2908 {
2909         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
2910         msg->len++;
2911 }
2912
2913 /* Return <0 on CRC error
2914    If there was a write before this read (most cases) we need to take the
2915    partial CRC from the write part into account.
2916    Note that this function does modify the message (we need to decrease the
2917    message length to hide the CRC byte from the caller). */
2918 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
2919 {
2920         u8 rpec = msg->buf[--msg->len];
2921         cpec = i2c_smbus_msg_pec(cpec, msg);
2922
2923         if (rpec != cpec) {
2924                 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
2925                         rpec, cpec);
2926                 return -EBADMSG;
2927         }
2928         return 0;
2929 }
2930
2931 /**
2932  * i2c_smbus_read_byte - SMBus "receive byte" protocol
2933  * @client: Handle to slave device
2934  *
2935  * This executes the SMBus "receive byte" protocol, returning negative errno
2936  * else the byte received from the device.
2937  */
2938 s32 i2c_smbus_read_byte(const struct i2c_client *client)
2939 {
2940         union i2c_smbus_data data;
2941         int status;
2942
2943         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2944                                 I2C_SMBUS_READ, 0,
2945                                 I2C_SMBUS_BYTE, &data);
2946         return (status < 0) ? status : data.byte;
2947 }
2948 EXPORT_SYMBOL(i2c_smbus_read_byte);
2949
2950 /**
2951  * i2c_smbus_write_byte - SMBus "send byte" protocol
2952  * @client: Handle to slave device
2953  * @value: Byte to be sent
2954  *
2955  * This executes the SMBus "send byte" protocol, returning negative errno
2956  * else zero on success.
2957  */
2958 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
2959 {
2960         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2961                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
2962 }
2963 EXPORT_SYMBOL(i2c_smbus_write_byte);
2964
2965 /**
2966  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
2967  * @client: Handle to slave device
2968  * @command: Byte interpreted by slave
2969  *
2970  * This executes the SMBus "read byte" protocol, returning negative errno
2971  * else a data byte received from the device.
2972  */
2973 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
2974 {
2975         union i2c_smbus_data data;
2976         int status;
2977
2978         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2979                                 I2C_SMBUS_READ, command,
2980                                 I2C_SMBUS_BYTE_DATA, &data);
2981         return (status < 0) ? status : data.byte;
2982 }
2983 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
2984
2985 /**
2986  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
2987  * @client: Handle to slave device
2988  * @command: Byte interpreted by slave
2989  * @value: Byte being written
2990  *
2991  * This executes the SMBus "write byte" protocol, returning negative errno
2992  * else zero on success.
2993  */
2994 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
2995                               u8 value)
2996 {
2997         union i2c_smbus_data data;
2998         data.byte = value;
2999         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3000                               I2C_SMBUS_WRITE, command,
3001                               I2C_SMBUS_BYTE_DATA, &data);
3002 }
3003 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
3004
3005 /**
3006  * i2c_smbus_read_word_data - SMBus "read word" protocol
3007  * @client: Handle to slave device
3008  * @command: Byte interpreted by slave
3009  *
3010  * This executes the SMBus "read word" protocol, returning negative errno
3011  * else a 16-bit unsigned "word" received from the device.
3012  */
3013 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
3014 {
3015         union i2c_smbus_data data;
3016         int status;
3017
3018         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3019                                 I2C_SMBUS_READ, command,
3020                                 I2C_SMBUS_WORD_DATA, &data);
3021         return (status < 0) ? status : data.word;
3022 }
3023 EXPORT_SYMBOL(i2c_smbus_read_word_data);
3024
3025 /**
3026  * i2c_smbus_write_word_data - SMBus "write word" protocol
3027  * @client: Handle to slave device
3028  * @command: Byte interpreted by slave
3029  * @value: 16-bit "word" being written
3030  *
3031  * This executes the SMBus "write word" protocol, returning negative errno
3032  * else zero on success.
3033  */
3034 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
3035                               u16 value)
3036 {
3037         union i2c_smbus_data data;
3038         data.word = value;
3039         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3040                               I2C_SMBUS_WRITE, command,
3041                               I2C_SMBUS_WORD_DATA, &data);
3042 }
3043 EXPORT_SYMBOL(i2c_smbus_write_word_data);
3044
3045 /**
3046  * i2c_smbus_read_block_data - SMBus "block read" protocol
3047  * @client: Handle to slave device
3048  * @command: Byte interpreted by slave
3049  * @values: Byte array into which data will be read; big enough to hold
3050  *      the data returned by the slave.  SMBus allows at most 32 bytes.
3051  *
3052  * This executes the SMBus "block read" protocol, returning negative errno
3053  * else the number of data bytes in the slave's response.
3054  *
3055  * Note that using this function requires that the client's adapter support
3056  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
3057  * support this; its emulation through I2C messaging relies on a specific
3058  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
3059  */
3060 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
3061                               u8 *values)
3062 {
3063         union i2c_smbus_data data;
3064         int status;
3065
3066         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3067                                 I2C_SMBUS_READ, command,
3068                                 I2C_SMBUS_BLOCK_DATA, &data);
3069         if (status)
3070                 return status;
3071
3072         memcpy(values, &data.block[1], data.block[0]);
3073         return data.block[0];
3074 }
3075 EXPORT_SYMBOL(i2c_smbus_read_block_data);
3076
3077 /**
3078  * i2c_smbus_write_block_data - SMBus "block write" protocol
3079  * @client: Handle to slave device
3080  * @command: Byte interpreted by slave
3081  * @length: Size of data block; SMBus allows at most 32 bytes
3082  * @values: Byte array which will be written.
3083  *
3084  * This executes the SMBus "block write" protocol, returning negative errno
3085  * else zero on success.
3086  */
3087 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
3088                                u8 length, const u8 *values)
3089 {
3090         union i2c_smbus_data data;
3091
3092         if (length > I2C_SMBUS_BLOCK_MAX)
3093                 length = I2C_SMBUS_BLOCK_MAX;
3094         data.block[0] = length;
3095         memcpy(&data.block[1], values, length);
3096         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3097                               I2C_SMBUS_WRITE, command,
3098                               I2C_SMBUS_BLOCK_DATA, &data);
3099 }
3100 EXPORT_SYMBOL(i2c_smbus_write_block_data);
3101
3102 /* Returns the number of read bytes */
3103 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
3104                                   u8 length, u8 *values)
3105 {
3106         union i2c_smbus_data data;
3107         int status;
3108
3109         if (length > I2C_SMBUS_BLOCK_MAX)
3110                 length = I2C_SMBUS_BLOCK_MAX;
3111         data.block[0] = length;
3112         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3113                                 I2C_SMBUS_READ, command,
3114                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
3115         if (status < 0)
3116                 return status;
3117
3118         memcpy(values, &data.block[1], data.block[0]);
3119         return data.block[0];
3120 }
3121 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
3122
3123 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
3124                                    u8 length, const u8 *values)
3125 {
3126         union i2c_smbus_data data;
3127
3128         if (length > I2C_SMBUS_BLOCK_MAX)
3129                 length = I2C_SMBUS_BLOCK_MAX;
3130         data.block[0] = length;
3131         memcpy(data.block + 1, values, length);
3132         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
3133                               I2C_SMBUS_WRITE, command,
3134                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
3135 }
3136 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
3137
3138 /* Simulate a SMBus command using the i2c protocol
3139    No checking of parameters is done!  */
3140 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
3141                                    unsigned short flags,
3142                                    char read_write, u8 command, int size,
3143                                    union i2c_smbus_data *data)
3144 {
3145         /* So we need to generate a series of msgs. In the case of writing, we
3146           need to use only one message; when reading, we need two. We initialize
3147           most things with sane defaults, to keep the code below somewhat
3148           simpler. */
3149         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
3150         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
3151         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
3152         int i;
3153         u8 partial_pec = 0;
3154         int status;
3155         struct i2c_msg msg[2] = {
3156                 {
3157                         .addr = addr,
3158                         .flags = flags,
3159                         .len = 1,
3160                         .buf = msgbuf0,
3161                 }, {
3162                         .addr = addr,
3163                         .flags = flags | I2C_M_RD,
3164                         .len = 0,
3165                         .buf = msgbuf1,
3166                 },
3167         };
3168
3169         msgbuf0[0] = command;
3170         switch (size) {
3171         case I2C_SMBUS_QUICK:
3172                 msg[0].len = 0;
3173                 /* Special case: The read/write field is used as data */
3174                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
3175                                         I2C_M_RD : 0);
3176                 num = 1;
3177                 break;
3178         case I2C_SMBUS_BYTE:
3179                 if (read_write == I2C_SMBUS_READ) {
3180                         /* Special case: only a read! */
3181                         msg[0].flags = I2C_M_RD | flags;
3182                         num = 1;
3183                 }
3184                 break;
3185         case I2C_SMBUS_BYTE_DATA:
3186                 if (read_write == I2C_SMBUS_READ)
3187                         msg[1].len = 1;
3188                 else {
3189                         msg[0].len = 2;
3190                         msgbuf0[1] = data->byte;
3191                 }
3192                 break;
3193         case I2C_SMBUS_WORD_DATA:
3194                 if (read_write == I2C_SMBUS_READ)
3195                         msg[1].len = 2;
3196                 else {
3197                         msg[0].len = 3;
3198                         msgbuf0[1] = data->word & 0xff;
3199                         msgbuf0[2] = data->word >> 8;
3200                 }
3201                 break;
3202         case I2C_SMBUS_PROC_CALL:
3203                 num = 2; /* Special case */
3204                 read_write = I2C_SMBUS_READ;
3205                 msg[0].len = 3;
3206                 msg[1].len = 2;
3207                 msgbuf0[1] = data->word & 0xff;
3208                 msgbuf0[2] = data->word >> 8;
3209                 break;
3210         case I2C_SMBUS_BLOCK_DATA:
3211                 if (read_write == I2C_SMBUS_READ) {
3212                         msg[1].flags |= I2C_M_RECV_LEN;
3213                         msg[1].len = 1; /* block length will be added by
3214                                            the underlying bus driver */
3215                 } else {
3216                         msg[0].len = data->block[0] + 2;
3217                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
3218                                 dev_err(&adapter->dev,
3219                                         "Invalid block write size %d\n",
3220                                         data->block[0]);
3221                                 return -EINVAL;
3222                         }
3223                         for (i = 1; i < msg[0].len; i++)
3224                                 msgbuf0[i] = data->block[i-1];
3225                 }
3226                 break;
3227         case I2C_SMBUS_BLOCK_PROC_CALL:
3228                 num = 2; /* Another special case */
3229                 read_write = I2C_SMBUS_READ;
3230                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
3231                         dev_err(&adapter->dev,
3232                                 "Invalid block write size %d\n",
3233                                 data->block[0]);
3234                         return -EINVAL;
3235                 }
3236                 msg[0].len = data->block[0] + 2;
3237                 for (i = 1; i < msg[0].len; i++)
3238                         msgbuf0[i] = data->block[i-1];
3239                 msg[1].flags |= I2C_M_RECV_LEN;
3240                 msg[1].len = 1; /* block length will be added by
3241                                    the underlying bus driver */
3242                 break;
3243         case I2C_SMBUS_I2C_BLOCK_DATA:
3244                 if (read_write == I2C_SMBUS_READ) {
3245                         msg[1].len = data->block[0];
3246                 } else {
3247                         msg[0].len = data->block[0] + 1;
3248                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
3249                                 dev_err(&adapter->dev,
3250                                         "Invalid block write size %d\n",
3251                                         data->block[0]);
3252                                 return -EINVAL;
3253                         }
3254                         for (i = 1; i <= data->block[0]; i++)
3255                                 msgbuf0[i] = data->block[i];
3256                 }
3257                 break;
3258         default:
3259                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
3260                 return -EOPNOTSUPP;
3261         }
3262
3263         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
3264                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
3265         if (i) {
3266                 /* Compute PEC if first message is a write */
3267                 if (!(msg[0].flags & I2C_M_RD)) {
3268                         if (num == 1) /* Write only */
3269                                 i2c_smbus_add_pec(&msg[0]);
3270                         else /* Write followed by read */
3271                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
3272                 }
3273                 /* Ask for PEC if last message is a read */
3274                 if (msg[num-1].flags & I2C_M_RD)
3275                         msg[num-1].len++;
3276         }
3277
3278         status = i2c_transfer(adapter, msg, num);
3279         if (status < 0)
3280                 return status;
3281
3282         /* Check PEC if last message is a read */
3283         if (i && (msg[num-1].flags & I2C_M_RD)) {
3284                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
3285                 if (status < 0)
3286                         return status;
3287         }
3288
3289         if (read_write == I2C_SMBUS_READ)
3290                 switch (size) {
3291                 case I2C_SMBUS_BYTE:
3292                         data->byte = msgbuf0[0];
3293                         break;
3294                 case I2C_SMBUS_BYTE_DATA:
3295                         data->byte = msgbuf1[0];
3296                         break;
3297                 case I2C_SMBUS_WORD_DATA:
3298                 case I2C_SMBUS_PROC_CALL:
3299                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
3300                         break;
3301                 case I2C_SMBUS_I2C_BLOCK_DATA:
3302                         for (i = 0; i < data->block[0]; i++)
3303                                 data->block[i+1] = msgbuf1[i];
3304                         break;
3305                 case I2C_SMBUS_BLOCK_DATA:
3306                 case I2C_SMBUS_BLOCK_PROC_CALL:
3307                         for (i = 0; i < msgbuf1[0] + 1; i++)
3308                                 data->block[i] = msgbuf1[i];
3309                         break;
3310                 }
3311         return 0;
3312 }
3313
3314 /**
3315  * i2c_smbus_xfer - execute SMBus protocol operations
3316  * @adapter: Handle to I2C bus
3317  * @addr: Address of SMBus slave on that bus
3318  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
3319  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
3320  * @command: Byte interpreted by slave, for protocols which use such bytes
3321  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
3322  * @data: Data to be read or written
3323  *
3324  * This executes an SMBus protocol operation, and returns a negative
3325  * errno code else zero on success.
3326  */
3327 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
3328                    char read_write, u8 command, int protocol,
3329                    union i2c_smbus_data *data)
3330 {
3331         unsigned long orig_jiffies;
3332         int try;
3333         s32 res;
3334
3335         /* If enabled, the following two tracepoints are conditional on
3336          * read_write and protocol.
3337          */
3338         trace_smbus_write(adapter, addr, flags, read_write,
3339                           command, protocol, data);
3340         trace_smbus_read(adapter, addr, flags, read_write,
3341                          command, protocol);
3342
3343         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
3344
3345         if (adapter->algo->smbus_xfer) {
3346                 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
3347
3348                 /* Retry automatically on arbitration loss */
3349                 orig_jiffies = jiffies;
3350                 for (res = 0, try = 0; try <= adapter->retries; try++) {
3351                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
3352                                                         read_write, command,
3353                                                         protocol, data);
3354                         if (res != -EAGAIN)
3355                                 break;
3356                         if (time_after(jiffies,
3357                                        orig_jiffies + adapter->timeout))
3358                                 break;
3359                 }
3360                 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
3361
3362                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
3363                         goto trace;
3364                 /*
3365                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
3366                  * implement native support for the SMBus operation.
3367                  */
3368         }
3369
3370         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
3371                                       command, protocol, data);
3372
3373 trace:
3374         /* If enabled, the reply tracepoint is conditional on read_write. */
3375         trace_smbus_reply(adapter, addr, flags, read_write,
3376                           command, protocol, data);
3377         trace_smbus_result(adapter, addr, flags, read_write,
3378                            command, protocol, res);
3379
3380         return res;
3381 }
3382 EXPORT_SYMBOL(i2c_smbus_xfer);
3383
3384 /**
3385  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
3386  * @client: Handle to slave device
3387  * @command: Byte interpreted by slave
3388  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
3389  * @values: Byte array into which data will be read; big enough to hold
3390  *      the data returned by the slave.  SMBus allows at most
3391  *      I2C_SMBUS_BLOCK_MAX bytes.
3392  *
3393  * This executes the SMBus "block read" protocol if supported by the adapter.
3394  * If block read is not supported, it emulates it using either word or byte
3395  * read protocols depending on availability.
3396  *
3397  * The addresses of the I2C slave device that are accessed with this function
3398  * must be mapped to a linear region, so that a block read will have the same
3399  * effect as a byte read. Before using this function you must double-check
3400  * if the I2C slave does support exchanging a block transfer with a byte
3401  * transfer.
3402  */
3403 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
3404                                               u8 command, u8 length, u8 *values)
3405 {
3406         u8 i = 0;
3407         int status;
3408
3409         if (length > I2C_SMBUS_BLOCK_MAX)
3410                 length = I2C_SMBUS_BLOCK_MAX;
3411
3412         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
3413                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
3414
3415         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
3416                 return -EOPNOTSUPP;
3417
3418         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
3419                 while ((i + 2) <= length) {
3420                         status = i2c_smbus_read_word_data(client, command + i);
3421                         if (status < 0)
3422                                 return status;
3423                         values[i] = status & 0xff;
3424                         values[i + 1] = status >> 8;
3425                         i += 2;
3426                 }
3427         }
3428
3429         while (i < length) {
3430                 status = i2c_smbus_read_byte_data(client, command + i);
3431                 if (status < 0)
3432                         return status;
3433                 values[i] = status;
3434                 i++;
3435         }
3436
3437         return i;
3438 }
3439 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
3440
3441 #if IS_ENABLED(CONFIG_I2C_SLAVE)
3442 int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb)
3443 {
3444         int ret;
3445
3446         if (!client || !slave_cb) {
3447                 WARN(1, "insufficent data\n");
3448      &nb