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