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