mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-17 01:34:00 +08:00
Merge branch 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
* 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6: i2c: Add info->archdata field i2c: Inform about deprecated chips directory i2c: Use pci_ioremap_bar() Schedule removal of the legacy i2c device driver binding model i2c: Clean up <linux/i2c.h> i2c: Update and clean up writing-clients document i2c: Drop 2-byte address block transfer defines i2c: Delete legacy model documentation i2c: Constify i2c_get_clientdata's parameter i2c: Delete outdated client porting guide i2c: Make clear what the class field of i2c_adapter is good for i2c-algo-pcf: Fix typo in debugging log message i2c-algo-pcf: Add adapter hooks around xfer begin and end i2c-algo-pcf: Pass adapter data into ->waitforpin() method i2c-i801: Add support for Intel Ibex Peak
This commit is contained in:
Linus Torvalds
commit
feeedc6c82
@ -359,3 +359,11 @@ Why: The 2.6 kernel supports direct writing to ide CD drives, which
|
||||
eliminates the need for ide-scsi. The new method is more
|
||||
efficient in every way.
|
||||
Who: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
|
||||
|
||||
---------------------------
|
||||
|
||||
What: i2c_attach_client(), i2c_detach_client(), i2c_driver->detach_client()
|
||||
When: 2.6.29 (ideally) or 2.6.30 (more likely)
|
||||
Why: Deprecated by the new (standard) device driver binding model. Use
|
||||
i2c_driver->probe() and ->remove() instead.
|
||||
Who: Jean Delvare <khali@linux-fr.org>
|
||||
|
||||
@ -13,8 +13,9 @@ Supported adapters:
|
||||
* Intel 631xESB/632xESB (ESB2)
|
||||
* Intel 82801H (ICH8)
|
||||
* Intel 82801I (ICH9)
|
||||
* Intel Tolapai
|
||||
* Intel ICH10
|
||||
* Intel EP80579 (Tolapai)
|
||||
* Intel 82801JI (ICH10)
|
||||
* Intel PCH
|
||||
Datasheets: Publicly available at the Intel website
|
||||
|
||||
Authors:
|
||||
@ -32,7 +33,7 @@ Description
|
||||
-----------
|
||||
|
||||
The ICH (properly known as the 82801AA), ICH0 (82801AB), ICH2 (82801BA),
|
||||
ICH3 (82801CA/CAM) and later devices are Intel chips that are a part of
|
||||
ICH3 (82801CA/CAM) and later devices (PCH) are Intel chips that are a part of
|
||||
Intel's '810' chipset for Celeron-based PCs, '810E' chipset for
|
||||
Pentium-based PCs, '815E' chipset, and others.
|
||||
|
||||
|
||||
@ -1,160 +0,0 @@
|
||||
Revision 7, 2007-04-19
|
||||
Jean Delvare <khali@linux-fr.org>
|
||||
Greg KH <greg@kroah.com>
|
||||
|
||||
This is a guide on how to convert I2C chip drivers from Linux 2.4 to
|
||||
Linux 2.6. I have been using existing drivers (lm75, lm78) as examples.
|
||||
Then I converted a driver myself (lm83) and updated this document.
|
||||
Note that this guide is strongly oriented towards hardware monitoring
|
||||
drivers. Many points are still valid for other type of drivers, but
|
||||
others may be irrelevant.
|
||||
|
||||
There are two sets of points below. The first set concerns technical
|
||||
changes. The second set concerns coding policy. Both are mandatory.
|
||||
|
||||
Although reading this guide will help you porting drivers, I suggest
|
||||
you keep an eye on an already ported driver while porting your own
|
||||
driver. This will help you a lot understanding what this guide
|
||||
exactly means. Choose the chip driver that is the more similar to
|
||||
yours for best results.
|
||||
|
||||
Technical changes:
|
||||
|
||||
* [Driver type] Any driver that was relying on i2c-isa has to be
|
||||
converted to a proper isa, platform or pci driver. This is not
|
||||
covered by this guide.
|
||||
|
||||
* [Includes] Get rid of "version.h" and <linux/i2c-proc.h>.
|
||||
Includes typically look like that:
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/jiffies.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/hwmon.h> /* for hardware monitoring drivers */
|
||||
#include <linux/hwmon-sysfs.h>
|
||||
#include <linux/hwmon-vid.h> /* if you need VRM support */
|
||||
#include <linux/err.h> /* for class registration */
|
||||
Please respect this inclusion order. Some extra headers may be
|
||||
required for a given driver (e.g. "lm75.h").
|
||||
|
||||
* [Addresses] SENSORS_I2C_END becomes I2C_CLIENT_END, ISA addresses
|
||||
are no more handled by the i2c core. Address ranges are no more
|
||||
supported either, define each individual address separately.
|
||||
SENSORS_INSMOD_<n> becomes I2C_CLIENT_INSMOD_<n>.
|
||||
|
||||
* [Client data] Get rid of sysctl_id. Try using standard names for
|
||||
register values (for example, temp_os becomes temp_max). You're
|
||||
still relatively free here, but you *have* to follow the standard
|
||||
names for sysfs files (see the Sysctl section below).
|
||||
|
||||
* [Function prototypes] The detect functions loses its flags
|
||||
parameter. Sysctl (e.g. lm75_temp) and miscellaneous functions
|
||||
are off the list of prototypes. This usually leaves five
|
||||
prototypes:
|
||||
static int lm75_attach_adapter(struct i2c_adapter *adapter);
|
||||
static int lm75_detect(struct i2c_adapter *adapter, int address,
|
||||
int kind);
|
||||
static void lm75_init_client(struct i2c_client *client);
|
||||
static int lm75_detach_client(struct i2c_client *client);
|
||||
static struct lm75_data lm75_update_device(struct device *dev);
|
||||
|
||||
* [Sysctl] All sysctl stuff is of course gone (defines, ctl_table
|
||||
and functions). Instead, you have to define show and set functions for
|
||||
each sysfs file. Only define set for writable values. Take a look at an
|
||||
existing 2.6 driver for details (it87 for example). Don't forget
|
||||
to define the attributes for each file (this is that step that
|
||||
links callback functions). Use the file names specified in
|
||||
Documentation/hwmon/sysfs-interface for the individual files. Also
|
||||
convert the units these files read and write to the specified ones.
|
||||
If you need to add a new type of file, please discuss it on the
|
||||
sensors mailing list <lm-sensors@lm-sensors.org> by providing a
|
||||
patch to the Documentation/hwmon/sysfs-interface file.
|
||||
|
||||
* [Attach] The attach function should make sure that the adapter's
|
||||
class has I2C_CLASS_HWMON (or whatever class is suitable for your
|
||||
driver), using the following construct:
|
||||
if (!(adapter->class & I2C_CLASS_HWMON))
|
||||
return 0;
|
||||
Call i2c_probe() instead of i2c_detect().
|
||||
|
||||
* [Detect] As mentioned earlier, the flags parameter is gone.
|
||||
The type_name and client_name strings are replaced by a single
|
||||
name string, which will be filled with a lowercase, short string.
|
||||
The labels used for error paths are reduced to the number needed.
|
||||
It is advised that the labels are given descriptive names such as
|
||||
exit and exit_free. Don't forget to properly set err before
|
||||
jumping to error labels. By the way, labels should be left-aligned.
|
||||
Use kzalloc instead of kmalloc.
|
||||
Use i2c_set_clientdata to set the client data (as opposed to
|
||||
a direct access to client->data).
|
||||
Use strlcpy instead of strcpy or snprintf to copy the client name.
|
||||
Replace the sysctl directory registration by calls to
|
||||
device_create_file. Move the driver initialization before any
|
||||
sysfs file creation.
|
||||
Register the client with the hwmon class (using hwmon_device_register)
|
||||
if applicable.
|
||||
Drop client->id.
|
||||
Drop any 24RF08 corruption prevention you find, as this is now done
|
||||
at the i2c-core level, and doing it twice voids it.
|
||||
Don't add I2C_CLIENT_ALLOW_USE to client->flags, it's the default now.
|
||||
|
||||
* [Init] Limits must not be set by the driver (can be done later in
|
||||
user-space). Chip should not be reset default (although a module
|
||||
parameter may be used to force it), and initialization should be
|
||||
limited to the strictly necessary steps.
|
||||
|
||||
* [Detach] Remove the call to i2c_deregister_entry. Do not log an
|
||||
error message if i2c_detach_client fails, as i2c-core will now do
|
||||
it for you.
|
||||
Unregister from the hwmon class if applicable.
|
||||
|
||||
* [Update] The function prototype changed, it is now
|
||||
passed a device structure, which you have to convert to a client
|
||||
using to_i2c_client(dev). The update function should return a
|
||||
pointer to the client data.
|
||||
Don't access client->data directly, use i2c_get_clientdata(client)
|
||||
instead.
|
||||
Use time_after() instead of direct jiffies comparison.
|
||||
|
||||
* [Interface] Make sure there is a MODULE_LICENSE() line, at the bottom
|
||||
of the file (after MODULE_AUTHOR() and MODULE_DESCRIPTION(), in this
|
||||
order).
|
||||
|
||||
* [Driver] The flags field of the i2c_driver structure is gone.
|
||||
I2C_DF_NOTIFY is now the default behavior.
|
||||
The i2c_driver structure has a driver member, which is itself a
|
||||
structure, those name member should be initialized to a driver name
|
||||
string. i2c_driver itself has no name member anymore.
|
||||
|
||||
* [Driver model] Instead of shutdown or reboot notifiers, provide a
|
||||
shutdown() method in your driver.
|
||||
|
||||
* [Power management] Use the driver model suspend() and resume()
|
||||
callbacks instead of the obsolete pm_register() calls.
|
||||
|
||||
Coding policy:
|
||||
|
||||
* [Copyright] Use (C), not (c), for copyright.
|
||||
|
||||
* [Debug/log] Get rid of #ifdef DEBUG/#endif constructs whenever you
|
||||
can. Calls to printk for debugging purposes are replaced by calls to
|
||||
dev_dbg where possible, else to pr_debug. Here is an example of how
|
||||
to call it (taken from lm75_detect):
|
||||
dev_dbg(&client->dev, "Starting lm75 update\n");
|
||||
Replace other printk calls with the dev_info, dev_err or dev_warn
|
||||
function, as appropriate.
|
||||
|
||||
* [Constants] Constants defines (registers, conversions) should be
|
||||
aligned. This greatly improves readability.
|
||||
Alignments are achieved by the means of tabs, not spaces. Remember
|
||||
that tabs are set to 8 in the Linux kernel code.
|
||||
|
||||
* [Layout] Avoid extra empty lines between comments and what they
|
||||
comment. Respect the coding style (see Documentation/CodingStyle),
|
||||
in particular when it comes to placing curly braces.
|
||||
|
||||
* [Comments] Make sure that no comment refers to a file that isn't
|
||||
part of the Linux source tree (typically doc/chips/<chip name>),
|
||||
and that remaining comments still match the code. Merging comment
|
||||
lines when possible is encouraged.
|
||||
@ -10,23 +10,21 @@ General remarks
|
||||
===============
|
||||
|
||||
Try to keep the kernel namespace as clean as possible. The best way to
|
||||
do this is to use a unique prefix for all global symbols. This is
|
||||
do this is to use a unique prefix for all global symbols. This is
|
||||
especially important for exported symbols, but it is a good idea to do
|
||||
it for non-exported symbols too. We will use the prefix `foo_' in this
|
||||
tutorial, and `FOO_' for preprocessor variables.
|
||||
tutorial.
|
||||
|
||||
|
||||
The driver structure
|
||||
====================
|
||||
|
||||
Usually, you will implement a single driver structure, and instantiate
|
||||
all clients from it. Remember, a driver structure contains general access
|
||||
all clients from it. Remember, a driver structure contains general access
|
||||
routines, and should be zero-initialized except for fields with data you
|
||||
provide. A client structure holds device-specific information like the
|
||||
driver model device node, and its I2C address.
|
||||
|
||||
/* iff driver uses driver model ("new style") binding model: */
|
||||
|
||||
static struct i2c_device_id foo_idtable[] = {
|
||||
{ "foo", my_id_for_foo },
|
||||
{ "bar", my_id_for_bar },
|
||||
@ -40,7 +38,6 @@ static struct i2c_driver foo_driver = {
|
||||
.name = "foo",
|
||||
},
|
||||
|
||||
/* iff driver uses driver model ("new style") binding model: */
|
||||
.id_table = foo_ids,
|
||||
.probe = foo_probe,
|
||||
.remove = foo_remove,
|
||||
@ -49,24 +46,19 @@ static struct i2c_driver foo_driver = {
|
||||
.detect = foo_detect,
|
||||
.address_data = &addr_data,
|
||||
|
||||
/* else, driver uses "legacy" binding model: */
|
||||
.attach_adapter = foo_attach_adapter,
|
||||
.detach_client = foo_detach_client,
|
||||
|
||||
/* these may be used regardless of the driver binding model */
|
||||
.shutdown = foo_shutdown, /* optional */
|
||||
.suspend = foo_suspend, /* optional */
|
||||
.resume = foo_resume, /* optional */
|
||||
.command = foo_command, /* optional */
|
||||
.command = foo_command, /* optional, deprecated */
|
||||
}
|
||||
|
||||
|
||||
The name field is the driver name, and must not contain spaces. It
|
||||
should match the module name (if the driver can be compiled as a module),
|
||||
although you can use MODULE_ALIAS (passing "foo" in this example) to add
|
||||
another name for the module. If the driver name doesn't match the module
|
||||
name, the module won't be automatically loaded (hotplug/coldplug).
|
||||
|
||||
All other fields are for call-back functions which will be explained
|
||||
All other fields are for call-back functions which will be explained
|
||||
below.
|
||||
|
||||
|
||||
@ -74,34 +66,13 @@ Extra client data
|
||||
=================
|
||||
|
||||
Each client structure has a special `data' field that can point to any
|
||||
structure at all. You should use this to keep device-specific data,
|
||||
especially in drivers that handle multiple I2C or SMBUS devices. You
|
||||
do not always need this, but especially for `sensors' drivers, it can
|
||||
be very useful.
|
||||
structure at all. You should use this to keep device-specific data.
|
||||
|
||||
/* store the value */
|
||||
void i2c_set_clientdata(struct i2c_client *client, void *data);
|
||||
|
||||
/* retrieve the value */
|
||||
void *i2c_get_clientdata(struct i2c_client *client);
|
||||
|
||||
An example structure is below.
|
||||
|
||||
struct foo_data {
|
||||
struct i2c_client client;
|
||||
enum chips type; /* To keep the chips type for `sensors' drivers. */
|
||||
|
||||
/* Because the i2c bus is slow, it is often useful to cache the read
|
||||
information of a chip for some time (for example, 1 or 2 seconds).
|
||||
It depends of course on the device whether this is really worthwhile
|
||||
or even sensible. */
|
||||
struct mutex update_lock; /* When we are reading lots of information,
|
||||
another process should not update the
|
||||
below information */
|
||||
char valid; /* != 0 if the following fields are valid. */
|
||||
unsigned long last_updated; /* In jiffies */
|
||||
/* Add the read information here too */
|
||||
};
|
||||
void *i2c_get_clientdata(const struct i2c_client *client);
|
||||
|
||||
|
||||
Accessing the client
|
||||
@ -109,11 +80,9 @@ Accessing the client
|
||||
|
||||
Let's say we have a valid client structure. At some time, we will need
|
||||
to gather information from the client, or write new information to the
|
||||
client. How we will export this information to user-space is less
|
||||
important at this moment (perhaps we do not need to do this at all for
|
||||
some obscure clients). But we need generic reading and writing routines.
|
||||
client.
|
||||
|
||||
I have found it useful to define foo_read and foo_write function for this.
|
||||
I have found it useful to define foo_read and foo_write functions for this.
|
||||
For some cases, it will be easier to call the i2c functions directly,
|
||||
but many chips have some kind of register-value idea that can easily
|
||||
be encapsulated.
|
||||
@ -121,33 +90,33 @@ be encapsulated.
|
||||
The below functions are simple examples, and should not be copied
|
||||
literally.
|
||||
|
||||
int foo_read_value(struct i2c_client *client, u8 reg)
|
||||
{
|
||||
if (reg < 0x10) /* byte-sized register */
|
||||
return i2c_smbus_read_byte_data(client,reg);
|
||||
else /* word-sized register */
|
||||
return i2c_smbus_read_word_data(client,reg);
|
||||
}
|
||||
int foo_read_value(struct i2c_client *client, u8 reg)
|
||||
{
|
||||
if (reg < 0x10) /* byte-sized register */
|
||||
return i2c_smbus_read_byte_data(client, reg);
|
||||
else /* word-sized register */
|
||||
return i2c_smbus_read_word_data(client, reg);
|
||||
}
|
||||
|
||||
int foo_write_value(struct i2c_client *client, u8 reg, u16 value)
|
||||
{
|
||||
if (reg == 0x10) /* Impossible to write - driver error! */ {
|
||||
return -1;
|
||||
else if (reg < 0x10) /* byte-sized register */
|
||||
return i2c_smbus_write_byte_data(client,reg,value);
|
||||
else /* word-sized register */
|
||||
return i2c_smbus_write_word_data(client,reg,value);
|
||||
}
|
||||
int foo_write_value(struct i2c_client *client, u8 reg, u16 value)
|
||||
{
|
||||
if (reg == 0x10) /* Impossible to write - driver error! */
|
||||
return -EINVAL;
|
||||
else if (reg < 0x10) /* byte-sized register */
|
||||
return i2c_smbus_write_byte_data(client, reg, value);
|
||||
else /* word-sized register */
|
||||
return i2c_smbus_write_word_data(client, reg, value);
|
||||
}
|
||||
|
||||
|
||||
Probing and attaching
|
||||
=====================
|
||||
|
||||
The Linux I2C stack was originally written to support access to hardware
|
||||
monitoring chips on PC motherboards, and thus it embeds some assumptions
|
||||
that are more appropriate to SMBus (and PCs) than to I2C. One of these
|
||||
assumptions is that most adapters and devices drivers support the SMBUS_QUICK
|
||||
protocol to probe device presence. Another is that devices and their drivers
|
||||
monitoring chips on PC motherboards, and thus used to embed some assumptions
|
||||
that were more appropriate to SMBus (and PCs) than to I2C. One of these
|
||||
assumptions was that most adapters and devices drivers support the SMBUS_QUICK
|
||||
protocol to probe device presence. Another was that devices and their drivers
|
||||
can be sufficiently configured using only such probe primitives.
|
||||
|
||||
As Linux and its I2C stack became more widely used in embedded systems
|
||||
@ -164,6 +133,9 @@ since the "legacy" model requires drivers to create "i2c_client" device
|
||||
objects after SMBus style probing, while the Linux driver model expects
|
||||
drivers to be given such device objects in their probe() routines.
|
||||
|
||||
The legacy model is deprecated now and will soon be removed, so we no
|
||||
longer document it here.
|
||||
|
||||
|
||||
Standard Driver Model Binding ("New Style")
|
||||
-------------------------------------------
|
||||
@ -193,8 +165,8 @@ matches the device's name. It is passed the entry that was matched so
|
||||
the driver knows which one in the table matched.
|
||||
|
||||
|
||||
Device Creation (Standard driver model)
|
||||
---------------------------------------
|
||||
Device Creation
|
||||
---------------
|
||||
|
||||
If you know for a fact that an I2C device is connected to a given I2C bus,
|
||||
you can instantiate that device by simply filling an i2c_board_info
|
||||
@ -221,8 +193,8 @@ in the I2C bus driver. You may want to save the returned i2c_client
|
||||
reference for later use.
|
||||
|
||||
|
||||
Device Detection (Standard driver model)
|
||||
----------------------------------------
|
||||
Device Detection
|
||||
----------------
|
||||
|
||||
Sometimes you do not know in advance which I2C devices are connected to
|
||||
a given I2C bus. This is for example the case of hardware monitoring
|
||||
@ -246,8 +218,8 @@ otherwise misdetections are likely to occur and things can get wrong
|
||||
quickly.
|
||||
|
||||
|
||||
Device Deletion (Standard driver model)
|
||||
---------------------------------------
|
||||
Device Deletion
|
||||
---------------
|
||||
|
||||
Each I2C device which has been created using i2c_new_device() or
|
||||
i2c_new_probed_device() can be unregistered by calling
|
||||
@ -256,264 +228,37 @@ called automatically before the underlying I2C bus itself is removed, as a
|
||||
device can't survive its parent in the device driver model.
|
||||
|
||||
|
||||
Legacy Driver Binding Model
|
||||
---------------------------
|
||||
Initializing the driver
|
||||
=======================
|
||||
|
||||
Most i2c devices can be present on several i2c addresses; for some this
|
||||
is determined in hardware (by soldering some chip pins to Vcc or Ground),
|
||||
for others this can be changed in software (by writing to specific client
|
||||
registers). Some devices are usually on a specific address, but not always;
|
||||
and some are even more tricky. So you will probably need to scan several
|
||||
i2c addresses for your clients, and do some sort of detection to see
|
||||
whether it is actually a device supported by your driver.
|
||||
When the kernel is booted, or when your foo driver module is inserted,
|
||||
you have to do some initializing. Fortunately, just registering the
|
||||
driver module is usually enough.
|
||||
|
||||
To give the user a maximum of possibilities, some default module parameters
|
||||
are defined to help determine what addresses are scanned. Several macros
|
||||
are defined in i2c.h to help you support them, as well as a generic
|
||||
detection algorithm.
|
||||
static int __init foo_init(void)
|
||||
{
|
||||
return i2c_add_driver(&foo_driver);
|
||||
}
|
||||
|
||||
You do not have to use this parameter interface; but don't try to use
|
||||
function i2c_probe() if you don't.
|
||||
static void __exit foo_cleanup(void)
|
||||
{
|
||||
i2c_del_driver(&foo_driver);
|
||||
}
|
||||
|
||||
/* Substitute your own name and email address */
|
||||
MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"
|
||||
MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices");
|
||||
|
||||
Probing classes (Legacy model)
|
||||
------------------------------
|
||||
/* a few non-GPL license types are also allowed */
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
All parameters are given as lists of unsigned 16-bit integers. Lists are
|
||||
terminated by I2C_CLIENT_END.
|
||||
The following lists are used internally:
|
||||
module_init(foo_init);
|
||||
module_exit(foo_cleanup);
|
||||
|
||||
normal_i2c: filled in by the module writer.
|
||||
A list of I2C addresses which should normally be examined.
|
||||
probe: insmod parameter.
|
||||
A list of pairs. The first value is a bus number (-1 for any I2C bus),
|
||||
the second is the address. These addresses are also probed, as if they
|
||||
were in the 'normal' list.
|
||||
ignore: insmod parameter.
|
||||
A list of pairs. The first value is a bus number (-1 for any I2C bus),
|
||||
the second is the I2C address. These addresses are never probed.
|
||||
This parameter overrules the 'normal_i2c' list only.
|
||||
force: insmod parameter.
|
||||
A list of pairs. The first value is a bus number (-1 for any I2C bus),
|
||||
the second is the I2C address. A device is blindly assumed to be on
|
||||
the given address, no probing is done.
|
||||
|
||||
Additionally, kind-specific force lists may optionally be defined if
|
||||
the driver supports several chip kinds. They are grouped in a
|
||||
NULL-terminated list of pointers named forces, those first element if the
|
||||
generic force list mentioned above. Each additional list correspond to an
|
||||
insmod parameter of the form force_<kind>.
|
||||
|
||||
Fortunately, as a module writer, you just have to define the `normal_i2c'
|
||||
parameter. The complete declaration could look like this:
|
||||
|
||||
/* Scan 0x4c to 0x4f */
|
||||
static const unsigned short normal_i2c[] = { 0x4c, 0x4d, 0x4e, 0x4f,
|
||||
I2C_CLIENT_END };
|
||||
|
||||
/* Magic definition of all other variables and things */
|
||||
I2C_CLIENT_INSMOD;
|
||||
/* Or, if your driver supports, say, 2 kind of devices: */
|
||||
I2C_CLIENT_INSMOD_2(foo, bar);
|
||||
|
||||
If you use the multi-kind form, an enum will be defined for you:
|
||||
enum chips { any_chip, foo, bar, ... }
|
||||
You can then (and certainly should) use it in the driver code.
|
||||
|
||||
Note that you *have* to call the defined variable `normal_i2c',
|
||||
without any prefix!
|
||||
|
||||
|
||||
Attaching to an adapter (Legacy model)
|
||||
--------------------------------------
|
||||
|
||||
Whenever a new adapter is inserted, or for all adapters if the driver is
|
||||
being registered, the callback attach_adapter() is called. Now is the
|
||||
time to determine what devices are present on the adapter, and to register
|
||||
a client for each of them.
|
||||
|
||||
The attach_adapter callback is really easy: we just call the generic
|
||||
detection function. This function will scan the bus for us, using the
|
||||
information as defined in the lists explained above. If a device is
|
||||
detected at a specific address, another callback is called.
|
||||
|
||||
int foo_attach_adapter(struct i2c_adapter *adapter)
|
||||
{
|
||||
return i2c_probe(adapter,&addr_data,&foo_detect_client);
|
||||
}
|
||||
|
||||
Remember, structure `addr_data' is defined by the macros explained above,
|
||||
so you do not have to define it yourself.
|
||||
|
||||
The i2c_probe function will call the foo_detect_client
|
||||
function only for those i2c addresses that actually have a device on
|
||||
them (unless a `force' parameter was used). In addition, addresses that
|
||||
are already in use (by some other registered client) are skipped.
|
||||
|
||||
|
||||
The detect client function (Legacy model)
|
||||
-----------------------------------------
|
||||
|
||||
The detect client function is called by i2c_probe. The `kind' parameter
|
||||
contains -1 for a probed detection, 0 for a forced detection, or a positive
|
||||
number for a forced detection with a chip type forced.
|
||||
|
||||
Returning an error different from -ENODEV in a detect function will cause
|
||||
the detection to stop: other addresses and adapters won't be scanned.
|
||||
This should only be done on fatal or internal errors, such as a memory
|
||||
shortage or i2c_attach_client failing.
|
||||
|
||||
For now, you can ignore the `flags' parameter. It is there for future use.
|
||||
|
||||
int foo_detect_client(struct i2c_adapter *adapter, int address,
|
||||
int kind)
|
||||
{
|
||||
int err = 0;
|
||||
int i;
|
||||
struct i2c_client *client;
|
||||
struct foo_data *data;
|
||||
const char *name = "";
|
||||
|
||||
/* Let's see whether this adapter can support what we need.
|
||||
Please substitute the things you need here! */
|
||||
if (!i2c_check_functionality(adapter,I2C_FUNC_SMBUS_WORD_DATA |
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE))
|
||||
goto ERROR0;
|
||||
|
||||
/* OK. For now, we presume we have a valid client. We now create the
|
||||
client structure, even though we cannot fill it completely yet.
|
||||
But it allows us to access several i2c functions safely */
|
||||
|
||||
if (!(data = kzalloc(sizeof(struct foo_data), GFP_KERNEL))) {
|
||||
err = -ENOMEM;
|
||||
goto ERROR0;
|
||||
}
|
||||
|
||||
client = &data->client;
|
||||
i2c_set_clientdata(client, data);
|
||||
|
||||
client->addr = address;
|
||||
client->adapter = adapter;
|
||||
client->driver = &foo_driver;
|
||||
|
||||
/* Now, we do the remaining detection. If no `force' parameter is used. */
|
||||
|
||||
/* First, the generic detection (if any), that is skipped if any force
|
||||
parameter was used. */
|
||||
if (kind < 0) {
|
||||
/* The below is of course bogus */
|
||||
if (foo_read(client, FOO_REG_GENERIC) != FOO_GENERIC_VALUE)
|
||||
goto ERROR1;
|
||||
}
|
||||
|
||||
/* Next, specific detection. This is especially important for `sensors'
|
||||
devices. */
|
||||
|
||||
/* Determine the chip type. Not needed if a `force_CHIPTYPE' parameter
|
||||
was used. */
|
||||
if (kind <= 0) {
|
||||
i = foo_read(client, FOO_REG_CHIPTYPE);
|
||||
if (i == FOO_TYPE_1)
|
||||
kind = chip1; /* As defined in the enum */
|
||||
else if (i == FOO_TYPE_2)
|
||||
kind = chip2;
|
||||
else {
|
||||
printk("foo: Ignoring 'force' parameter for unknown chip at "
|
||||
"adapter %d, address 0x%02x\n",i2c_adapter_id(adapter),address);
|
||||
goto ERROR1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Now set the type and chip names */
|
||||
if (kind == chip1) {
|
||||
name = "chip1";
|
||||
} else if (kind == chip2) {
|
||||
name = "chip2";
|
||||
}
|
||||
|
||||
/* Fill in the remaining client fields. */
|
||||
strlcpy(client->name, name, I2C_NAME_SIZE);
|
||||
data->type = kind;
|
||||
mutex_init(&data->update_lock); /* Only if you use this field */
|
||||
|
||||
/* Any other initializations in data must be done here too. */
|
||||
|
||||
/* This function can write default values to the client registers, if
|
||||
needed. */
|
||||
foo_init_client(client);
|
||||
|
||||
/* Tell the i2c layer a new client has arrived */
|
||||
if ((err = i2c_attach_client(client)))
|
||||
goto ERROR1;
|
||||
|
||||
return 0;
|
||||
|
||||
/* OK, this is not exactly good programming practice, usually. But it is
|
||||
very code-efficient in this case. */
|
||||
|
||||
ERROR1:
|
||||
kfree(data);
|
||||
ERROR0:
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
Removing the client (Legacy model)
|
||||
==================================
|
||||
|
||||
The detach_client call back function is called when a client should be
|
||||
removed. It may actually fail, but only when panicking. This code is
|
||||
much simpler than the attachment code, fortunately!
|
||||
|
||||
int foo_detach_client(struct i2c_client *client)
|
||||
{
|
||||
int err;
|
||||
|
||||
/* Try to detach the client from i2c space */
|
||||
if ((err = i2c_detach_client(client)))
|
||||
return err;
|
||||
|
||||
kfree(i2c_get_clientdata(client));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Initializing the module or kernel
|
||||
=================================
|
||||
|
||||
When the kernel is booted, or when your foo driver module is inserted,
|
||||
you have to do some initializing. Fortunately, just attaching (registering)
|
||||
the driver module is usually enough.
|
||||
|
||||
static int __init foo_init(void)
|
||||
{
|
||||
int res;
|
||||
|
||||
if ((res = i2c_add_driver(&foo_driver))) {
|
||||
printk("foo: Driver registration failed, module not inserted.\n");
|
||||
return res;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit foo_cleanup(void)
|
||||
{
|
||||
i2c_del_driver(&foo_driver);
|
||||
}
|
||||
|
||||
/* Substitute your own name and email address */
|
||||
MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"
|
||||
MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices");
|
||||
|
||||
/* a few non-GPL license types are also allowed */
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
module_init(foo_init);
|
||||
module_exit(foo_cleanup);
|
||||
|
||||
Note that some functions are marked by `__init', and some data structures
|
||||
by `__initdata'. These functions and structures can be removed after
|
||||
kernel booting (or module loading) is completed.
|
||||
Note that some functions are marked by `__init'. These functions can
|
||||
be removed after kernel booting (or module loading) is completed.
|
||||
Likewise, functions marked by `__exit' are dropped by the compiler when
|
||||
the code is built into the kernel, as they would never be called.
|
||||
|
||||
|
||||
Power Management
|
||||
@ -548,33 +293,35 @@ Command function
|
||||
|
||||
A generic ioctl-like function call back is supported. You will seldom
|
||||
need this, and its use is deprecated anyway, so newer design should not
|
||||
use it. Set it to NULL.
|
||||
use it.
|
||||
|
||||
|
||||
Sending and receiving
|
||||
=====================
|
||||
|
||||
If you want to communicate with your device, there are several functions
|
||||
to do this. You can find all of them in i2c.h.
|
||||
to do this. You can find all of them in <linux/i2c.h>.
|
||||
|
||||
If you can choose between plain i2c communication and SMBus level
|
||||
communication, please use the last. All adapters understand SMBus level
|
||||
commands, but only some of them understand plain i2c!
|
||||
If you can choose between plain I2C communication and SMBus level
|
||||
communication, please use the latter. All adapters understand SMBus level
|
||||
commands, but only some of them understand plain I2C!
|
||||
|
||||
|
||||
Plain i2c communication
|
||||
Plain I2C communication
|
||||
-----------------------
|
||||
|
||||
extern int i2c_master_send(struct i2c_client *,const char* ,int);
|
||||
extern int i2c_master_recv(struct i2c_client *,char* ,int);
|
||||
int i2c_master_send(struct i2c_client *client, const char *buf,
|
||||
int count);
|
||||
int i2c_master_recv(struct i2c_client *client, char *buf, int count);
|
||||
|
||||
These routines read and write some bytes from/to a client. The client
|
||||
contains the i2c address, so you do not have to include it. The second
|
||||
parameter contains the bytes the read/write, the third the length of the
|
||||
buffer. Returned is the actual number of bytes read/written.
|
||||
|
||||
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,
|
||||
int num);
|
||||
parameter contains the bytes to read/write, the third the number of bytes
|
||||
to read/write (must be less than the length of the buffer.) Returned is
|
||||
the actual number of bytes read/written.
|
||||
|
||||
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,
|
||||
int num);
|
||||
|
||||
This sends a series of messages. Each message can be a read or write,
|
||||
and they can be mixed in any way. The transactions are combined: no
|
||||
@ -583,49 +330,45 @@ for each message the client address, the number of bytes of the message
|
||||
and the message data itself.
|
||||
|
||||
You can read the file `i2c-protocol' for more information about the
|
||||
actual i2c protocol.
|
||||
actual I2C protocol.
|
||||
|
||||
|
||||
SMBus communication
|
||||
-------------------
|
||||
|
||||
extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr,
|
||||
unsigned short flags,
|
||||
char read_write, u8 command, int size,
|
||||
union i2c_smbus_data * data);
|
||||
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
|
||||
unsigned short flags, char read_write, u8 command,
|
||||
int size, union i2c_smbus_data *data);
|
||||
|
||||
This is the generic SMBus function. All functions below are implemented
|
||||
in terms of it. Never use this function directly!
|
||||
This is the generic SMBus function. All functions below are implemented
|
||||
in terms of it. Never use this function directly!
|
||||
|
||||
|
||||
extern s32 i2c_smbus_read_byte(struct i2c_client * client);
|
||||
extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
|
||||
extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
|
||||
extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
|
||||
u8 command, u8 value);
|
||||
extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
|
||||
extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
|
||||
u8 command, u16 value);
|
||||
extern s32 i2c_smbus_process_call(struct i2c_client *client,
|
||||
u8 command, u16 value);
|
||||
extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
|
||||
u8 command, u8 *values);
|
||||
extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
|
||||
u8 command, u8 length,
|
||||
u8 *values);
|
||||
extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
|
||||
u8 command, u8 length, u8 *values);
|
||||
extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
|
||||
u8 command, u8 length,
|
||||
u8 *values);
|
||||
s32 i2c_smbus_read_byte(struct i2c_client *client);
|
||||
s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
|
||||
s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
|
||||
s32 i2c_smbus_write_byte_data(struct i2c_client *client,
|
||||
u8 command, u8 value);
|
||||
s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
|
||||
s32 i2c_smbus_write_word_data(struct i2c_client *client,
|
||||
u8 command, u16 value);
|
||||
s32 i2c_smbus_process_call(struct i2c_client *client,
|
||||
u8 command, u16 value);
|
||||
s32 i2c_smbus_read_block_data(struct i2c_client *client,
|
||||
u8 command, u8 *values);
|
||||
s32 i2c_smbus_write_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length, const u8 *values);
|
||||
s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length, u8 *values);
|
||||
s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length,
|
||||
const u8 *values);
|
||||
|
||||
These ones were removed from i2c-core because they had no users, but could
|
||||
be added back later if needed:
|
||||
|
||||
extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
|
||||
extern s32 i2c_smbus_block_process_call(struct i2c_client *client,
|
||||
u8 command, u8 length,
|
||||
u8 *values)
|
||||
s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value);
|
||||
s32 i2c_smbus_block_process_call(struct i2c_client *client,
|
||||
u8 command, u8 length, u8 *values);
|
||||
|
||||
All these transactions return a negative errno value on failure. The 'write'
|
||||
transactions return 0 on success; the 'read' transactions return the read
|
||||
@ -642,7 +385,5 @@ General purpose routines
|
||||
Below all general purpose routines are listed, that were not mentioned
|
||||
before.
|
||||
|
||||
/* This call returns a unique low identifier for each registered adapter.
|
||||
*/
|
||||
extern int i2c_adapter_id(struct i2c_adapter *adap);
|
||||
|
||||
/* Return the adapter number for a specific adapter */
|
||||
int i2c_adapter_id(struct i2c_adapter *adap);
|
||||
|
||||
@ -135,7 +135,7 @@ static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) {
|
||||
*status = get_pcf(adap, 1);
|
||||
#ifndef STUB_I2C
|
||||
while (timeout-- && (*status & I2C_PCF_PIN)) {
|
||||
adap->waitforpin();
|
||||
adap->waitforpin(adap->data);
|
||||
*status = get_pcf(adap, 1);
|
||||
}
|
||||
if (*status & I2C_PCF_LAB) {
|
||||
@ -208,7 +208,7 @@ static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
printk(KERN_DEBUG "i2c-algo-pcf.o: deteted and initialized PCF8584.\n");
|
||||
printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -331,13 +331,16 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
|
||||
int i;
|
||||
int ret=0, timeout, status;
|
||||
|
||||
if (adap->xfer_begin)
|
||||
adap->xfer_begin(adap->data);
|
||||
|
||||
/* Check for bus busy */
|
||||
timeout = wait_for_bb(adap);
|
||||
if (timeout) {
|
||||
DEB2(printk(KERN_ERR "i2c-algo-pcf.o: "
|
||||
"Timeout waiting for BB in pcf_xfer\n");)
|
||||
return -EIO;
|
||||
i = -EIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
for (i = 0;ret >= 0 && i < num; i++) {
|
||||
@ -359,12 +362,14 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
|
||||
if (timeout) {
|
||||
if (timeout == -EINTR) {
|
||||
/* arbitration lost */
|
||||
return (-EINTR);
|
||||
i = -EINTR;
|
||||
goto out;
|
||||
}
|
||||
i2c_stop(adap);
|
||||
DEB2(printk(KERN_ERR "i2c-algo-pcf.o: Timeout waiting "
|
||||
"for PIN(1) in pcf_xfer\n");)
|
||||
return (-EREMOTEIO);
|
||||
i = -EREMOTEIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
#ifndef STUB_I2C
|
||||
@ -372,7 +377,8 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
|
||||
if (status & I2C_PCF_LRB) {
|
||||
i2c_stop(adap);
|
||||
DEB2(printk(KERN_ERR "i2c-algo-pcf.o: No LRB(1) in pcf_xfer\n");)
|
||||
return (-EREMOTEIO);
|
||||
i = -EREMOTEIO;
|
||||
goto out;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -404,6 +410,9 @@ static int pcf_xfer(struct i2c_adapter *i2c_adap,
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
if (adap->xfer_end)
|
||||
adap->xfer_end(adap->data);
|
||||
return (i);
|
||||
}
|
||||
|
||||
|
||||
@ -97,6 +97,7 @@ config I2C_I801
|
||||
ICH9
|
||||
Tolapai
|
||||
ICH10
|
||||
PCH
|
||||
|
||||
This driver can also be built as a module. If so, the module
|
||||
will be called i2c-i801.
|
||||
|
||||
@ -104,7 +104,8 @@ static int pcf_isa_getclock(void *data)
|
||||
return (clock);
|
||||
}
|
||||
|
||||
static void pcf_isa_waitforpin(void) {
|
||||
static void pcf_isa_waitforpin(void *data)
|
||||
{
|
||||
DEFINE_WAIT(wait);
|
||||
int timeout = 2;
|
||||
unsigned long flags;
|
||||
|
||||
@ -123,7 +123,7 @@ static int __devinit hydra_probe(struct pci_dev *dev,
|
||||
hydra_adap.name))
|
||||
return -EBUSY;
|
||||
|
||||
hydra_bit_data.data = ioremap(base, pci_resource_len(dev, 0));
|
||||
hydra_bit_data.data = pci_ioremap_bar(dev, 0);
|
||||
if (hydra_bit_data.data == NULL) {
|
||||
release_mem_region(base+offsetof(struct Hydra, CachePD), 4);
|
||||
return -ENODEV;
|
||||
|
||||
@ -41,6 +41,7 @@
|
||||
Tolapai 0x5032 32 hard yes yes yes
|
||||
ICH10 0x3a30 32 hard yes yes yes
|
||||
ICH10 0x3a60 32 hard yes yes yes
|
||||
PCH 0x3b30 32 hard yes yes yes
|
||||
|
||||
Features supported by this driver:
|
||||
Software PEC no
|
||||
@ -576,6 +577,7 @@ static struct pci_device_id i801_ids[] = {
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TOLAPAI_1) },
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_4) },
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_5) },
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PCH_SMBUS) },
|
||||
{ 0, }
|
||||
};
|
||||
|
||||
@ -599,6 +601,7 @@ static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id
|
||||
case PCI_DEVICE_ID_INTEL_TOLAPAI_1:
|
||||
case PCI_DEVICE_ID_INTEL_ICH10_4:
|
||||
case PCI_DEVICE_ID_INTEL_ICH10_5:
|
||||
case PCI_DEVICE_ID_INTEL_PCH_SMBUS:
|
||||
i801_features |= FEATURE_I2C_BLOCK_READ;
|
||||
/* fall through */
|
||||
case PCI_DEVICE_ID_INTEL_82801DB_3:
|
||||
|
||||
@ -1,6 +1,8 @@
|
||||
#
|
||||
# Miscellaneous I2C chip drivers configuration
|
||||
#
|
||||
# *** DEPRECATED! Do not add new entries! See Makefile ***
|
||||
#
|
||||
|
||||
menu "Miscellaneous I2C Chip support"
|
||||
|
||||
|
||||
@ -1,7 +1,8 @@
|
||||
#
|
||||
# Makefile for miscellaneous I2C chip drivers.
|
||||
#
|
||||
# Think twice before you add a new driver to this directory.
|
||||
# Do not add new drivers to this directory! It is DEPRECATED.
|
||||
#
|
||||
# Device drivers are better grouped according to the functionality they
|
||||
# implement rather than to the bus they are connected to. In particular:
|
||||
# * Hardware monitoring chip drivers go to drivers/hwmon
|
||||
|
||||
@ -266,6 +266,9 @@ i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
|
||||
|
||||
client->dev.platform_data = info->platform_data;
|
||||
|
||||
if (info->archdata)
|
||||
client->dev.archdata = *info->archdata;
|
||||
|
||||
client->flags = info->flags;
|
||||
client->addr = info->addr;
|
||||
client->irq = info->irq;
|
||||
|
||||
@ -450,7 +450,7 @@ static inline void set_dev_node(struct device *dev, int node)
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline void *dev_get_drvdata(struct device *dev)
|
||||
static inline void *dev_get_drvdata(const struct device *dev)
|
||||
{
|
||||
return dev->driver_data;
|
||||
}
|
||||
|
||||
@ -31,7 +31,10 @@ struct i2c_algo_pcf_data {
|
||||
int (*getpcf) (void *data, int ctl);
|
||||
int (*getown) (void *data);
|
||||
int (*getclock) (void *data);
|
||||
void (*waitforpin) (void);
|
||||
void (*waitforpin) (void *data);
|
||||
|
||||
void (*xfer_begin) (void *data);
|
||||
void (*xfer_end) (void *data);
|
||||
|
||||
/* Multi-master lost arbitration back-off delay (msecs)
|
||||
* This should be set by the bus adapter or knowledgable client
|
||||
|
||||
@ -53,45 +53,44 @@ struct i2c_board_info;
|
||||
* transmit one message at a time, a more complex version can be used to
|
||||
* transmit an arbitrary number of messages without interruption.
|
||||
*/
|
||||
extern int i2c_master_send(struct i2c_client *,const char* ,int);
|
||||
extern int i2c_master_recv(struct i2c_client *,char* ,int);
|
||||
extern int i2c_master_send(struct i2c_client *client, const char *buf,
|
||||
int count);
|
||||
extern int i2c_master_recv(struct i2c_client *client, char *buf, int count);
|
||||
|
||||
/* Transfer num messages.
|
||||
*/
|
||||
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
|
||||
|
||||
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
|
||||
int num);
|
||||
|
||||
/* This is the very generalized SMBus access routine. You probably do not
|
||||
want to use this, though; one of the functions below may be much easier,
|
||||
and probably just as fast.
|
||||
Note that we use i2c_adapter here, because you do not need a specific
|
||||
smbus adapter to call this function. */
|
||||
extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr,
|
||||
unsigned short flags,
|
||||
char read_write, u8 command, int size,
|
||||
union i2c_smbus_data * data);
|
||||
extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
|
||||
unsigned short flags, char read_write, u8 command,
|
||||
int size, union i2c_smbus_data *data);
|
||||
|
||||
/* Now follow the 'nice' access routines. These also document the calling
|
||||
conventions of i2c_smbus_xfer. */
|
||||
|
||||
extern s32 i2c_smbus_read_byte(struct i2c_client * client);
|
||||
extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
|
||||
extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
|
||||
extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
|
||||
u8 command, u8 value);
|
||||
extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
|
||||
extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
|
||||
u8 command, u16 value);
|
||||
extern s32 i2c_smbus_read_byte(struct i2c_client *client);
|
||||
extern s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
|
||||
extern s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
|
||||
extern s32 i2c_smbus_write_byte_data(struct i2c_client *client,
|
||||
u8 command, u8 value);
|
||||
extern s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
|
||||
extern s32 i2c_smbus_write_word_data(struct i2c_client *client,
|
||||
u8 command, u16 value);
|
||||
/* Returns the number of read bytes */
|
||||
extern s32 i2c_smbus_read_block_data(struct i2c_client *client,
|
||||
u8 command, u8 *values);
|
||||
extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
|
||||
u8 command, u8 length,
|
||||
const u8 *values);
|
||||
extern s32 i2c_smbus_write_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length, const u8 *values);
|
||||
/* Returns the number of read bytes */
|
||||
extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
|
||||
extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length, u8 *values);
|
||||
extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
|
||||
extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
|
||||
u8 command, u8 length,
|
||||
const u8 *values);
|
||||
|
||||
@ -169,7 +168,7 @@ struct i2c_driver {
|
||||
/* a ioctl like command that can be used to perform specific functions
|
||||
* with the device.
|
||||
*/
|
||||
int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
|
||||
int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
|
||||
|
||||
struct device_driver driver;
|
||||
const struct i2c_device_id *id_table;
|
||||
@ -224,14 +223,14 @@ static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
|
||||
return to_i2c_client(dev);
|
||||
}
|
||||
|
||||
static inline void *i2c_get_clientdata (struct i2c_client *dev)
|
||||
static inline void *i2c_get_clientdata(const struct i2c_client *dev)
|
||||
{
|
||||
return dev_get_drvdata (&dev->dev);
|
||||
return dev_get_drvdata(&dev->dev);
|
||||
}
|
||||
|
||||
static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
|
||||
static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
|
||||
{
|
||||
dev_set_drvdata (&dev->dev, data);
|
||||
dev_set_drvdata(&dev->dev, data);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -240,6 +239,7 @@ static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
|
||||
* @flags: to initialize i2c_client.flags
|
||||
* @addr: stored in i2c_client.addr
|
||||
* @platform_data: stored in i2c_client.dev.platform_data
|
||||
* @archdata: copied into i2c_client.dev.archdata
|
||||
* @irq: stored in i2c_client.irq
|
||||
*
|
||||
* I2C doesn't actually support hardware probing, although controllers and
|
||||
@ -259,6 +259,7 @@ struct i2c_board_info {
|
||||
unsigned short flags;
|
||||
unsigned short addr;
|
||||
void *platform_data;
|
||||
struct dev_archdata *archdata;
|
||||
int irq;
|
||||
};
|
||||
|
||||
@ -272,7 +273,7 @@ struct i2c_board_info {
|
||||
* fields (such as associated irq, or device-specific platform_data)
|
||||
* are provided using conventional syntax.
|
||||
*/
|
||||
#define I2C_BOARD_INFO(dev_type,dev_addr) \
|
||||
#define I2C_BOARD_INFO(dev_type, dev_addr) \
|
||||
.type = (dev_type), .addr = (dev_addr)
|
||||
|
||||
|
||||
@ -306,10 +307,12 @@ extern void i2c_unregister_device(struct i2c_client *);
|
||||
*/
|
||||
#ifdef CONFIG_I2C_BOARDINFO
|
||||
extern int
|
||||
i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned n);
|
||||
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
|
||||
unsigned n);
|
||||
#else
|
||||
static inline int
|
||||
i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned n)
|
||||
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
|
||||
unsigned n)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -328,11 +331,11 @@ struct i2c_algorithm {
|
||||
using common I2C messages */
|
||||
/* master_xfer should return the number of messages successfully
|
||||
processed, or a negative value on error */
|
||||
int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,
|
||||
int num);
|
||||
int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
|
||||
int num);
|
||||
int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
|
||||
unsigned short flags, char read_write,
|
||||
u8 command, int size, union i2c_smbus_data * data);
|
||||
unsigned short flags, char read_write,
|
||||
u8 command, int size, union i2c_smbus_data *data);
|
||||
|
||||
/* To determine what the adapter supports */
|
||||
u32 (*functionality) (struct i2c_adapter *);
|
||||
@ -345,7 +348,7 @@ struct i2c_algorithm {
|
||||
struct i2c_adapter {
|
||||
struct module *owner;
|
||||
unsigned int id;
|
||||
unsigned int class;
|
||||
unsigned int class; /* classes to allow probing for */
|
||||
const struct i2c_algorithm *algo; /* the algorithm to access the bus */
|
||||
void *algo_data;
|
||||
|
||||
@ -369,14 +372,14 @@ struct i2c_adapter {
|
||||
};
|
||||
#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
|
||||
|
||||
static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
|
||||
static inline void *i2c_get_adapdata(const struct i2c_adapter *dev)
|
||||
{
|
||||
return dev_get_drvdata (&dev->dev);
|
||||
return dev_get_drvdata(&dev->dev);
|
||||
}
|
||||
|
||||
static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
|
||||
static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
|
||||
{
|
||||
dev_set_drvdata (&dev->dev, data);
|
||||
dev_set_drvdata(&dev->dev, data);
|
||||
}
|
||||
|
||||
/*flags for the client struct: */
|
||||
@ -449,7 +452,7 @@ extern int i2c_probe(struct i2c_adapter *adapter,
|
||||
const struct i2c_client_address_data *address_data,
|
||||
int (*found_proc) (struct i2c_adapter *, int, int));
|
||||
|
||||
extern struct i2c_adapter* i2c_get_adapter(int id);
|
||||
extern struct i2c_adapter *i2c_get_adapter(int id);
|
||||
extern void i2c_put_adapter(struct i2c_adapter *adap);
|
||||
|
||||
|
||||
@ -465,7 +468,7 @@ static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
|
||||
return (func & i2c_get_functionality(adap)) == func;
|
||||
}
|
||||
|
||||
/* Return id number for a specific adapter */
|
||||
/* Return the adapter number for a specific adapter */
|
||||
static inline int i2c_adapter_id(struct i2c_adapter *adap)
|
||||
{
|
||||
return adap->nr;
|
||||
@ -526,7 +529,7 @@ struct i2c_msg {
|
||||
|
||||
#define I2C_FUNC_I2C 0x00000001
|
||||
#define I2C_FUNC_10BIT_ADDR 0x00000002
|
||||
#define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
|
||||
#define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_NOSTART etc. */
|
||||
#define I2C_FUNC_SMBUS_PEC 0x00000008
|
||||
#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */
|
||||
#define I2C_FUNC_SMBUS_QUICK 0x00010000
|
||||
@ -541,30 +544,26 @@ struct i2c_msg {
|
||||
#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
|
||||
#define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */
|
||||
#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */
|
||||
#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 0x10000000 /* I2C-like block xfer */
|
||||
#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
|
||||
|
||||
#define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE)
|
||||
#define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
|
||||
#define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_WORD_DATA)
|
||||
#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
|
||||
#define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
|
||||
I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
|
||||
#define I2C_FUNC_SMBUS_I2C_BLOCK_2 (I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
|
||||
I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2)
|
||||
#define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE)
|
||||
#define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
|
||||
#define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_WORD_DATA)
|
||||
#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
|
||||
I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
|
||||
#define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
|
||||
I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
|
||||
|
||||
#define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
|
||||
I2C_FUNC_SMBUS_BYTE | \
|
||||
I2C_FUNC_SMBUS_BYTE_DATA | \
|
||||
I2C_FUNC_SMBUS_WORD_DATA | \
|
||||
I2C_FUNC_SMBUS_PROC_CALL | \
|
||||
I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
|
||||
I2C_FUNC_SMBUS_I2C_BLOCK | \
|
||||
I2C_FUNC_SMBUS_PEC)
|
||||
#define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \
|
||||
I2C_FUNC_SMBUS_BYTE | \
|
||||
I2C_FUNC_SMBUS_BYTE_DATA | \
|
||||
I2C_FUNC_SMBUS_WORD_DATA | \
|
||||
I2C_FUNC_SMBUS_PROC_CALL | \
|
||||
I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
|
||||
I2C_FUNC_SMBUS_I2C_BLOCK | \
|
||||
I2C_FUNC_SMBUS_PEC)
|
||||
|
||||
/*
|
||||
* Data for SMBus Messages
|
||||
@ -574,7 +573,7 @@ union i2c_smbus_data {
|
||||
__u8 byte;
|
||||
__u16 word;
|
||||
__u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
|
||||
/* and one more for user-space compatibility */
|
||||
/* and one more for user-space compatibility */
|
||||
};
|
||||
|
||||
/* i2c_smbus_xfer read or write markers */
|
||||
@ -602,21 +601,21 @@ union i2c_smbus_data {
|
||||
|
||||
/* Default fill of many variables */
|
||||
#define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
|
||||
I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
|
||||
|
||||
/* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
|
||||
module header */
|
||||
@ -625,7 +624,7 @@ union i2c_smbus_data {
|
||||
static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
|
||||
static unsigned int var##_num; \
|
||||
module_param_array(var, short, &var##_num, 0); \
|
||||
MODULE_PARM_DESC(var,desc)
|
||||
MODULE_PARM_DESC(var, desc)
|
||||
|
||||
#define I2C_CLIENT_MODULE_PARM_FORCE(name) \
|
||||
I2C_CLIENT_MODULE_PARM(force_##name, \
|
||||
|
||||
Loading…
Reference in New Issue
Block a user