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