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