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