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