git.oblomov.eu Git - linux-2.6/blob - 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/seq_file.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/mutex.h>
  35 #include <linux/completion.h>
  36 #include <asm/uaccess.h>
  37
  38 #include "i2c-core.h"
  39
  40
  41 static LIST_HEAD(adapters);
  42 static LIST_HEAD(drivers);
  43 static DEFINE_MUTEX(core_lists);
  44 static DEFINE_IDR(i2c_adapter_idr);
  45
  46 #define is_newstyle_driver(d) ((d)->probe || (d)->remove)
  47
  48 /* ------------------------------------------------------------------------- */
  49
  50 static int i2c_device_match(struct device *dev, struct device_driver *drv)
  51 {
  52         struct i2c_client       *client = to_i2c_client(dev);
  53         struct i2c_driver       *driver = to_i2c_driver(drv);
  54
  55         /* make legacy i2c drivers bypass driver model probing entirely;
  56          * such drivers scan each i2c adapter/bus themselves.
  57          */
  58         if (!is_newstyle_driver(driver))
  59                 return 0;
  60
  61         /* new style drivers use the same kind of driver matching policy
  62          * as platform devices or SPI:  compare device and driver IDs.
  63          */
  64         return strcmp(client->driver_name, drv->name) == 0;
  65 }
  66
  67 #ifdef  CONFIG_HOTPLUG
  68
  69 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
  70 static int i2c_device_uevent(struct device *dev, char **envp, int num_envp,
  71                       char *buffer, int buffer_size)
  72 {
  73         struct i2c_client       *client = to_i2c_client(dev);
  74         int                     i = 0, length = 0;
  75
  76         /* by definition, legacy drivers can't hotplug */
  77         if (dev->driver || !client->driver_name)
  78                 return 0;
  79
  80         if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
  81                         "MODALIAS=%s", client->driver_name))
  82                 return -ENOMEM;
  83         envp[i] = NULL;
  84         dev_dbg(dev, "uevent\n");
  85         return 0;
  86 }
  87
  88 #else
  89 #define i2c_device_uevent       NULL
  90 #endif  /* CONFIG_HOTPLUG */
  91
  92 static int i2c_device_probe(struct device *dev)
  93 {
  94         struct i2c_client       *client = to_i2c_client(dev);
  95         struct i2c_driver       *driver = to_i2c_driver(dev->driver);
  96
  97         if (!driver->probe)
  98                 return -ENODEV;
  99         client->driver = driver;
 100         dev_dbg(dev, "probe\n");
 101         return driver->probe(client);
 102 }
 103
 104 static int i2c_device_remove(struct device *dev)
 105 {
 106         struct i2c_client       *client = to_i2c_client(dev);
 107         struct i2c_driver       *driver;
 108         int                     status;
 109
 110         if (!dev->driver)
 111                 return 0;
 112
 113         driver = to_i2c_driver(dev->driver);
 114         if (driver->remove) {
 115                 dev_dbg(dev, "remove\n");
 116                 status = driver->remove(client);
 117         } else {
 118                 dev->driver = NULL;
 119                 status = 0;
 120         }
 121         if (status == 0)
 122                 client->driver = NULL;
 123         return status;
 124 }
 125
 126 static void i2c_device_shutdown(struct device *dev)
 127 {
 128         struct i2c_driver *driver;
 129
 130         if (!dev->driver)
 131                 return;
 132         driver = to_i2c_driver(dev->driver);
 133         if (driver->shutdown)
 134                 driver->shutdown(to_i2c_client(dev));
 135 }
 136
 137 static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
 138 {
 139         struct i2c_driver *driver;
 140
 141         if (!dev->driver)
 142                 return 0;
 143         driver = to_i2c_driver(dev->driver);
 144         if (!driver->suspend)
 145                 return 0;
 146         return driver->suspend(to_i2c_client(dev), mesg);
 147 }
 148
 149 static int i2c_device_resume(struct device * dev)
 150 {
 151         struct i2c_driver *driver;
 152
 153         if (!dev->driver)
 154                 return 0;
 155         driver = to_i2c_driver(dev->driver);
 156         if (!driver->resume)
 157                 return 0;
 158         return driver->resume(to_i2c_client(dev));
 159 }
 160
 161 static void i2c_client_release(struct device *dev)
 162 {
 163         struct i2c_client *client = to_i2c_client(dev);
 164         complete(&client->released);
 165 }
 166
 167 static void i2c_client_dev_release(struct device *dev)
 168 {
 169         kfree(to_i2c_client(dev));
 170 }
 171
 172 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
 173 {
 174         struct i2c_client *client = to_i2c_client(dev);
 175         return sprintf(buf, "%s\n", client->name);
 176 }
 177
 178 static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 179 {
 180         struct i2c_client *client = to_i2c_client(dev);
 181         return client->driver_name
 182                 ? sprintf(buf, "%s\n", client->driver_name)
 183                 : 0;
 184 }
 185
 186 static struct device_attribute i2c_dev_attrs[] = {
 187         __ATTR(name, S_IRUGO, show_client_name, NULL),
 188         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
 189         __ATTR(modalias, S_IRUGO, show_modalias, NULL),
 190         { },
 191 };
 192
 193 struct bus_type i2c_bus_type = {
 194         .name           = "i2c",
 195         .dev_attrs      = i2c_dev_attrs,
 196         .match          = i2c_device_match,
 197         .uevent         = i2c_device_uevent,
 198         .probe          = i2c_device_probe,
 199         .remove         = i2c_device_remove,
 200         .shutdown       = i2c_device_shutdown,
 201         .suspend        = i2c_device_suspend,
 202         .resume         = i2c_device_resume,
 203 };
 204 EXPORT_SYMBOL_GPL(i2c_bus_type);
 205
 206 /**
 207  * i2c_new_device - instantiate an i2c device for use with a new style driver
 208  * @adap: the adapter managing the device
 209  * @info: describes one I2C device; bus_num is ignored
 210  * Context: can sleep
 211  *
 212  * Create a device to work with a new style i2c driver, where binding is
 213  * handled through driver model probe()/remove() methods.  This call is not
 214  * appropriate for use by mainboad initialization logic, which usually runs
 215  * during an arch_initcall() long before any i2c_adapter could exist.
 216  *
 217  * This returns the new i2c client, which may be saved for later use with
 218  * i2c_unregister_device(); or NULL to indicate an error.
 219  */
 220 struct i2c_client *
 221 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 222 {
 223         struct i2c_client       *client;
 224         int                     status;
 225
 226         client = kzalloc(sizeof *client, GFP_KERNEL);
 227         if (!client)
 228                 return NULL;
 229
 230         client->adapter = adap;
 231
 232         client->dev.platform_data = info->platform_data;
 233         client->flags = info->flags;
 234         client->addr = info->addr;
 235         client->irq = info->irq;
 236
 237         strlcpy(client->driver_name, info->driver_name,
 238                 sizeof(client->driver_name));
 239         strlcpy(client->name, info->type, sizeof(client->name));
 240
 241         /* a new style driver may be bound to this device when we
 242          * return from this function, or any later moment (e.g. maybe
 243          * hotplugging will load the driver module).  and the device
 244          * refcount model is the standard driver model one.
 245          */
 246         status = i2c_attach_client(client);
 247         if (status < 0) {
 248                 kfree(client);
 249                 client = NULL;
 250         }
 251         return client;
 252 }
 253 EXPORT_SYMBOL_GPL(i2c_new_device);
 254
 255
 256 /**
 257  * i2c_unregister_device - reverse effect of i2c_new_device()
 258  * @client: value returned from i2c_new_device()
 259  * Context: can sleep
 260  */
 261 void i2c_unregister_device(struct i2c_client *client)
 262 {
 263         struct i2c_adapter      *adapter = client->adapter;
 264         struct i2c_driver       *driver = client->driver;
 265
 266         if (driver && !is_newstyle_driver(driver)) {
 267                 dev_err(&client->dev, "can't unregister devices "
 268                         "with legacy drivers\n");
 269                 WARN_ON(1);
 270                 return;
 271         }
 272
 273         mutex_lock(&adapter->clist_lock);
 274         list_del(&client->list);
 275         mutex_unlock(&adapter->clist_lock);
 276
 277         device_unregister(&client->dev);
 278 }
 279 EXPORT_SYMBOL_GPL(i2c_unregister_device);
 280
 281
 282 /* ------------------------------------------------------------------------- */
 283
 284 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
 285
 286 void i2c_adapter_dev_release(struct device *dev)
 287 {
 288         struct i2c_adapter *adap = to_i2c_adapter(dev);
 289         complete(&adap->dev_released);
 290 }
 291 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);     /* exported to i2c-isa */
 292
 293 static ssize_t
 294 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
 295 {
 296         struct i2c_adapter *adap = to_i2c_adapter(dev);
 297         return sprintf(buf, "%s\n", adap->name);
 298 }
 299
 300 static struct device_attribute i2c_adapter_attrs[] = {
 301         __ATTR(name, S_IRUGO, show_adapter_name, NULL),
 302         { },
 303 };
 304
 305 struct class i2c_adapter_class = {
 306         .owner                  = THIS_MODULE,
 307         .name                   = "i2c-adapter",
 308         .dev_attrs              = i2c_adapter_attrs,
 309 };
 310 EXPORT_SYMBOL_GPL(i2c_adapter_class);           /* exported to i2c-isa */
 311
 312 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 313 {
 314         struct i2c_devinfo      *devinfo;
 315
 316         mutex_lock(&__i2c_board_lock);
 317         list_for_each_entry(devinfo, &__i2c_board_list, list) {
 318                 if (devinfo->busnum == adapter->nr
 319                                 && !i2c_new_device(adapter,
 320                                                 &devinfo->board_info))
 321                         printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
 322                                 i2c_adapter_id(adapter),
 323                                 devinfo->board_info.addr);
 324         }
 325         mutex_unlock(&__i2c_board_lock);
 326 }
 327
 328 static int i2c_register_adapter(struct i2c_adapter *adap)
 329 {
 330         int res = 0;
 331         struct list_head   *item;
 332         struct i2c_driver  *driver;
 333
 334         mutex_init(&adap->bus_lock);
 335         mutex_init(&adap->clist_lock);
 336         INIT_LIST_HEAD(&adap->clients);
 337
 338         mutex_lock(&core_lists);
 339         list_add_tail(&adap->list, &adapters);
 340
 341         /* Add the adapter to the driver core.
 342          * If the parent pointer is not set up,
 343          * we add this adapter to the host bus.
 344          */
 345         if (adap->dev.parent == NULL) {
 346                 adap->dev.parent = &platform_bus;
 347                 pr_debug("I2C adapter driver [%s] forgot to specify "
 348                          "physical device\n", adap->name);
 349         }
 350         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
 351         adap->dev.release = &i2c_adapter_dev_release;
 352         adap->dev.class = &i2c_adapter_class;
 353         res = device_register(&adap->dev);
 354         if (res)
 355                 goto out_list;
 356
 357         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 358
 359         /* create pre-declared device nodes for new-style drivers */
 360         if (adap->nr < __i2c_first_dynamic_bus_num)
 361                 i2c_scan_static_board_info(adap);
 362
 363         /* let legacy drivers scan this bus for matching devices */
 364         list_for_each(item,&drivers) {
 365                 driver = list_entry(item, struct i2c_driver, list);
 366                 if (driver->attach_adapter)
 367                         /* We ignore the return code; if it fails, too bad */
 368                         driver->attach_adapter(adap);
 369         }
 370
 371 out_unlock:
 372         mutex_unlock(&core_lists);
 373         return res;
 374
 375 out_list:
 376         list_del(&adap->list);
 377         idr_remove(&i2c_adapter_idr, adap->nr);
 378         goto out_unlock;
 379 }
 380
 381 /**
 382  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 383  * @adapter: the adapter to add
 384  * Context: can sleep
 385  *
 386  * This routine is used to declare an I2C adapter when its bus number
 387  * doesn't matter.  Examples: for I2C adapters dynamically added by
 388  * USB links or PCI plugin cards.
 389  *
 390  * When this returns zero, a new bus number was allocated and stored
 391  * in adap->nr, and the specified adapter became available for clients.
 392  * Otherwise, a negative errno value is returned.
 393  */
 394 int i2c_add_adapter(struct i2c_adapter *adapter)
 395 {
 396         int     id, res = 0;
 397
 398 retry:
 399         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 400                 return -ENOMEM;
 401
 402         mutex_lock(&core_lists);
 403         /* "above" here means "above or equal to", sigh */
 404         res = idr_get_new_above(&i2c_adapter_idr, adapter,
 405                                 __i2c_first_dynamic_bus_num, &id);
 406         mutex_unlock(&core_lists);
 407
 408         if (res < 0) {
 409                 if (res == -EAGAIN)
 410                         goto retry;
 411                 return res;
 412         }
 413
 414         adapter->nr = id;
 415         return i2c_register_adapter(adapter);
 416 }
 417 EXPORT_SYMBOL(i2c_add_adapter);
 418
 419 /**
 420  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 421  * @adap: the adapter to register (with adap->nr initialized)
 422  * Context: can sleep
 423  *
 424  * This routine is used to declare an I2C adapter when its bus number
 425  * matters.  Example: for I2C adapters from system-on-chip CPUs, or
 426  * otherwise built in to the system's mainboard, and where i2c_board_info
 427  * is used to properly configure I2C devices.
 428  *
 429  * If no devices have pre-been declared for this bus, then be sure to
 430  * register the adapter before any dynamically allocated ones.  Otherwise
 431  * the required bus ID may not be available.
 432  *
 433  * When this returns zero, the specified adapter became available for
 434  * clients using the bus number provided in adap->nr.  Also, the table
 435  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 436  * and the appropriate driver model device nodes are created.  Otherwise, a
 437  * negative errno value is returned.
 438  */
 439 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 440 {
 441         int     id;
 442         int     status;
 443
 444         if (adap->nr & ~MAX_ID_MASK)
 445                 return -EINVAL;
 446
 447 retry:
 448         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 449                 return -ENOMEM;
 450
 451         mutex_lock(&core_lists);
 452         /* "above" here means "above or equal to", sigh;
 453          * we need the "equal to" result to force the result
 454          */
 455         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 456         if (status == 0 && id != adap->nr) {
 457                 status = -EBUSY;
 458                 idr_remove(&i2c_adapter_idr, id);
 459         }
 460         mutex_unlock(&core_lists);
 461         if (status == -EAGAIN)
 462                 goto retry;
 463
 464         if (status == 0)
 465                 status = i2c_register_adapter(adap);
 466         return status;
 467 }
 468 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
 469
 470 /**
 471  * i2c_del_adapter - unregister I2C adapter
 472  * @adap: the adapter being unregistered
 473  * Context: can sleep
 474  *
 475  * This unregisters an I2C adapter which was previously registered
 476  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
 477  */
 478 int i2c_del_adapter(struct i2c_adapter *adap)
 479 {
 480         struct list_head  *item, *_n;
 481         struct i2c_adapter *adap_from_list;
 482         struct i2c_driver *driver;
 483         struct i2c_client *client;
 484         int res = 0;
 485
 486         mutex_lock(&core_lists);
 487
 488         /* First make sure that this adapter was ever added */
 489         list_for_each_entry(adap_from_list, &adapters, list) {
 490                 if (adap_from_list == adap)
 491                         break;
 492         }
 493         if (adap_from_list != adap) {
 494                 pr_debug("i2c-core: attempting to delete unregistered "
 495                          "adapter [%s]\n", adap->name);
 496                 res = -EINVAL;
 497                 goto out_unlock;
 498         }
 499
 500         list_for_each(item,&drivers) {
 501                 driver = list_entry(item, struct i2c_driver, list);
 502                 if (driver->detach_adapter)
 503                         if ((res = driver->detach_adapter(adap))) {
 504                                 dev_err(&adap->dev, "detach_adapter failed "
 505                                         "for driver [%s]\n",
 506                                         driver->driver.name);
 507                                 goto out_unlock;
 508                         }
 509         }
 510
 511         /* detach any active clients. This must be done first, because
 512          * it can fail; in which case we give up. */
 513         list_for_each_safe(item, _n, &adap->clients) {
 514                 struct i2c_driver       *driver;
 515
 516                 client = list_entry(item, struct i2c_client, list);
 517                 driver = client->driver;
 518
 519                 /* new style, follow standard driver model */
 520                 if (!driver || is_newstyle_driver(driver)) {
 521                         i2c_unregister_device(client);
 522                         continue;
 523                 }
 524
 525                 /* legacy drivers create and remove clients themselves */
 526                 if ((res = driver->detach_client(client))) {
 527                         dev_err(&adap->dev, "detach_client failed for client "
 528                                 "[%s] at address 0x%02x\n", client->name,
 529                                 client->addr);
 530                         goto out_unlock;
 531                 }
 532         }
 533
 534         /* clean up the sysfs representation */
 535         init_completion(&adap->dev_released);
 536         device_unregister(&adap->dev);
 537         list_del(&adap->list);
 538
 539         /* wait for sysfs to drop all references */
 540         wait_for_completion(&adap->dev_released);
 541
 542         /* free bus id */
 543         idr_remove(&i2c_adapter_idr, adap->nr);
 544
 545         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 546
 547  out_unlock:
 548         mutex_unlock(&core_lists);
 549         return res;
 550 }
 551 EXPORT_SYMBOL(i2c_del_adapter);
 552
 553
 554 /* ------------------------------------------------------------------------- */
 555
 556 /*
 557  * An i2c_driver is used with one or more i2c_client (device) nodes to access
 558  * i2c slave chips, on a bus instance associated with some i2c_adapter.  There
 559  * are two models for binding the driver to its device:  "new style" drivers
 560  * follow the standard Linux driver model and just respond to probe() calls
 561  * issued if the driver core sees they match(); "legacy" drivers create device
 562  * nodes themselves.
 563  */
 564
 565 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 566 {
 567         int res;
 568
 569         /* new style driver methods can't mix with legacy ones */
 570         if (is_newstyle_driver(driver)) {
 571                 if (driver->attach_adapter || driver->detach_adapter
 572                                 || driver->detach_client) {
 573                         printk(KERN_WARNING
 574                                         "i2c-core: driver [%s] is confused\n",
 575                                         driver->driver.name);
 576                         return -EINVAL;
 577                 }
 578         }
 579
 580         /* add the driver to the list of i2c drivers in the driver core */
 581         driver->driver.owner = owner;
 582         driver->driver.bus = &i2c_bus_type;
 583
 584         /* for new style drivers, when registration returns the driver core
 585          * will have called probe() for all matching-but-unbound devices.
 586          */
 587         res = driver_register(&driver->driver);
 588         if (res)
 589                 return res;
 590
 591         mutex_lock(&core_lists);
 592
 593         list_add_tail(&driver->list,&drivers);
 594         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 595
 596         /* legacy drivers scan i2c busses directly */
 597         if (driver->attach_adapter) {
 598                 struct i2c_adapter *adapter;
 599
 600                 list_for_each_entry(adapter, &adapters, list) {
 601                         driver->attach_adapter(adapter);
 602                 }
 603         }
 604
 605         mutex_unlock(&core_lists);
 606         return 0;
 607 }
 608 EXPORT_SYMBOL(i2c_register_driver);
 609
 610 /**
 611  * i2c_del_driver - unregister I2C driver
 612  * @driver: the driver being unregistered
 613  * Context: can sleep
 614  */
 615 void i2c_del_driver(struct i2c_driver *driver)
 616 {
 617         struct list_head   *item1, *item2, *_n;
 618         struct i2c_client  *client;
 619         struct i2c_adapter *adap;
 620
 621         mutex_lock(&core_lists);
 622
 623         /* new-style driver? */
 624         if (is_newstyle_driver(driver))
 625                 goto unregister;
 626
 627         /* Have a look at each adapter, if clients of this driver are still
 628          * attached. If so, detach them to be able to kill the driver
 629          * afterwards.
 630          */
 631         list_for_each(item1,&adapters) {
 632                 adap = list_entry(item1, struct i2c_adapter, list);
 633                 if (driver->detach_adapter) {
 634                         if (driver->detach_adapter(adap)) {
 635                                 dev_err(&adap->dev, "detach_adapter failed "
 636                                         "for driver [%s]\n",
 637                                         driver->driver.name);
 638                         }
 639                 } else {
 640                         list_for_each_safe(item2, _n, &adap->clients) {
 641                                 client = list_entry(item2, struct i2c_client, list);
 642                                 if (client->driver != driver)
 643                                         continue;
 644                                 dev_dbg(&adap->dev, "detaching client [%s] "
 645                                         "at 0x%02x\n", client->name,
 646                                         client->addr);
 647                                 if (driver->detach_client(client)) {
 648                                         dev_err(&adap->dev, "detach_client "
 649                                                 "failed for client [%s] at "
 650                                                 "0x%02x\n", client->name,
 651                                                 client->addr);
 652                                 }
 653                         }
 654                 }
 655         }
 656
 657  unregister:
 658         driver_unregister(&driver->driver);
 659         list_del(&driver->list);
 660         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
 661
 662         mutex_unlock(&core_lists);
 663 }
 664 EXPORT_SYMBOL(i2c_del_driver);
 665
 666 /* ------------------------------------------------------------------------- */
 667
 668 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
 669 {
 670         struct list_head   *item;
 671         struct i2c_client  *client;
 672
 673         list_for_each(item,&adapter->clients) {
 674                 client = list_entry(item, struct i2c_client, list);
 675                 if (client->addr == addr)
 676                         return -EBUSY;
 677         }
 678         return 0;
 679 }
 680
 681 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 682 {
 683         int rval;
 684
 685         mutex_lock(&adapter->clist_lock);
 686         rval = __i2c_check_addr(adapter, addr);
 687         mutex_unlock(&adapter->clist_lock);
 688
 689         return rval;
 690 }
 691 EXPORT_SYMBOL(i2c_check_addr);
 692
 693 int i2c_attach_client(struct i2c_client *client)
 694 {
 695         struct i2c_adapter *adapter = client->adapter;
 696         int res = 0;
 697
 698         mutex_lock(&adapter->clist_lock);
 699         if (__i2c_check_addr(client->adapter, client->addr)) {
 700                 res = -EBUSY;
 701                 goto out_unlock;
 702         }
 703         list_add_tail(&client->list,&adapter->clients);
 704
 705         client->usage_count = 0;
 706
 707         client->dev.parent = &client->adapter->dev;
 708         client->dev.bus = &i2c_bus_type;
 709
 710         if (client->driver)
 711                 client->dev.driver = &client->driver->driver;
 712
 713         if (client->driver && !is_newstyle_driver(client->driver)) {
 714                 client->dev.release = i2c_client_release;
 715                 client->dev.uevent_suppress = 1;
 716         } else
 717                 client->dev.release = i2c_client_dev_release;
 718
 719         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
 720                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
 721         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
 722                 client->name, client->dev.bus_id);
 723         res = device_register(&client->dev);
 724         if (res)
 725                 goto out_list;
 726         mutex_unlock(&adapter->clist_lock);
 727
 728         if (adapter->client_register)  {
 729                 if (adapter->client_register(client)) {
 730                         dev_dbg(&adapter->dev, "client_register "
 731                                 "failed for client [%s] at 0x%02x\n",
 732                                 client->name, client->addr);
 733                 }
 734         }
 735
 736         return 0;
 737
 738 out_list:
 739         list_del(&client->list);
 740         dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
 741                 "(%d)\n", client->name, client->addr, res);
 742 out_unlock:
 743         mutex_unlock(&adapter->clist_lock);
 744         return res;
 745 }
 746 EXPORT_SYMBOL(i2c_attach_client);
 747
 748 int i2c_detach_client(struct i2c_client *client)
 749 {
 750         struct i2c_adapter *adapter = client->adapter;
 751         int res = 0;
 752
 753         if (client->usage_count > 0) {
 754                 dev_warn(&client->dev, "Client [%s] still busy, "
 755                          "can't detach\n", client->name);
 756                 return -EBUSY;
 757         }
 758
 759         if (adapter->client_unregister)  {
 760                 res = adapter->client_unregister(client);
 761                 if (res) {
 762                         dev_err(&client->dev,
 763                                 "client_unregister [%s] failed, "
 764                                 "client not detached\n", client->name);
 765                         goto out;
 766                 }
 767         }
 768
 769         mutex_lock(&adapter->clist_lock);
 770         list_del(&client->list);
 771         init_completion(&client->released);
 772         device_unregister(&client->dev);
 773         mutex_unlock(&adapter->clist_lock);
 774         wait_for_completion(&client->released);
 775
 776  out:
 777         return res;
 778 }
 779 EXPORT_SYMBOL(i2c_detach_client);
 780
 781 static int i2c_inc_use_client(struct i2c_client *client)
 782 {
 783
 784         if (!try_module_get(client->driver->driver.owner))
 785                 return -ENODEV;
 786         if (!try_module_get(client->adapter->owner)) {
 787                 module_put(client->driver->driver.owner);
 788                 return -ENODEV;
 789         }
 790
 791         return 0;
 792 }
 793
 794 static void i2c_dec_use_client(struct i2c_client *client)
 795 {
 796         module_put(client->driver->driver.owner);
 797         module_put(client->adapter->owner);
 798 }
 799
 800 int i2c_use_client(struct i2c_client *client)
 801 {
 802         int ret;
 803
 804         ret = i2c_inc_use_client(client);
 805         if (ret)
 806                 return ret;
 807
 808         client->usage_count++;
 809
 810         return 0;
 811 }
 812 EXPORT_SYMBOL(i2c_use_client);
 813
 814 int i2c_release_client(struct i2c_client *client)
 815 {
 816         if (!client->usage_count) {
 817                 pr_debug("i2c-core: %s used one too many times\n",
 818                          __FUNCTION__);
 819                 return -EPERM;
 820         }
 821
 822         client->usage_count--;
 823         i2c_dec_use_client(client);
 824
 825         return 0;
 826 }
 827 EXPORT_SYMBOL(i2c_release_client);
 828
 829 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 830 {
 831         struct list_head  *item;
 832         struct i2c_client *client;
 833
 834         mutex_lock(&adap->clist_lock);
 835         list_for_each(item,&adap->clients) {
 836                 client = list_entry(item, struct i2c_client, list);
 837                 if (!try_module_get(client->driver->driver.owner))
 838                         continue;
 839                 if (NULL != client->driver->command) {
 840                         mutex_unlock(&adap->clist_lock);
 841                         client->driver->command(client,cmd,arg);
 842                         mutex_lock(&adap->clist_lock);
 843                 }
 844                 module_put(client->driver->driver.owner);
 845        }
 846        mutex_unlock(&adap->clist_lock);
 847 }
 848 EXPORT_SYMBOL(i2c_clients_command);
 849
 850 static int __init i2c_init(void)
 851 {
 852         int retval;
 853
 854         retval = bus_register(&i2c_bus_type);
 855         if (retval)
 856                 return retval;
 857         return class_register(&i2c_adapter_class);
 858 }
 859
 860 static void __exit i2c_exit(void)
 861 {
 862         class_unregister(&i2c_adapter_class);
 863         bus_unregister(&i2c_bus_type);
 864 }
 865
 866 subsys_initcall(i2c_init);
 867 module_exit(i2c_exit);
 868
 869 /* ----------------------------------------------------
 870  * the functional interface to the i2c busses.
 871  * ----------------------------------------------------
 872  */
 873
 874 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
 875 {
 876         int ret;
 877
 878         if (adap->algo->master_xfer) {
 879 #ifdef DEBUG
 880                 for (ret = 0; ret < num; ret++) {
 881                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
 882                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
 883                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
 884                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
 885                 }
 886 #endif
 887
 888                 mutex_lock_nested(&adap->bus_lock, adap->level);
 889                 ret = adap->algo->master_xfer(adap,msgs,num);
 890                 mutex_unlock(&adap->bus_lock);
 891
 892                 return ret;
 893         } else {
 894                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
 895                 return -ENOSYS;
 896         }
 897 }
 898 EXPORT_SYMBOL(i2c_transfer);
 899
 900 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
 901 {
 902         int ret;
 903         struct i2c_adapter *adap=client->adapter;
 904         struct i2c_msg msg;
 905
 906         msg.addr = client->addr;
 907         msg.flags = client->flags & I2C_M_TEN;
 908         msg.len = count;
 909         msg.buf = (char *)buf;
 910
 911         ret = i2c_transfer(adap, &msg, 1);
 912
 913         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 914            transmitted, else error code. */
 915         return (ret == 1) ? count : ret;
 916 }
 917 EXPORT_SYMBOL(i2c_master_send);
 918
 919 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
 920 {
 921         struct i2c_adapter *adap=client->adapter;
 922         struct i2c_msg msg;
 923         int ret;
 924
 925         msg.addr = client->addr;
 926         msg.flags = client->flags & I2C_M_TEN;
 927         msg.flags |= I2C_M_RD;
 928         msg.len = count;
 929         msg.buf = buf;
 930
 931         ret = i2c_transfer(adap, &msg, 1);
 932
 933         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 934            transmitted, else error code. */
 935         return (ret == 1) ? count : ret;
 936 }
 937 EXPORT_SYMBOL(i2c_master_recv);
 938
 939 int i2c_control(struct i2c_client *client,
 940         unsigned int cmd, unsigned long arg)
 941 {
 942         int ret = 0;
 943         struct i2c_adapter *adap = client->adapter;
 944
 945         dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
 946         switch (cmd) {
 947                 case I2C_RETRIES:
 948                         adap->retries = arg;
 949                         break;
 950                 case I2C_TIMEOUT:
 951                         adap->timeout = arg;
 952                         break;
 953                 default:
 954                         if (adap->algo->algo_control!=NULL)
 955                                 ret = adap->algo->algo_control(adap,cmd,arg);
 956         }
 957         return ret;
 958 }
 959 EXPORT_SYMBOL(i2c_control);
 960
 961 /* ----------------------------------------------------
 962  * the i2c address scanning function
 963  * Will not work for 10-bit addresses!
 964  * ----------------------------------------------------
 965  */
 966 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
 967                              int (*found_proc) (struct i2c_adapter *, int, int))
 968 {
 969         int err;
 970
 971         /* Make sure the address is valid */
 972         if (addr < 0x03 || addr > 0x77) {
 973                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
 974                          addr);
 975                 return -EINVAL;
 976         }
 977
 978         /* Skip if already in use */
 979         if (i2c_check_addr(adapter, addr))
 980                 return 0;
 981
 982         /* Make sure there is something at this address, unless forced */
 983         if (kind < 0) {
 984                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 985                                    I2C_SMBUS_QUICK, NULL) < 0)
 986                         return 0;
 987
 988                 /* prevent 24RF08 corruption */
 989                 if ((addr & ~0x0f) == 0x50)
 990                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 991                                        I2C_SMBUS_QUICK, NULL);
 992         }
 993
 994         /* Finally call the custom detection function */
 995         err = found_proc(adapter, addr, kind);
 996         /* -ENODEV can be returned if there is a chip at the given address
 997            but it isn't supported by this chip driver. We catch it here as
 998            this isn't an error. */
 999         if (err == -ENODEV)
1000                 err = 0;
1001
1002         if (err)
1003                 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1004                          addr, err);
1005         return err;
1006 }
1007
1008 int i2c_probe(struct i2c_adapter *adapter,
1009               struct i2c_client_address_data *address_data,
1010               int (*found_proc) (struct i2c_adapter *, int, int))
1011 {
1012         int i, err;
1013         int adap_id = i2c_adapter_id(adapter);
1014
1015         /* Force entries are done first, and are not affected by ignore
1016            entries */
1017         if (address_data->forces) {
1018                 unsigned short **forces = address_data->forces;
1019                 int kind;
1020
1021                 for (kind = 0; forces[kind]; kind++) {
1022                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1023                              i += 2) {
1024                                 if (forces[kind][i] == adap_id
1025                                  || forces[kind][i] == ANY_I2C_BUS) {
1026                                         dev_dbg(&adapter->dev, "found force "
1027                                                 "parameter for adapter %d, "
1028                                                 "addr 0x%02x, kind %d\n",
1029                                                 adap_id, forces[kind][i + 1],
1030                                                 kind);
1031                                         err = i2c_probe_address(adapter,
1032                                                 forces[kind][i + 1],
1033                                                 kind, found_proc);
1034                                         if (err)
1035                                                 return err;
1036                                 }
1037                         }
1038                 }
1039         }
1040
1041         /* Stop here if we can't use SMBUS_QUICK */
1042         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1043                 if (address_data->probe[0] == I2C_CLIENT_END
1044                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1045                         return 0;
1046
1047                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1048                          "can't probe for chips\n");
1049                 return -1;
1050         }
1051
1052         /* Probe entries are done second, and are not affected by ignore
1053            entries either */
1054         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1055                 if (address_data->probe[i] == adap_id
1056                  || address_data->probe[i] == ANY_I2C_BUS) {
1057                         dev_dbg(&adapter->dev, "found probe parameter for "
1058                                 "adapter %d, addr 0x%02x\n", adap_id,
1059                                 address_data->probe[i + 1]);
1060                         err = i2c_probe_address(adapter,
1061                                                 address_data->probe[i + 1],
1062                                                 -1, found_proc);
1063                         if (err)
1064                                 return err;
1065                 }
1066         }
1067
1068         /* Normal entries are done last, unless shadowed by an ignore entry */
1069         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1070                 int j, ignore;
1071
1072                 ignore = 0;
1073                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1074                      j += 2) {
1075                         if ((address_data->ignore[j] == adap_id ||
1076                              address_data->ignore[j] == ANY_I2C_BUS)
1077                          && address_data->ignore[j + 1]
1078                             == address_data->normal_i2c[i]) {
1079                                 dev_dbg(&adapter->dev, "found ignore "
1080                                         "parameter for adapter %d, "
1081                                         "addr 0x%02x\n", adap_id,
1082                                         address_data->ignore[j + 1]);
1083                                 ignore = 1;
1084                                 break;
1085                         }
1086                 }
1087                 if (ignore)
1088                         continue;
1089
1090                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1091                         "addr 0x%02x\n", adap_id,
1092                         address_data->normal_i2c[i]);
1093                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1094                                         -1, found_proc);
1095                 if (err)
1096                         return err;
1097         }
1098
1099         return 0;
1100 }
1101 EXPORT_SYMBOL(i2c_probe);
1102
1103 struct i2c_client *
1104 i2c_new_probed_device(struct i2c_adapter *adap,
1105                       struct i2c_board_info *info,
1106                       unsigned short const *addr_list)
1107 {
1108         int i;
1109
1110         /* Stop here if the bus doesn't support probing */
1111         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1112                 dev_err(&adap->dev, "Probing not supported\n");
1113                 return NULL;
1114         }
1115
1116         mutex_lock(&adap->clist_lock);
1117         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1118                 /* Check address validity */
1119                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1120                         dev_warn(&adap->dev, "Invalid 7-bit address "
1121                                  "0x%02x\n", addr_list[i]);
1122                         continue;
1123                 }
1124
1125                 /* Check address availability */
1126                 if (__i2c_check_addr(adap, addr_list[i])) {
1127                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1128                                 "use, not probing\n", addr_list[i]);
1129                         continue;
1130                 }
1131
1132                 /* Test address responsiveness
1133                    The default probe method is a quick write, but it is known
1134                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1135                    and could also irreversibly write-protect some EEPROMs, so
1136                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1137                    read instead. Also, some bus drivers don't implement
1138                    quick write, so we fallback to a byte read it that case
1139                    too. */
1140                 if ((addr_list[i] & ~0x07) == 0x30
1141                  || (addr_list[i] & ~0x0f) == 0x50
1142                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1143                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1144                                            I2C_SMBUS_READ, 0,
1145                                            I2C_SMBUS_BYTE, NULL) >= 0)
1146                                 break;
1147                 } else {
1148                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1149                                            I2C_SMBUS_WRITE, 0,
1150                                            I2C_SMBUS_QUICK, NULL) >= 0)
1151                                 break;
1152                 }
1153         }
1154         mutex_unlock(&adap->clist_lock);
1155
1156         if (addr_list[i] == I2C_CLIENT_END) {
1157                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1158                 return NULL;
1159         }
1160
1161         info->addr = addr_list[i];
1162         return i2c_new_device(adap, info);
1163 }
1164 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1165
1166 struct i2c_adapter* i2c_get_adapter(int id)
1167 {
1168         struct i2c_adapter *adapter;
1169
1170         mutex_lock(&core_lists);
1171         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1172         if (adapter && !try_module_get(adapter->owner))
1173                 adapter = NULL;
1174
1175         mutex_unlock(&core_lists);
1176         return adapter;
1177 }
1178 EXPORT_SYMBOL(i2c_get_adapter);
1179
1180 void i2c_put_adapter(struct i2c_adapter *adap)
1181 {
1182         module_put(adap->owner);
1183 }
1184 EXPORT_SYMBOL(i2c_put_adapter);
1185
1186 /* The SMBus parts */
1187
1188 #define POLY    (0x1070U << 3)
1189 static u8
1190 crc8(u16 data)
1191 {
1192         int i;
1193
1194         for(i = 0; i < 8; i++) {
1195                 if (data & 0x8000)
1196                         data = data ^ POLY;
1197                 data = data << 1;
1198         }
1199         return (u8)(data >> 8);
1200 }
1201
1202 /* Incremental CRC8 over count bytes in the array pointed to by p */
1203 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1204 {
1205         int i;
1206
1207         for(i = 0; i < count; i++)
1208                 crc = crc8((crc ^ p[i]) << 8);
1209         return crc;
1210 }
1211
1212 /* Assume a 7-bit address, which is reasonable for SMBus */
1213 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1214 {
1215         /* The address will be sent first */
1216         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1217         pec = i2c_smbus_pec(pec, &addr, 1);
1218
1219         /* The data buffer follows */
1220         return i2c_smbus_pec(pec, msg->buf, msg->len);
1221 }
1222
1223 /* Used for write only transactions */
1224 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1225 {
1226         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1227         msg->len++;
1228 }
1229
1230 /* Return <0 on CRC error
1231    If there was a write before this read (most cases) we need to take the
1232    partial CRC from the write part into account.
1233    Note that this function does modify the message (we need to decrease the
1234    message length to hide the CRC byte from the caller). */
1235 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1236 {
1237         u8 rpec = msg->buf[--msg->len];
1238         cpec = i2c_smbus_msg_pec(cpec, msg);
1239
1240         if (rpec != cpec) {
1241                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1242                         rpec, cpec);
1243                 return -1;
1244         }
1245         return 0;
1246 }
1247
1248 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1249 {
1250         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1251                               value,0,I2C_SMBUS_QUICK,NULL);
1252 }
1253 EXPORT_SYMBOL(i2c_smbus_write_quick);
1254
1255 s32 i2c_smbus_read_byte(struct i2c_client *client)
1256 {
1257         union i2c_smbus_data data;
1258         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1259                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1260                 return -1;
1261         else
1262                 return data.byte;
1263 }
1264 EXPORT_SYMBOL(i2c_smbus_read_byte);
1265
1266 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1267 {
1268         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1269                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1270 }
1271 EXPORT_SYMBOL(i2c_smbus_write_byte);
1272
1273 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1274 {
1275         union i2c_smbus_data data;
1276         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1277                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1278                 return -1;
1279         else
1280                 return data.byte;
1281 }
1282 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1283
1284 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1285 {
1286         union i2c_smbus_data data;
1287         data.byte = value;
1288         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1289                               I2C_SMBUS_WRITE,command,
1290                               I2C_SMBUS_BYTE_DATA,&data);
1291 }
1292 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1293
1294 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1295 {
1296         union i2c_smbus_data data;
1297         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1298                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1299                 return -1;
1300         else
1301                 return data.word;
1302 }
1303 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1304
1305 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1306 {
1307         union i2c_smbus_data data;
1308         data.word = value;
1309         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1310                               I2C_SMBUS_WRITE,command,
1311                               I2C_SMBUS_WORD_DATA,&data);
1312 }
1313 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1314
1315 /* Returns the number of read bytes */
1316 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1317                               u8 *values)
1318 {
1319         union i2c_smbus_data data;
1320
1321         if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1322                            I2C_SMBUS_READ, command,
1323                            I2C_SMBUS_BLOCK_DATA, &data))
1324                 return -1;
1325
1326         memcpy(values, &data.block[1], data.block[0]);
1327         return data.block[0];
1328 }
1329 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1330
1331 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1332                                u8 length, const u8 *values)
1333 {
1334         union i2c_smbus_data data;
1335
1336         if (length > I2C_SMBUS_BLOCK_MAX)
1337                 length = I2C_SMBUS_BLOCK_MAX;
1338         data.block[0] = length;
1339         memcpy(&data.block[1], values, length);
1340         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1341                               I2C_SMBUS_WRITE,command,
1342                               I2C_SMBUS_BLOCK_DATA,&data);
1343 }
1344 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1345
1346 /* Returns the number of read bytes */
1347 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1348                                   u8 length, u8 *values)
1349 {
1350         union i2c_smbus_data data;
1351
1352         if (length > I2C_SMBUS_BLOCK_MAX)
1353                 length = I2C_SMBUS_BLOCK_MAX;
1354         data.block[0] = length;
1355         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1356                               I2C_SMBUS_READ,command,
1357                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
1358                 return -1;
1359
1360         memcpy(values, &data.block[1], data.block[0]);
1361         return data.block[0];
1362 }
1363 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1364
1365 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1366                                    u8 length, const u8 *values)
1367 {
1368         union i2c_smbus_data data;
1369
1370         if (length > I2C_SMBUS_BLOCK_MAX)
1371                 length = I2C_SMBUS_BLOCK_MAX;
1372         data.block[0] = length;
1373         memcpy(data.block + 1, values, length);
1374         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1375                               I2C_SMBUS_WRITE, command,
1376                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1377 }
1378 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1379
1380 /* Simulate a SMBus command using the i2c protocol
1381    No checking of parameters is done!  */
1382 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1383                                    unsigned short flags,
1384                                    char read_write, u8 command, int size,
1385                                    union i2c_smbus_data * data)
1386 {
1387         /* So we need to generate a series of msgs. In the case of writing, we
1388           need to use only one message; when reading, we need two. We initialize
1389           most things with sane defaults, to keep the code below somewhat
1390           simpler. */
1391         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1392         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1393         int num = read_write == I2C_SMBUS_READ?2:1;
1394         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1395                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1396                                 };
1397         int i;
1398         u8 partial_pec = 0;
1399
1400         msgbuf0[0] = command;
1401         switch(size) {
1402         case I2C_SMBUS_QUICK:
1403                 msg[0].len = 0;
1404                 /* Special case: The read/write field is used as data */
1405                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1406                 num = 1;
1407                 break;
1408         case I2C_SMBUS_BYTE:
1409                 if (read_write == I2C_SMBUS_READ) {
1410                         /* Special case: only a read! */
1411                         msg[0].flags = I2C_M_RD | flags;
1412                         num = 1;
1413                 }
1414                 break;
1415         case I2C_SMBUS_BYTE_DATA:
1416                 if (read_write == I2C_SMBUS_READ)
1417                         msg[1].len = 1;
1418                 else {
1419                         msg[0].len = 2;
1420                         msgbuf0[1] = data->byte;
1421                 }
1422                 break;
1423         case I2C_SMBUS_WORD_DATA:
1424                 if (read_write == I2C_SMBUS_READ)
1425                         msg[1].len = 2;
1426                 else {
1427                         msg[0].len=3;
1428                         msgbuf0[1] = data->word & 0xff;
1429                         msgbuf0[2] = data->word >> 8;
1430                 }
1431                 break;
1432         case I2C_SMBUS_PROC_CALL:
1433                 num = 2; /* Special case */
1434                 read_write = I2C_SMBUS_READ;
1435                 msg[0].len = 3;
1436                 msg[1].len = 2;
1437                 msgbuf0[1] = data->word & 0xff;
1438                 msgbuf0[2] = data->word >> 8;
1439                 break;
1440         case I2C_SMBUS_BLOCK_DATA:
1441                 if (read_write == I2C_SMBUS_READ) {
1442                         msg[1].flags |= I2C_M_RECV_LEN;
1443                         msg[1].len = 1; /* block length will be added by
1444                                            the underlying bus driver */
1445                 } else {
1446                         msg[0].len = data->block[0] + 2;
1447                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1448                                 dev_err(&adapter->dev, "smbus_access called with "
1449                                        "invalid block write size (%d)\n",
1450                                        data->block[0]);
1451                                 return -1;
1452                         }
1453                         for (i = 1; i < msg[0].len; i++)
1454                                 msgbuf0[i] = data->block[i-1];
1455                 }
1456                 break;
1457         case I2C_SMBUS_BLOCK_PROC_CALL:
1458                 num = 2; /* Another special case */
1459                 read_write = I2C_SMBUS_READ;
1460                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1461                         dev_err(&adapter->dev, "%s called with invalid "
1462                                 "block proc call size (%d)\n", __FUNCTION__,
1463                                 data->block[0]);
1464                         return -1;
1465                 }
1466                 msg[0].len = data->block[0] + 2;
1467                 for (i = 1; i < msg[0].len; i++)
1468                         msgbuf0[i] = data->block[i-1];
1469                 msg[1].flags |= I2C_M_RECV_LEN;
1470                 msg[1].len = 1; /* block length will be added by
1471                                    the underlying bus driver */
1472                 break;
1473         case I2C_SMBUS_I2C_BLOCK_DATA:
1474                 if (read_write == I2C_SMBUS_READ) {
1475                         msg[1].len = data->block[0];
1476                 } else {
1477                         msg[0].len = data->block[0] + 1;
1478                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1479                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1480                                        "invalid block write size (%d)\n",
1481                                        data->block[0]);
1482                                 return -1;
1483                         }
1484                         for (i = 1; i <= data->block[0]; i++)
1485                                 msgbuf0[i] = data->block[i];
1486                 }
1487                 break;
1488         default:
1489                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1490                        size);
1491                 return -1;
1492         }
1493
1494         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1495                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1496         if (i) {
1497                 /* Compute PEC if first message is a write */
1498                 if (!(msg[0].flags & I2C_M_RD)) {
1499                         if (num == 1) /* Write only */
1500                                 i2c_smbus_add_pec(&msg[0]);
1501                         else /* Write followed by read */
1502                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1503                 }
1504                 /* Ask for PEC if last message is a read */
1505                 if (msg[num-1].flags & I2C_M_RD)
1506                         msg[num-1].len++;
1507         }
1508
1509         if (i2c_transfer(adapter, msg, num) < 0)
1510                 return -1;
1511
1512         /* Check PEC if last message is a read */
1513         if (i && (msg[num-1].flags & I2C_M_RD)) {
1514                 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1515                         return -1;
1516         }
1517
1518         if (read_write == I2C_SMBUS_READ)
1519                 switch(size) {
1520                         case I2C_SMBUS_BYTE:
1521                                 data->byte = msgbuf0[0];
1522                                 break;
1523                         case I2C_SMBUS_BYTE_DATA:
1524                                 data->byte = msgbuf1[0];
1525                                 break;
1526                         case I2C_SMBUS_WORD_DATA:
1527                         case I2C_SMBUS_PROC_CALL:
1528                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1529                                 break;
1530                         case I2C_SMBUS_I2C_BLOCK_DATA:
1531                                 for (i = 0; i < data->block[0]; i++)
1532                                         data->block[i+1] = msgbuf1[i];
1533                                 break;
1534                         case I2C_SMBUS_BLOCK_DATA:
1535                         case I2C_SMBUS_BLOCK_PROC_CALL:
1536                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1537                                         data->block[i] = msgbuf1[i];
1538                                 break;
1539                 }
1540         return 0;
1541 }
1542
1543
1544 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1545                    char read_write, u8 command, int size,
1546                    union i2c_smbus_data * data)
1547 {
1548         s32 res;
1549
1550         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1551
1552         if (adapter->algo->smbus_xfer) {
1553                 mutex_lock(&adapter->bus_lock);
1554                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1555                                                 command,size,data);
1556                 mutex_unlock(&adapter->bus_lock);
1557         } else
1558                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1559                                               command,size,data);
1560
1561         return res;
1562 }
1563 EXPORT_SYMBOL(i2c_smbus_xfer);
1564
1565 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1566 MODULE_DESCRIPTION("I2C-Bus main module");
1567 MODULE_LICENSE("GPL");