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