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