RFC: Add documentation on upgrading clients
I would like to get people's opinions on adding the following as Documentation/i2c/upgrading-clients.
Upgrading I2C Drivers to the new 2.6 Driver Model
=================================================
Ben Dooks <[email protected]>
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 };
static struct i2c_client_address_data addr_data = {
.normal_i2c = normal_addr,
.probe = ignore,
.ignore = ignore,
};static int example_attach(struct i2c_adapter *adap, int addr, int kind)
{
struct example_state *state;
struct device *dev = &adap->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;
}
example->i2c_client.addr = addr;
example->i2c_client.flags = 0;
example->i2c_client.adapter = adap;
i2c_set_clientdata(&state->i2c_client, state);
strlcpy(client->i2c_client.name, example_driver.driver.name,
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. */
return 0;
}static int example_remove(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_adapter 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 };
- static struct i2c_client_address_data addr_data = {
- .normal_i2c = normal_addr,
- .probe = ignore,
- .ignore = ignore,
- };
- 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 = simtec_pmu_probe,
+ .remove = simtec_pmu_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 *i2c_client,
+ const struct i2c_device_id *id)
Note, we 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.
Remove the setting of address and adapter, they are now not needed.
- example->i2c_client.addr = addr;
- example->i2c_client.flags = 0;
- example->i2c_client.adapter = adap;
Also remove the strlcpy, as the i2c_client's name is already filled in by the caller.
- strlcpy(client->i2c_client.name, example_driver.driver.name,
- I2C_NAME_SIZE);
The call to i2c_attach_client is no longer needed, if the probe routine exits succssfully, then the driver has been attached. 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;
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 = &adap->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 remove method to delete the i2c_detach_client call.
static int example_remove(struct i2c_client *client)
{
struct example_state *state = i2c_get_clientdata(client);- i2c_detach_client(client);
_______________________________________________
i2c mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/i2c
A message that is not in the archive (sent off-list or not yet received): [email protected]
Hi Ben,
just a few comments.
Quoted 129 lines · Ben Dooks
I would like to get people's opinions on adding the following as
Documentation/i2c/upgrading-clients.Upgrading I2C Drivers to the new 2.6 Driver Model
=================================================Ben Dooks <[email protected]>
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_driverexample_driver;static unsigned short ignore[] = {
I2C_CLIENT_END}; static unsigned short normal_addr[] = {OUR_ADDR,I2C_CLIENT_END};static struct i2c_client_address_data addr_data = { .normal_i2c = normal_addr, .probe = ignore, .ignore = ignore, };static int
example_attach(struct i2c_adapter *adap, int addr, int kind){ struct example_state *state; struct device *dev = &adap->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; } example->i2c_client.addr = addr; example->i2c_client.flags = 0; example->i2c_client.adapter = adap; i2c_set_clientdata(&state->i2c_client, state); strlcpy(client->i2c_client.name, example_driver.driver.name, 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. */ return 0; }static int
example_remove(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_driverexample_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_adapter methods can be removed, along with the
addr_data, as follows- static struct
i2c_driverexample_driver;- static unsigned short ignore[] = {
I2C_CLIENT_END};
- static unsigned short normal_addr[] = {OUR_ADDR,I2C_CLIENT_END};- static struct
i2c_client_address_dataaddr_data= {(quoted diff) +0
-10- .normal_i2c = normal_addr, - .probe = ignore, - .ignore = ignore, - }; - 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_driverexample_driver= {
Review
Quoted 3 lines
(quoted diff) +2
-0+ .probe = simtec_pmu_probe, + .remove = simtec_pmu_remove, }
This should be example_probe and example_remove.
Quoted 24 lines
Change the
example_attachmethod to accept the new parameters which include thei2c_clientthat it will be working with:- static int
example_attach(struct i2c_adapter *adap, int addr, int kind)
+ static int example_probe(structi2c_client*i2c_client,(quoted diff) +1
-0+ const struct i2c_device_id *id)Note, we change the name of
example_attachtoexample_probeto align it with thei2c_driverentry names. The rest of the probe routine will now need to be changed as thei2c_clienthas already been setup for use.Remove the setting of address and adapter, they are now not needed.
(quoted diff) +0
-3- example->i2c_client.addr = addr; - example->i2c_client.flags = 0; - example->i2c_client.adapter = adap;Also remove the strlcpy, as the i2c_client's name is already filled in by the caller.
(quoted diff) +0
-2- strlcpy(client->i2c_client.name, example_driver.driver.name, - I2C_NAME_SIZE);
Quoted 2 lines
The call to
i2c_attach_clientis no longer needed, if the probe routine exits succssfully,
"successfully"
Quoted 1 line
then the driver has been attached. Change
"will be attached" sounds better.
Quoted 43 lines
the probe routine as so:
(quoted diff) +0
-6- 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 'structexample_state' as we are provided with thei2c_clientin ourexample_probe. Instead we store a pointer to it for when it is needed.struct
example_state{(quoted diff) +1
-1- struct i2c_client client; + struct i2c_client *client;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 structi2c_device_id*id){ struct example_state *state; struct device *dev = &adap->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; }(quoted diff) +1
-0+ state->client = i2c_client;Update the remove method to delete the
i2c_detach_clientcall.static int
example_remove(struct i2c_client *client){ struct example_state *state = i2c_get_clientdata(client);(quoted diff) +0
-1- i2c_detach_client(client);
Signature · 9 lines
Laurent Pinchart CSE Semaphore Belgium Chaussee de Bruxelles, 732A B-1410 Waterloo Belgium T +32 (2) 387 42 59 F +32 (2) 387 42 75
_______________________________________________
i2c mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/i2c
A message that is not in the archive (sent off-list or not yet received): 200806031329.10290.laurentp-BSmb2szPELAwsLKNixborgC/[email protected]
On Tue, Jun 03, 2008 at 01:29:06PM +0200, Laurent Pinchart wrote:
Thanks, here's the next version, and I have included the example driver post-editing at the end of the file. Also found a couple of items that I forgot to add.
V2:
Upgrading I2C Drivers to the new 2.6 Driver Model
=================================================
Ben Dooks <[email protected]>
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 };
static struct i2c_client_address_data addr_data = {
.normal_i2c = normal_addr,
.probe = ignore,
.ignore = ignore,
};static int example_attach(struct i2c_adapter *adap, int addr, int kind)
{
struct example_state *state;
struct device *dev = &adap->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;
}
example->i2c_client.addr = addr;
example->i2c_client.flags = 0;
example->i2c_client.adapter = adap;
i2c_set_clientdata(&state->i2c_client, state);
strlcpy(client->i2c_client.name, example_driver.driver.name,
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. */
return 0;
}static int example_remove(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_adapter 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 };
- static struct i2c_client_address_data addr_data = {
- .normal_i2c = normal_addr,
- .probe = ignore,
- .ignore = ignore,
- };
- 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 *i2c_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.
Remove the setting of address and adapter, they are now not needed.
- example->i2c_client.addr = addr;
- example->i2c_client.flags = 0;
- example->i2c_client.adapter = adap;
Also remove the strlcpy, as the i2c_client's name is already filled in by the caller.
- strlcpy(client->i2c_client.name, example_driver.driver.name,
- I2C_NAME_SIZE);
The i2c_set_clientdata is now:
- i2c_set_clientdata(&state->i2c_client, state);
+ i2c_set_clientdata(i2c_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;
It is also necessary to change the temporary dev pointer to point into the new i2c client as so:
- struct device *dev = &adap->dev;
+ struct device *dev = &i2c_client->dev;
And remove the change aftre 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 remove method to delete the i2c_detach_client call.
static int example_remove(struct i2c_client *client)
{
struct example_state *state = i2c_get_clientdata(client);- i2c_detach_client(client);
Our driver should now look like this:
struct example_state {
struct i2c_client client;
....
};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;
i2c_set_clientdata(i2c_client, state);
/* rest of the initialisation goes here. */
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_driver example_driver = {
.driver = {
.owner = THIS_MODULE,
.name = "example",
},
.probe = example_probe,
.remove = example_remove,
.suspend = example_suspend,
.resume = example_resume,
};
_______________________________________________
i2c mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/i2c
A message that is not in the archive (sent off-list or not yet received): [email protected]
Hi Ben,
Quoted 10 lines · Ben Dooks
On Tue, Jun 03, 2008 at 01:29:06PM +0200, Laurent Pinchart wrote:
Thanks, here's the next version, and I have included the example driver post-editing at the end of the file. Also found a couple of items that I forgot to add.
V2:
Upgrading I2C Drivers to the new 2.6 Driver Model
=================================================
That's a good idea, thanks for doing this.
Quoted 21 lines
Ben Dooks <[email protected]>
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_driverexample_driver;
Quoted 8 lines
static unsigned short ignore[] = {
I2C_CLIENT_END}; static unsigned short normal_addr[] = {OUR_ADDR,I2C_CLIENT_END};static struct i2c_client_address_data addr_data = { .normal_i2c = normal_addr, .probe = ignore, .ignore = ignore, };
You could make the example slightly shorter with:
I2C_CLIENT_INSMOD;
Quoted 14 lines
static int
example_attach(struct i2c_adapter *adap, int addr, int kind){ struct example_state *state; struct device *dev = &adap->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; } example->i2c_client.addr = addr;
example->client.addr, same below and again later in the document.
Quoted 5 lines
example->i2c_client.flags = 0; example->i2c_client.adapter = adap; i2c_set_clientdata(&state->i2c_client, state); strlcpy(client->i2c_client.name, example_driver.driver.name,
It's a bad example, driver name != client name. Just use "example" as the client name. Would save you a forward declaration as well.
Quoted 10 lines
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;Doesn't seem terribly useful given that you skip all the code that would use it.
Quoted 7 lines
/* rest of the initialisation goes here. */ return 0; }static int
example_remove(struct i2c_client *client)
example_detach
Quoted 62 lines
{ 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_driverexample_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_adapter methods can be removed, along with the
addr_data, as follows- static struct
i2c_driverexample_driver;- static unsigned short ignore[] = {
I2C_CLIENT_END};
- static unsigned short normal_addr[] = {OUR_ADDR,I2C_CLIENT_END};- static struct
i2c_client_address_dataaddr_data= {(quoted diff) +0
-10- .normal_i2c = normal_addr, - .probe = ignore, - .ignore = ignore, - }; - 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_driverexample_driver= {(quoted diff) +2
-0+ .probe = example_probe, + .remove = example_remove, }
Quoted 5 lines
Change the
example_attachmethod to accept the new parameters which include thei2c_clientthat it will be working with:- static int
example_attach(struct i2c_adapter *adap, int addr, int kind)
+ static int example_probe(structi2c_client*i2c_client,
The client is typically named client, not i2c_client.
Quoted 15 lines
(quoted diff) +1
-0+ const struct i2c_device_id *id)Change the name of
example_attachtoexample_probeto align it with thei2c_driverentry names. The rest of the probe routine will now need to be changed as thei2c_clienthas already been setup for use.Remove the setting of address and adapter, they are now not needed.
(quoted diff) +0
-3- example->i2c_client.addr = addr; - example->i2c_client.flags = 0; - example->i2c_client.adapter = adap;Also remove the strlcpy, as the i2c_client's name is already filled in by the caller.
Review
Quoted 2 lines
(quoted diff) +0
-2- strlcpy(client->i2c_client.name, example_driver.driver.name, - I2C_NAME_SIZE);
In fact, the 3 items before are in the exact same case: they have already been set by the caller.
Quoted 12 lines
The
i2c_set_clientdatais now:(quoted diff) +1
-1- i2c_set_clientdata(&state->i2c_client, state); + i2c_set_clientdata(i2c_client, state);The call to
i2c_attach_clientis 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:
Review
Quoted 6 lines
(quoted diff) +0
-6- ret = i2c_attach_client(&state->i2c_client); - if (ret < 0) { - dev_err(dev, "failed to attach client\n"); - kfree(state); - return ret; - }
Doubled blank line.
Quoted 1 line
Remove the storage of 'struct
i2c_client' from the 'structexample_state'
Doubled space.
Review
Quoted 12 lines
as we are provided with the
i2c_clientin ourexample_probe. Instead we store a pointer to it for when it is needed.struct
example_state{(quoted diff) +1
-1- struct i2c_client client; + struct i2c_client *client;It is also necessary to change the temporary dev pointer to point into the new i2c client as so:
(quoted diff) +1
-1- struct device *dev = &adap->dev; + struct device *dev = &i2c_client->dev;
This is an implementation detail, many drivers don't use a local pointer for that, and it's IMHO rather confusing to present this as if an adapter had turned into a client. I think you can simply omit this, it's not worth insisting on.
Quoted 2 lines
And remove the change aftre our client is attached, as the driver no
Typo: after.
Quoted 32 lines
longer needs to register a new client structure with the core:
(quoted diff) +0
-1- 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 structi2c_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; }(quoted diff) +1
-0+ state->client = i2c_client;Update the remove method to delete the
i2c_detach_clientcall.static int
example_remove(struct i2c_client *client){ struct example_state *state = i2c_get_clientdata(client);(quoted diff) +0
-1- i2c_detach_client(client);
Quoted 4 lines
Our driver should now look like this:
struct example_state { struct i2c_client client;
*client
Quoted 4 lines
.... };static int example_probe(struct
i2c_client*i2c_client,
*client
Quoted 38 lines
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; i2c_set_clientdata(i2c_client, state); /* rest of the initialisation goes here. */ 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_driverexample_driver= {
.driver = {
.owner =THIS_MODULE,
.name = "example",
},
.probe =example_probe,
.remove =example_remove,
.suspend =example_suspend,
.resume =example_resume,
};
Signature · 6 lines
Jean Delvare _______________________________________________ i2c mailing list [email protected] http://lists.lm-sensors.org/mailman/listinfo/i2c