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 .pm = &example_pm_ops, 83 }, 84 .attach_adapter = example_attach_adapter, 85 .detach_client = example_detach, 86}; 87 88 89Updating the client 90------------------- 91 92The new style binding model will check against a list of supported 93devices and their associated address supplied by the code registering 94the busses. This means that the driver .attach_adapter and 95.detach_client methods can be removed, along with the addr_data, 96as follows: 97 98- static struct i2c_driver example_driver; 99 100- static unsigned short ignore[] = { I2C_CLIENT_END }; 101- static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END }; 102 103- I2C_CLIENT_INSMOD; 104 105- static int example_attach_adapter(struct i2c_adapter *adap) 106- { 107- return i2c_probe(adap, &addr_data, example_attach); 108- } 109 110 static struct i2c_driver example_driver = { 111- .attach_adapter = example_attach_adapter, 112- .detach_client = example_detach, 113 } 114 115Add the probe and remove methods to the i2c_driver, as so: 116 117 static struct i2c_driver example_driver = { 118+ .probe = example_probe, 119+ .remove = example_remove, 120 } 121 122Change the example_attach method to accept the new parameters 123which include the i2c_client that it will be working with: 124 125- static int example_attach(struct i2c_adapter *adap, int addr, int kind) 126+ static int example_probe(struct i2c_client *client, 127+ const struct i2c_device_id *id) 128 129Change the name of example_attach to example_probe to align it with the 130i2c_driver entry names. The rest of the probe routine will now need to be 131changed as the i2c_client has already been setup for use. 132 133The necessary client fields have already been setup before 134the probe function is called, so the following client setup 135can be removed: 136 137- example->client.addr = addr; 138- example->client.flags = 0; 139- example->client.adapter = adap; 140- 141- strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE); 142 143The i2c_set_clientdata is now: 144 145- i2c_set_clientdata(&state->client, state); 146+ i2c_set_clientdata(client, state); 147 148The call to i2c_attach_client is no longer needed, if the probe 149routine exits successfully, then the driver will be automatically 150attached by the core. Change the probe routine as so: 151 152- ret = i2c_attach_client(&state->i2c_client); 153- if (ret < 0) { 154- dev_err(dev, "failed to attach client\n"); 155- kfree(state); 156- return ret; 157- } 158 159 160Remove the storage of 'struct i2c_client' from the 'struct example_state' 161as we are provided with the i2c_client in our example_probe. Instead we 162store a pointer to it for when it is needed. 163 164struct example_state { 165- struct i2c_client client; 166+ struct i2c_client *client; 167 168the new i2c client as so: 169 170- struct device *dev = &adap->dev; /* to use for dev_ reports */ 171+ struct device *dev = &i2c_client->dev; /* to use for dev_ reports */ 172 173And remove the change after our client is attached, as the driver no 174longer needs to register a new client structure with the core: 175 176- dev = &state->i2c_client.dev; 177 178In the probe routine, ensure that the new state has the client stored 179in it: 180 181static int example_probe(struct i2c_client *i2c_client, 182 const struct i2c_device_id *id) 183{ 184 struct example_state *state; 185 struct device *dev = &i2c_client->dev; 186 int ret; 187 188 state = kzalloc(sizeof(struct example_state), GFP_KERNEL); 189 if (state == NULL) { 190 dev_err(dev, "failed to create our state\n"); 191 return -ENOMEM; 192 } 193 194+ state->client = i2c_client; 195 196Update the detach method, by changing the name to _remove and 197to delete the i2c_detach_client call. It is possible that you 198can also remove the ret variable as it is not needed for any 199of the core functions. 200 201- static int example_detach(struct i2c_client *client) 202+ static int example_remove(struct i2c_client *client) 203{ 204 struct example_state *state = i2c_get_clientdata(client); 205 206- i2c_detach_client(client); 207 208And finally ensure that we have the correct ID table for the i2c-core 209and other utilities: 210 211+ struct i2c_device_id example_idtable[] = { 212+ { "example", 0 }, 213+ { } 214+}; 215+ 216+MODULE_DEVICE_TABLE(i2c, example_idtable); 217 218static struct i2c_driver example_driver = { 219 .driver = { 220 .owner = THIS_MODULE, 221 .name = "example", 222 }, 223+ .id_table = example_ids, 224 225 226Our driver should now look like this: 227 228struct example_state { 229 struct i2c_client *client; 230 .... 231}; 232 233static int example_probe(struct i2c_client *client, 234 const struct i2c_device_id *id) 235{ 236 struct example_state *state; 237 struct device *dev = &client->dev; 238 239 state = kzalloc(sizeof(struct example_state), GFP_KERNEL); 240 if (state == NULL) { 241 dev_err(dev, "failed to create our state\n"); 242 return -ENOMEM; 243 } 244 245 state->client = client; 246 i2c_set_clientdata(client, state); 247 248 /* rest of the initialisation goes here. */ 249 250 dev_info(dev, "example client created\n"); 251 252 return 0; 253} 254 255static int example_remove(struct i2c_client *client) 256{ 257 struct example_state *state = i2c_get_clientdata(client); 258 259 kfree(state); 260 return 0; 261} 262 263static struct i2c_device_id example_idtable[] = { 264 { "example", 0 }, 265 { } 266}; 267 268MODULE_DEVICE_TABLE(i2c, example_idtable); 269 270static struct i2c_driver example_driver = { 271 .driver = { 272 .owner = THIS_MODULE, 273 .name = "example", 274 .pm = &example_pm_ops, 275 }, 276 .id_table = example_idtable, 277 .probe = example_probe, 278 .remove = example_remove, 279}; 280