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