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