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