609 lines
23 KiB
Text
609 lines
23 KiB
Text
This is a small guide for those who want to write kernel drivers for I2C
|
|
or SMBus devices, using Linux as the protocol host/master (not slave).
|
|
|
|
To set up a driver, you need to do several things. Some are optional, and
|
|
some things can be done slightly or completely different. Use this as a
|
|
guide, not as a rule book!
|
|
|
|
|
|
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
|
|
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.
|
|
|
|
|
|
The driver structure
|
|
====================
|
|
|
|
Usually, you will implement a single driver structure, and instantiate
|
|
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.
|
|
|
|
static struct i2c_driver foo_driver = {
|
|
.driver = {
|
|
.name = "foo",
|
|
},
|
|
|
|
/* iff driver uses driver model ("new style") binding model: */
|
|
.probe = foo_probe,
|
|
.remove = foo_remove,
|
|
|
|
/* 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 */
|
|
}
|
|
|
|
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
|
|
below.
|
|
|
|
|
|
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.
|
|
|
|
/* 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 */
|
|
};
|
|
|
|
|
|
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.
|
|
|
|
I have found it useful to define foo_read and foo_write function 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.
|
|
|
|
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_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);
|
|
}
|
|
|
|
|
|
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
|
|
can be sufficiently configured using only such probe primitives.
|
|
|
|
As Linux and its I2C stack became more widely used in embedded systems
|
|
and complex components such as DVB adapters, those assumptions became more
|
|
problematic. Drivers for I2C devices that issue interrupts need more (and
|
|
different) configuration information, as do drivers handling chip variants
|
|
that can't be distinguished by protocol probing, or which need some board
|
|
specific information to operate correctly.
|
|
|
|
Accordingly, the I2C stack now has two models for associating I2C devices
|
|
with their drivers: the original "legacy" model, and a newer one that's
|
|
fully compatible with the Linux 2.6 driver model. These models do not mix,
|
|
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.
|
|
|
|
|
|
Standard Driver Model Binding ("New Style")
|
|
-------------------------------------------
|
|
|
|
System infrastructure, typically board-specific initialization code or
|
|
boot firmware, reports what I2C devices exist. For example, there may be
|
|
a table, in the kernel or from the boot loader, identifying I2C devices
|
|
and linking them to board-specific configuration information about IRQs
|
|
and other wiring artifacts, chip type, and so on. That could be used to
|
|
create i2c_client objects for each I2C device.
|
|
|
|
I2C device drivers using this binding model work just like any other
|
|
kind of driver in Linux: they provide a probe() method to bind to
|
|
those devices, and a remove() method to unbind.
|
|
|
|
static int foo_probe(struct i2c_client *client);
|
|
static int foo_remove(struct i2c_client *client);
|
|
|
|
Remember that the i2c_driver does not create those client handles. The
|
|
handle may be used during foo_probe(). If foo_probe() reports success
|
|
(zero not a negative status code) it may save the handle and use it until
|
|
foo_remove() returns. That binding model is used by most Linux drivers.
|
|
|
|
Drivers match devices when i2c_client.driver_name and the driver name are
|
|
the same; this approach is used in several other busses that don't have
|
|
device typing support in the hardware. The driver and module name should
|
|
match, so hotplug/coldplug mechanisms will modprobe the driver.
|
|
|
|
|
|
Device Creation (Standard driver model)
|
|
---------------------------------------
|
|
|
|
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
|
|
structure with the device address and driver name, and calling
|
|
i2c_new_device(). This will create the device, then the driver core will
|
|
take care of finding the right driver and will call its probe() method.
|
|
If a driver supports different device types, you can specify the type you
|
|
want using the type field. You can also specify an IRQ and platform data
|
|
if needed.
|
|
|
|
Sometimes you know that a device is connected to a given I2C bus, but you
|
|
don't know the exact address it uses. This happens on TV adapters for
|
|
example, where the same driver supports dozens of slightly different
|
|
models, and I2C device addresses change from one model to the next. In
|
|
that case, you can use the i2c_new_probed_device() variant, which is
|
|
similar to i2c_new_device(), except that it takes an additional list of
|
|
possible I2C addresses to probe. A device is created for the first
|
|
responsive address in the list. If you expect more than one device to be
|
|
present in the address range, simply call i2c_new_probed_device() that
|
|
many times.
|
|
|
|
The call to i2c_new_device() or i2c_new_probed_device() typically happens
|
|
in the I2C bus driver. You may want to save the returned i2c_client
|
|
reference for later use.
|
|
|
|
|
|
Device Deletion (Standard driver model)
|
|
---------------------------------------
|
|
|
|
Each I2C device which has been created using i2c_new_device() or
|
|
i2c_new_probed_device() can be unregistered by calling
|
|
i2c_unregister_device(). If you don't call it explicitly, it will be
|
|
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
|
|
---------------------------
|
|
|
|
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.
|
|
|
|
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.
|
|
|
|
You do not have to use this parameter interface; but don't try to use
|
|
function i2c_probe() if you don't.
|
|
|
|
|
|
Probing classes (Legacy model)
|
|
------------------------------
|
|
|
|
All parameters are given as lists of unsigned 16-bit integers. Lists are
|
|
terminated by I2C_CLIENT_END.
|
|
The following lists are used internally:
|
|
|
|
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.
|
|
|
|
|
|
Power Management
|
|
================
|
|
|
|
If your I2C device needs special handling when entering a system low
|
|
power state -- like putting a transceiver into a low power mode, or
|
|
activating a system wakeup mechanism -- do that in the suspend() method.
|
|
The resume() method should reverse what the suspend() method does.
|
|
|
|
These are standard driver model calls, and they work just like they
|
|
would for any other driver stack. The calls can sleep, and can use
|
|
I2C messaging to the device being suspended or resumed (since their
|
|
parent I2C adapter is active when these calls are issued, and IRQs
|
|
are still enabled).
|
|
|
|
|
|
System Shutdown
|
|
===============
|
|
|
|
If your I2C device needs special handling when the system shuts down
|
|
or reboots (including kexec) -- like turning something off -- use a
|
|
shutdown() method.
|
|
|
|
Again, this is a standard driver model call, working just like it
|
|
would for any other driver stack: the calls can sleep, and can use
|
|
I2C messaging.
|
|
|
|
|
|
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.
|
|
|
|
|
|
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.
|
|
|
|
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!
|
|
|
|
|
|
Plain i2c communication
|
|
-----------------------
|
|
|
|
extern int i2c_master_send(struct i2c_client *,const char* ,int);
|
|
extern int i2c_master_recv(struct i2c_client *,char* ,int);
|
|
|
|
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);
|
|
|
|
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
|
|
stop bit is sent between transaction. The i2c_msg structure contains
|
|
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.
|
|
|
|
|
|
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);
|
|
|
|
This is the generic SMBus function. All functions below are implemented
|
|
in terms of it. Never use this function directly!
|
|
|
|
|
|
extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 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);
|
|
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);
|
|
|
|
These ones were removed in Linux 2.6.10 because they had no users, but could
|
|
be added back later if needed:
|
|
|
|
extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
|
|
u8 command, u8 *values);
|
|
extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
|
|
u8 command, u8 length,
|
|
u8 *values);
|
|
extern s32 i2c_smbus_process_call(struct i2c_client * client,
|
|
u8 command, u16 value);
|
|
extern s32 i2c_smbus_block_process_call(struct i2c_client *client,
|
|
u8 command, u8 length,
|
|
u8 *values)
|
|
|
|
All these transactions return -1 on failure. The 'write' transactions
|
|
return 0 on success; the 'read' transactions return the read value, except
|
|
for read_block, which returns the number of values read. The block buffers
|
|
need not be longer than 32 bytes.
|
|
|
|
You can read the file `smbus-protocol' for more information about the
|
|
actual SMBus protocol.
|
|
|
|
|
|
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);
|
|
|