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