SAFE public projects git trees. - safe/jmp/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/platform_device.h>
  33 #include <linux/mutex.h>
  34 #include <linux/completion.h>
  35 #include <linux/hardirq.h>
  36 #include <linux/irqflags.h>
  37 #include <asm/uaccess.h>
  38
  39 #include "i2c-core.h"
  40
  41
  42 static DEFINE_MUTEX(core_lock);
  43 static DEFINE_IDR(i2c_adapter_idr);
  44
  45 #define is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)
  46
  47 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
  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         return 0;
  78 }
  79
  80 #ifdef  CONFIG_HOTPLUG
  81
  82 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
  83 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  84 {
  85         struct i2c_client       *client = to_i2c_client(dev);
  86
  87         /* by definition, legacy drivers can't hotplug */
  88         if (dev->driver)
  89                 return 0;
  90
  91         if (add_uevent_var(env, "MODALIAS=%s%s",
  92                            I2C_MODULE_PREFIX, client->name))
  93                 return -ENOMEM;
  94         dev_dbg(dev, "uevent\n");
  95         return 0;
  96 }
  97
  98 #else
  99 #define i2c_device_uevent       NULL
 100 #endif  /* CONFIG_HOTPLUG */
 101
 102 static int i2c_device_probe(struct device *dev)
 103 {
 104         struct i2c_client       *client = to_i2c_client(dev);
 105         struct i2c_driver       *driver = to_i2c_driver(dev->driver);
 106         int status;
 107
 108         if (!driver->probe || !driver->id_table)
 109                 return -ENODEV;
 110         client->driver = driver;
 111         if (!device_can_wakeup(&client->dev))
 112                 device_init_wakeup(&client->dev,
 113                                         client->flags & I2C_CLIENT_WAKE);
 114         dev_dbg(dev, "probe\n");
 115
 116         status = driver->probe(client, i2c_match_id(driver->id_table, client));
 117         if (status)
 118                 client->driver = NULL;
 119         return status;
 120 }
 121
 122 static int i2c_device_remove(struct device *dev)
 123 {
 124         struct i2c_client       *client = to_i2c_client(dev);
 125         struct i2c_driver       *driver;
 126         int                     status;
 127
 128         if (!dev->driver)
 129                 return 0;
 130
 131         driver = to_i2c_driver(dev->driver);
 132         if (driver->remove) {
 133                 dev_dbg(dev, "remove\n");
 134                 status = driver->remove(client);
 135         } else {
 136                 dev->driver = NULL;
 137                 status = 0;
 138         }
 139         if (status == 0)
 140                 client->driver = NULL;
 141         return status;
 142 }
 143
 144 static void i2c_device_shutdown(struct device *dev)
 145 {
 146         struct i2c_driver *driver;
 147
 148         if (!dev->driver)
 149                 return;
 150         driver = to_i2c_driver(dev->driver);
 151         if (driver->shutdown)
 152                 driver->shutdown(to_i2c_client(dev));
 153 }
 154
 155 static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
 156 {
 157         struct i2c_driver *driver;
 158
 159         if (!dev->driver)
 160                 return 0;
 161         driver = to_i2c_driver(dev->driver);
 162         if (!driver->suspend)
 163                 return 0;
 164         return driver->suspend(to_i2c_client(dev), mesg);
 165 }
 166
 167 static int i2c_device_resume(struct device *dev)
 168 {
 169         struct i2c_driver *driver;
 170
 171         if (!dev->driver)
 172                 return 0;
 173         driver = to_i2c_driver(dev->driver);
 174         if (!driver->resume)
 175                 return 0;
 176         return driver->resume(to_i2c_client(dev));
 177 }
 178
 179 static void i2c_client_release(struct device *dev)
 180 {
 181         struct i2c_client *client = to_i2c_client(dev);
 182         complete(&client->released);
 183 }
 184
 185 static void i2c_client_dev_release(struct device *dev)
 186 {
 187         kfree(to_i2c_client(dev));
 188 }
 189
 190 static ssize_t
 191 show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
 192 {
 193         struct i2c_client *client = to_i2c_client(dev);
 194         return sprintf(buf, "%s\n", client->name);
 195 }
 196
 197 static ssize_t
 198 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 199 {
 200         struct i2c_client *client = to_i2c_client(dev);
 201         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
 202 }
 203
 204 static struct device_attribute i2c_dev_attrs[] = {
 205         __ATTR(name, S_IRUGO, show_client_name, NULL),
 206         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
 207         __ATTR(modalias, S_IRUGO, show_modalias, NULL),
 208         { },
 209 };
 210
 211 struct bus_type i2c_bus_type = {
 212         .name           = "i2c",
 213         .dev_attrs      = i2c_dev_attrs,
 214         .match          = i2c_device_match,
 215         .uevent         = i2c_device_uevent,
 216         .probe          = i2c_device_probe,
 217         .remove         = i2c_device_remove,
 218         .shutdown       = i2c_device_shutdown,
 219         .suspend        = i2c_device_suspend,
 220         .resume         = i2c_device_resume,
 221 };
 222 EXPORT_SYMBOL_GPL(i2c_bus_type);
 223
 224
 225 /**
 226  * i2c_verify_client - return parameter as i2c_client, or NULL
 227  * @dev: device, probably from some driver model iterator
 228  *
 229  * When traversing the driver model tree, perhaps using driver model
 230  * iterators like @device_for_each_child(), you can't assume very much
 231  * about the nodes you find.  Use this function to avoid oopses caused
 232  * by wrongly treating some non-I2C device as an i2c_client.
 233  */
 234 struct i2c_client *i2c_verify_client(struct device *dev)
 235 {
 236         return (dev->bus == &i2c_bus_type)
 237                         ? to_i2c_client(dev)
 238                         : NULL;
 239 }
 240 EXPORT_SYMBOL(i2c_verify_client);
 241
 242
 243 /**
 244  * i2c_new_device - instantiate an i2c device for use with a new style driver
 245  * @adap: the adapter managing the device
 246  * @info: describes one I2C device; bus_num is ignored
 247  * Context: can sleep
 248  *
 249  * Create a device to work with a new style i2c driver, where binding is
 250  * handled through driver model probe()/remove() methods.  This call is not
 251  * appropriate for use by mainboad initialization logic, which usually runs
 252  * during an arch_initcall() long before any i2c_adapter could exist.
 253  *
 254  * This returns the new i2c client, which may be saved for later use with
 255  * i2c_unregister_device(); or NULL to indicate an error.
 256  */
 257 struct i2c_client *
 258 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 259 {
 260         struct i2c_client       *client;
 261         int                     status;
 262
 263         client = kzalloc(sizeof *client, GFP_KERNEL);
 264         if (!client)
 265                 return NULL;
 266
 267         client->adapter = adap;
 268
 269         client->dev.platform_data = info->platform_data;
 270
 271         if (info->archdata)
 272                 client->dev.archdata = *info->archdata;
 273
 274         client->flags = info->flags;
 275         client->addr = info->addr;
 276         client->irq = info->irq;
 277
 278         strlcpy(client->name, info->type, sizeof(client->name));
 279
 280         /* a new style driver may be bound to this device when we
 281          * return from this function, or any later moment (e.g. maybe
 282          * hotplugging will load the driver module).  and the device
 283          * refcount model is the standard driver model one.
 284          */
 285         status = i2c_attach_client(client);
 286         if (status < 0) {
 287                 kfree(client);
 288                 client = NULL;
 289         }
 290         return client;
 291 }
 292 EXPORT_SYMBOL_GPL(i2c_new_device);
 293
 294
 295 /**
 296  * i2c_unregister_device - reverse effect of i2c_new_device()
 297  * @client: value returned from i2c_new_device()
 298  * Context: can sleep
 299  */
 300 void i2c_unregister_device(struct i2c_client *client)
 301 {
 302         struct i2c_adapter      *adapter = client->adapter;
 303         struct i2c_driver       *driver = client->driver;
 304
 305         if (driver && !is_newstyle_driver(driver)) {
 306                 dev_err(&client->dev, "can't unregister devices "
 307                         "with legacy drivers\n");
 308                 WARN_ON(1);
 309                 return;
 310         }
 311
 312         if (adapter->client_unregister) {
 313                 if (adapter->client_unregister(client)) {
 314                         dev_warn(&client->dev,
 315                                  "client_unregister [%s] failed\n",
 316                                  client->name);
 317                 }
 318         }
 319
 320         mutex_lock(&adapter->clist_lock);
 321         list_del(&client->list);
 322         mutex_unlock(&adapter->clist_lock);
 323
 324         device_unregister(&client->dev);
 325 }
 326 EXPORT_SYMBOL_GPL(i2c_unregister_device);
 327
 328
 329 static const struct i2c_device_id dummy_id[] = {
 330         { "dummy", 0 },
 331         { },
 332 };
 333
 334 static int dummy_probe(struct i2c_client *client,
 335                        const struct i2c_device_id *id)
 336 {
 337         return 0;
 338 }
 339
 340 static int dummy_remove(struct i2c_client *client)
 341 {
 342         return 0;
 343 }
 344
 345 static struct i2c_driver dummy_driver = {
 346         .driver.name    = "dummy",
 347         .probe          = dummy_probe,
 348         .remove         = dummy_remove,
 349         .id_table       = dummy_id,
 350 };
 351
 352 /**
 353  * i2c_new_dummy - return a new i2c device bound to a dummy driver
 354  * @adapter: the adapter managing the device
 355  * @address: seven bit address to be used
 356  * Context: can sleep
 357  *
 358  * This returns an I2C client bound to the "dummy" driver, intended for use
 359  * with devices that consume multiple addresses.  Examples of such chips
 360  * include various EEPROMS (like 24c04 and 24c08 models).
 361  *
 362  * These dummy devices have two main uses.  First, most I2C and SMBus calls
 363  * except i2c_transfer() need a client handle; the dummy will be that handle.
 364  * And second, this prevents the specified address from being bound to a
 365  * different driver.
 366  *
 367  * This returns the new i2c client, which should be saved for later use with
 368  * i2c_unregister_device(); or NULL to indicate an error.
 369  */
 370 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
 371 {
 372         struct i2c_board_info info = {
 373                 I2C_BOARD_INFO("dummy", address),
 374         };
 375
 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                         dev_err(&adapter->dev,
 418                                 "Can't create device at 0x%02x\n",
 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         /* Detect supported devices on that bus, and instantiate them */
 430         i2c_detect(adap, driver);
 431
 432         /* Let legacy drivers scan this bus for matching devices */
 433         if (driver->attach_adapter) {
 434                 /* We ignore the return code; if it fails, too bad */
 435                 driver->attach_adapter(adap);
 436         }
 437         return 0;
 438 }
 439
 440 static int i2c_register_adapter(struct i2c_adapter *adap)
 441 {
 442         int res = 0, dummy;
 443
 444         /* Can't register until after driver model init */
 445         if (unlikely(WARN_ON(!i2c_bus_type.p)))
 446                 return -EAGAIN;
 447
 448         mutex_init(&adap->bus_lock);
 449         mutex_init(&adap->clist_lock);
 450         INIT_LIST_HEAD(&adap->clients);
 451
 452         mutex_lock(&core_lock);
 453
 454         /* Add the adapter to the driver core.
 455          * If the parent pointer is not set up,
 456          * we add this adapter to the host bus.
 457          */
 458         if (adap->dev.parent == NULL) {
 459                 adap->dev.parent = &platform_bus;
 460                 pr_debug("I2C adapter driver [%s] forgot to specify "
 461                          "physical device\n", adap->name);
 462         }
 463
 464         /* Set default timeout to 1 second if not already set */
 465         if (adap->timeout == 0)
 466                 adap->timeout = HZ;
 467
 468         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
 469         adap->dev.release = &i2c_adapter_dev_release;
 470         adap->dev.class = &i2c_adapter_class;
 471         res = device_register(&adap->dev);
 472         if (res)
 473                 goto out_list;
 474
 475         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 476
 477         /* create pre-declared device nodes for new-style drivers */
 478         if (adap->nr < __i2c_first_dynamic_bus_num)
 479                 i2c_scan_static_board_info(adap);
 480
 481         /* Notify drivers */
 482         dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
 483                                  i2c_do_add_adapter);
 484
 485 out_unlock:
 486         mutex_unlock(&core_lock);
 487         return res;
 488
 489 out_list:
 490         idr_remove(&i2c_adapter_idr, adap->nr);
 491         goto out_unlock;
 492 }
 493
 494 /**
 495  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 496  * @adapter: the adapter to add
 497  * Context: can sleep
 498  *
 499  * This routine is used to declare an I2C adapter when its bus number
 500  * doesn't matter.  Examples: for I2C adapters dynamically added by
 501  * USB links or PCI plugin cards.
 502  *
 503  * When this returns zero, a new bus number was allocated and stored
 504  * in adap->nr, and the specified adapter became available for clients.
 505  * Otherwise, a negative errno value is returned.
 506  */
 507 int i2c_add_adapter(struct i2c_adapter *adapter)
 508 {
 509         int     id, res = 0;
 510
 511 retry:
 512         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 513                 return -ENOMEM;
 514
 515         mutex_lock(&core_lock);
 516         /* "above" here means "above or equal to", sigh */
 517         res = idr_get_new_above(&i2c_adapter_idr, adapter,
 518                                 __i2c_first_dynamic_bus_num, &id);
 519         mutex_unlock(&core_lock);
 520
 521         if (res < 0) {
 522                 if (res == -EAGAIN)
 523                         goto retry;
 524                 return res;
 525         }
 526
 527         adapter->nr = id;
 528         return i2c_register_adapter(adapter);
 529 }
 530 EXPORT_SYMBOL(i2c_add_adapter);
 531
 532 /**
 533  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 534  * @adap: the adapter to register (with adap->nr initialized)
 535  * Context: can sleep
 536  *
 537  * This routine is used to declare an I2C adapter when its bus number
 538  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 539  * or otherwise built in to the system's mainboard, and where i2c_board_info
 540  * is used to properly configure I2C devices.
 541  *
 542  * If no devices have pre-been declared for this bus, then be sure to
 543  * register the adapter before any dynamically allocated ones.  Otherwise
 544  * the required bus ID may not be available.
 545  *
 546  * When this returns zero, the specified adapter became available for
 547  * clients using the bus number provided in adap->nr.  Also, the table
 548  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 549  * and the appropriate driver model device nodes are created.  Otherwise, a
 550  * negative errno value is returned.
 551  */
 552 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 553 {
 554         int     id;
 555         int     status;
 556
 557         if (adap->nr & ~MAX_ID_MASK)
 558                 return -EINVAL;
 559
 560 retry:
 561         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 562                 return -ENOMEM;
 563
 564         mutex_lock(&core_lock);
 565         /* "above" here means "above or equal to", sigh;
 566          * we need the "equal to" result to force the result
 567          */
 568         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 569         if (status == 0 && id != adap->nr) {
 570                 status = -EBUSY;
 571                 idr_remove(&i2c_adapter_idr, id);
 572         }
 573         mutex_unlock(&core_lock);
 574         if (status == -EAGAIN)
 575                 goto retry;
 576
 577         if (status == 0)
 578                 status = i2c_register_adapter(adap);
 579         return status;
 580 }
 581 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
 582
 583 static int i2c_do_del_adapter(struct device_driver *d, void *data)
 584 {
 585         struct i2c_driver *driver = to_i2c_driver(d);
 586         struct i2c_adapter *adapter = data;
 587         struct i2c_client *client, *_n;
 588         int res;
 589
 590         /* Remove the devices we created ourselves as the result of hardware
 591          * probing (using a driver's detect method) */
 592         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 593                 if (client->adapter == adapter) {
 594                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 595                                 client->name, client->addr);
 596                         list_del(&client->detected);
 597                         i2c_unregister_device(client);
 598                 }
 599         }
 600
 601         if (!driver->detach_adapter)
 602                 return 0;
 603         res = driver->detach_adapter(adapter);
 604         if (res)
 605                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
 606                         "for driver [%s]\n", res, driver->driver.name);
 607         return res;
 608 }
 609
 610 /**
 611  * i2c_del_adapter - unregister I2C adapter
 612  * @adap: the adapter being unregistered
 613  * Context: can sleep
 614  *
 615  * This unregisters an I2C adapter which was previously registered
 616  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
 617  */
 618 int i2c_del_adapter(struct i2c_adapter *adap)
 619 {
 620         struct i2c_client *client, *_n;
 621         int res = 0;
 622
 623         mutex_lock(&core_lock);
 624
 625         /* First make sure that this adapter was ever added */
 626         if (idr_find(&i2c_adapter_idr, adap->nr) != adap) {
 627                 pr_debug("i2c-core: attempting to delete unregistered "
 628                          "adapter [%s]\n", adap->name);
 629                 res = -EINVAL;
 630                 goto out_unlock;
 631         }
 632
 633         /* Tell drivers about this removal */
 634         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
 635                                i2c_do_del_adapter);
 636         if (res)
 637                 goto out_unlock;
 638
 639         /* detach any active clients. This must be done first, because
 640          * it can fail; in which case we give up. */
 641         list_for_each_entry_safe_reverse(client, _n, &adap->clients, list) {
 642                 struct i2c_driver       *driver;
 643
 644                 driver = client->driver;
 645
 646                 /* new style, follow standard driver model */
 647                 if (!driver || is_newstyle_driver(driver)) {
 648                         i2c_unregister_device(client);
 649                         continue;
 650                 }
 651
 652                 /* legacy drivers create and remove clients themselves */
 653                 if ((res = driver->detach_client(client))) {
 654                         dev_err(&adap->dev, "detach_client failed for client "
 655                                 "[%s] at address 0x%02x\n", client->name,
 656                                 client->addr);
 657                         goto out_unlock;
 658                 }
 659         }
 660
 661         /* clean up the sysfs representation */
 662         init_completion(&adap->dev_released);
 663         device_unregister(&adap->dev);
 664
 665         /* wait for sysfs to drop all references */
 666         wait_for_completion(&adap->dev_released);
 667
 668         /* free bus id */
 669         idr_remove(&i2c_adapter_idr, adap->nr);
 670
 671         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 672
 673         /* Clear the device structure in case this adapter is ever going to be
 674            added again */
 675         memset(&adap->dev, 0, sizeof(adap->dev));
 676
 677  out_unlock:
 678         mutex_unlock(&core_lock);
 679         return res;
 680 }
 681 EXPORT_SYMBOL(i2c_del_adapter);
 682
 683
 684 /* ------------------------------------------------------------------------- */
 685
 686 static int __attach_adapter(struct device *dev, void *data)
 687 {
 688         struct i2c_adapter *adapter = to_i2c_adapter(dev);
 689         struct i2c_driver *driver = data;
 690
 691         i2c_detect(adapter, driver);
 692
 693         /* Legacy drivers scan i2c busses directly */
 694         if (driver->attach_adapter)
 695                 driver->attach_adapter(adapter);
 696
 697         return 0;
 698 }
 699
 700 /*
 701  * An i2c_driver is used with one or more i2c_client (device) nodes to access
 702  * i2c slave chips, on a bus instance associated with some i2c_adapter.  There
 703  * are two models for binding the driver to its device:  "new style" drivers
 704  * follow the standard Linux driver model and just respond to probe() calls
 705  * issued if the driver core sees they match(); "legacy" drivers create device
 706  * nodes themselves.
 707  */
 708
 709 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 710 {
 711         int res;
 712
 713         /* Can't register until after driver model init */
 714         if (unlikely(WARN_ON(!i2c_bus_type.p)))
 715                 return -EAGAIN;
 716
 717         /* new style driver methods can't mix with legacy ones */
 718         if (is_newstyle_driver(driver)) {
 719                 if (driver->attach_adapter || driver->detach_adapter
 720                                 || driver->detach_client) {
 721                         printk(KERN_WARNING
 722                                         "i2c-core: driver [%s] is confused\n",
 723                                         driver->driver.name);
 724                         return -EINVAL;
 725                 }
 726         }
 727
 728         /* add the driver to the list of i2c drivers in the driver core */
 729         driver->driver.owner = owner;
 730         driver->driver.bus = &i2c_bus_type;
 731
 732         /* for new style drivers, when registration returns the driver core
 733          * will have called probe() for all matching-but-unbound devices.
 734          */
 735         res = driver_register(&driver->driver);
 736         if (res)
 737                 return res;
 738
 739         mutex_lock(&core_lock);
 740
 741         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 742
 743         INIT_LIST_HEAD(&driver->clients);
 744         /* Walk the adapters that are already present */
 745         class_for_each_device(&i2c_adapter_class, NULL, driver,
 746                               __attach_adapter);
 747
 748         mutex_unlock(&core_lock);
 749         return 0;
 750 }
 751 EXPORT_SYMBOL(i2c_register_driver);
 752
 753 static int __detach_adapter(struct device *dev, void *data)
 754 {
 755         struct i2c_adapter *adapter = to_i2c_adapter(dev);
 756         struct i2c_driver *driver = data;
 757         struct i2c_client *client, *_n;
 758
 759         /* Remove the devices we created ourselves as the result of hardware
 760          * probing (using a driver's detect method) */
 761         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 762                 dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 763                         client->name, client->addr);
 764                 list_del(&client->detected);
 765                 i2c_unregister_device(client);
 766         }
 767
 768         if (is_newstyle_driver(driver))
 769                 return 0;
 770
 771         /* Have a look at each adapter, if clients of this driver are still
 772          * attached. If so, detach them to be able to kill the driver
 773          * afterwards.
 774          */
 775         if (driver->detach_adapter) {
 776                 if (driver->detach_adapter(adapter))
 777                         dev_err(&adapter->dev,
 778                                 "detach_adapter failed for driver [%s]\n",
 779                                 driver->driver.name);
 780         } else {
 781                 struct i2c_client *client, *_n;
 782
 783                 list_for_each_entry_safe(client, _n, &adapter->clients, list) {
 784                         if (client->driver != driver)
 785                                 continue;
 786                         dev_dbg(&adapter->dev,
 787                                 "detaching client [%s] at 0x%02x\n",
 788                                 client->name, client->addr);
 789                         if (driver->detach_client(client))
 790                                 dev_err(&adapter->dev, "detach_client "
 791                                         "failed for client [%s] at 0x%02x\n",
 792                                         client->name, client->addr);
 793                 }
 794         }
 795
 796         return 0;
 797 }
 798
 799 /**
 800  * i2c_del_driver - unregister I2C driver
 801  * @driver: the driver being unregistered
 802  * Context: can sleep
 803  */
 804 void i2c_del_driver(struct i2c_driver *driver)
 805 {
 806         mutex_lock(&core_lock);
 807
 808         class_for_each_device(&i2c_adapter_class, NULL, driver,
 809                               __detach_adapter);
 810
 811         driver_unregister(&driver->driver);
 812         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
 813
 814         mutex_unlock(&core_lock);
 815 }
 816 EXPORT_SYMBOL(i2c_del_driver);
 817
 818 /* ------------------------------------------------------------------------- */
 819
 820 static int __i2c_check_addr(struct device *dev, void *addrp)
 821 {
 822         struct i2c_client       *client = i2c_verify_client(dev);
 823         int                     addr = *(int *)addrp;
 824
 825         if (client && client->addr == addr)
 826                 return -EBUSY;
 827         return 0;
 828 }
 829
 830 static int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 831 {
 832         return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
 833 }
 834
 835 int i2c_attach_client(struct i2c_client *client)
 836 {
 837         struct i2c_adapter *adapter = client->adapter;
 838         int res;
 839
 840         /* Check for address business */
 841         res = i2c_check_addr(adapter, client->addr);
 842         if (res)
 843                 return res;
 844
 845         client->dev.parent = &client->adapter->dev;
 846         client->dev.bus = &i2c_bus_type;
 847
 848         if (client->driver)
 849                 client->dev.driver = &client->driver->driver;
 850
 851         if (client->driver && !is_newstyle_driver(client->driver)) {
 852                 client->dev.release = i2c_client_release;
 853                 dev_set_uevent_suppress(&client->dev, 1);
 854         } else
 855                 client->dev.release = i2c_client_dev_release;
 856
 857         dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adapter),
 858                      client->addr);
 859         res = device_register(&client->dev);
 860         if (res)
 861                 goto out_err;
 862
 863         mutex_lock(&adapter->clist_lock);
 864         list_add_tail(&client->list, &adapter->clients);
 865         mutex_unlock(&adapter->clist_lock);
 866
 867         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
 868                 client->name, dev_name(&client->dev));
 869
 870         if (adapter->client_register)  {
 871                 if (adapter->client_register(client)) {
 872                         dev_dbg(&adapter->dev, "client_register "
 873                                 "failed for client [%s] at 0x%02x\n",
 874                                 client->name, client->addr);
 875                 }
 876         }
 877
 878         return 0;
 879
 880 out_err:
 881         dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
 882                 "(%d)\n", client->name, client->addr, res);
 883         return res;
 884 }
 885 EXPORT_SYMBOL(i2c_attach_client);
 886
 887 int i2c_detach_client(struct i2c_client *client)
 888 {
 889         struct i2c_adapter *adapter = client->adapter;
 890         int res = 0;
 891
 892         if (adapter->client_unregister)  {
 893                 res = adapter->client_unregister(client);
 894                 if (res) {
 895                         dev_err(&client->dev,
 896                                 "client_unregister [%s] failed, "
 897                                 "client not detached\n", client->name);
 898                         goto out;
 899                 }
 900         }
 901
 902         mutex_lock(&adapter->clist_lock);
 903         list_del(&client->list);
 904         mutex_unlock(&adapter->clist_lock);
 905
 906         init_completion(&client->released);
 907         device_unregister(&client->dev);
 908         wait_for_completion(&client->released);
 909
 910  out:
 911         return res;
 912 }
 913 EXPORT_SYMBOL(i2c_detach_client);
 914
 915 /**
 916  * i2c_use_client - increments the reference count of the i2c client structure
 917  * @client: the client being referenced
 918  *
 919  * Each live reference to a client should be refcounted. The driver model does
 920  * that automatically as part of driver binding, so that most drivers don't
 921  * need to do this explicitly: they hold a reference until they're unbound
 922  * from the device.
 923  *
 924  * A pointer to the client with the incremented reference counter is returned.
 925  */
 926 struct i2c_client *i2c_use_client(struct i2c_client *client)
 927 {
 928         if (client && get_device(&client->dev))
 929                 return client;
 930         return NULL;
 931 }
 932 EXPORT_SYMBOL(i2c_use_client);
 933
 934 /**
 935  * i2c_release_client - release a use of the i2c client structure
 936  * @client: the client being no longer referenced
 937  *
 938  * Must be called when a user of a client is finished with it.
 939  */
 940 void i2c_release_client(struct i2c_client *client)
 941 {
 942         if (client)
 943                 put_device(&client->dev);
 944 }
 945 EXPORT_SYMBOL(i2c_release_client);
 946
 947 struct i2c_cmd_arg {
 948         unsigned        cmd;
 949         void            *arg;
 950 };
 951
 952 static int i2c_cmd(struct device *dev, void *_arg)
 953 {
 954         struct i2c_client       *client = i2c_verify_client(dev);
 955         struct i2c_cmd_arg      *arg = _arg;
 956
 957         if (client && client->driver && client->driver->command)
 958                 client->driver->command(client, arg->cmd, arg->arg);
 959         return 0;
 960 }
 961
 962 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 963 {
 964         struct i2c_cmd_arg      cmd_arg;
 965
 966         cmd_arg.cmd = cmd;
 967         cmd_arg.arg = arg;
 968         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
 969 }
 970 EXPORT_SYMBOL(i2c_clients_command);
 971
 972 static int __init i2c_init(void)
 973 {
 974         int retval;
 975
 976         retval = bus_register(&i2c_bus_type);
 977         if (retval)
 978                 return retval;
 979         retval = class_register(&i2c_adapter_class);
 980         if (retval)
 981                 goto bus_err;
 982         retval = i2c_add_driver(&dummy_driver);
 983         if (retval)
 984                 goto class_err;
 985         return 0;
 986
 987 class_err:
 988         class_unregister(&i2c_adapter_class);
 989 bus_err:
 990         bus_unregister(&i2c_bus_type);
 991         return retval;
 992 }
 993
 994 static void __exit i2c_exit(void)
 995 {
 996         i2c_del_driver(&dummy_driver);
 997         class_unregister(&i2c_adapter_class);
 998         bus_unregister(&i2c_bus_type);
 999 }
1000
1001 /* We must initialize early, because some subsystems register i2c drivers
1002  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1003  */
1004 postcore_initcall(i2c_init);
1005 module_exit(i2c_exit);
1006
1007 /* ----------------------------------------------------
1008  * the functional interface to the i2c busses.
1009  * ----------------------------------------------------
1010  */
1011
1012 /**
1013  * i2c_transfer - execute a single or combined I2C message
1014  * @adap: Handle to I2C bus
1015  * @msgs: One or more messages to execute before STOP is issued to
1016  *      terminate the operation; each message begins with a START.
1017  * @num: Number of messages to be executed.
1018  *
1019  * Returns negative errno, else the number of messages executed.
1020  *
1021  * Note that there is no requirement that each message be sent to
1022  * the same slave address, although that is the most common model.
1023  */
1024 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1025 {
1026         int ret;
1027
1028         /* REVISIT the fault reporting model here is weak:
1029          *
1030          *  - When we get an error after receiving N bytes from a slave,
1031          *    there is no way to report "N".
1032          *
1033          *  - When we get a NAK after transmitting N bytes to a slave,
1034          *    there is no way to report "N" ... or to let the master
1035          *    continue executing the rest of this combined message, if
1036          *    that's the appropriate response.
1037          *
1038          *  - When for example "num" is two and we successfully complete
1039          *    the first message but get an error part way through the
1040          *    second, it's unclear whether that should be reported as
1041          *    one (discarding status on the second message) or errno
1042          *    (discarding status on the first one).
1043          */
1044
1045         if (adap->algo->master_xfer) {
1046 #ifdef DEBUG
1047                 for (ret = 0; ret < num; ret++) {
1048                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1049                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1050                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1051                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1052                 }
1053 #endif
1054
1055                 if (in_atomic() || irqs_disabled()) {
1056                         ret = mutex_trylock(&adap->bus_lock);
1057                         if (!ret)
1058                                 /* I2C activity is ongoing. */
1059                                 return -EAGAIN;
1060                 } else {
1061                         mutex_lock_nested(&adap->bus_lock, adap->level);
1062                 }
1063
1064                 ret = adap->algo->master_xfer(adap,msgs,num);
1065                 mutex_unlock(&adap->bus_lock);
1066
1067                 return ret;
1068         } else {
1069                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1070                 return -EOPNOTSUPP;
1071         }
1072 }
1073 EXPORT_SYMBOL(i2c_transfer);
1074
1075 /**
1076  * i2c_master_send - issue a single I2C message in master transmit mode
1077  * @client: Handle to slave device
1078  * @buf: Data that will be written to the slave
1079  * @count: How many bytes to write
1080  *
1081  * Returns negative errno, or else the number of bytes written.
1082  */
1083 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
1084 {
1085         int ret;
1086         struct i2c_adapter *adap=client->adapter;
1087         struct i2c_msg msg;
1088
1089         msg.addr = client->addr;
1090         msg.flags = client->flags & I2C_M_TEN;
1091         msg.len = count;
1092         msg.buf = (char *)buf;
1093
1094         ret = i2c_transfer(adap, &msg, 1);
1095
1096         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1097            transmitted, else error code. */
1098         return (ret == 1) ? count : ret;
1099 }
1100 EXPORT_SYMBOL(i2c_master_send);
1101
1102 /**
1103  * i2c_master_recv - issue a single I2C message in master receive mode
1104  * @client: Handle to slave device
1105  * @buf: Where to store data read from slave
1106  * @count: How many bytes to read
1107  *
1108  * Returns negative errno, or else the number of bytes read.
1109  */
1110 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
1111 {
1112         struct i2c_adapter *adap=client->adapter;
1113         struct i2c_msg msg;
1114         int ret;
1115
1116         msg.addr = client->addr;
1117         msg.flags = client->flags & I2C_M_TEN;
1118         msg.flags |= I2C_M_RD;
1119         msg.len = count;
1120         msg.buf = buf;
1121
1122         ret = i2c_transfer(adap, &msg, 1);
1123
1124         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1125            transmitted, else error code. */
1126         return (ret == 1) ? count : ret;
1127 }
1128 EXPORT_SYMBOL(i2c_master_recv);
1129
1130 /* ----------------------------------------------------
1131  * the i2c address scanning function
1132  * Will not work for 10-bit addresses!
1133  * ----------------------------------------------------
1134  */
1135 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
1136                              int (*found_proc) (struct i2c_adapter *, int, int))
1137 {
1138         int err;
1139
1140         /* Make sure the address is valid */
1141         if (addr < 0x03 || addr > 0x77) {
1142                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1143                          addr);
1144                 return -EINVAL;
1145         }
1146
1147         /* Skip if already in use */
1148         if (i2c_check_addr(adapter, addr))
1149                 return 0;
1150
1151         /* Make sure there is something at this address, unless forced */
1152         if (kind < 0) {
1153                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1154                                    I2C_SMBUS_QUICK, NULL) < 0)
1155                         return 0;
1156
1157                 /* prevent 24RF08 corruption */
1158                 if ((addr & ~0x0f) == 0x50)
1159                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1160                                        I2C_SMBUS_QUICK, NULL);
1161         }
1162
1163         /* Finally call the custom detection function */
1164         err = found_proc(adapter, addr, kind);
1165         /* -ENODEV can be returned if there is a chip at the given address
1166            but it isn't supported by this chip driver. We catch it here as
1167            this isn't an error. */
1168         if (err == -ENODEV)
1169                 err = 0;
1170
1171         if (err)
1172                 dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
1173                          addr, err);
1174         return err;
1175 }
1176
1177 int i2c_probe(struct i2c_adapter *adapter,
1178               const struct i2c_client_address_data *address_data,
1179               int (*found_proc) (struct i2c_adapter *, int, int))
1180 {
1181         int i, err;
1182         int adap_id = i2c_adapter_id(adapter);
1183
1184         /* Force entries are done first, and are not affected by ignore
1185            entries */
1186         if (address_data->forces) {
1187                 const unsigned short * const *forces = address_data->forces;
1188                 int kind;
1189
1190                 for (kind = 0; forces[kind]; kind++) {
1191                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1192                              i += 2) {
1193                                 if (forces[kind][i] == adap_id
1194                                  || forces[kind][i] == ANY_I2C_BUS) {
1195                                         dev_dbg(&adapter->dev, "found force "
1196                                                 "parameter for adapter %d, "
1197                                                 "addr 0x%02x, kind %d\n",
1198                                                 adap_id, forces[kind][i + 1],
1199                                                 kind);
1200                                         err = i2c_probe_address(adapter,
1201                                                 forces[kind][i + 1],
1202                                                 kind, found_proc);
1203                                         if (err)
1204                                                 return err;
1205                                 }
1206                         }
1207                 }
1208         }
1209
1210         /* Stop here if we can't use SMBUS_QUICK */
1211         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1212                 if (address_data->probe[0] == I2C_CLIENT_END
1213                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1214                         return 0;
1215
1216                 dev_dbg(&adapter->dev, "SMBus Quick command not supported, "
1217                         "can't probe for chips\n");
1218                 return -EOPNOTSUPP;
1219         }
1220
1221         /* Probe entries are done second, and are not affected by ignore
1222            entries either */
1223         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1224                 if (address_data->probe[i] == adap_id
1225                  || address_data->probe[i] == ANY_I2C_BUS) {
1226                         dev_dbg(&adapter->dev, "found probe parameter for "
1227                                 "adapter %d, addr 0x%02x\n", adap_id,
1228                                 address_data->probe[i + 1]);
1229                         err = i2c_probe_address(adapter,
1230                                                 address_data->probe[i + 1],
1231                                                 -1, found_proc);
1232                         if (err)
1233                                 return err;
1234                 }
1235         }
1236
1237         /* Normal entries are done last, unless shadowed by an ignore entry */
1238         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1239                 int j, ignore;
1240
1241                 ignore = 0;
1242                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1243                      j += 2) {
1244                         if ((address_data->ignore[j] == adap_id ||
1245                              address_data->ignore[j] == ANY_I2C_BUS)
1246                          && address_data->ignore[j + 1]
1247                             == address_data->normal_i2c[i]) {
1248                                 dev_dbg(&adapter->dev, "found ignore "
1249                                         "parameter for adapter %d, "
1250                                         "addr 0x%02x\n", adap_id,
1251                                         address_data->ignore[j + 1]);
1252                                 ignore = 1;
1253                                 break;
1254                         }
1255                 }
1256                 if (ignore)
1257                         continue;
1258
1259                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1260                         "addr 0x%02x\n", adap_id,
1261                         address_data->normal_i2c[i]);
1262                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
1263                                         -1, found_proc);
1264                 if (err)
1265                         return err;
1266         }
1267
1268         return 0;
1269 }
1270 EXPORT_SYMBOL(i2c_probe);
1271
1272 /* Separate detection function for new-style drivers */
1273 static int i2c_detect_address(struct i2c_client *temp_client, int kind,
1274                               struct i2c_driver *driver)
1275 {
1276         struct i2c_board_info info;
1277         struct i2c_adapter *adapter = temp_client->adapter;
1278         int addr = temp_client->addr;
1279         int err;
1280
1281         /* Make sure the address is valid */
1282         if (addr < 0x03 || addr > 0x77) {
1283                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1284                          addr);
1285                 return -EINVAL;
1286         }
1287
1288         /* Skip if already in use */
1289         if (i2c_check_addr(adapter, addr))
1290                 return 0;
1291
1292         /* Make sure there is something at this address, unless forced */
1293         if (kind < 0) {
1294                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1295                                    I2C_SMBUS_QUICK, NULL) < 0)
1296                         return 0;
1297
1298                 /* prevent 24RF08 corruption */
1299                 if ((addr & ~0x0f) == 0x50)
1300                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
1301                                        I2C_SMBUS_QUICK, NULL);
1302         }
1303
1304         /* Finally call the custom detection function */
1305         memset(&info, 0, sizeof(struct i2c_board_info));
1306         info.addr = addr;
1307         err = driver->detect(temp_client, kind, &info);
1308         if (err) {
1309                 /* -ENODEV is returned if the detection fails. We catch it
1310                    here as this isn't an error. */
1311                 return err == -ENODEV ? 0 : err;
1312         }
1313
1314         /* Consistency check */
1315         if (info.type[0] == '\0') {
1316                 dev_err(&adapter->dev, "%s detection function provided "
1317                         "no name for 0x%x\n", driver->driver.name,
1318                         addr);
1319         } else {
1320                 struct i2c_client *client;
1321
1322                 /* Detection succeeded, instantiate the device */
1323                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1324                         info.type, info.addr);
1325                 client = i2c_new_device(adapter, &info);
1326                 if (client)
1327                         list_add_tail(&client->detected, &driver->clients);
1328                 else
1329                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1330                                 info.type, info.addr);
1331         }
1332         return 0;
1333 }
1334
1335 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1336 {
1337         const struct i2c_client_address_data *address_data;
1338         struct i2c_client *temp_client;
1339         int i, err = 0;
1340         int adap_id = i2c_adapter_id(adapter);
1341
1342         address_data = driver->address_data;
1343         if (!driver->detect || !address_data)
1344                 return 0;
1345
1346         /* Set up a temporary client to help detect callback */
1347         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1348         if (!temp_client)
1349                 return -ENOMEM;
1350         temp_client->adapter = adapter;
1351
1352         /* Force entries are done first, and are not affected by ignore
1353            entries */
1354         if (address_data->forces) {
1355                 const unsigned short * const *forces = address_data->forces;
1356                 int kind;
1357
1358                 for (kind = 0; forces[kind]; kind++) {
1359                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
1360                              i += 2) {
1361                                 if (forces[kind][i] == adap_id
1362                                  || forces[kind][i] == ANY_I2C_BUS) {
1363                                         dev_dbg(&adapter->dev, "found force "
1364                                                 "parameter for adapter %d, "
1365                                                 "addr 0x%02x, kind %d\n",
1366                                                 adap_id, forces[kind][i + 1],
1367                                                 kind);
1368                                         temp_client->addr = forces[kind][i + 1];
1369                                         err = i2c_detect_address(temp_client,
1370                                                 kind, driver);
1371                                         if (err)
1372                                                 goto exit_free;
1373                                 }
1374                         }
1375                 }
1376         }
1377
1378         /* Stop here if the classes do not match */
1379         if (!(adapter->class & driver->class))
1380                 goto exit_free;
1381
1382         /* Stop here if we can't use SMBUS_QUICK */
1383         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
1384                 if (address_data->probe[0] == I2C_CLIENT_END
1385                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
1386                         goto exit_free;
1387
1388                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
1389                          "can't probe for chips\n");
1390                 err = -EOPNOTSUPP;
1391                 goto exit_free;
1392         }
1393
1394         /* Probe entries are done second, and are not affected by ignore
1395            entries either */
1396         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
1397                 if (address_data->probe[i] == adap_id
1398                  || address_data->probe[i] == ANY_I2C_BUS) {
1399                         dev_dbg(&adapter->dev, "found probe parameter for "
1400                                 "adapter %d, addr 0x%02x\n", adap_id,
1401                                 address_data->probe[i + 1]);
1402                         temp_client->addr = address_data->probe[i + 1];
1403                         err = i2c_detect_address(temp_client, -1, driver);
1404                         if (err)
1405                                 goto exit_free;
1406                 }
1407         }
1408
1409         /* Normal entries are done last, unless shadowed by an ignore entry */
1410         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
1411                 int j, ignore;
1412
1413                 ignore = 0;
1414                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
1415                      j += 2) {
1416                         if ((address_data->ignore[j] == adap_id ||
1417                              address_data->ignore[j] == ANY_I2C_BUS)
1418                          && address_data->ignore[j + 1]
1419                             == address_data->normal_i2c[i]) {
1420                                 dev_dbg(&adapter->dev, "found ignore "
1421                                         "parameter for adapter %d, "
1422                                         "addr 0x%02x\n", adap_id,
1423                                         address_data->ignore[j + 1]);
1424                                 ignore = 1;
1425                                 break;
1426                         }
1427                 }
1428                 if (ignore)
1429                         continue;
1430
1431                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1432                         "addr 0x%02x\n", adap_id,
1433                         address_data->normal_i2c[i]);
1434                 temp_client->addr = address_data->normal_i2c[i];
1435                 err = i2c_detect_address(temp_client, -1, driver);
1436                 if (err)
1437                         goto exit_free;
1438         }
1439
1440  exit_free:
1441         kfree(temp_client);
1442         return err;
1443 }
1444
1445 struct i2c_client *
1446 i2c_new_probed_device(struct i2c_adapter *adap,
1447                       struct i2c_board_info *info,
1448                       unsigned short const *addr_list)
1449 {
1450         int i;
1451
1452         /* Stop here if the bus doesn't support probing */
1453         if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
1454                 dev_err(&adap->dev, "Probing not supported\n");
1455                 return NULL;
1456         }
1457
1458         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1459                 /* Check address validity */
1460                 if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
1461                         dev_warn(&adap->dev, "Invalid 7-bit address "
1462                                  "0x%02x\n", addr_list[i]);
1463                         continue;
1464                 }
1465
1466                 /* Check address availability */
1467                 if (i2c_check_addr(adap, addr_list[i])) {
1468                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1469                                 "use, not probing\n", addr_list[i]);
1470                         continue;
1471                 }
1472
1473                 /* Test address responsiveness
1474                    The default probe method is a quick write, but it is known
1475                    to corrupt the 24RF08 EEPROMs due to a state machine bug,
1476                    and could also irreversibly write-protect some EEPROMs, so
1477                    for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
1478                    read instead. Also, some bus drivers don't implement
1479                    quick write, so we fallback to a byte read it that case
1480                    too. */
1481                 if ((addr_list[i] & ~0x07) == 0x30
1482                  || (addr_list[i] & ~0x0f) == 0x50
1483                  || !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
1484                         union i2c_smbus_data data;
1485
1486                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1487                                            I2C_SMBUS_READ, 0,
1488                                            I2C_SMBUS_BYTE, &data) >= 0)
1489                                 break;
1490                 } else {
1491                         if (i2c_smbus_xfer(adap, addr_list[i], 0,
1492                                            I2C_SMBUS_WRITE, 0,
1493                                            I2C_SMBUS_QUICK, NULL) >= 0)
1494                                 break;
1495                 }
1496         }
1497
1498         if (addr_list[i] == I2C_CLIENT_END) {
1499                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1500                 return NULL;
1501         }
1502
1503         info->addr = addr_list[i];
1504         return i2c_new_device(adap, info);
1505 }
1506 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1507
1508 struct i2c_adapter* i2c_get_adapter(int id)
1509 {
1510         struct i2c_adapter *adapter;
1511
1512         mutex_lock(&core_lock);
1513         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
1514         if (adapter && !try_module_get(adapter->owner))
1515                 adapter = NULL;
1516
1517         mutex_unlock(&core_lock);
1518         return adapter;
1519 }
1520 EXPORT_SYMBOL(i2c_get_adapter);
1521
1522 void i2c_put_adapter(struct i2c_adapter *adap)
1523 {
1524         module_put(adap->owner);
1525 }
1526 EXPORT_SYMBOL(i2c_put_adapter);
1527
1528 /* The SMBus parts */
1529
1530 #define POLY    (0x1070U << 3)
1531 static u8 crc8(u16 data)
1532 {
1533         int i;
1534
1535         for(i = 0; i < 8; i++) {
1536                 if (data & 0x8000)
1537                         data = data ^ POLY;
1538                 data = data << 1;
1539         }
1540         return (u8)(data >> 8);
1541 }
1542
1543 /* Incremental CRC8 over count bytes in the array pointed to by p */
1544 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1545 {
1546         int i;
1547
1548         for(i = 0; i < count; i++)
1549                 crc = crc8((crc ^ p[i]) << 8);
1550         return crc;
1551 }
1552
1553 /* Assume a 7-bit address, which is reasonable for SMBus */
1554 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1555 {
1556         /* The address will be sent first */
1557         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1558         pec = i2c_smbus_pec(pec, &addr, 1);
1559
1560         /* The data buffer follows */
1561         return i2c_smbus_pec(pec, msg->buf, msg->len);
1562 }
1563
1564 /* Used for write only transactions */
1565 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1566 {
1567         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1568         msg->len++;
1569 }
1570
1571 /* Return <0 on CRC error
1572    If there was a write before this read (most cases) we need to take the
1573    partial CRC from the write part into account.
1574    Note that this function does modify the message (we need to decrease the
1575    message length to hide the CRC byte from the caller). */
1576 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1577 {
1578         u8 rpec = msg->buf[--msg->len];
1579         cpec = i2c_smbus_msg_pec(cpec, msg);
1580
1581         if (rpec != cpec) {
1582                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1583                         rpec, cpec);
1584                 return -EBADMSG;
1585         }
1586         return 0;
1587 }
1588
1589 /**
1590  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1591  * @client: Handle to slave device
1592  *
1593  * This executes the SMBus "receive byte" protocol, returning negative errno
1594  * else the byte received from the device.
1595  */
1596 s32 i2c_smbus_read_byte(struct i2c_client *client)
1597 {
1598         union i2c_smbus_data data;
1599         int status;
1600
1601         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1602                                 I2C_SMBUS_READ, 0,
1603                                 I2C_SMBUS_BYTE, &data);
1604         return (status < 0) ? status : data.byte;
1605 }
1606 EXPORT_SYMBOL(i2c_smbus_read_byte);
1607
1608 /**
1609  * i2c_smbus_write_byte - SMBus "send byte" protocol
1610  * @client: Handle to slave device
1611  * @value: Byte to be sent
1612  *
1613  * This executes the SMBus "send byte" protocol, returning negative errno
1614  * else zero on success.
1615  */
1616 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1617 {
1618         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1619                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1620 }
1621 EXPORT_SYMBOL(i2c_smbus_write_byte);
1622
1623 /**
1624  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1625  * @client: Handle to slave device
1626  * @command: Byte interpreted by slave
1627  *
1628  * This executes the SMBus "read byte" protocol, returning negative errno
1629  * else a data byte received from the device.
1630  */
1631 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1632 {
1633         union i2c_smbus_data data;
1634         int status;
1635
1636         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1637                                 I2C_SMBUS_READ, command,
1638                                 I2C_SMBUS_BYTE_DATA, &data);
1639         return (status < 0) ? status : data.byte;
1640 }
1641 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1642
1643 /**
1644  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1645  * @client: Handle to slave device
1646  * @command: Byte interpreted by slave
1647  * @value: Byte being written
1648  *
1649  * This executes the SMBus "write byte" protocol, returning negative errno
1650  * else zero on success.
1651  */
1652 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1653 {
1654         union i2c_smbus_data data;
1655         data.byte = value;
1656         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1657                               I2C_SMBUS_WRITE,command,
1658                               I2C_SMBUS_BYTE_DATA,&data);
1659 }
1660 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1661
1662 /**
1663  * i2c_smbus_read_word_data - SMBus "read word" protocol
1664  * @client: Handle to slave device
1665  * @command: Byte interpreted by slave
1666  *
1667  * This executes the SMBus "read word" protocol, returning negative errno
1668  * else a 16-bit unsigned "word" received from the device.
1669  */
1670 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1671 {
1672         union i2c_smbus_data data;
1673         int status;
1674
1675         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1676                                 I2C_SMBUS_READ, command,
1677                                 I2C_SMBUS_WORD_DATA, &data);
1678         return (status < 0) ? status : data.word;
1679 }
1680 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1681
1682 /**
1683  * i2c_smbus_write_word_data - SMBus "write word" protocol
1684  * @client: Handle to slave device
1685  * @command: Byte interpreted by slave
1686  * @value: 16-bit "word" being written
1687  *
1688  * This executes the SMBus "write word" protocol, returning negative errno
1689  * else zero on success.
1690  */
1691 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1692 {
1693         union i2c_smbus_data data;
1694         data.word = value;
1695         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1696                               I2C_SMBUS_WRITE,command,
1697                               I2C_SMBUS_WORD_DATA,&data);
1698 }
1699 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1700
1701 /**
1702  * i2c_smbus_process_call - SMBus "process call" protocol
1703  * @client: Handle to slave device
1704  * @command: Byte interpreted by slave
1705  * @value: 16-bit "word" being written
1706  *
1707  * This executes the SMBus "process call" protocol, returning negative errno
1708  * else a 16-bit unsigned "word" received from the device.
1709  */
1710 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1711 {
1712         union i2c_smbus_data data;
1713         int status;
1714         data.word = value;
1715
1716         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1717                                 I2C_SMBUS_WRITE, command,
1718                                 I2C_SMBUS_PROC_CALL, &data);
1719         return (status < 0) ? status : data.word;
1720 }
1721 EXPORT_SYMBOL(i2c_smbus_process_call);
1722
1723 /**
1724  * i2c_smbus_read_block_data - SMBus "block read" protocol
1725  * @client: Handle to slave device
1726  * @command: Byte interpreted by slave
1727  * @values: Byte array into which data will be read; big enough to hold
1728  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1729  *
1730  * This executes the SMBus "block read" protocol, returning negative errno
1731  * else the number of data bytes in the slave's response.
1732  *
1733  * Note that using this function requires that the client's adapter support
1734  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1735  * support this; its emulation through I2C messaging relies on a specific
1736  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1737  */
1738 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1739                               u8 *values)
1740 {
1741         union i2c_smbus_data data;
1742         int status;
1743
1744         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1745                                 I2C_SMBUS_READ, command,
1746                                 I2C_SMBUS_BLOCK_DATA, &data);
1747         if (status)
1748                 return status;
1749
1750         memcpy(values, &data.block[1], data.block[0]);
1751         return data.block[0];
1752 }
1753 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1754
1755 /**
1756  * i2c_smbus_write_block_data - SMBus "block write" protocol
1757  * @client: Handle to slave device
1758  * @command: Byte interpreted by slave
1759  * @length: Size of data block; SMBus allows at most 32 bytes
1760  * @values: Byte array which will be written.
1761  *
1762  * This executes the SMBus "block write" protocol, returning negative errno
1763  * else zero on success.
1764  */
1765 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1766                                u8 length, const u8 *values)
1767 {
1768         union i2c_smbus_data data;
1769
1770         if (length > I2C_SMBUS_BLOCK_MAX)
1771                 length = I2C_SMBUS_BLOCK_MAX;
1772         data.block[0] = length;
1773         memcpy(&data.block[1], values, length);
1774         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1775                               I2C_SMBUS_WRITE,command,
1776                               I2C_SMBUS_BLOCK_DATA,&data);
1777 }
1778 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1779
1780 /* Returns the number of read bytes */
1781 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1782                                   u8 length, u8 *values)
1783 {
1784         union i2c_smbus_data data;
1785         int status;
1786
1787         if (length > I2C_SMBUS_BLOCK_MAX)
1788                 length = I2C_SMBUS_BLOCK_MAX;
1789         data.block[0] = length;
1790         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1791                                 I2C_SMBUS_READ, command,
1792                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1793         if (status < 0)
1794                 return status;
1795
1796         memcpy(values, &data.block[1], data.block[0]);
1797         return data.block[0];
1798 }
1799 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1800
1801 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1802                                    u8 length, const u8 *values)
1803 {
1804         union i2c_smbus_data data;
1805
1806         if (length > I2C_SMBUS_BLOCK_MAX)
1807                 length = I2C_SMBUS_BLOCK_MAX;
1808         data.block[0] = length;
1809         memcpy(data.block + 1, values, length);
1810         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1811                               I2C_SMBUS_WRITE, command,
1812                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1813 }
1814 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1815
1816 /* Simulate a SMBus command using the i2c protocol
1817    No checking of parameters is done!  */
1818 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1819                                    unsigned short flags,
1820                                    char read_write, u8 command, int size,
1821                                    union i2c_smbus_data * data)
1822 {
1823         /* So we need to generate a series of msgs. In the case of writing, we
1824           need to use only one message; when reading, we need two. We initialize
1825           most things with sane defaults, to keep the code below somewhat
1826           simpler. */
1827         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1828         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1829         int num = read_write == I2C_SMBUS_READ?2:1;
1830         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1831                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1832                                 };
1833         int i;
1834         u8 partial_pec = 0;
1835         int status;
1836
1837         msgbuf0[0] = command;
1838         switch(size) {
1839         case I2C_SMBUS_QUICK:
1840                 msg[0].len = 0;
1841                 /* Special case: The read/write field is used as data */
1842                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1843                                         I2C_M_RD : 0);
1844                 num = 1;
1845                 break;
1846         case I2C_SMBUS_BYTE:
1847                 if (read_write == I2C_SMBUS_READ) {
1848                         /* Special case: only a read! */
1849                         msg[0].flags = I2C_M_RD | flags;
1850                         num = 1;
1851                 }
1852                 break;
1853         case I2C_SMBUS_BYTE_DATA:
1854                 if (read_write == I2C_SMBUS_READ)
1855                         msg[1].len = 1;
1856                 else {
1857                         msg[0].len = 2;
1858                         msgbuf0[1] = data->byte;
1859                 }
1860                 break;
1861         case I2C_SMBUS_WORD_DATA:
1862                 if (read_write == I2C_SMBUS_READ)
1863                         msg[1].len = 2;
1864                 else {
1865                         msg[0].len=3;
1866                         msgbuf0[1] = data->word & 0xff;
1867                         msgbuf0[2] = data->word >> 8;
1868                 }
1869                 break;
1870         case I2C_SMBUS_PROC_CALL:
1871                 num = 2; /* Special case */
1872                 read_write = I2C_SMBUS_READ;
1873                 msg[0].len = 3;
1874                 msg[1].len = 2;
1875                 msgbuf0[1] = data->word & 0xff;
1876                 msgbuf0[2] = data->word >> 8;
1877                 break;
1878         case I2C_SMBUS_BLOCK_DATA:
1879                 if (read_write == I2C_SMBUS_READ) {
1880                         msg[1].flags |= I2C_M_RECV_LEN;
1881                         msg[1].len = 1; /* block length will be added by
1882                                            the underlying bus driver */
1883                 } else {
1884                         msg[0].len = data->block[0] + 2;
1885                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1886                                 dev_err(&adapter->dev,
1887                                         "Invalid block write size %d\n",
1888                                         data->block[0]);
1889                                 return -EINVAL;
1890                         }
1891                         for (i = 1; i < msg[0].len; i++)
1892                                 msgbuf0[i] = data->block[i-1];
1893                 }
1894                 break;
1895         case I2C_SMBUS_BLOCK_PROC_CALL:
1896                 num = 2; /* Another special case */
1897                 read_write = I2C_SMBUS_READ;
1898                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1899                         dev_err(&adapter->dev,
1900                                 "Invalid block write size %d\n",
1901                                 data->block[0]);
1902                         return -EINVAL;
1903                 }
1904                 msg[0].len = data->block[0] + 2;
1905                 for (i = 1; i < msg[0].len; i++)
1906                         msgbuf0[i] = data->block[i-1];
1907                 msg[1].flags |= I2C_M_RECV_LEN;
1908                 msg[1].len = 1; /* block length will be added by
1909                                    the underlying bus driver */
1910                 break;
1911         case I2C_SMBUS_I2C_BLOCK_DATA:
1912                 if (read_write == I2C_SMBUS_READ) {
1913                         msg[1].len = data->block[0];
1914                 } else {
1915                         msg[0].len = data->block[0] + 1;
1916                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1917                                 dev_err(&adapter->dev,
1918                                         "Invalid block write size %d\n",
1919                                         data->block[0]);
1920                                 return -EINVAL;
1921                         }
1922                         for (i = 1; i <= data->block[0]; i++)
1923                                 msgbuf0[i] = data->block[i];
1924                 }
1925                 break;
1926         default:
1927                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
1928                 return -EOPNOTSUPP;
1929         }
1930
1931         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1932                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1933         if (i) {
1934                 /* Compute PEC if first message is a write */
1935                 if (!(msg[0].flags & I2C_M_RD)) {
1936                         if (num == 1) /* Write only */
1937                                 i2c_smbus_add_pec(&msg[0]);
1938                         else /* Write followed by read */
1939                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1940                 }
1941                 /* Ask for PEC if last message is a read */
1942                 if (msg[num-1].flags & I2C_M_RD)
1943                         msg[num-1].len++;
1944         }
1945
1946         status = i2c_transfer(adapter, msg, num);
1947         if (status < 0)
1948                 return status;
1949
1950         /* Check PEC if last message is a read */
1951         if (i && (msg[num-1].flags & I2C_M_RD)) {
1952                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
1953                 if (status < 0)
1954                         return status;
1955         }
1956
1957         if (read_write == I2C_SMBUS_READ)
1958                 switch(size) {
1959                         case I2C_SMBUS_BYTE:
1960                                 data->byte = msgbuf0[0];
1961                                 break;
1962                         case I2C_SMBUS_BYTE_DATA:
1963                                 data->byte = msgbuf1[0];
1964                                 break;
1965                         case I2C_SMBUS_WORD_DATA:
1966                         case I2C_SMBUS_PROC_CALL:
1967                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1968                                 break;
1969                         case I2C_SMBUS_I2C_BLOCK_DATA:
1970                                 for (i = 0; i < data->block[0]; i++)
1971                                         data->block[i+1] = msgbuf1[i];
1972                                 break;
1973                         case I2C_SMBUS_BLOCK_DATA:
1974                         case I2C_SMBUS_BLOCK_PROC_CALL:
1975                                 for (i = 0; i < msgbuf1[0] + 1; i++)
1976                                         data->block[i] = msgbuf1[i];
1977                                 break;
1978                 }
1979         return 0;
1980 }
1981
1982 /**
1983  * i2c_smbus_xfer - execute SMBus protocol operations
1984  * @adapter: Handle to I2C bus
1985  * @addr: Address of SMBus slave on that bus
1986  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
1987  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
1988  * @command: Byte interpreted by slave, for protocols which use such bytes
1989  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
1990  * @data: Data to be read or written
1991  *
1992  * This executes an SMBus protocol operation, and returns a negative
1993  * errno code else zero on success.
1994  */
1995 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
1996                    char read_write, u8 command, int protocol,
1997                    union i2c_smbus_data *data)
1998 {
1999         s32 res;
2000
2001         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2002
2003         if (adapter->algo->smbus_xfer) {
2004                 mutex_lock(&adapter->bus_lock);
2005                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
2006                                                 command, protocol, data);
2007                 mutex_unlock(&adapter->bus_lock);
2008         } else
2009                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
2010                                               command, protocol, data);
2011
2012         return res;
2013 }
2014 EXPORT_SYMBOL(i2c_smbus_xfer);
2015
2016 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2017 MODULE_DESCRIPTION("I2C-Bus main module");
2018 MODULE_LICENSE("GPL");