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