Documentation/i2c/writing-clients.rst

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