Upgrading I2C Drivers to the new 2.6 Driver Model ================================================= Ben Dooks <ben-linux@fluff.org> Introduction ------------ This guide outlines how to alter existing Linux 2.6 client drivers from the old to the new new binding methods. Example old-style driver ------------------------ struct example_state { struct i2c_client client; .... }; static struct i2c_driver example_driver; static unsigned short ignore[] = { I2C_CLIENT_END }; static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END }; I2C_CLIENT_INSMOD; static int example_attach(struct i2c_adapter *adap, int addr, int kind) { struct example_state *state; struct device *dev = &adap->dev; /* to use for dev_ reports */ int ret; state = kzalloc(sizeof(struct example_state), GFP_KERNEL); if (state == NULL) { dev_err(dev, "failed to create our state\n"); return -ENOMEM; } example->client.addr = addr; example->client.flags = 0; example->client.adapter = adap; i2c_set_clientdata(&state->i2c_client, state); strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE); ret = i2c_attach_client(&state->i2c_client); if (ret < 0) { dev_err(dev, "failed to attach client\n"); kfree(state); return ret; } dev = &state->i2c_client.dev; /* rest of the initialisation goes here. */ dev_info(dev, "example client created\n"); return 0; } static int example_detach(struct i2c_client *client) { struct example_state *state = i2c_get_clientdata(client); i2c_detach_client(client); kfree(state); return 0; } static int example_attach_adapter(struct i2c_adapter *adap) { return i2c_probe(adap, &addr_data, example_attach); } static struct i2c_driver example_driver = { .driver = { .owner = THIS_MODULE, .name = "example", }, .attach_adapter = example_attach_adapter, .detach_client = example_detach, .suspend = example_suspend, .resume = example_resume, }; Updating the client ------------------- The new style binding model will check against a list of supported devices and their associated address supplied by the code registering the busses. This means that the driver .attach_adapter and .detach_client methods can be removed, along with the addr_data, as follows: - static struct i2c_driver example_driver; - static unsigned short ignore[] = { I2C_CLIENT_END }; - static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END }; - I2C_CLIENT_INSMOD; - static int example_attach_adapter(struct i2c_adapter *adap) - { - return i2c_probe(adap, &addr_data, example_attach); - } static struct i2c_driver example_driver = { - .attach_adapter = example_attach_adapter, - .detach_client = example_detach, } Add the probe and remove methods to the i2c_driver, as so: static struct i2c_driver example_driver = { + .probe = example_probe, + .remove = example_remove, } Change the example_attach method to accept the new parameters which include the i2c_client that it will be working with: - static int example_attach(struct i2c_adapter *adap, int addr, int kind) + static int example_probe(struct i2c_client *client, + const struct i2c_device_id *id) Change the name of example_attach to example_probe to align it with the i2c_driver entry names. The rest of the probe routine will now need to be changed as the i2c_client has already been setup for use. The necessary client fields have already been setup before the probe function is called, so the following client setup can be removed: - example->client.addr = addr; - example->client.flags = 0; - example->client.adapter = adap; - - strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE); The i2c_set_clientdata is now: - i2c_set_clientdata(&state->client, state); + i2c_set_clientdata(client, state); The call to i2c_attach_client is no longer needed, if the probe routine exits successfully, then the driver will be automatically attached by the core. Change the probe routine as so: - ret = i2c_attach_client(&state->i2c_client); - if (ret < 0) { - dev_err(dev, "failed to attach client\n"); - kfree(state); - return ret; - } Remove the storage of 'struct i2c_client' from the 'struct example_state' as we are provided with the i2c_client in our example_probe. Instead we store a pointer to it for when it is needed. struct example_state { - struct i2c_client client; + struct i2c_client *client; the new i2c client as so: - struct device *dev = &adap->dev; /* to use for dev_ reports */ + struct device *dev = &i2c_client->dev; /* to use for dev_ reports */ And remove the change after our client is attached, as the driver no longer needs to register a new client structure with the core: - dev = &state->i2c_client.dev; In the probe routine, ensure that the new state has the client stored in it: static int example_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct example_state *state; struct device *dev = &i2c_client->dev; int ret; state = kzalloc(sizeof(struct example_state), GFP_KERNEL); if (state == NULL) { dev_err(dev, "failed to create our state\n"); return -ENOMEM; } + state->client = i2c_client; Update the detach method, by changing the name to _remove and to delete the i2c_detach_client call. It is possible that you can also remove the ret variable as it is not needed for any of the core functions. - static int example_detach(struct i2c_client *client) + static int example_remove(struct i2c_client *client) { struct example_state *state = i2c_get_clientdata(client); - i2c_detach_client(client); And finally ensure that we have the correct ID table for the i2c-core and other utilities: + struct i2c_device_id example_idtable[] = { + { "example", 0 }, + { } +}; + +MODULE_DEVICE_TABLE(i2c, example_idtable); static struct i2c_driver example_driver = { .driver = { .owner = THIS_MODULE, .name = "example", }, + .id_table = example_ids, Our driver should now look like this: struct example_state { struct i2c_client *client; .... }; static int example_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct example_state *state; struct device *dev = &client->dev; state = kzalloc(sizeof(struct example_state), GFP_KERNEL); if (state == NULL) { dev_err(dev, "failed to create our state\n"); return -ENOMEM; } state->client = client; i2c_set_clientdata(client, state); /* rest of the initialisation goes here. */ dev_info(dev, "example client created\n"); return 0; } static int example_remove(struct i2c_client *client) { struct example_state *state = i2c_get_clientdata(client); kfree(state); return 0; } static struct i2c_device_id example_idtable[] = { { "example", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, example_idtable); static struct i2c_driver example_driver = { .driver = { .owner = THIS_MODULE, .name = "example", }, .id_table = example_idtable, .probe = example_probe, .remove = example_remove, .suspend = example_suspend, .resume = example_resume, };