Merge branch 'cpus4096-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / media / video / gspca / m5602 / m5602_s5k83a.c
1 /*
2  * Driver for the s5k83a sensor
3  *
4  * Copyright (C) 2008 Erik AndrĂ©n
5  * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
6  * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
7  *
8  * Portions of code to USB interface and ALi driver software,
9  * Copyright (c) 2006 Willem Duinker
10  * v4l2 interface modeled after the V4L2 driver
11  * for SN9C10x PC Camera Controllers
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License as
15  * published by the Free Software Foundation, version 2.
16  *
17  */
18
19 #include "m5602_s5k83a.h"
20
21 static void s5k83a_dump_registers(struct sd *sd);
22
23 int s5k83a_probe(struct sd *sd)
24 {
25         u8 prod_id = 0, ver_id = 0;
26         int i, err = 0;
27
28         if (force_sensor) {
29                 if (force_sensor == S5K83A_SENSOR) {
30                         info("Forcing a %s sensor", s5k83a.name);
31                         goto sensor_found;
32                 }
33                 /* If we want to force another sensor, don't try to probe this
34                  * one */
35                 return -ENODEV;
36         }
37
38         info("Probing for a s5k83a sensor");
39
40         /* Preinit the sensor */
41         for (i = 0; i < ARRAY_SIZE(preinit_s5k83a) && !err; i++) {
42                 u8 data[2] = {preinit_s5k83a[i][2], preinit_s5k83a[i][3]};
43                 if (preinit_s5k83a[i][0] == SENSOR)
44                         err = m5602_write_sensor(sd, preinit_s5k83a[i][1],
45                                 data, 2);
46                 else
47                         err = m5602_write_bridge(sd, preinit_s5k83a[i][1],
48                                 data[0]);
49         }
50
51         /* We don't know what register (if any) that contain the product id
52          * Just pick the first addresses that seem to produce the same results
53          * on multiple machines */
54         if (m5602_read_sensor(sd, 0x00, &prod_id, 1))
55                 return -ENODEV;
56
57         if (m5602_read_sensor(sd, 0x01, &ver_id, 1))
58                 return -ENODEV;
59
60         if ((prod_id == 0xff) || (ver_id == 0xff))
61                 return -ENODEV;
62         else
63                 info("Detected a s5k83a sensor");
64
65 sensor_found:
66         sd->gspca_dev.cam.cam_mode = s5k83a.modes;
67         sd->gspca_dev.cam.nmodes = s5k83a.nmodes;
68         sd->desc->ctrls = s5k83a.ctrls;
69         sd->desc->nctrls = s5k83a.nctrls;
70         return 0;
71 }
72
73 int s5k83a_init(struct sd *sd)
74 {
75         int i, err = 0;
76
77         for (i = 0; i < ARRAY_SIZE(init_s5k83a) && !err; i++) {
78                 u8 data[2] = {0x00, 0x00};
79
80                 switch (init_s5k83a[i][0]) {
81                 case BRIDGE:
82                         err = m5602_write_bridge(sd,
83                                         init_s5k83a[i][1],
84                                         init_s5k83a[i][2]);
85                         break;
86
87                 case SENSOR:
88                         data[0] = init_s5k83a[i][2];
89                         err = m5602_write_sensor(sd,
90                                 init_s5k83a[i][1], data, 1);
91                         break;
92
93                 case SENSOR_LONG:
94                         data[0] = init_s5k83a[i][2];
95                         data[1] = init_s5k83a[i][3];
96                         err = m5602_write_sensor(sd,
97                                 init_s5k83a[i][1], data, 2);
98                         break;
99                 default:
100                         info("Invalid stream command, exiting init");
101                         return -EINVAL;
102                 }
103         }
104
105         if (dump_sensor)
106                 s5k83a_dump_registers(sd);
107
108         return (err < 0) ? err : 0;
109 }
110
111 int s5k83a_power_down(struct sd *sd)
112 {
113         return 0;
114 }
115
116 static void s5k83a_dump_registers(struct sd *sd)
117 {
118         int address;
119         u8 page, old_page;
120         m5602_read_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
121
122         for (page = 0; page < 16; page++) {
123                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
124                 info("Dumping the s5k83a register state for page 0x%x", page);
125                 for (address = 0; address <= 0xff; address++) {
126                         u8 val = 0;
127                         m5602_read_sensor(sd, address, &val, 1);
128                         info("register 0x%x contains 0x%x",
129                              address, val);
130                 }
131         }
132         info("s5k83a register state dump complete");
133
134         for (page = 0; page < 16; page++) {
135                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
136                 info("Probing for which registers that are read/write "
137                       "for page 0x%x", page);
138                 for (address = 0; address <= 0xff; address++) {
139                         u8 old_val, ctrl_val, test_val = 0xff;
140
141                         m5602_read_sensor(sd, address, &old_val, 1);
142                         m5602_write_sensor(sd, address, &test_val, 1);
143                         m5602_read_sensor(sd, address, &ctrl_val, 1);
144
145                         if (ctrl_val == test_val)
146                                 info("register 0x%x is writeable", address);
147                         else
148                                 info("register 0x%x is read only", address);
149
150                         /* Restore original val */
151                         m5602_write_sensor(sd, address, &old_val, 1);
152                 }
153         }
154         info("Read/write register probing complete");
155         m5602_write_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
156 }
157
158 int s5k83a_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
159 {
160         int err;
161         u8 data[2];
162         struct sd *sd = (struct sd *) gspca_dev;
163
164         err = m5602_read_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
165         if (err < 0)
166                 goto out;
167
168         data[1] = data[1] << 1;
169         *val = data[1];
170
171 out:
172         return err;
173 }
174
175 int s5k83a_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
176 {
177         int err;
178         u8 data[2];
179         struct sd *sd = (struct sd *) gspca_dev;
180
181         data[0] = 0x00;
182         data[1] = 0x20;
183         err = m5602_write_sensor(sd, 0x14, data, 2);
184         if (err < 0)
185                 goto out;
186
187         data[0] = 0x01;
188         data[1] = 0x00;
189         err = m5602_write_sensor(sd, 0x0d, data, 2);
190         if (err < 0)
191                 goto out;
192
193         /* FIXME: This is not sane, we need to figure out the composition
194                   of these registers */
195         data[0] = val >> 3; /* brightness, high 5 bits */
196         data[1] = val >> 1; /* brightness, high 7 bits */
197         err = m5602_write_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
198
199 out:
200         return err;
201 }
202
203 int s5k83a_get_whiteness(struct gspca_dev *gspca_dev, __s32 *val)
204 {
205         int err;
206         u8 data;
207         struct sd *sd = (struct sd *) gspca_dev;
208
209         err = m5602_read_sensor(sd, S5K83A_WHITENESS, &data, 1);
210         if (err < 0)
211                 goto out;
212
213         *val = data;
214
215 out:
216         return err;
217 }
218
219 int s5k83a_set_whiteness(struct gspca_dev *gspca_dev, __s32 val)
220 {
221         int err;
222         u8 data[1];
223         struct sd *sd = (struct sd *) gspca_dev;
224
225         data[0] = val;
226         err = m5602_write_sensor(sd, S5K83A_WHITENESS, data, 1);
227
228         return err;
229 }
230
231 int s5k83a_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
232 {
233         int err;
234         u8 data[2];
235         struct sd *sd = (struct sd *) gspca_dev;
236
237         err = m5602_read_sensor(sd, S5K83A_GAIN, data, 2);
238         if (err < 0)
239                 goto out;
240
241         data[1] = data[1] & 0x3f;
242         if (data[1] > S5K83A_MAXIMUM_GAIN)
243                 data[1] = S5K83A_MAXIMUM_GAIN;
244
245         *val = data[1];
246
247 out:
248         return err;
249 }
250
251 int s5k83a_set_gain(struct gspca_dev *gspca_dev, __s32 val)
252 {
253         int err;
254         u8 data[2];
255         struct sd *sd = (struct sd *) gspca_dev;
256
257         data[0] = 0;
258         data[1] = val;
259         err = m5602_write_sensor(sd, S5K83A_GAIN, data, 2);
260         return err;
261 }
262
263 int s5k83a_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
264 {
265         int err;
266         u8 data[1];
267         struct sd *sd = (struct sd *) gspca_dev;
268
269         data[0] = 0x05;
270         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
271         if (err < 0)
272                 goto out;
273
274         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
275         *val = (data[0] | 0x40) ? 1 : 0;
276
277 out:
278         return err;
279 }
280
281 int s5k83a_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
282 {
283         int err;
284         u8 data[1];
285         struct sd *sd = (struct sd *) gspca_dev;
286
287         data[0] = 0x05;
288         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
289         if (err < 0)
290                 goto out;
291
292         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
293         if (err < 0)
294                 goto out;
295
296         /* set or zero six bit, seven is hflip */
297         data[0] = (val) ? (data[0] & 0x80) | 0x40 | S5K83A_FLIP_MASK
298                         : (data[0] & 0x80) | S5K83A_FLIP_MASK;
299         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
300         if (err < 0)
301                 goto out;
302
303         data[0] = (val) ? 0x0b : 0x0a;
304         err = m5602_write_sensor(sd, S5K83A_VFLIP_TUNE, data, 1);
305
306 out:
307         return err;
308 }
309
310 int s5k83a_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
311 {
312         int err;
313         u8 data[1];
314         struct sd *sd = (struct sd *) gspca_dev;
315
316         data[0] = 0x05;
317         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
318         if (err < 0)
319                 goto out;
320
321         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
322         *val = (data[0] | 0x80) ? 1 : 0;
323
324 out:
325         return err;
326 }
327
328 int s5k83a_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
329 {
330         int err;
331         u8 data[1];
332         struct sd *sd = (struct sd *) gspca_dev;
333
334         data[0] = 0x05;
335         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
336         if (err < 0)
337                 goto out;
338
339         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
340         if (err < 0)
341                 goto out;
342
343         /* set or zero seven bit, six is vflip */
344         data[0] = (val) ? (data[0] & 0x40) | 0x80 | S5K83A_FLIP_MASK
345                         : (data[0] & 0x40) | S5K83A_FLIP_MASK;
346         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
347         if (err < 0)
348                 goto out;
349
350         data[0] = (val) ? 0x0a : 0x0b;
351         err = m5602_write_sensor(sd, S5K83A_HFLIP_TUNE, data, 1);
352 out:
353         return err;
354 }