drivers/i2c/i2c-core.c

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