drivers/i2c/i2c-core.c

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