2005-04-16 16:20:36 -06:00
|
|
|
|
/* i2c-core.c - a device driver for the iic-bus interface */
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
/* Copyright (C) 1995-99 Simon G. Vogl
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
/* With some changes from Ky<4B>sti M<>lkki <kmalkki@cc.hut.fi>.
|
|
|
|
|
All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
|
|
|
|
|
Jean Delvare <khali@linux-fr.org> */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/idr.h>
|
|
|
|
|
#include <linux/seq_file.h>
|
2005-10-29 12:07:23 -06:00
|
|
|
|
#include <linux/platform_device.h>
|
2006-01-11 02:50:26 -07:00
|
|
|
|
#include <linux/mutex.h>
|
2007-02-13 14:09:00 -07:00
|
|
|
|
#include <linux/completion.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
#include "i2c-core.h"
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
static LIST_HEAD(adapters);
|
|
|
|
|
static LIST_HEAD(drivers);
|
2006-01-11 02:50:26 -07:00
|
|
|
|
static DEFINE_MUTEX(core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static DEFINE_IDR(i2c_adapter_idr);
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
#define is_newstyle_driver(d) ((d)->probe || (d)->remove)
|
2007-02-13 14:09:00 -07:00
|
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static int i2c_device_match(struct device *dev, struct device_driver *drv)
|
|
|
|
|
{
|
2007-05-01 15:26:30 -06:00
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
struct i2c_driver *driver = to_i2c_driver(drv);
|
|
|
|
|
|
|
|
|
|
/* make legacy i2c drivers bypass driver model probing entirely;
|
|
|
|
|
* such drivers scan each i2c adapter/bus themselves.
|
|
|
|
|
*/
|
2007-05-01 15:26:30 -06:00
|
|
|
|
if (!is_newstyle_driver(driver))
|
2007-05-01 15:26:30 -06:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* new style drivers use the same kind of driver matching policy
|
|
|
|
|
* as platform devices or SPI: compare device and driver IDs.
|
|
|
|
|
*/
|
|
|
|
|
return strcmp(client->driver_name, drv->name) == 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
#ifdef CONFIG_HOTPLUG
|
|
|
|
|
|
|
|
|
|
/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
|
|
|
|
|
static int i2c_device_uevent(struct device *dev, char **envp, int num_envp,
|
|
|
|
|
char *buffer, int buffer_size)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
int i = 0, length = 0;
|
|
|
|
|
|
|
|
|
|
/* by definition, legacy drivers can't hotplug */
|
|
|
|
|
if (dev->driver || !client->driver_name)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
|
|
|
|
|
"MODALIAS=%s", client->driver_name))
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
envp[i] = NULL;
|
|
|
|
|
dev_dbg(dev, "uevent\n");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
#define i2c_device_uevent NULL
|
|
|
|
|
#endif /* CONFIG_HOTPLUG */
|
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
static int i2c_device_probe(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-05-01 15:26:30 -06:00
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
struct i2c_driver *driver = to_i2c_driver(dev->driver);
|
|
|
|
|
|
|
|
|
|
if (!driver->probe)
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
client->driver = driver;
|
|
|
|
|
dev_dbg(dev, "probe\n");
|
|
|
|
|
return driver->probe(client);
|
2007-02-13 14:09:00 -07:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
static int i2c_device_remove(struct device *dev)
|
|
|
|
|
{
|
2007-05-01 15:26:30 -06:00
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
if (!dev->driver)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
|
if (driver->remove) {
|
|
|
|
|
dev_dbg(dev, "remove\n");
|
|
|
|
|
status = driver->remove(client);
|
|
|
|
|
} else {
|
|
|
|
|
dev->driver = NULL;
|
|
|
|
|
status = 0;
|
|
|
|
|
}
|
|
|
|
|
if (status == 0)
|
|
|
|
|
client->driver = NULL;
|
|
|
|
|
return status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
static void i2c_device_shutdown(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-02-13 14:09:00 -07:00
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
|
|
if (!dev->driver)
|
|
|
|
|
return;
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
|
if (driver->shutdown)
|
|
|
|
|
driver->shutdown(to_i2c_client(dev));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-02-13 14:09:00 -07:00
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
|
|
if (!dev->driver)
|
|
|
|
|
return 0;
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
|
if (!driver->suspend)
|
|
|
|
|
return 0;
|
|
|
|
|
return driver->suspend(to_i2c_client(dev), mesg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
static int i2c_device_resume(struct device * dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-02-13 14:09:00 -07:00
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
|
|
|
|
if (!dev->driver)
|
|
|
|
|
return 0;
|
|
|
|
|
driver = to_i2c_driver(dev->driver);
|
|
|
|
|
if (!driver->resume)
|
|
|
|
|
return 0;
|
|
|
|
|
return driver->resume(to_i2c_client(dev));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
static void i2c_client_release(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
complete(&client->released);
|
|
|
|
|
}
|
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
static void i2c_client_dev_release(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
kfree(to_i2c_client(dev));
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
static ssize_t show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
return sprintf(buf, "%s\n", client->name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
|
return client->driver_name
|
|
|
|
|
? sprintf(buf, "%s\n", client->driver_name)
|
|
|
|
|
: 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct device_attribute i2c_dev_attrs[] = {
|
|
|
|
|
__ATTR(name, S_IRUGO, show_client_name, NULL),
|
|
|
|
|
/* modalias helps coldplug: modprobe $(cat .../modalias) */
|
|
|
|
|
__ATTR(modalias, S_IRUGO, show_modalias, NULL),
|
|
|
|
|
{ },
|
|
|
|
|
};
|
|
|
|
|
|
2006-01-05 07:37:50 -07:00
|
|
|
|
struct bus_type i2c_bus_type = {
|
2007-02-13 14:09:00 -07:00
|
|
|
|
.name = "i2c",
|
2007-05-01 15:26:30 -06:00
|
|
|
|
.dev_attrs = i2c_dev_attrs,
|
2007-02-13 14:09:00 -07:00
|
|
|
|
.match = i2c_device_match,
|
2007-05-01 15:26:30 -06:00
|
|
|
|
.uevent = i2c_device_uevent,
|
2007-02-13 14:09:00 -07:00
|
|
|
|
.probe = i2c_device_probe,
|
|
|
|
|
.remove = i2c_device_remove,
|
|
|
|
|
.shutdown = i2c_device_shutdown,
|
|
|
|
|
.suspend = i2c_device_suspend,
|
|
|
|
|
.resume = i2c_device_resume,
|
2006-01-05 07:37:50 -07:00
|
|
|
|
};
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_bus_type);
|
2006-01-05 07:37:50 -07:00
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
/**
|
|
|
|
|
* i2c_new_device - instantiate an i2c device for use with a new style driver
|
|
|
|
|
* @adap: the adapter managing the device
|
|
|
|
|
* @info: describes one I2C device; bus_num is ignored
|
2007-07-12 06:12:28 -06:00
|
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
*
|
|
|
|
|
* Create a device to work with a new style i2c driver, where binding is
|
|
|
|
|
* handled through driver model probe()/remove() methods. This call is not
|
|
|
|
|
* appropriate for use by mainboad initialization logic, which usually runs
|
|
|
|
|
* during an arch_initcall() long before any i2c_adapter could exist.
|
|
|
|
|
*
|
|
|
|
|
* This returns the new i2c client, which may be saved for later use with
|
|
|
|
|
* i2c_unregister_device(); or NULL to indicate an error.
|
|
|
|
|
*/
|
|
|
|
|
struct i2c_client *
|
|
|
|
|
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
client = kzalloc(sizeof *client, GFP_KERNEL);
|
|
|
|
|
if (!client)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
client->adapter = adap;
|
|
|
|
|
|
|
|
|
|
client->dev.platform_data = info->platform_data;
|
|
|
|
|
client->flags = info->flags;
|
|
|
|
|
client->addr = info->addr;
|
|
|
|
|
client->irq = info->irq;
|
|
|
|
|
|
|
|
|
|
strlcpy(client->driver_name, info->driver_name,
|
|
|
|
|
sizeof(client->driver_name));
|
|
|
|
|
strlcpy(client->name, info->type, sizeof(client->name));
|
|
|
|
|
|
|
|
|
|
/* a new style driver may be bound to this device when we
|
|
|
|
|
* return from this function, or any later moment (e.g. maybe
|
|
|
|
|
* hotplugging will load the driver module). and the device
|
|
|
|
|
* refcount model is the standard driver model one.
|
|
|
|
|
*/
|
|
|
|
|
status = i2c_attach_client(client);
|
|
|
|
|
if (status < 0) {
|
|
|
|
|
kfree(client);
|
|
|
|
|
client = NULL;
|
|
|
|
|
}
|
|
|
|
|
return client;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_device);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* i2c_unregister_device - reverse effect of i2c_new_device()
|
|
|
|
|
* @client: value returned from i2c_new_device()
|
2007-07-12 06:12:28 -06:00
|
|
|
|
* Context: can sleep
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
*/
|
|
|
|
|
void i2c_unregister_device(struct i2c_client *client)
|
2007-05-01 15:26:30 -06:00
|
|
|
|
{
|
|
|
|
|
struct i2c_adapter *adapter = client->adapter;
|
|
|
|
|
struct i2c_driver *driver = client->driver;
|
|
|
|
|
|
|
|
|
|
if (driver && !is_newstyle_driver(driver)) {
|
|
|
|
|
dev_err(&client->dev, "can't unregister devices "
|
|
|
|
|
"with legacy drivers\n");
|
|
|
|
|
WARN_ON(1);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&adapter->clist_lock);
|
|
|
|
|
list_del(&client->list);
|
|
|
|
|
mutex_unlock(&adapter->clist_lock);
|
|
|
|
|
|
|
|
|
|
device_unregister(&client->dev);
|
|
|
|
|
}
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_unregister_device);
|
2007-05-01 15:26:30 -06:00
|
|
|
|
|
|
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
2007-05-01 15:26:28 -06:00
|
|
|
|
/* I2C bus adapters -- one roots each I2C or SMBUS segment */
|
|
|
|
|
|
2005-07-20 15:03:50 -06:00
|
|
|
|
void i2c_adapter_dev_release(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-05-01 15:26:28 -06:00
|
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
complete(&adap->dev_released);
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:28 -06:00
|
|
|
|
static ssize_t
|
|
|
|
|
show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
|
{
|
2007-05-01 15:26:28 -06:00
|
|
|
|
struct i2c_adapter *adap = to_i2c_adapter(dev);
|
2007-05-01 15:26:28 -06:00
|
|
|
|
return sprintf(buf, "%s\n", adap->name);
|
|
|
|
|
}
|
2007-01-04 05:07:04 -07:00
|
|
|
|
|
2007-05-01 15:26:28 -06:00
|
|
|
|
static struct device_attribute i2c_adapter_attrs[] = {
|
|
|
|
|
__ATTR(name, S_IRUGO, show_adapter_name, NULL),
|
|
|
|
|
{ },
|
|
|
|
|
};
|
2007-01-04 05:07:04 -07:00
|
|
|
|
|
2005-07-20 15:03:50 -06:00
|
|
|
|
struct class i2c_adapter_class = {
|
2007-01-04 05:07:04 -07:00
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.name = "i2c-adapter",
|
2007-05-01 15:26:28 -06:00
|
|
|
|
.dev_attrs = i2c_adapter_attrs,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
};
|
|
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_devinfo *devinfo;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&__i2c_board_lock);
|
|
|
|
|
list_for_each_entry(devinfo, &__i2c_board_list, list) {
|
|
|
|
|
if (devinfo->busnum == adapter->nr
|
|
|
|
|
&& !i2c_new_device(adapter,
|
|
|
|
|
&devinfo->board_info))
|
|
|
|
|
printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
|
|
|
|
|
i2c_adapter_id(adapter),
|
|
|
|
|
devinfo->board_info.addr);
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&__i2c_board_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
static int i2c_register_adapter(struct i2c_adapter *adap)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-05-01 15:26:31 -06:00
|
|
|
|
int res = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct list_head *item;
|
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_init(&adap->bus_lock);
|
|
|
|
|
mutex_init(&adap->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
INIT_LIST_HEAD(&adap->clients);
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
mutex_lock(&core_lists);
|
|
|
|
|
list_add_tail(&adap->list, &adapters);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* Add the adapter to the driver core.
|
|
|
|
|
* If the parent pointer is not set up,
|
|
|
|
|
* we add this adapter to the host bus.
|
|
|
|
|
*/
|
2007-01-04 05:07:04 -07:00
|
|
|
|
if (adap->dev.parent == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
adap->dev.parent = &platform_bus;
|
2007-02-13 14:09:04 -07:00
|
|
|
|
pr_debug("I2C adapter driver [%s] forgot to specify "
|
|
|
|
|
"physical device\n", adap->name);
|
2007-01-04 05:07:04 -07:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
|
|
|
|
|
adap->dev.release = &i2c_adapter_dev_release;
|
2007-05-01 15:26:27 -06:00
|
|
|
|
adap->dev.class = &i2c_adapter_class;
|
2006-08-15 10:26:30 -06:00
|
|
|
|
res = device_register(&adap->dev);
|
|
|
|
|
if (res)
|
|
|
|
|
goto out_list;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
/* create pre-declared device nodes for new-style drivers */
|
|
|
|
|
if (adap->nr < __i2c_first_dynamic_bus_num)
|
|
|
|
|
i2c_scan_static_board_info(adap);
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* let legacy drivers scan this bus for matching devices */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
list_for_each(item,&drivers) {
|
|
|
|
|
driver = list_entry(item, struct i2c_driver, list);
|
2005-11-26 12:28:06 -07:00
|
|
|
|
if (driver->attach_adapter)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* We ignore the return code; if it fails, too bad */
|
|
|
|
|
driver->attach_adapter(adap);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out_unlock:
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_unlock(&core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return res;
|
2006-08-15 10:26:30 -06:00
|
|
|
|
|
|
|
|
|
out_list:
|
|
|
|
|
list_del(&adap->list);
|
|
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
|
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
/**
|
|
|
|
|
* i2c_add_adapter - declare i2c adapter, use dynamic bus number
|
|
|
|
|
* @adapter: the adapter to add
|
2007-07-12 06:12:28 -06:00
|
|
|
|
* Context: can sleep
|
2007-05-01 15:26:31 -06:00
|
|
|
|
*
|
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
|
|
|
|
* doesn't matter. Examples: for I2C adapters dynamically added by
|
|
|
|
|
* USB links or PCI plugin cards.
|
|
|
|
|
*
|
|
|
|
|
* When this returns zero, a new bus number was allocated and stored
|
|
|
|
|
* in adap->nr, and the specified adapter became available for clients.
|
|
|
|
|
* Otherwise, a negative errno value is returned.
|
|
|
|
|
*/
|
|
|
|
|
int i2c_add_adapter(struct i2c_adapter *adapter)
|
|
|
|
|
{
|
|
|
|
|
int id, res = 0;
|
|
|
|
|
|
|
|
|
|
retry:
|
|
|
|
|
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&core_lists);
|
|
|
|
|
/* "above" here means "above or equal to", sigh */
|
|
|
|
|
res = idr_get_new_above(&i2c_adapter_idr, adapter,
|
|
|
|
|
__i2c_first_dynamic_bus_num, &id);
|
|
|
|
|
mutex_unlock(&core_lists);
|
|
|
|
|
|
|
|
|
|
if (res < 0) {
|
|
|
|
|
if (res == -EAGAIN)
|
|
|
|
|
goto retry;
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
adapter->nr = id;
|
|
|
|
|
return i2c_register_adapter(adapter);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(i2c_add_adapter);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* i2c_add_numbered_adapter - declare i2c adapter, use static bus number
|
|
|
|
|
* @adap: the adapter to register (with adap->nr initialized)
|
2007-07-12 06:12:28 -06:00
|
|
|
|
* Context: can sleep
|
2007-05-01 15:26:31 -06:00
|
|
|
|
*
|
|
|
|
|
* This routine is used to declare an I2C adapter when its bus number
|
|
|
|
|
* matters. Example: for I2C adapters from system-on-chip CPUs, or
|
|
|
|
|
* otherwise built in to the system's mainboard, and where i2c_board_info
|
|
|
|
|
* is used to properly configure I2C devices.
|
|
|
|
|
*
|
|
|
|
|
* If no devices have pre-been declared for this bus, then be sure to
|
|
|
|
|
* register the adapter before any dynamically allocated ones. Otherwise
|
|
|
|
|
* the required bus ID may not be available.
|
|
|
|
|
*
|
|
|
|
|
* When this returns zero, the specified adapter became available for
|
|
|
|
|
* clients using the bus number provided in adap->nr. Also, the table
|
|
|
|
|
* of I2C devices pre-declared using i2c_register_board_info() is scanned,
|
|
|
|
|
* and the appropriate driver model device nodes are created. Otherwise, a
|
|
|
|
|
* negative errno value is returned.
|
|
|
|
|
*/
|
|
|
|
|
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
|
|
|
|
|
{
|
|
|
|
|
int id;
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
if (adap->nr & ~MAX_ID_MASK)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
retry:
|
|
|
|
|
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&core_lists);
|
|
|
|
|
/* "above" here means "above or equal to", sigh;
|
|
|
|
|
* we need the "equal to" result to force the result
|
|
|
|
|
*/
|
|
|
|
|
status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
|
|
|
|
|
if (status == 0 && id != adap->nr) {
|
|
|
|
|
status = -EBUSY;
|
|
|
|
|
idr_remove(&i2c_adapter_idr, id);
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&core_lists);
|
|
|
|
|
if (status == -EAGAIN)
|
|
|
|
|
goto retry;
|
|
|
|
|
|
|
|
|
|
if (status == 0)
|
|
|
|
|
status = i2c_register_adapter(adap);
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter);
|
|
|
|
|
|
2007-07-12 06:12:28 -06:00
|
|
|
|
/**
|
|
|
|
|
* i2c_del_adapter - unregister I2C adapter
|
|
|
|
|
* @adap: the adapter being unregistered
|
|
|
|
|
* Context: can sleep
|
|
|
|
|
*
|
|
|
|
|
* This unregisters an I2C adapter which was previously registered
|
|
|
|
|
* by @i2c_add_adapter or @i2c_add_numbered_adapter.
|
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int i2c_del_adapter(struct i2c_adapter *adap)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *item, *_n;
|
|
|
|
|
struct i2c_adapter *adap_from_list;
|
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
int res = 0;
|
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_lock(&core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* First make sure that this adapter was ever added */
|
|
|
|
|
list_for_each_entry(adap_from_list, &adapters, list) {
|
|
|
|
|
if (adap_from_list == adap)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (adap_from_list != adap) {
|
2005-07-31 11:02:53 -06:00
|
|
|
|
pr_debug("i2c-core: attempting to delete unregistered "
|
|
|
|
|
"adapter [%s]\n", adap->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
res = -EINVAL;
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_for_each(item,&drivers) {
|
|
|
|
|
driver = list_entry(item, struct i2c_driver, list);
|
|
|
|
|
if (driver->detach_adapter)
|
|
|
|
|
if ((res = driver->detach_adapter(adap))) {
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_err(&adap->dev, "detach_adapter failed "
|
2005-11-26 12:34:05 -07:00
|
|
|
|
"for driver [%s]\n",
|
|
|
|
|
driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* detach any active clients. This must be done first, because
|
2005-05-19 13:40:38 -06:00
|
|
|
|
* it can fail; in which case we give up. */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
list_for_each_safe(item, _n, &adap->clients) {
|
2007-05-01 15:26:30 -06:00
|
|
|
|
struct i2c_driver *driver;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
client = list_entry(item, struct i2c_client, list);
|
2007-05-01 15:26:30 -06:00
|
|
|
|
driver = client->driver;
|
|
|
|
|
|
|
|
|
|
/* new style, follow standard driver model */
|
|
|
|
|
if (!driver || is_newstyle_driver(driver)) {
|
|
|
|
|
i2c_unregister_device(client);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* legacy drivers create and remove clients themselves */
|
|
|
|
|
if ((res = driver->detach_client(client))) {
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_err(&adap->dev, "detach_client failed for client "
|
|
|
|
|
"[%s] at address 0x%02x\n", client->name,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
client->addr);
|
|
|
|
|
goto out_unlock;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* clean up the sysfs representation */
|
|
|
|
|
init_completion(&adap->dev_released);
|
|
|
|
|
device_unregister(&adap->dev);
|
|
|
|
|
list_del(&adap->list);
|
|
|
|
|
|
|
|
|
|
/* wait for sysfs to drop all references */
|
|
|
|
|
wait_for_completion(&adap->dev_released);
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
/* free bus id */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
idr_remove(&i2c_adapter_idr, adap->nr);
|
|
|
|
|
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
out_unlock:
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_unlock(&core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return res;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_del_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* An i2c_driver is used with one or more i2c_client (device) nodes to access
|
|
|
|
|
* i2c slave chips, on a bus instance associated with some i2c_adapter. There
|
|
|
|
|
* are two models for binding the driver to its device: "new style" drivers
|
|
|
|
|
* follow the standard Linux driver model and just respond to probe() calls
|
|
|
|
|
* issued if the driver core sees they match(); "legacy" drivers create device
|
|
|
|
|
* nodes themselves.
|
2005-04-16 16:20:36 -06:00
|
|
|
|
*/
|
|
|
|
|
|
2005-12-06 16:33:15 -07:00
|
|
|
|
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2006-02-05 15:28:21 -07:00
|
|
|
|
int res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* new style driver methods can't mix with legacy ones */
|
2007-05-01 15:26:30 -06:00
|
|
|
|
if (is_newstyle_driver(driver)) {
|
2007-05-01 15:26:30 -06:00
|
|
|
|
if (driver->attach_adapter || driver->detach_adapter
|
|
|
|
|
|| driver->detach_client) {
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"i2c-core: driver [%s] is confused\n",
|
|
|
|
|
driver->driver.name);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* add the driver to the list of i2c drivers in the driver core */
|
2005-12-06 16:33:15 -07:00
|
|
|
|
driver->driver.owner = owner;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
driver->driver.bus = &i2c_bus_type;
|
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
/* for new style drivers, when registration returns the driver core
|
|
|
|
|
* will have called probe() for all matching-but-unbound devices.
|
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
res = driver_register(&driver->driver);
|
|
|
|
|
if (res)
|
2006-02-05 15:28:21 -07:00
|
|
|
|
return res;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2006-02-05 15:28:21 -07:00
|
|
|
|
mutex_lock(&core_lists);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
list_add_tail(&driver->list,&drivers);
|
2005-11-26 12:34:05 -07:00
|
|
|
|
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* legacy drivers scan i2c busses directly */
|
2005-11-26 12:28:06 -07:00
|
|
|
|
if (driver->attach_adapter) {
|
2007-05-01 15:26:28 -06:00
|
|
|
|
struct i2c_adapter *adapter;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(adapter, &adapters, list) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
driver->attach_adapter(adapter);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_unlock(&core_lists);
|
2006-02-05 15:28:21 -07:00
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2005-12-06 16:33:15 -07:00
|
|
|
|
EXPORT_SYMBOL(i2c_register_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/**
|
|
|
|
|
* i2c_del_driver - unregister I2C driver
|
|
|
|
|
* @driver: the driver being unregistered
|
2007-07-12 06:12:28 -06:00
|
|
|
|
* Context: can sleep
|
2007-05-01 15:26:30 -06:00
|
|
|
|
*/
|
2007-05-01 15:26:32 -06:00
|
|
|
|
void i2c_del_driver(struct i2c_driver *driver)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct list_head *item1, *item2, *_n;
|
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
struct i2c_adapter *adap;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_lock(&core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* new-style driver? */
|
|
|
|
|
if (is_newstyle_driver(driver))
|
|
|
|
|
goto unregister;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* Have a look at each adapter, if clients of this driver are still
|
2006-12-10 13:21:31 -07:00
|
|
|
|
* attached. If so, detach them to be able to kill the driver
|
2005-04-16 16:20:36 -06:00
|
|
|
|
* afterwards.
|
|
|
|
|
*/
|
|
|
|
|
list_for_each(item1,&adapters) {
|
|
|
|
|
adap = list_entry(item1, struct i2c_adapter, list);
|
|
|
|
|
if (driver->detach_adapter) {
|
2007-05-01 15:26:32 -06:00
|
|
|
|
if (driver->detach_adapter(adap)) {
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_err(&adap->dev, "detach_adapter failed "
|
2005-11-26 12:34:05 -07:00
|
|
|
|
"for driver [%s]\n",
|
|
|
|
|
driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
list_for_each_safe(item2, _n, &adap->clients) {
|
|
|
|
|
client = list_entry(item2, struct i2c_client, list);
|
|
|
|
|
if (client->driver != driver)
|
|
|
|
|
continue;
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_dbg(&adap->dev, "detaching client [%s] "
|
|
|
|
|
"at 0x%02x\n", client->name,
|
|
|
|
|
client->addr);
|
2007-05-01 15:26:32 -06:00
|
|
|
|
if (driver->detach_client(client)) {
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_err(&adap->dev, "detach_client "
|
|
|
|
|
"failed for client [%s] at "
|
|
|
|
|
"0x%02x\n", client->name,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
client->addr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
unregister:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
driver_unregister(&driver->driver);
|
|
|
|
|
list_del(&driver->list);
|
2005-11-26 12:34:05 -07:00
|
|
|
|
pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_unlock(&core_lists);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_del_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:30 -06:00
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static int __i2c_check_addr(struct i2c_adapter *adapter, unsigned int addr)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *item;
|
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
|
|
list_for_each(item,&adapter->clients) {
|
|
|
|
|
client = list_entry(item, struct i2c_client, list);
|
|
|
|
|
if (client->addr == addr)
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int i2c_check_addr(struct i2c_adapter *adapter, int addr)
|
|
|
|
|
{
|
|
|
|
|
int rval;
|
|
|
|
|
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adapter->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
rval = __i2c_check_addr(adapter, addr);
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adapter->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_check_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_attach_client(struct i2c_client *client)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_adapter *adapter = client->adapter;
|
2006-08-15 10:26:30 -06:00
|
|
|
|
int res = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adapter->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (__i2c_check_addr(client->adapter, client->addr)) {
|
2006-08-15 10:26:30 -06:00
|
|
|
|
res = -EBUSY;
|
|
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
list_add_tail(&client->list,&adapter->clients);
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-11-26 13:00:54 -07:00
|
|
|
|
client->usage_count = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
client->dev.parent = &client->adapter->dev;
|
|
|
|
|
client->dev.bus = &i2c_bus_type;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
|
|
if (client->driver)
|
|
|
|
|
client->dev.driver = &client->driver->driver;
|
|
|
|
|
|
2007-05-22 11:49:16 -06:00
|
|
|
|
if (client->driver && !is_newstyle_driver(client->driver)) {
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
client->dev.release = i2c_client_release;
|
2007-05-22 11:49:16 -06:00
|
|
|
|
client->dev.uevent_suppress = 1;
|
|
|
|
|
} else
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
client->dev.release = i2c_client_dev_release;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
|
|
|
|
|
"%d-%04x", i2c_adapter_id(adapter), client->addr);
|
2005-07-31 11:02:53 -06:00
|
|
|
|
dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
|
|
|
|
|
client->name, client->dev.bus_id);
|
2006-08-15 10:26:30 -06:00
|
|
|
|
res = device_register(&client->dev);
|
|
|
|
|
if (res)
|
|
|
|
|
goto out_list;
|
|
|
|
|
mutex_unlock(&adapter->clist_lock);
|
2006-09-30 09:18:59 -06:00
|
|
|
|
|
|
|
|
|
if (adapter->client_register) {
|
|
|
|
|
if (adapter->client_register(client)) {
|
|
|
|
|
dev_dbg(&adapter->dev, "client_register "
|
|
|
|
|
"failed for client [%s] at 0x%02x\n",
|
|
|
|
|
client->name, client->addr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
2006-08-15 10:26:30 -06:00
|
|
|
|
|
|
|
|
|
out_list:
|
|
|
|
|
list_del(&client->list);
|
|
|
|
|
dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
|
|
|
|
|
"(%d)\n", client->name, client->addr, res);
|
2006-09-30 09:18:59 -06:00
|
|
|
|
out_unlock:
|
|
|
|
|
mutex_unlock(&adapter->clist_lock);
|
|
|
|
|
return res;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_attach_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_detach_client(struct i2c_client *client)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_adapter *adapter = client->adapter;
|
|
|
|
|
int res = 0;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-11-26 13:00:54 -07:00
|
|
|
|
if (client->usage_count > 0) {
|
2005-07-27 14:14:49 -06:00
|
|
|
|
dev_warn(&client->dev, "Client [%s] still busy, "
|
|
|
|
|
"can't detach\n", client->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return -EBUSY;
|
2005-07-27 14:14:49 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (adapter->client_unregister) {
|
|
|
|
|
res = adapter->client_unregister(client);
|
|
|
|
|
if (res) {
|
|
|
|
|
dev_err(&client->dev,
|
2005-07-29 13:15:29 -06:00
|
|
|
|
"client_unregister [%s] failed, "
|
|
|
|
|
"client not detached\n", client->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adapter->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
list_del(&client->list);
|
|
|
|
|
init_completion(&client->released);
|
|
|
|
|
device_unregister(&client->dev);
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adapter->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
wait_for_completion(&client->released);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
return res;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_detach_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
static int i2c_inc_use_client(struct i2c_client *client)
|
|
|
|
|
{
|
|
|
|
|
|
2005-11-26 12:34:05 -07:00
|
|
|
|
if (!try_module_get(client->driver->driver.owner))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return -ENODEV;
|
|
|
|
|
if (!try_module_get(client->adapter->owner)) {
|
2005-11-26 12:34:05 -07:00
|
|
|
|
module_put(client->driver->driver.owner);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void i2c_dec_use_client(struct i2c_client *client)
|
|
|
|
|
{
|
2005-11-26 12:34:05 -07:00
|
|
|
|
module_put(client->driver->driver.owner);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
module_put(client->adapter->owner);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int i2c_use_client(struct i2c_client *client)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
ret = i2c_inc_use_client(client);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2005-11-26 13:00:54 -07:00
|
|
|
|
client->usage_count++;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_use_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_release_client(struct i2c_client *client)
|
|
|
|
|
{
|
2005-11-26 13:00:54 -07:00
|
|
|
|
if (!client->usage_count) {
|
|
|
|
|
pr_debug("i2c-core: %s used one too many times\n",
|
|
|
|
|
__FUNCTION__);
|
|
|
|
|
return -EPERM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-11-26 13:00:54 -07:00
|
|
|
|
client->usage_count--;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
i2c_dec_use_client(client);
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_release_client);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *item;
|
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adap->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
list_for_each(item,&adap->clients) {
|
|
|
|
|
client = list_entry(item, struct i2c_client, list);
|
2005-11-26 12:34:05 -07:00
|
|
|
|
if (!try_module_get(client->driver->driver.owner))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
continue;
|
|
|
|
|
if (NULL != client->driver->command) {
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adap->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
client->driver->command(client,cmd,arg);
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adap->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2005-11-26 12:34:05 -07:00
|
|
|
|
module_put(client->driver->driver.owner);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adap->clist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_clients_command);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
static int __init i2c_init(void)
|
|
|
|
|
{
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
retval = bus_register(&i2c_bus_type);
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
return class_register(&i2c_adapter_class);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit i2c_exit(void)
|
|
|
|
|
{
|
|
|
|
|
class_unregister(&i2c_adapter_class);
|
|
|
|
|
bus_unregister(&i2c_bus_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
subsys_initcall(i2c_init);
|
|
|
|
|
module_exit(i2c_exit);
|
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------
|
|
|
|
|
* the functional interface to the i2c busses.
|
|
|
|
|
* ----------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (adap->algo->master_xfer) {
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
for (ret = 0; ret < num; ret++) {
|
|
|
|
|
dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
|
2007-05-01 15:26:29 -06:00
|
|
|
|
"len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
|
|
|
|
|
? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
|
|
|
|
|
(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-12-10 13:21:30 -07:00
|
|
|
|
mutex_lock_nested(&adap->bus_lock, adap->level);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ret = adap->algo->master_xfer(adap,msgs,num);
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adap->bus_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
} else {
|
|
|
|
|
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_transfer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct i2c_adapter *adap=client->adapter;
|
|
|
|
|
struct i2c_msg msg;
|
|
|
|
|
|
2005-05-07 14:58:46 -06:00
|
|
|
|
msg.addr = client->addr;
|
|
|
|
|
msg.flags = client->flags & I2C_M_TEN;
|
|
|
|
|
msg.len = count;
|
|
|
|
|
msg.buf = (char *)buf;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-05-07 14:58:46 -06:00
|
|
|
|
ret = i2c_transfer(adap, &msg, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2005-05-07 14:58:46 -06:00
|
|
|
|
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
|
|
|
|
|
transmitted, else error code. */
|
|
|
|
|
return (ret == 1) ? count : ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_master_send);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_adapter *adap=client->adapter;
|
|
|
|
|
struct i2c_msg msg;
|
|
|
|
|
int ret;
|
2005-05-07 14:58:46 -06:00
|
|
|
|
|
|
|
|
|
msg.addr = client->addr;
|
|
|
|
|
msg.flags = client->flags & I2C_M_TEN;
|
|
|
|
|
msg.flags |= I2C_M_RD;
|
|
|
|
|
msg.len = count;
|
|
|
|
|
msg.buf = buf;
|
|
|
|
|
|
|
|
|
|
ret = i2c_transfer(adap, &msg, 1);
|
|
|
|
|
|
|
|
|
|
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
|
|
|
|
|
transmitted, else error code. */
|
|
|
|
|
return (ret == 1) ? count : ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_master_recv);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
int i2c_control(struct i2c_client *client,
|
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct i2c_adapter *adap = client->adapter;
|
|
|
|
|
|
|
|
|
|
dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case I2C_RETRIES:
|
|
|
|
|
adap->retries = arg;
|
|
|
|
|
break;
|
|
|
|
|
case I2C_TIMEOUT:
|
|
|
|
|
adap->timeout = arg;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (adap->algo->algo_control!=NULL)
|
|
|
|
|
ret = adap->algo->algo_control(adap,cmd,arg);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_control);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------
|
|
|
|
|
* the i2c address scanning function
|
|
|
|
|
* Will not work for 10-bit addresses!
|
|
|
|
|
* ----------------------------------------------------
|
|
|
|
|
*/
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
static int i2c_probe_address(struct i2c_adapter *adapter, int addr, int kind,
|
|
|
|
|
int (*found_proc) (struct i2c_adapter *, int, int))
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
/* Make sure the address is valid */
|
|
|
|
|
if (addr < 0x03 || addr > 0x77) {
|
|
|
|
|
dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
|
|
|
|
|
addr);
|
|
|
|
|
return -EINVAL;
|
2005-07-31 13:20:43 -06:00
|
|
|
|
}
|
|
|
|
|
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
/* Skip if already in use */
|
|
|
|
|
if (i2c_check_addr(adapter, addr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Make sure there is something at this address, unless forced */
|
2005-08-09 12:28:10 -06:00
|
|
|
|
if (kind < 0) {
|
|
|
|
|
if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,
|
|
|
|
|
I2C_SMBUS_QUICK, NULL) < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* prevent 24RF08 corruption */
|
|
|
|
|
if ((addr & ~0x0f) == 0x50)
|
|
|
|
|
i2c_smbus_xfer(adapter, addr, 0, 0, 0,
|
|
|
|
|
I2C_SMBUS_QUICK, NULL);
|
|
|
|
|
}
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
|
|
|
|
|
/* Finally call the custom detection function */
|
|
|
|
|
err = found_proc(adapter, addr, kind);
|
|
|
|
|
/* -ENODEV can be returned if there is a chip at the given address
|
|
|
|
|
but it isn't supported by this chip driver. We catch it here as
|
|
|
|
|
this isn't an error. */
|
2006-09-03 14:25:04 -06:00
|
|
|
|
if (err == -ENODEV)
|
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
dev_warn(&adapter->dev, "Client creation failed at 0x%x (%d)\n",
|
|
|
|
|
addr, err);
|
|
|
|
|
return err;
|
2005-07-31 13:20:43 -06:00
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int i2c_probe(struct i2c_adapter *adapter,
|
|
|
|
|
struct i2c_client_address_data *address_data,
|
|
|
|
|
int (*found_proc) (struct i2c_adapter *, int, int))
|
|
|
|
|
{
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
int i, err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int adap_id = i2c_adapter_id(adapter);
|
|
|
|
|
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
/* Force entries are done first, and are not affected by ignore
|
|
|
|
|
entries */
|
|
|
|
|
if (address_data->forces) {
|
|
|
|
|
unsigned short **forces = address_data->forces;
|
|
|
|
|
int kind;
|
|
|
|
|
|
|
|
|
|
for (kind = 0; forces[kind]; kind++) {
|
|
|
|
|
for (i = 0; forces[kind][i] != I2C_CLIENT_END;
|
|
|
|
|
i += 2) {
|
|
|
|
|
if (forces[kind][i] == adap_id
|
|
|
|
|
|| forces[kind][i] == ANY_I2C_BUS) {
|
|
|
|
|
dev_dbg(&adapter->dev, "found force "
|
|
|
|
|
"parameter for adapter %d, "
|
|
|
|
|
"addr 0x%02x, kind %d\n",
|
|
|
|
|
adap_id, forces[kind][i + 1],
|
|
|
|
|
kind);
|
|
|
|
|
err = i2c_probe_address(adapter,
|
|
|
|
|
forces[kind][i + 1],
|
|
|
|
|
kind, found_proc);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
}
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2005-09-25 08:50:06 -06:00
|
|
|
|
/* Stop here if we can't use SMBUS_QUICK */
|
|
|
|
|
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {
|
|
|
|
|
if (address_data->probe[0] == I2C_CLIENT_END
|
|
|
|
|
&& address_data->normal_i2c[0] == I2C_CLIENT_END)
|
2006-12-10 13:21:31 -07:00
|
|
|
|
return 0;
|
2005-09-25 08:50:06 -06:00
|
|
|
|
|
|
|
|
|
dev_warn(&adapter->dev, "SMBus Quick command not supported, "
|
|
|
|
|
"can't probe for chips\n");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
/* Probe entries are done second, and are not affected by ignore
|
|
|
|
|
entries either */
|
|
|
|
|
for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {
|
|
|
|
|
if (address_data->probe[i] == adap_id
|
|
|
|
|
|| address_data->probe[i] == ANY_I2C_BUS) {
|
|
|
|
|
dev_dbg(&adapter->dev, "found probe parameter for "
|
|
|
|
|
"adapter %d, addr 0x%02x\n", adap_id,
|
|
|
|
|
address_data->probe[i + 1]);
|
|
|
|
|
err = i2c_probe_address(adapter,
|
|
|
|
|
address_data->probe[i + 1],
|
|
|
|
|
-1, found_proc);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
/* Normal entries are done last, unless shadowed by an ignore entry */
|
|
|
|
|
for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {
|
|
|
|
|
int j, ignore;
|
|
|
|
|
|
|
|
|
|
ignore = 0;
|
|
|
|
|
for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;
|
|
|
|
|
j += 2) {
|
|
|
|
|
if ((address_data->ignore[j] == adap_id ||
|
|
|
|
|
address_data->ignore[j] == ANY_I2C_BUS)
|
|
|
|
|
&& address_data->ignore[j + 1]
|
|
|
|
|
== address_data->normal_i2c[i]) {
|
|
|
|
|
dev_dbg(&adapter->dev, "found ignore "
|
|
|
|
|
"parameter for adapter %d, "
|
|
|
|
|
"addr 0x%02x\n", adap_id,
|
|
|
|
|
address_data->ignore[j + 1]);
|
2006-07-01 09:01:59 -06:00
|
|
|
|
ignore = 1;
|
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
}
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
if (ignore)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
continue;
|
|
|
|
|
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
|
|
|
|
|
"addr 0x%02x\n", adap_id,
|
|
|
|
|
address_data->normal_i2c[i]);
|
|
|
|
|
err = i2c_probe_address(adapter, address_data->normal_i2c[i],
|
|
|
|
|
-1, found_proc);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
[PATCH] I2C: Rewrite i2c_probe
i2c_probe was quite complex and slow, so I rewrote it in a more
efficient and hopefully clearer way.
Note that this slightly changes the way the module parameters are
handled. This shouldn't change anything for the most common cases
though.
For one thing, the function now respects the order of the parameters
for address probing. It used to always do lower addresses first. The
new approach gives the user more control.
For another, ignore addresses don't overrule probe addresses anymore.
This could have been restored the way it was at the cost of a few more
lines of code, but I don't think it's worth it. Both lists are given
as module parameters, so a user would be quite silly to specify the
same addresses in both lists. The normal addresses list is the only
one that isn't controlled by a module parameter, thus is the only one
the user may reasonably want to remove an address from.
Another significant change is the fact that i2c_probe() will no more
stop when a detection function returns -ENODEV. Just because a driver
found a chip it doesn't support isn't a valid reason to stop all
probings for this one driver. This closes the long standing lm_sensors
ticket #1807.
http://www2.lm-sensors.nu/~lm78/readticket.cgi?ticket=1807
I updated the documentation accordingly.
In terms of algorithmic complexity, the new code is way better. If
I is the ignore address count, P the probe address count, N the
normal address count and F the force address count, the old code
was doing 128 * (F + I + P + N) iterations max, while the new code
does F + P + ((I+1) * N) iterations max. For the most common case
where F, I and P are empty, this is down from 128 * N to N.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-08-09 12:17:55 -06:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_probe);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
|
struct i2c_client *
|
|
|
|
|
i2c_new_probed_device(struct i2c_adapter *adap,
|
|
|
|
|
struct i2c_board_info *info,
|
|
|
|
|
unsigned short const *addr_list)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Stop here if the bus doesn't support probing */
|
|
|
|
|
if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) {
|
|
|
|
|
dev_err(&adap->dev, "Probing not supported\n");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&adap->clist_lock);
|
|
|
|
|
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
|
|
|
|
|
/* Check address validity */
|
|
|
|
|
if (addr_list[i] < 0x03 || addr_list[i] > 0x77) {
|
|
|
|
|
dev_warn(&adap->dev, "Invalid 7-bit address "
|
|
|
|
|
"0x%02x\n", addr_list[i]);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check address availability */
|
|
|
|
|
if (__i2c_check_addr(adap, addr_list[i])) {
|
|
|
|
|
dev_dbg(&adap->dev, "Address 0x%02x already in "
|
|
|
|
|
"use, not probing\n", addr_list[i]);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Test address responsiveness
|
|
|
|
|
The default probe method is a quick write, but it is known
|
|
|
|
|
to corrupt the 24RF08 EEPROMs due to a state machine bug,
|
|
|
|
|
and could also irreversibly write-protect some EEPROMs, so
|
|
|
|
|
for address ranges 0x30-0x37 and 0x50-0x5f, we use a byte
|
|
|
|
|
read instead. Also, some bus drivers don't implement
|
|
|
|
|
quick write, so we fallback to a byte read it that case
|
|
|
|
|
too. */
|
|
|
|
|
if ((addr_list[i] & ~0x07) == 0x30
|
|
|
|
|
|| (addr_list[i] & ~0x0f) == 0x50
|
|
|
|
|
|| !i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) {
|
|
|
|
|
if (i2c_smbus_xfer(adap, addr_list[i], 0,
|
|
|
|
|
I2C_SMBUS_READ, 0,
|
|
|
|
|
I2C_SMBUS_BYTE, NULL) >= 0)
|
|
|
|
|
break;
|
|
|
|
|
} else {
|
|
|
|
|
if (i2c_smbus_xfer(adap, addr_list[i], 0,
|
|
|
|
|
I2C_SMBUS_WRITE, 0,
|
|
|
|
|
I2C_SMBUS_QUICK, NULL) >= 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
mutex_unlock(&adap->clist_lock);
|
|
|
|
|
|
|
|
|
|
if (addr_list[i] == I2C_CLIENT_END) {
|
|
|
|
|
dev_dbg(&adap->dev, "Probing failed, no device found\n");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
info->addr = addr_list[i];
|
|
|
|
|
return i2c_new_device(adap, info);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(i2c_new_probed_device);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct i2c_adapter* i2c_get_adapter(int id)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_adapter *adapter;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_lock(&core_lists);
|
2005-06-27 22:21:30 -06:00
|
|
|
|
adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
|
|
|
|
|
if (adapter && !try_module_get(adapter->owner))
|
|
|
|
|
adapter = NULL;
|
|
|
|
|
|
2006-01-11 02:50:26 -07:00
|
|
|
|
mutex_unlock(&core_lists);
|
2005-06-27 22:21:30 -06:00
|
|
|
|
return adapter;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_get_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
void i2c_put_adapter(struct i2c_adapter *adap)
|
|
|
|
|
{
|
|
|
|
|
module_put(adap->owner);
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_put_adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* The SMBus parts */
|
|
|
|
|
|
2006-12-10 13:21:31 -07:00
|
|
|
|
#define POLY (0x1070U << 3)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static u8
|
|
|
|
|
crc8(u16 data)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
for(i = 0; i < 8; i++) {
|
2006-12-10 13:21:31 -07:00
|
|
|
|
if (data & 0x8000)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
data = data ^ POLY;
|
|
|
|
|
data = data << 1;
|
|
|
|
|
}
|
|
|
|
|
return (u8)(data >> 8);
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* Incremental CRC8 over count bytes in the array pointed to by p */
|
|
|
|
|
static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for(i = 0; i < count; i++)
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
crc = crc8((crc ^ p[i]) << 8);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return crc;
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* Assume a 7-bit address, which is reasonable for SMBus */
|
|
|
|
|
static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* The address will be sent first */
|
|
|
|
|
u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD);
|
|
|
|
|
pec = i2c_smbus_pec(pec, &addr, 1);
|
|
|
|
|
|
|
|
|
|
/* The data buffer follows */
|
|
|
|
|
return i2c_smbus_pec(pec, msg->buf, msg->len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* Used for write only transactions */
|
|
|
|
|
static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
|
|
|
|
|
msg->len++;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* Return <0 on CRC error
|
|
|
|
|
If there was a write before this read (most cases) we need to take the
|
|
|
|
|
partial CRC from the write part into account.
|
|
|
|
|
Note that this function does modify the message (we need to decrease the
|
|
|
|
|
message length to hide the CRC byte from the caller). */
|
|
|
|
|
static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
u8 rpec = msg->buf[--msg->len];
|
|
|
|
|
cpec = i2c_smbus_msg_pec(cpec, msg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (rpec != cpec) {
|
|
|
|
|
pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x\n",
|
|
|
|
|
rpec, cpec);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2006-12-10 13:21:31 -07:00
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value)
|
|
|
|
|
{
|
|
|
|
|
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
2006-12-10 13:21:31 -07:00
|
|
|
|
value,0,I2C_SMBUS_QUICK,NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_quick);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_read_byte(struct i2c_client *client)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
2006-09-03 14:24:00 -06:00
|
|
|
|
return data.byte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_byte);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)
|
|
|
|
|
{
|
|
|
|
|
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_byte);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
2006-09-03 14:24:00 -06:00
|
|
|
|
return data.byte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_byte_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
data.byte = value;
|
|
|
|
|
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_WRITE,command,
|
|
|
|
|
I2C_SMBUS_BYTE_DATA,&data);
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_byte_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
|
|
|
|
|
return -1;
|
|
|
|
|
else
|
2006-09-03 14:24:00 -06:00
|
|
|
|
return data.word;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_word_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
data.word = value;
|
|
|
|
|
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_WRITE,command,
|
|
|
|
|
I2C_SMBUS_WORD_DATA,&data);
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_word_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-05-01 15:26:34 -06:00
|
|
|
|
/* Returns the number of read bytes */
|
|
|
|
|
s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
|
|
|
|
|
u8 *values)
|
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
|
|
|
|
|
if (i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
|
I2C_SMBUS_READ, command,
|
|
|
|
|
I2C_SMBUS_BLOCK_DATA, &data))
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
memcpy(values, &data.block[1], data.block[0]);
|
|
|
|
|
return data.block[0];
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_block_data);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
|
2006-06-12 13:42:20 -06:00
|
|
|
|
u8 length, const u8 *values)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
2006-01-18 15:14:55 -07:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (length > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
|
length = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
|
data.block[0] = length;
|
2006-01-18 15:14:55 -07:00
|
|
|
|
memcpy(&data.block[1], values, length);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_WRITE,command,
|
|
|
|
|
I2C_SMBUS_BLOCK_DATA,&data);
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_block_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* Returns the number of read bytes */
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 06:12:29 -06:00
|
|
|
|
s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command,
|
|
|
|
|
u8 length, u8 *values)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
2006-01-18 15:14:55 -07:00
|
|
|
|
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 06:12:29 -06:00
|
|
|
|
if (length > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
|
length = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
|
data.block[0] = length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
|
|
|
|
|
I2C_SMBUS_READ,command,
|
|
|
|
|
I2C_SMBUS_I2C_BLOCK_DATA,&data))
|
|
|
|
|
return -1;
|
2006-01-18 15:14:55 -07:00
|
|
|
|
|
|
|
|
|
memcpy(values, &data.block[1], data.block[0]);
|
|
|
|
|
return data.block[0];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-01-08 21:19:18 -07:00
|
|
|
|
s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
|
2006-06-12 13:42:20 -06:00
|
|
|
|
u8 length, const u8 *values)
|
2006-01-08 21:19:18 -07:00
|
|
|
|
{
|
|
|
|
|
union i2c_smbus_data data;
|
|
|
|
|
|
|
|
|
|
if (length > I2C_SMBUS_BLOCK_MAX)
|
|
|
|
|
length = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
|
data.block[0] = length;
|
|
|
|
|
memcpy(data.block + 1, values, length);
|
|
|
|
|
return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
|
|
|
|
|
I2C_SMBUS_WRITE, command,
|
|
|
|
|
I2C_SMBUS_I2C_BLOCK_DATA, &data);
|
|
|
|
|
}
|
2007-05-01 15:26:31 -06:00
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
|
2006-01-08 21:19:18 -07:00
|
|
|
|
|
2006-12-10 13:21:31 -07:00
|
|
|
|
/* Simulate a SMBus command using the i2c protocol
|
2005-04-16 16:20:36 -06:00
|
|
|
|
No checking of parameters is done! */
|
2006-12-10 13:21:31 -07:00
|
|
|
|
static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned short flags,
|
2006-12-10 13:21:31 -07:00
|
|
|
|
char read_write, u8 command, int size,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
union i2c_smbus_data * data)
|
|
|
|
|
{
|
|
|
|
|
/* So we need to generate a series of msgs. In the case of writing, we
|
|
|
|
|
need to use only one message; when reading, we need two. We initialize
|
|
|
|
|
most things with sane defaults, to keep the code below somewhat
|
|
|
|
|
simpler. */
|
2005-09-25 09:01:11 -06:00
|
|
|
|
unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
|
|
|
|
|
unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int num = read_write == I2C_SMBUS_READ?2:1;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{ addr, flags | I2C_M_RD, 0, msgbuf1 }
|
|
|
|
|
};
|
|
|
|
|
int i;
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
u8 partial_pec = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
msgbuf0[0] = command;
|
|
|
|
|
switch(size) {
|
|
|
|
|
case I2C_SMBUS_QUICK:
|
|
|
|
|
msg[0].len = 0;
|
|
|
|
|
/* Special case: The read/write field is used as data */
|
|
|
|
|
msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
|
|
|
|
|
num = 1;
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_BYTE:
|
|
|
|
|
if (read_write == I2C_SMBUS_READ) {
|
|
|
|
|
/* Special case: only a read! */
|
|
|
|
|
msg[0].flags = I2C_M_RD | flags;
|
|
|
|
|
num = 1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_BYTE_DATA:
|
|
|
|
|
if (read_write == I2C_SMBUS_READ)
|
|
|
|
|
msg[1].len = 1;
|
|
|
|
|
else {
|
|
|
|
|
msg[0].len = 2;
|
|
|
|
|
msgbuf0[1] = data->byte;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_WORD_DATA:
|
|
|
|
|
if (read_write == I2C_SMBUS_READ)
|
|
|
|
|
msg[1].len = 2;
|
|
|
|
|
else {
|
|
|
|
|
msg[0].len=3;
|
|
|
|
|
msgbuf0[1] = data->word & 0xff;
|
2006-09-03 14:24:00 -06:00
|
|
|
|
msgbuf0[2] = data->word >> 8;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_PROC_CALL:
|
|
|
|
|
num = 2; /* Special case */
|
|
|
|
|
read_write = I2C_SMBUS_READ;
|
|
|
|
|
msg[0].len = 3;
|
|
|
|
|
msg[1].len = 2;
|
|
|
|
|
msgbuf0[1] = data->word & 0xff;
|
2006-09-03 14:24:00 -06:00
|
|
|
|
msgbuf0[2] = data->word >> 8;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_BLOCK_DATA:
|
|
|
|
|
if (read_write == I2C_SMBUS_READ) {
|
2007-05-01 15:26:29 -06:00
|
|
|
|
msg[1].flags |= I2C_M_RECV_LEN;
|
|
|
|
|
msg[1].len = 1; /* block length will be added by
|
|
|
|
|
the underlying bus driver */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
} else {
|
|
|
|
|
msg[0].len = data->block[0] + 2;
|
|
|
|
|
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
|
|
|
|
|
dev_err(&adapter->dev, "smbus_access called with "
|
|
|
|
|
"invalid block write size (%d)\n",
|
|
|
|
|
data->block[0]);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2005-09-25 09:01:11 -06:00
|
|
|
|
for (i = 1; i < msg[0].len; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
msgbuf0[i] = data->block[i-1];
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_BLOCK_PROC_CALL:
|
2007-05-01 15:26:29 -06:00
|
|
|
|
num = 2; /* Another special case */
|
|
|
|
|
read_write = I2C_SMBUS_READ;
|
|
|
|
|
if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
|
|
|
|
|
dev_err(&adapter->dev, "%s called with invalid "
|
|
|
|
|
"block proc call size (%d)\n", __FUNCTION__,
|
|
|
|
|
data->block[0]);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
msg[0].len = data->block[0] + 2;
|
|
|
|
|
for (i = 1; i < msg[0].len; i++)
|
|
|
|
|
msgbuf0[i] = data->block[i-1];
|
|
|
|
|
msg[1].flags |= I2C_M_RECV_LEN;
|
|
|
|
|
msg[1].len = 1; /* block length will be added by
|
|
|
|
|
the underlying bus driver */
|
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
case I2C_SMBUS_I2C_BLOCK_DATA:
|
|
|
|
|
if (read_write == I2C_SMBUS_READ) {
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 06:12:29 -06:00
|
|
|
|
msg[1].len = data->block[0];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
} else {
|
|
|
|
|
msg[0].len = data->block[0] + 1;
|
2005-10-07 16:15:59 -06:00
|
|
|
|
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
|
|
|
|
|
"invalid block write size (%d)\n",
|
|
|
|
|
data->block[0]);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
for (i = 1; i <= data->block[0]; i++)
|
|
|
|
|
msgbuf0[i] = data->block[i];
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
dev_err(&adapter->dev, "smbus_access called with invalid size (%d)\n",
|
|
|
|
|
size);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
|
|
|
|
|
&& size != I2C_SMBUS_I2C_BLOCK_DATA);
|
|
|
|
|
if (i) {
|
|
|
|
|
/* Compute PEC if first message is a write */
|
|
|
|
|
if (!(msg[0].flags & I2C_M_RD)) {
|
2006-12-10 13:21:31 -07:00
|
|
|
|
if (num == 1) /* Write only */
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
i2c_smbus_add_pec(&msg[0]);
|
|
|
|
|
else /* Write followed by read */
|
|
|
|
|
partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
|
|
|
|
|
}
|
|
|
|
|
/* Ask for PEC if last message is a read */
|
|
|
|
|
if (msg[num-1].flags & I2C_M_RD)
|
2006-12-10 13:21:31 -07:00
|
|
|
|
msg[num-1].len++;
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (i2c_transfer(adapter, msg, num) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
[PATCH] i2c: SMBus PEC support rewrite, 2 of 3
This is my rewrite of the SMBus PEC support. The original
implementation was known to have bugs (credits go to Hideki Iwamoto
for reporting many of them recently), and was incomplete due to a
conceptual limitation.
The rewrite affects only software PEC. Hardware PEC needs very little
code and is mostly untouched.
Technically, both implementations differ in that the original one
was emulating PEC in software by modifying the contents of an
i2c_smbus_data union (changing the transaction to a different type),
while the new one works one level lower, on i2c_msg structures (working
on message contents). Due to the definition of the i2c_smbus_data union,
not all SMBus transactions could be handled (at least not without
changing the definition of this union, which would break user-space
compatibility), and those which could had to be implemented
individually. At the opposite, adding PEC to an i2c_msg structure
can be done on any SMBus transaction with common code.
Advantages of the new implementation:
* It's about twice as small (from ~136 lines before to ~70 now, only
counting i2c-core, including blank and comment lines). The memory
used by i2c-core is down by ~640 bytes (~3.5%).
* Easier to validate, less tricky code. The code being common to all
transactions by design, the risk that a bug can stay uncovered is
lower.
* All SMBus transactions have PEC support in I2C emulation mode
(providing the non-PEC transaction is also implemented). Transactions
which have no emulation code right now will get PEC support for free
when they finally get implemented.
* Allows for code simplifications in header files and bus drivers
(patch follows).
Drawbacks (I guess there had to be at least one):
* PEC emulation for non-PEC capable non-I2C SMBus masters was dropped.
It was based on SMBus tricks and doesn't quite fit in the new design.
I don't think it's really a problem, as the benefit was certainly
not worth the additional complexity, but it's only fair that I at
least mention it.
Lastly, let's note that the new implementation does slightly affect
compatibility (both in kernel and user-space), but doesn't actually
break it. Some defines will be dropped, but the code can always be
changed in a way that will work with both the old and the new
implementations. It shouldn't be a problem as there doesn't seem to be
many users of SMBus PEC to date anyway.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-10-26 13:28:55 -06:00
|
|
|
|
/* Check PEC if last message is a read */
|
|
|
|
|
if (i && (msg[num-1].flags & I2C_M_RD)) {
|
|
|
|
|
if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (read_write == I2C_SMBUS_READ)
|
|
|
|
|
switch(size) {
|
|
|
|
|
case I2C_SMBUS_BYTE:
|
|
|
|
|
data->byte = msgbuf0[0];
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_BYTE_DATA:
|
|
|
|
|
data->byte = msgbuf1[0];
|
|
|
|
|
break;
|
2006-12-10 13:21:31 -07:00
|
|
|
|
case I2C_SMBUS_WORD_DATA:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
case I2C_SMBUS_PROC_CALL:
|
|
|
|
|
data->word = msgbuf1[0] | (msgbuf1[1] << 8);
|
|
|
|
|
break;
|
|
|
|
|
case I2C_SMBUS_I2C_BLOCK_DATA:
|
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 06:12:29 -06:00
|
|
|
|
for (i = 0; i < data->block[0]; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
data->block[i+1] = msgbuf1[i];
|
|
|
|
|
break;
|
2007-05-01 15:26:29 -06:00
|
|
|
|
case I2C_SMBUS_BLOCK_DATA:
|
|
|
|
|
case I2C_SMBUS_BLOCK_PROC_CALL:
|
|
|
|
|
for (i = 0; i < msgbuf1[0] + 1; i++)
|
|
|
|
|
data->block[i] = msgbuf1[i];
|
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
|
2006-12-10 13:21:31 -07:00
|
|
|
|
char read_write, u8 command, int size,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
union i2c_smbus_data * data)
|
|
|
|
|
{
|
|
|
|
|
s32 res;
|
|
|
|
|
|
|
|
|
|
flags &= I2C_M_TEN | I2C_CLIENT_PEC;
|
|
|
|
|
|
|
|
|
|
if (adapter->algo->smbus_xfer) {
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_lock(&adapter->bus_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
|
|
|
|
|
command,size,data);
|
2006-01-18 15:16:04 -07:00
|
|
|
|
mutex_unlock(&adapter->bus_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
} else
|
|
|
|
|
res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
|
|
|
|
|
command,size,data);
|
|
|
|
|
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(i2c_smbus_xfer);
|
|
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
|
|
|
|
|
MODULE_DESCRIPTION("I2C-Bus main module");
|
|
|
|
|
MODULE_LICENSE("GPL");
|