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