forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
428 lines
15 KiB
428 lines
15 KiB
=============================== |
|
Implementing I2C device drivers |
|
=============================== |
|
|
|
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. |
|
|
|
|
|
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_device_id foo_idtable[] = { |
|
{ "foo", my_id_for_foo }, |
|
{ "bar", my_id_for_bar }, |
|
{ } |
|
}; |
|
|
|
MODULE_DEVICE_TABLE(i2c, foo_idtable); |
|
|
|
static struct i2c_driver foo_driver = { |
|
.driver = { |
|
.name = "foo", |
|
.pm = &foo_pm_ops, /* optional */ |
|
}, |
|
|
|
.id_table = foo_idtable, |
|
.probe_new = foo_probe, |
|
.remove = foo_remove, |
|
/* if device autodetection is needed: */ |
|
.class = I2C_CLASS_SOMETHING, |
|
.detect = foo_detect, |
|
.address_list = normal_i2c, |
|
|
|
.shutdown = foo_shutdown, /* 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 |
|
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. |
|
|
|
:: |
|
|
|
/* store the value */ |
|
void i2c_set_clientdata(struct i2c_client *client, void *data); |
|
|
|
/* retrieve the value */ |
|
void *i2c_get_clientdata(const struct i2c_client *client); |
|
|
|
Note that starting with kernel 2.6.34, you don't have to set the ``data`` field |
|
to NULL in remove() or if probe() failed anymore. The i2c-core does this |
|
automatically on these occasions. Those are also the only times the core will |
|
touch this field. |
|
|
|
|
|
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. |
|
|
|
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. |
|
|
|
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 -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 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 |
|
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. |
|
|
|
|
|
Device/Driver Binding |
|
--------------------- |
|
|
|
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. |
|
|
|
The probe function is called when an entry in the id_table name field |
|
matches the device's name. If the probe function needs that entry, it |
|
can retrieve it using |
|
|
|
:: |
|
|
|
const struct i2c_device_id *id = i2c_match_id(foo_idtable, client); |
|
|
|
|
|
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 |
|
structure with the device address and driver name, and calling |
|
i2c_new_client_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_scanned_device() variant, which is |
|
similar to i2c_new_client_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_scanned_device() that |
|
many times. |
|
|
|
The call to i2c_new_client_device() or i2c_new_scanned_device() typically |
|
happens in the I2C bus driver. You may want to save the returned i2c_client |
|
reference for later use. |
|
|
|
|
|
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 |
|
devices on a PC's SMBus. In that case, you may want to let your driver |
|
detect supported devices automatically. This is how the legacy model |
|
was working, and is now available as an extension to the standard |
|
driver model. |
|
|
|
You simply have to define a detect callback which will attempt to |
|
identify supported devices (returning 0 for supported ones and -ENODEV |
|
for unsupported ones), a list of addresses to probe, and a device type |
|
(or class) so that only I2C buses which may have that type of device |
|
connected (and not otherwise enumerated) will be probed. For example, |
|
a driver for a hardware monitoring chip for which auto-detection is |
|
needed would set its class to I2C_CLASS_HWMON, and only I2C adapters |
|
with a class including I2C_CLASS_HWMON would be probed by this driver. |
|
Note that the absence of matching classes does not prevent the use of |
|
a device of that type on the given I2C adapter. All it prevents is |
|
auto-detection; explicit instantiation of devices is still possible. |
|
|
|
Note that this mechanism is purely optional and not suitable for all |
|
devices. You need some reliable way to identify the supported devices |
|
(typically using device-specific, dedicated identification registers), |
|
otherwise misdetections are likely to occur and things can get wrong |
|
quickly. Keep in mind that the I2C protocol doesn't include any |
|
standard way to detect the presence of a chip at a given address, let |
|
alone a standard way to identify devices. Even worse is the lack of |
|
semantics associated to bus transfers, which means that the same |
|
transfer can be seen as a read operation by a chip and as a write |
|
operation by another chip. For these reasons, explicit device |
|
instantiation should always be preferred to auto-detection where |
|
possible. |
|
|
|
|
|
Device Deletion |
|
--------------- |
|
|
|
Each I2C device which has been created using i2c_new_client_device() |
|
or i2c_new_scanned_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. |
|
|
|
|
|
Initializing the 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. |
|
|
|
:: |
|
|
|
static int __init foo_init(void) |
|
{ |
|
return i2c_add_driver(&foo_driver); |
|
} |
|
module_init(foo_init); |
|
|
|
static void __exit foo_cleanup(void) |
|
{ |
|
i2c_del_driver(&foo_driver); |
|
} |
|
module_exit(foo_cleanup); |
|
|
|
The module_i2c_driver() macro can be used to reduce above code. |
|
|
|
module_i2c_driver(foo_driver); |
|
|
|
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. |
|
|
|
|
|
Driver Information |
|
================== |
|
|
|
:: |
|
|
|
/* Substitute your own name and email address */ |
|
MODULE_AUTHOR("Frodo Looijaard <[email protected]>" |
|
MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices"); |
|
|
|
/* a few non-GPL license types are also allowed */ |
|
MODULE_LICENSE("GPL"); |
|
|
|
|
|
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 by implementing the |
|
appropriate callbacks for the dev_pm_ops of the driver (like suspend |
|
and resume). |
|
|
|
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. |
|
|
|
|
|
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 <linux/i2c.h>. |
|
|
|
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 |
|
----------------------- |
|
|
|
:: |
|
|
|
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 to read/write, the third the number of bytes |
|
to read/write (must be less than the length of the buffer, also should be |
|
less than 64k since msg.len is u16.) 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 |
|
stop condition is issued 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 |
|
------------------- |
|
|
|
:: |
|
|
|
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! |
|
|
|
:: |
|
|
|
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_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:: |
|
|
|
s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value); |
|
s32 i2c_smbus_process_call(struct i2c_client *client, |
|
u8 command, u16 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 |
|
value, except for block transactions, which return 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:: |
|
|
|
/* Return the adapter number for a specific adapter */ |
|
int i2c_adapter_id(struct i2c_adapter *adap);
|
|
|