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