Root/
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 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 = 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_client 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 = 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 = 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 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 | |
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 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 = example_remove, |
279 | .suspend = example_suspend, |
280 | .resume = example_resume, |
281 | }; |
282 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9