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