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