1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/delay.h>
24#include <linux/i2c.h>
25#include <linux/init.h>
26#include <linux/kernel.h>
27#include <linux/math64.h>
28#include <linux/module.h>
29#include <linux/mutex.h>
30#include <linux/slab.h>
31#include <linux/v4l2-mediabus.h>
32
33#include <media/media-entity.h>
34#include <media/mt9m032.h>
35#include <media/v4l2-ctrls.h>
36#include <media/v4l2-device.h>
37#include <media/v4l2-subdev.h>
38
39#include "aptina-pll.h"
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56#define MT9M032_PIXEL_ARRAY_WIDTH 1600
57#define MT9M032_PIXEL_ARRAY_HEIGHT 1152
58
59#define MT9M032_CHIP_VERSION 0x00
60#define MT9M032_CHIP_VERSION_VALUE 0x1402
61#define MT9M032_ROW_START 0x01
62#define MT9M032_ROW_START_MIN 0
63#define MT9M032_ROW_START_MAX 1152
64#define MT9M032_ROW_START_DEF 60
65#define MT9M032_COLUMN_START 0x02
66#define MT9M032_COLUMN_START_MIN 0
67#define MT9M032_COLUMN_START_MAX 1600
68#define MT9M032_COLUMN_START_DEF 16
69#define MT9M032_ROW_SIZE 0x03
70#define MT9M032_ROW_SIZE_MIN 32
71#define MT9M032_ROW_SIZE_MAX 1152
72#define MT9M032_ROW_SIZE_DEF 1080
73#define MT9M032_COLUMN_SIZE 0x04
74#define MT9M032_COLUMN_SIZE_MIN 32
75#define MT9M032_COLUMN_SIZE_MAX 1600
76#define MT9M032_COLUMN_SIZE_DEF 1440
77#define MT9M032_HBLANK 0x05
78#define MT9M032_VBLANK 0x06
79#define MT9M032_VBLANK_MAX 0x7ff
80#define MT9M032_SHUTTER_WIDTH_HIGH 0x08
81#define MT9M032_SHUTTER_WIDTH_LOW 0x09
82#define MT9M032_SHUTTER_WIDTH_MIN 1
83#define MT9M032_SHUTTER_WIDTH_MAX 1048575
84#define MT9M032_SHUTTER_WIDTH_DEF 1943
85#define MT9M032_PIX_CLK_CTRL 0x0a
86#define MT9M032_PIX_CLK_CTRL_INV_PIXCLK 0x8000
87#define MT9M032_RESTART 0x0b
88#define MT9M032_RESET 0x0d
89#define MT9M032_PLL_CONFIG1 0x11
90#define MT9M032_PLL_CONFIG1_PREDIV_MASK 0x3f
91#define MT9M032_PLL_CONFIG1_MUL_SHIFT 8
92#define MT9M032_READ_MODE1 0x1e
93#define MT9M032_READ_MODE1_OUTPUT_BAD_FRAMES (1 << 13)
94#define MT9M032_READ_MODE1_MAINTAIN_FRAME_RATE (1 << 12)
95#define MT9M032_READ_MODE1_XOR_LINE_VALID (1 << 11)
96#define MT9M032_READ_MODE1_CONT_LINE_VALID (1 << 10)
97#define MT9M032_READ_MODE1_INVERT_TRIGGER (1 << 9)
98#define MT9M032_READ_MODE1_SNAPSHOT (1 << 8)
99#define MT9M032_READ_MODE1_GLOBAL_RESET (1 << 7)
100#define MT9M032_READ_MODE1_BULB_EXPOSURE (1 << 6)
101#define MT9M032_READ_MODE1_INVERT_STROBE (1 << 5)
102#define MT9M032_READ_MODE1_STROBE_ENABLE (1 << 4)
103#define MT9M032_READ_MODE1_STROBE_START_TRIG1 (0 << 2)
104#define MT9M032_READ_MODE1_STROBE_START_EXP (1 << 2)
105#define MT9M032_READ_MODE1_STROBE_START_SHUTTER (2 << 2)
106#define MT9M032_READ_MODE1_STROBE_START_TRIG2 (3 << 2)
107#define MT9M032_READ_MODE1_STROBE_END_TRIG1 (0 << 0)
108#define MT9M032_READ_MODE1_STROBE_END_EXP (1 << 0)
109#define MT9M032_READ_MODE1_STROBE_END_SHUTTER (2 << 0)
110#define MT9M032_READ_MODE1_STROBE_END_TRIG2 (3 << 0)
111#define MT9M032_READ_MODE2 0x20
112#define MT9M032_READ_MODE2_VFLIP_SHIFT 15
113#define MT9M032_READ_MODE2_HFLIP_SHIFT 14
114#define MT9M032_READ_MODE2_ROW_BLC 0x40
115#define MT9M032_GAIN_GREEN1 0x2b
116#define MT9M032_GAIN_BLUE 0x2c
117#define MT9M032_GAIN_RED 0x2d
118#define MT9M032_GAIN_GREEN2 0x2e
119
120
121#define MT9M032_GAIN_ALL 0x35
122#define MT9M032_GAIN_DIGITAL_MASK 0x7f
123#define MT9M032_GAIN_DIGITAL_SHIFT 8
124#define MT9M032_GAIN_AMUL_SHIFT 6
125#define MT9M032_GAIN_ANALOG_MASK 0x3f
126#define MT9M032_FORMATTER1 0x9e
127#define MT9M032_FORMATTER1_PLL_P1_6 (1 << 8)
128#define MT9M032_FORMATTER1_PARALLEL (1 << 12)
129#define MT9M032_FORMATTER2 0x9f
130#define MT9M032_FORMATTER2_DOUT_EN 0x1000
131#define MT9M032_FORMATTER2_PIXCLK_EN 0x2000
132
133
134
135
136
137
138
139
140#define MT9P031_PLL_CONTROL 0x10
141#define MT9P031_PLL_CONTROL_PWROFF 0x0050
142#define MT9P031_PLL_CONTROL_PWRON 0x0051
143#define MT9P031_PLL_CONTROL_USEPLL 0x0052
144
145struct mt9m032 {
146 struct v4l2_subdev subdev;
147 struct media_pad pad;
148 struct mt9m032_platform_data *pdata;
149
150 unsigned int pix_clock;
151
152 struct v4l2_ctrl_handler ctrls;
153 struct {
154 struct v4l2_ctrl *hflip;
155 struct v4l2_ctrl *vflip;
156 };
157
158 struct mutex lock;
159
160 bool streaming;
161
162 struct v4l2_mbus_framefmt format;
163 struct v4l2_rect crop;
164 struct v4l2_fract frame_interval;
165};
166
167#define to_mt9m032(sd) container_of(sd, struct mt9m032, subdev)
168#define to_dev(sensor) \
169 (&((struct i2c_client *)v4l2_get_subdevdata(&(sensor)->subdev))->dev)
170
171static int mt9m032_read(struct i2c_client *client, u8 reg)
172{
173 return i2c_smbus_read_word_swapped(client, reg);
174}
175
176static int mt9m032_write(struct i2c_client *client, u8 reg, const u16 data)
177{
178 return i2c_smbus_write_word_swapped(client, reg, data);
179}
180
181static u32 mt9m032_row_time(struct mt9m032 *sensor, unsigned int width)
182{
183 unsigned int effective_width;
184 u32 ns;
185
186 effective_width = width + 716;
187 ns = div_u64(1000000000ULL * effective_width, sensor->pix_clock);
188 dev_dbg(to_dev(sensor), "MT9M032 line time: %u ns\n", ns);
189 return ns;
190}
191
192static int mt9m032_update_timing(struct mt9m032 *sensor,
193 struct v4l2_fract *interval)
194{
195 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
196 struct v4l2_rect *crop = &sensor->crop;
197 unsigned int min_vblank;
198 unsigned int vblank;
199 u32 row_time;
200
201 if (!interval)
202 interval = &sensor->frame_interval;
203
204 row_time = mt9m032_row_time(sensor, crop->width);
205
206 vblank = div_u64(1000000000ULL * interval->numerator,
207 (u64)row_time * interval->denominator)
208 - crop->height;
209
210 if (vblank > MT9M032_VBLANK_MAX) {
211
212 interval->denominator = 1000;
213 interval->numerator =
214 div_u64((crop->height + MT9M032_VBLANK_MAX) *
215 (u64)row_time * interval->denominator,
216 1000000000ULL);
217 vblank = div_u64(1000000000ULL * interval->numerator,
218 (u64)row_time * interval->denominator)
219 - crop->height;
220 }
221
222 min_vblank = 1600000 / row_time;
223 vblank = clamp_t(unsigned int, vblank, min_vblank, MT9M032_VBLANK_MAX);
224
225 return mt9m032_write(client, MT9M032_VBLANK, vblank);
226}
227
228static int mt9m032_update_geom_timing(struct mt9m032 *sensor)
229{
230 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
231 int ret;
232
233 ret = mt9m032_write(client, MT9M032_COLUMN_SIZE,
234 sensor->crop.width - 1);
235 if (!ret)
236 ret = mt9m032_write(client, MT9M032_ROW_SIZE,
237 sensor->crop.height - 1);
238 if (!ret)
239 ret = mt9m032_write(client, MT9M032_COLUMN_START,
240 sensor->crop.left);
241 if (!ret)
242 ret = mt9m032_write(client, MT9M032_ROW_START,
243 sensor->crop.top);
244 if (!ret)
245 ret = mt9m032_update_timing(sensor, NULL);
246 return ret;
247}
248
249static int update_formatter2(struct mt9m032 *sensor, bool streaming)
250{
251 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
252 u16 reg_val = MT9M032_FORMATTER2_DOUT_EN
253 | 0x0070;
254
255
256 if (streaming)
257 reg_val |= MT9M032_FORMATTER2_PIXCLK_EN;
258
259 return mt9m032_write(client, MT9M032_FORMATTER2, reg_val);
260}
261
262static int mt9m032_setup_pll(struct mt9m032 *sensor)
263{
264 static const struct aptina_pll_limits limits = {
265 .ext_clock_min = 8000000,
266 .ext_clock_max = 16500000,
267 .int_clock_min = 2000000,
268 .int_clock_max = 24000000,
269 .out_clock_min = 322000000,
270 .out_clock_max = 693000000,
271 .pix_clock_max = 99000000,
272 .n_min = 1,
273 .n_max = 64,
274 .m_min = 16,
275 .m_max = 255,
276 .p1_min = 6,
277 .p1_max = 7,
278 };
279
280 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
281 struct mt9m032_platform_data *pdata = sensor->pdata;
282 struct aptina_pll pll;
283 u16 reg_val;
284 int ret;
285
286 pll.ext_clock = pdata->ext_clock;
287 pll.pix_clock = pdata->pix_clock;
288
289 ret = aptina_pll_calculate(&client->dev, &limits, &pll);
290 if (ret < 0)
291 return ret;
292
293 sensor->pix_clock = pdata->pix_clock;
294
295 ret = mt9m032_write(client, MT9M032_PLL_CONFIG1,
296 (pll.m << MT9M032_PLL_CONFIG1_MUL_SHIFT) |
297 ((pll.n - 1) & MT9M032_PLL_CONFIG1_PREDIV_MASK));
298 if (!ret)
299 ret = mt9m032_write(client, MT9P031_PLL_CONTROL,
300 MT9P031_PLL_CONTROL_PWRON |
301 MT9P031_PLL_CONTROL_USEPLL);
302 if (!ret)
303 ret = mt9m032_write(client, MT9M032_READ_MODE1, 0x8000 |
304 MT9M032_READ_MODE1_STROBE_START_EXP |
305 MT9M032_READ_MODE1_STROBE_END_SHUTTER);
306 if (!ret) {
307 reg_val = (pll.p1 == 6 ? MT9M032_FORMATTER1_PLL_P1_6 : 0)
308 | MT9M032_FORMATTER1_PARALLEL | 0x001e;
309 ret = mt9m032_write(client, MT9M032_FORMATTER1, reg_val);
310 }
311
312 return ret;
313}
314
315
316
317
318
319static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
320 struct v4l2_subdev_fh *fh,
321 struct v4l2_subdev_mbus_code_enum *code)
322{
323 if (code->index != 0)
324 return -EINVAL;
325
326 code->code = V4L2_MBUS_FMT_Y8_1X8;
327 return 0;
328}
329
330static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
331 struct v4l2_subdev_fh *fh,
332 struct v4l2_subdev_frame_size_enum *fse)
333{
334 if (fse->index != 0 || fse->code != V4L2_MBUS_FMT_Y8_1X8)
335 return -EINVAL;
336
337 fse->min_width = MT9M032_COLUMN_SIZE_DEF;
338 fse->max_width = MT9M032_COLUMN_SIZE_DEF;
339 fse->min_height = MT9M032_ROW_SIZE_DEF;
340 fse->max_height = MT9M032_ROW_SIZE_DEF;
341
342 return 0;
343}
344
345
346
347
348
349
350
351
352
353static struct v4l2_rect *
354__mt9m032_get_pad_crop(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
355 enum v4l2_subdev_format_whence which)
356{
357 switch (which) {
358 case V4L2_SUBDEV_FORMAT_TRY:
359 return v4l2_subdev_get_try_crop(fh, 0);
360 case V4L2_SUBDEV_FORMAT_ACTIVE:
361 return &sensor->crop;
362 default:
363 return NULL;
364 }
365}
366
367
368
369
370
371
372
373
374
375static struct v4l2_mbus_framefmt *
376__mt9m032_get_pad_format(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
377 enum v4l2_subdev_format_whence which)
378{
379 switch (which) {
380 case V4L2_SUBDEV_FORMAT_TRY:
381 return v4l2_subdev_get_try_format(fh, 0);
382 case V4L2_SUBDEV_FORMAT_ACTIVE:
383 return &sensor->format;
384 default:
385 return NULL;
386 }
387}
388
389static int mt9m032_get_pad_format(struct v4l2_subdev *subdev,
390 struct v4l2_subdev_fh *fh,
391 struct v4l2_subdev_format *fmt)
392{
393 struct mt9m032 *sensor = to_mt9m032(subdev);
394
395 mutex_lock(&sensor->lock);
396 fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
397 mutex_unlock(&sensor->lock);
398
399 return 0;
400}
401
402static int mt9m032_set_pad_format(struct v4l2_subdev *subdev,
403 struct v4l2_subdev_fh *fh,
404 struct v4l2_subdev_format *fmt)
405{
406 struct mt9m032 *sensor = to_mt9m032(subdev);
407 int ret;
408
409 mutex_lock(&sensor->lock);
410
411 if (sensor->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
412 ret = -EBUSY;
413 goto done;
414 }
415
416
417 fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
418 ret = 0;
419
420done:
421 mutex_unlock(&sensor->lock);
422 return ret;
423}
424
425static int mt9m032_get_pad_crop(struct v4l2_subdev *subdev,
426 struct v4l2_subdev_fh *fh,
427 struct v4l2_subdev_crop *crop)
428{
429 struct mt9m032 *sensor = to_mt9m032(subdev);
430
431 mutex_lock(&sensor->lock);
432 crop->rect = *__mt9m032_get_pad_crop(sensor, fh, crop->which);
433 mutex_unlock(&sensor->lock);
434
435 return 0;
436}
437
438static int mt9m032_set_pad_crop(struct v4l2_subdev *subdev,
439 struct v4l2_subdev_fh *fh,
440 struct v4l2_subdev_crop *crop)
441{
442 struct mt9m032 *sensor = to_mt9m032(subdev);
443 struct v4l2_mbus_framefmt *format;
444 struct v4l2_rect *__crop;
445 struct v4l2_rect rect;
446 int ret = 0;
447
448 mutex_lock(&sensor->lock);
449
450 if (sensor->streaming && crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
451 ret = -EBUSY;
452 goto done;
453 }
454
455
456
457
458 rect.left = clamp(ALIGN(crop->rect.left, 2), MT9M032_COLUMN_START_MIN,
459 MT9M032_COLUMN_START_MAX);
460 rect.top = clamp(ALIGN(crop->rect.top, 2), MT9M032_ROW_START_MIN,
461 MT9M032_ROW_START_MAX);
462 rect.width = clamp(ALIGN(crop->rect.width, 2), MT9M032_COLUMN_SIZE_MIN,
463 MT9M032_COLUMN_SIZE_MAX);
464 rect.height = clamp(ALIGN(crop->rect.height, 2), MT9M032_ROW_SIZE_MIN,
465 MT9M032_ROW_SIZE_MAX);
466
467 rect.width = min(rect.width, MT9M032_PIXEL_ARRAY_WIDTH - rect.left);
468 rect.height = min(rect.height, MT9M032_PIXEL_ARRAY_HEIGHT - rect.top);
469
470 __crop = __mt9m032_get_pad_crop(sensor, fh, crop->which);
471
472 if (rect.width != __crop->width || rect.height != __crop->height) {
473
474
475
476 format = __mt9m032_get_pad_format(sensor, fh, crop->which);
477 format->width = rect.width;
478 format->height = rect.height;
479 }
480
481 *__crop = rect;
482 crop->rect = rect;
483
484 if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE)
485 ret = mt9m032_update_geom_timing(sensor);
486
487done:
488 mutex_unlock(&sensor->lock);
489 return ret;
490}
491
492static int mt9m032_get_frame_interval(struct v4l2_subdev *subdev,
493 struct v4l2_subdev_frame_interval *fi)
494{
495 struct mt9m032 *sensor = to_mt9m032(subdev);
496
497 mutex_lock(&sensor->lock);
498 memset(fi, 0, sizeof(*fi));
499 fi->interval = sensor->frame_interval;
500 mutex_unlock(&sensor->lock);
501
502 return 0;
503}
504
505static int mt9m032_set_frame_interval(struct v4l2_subdev *subdev,
506 struct v4l2_subdev_frame_interval *fi)
507{
508 struct mt9m032 *sensor = to_mt9m032(subdev);
509 int ret;
510
511 mutex_lock(&sensor->lock);
512
513 if (sensor->streaming) {
514 ret = -EBUSY;
515 goto done;
516 }
517
518
519 if (fi->interval.denominator == 0)
520 fi->interval.denominator = 1;
521
522 ret = mt9m032_update_timing(sensor, &fi->interval);
523 if (!ret)
524 sensor->frame_interval = fi->interval;
525
526done:
527 mutex_unlock(&sensor->lock);
528 return ret;
529}
530
531static int mt9m032_s_stream(struct v4l2_subdev *subdev, int streaming)
532{
533 struct mt9m032 *sensor = to_mt9m032(subdev);
534 int ret;
535
536 mutex_lock(&sensor->lock);
537 ret = update_formatter2(sensor, streaming);
538 if (!ret)
539 sensor->streaming = streaming;
540 mutex_unlock(&sensor->lock);
541
542 return ret;
543}
544
545
546
547
548
549#ifdef CONFIG_VIDEO_ADV_DEBUG
550static int mt9m032_g_register(struct v4l2_subdev *sd,
551 struct v4l2_dbg_register *reg)
552{
553 struct mt9m032 *sensor = to_mt9m032(sd);
554 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
555 int val;
556
557 if (reg->reg > 0xff)
558 return -EINVAL;
559
560 val = mt9m032_read(client, reg->reg);
561 if (val < 0)
562 return -EIO;
563
564 reg->size = 2;
565 reg->val = val;
566
567 return 0;
568}
569
570static int mt9m032_s_register(struct v4l2_subdev *sd,
571 const struct v4l2_dbg_register *reg)
572{
573 struct mt9m032 *sensor = to_mt9m032(sd);
574 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
575
576 if (reg->reg > 0xff)
577 return -EINVAL;
578
579 return mt9m032_write(client, reg->reg, reg->val);
580}
581#endif
582
583
584
585
586
587static int update_read_mode2(struct mt9m032 *sensor, bool vflip, bool hflip)
588{
589 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
590 int reg_val = (vflip << MT9M032_READ_MODE2_VFLIP_SHIFT)
591 | (hflip << MT9M032_READ_MODE2_HFLIP_SHIFT)
592 | MT9M032_READ_MODE2_ROW_BLC
593 | 0x0007;
594
595 return mt9m032_write(client, MT9M032_READ_MODE2, reg_val);
596}
597
598static int mt9m032_set_gain(struct mt9m032 *sensor, s32 val)
599{
600 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
601 int digital_gain_val;
602 int analog_mul;
603 int analog_gain_val;
604 u16 reg_val;
605
606 digital_gain_val = 51;
607
608 if (val < 63) {
609 analog_mul = 0;
610 analog_gain_val = val;
611 } else {
612 analog_mul = 1;
613 analog_gain_val = val / 2;
614 }
615
616
617
618
619 reg_val = ((digital_gain_val & MT9M032_GAIN_DIGITAL_MASK)
620 << MT9M032_GAIN_DIGITAL_SHIFT)
621 | ((analog_mul & 1) << MT9M032_GAIN_AMUL_SHIFT)
622 | (analog_gain_val & MT9M032_GAIN_ANALOG_MASK);
623
624 return mt9m032_write(client, MT9M032_GAIN_ALL, reg_val);
625}
626
627static int mt9m032_try_ctrl(struct v4l2_ctrl *ctrl)
628{
629 if (ctrl->id == V4L2_CID_GAIN && ctrl->val >= 63) {
630
631 ctrl->val &= ~1;
632 }
633
634 return 0;
635}
636
637static int mt9m032_set_ctrl(struct v4l2_ctrl *ctrl)
638{
639 struct mt9m032 *sensor =
640 container_of(ctrl->handler, struct mt9m032, ctrls);
641 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
642 int ret;
643
644 switch (ctrl->id) {
645 case V4L2_CID_GAIN:
646 return mt9m032_set_gain(sensor, ctrl->val);
647
648 case V4L2_CID_HFLIP:
649
650 return update_read_mode2(sensor, sensor->vflip->val,
651 sensor->hflip->val);
652
653 case V4L2_CID_EXPOSURE:
654 ret = mt9m032_write(client, MT9M032_SHUTTER_WIDTH_HIGH,
655 (ctrl->val >> 16) & 0xffff);
656 if (ret < 0)
657 return ret;
658
659 return mt9m032_write(client, MT9M032_SHUTTER_WIDTH_LOW,
660 ctrl->val & 0xffff);
661 }
662
663 return 0;
664}
665
666static struct v4l2_ctrl_ops mt9m032_ctrl_ops = {
667 .s_ctrl = mt9m032_set_ctrl,
668 .try_ctrl = mt9m032_try_ctrl,
669};
670
671
672
673static const struct v4l2_subdev_core_ops mt9m032_core_ops = {
674#ifdef CONFIG_VIDEO_ADV_DEBUG
675 .g_register = mt9m032_g_register,
676 .s_register = mt9m032_s_register,
677#endif
678};
679
680static const struct v4l2_subdev_video_ops mt9m032_video_ops = {
681 .s_stream = mt9m032_s_stream,
682 .g_frame_interval = mt9m032_get_frame_interval,
683 .s_frame_interval = mt9m032_set_frame_interval,
684};
685
686static const struct v4l2_subdev_pad_ops mt9m032_pad_ops = {
687 .enum_mbus_code = mt9m032_enum_mbus_code,
688 .enum_frame_size = mt9m032_enum_frame_size,
689 .get_fmt = mt9m032_get_pad_format,
690 .set_fmt = mt9m032_set_pad_format,
691 .set_crop = mt9m032_set_pad_crop,
692 .get_crop = mt9m032_get_pad_crop,
693};
694
695static const struct v4l2_subdev_ops mt9m032_ops = {
696 .core = &mt9m032_core_ops,
697 .video = &mt9m032_video_ops,
698 .pad = &mt9m032_pad_ops,
699};
700
701
702
703
704
705static int mt9m032_probe(struct i2c_client *client,
706 const struct i2c_device_id *devid)
707{
708 struct mt9m032_platform_data *pdata = client->dev.platform_data;
709 struct i2c_adapter *adapter = client->adapter;
710 struct mt9m032 *sensor;
711 int chip_version;
712 int ret;
713
714 if (pdata == NULL) {
715 dev_err(&client->dev, "No platform data\n");
716 return -EINVAL;
717 }
718
719 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
720 dev_warn(&client->dev,
721 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
722 return -EIO;
723 }
724
725 if (!client->dev.platform_data)
726 return -ENODEV;
727
728 sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
729 if (sensor == NULL)
730 return -ENOMEM;
731
732 mutex_init(&sensor->lock);
733
734 sensor->pdata = pdata;
735
736 v4l2_i2c_subdev_init(&sensor->subdev, client, &mt9m032_ops);
737 sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
738
739 chip_version = mt9m032_read(client, MT9M032_CHIP_VERSION);
740 if (chip_version != MT9M032_CHIP_VERSION_VALUE) {
741 dev_err(&client->dev, "MT9M032 not detected, wrong version "
742 "0x%04x\n", chip_version);
743 ret = -ENODEV;
744 goto error_sensor;
745 }
746
747 dev_info(&client->dev, "MT9M032 detected at address 0x%02x\n",
748 client->addr);
749
750 sensor->frame_interval.numerator = 1;
751 sensor->frame_interval.denominator = 30;
752
753 sensor->crop.left = MT9M032_COLUMN_START_DEF;
754 sensor->crop.top = MT9M032_ROW_START_DEF;
755 sensor->crop.width = MT9M032_COLUMN_SIZE_DEF;
756 sensor->crop.height = MT9M032_ROW_SIZE_DEF;
757
758 sensor->format.width = sensor->crop.width;
759 sensor->format.height = sensor->crop.height;
760 sensor->format.code = V4L2_MBUS_FMT_Y8_1X8;
761 sensor->format.field = V4L2_FIELD_NONE;
762 sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
763
764 v4l2_ctrl_handler_init(&sensor->ctrls, 5);
765
766 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
767 V4L2_CID_GAIN, 0, 127, 1, 64);
768
769 sensor->hflip = v4l2_ctrl_new_std(&sensor->ctrls,
770 &mt9m032_ctrl_ops,
771 V4L2_CID_HFLIP, 0, 1, 1, 0);
772 sensor->vflip = v4l2_ctrl_new_std(&sensor->ctrls,
773 &mt9m032_ctrl_ops,
774 V4L2_CID_VFLIP, 0, 1, 1, 0);
775
776 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
777 V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,
778 MT9M032_SHUTTER_WIDTH_MAX, 1,
779 MT9M032_SHUTTER_WIDTH_DEF);
780 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
781 V4L2_CID_PIXEL_RATE, pdata->pix_clock,
782 pdata->pix_clock, 1, pdata->pix_clock);
783
784 if (sensor->ctrls.error) {
785 ret = sensor->ctrls.error;
786 dev_err(&client->dev, "control initialization error %d\n", ret);
787 goto error_ctrl;
788 }
789
790 v4l2_ctrl_cluster(2, &sensor->hflip);
791
792 sensor->subdev.ctrl_handler = &sensor->ctrls;
793 sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
794 ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);
795 if (ret < 0)
796 goto error_ctrl;
797
798 ret = mt9m032_write(client, MT9M032_RESET, 1);
799 if (ret < 0)
800 goto error_entity;
801 ret = mt9m032_write(client, MT9M032_RESET, 0);
802 if (ret < 0)
803 goto error_entity;
804
805 ret = mt9m032_setup_pll(sensor);
806 if (ret < 0)
807 goto error_entity;
808 usleep_range(10000, 11000);
809
810 ret = v4l2_ctrl_handler_setup(&sensor->ctrls);
811 if (ret < 0)
812 goto error_entity;
813
814
815 ret = mt9m032_update_geom_timing(sensor);
816 if (ret < 0)
817 goto error_entity;
818
819 ret = mt9m032_write(client, 0x41, 0x0000);
820 if (ret < 0)
821 goto error_entity;
822 ret = mt9m032_write(client, 0x42, 0x0003);
823 if (ret < 0)
824 goto error_entity;
825 ret = mt9m032_write(client, 0x43, 0x0003);
826 if (ret < 0)
827 goto error_entity;
828 ret = mt9m032_write(client, 0x7f, 0x0000);
829 if (ret < 0)
830 goto error_entity;
831 if (sensor->pdata->invert_pixclock) {
832 ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,
833 MT9M032_PIX_CLK_CTRL_INV_PIXCLK);
834 if (ret < 0)
835 goto error_entity;
836 }
837
838 ret = mt9m032_write(client, MT9M032_RESTART, 1);
839 if (ret < 0)
840 goto error_entity;
841 msleep(100);
842 ret = mt9m032_write(client, MT9M032_RESTART, 0);
843 if (ret < 0)
844 goto error_entity;
845 msleep(100);
846 ret = update_formatter2(sensor, false);
847 if (ret < 0)
848 goto error_entity;
849
850 return ret;
851
852error_entity:
853 media_entity_cleanup(&sensor->subdev.entity);
854error_ctrl:
855 v4l2_ctrl_handler_free(&sensor->ctrls);
856error_sensor:
857 mutex_destroy(&sensor->lock);
858 return ret;
859}
860
861static int mt9m032_remove(struct i2c_client *client)
862{
863 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
864 struct mt9m032 *sensor = to_mt9m032(subdev);
865
866 v4l2_device_unregister_subdev(subdev);
867 v4l2_ctrl_handler_free(&sensor->ctrls);
868 media_entity_cleanup(&subdev->entity);
869 mutex_destroy(&sensor->lock);
870 return 0;
871}
872
873static const struct i2c_device_id mt9m032_id_table[] = {
874 { MT9M032_NAME, 0 },
875 { }
876};
877
878MODULE_DEVICE_TABLE(i2c, mt9m032_id_table);
879
880static struct i2c_driver mt9m032_i2c_driver = {
881 .driver = {
882 .name = MT9M032_NAME,
883 },
884 .probe = mt9m032_probe,
885 .remove = mt9m032_remove,
886 .id_table = mt9m032_id_table,
887};
888
889module_i2c_driver(mt9m032_i2c_driver);
890
891MODULE_AUTHOR("Martin Hostettler <martin@neutronstar.dyndns.org>");
892MODULE_DESCRIPTION("MT9M032 camera sensor driver");
893MODULE_LICENSE("GPL v2");
894
