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)
1025                 i2c_unregister_device(client);
1026         return 0;
1027 }
1028
1029 static int __process_removed_adapter(struct device_driver *d, void *data)
1030 {
1031         return i2c_do_del_adapter(to_i2c_driver(d), data);
1032 }
1033
1034 /**
1035  * i2c_del_adapter - unregister I2C adapter
1036  * @adap: the adapter being unregistered
1037  * Context: can sleep
1038  *
1039  * This unregisters an I2C adapter which was previously registered
1040  * by @i2c_add_adapter or @i2c_add_numbered_adapter.
1041  */
1042 int i2c_del_adapter(struct i2c_adapter *adap)
1043 {
1044         int res = 0;
1045         struct i2c_adapter *found;
1046         struct i2c_client *client, *next;
1047
1048         /* First make sure that this adapter was ever added */
1049         mutex_lock(&core_lock);
1050         found = idr_find(&i2c_adapter_idr, adap->nr);
1051         mutex_unlock(&core_lock);
1052         if (found != adap) {
1053                 pr_debug("i2c-core: attempting to delete unregistered "
1054                          "adapter [%s]\n", adap->name);
1055                 return -EINVAL;
1056         }
1057
1058         /* Tell drivers about this removal */
1059         mutex_lock(&core_lock);
1060         res = bus_for_each_drv(&i2c_bus_type, NULL, adap,
1061                                __process_removed_adapter);
1062         mutex_unlock(&core_lock);
1063         if (res)
1064                 return res;
1065
1066         /* Remove devices instantiated from sysfs */
1067         mutex_lock(&adap->userspace_clients_lock);
1068         list_for_each_entry_safe(client, next, &adap->userspace_clients,
1069                                  detected) {
1070                 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1071                         client->addr);
1072                 list_del(&client->detected);
1073                 i2c_unregister_device(client);
1074         }
1075         mutex_unlock(&adap->userspace_clients_lock);
1076
1077         /* Detach any active clients. This can't fail, thus we do not
1078            checking the returned value. */
1079         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
1080
1081 #ifdef CONFIG_I2C_COMPAT
1082         class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1083                                  adap->dev.parent);
1084 #endif
1085
1086         /* device name is gone after device_unregister */
1087         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1088
1089         /* clean up the sysfs representation */
1090         init_completion(&adap->dev_released);
1091         device_unregister(&adap->dev);
1092
1093         /* wait for sysfs to drop all references */
1094         wait_for_completion(&adap->dev_released);
1095
1096         /* free bus id */
1097         mutex_lock(&core_lock);
1098         idr_remove(&i2c_adapter_idr, adap->nr);
1099         mutex_unlock(&core_lock);
1100
1101         /* Clear the device structure in case this adapter is ever going to be
1102            added again */
1103         memset(&adap->dev, 0, sizeof(adap->dev));
1104
1105         return 0;
1106 }
1107 EXPORT_SYMBOL(i2c_del_adapter);
1108
1109
1110 /* ------------------------------------------------------------------------- */
1111
1112 static int __process_new_driver(struct device *dev, void *data)
1113 {
1114         if (dev->type != &i2c_adapter_type)
1115                 return 0;
1116         return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1117 }
1118
1119 /*
1120  * An i2c_driver is used with one or more i2c_client (device) nodes to access
1121  * i2c slave chips, on a bus instance associated with some i2c_adapter.
1122  */
1123
1124 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1125 {
1126         int res;
1127
1128         /* Can't register until after driver model init */
1129         if (unlikely(WARN_ON(!i2c_bus_type.p)))
1130                 return -EAGAIN;
1131
1132         /* add the driver to the list of i2c drivers in the driver core */
1133         driver->driver.owner = owner;
1134         driver->driver.bus = &i2c_bus_type;
1135
1136         /* When registration returns, the driver core
1137          * will have called probe() for all matching-but-unbound devices.
1138          */
1139         res = driver_register(&driver->driver);
1140         if (res)
1141                 return res;
1142
1143         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1144
1145         INIT_LIST_HEAD(&driver->clients);
1146         /* Walk the adapters that are already present */
1147         mutex_lock(&core_lock);
1148         bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);
1149         mutex_unlock(&core_lock);
1150
1151         return 0;
1152 }
1153 EXPORT_SYMBOL(i2c_register_driver);
1154
1155 static int __process_removed_driver(struct device *dev, void *data)
1156 {
1157         if (dev->type != &i2c_adapter_type)
1158                 return 0;
1159         return i2c_do_del_adapter(data, to_i2c_adapter(dev));
1160 }
1161
1162 /**
1163  * i2c_del_driver - unregister I2C driver
1164  * @driver: the driver being unregistered
1165  * Context: can sleep
1166  */
1167 void i2c_del_driver(struct i2c_driver *driver)
1168 {
1169         mutex_lock(&core_lock);
1170         bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_removed_driver);
1171         mutex_unlock(&core_lock);
1172
1173         driver_unregister(&driver->driver);
1174         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
1175 }
1176 EXPORT_SYMBOL(i2c_del_driver);
1177
1178 /* ------------------------------------------------------------------------- */
1179
1180 /**
1181  * i2c_use_client - increments the reference count of the i2c client structure
1182  * @client: the client being referenced
1183  *
1184  * Each live reference to a client should be refcounted. The driver model does
1185  * that automatically as part of driver binding, so that most drivers don't
1186  * need to do this explicitly: they hold a reference until they're unbound
1187  * from the device.
1188  *
1189  * A pointer to the client with the incremented reference counter is returned.
1190  */
1191 struct i2c_client *i2c_use_client(struct i2c_client *client)
1192 {
1193         if (client && get_device(&client->dev))
1194                 return client;
1195         return NULL;
1196 }
1197 EXPORT_SYMBOL(i2c_use_client);
1198
1199 /**
1200  * i2c_release_client - release a use of the i2c client structure
1201  * @client: the client being no longer referenced
1202  *
1203  * Must be called when a user of a client is finished with it.
1204  */
1205 void i2c_release_client(struct i2c_client *client)
1206 {
1207         if (client)
1208                 put_device(&client->dev);
1209 }
1210 EXPORT_SYMBOL(i2c_release_client);
1211
1212 struct i2c_cmd_arg {
1213         unsigned        cmd;
1214         void            *arg;
1215 };
1216
1217 static int i2c_cmd(struct device *dev, void *_arg)
1218 {
1219         struct i2c_client       *client = i2c_verify_client(dev);
1220         struct i2c_cmd_arg      *arg = _arg;
1221
1222         if (client && client->driver && client->driver->command)
1223                 client->driver->command(client, arg->cmd, arg->arg);
1224         return 0;
1225 }
1226
1227 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
1228 {
1229         struct i2c_cmd_arg      cmd_arg;
1230
1231         cmd_arg.cmd = cmd;
1232         cmd_arg.arg = arg;
1233         device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
1234 }
1235 EXPORT_SYMBOL(i2c_clients_command);
1236
1237 static int __init i2c_init(void)
1238 {
1239         int retval;
1240
1241         retval = bus_register(&i2c_bus_type);
1242         if (retval)
1243                 return retval;
1244 #ifdef CONFIG_I2C_COMPAT
1245         i2c_adapter_compat_class = class_compat_register("i2c-adapter");
1246         if (!i2c_adapter_compat_class) {
1247                 retval = -ENOMEM;
1248                 goto bus_err;
1249         }
1250 #endif
1251         retval = i2c_add_driver(&dummy_driver);
1252         if (retval)
1253                 goto class_err;
1254         return 0;
1255
1256 class_err:
1257 #ifdef CONFIG_I2C_COMPAT
1258         class_compat_unregister(i2c_adapter_compat_class);
1259 bus_err:
1260 #endif
1261         bus_unregister(&i2c_bus_type);
1262         return retval;
1263 }
1264
1265 static void __exit i2c_exit(void)
1266 {
1267         i2c_del_driver(&dummy_driver);
1268 #ifdef CONFIG_I2C_COMPAT
1269         class_compat_unregister(i2c_adapter_compat_class);
1270 #endif
1271         bus_unregister(&i2c_bus_type);
1272 }
1273
1274 /* We must initialize early, because some subsystems register i2c drivers
1275  * in subsys_initcall() code, but are linked (and initialized) before i2c.
1276  */
1277 postcore_initcall(i2c_init);
1278 module_exit(i2c_exit);
1279
1280 /* ----------------------------------------------------
1281  * the functional interface to the i2c busses.
1282  * ----------------------------------------------------
1283  */
1284
1285 /**
1286  * i2c_transfer - execute a single or combined I2C message
1287  * @adap: Handle to I2C bus
1288  * @msgs: One or more messages to execute before STOP is issued to
1289  *      terminate the operation; each message begins with a START.
1290  * @num: Number of messages to be executed.
1291  *
1292  * Returns negative errno, else the number of messages executed.
1293  *
1294  * Note that there is no requirement that each message be sent to
1295  * the same slave address, although that is the most common model.
1296  */
1297 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
1298 {
1299         unsigned long orig_jiffies;
1300         int ret, try;
1301
1302         /* REVISIT the fault reporting model here is weak:
1303          *
1304          *  - When we get an error after receiving N bytes from a slave,
1305          *    there is no way to report "N".
1306          *
1307          *  - When we get a NAK after transmitting N bytes to a slave,
1308          *    there is no way to report "N" ... or to let the master
1309          *    continue executing the rest of this combined message, if
1310          *    that's the appropriate response.
1311          *
1312          *  - When for example "num" is two and we successfully complete
1313          *    the first message but get an error part way through the
1314          *    second, it's unclear whether that should be reported as
1315          *    one (discarding status on the second message) or errno
1316          *    (discarding status on the first one).
1317          */
1318
1319         if (adap->algo->master_xfer) {
1320 #ifdef DEBUG
1321                 for (ret = 0; ret < num; ret++) {
1322                         dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
1323                                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
1324                                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
1325                                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
1326                 }
1327 #endif
1328
1329                 if (in_atomic() || irqs_disabled()) {
1330                         ret = i2c_trylock_adapter(adap);
1331                         if (!ret)
1332                                 /* I2C activity is ongoing. */
1333                                 return -EAGAIN;
1334                 } else {
1335                         i2c_lock_adapter(adap);
1336                 }
1337
1338                 /* Retry automatically on arbitration loss */
1339                 orig_jiffies = jiffies;
1340                 for (ret = 0, try = 0; try <= adap->retries; try++) {
1341                         ret = adap->algo->master_xfer(adap, msgs, num);
1342                         if (ret != -EAGAIN)
1343                                 break;
1344                         if (time_after(jiffies, orig_jiffies + adap->timeout))
1345                                 break;
1346                 }
1347                 i2c_unlock_adapter(adap);
1348
1349                 return ret;
1350         } else {
1351                 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
1352                 return -EOPNOTSUPP;
1353         }
1354 }
1355 EXPORT_SYMBOL(i2c_transfer);
1356
1357 /**
1358  * i2c_master_send - issue a single I2C message in master transmit mode
1359  * @client: Handle to slave device
1360  * @buf: Data that will be written to the slave
1361  * @count: How many bytes to write, must be less than 64k since msg.len is u16
1362  *
1363  * Returns negative errno, or else the number of bytes written.
1364  */
1365 int i2c_master_send(struct i2c_client *client, const char *buf, int count)
1366 {
1367         int ret;
1368         struct i2c_adapter *adap = client->adapter;
1369         struct i2c_msg msg;
1370
1371         msg.addr = client->addr;
1372         msg.flags = client->flags & I2C_M_TEN;
1373         msg.len = count;
1374         msg.buf = (char *)buf;
1375
1376         ret = i2c_transfer(adap, &msg, 1);
1377
1378         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1379            transmitted, else error code. */
1380         return (ret == 1) ? count : ret;
1381 }
1382 EXPORT_SYMBOL(i2c_master_send);
1383
1384 /**
1385  * i2c_master_recv - issue a single I2C message in master receive mode
1386  * @client: Handle to slave device
1387  * @buf: Where to store data read from slave
1388  * @count: How many bytes to read, must be less than 64k since msg.len is u16
1389  *
1390  * Returns negative errno, or else the number of bytes read.
1391  */
1392 int i2c_master_recv(struct i2c_client *client, char *buf, int count)
1393 {
1394         struct i2c_adapter *adap = client->adapter;
1395         struct i2c_msg msg;
1396         int ret;
1397
1398         msg.addr = client->addr;
1399         msg.flags = client->flags & I2C_M_TEN;
1400         msg.flags |= I2C_M_RD;
1401         msg.len = count;
1402         msg.buf = buf;
1403
1404         ret = i2c_transfer(adap, &msg, 1);
1405
1406         /* If everything went ok (i.e. 1 msg transmitted), return #bytes
1407            transmitted, else error code. */
1408         return (ret == 1) ? count : ret;
1409 }
1410 EXPORT_SYMBOL(i2c_master_recv);
1411
1412 /* ----------------------------------------------------
1413  * the i2c address scanning function
1414  * Will not work for 10-bit addresses!
1415  * ----------------------------------------------------
1416  */
1417
1418 /*
1419  * Legacy default probe function, mostly relevant for SMBus. The default
1420  * probe method is a quick write, but it is known to corrupt the 24RF08
1421  * EEPROMs due to a state machine bug, and could also irreversibly
1422  * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f,
1423  * we use a short byte read instead. Also, some bus drivers don't implement
1424  * quick write, so we fallback to a byte read in that case too.
1425  * On x86, there is another special case for FSC hardware monitoring chips,
1426  * which want regular byte reads (address 0x73.) Fortunately, these are the
1427  * only known chips using this I2C address on PC hardware.
1428  * Returns 1 if probe succeeded, 0 if not.
1429  */
1430 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
1431 {
1432         int err;
1433         union i2c_smbus_data dummy;
1434
1435 #ifdef CONFIG_X86
1436         if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
1437          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
1438                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1439                                      I2C_SMBUS_BYTE_DATA, &dummy);
1440         else
1441 #endif
1442         if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)
1443          && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
1444                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
1445                                      I2C_SMBUS_QUICK, NULL);
1446         else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
1447                 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1448                                      I2C_SMBUS_BYTE, &dummy);
1449         else {
1450                 dev_warn(&adap->dev, "No suitable probing method supported\n");
1451                 err = -EOPNOTSUPP;
1452         }
1453
1454         return err >= 0;
1455 }
1456
1457 static int i2c_detect_address(struct i2c_client *temp_client,
1458                               struct i2c_driver *driver)
1459 {
1460         struct i2c_board_info info;
1461         struct i2c_adapter *adapter = temp_client->adapter;
1462         int addr = temp_client->addr;
1463         int err;
1464
1465         /* Make sure the address is valid */
1466         err = i2c_check_addr_validity(addr);
1467         if (err) {
1468                 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1469                          addr);
1470                 return err;
1471         }
1472
1473         /* Skip if already in use */
1474         if (i2c_check_addr_busy(adapter, addr))
1475                 return 0;
1476
1477         /* Make sure there is something at this address */
1478         if (!i2c_default_probe(adapter, addr))
1479                 return 0;
1480
1481         /* Finally call the custom detection function */
1482         memset(&info, 0, sizeof(struct i2c_board_info));
1483         info.addr = addr;
1484         err = driver->detect(temp_client, &info);
1485         if (err) {
1486                 /* -ENODEV is returned if the detection fails. We catch it
1487                    here as this isn't an error. */
1488                 return err == -ENODEV ? 0 : err;
1489         }
1490
1491         /* Consistency check */
1492         if (info.type[0] == '\0') {
1493                 dev_err(&adapter->dev, "%s detection function provided "
1494                         "no name for 0x%x\n", driver->driver.name,
1495                         addr);
1496         } else {
1497                 struct i2c_client *client;
1498
1499                 /* Detection succeeded, instantiate the device */
1500                 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1501                         info.type, info.addr);
1502                 client = i2c_new_device(adapter, &info);
1503                 if (client)
1504                         list_add_tail(&client->detected, &driver->clients);
1505                 else
1506                         dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1507                                 info.type, info.addr);
1508         }
1509         return 0;
1510 }
1511
1512 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1513 {
1514         const unsigned short *address_list;
1515         struct i2c_client *temp_client;
1516         int i, err = 0;
1517         int adap_id = i2c_adapter_id(adapter);
1518
1519         address_list = driver->address_list;
1520         if (!driver->detect || !address_list)
1521                 return 0;
1522
1523         /* Stop here if the classes do not match */
1524         if (!(adapter->class & driver->class))
1525                 return 0;
1526
1527         /* Set up a temporary client to help detect callback */
1528         temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1529         if (!temp_client)
1530                 return -ENOMEM;
1531         temp_client->adapter = adapter;
1532
1533         for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1534                 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1535                         "addr 0x%02x\n", adap_id, address_list[i]);
1536                 temp_client->addr = address_list[i];
1537                 err = i2c_detect_address(temp_client, driver);
1538                 if (unlikely(err))
1539                         break;
1540         }
1541
1542         kfree(temp_client);
1543         return err;
1544 }
1545
1546 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
1547 {
1548         return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
1549                               I2C_SMBUS_QUICK, NULL) >= 0;
1550 }
1551 EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read);
1552
1553 struct i2c_client *
1554 i2c_new_probed_device(struct i2c_adapter *adap,
1555                       struct i2c_board_info *info,
1556                       unsigned short const *addr_list,
1557                       int (*probe)(struct i2c_adapter *, unsigned short addr))
1558 {
1559         int i;
1560
1561         if (!probe)
1562                 probe = i2c_default_probe;
1563
1564         for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
1565                 /* Check address validity */
1566                 if (i2c_check_addr_validity(addr_list[i]) < 0) {
1567                         dev_warn(&adap->dev, "Invalid 7-bit address "
1568                                  "0x%02x\n", addr_list[i]);
1569                         continue;
1570                 }
1571
1572                 /* Check address availability */
1573                 if (i2c_check_addr_busy(adap, addr_list[i])) {
1574                         dev_dbg(&adap->dev, "Address 0x%02x already in "
1575                                 "use, not probing\n", addr_list[i]);
1576                         continue;
1577                 }
1578
1579                 /* Test address responsiveness */
1580                 if (probe(adap, addr_list[i]))
1581                         break;
1582         }
1583
1584         if (addr_list[i] == I2C_CLIENT_END) {
1585                 dev_dbg(&adap->dev, "Probing failed, no device found\n");
1586                 return NULL;
1587         }
1588
1589         info->addr = addr_list[i];
1590         return i2c_new_device(adap, info);
1591 }
1592 EXPORT_SYMBOL_GPL(i2c_new_probed_device);
1593
1594 struct i2c_adapter *i2c_get_adapter(int id)
1595 {
1596         struct i2c_adapter *adapter;
1597
1598         mutex_lock(&core_lock);
1599         adapter = idr_find(&i2c_adapter_idr, id);
1600         if (adapter && !try_module_get(adapter->owner))
1601                 adapter = NULL;
1602
1603         mutex_unlock(&core_lock);
1604         return adapter;
1605 }
1606 EXPORT_SYMBOL(i2c_get_adapter);
1607
1608 void i2c_put_adapter(struct i2c_adapter *adap)
1609 {
1610         module_put(adap->owner);
1611 }
1612 EXPORT_SYMBOL(i2c_put_adapter);
1613
1614 /* The SMBus parts */
1615
1616 #define POLY    (0x1070U << 3)
1617 static u8 crc8(u16 data)
1618 {
1619         int i;
1620
1621         for (i = 0; i < 8; i++) {
1622                 if (data & 0x8000)
1623                         data = data ^ POLY;
1624                 data = data << 1;
1625         }
1626         return (u8)(data >> 8);
1627 }
1628
1629 /* Incremental CRC8 over count bytes in the array pointed to by p */
1630 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
1631 {
1632         int i;
1633
1634         for (i = 0; i < count; i++)
1635                 crc = crc8((crc ^ p[i]) << 8);
1636         return crc;
1637 }
1638
1639 /* Assume a 7-bit address, which is reasonable for SMBus */
1640 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
1641 {
1642         /* The address will be sent first */
1643         u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
1644         pec = i2c_smbus_pec(pec, &addr, 1);
1645
1646         /* The data buffer follows */
1647         return i2c_smbus_pec(pec, msg->buf, msg->len);
1648 }
1649
1650 /* Used for write only transactions */
1651 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
1652 {
1653         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
1654         msg->len++;
1655 }
1656
1657 /* Return <0 on CRC error
1658    If there was a write before this read (most cases) we need to take the
1659    partial CRC from the write part into account.
1660    Note that this function does modify the message (we need to decrease the
1661    message length to hide the CRC byte from the caller). */
1662 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
1663 {
1664         u8 rpec = msg->buf[--msg->len];
1665         cpec = i2c_smbus_msg_pec(cpec, msg);
1666
1667         if (rpec != cpec) {
1668                 pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
1669                         rpec, cpec);
1670                 return -EBADMSG;
1671         }
1672         return 0;
1673 }
1674
1675 /**
1676  * i2c_smbus_read_byte - SMBus "receive byte" protocol
1677  * @client: Handle to slave device
1678  *
1679  * This executes the SMBus "receive byte" protocol, returning negative errno
1680  * else the byte received from the device.
1681  */
1682 s32 i2c_smbus_read_byte(struct i2c_client *client)
1683 {
1684         union i2c_smbus_data data;
1685         int status;
1686
1687         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1688                                 I2C_SMBUS_READ, 0,
1689                                 I2C_SMBUS_BYTE, &data);
1690         return (status < 0) ? status : data.byte;
1691 }
1692 EXPORT_SYMBOL(i2c_smbus_read_byte);
1693
1694 /**
1695  * i2c_smbus_write_byte - SMBus "send byte" protocol
1696  * @client: Handle to slave device
1697  * @value: Byte to be sent
1698  *
1699  * This executes the SMBus "send byte" protocol, returning negative errno
1700  * else zero on success.
1701  */
1702 s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
1703 {
1704         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1705                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
1706 }
1707 EXPORT_SYMBOL(i2c_smbus_write_byte);
1708
1709 /**
1710  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
1711  * @client: Handle to slave device
1712  * @command: Byte interpreted by slave
1713  *
1714  * This executes the SMBus "read byte" protocol, returning negative errno
1715  * else a data byte received from the device.
1716  */
1717 s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
1718 {
1719         union i2c_smbus_data data;
1720         int status;
1721
1722         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1723                                 I2C_SMBUS_READ, command,
1724                                 I2C_SMBUS_BYTE_DATA, &data);
1725         return (status < 0) ? status : data.byte;
1726 }
1727 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
1728
1729 /**
1730  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
1731  * @client: Handle to slave device
1732  * @command: Byte interpreted by slave
1733  * @value: Byte being written
1734  *
1735  * This executes the SMBus "write byte" protocol, returning negative errno
1736  * else zero on success.
1737  */
1738 s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
1739 {
1740         union i2c_smbus_data data;
1741         data.byte = value;
1742         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1743                               I2C_SMBUS_WRITE, command,
1744                               I2C_SMBUS_BYTE_DATA, &data);
1745 }
1746 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
1747
1748 /**
1749  * i2c_smbus_read_word_data - SMBus "read word" protocol
1750  * @client: Handle to slave device
1751  * @command: Byte interpreted by slave
1752  *
1753  * This executes the SMBus "read word" protocol, returning negative errno
1754  * else a 16-bit unsigned "word" received from the device.
1755  */
1756 s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
1757 {
1758         union i2c_smbus_data data;
1759         int status;
1760
1761         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1762                                 I2C_SMBUS_READ, command,
1763                                 I2C_SMBUS_WORD_DATA, &data);
1764         return (status < 0) ? status : data.word;
1765 }
1766 EXPORT_SYMBOL(i2c_smbus_read_word_data);
1767
1768 /**
1769  * i2c_smbus_write_word_data - SMBus "write word" protocol
1770  * @client: Handle to slave device
1771  * @command: Byte interpreted by slave
1772  * @value: 16-bit "word" being written
1773  *
1774  * This executes the SMBus "write word" protocol, returning negative errno
1775  * else zero on success.
1776  */
1777 s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
1778 {
1779         union i2c_smbus_data data;
1780         data.word = value;
1781         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1782                               I2C_SMBUS_WRITE, command,
1783                               I2C_SMBUS_WORD_DATA, &data);
1784 }
1785 EXPORT_SYMBOL(i2c_smbus_write_word_data);
1786
1787 /**
1788  * i2c_smbus_process_call - SMBus "process call" protocol
1789  * @client: Handle to slave device
1790  * @command: Byte interpreted by slave
1791  * @value: 16-bit "word" being written
1792  *
1793  * This executes the SMBus "process call" protocol, returning negative errno
1794  * else a 16-bit unsigned "word" received from the device.
1795  */
1796 s32 i2c_smbus_process_call(struct i2c_client *client, u8 command, u16 value)
1797 {
1798         union i2c_smbus_data data;
1799         int status;
1800         data.word = value;
1801
1802         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1803                                 I2C_SMBUS_WRITE, command,
1804                                 I2C_SMBUS_PROC_CALL, &data);
1805         return (status < 0) ? status : data.word;
1806 }
1807 EXPORT_SYMBOL(i2c_smbus_process_call);
1808
1809 /**
1810  * i2c_smbus_read_block_data - SMBus "block read" protocol
1811  * @client: Handle to slave device
1812  * @command: Byte interpreted by slave
1813  * @values: Byte array into which data will be read; big enough to hold
1814  *      the data returned by the slave.  SMBus allows at most 32 bytes.
1815  *
1816  * This executes the SMBus "block read" protocol, returning negative errno
1817  * else the number of data bytes in the slave's response.
1818  *
1819  * Note that using this function requires that the client's adapter support
1820  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
1821  * support this; its emulation through I2C messaging relies on a specific
1822  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
1823  */
1824 s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
1825                               u8 *values)
1826 {
1827         union i2c_smbus_data data;
1828         int status;
1829
1830         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1831                                 I2C_SMBUS_READ, command,
1832                                 I2C_SMBUS_BLOCK_DATA, &data);
1833         if (status)
1834                 return status;
1835
1836         memcpy(values, &data.block[1], data.block[0]);
1837         return data.block[0];
1838 }
1839 EXPORT_SYMBOL(i2c_smbus_read_block_data);
1840
1841 /**
1842  * i2c_smbus_write_block_data - SMBus "block write" protocol
1843  * @client: Handle to slave device
1844  * @command: Byte interpreted by slave
1845  * @length: Size of data block; SMBus allows at most 32 bytes
1846  * @values: Byte array which will be written.
1847  *
1848  * This executes the SMBus "block write" protocol, returning negative errno
1849  * else zero on success.
1850  */
1851 s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
1852                                u8 length, const u8 *values)
1853 {
1854         union i2c_smbus_data data;
1855
1856         if (length > I2C_SMBUS_BLOCK_MAX)
1857                 length = I2C_SMBUS_BLOCK_MAX;
1858         data.block[0] = length;
1859         memcpy(&data.block[1], values, length);
1860         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1861                               I2C_SMBUS_WRITE, command,
1862                               I2C_SMBUS_BLOCK_DATA, &data);
1863 }
1864 EXPORT_SYMBOL(i2c_smbus_write_block_data);
1865
1866 /* Returns the number of read bytes */
1867 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
1868                                   u8 length, u8 *values)
1869 {
1870         union i2c_smbus_data data;
1871         int status;
1872
1873         if (length > I2C_SMBUS_BLOCK_MAX)
1874                 length = I2C_SMBUS_BLOCK_MAX;
1875         data.block[0] = length;
1876         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1877                                 I2C_SMBUS_READ, command,
1878                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
1879         if (status < 0)
1880                 return status;
1881
1882         memcpy(values, &data.block[1], data.block[0]);
1883         return data.block[0];
1884 }
1885 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
1886
1887 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
1888                                    u8 length, const u8 *values)
1889 {
1890         union i2c_smbus_data data;
1891
1892         if (length > I2C_SMBUS_BLOCK_MAX)
1893                 length = I2C_SMBUS_BLOCK_MAX;
1894         data.block[0] = length;
1895         memcpy(data.block + 1, values, length);
1896         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
1897                               I2C_SMBUS_WRITE, command,
1898                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
1899 }
1900 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
1901
1902 /* Simulate a SMBus command using the i2c protocol
1903    No checking of parameters is done!  */
1904 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
1905                                    unsigned short flags,
1906                                    char read_write, u8 command, int size,
1907                                    union i2c_smbus_data *data)
1908 {
1909         /* So we need to generate a series of msgs. In the case of writing, we
1910           need to use only one message; when reading, we need two. We initialize
1911           most things with sane defaults, to keep the code below somewhat
1912           simpler. */
1913         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
1914         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
1915         int num = read_write == I2C_SMBUS_READ ? 2 : 1;
1916         struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
1917                                   { addr, flags | I2C_M_RD, 0, msgbuf1 }
1918                                 };
1919         int i;
1920         u8 partial_pec = 0;
1921         int status;
1922
1923         msgbuf0[0] = command;
1924         switch (size) {
1925         case I2C_SMBUS_QUICK:
1926                 msg[0].len = 0;
1927                 /* Special case: The read/write field is used as data */
1928                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
1929                                         I2C_M_RD : 0);
1930                 num = 1;
1931                 break;
1932         case I2C_SMBUS_BYTE:
1933                 if (read_write == I2C_SMBUS_READ) {
1934                         /* Special case: only a read! */
1935                         msg[0].flags = I2C_M_RD | flags;
1936                         num = 1;
1937                 }
1938                 break;
1939         case I2C_SMBUS_BYTE_DATA:
1940                 if (read_write == I2C_SMBUS_READ)
1941                         msg[1].len = 1;
1942                 else {
1943                         msg[0].len = 2;
1944                         msgbuf0[1] = data->byte;
1945                 }
1946                 break;
1947         case I2C_SMBUS_WORD_DATA:
1948                 if (read_write == I2C_SMBUS_READ)
1949                         msg[1].len = 2;
1950                 else {
1951                         msg[0].len = 3;
1952                         msgbuf0[1] = data->word & 0xff;
1953                         msgbuf0[2] = data->word >> 8;
1954                 }
1955                 break;
1956         case I2C_SMBUS_PROC_CALL:
1957                 num = 2; /* Special case */
1958                 read_write = I2C_SMBUS_READ;
1959                 msg[0].len = 3;
1960                 msg[1].len = 2;
1961                 msgbuf0[1] = data->word & 0xff;
1962                 msgbuf0[2] = data->word >> 8;
1963                 break;
1964         case I2C_SMBUS_BLOCK_DATA:
1965                 if (read_write == I2C_SMBUS_READ) {
1966                         msg[1].flags |= I2C_M_RECV_LEN;
1967                         msg[1].len = 1; /* block length will be added by
1968                                            the underlying bus driver */
1969                 } else {
1970                         msg[0].len = data->block[0] + 2;
1971                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
1972                                 dev_err(&adapter->dev,
1973                                         "Invalid block write size %d\n",
1974                                         data->block[0]);
1975                                 return -EINVAL;
1976                         }
1977                         for (i = 1; i < msg[0].len; i++)
1978                                 msgbuf0[i] = data->block[i-1];
1979                 }
1980                 break;
1981         case I2C_SMBUS_BLOCK_PROC_CALL:
1982                 num = 2; /* Another special case */
1983                 read_write = I2C_SMBUS_READ;
1984                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
1985                         dev_err(&adapter->dev,
1986                                 "Invalid block write size %d\n",
1987                                 data->block[0]);
1988                         return -EINVAL;
1989                 }
1990                 msg[0].len = data->block[0] + 2;
1991                 for (i = 1; i < msg[0].len; i++)
1992                         msgbuf0[i] = data->block[i-1];
1993                 msg[1].flags |= I2C_M_RECV_LEN;
1994                 msg[1].len = 1; /* block length will be added by
1995                                    the underlying bus driver */
1996                 break;
1997         case I2C_SMBUS_I2C_BLOCK_DATA:
1998                 if (read_write == I2C_SMBUS_READ) {
1999                         msg[1].len = data->block[0];
2000                 } else {
2001                         msg[0].len = data->block[0] + 1;
2002                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
2003                                 dev_err(&adapter->dev,
2004                                         "Invalid block write size %d\n",
2005                                         data->block[0]);
2006                                 return -EINVAL;
2007                         }
2008                         for (i = 1; i <= data->block[0]; i++)
2009                                 msgbuf0[i] = data->block[i];
2010                 }
2011                 break;
2012         default:
2013                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
2014                 return -EOPNOTSUPP;
2015         }
2016
2017         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
2018                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
2019         if (i) {
2020                 /* Compute PEC if first message is a write */
2021                 if (!(msg[0].flags & I2C_M_RD)) {
2022                         if (num == 1) /* Write only */
2023                                 i2c_smbus_add_pec(&msg[0]);
2024                         else /* Write followed by read */
2025                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
2026                 }
2027                 /* Ask for PEC if last message is a read */
2028                 if (msg[num-1].flags & I2C_M_RD)
2029                         msg[num-1].len++;
2030         }
2031
2032         status = i2c_transfer(adapter, msg, num);
2033         if (status < 0)
2034                 return status;
2035
2036         /* Check PEC if last message is a read */
2037         if (i && (msg[num-1].flags & I2C_M_RD)) {
2038                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
2039                 if (status < 0)
2040                         return status;
2041         }
2042
2043         if (read_write == I2C_SMBUS_READ)
2044                 switch (size) {
2045                 case I2C_SMBUS_BYTE:
2046                         data->byte = msgbuf0[0];
2047                         break;
2048                 case I2C_SMBUS_BYTE_DATA:
2049                         data->byte = msgbuf1[0];
2050                         break;
2051                 case I2C_SMBUS_WORD_DATA:
2052                 case I2C_SMBUS_PROC_CALL:
2053                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
2054                         break;
2055                 case I2C_SMBUS_I2C_BLOCK_DATA:
2056                         for (i = 0; i < data->block[0]; i++)
2057                                 data->block[i+1] = msgbuf1[i];
2058                         break;
2059                 case I2C_SMBUS_BLOCK_DATA:
2060                 case I2C_SMBUS_BLOCK_PROC_CALL:
2061                         for (i = 0; i < msgbuf1[0] + 1; i++)
2062                                 data->block[i] = msgbuf1[i];
2063                         break;
2064                 }
2065         return 0;
2066 }
2067
2068 /**
2069  * i2c_smbus_xfer - execute SMBus protocol operations
2070  * @adapter: Handle to I2C bus
2071  * @addr: Address of SMBus slave on that bus
2072  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
2073  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
2074  * @command: Byte interpreted by slave, for protocols which use such bytes
2075  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
2076  * @data: Data to be read or written
2077  *
2078  * This executes an SMBus protocol operation, and returns a negative
2079  * errno code else zero on success.
2080  */
2081 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
2082                    char read_write, u8 command, int protocol,
2083                    union i2c_smbus_data *data)
2084 {
2085         unsigned long orig_jiffies;
2086         int try;
2087         s32 res;
2088
2089         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
2090
2091         if (adapter->algo->smbus_xfer) {
2092                 i2c_lock_adapter(adapter);
2093
2094                 /* Retry automatically on arbitration loss */
2095                 orig_jiffies = jiffies;
2096                 for (res = 0, try = 0; try <= adapter->retries; try++) {
2097                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
2098                                                         read_write, command,
2099                                                         protocol, data);
2100                         if (res != -EAGAIN)
2101                                 break;
2102                         if (time_after(jiffies,
2103                                        orig_jiffies + adapter->timeout))
2104                                 break;
2105                 }
2106                 i2c_unlock_adapter(adapter);
2107         } else
2108                 res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
2109                                               command, protocol, data);
2110
2111         return res;
2112 }
2113 EXPORT_SYMBOL(i2c_smbus_xfer);
2114
2115 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
2116 MODULE_DESCRIPTION("I2C-Bus main module");
2117 MODULE_LICENSE("GPL");