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