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