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