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