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