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