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