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         else
 703                 client->dev.release = i2c_client_dev_release;
 704
 705         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
 706                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
 707         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
 708                 client->name, client->dev.bus_id);
 709         res = device_register(&client->dev);
 710         if (res)
 711                 goto out_list;
 712         mutex_unlock(&adapter->clist_lock);
 713
 714         if (adapter->client_register)  {
 715                 if (adapter->client_register(client)) {
 716                         dev_dbg(&adapter->dev, "client_register "
 717                                 "failed for client [%s] at 0x%02x\n",
 718                                 client->name, client->addr);
 719                 }
 720         }
 721
 722         return 0;
 723
 724 out_list:
 725         list_del(&client->list);
 726         dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
 727                 "(%d)\n", client->name, client->addr, res);
 728 out_unlock:
 729         mutex_unlock(&adapter->clist_lock);
 730         return res;
 731 }
 732 EXPORT_SYMBOL(i2c_attach_client);
 733
 734 int i2c_detach_client(struct i2c_client *client)
 735 {
 736         struct i2c_adapter *adapter = client->adapter;
 737         int res = 0;
 738
 739         if (client->usage_count > 0) {
 740                 dev_warn(&client->dev, "Client [%s] still busy, "
 741                          "can't detach\n", client->name);
 742                 return -EBUSY;
 743         }
 744
 745         if (adapter->client_unregister)  {
 746                 res = adapter->client_unregister(client);
 747                 if (res) {
 748                         dev_err(&client->dev,
 749                                 "client_unregister [%s] failed, "
 750                                 "client not detached\n", client->name);
 751                         goto out;
 752                 }
 753         }
 754
 755         mutex_lock(&adapter->clist_lock);
 756         list_del(&client->list);
 757         init_completion(&client->released);
 758         device_unregister(&client->dev);
 759         mutex_unlock(&adapter->clist_lock);
 760         wait_for_completion(&client->released);
 761
 762  out:
 763         return res;
 764 }
 765 EXPORT_SYMBOL(i2c_detach_client);
 766
 767 static int i2c_inc_use_client(struct i2c_client *client)
 768 {
 769
 770         if (!try_module_get(client->driver->driver.owner))
 771                 return -ENODEV;
 772         if (!try_module_get(client->adapter->owner)) {
 773                 module_put(client->driver->driver.owner);
 774                 return -ENODEV;
 775         }
 776
 777         return 0;
 778 }
 779
 780 static void i2c_dec_use_client(struct i2c_client *client)
 781 {
 782         module_put(client->driver->driver.owner);
 783         module_put(client->adapter->owner);
 784 }
 785
 786 int i2c_use_client(struct i2c_client *client)
 787 {
 788         int ret;
 789
 790         ret = i2c_inc_use_client(client);
 791         if (ret)
 792                 return ret;
 793
 794         client->usage_count++;
 795
 796         return 0;
 797 }
 798 EXPORT_SYMBOL(i2c_use_client);
 799
 800 int i2c_release_client(struct i2c_client *client)
 801 {
 802         if (!client->usage_count) {
 803                 pr_debug("i2c-core: %s used one too many times\n",
 804                          __FUNCTION__);
 805                 return -EPERM;
 806         }
 807
 808         client->usage_count--;
 809         i2c_dec_use_client(client);
 810
 811         return 0;
 812 }
 813 EXPORT_SYMBOL(i2c_release_client);
 814
 815 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 816 {
 817         struct list_head  *item;
 818         struct i2c_client *client;
 819
 820         mutex_lock(&adap->clist_lock);
 821         list_for_each(item,&adap->clients) {
 822                 client = list_entry(item, struct i2c_client, list);
 823                 if (!try_module_get(client->driver->driver.owner))
 824                         continue;
 825                 if (NULL != client->driver->command) {
 826                         mutex_unlock(&adap->clist_lock);
 827                         client->driver->command(client,cmd,arg);
 828                         mutex_lock(&adap->clist_lock);
 829                 }
 830                 module_put(client->driver->driver.owner);
 831        }
 832        mutex_unlock(&adap->clist_lock);
 833 }
 834 EXPORT_SYMBOL(i2c_clients_command);
 835
 836 static int __init i2c_init(void)
 837 {
 838         int retval;
 839
 840         retval = bus_register(&i2c_bus_type);
 841         if (retval)
 842                 return retval;
 843         return class_register(&i2c_adapter_class);
 844 }
 845
 846 static void __exit i2c_exit(void)
 847 {
 848         class_unregister(&i2c_adapter_class);
 849         bus_unregister(&i2c_bus_type);
 850 }
 851
 852 subsys_initcall(i2c_init);
 853 module_exit(i2c_exit);
 854
 855 /* ----------------------------------------------------
 856  * the functional interface to the i2c busses.
 857  * ----------------------------------------------------
 858  */
 859
 860 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
 861 {
 862         int ret;
 863
 864         if (adap->algo->master_xfer) {
 865 #ifdef DEBUG
 866                 for (ret = 0; ret < num; ret++) {
 867                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
 868                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
 869                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
 870                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
 871                 }
 872 #endif
 873
 874                 mutex_lock_nested(&adap->bus_lock, adap->level);
 875                 ret = adap->algo->master_xfer(adap,msgs,num);
 876                 mutex_unlock(&adap->bus_lock);
 877
 878                 return ret;
 879         } else {
 880                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
 881                 return -ENOSYS;
 882         }
 883 }
 884 EXPORT_SYMBOL(i2c_transfer);
 885
 886 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
 887 {
 888         int ret;
 889         struct i2c_adapter *adap=client->adapter;
 890         struct i2c_msg msg;
 891
 892         msg.addr = client->addr;
 893         msg.flags = client->flags & I2C_M_TEN;
 894         msg.len = count;
 895         msg.buf = (char *)buf;
 896
 897         ret = i2c_transfer(adap, &msg, 1);
 898
 899         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 900            transmitted, else error code. */
 901         return (ret == 1) ? count : ret;
 902 }
 903 EXPORT_SYMBOL(i2c_master_send);
 904
 905 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
 906 {
 907         struct i2c_adapter *adap=client->adapter;
 908         struct i2c_msg msg;
 909         int ret;
 910
 911         msg.addr = client->addr;
 912         msg.flags = client->flags & I2C_M_TEN;
 913         msg.flags |= I2C_M_RD;
 914         msg.len = count;
 915         msg.buf = buf;
 916
 917         ret = i2c_transfer(adap, &msg, 1);
 918
 919         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 920            transmitted, else error code. */
 921         return (ret == 1) ? count : ret;
 922 }
 923 EXPORT_SYMBOL(i2c_master_recv);
 924
 925 int i2c_control(struct i2c_client *client,
 926         unsigned int cmd, unsigned long arg)
 927 {
 928         int ret = 0;
 929         struct i2c_adapter *adap = client->adapter;
 930
 931         dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
 932         switch (cmd) {
 933                 case I2C_RETRIES:
 934                         adap->retries = arg;
 935                         break;
 936                 case I2C_TIMEOUT:
 937                         adap->timeout = arg;
 938                         break;
 939                 default:
 940                         if (adap->algo->algo_control!=NULL)
 941                                 ret = adap->algo->algo_control(adap,cmd,arg);
 942         }
 943         return ret;
 944 }
 945 EXPORT_SYMBOL(i2c_control);
 946
 947 /* ----------------------------------------------------
 948  * the i2c address scanning function
 949  * Will not work for 10-bit addresses!
 950  * ----------------------------------------------------
 951  */
 952 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
 953                              int (*found_proc) (struct i2c_adapter *, int, int))
 954 {
 955         int err;
 956
 957         /* Make sure the address is valid */
 958         if (addr < 0x03 || addr > 0x77) {
 959                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
 960                          addr);
 961                 return -EINVAL;
 962         }
 963
 964         /* Skip if already in use */
 965         if (i2c_check_addr(adapter, addr))
 966                 return 0;
 967
 968         /* Make sure there is something at this address, unless forced */
 969         if (kind < 0) {
 970                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 971                                    I2C_SMBUS_QUICK, NULL) < 0)
 972                         return 0;
 973
 974                 /* prevent 24RF08 corruption */
 975                 if ((addr & ~0x0f) == 0x50)
 976                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 977                                        I2C_SMBUS_QUICK, NULL);
 978         }
 979
 980         /* Finally call the custom detection function */
 981         err = found_proc(adapter, addr, kind);
 982         /* -ENODEV can be returned if there is a chip at the given address
 983            but it isn't supported by this chip driver. We catch it here as
 984            this isn't an error. */
 985         if (err == -ENODEV)
 986                 err = 0;
 987
 988         if (err)
 989                 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
 990                          addr, err);
 991         return err;
 992 }
 993
 994 int i2c_probe(struct i2c_adapter *adapter,
 995               struct i2c_client_address_data *address_data,
 996               int (*found_proc) (struct i2c_adapter *, int, int))
 997 {
 998         int i, err;
 999         int adap_id = i2c_adapter_id(adapter);
1000
1001         /* Force entries are done first, and are not affected by ignore
1002            entries */
1003         if (address_data->forces) {
1004                 unsigned short **forces = address_data->forces;
1005                 int kind;
1006
1007                 for (kind = 0; forces[kind]; kind++) {
1008                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1009                              i += 2) {
1010                                 if (forces[kind][i] == adap_id
1011                                  || forces[kind][i] == ANY_I2C_BUS) {
1012                                         dev_dbg(&adapter->dev, "found force "
1013                                                 "parameter for adapter %d, "
1014                                                 "addr 0x%02x, kind %d\n",
1015                                                 adap_id, forces[kind][i + 1],
1016                                                 kind);
1017                                         err = i2c_probe_address(adapter,
1018                                                 forces[kind][i + 1],
1019                                                 kind, found_proc);
1020                                         if (err)
1021                                                 return err;
1022                                 }
1023                         }
1024                 }
1025         }
1026
1027         /* Stop here if we can't use SMBUS_QUICK */
1028         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1029                 if (address_data->probe[0] == I2C_CLIENT_END
1030                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1031                         return 0;
1032
1033                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1034                          "can't probe for chips\n");
1035                 return -1;
1036         }
1037
1038         /* Probe entries are done second, and are not affected by ignore
1039            entries either */
1040         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1041                 if (address_data->probe[i] == adap_id
1042                  || address_data->probe[i] == ANY_I2C_BUS) {
1043                         dev_dbg(&adapter->dev, "found probe parameter for "
1044                                 "adapter %d, addr 0x%02x\n", adap_id,
1045                                 address_data->probe[i + 1]);
1046                         err = i2c_probe_address(adapter,
1047                                                 address_data->probe[i + 1],
1048                                                 -1, found_proc);
1049                         if (err)
1050                                 return err;
1051                 }
1052         }
1053
1054         /* Normal entries are done last, unless shadowed by an ignore entry */
1055         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1056                 int j, ignore;
1057
1058                 ignore = 0;
1059                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1060                      j += 2) {
1061                         if ((address_data->ignore[j] == adap_id ||
1062                              address_data->ignore[j] == ANY_I2C_BUS)
1063                          && address_data->ignore[j + 1]
1064                             == address_data->normal_i2c[i]) {
1065                                 dev_dbg(&adapter->dev, "found ignore "
1066                                         "parameter for adapter %d, "
1067                                         "addr 0x%02x\n", adap_id,
1068                                         address_data->ignore[j + 1]);
1069                                 ignore = 1;
1070                                 break;
1071                         }
1072                 }
1073                 if (ignore)
1074                         continue;
1075
1076                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1077                         "addr 0x%02x\n", adap_id,
1078                         address_data->normal_i2c[i]);
1079                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1080                                         -1, found_proc);
1081                 if (err)
1082                         return err;
1083         }
1084
1085         return 0;
1086 }
1087 EXPORT_SYMBOL(i2c_probe);
1088
1089 struct i2c_client *
1090 i2c_new_probed_device(struct i2c_adapter *adap,
1091                       struct i2c_board_info *info,
1092                       unsigned short const *addr_list)
1093 {
1094         int i;
1095
1096         /* Stop here if the bus doesn't support probing */
1097         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1098                 dev_err(&adap->dev, "Probing not supported\n");
1099                 return NULL;
1100         }
1101
1102         mutex_lock(&adap->clist_lock);
1103         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1104                 /* Check address validity */
1105                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1106                         dev_warn(&adap->dev, "Invalid 7-bit address "
1107                                  "0x%02x\n", addr_list[i]);
1108                         continue;
1109                 }
1110
1111                 /* Check address availability */
1112                 if (__i2c_check_addr(adap, addr_list[i])) {
1113                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1114                                 "use, not probing\n", addr_list[i]);
1115                         continue;
1116                 }
1117
1118                 /* Test address responsiveness
1119                    The default probe method is a quick write, but it is known
1120                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1121                    and could also irreversibly write-protect some EEPROMs, so
1122                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1123                    read instead. Also, some bus drivers don't implement
1124                    quick write, so we fallback to a byte read it that case
1125                    too. */
1126                 if ((addr_list[i] & ~0x07) == 0x30
1127                  || (addr_list[i] & ~0x0f) == 0x50
1128                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1129                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1130                                            I2C_SMBUS_READ, 0,
1131                                            I2C_SMBUS_BYTE, NULL) >= 0)
1132                                 break;
1133                 } else {
1134                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1135                                            I2C_SMBUS_WRITE, 0,
1136                                            I2C_SMBUS_QUICK, NULL) >= 0)
1137                                 break;
1138                 }
1139         }
1140         mutex_unlock(&adap->clist_lock);
1141
1142         if (addr_list[i] == I2C_CLIENT_END) {
1143                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1144                 return NULL;
1145         }
1146
1147         info->addr = addr_list[i];
1148         return i2c_new_device(adap, info);
1149 }
1150 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1151
1152 struct i2c_adapter* i2c_get_adapter(int id)
1153 {
1154         struct i2c_adapter *adapter;
1155
1156         mutex_lock(&core_lists);
1157         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1158         if (adapter && !try_module_get(adapter->owner))
1159                 adapter = NULL;
1160
1161         mutex_unlock(&core_lists);
1162         return adapter;
1163 }
1164 EXPORT_SYMBOL(i2c_get_adapter);
1165
1166 void i2c_put_adapter(struct i2c_adapter *adap)
1167 {
1168         module_put(adap->owner);
1169 }
1170 EXPORT_SYMBOL(i2c_put_adapter);
1171
1172 /* The SMBus parts */
1173
1174 #define POLY    (0x1070U << 3)
1175 static u8
1176 crc8(u16 data)
1177 {
1178         int i;
1179
1180         for(i = 0; i < 8; i++) {
1181                 if (data & 0x8000)
1182                         data = data ^ POLY;
1183                 data = data << 1;
1184         }
1185         return (u8)(data >> 8);
1186 }
1187
1188 /* Incremental CRC8 over count bytes in the array pointed to by p */
1189 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1190 {
1191         int i;
1192
1193         for(i = 0; i < count; i++)
1194                 crc = crc8((crc ^ p[i]) << 8);
1195         return crc;
1196 }
1197
1198 /* Assume a 7-bit address, which is reasonable for SMBus */
1199 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1200 {
1201         /* The address will be sent first */
1202         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1203         pec = i2c_smbus_pec(pec, &addr, 1);
1204
1205         /* The data buffer follows */
1206         return i2c_smbus_pec(pec, msg->buf, msg->len);
1207 }
1208
1209 /* Used for write only transactions */
1210 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1211 {
1212         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1213         msg->len++;
1214 }
1215
1216 /* Return <0 on CRC error
1217    If there was a write before this read (most cases) we need to take the
1218    partial CRC from the write part into account.
1219    Note that this function does modify the message (we need to decrease the
1220    message length to hide the CRC byte from the caller). */
1221 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1222 {
1223         u8 rpec = msg->buf[--msg->len];
1224         cpec = i2c_smbus_msg_pec(cpec, msg);
1225
1226         if (rpec != cpec) {
1227                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1228                         rpec, cpec);
1229                 return -1;
1230         }
1231         return 0;
1232 }
1233
1234 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
1235 {
1236         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1237                               value,0,I2C_SMBUS_QUICK,NULL);
1238 }
1239 EXPORT_SYMBOL(i2c_smbus_write_quick);
1240
1241 s32 i2c_smbus_read_byte(struct i2c_client *client)
1242 {
1243         union i2c_smbus_data data;
1244         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1245                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
1246                 return -1;
1247         else
1248                 return data.byte;
1249 }
1250 EXPORT_SYMBOL(i2c_smbus_read_byte);
1251
1252 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1253 {
1254         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1255                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1256 }
1257 EXPORT_SYMBOL(i2c_smbus_write_byte);
1258
1259 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1260 {
1261         union i2c_smbus_data data;
1262         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1263                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
1264                 return -1;
1265         else
1266                 return data.byte;
1267 }
1268 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1269
1270 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1271 {
1272         union i2c_smbus_data data;
1273         data.byte = value;
1274         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1275                               I2C_SMBUS_WRITE,command,
1276                               I2C_SMBUS_BYTE_DATA,&data);
1277 }
1278 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1279
1280 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1281 {
1282         union i2c_smbus_data data;
1283         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1284                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
1285                 return -1;
1286         else
1287                 return data.word;
1288 }
1289 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1290
1291 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1292 {
1293         union i2c_smbus_data data;
1294         data.word = value;
1295         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1296                               I2C_SMBUS_WRITE,command,
1297                               I2C_SMBUS_WORD_DATA,&data);
1298 }
1299 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1300
1301 /* Returns the number of read bytes */
1302 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1303                               u8 *values)
1304 {
1305         union i2c_smbus_data data;
1306
1307         if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1308                            I2C_SMBUS_READ, command,
1309                            I2C_SMBUS_BLOCK_DATA, &data))
1310                 return -1;
1311
1312         memcpy(values, &data.block[1], data.block[0]);
1313         return data.block[0];
1314 }
1315 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1316
1317 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1318                                u8 length, const u8 *values)
1319 {
1320         union i2c_smbus_data data;
1321
1322         if (length > I2C_SMBUS_BLOCK_MAX)
1323                 length = I2C_SMBUS_BLOCK_MAX;
1324         data.block[0] = length;
1325         memcpy(&data.block[1], values, length);
1326         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1327                               I2C_SMBUS_WRITE,command,
1328                               I2C_SMBUS_BLOCK_DATA,&data);
1329 }
1330 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1331
1332 /* Returns the number of read bytes */
1333 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
1334 {
1335         union i2c_smbus_data data;
1336
1337         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1338                               I2C_SMBUS_READ,command,
1339                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
1340                 return -1;
1341
1342         memcpy(values, &data.block[1], data.block[0]);
1343         return data.block[0];
1344 }
1345 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1346
1347 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1348                                    u8 length, const u8 *values)
1349 {
1350         union i2c_smbus_data data;
1351
1352         if (length > I2C_SMBUS_BLOCK_MAX)
1353                 length = I2C_SMBUS_BLOCK_MAX;
1354         data.block[0] = length;
1355         memcpy(data.block + 1, values, length);
1356         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1357                               I2C_SMBUS_WRITE, command,
1358                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1359 }
1360 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1361
1362 /* Simulate a SMBus command using the i2c protocol
1363    No checking of parameters is done!  */
1364 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1365                                    unsigned short flags,
1366                                    char read_write, u8 command, int size,
1367                                    union i2c_smbus_data * data)
1368 {
1369         /* So we need to generate a series of msgs. In the case of writing, we
1370           need to use only one message; when reading, we need two. We initialize
1371           most things with sane defaults, to keep the code below somewhat
1372           simpler. */
1373         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1374         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1375         int num = read_write == I2C_SMBUS_READ?2:1;
1376         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1377                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1378                                 };
1379         int i;
1380         u8 partial_pec = 0;
1381
1382         msgbuf0[0] = command;
1383         switch(size) {
1384         case I2C_SMBUS_QUICK:
1385                 msg[0].len = 0;
1386                 /* Special case: The read/write field is used as data */
1387                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1388                 num = 1;
1389                 break;
1390         case I2C_SMBUS_BYTE:
1391                 if (read_write == I2C_SMBUS_READ) {
1392                         /* Special case: only a read! */
1393                         msg[0].flags = I2C_M_RD | flags;
1394                         num = 1;
1395                 }
1396                 break;
1397         case I2C_SMBUS_BYTE_DATA:
1398                 if (read_write == I2C_SMBUS_READ)
1399                         msg[1].len = 1;
1400                 else {
1401                         msg[0].len = 2;
1402                         msgbuf0[1] = data->byte;
1403                 }
1404                 break;
1405         case I2C_SMBUS_WORD_DATA:
1406                 if (read_write == I2C_SMBUS_READ)
1407                         msg[1].len = 2;
1408                 else {
1409                         msg[0].len=3;
1410                         msgbuf0[1] = data->word & 0xff;
1411                         msgbuf0[2] = data->word >> 8;
1412                 }
1413                 break;
1414         case I2C_SMBUS_PROC_CALL:
1415                 num = 2; /* Special case */
1416                 read_write = I2C_SMBUS_READ;
1417                 msg[0].len = 3;
1418                 msg[1].len = 2;
1419                 msgbuf0[1] = data->word & 0xff;
1420                 msgbuf0[2] = data->word >> 8;
1421                 break;
1422         case I2C_SMBUS_BLOCK_DATA:
1423                 if (read_write == I2C_SMBUS_READ) {
1424                         msg[1].flags |= I2C_M_RECV_LEN;
1425                         msg[1].len = 1; /* block length will be added by
1426                                            the underlying bus driver */
1427                 } else {
1428                         msg[0].len = data->block[0] + 2;
1429                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1430                                 dev_err(&adapter->dev, "smbus_access called with "
1431                                        "invalid block write size (%d)\n",
1432                                        data->block[0]);
1433                                 return -1;
1434                         }
1435                         for (i = 1; i < msg[0].len; i++)
1436                                 msgbuf0[i] = data->block[i-1];
1437                 }
1438                 break;
1439         case I2C_SMBUS_BLOCK_PROC_CALL:
1440                 num = 2; /* Another special case */
1441                 read_write = I2C_SMBUS_READ;
1442                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1443                         dev_err(&adapter->dev, "%s called with invalid "
1444                                 "block proc call size (%d)\n", __FUNCTION__,
1445                                 data->block[0]);
1446                         return -1;
1447                 }
1448                 msg[0].len = data->block[0] + 2;
1449                 for (i = 1; i < msg[0].len; i++)
1450                         msgbuf0[i] = data->block[i-1];
1451                 msg[1].flags |= I2C_M_RECV_LEN;
1452                 msg[1].len = 1; /* block length will be added by
1453                                    the underlying bus driver */
1454                 break;
1455         case I2C_SMBUS_I2C_BLOCK_DATA:
1456                 if (read_write == I2C_SMBUS_READ) {
1457                         msg[1].len = I2C_SMBUS_BLOCK_MAX;
1458                 } else {
1459                         msg[0].len = data->block[0] + 1;
1460                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1461                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1462                                        "invalid block write size (%d)\n",
1463                                        data->block[0]);
1464                                 return -1;
1465                         }
1466                         for (i = 1; i <= data->block[0]; i++)
1467                                 msgbuf0[i] = data->block[i];
1468                 }
1469                 break;
1470         default:
1471                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1472                        size);
1473                 return -1;
1474         }
1475
1476         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1477                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1478         if (i) {
1479                 /* Compute PEC if first message is a write */
1480                 if (!(msg[0].flags & I2C_M_RD)) {
1481                         if (num == 1) /* Write only */
1482                                 i2c_smbus_add_pec(&msg[0]);
1483                         else /* Write followed by read */
1484                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1485                 }
1486                 /* Ask for PEC if last message is a read */
1487                 if (msg[num-1].flags & I2C_M_RD)
1488                         msg[num-1].len++;
1489         }
1490
1491         if (i2c_transfer(adapter, msg, num) < 0)
1492                 return -1;
1493
1494         /* Check PEC if last message is a read */
1495         if (i && (msg[num-1].flags & I2C_M_RD)) {
1496                 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1497                         return -1;
1498         }
1499
1500         if (read_write == I2C_SMBUS_READ)
1501                 switch(size) {
1502                         case I2C_SMBUS_BYTE:
1503                                 data->byte = msgbuf0[0];
1504                                 break;
1505                         case I2C_SMBUS_BYTE_DATA:
1506                                 data->byte = msgbuf1[0];
1507                                 break;
1508                         case I2C_SMBUS_WORD_DATA:
1509                         case I2C_SMBUS_PROC_CALL:
1510                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1511                                 break;
1512                         case I2C_SMBUS_I2C_BLOCK_DATA:
1513                                 /* fixed at 32 for now */
1514                                 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1515                                 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1516                                         data->block[i+1] = msgbuf1[i];
1517                                 break;
1518                         case I2C_SMBUS_BLOCK_DATA:
1519                         case I2C_SMBUS_BLOCK_PROC_CALL:
1520                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1521                                         data->block[i] = msgbuf1[i];
1522                                 break;
1523                 }
1524         return 0;
1525 }
1526
1527
1528 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1529                    char read_write, u8 command, int size,
1530                    union i2c_smbus_data * data)
1531 {
1532         s32 res;
1533
1534         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1535
1536         if (adapter->algo->smbus_xfer) {
1537                 mutex_lock(&adapter->bus_lock);
1538                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1539                                                 command,size,data);
1540                 mutex_unlock(&adapter->bus_lock);
1541         } else
1542                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1543                                               command,size,data);
1544
1545         return res;
1546 }
1547 EXPORT_SYMBOL(i2c_smbus_xfer);
1548
1549 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1550 MODULE_DESCRIPTION("I2C-Bus main module");
1551 MODULE_LICENSE("GPL");