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