Documentation/i2c/writing-clients

   1 This is a small guide for those who want to write kernel drivers for I2C
   2 or SMBus devices, using Linux as the protocol host/master (not slave).
   3
   4 To set up a driver, you need to do several things. Some are optional, and
   5 some things can be done slightly or completely different. Use this as a
   6 guide, not as a rule book!
   7
   8
   9 General remarks
  10 ===============
  11
  12 Try to keep the kernel namespace as clean as possible. The best way to
  13 do this is to use a unique prefix for all global symbols. This is
  14 especially important for exported symbols, but it is a good idea to do
  15 it for non-exported symbols too. We will use the prefix `foo_' in this
  16 tutorial.
  17
  18
  19 The driver structure
  20 ====================
  21
  22 Usually, you will implement a single driver structure, and instantiate
  23 all clients from it. Remember, a driver structure contains general access
  24 routines, and should be zero-initialized except for fields with data you
  25 provide.  A client structure holds device-specific information like the
  26 driver model device node, and its I2C address.
  27
  28 static struct i2c_device_id foo_idtable[] = {
  29         { "foo", my_id_for_foo },
  30         { "bar", my_id_for_bar },
  31         { }
  32 };
  33
  34 MODULE_DEVICE_TABLE(i2c, foo_idtable);
  35
  36 static struct i2c_driver foo_driver = {
  37         .driver = {
  38                 .name   = "foo",
  39         },
  40
  41         .id_table       = foo_ids,
  42         .probe          = foo_probe,
  43         .remove         = foo_remove,
  44         /* if device autodetection is needed: */
  45         .class          = I2C_CLASS_SOMETHING,
  46         .detect         = foo_detect,
  47         .address_data   = &addr_data,
  48
  49         .shutdown       = foo_shutdown, /* optional */
  50         .suspend        = foo_suspend,  /* optional */
  51         .resume         = foo_resume,   /* optional */
  52         .command        = foo_command,  /* optional, deprecated */
  53 }
  54
  55 The name field is the driver name, and must not contain spaces.  It
  56 should match the module name (if the driver can be compiled as a module),
  57 although you can use MODULE_ALIAS (passing "foo" in this example) to add
  58 another name for the module.  If the driver name doesn't match the module
  59 name, the module won't be automatically loaded (hotplug/coldplug).
  60
  61 All other fields are for call-back functions which will be explained
  62 below.
  63
  64
  65 Extra client data
  66 =================
  67
  68 Each client structure has a special `data' field that can point to any
  69 structure at all.  You should use this to keep device-specific data.
  70
  71         /* store the value */
  72         void i2c_set_clientdata(struct i2c_client *client, void *data);
  73
  74         /* retrieve the value */
  75         void *i2c_get_clientdata(const struct i2c_client *client);
  76
  77
  78 Accessing the client
  79 ====================
  80
  81 Let's say we have a valid client structure. At some time, we will need
  82 to gather information from the client, or write new information to the
  83 client.
  84
  85 I have found it useful to define foo_read and foo_write functions for this.
  86 For some cases, it will be easier to call the i2c functions directly,
  87 but many chips have some kind of register-value idea that can easily
  88 be encapsulated.
  89
  90 The below functions are simple examples, and should not be copied
  91 literally.
  92
  93 int foo_read_value(struct i2c_client *client, u8 reg)
  94 {
  95         if (reg < 0x10) /* byte-sized register */
  96                 return i2c_smbus_read_byte_data(client, reg);
  97         else            /* word-sized register */
  98                 return i2c_smbus_read_word_data(client, reg);
  99 }
 100
 101 int foo_write_value(struct i2c_client *client, u8 reg, u16 value)
 102 {
 103         if (reg == 0x10)        /* Impossible to write - driver error! */
 104                 return -EINVAL;
 105         else if (reg < 0x10)    /* byte-sized register */
 106                 return i2c_smbus_write_byte_data(client, reg, value);
 107         else                    /* word-sized register */
 108                 return i2c_smbus_write_word_data(client, reg, value);
 109 }
 110
 111
 112 Probing and attaching
 113 =====================
 114
 115 The Linux I2C stack was originally written to support access to hardware
 116 monitoring chips on PC motherboards, and thus used to embed some assumptions
 117 that were more appropriate to SMBus (and PCs) than to I2C.  One of these
 118 assumptions was that most adapters and devices drivers support the SMBUS_QUICK
 119 protocol to probe device presence.  Another was that devices and their drivers
 120 can be sufficiently configured using only such probe primitives.
 121
 122 As Linux and its I2C stack became more widely used in embedded systems
 123 and complex components such as DVB adapters, those assumptions became more
 124 problematic.  Drivers for I2C devices that issue interrupts need more (and
 125 different) configuration information, as do drivers handling chip variants
 126 that can't be distinguished by protocol probing, or which need some board
 127 specific information to operate correctly.
 128
 129 Accordingly, the I2C stack now has two models for associating I2C devices
 130 with their drivers:  the original "legacy" model, and a newer one that's
 131 fully compatible with the Linux 2.6 driver model.  These models do not mix,
 132 since the "legacy" model requires drivers to create "i2c_client" device
 133 objects after SMBus style probing, while the Linux driver model expects
 134 drivers to be given such device objects in their probe() routines.
 135
 136 The legacy model is deprecated now and will soon be removed, so we no
 137 longer document it here.
 138
 139
 140 Standard Driver Model Binding ("New Style")
 141 -------------------------------------------
 142
 143 System infrastructure, typically board-specific initialization code or
 144 boot firmware, reports what I2C devices exist.  For example, there may be
 145 a table, in the kernel or from the boot loader, identifying I2C devices
 146 and linking them to board-specific configuration information about IRQs
 147 and other wiring artifacts, chip type, and so on.  That could be used to
 148 create i2c_client objects for each I2C device.
 149
 150 I2C device drivers using this binding model work just like any other
 151 kind of driver in Linux:  they provide a probe() method to bind to
 152 those devices, and a remove() method to unbind.
 153
 154         static int foo_probe(struct i2c_client *client,
 155                              const struct i2c_device_id *id);
 156         static int foo_remove(struct i2c_client *client);
 157
 158 Remember that the i2c_driver does not create those client handles.  The
 159 handle may be used during foo_probe().  If foo_probe() reports success
 160 (zero not a negative status code) it may save the handle and use it until
 161 foo_remove() returns.  That binding model is used by most Linux drivers.
 162
 163 The probe function is called when an entry in the id_table name field
 164 matches the device's name. It is passed the entry that was matched so
 165 the driver knows which one in the table matched.
 166
 167
 168 Device Creation
 169 ---------------
 170
 171 If you know for a fact that an I2C device is connected to a given I2C bus,
 172 you can instantiate that device by simply filling an i2c_board_info
 173 structure with the device address and driver name, and calling
 174 i2c_new_device().  This will create the device, then the driver core will
 175 take care of finding the right driver and will call its probe() method.
 176 If a driver supports different device types, you can specify the type you
 177 want using the type field.  You can also specify an IRQ and platform data
 178 if needed.
 179
 180 Sometimes you know that a device is connected to a given I2C bus, but you
 181 don't know the exact address it uses.  This happens on TV adapters for
 182 example, where the same driver supports dozens of slightly different
 183 models, and I2C device addresses change from one model to the next.  In
 184 that case, you can use the i2c_new_probed_device() variant, which is
 185 similar to i2c_new_device(), except that it takes an additional list of
 186 possible I2C addresses to probe.  A device is created for the first
 187 responsive address in the list.  If you expect more than one device to be
 188 present in the address range, simply call i2c_new_probed_device() that
 189 many times.
 190
 191 The call to i2c_new_device() or i2c_new_probed_device() typically happens
 192 in the I2C bus driver. You may want to save the returned i2c_client
 193 reference for later use.
 194
 195
 196 Device Detection
 197 ----------------
 198
 199 Sometimes you do not know in advance which I2C devices are connected to
 200 a given I2C bus.  This is for example the case of hardware monitoring
 201 devices on a PC's SMBus.  In that case, you may want to let your driver
 202 detect supported devices automatically.  This is how the legacy model
 203 was working, and is now available as an extension to the standard
 204 driver model (so that we can finally get rid of the legacy model.)
 205
 206 You simply have to define a detect callback which will attempt to
 207 identify supported devices (returning 0 for supported ones and -ENODEV
 208 for unsupported ones), a list of addresses to probe, and a device type
 209 (or class) so that only I2C buses which may have that type of device
 210 connected (and not otherwise enumerated) will be probed.  The i2c
 211 core will then call you back as needed and will instantiate a device
 212 for you for every successful detection.
 213
 214 Note that this mechanism is purely optional and not suitable for all
 215 devices.  You need some reliable way to identify the supported devices
 216 (typically using device-specific, dedicated identification registers),
 217 otherwise misdetections are likely to occur and things can get wrong
 218 quickly.
 219
 220
 221 Device Deletion
 222 ---------------
 223
 224 Each I2C device which has been created using i2c_new_device() or
 225 i2c_new_probed_device() can be unregistered by calling
 226 i2c_unregister_device().  If you don't call it explicitly, it will be
 227 called automatically before the underlying I2C bus itself is removed, as a
 228 device can't survive its parent in the device driver model.
 229
 230
 231 Initializing the driver
 232 =======================
 233
 234 When the kernel is booted, or when your foo driver module is inserted,
 235 you have to do some initializing. Fortunately, just registering the
 236 driver module is usually enough.
 237
 238 static int __init foo_init(void)
 239 {
 240         return i2c_add_driver(&foo_driver);
 241 }
 242
 243 static void __exit foo_cleanup(void)
 244 {
 245         i2c_del_driver(&foo_driver);
 246 }
 247
 248 /* Substitute your own name and email address */
 249 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"
 250 MODULE_DESCRIPTION("Driver for Barf Inc. Foo I2C devices");
 251
 252 /* a few non-GPL license types are also allowed */
 253 MODULE_LICENSE("GPL");
 254
 255 module_init(foo_init);
 256 module_exit(foo_cleanup);
 257
 258 Note that some functions are marked by `__init'.  These functions can
 259 be removed after kernel booting (or module loading) is completed.
 260 Likewise, functions marked by `__exit' are dropped by the compiler when
 261 the code is built into the kernel, as they would never be called.
 262
 263
 264 Power Management
 265 ================
 266
 267 If your I2C device needs special handling when entering a system low
 268 power state -- like putting a transceiver into a low power mode, or
 269 activating a system wakeup mechanism -- do that in the suspend() method.
 270 The resume() method should reverse what the suspend() method does.
 271
 272 These are standard driver model calls, and they work just like they
 273 would for any other driver stack.  The calls can sleep, and can use
 274 I2C messaging to the device being suspended or resumed (since their
 275 parent I2C adapter is active when these calls are issued, and IRQs
 276 are still enabled).
 277
 278
 279 System Shutdown
 280 ===============
 281
 282 If your I2C device needs special handling when the system shuts down
 283 or reboots (including kexec) -- like turning something off -- use a
 284 shutdown() method.
 285
 286 Again, this is a standard driver model call, working just like it
 287 would for any other driver stack:  the calls can sleep, and can use
 288 I2C messaging.
 289
 290
 291 Command function
 292 ================
 293
 294 A generic ioctl-like function call back is supported. You will seldom
 295 need this, and its use is deprecated anyway, so newer design should not
 296 use it.
 297
 298
 299 Sending and receiving
 300 =====================
 301
 302 If you want to communicate with your device, there are several functions
 303 to do this. You can find all of them in <linux/i2c.h>.
 304
 305 If you can choose between plain I2C communication and SMBus level
 306 communication, please use the latter. All adapters understand SMBus level
 307 commands, but only some of them understand plain I2C!
 308
 309
 310 Plain I2C communication
 311 -----------------------
 312
 313         int i2c_master_send(struct i2c_client *client, const char *buf,
 314                             int count);
 315         int i2c_master_recv(struct i2c_client *client, char *buf, int count);
 316
 317 These routines read and write some bytes from/to a client. The client
 318 contains the i2c address, so you do not have to include it. The second
 319 parameter contains the bytes to read/write, the third the number of bytes
 320 to read/write (must be less than the length of the buffer.) Returned is
 321 the actual number of bytes read/written.
 322
 323         int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,
 324                          int num);
 325
 326 This sends a series of messages. Each message can be a read or write,
 327 and they can be mixed in any way. The transactions are combined: no
 328 stop bit is sent between transaction. The i2c_msg structure contains
 329 for each message the client address, the number of bytes of the message
 330 and the message data itself.
 331
 332 You can read the file `i2c-protocol' for more information about the
 333 actual I2C protocol.
 334
 335
 336 SMBus communication
 337 -------------------
 338
 339         s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 340                            unsigned short flags, char read_write, u8 command,
 341                            int size, union i2c_smbus_data *data);
 342
 343 This is the generic SMBus function. All functions below are implemented
 344 in terms of it. Never use this function directly!
 345
 346         s32 i2c_smbus_read_byte(struct i2c_client *client);
 347         s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
 348         s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
 349         s32 i2c_smbus_write_byte_data(struct i2c_client *client,
 350                                       u8 command, u8 value);
 351         s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
 352         s32 i2c_smbus_write_word_data(struct i2c_client *client,
 353                                       u8 command, u16 value);
 354         s32 i2c_smbus_process_call(struct i2c_client *client,
 355                                    u8 command, u16 value);
 356         s32 i2c_smbus_read_block_data(struct i2c_client *client,
 357                                       u8 command, u8 *values);
 358         s32 i2c_smbus_write_block_data(struct i2c_client *client,
 359                                        u8 command, u8 length, const u8 *values);
 360         s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
 361                                           u8 command, u8 length, u8 *values);
 362         s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
 363                                            u8 command, u8 length,
 364                                            const u8 *values);
 365
 366 These ones were removed from i2c-core because they had no users, but could
 367 be added back later if needed:
 368
 369         s32 i2c_smbus_write_quick(struct i2c_client *client, u8 value);
 370         s32 i2c_smbus_block_process_call(struct i2c_client *client,
 371                                          u8 command, u8 length, u8 *values);
 372
 373 All these transactions return a negative errno value on failure. The 'write'
 374 transactions return 0 on success; the 'read' transactions return the read
 375 value, except for block transactions, which return the number of values
 376 read. The block buffers need not be longer than 32 bytes.
 377
 378 You can read the file `smbus-protocol' for more information about the
 379 actual SMBus protocol.
 380
 381
 382 General purpose routines
 383 ========================
 384
 385 Below all general purpose routines are listed, that were not mentioned
 386 before.
 387
 388         /* Return the adapter number for a specific adapter */
 389         int i2c_adapter_id(struct i2c_adapter *adap);