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