drivers/i2c/i2c-core.c

   1 /* i2c-core.c - a device driver for the iic-bus interface                    */
   2 /* ------------------------------------------------------------------------- */
   3 /*   Copyright (C) 1995-99 Simon G. Vogl
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  18 /* ------------------------------------------------------------------------- */
  19
  20 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
  21    All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
  22    SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
  23    Jean Delvare <khali@linux-fr.org> */
  24
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/errno.h>
  28 #include <linux/slab.h>
  29 #include <linux/i2c.h>
  30 #include <linux/init.h>
  31 #include <linux/idr.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/platform_device.h>
  34 #include <asm/uaccess.h>
  35
  36
  37 static LIST_HEAD(adapters);
  38 static LIST_HEAD(drivers);
  39 static DECLARE_MUTEX(core_lists);
  40 static DEFINE_IDR(i2c_adapter_idr);
  41
  42 /* match always succeeds, as we want the probe() to tell if we really accept this match */
  43 static int i2c_device_match(struct device *dev, struct device_driver *drv)
  44 {
  45         return 1;
  46 }
  47
  48 static int i2c_bus_suspend(struct device * dev, pm_message_t state)
  49 {
  50         int rc = 0;
  51
  52         if (dev->driver && dev->driver->suspend)
  53                 rc = dev->driver->suspend(dev, state);
  54         return rc;
  55 }
  56
  57 static int i2c_bus_resume(struct device * dev)
  58 {
  59         int rc = 0;
  60
  61         if (dev->driver && dev->driver->resume)
  62                 rc = dev->driver->resume(dev);
  63         return rc;
  64 }
  65
  66 struct bus_type i2c_bus_type = {
  67         .name =         "i2c",
  68         .match =        i2c_device_match,
  69         .suspend =      i2c_bus_suspend,
  70         .resume =       i2c_bus_resume,
  71 };
  72
  73 static int i2c_device_probe(struct device *dev)
  74 {
  75         return -ENODEV;
  76 }
  77
  78 static int i2c_device_remove(struct device *dev)
  79 {
  80         return 0;
  81 }
  82
  83 void i2c_adapter_dev_release(struct device *dev)
  84 {
  85         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
  86         complete(&adap->dev_released);
  87 }
  88
  89 struct device_driver i2c_adapter_driver = {
  90         .owner = THIS_MODULE,
  91         .name = "i2c_adapter",
  92         .bus = &i2c_bus_type,
  93         .probe = i2c_device_probe,
  94         .remove = i2c_device_remove,
  95 };
  96
  97 static void i2c_adapter_class_dev_release(struct class_device *dev)
  98 {
  99         struct i2c_adapter *adap = class_dev_to_i2c_adapter(dev);
 100         complete(&adap->class_dev_released);
 101 }
 102
 103 struct class i2c_adapter_class = {
 104         .owner =        THIS_MODULE,
 105         .name =         "i2c-adapter",
 106         .release =      &i2c_adapter_class_dev_release,
 107 };
 108
 109 static ssize_t show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
 110 {
 111         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
 112         return sprintf(buf, "%s\n", adap->name);
 113 }
 114 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
 115
 116
 117 static void i2c_client_release(struct device *dev)
 118 {
 119         struct i2c_client *client = to_i2c_client(dev);
 120         complete(&client->released);
 121 }
 122
 123 static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
 124 {
 125         struct i2c_client *client = to_i2c_client(dev);
 126         return sprintf(buf, "%s\n", client->name);
 127 }
 128
 129 /*
 130  * We can't use the DEVICE_ATTR() macro here as we want the same filename for a
 131  * different type of a device.  So beware if the DEVICE_ATTR() macro ever
 132  * changes, this definition will also have to change.
 133  */
 134 static struct device_attribute dev_attr_client_name = {
 135         .attr   = {.name = "name", .mode = S_IRUGO, .owner = THIS_MODULE },
 136         .show   = &show_client_name,
 137 };
 138
 139
 140 /* ---------------------------------------------------
 141  * registering functions
 142  * ---------------------------------------------------
 143  */
 144
 145 /* -----
 146  * i2c_add_adapter is called from within the algorithm layer,
 147  * when a new hw adapter registers. A new device is register to be
 148  * available for clients.
 149  */
 150 int i2c_add_adapter(struct i2c_adapter *adap)
 151 {
 152         int id, res = 0;
 153         struct list_head   *item;
 154         struct i2c_driver  *driver;
 155
 156         down(&core_lists);
 157
 158         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
 159                 res = -ENOMEM;
 160                 goto out_unlock;
 161         }
 162
 163         res = idr_get_new(&i2c_adapter_idr, adap, &id);
 164         if (res < 0) {
 165                 if (res == -EAGAIN)
 166                         res = -ENOMEM;
 167                 goto out_unlock;
 168         }
 169
 170         adap->nr =  id & MAX_ID_MASK;
 171         init_MUTEX(&adap->bus_lock);
 172         init_MUTEX(&adap->clist_lock);
 173         list_add_tail(&adap->list,&adapters);
 174         INIT_LIST_HEAD(&adap->clients);
 175
 176         /* Add the adapter to the driver core.
 177          * If the parent pointer is not set up,
 178          * we add this adapter to the host bus.
 179          */
 180         if (adap->dev.parent == NULL)
 181                 adap->dev.parent = &platform_bus;
 182         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
 183         adap->dev.driver = &i2c_adapter_driver;
 184         adap->dev.release = &i2c_adapter_dev_release;
 185         device_register(&adap->dev);
 186         device_create_file(&adap->dev, &dev_attr_name);
 187
 188         /* Add this adapter to the i2c_adapter class */
 189         memset(&adap->class_dev, 0x00, sizeof(struct class_device));
 190         adap->class_dev.dev = &adap->dev;
 191         adap->class_dev.class = &i2c_adapter_class;
 192         strlcpy(adap->class_dev.class_id, adap->dev.bus_id, BUS_ID_SIZE);
 193         class_device_register(&adap->class_dev);
 194
 195         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 196
 197         /* inform drivers of new adapters */
 198         list_for_each(item,&drivers) {
 199                 driver = list_entry(item, struct i2c_driver, list);
 200                 if (driver->attach_adapter)
 201                         /* We ignore the return code; if it fails, too bad */
 202                         driver->attach_adapter(adap);
 203         }
 204
 205 out_unlock:
 206         up(&core_lists);
 207         return res;
 208 }
 209
 210
 211 int i2c_del_adapter(struct i2c_adapter *adap)
 212 {
 213         struct list_head  *item, *_n;
 214         struct i2c_adapter *adap_from_list;
 215         struct i2c_driver *driver;
 216         struct i2c_client *client;
 217         int res = 0;
 218
 219         down(&core_lists);
 220
 221         /* First make sure that this adapter was ever added */
 222         list_for_each_entry(adap_from_list, &adapters, list) {
 223                 if (adap_from_list == adap)
 224                         break;
 225         }
 226         if (adap_from_list != adap) {
 227                 pr_debug("i2c-core: attempting to delete unregistered "
 228                          "adapter [%s]\n", adap->name);
 229                 res = -EINVAL;
 230                 goto out_unlock;
 231         }
 232
 233         list_for_each(item,&drivers) {
 234                 driver = list_entry(item, struct i2c_driver, list);
 235                 if (driver->detach_adapter)
 236                         if ((res = driver->detach_adapter(adap))) {
 237                                 dev_err(&adap->dev, "detach_adapter failed "
 238                                         "for driver [%s]\n", driver->name);
 239                                 goto out_unlock;
 240                         }
 241         }
 242
 243         /* detach any active clients. This must be done first, because
 244          * it can fail; in which case we give up. */
 245         list_for_each_safe(item, _n, &adap->clients) {
 246                 client = list_entry(item, struct i2c_client, list);
 247
 248                 /* detaching devices is unconditional of the set notify
 249                  * flag, as _all_ clients that reside on the adapter
 250                  * must be deleted, as this would cause invalid states.
 251                  */
 252                 if ((res=client->driver->detach_client(client))) {
 253                         dev_err(&adap->dev, "detach_client failed for client "
 254                                 "[%s] at address 0x%02x\n", client->name,
 255                                 client->addr);
 256                         goto out_unlock;
 257                 }
 258         }
 259
 260         /* clean up the sysfs representation */
 261         init_completion(&adap->dev_released);
 262         init_completion(&adap->class_dev_released);
 263         class_device_unregister(&adap->class_dev);
 264         device_remove_file(&adap->dev, &dev_attr_name);
 265         device_unregister(&adap->dev);
 266         list_del(&adap->list);
 267
 268         /* wait for sysfs to drop all references */
 269         wait_for_completion(&adap->dev_released);
 270         wait_for_completion(&adap->class_dev_released);
 271
 272         /* free dynamically allocated bus id */
 273         idr_remove(&i2c_adapter_idr, adap->nr);
 274
 275         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 276
 277  out_unlock:
 278         up(&core_lists);
 279         return res;
 280 }
 281
 282
 283 /* -----
 284  * What follows is the "upwards" interface: commands for talking to clients,
 285  * which implement the functions to access the physical information of the
 286  * chips.
 287  */
 288
 289 int i2c_add_driver(struct i2c_driver *driver)
 290 {
 291         struct list_head   *item;
 292         struct i2c_adapter *adapter;
 293         int res = 0;
 294
 295         down(&core_lists);
 296
 297         /* add the driver to the list of i2c drivers in the driver core */
 298         driver->driver.owner = driver->owner;
 299         driver->driver.name = driver->name;
 300         driver->driver.bus = &i2c_bus_type;
 301         driver->driver.probe = i2c_device_probe;
 302         driver->driver.remove = i2c_device_remove;
 303
 304         res = driver_register(&driver->driver);
 305         if (res)
 306                 goto out_unlock;
 307
 308         list_add_tail(&driver->list,&drivers);
 309         pr_debug("i2c-core: driver [%s] registered\n", driver->name);
 310
 311         /* now look for instances of driver on our adapters */
 312         if (driver->attach_adapter) {
 313                 list_for_each(item,&adapters) {
 314                         adapter = list_entry(item, struct i2c_adapter, list);
 315                         driver->attach_adapter(adapter);
 316                 }
 317         }
 318
 319  out_unlock:
 320         up(&core_lists);
 321         return res;
 322 }
 323
 324 int i2c_del_driver(struct i2c_driver *driver)
 325 {
 326         struct list_head   *item1, *item2, *_n;
 327         struct i2c_client  *client;
 328         struct i2c_adapter *adap;
 329
 330         int res = 0;
 331
 332         down(&core_lists);
 333
 334         /* Have a look at each adapter, if clients of this driver are still
 335          * attached. If so, detach them to be able to kill the driver
 336          * afterwards.
 337          *
 338          * Removing clients does not depend on the notify flag, else
 339          * invalid operation might (will!) result, when using stale client
 340          * pointers.
 341          */
 342         list_for_each(item1,&adapters) {
 343                 adap = list_entry(item1, struct i2c_adapter, list);
 344                 if (driver->detach_adapter) {
 345                         if ((res = driver->detach_adapter(adap))) {
 346                                 dev_err(&adap->dev, "detach_adapter failed "
 347                                         "for driver [%s]\n", driver->name);
 348                                 goto out_unlock;
 349                         }
 350                 } else {
 351                         list_for_each_safe(item2, _n, &adap->clients) {
 352                                 client = list_entry(item2, struct i2c_client, list);
 353                                 if (client->driver != driver)
 354                                         continue;
 355                                 dev_dbg(&adap->dev, "detaching client [%s] "
 356                                         "at 0x%02x\n", client->name,
 357                                         client->addr);
 358                                 if ((res = driver->detach_client(client))) {
 359                                         dev_err(&adap->dev, "detach_client "
 360                                                 "failed for client [%s] at "
 361                                                 "0x%02x\n", client->name,
 362                                                 client->addr);
 363                                         goto out_unlock;
 364                                 }
 365                         }
 366                 }
 367         }
 368
 369         driver_unregister(&driver->driver);
 370         list_del(&driver->list);
 371         pr_debug("i2c-core: driver [%s] unregistered\n", driver->name);
 372
 373  out_unlock:
 374         up(&core_lists);
 375         return 0;
 376 }
 377
 378 static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
 379 {
 380         struct list_head   *item;
 381         struct i2c_client  *client;
 382
 383         list_for_each(item,&adapter->clients) {
 384                 client = list_entry(item, struct i2c_client, list);
 385                 if (client->addr == addr)
 386                         return -EBUSY;
 387         }
 388         return 0;
 389 }
 390
 391 int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 392 {
 393         int rval;
 394
 395         down(&adapter->clist_lock);
 396         rval = __i2c_check_addr(adapter, addr);
 397         up(&adapter->clist_lock);
 398
 399         return rval;
 400 }
 401
 402 int i2c_attach_client(struct i2c_client *client)
 403 {
 404         struct i2c_adapter *adapter = client->adapter;
 405
 406         down(&adapter->clist_lock);
 407         if (__i2c_check_addr(client->adapter, client->addr)) {
 408                 up(&adapter->clist_lock);
 409                 return -EBUSY;
 410         }
 411         list_add_tail(&client->list,&adapter->clients);
 412         up(&adapter->clist_lock);
 413
 414         if (adapter->client_register)  {
 415                 if (adapter->client_register(client))  {
 416                         dev_dbg(&adapter->dev, "client_register "
 417                                 "failed for client [%s] at 0x%02x\n",
 418                                 client->name, client->addr);
 419                 }
 420         }
 421
 422         client->usage_count = 0;
 423
 424         client->dev.parent = &client->adapter->dev;
 425         client->dev.driver = &client->driver->driver;
 426         client->dev.bus = &i2c_bus_type;
 427         client->dev.release = &i2c_client_release;
 428
 429         snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
 430                 "%d-%04x", i2c_adapter_id(adapter), client->addr);
 431         dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
 432                 client->name, client->dev.bus_id);
 433         device_register(&client->dev);
 434         device_create_file(&client->dev, &dev_attr_client_name);
 435
 436         return 0;
 437 }
 438
 439
 440 int i2c_detach_client(struct i2c_client *client)
 441 {
 442         struct i2c_adapter *adapter = client->adapter;
 443         int res = 0;
 444
 445         if (client->usage_count > 0) {
 446                 dev_warn(&client->dev, "Client [%s] still busy, "
 447                          "can't detach\n", client->name);
 448                 return -EBUSY;
 449         }
 450
 451         if (adapter->client_unregister)  {
 452                 res = adapter->client_unregister(client);
 453                 if (res) {
 454                         dev_err(&client->dev,
 455                                 "client_unregister [%s] failed, "
 456                                 "client not detached\n", client->name);
 457                         goto out;
 458                 }
 459         }
 460
 461         down(&adapter->clist_lock);
 462         list_del(&client->list);
 463         init_completion(&client->released);
 464         device_remove_file(&client->dev, &dev_attr_client_name);
 465         device_unregister(&client->dev);
 466         up(&adapter->clist_lock);
 467         wait_for_completion(&client->released);
 468
 469  out:
 470         return res;
 471 }
 472
 473 static int i2c_inc_use_client(struct i2c_client *client)
 474 {
 475
 476         if (!try_module_get(client->driver->owner))
 477                 return -ENODEV;
 478         if (!try_module_get(client->adapter->owner)) {
 479                 module_put(client->driver->owner);
 480                 return -ENODEV;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static void i2c_dec_use_client(struct i2c_client *client)
 487 {
 488         module_put(client->driver->owner);
 489         module_put(client->adapter->owner);
 490 }
 491
 492 int i2c_use_client(struct i2c_client *client)
 493 {
 494         int ret;
 495
 496         ret = i2c_inc_use_client(client);
 497         if (ret)
 498                 return ret;
 499
 500         if (client->usage_count > 0)
 501                 goto busy;
 502         client->usage_count++;
 503
 504         return 0;
 505  busy:
 506         i2c_dec_use_client(client);
 507         return -EBUSY;
 508 }
 509
 510 int i2c_release_client(struct i2c_client *client)
 511 {
 512         if (!client->usage_count) {
 513                 pr_debug("i2c-core: %s used one too many times\n",
 514                          __FUNCTION__);
 515                 return -EPERM;
 516         }
 517
 518         client->usage_count--;
 519         i2c_dec_use_client(client);
 520
 521         return 0;
 522 }
 523
 524 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
 525 {
 526         struct list_head  *item;
 527         struct i2c_client *client;
 528
 529         down(&adap->clist_lock);
 530         list_for_each(item,&adap->clients) {
 531                 client = list_entry(item, struct i2c_client, list);
 532                 if (!try_module_get(client->driver->owner))
 533                         continue;
 534                 if (NULL != client->driver->command) {
 535                         up(&adap->clist_lock);
 536                         client->driver->command(client,cmd,arg);
 537                         down(&adap->clist_lock);
 538                 }
 539                 module_put(client->driver->owner);
 540        }
 541        up(&adap->clist_lock);
 542 }
 543
 544 static int __init i2c_init(void)
 545 {
 546         int retval;
 547
 548         retval = bus_register(&i2c_bus_type);
 549         if (retval)
 550                 return retval;
 551         retval = driver_register(&i2c_adapter_driver);
 552         if (retval)
 553                 return retval;
 554         return class_register(&i2c_adapter_class);
 555 }
 556
 557 static void __exit i2c_exit(void)
 558 {
 559         class_unregister(&i2c_adapter_class);
 560         driver_unregister(&i2c_adapter_driver);
 561         bus_unregister(&i2c_bus_type);
 562 }
 563
 564 subsys_initcall(i2c_init);
 565 module_exit(i2c_exit);
 566
 567 /* ----------------------------------------------------
 568  * the functional interface to the i2c busses.
 569  * ----------------------------------------------------
 570  */
 571
 572 int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
 573 {
 574         int ret;
 575
 576         if (adap->algo->master_xfer) {
 577 #ifdef DEBUG
 578                 for (ret = 0; ret < num; ret++) {
 579                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
 580                                 "len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
 581                                 'R' : 'W', msgs[ret].addr, msgs[ret].len);
 582                 }
 583 #endif
 584
 585                 down(&adap->bus_lock);
 586                 ret = adap->algo->master_xfer(adap,msgs,num);
 587                 up(&adap->bus_lock);
 588
 589                 return ret;
 590         } else {
 591                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
 592                 return -ENOSYS;
 593         }
 594 }
 595
 596 int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
 597 {
 598         int ret;
 599         struct i2c_adapter *adap=client->adapter;
 600         struct i2c_msg msg;
 601
 602         msg.addr = client->addr;
 603         msg.flags = client->flags & I2C_M_TEN;
 604         msg.len = count;
 605         msg.buf = (char *)buf;
 606
 607         ret = i2c_transfer(adap, &msg, 1);
 608
 609         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 610            transmitted, else error code. */
 611         return (ret == 1) ? count : ret;
 612 }
 613
 614 int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
 615 {
 616         struct i2c_adapter *adap=client->adapter;
 617         struct i2c_msg msg;
 618         int ret;
 619
 620         msg.addr = client->addr;
 621         msg.flags = client->flags & I2C_M_TEN;
 622         msg.flags |= I2C_M_RD;
 623         msg.len = count;
 624         msg.buf = buf;
 625
 626         ret = i2c_transfer(adap, &msg, 1);
 627
 628         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
 629            transmitted, else error code. */
 630         return (ret == 1) ? count : ret;
 631 }
 632
 633
 634 int i2c_control(struct i2c_client *client,
 635         unsigned int cmd, unsigned long arg)
 636 {
 637         int ret = 0;
 638         struct i2c_adapter *adap = client->adapter;
 639
 640         dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
 641         switch (cmd) {
 642                 case I2C_RETRIES:
 643                         adap->retries = arg;
 644                         break;
 645                 case I2C_TIMEOUT:
 646                         adap->timeout = arg;
 647                         break;
 648                 default:
 649                         if (adap->algo->algo_control!=NULL)
 650                                 ret = adap->algo->algo_control(adap,cmd,arg);
 651         }
 652         return ret;
 653 }
 654
 655 /* ----------------------------------------------------
 656  * the i2c address scanning function
 657  * Will not work for 10-bit addresses!
 658  * ----------------------------------------------------
 659  */
 660 static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
 661                              int (*found_proc) (struct i2c_adapter *, int, int))
 662 {
 663         int err;
 664
 665         /* Make sure the address is valid */
 666         if (addr < 0x03 || addr > 0x77) {
 667                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
 668                          addr);
 669                 return -EINVAL;
 670         }
 671
 672         /* Skip if already in use */
 673         if (i2c_check_addr(adapter, addr))
 674                 return 0;
 675
 676         /* Make sure there is something at this address, unless forced */
 677         if (kind < 0) {
 678                 if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 679                                    I2C_SMBUS_QUICK, NULL) < 0)
 680                         return 0;
 681
 682                 /* prevent 24RF08 corruption */
 683                 if ((addr & ~0x0f) == 0x50)
 684                         i2c_smbus_xfer(adapter, addr, 0, 0, 0,
 685                                        I2C_SMBUS_QUICK, NULL);
 686         }
 687
 688         /* Finally call the custom detection function */
 689         err = found_proc(adapter, addr, kind);
 690
 691         /* -ENODEV can be returned if there is a chip at the given address
 692            but it isn't supported by this chip driver. We catch it here as
 693            this isn't an error. */
 694         return (err == -ENODEV) ? 0 : err;
 695 }
 696
 697 int i2c_probe(struct i2c_adapter *adapter,
 698               struct i2c_client_address_data *address_data,
 699               int (*found_proc) (struct i2c_adapter *, int, int))
 700 {
 701         int i, err;
 702         int adap_id = i2c_adapter_id(adapter);
 703
 704         /* Force entries are done first, and are not affected by ignore
 705            entries */
 706         if (address_data->forces) {
 707                 unsigned short **forces = address_data->forces;
 708                 int kind;
 709
 710                 for (kind = 0; forces[kind]; kind++) {
 711                         for (i = 0; forces[kind][i] != I2C_CLIENT_END;
 712                              i += 2) {
 713                                 if (forces[kind][i] == adap_id
 714                                  || forces[kind][i] == ANY_I2C_BUS) {
 715                                         dev_dbg(&adapter->dev, "found force "
 716                                                 "parameter for adapter %d, "
 717                                                 "addr 0x%02x, kind %d\n",
 718                                                 adap_id, forces[kind][i + 1],
 719                                                 kind);
 720                                         err = i2c_probe_address(adapter,
 721                                                 forces[kind][i + 1],
 722                                                 kind, found_proc);
 723                                         if (err)
 724                                                 return err;
 725                                 }
 726                         }
 727                 }
 728         }
 729
 730         /* Stop here if we can't use SMBUS_QUICK */
 731         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
 732                 if (address_data->probe[0] == I2C_CLIENT_END
 733                  && address_data->normal_i2c[0] == I2C_CLIENT_END)
 734                         return 0;
 735
 736                 dev_warn(&adapter->dev, "SMBus Quick command not supported, "
 737                          "can't probe for chips\n");
 738                 return -1;
 739         }
 740
 741         /* Probe entries are done second, and are not affected by ignore
 742            entries either */
 743         for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
 744                 if (address_data->probe[i] == adap_id
 745                  || address_data->probe[i] == ANY_I2C_BUS) {
 746                         dev_dbg(&adapter->dev, "found probe parameter for "
 747                                 "adapter %d, addr 0x%02x\n", adap_id,
 748                                 address_data->probe[i + 1]);
 749                         err = i2c_probe_address(adapter,
 750                                                 address_data->probe[i + 1],
 751                                                 -1, found_proc);
 752                         if (err)
 753                                 return err;
 754                 }
 755         }
 756
 757         /* Normal entries are done last, unless shadowed by an ignore entry */
 758         for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
 759                 int j, ignore;
 760
 761                 ignore = 0;
 762                 for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
 763                      j += 2) {
 764                         if ((address_data->ignore[j] == adap_id ||
 765                              address_data->ignore[j] == ANY_I2C_BUS)
 766                          && address_data->ignore[j + 1]
 767                             == address_data->normal_i2c[i]) {
 768                                 dev_dbg(&adapter->dev, "found ignore "
 769                                         "parameter for adapter %d, "
 770                                         "addr 0x%02x\n", adap_id,
 771                                         address_data->ignore[j + 1]);
 772                         }
 773                         ignore = 1;
 774                         break;
 775                 }
 776                 if (ignore)
 777                         continue;
 778
 779                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
 780                         "addr 0x%02x\n", adap_id,
 781                         address_data->normal_i2c[i]);
 782                 err = i2c_probe_address(adapter, address_data->normal_i2c[i],
 783                                         -1, found_proc);
 784                 if (err)
 785                         return err;
 786         }
 787
 788         return 0;
 789 }
 790
 791 struct i2c_adapter* i2c_get_adapter(int id)
 792 {
 793         struct i2c_adapter *adapter;
 794
 795         down(&core_lists);
 796         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
 797         if (adapter && !try_module_get(adapter->owner))
 798                 adapter = NULL;
 799
 800         up(&core_lists);
 801         return adapter;
 802 }
 803
 804 void i2c_put_adapter(struct i2c_adapter *adap)
 805 {
 806         module_put(adap->owner);
 807 }
 808
 809 /* The SMBus parts */
 810
 811 #define POLY    (0x1070U << 3)
 812 static u8
 813 crc8(u16 data)
 814 {
 815         int i;
 816
 817         for(i = 0; i < 8; i++) {
 818                 if (data & 0x8000)
 819                         data = data ^ POLY;
 820                 data = data << 1;
 821         }
 822         return (u8)(data >> 8);
 823 }
 824
 825 /* Incremental CRC8 over count bytes in the array pointed to by p */
 826 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
 827 {
 828         int i;
 829
 830         for(i = 0; i < count; i++)
 831                 crc = crc8((crc ^ p[i]) << 8);
 832         return crc;
 833 }
 834
 835 /* Assume a 7-bit address, which is reasonable for SMBus */
 836 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
 837 {
 838         /* The address will be sent first */
 839         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
 840         pec = i2c_smbus_pec(pec, &addr, 1);
 841
 842         /* The data buffer follows */
 843         return i2c_smbus_pec(pec, msg->buf, msg->len);
 844 }
 845
 846 /* Used for write only transactions */
 847 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
 848 {
 849         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
 850         msg->len++;
 851 }
 852
 853 /* Return <0 on CRC error
 854    If there was a write before this read (most cases) we need to take the
 855    partial CRC from the write part into account.
 856    Note that this function does modify the message (we need to decrease the
 857    message length to hide the CRC byte from the caller). */
 858 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
 859 {
 860         u8 rpec = msg->buf[--msg->len];
 861         cpec = i2c_smbus_msg_pec(cpec, msg);
 862
 863         if (rpec != cpec) {
 864                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
 865                         rpec, cpec);
 866                 return -1;
 867         }
 868         return 0;
 869 }
 870
 871 s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
 872 {
 873         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 874                               value,0,I2C_SMBUS_QUICK,NULL);
 875 }
 876
 877 s32 i2c_smbus_read_byte(struct i2c_client *client)
 878 {
 879         union i2c_smbus_data data;
 880         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 881                            I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
 882                 return -1;
 883         else
 884                 return 0x0FF & data.byte;
 885 }
 886
 887 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
 888 {
 889         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 890                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 891 }
 892
 893 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
 894 {
 895         union i2c_smbus_data data;
 896         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 897                            I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
 898                 return -1;
 899         else
 900                 return 0x0FF & data.byte;
 901 }
 902
 903 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
 904 {
 905         union i2c_smbus_data data;
 906         data.byte = value;
 907         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 908                               I2C_SMBUS_WRITE,command,
 909                               I2C_SMBUS_BYTE_DATA,&data);
 910 }
 911
 912 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
 913 {
 914         union i2c_smbus_data data;
 915         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 916                            I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
 917                 return -1;
 918         else
 919                 return 0x0FFFF & data.word;
 920 }
 921
 922 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
 923 {
 924         union i2c_smbus_data data;
 925         data.word = value;
 926         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 927                               I2C_SMBUS_WRITE,command,
 928                               I2C_SMBUS_WORD_DATA,&data);
 929 }
 930
 931 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
 932                                u8 length, u8 *values)
 933 {
 934         union i2c_smbus_data data;
 935         int i;
 936         if (length > I2C_SMBUS_BLOCK_MAX)
 937                 length = I2C_SMBUS_BLOCK_MAX;
 938         for (i = 1; i <= length; i++)
 939                 data.block[i] = values[i-1];
 940         data.block[0] = length;
 941         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 942                               I2C_SMBUS_WRITE,command,
 943                               I2C_SMBUS_BLOCK_DATA,&data);
 944 }
 945
 946 /* Returns the number of read bytes */
 947 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
 948 {
 949         union i2c_smbus_data data;
 950         int i;
 951         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
 952                               I2C_SMBUS_READ,command,
 953                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
 954                 return -1;
 955         else {
 956                 for (i = 1; i <= data.block[0]; i++)
 957                         values[i-1] = data.block[i];
 958                 return data.block[0];
 959         }
 960 }
 961
 962 /* Simulate a SMBus command using the i2c protocol
 963    No checking of parameters is done!  */
 964 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
 965                                    unsigned short flags,
 966                                    char read_write, u8 command, int size,
 967                                    union i2c_smbus_data * data)
 968 {
 969         /* So we need to generate a series of msgs. In the case of writing, we
 970           need to use only one message; when reading, we need two. We initialize
 971           most things with sane defaults, to keep the code below somewhat
 972           simpler. */
 973         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
 974         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
 975         int num = read_write == I2C_SMBUS_READ?2:1;
 976         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
 977                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
 978                                 };
 979         int i;
 980         u8 partial_pec = 0;
 981
 982         msgbuf0[0] = command;
 983         switch(size) {
 984         case I2C_SMBUS_QUICK:
 985                 msg[0].len = 0;
 986                 /* Special case: The read/write field is used as data */
 987                 msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
 988                 num = 1;
 989                 break;
 990         case I2C_SMBUS_BYTE:
 991                 if (read_write == I2C_SMBUS_READ) {
 992                         /* Special case: only a read! */
 993                         msg[0].flags = I2C_M_RD | flags;
 994                         num = 1;
 995                 }
 996                 break;
 997         case I2C_SMBUS_BYTE_DATA:
 998                 if (read_write == I2C_SMBUS_READ)
 999                         msg[1].len = 1;
1000                 else {
1001                         msg[0].len = 2;
1002                         msgbuf0[1] = data->byte;
1003                 }
1004                 break;
1005         case I2C_SMBUS_WORD_DATA:
1006                 if (read_write == I2C_SMBUS_READ)
1007                         msg[1].len = 2;
1008                 else {
1009                         msg[0].len=3;
1010                         msgbuf0[1] = data->word & 0xff;
1011                         msgbuf0[2] = (data->word >> 8) & 0xff;
1012                 }
1013                 break;
1014         case I2C_SMBUS_PROC_CALL:
1015                 num = 2; /* Special case */
1016                 read_write = I2C_SMBUS_READ;
1017                 msg[0].len = 3;
1018                 msg[1].len = 2;
1019                 msgbuf0[1] = data->word & 0xff;
1020                 msgbuf0[2] = (data->word >> 8) & 0xff;
1021                 break;
1022         case I2C_SMBUS_BLOCK_DATA:
1023                 if (read_write == I2C_SMBUS_READ) {
1024                         dev_err(&adapter->dev, "Block read not supported "
1025                                "under I2C emulation!\n");
1026                         return -1;
1027                 } else {
1028                         msg[0].len = data->block[0] + 2;
1029                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1030                                 dev_err(&adapter->dev, "smbus_access called with "
1031                                        "invalid block write size (%d)\n",
1032                                        data->block[0]);
1033                                 return -1;
1034                         }
1035                         for (i = 1; i < msg[0].len; i++)
1036                                 msgbuf0[i] = data->block[i-1];
1037                 }
1038                 break;
1039         case I2C_SMBUS_BLOCK_PROC_CALL:
1040                 dev_dbg(&adapter->dev, "Block process call not supported "
1041                        "under I2C emulation!\n");
1042                 return -1;
1043         case I2C_SMBUS_I2C_BLOCK_DATA:
1044                 if (read_write == I2C_SMBUS_READ) {
1045                         msg[1].len = I2C_SMBUS_BLOCK_MAX;
1046                 } else {
1047                         msg[0].len = data->block[0] + 1;
1048                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
1049                                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
1050                                        "invalid block write size (%d)\n",
1051                                        data->block[0]);
1052                                 return -1;
1053                         }
1054                         for (i = 1; i <= data->block[0]; i++)
1055                                 msgbuf0[i] = data->block[i];
1056                 }
1057                 break;
1058         default:
1059                 dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
1060                        size);
1061                 return -1;
1062         }
1063
1064         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
1065                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
1066         if (i) {
1067                 /* Compute PEC if first message is a write */
1068                 if (!(msg[0].flags & I2C_M_RD)) {
1069                         if (num == 1) /* Write only */
1070                                 i2c_smbus_add_pec(&msg[0]);
1071                         else /* Write followed by read */
1072                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
1073                 }
1074                 /* Ask for PEC if last message is a read */
1075                 if (msg[num-1].flags & I2C_M_RD)
1076                         msg[num-1].len++;
1077         }
1078
1079         if (i2c_transfer(adapter, msg, num) < 0)
1080                 return -1;
1081
1082         /* Check PEC if last message is a read */
1083         if (i && (msg[num-1].flags & I2C_M_RD)) {
1084                 if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
1085                         return -1;
1086         }
1087
1088         if (read_write == I2C_SMBUS_READ)
1089                 switch(size) {
1090                         case I2C_SMBUS_BYTE:
1091                                 data->byte = msgbuf0[0];
1092                                 break;
1093                         case I2C_SMBUS_BYTE_DATA:
1094                                 data->byte = msgbuf1[0];
1095                                 break;
1096                         case I2C_SMBUS_WORD_DATA:
1097                         case I2C_SMBUS_PROC_CALL:
1098                                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
1099                                 break;
1100                         case I2C_SMBUS_I2C_BLOCK_DATA:
1101                                 /* fixed at 32 for now */
1102                                 data->block[0] = I2C_SMBUS_BLOCK_MAX;
1103                                 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
1104                                         data->block[i+1] = msgbuf1[i];
1105                                 break;
1106                 }
1107         return 0;
1108 }
1109
1110
1111 s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
1112                    char read_write, u8 command, int size,
1113                    union i2c_smbus_data * data)
1114 {
1115         s32 res;
1116
1117         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
1118
1119         if (adapter->algo->smbus_xfer) {
1120                 down(&adapter->bus_lock);
1121                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
1122                                                 command,size,data);
1123                 up(&adapter->bus_lock);
1124         } else
1125                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
1126                                               command,size,data);
1127
1128         return res;
1129 }
1130
1131
1132 /* Next four are needed by i2c-isa */
1133 EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);
1134 EXPORT_SYMBOL_GPL(i2c_adapter_driver);
1135 EXPORT_SYMBOL_GPL(i2c_adapter_class);
1136 EXPORT_SYMBOL_GPL(i2c_bus_type);
1137
1138 EXPORT_SYMBOL(i2c_add_adapter);
1139 EXPORT_SYMBOL(i2c_del_adapter);
1140 EXPORT_SYMBOL(i2c_add_driver);
1141 EXPORT_SYMBOL(i2c_del_driver);
1142 EXPORT_SYMBOL(i2c_attach_client);
1143 EXPORT_SYMBOL(i2c_detach_client);
1144 EXPORT_SYMBOL(i2c_use_client);
1145 EXPORT_SYMBOL(i2c_release_client);
1146 EXPORT_SYMBOL(i2c_clients_command);
1147 EXPORT_SYMBOL(i2c_check_addr);
1148
1149 EXPORT_SYMBOL(i2c_master_send);
1150 EXPORT_SYMBOL(i2c_master_recv);
1151 EXPORT_SYMBOL(i2c_control);
1152 EXPORT_SYMBOL(i2c_transfer);
1153 EXPORT_SYMBOL(i2c_get_adapter);
1154 EXPORT_SYMBOL(i2c_put_adapter);
1155 EXPORT_SYMBOL(i2c_probe);
1156
1157 EXPORT_SYMBOL(i2c_smbus_xfer);
1158 EXPORT_SYMBOL(i2c_smbus_write_quick);
1159 EXPORT_SYMBOL(i2c_smbus_read_byte);
1160 EXPORT_SYMBOL(i2c_smbus_write_byte);
1161 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1162 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1163 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1164 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1165 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1166 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1167
1168 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
1169 MODULE_DESCRIPTION("I2C-Bus main module");
1170 MODULE_LICENSE("GPL");