?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "[PATCH] paravirt: Add startup infrastructure for paravirtualization"
[pv_ops_mirror.git] / drivers / media / video / sn9c102 / sn9c102_mi0360.c
blob64698acb0b15cd57feaa43a96bbfb6466b0729d9
1 /***************************************************************************
2 * Plug-in for MI-0360 image sensor connected to the SN9C1xx PC Camera *
3 * Controllers *
4 * *
5 * Copyright (C) 2007 by Luca Risolia <luca.risolia@studio.unibo.it> *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the Free Software *
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
20 ***************************************************************************/
21
22 #include "sn9c102_sensor.h"
23
24
25 static int mi0360_init(struct sn9c102_device* cam)
26 {
27 struct sn9c102_sensor* s = sn9c102_get_sensor(cam);
28 int err = 0;
29
30 err = sn9c102_write_const_regs(cam, {0x00, 0x10}, {0x00, 0x11},
31 {0x0a, 0x14}, {0x40, 0x01},
32 {0x20, 0x17}, {0x07, 0x18},
33 {0xa0, 0x19}, {0x02, 0x1c},
34 {0x03, 0x1d}, {0x0f, 0x1e},
35 {0x0c, 0x1f}, {0x00, 0x20},
36 {0x10, 0x21}, {0x20, 0x22},
37 {0x30, 0x23}, {0x40, 0x24},
38 {0x50, 0x25}, {0x60, 0x26},
39 {0x70, 0x27}, {0x80, 0x28},
40 {0x90, 0x29}, {0xa0, 0x2a},
41 {0xb0, 0x2b}, {0xc0, 0x2c},
42 {0xd0, 0x2d}, {0xe0, 0x2e},
43 {0xf0, 0x2f}, {0xff, 0x30});
44
45 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x0d,
46 0x00, 0x01, 0, 0);
47 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x0d,
48 0x00, 0x00, 0, 0);
49 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x03,
50 0x01, 0xe1, 0, 0);
51 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x04,
52 0x02, 0x81, 0, 0);
53 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x05,
54 0x00, 0x17, 0, 0);
55 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x06,
56 0x00, 0x11, 0, 0);
57 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id, 0x62,
58 0x04, 0x9a, 0, 0);
59
60 return err;
61 }
62
63
64 static int mi0360_get_ctrl(struct sn9c102_device* cam,
65 struct v4l2_control* ctrl)
66 {
67 struct sn9c102_sensor* s = sn9c102_get_sensor(cam);
68 u8 data[5+1];
69
70 switch (ctrl->id) {
71 case V4L2_CID_EXPOSURE:
72 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x09,
73 2+1, data) < 0)
74 return -EIO;
75 ctrl->value = data[2];
76 return 0;
77 case V4L2_CID_GAIN:
78 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x35,
79 2+1, data) < 0)
80 return -EIO;
81 ctrl->value = data[3];
82 return 0;
83 case V4L2_CID_RED_BALANCE:
84 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x2c,
85 2+1, data) < 0)
86 return -EIO;
87 ctrl->value = data[3];
88 return 0;
89 case V4L2_CID_BLUE_BALANCE:
90 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x2d,
91 2+1, data) < 0)
92 return -EIO;
93 ctrl->value = data[3];
94 return 0;
95 case SN9C102_V4L2_CID_GREEN_BALANCE:
96 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x2e,
97 2+1, data) < 0)
98 return -EIO;
99 ctrl->value = data[3];
100 return 0;
101 case V4L2_CID_HFLIP:
102 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x20,
103 2+1, data) < 0)
104 return -EIO;
105 ctrl->value = data[3] & 0x20 ? 1 : 0;
106 return 0;
107 case V4L2_CID_VFLIP:
108 if (sn9c102_i2c_try_raw_read(cam, s, s->i2c_slave_id, 0x20,
109 2+1, data) < 0)
110 return -EIO;
111 ctrl->value = data[3] & 0x80 ? 1 : 0;
112 return 0;
113 default:
114 return -EINVAL;
115 }
116
117 return 0;
118 }
119
120
121 static int mi0360_set_ctrl(struct sn9c102_device* cam,
122 const struct v4l2_control* ctrl)
123 {
124 struct sn9c102_sensor* s = sn9c102_get_sensor(cam);
125 int err = 0;
126
127 switch (ctrl->id) {
128 case V4L2_CID_EXPOSURE:
129 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
130 0x09, ctrl->value, 0x00,
131 0, 0);
132 break;
133 case V4L2_CID_GAIN:
134 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
135 0x35, 0x03, ctrl->value,
136 0, 0);
137 break;
138 case V4L2_CID_RED_BALANCE:
139 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
140 0x2c, 0x03, ctrl->value,
141 0, 0);
142 break;
143 case V4L2_CID_BLUE_BALANCE:
144 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
145 0x2d, 0x03, ctrl->value,
146 0, 0);
147 break;
148 case SN9C102_V4L2_CID_GREEN_BALANCE:
149 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
150 0x2b, 0x03, ctrl->value,
151 0, 0);
152 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
153 0x2e, 0x03, ctrl->value,
154 0, 0);
155 break;
156 case V4L2_CID_HFLIP:
157 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
158 0x20, ctrl->value ? 0x40:0x00,
159 ctrl->value ? 0x20:0x00,
160 0, 0);
161 break;
162 case V4L2_CID_VFLIP:
163 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
164 0x20, ctrl->value ? 0x80:0x00,
165 ctrl->value ? 0x80:0x00,
166 0, 0);
167 break;
168 default:
169 return -EINVAL;
170 }
171
172 return err ? -EIO : 0;
173 }
174
175
176 static int mi0360_set_crop(struct sn9c102_device* cam,
177 const struct v4l2_rect* rect)
178 {
179 struct sn9c102_sensor* s = sn9c102_get_sensor(cam);
180 int err = 0;
181 u8 h_start = (u8)(rect->left - s->cropcap.bounds.left) + 0,
182 v_start = (u8)(rect->top - s->cropcap.bounds.top) + 1;
183
184 err += sn9c102_write_reg(cam, h_start, 0x12);
185 err += sn9c102_write_reg(cam, v_start, 0x13);
186
187 return err;
188 }
189
190
191 static int mi0360_set_pix_format(struct sn9c102_device* cam,
192 const struct v4l2_pix_format* pix)
193 {
194 struct sn9c102_sensor* s = sn9c102_get_sensor(cam);
195 int err = 0;
196
197 if (pix->pixelformat == V4L2_PIX_FMT_SN9C10X) {
198 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
199 0x0a, 0x00, 0x02, 0, 0);
200 err += sn9c102_write_reg(cam, 0x20, 0x19);
201 } else {
202 err += sn9c102_i2c_try_raw_write(cam, s, 4, s->i2c_slave_id,
203 0x0a, 0x00, 0x05, 0, 0);
204 err += sn9c102_write_reg(cam, 0x60, 0x19);
205 }
206
207 return err;
208 }
209
210
211 static struct sn9c102_sensor mi0360 = {
212 .name = "MI-0360",
213 .maintainer = "Luca Risolia <luca.risolia@studio.unibo.it>",
214 .supported_bridge = BRIDGE_SN9C103,
215 .frequency = SN9C102_I2C_100KHZ,
216 .interface = SN9C102_I2C_2WIRES,
217 .i2c_slave_id = 0x5d,
218 .init = &mi0360_init,
219 .qctrl = {
220 {
221 .id = V4L2_CID_EXPOSURE,
222 .type = V4L2_CTRL_TYPE_INTEGER,
223 .name = "exposure",
224 .minimum = 0x00,
225 .maximum = 0x0f,
226 .step = 0x01,
227 .default_value = 0x05,
228 .flags = 0,
229 },
230 {
231 .id = V4L2_CID_GAIN,
232 .type = V4L2_CTRL_TYPE_INTEGER,
233 .name = "global gain",
234 .minimum = 0x00,
235 .maximum = 0x7f,
236 .step = 0x01,
237 .default_value = 0x25,
238 .flags = 0,
239 },
240 {
241 .id = V4L2_CID_HFLIP,
242 .type = V4L2_CTRL_TYPE_BOOLEAN,
243 .name = "horizontal mirror",
244 .minimum = 0,
245 .maximum = 1,
246 .step = 1,
247 .default_value = 0,
248 .flags = 0,
249 },
250 {
251 .id = V4L2_CID_VFLIP,
252 .type = V4L2_CTRL_TYPE_BOOLEAN,
253 .name = "vertical mirror",
254 .minimum = 0,
255 .maximum = 1,
256 .step = 1,
257 .default_value = 0,
258 .flags = 0,
259 },
260 {
261 .id = V4L2_CID_BLUE_BALANCE,
262 .type = V4L2_CTRL_TYPE_INTEGER,
263 .name = "blue balance",
264 .minimum = 0x00,
265 .maximum = 0x7f,
266 .step = 0x01,
267 .default_value = 0x0f,
268 .flags = 0,
269 },
270 {
271 .id = V4L2_CID_RED_BALANCE,
272 .type = V4L2_CTRL_TYPE_INTEGER,
273 .name = "red balance",
274 .minimum = 0x00,
275 .maximum = 0x7f,
276 .step = 0x01,
277 .default_value = 0x32,
278 .flags = 0,
279 },
280 {
281 .id = SN9C102_V4L2_CID_GREEN_BALANCE,
282 .type = V4L2_CTRL_TYPE_INTEGER,
283 .name = "green balance",
284 .minimum = 0x00,
285 .maximum = 0x7f,
286 .step = 0x01,
287 .default_value = 0x25,
288 .flags = 0,
289 },
290 },
291 .get_ctrl = &mi0360_get_ctrl,
292 .set_ctrl = &mi0360_set_ctrl,
293 .cropcap = {
294 .bounds = {
295 .left = 0,
296 .top = 0,
297 .width = 640,
298 .height = 480,
299 },
300 .defrect = {
301 .left = 0,
302 .top = 0,
303 .width = 640,
304 .height = 480,
305 },
306 },
307 .set_crop = &mi0360_set_crop,
308 .pix_format = {
309 .width = 640,
310 .height = 480,
311 .pixelformat = V4L2_PIX_FMT_SBGGR8,
312 .priv = 8,
313 },
314 .set_pix_format = &mi0360_set_pix_format
315 };
316
317
318 int sn9c102_probe_mi0360(struct sn9c102_device* cam)
319 {
320 u8 data[5+1];
321 int err;
322
323 err = sn9c102_write_const_regs(cam, {0x01, 0x01}, {0x00, 0x01},
324 {0x28, 0x17});
325 if (err)
326 return -EIO;
327
328 if (sn9c102_i2c_try_raw_read(cam, &mi0360, mi0360.i2c_slave_id, 0x00,
329 2+1, data) < 0)
330 return -EIO;
331
332 if (data[2] != 0x82 || data[3] != 0x43)
333 return -ENODEV;
334
335 sn9c102_attach_sensor(cam, &mi0360);
336
337 return 0;
338 }
Mirror for ia64_pv_ops.git