i2c/chips: Remove deprecated pca9539 driver
[linux-2.6.git] / Documentation / i2c / upgrading-clients
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 };