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