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