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