linux/Documentation/i2c/upgrading-clients
<<
>>
Prefs
   1Upgrading I2C Drivers to the new 2.6 Driver Model
   2=================================================
   3
   4Ben Dooks <ben-linux@fluff.org>
   5
   6Introduction
   7------------
   8
   9This guide outlines how to alter existing Linux 2.6 client drivers from
  10the old to the new new binding methods.
  11
  12
  13Example old-style driver
  14------------------------
  15
  16
  17struct example_state {
  18        struct i2c_client       client;
  19        ....
  20};
  21
  22static struct i2c_driver example_driver;
  23
  24static unsigned short ignore[] = { I2C_CLIENT_END };
  25static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END };
  26
  27I2C_CLIENT_INSMOD;
  28
  29static int example_attach(struct i2c_adapter *adap, int addr, int kind)
  30{
  31        struct example_state *state;
  32        struct device *dev = &adap->dev;  /* to use for dev_ reports */
  33        int ret;
  34
  35        state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
  36        if (state == NULL) {
  37                dev_err(dev, "failed to create our state\n");
  38                return -ENOMEM;
  39        }
  40
  41        example->client.addr    = addr;
  42        example->client.flags   = 0;
  43        example->client.adapter = adap;
  44
  45        i2c_set_clientdata(&state->i2c_client, state);
  46        strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE);
  47
  48        ret = i2c_attach_client(&state->i2c_client);
  49        if (ret < 0) {
  50                dev_err(dev, "failed to attach client\n");
  51                kfree(state);
  52                return ret;
  53        }
  54
  55        dev = &state->i2c_client.dev;
  56
  57        /* rest of the initialisation goes here. */
  58
  59        dev_info(dev, "example client created\n");
  60
  61        return 0;
  62}
  63
  64static int example_detach(struct i2c_client *client)
  65{
  66        struct example_state *state = i2c_get_clientdata(client);
  67
  68        i2c_detach_client(client);
  69        kfree(state);
  70        return 0;
  71}
  72
  73static int example_attach_adapter(struct i2c_adapter *adap)
  74{
  75        return i2c_probe(adap, &addr_data, example_attach);
  76}
  77
  78static struct i2c_driver example_driver = {
  79        .driver         = {
  80                .owner          = THIS_MODULE,
  81                .name           = "example",
  82        },
  83        .attach_adapter = example_attach_adapter,
  84        .detach_client  = example_detach,
  85        .suspend        = example_suspend,
  86        .resume         = example_resume,
  87};
  88
  89
  90Updating the client
  91-------------------
  92
  93The new style binding model will check against a list of supported
  94devices and their associated address supplied by the code registering
  95the busses. This means that the driver .attach_adapter and
  96.detach_client methods can be removed, along with the addr_data,
  97as follows:
  98
  99- static struct i2c_driver example_driver;
 100
 101- static unsigned short ignore[] = { I2C_CLIENT_END };
 102- static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END };
 103
 104- I2C_CLIENT_INSMOD;
 105
 106- static int example_attach_adapter(struct i2c_adapter *adap)
 107- {
 108-       return i2c_probe(adap, &addr_data, example_attach);
 109- }
 110
 111 static struct i2c_driver example_driver = {
 112-       .attach_adapter = example_attach_adapter,
 113-       .detach_client  = example_detach,
 114 }
 115
 116Add the probe and remove methods to the i2c_driver, as so:
 117
 118 static struct i2c_driver example_driver = {
 119+       .probe          = example_probe,
 120+       .remove         = example_remove,
 121 }
 122
 123Change the example_attach method to accept the new parameters
 124which include the i2c_client that it will be working with:
 125
 126- static int example_attach(struct i2c_adapter *adap, int addr, int kind)
 127+ static int example_probe(struct i2c_client *client,
 128+                          const struct i2c_device_id *id)
 129
 130Change the name of example_attach to example_probe to align it with the
 131i2c_driver entry names. The rest of the probe routine will now need to be
 132changed as the i2c_client has already been setup for use.
 133
 134The necessary client fields have already been setup before
 135the probe function is called, so the following client setup
 136can be removed:
 137
 138-       example->client.addr    = addr;
 139-       example->client.flags   = 0;
 140-       example->client.adapter = adap;
 141-
 142-       strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE);
 143
 144The i2c_set_clientdata is now:
 145
 146-       i2c_set_clientdata(&state->client, state);
 147+       i2c_set_clientdata(client, state);
 148
 149The call to i2c_attach_client is no longer needed, if the probe
 150routine exits successfully, then the driver will be automatically
 151attached by the core. Change the probe routine as so:
 152
 153-       ret = i2c_attach_client(&state->i2c_client);
 154-       if (ret < 0) {
 155-               dev_err(dev, "failed to attach client\n");
 156-               kfree(state);
 157-               return ret;
 158-       }
 159
 160
 161Remove the storage of 'struct i2c_client' from the 'struct example_state'
 162as we are provided with the i2c_client in our example_probe. Instead we
 163store a pointer to it for when it is needed.
 164
 165struct example_state {
 166-       struct i2c_client       client;
 167+       struct i2c_client       *client;
 168
 169the new i2c client as so:
 170
 171-       struct device *dev = &adap->dev;  /* to use for dev_ reports */
 172+       struct device *dev = &i2c_client->dev;  /* to use for dev_ reports */
 173
 174And remove the change after our client is attached, as the driver no
 175longer needs to register a new client structure with the core:
 176
 177-       dev = &state->i2c_client.dev;
 178
 179In the probe routine, ensure that the new state has the client stored
 180in it:
 181
 182static int example_probe(struct i2c_client *i2c_client,
 183                         const struct i2c_device_id *id)
 184{
 185        struct example_state *state;
 186        struct device *dev = &i2c_client->dev;
 187        int ret;
 188
 189        state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
 190        if (state == NULL) {
 191                dev_err(dev, "failed to create our state\n");
 192                return -ENOMEM;
 193        }
 194
 195+       state->client = i2c_client;
 196
 197Update the detach method, by changing the name to _remove and
 198to delete the i2c_detach_client call. It is possible that you
 199can also remove the ret variable as it is not not needed for
 200any of the core functions.
 201
 202- static int example_detach(struct i2c_client *client)
 203+ static int example_remove(struct i2c_client *client)
 204{
 205        struct example_state *state = i2c_get_clientdata(client);
 206
 207-       i2c_detach_client(client);
 208
 209And finally ensure that we have the correct ID table for the i2c-core
 210and other utilities:
 211
 212+ struct i2c_device_id example_idtable[] = {
 213+       { "example", 0 },
 214+       { }
 215+};
 216+
 217+MODULE_DEVICE_TABLE(i2c, example_idtable);
 218
 219static struct i2c_driver example_driver = {
 220        .driver         = {
 221                .owner          = THIS_MODULE,
 222                .name           = "example",
 223        },
 224+       .id_table       = example_ids,
 225
 226
 227Our driver should now look like this:
 228
 229struct example_state {
 230        struct i2c_client       *client;
 231        ....
 232};
 233
 234static int example_probe(struct i2c_client *client,
 235                         const struct i2c_device_id *id)
 236{
 237        struct example_state *state;
 238        struct device *dev = &client->dev;
 239
 240        state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
 241        if (state == NULL) {
 242                dev_err(dev, "failed to create our state\n");
 243                return -ENOMEM;
 244        }
 245
 246        state->client = client;
 247        i2c_set_clientdata(client, state);
 248
 249        /* rest of the initialisation goes here. */
 250
 251        dev_info(dev, "example client created\n");
 252
 253        return 0;
 254}
 255
 256static int example_remove(struct i2c_client *client)
 257{
 258        struct example_state *state = i2c_get_clientdata(client);
 259
 260        kfree(state);
 261        return 0;
 262}
 263
 264static struct i2c_device_id example_idtable[] = {
 265        { "example", 0 },
 266        { }
 267};
 268
 269MODULE_DEVICE_TABLE(i2c, example_idtable);
 270
 271static struct i2c_driver example_driver = {
 272        .driver         = {
 273                .owner          = THIS_MODULE,
 274                .name           = "example",
 275        },
 276        .id_table       = example_idtable,
 277        .probe          = example_probe,
 278        .remove         = example_remove,
 279        .suspend        = example_suspend,
 280        .resume         = example_resume,
 281};
 282
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.