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