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