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