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  * This function is only needed for mutex_lock_nested, so it is never
 641  * called unless locking correctness checking is enabled. Thus we
 642  * make it inline to avoid a compiler warning. That's what gcc ends up
 643  * doing anyway.
 644  */
 645 static inline unsigned int i2c_adapter_depth(struct i2c_adapter *adapter)
 646 {
 647         unsigned int depth = 0;
 648
 649         while ((adapter = i2c_parent_is_i2c_adapter(adapter)))
 650                 depth++;
 651
 652         return depth;
 653 }
 654
 655 /*
 656  * Let users instantiate I2C devices through sysfs. This can be used when
 657  * platform initialization code doesn't contain the proper data for
 658  * whatever reason. Also useful for drivers that do device detection and
 659  * detection fails, either because the device uses an unexpected address,
 660  * or this is a compatible device with different ID register values.
 661  *
 662  * Parameter checking may look overzealous, but we really don't want
 663  * the user to provide incorrect parameters.
 664  */
 665 static ssize_t
 666 i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr,
 667                      const char *buf, size_t count)
 668 {
 669         struct i2c_adapter *adap = to_i2c_adapter(dev);
 670         struct i2c_board_info info;
 671         struct i2c_client *client;
 672         char *blank, end;
 673         int res;
 674
 675         memset(&info, 0, sizeof(struct i2c_board_info));
 676
 677         blank = strchr(buf, ' ');
 678         if (!blank) {
 679                 dev_err(dev, "%s: Missing parameters\n", "new_device");
 680                 return -EINVAL;
 681         }
 682         if (blank - buf > I2C_NAME_SIZE - 1) {
 683                 dev_err(dev, "%s: Invalid device name\n", "new_device");
 684                 return -EINVAL;
 685         }
 686         memcpy(info.type, buf, blank - buf);
 687
 688         /* Parse remaining parameters, reject extra parameters */
 689         res = sscanf(++blank, "%hi%c", &info.addr, &end);
 690         if (res < 1) {
 691                 dev_err(dev, "%s: Can't parse I2C address\n", "new_device");
 692                 return -EINVAL;
 693         }
 694         if (res > 1  && end != '\n') {
 695                 dev_err(dev, "%s: Extra parameters\n", "new_device");
 696                 return -EINVAL;
 697         }
 698
 699         client = i2c_new_device(adap, &info);
 700         if (!client)
 701                 return -EINVAL;
 702
 703         /* Keep track of the added device */
 704         mutex_lock(&adap->userspace_clients_lock);
 705         list_add_tail(&client->detected, &adap->userspace_clients);
 706         mutex_unlock(&adap->userspace_clients_lock);
 707         dev_info(dev, "%s: Instantiated device %s at 0x%02hx\n", "new_device",
 708                  info.type, info.addr);
 709
 710         return count;
 711 }
 712
 713 /*
 714  * And of course let the users delete the devices they instantiated, if
 715  * they got it wrong. This interface can only be used to delete devices
 716  * instantiated by i2c_sysfs_new_device above. This guarantees that we
 717  * don't delete devices to which some kernel code still has references.
 718  *
 719  * Parameter checking may look overzealous, but we really don't want
 720  * the user to delete the wrong device.
 721  */
 722 static ssize_t
 723 i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
 724                         const char *buf, size_t count)
 725 {
 726         struct i2c_adapter *adap = to_i2c_adapter(dev);
 727         struct i2c_client *client, *next;
 728         unsigned short addr;
 729         char end;
 730         int res;
 731
 732         /* Parse parameters, reject extra parameters */
 733         res = sscanf(buf, "%hi%c", &addr, &end);
 734         if (res < 1) {
 735                 dev_err(dev, "%s: Can't parse I2C address\n", "delete_device");
 736                 return -EINVAL;
 737         }
 738         if (res > 1  && end != '\n') {
 739                 dev_err(dev, "%s: Extra parameters\n", "delete_device");
 740                 return -EINVAL;
 741         }
 742
 743         /* Make sure the device was added through sysfs */
 744         res = -ENOENT;
 745         mutex_lock_nested(&adap->userspace_clients_lock,
 746                           i2c_adapter_depth(adap));
 747         list_for_each_entry_safe(client, next, &adap->userspace_clients,
 748                                  detected) {
 749                 if (client->addr == addr) {
 750                         dev_info(dev, "%s: Deleting device %s at 0x%02hx\n",
 751                                  "delete_device", client->name, client->addr);
 752
 753                         list_del(&client->detected);
 754                         i2c_unregister_device(client);
 755                         res = count;
 756                         break;
 757                 }
 758         }
 759         mutex_unlock(&adap->userspace_clients_lock);
 760
 761         if (res < 0)
 762                 dev_err(dev, "%s: Can't find device in list\n",
 763                         "delete_device");
 764         return res;
 765 }
 766
 767 static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
 768 static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
 769
 770 static struct attribute *i2c_adapter_attrs[] = {
 771         &dev_attr_name.attr,
 772         &dev_attr_new_device.attr,
 773         &dev_attr_delete_device.attr,
 774         NULL
 775 };
 776
 777 static struct attribute_group i2c_adapter_attr_group = {
 778         .attrs          = i2c_adapter_attrs,
 779 };
 780
 781 static const struct attribute_group *i2c_adapter_attr_groups[] = {
 782         &i2c_adapter_attr_group,
 783         NULL
 784 };
 785
 786 struct device_type i2c_adapter_type = {
 787         .groups         = i2c_adapter_attr_groups,
 788         .release        = i2c_adapter_dev_release,
 789 };
 790 EXPORT_SYMBOL_GPL(i2c_adapter_type);
 791
 792 /**
 793  * i2c_verify_adapter - return parameter as i2c_adapter or NULL
 794  * @dev: device, probably from some driver model iterator
 795  *
 796  * When traversing the driver model tree, perhaps using driver model
 797  * iterators like @device_for_each_child(), you can't assume very much
 798  * about the nodes you find.  Use this function to avoid oopses caused
 799  * by wrongly treating some non-I2C device as an i2c_adapter.
 800  */
 801 struct i2c_adapter *i2c_verify_adapter(struct device *dev)
 802 {
 803         return (dev->type == &i2c_adapter_type)
 804                         ? to_i2c_adapter(dev)
 805                         : NULL;
 806 }
 807 EXPORT_SYMBOL(i2c_verify_adapter);
 808
 809 #ifdef CONFIG_I2C_COMPAT
 810 static struct class_compat *i2c_adapter_compat_class;
 811 #endif
 812
 813 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 814 {
 815         struct i2c_devinfo      *devinfo;
 816
 817         down_read(&__i2c_board_lock);
 818         list_for_each_entry(devinfo, &__i2c_board_list, list) {
 819                 if (devinfo->busnum == adapter->nr
 820                                 && !i2c_new_device(adapter,
 821                                                 &devinfo->board_info))
 822                         dev_err(&adapter->dev,
 823                                 "Can't create device at 0x%02x\n",
 824                                 devinfo->board_info.addr);
 825         }
 826         up_read(&__i2c_board_lock);
 827 }
 828
 829 static int i2c_do_add_adapter(struct i2c_driver *driver,
 830                               struct i2c_adapter *adap)
 831 {
 832         /* Detect supported devices on that bus, and instantiate them */
 833         i2c_detect(adap, driver);
 834
 835         /* Let legacy drivers scan this bus for matching devices */
 836         if (driver->attach_adapter) {
 837                 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
 838                          driver->driver.name);
 839                 dev_warn(&adap->dev, "Please use another way to instantiate "
 840                          "your i2c_client\n");
 841                 /* We ignore the return code; if it fails, too bad */
 842                 driver->attach_adapter(adap);
 843         }
 844         return 0;
 845 }
 846
 847 static int __process_new_adapter(struct device_driver *d, void *data)
 848 {
 849         return i2c_do_add_adapter(to_i2c_driver(d), data);
 850 }
 851
 852 static int i2c_register_adapter(struct i2c_adapter *adap)
 853 {
 854         int res = 0;
 855
 856         /* Can't register until after driver model init */
 857         if (unlikely(WARN_ON(!i2c_bus_type.p))) {
 858                 res = -EAGAIN;
 859                 goto out_list;
 860         }
 861
 862         /* Sanity checks */
 863         if (unlikely(adap->name[0] == '\0')) {
 864                 pr_err("i2c-core: Attempt to register an adapter with "
 865                        "no name!\n");
 866                 return -EINVAL;
 867         }
 868         if (unlikely(!adap->algo)) {
 869                 pr_err("i2c-core: Attempt to register adapter '%s' with "
 870                        "no algo!\n", adap->name);
 871                 return -EINVAL;
 872         }
 873
 874         rt_mutex_init(&adap->bus_lock);
 875         mutex_init(&adap->userspace_clients_lock);
 876         INIT_LIST_HEAD(&adap->userspace_clients);
 877
 878         /* Set default timeout to 1 second if not already set */
 879         if (adap->timeout == 0)
 880                 adap->timeout = HZ;
 881
 882         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
 883         adap->dev.bus = &i2c_bus_type;
 884         adap->dev.type = &i2c_adapter_type;
 885         res = device_register(&adap->dev);
 886         if (res)
 887                 goto out_list;
 888
 889         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 890
 891 #ifdef CONFIG_I2C_COMPAT
 892         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
 893                                        adap->dev.parent);
 894         if (res)
 895                 dev_warn(&adap->dev,
 896                          "Failed to create compatibility class link\n");
 897 #endif
 898
 899         /* create pre-declared device nodes */
 900         if (adap->nr < __i2c_first_dynamic_bus_num)
 901                 i2c_scan_static_board_info(adap);
 902
 903         /* Notify drivers */
 904         mutex_lock(&core_lock);
 905         bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
 906         mutex_unlock(&core_lock);
 907
 908         return 0;
 909
 910 out_list:
 911         mutex_lock(&core_lock);
 912         idr_remove(&i2c_adapter_idr, adap->nr);
 913         mutex_unlock(&core_lock);
 914         return res;
 915 }
 916
 917 /**
 918  * i2c_add_adapter - declare i2c adapter, use dynamic bus number
 919  * @adapter: the adapter to add
 920  * Context: can sleep
 921  *
 922  * This routine is used to declare an I2C adapter when its bus number
 923  * doesn't matter.  Examples: for I2C adapters dynamically added by
 924  * USB links or PCI plugin cards.
 925  *
 926  * When this returns zero, a new bus number was allocated and stored
 927  * in adap->nr, and the specified adapter became available for clients.
 928  * Otherwise, a negative errno value is returned.
 929  */
 930 int i2c_add_adapter(struct i2c_adapter *adapter)
 931 {
 932         int     id, res = 0;
 933
 934 retry:
 935         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 936                 return -ENOMEM;
 937
 938         mutex_lock(&core_lock);
 939         /* "above" here means "above or equal to", sigh */
 940         res = idr_get_new_above(&i2c_adapter_idr, adapter,
 941                                 __i2c_first_dynamic_bus_num, &id);
 942         mutex_unlock(&core_lock);
 943
 944         if (res < 0) {
 945                 if (res == -EAGAIN)
 946                         goto retry;
 947                 return res;
 948         }
 949
 950         adapter->nr = id;
 951         return i2c_register_adapter(adapter);
 952 }
 953 EXPORT_SYMBOL(i2c_add_adapter);
 954
 955 /**
 956  * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
 957  * @adap: the adapter to register (with adap->nr initialized)
 958  * Context: can sleep
 959  *
 960  * This routine is used to declare an I2C adapter when its bus number
 961  * matters.  For example, use it for I2C adapters from system-on-chip CPUs,
 962  * or otherwise built in to the system's mainboard, and where i2c_board_info
 963  * is used to properly configure I2C devices.
 964  *
 965  * If the requested bus number is set to -1, then this function will behave
 966  * identically to i2c_add_adapter, and will dynamically assign a bus number.
 967  *
 968  * If no devices have pre-been declared for this bus, then be sure to
 969  * register the adapter before any dynamically allocated ones.  Otherwise
 970  * the required bus ID may not be available.
 971  *
 972  * When this returns zero, the specified adapter became available for
 973  * clients using the bus number provided in adap->nr.  Also, the table
 974  * of I2C devices pre-declared using i2c_register_board_info() is scanned,
 975  * and the appropriate driver model device nodes are created.  Otherwise, a
 976  * negative errno value is returned.
 977  */
 978 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 979 {
 980         int     id;
 981         int     status;
 982
 983         if (adap->nr == -1) /* -1 means dynamically assign bus id */
 984                 return i2c_add_adapter(adap);
 985         if (adap->nr & ~MAX_IDR_MASK)
 986                 return -EINVAL;
 987
 988 retry:
 989         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
 990                 return -ENOMEM;
 991
 992         mutex_lock(&core_lock);
 993         /* "above" here means "above or equal to", sigh;
 994          * we need the "equal to" result to force the result
 995          */
 996         status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
 997         if (status == 0 && id != adap->nr) {
 998                 status = -EBUSY;
 999                 idr_remove(&i2c_adapter_idr, id);
1000         }
1001         mutex_unlock(&core_lock);
1002         if (status == -EAGAIN)
1003                 goto retry;
1004
1005         if (status == 0)
1006                 status = i2c_register_adapter(adap);
1007         return status;
1008 }
1009 EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
1010
1011 static int i2c_do_del_adapter(struct i2c_driver *driver,
1012                               struct i2c_adapter *adapter)
1013 {
1014         struct i2c_client *client, *_n;
1015         int res;
1016
1017         /* Remove the devices we created ourselves as the result of hardware
1018          * probing (using a driver's detect method) */
1019         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1020                 if (client->adapter == adapter) {
1021                         dev_dbg(&adapter->dev, "Removing %s at 0x%x\n",
1022                                 client->name, client->addr);
1023                         list_del(&client->detected);
1024                         i2c_unregister_device(client);
1025                 }
1026         }
1027
1028         if (!driver->detach_adapter)
1029                 return 0;
1030         dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated\n",
1031                  driver->driver.name);
1032         res = driver->detach_adapter(adapter);
1033         if (res)
1034                 dev_err(&adapter->dev, "detach_adapter failed (%d) "
1035                         "for driver [%s]\n", res, driver->driver.name);
1036         return res;
1037 }
1038
1039 static int __unregister_client(struct device *dev, void *dummy)
1040 {
1041         struct i2c_client *client = i2c_verify_client(dev);
1042         if (client && strcmp(client->name, "dummy"))
1043                 i2c_unregister_device(client);
1044         return 0;
1045 }
1046
1047 static int __unregister_dummy(struct device *dev, void *dummy)
1048 {
1049         struct i2c_client *client = i2c_verify_client(dev);
1050         if (client)
1051                 i2c_unregister_device(client);
1052         return 0;
1053 }
1054
1055 static int __process_removed_adapter(struct device_driver *d, void *data)
1056 {
1057         return i2c_do_del_adapter(to_i2c_driver(d), data);
1058 }
1059
1060 /**
1061  * i2c_del_adapter - unregister I2C adapter
1062  * @adap: the adapter being unregistered
1063  * Context: can sleep
1064  *
1065  * This unregisters an I2C adapter which was previously registered
1066  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1067  */
1068 int i2c_del_adapter(struct i2c_adapter *adap)
1069 {
1070         int res = 0;
1071         struct i2c_adapter *found;
1072         struct i2c_client *client, *next;
1073
1074         /* First make sure that this adapter was ever added */
1075         mutex_lock(&core_lock);
1076         found = idr_find(&i2c_adapter_idr, adap->nr);
1077         mutex_unlock(&core_lock);
1078         if (found != adap) {
1079                 pr_debug("i2c-core: attempting to delete unregistered "
1080                          "adapter [%s]\n", adap->name);
1081                 return -EINVAL;
1082         }
1083
1084         /* Tell drivers about this removal */
1085         mutex_lock(&core_lock);
1086         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1087                                __process_removed_adapter);
1088         mutex_unlock(&core_lock);
1089         if (res)
1090                 return res;
1091
1092         /* Remove devices instantiated from sysfs */
1093         mutex_lock_nested(&adap->userspace_clients_lock,
1094                           i2c_adapter_depth(adap));
1095         list_for_each_entry_safe(client, next, &adap->userspace_clients,
1096                                  detected) {
1097                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1098                         client->addr);
1099                 list_del(&client->detected);
1100                 i2c_unregister_device(client);
1101         }
1102         mutex_unlock(&adap->userspace_clients_lock);
1103
1104         /* Detach any active clients. This can't fail, thus we do not
1105          * check the returned value. This is a two-pass process, because
1106          * we can't remove the dummy devices during the first pass: they
1107          * could have been instantiated by real devices wishing to clean
1108          * them up properly, so we give them a chance to do that first. */
1109         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1110         res = device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1111
1112 #ifdef CONFIG_I2C_COMPAT
1113         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1114                                  adap->dev.parent);
1115 #endif
1116
1117         /* device name is gone after device_unregister */
1118         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1119
1120         /* clean up the sysfs representation */
1121         init_completion(&adap->dev_released);
1122         device_unregister(&adap->dev);
1123
1124         /* wait for sysfs to drop all references */
1125         wait_for_completion(&adap->dev_released);
1126
1127         /* free bus id */
1128         mutex_lock(&core_lock);
1129         idr_remove(&i2c_adapter_idr, adap->nr);
1130         mutex_unlock(&core_lock);
1131
1132         /* Clear the device structure in case this adapter is ever going to be
1133            added again */
1134         memset(&adap->dev, 0, sizeof(adap->dev));
1135
1136         return 0;
1137 }
1138 EXPORT_SYMBOL(i2c_del_adapter);
1139
1140
1141 /* ------------------------------------------------------------------------- */
1142
1143 int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1144 {
1145         int res;
1146
1147         mutex_lock(&core_lock);
1148         res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1149         mutex_unlock(&core_lock);
1150
1151         return res;
1152 }
1153 EXPORT_SYMBOL_GPL(i2c_for_each_dev);
1154
1155 static int __process_new_driver(struct device *dev, void *data)
1156 {
1157         if (dev->type != &i2c_adapter_type)
1158                 return 0;
1159         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1160 }
1161
1162 /*
1163  * An i2c_driver is used with one or more i2c_client (device) nodes to access
1164  * i2c slave chips, on a bus instance associated with some i2c_adapter.
1165  */
1166
1167 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1168 {
1169         int res;
1170
1171         /* Can't register until after driver model init */
1172         if (unlikely(WARN_ON(!i2c_bus_type.p)))
1173                 return -EAGAIN;
1174
1175         /* add the driver to the list of i2c drivers in the driver core */
1176         driver->driver.owner = owner;
1177         driver->driver.bus = &i2c_bus_type;
1178
1179         /* When registration returns, the driver core
1180          * will have called probe() for all matching-but-unbound devices.
1181          */
1182         res = driver_register(&driver->driver);
1183         if (res)
1184                 return res;
1185
1186         /* Drivers should switch to dev_pm_ops instead. */
1187         if (driver->suspend)
1188                 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1189                         driver->driver.name);
1190         if (driver->resume)
1191                 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1192                         driver->driver.name);
1193
1194         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1195
1196         INIT_LIST_HEAD(&driver->clients);
1197         /* Walk the adapters that are already present */
1198         i2c_for_each_dev(driver, __process_new_driver);
1199
1200         return 0;
1201 }
1202 EXPORT_SYMBOL(i2c_register_driver);
1203
1204 static int __process_removed_driver(struct device *dev, void *data)
1205 {
1206         if (dev->type != &i2c_adapter_type)
1207                 return 0;
1208         return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1209 }
1210
1211 /**
1212  * i2c_del_driver - unregister I2C driver
1213  * @driver: the driver being unregistered
1214  * Context: can sleep
1215  */
1216 void i2c_del_driver(struct i2c_driver *driver)
1217 {
1218         i2c_for_each_dev(driver, __process_removed_driver);
1219
1220         driver_unregister(&driver->driver);
1221         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1222 }
1223 EXPORT_SYMBOL(i2c_del_driver);
1224
1225 /* ------------------------------------------------------------------------- */
1226
1227 /**
1228  * i2c_use_client - increments the reference count of the i2c client structure
1229  * @client: the client being referenced
1230  *
1231  * Each live reference to a client should be refcounted. The driver model does
1232  * that automatically as part of driver binding, so that most drivers don't
1233  * need to do this explicitly: they hold a reference until they're unbound
1234  * from the device.
1235  *
1236  * A pointer to the client with the incremented reference counter is returned.
1237  */
1238 struct i2c_client *i2c_use_client(struct i2c_client *client)
1239 {
1240         if (client && get_device(&client->dev))
1241                 return client;
1242         return NULL;
1243 }
1244 EXPORT_SYMBOL(i2c_use_client);
1245
1246 /**
1247  * i2c_release_client - release a use of the i2c client structure
1248  * @client: the client being no longer referenced
1249  *
1250  * Must be called when a user of a client is finished with it.
1251  */
1252 void i2c_release_client(struct i2c_client *client)
1253 {
1254         if (client)
1255                 put_device(&client->dev);
1256 }
1257 EXPORT_SYMBOL(i2c_release_client);
1258
1259 struct i2c_cmd_arg {
1260         unsigned        cmd;
1261         void            *arg;
1262 };
1263
1264 static int i2c_cmd(struct device *dev, void *_arg)
1265 {
1266         struct i2c_client       *client = i2c_verify_client(dev);
1267         struct i2c_cmd_arg      *arg = _arg;
1268
1269         if (client && client->driver && client->driver->command)
1270                 client->driver->command(client, arg->cmd, arg->arg);
1271         return 0;
1272 }
1273
1274 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1275 {
1276         struct i2c_cmd_arg      cmd_arg;
1277
1278         cmd_arg.cmd = cmd;
1279         cmd_arg.arg = arg;
1280         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1281 }
1282 EXPORT_SYMBOL(i2c_clients_command);
1283
1284 static int __init i2c_init(void)
1285 {
1286         int retval;
1287
1288         retval = bus_register(&i2c_bus_type);
1289         if (retval)
1290                 return retval;
1291 #ifdef CONFIG_I2C_COMPAT
1292         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1293         if (!i2c_adapter_compat_class) {
1294                 retval = -ENOMEM;
1295                 goto bus_err;
1296         }
1297 #endif
1298         retval = i2c_add_driver(&dummy_driver);
1299         if (retval)
1300                 goto class_err;
1301         return 0;
1302
1303 class_err:
1304 #ifdef CONFIG_I2C_COMPAT
1305         class_compat_unregister(i2c_adapter_compat_class);
1306 bus_err:
1307 #endif
1308         bus_unregister(&i2c_bus_type);
1309         return retval;
1310 }
1311
1312 static void __exit i2c_exit(void)
1313 {
1314         i2c_del_driver(&dummy_driver);
1315 #ifdef CONFIG_I2C_COMPAT
1316         class_compat_unregister(i2c_adapter_compat_class);
1317 #endif
1318         bus_unregister(&i2c_bus_type);
1319 }
1320
1321 /* We must initialize early, because some subsystems register i2c drivers
1322  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1323  */
1324 postcore_initcall(i2c_init);
1325 module_exit(i2c_exit);
1326
1327 /* ----------------------------------------------------
1328  * the functional interface to the i2c busses.
1329  * ----------------------------------------------------
1330  */
1331
1332 /**
1333  * __i2c_transfer - unlocked flavor of i2c_transfer
1334  * @adap: Handle to I2C bus
1335  * @msgs: One or more messages to execute before STOP is issued to
1336  *      terminate the operation; each message begins with a START.
1337  * @num: Number of messages to be executed.
1338  *
1339  * Returns negative errno, else the number of messages executed.
1340  *
1341  * Adapter lock must be held when calling this function. No debug logging
1342  * takes place. adap->algo->master_xfer existence isn't checked.
1343  */
1344 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1345 {
1346         unsigned long orig_jiffies;
1347         int ret, try;
1348
1349         /* Retry automatically on arbitration loss */
1350         orig_jiffies = jiffies;
1351         for (ret = 0, try = 0; try <= adap->retries; try++) {
1352                 ret = adap->algo->master_xfer(adap, msgs, num);
1353                 if (ret != -EAGAIN)
1354                         break;
1355                 if (time_after(jiffies, orig_jiffies + adap->timeout))
1356                         break;
1357         }
1358
1359         return ret;
1360 }
1361 EXPORT_SYMBOL(__i2c_transfer);
1362
1363 /**
1364  * i2c_transfer - execute a single or combined I2C message
1365  * @adap: Handle to I2C bus
1366  * @msgs: One or more messages to execute before STOP is issued to
1367  *      terminate the operation; each message begins with a START.
1368  * @num: Number of messages to be executed.
1369  *
1370  * Returns negative errno, else the number of messages executed.
1371  *
1372  * Note that there is no requirement that each message be sent to
1373  * the same slave address, although that is the most common model.
1374  */
1375 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1376 {
1377         int ret;
1378
1379         /* REVISIT the fault reporting model here is weak:
1380          *
1381          *  - When we get an error after receiving N bytes from a slave,
1382          *    there is no way to report "N".
1383          *
1384          *  - When we get a NAK after transmitting N bytes to a slave,
1385          *    there is no way to report "N" ... or to let the master
1386          *    continue executing the rest of this combined message, if
1387          *    that's the appropriate response.
1388          *
1389          *  - When for example "num" is two and we successfully complete
1390          *    the first message but get an error part way through the
1391          *    second, it's unclear whether that should be reported as
1392          *    one (discarding status on the second message) or errno
1393          *    (discarding status on the first one).
1394          */
1395
1396         if (adap->algo->master_xfer) {
1397 #ifdef DEBUG
1398                 for (ret = 0; ret < num; ret++) {
1399                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1400                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1401                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1402                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1403                 }
1404 #endif
1405
1406                 if (in_atomic() || irqs_disabled()) {
1407                         ret = i2c_trylock_adapter(adap);
1408                         if (!ret)
1409                                 /* I2C activity is ongoing. */
1410                                 return -EAGAIN;
1411                 } else {
1412                         i2c_lock_adapter(adap);
1413                 }
1414
1415                 ret = __i2c_transfer(adap, msgs, num);
1416                 i2c_unlock_adapter(adap);
1417
1418                 return ret;
1419         } else {
1420                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1421                 return -EOPNOTSUPP;
1422         }
1423 }
1424 EXPORT_SYMBOL(i2c_transfer);
1425
1426 /**
1427  * i2c_master_send - issue a single I2C message in master transmit mode
1428  * @client: Handle to slave device
1429  * @buf: Data that will be written to the slave
1430  * @count: How many bytes to write, must be less than 64k since msg.len is u16
1431  *
1432  * Returns negative errno, or else the number of bytes written.
1433  */
1434 int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
1435 {
1436         int ret;
1437         struct i2c_adapter *adap = client->adapter;
1438         struct i2c_msg msg;
1439
1440         msg.addr = client->addr;
1441         msg.flags = client->flags & I2C_M_TEN;
1442         msg.len = count;
1443         msg.buf = (char *)buf;
1444
1445         ret = i2c_transfer(adap, &msg, 1);
1446
1447         /*
1448          * If everything went ok (i.e. 1 msg transmitted), return #bytes
1449          * transmitted, else error code.
1450          */
1451         return (ret == 1) ? count : ret;
1452 }
1453 EXPORT_SYMBOL(i2c_master_send);
1454
1455 /**
1456  * i2c_master_recv - issue a single I2C message in master receive mode
1457  * @client: Handle to slave device
1458  * @buf: Where to store data read from slave
1459  * @count: How many bytes to read, must be less than 64k since msg.len is u16
1460  *
1461  * Returns negative errno, or else the number of bytes read.
1462  */
1463 int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
1464 {
1465         struct i2c_adapter *adap = client->adapter;
1466         struct i2c_msg msg;
1467         int ret;
1468
1469         msg.addr = client->addr;
1470         msg.flags = client->flags & I2C_M_TEN;
1471         msg.flags |= I2C_M_RD;
1472         msg.len = count;
1473         msg.buf = buf;
1474
1475         ret = i2c_transfer(adap, &msg, 1);
1476
1477         /*
1478          * If everything went ok (i.e. 1 msg received), return #bytes received,
1479          * else error code.
1480          */
1481         return (ret == 1) ? count : ret;
1482 }
1483 EXPORT_SYMBOL(i2c_master_recv);
1484
1485 /* ----------------------------------------------------
1486  * the i2c address scanning function
1487  * Will not work for 10-bit addresses!
1488  * ----------------------------------------------------
1489  */
1490
1491 /*
1492  * Legacy default probe function, mostly relevant for SMBus. The default
1493  * probe method is a quick write, but it is known to corrupt the 24RF08
1494  * EEPROMs due to a state machine bug, and could also irreversibly
1495  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1496  * we use a short byte read instead. Also, some bus drivers don't implement
1497  * quick write, so we fallback to a byte read in that case too.
1498  * On x86, there is another special case for FSC hardware monitoring chips,
1499  * which want regular byte reads (address 0x73.) Fortunately, these are the
1500  * only known chips using this I2C address on PC hardware.
1501  * Returns 1 if probe succeeded, 0 if not.
1502  */
1503 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1504 {
1505         int err;
1506         union i2c_smbus_data dummy;
1507
1508 #ifdef CONFIG_X86
1509         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1510          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1511                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1512                                      I2C_SMBUS_BYTE_DATA, &dummy);
1513         else
1514 #endif
1515         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1516          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1517                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1518                                      I2C_SMBUS_QUICK, NULL);
1519         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1520                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1521                                      I2C_SMBUS_BYTE, &dummy);
1522         else {
1523                 dev_warn(&adap->dev, "No suitable probing method supported\n");
1524                 err = -EOPNOTSUPP;
1525         }
1526
1527         return err >= 0;
1528 }
1529
1530 static int i2c_detect_address(struct i2c_client *temp_client,
1531                               struct i2c_driver *driver)
1532 {
1533         struct i2c_board_info info;
1534         struct i2c_adapter *adapter = temp_client->adapter;
1535         int addr = temp_client->addr;
1536         int err;
1537
1538         /* Make sure the address is valid */
1539         err = i2c_check_addr_validity(addr);
1540         if (err) {
1541                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1542                          addr);
1543                 return err;
1544         }
1545
1546         /* Skip if already in use */
1547         if (i2c_check_addr_busy(adapter, addr))
1548                 return 0;
1549
1550         /* Make sure there is something at this address */
1551         if (!i2c_default_probe(adapter, addr))
1552                 return 0;
1553
1554         /* Finally call the custom detection function */
1555         memset(&info, 0, sizeof(struct i2c_board_info));
1556         info.addr = addr;
1557         err = driver->detect(temp_client, &info);
1558         if (err) {
1559                 /* -ENODEV is returned if the detection fails. We catch it
1560                    here as this isn't an error. */
1561                 return err == -ENODEV ? 0 : err;
1562         }
1563
1564         /* Consistency check */
1565         if (info.type[0] == '\0') {
1566                 dev_err(&adapter->dev, "%s detection function provided "
1567                         "no name for 0x%x\n", driver->driver.name,
1568                         addr);
1569         } else {
1570                 struct i2c_client *client;
1571
1572                 /* Detection succeeded, instantiate the device */
1573                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1574                         info.type, info.addr);
1575                 client = i2c_new_device(adapter, &info);
1576                 if (client)
1577                         list_add_tail(&client->detected, &driver->clients);
1578                 else
1579                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1580                                 info.type, info.addr);
1581         }
1582         return 0;
1583 }
1584
1585 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1586 {
1587         const unsigned short *address_list;
1588         struct i2c_client *temp_client;
1589         int i, err = 0;
1590         int adap_id = i2c_adapter_id(adapter);
1591
1592         address_list = driver->address_list;
1593         if (!driver->detect || !address_list)
1594                 return 0;
1595
1596         /* Stop here if the classes do not match */
1597         if (!(adapter->class & driver->class))
1598                 return 0;
1599
1600         /* Set up a temporary client to help detect callback */
1601         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1602         if (!temp_client)
1603                 return -ENOMEM;
1604         temp_client->adapter = adapter;
1605
1606         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1607                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1608                         "addr 0x%02x\n", adap_id, address_list[i]);
1609                 temp_client->addr = address_list[i];
1610                 err = i2c_detect_address(temp_client, driver);
1611                 if (unlikely(err))
1612                         break;
1613         }
1614
1615         kfree(temp_client);
1616         return err;
1617 }
1618
1619 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1620 {
1621         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1622                               I2C_SMBUS_QUICK, NULL) >= 0;
1623 }
1624 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1625
1626 struct i2c_client *
1627 i2c_new_probed_device(struct i2c_adapter *adap,
1628                       struct i2c_board_info *info,
1629                       unsigned short const *addr_list,
1630                       int (*probe)(struct i2c_adapter *, unsigned short addr))
1631 {
1632         int i;
1633
1634         if (!probe)
1635                 probe = i2c_default_probe;
1636
1637         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1638                 /* Check address validity */
1639                 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1640                         dev_warn(&adap->dev, "Invalid 7-bit address "
1641                                  "0x%02x\n", addr_list[i]);
1642                         continue;
1643                 }
1644
1645                 /* Check address availability */
1646                 if (i2c_check_addr_busy(adap, addr_list[i])) {
1647                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1648                                 "use, not probing\n", addr_list[i]);
1649                         continue;
1650                 }
1651
1652                 /* Test address responsiveness */
1653                 if (probe(adap, addr_list[i]))
1654                         break;
1655         }
1656
1657         if (addr_list[i] == I2C_CLIENT_END) {
1658                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1659                 return NULL;
1660         }
1661
1662         info->addr = addr_list[i];
1663         return i2c_new_device(adap, info);
1664 }
1665 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1666
1667 struct i2c_adapter *i2c_get_adapter(int nr)
1668 {
1669         struct i2c_adapter *adapter;
1670
1671         mutex_lock(&core_lock);
1672         adapter = idr_find(&i2c_adapter_idr, nr);
1673         if (adapter && !try_module_get(adapter->owner))
1674                 adapter = NULL;
1675
1676         mutex_unlock(&core_lock);
1677         return adapter;
1678 }
1679 EXPORT_SYMBOL(i2c_get_adapter);
1680
1681 void i2c_put_adapter(struct i2c_adapter *adap)
1682 {
1683         module_put(adap->owner);
1684 }
1685 EXPORT_SYMBOL(i2c_put_adapter);
1686
1687 /* The SMBus parts */
1688
1689 #define POLY    (0x1070U << 3)
1690 static u8 crc8(u16 data)
1691 {
1692         int i;
1693
1694         for (i = 0; i < 8; i++) {
1695                 if (data & 0x8000)
1696                         data = data ^ POLY;
1697                 data = data << 1;
1698         }
1699         return (u8)(data >> 8);
1700 }
1701
1702 /* Incremental CRC8 over count bytes in the array pointed to by p */
1703 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1704 {
1705         int i;
1706
1707         for (i = 0; i < count; i++)
1708                 crc = crc8((crc ^ p[i]) << 8);
1709         return crc;
1710 }
1711
1712 /* Assume a 7-bit address, which is reasonable for SMBus */
1713 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1714 {
1715         /* The address will be sent first */
1716         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1717         pec = i2c_smbus_pec(pec, &addr, 1);
1718
1719         /* The data buffer follows */
1720         return i2c_smbus_pec(pec, msg->buf, msg->len);
1721 }
1722
1723 /* Used for write only transactions */
1724 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1725 {
1726         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1727         msg->len++;
1728 }
1729
1730 /* Return <0 on CRC error
1731    If there was a write before this read (most cases) we need to take the
1732    partial CRC from the write part into account.
1733    Note that this function does modify the message (we need to decrease the
1734    message length to hide the CRC byte from the caller). */
1735 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1736 {
1737         u8 rpec = msg->buf[--msg->len];
1738         cpec = i2c_smbus_msg_pec(cpec, msg);
1739
1740         if (rpec != cpec) {
1741                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1742                         rpec, cpec);
1743                 return -EBADMSG;
1744         }
1745         return 0;
1746 }
1747
1748 /**
1749  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1750  * @client: Handle to slave device
1751  *
1752  * This executes the SMBus "receive byte" protocol, returning negative errno
1753  * else the byte received from the device.
1754  */
1755 s32 i2c_smbus_read_byte(const struct i2c_client *client)
1756 {
1757         union i2c_smbus_data data;
1758         int status;
1759
1760         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1761                                 I2C_SMBUS_READ, 0,
1762                                 I2C_SMBUS_BYTE, &data);
1763         return (status < 0) ? status : data.byte;
1764 }
1765 EXPORT_SYMBOL(i2c_smbus_read_byte);
1766
1767 /**
1768  * i2c_smbus_write_byte - SMBus "send byte" protocol
1769  * @client: Handle to slave device
1770  * @value: Byte to be sent
1771  *
1772  * This executes the SMBus "send byte" protocol, returning negative errno
1773  * else zero on success.
1774  */
1775 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
1776 {
1777         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1778                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1779 }
1780 EXPORT_SYMBOL(i2c_smbus_write_byte);
1781
1782 /**
1783  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1784  * @client: Handle to slave device
1785  * @command: Byte interpreted by slave
1786  *
1787  * This executes the SMBus "read byte" protocol, returning negative errno
1788  * else a data byte received from the device.
1789  */
1790 s32 i2c_smbus_read_byte_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_BYTE_DATA, &data);
1798         return (status < 0) ? status : data.byte;
1799 }
1800 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1801
1802 /**
1803  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1804  * @client: Handle to slave device
1805  * @command: Byte interpreted by slave
1806  * @value: Byte being written
1807  *
1808  * This executes the SMBus "write byte" protocol, returning negative errno
1809  * else zero on success.
1810  */
1811 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
1812                               u8 value)
1813 {
1814         union i2c_smbus_data data;
1815         data.byte = value;
1816         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1817                               I2C_SMBUS_WRITE, command,
1818                               I2C_SMBUS_BYTE_DATA, &data);
1819 }
1820 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1821
1822 /**
1823  * i2c_smbus_read_word_data - SMBus "read word" protocol
1824  * @client: Handle to slave device
1825  * @command: Byte interpreted by slave
1826  *
1827  * This executes the SMBus "read word" protocol, returning negative errno
1828  * else a 16-bit unsigned "word" received from the device.
1829  */
1830 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
1831 {
1832         union i2c_smbus_data data;
1833         int status;
1834
1835         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1836                                 I2C_SMBUS_READ, command,
1837                                 I2C_SMBUS_WORD_DATA, &data);
1838         return (status < 0) ? status : data.word;
1839 }
1840 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1841
1842 /**
1843  * i2c_smbus_write_word_data - SMBus "write word" protocol
1844  * @client: Handle to slave device
1845  * @command: Byte interpreted by slave
1846  * @value: 16-bit "word" being written
1847  *
1848  * This executes the SMBus "write word" protocol, returning negative errno
1849  * else zero on success.
1850  */
1851 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
1852                               u16 value)
1853 {
1854         union i2c_smbus_data data;
1855         data.word = value;
1856         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1857                               I2C_SMBUS_WRITE, command,
1858                               I2C_SMBUS_WORD_DATA, &data);
1859 }
1860 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1861
1862 /**
1863  * i2c_smbus_process_call - SMBus "process call" protocol
1864  * @client: Handle to slave device
1865  * @command: Byte interpreted by slave
1866  * @value: 16-bit "word" being written
1867  *
1868  * This executes the SMBus "process call" protocol, returning negative errno
1869  * else a 16-bit unsigned "word" received from the device.
1870  */
1871 s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command,
1872                            u16 value)
1873 {
1874         union i2c_smbus_data data;
1875         int status;
1876         data.word = value;
1877
1878         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1879                                 I2C_SMBUS_WRITE, command,
1880                                 I2C_SMBUS_PROC_CALL, &data);
1881         return (status < 0) ? status : data.word;
1882 }
1883 EXPORT_SYMBOL(i2c_smbus_process_call);
1884
1885 /**
1886  * i2c_smbus_read_block_data - SMBus "block read" protocol
1887  * @client: Handle to slave device
1888  * @command: Byte interpreted by slave
1889  * @values: Byte array into which data will be read; big enough to hold
1890  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1891  *
1892  * This executes the SMBus "block read" protocol, returning negative errno
1893  * else the number of data bytes in the slave's response.
1894  *
1895  * Note that using this function requires that the client's adapter support
1896  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1897  * support this; its emulation through I2C messaging relies on a specific
1898  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1899  */
1900 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
1901                               u8 *values)
1902 {
1903         union i2c_smbus_data data;
1904         int status;
1905
1906         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1907                                 I2C_SMBUS_READ, command,
1908                                 I2C_SMBUS_BLOCK_DATA, &data);
1909         if (status)
1910                 return status;
1911
1912         memcpy(values, &data.block[1], data.block[0]);
1913         return data.block[0];
1914 }
1915 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1916
1917 /**
1918  * i2c_smbus_write_block_data - SMBus "block write" protocol
1919  * @client: Handle to slave device
1920  * @command: Byte interpreted by slave
1921  * @length: Size of data block; SMBus allows at most 32 bytes
1922  * @values: Byte array which will be written.
1923  *
1924  * This executes the SMBus "block write" protocol, returning negative errno
1925  * else zero on success.
1926  */
1927 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
1928                                u8 length, const u8 *values)
1929 {
1930         union i2c_smbus_data data;
1931
1932         if (length > I2C_SMBUS_BLOCK_MAX)
1933                 length = I2C_SMBUS_BLOCK_MAX;
1934         data.block[0] = length;
1935         memcpy(&data.block[1], values, length);
1936         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1937                               I2C_SMBUS_WRITE, command,
1938                               I2C_SMBUS_BLOCK_DATA, &data);
1939 }
1940 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1941
1942 /* Returns the number of read bytes */
1943 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
1944                                   u8 length, u8 *values)
1945 {
1946         union i2c_smbus_data data;
1947         int status;
1948
1949         if (length > I2C_SMBUS_BLOCK_MAX)
1950                 length = I2C_SMBUS_BLOCK_MAX;
1951         data.block[0] = length;
1952         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1953                                 I2C_SMBUS_READ, command,
1954                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1955         if (status < 0)
1956                 return status;
1957
1958         memcpy(values, &data.block[1], data.block[0]);
1959         return data.block[0];
1960 }
1961 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1962
1963 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
1964                                    u8 length, const u8 *values)
1965 {
1966         union i2c_smbus_data data;
1967
1968         if (length > I2C_SMBUS_BLOCK_MAX)
1969                 length = I2C_SMBUS_BLOCK_MAX;
1970         data.block[0] = length;
1971         memcpy(data.block + 1, values, length);
1972         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1973                               I2C_SMBUS_WRITE, command,
1974                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1975 }
1976 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1977
1978 /* Simulate a SMBus command using the i2c protocol
1979    No checking of parameters is done!  */
1980 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1981                                    unsigned short flags,
1982                                    char read_write, u8 command, int size,
1983                                    union i2c_smbus_data *data)
1984 {
1985         /* So we need to generate a series of msgs. In the case of writing, we
1986           need to use only one message; when reading, we need two. We initialize
1987           most things with sane defaults, to keep the code below somewhat
1988           simpler. */
1989         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1990         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1991         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1992         int i;
1993         u8 partial_pec = 0;
1994         int status;
1995         struct i2c_msg msg[2] = {
1996                 {
1997                         .addr = addr,
1998                         .flags = flags,
1999                         .len = 1,
2000                         .buf = msgbuf0,
2001                 }, {
2002                         .addr = addr,
2003                         .flags = flags | I2C_M_RD,
2004                         .len = 0,
2005                         .buf = msgbuf1,
2006                 },
2007         };
2008
2009         msgbuf0[0] = command;
2010         switch (size) {
2011         case I2C_SMBUS_QUICK:
2012                 msg[0].len = 0;
2013                 /* Special case: The read/write field is used as data */
2014                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
2015                                         I2C_M_RD : 0);
2016                 num = 1;
2017                 break;
2018         case I2C_SMBUS_BYTE:
2019                 if (read_write == I2C_SMBUS_READ) {
2020                         /* Special case: only a read! */
2021                         msg[0].flags = I2C_M_RD | flags;
2022                         num = 1;
2023                 }
2024                 break;
2025         case I2C_SMBUS_BYTE_DATA:
2026                 if (read_write == I2C_SMBUS_READ)
2027                         msg[1].len = 1;
2028                 else {
2029                         msg[0].len = 2;
2030                         msgbuf0[1] = data->byte;
2031                 }
2032                 break;
2033         case I2C_SMBUS_WORD_DATA:
2034                 if (read_write == I2C_SMBUS_READ)
2035                         msg[1].len = 2;
2036                 else {
2037                         msg[0].len = 3;
2038                         msgbuf0[1] = data->word & 0xff;
2039                         msgbuf0[2] = data->word >> 8;
2040                 }
2041                 break;
2042         case I2C_SMBUS_PROC_CALL:
2043                 num = 2; /* Special case */
2044                 read_write = I2C_SMBUS_READ;
2045                 msg[0].len = 3;
2046                 msg[1].len = 2;
2047                 msgbuf0[1] = data->word & 0xff;
2048                 msgbuf0[2] = data->word >> 8;
2049                 break;
2050         case I2C_SMBUS_BLOCK_DATA:
2051                 if (read_write == I2C_SMBUS_READ) {
2052                         msg[1].flags |= I2C_M_RECV_LEN;
2053                         msg[1].len = 1; /* block length will be added by
2054                                            the underlying bus driver */
2055                 } else {
2056                         msg[0].len = data->block[0] + 2;
2057                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
2058                                 dev_err(&adapter->dev,
2059                                         "Invalid block write size %d\n",
2060                                         data->block[0]);
2061                                 return -EINVAL;
2062                         }
2063                         for (i = 1; i < msg[0].len; i++)
2064                                 msgbuf0[i] = data->block[i-1];
2065                 }
2066                 break;
2067         case I2C_SMBUS_BLOCK_PROC_CALL:
2068                 num = 2; /* Another special case */
2069                 read_write = I2C_SMBUS_READ;
2070                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
2071                         dev_err(&adapter->dev,
2072                                 "Invalid block write size %d\n",
2073                                 data->block[0]);
2074                         return -EINVAL;
2075                 }
2076                 msg[0].len = data->block[0] + 2;
2077                 for (i = 1; i < msg[0].len; i++)
2078                         msgbuf0[i] = data->block[i-1];
2079                 msg[1].flags |= I2C_M_RECV_LEN;
2080                 msg[1].len = 1; /* block length will be added by
2081                                    the underlying bus driver */
2082                 break;
2083         case I2C_SMBUS_I2C_BLOCK_DATA:
2084                 if (read_write == I2C_SMBUS_READ) {
2085                         msg[1].len = data->block[0];
2086                 } else {
2087                         msg[0].len = data->block[0] + 1;
2088                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2089                                 dev_err(&adapter->dev,
2090                                         "Invalid block write size %d\n",
2091                                         data->block[0]);
2092                                 return -EINVAL;
2093                         }
2094                         for (i = 1; i <= data->block[0]; i++)
2095                                 msgbuf0[i] = data->block[i];
2096                 }
2097                 break;
2098         default:
2099                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2100                 return -EOPNOTSUPP;
2101         }
2102
2103         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2104                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
2105         if (i) {
2106                 /* Compute PEC if first message is a write */
2107                 if (!(msg[0].flags & I2C_M_RD)) {
2108                         if (num == 1) /* Write only */
2109                                 i2c_smbus_add_pec(&msg[0]);
2110                         else /* Write followed by read */
2111                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2112                 }
2113                 /* Ask for PEC if last message is a read */
2114                 if (msg[num-1].flags & I2C_M_RD)
2115                         msg[num-1].len++;
2116         }
2117
2118         status = i2c_transfer(adapter, msg, num);
2119         if (status < 0)
2120                 return status;
2121
2122         /* Check PEC if last message is a read */
2123         if (i && (msg[num-1].flags & I2C_M_RD)) {
2124                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2125                 if (status < 0)
2126                         return status;
2127         }
2128
2129         if (read_write == I2C_SMBUS_READ)
2130                 switch (size) {
2131                 case I2C_SMBUS_BYTE:
2132                         data->byte = msgbuf0[0];
2133                         break;
2134                 case I2C_SMBUS_BYTE_DATA:
2135                         data->byte = msgbuf1[0];
2136                         break;
2137                 case I2C_SMBUS_WORD_DATA:
2138                 case I2C_SMBUS_PROC_CALL:
2139                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2140                         break;
2141                 case I2C_SMBUS_I2C_BLOCK_DATA:
2142                         for (i = 0; i < data->block[0]; i++)
2143                                 data->block[i+1] = msgbuf1[i];
2144                         break;
2145                 case I2C_SMBUS_BLOCK_DATA:
2146                 case I2C_SMBUS_BLOCK_PROC_CALL:
2147                         for (i = 0; i < msgbuf1[0] + 1; i++)
2148                                 data->block[i] = msgbuf1[i];
2149                         break;
2150                 }
2151         return 0;
2152 }
2153
2154 /**
2155  * i2c_smbus_xfer - execute SMBus protocol operations
2156  * @adapter: Handle to I2C bus
2157  * @addr: Address of SMBus slave on that bus
2158  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2159  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2160  * @command: Byte interpreted by slave, for protocols which use such bytes
2161  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2162  * @data: Data to be read or written
2163  *
2164  * This executes an SMBus protocol operation, and returns a negative
2165  * errno code else zero on success.
2166  */
2167 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2168                    char read_write, u8 command, int protocol,
2169                    union i2c_smbus_data *data)
2170 {
2171         unsigned long orig_jiffies;
2172         int try;
2173         s32 res;
2174
2175         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
2176
2177         if (adapter->algo->smbus_xfer) {
2178                 i2c_lock_adapter(adapter);
2179
2180                 /* Retry automatically on arbitration loss */
2181                 orig_jiffies = jiffies;
2182                 for (res = 0, try = 0; try <= adapter->retries; try++) {
2183                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
2184                                                         read_write, command,
2185                                                         protocol, data);
2186                         if (res != -EAGAIN)
2187                                 break;
2188                         if (time_after(jiffies,
2189                                        orig_jiffies + adapter->timeout))
2190                                 break;
2191                 }
2192                 i2c_unlock_adapter(adapter);
2193
2194                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
2195                         return res;
2196                 /*
2197                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
2198                  * implement native support for the SMBus operation.
2199                  */
2200         }
2201
2202         return i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2203                                        command, protocol, data);
2204 }
2205 EXPORT_SYMBOL(i2c_smbus_xfer);
2206
2207 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2208 MODULE_DESCRIPTION("I2C-Bus main module");
2209 MODULE_LICENSE("GPL");