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>                */
  23
  24 #include <linux/config.h>
  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 <asm/uaccess.h>
  34
  35
  36 static LIST_HEAD(adapters);
  37 static LIST_HEAD(drivers);
  38 static DECLARE_MUTEX(core_lists);
  39 static DEFINE_IDR(i2c_adapter_idr);
  40
  41 int i2c_device_probe(struct device *dev)
  42 {
  43         return -ENODEV;
  44 }
  45
  46 int i2c_device_remove(struct device *dev)
  47 {
  48         return 0;
  49 }
  50
  51 static void i2c_adapter_dev_release(struct device *dev)
  52 {
  53         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
  54         complete(&adap->dev_released);
  55 }
  56
  57 static struct device_driver i2c_adapter_driver = {
  58         .name = "i2c_adapter",
  59         .bus = &i2c_bus_type,
  60         .probe = i2c_device_probe,
  61         .remove = i2c_device_remove,
  62 };
  63
  64 static void i2c_adapter_class_dev_release(struct class_device *dev)
  65 {
  66         struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
  67         complete(&adap->class_dev_released);
  68 }
  69
  70 static struct class i2c_adapter_class = {
  71         .name =         "i2c-adapter",
  72         .release =      &i2c_adapter_class_dev_release,
  73 };
  74
  75 static ssize_t show_adapter_name(struct device *dev, char *buf)
  76 {
  77         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
  78         return sprintf(buf, "%s\n", adap->name);
  79 }
  80 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
  81
  82
  83 static void i2c_client_release(struct device *dev)
  84 {
  85         struct i2c_client *client = to_i2c_client(dev);
  86         complete(&client->released);
  87 }
  88
  89 static ssize_t show_client_name(struct device *dev, char *buf)
  90 {
  91         struct i2c_client *client = to_i2c_client(dev);
  92         return sprintf(buf, "%s\n", client->name);
  93 }
  94
  95 /*
  96  * We can't use the DEVICE_ATTR() macro here as we want the same filename for a
  97  * different type of a device.  So beware if the DEVICE_ATTR() macro ever
  98  * changes, this definition will also have to change.
  99  */
 100 static struct device_attribute dev_attr_client_name = {
 101         .attr   = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE },
 102         .show   = &show_client_name,
 103 };
 104
 105
 106 /* ---------------------------------------------------
 107  * registering functions
 108  * ---------------------------------------------------
 109  */
 110
 111 /* -----
 112  * i2c_add_adapter is called from within the algorithm layer,
 113  * when a new hw adapter registers. A new device is register to be
 114  * available for clients.
 115  */
 116 int i2c_add_adapter(struct i2c_adapter *adap)
 117 {
 118         int id, res = 0;
 119         struct list_head   *item;
 120         struct i2c_driver  *driver;
 121
 122         down(&core_lists);
 123
 124         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
 125                 res = -ENOMEM;
 126                 goto out_unlock;
 127         }
 128
 129         id = idr_get_new(&i2c_adapter_idr, NULL);
 130         adap->nr =  id & MAX_ID_MASK;
 131         init_MUTEX(&adap->bus_lock);
 132         init_MUTEX(&adap->clist_lock);
 133         list_add_tail(&adap->list,&adapters);
 134         INIT_LIST_HEAD(&adap->clients);
 135
 136         /* Add the adapter to the driver core.
 137          * If the parent pointer is not set up,
 138          * we add this adapter to the host bus.
 139          */
 140         if (adap->dev.parent == NULL)
 141                 adap->dev.parent = &platform_bus;
 142         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
 143         adap->dev.driver = &i2c_adapter_driver;
 144         adap->dev.release = &i2c_adapter_dev_release;
 145         device_register(&adap->dev);
 146         device_create_file(&adap->dev, &dev_attr_name);
 147
 148         /* Add this adapter to the i2c_adapter class */
 149         memset(&adap->class_dev, 0x00, sizeof(struct class_device));
 150         adap->class_dev.dev = &adap->dev;
 151         adap->class_dev.class = &i2c_adapter_class;
 152         strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
 153         class_device_register(&adap->class_dev);
 154
 155         /* inform drivers of new adapters */
 156         list_for_each(item,&drivers) {
 157                 driver = list_entry(item, struct i2c_driver, list);
 158                 if (driver->flags & I2C_DF_NOTIFY)
 159                         /* We ignore the return code; if it fails, too bad */
 160                         driver->attach_adapter(adap);
 161         }
 162
 163         dev_dbg(&adap->dev, "registered as adapter #%d\n", adap->nr);
 164
 165  out_unlock:
 166         up(&core_lists);
 167         return res;
 168 }
 169
 170
 171 int i2c_del_adapter(struct i2c_adapter *adap)
 172 {
 173         struct list_head  *item, *_n;
 174         struct i2c_driver *driver;
 175         struct i2c_client *client;
 176         int res = 0;
 177
 178         down(&core_lists);
 179
 180         list_for_each(item,&drivers) {
 181                 driver = list_entry(item, struct i2c_driver, list);
 182                 if (driver->detach_adapter)
 183                         if ((res = driver->detach_adapter(adap))) {
 184                                 dev_warn(&adap->dev, "can't detach adapter "
 185                                          "while detaching driver %s: driver not "
 186                                          "detached!", driver->name);
 187                                 goto out_unlock;
 188                         }
 189         }
 190
 191         /* detach any active clients. This must be done first, because
 192          * it can fail; in which case we give upp. */
 193         list_for_each_safe(item, _n, &adap->clients) {
 194                 client = list_entry(item, struct i2c_client, list);
 195
 196                 /* detaching devices is unconditional of the set notify
 197                  * flag, as _all_ clients that reside on the adapter
 198                  * must be deleted, as this would cause invalid states.
 199                  */
 200                 if ((res=client->driver->detach_client(client))) {
 201                         dev_err(&adap->dev, "adapter not "
 202                                 "unregistered, because client at "
 203                                 "address %02x can't be detached. ",
 204                                 client->addr);
 205                         goto out_unlock;
 206                 }
 207         }
 208
 209         /* clean up the sysfs representation */
 210         init_completion(&adap->dev_released);
 211         init_completion(&adap->class_dev_released);
 212         class_device_unregister(&adap->class_dev);
 213         device_remove_file(&adap->dev, &dev_attr_name);
 214         device_unregister(&adap->dev);
 215         list_del(&adap->list);
 216
 217         /* wait for sysfs to drop all references */
 218         wait_for_completion(&adap->dev_released);
 219         wait_for_completion(&adap->class_dev_released);
 220
 221         /* free dynamically allocated bus id */
 222         idr_remove(&i2c_adapter_idr, adap->nr);
 223
 224         dev_dbg(&adap->dev, "adapter unregistered\n");
 225
 226  out_unlock:
 227         up(&core_lists);
 228         return res;
 229 }
 230
 231
 232 /* -----
 233  * What follows is the "upwards" interface: commands for talking to clients,
 234  * which implement the functions to access the physical information of the
 235  * chips.
 236  */
 237
 238 int i2c_add_driver(struct i2c_driver *driver)
 239 {
 240         struct list_head   *item;
 241         struct i2c_adapter *adapter;
 242         int res = 0;
 243
 244         down(&core_lists);
 245
 246         /* add the driver to the list of i2c drivers in the driver core */
 247         driver->driver.name = driver->name;
 248         driver->driver.bus = &i2c_bus_type;
 249         driver->driver.probe = i2c_device_probe;
 250         driver->driver.remove = i2c_device_remove;
 251
 252         res = driver_register(&driver->driver);
 253         if (res)
 254                 goto out_unlock;
 255
 256         list_add_tail(&driver->list,&drivers);
 257         pr_debug("i2c-core: driver %s registered.\n", driver->name);
 258
 259         /* now look for instances of driver on our adapters */
 260         if (driver->flags & I2C_DF_NOTIFY) {
 261                 list_for_each(item,&adapters) {
 262                         adapter = list_entry(item, struct i2c_adapter, list);
 263                         driver->attach_adapter(adapter);
 264                 }
 265         }
 266
 267  out_unlock:
 268         up(&core_lists);
 269         return res;
 270 }
 271
 272 int i2c_del_driver(struct i2c_driver *driver)
 273 {
 274         struct list_head   *item1, *item2, *_n;
 275         struct i2c_client  *client;
 276         struct i2c_adapter *adap;
 277
 278         int res = 0;
 279
 280         down(&core_lists);
 281
 282         /* Have a look at each adapter, if clients of this driver are still
 283          * attached. If so, detach them to be able to kill the driver
 284          * afterwards.
 285          */
 286         pr_debug("i2c-core: unregister_driver - looking for clients.\n");
 287         /* removing clients does not depend on the notify flag, else
 288          * invalid operation might (will!) result, when using stale client
 289          * pointers.
 290          */
 291         list_for_each(item1,&adapters) {
 292                 adap = list_entry(item1, struct i2c_adapter, list);
 293                 dev_dbg(&adap->dev, "examining adapter\n");
 294                 if (driver->detach_adapter) {
 295                         if ((res = driver->detach_adapter(adap))) {
 296                                 dev_warn(&adap->dev, "while unregistering "
 297                                        "dummy driver %s, adapter could "
 298                                        "not be detached properly; driver "
 299                                        "not unloaded!",driver->name);
 300                                 goto out_unlock;
 301                         }
 302                 } else {
 303                         list_for_each_safe(item2, _n, &adap->clients) {
 304                                 client = list_entry(item2, struct i2c_client, list);
 305                                 if (client->driver != driver)
 306                                         continue;
 307                                 pr_debug("i2c-core.o: detaching client %s:\n", client->name);
 308                                 if ((res = driver->detach_client(client))) {
 309                                         dev_err(&adap->dev, "while "
 310                                                 "unregistering driver "
 311                                                 "`%s', the client at "
 312                                                 "address %02x of "
 313                                                 "adapter could not "
 314                                                 "be detached; driver "
 315                                                 "not unloaded!",
 316                                                 driver->name,
 317                                                 client->addr);
 318                                         goto out_unlock;
 319                                 }
 320                         }
 321                 }
 322         }
 323
 324         driver_unregister(&driver->driver);
 325         list_del(&driver->list);
 326         pr_debug("i2c-core: driver unregistered: %s\n", driver->name);
 327
 328  out_unlock:
 329         up(&core_lists);
 330         return 0;
 331 }
 332
 333 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
 334 {
 335         struct list_head   *item;
 336         struct i2c_client  *client;
 337
 338         list_for_each(item,&adapter->clients) {
 339                 client = list_entry(item, struct i2c_client, list);
 340                 if (client->addr == addr)
 341                         return -EBUSY;
 342         }
 343         return 0;
 344 }
 345
 346 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 347 {
 348         int rval;
 349
 350         down(&adapter->clist_lock);
 351         rval = __i2c_check_addr(adapter, addr);
 352         up(&adapter->clist_lock);
 353
 354         return rval;
 355 }
 356
 357 int i2c_attach_client(struct i2c_client *client)
 358 {
 359         struct i2c_adapter *adapter = client->adapter;
 360
 361         down(&adapter->clist_lock);
 362         if (__i2c_check_addr(client->adapter, client->addr)) {
 363                 up(&adapter->clist_lock);
 364                 return -EBUSY;
 365         }
 366         list_add_tail(&client->list,&adapter->clients);
 367         up(&adapter->clist_lock);
 368
 369         if (adapter->client_register)  {
 370                 if (adapter->client_register(client))  {
 371                         dev_warn(&adapter->dev, "warning: client_register "
 372                                 "seems to have failed for client %02x\n",
 373                                 client->addr);
 374                 }
 375         }
 376
 377         dev_dbg(&adapter->dev, "client [%s] registered to adapter\n",
 378                 client->name);
 379
 380         if (client->flags & I2C_CLIENT_ALLOW_USE)
 381                 client->usage_count = 0;
 382
 383         client->dev.parent = &client->adapter->dev;
 384         client->dev.driver = &client->driver->driver;
 385         client->dev.bus = &i2c_bus_type;
 386         client->dev.release = &i2c_client_release;
 387
 388         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
 389                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
 390         pr_debug("registering %s\n", client->dev.bus_id);
 391         device_register(&client->dev);
 392         device_create_file(&client->dev, &dev_attr_client_name);
 393
 394         return 0;
 395 }
 396
 397
 398 int i2c_detach_client(struct i2c_client *client)
 399 {
 400         struct i2c_adapter *adapter = client->adapter;
 401         int res = 0;
 402
 403         if ((client->flags & I2C_CLIENT_ALLOW_USE) && (client->usage_count > 0))
 404                 return -EBUSY;
 405
 406         if (adapter->client_unregister)  {
 407                 res = adapter->client_unregister(client);
 408                 if (res) {
 409                         dev_err(&client->dev,
 410                                "client_unregister [%s] failed, "
 411                                "client not detached", client->name);
 412                         goto out;
 413                 }
 414         }
 415
 416         down(&adapter->clist_lock);
 417         list_del(&client->list);
 418         init_completion(&client->released);
 419         device_remove_file(&client->dev, &dev_attr_client_name);
 420         device_unregister(&client->dev);
 421         up(&adapter->clist_lock);
 422         wait_for_completion(&client->released);
 423
 424  out:
 425         return res;
 426 }
 427
 428 static int i2c_inc_use_client(struct i2c_client *client)
 429 {
 430
 431         if (!try_module_get(client->driver->owner))
 432                 return -ENODEV;
 433         if (!try_module_get(client->adapter->owner)) {
 434                 module_put(client->driver->owner);
 435                 return -ENODEV;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static void i2c_dec_use_client(struct i2c_client *client)
 442 {
 443         module_put(client->driver->owner);
 444         module_put(client->adapter->owner);
 445 }
 446
 447 int i2c_use_client(struct i2c_client *client)
 448 {
 449         int ret;
 450
 451         ret = i2c_inc_use_client(client);
 452         if (ret)
 453                 return ret;
 454
 455         if (client->flags & I2C_CLIENT_ALLOW_USE) {
 456                 if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE)
 457                         client->usage_count++;
 458                 else if (client->usage_count > 0)
 459                         goto busy;
 460                 else
 461                         client->usage_count++;
 462         }
 463
 464         return 0;
 465  busy:
 466         i2c_dec_use_client(client);
 467         return -EBUSY;
 468 }
 469
 470 int i2c_release_client(struct i2c_client *client)
 471 {
 472         if(client->flags & I2C_CLIENT_ALLOW_USE) {
 473                 if(client->usage_count>0)
 474                         client->usage_count--;
 475                 else {
 476                         pr_debug("i2c-core: %s used one too many times\n",
 477                                 __FUNCTION__);
 478                         return -EPERM;
 479                 }
 480         }
 481
 482         i2c_dec_use_client(client);
 483
 484         return 0;
 485 }
 486
 487 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 488 {
 489         struct list_head  *item;
 490         struct i2c_client *client;
 491
 492         down(&adap->clist_lock);
 493         list_for_each(item,&adap->clients) {
 494                 client = list_entry(item, struct i2c_client, list);
 495                 if (!try_module_get(client->driver->owner))
 496                         continue;
 497                 if (NULL != client->driver->command) {
 498                         up(&adap->clist_lock);
 499                         client->driver->command(client,cmd,arg);
 500                         down(&adap->clist_lock);
 501                 }
 502                 module_put(client->driver->owner);
 503        }
 504        up(&adap->clist_lock);
 505 }
 506
 507
 508 /* match always succeeds, as we want the probe() to tell if we really accept this match */
 509 static int i2c_device_match(struct device *dev, struct device_driver *drv)
 510 {
 511         return 1;
 512 }
 513
 514 struct bus_type i2c_bus_type = {
 515         .name =         "i2c",
 516         .match =        i2c_device_match,
 517 };
 518
 519 static int __init i2c_init(void)
 520 {
 521         int retval;
 522
 523         retval = bus_register(&i2c_bus_type);
 524         if (retval)
 525                 return retval;
 526         retval = driver_register(&i2c_adapter_driver);
 527         if (retval)
 528                 return retval;
 529         return class_register(&i2c_adapter_class);
 530 }
 531
 532 static void __exit i2c_exit(void)
 533 {
 534         class_unregister(&i2c_adapter_class);
 535         driver_unregister(&i2c_adapter_driver);
 536         bus_unregister(&i2c_bus_type);
 537 }
 538
 539 subsys_initcall(i2c_init);
 540 module_exit(i2c_exit);
 541
 542 /* ----------------------------------------------------
 543  * the functional interface to the i2c busses.
 544  * ----------------------------------------------------
 545  */
 546
 547 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg msgs[],int num)
 548 {
 549         int ret;
 550
 551         if (adap->algo->master_xfer) {
 552                 dev_dbg(&adap->dev, "master_xfer: with %d msgs.\n", num);
 553
 554                 down(&adap->bus_lock);
 555                 ret = adap->algo->master_xfer(adap,msgs,num);
 556                 up(&adap->bus_lock);
 557
 558                 return ret;
 559         } else {
 560                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
 561                 return -ENOSYS;
 562         }
 563 }
 564
 565 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
 566 {
 567         int ret;
 568         struct i2c_adapter *adap=client->adapter;
 569         struct i2c_msg msg;
 570
 571         if (client->adapter->algo->master_xfer) {
 572                 msg.addr   = client->addr;
 573                 msg.flags = client->flags & I2C_M_TEN;
 574                 msg.len = count;
 575                 msg.buf = (char *)buf;
 576
 577                 dev_dbg(&client->adapter->dev, "master_send: writing %d bytes.\n",
 578                         count);
 579
 580                 down(&adap->bus_lock);
 581                 ret = adap->algo->master_xfer(adap,&msg,1);
 582                 up(&adap->bus_lock);
 583
 584                 /* if everything went ok (i.e. 1 msg transmitted), return #bytes
 585                  * transmitted, else error code.
 586                  */
 587                 return (ret == 1 )? count : ret;
 588         } else {
 589                 dev_err(&client->adapter->dev, "I2C level transfers not supported\n");
 590                 return -ENOSYS;
 591         }
 592 }
 593
 594 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
 595 {
 596         struct i2c_adapter *adap=client->adapter;
 597         struct i2c_msg msg;
 598         int ret;
 599         if (client->adapter->algo->master_xfer) {
 600                 msg.addr   = client->addr;
 601                 msg.flags = client->flags & I2C_M_TEN;
 602                 msg.flags |= I2C_M_RD;
 603                 msg.len = count;
 604                 msg.buf = buf;
 605
 606                 dev_dbg(&client->adapter->dev, "master_recv: reading %d bytes.\n",
 607                         count);
 608
 609                 down(&adap->bus_lock);
 610                 ret = adap->algo->master_xfer(adap,&msg,1);
 611                 up(&adap->bus_lock);
 612
 613                 dev_dbg(&client->adapter->dev, "master_recv: return:%d (count:%d, addr:0x%02x)\n",
 614                         ret, count, client->addr);
 615
 616                 /* if everything went ok (i.e. 1 msg transmitted), return #bytes
 617                 * transmitted, else error code.
 618                 */
 619                 return (ret == 1 )? count : ret;
 620         } else {
 621                 dev_err(&client->adapter->dev, "I2C level transfers not supported\n");
 622                 return -ENOSYS;
 623         }
 624 }
 625
 626
 627 int i2c_control(struct i2c_client *client,
 628         unsigned int cmd, unsigned long arg)
 629 {
 630         int ret = 0;
 631         struct i2c_adapter *adap = client->adapter;
 632
 633         dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
 634         switch (cmd) {
 635                 case I2C_RETRIES:
 636                         adap->retries = arg;
 637                         break;
 638                 case I2C_TIMEOUT:
 639                         adap->timeout = arg;
 640                         break;
 641                 default:
 642                         if (adap->algo->algo_control!=NULL)
 643                                 ret = adap->algo->algo_control(adap,cmd,arg);
 644         }
 645         return ret;
 646 }
 647
 648 /* ----------------------------------------------------
 649  * the i2c address scanning function
 650  * Will not work for 10-bit addresses!
 651  * ----------------------------------------------------
 652  */
 653 int i2c_probe(struct i2c_adapter *adapter,
 654               struct i2c_client_address_data *address_data,
 655               int (*found_proc) (struct i2c_adapter *, int, int))
 656 {
 657         int addr,i,found,err;
 658         int adap_id = i2c_adapter_id(adapter);
 659
 660         /* Forget it if we can't probe using SMBUS_QUICK */
 661         if (! i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK))
 662                 return -1;
 663
 664         for (addr = 0x00; addr <= 0x7f; addr++) {
 665
 666                 /* Skip if already in use */
 667                 if (i2c_check_addr(adapter,addr))
 668                         continue;
 669
 670                 /* If it is in one of the force entries, we don't do any detection
 671                    at all */
 672                 found = 0;
 673
 674                 for (i = 0; !found && (address_data->force[i] != I2C_CLIENT_END); i += 3) {
 675                         if (((adap_id == address_data->force[i]) ||
 676                              (address_data->force[i] == ANY_I2C_BUS)) &&
 677                              (addr == address_data->force[i+1])) {
 678                                 dev_dbg(&adapter->dev, "found force parameter for adapter %d, addr %04x\n",
 679                                         adap_id, addr);
 680                                 if ((err = found_proc(adapter,addr,0)))
 681                                         return err;
 682                                 found = 1;
 683                         }
 684                 }
 685                 if (found)
 686                         continue;
 687
 688                 /* If this address is in one of the ignores, we can forget about
 689                    it right now */
 690                 for (i = 0;
 691                      !found && (address_data->ignore[i] != I2C_CLIENT_END);
 692                      i += 2) {
 693                         if (((adap_id == address_data->ignore[i]) ||
 694                             ((address_data->ignore[i] == ANY_I2C_BUS))) &&
 695                             (addr == address_data->ignore[i+1])) {
 696                                 dev_dbg(&adapter->dev, "found ignore parameter for adapter %d, "
 697                                         "addr %04x\n", adap_id ,addr);
 698                                 found = 1;
 699                         }
 700                 }
 701                 for (i = 0;
 702                      !found && (address_data->ignore_range[i] != I2C_CLIENT_END);
 703                      i += 3) {
 704                         if (((adap_id == address_data->ignore_range[i]) ||
 705                             ((address_data->ignore_range[i]==ANY_I2C_BUS))) &&
 706                             (addr >= address_data->ignore_range[i+1]) &&
 707                             (addr <= address_data->ignore_range[i+2])) {
 708                                 dev_dbg(&adapter->dev, "found ignore_range parameter for adapter %d, "
 709                                         "addr %04x\n", adap_id,addr);
 710                                 found = 1;
 711                         }
 712                 }
 713                 if (found)
 714                         continue;
 715
 716                 /* Now, we will do a detection, but only if it is in the normal or
 717                    probe entries */
 718                 for (i = 0;
 719                      !found && (address_data->normal_i2c[i] != I2C_CLIENT_END);
 720                      i += 1) {
 721                         if (addr == address_data->normal_i2c[i]) {
 722                                 found = 1;
 723                                 dev_dbg(&adapter->dev, "found normal i2c entry for adapter %d, "
 724                                         "addr %02x", adap_id,addr);
 725                         }
 726                 }
 727
 728                 for (i = 0;
 729                      !found && (address_data->normal_i2c_range[i] != I2C_CLIENT_END);
 730                      i += 2) {
 731                         if ((addr >= address_data->normal_i2c_range[i]) &&
 732                             (addr <= address_data->normal_i2c_range[i+1])) {
 733                                 found = 1;
 734                                 dev_dbg(&adapter->dev, "found normal i2c_range entry for adapter %d, "
 735                                         "addr %04x\n", adap_id,addr);
 736                         }
 737                 }
 738
 739                 for (i = 0;
 740                      !found && (address_data->probe[i] != I2C_CLIENT_END);
 741                      i += 2) {
 742                         if (((adap_id == address_data->probe[i]) ||
 743                             ((address_data->probe[i] == ANY_I2C_BUS))) &&
 744                             (addr == address_data->probe[i+1])) {
 745                                 found = 1;
 746                                 dev_dbg(&adapter->dev, "found probe parameter for adapter %d, "
 747                                         "addr %04x\n", adap_id,addr);
 748                         }
 749                 }
 750                 for (i = 0;
 751                      !found && (address_data->probe_range[i] != I2C_CLIENT_END);
 752                      i += 3) {
 753                         if (((adap_id == address_data->probe_range[i]) ||
 754                            (address_data->probe_range[i] == ANY_I2C_BUS)) &&
 755                            (addr >= address_data->probe_range[i+1]) &&
 756                            (addr <= address_data->probe_range[i+2])) {
 757                                 found = 1;
 758                                 dev_dbg(&adapter->dev, "found probe_range parameter for adapter %d, "
 759                                         "addr %04x\n", adap_id,addr);
 760                         }
 761                 }
 762                 if (!found)
 763                         continue;
 764
 765                 /* OK, so we really should examine this address. First check
 766                    whether there is some client here at all! */
 767                 if (i2c_smbus_xfer(adapter,addr,0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
 768                         if ((err = found_proc(adapter,addr,-1)))
 769                                 return err;
 770         }
 771         return 0;
 772 }
 773
 774 /*
 775  * return id number for a specific adapter
 776  */
 777 int i2c_adapter_id(struct i2c_adapter *adap)
 778 {
 779         return adap->nr;
 780 }
 781
 782 struct i2c_adapter* i2c_get_adapter(int id)
 783 {
 784         struct list_head   *item;
 785         struct i2c_adapter *adapter;
 786
 787         down(&core_lists);
 788         list_for_each(item,&adapters) {
 789                 adapter = list_entry(item, struct i2c_adapter, list);
 790                 if (id == adapter->nr &&
 791                     try_module_get(adapter->owner)) {
 792                         up(&core_lists);
 793                         return adapter;
 794                 }
 795         }
 796         up(&core_lists);
 797         return NULL;
 798 }
 799
 800 void i2c_put_adapter(struct i2c_adapter *adap)
 801 {
 802         module_put(adap->owner);
 803 }
 804
 805 /* The SMBus parts */
 806
 807 #define POLY    (0x1070U << 3)
 808 static u8
 809 crc8(u16 data)
 810 {
 811         int i;
 812
 813         for(i = 0; i < 8; i++) {
 814                 if (data & 0x8000)
 815                         data = data ^ POLY;
 816                 data = data << 1;
 817         }
 818         return (u8)(data >> 8);
 819 }
 820
 821 /* CRC over count bytes in the first array plus the bytes in the rest
 822    array if it is non-null. rest[0] is the (length of rest) - 1
 823    and is included. */
 824 u8 i2c_smbus_partial_pec(u8 crc, int count, u8 *first, u8 *rest)
 825 {
 826         int i;
 827
 828         for(i = 0; i < count; i++)
 829                 crc = crc8((crc ^ first[i]) << 8);
 830         if(rest != NULL)
 831                 for(i = 0; i <= rest[0]; i++)
 832                         crc = crc8((crc ^ rest[i]) << 8);
 833         return crc;
 834 }
 835
 836 u8 i2c_smbus_pec(int count, u8 *first, u8 *rest)
 837 {
 838         return i2c_smbus_partial_pec(0, count, first, rest);
 839 }
 840
 841 /* Returns new "size" (transaction type)
 842    Note that we convert byte to byte_data and byte_data to word_data
 843    rather than invent new xxx_PEC transactions. */
 844 int i2c_smbus_add_pec(u16 addr, u8 command, int size,
 845                       union i2c_smbus_data *data)
 846 {
 847         u8 buf[3];
 848
 849         buf[0] = addr << 1;
 850         buf[1] = command;
 851         switch(size) {
 852                 case I2C_SMBUS_BYTE:
 853                         data->byte = i2c_smbus_pec(2, buf, NULL);
 854                         size = I2C_SMBUS_BYTE_DATA;
 855                         break;
 856                 case I2C_SMBUS_BYTE_DATA:
 857                         buf[2] = data->byte;
 858                         data->word = buf[2] ||
 859                                     (i2c_smbus_pec(3, buf, NULL) << 8);
 860                         size = I2C_SMBUS_WORD_DATA;
 861                         break;
 862                 case I2C_SMBUS_WORD_DATA:
 863                         /* unsupported */
 864                         break;
 865                 case I2C_SMBUS_BLOCK_DATA:
 866                         data->block[data->block[0] + 1] =
 867                                      i2c_smbus_pec(2, buf, data->block);
 868                         size = I2C_SMBUS_BLOCK_DATA_PEC;
 869                         break;
 870         }
 871         return size;
 872 }
 873
 874 int i2c_smbus_check_pec(u16 addr, u8 command, int size, u8 partial,
 875                         union i2c_smbus_data *data)
 876 {
 877         u8 buf[3], rpec, cpec;
 878
 879         buf[1] = command;
 880         switch(size) {
 881                 case I2C_SMBUS_BYTE_DATA:
 882                         buf[0] = (addr << 1) | 1;
 883                         cpec = i2c_smbus_pec(2, buf, NULL);
 884                         rpec = data->byte;
 885                         break;
 886                 case I2C_SMBUS_WORD_DATA:
 887                         buf[0] = (addr << 1) | 1;
 888                         buf[2] = data->word & 0xff;
 889                         cpec = i2c_smbus_pec(3, buf, NULL);
 890                         rpec = data->word >> 8;
 891                         break;
 892                 case I2C_SMBUS_WORD_DATA_PEC:
 893                         /* unsupported */
 894                         cpec = rpec = 0;
 895                         break;
 896                 case I2C_SMBUS_PROC_CALL_PEC:
 897                         /* unsupported */
 898                         cpec = rpec = 0;
 899                         break;
 900                 case I2C_SMBUS_BLOCK_DATA_PEC:
 901                         buf[0] = (addr << 1);
 902                         buf[2] = (addr << 1) | 1;
 903                         cpec = i2c_smbus_pec(3, buf, data->block);
 904                         rpec = data->block[data->block[0] + 1];
 905                         break;
 906                 case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
 907                         buf[0] = (addr << 1) | 1;
 908                         rpec = i2c_smbus_partial_pec(partial, 1,
 909                                                      buf, data->block);
 910                         cpec = data->block[data->block[0] + 1];
 911                         break;
 912                 default:
 913                         cpec = rpec = 0;
 914                         break;
 915         }
 916         if (rpec != cpec) {
 917                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
 918                         rpec, cpec);
 919                 return -1;
 920         }
 921         return 0;
 922 }
 923
 924 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
 925 {
 926         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 927                               value,0,I2C_SMBUS_QUICK,NULL);
 928 }
 929
 930 s32 i2c_smbus_read_byte(struct i2c_client *client)
 931 {
 932         union i2c_smbus_data data;
 933         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 934                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
 935                 return -1;
 936         else
 937                 return 0x0FF & data.byte;
 938 }
 939
 940 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
 941 {
 942         union i2c_smbus_data data;      /* only for PEC */
 943         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 944                               I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,&data);
 945 }
 946
 947 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
 948 {
 949         union i2c_smbus_data data;
 950         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 951                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
 952                 return -1;
 953         else
 954                 return 0x0FF & data.byte;
 955 }
 956
 957 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
 958 {
 959         union i2c_smbus_data data;
 960         data.byte = value;
 961         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 962                               I2C_SMBUS_WRITE,command,
 963                               I2C_SMBUS_BYTE_DATA,&data);
 964 }
 965
 966 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
 967 {
 968         union i2c_smbus_data data;
 969         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 970                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
 971                 return -1;
 972         else
 973                 return 0x0FFFF & data.word;
 974 }
 975
 976 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
 977 {
 978         union i2c_smbus_data data;
 979         data.word = value;
 980         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 981                               I2C_SMBUS_WRITE,command,
 982                               I2C_SMBUS_WORD_DATA,&data);
 983 }
 984
 985 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
 986 {
 987         union i2c_smbus_data data;
 988         data.word = value;
 989         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 990                            I2C_SMBUS_WRITE,command,
 991                            I2C_SMBUS_PROC_CALL, &data))
 992                 return -1;
 993         else
 994                 return 0x0FFFF & data.word;
 995 }
 996
 997 /* Returns the number of read bytes */
 998 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command, u8 *values)
 999 {
1000         union i2c_smbus_data data;
1001         int i;
1002         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1003                            I2C_SMBUS_READ,command,
1004                            I2C_SMBUS_BLOCK_DATA,&data))
1005                 return -1;
1006         else {
1007                 for (i = 1; i <= data.block[0]; i++)
1008                         values[i-1] = data.block[i];
1009                 return data.block[0];
1010         }
1011 }
1012
1013 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command, u8 length, u8 *values)
1014 {
1015         union i2c_smbus_data data;
1016         int i;
1017         if (length > I2C_SMBUS_BLOCK_MAX)
1018                 length = I2C_SMBUS_BLOCK_MAX;
1019         for (i = 1; i <= length; i++)
1020                 data.block[i] = values[i-1];
1021         data.block[0] = length;
1022         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1023                               I2C_SMBUS_WRITE,command,
1024                               I2C_SMBUS_BLOCK_DATA,&data);
1025 }
1026
1027 /* Returns the number of read bytes */
1028 s32 i2c_smbus_block_process_call(struct i2c_client *client, u8 command, u8 length, u8 *values)
1029 {
1030         union i2c_smbus_data data;
1031         int i;
1032         if (length > I2C_SMBUS_BLOCK_MAX - 1)
1033                 return -1;
1034         data.block[0] = length;
1035         for (i = 1; i <= length; i++)
1036                 data.block[i] = values[i-1];
1037         if(i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1038                           I2C_SMBUS_WRITE, command,
1039                           I2C_SMBUS_BLOCK_PROC_CALL, &data))
1040                 return -1;
1041         for (i = 1; i <= data.block[0]; i++)
1042                 values[i-1] = data.block[i];
1043         return data.block[0];
1044 }
1045
1046 /* Returns the number of read bytes */
1047 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
1048 {
1049         union i2c_smbus_data data;
1050         int i;
1051         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1052                               I2C_SMBUS_READ,command,
1053                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
1054                 return -1;
1055         else {
1056                 for (i = 1; i <= data.block[0]; i++)
1057                         values[i-1] = data.block[i];
1058                 return data.block[0];
1059         }
1060 }
1061
1062 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command, u8 length, u8 *values)
1063 {
1064         union i2c_smbus_data data;
1065         int i;
1066         if (length > I2C_SMBUS_I2C_BLOCK_MAX)
1067                 length = I2C_SMBUS_I2C_BLOCK_MAX;
1068         for (i = 1; i <= length; i++)
1069                 data.block[i] = values[i-1];
1070         data.block[0] = length;
1071         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
1072                               I2C_SMBUS_WRITE,command,
1073                               I2C_SMBUS_I2C_BLOCK_DATA,&data);
1074 }
1075
1076 /* Simulate a SMBus command using the i2c protocol
1077    No checking of parameters is done!  */
1078 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
1079                                    unsigned short flags,
1080                                    char read_write, u8 command, int size,
1081                                    union i2c_smbus_data * data)
1082 {
1083         /* So we need to generate a series of msgs. In the case of writing, we
1084           need to use only one message; when reading, we need two. We initialize
1085           most things with sane defaults, to keep the code below somewhat
1086           simpler. */
1087         unsigned char msgbuf0[34];
1088         unsigned char msgbuf1[34];
1089         int num = read_write == I2C_SMBUS_READ?2:1;
1090         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1091                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1092                                 };
1093         int i;
1094
1095         msgbuf0[0] = command;
1096         switch(size) {
1097         case I2C_SMBUS_QUICK:
1098                 msg[0].len = 0;
1099                 /* Special case: The read/write field is used as data */
1100                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
1101                 num = 1;
1102                 break;
1103         case I2C_SMBUS_BYTE:
1104                 if (read_write == I2C_SMBUS_READ) {
1105                         /* Special case: only a read! */
1106                         msg[0].flags = I2C_M_RD | flags;
1107                         num = 1;
1108                 }
1109                 break;
1110         case I2C_SMBUS_BYTE_DATA:
1111                 if (read_write == I2C_SMBUS_READ)
1112                         msg[1].len = 1;
1113                 else {
1114                         msg[0].len = 2;
1115                         msgbuf0[1] = data->byte;
1116                 }
1117                 break;
1118         case I2C_SMBUS_WORD_DATA:
1119                 if (read_write == I2C_SMBUS_READ)
1120                         msg[1].len = 2;
1121                 else {
1122                         msg[0].len=3;
1123                         msgbuf0[1] = data->word & 0xff;
1124                         msgbuf0[2] = (data->word >> 8) & 0xff;
1125                 }
1126                 break;
1127         case I2C_SMBUS_PROC_CALL:
1128                 num = 2; /* Special case */
1129                 read_write = I2C_SMBUS_READ;
1130                 msg[0].len = 3;
1131                 msg[1].len = 2;
1132                 msgbuf0[1] = data->word & 0xff;
1133                 msgbuf0[2] = (data->word >> 8) & 0xff;
1134                 break;
1135         case I2C_SMBUS_BLOCK_DATA:
1136         case I2C_SMBUS_BLOCK_DATA_PEC:
1137                 if (read_write == I2C_SMBUS_READ) {
1138                         dev_err(&adapter->dev, "Block read not supported "
1139                                "under I2C emulation!\n");
1140                         return -1;
1141                 } else {
1142                         msg[0].len = data->block[0] + 2;
1143                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1144                                 dev_err(&adapter->dev, "smbus_access called with "
1145                                        "invalid block write size (%d)\n",
1146                                        data->block[0]);
1147                                 return -1;
1148                         }
1149                         if(size == I2C_SMBUS_BLOCK_DATA_PEC)
1150                                 (msg[0].len)++;
1151                         for (i = 1; i <= msg[0].len; i++)
1152                                 msgbuf0[i] = data->block[i-1];
1153                 }
1154                 break;
1155         case I2C_SMBUS_BLOCK_PROC_CALL:
1156         case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
1157                 dev_dbg(&adapter->dev, "Block process call not supported "
1158                        "under I2C emulation!\n");
1159                 return -1;
1160         case I2C_SMBUS_I2C_BLOCK_DATA:
1161                 if (read_write == I2C_SMBUS_READ) {
1162                         msg[1].len = I2C_SMBUS_I2C_BLOCK_MAX;
1163                 } else {
1164                         msg[0].len = data->block[0] + 1;
1165                         if (msg[0].len > I2C_SMBUS_I2C_BLOCK_MAX + 1) {
1166                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1167                                        "invalid block write size (%d)\n",
1168                                        data->block[0]);
1169                                 return -1;
1170                         }
1171                         for (i = 1; i <= data->block[0]; i++)
1172                                 msgbuf0[i] = data->block[i];
1173                 }
1174                 break;
1175         default:
1176                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1177                        size);
1178                 return -1;
1179         }
1180
1181         if (i2c_transfer(adapter, msg, num) < 0)
1182                 return -1;
1183
1184         if (read_write == I2C_SMBUS_READ)
1185                 switch(size) {
1186                         case I2C_SMBUS_BYTE:
1187                                 data->byte = msgbuf0[0];
1188                                 break;
1189                         case I2C_SMBUS_BYTE_DATA:
1190                                 data->byte = msgbuf1[0];
1191                                 break;
1192                         case I2C_SMBUS_WORD_DATA:
1193                         case I2C_SMBUS_PROC_CALL:
1194                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1195                                 break;
1196                         case I2C_SMBUS_I2C_BLOCK_DATA:
1197                                 /* fixed at 32 for now */
1198                                 data->block[0] = I2C_SMBUS_I2C_BLOCK_MAX;
1199                                 for (i = 0; i < I2C_SMBUS_I2C_BLOCK_MAX; i++)
1200                                         data->block[i+1] = msgbuf1[i];
1201                                 break;
1202                 }
1203         return 0;
1204 }
1205
1206
1207 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1208                    char read_write, u8 command, int size,
1209                    union i2c_smbus_data * data)
1210 {
1211         s32 res;
1212         int swpec = 0;
1213         u8 partial = 0;
1214
1215         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1216         if((flags & I2C_CLIENT_PEC) &&
1217            !(i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HWPEC_CALC))) {
1218                 swpec = 1;
1219                 if(read_write == I2C_SMBUS_READ &&
1220                    size == I2C_SMBUS_BLOCK_DATA)
1221                         size = I2C_SMBUS_BLOCK_DATA_PEC;
1222                 else if(size == I2C_SMBUS_PROC_CALL)
1223                         size = I2C_SMBUS_PROC_CALL_PEC;
1224                 else if(size == I2C_SMBUS_BLOCK_PROC_CALL) {
1225                         i2c_smbus_add_pec(addr, command,
1226                                           I2C_SMBUS_BLOCK_DATA, data);
1227                         partial = data->block[data->block[0] + 1];
1228                         size = I2C_SMBUS_BLOCK_PROC_CALL_PEC;
1229                 } else if(read_write == I2C_SMBUS_WRITE &&
1230                           size != I2C_SMBUS_QUICK &&
1231                           size != I2C_SMBUS_I2C_BLOCK_DATA)
1232                         size = i2c_smbus_add_pec(addr, command, size, data);
1233         }
1234
1235         if (adapter->algo->smbus_xfer) {
1236                 down(&adapter->bus_lock);
1237                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1238                                                 command,size,data);
1239                 up(&adapter->bus_lock);
1240         } else
1241                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1242                                               command,size,data);
1243
1244         if(res >= 0 && swpec &&
1245            size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA &&
1246            (read_write == I2C_SMBUS_READ || size == I2C_SMBUS_PROC_CALL_PEC ||
1247             size == I2C_SMBUS_BLOCK_PROC_CALL_PEC)) {
1248                 if(i2c_smbus_check_pec(addr, command, size, partial, data))
1249                         return -1;
1250         }
1251         return res;
1252 }
1253
1254
1255 /* You should always define `functionality'; the 'else' is just for
1256    backward compatibility. */
1257 u32 i2c_get_functionality (struct i2c_adapter *adap)
1258 {
1259         if (adap->algo->functionality)
1260                 return adap->algo->functionality(adap);
1261         else
1262                 return 0xffffffff;
1263 }
1264
1265 int i2c_check_functionality (struct i2c_adapter *adap, u32 func)
1266 {
1267         u32 adap_func = i2c_get_functionality (adap);
1268         return (func & adap_func) == func;
1269 }
1270
1271 EXPORT_SYMBOL(i2c_add_adapter);
1272 EXPORT_SYMBOL(i2c_del_adapter);
1273 EXPORT_SYMBOL(i2c_add_driver);
1274 EXPORT_SYMBOL(i2c_del_driver);
1275 EXPORT_SYMBOL(i2c_attach_client);
1276 EXPORT_SYMBOL(i2c_detach_client);
1277 EXPORT_SYMBOL(i2c_use_client);
1278 EXPORT_SYMBOL(i2c_release_client);
1279 EXPORT_SYMBOL(i2c_clients_command);
1280 EXPORT_SYMBOL(i2c_check_addr);
1281
1282 EXPORT_SYMBOL(i2c_master_send);
1283 EXPORT_SYMBOL(i2c_master_recv);
1284 EXPORT_SYMBOL(i2c_control);
1285 EXPORT_SYMBOL(i2c_transfer);
1286 EXPORT_SYMBOL(i2c_adapter_id);
1287 EXPORT_SYMBOL(i2c_get_adapter);
1288 EXPORT_SYMBOL(i2c_put_adapter);
1289 EXPORT_SYMBOL(i2c_probe);
1290
1291 EXPORT_SYMBOL(i2c_smbus_xfer);
1292 EXPORT_SYMBOL(i2c_smbus_write_quick);
1293 EXPORT_SYMBOL(i2c_smbus_read_byte);
1294 EXPORT_SYMBOL(i2c_smbus_write_byte);
1295 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1296 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1297 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1298 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1299 EXPORT_SYMBOL(i2c_smbus_process_call);
1300 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1301 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1302 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1303 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1304
1305 EXPORT_SYMBOL(i2c_get_functionality);
1306 EXPORT_SYMBOL(i2c_check_functionality);
1307
1308 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1309 MODULE_DESCRIPTION("I2C-Bus main module");
1310 MODULE_LICENSE("GPL");