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