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