?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: qmi_wwan: add Olivetti Olicard 500
[linux/fpc-iii.git] / drivers / media / i2c / soc_camera / mt9m001.c
blobdf97033fa6ef3a0386900b029df456fbb1957401
1 /*
2 * Driver for MT9M001 CMOS Image Sensor from Micron
3 *
4 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11 #include <linux/videodev2.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/log2.h>
15 #include <linux/module.h>
16
17 #include <media/soc_camera.h>
18 #include <media/soc_mediabus.h>
19 #include <media/v4l2-clk.h>
20 #include <media/v4l2-subdev.h>
21 #include <media/v4l2-ctrls.h>
22
23 /*
24 * mt9m001 i2c address 0x5d
25 * The platform has to define struct i2c_board_info objects and link to them
26 * from struct soc_camera_host_desc
27 */
28
29 /* mt9m001 selected register addresses */
30 #define MT9M001_CHIP_VERSION 0x00
31 #define MT9M001_ROW_START 0x01
32 #define MT9M001_COLUMN_START 0x02
33 #define MT9M001_WINDOW_HEIGHT 0x03
34 #define MT9M001_WINDOW_WIDTH 0x04
35 #define MT9M001_HORIZONTAL_BLANKING 0x05
36 #define MT9M001_VERTICAL_BLANKING 0x06
37 #define MT9M001_OUTPUT_CONTROL 0x07
38 #define MT9M001_SHUTTER_WIDTH 0x09
39 #define MT9M001_FRAME_RESTART 0x0b
40 #define MT9M001_SHUTTER_DELAY 0x0c
41 #define MT9M001_RESET 0x0d
42 #define MT9M001_READ_OPTIONS1 0x1e
43 #define MT9M001_READ_OPTIONS2 0x20
44 #define MT9M001_GLOBAL_GAIN 0x35
45 #define MT9M001_CHIP_ENABLE 0xF1
46
47 #define MT9M001_MAX_WIDTH 1280
48 #define MT9M001_MAX_HEIGHT 1024
49 #define MT9M001_MIN_WIDTH 48
50 #define MT9M001_MIN_HEIGHT 32
51 #define MT9M001_COLUMN_SKIP 20
52 #define MT9M001_ROW_SKIP 12
53
54 /* MT9M001 has only one fixed colorspace per pixelcode */
55 struct mt9m001_datafmt {
56 enum v4l2_mbus_pixelcode code;
57 enum v4l2_colorspace colorspace;
58 };
59
60 /* Find a data format by a pixel code in an array */
61 static const struct mt9m001_datafmt *mt9m001_find_datafmt(
62 enum v4l2_mbus_pixelcode code, const struct mt9m001_datafmt *fmt,
63 int n)
64 {
65 int i;
66 for (i = 0; i < n; i++)
67 if (fmt[i].code == code)
68 return fmt + i;
69
70 return NULL;
71 }
72
73 static const struct mt9m001_datafmt mt9m001_colour_fmts[] = {
74 /*
75 * Order important: first natively supported,
76 * second supported with a GPIO extender
77 */
78 {V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB},
79 {V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
80 };
81
82 static const struct mt9m001_datafmt mt9m001_monochrome_fmts[] = {
83 /* Order important - see above */
84 {V4L2_MBUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG},
85 {V4L2_MBUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG},
86 };
87
88 struct mt9m001 {
89 struct v4l2_subdev subdev;
90 struct v4l2_ctrl_handler hdl;
91 struct {
92 /* exposure/auto-exposure cluster */
93 struct v4l2_ctrl *autoexposure;
94 struct v4l2_ctrl *exposure;
95 };
96 struct v4l2_rect rect; /* Sensor window */
97 struct v4l2_clk *clk;
98 const struct mt9m001_datafmt *fmt;
99 const struct mt9m001_datafmt *fmts;
100 int num_fmts;
101 unsigned int total_h;
102 unsigned short y_skip_top; /* Lines to skip at the top */
103 };
104
105 static struct mt9m001 *to_mt9m001(const struct i2c_client *client)
106 {
107 return container_of(i2c_get_clientdata(client), struct mt9m001, subdev);
108 }
109
110 static int reg_read(struct i2c_client *client, const u8 reg)
111 {
112 return i2c_smbus_read_word_swapped(client, reg);
113 }
114
115 static int reg_write(struct i2c_client *client, const u8 reg,
116 const u16 data)
117 {
118 return i2c_smbus_write_word_swapped(client, reg, data);
119 }
120
121 static int reg_set(struct i2c_client *client, const u8 reg,
122 const u16 data)
123 {
124 int ret;
125
126 ret = reg_read(client, reg);
127 if (ret < 0)
128 return ret;
129 return reg_write(client, reg, ret | data);
130 }
131
132 static int reg_clear(struct i2c_client *client, const u8 reg,
133 const u16 data)
134 {
135 int ret;
136
137 ret = reg_read(client, reg);
138 if (ret < 0)
139 return ret;
140 return reg_write(client, reg, ret & ~data);
141 }
142
143 static int mt9m001_init(struct i2c_client *client)
144 {
145 int ret;
146
147 dev_dbg(&client->dev, "%s\n", __func__);
148
149 /*
150 * We don't know, whether platform provides reset, issue a soft reset
151 * too. This returns all registers to their default values.
152 */
153 ret = reg_write(client, MT9M001_RESET, 1);
154 if (!ret)
155 ret = reg_write(client, MT9M001_RESET, 0);
156
157 /* Disable chip, synchronous option update */
158 if (!ret)
159 ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 0);
160
161 return ret;
162 }
163
164 static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)
165 {
166 struct i2c_client *client = v4l2_get_subdevdata(sd);
167
168 /* Switch to master "normal" mode or stop sensor readout */
169 if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0)
170 return -EIO;
171 return 0;
172 }
173
174 static int mt9m001_s_crop(struct v4l2_subdev *sd, const struct v4l2_crop *a)
175 {
176 struct i2c_client *client = v4l2_get_subdevdata(sd);
177 struct mt9m001 *mt9m001 = to_mt9m001(client);
178 struct v4l2_rect rect = a->c;
179 int ret;
180 const u16 hblank = 9, vblank = 25;
181
182 if (mt9m001->fmts == mt9m001_colour_fmts)
183 /*
184 * Bayer format - even number of rows for simplicity,
185 * but let the user play with the top row.
186 */
187 rect.height = ALIGN(rect.height, 2);
188
189 /* Datasheet requirement: see register description */
190 rect.width = ALIGN(rect.width, 2);
191 rect.left = ALIGN(rect.left, 2);
192
193 soc_camera_limit_side(&rect.left, &rect.width,
194 MT9M001_COLUMN_SKIP, MT9M001_MIN_WIDTH, MT9M001_MAX_WIDTH);
195
196 soc_camera_limit_side(&rect.top, &rect.height,
197 MT9M001_ROW_SKIP, MT9M001_MIN_HEIGHT, MT9M001_MAX_HEIGHT);
198
199 mt9m001->total_h = rect.height + mt9m001->y_skip_top + vblank;
200
201 /* Blanking and start values - default... */
202 ret = reg_write(client, MT9M001_HORIZONTAL_BLANKING, hblank);
203 if (!ret)
204 ret = reg_write(client, MT9M001_VERTICAL_BLANKING, vblank);
205
206 /*
207 * The caller provides a supported format, as verified per
208 * call to .try_mbus_fmt()
209 */
210 if (!ret)
211 ret = reg_write(client, MT9M001_COLUMN_START, rect.left);
212 if (!ret)
213 ret = reg_write(client, MT9M001_ROW_START, rect.top);
214 if (!ret)
215 ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect.width - 1);
216 if (!ret)
217 ret = reg_write(client, MT9M001_WINDOW_HEIGHT,
218 rect.height + mt9m001->y_skip_top - 1);
219 if (!ret && v4l2_ctrl_g_ctrl(mt9m001->autoexposure) == V4L2_EXPOSURE_AUTO)
220 ret = reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h);
221
222 if (!ret)
223 mt9m001->rect = rect;
224
225 return ret;
226 }
227
228 static int mt9m001_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
229 {
230 struct i2c_client *client = v4l2_get_subdevdata(sd);
231 struct mt9m001 *mt9m001 = to_mt9m001(client);
232
233 a->c = mt9m001->rect;
234 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
235
236 return 0;
237 }
238
239 static int mt9m001_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
240 {
241 a->bounds.left = MT9M001_COLUMN_SKIP;
242 a->bounds.top = MT9M001_ROW_SKIP;
243 a->bounds.width = MT9M001_MAX_WIDTH;
244 a->bounds.height = MT9M001_MAX_HEIGHT;
245 a->defrect = a->bounds;
246 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
247 a->pixelaspect.numerator = 1;
248 a->pixelaspect.denominator = 1;
249
250 return 0;
251 }
252
253 static int mt9m001_g_fmt(struct v4l2_subdev *sd,
254 struct v4l2_mbus_framefmt *mf)
255 {
256 struct i2c_client *client = v4l2_get_subdevdata(sd);
257 struct mt9m001 *mt9m001 = to_mt9m001(client);
258
259 mf->width = mt9m001->rect.width;
260 mf->height = mt9m001->rect.height;
261 mf->code = mt9m001->fmt->code;
262 mf->colorspace = mt9m001->fmt->colorspace;
263 mf->field = V4L2_FIELD_NONE;
264
265 return 0;
266 }
267
268 static int mt9m001_s_fmt(struct v4l2_subdev *sd,
269 struct v4l2_mbus_framefmt *mf)
270 {
271 struct i2c_client *client = v4l2_get_subdevdata(sd);
272 struct mt9m001 *mt9m001 = to_mt9m001(client);
273 struct v4l2_crop a = {
274 .c = {
275 .left = mt9m001->rect.left,
276 .top = mt9m001->rect.top,
277 .width = mf->width,
278 .height = mf->height,
279 },
280 };
281 int ret;
282
283 /* No support for scaling so far, just crop. TODO: use skipping */
284 ret = mt9m001_s_crop(sd, &a);
285 if (!ret) {
286 mf->width = mt9m001->rect.width;
287 mf->height = mt9m001->rect.height;
288 mt9m001->fmt = mt9m001_find_datafmt(mf->code,
289 mt9m001->fmts, mt9m001->num_fmts);
290 mf->colorspace = mt9m001->fmt->colorspace;
291 }
292
293 return ret;
294 }
295
296 static int mt9m001_try_fmt(struct v4l2_subdev *sd,
297 struct v4l2_mbus_framefmt *mf)
298 {
299 struct i2c_client *client = v4l2_get_subdevdata(sd);
300 struct mt9m001 *mt9m001 = to_mt9m001(client);
301 const struct mt9m001_datafmt *fmt;
302
303 v4l_bound_align_image(&mf->width, MT9M001_MIN_WIDTH,
304 MT9M001_MAX_WIDTH, 1,
305 &mf->height, MT9M001_MIN_HEIGHT + mt9m001->y_skip_top,
306 MT9M001_MAX_HEIGHT + mt9m001->y_skip_top, 0, 0);
307
308 if (mt9m001->fmts == mt9m001_colour_fmts)
309 mf->height = ALIGN(mf->height - 1, 2);
310
311 fmt = mt9m001_find_datafmt(mf->code, mt9m001->fmts,
312 mt9m001->num_fmts);
313 if (!fmt) {
314 fmt = mt9m001->fmt;
315 mf->code = fmt->code;
316 }
317
318 mf->colorspace = fmt->colorspace;
319
320 return 0;
321 }
322
323 #ifdef CONFIG_VIDEO_ADV_DEBUG
324 static int mt9m001_g_register(struct v4l2_subdev *sd,
325 struct v4l2_dbg_register *reg)
326 {
327 struct i2c_client *client = v4l2_get_subdevdata(sd);
328
329 if (reg->reg > 0xff)
330 return -EINVAL;
331
332 reg->size = 2;
333 reg->val = reg_read(client, reg->reg);
334
335 if (reg->val > 0xffff)
336 return -EIO;
337
338 return 0;
339 }
340
341 static int mt9m001_s_register(struct v4l2_subdev *sd,
342 const struct v4l2_dbg_register *reg)
343 {
344 struct i2c_client *client = v4l2_get_subdevdata(sd);
345
346 if (reg->reg > 0xff)
347 return -EINVAL;
348
349 if (reg_write(client, reg->reg, reg->val) < 0)
350 return -EIO;
351
352 return 0;
353 }
354 #endif
355
356 static int mt9m001_s_power(struct v4l2_subdev *sd, int on)
357 {
358 struct i2c_client *client = v4l2_get_subdevdata(sd);
359 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
360 struct mt9m001 *mt9m001 = to_mt9m001(client);
361
362 return soc_camera_set_power(&client->dev, ssdd, mt9m001->clk, on);
363 }
364
365 static int mt9m001_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
366 {
367 struct mt9m001 *mt9m001 = container_of(ctrl->handler,
368 struct mt9m001, hdl);
369 s32 min, max;
370
371 switch (ctrl->id) {
372 case V4L2_CID_EXPOSURE_AUTO:
373 min = mt9m001->exposure->minimum;
374 max = mt9m001->exposure->maximum;
375 mt9m001->exposure->val =
376 (524 + (mt9m001->total_h - 1) * (max - min)) / 1048 + min;
377 break;
378 }
379 return 0;
380 }
381
382 static int mt9m001_s_ctrl(struct v4l2_ctrl *ctrl)
383 {
384 struct mt9m001 *mt9m001 = container_of(ctrl->handler,
385 struct mt9m001, hdl);
386 struct v4l2_subdev *sd = &mt9m001->subdev;
387 struct i2c_client *client = v4l2_get_subdevdata(sd);
388 struct v4l2_ctrl *exp = mt9m001->exposure;
389 int data;
390
391 switch (ctrl->id) {
392 case V4L2_CID_VFLIP:
393 if (ctrl->val)
394 data = reg_set(client, MT9M001_READ_OPTIONS2, 0x8000);
395 else
396 data = reg_clear(client, MT9M001_READ_OPTIONS2, 0x8000);
397 if (data < 0)
398 return -EIO;
399 return 0;
400
401 case V4L2_CID_GAIN:
402 /* See Datasheet Table 7, Gain settings. */
403 if (ctrl->val <= ctrl->default_value) {
404 /* Pack it into 0..1 step 0.125, register values 0..8 */
405 unsigned long range = ctrl->default_value - ctrl->minimum;
406 data = ((ctrl->val - ctrl->minimum) * 8 + range / 2) / range;
407
408 dev_dbg(&client->dev, "Setting gain %d\n", data);
409 data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
410 if (data < 0)
411 return -EIO;
412 } else {
413 /* Pack it into 1.125..15 variable step, register values 9..67 */
414 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
415 unsigned long range = ctrl->maximum - ctrl->default_value - 1;
416 unsigned long gain = ((ctrl->val - ctrl->default_value - 1) *
417 111 + range / 2) / range + 9;
418
419 if (gain <= 32)
420 data = gain;
421 else if (gain <= 64)
422 data = ((gain - 32) * 16 + 16) / 32 + 80;
423 else
424 data = ((gain - 64) * 7 + 28) / 56 + 96;
425
426 dev_dbg(&client->dev, "Setting gain from %d to %d\n",
427 reg_read(client, MT9M001_GLOBAL_GAIN), data);
428 data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
429 if (data < 0)
430 return -EIO;
431 }
432 return 0;
433
434 case V4L2_CID_EXPOSURE_AUTO:
435 if (ctrl->val == V4L2_EXPOSURE_MANUAL) {
436 unsigned long range = exp->maximum - exp->minimum;
437 unsigned long shutter = ((exp->val - exp->minimum) * 1048 +
438 range / 2) / range + 1;
439
440 dev_dbg(&client->dev,
441 "Setting shutter width from %d to %lu\n",
442 reg_read(client, MT9M001_SHUTTER_WIDTH), shutter);
443 if (reg_write(client, MT9M001_SHUTTER_WIDTH, shutter) < 0)
444 return -EIO;
445 } else {
446 const u16 vblank = 25;
447
448 mt9m001->total_h = mt9m001->rect.height +
449 mt9m001->y_skip_top + vblank;
450 if (reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h) < 0)
451 return -EIO;
452 }
453 return 0;
454 }
455 return -EINVAL;
456 }
457
458 /*
459 * Interface active, can use i2c. If it fails, it can indeed mean, that
460 * this wasn't our capture interface, so, we wait for the right one
461 */
462 static int mt9m001_video_probe(struct soc_camera_subdev_desc *ssdd,
463 struct i2c_client *client)
464 {
465 struct mt9m001 *mt9m001 = to_mt9m001(client);
466 s32 data;
467 unsigned long flags;
468 int ret;
469
470 ret = mt9m001_s_power(&mt9m001->subdev, 1);
471 if (ret < 0)
472 return ret;
473
474 /* Enable the chip */
475 data = reg_write(client, MT9M001_CHIP_ENABLE, 1);
476 dev_dbg(&client->dev, "write: %d\n", data);
477
478 /* Read out the chip version register */
479 data = reg_read(client, MT9M001_CHIP_VERSION);
480
481 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
482 switch (data) {
483 case 0x8411:
484 case 0x8421:
485 mt9m001->fmts = mt9m001_colour_fmts;
486 break;
487 case 0x8431:
488 mt9m001->fmts = mt9m001_monochrome_fmts;
489 break;
490 default:
491 dev_err(&client->dev,
492 "No MT9M001 chip detected, register read %x\n", data);
493 ret = -ENODEV;
494 goto done;
495 }
496
497 mt9m001->num_fmts = 0;
498
499 /*
500 * This is a 10bit sensor, so by default we only allow 10bit.
501 * The platform may support different bus widths due to
502 * different routing of the data lines.
503 */
504 if (ssdd->query_bus_param)
505 flags = ssdd->query_bus_param(ssdd);
506 else
507 flags = SOCAM_DATAWIDTH_10;
508
509 if (flags & SOCAM_DATAWIDTH_10)
510 mt9m001->num_fmts++;
511 else
512 mt9m001->fmts++;
513
514 if (flags & SOCAM_DATAWIDTH_8)
515 mt9m001->num_fmts++;
516
517 mt9m001->fmt = &mt9m001->fmts[0];
518
519 dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
520 data == 0x8431 ? "C12STM" : "C12ST");
521
522 ret = mt9m001_init(client);
523 if (ret < 0) {
524 dev_err(&client->dev, "Failed to initialise the camera\n");
525 goto done;
526 }
527
528 /* mt9m001_init() has reset the chip, returning registers to defaults */
529 ret = v4l2_ctrl_handler_setup(&mt9m001->hdl);
530
531 done:
532 mt9m001_s_power(&mt9m001->subdev, 0);
533 return ret;
534 }
535
536 static void mt9m001_video_remove(struct soc_camera_subdev_desc *ssdd)
537 {
538 if (ssdd->free_bus)
539 ssdd->free_bus(ssdd);
540 }
541
542 static int mt9m001_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)
543 {
544 struct i2c_client *client = v4l2_get_subdevdata(sd);
545 struct mt9m001 *mt9m001 = to_mt9m001(client);
546
547 *lines = mt9m001->y_skip_top;
548
549 return 0;
550 }
551
552 static const struct v4l2_ctrl_ops mt9m001_ctrl_ops = {
553 .g_volatile_ctrl = mt9m001_g_volatile_ctrl,
554 .s_ctrl = mt9m001_s_ctrl,
555 };
556
557 static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {
558 #ifdef CONFIG_VIDEO_ADV_DEBUG
559 .g_register = mt9m001_g_register,
560 .s_register = mt9m001_s_register,
561 #endif
562 .s_power = mt9m001_s_power,
563 };
564
565 static int mt9m001_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
566 enum v4l2_mbus_pixelcode *code)
567 {
568 struct i2c_client *client = v4l2_get_subdevdata(sd);
569 struct mt9m001 *mt9m001 = to_mt9m001(client);
570
571 if (index >= mt9m001->num_fmts)
572 return -EINVAL;
573
574 *code = mt9m001->fmts[index].code;
575 return 0;
576 }
577
578 static int mt9m001_g_mbus_config(struct v4l2_subdev *sd,
579 struct v4l2_mbus_config *cfg)
580 {
581 struct i2c_client *client = v4l2_get_subdevdata(sd);
582 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
583
584 /* MT9M001 has all capture_format parameters fixed */
585 cfg->flags = V4L2_MBUS_PCLK_SAMPLE_FALLING |
586 V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH |
587 V4L2_MBUS_DATA_ACTIVE_HIGH | V4L2_MBUS_MASTER;
588 cfg->type = V4L2_MBUS_PARALLEL;
589 cfg->flags = soc_camera_apply_board_flags(ssdd, cfg);
590
591 return 0;
592 }
593
594 static int mt9m001_s_mbus_config(struct v4l2_subdev *sd,
595 const struct v4l2_mbus_config *cfg)
596 {
597 const struct i2c_client *client = v4l2_get_subdevdata(sd);
598 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
599 struct mt9m001 *mt9m001 = to_mt9m001(client);
600 unsigned int bps = soc_mbus_get_fmtdesc(mt9m001->fmt->code)->bits_per_sample;
601
602 if (ssdd->set_bus_param)
603 return ssdd->set_bus_param(ssdd, 1 << (bps - 1));
604
605 /*
606 * Without board specific bus width settings we only support the
607 * sensors native bus width
608 */
609 return bps == 10 ? 0 : -EINVAL;
610 }
611
612 static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {
613 .s_stream = mt9m001_s_stream,
614 .s_mbus_fmt = mt9m001_s_fmt,
615 .g_mbus_fmt = mt9m001_g_fmt,
616 .try_mbus_fmt = mt9m001_try_fmt,
617 .s_crop = mt9m001_s_crop,
618 .g_crop = mt9m001_g_crop,
619 .cropcap = mt9m001_cropcap,
620 .enum_mbus_fmt = mt9m001_enum_fmt,
621 .g_mbus_config = mt9m001_g_mbus_config,
622 .s_mbus_config = mt9m001_s_mbus_config,
623 };
624
625 static struct v4l2_subdev_sensor_ops mt9m001_subdev_sensor_ops = {
626 .g_skip_top_lines = mt9m001_g_skip_top_lines,
627 };
628
629 static struct v4l2_subdev_ops mt9m001_subdev_ops = {
630 .core = &mt9m001_subdev_core_ops,
631 .video = &mt9m001_subdev_video_ops,
632 .sensor = &mt9m001_subdev_sensor_ops,
633 };
634
635 static int mt9m001_probe(struct i2c_client *client,
636 const struct i2c_device_id *did)
637 {
638 struct mt9m001 *mt9m001;
639 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
640 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
641 int ret;
642
643 if (!ssdd) {
644 dev_err(&client->dev, "MT9M001 driver needs platform data\n");
645 return -EINVAL;
646 }
647
648 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
649 dev_warn(&adapter->dev,
650 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
651 return -EIO;
652 }
653
654 mt9m001 = devm_kzalloc(&client->dev, sizeof(struct mt9m001), GFP_KERNEL);
655 if (!mt9m001)
656 return -ENOMEM;
657
658 v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);
659 v4l2_ctrl_handler_init(&mt9m001->hdl, 4);
660 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
661 V4L2_CID_VFLIP, 0, 1, 1, 0);
662 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
663 V4L2_CID_GAIN, 0, 127, 1, 64);
664 mt9m001->exposure = v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,
665 V4L2_CID_EXPOSURE, 1, 255, 1, 255);
666 /*
667 * Simulated autoexposure. If enabled, we calculate shutter width
668 * ourselves in the driver based on vertical blanking and frame width
669 */
670 mt9m001->autoexposure = v4l2_ctrl_new_std_menu(&mt9m001->hdl,
671 &mt9m001_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
672 V4L2_EXPOSURE_AUTO);
673 mt9m001->subdev.ctrl_handler = &mt9m001->hdl;
674 if (mt9m001->hdl.error)
675 return mt9m001->hdl.error;
676
677 v4l2_ctrl_auto_cluster(2, &mt9m001->autoexposure,
678 V4L2_EXPOSURE_MANUAL, true);
679
680 /* Second stage probe - when a capture adapter is there */
681 mt9m001->y_skip_top = 0;
682 mt9m001->rect.left = MT9M001_COLUMN_SKIP;
683 mt9m001->rect.top = MT9M001_ROW_SKIP;
684 mt9m001->rect.width = MT9M001_MAX_WIDTH;
685 mt9m001->rect.height = MT9M001_MAX_HEIGHT;
686
687 mt9m001->clk = v4l2_clk_get(&client->dev, "mclk");
688 if (IS_ERR(mt9m001->clk)) {
689 ret = PTR_ERR(mt9m001->clk);
690 goto eclkget;
691 }
692
693 ret = mt9m001_video_probe(ssdd, client);
694 if (ret) {
695 v4l2_clk_put(mt9m001->clk);
696 eclkget:
697 v4l2_ctrl_handler_free(&mt9m001->hdl);
698 }
699
700 return ret;
701 }
702
703 static int mt9m001_remove(struct i2c_client *client)
704 {
705 struct mt9m001 *mt9m001 = to_mt9m001(client);
706 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
707
708 v4l2_clk_put(mt9m001->clk);
709 v4l2_device_unregister_subdev(&mt9m001->subdev);
710 v4l2_ctrl_handler_free(&mt9m001->hdl);
711 mt9m001_video_remove(ssdd);
712
713 return 0;
714 }
715
716 static const struct i2c_device_id mt9m001_id[] = {
717 { "mt9m001", 0 },
718 { }
719 };
720 MODULE_DEVICE_TABLE(i2c, mt9m001_id);
721
722 static struct i2c_driver mt9m001_i2c_driver = {
723 .driver = {
724 .name = "mt9m001",
725 },
726 .probe = mt9m001_probe,
727 .remove = mt9m001_remove,
728 .id_table = mt9m001_id,
729 };
730
731 module_i2c_driver(mt9m001_i2c_driver);
732
733 MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
734 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
735 MODULE_LICENSE("GPL");
Linux with added FPC-III support