mt9t112: Add Context selection to configuration
[beagleboard-validation:linux.git] / drivers / media / video / mt9t112.c
1 /*
2  * mt9t112 Camera Driver
3  *
4  * Copyright (C) 2009 Renesas Solutions Corp.
5  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
6  *
7  * Based on ov772x driver, mt9m111 driver,
8  *
9  * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
10  * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
11  * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
12  * Copyright (C) 2008 Magnus Damm
13  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License version 2 as
17  * published by the Free Software Foundation.
18  */
19
20 #include <linux/delay.h>
21 #include <linux/i2c.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/videodev2.h>
26
27 #include <media/mt9t112.h>
28 #include <media/v4l2-int-device.h>
29 #include <media/v4l2-chip-ident.h>
30
31 /* you can check PLL/clock info */
32 /* #define EXT_CLOCK 24000000 */
33
34 /************************************************************************
35
36
37                         macro
38
39
40 ************************************************************************/
41 /*
42  * frame size
43  */
44 #define MAX_WIDTH   2048
45 #define MAX_HEIGHT  1536
46
47 #define MAX_WIDTH_PREV   1024
48 #define MAX_HEIGHT_PREV  768
49
50 #define VGA_WIDTH   640
51 #define VGA_HEIGHT  480
52
53 /*
54  * macro of read/write
55  */
56 #define ECHECKER(ret, x)                \
57         do {                            \
58                 (ret) = (x);            \
59                 if ((ret) < 0)          \
60                         return (ret);   \
61         } while (0)
62
63 #define mt9t112_reg_write(ret, client, a, b) \
64         ECHECKER(ret, __mt9t112_reg_write(client, a, b))
65 #define mt9t112_mcu_write(ret, client, a, b) \
66         ECHECKER(ret, __mt9t112_mcu_write(client, a, b))
67
68 #define mt9t112_reg_mask_set(ret, client, a, b, c) \
69         ECHECKER(ret, __mt9t112_reg_mask_set(client, a, b, c))
70 #define mt9t112_mcu_mask_set(ret, client, a, b, c) \
71         ECHECKER(ret, __mt9t112_mcu_mask_set(client, a, b, c))
72
73 #define mt9t112_reg_read(ret, client, a) \
74         ECHECKER(ret, __mt9t112_reg_read(client, a))
75
76 #define mt9t112_mcu_read(ret, client, a) \
77         ECHECKER(ret, __mt9t112_mcu_read(client, a))
78
79 /*
80  * Logical address
81  */
82 #define _VAR(id, offset, base)  (base | (id & 0x1f) << 10 | (offset & 0x3ff))
83 #define VAR(id, offset)  _VAR(id, offset, 0x0000)
84 #define VAR8(id, offset) _VAR(id, offset, 0x8000)
85
86 /************************************************************************
87
88
89                         struct
90
91
92 ************************************************************************/
93 struct mt9t112_frame_size {
94         u16 width;
95         u16 height;
96 };
97
98 struct mt9t112_priv {
99         struct mt9t112_platform_data    *pdata;
100         struct v4l2_int_device          *v4l2_int_device;
101         struct mt9t112_camera_info      info;
102         struct i2c_client               *client;
103         struct v4l2_pix_format           pix;
104         int                              model;
105         u32                              flags;
106 /* for flags */
107 #define INIT_DONE  (1<<0)
108 };
109
110 /************************************************************************
111
112
113                         supported format
114
115
116 ************************************************************************/
117
118 const static struct v4l2_fmtdesc mt9t112_formats[] = {
119         {
120                 .description    = "YUYV (YUV 4:2:2), packed",
121                 .pixelformat    = V4L2_PIX_FMT_YUYV,
122         },
123         {
124                 .description    = "RGB555, le",
125                 .pixelformat    = V4L2_PIX_FMT_RGB555,
126         },
127         {
128                 .description    = "RGB565, le",
129                 .pixelformat    = V4L2_PIX_FMT_RGB565,
130         },
131 };
132
133 /************************************************************************
134
135
136                         supported sizes
137
138
139 ************************************************************************/
140 const static struct mt9t112_frame_size mt9t112_sizes[] = {
141         {  640, 480 },
142         { 2048, 1536}
143 };
144
145 /************************************************************************
146
147
148                         supported sizes
149
150
151 ************************************************************************/
152 const struct v4l2_fract mt9t112_frameintervals[] = {
153         {  .numerator = 1, .denominator = 30 }
154 };
155
156 /************************************************************************
157
158
159                         general function
160
161
162 ************************************************************************/
163 static u16 mt9t112_pixfmt_to_fmt(u32 pixelformat)
164 {
165         switch (pixelformat) {
166         case V4L2_PIX_FMT_RGB555:
167                 return 8;
168         case V4L2_PIX_FMT_RGB565:
169                 return 4;
170         case V4L2_PIX_FMT_YUYV:
171                 /* FALLTHROUGH */
172         default:
173                 return 1;
174         }
175 }
176
177 static u16 mt9t112_pixfmt_to_order(u32 pixelformat)
178 {
179         switch (pixelformat) {
180         case V4L2_PIX_FMT_RGB555:
181                 /* FALLTHROUGH */
182         case V4L2_PIX_FMT_RGB565:
183                 return 2;
184         case V4L2_PIX_FMT_YUYV:
185                 /* FALLTHROUGH */
186         default:
187                 return 0;
188         }
189 }
190
191 static int __mt9t112_reg_read(const struct i2c_client *client, u16 command)
192 {
193         struct i2c_msg msg[2];
194         u8 buf[2];
195         int ret;
196
197         command = swab16(command);
198
199         msg[0].addr  = client->addr;
200         msg[0].flags = 0;
201         msg[0].len   = 2;
202         msg[0].buf   = (u8 *)&command;
203
204         msg[1].addr  = client->addr;
205         msg[1].flags = I2C_M_RD;
206         msg[1].len   = 2;
207         msg[1].buf   = buf;
208
209         /*
210          * if return value of this function is < 0,
211          * it mean error.
212          * else, under 16bit is valid data.
213          */
214         ret = i2c_transfer(client->adapter, msg, 2);
215         if (ret < 0)
216                 return ret;
217
218         memcpy(&ret, buf, 2);
219         return swab16(ret);
220 }
221
222 static int __mt9t112_reg_write(const struct i2c_client *client,
223                                u16 command, u16 data)
224 {
225         struct i2c_msg msg;
226         u8 buf[4];
227         int ret;
228
229         command = swab16(command);
230         data = swab16(data);
231
232         memcpy(buf + 0, &command, 2);
233         memcpy(buf + 2, &data,    2);
234
235         msg.addr  = client->addr;
236         msg.flags = 0;
237         msg.len   = 4;
238         msg.buf   = buf;
239
240         /*
241          * i2c_transfer return message length,
242          * but this function should return 0 if correct case
243          */
244         ret = i2c_transfer(client->adapter, &msg, 1);
245         if (ret >= 0)
246                 ret = 0;
247
248         return ret;
249 }
250
251 static int __mt9t112_reg_mask_set(const struct i2c_client *client,
252                                   u16  command,
253                                   u16  mask,
254                                   u16  set)
255 {
256         int val = __mt9t112_reg_read(client, command);
257         if (val < 0)
258                 return val;
259
260         val &= ~mask;
261         val |= set & mask;
262
263         return __mt9t112_reg_write(client, command, val);
264 }
265
266 /* mcu access */
267 static int __mt9t112_mcu_read(const struct i2c_client *client, u16 command)
268 {
269         int ret;
270
271         ret = __mt9t112_reg_write(client, 0x098E, command);
272         if (ret < 0)
273                 return ret;
274
275         return __mt9t112_reg_read(client, 0x0990);
276 }
277
278 static int __mt9t112_mcu_write(const struct i2c_client *client,
279                                u16 command, u16 data)
280 {
281         int ret;
282
283         ret = __mt9t112_reg_write(client, 0x098E, command);
284         if (ret < 0)
285                 return ret;
286
287         return __mt9t112_reg_write(client, 0x0990, data);
288 }
289
290 static int __mt9t112_mcu_mask_set(const struct i2c_client *client,
291                                   u16  command,
292                                   u16  mask,
293                                   u16  set)
294 {
295         int val = __mt9t112_mcu_read(client, command);
296         if (val < 0)
297                 return val;
298
299         val &= ~mask;
300         val |= set & mask;
301
302         return __mt9t112_mcu_write(client, command, val);
303 }
304
305 static int mt9t112_reset(const struct i2c_client *client)
306 {
307         int ret;
308
309         mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0001);
310         msleep(1);
311         mt9t112_reg_mask_set(ret, client, 0x001a, 0x0001, 0x0000);
312
313         return ret;
314 }
315
316 #ifndef EXT_CLOCK
317 #define CLOCK_INFO(a, b)
318 #else
319 #define CLOCK_INFO(a, b) mt9t112_clock_info(a, b)
320 static int mt9t112_clock_info(const struct i2c_client *client, u32 ext)
321 {
322         int m, n, p1, p2, p3, p4, p5, p6, p7;
323         u32 vco, clk;
324         char *enable;
325
326         ext /= 1000; /* kbyte order */
327
328         mt9t112_reg_read(n, client, 0x0012);
329         p1 = n & 0x000f;
330         n = n >> 4;
331         p2 = n & 0x000f;
332         n = n >> 4;
333         p3 = n & 0x000f;
334
335         mt9t112_reg_read(n, client, 0x002a);
336         p4 = n & 0x000f;
337         n = n >> 4;
338         p5 = n & 0x000f;
339         n = n >> 4;
340         p6 = n & 0x000f;
341
342         mt9t112_reg_read(n, client, 0x002c);
343         p7 = n & 0x000f;
344
345         mt9t112_reg_read(n, client, 0x0010);
346         m = n & 0x00ff;
347         n = (n >> 8) & 0x003f;
348
349         enable = ((6000 > ext) || (54000 < ext)) ? "X" : "";
350         dev_info(&client->dev, "EXTCLK          : %10u K %s\n", ext, enable);
351
352         vco = 2 * m * ext / (n+1);
353         enable = ((384000 > vco) || (768000 < vco)) ? "X" : "";
354         dev_info(&client->dev, "VCO             : %10u K %s\n", vco, enable);
355
356         clk = vco / (p1+1) / (p2+1);
357         enable = (96000 < clk) ? "X" : "";
358         dev_info(&client->dev, "PIXCLK          : %10u K %s\n", clk, enable);
359
360         clk = vco / (p3+1);
361         enable = (768000 < clk) ? "X" : "";
362         dev_info(&client->dev, "MIPICLK         : %10u K %s\n", clk, enable);
363
364         clk = vco / (p6+1);
365         enable = (96000 < clk) ? "X" : "";
366         dev_info(&client->dev, "MCU CLK         : %10u K %s\n", clk, enable);
367
368         clk = vco / (p5+1);
369         enable = (54000 < clk) ? "X" : "";
370         dev_info(&client->dev, "SOC CLK         : %10u K %s\n", clk, enable);
371
372         clk = vco / (p4+1);
373         enable = (70000 < clk) ? "X" : "";
374         dev_info(&client->dev, "Sensor CLK      : %10u K %s\n", clk, enable);
375
376         clk = vco / (p7+1);
377         dev_info(&client->dev, "External sensor : %10u K\n", clk);
378
379         clk = ext / (n+1);
380         enable = ((2000 > clk) || (24000 < clk)) ? "X" : "";
381         dev_info(&client->dev, "PFD             : %10u K %s\n", clk, enable);
382
383         return 0;
384 }
385 #endif
386
387 static void mt9t112_frame_check(u32 *width, u32 *height)
388 {
389         if (*width > MAX_WIDTH)
390                 *width = MAX_WIDTH;
391
392         if (*height > MAX_HEIGHT)
393                 *height = MAX_HEIGHT;
394 }
395
396 static int mt9t112_set_pll_dividers(const struct i2c_client *client,
397                                     u8 m, u8 n,
398                                     u8 p1, u8 p2, u8 p3,
399                                     u8 p4, u8 p5, u8 p6,
400                                     u8 p7)
401 {
402         int ret;
403         u16 val;
404
405         /* N/M */
406         val = (n << 8) |
407               (m << 0);
408         mt9t112_reg_mask_set(ret, client, 0x0010, 0x3fff, val);
409
410         /* P1/P2/P3 */
411         val = ((p3 & 0x0F) << 8) |
412               ((p2 & 0x0F) << 4) |
413               ((p1 & 0x0F) << 0);
414         mt9t112_reg_mask_set(ret, client, 0x0012, 0x0fff, val);
415
416         /* P4/P5/P6 */
417         val = (0x7         << 12) |
418               ((p6 & 0x0F) <<  8) |
419               ((p5 & 0x0F) <<  4) |
420               ((p4 & 0x0F) <<  0);
421         mt9t112_reg_mask_set(ret, client, 0x002A, 0x7fff, val);
422
423         /* P7 */
424         val = (0x1         << 12) |
425               ((p7 & 0x0F) <<  0);
426         mt9t112_reg_mask_set(ret, client, 0x002C, 0x100f, val);
427
428         return ret;
429 }
430
431 static int mt9t112_init_pll(const struct i2c_client *client)
432 {
433         struct mt9t112_priv *priv = i2c_get_clientdata(client);
434         int data, i, ret;
435
436         mt9t112_reg_mask_set(ret, client, 0x0014, 0x003, 0x0001);
437
438         /* PLL control: BYPASS PLL = 8517 */
439         mt9t112_reg_write(ret, client, 0x0014, 0x2145);
440
441         /* Replace these registers when new timing parameters are generated */
442         mt9t112_set_pll_dividers(client,
443                                  priv->info.divider.m,
444                                  priv->info.divider.n,
445                                  priv->info.divider.p1,
446                                  priv->info.divider.p2,
447                                  priv->info.divider.p3,
448                                  priv->info.divider.p4,
449                                  priv->info.divider.p5,
450                                  priv->info.divider.p6,
451                                  priv->info.divider.p7);
452
453         /*
454          * TEST_BYPASS  on
455          * PLL_ENABLE   on
456          * SEL_LOCK_DET on
457          * TEST_BYPASS  off
458          */
459         mt9t112_reg_write(ret, client, 0x0014, 0x2525);
460         mt9t112_reg_write(ret, client, 0x0014, 0x2527);
461         mt9t112_reg_write(ret, client, 0x0014, 0x3427);
462         mt9t112_reg_write(ret, client, 0x0014, 0x3027);
463
464         mdelay(10);
465
466         /*
467          * PLL_BYPASS off
468          * Reference clock count
469          * I2C Master Clock Divider
470          */
471         mt9t112_reg_write(ret, client, 0x0014, 0x3046);
472         mt9t112_reg_write(ret, client, 0x0022, 0x0190);
473         mt9t112_reg_write(ret, client, 0x3B84, 0x0212);
474
475         /* External sensor clock is PLL bypass */
476         mt9t112_reg_write(ret, client, 0x002E, 0x0500);
477
478         mt9t112_reg_mask_set(ret, client, 0x0018, 0x0002, 0x0002);
479         mt9t112_reg_mask_set(ret, client, 0x3B82, 0x0004, 0x0004);
480
481         /* MCU disabled */
482         mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0x0004);
483
484         /* out of standby */
485         mt9t112_reg_mask_set(ret, client, 0x0018, 0x0001, 0);
486
487         mdelay(50);
488
489         /*
490          * Standby Workaround
491          * Disable Secondary I2C Pads
492          */
493         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
494         mdelay(1);
495         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
496         mdelay(1);
497         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
498         mdelay(1);
499         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
500         mdelay(1);
501         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
502         mdelay(1);
503         mt9t112_reg_write(ret, client, 0x0614, 0x0001);
504         mdelay(1);
505
506         /* poll to verify out of standby. Must Poll this bit */
507         for (i = 0; i < 100; i++) {
508                 mt9t112_reg_read(data, client, 0x0018);
509                 if (!(0x4000 & data))
510                         break;
511
512                 mdelay(10);
513         }
514
515         return ret;
516 }
517
518 static int mt9t112_init_setting(const struct i2c_client *client)
519 {
520
521         int ret;
522
523         /* Output Width (A) */
524         mt9t112_mcu_write(ret, client, VAR(26, 0), 640);
525
526         /* Output Height (A) */
527         mt9t112_mcu_write(ret, client, VAR(26, 2), 480);
528
529         /* Adaptive Output Clock (A) */
530         mt9t112_mcu_mask_set(ret, client, VAR(26, 160), 0x0040, 0x0000);
531
532         /* Row Start (A) */
533         mt9t112_mcu_write(ret, client, VAR(18, 2), 0);
534
535         /* Column Start (A) */
536         mt9t112_mcu_write(ret, client, VAR(18, 4), 0);
537
538         /* Row End (A) */
539         mt9t112_mcu_write(ret, client, VAR(18, 6), 1549);
540
541         /* Column End (A) */
542         mt9t112_mcu_write(ret, client, VAR(18, 8), 2061);
543
544         /* Read Mode (A) */
545         mt9t112_mcu_write(ret, client, VAR(18, 12), 0x046C);
546
547         /* Fine Correction (A) */
548         mt9t112_mcu_write(ret, client, VAR(18, 15), 0x00CC);
549
550         /* Fine IT Min (A) */
551         mt9t112_mcu_write(ret, client, VAR(18, 17), 0x0381);
552
553         /* Fine IT Max Margin (A) */
554         mt9t112_mcu_write(ret, client, VAR(18, 19), 0x024F);
555
556         /* Base Frame Lines (A) */
557         mt9t112_mcu_write(ret, client, VAR(18, 29), 0x0378);
558
559         /* Min Line Length (A) */
560         mt9t112_mcu_write(ret, client, VAR(18, 31), 0x05D0);
561
562         /* Line Length (A) */
563         mt9t112_mcu_write(ret, client, VAR(18, 37), 0x07AC);
564
565         /* Context Width (A) */
566         mt9t112_mcu_write(ret, client, VAR(18, 43), 8 + 1024);
567
568         /* Context Height (A) */
569         mt9t112_mcu_write(ret, client, VAR(18, 45), 8 + 768);
570
571         /* Output Width (B) */
572         mt9t112_mcu_write(ret, client, VAR(27, 0), 2048);
573
574         /* Output Hieght (B) */
575         mt9t112_mcu_write(ret, client, VAR(27, 2), 1536);
576
577         /* Adaptive Output Clock (B) */
578         mt9t112_mcu_mask_set(ret, client, VAR(27, 160), 0x0040, 0x0000);
579
580         /* Row Start (B) */
581         mt9t112_mcu_write(ret, client, VAR(18, 74), 0x004);
582
583         /* Column Start (B) */
584         mt9t112_mcu_write(ret, client, VAR(18, 76), 0x004);
585
586         /* Row End (B) */
587         mt9t112_mcu_write(ret, client, VAR(18, 78), 0x60B);
588
589         /* Column End (B) */
590         mt9t112_mcu_write(ret, client, VAR(18, 80), 0x80B);
591
592         /* Fine Correction (B) */
593         mt9t112_mcu_write(ret, client, VAR(18, 87), 0x008C);
594
595         /* Fine IT Min (B) */
596         mt9t112_mcu_write(ret, client, VAR(18, 89), 0x01F1);
597
598         /* Fine IT Max Margin (B) */
599         mt9t112_mcu_write(ret, client, VAR(18, 91), 0x00FF);
600
601         /* Base Frame Lines (B) */
602         mt9t112_mcu_write(ret, client, VAR(18, 101), 0x066C);
603
604         /* Min Line Length (B) */
605         mt9t112_mcu_write(ret, client, VAR(18, 103), 0x0378);
606
607         /* Line Length (B) */
608         mt9t112_mcu_write(ret, client, VAR(18, 109), 0x0CB1);
609
610         /* Context Width (B) */
611         mt9t112_mcu_write(ret, client, VAR(18, 115), 8 + 2048);
612
613         /* Context Height (B) */
614         mt9t112_mcu_write(ret, client, VAR(18, 117), 8 + 1536);
615
616         /*
617          * Flicker Dectection registers
618          * This section should be replaced whenever new Timing file is generated
619          * All the following registers need to be replaced
620          * Following registers are generated from Register Wizard but user can
621          * modify them. For detail see auto flicker detection tuning
622          */
623
624         /* FD_FDPERIOD_SELECT */
625         mt9t112_mcu_write(ret, client, VAR8(8, 5), 0x01);
626
627         /* PRI_B_CONFIG_FD_ALGO_RUN */
628         mt9t112_mcu_write(ret, client, VAR(27, 17), 0x0003);
629
630         /* PRI_A_CONFIG_FD_ALGO_RUN */
631         mt9t112_mcu_write(ret, client, VAR(26, 17), 0x0003);
632
633         /*
634          * AFD range detection tuning registers
635          */
636
637         /* search_f1_50 */
638         mt9t112_mcu_write(ret, client, VAR8(18, 165), 0x25);
639
640         /* search_f2_50 */
641         mt9t112_mcu_write(ret, client, VAR8(18, 166), 0x28);
642
643         /* search_f1_60 */
644         mt9t112_mcu_write(ret, client, VAR8(18, 167), 0x2C);
645
646         /* search_f2_60 */
647         mt9t112_mcu_write(ret, client, VAR8(18, 168), 0x2F);
648
649         /* period_50Hz (A) */
650         mt9t112_mcu_write(ret, client, VAR8(18, 68), 0xBA);
651
652         /* secret register by aptina */
653         /* period_50Hz (A MSB) */
654         mt9t112_mcu_write(ret, client, VAR8(18, 303), 0x00);
655
656         /* period_60Hz (A) */
657         mt9t112_mcu_write(ret, client, VAR8(18, 69), 0x9B);
658
659         /* secret register by aptina */
660         /* period_60Hz (A MSB) */
661         mt9t112_mcu_write(ret, client, VAR8(18, 301), 0x00);
662
663         /* period_50Hz (B) */
664         mt9t112_mcu_write(ret, client, VAR8(18, 140), 0x82);
665
666         /* secret register by aptina */
667         /* period_50Hz (B) MSB */
668         mt9t112_mcu_write(ret, client, VAR8(18, 304), 0x00);
669
670         /* period_60Hz (B) */
671         mt9t112_mcu_write(ret, client, VAR8(18, 141), 0x6D);
672
673         /* secret register by aptina */
674         /* period_60Hz (B) MSB */
675         mt9t112_mcu_write(ret, client, VAR8(18, 302), 0x00);
676
677         /* FD Mode */
678         mt9t112_mcu_write(ret, client, VAR8(8, 2), 0x10);
679
680         /* Stat_min */
681         mt9t112_mcu_write(ret, client, VAR8(8, 9), 0x02);
682
683         /* Stat_max */
684         mt9t112_mcu_write(ret, client, VAR8(8, 10), 0x03);
685
686         /* Min_amplitude */
687         mt9t112_mcu_write(ret, client, VAR8(8, 12), 0x0A);
688
689         /* RX FIFO Watermark (A) */
690         mt9t112_mcu_write(ret, client, VAR(18, 70), 0x0080);
691
692         /* RX FIFO Watermark (B) */
693         mt9t112_mcu_write(ret, client, VAR(18, 142), 0x0080);
694
695         /* MCLK: 16MHz
696          * PCLK: 73MHz
697          * CorePixCLK: 36.5 MHz
698          */
699         mt9t112_mcu_write(ret, client, VAR8(18, 0x0044), 133);
700         mt9t112_mcu_write(ret, client, VAR8(18, 0x0045), 110);
701         mt9t112_mcu_write(ret, client, VAR8(18, 0x008c), 130);
702         mt9t112_mcu_write(ret, client, VAR8(18, 0x008d), 108);
703
704         mt9t112_mcu_write(ret, client, VAR8(18, 0x00A5), 27);
705         mt9t112_mcu_write(ret, client, VAR8(18, 0x00a6), 30);
706         mt9t112_mcu_write(ret, client, VAR8(18, 0x00a7), 32);
707         mt9t112_mcu_write(ret, client, VAR8(18, 0x00a8), 35);
708
709         return ret;
710 }
711
712 static int mt9t112_auto_focus_setting(const struct i2c_client *client)
713 {
714         int ret;
715
716         mt9t112_mcu_write(ret, client, VAR(12, 13),     0x000F);
717         mt9t112_mcu_write(ret, client, VAR(12, 23),     0x0F0F);
718         mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x06);
719
720         mt9t112_reg_write(ret, client, 0x0614, 0x0000);
721
722         mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
723         mt9t112_mcu_write(ret, client, VAR8(12, 2),     0x02);
724         mt9t112_mcu_write(ret, client, VAR(12, 3),      0x0002);
725         mt9t112_mcu_write(ret, client, VAR(17, 3),      0x8001);
726         mt9t112_mcu_write(ret, client, VAR(17, 11),     0x0025);
727         mt9t112_mcu_write(ret, client, VAR(17, 13),     0x0193);
728         mt9t112_mcu_write(ret, client, VAR8(17, 33),    0x18);
729         mt9t112_mcu_write(ret, client, VAR8(1, 0),      0x05);
730
731         return ret;
732 }
733
734 static int mt9t112_auto_focus_trigger(const struct i2c_client *client)
735 {
736         int ret;
737
738         mt9t112_mcu_write(ret, client, VAR8(12, 25), 0x01);
739
740         return ret;
741 }
742
743 static int mt9t112_goto_preview(const struct i2c_client *client)
744 {
745         int ret, trycount = 0;
746
747         /* Is it already in preview mode? */
748         mt9t112_mcu_read(ret, client, VAR8(1, 1));
749         if (ret == 0x3)
750                 return 0;
751
752         /* Go to preview mode */
753         mt9t112_mcu_write(ret, client, VAR8(1, 0), 1);
754         do {
755                 mt9t112_mcu_read(ret, client, VAR8(1, 1));
756                 mdelay(1);
757         } while ((ret != 0x3) && (++trycount < 100));
758
759         if (trycount >= 100)
760                 return -EBUSY;
761
762         return 0;
763 }
764
765 static int mt9t112_goto_capture(const struct i2c_client *client)
766 {
767         int ret, trycount = 0;
768
769         /* Is it already in capture mode? */
770         mt9t112_mcu_read(ret, client, VAR8(1, 1));
771         if (ret == 0x7)
772                 return 0;
773
774         /* Go to capture mode */
775         mt9t112_mcu_write(ret, client, VAR8(1, 0), 2);
776         do {
777                 mt9t112_mcu_read(ret, client, VAR8(1, 1));
778                 mdelay(1);
779         } while ((ret != 0x7) && (++trycount < 100));
780
781         if (trycount >= 100)
782                 return -EBUSY;
783
784         return 0;
785 }
786
787 static int mt9t112_init_camera(const struct i2c_client *client)
788 {
789         int ret;
790
791         ECHECKER(ret, mt9t112_reset(client));
792
793         ECHECKER(ret, mt9t112_init_pll(client));
794
795         ECHECKER(ret, mt9t112_init_setting(client));
796
797         ECHECKER(ret, mt9t112_auto_focus_setting(client));
798
799         mt9t112_reg_mask_set(ret, client, 0x0018, 0x0004, 0);
800
801         /* Analog setting B */
802         mt9t112_reg_write(ret, client, 0x3084, 0x2409);
803         mt9t112_reg_write(ret, client, 0x3092, 0x0A49);
804         mt9t112_reg_write(ret, client, 0x3094, 0x4949);
805         mt9t112_reg_write(ret, client, 0x3096, 0x4950);
806
807         /*
808          * Disable adaptive clock
809          * PRI_A_CONFIG_JPEG_OB_TX_CONTROL_VAR
810          * PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR
811          */
812         mt9t112_mcu_write(ret, client, VAR(26, 160), 0x0A2E);
813         mt9t112_mcu_write(ret, client, VAR(27, 160), 0x0A2E);
814
815         /* Configure STatus in Status_before_length Format and enable header */
816         /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
817         mt9t112_mcu_write(ret, client, VAR(27, 144), 0x0CB4);
818
819         /* Enable JPEG in context B */
820         /* PRI_B_CONFIG_JPEG_OB_TX_CONTROL_VAR */
821         mt9t112_mcu_write(ret, client, VAR8(27, 142), 0x01);
822
823         /* Disable Dac_TXLO */
824         mt9t112_reg_write(ret, client, 0x316C, 0x350F);
825
826         /* Set max slew rates */
827         mt9t112_reg_write(ret, client, 0x1E, 0x777);
828
829         return ret;
830 }
831
832 static int mt9t112_set_params(struct i2c_client *client, u32 width, u32 height,
833                               u32 pixelformat)
834 {
835         struct mt9t112_priv *priv = i2c_get_clientdata(client);
836         int i;
837
838         /*
839          * frame size check
840          */
841         mt9t112_frame_check(&width, &height);
842
843         /*
844          * get color format
845          */
846         for (i = 0; i < ARRAY_SIZE(mt9t112_formats); i++)
847                 if (mt9t112_formats[i].pixelformat == pixelformat)
848                         break;
849
850         if (i == ARRAY_SIZE(mt9t112_formats))
851                 return -EINVAL;
852
853         priv->pix.width  = (u16)width;
854         priv->pix.height = (u16)height;
855
856         priv->pix.pixelformat = pixelformat;
857
858         return 0;
859 }
860
861 static int mt9t112_v4l2_int_cropcap(struct v4l2_int_device *s,
862                                     struct v4l2_cropcap *a)
863 {
864         a->bounds.left                  = 0;
865         a->bounds.top                   = 0;
866         a->bounds.width                 = VGA_WIDTH;
867         a->bounds.height                = VGA_HEIGHT;
868         a->defrect                      = a->bounds;
869         a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
870         a->pixelaspect.numerator        = 1;
871         a->pixelaspect.denominator      = 1;
872
873         return 0;
874 }
875
876 static int mt9t112_v4l2_int_g_crop(struct v4l2_int_device *s,
877                                    struct v4l2_crop *a)
878 {
879         a->c.left       = 0;
880         a->c.top        = 0;
881         a->c.width      = VGA_WIDTH;
882         a->c.height     = VGA_HEIGHT;
883         a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
884
885         return 0;
886 }
887
888 static int mt9t112_v4l2_int_s_crop(struct v4l2_int_device *s,
889                                    struct v4l2_crop *a)
890 {
891         if ((a->c.left != 0) ||
892             (a->c.top != 0) ||
893             (a->c.width != VGA_WIDTH) ||
894             (a->c.height != VGA_HEIGHT)) {
895                 return -EINVAL;
896         }
897         return 0;
898 }
899
900 static int mt9t112_v4l2_int_g_fmt_cap(struct v4l2_int_device *s,
901                                       struct v4l2_format *f)
902 {
903         struct mt9t112_priv *priv = s->priv;
904         struct i2c_client *client = priv->client;
905
906         if ((priv->pix.pixelformat == 0) ||
907             (priv->pix.width == 0) ||
908             (priv->pix.height == 0)) {
909                 int ret = mt9t112_set_params(client, VGA_WIDTH, VGA_HEIGHT,
910                                              V4L2_PIX_FMT_YUYV);
911                 if (ret < 0)
912                         return ret;
913         }
914
915         f->fmt.pix.width        = priv->pix.width;
916         f->fmt.pix.height       = priv->pix.height;
917         /* TODO: set colorspace */
918         f->fmt.pix.pixelformat  = priv->pix.pixelformat;
919         f->fmt.pix.field        = V4L2_FIELD_NONE;
920
921         return 0;
922 }
923
924
925 static int mt9t112_v4l2_int_s_fmt_cap(struct v4l2_int_device *s,
926                                       struct v4l2_format *f)
927 {
928         struct mt9t112_priv *priv = s->priv;
929         struct i2c_client *client = priv->client;
930
931         /* TODO: set colorspace */
932         return mt9t112_set_params(client, f->fmt.pix.width, f->fmt.pix.height,
933                                   f->fmt.pix.pixelformat);
934 }
935
936 static int mt9t112_v4l2_int_try_fmt_cap(struct v4l2_int_device *s,
937                                         struct v4l2_format *f)
938 {
939         mt9t112_frame_check(&f->fmt.pix.width, &f->fmt.pix.height);
940
941         /* TODO: set colorspace */
942         f->fmt.pix.field = V4L2_FIELD_NONE;
943
944         return 0;
945 }
946
947 static int mt9t112_v4l2_int_enum_fmt_cap(struct v4l2_int_device *s,
948                                          struct v4l2_fmtdesc *fmt)
949 {
950         int index = fmt->index;
951         enum v4l2_buf_type type = fmt->type;
952
953         memset(fmt, 0, sizeof(*fmt));
954         fmt->index = index;
955         fmt->type = type;
956
957         switch (fmt->type) {
958         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
959                 if (index >= ARRAY_SIZE(mt9t112_formats))
960                         return -EINVAL;
961         break;
962         default:
963                 return -EINVAL;
964         }
965
966         fmt->flags = mt9t112_formats[index].flags;
967         strlcpy(fmt->description, mt9t112_formats[index].description,
968                                         sizeof(fmt->description));
969         fmt->pixelformat = mt9t112_formats[index].pixelformat;
970         return 0;
971 }
972
973 static int mt9t112_v4l2_int_s_parm(struct v4l2_int_device *s,
974                                    struct v4l2_streamparm *a)
975 {
976         /* TODO: set paramters */
977         return 0;
978 }
979
980 static int mt9t112_v4l2_int_g_parm(struct v4l2_int_device *s,
981                                    struct v4l2_streamparm *a)
982 {
983         struct v4l2_captureparm *cparm = &a->parm.capture;
984
985         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
986                 return -EINVAL;
987
988         memset(a, 0, sizeof(*a));
989         a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
990
991         cparm->capability = V4L2_CAP_TIMEPERFRAME;
992         /* FIXME: Is 30 fps really the only option? */
993         cparm->timeperframe.numerator = 1;
994         cparm->timeperframe.denominator = 30;
995
996         return 0;
997 }
998
999 /************************************************************************
1000
1001
1002                         i2c driver
1003
1004
1005 ************************************************************************/
1006
1007 static int mt9t112_detect(struct i2c_client *client)
1008 {
1009         struct mt9t112_priv *priv = i2c_get_clientdata(client);
1010         const char          *devname;
1011         int                  chipid;
1012
1013         /*
1014          * check and show chip ID
1015          */
1016         mt9t112_reg_read(chipid, client, 0x0000);
1017
1018         switch (chipid) {
1019         case 0x2680:
1020                 devname = "mt9t111";
1021                 priv->model = V4L2_IDENT_MT9T111;
1022                 break;
1023         case 0x2682:
1024                 devname = "mt9t112";
1025                 priv->model = V4L2_IDENT_MT9T112;
1026                 break;
1027         default:
1028                 dev_err(&client->dev, "Product ID error %04x\n", chipid);
1029                 return -ENODEV;
1030         }
1031
1032         dev_info(&client->dev, "%s chip ID %04x\n", devname, chipid);
1033
1034         return 0;
1035 }
1036
1037 static int mt9t112_v4l2_int_s_power(struct v4l2_int_device *s,
1038                                     enum v4l2_power power)
1039 {
1040         struct mt9t112_priv *priv = s->priv;
1041         struct i2c_client *client = priv->client;
1042         u16 param = (MT9T112_FLAG_PCLK_RISING_EDGE &
1043                      priv->info.flags) ? 0x0001 : 0x0000;
1044         int ret;
1045
1046         switch (power) {
1047         case V4L2_POWER_STANDBY:
1048                 /* FALLTHROUGH */
1049         case V4L2_POWER_OFF:
1050                 ret = priv->pdata->power_set(s, power);
1051                 if (ret < 0) {
1052                         dev_err(&client->dev, "Unable to set target board power "
1053                                          "state (OFF/STANDBY)\n");
1054                         return ret;
1055                 }
1056                 break;
1057         case V4L2_POWER_ON:
1058                 ret = priv->pdata->power_set(s, power);
1059                 if (ret < 0) {
1060                         dev_err(&client->dev, "Unable to set target board power "
1061                                          "state (ON)\n");
1062                         return ret;
1063                 }
1064                 if (!(priv->flags & INIT_DONE)) {
1065                         ECHECKER(ret, mt9t112_detect(client));
1066
1067                         priv->flags |= INIT_DONE;
1068                 }
1069
1070                 ECHECKER(ret, mt9t112_init_camera(client));
1071
1072                 /* Invert PCLK (Data sampled on falling edge of pixclk) */
1073                 mt9t112_reg_write(ret, client, 0x3C20, param);
1074
1075                 mdelay(5);
1076                 mt9t112_mcu_write(ret, client, VAR(26, 7),
1077                                   mt9t112_pixfmt_to_fmt(priv->pix.pixelformat));
1078                 mt9t112_mcu_write(ret, client, VAR(26, 9),
1079                                   mt9t112_pixfmt_to_order(priv->pix.pixelformat));
1080                 mt9t112_mcu_write(ret, client, VAR8(1, 0), 0x06);
1081
1082                 ECHECKER(ret, mt9t112_auto_focus_trigger(client));
1083
1084                 ECHECKER(ret, mt9t112_goto_preview(client));
1085
1086                 if ((priv->pix.width == MAX_WIDTH) &&
1087                     (priv->pix.height == MAX_HEIGHT)) {
1088                         ECHECKER(ret, mt9t112_goto_capture(client));
1089                 }
1090
1091                 dev_dbg(&client->dev, "format : %d\n", priv->pix.pixelformat);
1092                 dev_dbg(&client->dev, "size   : %d x %d\n",
1093                         priv->pix.width,
1094                         priv->pix.height);
1095
1096                 CLOCK_INFO(client, EXT_CLOCK);
1097         }
1098         return 0;
1099 }
1100
1101 static int mt9t112_v4l2_int_g_priv(struct v4l2_int_device *s, void *p)
1102 {
1103         struct mt9t112_priv *priv = s->priv;
1104
1105         return priv->pdata->priv_data_set(p);
1106 }
1107
1108 static int mt9t112_v4l2_int_g_ifparm(struct v4l2_int_device *s,
1109                                      struct v4l2_ifparm *p)
1110 {
1111         struct mt9t112_priv *priv = s->priv;
1112         int rval;
1113
1114         if (p == NULL)
1115                 return -EINVAL;
1116
1117         if (!priv->pdata->ifparm)
1118                 return -EINVAL;
1119
1120         rval = priv->pdata->ifparm(p);
1121         if (rval) {
1122                 v4l_err(priv->client, "g_ifparm.Err[%d]\n", rval);
1123                 return rval;
1124         }
1125
1126         p->u.ycbcr.clock_curr = 40 * 1000000; /* temporal value */
1127
1128         return 0;
1129 }
1130
1131 static int mt9t112_v4l2_int_enum_framesizes(struct v4l2_int_device *s,
1132                                             struct v4l2_frmsizeenum *frms)
1133 {
1134         int ifmt;
1135
1136         for (ifmt = 0; ifmt < ARRAY_SIZE(mt9t112_formats); ifmt++)
1137                 if (mt9t112_formats[ifmt].pixelformat == frms->pixel_format)
1138                         break;
1139
1140         if (ifmt == ARRAY_SIZE(mt9t112_formats))
1141                 return -EINVAL;
1142
1143         /* Do we already reached all discrete framesizes? */
1144         if (frms->index >= ARRAY_SIZE(mt9t112_sizes))
1145                 return -EINVAL;
1146
1147         frms->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1148         frms->discrete.width = mt9t112_sizes[frms->index].width;
1149         frms->discrete.height = mt9t112_sizes[frms->index].height;
1150
1151         return 0;
1152
1153 }
1154
1155 static int mt9t112_v4l2_int_enum_frameintervals(struct v4l2_int_device *s,
1156                                                 struct v4l2_frmivalenum *frmi)
1157 {
1158         int ifmt;
1159
1160         for (ifmt = 0; ifmt < ARRAY_SIZE(mt9t112_formats); ifmt++)
1161                 if (mt9t112_formats[ifmt].pixelformat == frmi->pixel_format)
1162                         break;
1163
1164         if (ifmt == ARRAY_SIZE(mt9t112_formats))
1165                 return -EINVAL;
1166
1167         if (frmi->index >= ARRAY_SIZE(mt9t112_frameintervals))
1168                 return -EINVAL;
1169
1170         frmi->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1171         frmi->discrete.numerator =
1172                                 mt9t112_frameintervals[frmi->index].numerator;
1173         frmi->discrete.denominator =
1174                                 mt9t112_frameintervals[frmi->index].denominator;
1175         return 0;
1176 }
1177
1178 static struct v4l2_int_ioctl_desc mt9t112_ioctl_desc[] = {
1179         { .num = vidioc_int_enum_framesizes_num,
1180           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_enum_framesizes },
1181         { .num = vidioc_int_enum_frameintervals_num,
1182           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_enum_frameintervals },
1183         { .num = vidioc_int_s_power_num,
1184           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_s_power },
1185         { .num = vidioc_int_g_priv_num,
1186           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_g_priv },
1187         { .num = vidioc_int_g_ifparm_num,
1188           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_g_ifparm },
1189         { .num = vidioc_int_enum_fmt_cap_num,
1190           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_enum_fmt_cap },
1191         { .num = vidioc_int_try_fmt_cap_num,
1192           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_try_fmt_cap },
1193         { .num = vidioc_int_g_fmt_cap_num,
1194           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_g_fmt_cap },
1195         { .num = vidioc_int_s_fmt_cap_num,
1196           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_s_fmt_cap },
1197         { .num = vidioc_int_g_parm_num,
1198           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_g_parm },
1199         { .num = vidioc_int_s_parm_num,
1200           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_s_parm },
1201         { .num = vidioc_int_cropcap_num,
1202           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_cropcap },
1203         { .num = vidioc_int_g_crop_num,
1204           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_g_crop },
1205         { .num = vidioc_int_s_crop_num,
1206           .func = (v4l2_int_ioctl_func *)mt9t112_v4l2_int_s_crop },
1207 };
1208
1209 static struct v4l2_int_slave mt9t112_slave = {
1210         .ioctls = mt9t112_ioctl_desc,
1211         .num_ioctls = ARRAY_SIZE(mt9t112_ioctl_desc),
1212 };
1213
1214 static int mt9t112_probe(struct i2c_client *client,
1215                          const struct i2c_device_id *did)
1216 {
1217         struct mt9t112_priv        *priv;
1218         struct v4l2_int_device     *v4l2_int_device;
1219         int                         ret;
1220
1221         if (!client->dev.platform_data) {
1222                 dev_err(&client->dev, "no platform data?\n");
1223                 return -ENODEV;
1224         }
1225
1226         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1227         if (!priv)
1228                 return -ENOMEM;
1229
1230         v4l2_int_device = kzalloc(sizeof(*v4l2_int_device), GFP_KERNEL);
1231         if (!v4l2_int_device) {
1232                 kfree(priv);
1233                 return -ENOMEM;
1234         }
1235
1236         v4l2_int_device->module = THIS_MODULE;
1237         strncpy(v4l2_int_device->name, "mt9t112", sizeof(v4l2_int_device->name));
1238         v4l2_int_device->type = v4l2_int_type_slave;
1239         v4l2_int_device->u.slave = &mt9t112_slave;
1240         v4l2_int_device->priv = priv;
1241
1242         priv->v4l2_int_device = v4l2_int_device;
1243         priv->client = client;
1244         priv->pdata = client->dev.platform_data;
1245
1246         /* Revisit: Init Sensor info settings */
1247         priv->info.divider.m = 24;
1248         priv->info.divider.n = 1;
1249         priv->info.divider.p1 = 0;
1250         priv->info.divider.p2 = 8;
1251         priv->info.divider.p3 = 0;
1252         priv->info.divider.p4 = 11;
1253         priv->info.divider.p5 = 11;
1254         priv->info.divider.p6 = 8;
1255         priv->info.divider.p7 = 0;
1256         priv->info.flags = MT9T112_FLAG_PCLK_RISING_EDGE;
1257
1258         i2c_set_clientdata(client, priv);
1259
1260         //ret = mt9t112_detect(client);
1261
1262         ret = v4l2_int_device_register(priv->v4l2_int_device);
1263         if (ret) {
1264                 i2c_set_clientdata(client, NULL);
1265                 kfree(v4l2_int_device);
1266                 kfree(priv);
1267         }
1268
1269         return ret;
1270 }
1271
1272 static int mt9t112_remove(struct i2c_client *client)
1273 {
1274         struct mt9t112_priv *priv = i2c_get_clientdata(client);
1275
1276         v4l2_int_device_unregister(priv->v4l2_int_device);
1277         i2c_set_clientdata(client, NULL);
1278
1279         kfree(priv->v4l2_int_device);
1280         kfree(priv);
1281         return 0;
1282 }
1283
1284 static const struct i2c_device_id mt9t112_id[] = {
1285         { "mt9t112", 0 },
1286         { }
1287 };
1288 MODULE_DEVICE_TABLE(i2c, mt9t112_id);
1289
1290 static struct i2c_driver mt9t112_i2c_driver = {
1291         .driver = {
1292                 .name = "mt9t112",
1293         },
1294         .probe    = mt9t112_probe,
1295         .remove   = mt9t112_remove,
1296         .id_table = mt9t112_id,
1297 };
1298
1299 /************************************************************************
1300
1301
1302                         module function
1303
1304
1305 ************************************************************************/
1306 static int __init mt9t112_module_init(void)
1307 {
1308         return i2c_add_driver(&mt9t112_i2c_driver);
1309 }
1310
1311 static void __exit mt9t112_module_exit(void)
1312 {
1313         i2c_del_driver(&mt9t112_i2c_driver);
1314 }
1315
1316 module_init(mt9t112_module_init);
1317 module_exit(mt9t112_module_exit);
1318
1319 MODULE_DESCRIPTION("mt9t112 sensor driver");
1320 MODULE_AUTHOR("Kuninori Morimoto");
1321 MODULE_LICENSE("GPL v2");