SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/i2c/i2c-core.c

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