Commit | Line | Data |
---|---|---|
31321b76 BD |
1 | Upgrading I2C Drivers to the new 2.6 Driver Model |
2 | ================================================= | |
3 | ||
4 | Ben Dooks <ben-linux@fluff.org> | |
5 | ||
6 | Introduction | |
7 | ------------ | |
8 | ||
9 | This guide outlines how to alter existing Linux 2.6 client drivers from | |
10 | the old to the new new binding methods. | |
11 | ||
12 | ||
13 | Example old-style driver | |
14 | ------------------------ | |
15 | ||
16 | ||
17 | struct example_state { | |
18 | struct i2c_client client; | |
19 | .... | |
20 | }; | |
21 | ||
22 | static struct i2c_driver example_driver; | |
23 | ||
24 | static unsigned short ignore[] = { I2C_CLIENT_END }; | |
25 | static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END }; | |
26 | ||
27 | I2C_CLIENT_INSMOD; | |
28 | ||
29 | static 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 | ||
64 | static int __devexit 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 | ||
73 | static int example_attach_adapter(struct i2c_adapter *adap) | |
74 | { | |
75 | return i2c_probe(adap, &addr_data, example_attach); | |
76 | } | |
77 | ||
78 | static struct i2c_driver example_driver = { | |
79 | .driver = { | |
80 | .owner = THIS_MODULE, | |
81 | .name = "example", | |
82 | }, | |
83 | .attach_adapter = example_attach_adapter, | |
84 | .detach_client = __devexit_p(example_detach), | |
85 | .suspend = example_suspend, | |
86 | .resume = example_resume, | |
87 | }; | |
88 | ||
89 | ||
90 | Updating the client | |
91 | ------------------- | |
92 | ||
93 | The new style binding model will check against a list of supported | |
94 | devices and their associated address supplied by the code registering | |
95 | the busses. This means that the driver .attach_adapter and | |
96 | .detach_adapter methods can be removed, along with the addr_data, | |
97 | as 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 = __devexit_p(example_detach), | |
114 | } | |
115 | ||
116 | Add 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 = __devexit_p(example_remove), | |
121 | } | |
122 | ||
123 | Change the example_attach method to accept the new parameters | |
124 | which 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 | ||
130 | Change the name of example_attach to example_probe to align it with the | |
131 | i2c_driver entry names. The rest of the probe routine will now need to be | |
132 | changed as the i2c_client has already been setup for use. | |
133 | ||
134 | The necessary client fields have already been setup before | |
135 | the probe function is called, so the following client setup | |
136 | can 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 | ||
144 | The i2c_set_clientdata is now: | |
145 | ||
146 | - i2c_set_clientdata(&state->client, state); | |
147 | + i2c_set_clientdata(client, state); | |
148 | ||
149 | The call to i2c_attach_client is no longer needed, if the probe | |
150 | routine exits successfully, then the driver will be automatically | |
151 | attached 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 | ||
161 | Remove the storage of 'struct i2c_client' from the 'struct example_state' | |
162 | as we are provided with the i2c_client in our example_probe. Instead we | |
163 | store a pointer to it for when it is needed. | |
164 | ||
165 | struct example_state { | |
166 | - struct i2c_client client; | |
167 | + struct i2c_client *client; | |
168 | ||
169 | the 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 | ||
174 | And remove the change after our client is attached, as the driver no | |
175 | longer needs to register a new client structure with the core: | |
176 | ||
177 | - dev = &state->i2c_client.dev; | |
178 | ||
179 | In the probe routine, ensure that the new state has the client stored | |
180 | in it: | |
181 | ||
182 | static 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 | ||
197 | Update the detach method, by changing the name to _remove and | |
198 | to delete the i2c_detach_client call. It is possible that you | |
199 | can also remove the ret variable as it is not not needed for | |
200 | any of the core functions. | |
201 | ||
202 | - static int __devexit example_detach(struct i2c_client *client) | |
203 | + static int __devexit example_remove(struct i2c_client *client) | |
204 | { | |
205 | struct example_state *state = i2c_get_clientdata(client); | |
206 | ||
207 | - i2c_detach_client(client); | |
208 | ||
209 | And finally ensure that we have the correct ID table for the i2c-core | |
210 | and other utilities: | |
211 | ||
212 | + struct i2c_device_id example_idtable[] = { | |
213 | + { "example", 0 }, | |
214 | + { } | |
215 | +}; | |
216 | + | |
217 | +MODULE_DEVICE_TABLE(i2c, example_idtable); | |
218 | ||
219 | static struct i2c_driver example_driver = { | |
220 | .driver = { | |
221 | .owner = THIS_MODULE, | |
222 | .name = "example", | |
223 | }, | |
224 | + .id_table = example_ids, | |
225 | ||
226 | ||
227 | Our driver should now look like this: | |
228 | ||
229 | struct example_state { | |
230 | struct i2c_client *client; | |
231 | .... | |
232 | }; | |
233 | ||
234 | static 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 | ||
256 | static int __devexit 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 | ||
264 | static struct i2c_device_id example_idtable[] = { | |
265 | { "example", 0 }, | |
266 | { } | |
267 | }; | |
268 | ||
269 | MODULE_DEVICE_TABLE(i2c, example_idtable); | |
270 | ||
271 | static 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 = __devexit_p(example_remove), | |
279 | .suspend = example_suspend, | |
280 | .resume = example_resume, | |
281 | }; |