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