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     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  18 /* ------------------------------------------------------------------------- */
  19
  20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
  21    All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
  22    SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
  23    Jean Delvare <khali@linux-fr.org> */
  24
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/errno.h>
  28 #include <linux/slab.h>
  29 #include <linux/i2c.h>
  30 #include <linux/init.h>
  31 #include <linux/idr.h>
  32 #include <linux/mutex.h>
  33 #include <linux/completion.h>
  34 #include <linux/hardirq.h>
  35 #include <linux/irqflags.h>
  36 #include <linux/rwsem.h>
  37 #include <asm/uaccess.h>
  38
  39 #include "i2c-core.h"
  40
  41
  42 /* core_lock protects i2c_adapter_idr, userspace_devices, and guarantees
  43    that device detection, deletion of detected devices, and attach_adapter
  44    and detach_adapter calls are serialized */
  45 static DEFINE_MUTEX(core_lock);
  46 static DEFINE_IDR(i2c_adapter_idr);
  47 static LIST_HEAD(userspace_devices);
  48
  49 static struct device_type i2c_client_type;
  50 static int i2c_check_addr(struct i2c_adapter *adapter, int addr);
  51 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
  52
  53 /* ------------------------------------------------------------------------- */
  54
  55 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
  56                                                 const struct i2c_client *client)
  57 {
  58         while (id->name[0]) {
  59                 if (strcmp(client->name, id->name) == 0)
  60                         return id;
  61                 id++;
  62         }
  63         return NULL;
  64 }
  65
  66 static int i2c_device_match(struct device *dev, struct device_driver *drv)
  67 {
  68         struct i2c_client       *client = i2c_verify_client(dev);
  69         struct i2c_driver       *driver;
  70
  71         if (!client)
  72                 return 0;
  73
  74         driver = to_i2c_driver(drv);
  75         /* match on an id table if there is one */
  76         if (driver->id_table)
  77                 return i2c_match_id(driver->id_table, client) != NULL;
  78
  79         return 0;
  80 }
  81
  82 #ifdef  CONFIG_HOTPLUG
  83
  84 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
  85 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  86 {
  87         struct i2c_client       *client = to_i2c_client(dev);
  88
  89         if (add_uevent_var(env, "MODALIAS=%s%s",
  90                            I2C_MODULE_PREFIX, client->name))
  91                 return -ENOMEM;
  92         dev_dbg(dev, "uevent\n");
  93         return 0;
  94 }
  95
  96 #else
  97 #define i2c_device_uevent       NULL
  98 #endif  /* CONFIG_HOTPLUG */
  99
 100 static int i2c_device_probe(struct device *dev)
 101 {
 102         struct i2c_client       *client = i2c_verify_client(dev);
 103         struct i2c_driver       *driver;
 104         int status;
 105
 106         if (!client)
 107                 return 0;
 108
 109         driver = to_i2c_driver(dev->driver);
 110         if (!driver->probe || !driver->id_table)
 111                 return -ENODEV;
 112         client->driver = driver;
 113         if (!device_can_wakeup(&client->dev))
 114                 device_init_wakeup(&client->dev,
 115                                         client->flags & I2C_CLIENT_WAKE);
 116         dev_dbg(dev, "probe\n");
 117
 118         status = driver->probe(client, i2c_match_id(driver->id_table, client));
 119         if (status)
 120                 client->driver = NULL;
 121         return status;
 122 }
 123
 124 static int i2c_device_remove(struct device *dev)
 125 {
 126         struct i2c_client       *client = i2c_verify_client(dev);
 127         struct i2c_driver       *driver;
 128         int                     status;
 129
 130         if (!client || !dev->driver)
 131                 return 0;
 132
 133         driver = to_i2c_driver(dev->driver);
 134         if (driver->remove) {
 135                 dev_dbg(dev, "remove\n");
 136                 status = driver->remove(client);
 137         } else {
 138                 dev->driver = NULL;
 139                 status = 0;
 140         }
 141         if (status == 0)
 142                 client->driver = NULL;
 143         return status;
 144 }
 145
 146 static void i2c_device_shutdown(struct device *dev)
 147 {
 148         struct i2c_client *client = i2c_verify_client(dev);
 149         struct i2c_driver *driver;
 150
 151         if (!client || !dev->driver)
 152                 return;
 153         driver = to_i2c_driver(dev->driver);
 154         if (driver->shutdown)
 155                 driver->shutdown(client);
 156 }
 157
 158 static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
 159 {
 160         struct i2c_client *client = i2c_verify_client(dev);
 161         struct i2c_driver *driver;
 162
 163         if (!client || !dev->driver)
 164                 return 0;
 165         driver = to_i2c_driver(dev->driver);
 166         if (!driver->suspend)
 167                 return 0;
 168         return driver->suspend(client, mesg);
 169 }
 170
 171 static int i2c_device_resume(struct device *dev)
 172 {
 173         struct i2c_client *client = i2c_verify_client(dev);
 174         struct i2c_driver *driver;
 175
 176         if (!client || !dev->driver)
 177                 return 0;
 178         driver = to_i2c_driver(dev->driver);
 179         if (!driver->resume)
 180                 return 0;
 181         return driver->resume(client);
 182 }
 183
 184 static void i2c_client_dev_release(struct device *dev)
 185 {
 186         kfree(to_i2c_client(dev));
 187 }
 188
 189 static ssize_t
 190 show_name(struct device *dev, struct device_attribute *attr, char *buf)
 191 {
 192         return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
 193                        to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
 194 }
 195
 196 static ssize_t
 197 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 198 {
 199         struct i2c_client *client = to_i2c_client(dev);
 200         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
 201 }
 202
 203 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 204 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 205
 206 static struct attribute *i2c_dev_attrs[] = {
 207         &dev_attr_name.attr,
 208         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
 209         &dev_attr_modalias.attr,
 210         NULL
 211 };
 212
 213 static struct attribute_group i2c_dev_attr_group = {
 214         .attrs          = i2c_dev_attrs,
 215 };
 216
 217 static const struct attribute_group *i2c_dev_attr_groups[] = {
 218         &i2c_dev_attr_group,
 219         NULL
 220 };
 221
 222 struct bus_type i2c_bus_type = {
 223         .name           = "i2c",
 224         .match          = i2c_device_match,
 225         .probe          = i2c_device_probe,
 226         .remove         = i2c_device_remove,
 227         .shutdown       = i2c_device_shutdown,
 228         .suspend        = i2c_device_suspend,
 229         .resume         = i2c_device_resume,
 230 };
 231 EXPORT_SYMBOL_GPL(i2c_bus_type);
 232
 233 static struct device_type i2c_client_type = {
 234         .groups         = i2c_dev_attr_groups,
 235         .uevent         = i2c_device_uevent,
 236         .release        = i2c_client_dev_release,
 237 };
 238
 239
 240 /**
 241  * i2c_verify_client - return parameter as i2c_client, or NULL
 242  * @dev: device, probably from some driver model iterator
 243  *
 244  * When traversing the driver model tree, perhaps using driver model
 245  * iterators like @device_for_each_child(), you can't assume very much
 246  * about the nodes you find.  Use this function to avoid oopses caused
 247  * by wrongly treating some non-I2C device as an i2c_client.
 248  */
 249 struct i2c_client *i2c_verify_client(struct device *dev)
 250 {
 251         return (dev->type == &i2c_client_type)
 252                         ? to_i2c_client(dev)
 253                         : NULL;
 254 }
 255 EXPORT_SYMBOL(i2c_verify_client);
 256
 257
 258 /**
 259  * i2c_new_device - instantiate an i2c device
 260  * @adap: the adapter managing the device
 261  * @info: describes one I2C device; bus_num is ignored
 262  * Context: can sleep
 263  *
 264  * Create an i2c device. Binding is handled through driver model
 265  * probe()/remove() methods.  A driver may be bound to this device when we
 266  * return from this function, or any later moment (e.g. maybe hotplugging will
 267  * load the driver module).  This call is not appropriate for use by mainboard
 268  * initialization logic, which usually runs during an arch_initcall() long
 269  * before any i2c_adapter could exist.
 270  *
 271  * This returns the new i2c client, which may be saved for later use with
 272  * i2c_unregister_device(); or NULL to indicate an error.
 273  */
 274 struct i2c_client *
 275 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 276 {
 277         struct i2c_client       *client;
 278         int                     status;
 279
 280         client = kzalloc(sizeof *client, GFP_KERNEL);
 281         if (!client)
 282                 return NULL;
 283
 284         client->adapter = adap;
 285
 286         client->dev.platform_data = info->platform_data;
 287
 288         if (info->archdata)
 289                 client->dev.archdata = *info->archdata;
 290
 291         client->flags = info->flags;
 292         client->addr = info->addr;
 293         client->irq = info->irq;
 294
 295         strlcpy(client->name, info->type, sizeof(client->name));
 296
 297         /* Check for address business */
 298         status = i2c_check_addr(adap, client->addr);
 299         if (status)
 300                 goto out_err;
 301
 302         client->dev.parent = &client->adapter->dev;
 303         client->dev.bus = &i2c_bus_type;
 304         client->dev.type = &i2c_client_type;
 305
 306         dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
 307                      client->addr);
 308         status = device_register(&client->dev);
 309         if (status)
 310                 goto out_err;
 311
 312         dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
 313                 client->name, dev_name(&client->dev));
 314
 315         return client;
 316
 317 out_err:
 318         dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
 319                 "(%d)\n", client->name, client->addr, status);
 320         kfree(client);
 321         return NULL;
 322 }
 323 EXPORT_SYMBOL_GPL(i2c_new_device);
 324
 325
 326 /**
 327  * i2c_unregister_device - reverse effect of i2c_new_device()
 328  * @client: value returned from i2c_new_device()
 329  * Context: can sleep
 330  */
 331 void i2c_unregister_device(struct i2c_client *client)
 332 {
 333         device_unregister(&client->dev);
 334 }
 335 EXPORT_SYMBOL_GPL(i2c_unregister_device);
 336
 337
 338 static const struct i2c_device_id dummy_id[] = {
 339         { "dummy", 0 },
 340         { },
 341 };
 342
 343 static int dummy_probe(struct i2c_client *client,
 344                        const struct i2c_device_id *id)
 345 {
 346         return 0;
 347 }
 348
 349 static int dummy_remove(struct i2c_client *client)
 350 {
 351         return 0;
 352 }
 353
 354 static struct i2c_driver dummy_driver = {
 355         .driver.name    = "dummy",
 356         .probe          = dummy_probe,
 357         .remove         = dummy_remove,
 358         .id_table       = dummy_id,
 359 };
 360
 361 /**
 362  * i2c_new_dummy - return a new i2c device bound to a dummy driver
 363  * @adapter: the adapter managing the device
 364  * @address: seven bit address to be used
 365  * Context: can sleep
 366  *
 367  * This returns an I2C client bound to the "dummy" driver, intended for use
 368  * with devices that consume multiple addresses.  Examples of such chips
 369  * include various EEPROMS (like 24c04 and 24c08 models).
 370  *
 371  * These dummy devices have two main uses.  First, most I2C and SMBus calls
 372  * except i2c_transfer() need a client handle; the dummy will be that handle.
 373  * And second, this prevents the specified address from being bound to a
 374  * different driver.
 375  *
 376  * This returns the new i2c client, which should be saved for later use with
 377  * i2c_unregister_device(); or NULL to indicate an error.
 378  */
 379 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
 380 {
 381         struct i2c_board_info info = {
 382                 I2C_BOARD_INFO("dummy", address),
 383         };
 384
 385         return i2c_new_device(adapter, &info);
 386 }
 387 EXPORT_SYMBOL_GPL(i2c_new_dummy);
 388
 389 /* ------------------------------------------------------------------------- */
 390
 391 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
 392
 393 static void i2c_adapter_dev_release(struct device *dev)
 394 {
 395         struct i2c_adapter *adap = to_i2c_adapter(dev);
 396         complete(&adap->dev_released);
 397 }
 398
 399 /*
 400  * Let users instantiate I2C devices through sysfs. This can be used when
 401  * platform initialization code doesn't contain the proper data for
 402  * whatever reason. Also useful for drivers that do device detection and
 403  * detection fails, either because the device uses an unexpected address,
 404  * or this is a compatible device with different ID register values.
 405  *
 406  * Parameter checking may look overzealous, but we really don't want
 407  * the user to provide incorrect parameters.
 408  */
 409 static ssize_t
 410 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
 411                      const char *buf, size_t count)
 412 {
 413         struct i2c_adapter *adap = to_i2c_adapter(dev);
 414         struct i2c_board_info info;
 415         struct i2c_client *client;
 416         char *blank, end;
 417         int res;
 418
 419         dev_warn(dev, "The new_device interface is still experimental "
 420                  "and may change in a near future\n");
 421         memset(&info, 0, sizeof(struct i2c_board_info));
 422
 423         blank = strchr(buf, ' ');
 424         if (!blank) {
 425                 dev_err(dev, "%s: Missing parameters\n", "new_device");
 426                 return -EINVAL;
 427         }
 428         if (blank - buf > I2C_NAME_SIZE - 1) {
 429                 dev_err(dev, "%s: Invalid device name\n", "new_device");
 430                 return -EINVAL;
 431         }
 432         memcpy(info.type, buf, blank - buf);
 433
 434         /* Parse remaining parameters, reject extra parameters */
 435         res = sscanf(++blank, "%hi%c", &info.addr, &end);
 436         if (res < 1) {
 437                 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
 438                 return -EINVAL;
 439         }
 440         if (res > 1  && end != '\n') {
 441                 dev_err(dev, "%s: Extra parameters\n", "new_device");
 442                 return -EINVAL;
 443         }
 444
 445         if (info.addr < 0x03 || info.addr > 0x77) {
 446                 dev_err(dev, "%s: Invalid I2C address 0x%hx\n", "new_device",
 447                         info.addr);
 448                 return -EINVAL;
 449         }
 450
 451         client = i2c_new_device(adap, &info);
 452         if (!client)
 453                 return -EEXIST;
 454
 455         /* Keep track of the added device */
 456         mutex_lock(&core_lock);
 457         list_add_tail(&client->detected, &userspace_devices);
 458         mutex_unlock(&core_lock);
 459         dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
 460                  info.type, info.addr);
 461
 462         return count;
 463 }
 464
 465 /*
 466  * And of course let the users delete the devices they instantiated, if
 467  * they got it wrong. This interface can only be used to delete devices
 468  * instantiated by i2c_sysfs_new_device above. This guarantees that we
 469  * don't delete devices to which some kernel code still has references.
 470  *
 471  * Parameter checking may look overzealous, but we really don't want
 472  * the user to delete the wrong device.
 473  */
 474 static ssize_t
 475 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
 476                         const char *buf, size_t count)
 477 {
 478         struct i2c_adapter *adap = to_i2c_adapter(dev);
 479         struct i2c_client *client, *next;
 480         unsigned short addr;
 481         char end;
 482         int res;
 483
 484         /* Parse parameters, reject extra parameters */
 485         res = sscanf(buf, "%hi%c", &addr, &end);
 486         if (res < 1) {
 487                 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
 488                 return -EINVAL;
 489         }
 490         if (res > 1  && end != '\n') {
 491                 dev_err(dev, "%s: Extra parameters\n", "delete_device");
 492                 return -EINVAL;
 493         }
 494
 495         /* Make sure the device was added through sysfs */
 496         res = -ENOENT;
 497         mutex_lock(&core_lock);
 498         list_for_each_entry_safe(client, next, &userspace_devices, detected) {
 499                 if (client->addr == addr && client->adapter == adap) {
 500                         dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
 501                                  "delete_device", client->name, client->addr);
 502
 503                         list_del(&client->detected);
 504                         i2c_unregister_device(client);
 505                         res = count;
 506                         break;
 507                 }
 508         }
 509         mutex_unlock(&core_lock);
 510
 511         if (res < 0)
 512                 dev_err(dev, "%s: Can't find device in list\n",
 513                         "delete_device");
 514         return res;
 515 }
 516
 517 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 518 static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
 519
 520 static struct attribute *i2c_adapter_attrs[] = {
 521         &dev_attr_name.attr,
 522         &dev_attr_new_device.attr,
 523         &dev_attr_delete_device.attr,
 524         NULL
 525 };
 526
 527 static struct attribute_group i2c_adapter_attr_group = {
 528         .attrs          = i2c_adapter_attrs,
 529 };
 530
 531 static const struct attribute_group *i2c_adapter_attr_groups[] = {
 532         &i2c_adapter_attr_group,
 533         NULL
 534 };
 535
 536 static struct device_type i2c_adapter_type = {
 537         .groups         = i2c_adapter_attr_groups,
 538         .release        = i2c_adapter_dev_release,
 539 };
 540
 541 #ifdef CONFIG_I2C_COMPAT
 542 static struct class_compat *i2c_adapter_compat_class;
 543 #endif
 544
 545 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 546 {
 547         struct i2c_devinfo      *devinfo;
 548
 549         down_read(&__i2c_board_lock);
 550         list_for_each_entry(devinfo, &__i2c_board_list, list) {
 551                 if (devinfo->busnum == adapter->nr
 552                                 && !i2c_new_device(adapter,
 553                                                 &devinfo->board_info))
 554                         dev_err(&adapter->dev,
 555                                 "Can't create device at 0x%02x\n",
 556                                 devinfo->board_info.addr);
 557         }
 558         up_read(&__i2c_board_lock);
 559 }
 560
 561 static int i2c_do_add_adapter(struct device_driver *d, void *data)
 562 {
 563         struct i2c_driver *driver = to_i2c_driver(d);
 564         struct i2c_adapter *adap = data;
 565
 566         /* Detect supported devices on that bus, and instantiate them */
 567         i2c_detect(adap, driver);
 568
 569         /* Let legacy drivers scan this bus for matching devices */
 570         if (driver->attach_adapter) {
 571                 /* We ignore the return code; if it fails, too bad */
 572                 driver->attach_adapter(adap);
 573         }
 574         return 0;
 575 }
 576
 577 static int i2c_register_adapter(struct i2c_adapter *adap)
 578 {
 579         int res = 0, dummy;
 580
 581         /* Can't register until after driver model init */
 582         if (unlikely(WARN_ON(!i2c_bus_type.p))) {
 583                 res = -EAGAIN;
 584                 goto out_list;
 585         }
 586
 587         mutex_init(&adap->bus_lock);
 588
 589         /* Set default timeout to 1 second if not already set */
 590         if (adap->timeout == 0)
 591                 adap->timeout = HZ;
 592
 593         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
 594         adap->dev.bus = &i2c_bus_type;
 595         adap->dev.type = &i2c_adapter_type;
 596         res = device_register(&adap->dev);
 597         if (res)
 598                 goto out_list;
 599
 600         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 601
 602 #ifdef CONFIG_I2C_COMPAT
 603         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
 604                                        adap->dev.parent);
 605         if (res)
 606                 dev_warn(&adap->dev,
 607                          "Failed to create compatibility class link\n");
 608 #endif
 609
 610         /* create pre-declared device nodes */
 611         if (adap->nr < __i2c_first_dynamic_bus_num)
 612                 i2c_scan_static_board_info(adap);
 613
 614         /* Notify drivers */
 615         mutex_lock(&core_lock);
 616         dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
 617                                  i2c_do_add_adapter);
 618         mutex_unlock(&core_lock);
 619
 620         return 0;
 621
 622 out_list:
 623         mutex_lock(&core_lock);
 624         idr_remove(&i2c_adapter_idr, adap->nr);
 625         mutex_unlock(&core_lock);
 626         return res;
 627 }
 628
 629 /**
 630  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 631  * @adapter: the adapter to add
 632  * Context: can sleep
 633  *
 634  * This routine is used to declare an I2C adapter when its bus number
 635  * doesn't matter.  Examples: for I2C adapters dynamically added by
 636  * USB links or PCI plugin cards.
 637  *
 638  * When this returns zero, a new bus number was allocated and stored
 639  * in adap->nr, and the specified adapter became available for clients.
 640  * Otherwise, a negative errno value is returned.
 641  */
 642 int i2c_add_adapter(struct i2c_adapter *adapter)
 643 {
 644         int     id, res = 0;
 645
 646 retry:
 647         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 648                 return -ENOMEM;
 649
 650         mutex_lock(&core_lock);
 651         /* "above" here means "above or equal to", sigh */
 652         res = idr_get_new_above(&i2c_adapter_idr, adapter,
 653                                 __i2c_first_dynamic_bus_num, &id);
 654         mutex_unlock(&core_lock);
 655
 656         if (res < 0) {
 657                 if (res == -EAGAIN)
 658                         goto retry;
 659                 return res;
 660         }
 661
 662         adapter->nr = id;
 663         return i2c_register_adapter(adapter);
 664 }
 665 EXPORT_SYMBOL(i2c_add_adapter);
 666
 667 /**
 668  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 669  * @adap: the adapter to register (with adap->nr initialized)
 670  * Context: can sleep
 671  *
 672  * This routine is used to declare an I2C adapter when its bus number
 673  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 674  * or otherwise built in to the system's mainboard, and where i2c_board_info
 675  * is used to properly configure I2C devices.
 676  *
 677  * If no devices have pre-been declared for this bus, then be sure to
 678  * register the adapter before any dynamically allocated ones.  Otherwise
 679  * the required bus ID may not be available.
 680  *
 681  * When this returns zero, the specified adapter became available for
 682  * clients using the bus number provided in adap->nr.  Also, the table
 683  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 684  * and the appropriate driver model device nodes are created.  Otherwise, a
 685  * negative errno value is returned.
 686  */
 687 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 688 {
 689         int     id;
 690         int     status;
 691
 692         if (adap->nr & ~MAX_ID_MASK)
 693                 return -EINVAL;
 694
 695 retry:
 696         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 697                 return -ENOMEM;
 698
 699         mutex_lock(&core_lock);
 700         /* "above" here means "above or equal to", sigh;
 701          * we need the "equal to" result to force the result
 702          */
 703         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 704         if (status == 0 && id != adap->nr) {
 705                 status = -EBUSY;
 706                 idr_remove(&i2c_adapter_idr, id);
 707         }
 708         mutex_unlock(&core_lock);
 709         if (status == -EAGAIN)
 710                 goto retry;
 711
 712         if (status == 0)
 713                 status = i2c_register_adapter(adap);
 714         return status;
 715 }
 716 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
 717
 718 static int i2c_do_del_adapter(struct device_driver *d, void *data)
 719 {
 720         struct i2c_driver *driver = to_i2c_driver(d);
 721         struct i2c_adapter *adapter = data;
 722         struct i2c_client *client, *_n;
 723         int res;
 724
 725         /* Remove the devices we created ourselves as the result of hardware
 726          * probing (using a driver's detect method) */
 727         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 728                 if (client->adapter == adapter) {
 729                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 730                                 client->name, client->addr);
 731                         list_del(&client->detected);
 732                         i2c_unregister_device(client);
 733                 }
 734         }
 735
 736         if (!driver->detach_adapter)
 737                 return 0;
 738         res = driver->detach_adapter(adapter);
 739         if (res)
 740                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
 741                         "for driver [%s]\n", res, driver->driver.name);
 742         return res;
 743 }
 744
 745 static int __unregister_client(struct device *dev, void *dummy)
 746 {
 747         struct i2c_client *client = i2c_verify_client(dev);
 748         if (client)
 749                 i2c_unregister_device(client);
 750         return 0;
 751 }
 752
 753 /**
 754  * i2c_del_adapter - unregister I2C adapter
 755  * @adap: the adapter being unregistered
 756  * Context: can sleep
 757  *
 758  * This unregisters an I2C adapter which was previously registered
 759  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
 760  */
 761 int i2c_del_adapter(struct i2c_adapter *adap)
 762 {
 763         int res = 0;
 764         struct i2c_adapter *found;
 765
 766         /* First make sure that this adapter was ever added */
 767         mutex_lock(&core_lock);
 768         found = idr_find(&i2c_adapter_idr, adap->nr);
 769         mutex_unlock(&core_lock);
 770         if (found != adap) {
 771                 pr_debug("i2c-core: attempting to delete unregistered "
 772                          "adapter [%s]\n", adap->name);
 773                 return -EINVAL;
 774         }
 775
 776         /* Tell drivers about this removal */
 777         mutex_lock(&core_lock);
 778         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
 779                                i2c_do_del_adapter);
 780         mutex_unlock(&core_lock);
 781         if (res)
 782                 return res;
 783
 784         /* Detach any active clients. This can't fail, thus we do not
 785            checking the returned value. */
 786         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
 787
 788 #ifdef CONFIG_I2C_COMPAT
 789         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
 790                                  adap->dev.parent);
 791 #endif
 792
 793         /* clean up the sysfs representation */
 794         init_completion(&adap->dev_released);
 795         device_unregister(&adap->dev);
 796
 797         /* wait for sysfs to drop all references */
 798         wait_for_completion(&adap->dev_released);
 799
 800         /* free bus id */
 801         mutex_lock(&core_lock);
 802         idr_remove(&i2c_adapter_idr, adap->nr);
 803         mutex_unlock(&core_lock);
 804
 805         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 806
 807         /* Clear the device structure in case this adapter is ever going to be
 808            added again */
 809         memset(&adap->dev, 0, sizeof(adap->dev));
 810
 811         return 0;
 812 }
 813 EXPORT_SYMBOL(i2c_del_adapter);
 814
 815
 816 /* ------------------------------------------------------------------------- */
 817
 818 static int __attach_adapter(struct device *dev, void *data)
 819 {
 820         struct i2c_adapter *adapter;
 821         struct i2c_driver *driver = data;
 822
 823         if (dev->type != &i2c_adapter_type)
 824                 return 0;
 825         adapter = to_i2c_adapter(dev);
 826
 827         i2c_detect(adapter, driver);
 828
 829         /* Legacy drivers scan i2c busses directly */
 830         if (driver->attach_adapter)
 831                 driver->attach_adapter(adapter);
 832
 833         return 0;
 834 }
 835
 836 /*
 837  * An i2c_driver is used with one or more i2c_client (device) nodes to access
 838  * i2c slave chips, on a bus instance associated with some i2c_adapter.
 839  */
 840
 841 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 842 {
 843         int res;
 844
 845         /* Can't register until after driver model init */
 846         if (unlikely(WARN_ON(!i2c_bus_type.p)))
 847                 return -EAGAIN;
 848
 849         /* add the driver to the list of i2c drivers in the driver core */
 850         driver->driver.owner = owner;
 851         driver->driver.bus = &i2c_bus_type;
 852
 853         /* When registration returns, the driver core
 854          * will have called probe() for all matching-but-unbound devices.
 855          */
 856         res = driver_register(&driver->driver);
 857         if (res)
 858                 return res;
 859
 860         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 861
 862         INIT_LIST_HEAD(&driver->clients);
 863         /* Walk the adapters that are already present */
 864         mutex_lock(&core_lock);
 865         bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter);
 866         mutex_unlock(&core_lock);
 867
 868         return 0;
 869 }
 870 EXPORT_SYMBOL(i2c_register_driver);
 871
 872 static int __detach_adapter(struct device *dev, void *data)
 873 {
 874         struct i2c_adapter *adapter;
 875         struct i2c_driver *driver = data;
 876         struct i2c_client *client, *_n;
 877
 878         if (dev->type != &i2c_adapter_type)
 879                 return 0;
 880         adapter = to_i2c_adapter(dev);
 881
 882         /* Remove the devices we created ourselves as the result of hardware
 883          * probing (using a driver's detect method) */
 884         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 885                 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 886                         client->name, client->addr);
 887                 list_del(&client->detected);
 888                 i2c_unregister_device(client);
 889         }
 890
 891         if (driver->detach_adapter) {
 892                 if (driver->detach_adapter(adapter))
 893                         dev_err(&adapter->dev,
 894                                 "detach_adapter failed for driver [%s]\n",
 895                                 driver->driver.name);
 896         }
 897
 898         return 0;
 899 }
 900
 901 /**
 902  * i2c_del_driver - unregister I2C driver
 903  * @driver: the driver being unregistered
 904  * Context: can sleep
 905  */
 906 void i2c_del_driver(struct i2c_driver *driver)
 907 {
 908         mutex_lock(&core_lock);
 909         bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter);
 910         mutex_unlock(&core_lock);
 911
 912         driver_unregister(&driver->driver);
 913         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
 914 }
 915 EXPORT_SYMBOL(i2c_del_driver);
 916
 917 /* ------------------------------------------------------------------------- */
 918
 919 static int __i2c_check_addr(struct device *dev, void *addrp)
 920 {
 921         struct i2c_client       *client = i2c_verify_client(dev);
 922         int                     addr = *(int *)addrp;
 923
 924         if (client && client->addr == addr)
 925                 return -EBUSY;
 926         return 0;
 927 }
 928
 929 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 930 {
 931         return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
 932 }
 933
 934 /**
 935  * i2c_use_client - increments the reference count of the i2c client structure
 936  * @client: the client being referenced
 937  *
 938  * Each live reference to a client should be refcounted. The driver model does
 939  * that automatically as part of driver binding, so that most drivers don't
 940  * need to do this explicitly: they hold a reference until they're unbound
 941  * from the device.
 942  *
 943  * A pointer to the client with the incremented reference counter is returned.
 944  */
 945 struct i2c_client *i2c_use_client(struct i2c_client *client)
 946 {
 947         if (client && get_device(&client->dev))
 948                 return client;
 949         return NULL;
 950 }
 951 EXPORT_SYMBOL(i2c_use_client);
 952
 953 /**
 954  * i2c_release_client - release a use of the i2c client structure
 955  * @client: the client being no longer referenced
 956  *
 957  * Must be called when a user of a client is finished with it.
 958  */
 959 void i2c_release_client(struct i2c_client *client)
 960 {
 961         if (client)
 962                 put_device(&client->dev);
 963 }
 964 EXPORT_SYMBOL(i2c_release_client);
 965
 966 struct i2c_cmd_arg {
 967         unsigned        cmd;
 968         void            *arg;
 969 };
 970
 971 static int i2c_cmd(struct device *dev, void *_arg)
 972 {
 973         struct i2c_client       *client = i2c_verify_client(dev);
 974         struct i2c_cmd_arg      *arg = _arg;
 975
 976         if (client && client->driver && client->driver->command)
 977                 client->driver->command(client, arg->cmd, arg->arg);
 978         return 0;
 979 }
 980
 981 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 982 {
 983         struct i2c_cmd_arg      cmd_arg;
 984
 985         cmd_arg.cmd = cmd;
 986         cmd_arg.arg = arg;
 987         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
 988 }
 989 EXPORT_SYMBOL(i2c_clients_command);
 990
 991 static int __init i2c_init(void)
 992 {
 993         int retval;
 994
 995         retval = bus_register(&i2c_bus_type);
 996         if (retval)
 997                 return retval;
 998 #ifdef CONFIG_I2C_COMPAT
 999         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1000         if (!i2c_adapter_compat_class) {
1001                 retval = -ENOMEM;
1002                 goto bus_err;
1003         }
1004 #endif
1005         retval = i2c_add_driver(&dummy_driver);
1006         if (retval)
1007                 goto class_err;
1008         return 0;
1009
1010 class_err:
1011 #ifdef CONFIG_I2C_COMPAT
1012         class_compat_unregister(i2c_adapter_compat_class);
1013 bus_err:
1014 #endif
1015         bus_unregister(&i2c_bus_type);
1016         return retval;
1017 }
1018
1019 static void __exit i2c_exit(void)
1020 {
1021         i2c_del_driver(&dummy_driver);
1022 #ifdef CONFIG_I2C_COMPAT
1023         class_compat_unregister(i2c_adapter_compat_class);
1024 #endif
1025         bus_unregister(&i2c_bus_type);
1026 }
1027
1028 /* We must initialize early, because some subsystems register i2c drivers
1029  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1030  */
1031 postcore_initcall(i2c_init);
1032 module_exit(i2c_exit);
1033
1034 /* ----------------------------------------------------
1035  * the functional interface to the i2c busses.
1036  * ----------------------------------------------------
1037  */
1038
1039 /**
1040  * i2c_transfer - execute a single or combined I2C message
1041  * @adap: Handle to I2C bus
1042  * @msgs: One or more messages to execute before STOP is issued to
1043  *      terminate the operation; each message begins with a START.
1044  * @num: Number of messages to be executed.
1045  *
1046  * Returns negative errno, else the number of messages executed.
1047  *
1048  * Note that there is no requirement that each message be sent to
1049  * the same slave address, although that is the most common model.
1050  */
1051 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1052 {
1053         unsigned long orig_jiffies;
1054         int ret, try;
1055
1056         /* REVISIT the fault reporting model here is weak:
1057          *
1058          *  - When we get an error after receiving N bytes from a slave,
1059          *    there is no way to report "N".
1060          *
1061          *  - When we get a NAK after transmitting N bytes to a slave,
1062          *    there is no way to report "N" ... or to let the master
1063          *    continue executing the rest of this combined message, if
1064          *    that's the appropriate response.
1065          *
1066          *  - When for example "num" is two and we successfully complete
1067          *    the first message but get an error part way through the
1068          *    second, it's unclear whether that should be reported as
1069          *    one (discarding status on the second message) or errno
1070          *    (discarding status on the first one).
1071          */
1072
1073         if (adap->algo->master_xfer) {
1074 #ifdef DEBUG
1075                 for (ret = 0; ret < num; ret++) {
1076                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1077                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1078                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1079                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1080                 }
1081 #endif
1082
1083                 if (in_atomic() || irqs_disabled()) {
1084                         ret = mutex_trylock(&adap->bus_lock);
1085                         if (!ret)
1086                                 /* I2C activity is ongoing. */
1087                                 return -EAGAIN;
1088                 } else {
1089                         mutex_lock_nested(&adap->bus_lock, adap->level);
1090                 }
1091
1092                 /* Retry automatically on arbitration loss */
1093                 orig_jiffies = jiffies;
1094                 for (ret = 0, try = 0; try <= adap->retries; try++) {
1095                         ret = adap->algo->master_xfer(adap, msgs, num);
1096                         if (ret != -EAGAIN)
1097                                 break;
1098                         if (time_after(jiffies, orig_jiffies + adap->timeout))
1099                                 break;
1100                 }
1101                 mutex_unlock(&adap->bus_lock);
1102
1103                 return ret;
1104         } else {
1105                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1106                 return -EOPNOTSUPP;
1107         }
1108 }
1109 EXPORT_SYMBOL(i2c_transfer);
1110
1111 /**
1112  * i2c_master_send - issue a single I2C message in master transmit mode
1113  * @client: Handle to slave device
1114  * @buf: Data that will be written to the slave
1115  * @count: How many bytes to write
1116  *
1117  * Returns negative errno, or else the number of bytes written.
1118  */
1119 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1120 {
1121         int ret;
1122         struct i2c_adapter *adap=client->adapter;
1123         struct i2c_msg msg;
1124
1125         msg.addr = client->addr;
1126         msg.flags = client->flags & I2C_M_TEN;
1127         msg.len = count;
1128         msg.buf = (char *)buf;
1129
1130         ret = i2c_transfer(adap, &msg, 1);
1131
1132         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1133            transmitted, else error code. */
1134         return (ret == 1) ? count : ret;
1135 }
1136 EXPORT_SYMBOL(i2c_master_send);
1137
1138 /**
1139  * i2c_master_recv - issue a single I2C message in master receive mode
1140  * @client: Handle to slave device
1141  * @buf: Where to store data read from slave
1142  * @count: How many bytes to read
1143  *
1144  * Returns negative errno, or else the number of bytes read.
1145  */
1146 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1147 {
1148         struct i2c_adapter *adap=client->adapter;
1149         struct i2c_msg msg;
1150         int ret;
1151
1152         msg.addr = client->addr;
1153         msg.flags = client->flags & I2C_M_TEN;
1154         msg.flags |= I2C_M_RD;
1155         msg.len = count;
1156         msg.buf = buf;
1157
1158         ret = i2c_transfer(adap, &msg, 1);
1159
1160         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1161            transmitted, else error code. */
1162         return (ret == 1) ? count : ret;
1163 }
1164 EXPORT_SYMBOL(i2c_master_recv);
1165
1166 /* ----------------------------------------------------
1167  * the i2c address scanning function
1168  * Will not work for 10-bit addresses!
1169  * ----------------------------------------------------
1170  */
1171
1172 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1173                               struct i2c_driver *driver)
1174 {
1175         struct i2c_board_info info;
1176         struct i2c_adapter *adapter = temp_client->adapter;
1177         int addr = temp_client->addr;
1178         int err;
1179
1180         /* Make sure the address is valid */
1181         if (addr < 0x03 || addr > 0x77) {
1182                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1183                          addr);
1184                 return -EINVAL;
1185         }
1186
1187         /* Skip if already in use */
1188         if (i2c_check_addr(adapter, addr))
1189                 return 0;
1190
1191         /* Make sure there is something at this address, unless forced */
1192         if (kind < 0) {
1193                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1194                                    I2C_SMBUS_QUICK, NULL) < 0)
1195                         return 0;
1196
1197                 /* prevent 24RF08 corruption */
1198                 if ((addr & ~0x0f) == 0x50)
1199                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1200                                        I2C_SMBUS_QUICK, NULL);
1201         }
1202
1203         /* Finally call the custom detection function */
1204         memset(&info, 0, sizeof(struct i2c_board_info));
1205         info.addr = addr;
1206         err = driver->detect(temp_client, kind, &info);
1207         if (err) {
1208                 /* -ENODEV is returned if the detection fails. We catch it
1209                    here as this isn't an error. */
1210                 return err == -ENODEV ? 0 : err;
1211         }
1212
1213         /* Consistency check */
1214         if (info.type[0] == '\0') {
1215                 dev_err(&adapter->dev, "%s detection function provided "
1216                         "no name for 0x%x\n", driver->driver.name,
1217                         addr);
1218         } else {
1219                 struct i2c_client *client;
1220
1221                 /* Detection succeeded, instantiate the device */
1222                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1223                         info.type, info.addr);
1224                 client = i2c_new_device(adapter, &info);
1225                 if (client)
1226                         list_add_tail(&client->detected, &driver->clients);
1227                 else
1228                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1229                                 info.type, info.addr);
1230         }
1231         return 0;
1232 }
1233
1234 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1235 {
1236         const struct i2c_client_address_data *address_data;
1237         struct i2c_client *temp_client;
1238         int i, err = 0;
1239         int adap_id = i2c_adapter_id(adapter);
1240
1241         address_data = driver->address_data;
1242         if (!driver->detect || !address_data)
1243                 return 0;
1244
1245         /* Set up a temporary client to help detect callback */
1246         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1247         if (!temp_client)
1248                 return -ENOMEM;
1249         temp_client->adapter = adapter;
1250
1251         /* Force entries are done first, and are not affected by ignore
1252            entries */
1253         if (address_data->forces) {
1254                 const unsigned short * const *forces = address_data->forces;
1255                 int kind;
1256
1257                 for (kind = 0; forces[kind]; kind++) {
1258                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1259                              i += 2) {
1260                                 if (forces[kind][i] == adap_id
1261                                  || forces[kind][i] == ANY_I2C_BUS) {
1262                                         dev_dbg(&adapter->dev, "found force "
1263                                                 "parameter for adapter %d, "
1264                                                 "addr 0x%02x, kind %d\n",
1265                                                 adap_id, forces[kind][i + 1],
1266                                                 kind);
1267                                         temp_client->addr = forces[kind][i + 1];
1268                                         err = i2c_detect_address(temp_client,
1269                                                 kind, driver);
1270                                         if (err)
1271                                                 goto exit_free;
1272                                 }
1273                         }
1274                 }
1275         }
1276
1277         /* Stop here if the classes do not match */
1278         if (!(adapter->class & driver->class))
1279                 goto exit_free;
1280
1281         /* Stop here if we can't use SMBUS_QUICK */
1282         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1283                 if (address_data->probe[0] == I2C_CLIENT_END
1284                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1285                         goto exit_free;
1286
1287                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1288                          "can't probe for chips\n");
1289                 err = -EOPNOTSUPP;
1290                 goto exit_free;
1291         }
1292
1293         /* Probe entries are done second, and are not affected by ignore
1294            entries either */
1295         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1296                 if (address_data->probe[i] == adap_id
1297                  || address_data->probe[i] == ANY_I2C_BUS) {
1298                         dev_dbg(&adapter->dev, "found probe parameter for "
1299                                 "adapter %d, addr 0x%02x\n", adap_id,
1300                                 address_data->probe[i + 1]);
1301                         temp_client->addr = address_data->probe[i + 1];
1302                         err = i2c_detect_address(temp_client, -1, driver);
1303                         if (err)
1304                                 goto exit_free;
1305                 }
1306         }
1307
1308         /* Normal entries are done last, unless shadowed by an ignore entry */
1309         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1310                 int j, ignore;
1311
1312                 ignore = 0;
1313                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1314                      j += 2) {
1315                         if ((address_data->ignore[j] == adap_id ||
1316                              address_data->ignore[j] == ANY_I2C_BUS)
1317                          && address_data->ignore[j + 1]
1318                             == address_data->normal_i2c[i]) {
1319                                 dev_dbg(&adapter->dev, "found ignore "
1320                                         "parameter for adapter %d, "
1321                                         "addr 0x%02x\n", adap_id,
1322                                         address_data->ignore[j + 1]);
1323                                 ignore = 1;
1324                                 break;
1325                         }
1326                 }
1327                 if (ignore)
1328                         continue;
1329
1330                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1331                         "addr 0x%02x\n", adap_id,
1332                         address_data->normal_i2c[i]);
1333                 temp_client->addr = address_data->normal_i2c[i];
1334                 err = i2c_detect_address(temp_client, -1, driver);
1335                 if (err)
1336                         goto exit_free;
1337         }
1338
1339  exit_free:
1340         kfree(temp_client);
1341         return err;
1342 }
1343
1344 struct i2c_client *
1345 i2c_new_probed_device(struct i2c_adapter *adap,
1346                       struct i2c_board_info *info,
1347                       unsigned short const *addr_list)
1348 {
1349         int i;
1350
1351         /* Stop here if the bus doesn't support probing */
1352         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1353                 dev_err(&adap->dev, "Probing not supported\n");
1354                 return NULL;
1355         }
1356
1357         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1358                 /* Check address validity */
1359                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1360                         dev_warn(&adap->dev, "Invalid 7-bit address "
1361                                  "0x%02x\n", addr_list[i]);
1362                         continue;
1363                 }
1364
1365                 /* Check address availability */
1366                 if (i2c_check_addr(adap, addr_list[i])) {
1367                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1368                                 "use, not probing\n", addr_list[i]);
1369                         continue;
1370                 }
1371
1372                 /* Test address responsiveness
1373                    The default probe method is a quick write, but it is known
1374                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1375                    and could also irreversibly write-protect some EEPROMs, so
1376                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1377                    read instead. Also, some bus drivers don't implement
1378                    quick write, so we fallback to a byte read it that case
1379                    too. */
1380                 if ((addr_list[i] & ~0x07) == 0x30
1381                  || (addr_list[i] & ~0x0f) == 0x50
1382                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1383                         union i2c_smbus_data data;
1384
1385                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1386                                            I2C_SMBUS_READ, 0,
1387                                            I2C_SMBUS_BYTE, &data) >= 0)
1388                                 break;
1389                 } else {
1390                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1391                                            I2C_SMBUS_WRITE, 0,
1392                                            I2C_SMBUS_QUICK, NULL) >= 0)
1393                                 break;
1394                 }
1395         }
1396
1397         if (addr_list[i] == I2C_CLIENT_END) {
1398                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1399                 return NULL;
1400         }
1401
1402         info->addr = addr_list[i];
1403         return i2c_new_device(adap, info);
1404 }
1405 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1406
1407 struct i2c_adapter* i2c_get_adapter(int id)
1408 {
1409         struct i2c_adapter *adapter;
1410
1411         mutex_lock(&core_lock);
1412         adapter = idr_find(&i2c_adapter_idr, id);
1413         if (adapter && !try_module_get(adapter->owner))
1414                 adapter = NULL;
1415
1416         mutex_unlock(&core_lock);
1417         return adapter;
1418 }
1419 EXPORT_SYMBOL(i2c_get_adapter);
1420
1421 void i2c_put_adapter(struct i2c_adapter *adap)
1422 {
1423         module_put(adap->owner);
1424 }
1425 EXPORT_SYMBOL(i2c_put_adapter);
1426
1427 /* The SMBus parts */
1428
1429 #define POLY    (0x1070U << 3)
1430 static u8 crc8(u16 data)
1431 {
1432         int i;
1433
1434         for(i = 0; i < 8; i++) {
1435                 if (data & 0x8000)
1436                         data = data ^ POLY;
1437                 data = data << 1;
1438         }
1439         return (u8)(data >> 8);
1440 }
1441
1442 /* Incremental CRC8 over count bytes in the array pointed to by p */
1443 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1444 {
1445         int i;
1446
1447         for(i = 0; i < count; i++)
1448                 crc = crc8((crc ^ p[i]) << 8);
1449         return crc;
1450 }
1451
1452 /* Assume a 7-bit address, which is reasonable for SMBus */
1453 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1454 {
1455         /* The address will be sent first */
1456         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1457         pec = i2c_smbus_pec(pec, &addr, 1);
1458
1459         /* The data buffer follows */
1460         return i2c_smbus_pec(pec, msg->buf, msg->len);
1461 }
1462
1463 /* Used for write only transactions */
1464 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1465 {
1466         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1467         msg->len++;
1468 }
1469
1470 /* Return <0 on CRC error
1471    If there was a write before this read (most cases) we need to take the
1472    partial CRC from the write part into account.
1473    Note that this function does modify the message (we need to decrease the
1474    message length to hide the CRC byte from the caller). */
1475 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1476 {
1477         u8 rpec = msg->buf[--msg->len];
1478         cpec = i2c_smbus_msg_pec(cpec, msg);
1479
1480         if (rpec != cpec) {
1481                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1482                         rpec, cpec);
1483                 return -EBADMSG;
1484         }
1485         return 0;
1486 }
1487
1488 /**
1489  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1490  * @client: Handle to slave device
1491  *
1492  * This executes the SMBus "receive byte" protocol, returning negative errno
1493  * else the byte received from the device.
1494  */
1495 s32 i2c_smbus_read_byte(struct i2c_client *client)
1496 {
1497         union i2c_smbus_data data;
1498         int status;
1499
1500         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1501                                 I2C_SMBUS_READ, 0,
1502                                 I2C_SMBUS_BYTE, &data);
1503         return (status < 0) ? status : data.byte;
1504 }
1505 EXPORT_SYMBOL(i2c_smbus_read_byte);
1506
1507 /**
1508  * i2c_smbus_write_byte - SMBus "send byte" protocol
1509  * @client: Handle to slave device
1510  * @value: Byte to be sent
1511  *
1512  * This executes the SMBus "send byte" protocol, returning negative errno
1513  * else zero on success.
1514  */
1515 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1516 {
1517         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1518                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1519 }
1520 EXPORT_SYMBOL(i2c_smbus_write_byte);
1521
1522 /**
1523  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1524  * @client: Handle to slave device
1525  * @command: Byte interpreted by slave
1526  *
1527  * This executes the SMBus "read byte" protocol, returning negative errno
1528  * else a data byte received from the device.
1529  */
1530 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1531 {
1532         union i2c_smbus_data data;
1533         int status;
1534
1535         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1536                                 I2C_SMBUS_READ, command,
1537                                 I2C_SMBUS_BYTE_DATA, &data);
1538         return (status < 0) ? status : data.byte;
1539 }
1540 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1541
1542 /**
1543  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1544  * @client: Handle to slave device
1545  * @command: Byte interpreted by slave
1546  * @value: Byte being written
1547  *
1548  * This executes the SMBus "write byte" protocol, returning negative errno
1549  * else zero on success.
1550  */
1551 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1552 {
1553         union i2c_smbus_data data;
1554         data.byte = value;
1555         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1556                               I2C_SMBUS_WRITE,command,
1557                               I2C_SMBUS_BYTE_DATA,&data);
1558 }
1559 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1560
1561 /**
1562  * i2c_smbus_read_word_data - SMBus "read word" protocol
1563  * @client: Handle to slave device
1564  * @command: Byte interpreted by slave
1565  *
1566  * This executes the SMBus "read word" protocol, returning negative errno
1567  * else a 16-bit unsigned "word" received from the device.
1568  */
1569 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1570 {
1571         union i2c_smbus_data data;
1572         int status;
1573
1574         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1575                                 I2C_SMBUS_READ, command,
1576                                 I2C_SMBUS_WORD_DATA, &data);
1577         return (status < 0) ? status : data.word;
1578 }
1579 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1580
1581 /**
1582  * i2c_smbus_write_word_data - SMBus "write word" protocol
1583  * @client: Handle to slave device
1584  * @command: Byte interpreted by slave
1585  * @value: 16-bit "word" being written
1586  *
1587  * This executes the SMBus "write word" protocol, returning negative errno
1588  * else zero on success.
1589  */
1590 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1591 {
1592         union i2c_smbus_data data;
1593         data.word = value;
1594         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1595                               I2C_SMBUS_WRITE,command,
1596                               I2C_SMBUS_WORD_DATA,&data);
1597 }
1598 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1599
1600 /**
1601  * i2c_smbus_process_call - SMBus "process call" protocol
1602  * @client: Handle to slave device
1603  * @command: Byte interpreted by slave
1604  * @value: 16-bit "word" being written
1605  *
1606  * This executes the SMBus "process call" protocol, returning negative errno
1607  * else a 16-bit unsigned "word" received from the device.
1608  */
1609 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1610 {
1611         union i2c_smbus_data data;
1612         int status;
1613         data.word = value;
1614
1615         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1616                                 I2C_SMBUS_WRITE, command,
1617                                 I2C_SMBUS_PROC_CALL, &data);
1618         return (status < 0) ? status : data.word;
1619 }
1620 EXPORT_SYMBOL(i2c_smbus_process_call);
1621
1622 /**
1623  * i2c_smbus_read_block_data - SMBus "block read" protocol
1624  * @client: Handle to slave device
1625  * @command: Byte interpreted by slave
1626  * @values: Byte array into which data will be read; big enough to hold
1627  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1628  *
1629  * This executes the SMBus "block read" protocol, returning negative errno
1630  * else the number of data bytes in the slave's response.
1631  *
1632  * Note that using this function requires that the client's adapter support
1633  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1634  * support this; its emulation through I2C messaging relies on a specific
1635  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1636  */
1637 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1638                               u8 *values)
1639 {
1640         union i2c_smbus_data data;
1641         int status;
1642
1643         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1644                                 I2C_SMBUS_READ, command,
1645                                 I2C_SMBUS_BLOCK_DATA, &data);
1646         if (status)
1647                 return status;
1648
1649         memcpy(values, &data.block[1], data.block[0]);
1650         return data.block[0];
1651 }
1652 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1653
1654 /**
1655  * i2c_smbus_write_block_data - SMBus "block write" protocol
1656  * @client: Handle to slave device
1657  * @command: Byte interpreted by slave
1658  * @length: Size of data block; SMBus allows at most 32 bytes
1659  * @values: Byte array which will be written.
1660  *
1661  * This executes the SMBus "block write" protocol, returning negative errno
1662  * else zero on success.
1663  */
1664 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1665                                u8 length, const u8 *values)
1666 {
1667         union i2c_smbus_data data;
1668
1669         if (length > I2C_SMBUS_BLOCK_MAX)
1670                 length = I2C_SMBUS_BLOCK_MAX;
1671         data.block[0] = length;
1672         memcpy(&data.block[1], values, length);
1673         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1674                               I2C_SMBUS_WRITE,command,
1675                               I2C_SMBUS_BLOCK_DATA,&data);
1676 }
1677 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1678
1679 /* Returns the number of read bytes */
1680 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1681                                   u8 length, u8 *values)
1682 {
1683         union i2c_smbus_data data;
1684         int status;
1685
1686         if (length > I2C_SMBUS_BLOCK_MAX)
1687                 length = I2C_SMBUS_BLOCK_MAX;
1688         data.block[0] = length;
1689         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1690                                 I2C_SMBUS_READ, command,
1691                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1692         if (status < 0)
1693                 return status;
1694
1695         memcpy(values, &data.block[1], data.block[0]);
1696         return data.block[0];
1697 }
1698 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1699
1700 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1701                                    u8 length, const u8 *values)
1702 {
1703         union i2c_smbus_data data;
1704
1705         if (length > I2C_SMBUS_BLOCK_MAX)
1706                 length = I2C_SMBUS_BLOCK_MAX;
1707         data.block[0] = length;
1708         memcpy(data.block + 1, values, length);
1709         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1710                               I2C_SMBUS_WRITE, command,
1711                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1712 }
1713 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1714
1715 /* Simulate a SMBus command using the i2c protocol
1716    No checking of parameters is done!  */
1717 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1718                                    unsigned short flags,
1719                                    char read_write, u8 command, int size,
1720                                    union i2c_smbus_data * data)
1721 {
1722         /* So we need to generate a series of msgs. In the case of writing, we
1723           need to use only one message; when reading, we need two. We initialize
1724           most things with sane defaults, to keep the code below somewhat
1725           simpler. */
1726         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1727         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1728         int num = read_write == I2C_SMBUS_READ?2:1;
1729         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1730                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1731                                 };
1732         int i;
1733         u8 partial_pec = 0;
1734         int status;
1735
1736         msgbuf0[0] = command;
1737         switch(size) {
1738         case I2C_SMBUS_QUICK:
1739                 msg[0].len = 0;
1740                 /* Special case: The read/write field is used as data */
1741                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1742                                         I2C_M_RD : 0);
1743                 num = 1;
1744                 break;
1745         case I2C_SMBUS_BYTE:
1746                 if (read_write == I2C_SMBUS_READ) {
1747                         /* Special case: only a read! */
1748                         msg[0].flags = I2C_M_RD | flags;
1749                         num = 1;
1750                 }
1751                 break;
1752         case I2C_SMBUS_BYTE_DATA:
1753                 if (read_write == I2C_SMBUS_READ)
1754                         msg[1].len = 1;
1755                 else {
1756                         msg[0].len = 2;
1757                         msgbuf0[1] = data->byte;
1758                 }
1759                 break;
1760         case I2C_SMBUS_WORD_DATA:
1761                 if (read_write == I2C_SMBUS_READ)
1762                         msg[1].len = 2;
1763                 else {
1764                         msg[0].len=3;
1765                         msgbuf0[1] = data->word & 0xff;
1766                         msgbuf0[2] = data->word >> 8;
1767                 }
1768                 break;
1769         case I2C_SMBUS_PROC_CALL:
1770                 num = 2; /* Special case */
1771                 read_write = I2C_SMBUS_READ;
1772                 msg[0].len = 3;
1773                 msg[1].len = 2;
1774                 msgbuf0[1] = data->word & 0xff;
1775                 msgbuf0[2] = data->word >> 8;
1776                 break;
1777         case I2C_SMBUS_BLOCK_DATA:
1778                 if (read_write == I2C_SMBUS_READ) {
1779                         msg[1].flags |= I2C_M_RECV_LEN;
1780                         msg[1].len = 1; /* block length will be added by
1781                                            the underlying bus driver */
1782                 } else {
1783                         msg[0].len = data->block[0] + 2;
1784                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1785                                 dev_err(&adapter->dev,
1786                                         "Invalid block write size %d\n",
1787                                         data->block[0]);
1788                                 return -EINVAL;
1789                         }
1790                         for (i = 1; i < msg[0].len; i++)
1791                                 msgbuf0[i] = data->block[i-1];
1792                 }
1793                 break;
1794         case I2C_SMBUS_BLOCK_PROC_CALL:
1795                 num = 2; /* Another special case */
1796                 read_write = I2C_SMBUS_READ;
1797                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1798                         dev_err(&adapter->dev,
1799                                 "Invalid block write size %d\n",
1800                                 data->block[0]);
1801                         return -EINVAL;
1802                 }
1803                 msg[0].len = data->block[0] + 2;
1804                 for (i = 1; i < msg[0].len; i++)
1805                         msgbuf0[i] = data->block[i-1];
1806                 msg[1].flags |= I2C_M_RECV_LEN;
1807                 msg[1].len = 1; /* block length will be added by
1808                                    the underlying bus driver */
1809                 break;
1810         case I2C_SMBUS_I2C_BLOCK_DATA:
1811                 if (read_write == I2C_SMBUS_READ) {
1812                         msg[1].len = data->block[0];
1813                 } else {
1814                         msg[0].len = data->block[0] + 1;
1815                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1816                                 dev_err(&adapter->dev,
1817                                         "Invalid block write size %d\n",
1818                                         data->block[0]);
1819                                 return -EINVAL;
1820                         }
1821                         for (i = 1; i <= data->block[0]; i++)
1822                                 msgbuf0[i] = data->block[i];
1823                 }
1824                 break;
1825         default:
1826                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1827                 return -EOPNOTSUPP;
1828         }
1829
1830         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1831                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1832         if (i) {
1833                 /* Compute PEC if first message is a write */
1834                 if (!(msg[0].flags & I2C_M_RD)) {
1835                         if (num == 1) /* Write only */
1836                                 i2c_smbus_add_pec(&msg[0]);
1837                         else /* Write followed by read */
1838                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1839                 }
1840                 /* Ask for PEC if last message is a read */
1841                 if (msg[num-1].flags & I2C_M_RD)
1842                         msg[num-1].len++;
1843         }
1844
1845         status = i2c_transfer(adapter, msg, num);
1846         if (status < 0)
1847                 return status;
1848
1849         /* Check PEC if last message is a read */
1850         if (i && (msg[num-1].flags & I2C_M_RD)) {
1851                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1852                 if (status < 0)
1853                         return status;
1854         }
1855
1856         if (read_write == I2C_SMBUS_READ)
1857                 switch(size) {
1858                         case I2C_SMBUS_BYTE:
1859                                 data->byte = msgbuf0[0];
1860                                 break;
1861                         case I2C_SMBUS_BYTE_DATA:
1862                                 data->byte = msgbuf1[0];
1863                                 break;
1864                         case I2C_SMBUS_WORD_DATA:
1865                         case I2C_SMBUS_PROC_CALL:
1866                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1867                                 break;
1868                         case I2C_SMBUS_I2C_BLOCK_DATA:
1869                                 for (i = 0; i < data->block[0]; i++)
1870                                         data->block[i+1] = msgbuf1[i];
1871                                 break;
1872                         case I2C_SMBUS_BLOCK_DATA:
1873                         case I2C_SMBUS_BLOCK_PROC_CALL:
1874                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1875                                         data->block[i] = msgbuf1[i];
1876                                 break;
1877                 }
1878         return 0;
1879 }
1880
1881 /**
1882  * i2c_smbus_xfer - execute SMBus protocol operations
1883  * @adapter: Handle to I2C bus
1884  * @addr: Address of SMBus slave on that bus
1885  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1886  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1887  * @command: Byte interpreted by slave, for protocols which use such bytes
1888  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1889  * @data: Data to be read or written
1890  *
1891  * This executes an SMBus protocol operation, and returns a negative
1892  * errno code else zero on success.
1893  */
1894 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
1895                    char read_write, u8 command, int protocol,
1896                    union i2c_smbus_data *data)
1897 {
1898         unsigned long orig_jiffies;
1899         int try;
1900         s32 res;
1901
1902         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1903
1904         if (adapter->algo->smbus_xfer) {
1905                 mutex_lock(&adapter->bus_lock);
1906
1907                 /* Retry automatically on arbitration loss */
1908                 orig_jiffies = jiffies;
1909                 for (res = 0, try = 0; try <= adapter->retries; try++) {
1910                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
1911                                                         read_write, command,
1912                                                         protocol, data);
1913                         if (res != -EAGAIN)
1914                                 break;
1915                         if (time_after(jiffies,
1916                                        orig_jiffies + adapter->timeout))
1917                                 break;
1918                 }
1919                 mutex_unlock(&adapter->bus_lock);
1920         } else
1921                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1922                                               command, protocol, data);
1923
1924         return res;
1925 }
1926 EXPORT_SYMBOL(i2c_smbus_xfer);
1927
1928 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1929 MODULE_DESCRIPTION("I2C-Bus main module");
1930 MODULE_LICENSE("GPL");