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    Mux support by Rodolfo Giometti <giometti@enneenne.com> and
  25    Michael Lawnick <michael.lawnick.ext@nsn.com> */
  26
  27 #include <linux/module.h>
  28 #include <linux/kernel.h>
  29 #include <linux/errno.h>
  30 #include <linux/slab.h>
  31 #include <linux/i2c.h>
  32 #include <linux/init.h>
  33 #include <linux/idr.h>
  34 #include <linux/mutex.h>
  35 #include <linux/of_device.h>
  36 #include <linux/completion.h>
  37 #include <linux/hardirq.h>
  38 #include <linux/irqflags.h>
  39 #include <linux/rwsem.h>
  40 #include <linux/pm_runtime.h>
  41 #include <asm/uaccess.h>
  42
  43 #include "i2c-core.h"
  44
  45
  46 /* core_lock protects i2c_adapter_idr, and guarantees
  47    that device detection, deletion of detected devices, and attach_adapter
  48    and detach_adapter calls are serialized */
  49 static DEFINE_MUTEX(core_lock);
  50 static DEFINE_IDR(i2c_adapter_idr);
  51
  52 static struct device_type i2c_client_type;
  53 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
  54
  55 /* ------------------------------------------------------------------------- */
  56
  57 static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
  58                                                 const struct i2c_client *client)
  59 {
  60         while (id->name[0]) {
  61                 if (strcmp(client->name, id->name) == 0)
  62                         return id;
  63                 id++;
  64         }
  65         return NULL;
  66 }
  67
  68 static int i2c_device_match(struct device *dev, struct device_driver *drv)
  69 {
  70         struct i2c_client       *client = i2c_verify_client(dev);
  71         struct i2c_driver       *driver;
  72
  73         if (!client)
  74                 return 0;
  75
  76         /* Attempt an OF style match */
  77         if (of_driver_match_device(dev, drv))
  78                 return 1;
  79
  80         driver = to_i2c_driver(drv);
  81         /* match on an id table if there is one */
  82         if (driver->id_table)
  83                 return i2c_match_id(driver->id_table, client) != NULL;
  84
  85         return 0;
  86 }
  87
  88 #ifdef  CONFIG_HOTPLUG
  89
  90 /* uevent helps with hotplug: modprobe -q $(MODALIAS) */
  91 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  92 {
  93         struct i2c_client       *client = to_i2c_client(dev);
  94
  95         if (add_uevent_var(env, "MODALIAS=%s%s",
  96                            I2C_MODULE_PREFIX, client->name))
  97                 return -ENOMEM;
  98         dev_dbg(dev, "uevent\n");
  99         return 0;
 100 }
 101
 102 #else
 103 #define i2c_device_uevent       NULL
 104 #endif  /* CONFIG_HOTPLUG */
 105
 106 static int i2c_device_probe(struct device *dev)
 107 {
 108         struct i2c_client       *client = i2c_verify_client(dev);
 109         struct i2c_driver       *driver;
 110         int status;
 111
 112         if (!client)
 113                 return 0;
 114
 115         driver = to_i2c_driver(dev->driver);
 116         if (!driver->probe || !driver->id_table)
 117                 return -ENODEV;
 118         client->driver = driver;
 119         if (!device_can_wakeup(&client->dev))
 120                 device_init_wakeup(&client->dev,
 121                                         client->flags & I2C_CLIENT_WAKE);
 122         dev_dbg(dev, "probe\n");
 123
 124         status = driver->probe(client, i2c_match_id(driver->id_table, client));
 125         if (status) {
 126                 client->driver = NULL;
 127                 i2c_set_clientdata(client, NULL);
 128         }
 129         return status;
 130 }
 131
 132 static int i2c_device_remove(struct device *dev)
 133 {
 134         struct i2c_client       *client = i2c_verify_client(dev);
 135         struct i2c_driver       *driver;
 136         int                     status;
 137
 138         if (!client || !dev->driver)
 139                 return 0;
 140
 141         driver = to_i2c_driver(dev->driver);
 142         if (driver->remove) {
 143                 dev_dbg(dev, "remove\n");
 144                 status = driver->remove(client);
 145         } else {
 146                 dev->driver = NULL;
 147                 status = 0;
 148         }
 149         if (status == 0) {
 150                 client->driver = NULL;
 151                 i2c_set_clientdata(client, NULL);
 152         }
 153         return status;
 154 }
 155
 156 static void i2c_device_shutdown(struct device *dev)
 157 {
 158         struct i2c_client *client = i2c_verify_client(dev);
 159         struct i2c_driver *driver;
 160
 161         if (!client || !dev->driver)
 162                 return;
 163         driver = to_i2c_driver(dev->driver);
 164         if (driver->shutdown)
 165                 driver->shutdown(client);
 166 }
 167
 168 #ifdef CONFIG_PM_SLEEP
 169 static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg)
 170 {
 171         struct i2c_client *client = i2c_verify_client(dev);
 172         struct i2c_driver *driver;
 173
 174         if (!client || !dev->driver)
 175                 return 0;
 176         driver = to_i2c_driver(dev->driver);
 177         if (!driver->suspend)
 178                 return 0;
 179         return driver->suspend(client, mesg);
 180 }
 181
 182 static int i2c_legacy_resume(struct device *dev)
 183 {
 184         struct i2c_client *client = i2c_verify_client(dev);
 185         struct i2c_driver *driver;
 186
 187         if (!client || !dev->driver)
 188                 return 0;
 189         driver = to_i2c_driver(dev->driver);
 190         if (!driver->resume)
 191                 return 0;
 192         return driver->resume(client);
 193 }
 194
 195 static int i2c_device_pm_suspend(struct device *dev)
 196 {
 197         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 198
 199         if (pm)
 200                 return pm_generic_suspend(dev);
 201         else
 202                 return i2c_legacy_suspend(dev, PMSG_SUSPEND);
 203 }
 204
 205 static int i2c_device_pm_resume(struct device *dev)
 206 {
 207         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 208
 209         if (pm)
 210                 return pm_generic_resume(dev);
 211         else
 212                 return i2c_legacy_resume(dev);
 213 }
 214
 215 static int i2c_device_pm_freeze(struct device *dev)
 216 {
 217         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 218
 219         if (pm)
 220                 return pm_generic_freeze(dev);
 221         else
 222                 return i2c_legacy_suspend(dev, PMSG_FREEZE);
 223 }
 224
 225 static int i2c_device_pm_thaw(struct device *dev)
 226 {
 227         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 228
 229         if (pm)
 230                 return pm_generic_thaw(dev);
 231         else
 232                 return i2c_legacy_resume(dev);
 233 }
 234
 235 static int i2c_device_pm_poweroff(struct device *dev)
 236 {
 237         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 238
 239         if (pm)
 240                 return pm_generic_poweroff(dev);
 241         else
 242                 return i2c_legacy_suspend(dev, PMSG_HIBERNATE);
 243 }
 244
 245 static int i2c_device_pm_restore(struct device *dev)
 246 {
 247         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 248
 249         if (pm)
 250                 return pm_generic_restore(dev);
 251         else
 252                 return i2c_legacy_resume(dev);
 253 }
 254 #else /* !CONFIG_PM_SLEEP */
 255 #define i2c_device_pm_suspend   NULL
 256 #define i2c_device_pm_resume    NULL
 257 #define i2c_device_pm_freeze    NULL
 258 #define i2c_device_pm_thaw      NULL
 259 #define i2c_device_pm_poweroff  NULL
 260 #define i2c_device_pm_restore   NULL
 261 #endif /* !CONFIG_PM_SLEEP */
 262
 263 static void i2c_client_dev_release(struct device *dev)
 264 {
 265         kfree(to_i2c_client(dev));
 266 }
 267
 268 static ssize_t
 269 show_name(struct device *dev, struct device_attribute *attr, char *buf)
 270 {
 271         return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
 272                        to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
 273 }
 274
 275 static ssize_t
 276 show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 277 {
 278         struct i2c_client *client = to_i2c_client(dev);
 279         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
 280 }
 281
 282 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 283 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 284
 285 static struct attribute *i2c_dev_attrs[] = {
 286         &dev_attr_name.attr,
 287         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
 288         &dev_attr_modalias.attr,
 289         NULL
 290 };
 291
 292 static struct attribute_group i2c_dev_attr_group = {
 293         .attrs          = i2c_dev_attrs,
 294 };
 295
 296 static const struct attribute_group *i2c_dev_attr_groups[] = {
 297         &i2c_dev_attr_group,
 298         NULL
 299 };
 300
 301 static const struct dev_pm_ops i2c_device_pm_ops = {
 302         .suspend = i2c_device_pm_suspend,
 303         .resume = i2c_device_pm_resume,
 304         .freeze = i2c_device_pm_freeze,
 305         .thaw = i2c_device_pm_thaw,
 306         .poweroff = i2c_device_pm_poweroff,
 307         .restore = i2c_device_pm_restore,
 308         SET_RUNTIME_PM_OPS(
 309                 pm_generic_runtime_suspend,
 310                 pm_generic_runtime_resume,
 311                 pm_generic_runtime_idle
 312         )
 313 };
 314
 315 struct bus_type i2c_bus_type = {
 316         .name           = "i2c",
 317         .match          = i2c_device_match,
 318         .probe          = i2c_device_probe,
 319         .remove         = i2c_device_remove,
 320         .shutdown       = i2c_device_shutdown,
 321         .pm             = &i2c_device_pm_ops,
 322 };
 323 EXPORT_SYMBOL_GPL(i2c_bus_type);
 324
 325 static struct device_type i2c_client_type = {
 326         .groups         = i2c_dev_attr_groups,
 327         .uevent         = i2c_device_uevent,
 328         .release        = i2c_client_dev_release,
 329 };
 330
 331
 332 /**
 333  * i2c_verify_client - return parameter as i2c_client, or NULL
 334  * @dev: device, probably from some driver model iterator
 335  *
 336  * When traversing the driver model tree, perhaps using driver model
 337  * iterators like @device_for_each_child(), you can't assume very much
 338  * about the nodes you find.  Use this function to avoid oopses caused
 339  * by wrongly treating some non-I2C device as an i2c_client.
 340  */
 341 struct i2c_client *i2c_verify_client(struct device *dev)
 342 {
 343         return (dev->type == &i2c_client_type)
 344                         ? to_i2c_client(dev)
 345                         : NULL;
 346 }
 347 EXPORT_SYMBOL(i2c_verify_client);
 348
 349
 350 /* This is a permissive address validity check, I2C address map constraints
 351  * are purposely not enforced, except for the general call address. */
 352 static int i2c_check_client_addr_validity(const struct i2c_client *client)
 353 {
 354         if (client->flags & I2C_CLIENT_TEN) {
 355                 /* 10-bit address, all values are valid */
 356                 if (client->addr > 0x3ff)
 357                         return -EINVAL;
 358         } else {
 359                 /* 7-bit address, reject the general call address */
 360                 if (client->addr == 0x00 || client->addr > 0x7f)
 361                         return -EINVAL;
 362         }
 363         return 0;
 364 }
 365
 366 /* And this is a strict address validity check, used when probing. If a
 367  * device uses a reserved address, then it shouldn't be probed. 7-bit
 368  * addressing is assumed, 10-bit address devices are rare and should be
 369  * explicitly enumerated. */
 370 static int i2c_check_addr_validity(unsigned short addr)
 371 {
 372         /*
 373          * Reserved addresses per I2C specification:
 374          *  0x00       General call address / START byte
 375          *  0x01       CBUS address
 376          *  0x02       Reserved for different bus format
 377          *  0x03       Reserved for future purposes
 378          *  0x04-0x07  Hs-mode master code
 379          *  0x78-0x7b  10-bit slave addressing
 380          *  0x7c-0x7f  Reserved for future purposes
 381          */
 382         if (addr < 0x08 || addr > 0x77)
 383                 return -EINVAL;
 384         return 0;
 385 }
 386
 387 static int __i2c_check_addr_busy(struct device *dev, void *addrp)
 388 {
 389         struct i2c_client       *client = i2c_verify_client(dev);
 390         int                     addr = *(int *)addrp;
 391
 392         if (client && client->addr == addr)
 393                 return -EBUSY;
 394         return 0;
 395 }
 396
 397 /* walk up mux tree */
 398 static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr)
 399 {
 400         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
 401         int result;
 402
 403         result = device_for_each_child(&adapter->dev, &addr,
 404                                         __i2c_check_addr_busy);
 405
 406         if (!result && parent)
 407                 result = i2c_check_mux_parents(parent, addr);
 408
 409         return result;
 410 }
 411
 412 /* recurse down mux tree */
 413 static int i2c_check_mux_children(struct device *dev, void *addrp)
 414 {
 415         int result;
 416
 417         if (dev->type == &i2c_adapter_type)
 418                 result = device_for_each_child(dev, addrp,
 419                                                 i2c_check_mux_children);
 420         else
 421                 result = __i2c_check_addr_busy(dev, addrp);
 422
 423         return result;
 424 }
 425
 426 static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr)
 427 {
 428         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
 429         int result = 0;
 430
 431         if (parent)
 432                 result = i2c_check_mux_parents(parent, addr);
 433
 434         if (!result)
 435                 result = device_for_each_child(&adapter->dev, &addr,
 436                                                 i2c_check_mux_children);
 437
 438         return result;
 439 }
 440
 441 /**
 442  * i2c_lock_adapter - Get exclusive access to an I2C bus segment
 443  * @adapter: Target I2C bus segment
 444  */
 445 void i2c_lock_adapter(struct i2c_adapter *adapter)
 446 {
 447         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
 448
 449         if (parent)
 450                 i2c_lock_adapter(parent);
 451         else
 452                 rt_mutex_lock(&adapter->bus_lock);
 453 }
 454 EXPORT_SYMBOL_GPL(i2c_lock_adapter);
 455
 456 /**
 457  * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment
 458  * @adapter: Target I2C bus segment
 459  */
 460 static int i2c_trylock_adapter(struct i2c_adapter *adapter)
 461 {
 462         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
 463
 464         if (parent)
 465                 return i2c_trylock_adapter(parent);
 466         else
 467                 return rt_mutex_trylock(&adapter->bus_lock);
 468 }
 469
 470 /**
 471  * i2c_unlock_adapter - Release exclusive access to an I2C bus segment
 472  * @adapter: Target I2C bus segment
 473  */
 474 void i2c_unlock_adapter(struct i2c_adapter *adapter)
 475 {
 476         struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
 477
 478         if (parent)
 479                 i2c_unlock_adapter(parent);
 480         else
 481                 rt_mutex_unlock(&adapter->bus_lock);
 482 }
 483 EXPORT_SYMBOL_GPL(i2c_unlock_adapter);
 484
 485 /**
 486  * i2c_new_device - instantiate an i2c device
 487  * @adap: the adapter managing the device
 488  * @info: describes one I2C device; bus_num is ignored
 489  * Context: can sleep
 490  *
 491  * Create an i2c device. Binding is handled through driver model
 492  * probe()/remove() methods.  A driver may be bound to this device when we
 493  * return from this function, or any later moment (e.g. maybe hotplugging will
 494  * load the driver module).  This call is not appropriate for use by mainboard
 495  * initialization logic, which usually runs during an arch_initcall() long
 496  * before any i2c_adapter could exist.
 497  *
 498  * This returns the new i2c client, which may be saved for later use with
 499  * i2c_unregister_device(); or NULL to indicate an error.
 500  */
 501 struct i2c_client *
 502 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 503 {
 504         struct i2c_client       *client;
 505         int                     status;
 506
 507         client = kzalloc(sizeof *client, GFP_KERNEL);
 508         if (!client)
 509                 return NULL;
 510
 511         client->adapter = adap;
 512
 513         client->dev.platform_data = info->platform_data;
 514
 515         if (info->archdata)
 516                 client->dev.archdata = *info->archdata;
 517
 518         client->flags = info->flags;
 519         client->addr = info->addr;
 520         client->irq = info->irq;
 521
 522         strlcpy(client->name, info->type, sizeof(client->name));
 523
 524         /* Check for address validity */
 525         status = i2c_check_client_addr_validity(client);
 526         if (status) {
 527                 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
 528                         client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
 529                 goto out_err_silent;
 530         }
 531
 532         /* Check for address business */
 533         status = i2c_check_addr_busy(adap, client->addr);
 534         if (status)
 535                 goto out_err;
 536
 537         client->dev.parent = &client->adapter->dev;
 538         client->dev.bus = &i2c_bus_type;
 539         client->dev.type = &i2c_client_type;
 540         client->dev.of_node = info->of_node;
 541
 542         dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
 543                      client->addr);
 544         status = device_register(&client->dev);
 545         if (status)
 546                 goto out_err;
 547
 548         dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
 549                 client->name, dev_name(&client->dev));
 550
 551         return client;
 552
 553 out_err:
 554         dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
 555                 "(%d)\n", client->name, client->addr, status);
 556 out_err_silent:
 557         kfree(client);
 558         return NULL;
 559 }
 560 EXPORT_SYMBOL_GPL(i2c_new_device);
 561
 562
 563 /**
 564  * i2c_unregister_device - reverse effect of i2c_new_device()
 565  * @client: value returned from i2c_new_device()
 566  * Context: can sleep
 567  */
 568 void i2c_unregister_device(struct i2c_client *client)
 569 {
 570         device_unregister(&client->dev);
 571 }
 572 EXPORT_SYMBOL_GPL(i2c_unregister_device);
 573
 574
 575 static const struct i2c_device_id dummy_id[] = {
 576         { "dummy", 0 },
 577         { },
 578 };
 579
 580 static int dummy_probe(struct i2c_client *client,
 581                        const struct i2c_device_id *id)
 582 {
 583         return 0;
 584 }
 585
 586 static int dummy_remove(struct i2c_client *client)
 587 {
 588         return 0;
 589 }
 590
 591 static struct i2c_driver dummy_driver = {
 592         .driver.name    = "dummy",
 593         .probe          = dummy_probe,
 594         .remove         = dummy_remove,
 595         .id_table       = dummy_id,
 596 };
 597
 598 /**
 599  * i2c_new_dummy - return a new i2c device bound to a dummy driver
 600  * @adapter: the adapter managing the device
 601  * @address: seven bit address to be used
 602  * Context: can sleep
 603  *
 604  * This returns an I2C client bound to the "dummy" driver, intended for use
 605  * with devices that consume multiple addresses.  Examples of such chips
 606  * include various EEPROMS (like 24c04 and 24c08 models).
 607  *
 608  * These dummy devices have two main uses.  First, most I2C and SMBus calls
 609  * except i2c_transfer() need a client handle; the dummy will be that handle.
 610  * And second, this prevents the specified address from being bound to a
 611  * different driver.
 612  *
 613  * This returns the new i2c client, which should be saved for later use with
 614  * i2c_unregister_device(); or NULL to indicate an error.
 615  */
 616 struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address)
 617 {
 618         struct i2c_board_info info = {
 619                 I2C_BOARD_INFO("dummy", address),
 620         };
 621
 622         return i2c_new_device(adapter, &info);
 623 }
 624 EXPORT_SYMBOL_GPL(i2c_new_dummy);
 625
 626 /* ------------------------------------------------------------------------- */
 627
 628 /* I2C bus adapters -- one roots each I2C or SMBUS segment */
 629
 630 static void i2c_adapter_dev_release(struct device *dev)
 631 {
 632         struct i2c_adapter *adap = to_i2c_adapter(dev);
 633         complete(&adap->dev_released);
 634 }
 635
 636 /*
 637  * Let users instantiate I2C devices through sysfs. This can be used when
 638  * platform initialization code doesn't contain the proper data for
 639  * whatever reason. Also useful for drivers that do device detection and
 640  * detection fails, either because the device uses an unexpected address,
 641  * or this is a compatible device with different ID register values.
 642  *
 643  * Parameter checking may look overzealous, but we really don't want
 644  * the user to provide incorrect parameters.
 645  */
 646 static ssize_t
 647 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
 648                      const char *buf, size_t count)
 649 {
 650         struct i2c_adapter *adap = to_i2c_adapter(dev);
 651         struct i2c_board_info info;
 652         struct i2c_client *client;
 653         char *blank, end;
 654         int res;
 655
 656         memset(&info, 0, sizeof(struct i2c_board_info));
 657
 658         blank = strchr(buf, ' ');
 659         if (!blank) {
 660                 dev_err(dev, "%s: Missing parameters\n", "new_device");
 661                 return -EINVAL;
 662         }
 663         if (blank - buf > I2C_NAME_SIZE - 1) {
 664                 dev_err(dev, "%s: Invalid device name\n", "new_device");
 665                 return -EINVAL;
 666         }
 667         memcpy(info.type, buf, blank - buf);
 668
 669         /* Parse remaining parameters, reject extra parameters */
 670         res = sscanf(++blank, "%hi%c", &info.addr, &end);
 671         if (res < 1) {
 672                 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
 673                 return -EINVAL;
 674         }
 675         if (res > 1  && end != '\n') {
 676                 dev_err(dev, "%s: Extra parameters\n", "new_device");
 677                 return -EINVAL;
 678         }
 679
 680         client = i2c_new_device(adap, &info);
 681         if (!client)
 682                 return -EINVAL;
 683
 684         /* Keep track of the added device */
 685         mutex_lock(&adap->userspace_clients_lock);
 686         list_add_tail(&client->detected, &adap->userspace_clients);
 687         mutex_unlock(&adap->userspace_clients_lock);
 688         dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
 689                  info.type, info.addr);
 690
 691         return count;
 692 }
 693
 694 /*
 695  * And of course let the users delete the devices they instantiated, if
 696  * they got it wrong. This interface can only be used to delete devices
 697  * instantiated by i2c_sysfs_new_device above. This guarantees that we
 698  * don't delete devices to which some kernel code still has references.
 699  *
 700  * Parameter checking may look overzealous, but we really don't want
 701  * the user to delete the wrong device.
 702  */
 703 static ssize_t
 704 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
 705                         const char *buf, size_t count)
 706 {
 707         struct i2c_adapter *adap = to_i2c_adapter(dev);
 708         struct i2c_client *client, *next;
 709         unsigned short addr;
 710         char end;
 711         int res;
 712
 713         /* Parse parameters, reject extra parameters */
 714         res = sscanf(buf, "%hi%c", &addr, &end);
 715         if (res < 1) {
 716                 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
 717                 return -EINVAL;
 718         }
 719         if (res > 1  && end != '\n') {
 720                 dev_err(dev, "%s: Extra parameters\n", "delete_device");
 721                 return -EINVAL;
 722         }
 723
 724         /* Make sure the device was added through sysfs */
 725         res = -ENOENT;
 726         mutex_lock(&adap->userspace_clients_lock);
 727         list_for_each_entry_safe(client, next, &adap->userspace_clients,
 728                                  detected) {
 729                 if (client->addr == addr) {
 730                         dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
 731                                  "delete_device", client->name, client->addr);
 732
 733                         list_del(&client->detected);
 734                         i2c_unregister_device(client);
 735                         res = count;
 736                         break;
 737                 }
 738         }
 739         mutex_unlock(&adap->userspace_clients_lock);
 740
 741         if (res < 0)
 742                 dev_err(dev, "%s: Can't find device in list\n",
 743                         "delete_device");
 744         return res;
 745 }
 746
 747 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 748 static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
 749
 750 static struct attribute *i2c_adapter_attrs[] = {
 751         &dev_attr_name.attr,
 752         &dev_attr_new_device.attr,
 753         &dev_attr_delete_device.attr,
 754         NULL
 755 };
 756
 757 static struct attribute_group i2c_adapter_attr_group = {
 758         .attrs          = i2c_adapter_attrs,
 759 };
 760
 761 static const struct attribute_group *i2c_adapter_attr_groups[] = {
 762         &i2c_adapter_attr_group,
 763         NULL
 764 };
 765
 766 struct device_type i2c_adapter_type = {
 767         .groups         = i2c_adapter_attr_groups,
 768         .release        = i2c_adapter_dev_release,
 769 };
 770 EXPORT_SYMBOL_GPL(i2c_adapter_type);
 771
 772 #ifdef CONFIG_I2C_COMPAT
 773 static struct class_compat *i2c_adapter_compat_class;
 774 #endif
 775
 776 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 777 {
 778         struct i2c_devinfo      *devinfo;
 779
 780         down_read(&__i2c_board_lock);
 781         list_for_each_entry(devinfo, &__i2c_board_list, list) {
 782                 if (devinfo->busnum == adapter->nr
 783                                 && !i2c_new_device(adapter,
 784                                                 &devinfo->board_info))
 785                         dev_err(&adapter->dev,
 786                                 "Can't create device at 0x%02x\n",
 787                                 devinfo->board_info.addr);
 788         }
 789         up_read(&__i2c_board_lock);
 790 }
 791
 792 static int i2c_do_add_adapter(struct i2c_driver *driver,
 793                               struct i2c_adapter *adap)
 794 {
 795         /* Detect supported devices on that bus, and instantiate them */
 796         i2c_detect(adap, driver);
 797
 798         /* Let legacy drivers scan this bus for matching devices */
 799         if (driver->attach_adapter) {
 800                 dev_warn(&adap->dev, "attach_adapter method is deprecated\n");
 801                 dev_warn(&adap->dev, "Please use another way to instantiate "
 802                          "your i2c_client\n");
 803                 /* We ignore the return code; if it fails, too bad */
 804                 driver->attach_adapter(adap);
 805         }
 806         return 0;
 807 }
 808
 809 static int __process_new_adapter(struct device_driver *d, void *data)
 810 {
 811         return i2c_do_add_adapter(to_i2c_driver(d), data);
 812 }
 813
 814 static int i2c_register_adapter(struct i2c_adapter *adap)
 815 {
 816         int res = 0;
 817
 818         /* Can't register until after driver model init */
 819         if (unlikely(WARN_ON(!i2c_bus_type.p))) {
 820                 res = -EAGAIN;
 821                 goto out_list;
 822         }
 823
 824         /* Sanity checks */
 825         if (unlikely(adap->name[0] == '\0')) {
 826                 pr_err("i2c-core: Attempt to register an adapter with "
 827                        "no name!\n");
 828                 return -EINVAL;
 829         }
 830         if (unlikely(!adap->algo)) {
 831                 pr_err("i2c-core: Attempt to register adapter '%s' with "
 832                        "no algo!\n", adap->name);
 833                 return -EINVAL;
 834         }
 835
 836         rt_mutex_init(&adap->bus_lock);
 837         mutex_init(&adap->userspace_clients_lock);
 838         INIT_LIST_HEAD(&adap->userspace_clients);
 839
 840         /* Set default timeout to 1 second if not already set */
 841         if (adap->timeout == 0)
 842                 adap->timeout = HZ;
 843
 844         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
 845         adap->dev.bus = &i2c_bus_type;
 846         adap->dev.type = &i2c_adapter_type;
 847         res = device_register(&adap->dev);
 848         if (res)
 849                 goto out_list;
 850
 851         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 852
 853 #ifdef CONFIG_I2C_COMPAT
 854         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
 855                                        adap->dev.parent);
 856         if (res)
 857                 dev_warn(&adap->dev,
 858                          "Failed to create compatibility class link\n");
 859 #endif
 860
 861         /* create pre-declared device nodes */
 862         if (adap->nr < __i2c_first_dynamic_bus_num)
 863                 i2c_scan_static_board_info(adap);
 864
 865         /* Notify drivers */
 866         mutex_lock(&core_lock);
 867         bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
 868         mutex_unlock(&core_lock);
 869
 870         return 0;
 871
 872 out_list:
 873         mutex_lock(&core_lock);
 874         idr_remove(&i2c_adapter_idr, adap->nr);
 875         mutex_unlock(&core_lock);
 876         return res;
 877 }
 878
 879 /**
 880  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 881  * @adapter: the adapter to add
 882  * Context: can sleep
 883  *
 884  * This routine is used to declare an I2C adapter when its bus number
 885  * doesn't matter.  Examples: for I2C adapters dynamically added by
 886  * USB links or PCI plugin cards.
 887  *
 888  * When this returns zero, a new bus number was allocated and stored
 889  * in adap->nr, and the specified adapter became available for clients.
 890  * Otherwise, a negative errno value is returned.
 891  */
 892 int i2c_add_adapter(struct i2c_adapter *adapter)
 893 {
 894         int     id, res = 0;
 895
 896 retry:
 897         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 898                 return -ENOMEM;
 899
 900         mutex_lock(&core_lock);
 901         /* "above" here means "above or equal to", sigh */
 902         res = idr_get_new_above(&i2c_adapter_idr, adapter,
 903                                 __i2c_first_dynamic_bus_num, &id);
 904         mutex_unlock(&core_lock);
 905
 906         if (res < 0) {
 907                 if (res == -EAGAIN)
 908                         goto retry;
 909                 return res;
 910         }
 911
 912         adapter->nr = id;
 913         return i2c_register_adapter(adapter);
 914 }
 915 EXPORT_SYMBOL(i2c_add_adapter);
 916
 917 /**
 918  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 919  * @adap: the adapter to register (with adap->nr initialized)
 920  * Context: can sleep
 921  *
 922  * This routine is used to declare an I2C adapter when its bus number
 923  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 924  * or otherwise built in to the system's mainboard, and where i2c_board_info
 925  * is used to properly configure I2C devices.
 926  *
 927  * If no devices have pre-been declared for this bus, then be sure to
 928  * register the adapter before any dynamically allocated ones.  Otherwise
 929  * the required bus ID may not be available.
 930  *
 931  * When this returns zero, the specified adapter became available for
 932  * clients using the bus number provided in adap->nr.  Also, the table
 933  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 934  * and the appropriate driver model device nodes are created.  Otherwise, a
 935  * negative errno value is returned.
 936  */
 937 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 938 {
 939         int     id;
 940         int     status;
 941
 942         if (adap->nr & ~MAX_ID_MASK)
 943                 return -EINVAL;
 944
 945 retry:
 946         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 947                 return -ENOMEM;
 948
 949         mutex_lock(&core_lock);
 950         /* "above" here means "above or equal to", sigh;
 951          * we need the "equal to" result to force the result
 952          */
 953         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 954         if (status == 0 && id != adap->nr) {
 955                 status = -EBUSY;
 956                 idr_remove(&i2c_adapter_idr, id);
 957         }
 958         mutex_unlock(&core_lock);
 959         if (status == -EAGAIN)
 960                 goto retry;
 961
 962         if (status == 0)
 963                 status = i2c_register_adapter(adap);
 964         return status;
 965 }
 966 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
 967
 968 static int i2c_do_del_adapter(struct i2c_driver *driver,
 969                               struct i2c_adapter *adapter)
 970 {
 971         struct i2c_client *client, *_n;
 972         int res;
 973
 974         /* Remove the devices we created ourselves as the result of hardware
 975          * probing (using a driver's detect method) */
 976         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 977                 if (client->adapter == adapter) {
 978                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 979                                 client->name, client->addr);
 980                         list_del(&client->detected);
 981                         i2c_unregister_device(client);
 982                 }
 983         }
 984
 985         if (!driver->detach_adapter)
 986                 return 0;
 987         dev_warn(&adapter->dev, "detach_adapter method is deprecated\n");
 988         res = driver->detach_adapter(adapter);
 989         if (res)
 990                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
 991                         "for driver [%s]\n", res, driver->driver.name);
 992         return res;
 993 }
 994
 995 static int __unregister_client(struct device *dev, void *dummy)
 996 {
 997         struct i2c_client *client = i2c_verify_client(dev);
 998         if (client && strcmp(client->name, "dummy"))
 999                 i2c_unregister_device(client);
1000         return 0;
1001 }
1002
1003 static int __unregister_dummy(struct device *dev, void *dummy)
1004 {
1005         struct i2c_client *client = i2c_verify_client(dev);
1006         if (client)
1007                 i2c_unregister_device(client);
1008         return 0;
1009 }
1010
1011 static int __process_removed_adapter(struct device_driver *d, void *data)
1012 {
1013         return i2c_do_del_adapter(to_i2c_driver(d), data);
1014 }
1015
1016 /**
1017  * i2c_del_adapter - unregister I2C adapter
1018  * @adap: the adapter being unregistered
1019  * Context: can sleep
1020  *
1021  * This unregisters an I2C adapter which was previously registered
1022  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1023  */
1024 int i2c_del_adapter(struct i2c_adapter *adap)
1025 {
1026         int res = 0;
1027         struct i2c_adapter *found;
1028         struct i2c_client *client, *next;
1029
1030         /* First make sure that this adapter was ever added */
1031         mutex_lock(&core_lock);
1032         found = idr_find(&i2c_adapter_idr, adap->nr);
1033         mutex_unlock(&core_lock);
1034         if (found != adap) {
1035                 pr_debug("i2c-core: attempting to delete unregistered "
1036                          "adapter [%s]\n", adap->name);
1037                 return -EINVAL;
1038         }
1039
1040         /* Tell drivers about this removal */
1041         mutex_lock(&core_lock);
1042         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1043                                __process_removed_adapter);
1044         mutex_unlock(&core_lock);
1045         if (res)
1046                 return res;
1047
1048         /* Remove devices instantiated from sysfs */
1049         mutex_lock(&adap->userspace_clients_lock);
1050         list_for_each_entry_safe(client, next, &adap->userspace_clients,
1051                                  detected) {
1052                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1053                         client->addr);
1054                 list_del(&client->detected);
1055                 i2c_unregister_device(client);
1056         }
1057         mutex_unlock(&adap->userspace_clients_lock);
1058
1059         /* Detach any active clients. This can't fail, thus we do not
1060          * check the returned value. This is a two-pass process, because
1061          * we can't remove the dummy devices during the first pass: they
1062          * could have been instantiated by real devices wishing to clean
1063          * them up properly, so we give them a chance to do that first. */
1064         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1065         res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1066
1067 #ifdef CONFIG_I2C_COMPAT
1068         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1069                                  adap->dev.parent);
1070 #endif
1071
1072         /* device name is gone after device_unregister */
1073         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1074
1075         /* clean up the sysfs representation */
1076         init_completion(&adap->dev_released);
1077         device_unregister(&adap->dev);
1078
1079         /* wait for sysfs to drop all references */
1080         wait_for_completion(&adap->dev_released);
1081
1082         /* free bus id */
1083         mutex_lock(&core_lock);
1084         idr_remove(&i2c_adapter_idr, adap->nr);
1085         mutex_unlock(&core_lock);
1086
1087         /* Clear the device structure in case this adapter is ever going to be
1088            added again */
1089         memset(&adap->dev, 0, sizeof(adap->dev));
1090
1091         return 0;
1092 }
1093 EXPORT_SYMBOL(i2c_del_adapter);
1094
1095
1096 /* ------------------------------------------------------------------------- */
1097
1098 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1099 {
1100         int res;
1101
1102         mutex_lock(&core_lock);
1103         res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1104         mutex_unlock(&core_lock);
1105
1106         return res;
1107 }
1108 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1109
1110 static int __process_new_driver(struct device *dev, void *data)
1111 {
1112         if (dev->type != &i2c_adapter_type)
1113                 return 0;
1114         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1115 }
1116
1117 /*
1118  * An i2c_driver is used with one or more i2c_client (device) nodes to access
1119  * i2c slave chips, on a bus instance associated with some i2c_adapter.
1120  */
1121
1122 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1123 {
1124         int res;
1125
1126         /* Can't register until after driver model init */
1127         if (unlikely(WARN_ON(!i2c_bus_type.p)))
1128                 return -EAGAIN;
1129
1130         /* add the driver to the list of i2c drivers in the driver core */
1131         driver->driver.owner = owner;
1132         driver->driver.bus = &i2c_bus_type;
1133
1134         /* When registration returns, the driver core
1135          * will have called probe() for all matching-but-unbound devices.
1136          */
1137         res = driver_register(&driver->driver);
1138         if (res)
1139                 return res;
1140
1141         /* Drivers should switch to dev_pm_ops instead. */
1142         if (driver->suspend)
1143                 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1144                         driver->driver.name);
1145         if (driver->resume)
1146                 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1147                         driver->driver.name);
1148
1149         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1150
1151         INIT_LIST_HEAD(&driver->clients);
1152         /* Walk the adapters that are already present */
1153         i2c_for_each_dev(driver, __process_new_driver);
1154
1155         return 0;
1156 }
1157 EXPORT_SYMBOL(i2c_register_driver);
1158
1159 static int __process_removed_driver(struct device *dev, void *data)
1160 {
1161         if (dev->type != &i2c_adapter_type)
1162                 return 0;
1163         return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1164 }
1165
1166 /**
1167  * i2c_del_driver - unregister I2C driver
1168  * @driver: the driver being unregistered
1169  * Context: can sleep
1170  */
1171 void i2c_del_driver(struct i2c_driver *driver)
1172 {
1173         i2c_for_each_dev(driver, __process_removed_driver);
1174
1175         driver_unregister(&driver->driver);
1176         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1177 }
1178 EXPORT_SYMBOL(i2c_del_driver);
1179
1180 /* ------------------------------------------------------------------------- */
1181
1182 /**
1183  * i2c_use_client - increments the reference count of the i2c client structure
1184  * @client: the client being referenced
1185  *
1186  * Each live reference to a client should be refcounted. The driver model does
1187  * that automatically as part of driver binding, so that most drivers don't
1188  * need to do this explicitly: they hold a reference until they're unbound
1189  * from the device.
1190  *
1191  * A pointer to the client with the incremented reference counter is returned.
1192  */
1193 struct i2c_client *i2c_use_client(struct i2c_client *client)
1194 {
1195         if (client && get_device(&client->dev))
1196                 return client;
1197         return NULL;
1198 }
1199 EXPORT_SYMBOL(i2c_use_client);
1200
1201 /**
1202  * i2c_release_client - release a use of the i2c client structure
1203  * @client: the client being no longer referenced
1204  *
1205  * Must be called when a user of a client is finished with it.
1206  */
1207 void i2c_release_client(struct i2c_client *client)
1208 {
1209         if (client)
1210                 put_device(&client->dev);
1211 }
1212 EXPORT_SYMBOL(i2c_release_client);
1213
1214 struct i2c_cmd_arg {
1215         unsigned        cmd;
1216         void            *arg;
1217 };
1218
1219 static int i2c_cmd(struct device *dev, void *_arg)
1220 {
1221         struct i2c_client       *client = i2c_verify_client(dev);
1222         struct i2c_cmd_arg      *arg = _arg;
1223
1224         if (client && client->driver && client->driver->command)
1225                 client->driver->command(client, arg->cmd, arg->arg);
1226         return 0;
1227 }
1228
1229 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1230 {
1231         struct i2c_cmd_arg      cmd_arg;
1232
1233         cmd_arg.cmd = cmd;
1234         cmd_arg.arg = arg;
1235         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1236 }
1237 EXPORT_SYMBOL(i2c_clients_command);
1238
1239 static int __init i2c_init(void)
1240 {
1241         int retval;
1242
1243         retval = bus_register(&i2c_bus_type);
1244         if (retval)
1245                 return retval;
1246 #ifdef CONFIG_I2C_COMPAT
1247         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1248         if (!i2c_adapter_compat_class) {
1249                 retval = -ENOMEM;
1250                 goto bus_err;
1251         }
1252 #endif
1253         retval = i2c_add_driver(&dummy_driver);
1254         if (retval)
1255                 goto class_err;
1256         return 0;
1257
1258 class_err:
1259 #ifdef CONFIG_I2C_COMPAT
1260         class_compat_unregister(i2c_adapter_compat_class);
1261 bus_err:
1262 #endif
1263         bus_unregister(&i2c_bus_type);
1264         return retval;
1265 }
1266
1267 static void __exit i2c_exit(void)
1268 {
1269         i2c_del_driver(&dummy_driver);
1270 #ifdef CONFIG_I2C_COMPAT
1271         class_compat_unregister(i2c_adapter_compat_class);
1272 #endif
1273         bus_unregister(&i2c_bus_type);
1274 }
1275
1276 /* We must initialize early, because some subsystems register i2c drivers
1277  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1278  */
1279 postcore_initcall(i2c_init);
1280 module_exit(i2c_exit);
1281
1282 /* ----------------------------------------------------
1283  * the functional interface to the i2c busses.
1284  * ----------------------------------------------------
1285  */
1286
1287 /**
1288  * i2c_transfer - execute a single or combined I2C message
1289  * @adap: Handle to I2C bus
1290  * @msgs: One or more messages to execute before STOP is issued to
1291  *      terminate the operation; each message begins with a START.
1292  * @num: Number of messages to be executed.
1293  *
1294  * Returns negative errno, else the number of messages executed.
1295  *
1296  * Note that there is no requirement that each message be sent to
1297  * the same slave address, although that is the most common model.
1298  */
1299 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1300 {
1301         unsigned long orig_jiffies;
1302         int ret, try;
1303
1304         /* REVISIT the fault reporting model here is weak:
1305          *
1306          *  - When we get an error after receiving N bytes from a slave,
1307          *    there is no way to report "N".
1308          *
1309          *  - When we get a NAK after transmitting N bytes to a slave,
1310          *    there is no way to report "N" ... or to let the master
1311          *    continue executing the rest of this combined message, if
1312          *    that's the appropriate response.
1313          *
1314          *  - When for example "num" is two and we successfully complete
1315          *    the first message but get an error part way through the
1316          *    second, it's unclear whether that should be reported as
1317          *    one (discarding status on the second message) or errno
1318          *    (discarding status on the first one).
1319          */
1320
1321         if (adap->algo->master_xfer) {
1322 #ifdef DEBUG
1323                 for (ret = 0; ret < num; ret++) {
1324                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1325                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1326                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1327                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1328                 }
1329 #endif
1330
1331                 if (in_atomic() || irqs_disabled()) {
1332                         ret = i2c_trylock_adapter(adap);
1333                         if (!ret)
1334                                 /* I2C activity is ongoing. */
1335                                 return -EAGAIN;
1336                 } else {
1337                         i2c_lock_adapter(adap);
1338                 }
1339
1340                 /* Retry automatically on arbitration loss */
1341                 orig_jiffies = jiffies;
1342                 for (ret = 0, try = 0; try <= adap->retries; try++) {
1343                         ret = adap->algo->master_xfer(adap, msgs, num);
1344                         if (ret != -EAGAIN)
1345                                 break;
1346                         if (time_after(jiffies, orig_jiffies + adap->timeout))
1347                                 break;
1348                 }
1349                 i2c_unlock_adapter(adap);
1350
1351                 return ret;
1352         } else {
1353                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1354                 return -EOPNOTSUPP;
1355         }
1356 }
1357 EXPORT_SYMBOL(i2c_transfer);
1358
1359 /**
1360  * i2c_master_send - issue a single I2C message in master transmit mode
1361  * @client: Handle to slave device
1362  * @buf: Data that will be written to the slave
1363  * @count: How many bytes to write, must be less than 64k since msg.len is u16
1364  *
1365  * Returns negative errno, or else the number of bytes written.
1366  */
1367 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1368 {
1369         int ret;
1370         struct i2c_adapter *adap = client->adapter;
1371         struct i2c_msg msg;
1372
1373         msg.addr = client->addr;
1374         msg.flags = client->flags & I2C_M_TEN;
1375         msg.len = count;
1376         msg.buf = (char *)buf;
1377
1378         ret = i2c_transfer(adap, &msg, 1);
1379
1380         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1381            transmitted, else error code. */
1382         return (ret == 1) ? count : ret;
1383 }
1384 EXPORT_SYMBOL(i2c_master_send);
1385
1386 /**
1387  * i2c_master_recv - issue a single I2C message in master receive mode
1388  * @client: Handle to slave device
1389  * @buf: Where to store data read from slave
1390  * @count: How many bytes to read, must be less than 64k since msg.len is u16
1391  *
1392  * Returns negative errno, or else the number of bytes read.
1393  */
1394 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1395 {
1396         struct i2c_adapter *adap = client->adapter;
1397         struct i2c_msg msg;
1398         int ret;
1399
1400         msg.addr = client->addr;
1401         msg.flags = client->flags & I2C_M_TEN;
1402         msg.flags |= I2C_M_RD;
1403         msg.len = count;
1404         msg.buf = buf;
1405
1406         ret = i2c_transfer(adap, &msg, 1);
1407
1408         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1409            transmitted, else error code. */
1410         return (ret == 1) ? count : ret;
1411 }
1412 EXPORT_SYMBOL(i2c_master_recv);
1413
1414 /* ----------------------------------------------------
1415  * the i2c address scanning function
1416  * Will not work for 10-bit addresses!
1417  * ----------------------------------------------------
1418  */
1419
1420 /*
1421  * Legacy default probe function, mostly relevant for SMBus. The default
1422  * probe method is a quick write, but it is known to corrupt the 24RF08
1423  * EEPROMs due to a state machine bug, and could also irreversibly
1424  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1425  * we use a short byte read instead. Also, some bus drivers don't implement
1426  * quick write, so we fallback to a byte read in that case too.
1427  * On x86, there is another special case for FSC hardware monitoring chips,
1428  * which want regular byte reads (address 0x73.) Fortunately, these are the
1429  * only known chips using this I2C address on PC hardware.
1430  * Returns 1 if probe succeeded, 0 if not.
1431  */
1432 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1433 {
1434         int err;
1435         union i2c_smbus_data dummy;
1436
1437 #ifdef CONFIG_X86
1438         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1439          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1440                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1441                                      I2C_SMBUS_BYTE_DATA, &dummy);
1442         else
1443 #endif
1444         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1445          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1446                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1447                                      I2C_SMBUS_QUICK, NULL);
1448         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1449                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1450                                      I2C_SMBUS_BYTE, &dummy);
1451         else {
1452                 dev_warn(&adap->dev, "No suitable probing method supported\n");
1453                 err = -EOPNOTSUPP;
1454         }
1455
1456         return err >= 0;
1457 }
1458
1459 static int i2c_detect_address(struct i2c_client *temp_client,
1460                               struct i2c_driver *driver)
1461 {
1462         struct i2c_board_info info;
1463         struct i2c_adapter *adapter = temp_client->adapter;
1464         int addr = temp_client->addr;
1465         int err;
1466
1467         /* Make sure the address is valid */
1468         err = i2c_check_addr_validity(addr);
1469         if (err) {
1470                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1471                          addr);
1472                 return err;
1473         }
1474
1475         /* Skip if already in use */
1476         if (i2c_check_addr_busy(adapter, addr))
1477                 return 0;
1478
1479         /* Make sure there is something at this address */
1480         if (!i2c_default_probe(adapter, addr))
1481                 return 0;
1482
1483         /* Finally call the custom detection function */
1484         memset(&info, 0, sizeof(struct i2c_board_info));
1485         info.addr = addr;
1486         err = driver->detect(temp_client, &info);
1487         if (err) {
1488                 /* -ENODEV is returned if the detection fails. We catch it
1489                    here as this isn't an error. */
1490                 return err == -ENODEV ? 0 : err;
1491         }
1492
1493         /* Consistency check */
1494         if (info.type[0] == '\0') {
1495                 dev_err(&adapter->dev, "%s detection function provided "
1496                         "no name for 0x%x\n", driver->driver.name,
1497                         addr);
1498         } else {
1499                 struct i2c_client *client;
1500
1501                 /* Detection succeeded, instantiate the device */
1502                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1503                         info.type, info.addr);
1504                 client = i2c_new_device(adapter, &info);
1505                 if (client)
1506                         list_add_tail(&client->detected, &driver->clients);
1507                 else
1508                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1509                                 info.type, info.addr);
1510         }
1511         return 0;
1512 }
1513
1514 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1515 {
1516         const unsigned short *address_list;
1517         struct i2c_client *temp_client;
1518         int i, err = 0;
1519         int adap_id = i2c_adapter_id(adapter);
1520
1521         address_list = driver->address_list;
1522         if (!driver->detect || !address_list)
1523                 return 0;
1524
1525         /* Stop here if the classes do not match */
1526         if (!(adapter->class & driver->class))
1527                 return 0;
1528
1529         /* Set up a temporary client to help detect callback */
1530         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1531         if (!temp_client)
1532                 return -ENOMEM;
1533         temp_client->adapter = adapter;
1534
1535         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1536                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1537                         "addr 0x%02x\n", adap_id, address_list[i]);
1538                 temp_client->addr = address_list[i];
1539                 err = i2c_detect_address(temp_client, driver);
1540                 if (unlikely(err))
1541                         break;
1542         }
1543
1544         kfree(temp_client);
1545         return err;
1546 }
1547
1548 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1549 {
1550         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1551                               I2C_SMBUS_QUICK, NULL) >= 0;
1552 }
1553 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1554
1555 struct i2c_client *
1556 i2c_new_probed_device(struct i2c_adapter *adap,
1557                       struct i2c_board_info *info,
1558                       unsigned short const *addr_list,
1559                       int (*probe)(struct i2c_adapter *, unsigned short addr))
1560 {
1561         int i;
1562
1563         if (!probe)
1564                 probe = i2c_default_probe;
1565
1566         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1567                 /* Check address validity */
1568                 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1569                         dev_warn(&adap->dev, "Invalid 7-bit address "
1570                                  "0x%02x\n", addr_list[i]);
1571                         continue;
1572                 }
1573
1574                 /* Check address availability */
1575                 if (i2c_check_addr_busy(adap, addr_list[i])) {
1576                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1577                                 "use, not probing\n", addr_list[i]);
1578                         continue;
1579                 }
1580
1581                 /* Test address responsiveness */
1582                 if (probe(adap, addr_list[i]))
1583                         break;
1584         }
1585
1586         if (addr_list[i] == I2C_CLIENT_END) {
1587                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1588                 return NULL;
1589         }
1590
1591         info->addr = addr_list[i];
1592         return i2c_new_device(adap, info);
1593 }
1594 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1595
1596 struct i2c_adapter *i2c_get_adapter(int nr)
1597 {
1598         struct i2c_adapter *adapter;
1599
1600         mutex_lock(&core_lock);
1601         adapter = idr_find(&i2c_adapter_idr, nr);
1602         if (adapter && !try_module_get(adapter->owner))
1603                 adapter = NULL;
1604
1605         mutex_unlock(&core_lock);
1606         return adapter;
1607 }
1608 EXPORT_SYMBOL(i2c_get_adapter);
1609
1610 void i2c_put_adapter(struct i2c_adapter *adap)
1611 {
1612         module_put(adap->owner);
1613 }
1614 EXPORT_SYMBOL(i2c_put_adapter);
1615
1616 /* The SMBus parts */
1617
1618 #define POLY    (0x1070U << 3)
1619 static u8 crc8(u16 data)
1620 {
1621         int i;
1622
1623         for (i = 0; i < 8; i++) {
1624                 if (data & 0x8000)
1625                         data = data ^ POLY;
1626                 data = data << 1;
1627         }
1628         return (u8)(data >> 8);
1629 }
1630
1631 /* Incremental CRC8 over count bytes in the array pointed to by p */
1632 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1633 {
1634         int i;
1635
1636         for (i = 0; i < count; i++)
1637                 crc = crc8((crc ^ p[i]) << 8);
1638         return crc;
1639 }
1640
1641 /* Assume a 7-bit address, which is reasonable for SMBus */
1642 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1643 {
1644         /* The address will be sent first */
1645         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1646         pec = i2c_smbus_pec(pec, &addr, 1);
1647
1648         /* The data buffer follows */
1649         return i2c_smbus_pec(pec, msg->buf, msg->len);
1650 }
1651
1652 /* Used for write only transactions */
1653 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1654 {
1655         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1656         msg->len++;
1657 }
1658
1659 /* Return <0 on CRC error
1660    If there was a write before this read (most cases) we need to take the
1661    partial CRC from the write part into account.
1662    Note that this function does modify the message (we need to decrease the
1663    message length to hide the CRC byte from the caller). */
1664 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1665 {
1666         u8 rpec = msg->buf[--msg->len];
1667         cpec = i2c_smbus_msg_pec(cpec, msg);
1668
1669         if (rpec != cpec) {
1670                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1671                         rpec, cpec);
1672                 return -EBADMSG;
1673         }
1674         return 0;
1675 }
1676
1677 /**
1678  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1679  * @client: Handle to slave device
1680  *
1681  * This executes the SMBus "receive byte" protocol, returning negative errno
1682  * else the byte received from the device.
1683  */
1684 s32 i2c_smbus_read_byte(const struct i2c_client *client)
1685 {
1686         union i2c_smbus_data data;
1687         int status;
1688
1689         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1690                                 I2C_SMBUS_READ, 0,
1691                                 I2C_SMBUS_BYTE, &data);
1692         return (status < 0) ? status : data.byte;
1693 }
1694 EXPORT_SYMBOL(i2c_smbus_read_byte);
1695
1696 /**
1697  * i2c_smbus_write_byte - SMBus "send byte" protocol
1698  * @client: Handle to slave device
1699  * @value: Byte to be sent
1700  *
1701  * This executes the SMBus "send byte" protocol, returning negative errno
1702  * else zero on success.
1703  */
1704 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1705 {
1706         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1707                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1708 }
1709 EXPORT_SYMBOL(i2c_smbus_write_byte);
1710
1711 /**
1712  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1713  * @client: Handle to slave device
1714  * @command: Byte interpreted by slave
1715  *
1716  * This executes the SMBus "read byte" protocol, returning negative errno
1717  * else a data byte received from the device.
1718  */
1719 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1720 {
1721         union i2c_smbus_data data;
1722         int status;
1723
1724         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1725                                 I2C_SMBUS_READ, command,
1726                                 I2C_SMBUS_BYTE_DATA, &data);
1727         return (status < 0) ? status : data.byte;
1728 }
1729 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1730
1731 /**
1732  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1733  * @client: Handle to slave device
1734  * @command: Byte interpreted by slave
1735  * @value: Byte being written
1736  *
1737  * This executes the SMBus "write byte" protocol, returning negative errno
1738  * else zero on success.
1739  */
1740 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1741                               u8 value)
1742 {
1743         union i2c_smbus_data data;
1744         data.byte = value;
1745         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1746                               I2C_SMBUS_WRITE, command,
1747                               I2C_SMBUS_BYTE_DATA, &data);
1748 }
1749 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1750
1751 /**
1752  * i2c_smbus_read_word_data - SMBus "read word" protocol
1753  * @client: Handle to slave device
1754  * @command: Byte interpreted by slave
1755  *
1756  * This executes the SMBus "read word" protocol, returning negative errno
1757  * else a 16-bit unsigned "word" received from the device.
1758  */
1759 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1760 {
1761         union i2c_smbus_data data;
1762         int status;
1763
1764         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1765                                 I2C_SMBUS_READ, command,
1766                                 I2C_SMBUS_WORD_DATA, &data);
1767         return (status < 0) ? status : data.word;
1768 }
1769 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1770
1771 /**
1772  * i2c_smbus_write_word_data - SMBus "write word" protocol
1773  * @client: Handle to slave device
1774  * @command: Byte interpreted by slave
1775  * @value: 16-bit "word" being written
1776  *
1777  * This executes the SMBus "write word" protocol, returning negative errno
1778  * else zero on success.
1779  */
1780 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1781                               u16 value)
1782 {
1783         union i2c_smbus_data data;
1784         data.word = value;
1785         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1786                               I2C_SMBUS_WRITE, command,
1787                               I2C_SMBUS_WORD_DATA, &data);
1788 }
1789 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1790
1791 /**
1792  * i2c_smbus_process_call - SMBus "process call" protocol
1793  * @client: Handle to slave device
1794  * @command: Byte interpreted by slave
1795  * @value: 16-bit "word" being written
1796  *
1797  * This executes the SMBus "process call" protocol, returning negative errno
1798  * else a 16-bit unsigned "word" received from the device.
1799  */
1800 s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1801                            u16 value)
1802 {
1803         union i2c_smbus_data data;
1804         int status;
1805         data.word = value;
1806
1807         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1808                                 I2C_SMBUS_WRITE, command,
1809                                 I2C_SMBUS_PROC_CALL, &data);
1810         return (status < 0) ? status : data.word;
1811 }
1812 EXPORT_SYMBOL(i2c_smbus_process_call);
1813
1814 /**
1815  * i2c_smbus_read_block_data - SMBus "block read" protocol
1816  * @client: Handle to slave device
1817  * @command: Byte interpreted by slave
1818  * @values: Byte array into which data will be read; big enough to hold
1819  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1820  *
1821  * This executes the SMBus "block read" protocol, returning negative errno
1822  * else the number of data bytes in the slave's response.
1823  *
1824  * Note that using this function requires that the client's adapter support
1825  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1826  * support this; its emulation through I2C messaging relies on a specific
1827  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1828  */
1829 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1830                               u8 *values)
1831 {
1832         union i2c_smbus_data data;
1833         int status;
1834
1835         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1836                                 I2C_SMBUS_READ, command,
1837                                 I2C_SMBUS_BLOCK_DATA, &data);
1838         if (status)
1839                 return status;
1840
1841         memcpy(values, &data.block[1], data.block[0]);
1842         return data.block[0];
1843 }
1844 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1845
1846 /**
1847  * i2c_smbus_write_block_data - SMBus "block write" protocol
1848  * @client: Handle to slave device
1849  * @command: Byte interpreted by slave
1850  * @length: Size of data block; SMBus allows at most 32 bytes
1851  * @values: Byte array which will be written.
1852  *
1853  * This executes the SMBus "block write" protocol, returning negative errno
1854  * else zero on success.
1855  */
1856 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1857                                u8 length, const u8 *values)
1858 {
1859         union i2c_smbus_data data;
1860
1861         if (length > I2C_SMBUS_BLOCK_MAX)
1862                 length = I2C_SMBUS_BLOCK_MAX;
1863         data.block[0] = length;
1864         memcpy(&data.block[1], values, length);
1865         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1866                               I2C_SMBUS_WRITE, command,
1867                               I2C_SMBUS_BLOCK_DATA, &data);
1868 }
1869 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1870
1871 /* Returns the number of read bytes */
1872 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1873                                   u8 length, u8 *values)
1874 {
1875         union i2c_smbus_data data;
1876         int status;
1877
1878         if (length > I2C_SMBUS_BLOCK_MAX)
1879                 length = I2C_SMBUS_BLOCK_MAX;
1880         data.block[0] = length;
1881         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1882                                 I2C_SMBUS_READ, command,
1883                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1884         if (status < 0)
1885                 return status;
1886
1887         memcpy(values, &data.block[1], data.block[0]);
1888         return data.block[0];
1889 }
1890 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1891
1892 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1893                                    u8 length, const u8 *values)
1894 {
1895         union i2c_smbus_data data;
1896
1897         if (length > I2C_SMBUS_BLOCK_MAX)
1898                 length = I2C_SMBUS_BLOCK_MAX;
1899         data.block[0] = length;
1900         memcpy(data.block + 1, values, length);
1901         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1902                               I2C_SMBUS_WRITE, command,
1903                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1904 }
1905 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1906
1907 /* Simulate a SMBus command using the i2c protocol
1908    No checking of parameters is done!  */
1909 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1910                                    unsigned short flags,
1911                                    char read_write, u8 command, int size,
1912                                    union i2c_smbus_data *data)
1913 {
1914         /* So we need to generate a series of msgs. In the case of writing, we
1915           need to use only one message; when reading, we need two. We initialize
1916           most things with sane defaults, to keep the code below somewhat
1917           simpler. */
1918         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1919         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1920         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1921         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1922                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1923                                 };
1924         int i;
1925         u8 partial_pec = 0;
1926         int status;
1927
1928         msgbuf0[0] = command;
1929         switch (size) {
1930         case I2C_SMBUS_QUICK:
1931                 msg[0].len = 0;
1932                 /* Special case: The read/write field is used as data */
1933                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1934                                         I2C_M_RD : 0);
1935                 num = 1;
1936                 break;
1937         case I2C_SMBUS_BYTE:
1938                 if (read_write == I2C_SMBUS_READ) {
1939                         /* Special case: only a read! */
1940                         msg[0].flags = I2C_M_RD | flags;
1941                         num = 1;
1942                 }
1943                 break;
1944         case I2C_SMBUS_BYTE_DATA:
1945                 if (read_write == I2C_SMBUS_READ)
1946                         msg[1].len = 1;
1947                 else {
1948                         msg[0].len = 2;
1949                         msgbuf0[1] = data->byte;
1950                 }
1951                 break;
1952         case I2C_SMBUS_WORD_DATA:
1953                 if (read_write == I2C_SMBUS_READ)
1954                         msg[1].len = 2;
1955                 else {
1956                         msg[0].len = 3;
1957                         msgbuf0[1] = data->word & 0xff;
1958                         msgbuf0[2] = data->word >> 8;
1959                 }
1960                 break;
1961         case I2C_SMBUS_PROC_CALL:
1962                 num = 2; /* Special case */
1963                 read_write = I2C_SMBUS_READ;
1964                 msg[0].len = 3;
1965                 msg[1].len = 2;
1966                 msgbuf0[1] = data->word & 0xff;
1967                 msgbuf0[2] = data->word >> 8;
1968                 break;
1969         case I2C_SMBUS_BLOCK_DATA:
1970                 if (read_write == I2C_SMBUS_READ) {
1971                         msg[1].flags |= I2C_M_RECV_LEN;
1972                         msg[1].len = 1; /* block length will be added by
1973                                            the underlying bus driver */
1974                 } else {
1975                         msg[0].len = data->block[0] + 2;
1976                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1977                                 dev_err(&adapter->dev,
1978                                         "Invalid block write size %d\n",
1979                                         data->block[0]);
1980                                 return -EINVAL;
1981                         }
1982                         for (i = 1; i < msg[0].len; i++)
1983                                 msgbuf0[i] = data->block[i-1];
1984                 }
1985                 break;
1986         case I2C_SMBUS_BLOCK_PROC_CALL:
1987                 num = 2; /* Another special case */
1988                 read_write = I2C_SMBUS_READ;
1989                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1990                         dev_err(&adapter->dev,
1991                                 "Invalid block write size %d\n",
1992                                 data->block[0]);
1993                         return -EINVAL;
1994                 }
1995                 msg[0].len = data->block[0] + 2;
1996                 for (i = 1; i < msg[0].len; i++)
1997                         msgbuf0[i] = data->block[i-1];
1998                 msg[1].flags |= I2C_M_RECV_LEN;
1999                 msg[1].len = 1; /* block length will be added by
2000                                    the underlying bus driver */
2001                 break;
2002         case I2C_SMBUS_I2C_BLOCK_DATA:
2003                 if (read_write == I2C_SMBUS_READ) {
2004                         msg[1].len = data->block[0];
2005                 } else {
2006                         msg[0].len = data->block[0] + 1;
2007                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2008                                 dev_err(&adapter->dev,
2009                                         "Invalid block write size %d\n",
2010                                         data->block[0]);
2011                                 return -EINVAL;
2012                         }
2013                         for (i = 1; i <= data->block[0]; i++)
2014                                 msgbuf0[i] = data->block[i];
2015                 }
2016                 break;
2017         default:
2018                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2019                 return -EOPNOTSUPP;
2020         }
2021
2022         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2023                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
2024         if (i) {
2025                 /* Compute PEC if first message is a write */
2026                 if (!(msg[0].flags & I2C_M_RD)) {
2027                         if (num == 1) /* Write only */
2028                                 i2c_smbus_add_pec(&msg[0]);
2029                         else /* Write followed by read */
2030                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2031                 }
2032                 /* Ask for PEC if last message is a read */
2033                 if (msg[num-1].flags & I2C_M_RD)
2034                         msg[num-1].len++;
2035         }
2036
2037         status = i2c_transfer(adapter, msg, num);
2038         if (status < 0)
2039                 return status;
2040
2041         /* Check PEC if last message is a read */
2042         if (i && (msg[num-1].flags & I2C_M_RD)) {
2043                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2044                 if (status < 0)
2045                         return status;
2046         }
2047
2048         if (read_write == I2C_SMBUS_READ)
2049                 switch (size) {
2050                 case I2C_SMBUS_BYTE:
2051                         data->byte = msgbuf0[0];
2052                         break;
2053                 case I2C_SMBUS_BYTE_DATA:
2054                         data->byte = msgbuf1[0];
2055                         break;
2056                 case I2C_SMBUS_WORD_DATA:
2057                 case I2C_SMBUS_PROC_CALL:
2058                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2059                         break;
2060                 case I2C_SMBUS_I2C_BLOCK_DATA:
2061                         for (i = 0; i < data->block[0]; i++)
2062                                 data->block[i+1] = msgbuf1[i];
2063                         break;
2064                 case I2C_SMBUS_BLOCK_DATA:
2065                 case I2C_SMBUS_BLOCK_PROC_CALL:
2066                         for (i = 0; i < msgbuf1[0] + 1; i++)
2067                                 data->block[i] = msgbuf1[i];
2068                         break;
2069                 }
2070         return 0;
2071 }
2072
2073 /**
2074  * i2c_smbus_xfer - execute SMBus protocol operations
2075  * @adapter: Handle to I2C bus
2076  * @addr: Address of SMBus slave on that bus
2077  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2078  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2079  * @command: Byte interpreted by slave, for protocols which use such bytes
2080  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2081  * @data: Data to be read or written
2082  *
2083  * This executes an SMBus protocol operation, and returns a negative
2084  * errno code else zero on success.
2085  */
2086 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2087                    char read_write, u8 command, int protocol,
2088                    union i2c_smbus_data *data)
2089 {
2090         unsigned long orig_jiffies;
2091         int try;
2092         s32 res;
2093
2094         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2095
2096         if (adapter->algo->smbus_xfer) {
2097                 i2c_lock_adapter(adapter);
2098
2099                 /* Retry automatically on arbitration loss */
2100                 orig_jiffies = jiffies;
2101                 for (res = 0, try = 0; try <= adapter->retries; try++) {
2102                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
2103                                                         read_write, command,
2104                                                         protocol, data);
2105                         if (res != -EAGAIN)
2106                                 break;
2107                         if (time_after(jiffies,
2108                                        orig_jiffies + adapter->timeout))
2109                                 break;
2110                 }
2111                 i2c_unlock_adapter(adapter);
2112         } else
2113                 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2114                                               command, protocol, data);
2115
2116         return res;
2117 }
2118 EXPORT_SYMBOL(i2c_smbus_xfer);
2119
2120 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2121 MODULE_DESCRIPTION("I2C-Bus main module");
2122 MODULE_LICENSE("GPL");