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., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  18/* ------------------------------------------------------------------------- */
  19
  20/* With some changes from Ky\xC3\xB6sti M\xC3\xA4lkki <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 */
  49static DEFINE_MUTEX(core_lock);
  50static DEFINE_IDR(i2c_adapter_idr);
  51
  52static struct device_type i2c_client_type;
  53static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
  54
  55/* ------------------------------------------------------------------------- */
  56
  57static 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
  68static 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) */
  91static 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
 106static 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
 132static 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
 156static 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
 169static 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
 182static 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
 195static 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
 205static 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
 215static 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
 225static 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
 235static 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
 245static 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
 263static void i2c_client_dev_release(struct device *dev)
 264{
 265        kfree(to_i2c_client(dev));
 266}
 267
 268static ssize_t
 269show_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
 275static ssize_t
 276show_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
 282static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 283static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 284
 285static 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
 292static struct attribute_group i2c_dev_attr_group = {
 293        .attrs          = i2c_dev_attrs,
 294};
 295
 296static const struct attribute_group *i2c_dev_attr_groups[] = {
 297        &i2c_dev_attr_group,
 298        NULL
 299};
 300
 301static 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
 315struct 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};
 323EXPORT_SYMBOL_GPL(i2c_bus_type);
 324
 325static 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 */
 341struct i2c_client *i2c_verify_client(struct device *dev)
 342{
 343        return (dev->type == &i2c_client_type)
 344                        ? to_i2c_client(dev)
 345                        : NULL;
 346}
 347EXPORT_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. */
 352static 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. */
 370static 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
 387static 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 */
 398static 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 */
 413static 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
 426static 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 */
 445void 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}
 454EXPORT_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 */
 460static 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 */
 474void 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}
 483EXPORT_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 */
 501struct i2c_client *
 502i2c_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
 553out_err:
 554        dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
 555                "(%d)\n", client->name, client->addr, status);
 556out_err_silent:
 557        kfree(client);
 558        return NULL;
 559}
 560EXPORT_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 */
 568void i2c_unregister_device(struct i2c_client *client)
 569{
 570        device_unregister(&client->dev);
 571}
 572EXPORT_SYMBOL_GPL(i2c_unregister_device);
 573
 574
 575static const struct i2c_device_id dummy_id[] = {
 576        { "dummy", 0 },
 577        { },
 578};
 579
 580static int dummy_probe(struct i2c_client *client,
 581                       const struct i2c_device_id *id)
 582{
 583        return 0;
 584}
 585
 586static int dummy_remove(struct i2c_client *client)
 587{
 588        return 0;
 589}
 590
 591static 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 */
 616struct 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}
 624EXPORT_SYMBOL_GPL(i2c_new_dummy);
 625
 626/* ------------------------------------------------------------------------- */
 627
 628/* I2C bus adapters -- one roots each I2C or SMBUS segment */
 629
 630static 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 */
 646static ssize_t
 647i2c_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 */
 703static ssize_t
 704i2c_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
 747static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 748static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
 749
 750static 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
 757static struct attribute_group i2c_adapter_attr_group = {
 758        .attrs          = i2c_adapter_attrs,
 759};
 760
 761static const struct attribute_group *i2c_adapter_attr_groups[] = {
 762        &i2c_adapter_attr_group,
 763        NULL
 764};
 765
 766struct device_type i2c_adapter_type = {
 767        .groups         = i2c_adapter_attr_groups,
 768        .release        = i2c_adapter_dev_release,
 769};
 770EXPORT_SYMBOL_GPL(i2c_adapter_type);
 771
 772#ifdef CONFIG_I2C_COMPAT
 773static struct class_compat *i2c_adapter_compat_class;
 774#endif
 775
 776static 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
 792static 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, "%s: attach_adapter method is deprecated\n",
 801                         driver->driver.name);
 802                dev_warn(&adap->dev, "Please use another way to instantiate "
 803                         "your i2c_client\n");
 804                /* We ignore the return code; if it fails, too bad */
 805                driver->attach_adapter(adap);
 806        }
 807        return 0;
 808}
 809
 810static int __process_new_adapter(struct device_driver *d, void *data)
 811{
 812        return i2c_do_add_adapter(to_i2c_driver(d), data);
 813}
 814
 815static int i2c_register_adapter(struct i2c_adapter *adap)
 816{
 817        int res = 0;
 818
 819        /* Can't register until after driver model init */
 820        if (unlikely(WARN_ON(!i2c_bus_type.p))) {
 821                res = -EAGAIN;
 822                goto out_list;
 823        }
 824
 825        /* Sanity checks */
 826        if (unlikely(adap->name[0] == '\0')) {
 827                pr_err("i2c-core: Attempt to register an adapter with "
 828                       "no name!\n");
 829                return -EINVAL;
 830        }
 831        if (unlikely(!adap->algo)) {
 832                pr_err("i2c-core: Attempt to register adapter '%s' with "
 833                       "no algo!\n", adap->name);
 834                return -EINVAL;
 835        }
 836
 837        rt_mutex_init(&adap->bus_lock);
 838        mutex_init(&adap->userspace_clients_lock);
 839        INIT_LIST_HEAD(&adap->userspace_clients);
 840
 841        /* Set default timeout to 1 second if not already set */
 842        if (adap->timeout == 0)
 843                adap->timeout = HZ;
 844
 845        dev_set_name(&adap->dev, "i2c-%d", adap->nr);
 846        adap->dev.bus = &i2c_bus_type;
 847        adap->dev.type = &i2c_adapter_type;
 848        res = device_register(&adap->dev);
 849        if (res)
 850                goto out_list;
 851
 852        dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 853
 854#ifdef CONFIG_I2C_COMPAT
 855        res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
 856                                       adap->dev.parent);
 857        if (res)
 858                dev_warn(&adap->dev,
 859                         "Failed to create compatibility class link\n");
 860#endif
 861
 862        /* create pre-declared device nodes */
 863        if (adap->nr < __i2c_first_dynamic_bus_num)
 864                i2c_scan_static_board_info(adap);
 865
 866        /* Notify drivers */
 867        mutex_lock(&core_lock);
 868        bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
 869        mutex_unlock(&core_lock);
 870
 871        return 0;
 872
 873out_list:
 874        mutex_lock(&core_lock);
 875        idr_remove(&i2c_adapter_idr, adap->nr);
 876        mutex_unlock(&core_lock);
 877        return res;
 878}
 879
 880/**
 881 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 882 * @adapter: the adapter to add
 883 * Context: can sleep
 884 *
 885 * This routine is used to declare an I2C adapter when its bus number
 886 * doesn't matter.  Examples: for I2C adapters dynamically added by
 887 * USB links or PCI plugin cards.
 888 *
 889 * When this returns zero, a new bus number was allocated and stored
 890 * in adap->nr, and the specified adapter became available for clients.
 891 * Otherwise, a negative errno value is returned.
 892 */
 893int i2c_add_adapter(struct i2c_adapter *adapter)
 894{
 895        int     id, res = 0;
 896
 897retry:
 898        if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 899                return -ENOMEM;
 900
 901        mutex_lock(&core_lock);
 902        /* "above" here means "above or equal to", sigh */
 903        res = idr_get_new_above(&i2c_adapter_idr, adapter,
 904                                __i2c_first_dynamic_bus_num, &id);
 905        mutex_unlock(&core_lock);
 906
 907        if (res < 0) {
 908                if (res == -EAGAIN)
 909                        goto retry;
 910                return res;
 911        }
 912
 913        adapter->nr = id;
 914        return i2c_register_adapter(adapter);
 915}
 916EXPORT_SYMBOL(i2c_add_adapter);
 917
 918/**
 919 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 920 * @adap: the adapter to register (with adap->nr initialized)
 921 * Context: can sleep
 922 *
 923 * This routine is used to declare an I2C adapter when its bus number
 924 * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 925 * or otherwise built in to the system's mainboard, and where i2c_board_info
 926 * is used to properly configure I2C devices.
 927 *
 928 * If no devices have pre-been declared for this bus, then be sure to
 929 * register the adapter before any dynamically allocated ones.  Otherwise
 930 * the required bus ID may not be available.
 931 *
 932 * When this returns zero, the specified adapter became available for
 933 * clients using the bus number provided in adap->nr.  Also, the table
 934 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 935 * and the appropriate driver model device nodes are created.  Otherwise, a
 936 * negative errno value is returned.
 937 */
 938int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 939{
 940        int     id;
 941        int     status;
 942
 943        if (adap->nr & ~MAX_ID_MASK)
 944                return -EINVAL;
 945
 946retry:
 947        if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 948                return -ENOMEM;
 949
 950        mutex_lock(&core_lock);
 951        /* "above" here means "above or equal to", sigh;
 952         * we need the "equal to" result to force the result
 953         */
 954        status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 955        if (status == 0 && id != adap->nr) {
 956                status = -EBUSY;
 957                idr_remove(&i2c_adapter_idr, id);
 958        }
 959        mutex_unlock(&core_lock);
 960        if (status == -EAGAIN)
 961                goto retry;
 962
 963        if (status == 0)
 964                status = i2c_register_adapter(adap);
 965        return status;
 966}
 967EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
 968
 969static int i2c_do_del_adapter(struct i2c_driver *driver,
 970                              struct i2c_adapter *adapter)
 971{
 972        struct i2c_client *client, *_n;
 973        int res;
 974
 975        /* Remove the devices we created ourselves as the result of hardware
 976         * probing (using a driver's detect method) */
 977        list_for_each_entry_safe(client, _n, &driver->clients, detected) {
 978                if (client->adapter == adapter) {
 979                        dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
 980                                client->name, client->addr);
 981                        list_del(&client->detected);
 982                        i2c_unregister_device(client);
 983                }
 984        }
 985
 986        if (!driver->detach_adapter)
 987                return 0;
 988        dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
 989                 driver->driver.name);
 990        res = driver->detach_adapter(adapter);
 991        if (res)
 992                dev_err(&adapter->dev, "detach_adapter failed (%d) "
 993                        "for driver [%s]\n", res, driver->driver.name);
 994        return res;
 995}
 996
 997static int __unregister_client(struct device *dev, void *dummy)
 998{
 999        struct i2c_client *client = i2c_verify_client(dev);
1000        if (client && strcmp(client->name, "dummy"))
1001                i2c_unregister_device(client);
1002        return 0;
1003}
1004
1005static int __unregister_dummy(struct device *dev, void *dummy)
1006{
1007        struct i2c_client *client = i2c_verify_client(dev);
1008        if (client)
1009                i2c_unregister_device(client);
1010        return 0;
1011}
1012
1013static int __process_removed_adapter(struct device_driver *d, void *data)
1014{
1015        return i2c_do_del_adapter(to_i2c_driver(d), data);
1016}
1017
1018/**
1019 * i2c_del_adapter - unregister I2C adapter
1020 * @adap: the adapter being unregistered
1021 * Context: can sleep
1022 *
1023 * This unregisters an I2C adapter which was previously registered
1024 * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1025 */
1026int i2c_del_adapter(struct i2c_adapter *adap)
1027{
1028        int res = 0;
1029        struct i2c_adapter *found;
1030        struct i2c_client *client, *next;
1031
1032        /* First make sure that this adapter was ever added */
1033        mutex_lock(&core_lock);
1034        found = idr_find(&i2c_adapter_idr, adap->nr);
1035        mutex_unlock(&core_lock);
1036        if (found != adap) {
1037                pr_debug("i2c-core: attempting to delete unregistered "
1038                         "adapter [%s]\n", adap->name);
1039                return -EINVAL;
1040        }
1041
1042        /* Tell drivers about this removal */
1043        mutex_lock(&core_lock);
1044        res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1045                               __process_removed_adapter);
1046        mutex_unlock(&core_lock);
1047        if (res)
1048                return res;
1049
1050        /* Remove devices instantiated from sysfs */
1051        mutex_lock(&adap->userspace_clients_lock);
1052        list_for_each_entry_safe(client, next, &adap->userspace_clients,
1053                                 detected) {
1054                dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1055                        client->addr);
1056                list_del(&client->detected);
1057                i2c_unregister_device(client);
1058        }
1059        mutex_unlock(&adap->userspace_clients_lock);
1060
1061        /* Detach any active clients. This can't fail, thus we do not
1062         * check the returned value. This is a two-pass process, because
1063         * we can't remove the dummy devices during the first pass: they
1064         * could have been instantiated by real devices wishing to clean
1065         * them up properly, so we give them a chance to do that first. */
1066        res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1067        res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1068
1069#ifdef CONFIG_I2C_COMPAT
1070        class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1071                                 adap->dev.parent);
1072#endif
1073
1074        /* device name is gone after device_unregister */
1075        dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1076
1077        /* clean up the sysfs representation */
1078        init_completion(&adap->dev_released);
1079        device_unregister(&adap->dev);
1080
1081        /* wait for sysfs to drop all references */
1082        wait_for_completion(&adap->dev_released);
1083
1084        /* free bus id */
1085        mutex_lock(&core_lock);
1086        idr_remove(&i2c_adapter_idr, adap->nr);
1087        mutex_unlock(&core_lock);
1088
1089        /* Clear the device structure in case this adapter is ever going to be
1090           added again */
1091        memset(&adap->dev, 0, sizeof(adap->dev));
1092
1093        return 0;
1094}
1095EXPORT_SYMBOL(i2c_del_adapter);
1096
1097
1098/* ------------------------------------------------------------------------- */
1099
1100int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1101{
1102        int res;
1103
1104        mutex_lock(&core_lock);
1105        res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1106        mutex_unlock(&core_lock);
1107
1108        return res;
1109}
1110EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1111
1112static int __process_new_driver(struct device *dev, void *data)
1113{
1114        if (dev->type != &i2c_adapter_type)
1115                return 0;
1116        return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1117}
1118
1119/*
1120 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1121 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1122 */
1123
1124int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1125{
1126        int res;
1127
1128        /* Can't register until after driver model init */
1129        if (unlikely(WARN_ON(!i2c_bus_type.p)))
1130                return -EAGAIN;
1131
1132        /* add the driver to the list of i2c drivers in the driver core */
1133        driver->driver.owner = owner;
1134        driver->driver.bus = &i2c_bus_type;
1135
1136        /* When registration returns, the driver core
1137         * will have called probe() for all matching-but-unbound devices.
1138         */
1139        res = driver_register(&driver->driver);
1140        if (res)
1141                return res;
1142
1143        /* Drivers should switch to dev_pm_ops instead. */
1144        if (driver->suspend)
1145                pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1146                        driver->driver.name);
1147        if (driver->resume)
1148                pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1149                        driver->driver.name);
1150
1151        pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1152
1153        INIT_LIST_HEAD(&driver->clients);
1154        /* Walk the adapters that are already present */
1155        i2c_for_each_dev(driver, __process_new_driver);
1156
1157        return 0;
1158}
1159EXPORT_SYMBOL(i2c_register_driver);
1160
1161static int __process_removed_driver(struct device *dev, void *data)
1162{
1163        if (dev->type != &i2c_adapter_type)
1164                return 0;
1165        return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1166}
1167
1168/**
1169 * i2c_del_driver - unregister I2C driver
1170 * @driver: the driver being unregistered
1171 * Context: can sleep
1172 */
1173void i2c_del_driver(struct i2c_driver *driver)
1174{
1175        i2c_for_each_dev(driver, __process_removed_driver);
1176
1177        driver_unregister(&driver->driver);
1178        pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1179}
1180EXPORT_SYMBOL(i2c_del_driver);
1181
1182/* ------------------------------------------------------------------------- */
1183
1184/**
1185 * i2c_use_client - increments the reference count of the i2c client structure
1186 * @client: the client being referenced
1187 *
1188 * Each live reference to a client should be refcounted. The driver model does
1189 * that automatically as part of driver binding, so that most drivers don't
1190 * need to do this explicitly: they hold a reference until they're unbound
1191 * from the device.
1192 *
1193 * A pointer to the client with the incremented reference counter is returned.
1194 */
1195struct i2c_client *i2c_use_client(struct i2c_client *client)
1196{
1197        if (client && get_device(&client->dev))
1198                return client;
1199        return NULL;
1200}
1201EXPORT_SYMBOL(i2c_use_client);
1202
1203/**
1204 * i2c_release_client - release a use of the i2c client structure
1205 * @client: the client being no longer referenced
1206 *
1207 * Must be called when a user of a client is finished with it.
1208 */
1209void i2c_release_client(struct i2c_client *client)
1210{
1211        if (client)
1212                put_device(&client->dev);
1213}
1214EXPORT_SYMBOL(i2c_release_client);
1215
1216struct i2c_cmd_arg {
1217        unsigned        cmd;
1218        void            *arg;
1219};
1220
1221static int i2c_cmd(struct device *dev, void *_arg)
1222{
1223        struct i2c_client       *client = i2c_verify_client(dev);
1224        struct i2c_cmd_arg      *arg = _arg;
1225
1226        if (client && client->driver && client->driver->command)
1227                client->driver->command(client, arg->cmd, arg->arg);
1228        return 0;
1229}
1230
1231void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1232{
1233        struct i2c_cmd_arg      cmd_arg;
1234
1235        cmd_arg.cmd = cmd;
1236        cmd_arg.arg = arg;
1237        device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1238}
1239EXPORT_SYMBOL(i2c_clients_command);
1240
1241static int __init i2c_init(void)
1242{
1243        int retval;
1244
1245        retval = bus_register(&i2c_bus_type);
1246        if (retval)
1247                return retval;
1248#ifdef CONFIG_I2C_COMPAT
1249        i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1250        if (!i2c_adapter_compat_class) {
1251                retval = -ENOMEM;
1252                goto bus_err;
1253        }
1254#endif
1255        retval = i2c_add_driver(&dummy_driver);
1256        if (retval)
1257                goto class_err;
1258        return 0;
1259
1260class_err:
1261#ifdef CONFIG_I2C_COMPAT
1262        class_compat_unregister(i2c_adapter_compat_class);
1263bus_err:
1264#endif
1265        bus_unregister(&i2c_bus_type);
1266        return retval;
1267}
1268
1269static void __exit i2c_exit(void)
1270{
1271        i2c_del_driver(&dummy_driver);
1272#ifdef CONFIG_I2C_COMPAT
1273        class_compat_unregister(i2c_adapter_compat_class);
1274#endif
1275        bus_unregister(&i2c_bus_type);
1276}
1277
1278/* We must initialize early, because some subsystems register i2c drivers
1279 * in subsys_initcall() code, but are linked (and initialized) before i2c.
1280 */
1281postcore_initcall(i2c_init);
1282module_exit(i2c_exit);
1283
1284/* ----------------------------------------------------
1285 * the functional interface to the i2c busses.
1286 * ----------------------------------------------------
1287 */
1288
1289/**
1290 * i2c_transfer - execute a single or combined I2C message
1291 * @adap: Handle to I2C bus
1292 * @msgs: One or more messages to execute before STOP is issued to
1293 *      terminate the operation; each message begins with a START.
1294 * @num: Number of messages to be executed.
1295 *
1296 * Returns negative errno, else the number of messages executed.
1297 *
1298 * Note that there is no requirement that each message be sent to
1299 * the same slave address, although that is the most common model.
1300 */
1301int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1302{
1303        unsigned long orig_jiffies;
1304        int ret, try;
1305
1306        /* REVISIT the fault reporting model here is weak:
1307         *
1308         *  - When we get an error after receiving N bytes from a slave,
1309         *    there is no way to report "N".
1310         *
1311         *  - When we get a NAK after transmitting N bytes to a slave,
1312         *    there is no way to report "N" ... or to let the master
1313         *    continue executing the rest of this combined message, if
1314         *    that's the appropriate response.
1315         *
1316         *  - When for example "num" is two and we successfully complete
1317         *    the first message but get an error part way through the
1318         *    second, it's unclear whether that should be reported as
1319         *    one (discarding status on the second message) or errno
1320         *    (discarding status on the first one).
1321         */
1322
1323        if (adap->algo->master_xfer) {
1324#ifdef DEBUG
1325                for (ret = 0; ret < num; ret++) {
1326                        dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1327                                "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1328                                ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1329                                (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1330                }
1331#endif
1332
1333                if (in_atomic() || irqs_disabled()) {
1334                        ret = i2c_trylock_adapter(adap);
1335                        if (!ret)
1336                                /* I2C activity is ongoing. */
1337                                return -EAGAIN;
1338                } else {
1339                        i2c_lock_adapter(adap);
1340                }
1341
1342                /* Retry automatically on arbitration loss */
1343                orig_jiffies = jiffies;
1344                for (ret = 0, try = 0; try <= adap->retries; try++) {
1345                        ret = adap->algo->master_xfer(adap, msgs, num);
1346                        if (ret != -EAGAIN)
1347                                break;
1348                        if (time_after(jiffies, orig_jiffies + adap->timeout))
1349                                break;
1350                }
1351                i2c_unlock_adapter(adap);
1352
1353                return ret;
1354        } else {
1355                dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1356                return -EOPNOTSUPP;
1357        }
1358}
1359EXPORT_SYMBOL(i2c_transfer);
1360
1361/**
1362 * i2c_master_send - issue a single I2C message in master transmit mode
1363 * @client: Handle to slave device
1364 * @buf: Data that will be written to the slave
1365 * @count: How many bytes to write, must be less than 64k since msg.len is u16
1366 *
1367 * Returns negative errno, or else the number of bytes written.
1368 */
1369int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1370{
1371        int ret;
1372        struct i2c_adapter *adap = client->adapter;
1373        struct i2c_msg msg;
1374
1375        msg.addr = client->addr;
1376        msg.flags = client->flags & I2C_M_TEN;
1377        msg.len = count;
1378        msg.buf = (char *)buf;
1379
1380        ret = i2c_transfer(adap, &msg, 1);
1381
1382        /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1383           transmitted, else error code. */
1384        return (ret == 1) ? count : ret;
1385}
1386EXPORT_SYMBOL(i2c_master_send);
1387
1388/**
1389 * i2c_master_recv - issue a single I2C message in master receive mode
1390 * @client: Handle to slave device
1391 * @buf: Where to store data read from slave
1392 * @count: How many bytes to read, must be less than 64k since msg.len is u16
1393 *
1394 * Returns negative errno, or else the number of bytes read.
1395 */
1396int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1397{
1398        struct i2c_adapter *adap = client->adapter;
1399        struct i2c_msg msg;
1400        int ret;
1401
1402        msg.addr = client->addr;
1403        msg.flags = client->flags & I2C_M_TEN;
1404        msg.flags |= I2C_M_RD;
1405        msg.len = count;
1406        msg.buf = buf;
1407
1408        ret = i2c_transfer(adap, &msg, 1);
1409
1410        /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1411           transmitted, else error code. */
1412        return (ret == 1) ? count : ret;
1413}
1414EXPORT_SYMBOL(i2c_master_recv);
1415
1416/* ----------------------------------------------------
1417 * the i2c address scanning function
1418 * Will not work for 10-bit addresses!
1419 * ----------------------------------------------------
1420 */
1421
1422/*
1423 * Legacy default probe function, mostly relevant for SMBus. The default
1424 * probe method is a quick write, but it is known to corrupt the 24RF08
1425 * EEPROMs due to a state machine bug, and could also irreversibly
1426 * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1427 * we use a short byte read instead. Also, some bus drivers don't implement
1428 * quick write, so we fallback to a byte read in that case too.
1429 * On x86, there is another special case for FSC hardware monitoring chips,
1430 * which want regular byte reads (address 0x73.) Fortunately, these are the
1431 * only known chips using this I2C address on PC hardware.
1432 * Returns 1 if probe succeeded, 0 if not.
1433 */
1434static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1435{
1436        int err;
1437        union i2c_smbus_data dummy;
1438
1439#ifdef CONFIG_X86
1440        if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1441         && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1442                err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1443                                     I2C_SMBUS_BYTE_DATA, &dummy);
1444        else
1445#endif
1446        if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1447         && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1448                err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1449                                     I2C_SMBUS_QUICK, NULL);
1450        else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1451                err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1452                                     I2C_SMBUS_BYTE, &dummy);
1453        else {
1454                dev_warn(&adap->dev, "No suitable probing method supported\n");
1455                err = -EOPNOTSUPP;
1456        }
1457
1458        return err >= 0;
1459}
1460
1461static int i2c_detect_address(struct i2c_client *temp_client,
1462                              struct i2c_driver *driver)
1463{
1464        struct i2c_board_info info;
1465        struct i2c_adapter *adapter = temp_client->adapter;
1466        int addr = temp_client->addr;
1467        int err;
1468
1469        /* Make sure the address is valid */
1470        err = i2c_check_addr_validity(addr);
1471        if (err) {
1472                dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1473                         addr);
1474                return err;
1475        }
1476
1477        /* Skip if already in use */
1478        if (i2c_check_addr_busy(adapter, addr))
1479                return 0;
1480
1481        /* Make sure there is something at this address */
1482        if (!i2c_default_probe(adapter, addr))
1483                return 0;
1484
1485        /* Finally call the custom detection function */
1486        memset(&info, 0, sizeof(struct i2c_board_info));
1487        info.addr = addr;
1488        err = driver->detect(temp_client, &info);
1489        if (err) {
1490                /* -ENODEV is returned if the detection fails. We catch it
1491                   here as this isn't an error. */
1492                return err == -ENODEV ? 0 : err;
1493        }
1494
1495        /* Consistency check */
1496        if (info.type[0] == '\0') {
1497                dev_err(&adapter->dev, "%s detection function provided "
1498                        "no name for 0x%x\n", driver->driver.name,
1499                        addr);
1500        } else {
1501                struct i2c_client *client;
1502
1503                /* Detection succeeded, instantiate the device */
1504                dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1505                        info.type, info.addr);
1506                client = i2c_new_device(adapter, &info);
1507                if (client)
1508                        list_add_tail(&client->detected, &driver->clients);
1509                else
1510                        dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1511                                info.type, info.addr);
1512        }
1513        return 0;
1514}
1515
1516static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1517{
1518        const unsigned short *address_list;
1519        struct i2c_client *temp_client;
1520        int i, err = 0;
1521        int adap_id = i2c_adapter_id(adapter);
1522
1523        address_list = driver->address_list;
1524        if (!driver->detect || !address_list)
1525                return 0;
1526
1527        /* Stop here if the classes do not match */
1528        if (!(adapter->class & driver->class))
1529                return 0;
1530
1531        /* Set up a temporary client to help detect callback */
1532        temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1533        if (!temp_client)
1534                return -ENOMEM;
1535        temp_client->adapter = adapter;
1536
1537        for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1538                dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1539                        "addr 0x%02x\n", adap_id, address_list[i]);
1540                temp_client->addr = address_list[i];
1541                err = i2c_detect_address(temp_client, driver);
1542                if (unlikely(err))
1543                        break;
1544        }
1545
1546        kfree(temp_client);
1547        return err;
1548}
1549
1550int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1551{
1552        return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1553                              I2C_SMBUS_QUICK, NULL) >= 0;
1554}
1555EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1556
1557struct i2c_client *
1558i2c_new_probed_device(struct i2c_adapter *adap,
1559                      struct i2c_board_info *info,
1560                      unsigned short const *addr_list,
1561                      int (*probe)(struct i2c_adapter *, unsigned short addr))
1562{
1563        int i;
1564
1565        if (!probe)
1566                probe = i2c_default_probe;
1567
1568        for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1569                /* Check address validity */
1570                if (i2c_check_addr_validity(addr_list[i]) < 0) {
1571                        dev_warn(&adap->dev, "Invalid 7-bit address "
1572                                 "0x%02x\n", addr_list[i]);
1573                        continue;
1574                }
1575
1576                /* Check address availability */
1577                if (i2c_check_addr_busy(adap, addr_list[i])) {
1578                        dev_dbg(&adap->dev, "Address 0x%02x already in "
1579                                "use, not probing\n", addr_list[i]);
1580                        continue;
1581                }
1582
1583                /* Test address responsiveness */
1584                if (probe(adap, addr_list[i]))
1585                        break;
1586        }
1587
1588        if (addr_list[i] == I2C_CLIENT_END) {
1589                dev_dbg(&adap->dev, "Probing failed, no device found\n");
1590                return NULL;
1591        }
1592
1593        info->addr = addr_list[i];
1594        return i2c_new_device(adap, info);
1595}
1596EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1597
1598struct i2c_adapter *i2c_get_adapter(int nr)
1599{
1600        struct i2c_adapter *adapter;
1601
1602        mutex_lock(&core_lock);
1603        adapter = idr_find(&i2c_adapter_idr, nr);
1604        if (adapter && !try_module_get(adapter->owner))
1605                adapter = NULL;
1606
1607        mutex_unlock(&core_lock);
1608        return adapter;
1609}
1610EXPORT_SYMBOL(i2c_get_adapter);
1611
1612void i2c_put_adapter(struct i2c_adapter *adap)
1613{
1614        module_put(adap->owner);
1615}
1616EXPORT_SYMBOL(i2c_put_adapter);
1617
1618/* The SMBus parts */
1619
1620#define POLY    (0x1070U << 3)
1621static u8 crc8(u16 data)
1622{
1623        int i;
1624
1625        for (i = 0; i < 8; i++) {
1626                if (data & 0x8000)
1627                        data = data ^ POLY;
1628                data = data << 1;
1629        }
1630        return (u8)(data >> 8);
1631}
1632
1633/* Incremental CRC8 over count bytes in the array pointed to by p */
1634static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1635{
1636        int i;
1637
1638        for (i = 0; i < count; i++)
1639                crc = crc8((crc ^ p[i]) << 8);
1640        return crc;
1641}
1642
1643/* Assume a 7-bit address, which is reasonable for SMBus */
1644static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1645{
1646        /* The address will be sent first */
1647        u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1648        pec = i2c_smbus_pec(pec, &addr, 1);
1649
1650        /* The data buffer follows */
1651        return i2c_smbus_pec(pec, msg->buf, msg->len);
1652}
1653
1654/* Used for write only transactions */
1655static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1656{
1657        msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1658        msg->len++;
1659}
1660
1661/* Return <0 on CRC error
1662   If there was a write before this read (most cases) we need to take the
1663   partial CRC from the write part into account.
1664   Note that this function does modify the message (we need to decrease the
1665   message length to hide the CRC byte from the caller). */
1666static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1667{
1668        u8 rpec = msg->buf[--msg->len];
1669        cpec = i2c_smbus_msg_pec(cpec, msg);
1670
1671        if (rpec != cpec) {
1672                pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1673                        rpec, cpec);
1674                return -EBADMSG;
1675        }
1676        return 0;
1677}
1678
1679/**
1680 * i2c_smbus_read_byte - SMBus "receive byte" protocol
1681 * @client: Handle to slave device
1682 *
1683 * This executes the SMBus "receive byte" protocol, returning negative errno
1684 * else the byte received from the device.
1685 */
1686s32 i2c_smbus_read_byte(const struct i2c_client *client)
1687{
1688        union i2c_smbus_data data;
1689        int status;
1690
1691        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1692                                I2C_SMBUS_READ, 0,
1693                                I2C_SMBUS_BYTE, &data);
1694        return (status < 0) ? status : data.byte;
1695}
1696EXPORT_SYMBOL(i2c_smbus_read_byte);
1697
1698/**
1699 * i2c_smbus_write_byte - SMBus "send byte" protocol
1700 * @client: Handle to slave device
1701 * @value: Byte to be sent
1702 *
1703 * This executes the SMBus "send byte" protocol, returning negative errno
1704 * else zero on success.
1705 */
1706s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1707{
1708        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1709                              I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1710}
1711EXPORT_SYMBOL(i2c_smbus_write_byte);
1712
1713/**
1714 * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1715 * @client: Handle to slave device
1716 * @command: Byte interpreted by slave
1717 *
1718 * This executes the SMBus "read byte" protocol, returning negative errno
1719 * else a data byte received from the device.
1720 */
1721s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
1722{
1723        union i2c_smbus_data data;
1724        int status;
1725
1726        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1727                                I2C_SMBUS_READ, command,
1728                                I2C_SMBUS_BYTE_DATA, &data);
1729        return (status < 0) ? status : data.byte;
1730}
1731EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1732
1733/**
1734 * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1735 * @client: Handle to slave device
1736 * @command: Byte interpreted by slave
1737 * @value: Byte being written
1738 *
1739 * This executes the SMBus "write byte" protocol, returning negative errno
1740 * else zero on success.
1741 */
1742s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1743                              u8 value)
1744{
1745        union i2c_smbus_data data;
1746        data.byte = value;
1747        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1748                              I2C_SMBUS_WRITE, command,
1749                              I2C_SMBUS_BYTE_DATA, &data);
1750}
1751EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1752
1753/**
1754 * i2c_smbus_read_word_data - SMBus "read word" protocol
1755 * @client: Handle to slave device
1756 * @command: Byte interpreted by slave
1757 *
1758 * This executes the SMBus "read word" protocol, returning negative errno
1759 * else a 16-bit unsigned "word" received from the device.
1760 */
1761s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1762{
1763        union i2c_smbus_data data;
1764        int status;
1765
1766        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1767                                I2C_SMBUS_READ, command,
1768                                I2C_SMBUS_WORD_DATA, &data);
1769        return (status < 0) ? status : data.word;
1770}
1771EXPORT_SYMBOL(i2c_smbus_read_word_data);
1772
1773/**
1774 * i2c_smbus_write_word_data - SMBus "write word" protocol
1775 * @client: Handle to slave device
1776 * @command: Byte interpreted by slave
1777 * @value: 16-bit "word" being written
1778 *
1779 * This executes the SMBus "write word" protocol, returning negative errno
1780 * else zero on success.
1781 */
1782s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1783                              u16 value)
1784{
1785        union i2c_smbus_data data;
1786        data.word = value;
1787        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1788                              I2C_SMBUS_WRITE, command,
1789                              I2C_SMBUS_WORD_DATA, &data);
1790}
1791EXPORT_SYMBOL(i2c_smbus_write_word_data);
1792
1793/**
1794 * i2c_smbus_process_call - SMBus "process call" protocol
1795 * @client: Handle to slave device
1796 * @command: Byte interpreted by slave
1797 * @value: 16-bit "word" being written
1798 *
1799 * This executes the SMBus "process call" protocol, returning negative errno
1800 * else a 16-bit unsigned "word" received from the device.
1801 */
1802s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1803                           u16 value)
1804{
1805        union i2c_smbus_data data;
1806        int status;
1807        data.word = value;
1808
1809        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1810                                I2C_SMBUS_WRITE, command,
1811                                I2C_SMBUS_PROC_CALL, &data);
1812        return (status < 0) ? status : data.word;
1813}
1814EXPORT_SYMBOL(i2c_smbus_process_call);
1815
1816/**
1817 * i2c_smbus_read_block_data - SMBus "block read" protocol
1818 * @client: Handle to slave device
1819 * @command: Byte interpreted by slave
1820 * @values: Byte array into which data will be read; big enough to hold
1821 *      the data returned by the slave.  SMBus allows at most 32 bytes.
1822 *
1823 * This executes the SMBus "block read" protocol, returning negative errno
1824 * else the number of data bytes in the slave's response.
1825 *
1826 * Note that using this function requires that the client's adapter support
1827 * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1828 * support this; its emulation through I2C messaging relies on a specific
1829 * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1830 */
1831s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1832                              u8 *values)
1833{
1834        union i2c_smbus_data data;
1835        int status;
1836
1837        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1838                                I2C_SMBUS_READ, command,
1839                                I2C_SMBUS_BLOCK_DATA, &data);
1840        if (status)
1841                return status;
1842
1843        memcpy(values, &data.block[1], data.block[0]);
1844        return data.block[0];
1845}
1846EXPORT_SYMBOL(i2c_smbus_read_block_data);
1847
1848/**
1849 * i2c_smbus_write_block_data - SMBus "block write" protocol
1850 * @client: Handle to slave device
1851 * @command: Byte interpreted by slave
1852 * @length: Size of data block; SMBus allows at most 32 bytes
1853 * @values: Byte array which will be written.
1854 *
1855 * This executes the SMBus "block write" protocol, returning negative errno
1856 * else zero on success.
1857 */
1858s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1859                               u8 length, const u8 *values)
1860{
1861        union i2c_smbus_data data;
1862
1863        if (length > I2C_SMBUS_BLOCK_MAX)
1864                length = I2C_SMBUS_BLOCK_MAX;
1865        data.block[0] = length;
1866        memcpy(&data.block[1], values, length);
1867        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1868                              I2C_SMBUS_WRITE, command,
1869                              I2C_SMBUS_BLOCK_DATA, &data);
1870}
1871EXPORT_SYMBOL(i2c_smbus_write_block_data);
1872
1873/* Returns the number of read bytes */
1874s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1875                                  u8 length, u8 *values)
1876{
1877        union i2c_smbus_data data;
1878        int status;
1879
1880        if (length > I2C_SMBUS_BLOCK_MAX)
1881                length = I2C_SMBUS_BLOCK_MAX;
1882        data.block[0] = length;
1883        status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1884                                I2C_SMBUS_READ, command,
1885                                I2C_SMBUS_I2C_BLOCK_DATA, &data);
1886        if (status < 0)
1887                return status;
1888
1889        memcpy(values, &data.block[1], data.block[0]);
1890        return data.block[0];
1891}
1892EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1893
1894s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1895                                   u8 length, const u8 *values)
1896{
1897        union i2c_smbus_data data;
1898
1899        if (length > I2C_SMBUS_BLOCK_MAX)
1900                length = I2C_SMBUS_BLOCK_MAX;
1901        data.block[0] = length;
1902        memcpy(data.block + 1, values, length);
1903        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1904                              I2C_SMBUS_WRITE, command,
1905                              I2C_SMBUS_I2C_BLOCK_DATA, &data);
1906}
1907EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1908
1909/* Simulate a SMBus command using the i2c protocol
1910   No checking of parameters is done!  */
1911static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1912                                   unsigned short flags,
1913                                   char read_write, u8 command, int size,
1914                                   union i2c_smbus_data *data)
1915{
1916        /* So we need to generate a series of msgs. In the case of writing, we
1917          need to use only one message; when reading, we need two. We initialize
1918          most things with sane defaults, to keep the code below somewhat
1919          simpler. */
1920        unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1921        unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1922        int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1923        struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1924                                  { addr, flags | I2C_M_RD, 0, msgbuf1 }
1925                                };
1926        int i;
1927        u8 partial_pec = 0;
1928        int status;
1929
1930        msgbuf0[0] = command;
1931        switch (size) {
1932        case I2C_SMBUS_QUICK:
1933                msg[0].len = 0;
1934                /* Special case: The read/write field is used as data */
1935                msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1936                                        I2C_M_RD : 0);
1937                num = 1;
1938                break;
1939        case I2C_SMBUS_BYTE:
1940                if (read_write == I2C_SMBUS_READ) {
1941                        /* Special case: only a read! */
1942                        msg[0].flags = I2C_M_RD | flags;
1943                        num = 1;
1944                }
1945                break;
1946        case I2C_SMBUS_BYTE_DATA:
1947                if (read_write == I2C_SMBUS_READ)
1948                        msg[1].len = 1;
1949                else {
1950                        msg[0].len = 2;
1951                        msgbuf0[1] = data->byte;
1952                }
1953                break;
1954        case I2C_SMBUS_WORD_DATA:
1955                if (read_write == I2C_SMBUS_READ)
1956                        msg[1].len = 2;
1957                else {
1958                        msg[0].len = 3;
1959                        msgbuf0[1] = data->word & 0xff;
1960                        msgbuf0[2] = data->word >> 8;
1961                }
1962                break;
1963        case I2C_SMBUS_PROC_CALL:
1964                num = 2; /* Special case */
1965                read_write = I2C_SMBUS_READ;
1966                msg[0].len = 3;
1967                msg[1].len = 2;
1968                msgbuf0[1] = data->word & 0xff;
1969                msgbuf0[2] = data->word >> 8;
1970                break;
1971        case I2C_SMBUS_BLOCK_DATA:
1972                if (read_write == I2C_SMBUS_READ) {
1973                        msg[1].flags |= I2C_M_RECV_LEN;
1974                        msg[1].len = 1; /* block length will be added by
1975                                           the underlying bus driver */
1976                } else {
1977                        msg[0].len = data->block[0] + 2;
1978                        if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1979                                dev_err(&adapter->dev,
1980                                        "Invalid block write size %d\n",
1981                                        data->block[0]);
1982                                return -EINVAL;
1983                        }
1984                        for (i = 1; i < msg[0].len; i++)
1985                                msgbuf0[i] = data->block[i-1];
1986                }
1987                break;
1988        case I2C_SMBUS_BLOCK_PROC_CALL:
1989                num = 2; /* Another special case */
1990                read_write = I2C_SMBUS_READ;
1991                if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1992                        dev_err(&adapter->dev,
1993                                "Invalid block write size %d\n",
1994                                data->block[0]);
1995                        return -EINVAL;
1996                }
1997                msg[0].len = data->block[0] + 2;
1998                for (i = 1; i < msg[0].len; i++)
1999                        msgbuf0[i] = data->block[i-1];
2000                msg[1].flags |= I2C_M_RECV_LEN;
2001                msg[1].len = 1; /* block length will be added by
2002                                   the underlying bus driver */
2003                break;
2004        case I2C_SMBUS_I2C_BLOCK_DATA:
2005                if (read_write == I2C_SMBUS_READ) {
2006                        msg[1].len = data->block[0];
2007                } else {
2008                        msg[0].len = data->block[0] + 1;
2009                        if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2010                                dev_err(&adapter->dev,
2011                                        "Invalid block write size %d\n",
2012                                        data->block[0]);
2013                                return -EINVAL;
2014                        }
2015                        for (i = 1; i <= data->block[0]; i++)
2016                                msgbuf0[i] = data->block[i];
2017                }
2018                break;
2019        default:
2020                dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2021                return -EOPNOTSUPP;
2022        }
2023
2024        i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2025                                      && size != I2C_SMBUS_I2C_BLOCK_DATA);
2026        if (i) {
2027                /* Compute PEC if first message is a write */
2028                if (!(msg[0].flags & I2C_M_RD)) {
2029                        if (num == 1) /* Write only */
2030                                i2c_smbus_add_pec(&msg[0]);
2031                        else /* Write followed by read */
2032                                partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2033                }
2034                /* Ask for PEC if last message is a read */
2035                if (msg[num-1].flags & I2C_M_RD)
2036                        msg[num-1].len++;
2037        }
2038
2039        status = i2c_transfer(adapter, msg, num);
2040        if (status < 0)
2041                return status;
2042
2043        /* Check PEC if last message is a read */
2044        if (i && (msg[num-1].flags & I2C_M_RD)) {
2045                status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2046                if (status < 0)
2047                        return status;
2048        }
2049
2050        if (read_write == I2C_SMBUS_READ)
2051                switch (size) {
2052                case I2C_SMBUS_BYTE:
2053                        data->byte = msgbuf0[0];
2054                        break;
2055                case I2C_SMBUS_BYTE_DATA:
2056                        data->byte = msgbuf1[0];
2057                        break;
2058                case I2C_SMBUS_WORD_DATA:
2059                case I2C_SMBUS_PROC_CALL:
2060                        data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2061                        break;
2062                case I2C_SMBUS_I2C_BLOCK_DATA:
2063                        for (i = 0; i < data->block[0]; i++)
2064                                data->block[i+1] = msgbuf1[i];
2065                        break;
2066                case I2C_SMBUS_BLOCK_DATA:
2067                case I2C_SMBUS_BLOCK_PROC_CALL:
2068                        for (i = 0; i < msgbuf1[0] + 1; i++)
2069                                data->block[i] = msgbuf1[i];
2070                        break;
2071                }
2072        return 0;
2073}
2074
2075/**
2076 * i2c_smbus_xfer - execute SMBus protocol operations
2077 * @adapter: Handle to I2C bus
2078 * @addr: Address of SMBus slave on that bus
2079 * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2080 * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2081 * @command: Byte interpreted by slave, for protocols which use such bytes
2082 * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2083 * @data: Data to be read or written
2084 *
2085 * This executes an SMBus protocol operation, and returns a negative
2086 * errno code else zero on success.
2087 */
2088s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2089                   char read_write, u8 command, int protocol,
2090                   union i2c_smbus_data *data)
2091{
2092        unsigned long orig_jiffies;
2093        int try;
2094        s32 res;
2095
2096        flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2097
2098        if (adapter->algo->smbus_xfer) {
2099                i2c_lock_adapter(adapter);
2100
2101                /* Retry automatically on arbitration loss */
2102                orig_jiffies = jiffies;
2103                for (res = 0, try = 0; try <= adapter->retries; try++) {
2104                        res = adapter->algo->smbus_xfer(adapter, addr, flags,
2105                                                        read_write, command,
2106                                                        protocol, data);
2107                        if (res != -EAGAIN)
2108                                break;
2109                        if (time_after(jiffies,
2110                                       orig_jiffies + adapter->timeout))
2111                                break;
2112                }
2113                i2c_unlock_adapter(adapter);
2114        } else
2115                res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2116                                              command, protocol, data);
2117
2118        return res;
2119}
2120EXPORT_SYMBOL(i2c_smbus_xfer);
2121
2122MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2123MODULE_DESCRIPTION("I2C-Bus main module");
2124MODULE_LICENSE("GPL");
2125