?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Full support for Ginger Console
[linux-ginger.git] / drivers / media / video / imx046.c
blob34156725ec3769481cc0b06e5d9500db9191d8e1
1 /*
2 * drivers/media/video/imx046.c
3 *
4 * Sony imx046 sensor driver
5 *
6 *
7 * Copyright (C) 2008 Hewlett Packard
8 *
9 * Leverage mt9p012.c
10 *
11 * This file is licensed under the terms of the GNU General Public License
12 * version 2. This program is licensed "as is" without any warranty of any
13 * kind, whether express or implied.
14 */
15
16 #include <linux/i2c.h>
17 #include <linux/delay.h>
18
19 #include <media/v4l2-int-device.h>
20 #include <media/imx046.h>
21
22 #include "imx046_regs.h"
23 #include "omap34xxcam.h"
24 #include "isp/isp.h"
25 #include "isp/ispcsi2.h"
26
27
28 #define IMX046_DRIVER_NAME "imx046"
29 #define IMX046_MOD_NAME "IMX046: "
30
31 #define I2C_M_WR 0
32
33
34 /* from IMX046ES_registerSetting_I2C_MIPI_2lane_def_080925.xls */
35 const static struct imx046_reg initial_list[] = {
36 {IMX046_REG_IMAGE_ORIENTATION, 0x03, I2C_8BIT},
37 {IMX046_REG_COARSE_INT_TIME, 0x0120, I2C_16BIT},
38 {IMX046_REG_ANALOG_GAIN_GLOBAL, 0x80, I2C_16BIT},
39 {0x300A, 0x80, I2C_8BIT},
40 {IMX046_REG_Y_OPBADDR_START_DI, 0x08, I2C_8BIT},
41 {IMX046_REG_Y_OPBADDR_END_DI, 0x37, I2C_8BIT},
42 {IMX046_REG_CHCODE_OUTCHSINGLE, 0x60, I2C_8BIT},
43 {IMX046_REG_OUTIF, 0x01, I2C_8BIT},
44 {IMX046_REG_RGPOF_RGPOFV2, 0x28, I2C_8BIT},
45 {IMX046_REG_CPCKAUTOEN, 0x00, I2C_8BIT},
46 {IMX046_REG_RGCPVFB, 0x60, I2C_8BIT},
47 {IMX046_REG_RGAZPDRV, 0x24, I2C_8BIT},
48 {IMX046_REG_RGAZTEST, 0x34, I2C_8BIT},
49 {IMX046_REG_RGVSUNLV, 0x3B, I2C_8BIT},
50 {IMX046_REG_CLPOWER, 0x30, I2C_8BIT},
51 {IMX046_REG_CLPOWERSP, 0x00, I2C_8BIT},
52 {IMX046_REG_ACLDIRV_TVADDCLP, 0x00, I2C_8BIT},
53 {IMX046_REG_OPB_CTRL, 0x0080, I2C_16BIT},
54 {0x30AB, 0x1C, I2C_8BIT},
55 {0x30B0, 0x32, I2C_8BIT},
56 {0x30B2, 0x83, I2C_8BIT},
57 {IMX046_REG_RAW10CH2V2P_LO, 0xD8, I2C_8BIT},
58 {IMX046_REG_RAW10CH2V2D_LO, 0x17, I2C_8BIT},
59 {IMX046_REG_COMP8CH1V2P_LO, 0xCF, I2C_8BIT},
60 {IMX046_REG_COMP8CH1V2D_LO, 0xF1, I2C_8BIT},
61 {IMX046_REG_RAW10CH1V2P_LO, 0xD8, I2C_8BIT},
62 {IMX046_REG_RAW10CH1V2D_LO, 0x17, I2C_8BIT},
63 {0x3302, 0x0A, I2C_8BIT},
64 {0x3303, 0x09, I2C_8BIT},
65 {IMX046_REG_RGTLPX, 0x05, I2C_8BIT},
66 {IMX046_REG_RGTCLKPREPARE, 0x04, I2C_8BIT},
67 {IMX046_REG_RGTCLKZERO, 0x15, I2C_8BIT},
68 {IMX046_REG_RGTCLKPRE, 0x03, I2C_8BIT},
69 {IMX046_REG_RGTCLKPOST, 0x13, I2C_8BIT},
70 {IMX046_REG_RGTCLKTRAIL, 0x05, I2C_8BIT},
71 {IMX046_REG_RGTHSEXIT, 0x0B, I2C_8BIT},
72 {0x302B, 0x38, I2C_8BIT}, /* for 18Mhz xclk */
73 {I2C_REG_TERM, I2C_VAL_TERM, I2C_LEN_TERM}
74 };
75
76 /**
77 * struct imx046_sensor - main structure for storage of sensor information
78 * @pdata: access functions and data for platform level information
79 * @v4l2_int_device: V4L2 device structure structure
80 * @i2c_client: iic client device structure
81 * @pix: V4L2 pixel format information structure
82 * @timeperframe: time per frame expressed as V4L fraction
83 * @scaler:
84 * @ver: imx046 chip version
85 * @fps: frames per second value
86 */
87 struct imx046_sensor {
88 const struct imx046_platform_data *pdata;
89 struct v4l2_int_device *v4l2_int_device;
90 struct i2c_client *i2c_client;
91 struct v4l2_pix_format pix;
92 struct v4l2_fract timeperframe;
93 int scaler;
94 int ver;
95 int fps;
96 int state;
97 bool resuming;
98 };
99
100 static struct imx046_sensor imx046;
101 static struct i2c_driver imx046sensor_i2c_driver;
102 static unsigned long xclk_current = IMX046_XCLK_NOM_1;
103 static enum imx046_image_size isize_current = EIGHT_MP;
104
105 /* list of image formats supported by imx046 sensor */
106 const static struct v4l2_fmtdesc imx046_formats[] = {
107 {
108 .description = "Bayer10 (RGr/GbB)",
109 .pixelformat = V4L2_PIX_FMT_SRGGB10,
110 }
111 };
112
113 #define NUM_CAPTURE_FORMATS ARRAY_SIZE(imx046_formats)
114
115 static u32 min_exposure_time = 1000;
116 static u32 max_exposure_time = 128000;
117 static enum v4l2_power current_power_state;
118
119 /* Structure of Sensor settings that change with image size */
120 static struct imx046_sensor_settings sensor_settings[] = {
121 /* NOTE: must be in same order as image_size array */
122
123 /* QUART_MP */
124 {
125 .clk = {
126 .pre_pll_div = 1,
127 .pll_mult = 18,
128 .post_pll_div = 1,
129 .vt_pix_clk_div = 10,
130 .vt_sys_clk_div = 1,
131 },
132 .mipi = {
133 .data_lanes = 1,
134 .ths_prepare = 2,
135 .ths_zero = 5,
136 .ths_settle_lower = 8,
137 .ths_settle_upper = 28,
138 },
139 .frame = {
140 .frame_len_lines_min = 629,
141 .line_len_pck = 3440,
142 .x_addr_start = 0,
143 .x_addr_end = 3279,
144 .y_addr_start = 0,
145 .y_addr_end = 2463,
146 .x_output_size = 410,
147 .y_output_size = 308,
148 .x_even_inc = 9,
149 .x_odd_inc = 7,
150 .y_even_inc = 9,
151 .y_odd_inc = 7,
152 .v_mode_add = 0,
153 .h_mode_add = 0,
154 .h_add_ave = 1,
155 },
156 },
157
158 /* HALF_MP */
159 {
160 .clk = {
161 .pre_pll_div = 1,
162 .pll_mult = 18,
163 .post_pll_div = 1,
164 .vt_pix_clk_div = 10,
165 .vt_sys_clk_div = 1,
166 },
167 .mipi = {
168 .data_lanes = 1,
169 .ths_prepare = 2,
170 .ths_zero = 5,
171 .ths_settle_lower = 8,
172 .ths_settle_upper = 28,
173 },
174 .frame = {
175 .frame_len_lines_min = 629,
176 .line_len_pck = 3440,
177 .x_addr_start = 0,
178 .x_addr_end = 3279,
179 .y_addr_start = 0,
180 .y_addr_end = 2463,
181 .x_output_size = 820,
182 .y_output_size = 616,
183 .x_even_inc = 5,
184 .x_odd_inc = 3,
185 .y_even_inc = 5,
186 .y_odd_inc = 3,
187 .v_mode_add = 0,
188 .h_mode_add = 0,
189 .h_add_ave = 1,
190 },
191 },
192
193 /* TWO_MP */
194 {
195 .clk = {
196 .pre_pll_div = 1,
197 .pll_mult = 18,
198 .post_pll_div = 1,
199 .vt_pix_clk_div = 10,
200 .vt_sys_clk_div = 1,
201 },
202 .mipi = {
203 .data_lanes = 2,
204 .ths_prepare = 4,
205 .ths_zero = 5,
206 .ths_settle_lower = 13,
207 .ths_settle_upper = 33,
208 },
209 .frame = {
210 .frame_len_lines_min = 629,
211 .line_len_pck = 3440,
212 .x_addr_start = 0,
213 .x_addr_end = 3279,
214 .y_addr_start = 0,
215 .y_addr_end = 2463,
216 .x_output_size = 3280,
217 .y_output_size = 618,
218 .x_even_inc = 1,
219 .x_odd_inc = 1,
220 .y_even_inc = 5,
221 .y_odd_inc = 3,
222 .v_mode_add = 0,
223 .h_mode_add = 0,
224 .h_add_ave = 0,
225 },
226 },
227
228 /* EIGHT_MP */
229 {
230 .clk = {
231 .pre_pll_div = 1,
232 .pll_mult = 18,
233 .post_pll_div = 1,
234 .vt_pix_clk_div = 10,
235 .vt_sys_clk_div = 1,
236 },
237 .mipi = {
238 .data_lanes = 2,
239 .ths_prepare = 4,
240 .ths_zero = 5,
241 .ths_settle_lower = 13,
242 .ths_settle_upper = 33,
243 },
244 .frame = {
245 .frame_len_lines_min = 2510,
246 .line_len_pck = 3440,
247 .x_addr_start = 0,
248 .x_addr_end = 3279,
249 .y_addr_start = 0,
250 .y_addr_end = 2463,
251 .x_output_size = 3280,
252 .y_output_size = 2464,
253 .x_even_inc = 1,
254 .x_odd_inc = 1,
255 .y_even_inc = 1,
256 .y_odd_inc = 1,
257 .v_mode_add = 0,
258 .h_mode_add = 0,
259 .h_add_ave = 0,
260 },
261 },
262 };
263
264 static struct imx046_clock_freq current_clk;
265
266 struct i2c_list {
267 struct i2c_msg *reg_list;
268 unsigned int list_size;
269 };
270
271 /**
272 * struct vcontrol - Video controls
273 * @v4l2_queryctrl: V4L2 VIDIOC_QUERYCTRL ioctl structure
274 * @current_value: current value of this control
275 */
276 static struct vcontrol {
277 struct v4l2_queryctrl qc;
278 int current_value;
279 } imx046sensor_video_control[] = {
280 {
281 {
282 .id = V4L2_CID_EXPOSURE,
283 .type = V4L2_CTRL_TYPE_INTEGER,
284 .name = "Exposure",
285 .minimum = IMX046_MIN_EXPOSURE,
286 .maximum = IMX046_MAX_EXPOSURE,
287 .step = IMX046_EXPOSURE_STEP,
288 .default_value = IMX046_DEF_EXPOSURE,
289 },
290 .current_value = IMX046_DEF_EXPOSURE,
291 },
292 {
293 {
294 .id = V4L2_CID_GAIN,
295 .type = V4L2_CTRL_TYPE_INTEGER,
296 .name = "Analog Gain",
297 .minimum = IMX046_EV_MIN_GAIN,
298 .maximum = IMX046_EV_MAX_GAIN,
299 .step = IMX046_EV_GAIN_STEP,
300 .default_value = IMX046_EV_DEF_GAIN,
301 },
302 .current_value = IMX046_EV_DEF_GAIN,
303 },
304 {
305 {
306 .id = V4L2_CID_TEST_PATTERN,
307 .type = V4L2_CTRL_TYPE_INTEGER,
308 .name = "Test Pattern",
309 .minimum = IMX046_MIN_TEST_PATT_MODE,
310 .maximum = IMX046_MAX_TEST_PATT_MODE,
311 .step = IMX046_MODE_TEST_PATT_STEP,
312 .default_value = IMX046_MIN_TEST_PATT_MODE,
313 },
314 .current_value = IMX046_MIN_TEST_PATT_MODE,
315 }
316 };
317
318 /**
319 * find_vctrl - Finds the requested ID in the video control structure array
320 * @id: ID of control to search the video control array for
321 *
322 * Returns the index of the requested ID from the control structure array
323 */
324 static int
325 find_vctrl(int id)
326 {
327 int i;
328
329 if (id < V4L2_CID_BASE)
330 return -EDOM;
331
332 for (i = (ARRAY_SIZE(imx046sensor_video_control) - 1); i >= 0; i--)
333 if (imx046sensor_video_control[i].qc.id == id)
334 break;
335 if (i < 0)
336 i = -EINVAL;
337 return i;
338 }
339
340 /**
341 * imx046_read_reg - Read a value from a register in an imx046 sensor device
342 * @client: i2c driver client structure
343 * @data_length: length of data to be read
344 * @reg: register address / offset
345 * @val: stores the value that gets read
346 *
347 * Read a value from a register in an imx046 sensor device.
348 * The value is returned in 'val'.
349 * Returns zero if successful, or non-zero otherwise.
350 */
351 static int
352 imx046_read_reg(struct i2c_client *client, u16 data_length, u16 reg, u32 *val)
353 {
354 int err;
355 struct i2c_msg msg[1];
356 unsigned char data[4];
357
358 if (!client->adapter)
359 return -ENODEV;
360 if (data_length != I2C_8BIT && data_length != I2C_16BIT
361 && data_length != I2C_32BIT)
362 return -EINVAL;
363
364 msg->addr = client->addr;
365 msg->flags = 0;
366 msg->len = 2;
367 msg->buf = data;
368
369 /* Write addr - high byte goes out first */
370 data[0] = (u8) (reg >> 8);;
371 data[1] = (u8) (reg & 0xff);
372 err = i2c_transfer(client->adapter, msg, 1);
373
374 /* Read back data */
375 if (err >= 0) {
376 msg->len = data_length;
377 msg->flags = I2C_M_RD;
378 err = i2c_transfer(client->adapter, msg, 1);
379 }
380 if (err >= 0) {
381 *val = 0;
382 /* high byte comes first */
383 if (data_length == I2C_8BIT)
384 *val = data[0];
385 else if (data_length == I2C_16BIT)
386 *val = data[1] + (data[0] << 8);
387 else
388 *val = data[3] + (data[2] << 8) +
389 (data[1] << 16) + (data[0] << 24);
390 return 0;
391 }
392 v4l_err(client, "read from offset 0x%x error %d", reg, err);
393 return err;
394 }
395
396 /**
397 * Write a value to a register in imx046 sensor device.
398 * @client: i2c driver client structure.
399 * @reg: Address of the register to read value from.
400 * @val: Value to be written to a specific register.
401 * Returns zero if successful, or non-zero otherwise.
402 */
403 static int imx046_write_reg(struct i2c_client *client, u16 reg,
404 u32 val, u16 data_length)
405 {
406 int err = 0;
407 struct i2c_msg msg[1];
408 unsigned char data[6];
409 int retries = 0;
410
411 if (!client->adapter)
412 return -ENODEV;
413
414 if (data_length != I2C_8BIT && data_length != I2C_16BIT
415 && data_length != I2C_32BIT)
416 return -EINVAL;
417
418 retry:
419 msg->addr = client->addr;
420 msg->flags = I2C_M_WR;
421 msg->len = data_length+2; /* add address bytes */
422 msg->buf = data;
423
424 /* high byte goes out first */
425 data[0] = (u8) (reg >> 8);
426 data[1] = (u8) (reg & 0xff);
427 if (data_length == I2C_8BIT) {
428 data[2] = val & 0xff;
429 } else if (data_length == I2C_16BIT) {
430 data[2] = (val >> 8) & 0xff;
431 data[3] = val & 0xff;
432 } else {
433 data[2] = (val >> 24) & 0xff;
434 data[3] = (val >> 16) & 0xff;
435 data[4] = (val >> 8) & 0xff;
436 data[5] = val & 0xff;
437 }
438
439 if (data_length == 1)
440 dev_dbg(&client->dev, "IMX046 Wrt:[0x%04X]=0x%02X\n",
441 reg, val);
442 else if (data_length == 2)
443 dev_dbg(&client->dev, "IMX046 Wrt:[0x%04X]=0x%04X\n",
444 reg, val);
445
446 err = i2c_transfer(client->adapter, msg, 1);
447
448 if (err >= 0)
449 return 0;
450
451 if (retries <= 5) {
452 v4l_info(client, "Retrying I2C... %d", retries);
453 retries++;
454 mdelay(20);
455 goto retry;
456 }
457
458 return err;
459 }
460
461 /**
462 * Initialize a list of imx046 registers.
463 * The list of registers is terminated by the pair of values
464 * {OV3640_REG_TERM, OV3640_VAL_TERM}.
465 * @client: i2c driver client structure.
466 * @reglist[]: List of address of the registers to write data.
467 * Returns zero if successful, or non-zero otherwise.
468 */
469 static int imx046_write_regs(struct i2c_client *client,
470 const struct imx046_reg reglist[])
471 {
472 int err = 0;
473 const struct imx046_reg *list = reglist;
474
475 while (!((list->reg == I2C_REG_TERM)
476 && (list->val == I2C_VAL_TERM))) {
477 err = imx046_write_reg(client, list->reg,
478 list->val, list->length);
479 if (err)
480 return err;
481 list++;
482 }
483 return 0;
484 }
485
486 /**
487 * imx046_find_size - Find the best match for a requested image capture size
488 * @width: requested image width in pixels
489 * @height: requested image height in pixels
490 *
491 * Find the best match for a requested image capture size. The best match
492 * is chosen as the nearest match that has the same number or fewer pixels
493 * as the requested size, or the smallest image size if the requested size
494 * has fewer pixels than the smallest image.
495 * Since the available sizes are subsampled in the vertical direction only,
496 * the routine will find the size with a height that is equal to or less
497 * than the requested height.
498 */
499 static enum imx046_image_size imx046_find_size(unsigned int width,
500 unsigned int height)
501 {
502 enum imx046_image_size isize;
503
504 for (isize = QUART_MP; isize <= EIGHT_MP; isize++) {
505 if ((imx046_sizes[isize].height >= height) &&
506 (imx046_sizes[isize].width >= width)) {
507 break;
508 }
509 }
510
511 printk(KERN_DEBUG "imx046_find_size: Req Size=%dx%d, "
512 "Calc Size=%dx%d\n",
513 width, height, (int)imx046_sizes[isize].width,
514 (int)imx046_sizes[isize].height);
515
516 return isize;
517 }
518
519 /**
520 * Set CSI2 Virtual ID.
521 * @client: i2c client driver structure
522 * @id: Virtual channel ID.
523 *
524 * Sets the channel ID which identifies data packets sent by this device
525 * on the CSI2 bus.
526 **/
527 static int imx046_set_virtual_id(struct i2c_client *client, u32 id)
528 {
529 return imx046_write_reg(client, IMX046_REG_CCP2_CHANNEL_ID,
530 (0x3 & id), I2C_8BIT);
531 }
532
533 /**
534 * imx046_set_framerate - Sets framerate by adjusting frame_length_lines reg.
535 * @s: pointer to standard V4L2 device structure
536 * @fper: frame period numerator and denominator in seconds
537 *
538 * The maximum exposure time is also updated since it is affected by the
539 * frame rate.
540 **/
541 static int imx046_set_framerate(struct v4l2_int_device *s,
542 struct v4l2_fract *fper)
543 {
544 int err = 0;
545 u16 isize = isize_current;
546 u32 frame_length_lines, line_time_q8;
547 struct imx046_sensor *sensor = s->priv;
548 struct i2c_client *client = sensor->i2c_client;
549 struct imx046_sensor_settings *ss;
550
551 if ((fper->numerator == 0) || (fper->denominator == 0)) {
552 /* supply a default nominal_timeperframe */
553 fper->numerator = 1;
554 fper->denominator = IMX046_DEF_FPS;
555 }
556
557 sensor->fps = fper->denominator / fper->numerator;
558 if (sensor->fps < IMX046_MIN_FPS) {
559 sensor->fps = IMX046_MIN_FPS;
560 fper->numerator = 1;
561 fper->denominator = sensor->fps;
562 } else if (sensor->fps > IMX046_MAX_FPS) {
563 sensor->fps = IMX046_MAX_FPS;
564 fper->numerator = 1;
565 fper->denominator = sensor->fps;
566 }
567
568 ss = &sensor_settings[isize_current];
569
570 line_time_q8 = ((u32)ss->frame.line_len_pck * 1000000) /
571 (current_clk.vt_pix_clk >> 8); /* usec's */
572
573 frame_length_lines = (((u32)fper->numerator * 1000000 * 256 /
574 fper->denominator)) / line_time_q8;
575
576 /* Range check frame_length_lines */
577 if (frame_length_lines > IMX046_MAX_FRAME_LENGTH_LINES)
578 frame_length_lines = IMX046_MAX_FRAME_LENGTH_LINES;
579 else if (frame_length_lines < ss->frame.frame_len_lines_min)
580 frame_length_lines = ss->frame.frame_len_lines_min;
581
582 imx046_write_reg(client, IMX046_REG_FRAME_LEN_LINES,
583 frame_length_lines, I2C_16BIT);
584
585 sensor_settings[isize].frame.frame_len_lines = frame_length_lines;
586
587 /* Update max exposure time */
588 max_exposure_time = (line_time_q8 * (frame_length_lines - 1)) >> 8;
589
590 printk(KERN_DEBUG "IMX046 Set Framerate: fper=%d/%d, "
591 "frame_len_lines=%d, max_expT=%dus\n", fper->numerator,
592 fper->denominator, frame_length_lines, max_exposure_time);
593
594 return err;
595 }
596
597 /**
598 * imx046sensor_calc_xclk - Calculate the required xclk frequency
599 *
600 * Xclk is not determined from framerate for the IMX046
601 */
602 static unsigned long imx046sensor_calc_xclk(void)
603 {
604 xclk_current = IMX046_XCLK_NOM_1;
605
606 return xclk_current;
607 }
608
609 /**
610 * Sets the correct orientation based on the sensor version.
611 * IU046F2-Z version=2 orientation=3
612 * IU046F4-2D version>2 orientation=0
613 */
614 static int imx046_set_orientation(struct i2c_client *client, u32 ver)
615 {
616 int err;
617 u8 orient;
618
619 orient = (ver <= 0x2) ? 0x3 : 0x0;
620 err = imx046_write_reg(client, IMX046_REG_IMAGE_ORIENTATION,
621 orient, I2C_8BIT);
622 return err;
623 }
624
625 /**
626 * imx046sensor_set_exposure_time - sets exposure time per input value
627 * @exp_time: exposure time to be set on device (in usec)
628 * @s: pointer to standard V4L2 device structure
629 * @lvc: pointer to V4L2 exposure entry in imx046sensor_video_controls array
630 *
631 * If the requested exposure time is within the allowed limits, the HW
632 * is configured to use the new exposure time, and the
633 * imx046sensor_video_control[] array is updated with the new current value.
634 * The function returns 0 upon success. Otherwise an error code is
635 * returned.
636 */
637 int imx046sensor_set_exposure_time(u32 exp_time, struct v4l2_int_device *s,
638 struct vcontrol *lvc)
639 {
640 int err = 0, i;
641 struct imx046_sensor *sensor = s->priv;
642 struct i2c_client *client = sensor->i2c_client;
643 u16 coarse_int_time = 0;
644 u32 line_time_q8 = 0;
645 struct imx046_sensor_settings *ss;
646
647 if ((current_power_state == V4L2_POWER_ON) || sensor->resuming) {
648 if (exp_time < min_exposure_time) {
649 v4l_err(client, "Exposure time %d us not within"
650 " the legal range.\n", exp_time);
651 v4l_err(client, "Exposure time must be between"
652 " %d us and %d us\n",
653 min_exposure_time, max_exposure_time);
654 exp_time = min_exposure_time;
655 }
656
657 if (exp_time > max_exposure_time) {
658 v4l_err(client, "Exposure time %d us not within"
659 " the legal range.\n", exp_time);
660 v4l_err(client, "Exposure time must be between"
661 " %d us and %d us\n",
662 min_exposure_time, max_exposure_time);
663 exp_time = max_exposure_time;
664 }
665
666 ss = &sensor_settings[isize_current];
667
668 line_time_q8 =
669 ((u32)ss->frame.line_len_pck * 1000000) /
670 (current_clk.vt_pix_clk >> 8); /* usec's */
671
672 coarse_int_time = ((exp_time * 256) + (line_time_q8 >> 1)) /
673 line_time_q8;
674
675 if (coarse_int_time > ss->frame.frame_len_lines - 2)
676 coarse_int_time = ss->frame.frame_len_lines - 2;
677
678 err = imx046_write_reg(client, IMX046_REG_COARSE_INT_TIME,
679 coarse_int_time, I2C_16BIT);
680 }
681
682 if (err) {
683 v4l_err(client, "Error setting exposure time: %d", err);
684 } else {
685 i = find_vctrl(V4L2_CID_EXPOSURE);
686 if (i >= 0) {
687 lvc = &imx046sensor_video_control[i];
688 lvc->current_value = exp_time;
689 }
690 }
691
692 return err;
693 }
694
695 /**
696 * This table describes what should be written to the sensor register for each
697 * gain value. The gain(index in the table) is in terms of 0.1EV, i.e. 10
698 * indexes in the table give 2 time more gain
699 *
700 * Elements in TS2_8_GAIN_TBL doesn't comply linearity. This is because
701 * there is nonlinear dependecy between analogue_gain_code_global and real gain
702 * value: Gain_analog = 256 / (256 - analogue_gain_code_global)
703 */
704
705 const u16 IMX046_EV_GAIN_TBL[IMX046_EV_TABLE_GAIN_MAX + 1] = {
706 /* Gain x1 */
707 0, 16, 33, 48,
708 62, 74, 88, 98,
709 109, 119,
710
711 /* Gain x2 */
712 128, 136, 144, 152,
713 159, 165, 171, 177,
714 182, 187,
715
716 /* Gain x4 */
717 192, 196, 200, 204,
718 208, 211, 214, 216,
719 219, 222,
720
721 /* Gain x8 */
722 224
723 };
724
725 /**
726 * imx046sensor_set_gain - sets sensor analog gain per input value
727 * @gain: analog gain value to be set on device
728 * @s: pointer to standard V4L2 device structure
729 * @lvc: pointer to V4L2 analog gain entry in imx046sensor_video_control array
730 *
731 * If the requested analog gain is within the allowed limits, the HW
732 * is configured to use the new gain value, and the imx046sensor_video_control
733 * array is updated with the new current value.
734 * The function returns 0 upon success. Otherwise an error code is
735 * returned.
736 */
737 int imx046sensor_set_gain(u16 lineargain, struct v4l2_int_device *s,
738 struct vcontrol *lvc)
739 {
740 int err = 0, i;
741 u16 reg_gain = 0;
742 struct imx046_sensor *sensor = s->priv;
743 struct i2c_client *client = sensor->i2c_client;
744
745 if (current_power_state == V4L2_POWER_ON || sensor->resuming) {
746
747 if (lineargain < IMX046_EV_MIN_GAIN) {
748 lineargain = IMX046_EV_MIN_GAIN;
749 v4l_err(client, "Gain out of legal range.");
750 }
751 if (lineargain > IMX046_EV_MAX_GAIN) {
752 lineargain = IMX046_EV_MAX_GAIN;
753 v4l_err(client, "Gain out of legal range.");
754 }
755
756 reg_gain = IMX046_EV_GAIN_TBL[lineargain];
757
758 err = imx046_write_reg(client, IMX046_REG_ANALOG_GAIN_GLOBAL,
759 reg_gain, I2C_16BIT);
760 }
761
762 if (err) {
763 v4l_err(client, "Error setting analog gain: %d", err);
764 } else {
765 i = find_vctrl(V4L2_CID_GAIN);
766 if (i >= 0) {
767 lvc = &imx046sensor_video_control[i];
768 lvc->current_value = lineargain;
769 }
770 }
771
772 return err;
773 }
774
775 /**
776 * imx046_update_clocks - calcs sensor clocks based on sensor settings.
777 * @isize: image size enum
778 */
779 int imx046_update_clocks(u32 xclk, enum imx046_image_size isize)
780 {
781 current_clk.vco_clk =
782 xclk * sensor_settings[isize].clk.pll_mult /
783 sensor_settings[isize].clk.pre_pll_div /
784 sensor_settings[isize].clk.post_pll_div;
785
786 current_clk.vt_pix_clk = current_clk.vco_clk * 2 /
787 (sensor_settings[isize].clk.vt_pix_clk_div *
788 sensor_settings[isize].clk.vt_sys_clk_div);
789
790 if (sensor_settings[isize].mipi.data_lanes == 2)
791 current_clk.mipi_clk = current_clk.vco_clk;
792 else
793 current_clk.mipi_clk = current_clk.vco_clk / 2;
794
795 current_clk.ddr_clk = current_clk.mipi_clk / 2;
796
797 printk(KERN_DEBUG "IMX046: xclk=%u, vco_clk=%u, "
798 "vt_pix_clk=%u, mipi_clk=%u, ddr_clk=%u\n",
799 xclk, current_clk.vco_clk, current_clk.vt_pix_clk,
800 current_clk.mipi_clk, current_clk.ddr_clk);
801
802 return 0;
803 }
804
805 /**
806 * imx046_setup_pll - initializes sensor PLL registers.
807 * @c: i2c client driver structure
808 * @isize: image size enum
809 */
810 int imx046_setup_pll(struct i2c_client *client, enum imx046_image_size isize)
811 {
812 u32 rgpltd_reg;
813 u32 rgpltd[3] = {2, 0, 1};
814
815 imx046_write_reg(client, IMX046_REG_PRE_PLL_CLK_DIV,
816 sensor_settings[isize].clk.pre_pll_div, I2C_16BIT);
817
818 imx046_write_reg(client, IMX046_REG_PLL_MULTIPLIER,
819 sensor_settings[isize].clk.pll_mult, I2C_16BIT);
820
821 imx046_read_reg(client, I2C_8BIT, IMX046_REG_RGPLTD_RGCLKEN,
822 &rgpltd_reg);
823 rgpltd_reg &= ~RGPLTD_MASK;
824 rgpltd_reg |= rgpltd[sensor_settings[isize].clk.post_pll_div >> 1];
825 imx046_write_reg(client, IMX046_REG_RGPLTD_RGCLKEN,
826 rgpltd_reg, I2C_8BIT);
827
828 imx046_write_reg(client, IMX046_REG_VT_PIX_CLK_DIV,
829 sensor_settings[isize].clk.vt_pix_clk_div, I2C_16BIT);
830
831 imx046_write_reg(client, IMX046_REG_VT_SYS_CLK_DIV,
832 sensor_settings[isize].clk.vt_sys_clk_div, I2C_16BIT);
833
834 printk(KERN_DEBUG "IMX046: pre_pll_clk_div=%u, pll_mult=%u, "
835 "rgpltd=0x%x, vt_pix_clk_div=%u, vt_sys_clk_div=%u\n",
836 sensor_settings[isize].clk.pre_pll_div,
837 sensor_settings[isize].clk.pll_mult, rgpltd_reg,
838 sensor_settings[isize].clk.vt_pix_clk_div,
839 sensor_settings[isize].clk.vt_sys_clk_div);
840
841 return 0;
842 }
843
844 /**
845 * imx046_setup_mipi - initializes sensor & isp MIPI registers.
846 * @c: i2c client driver structure
847 * @isize: image size enum
848 */
849 int imx046_setup_mipi(struct imx046_sensor *sensor,
850 enum imx046_image_size isize)
851 {
852 struct i2c_client *client = sensor->i2c_client;
853
854 /* NOTE: Make sure imx046_update_clocks is called 1st */
855
856 /* Enable MIPI */
857 imx046_write_reg(client, IMX046_REG_RGOUTSEL1, 0x00, I2C_8BIT);
858 imx046_write_reg(client, IMX046_REG_TESTDI, 0x04, I2C_8BIT);
859
860 /* Set sensor Mipi timing params */
861 imx046_write_reg(client, IMX046_REG_RGTHSTRAIL, 0x06, I2C_8BIT);
862
863 imx046_write_reg(client, IMX046_REG_RGTHSPREPARE,
864 sensor_settings[isize].mipi.ths_prepare, I2C_8BIT);
865
866 imx046_write_reg(client, IMX046_REG_RGTHSZERO,
867 sensor_settings[isize].mipi.ths_zero, I2C_8BIT);
868
869 /* Set number of lanes in sensor */
870 if (sensor_settings[isize].mipi.data_lanes == 2)
871 imx046_write_reg(client, IMX046_REG_RGLANESEL, 0x00, I2C_8BIT);
872 else
873 imx046_write_reg(client, IMX046_REG_RGLANESEL, 0x01, I2C_8BIT);
874
875 /* Set number of lanes in isp */
876 sensor->pdata->csi2_lane_count(sensor_settings[isize].mipi.data_lanes);
877
878 /* Send settings to ISP-CSI2 Receiver PHY */
879 sensor->pdata->csi2_calc_phy_cfg0(current_clk.mipi_clk,
880 sensor_settings[isize].mipi.ths_settle_lower,
881 sensor_settings[isize].mipi.ths_settle_upper);
882
883 /* Dump some registers for debug purposes */
884 printk(KERN_DEBUG "imx:THSPREPARE=0x%02X\n",
885 sensor_settings[isize].mipi.ths_prepare);
886 printk(KERN_DEBUG "imx:THSZERO=0x%02X\n",
887 sensor_settings[isize].mipi.ths_zero);
888 printk(KERN_DEBUG "imx:LANESEL=0x%02X\n",
889 (sensor_settings[isize].mipi.data_lanes == 2) ? 0 : 1);
890
891 return 0;
892 }
893
894 /**
895 * imx046_configure_frame - initializes image frame registers
896 * @c: i2c client driver structure
897 * @isize: image size enum
898 */
899 int imx046_configure_frame(struct i2c_client *client,
900 enum imx046_image_size isize)
901 {
902 u32 val;
903
904 imx046_write_reg(client, IMX046_REG_FRAME_LEN_LINES,
905 sensor_settings[isize].frame.frame_len_lines_min, I2C_16BIT);
906
907 imx046_write_reg(client, IMX046_REG_LINE_LEN_PCK,
908 sensor_settings[isize].frame.line_len_pck, I2C_16BIT);
909
910 imx046_write_reg(client, IMX046_REG_X_ADDR_START,
911 sensor_settings[isize].frame.x_addr_start, I2C_16BIT);
912
913 imx046_write_reg(client, IMX046_REG_X_ADDR_END,
914 sensor_settings[isize].frame.x_addr_end, I2C_16BIT);
915
916 imx046_write_reg(client, IMX046_REG_Y_ADDR_START,
917 sensor_settings[isize].frame.y_addr_start, I2C_16BIT);
918
919 imx046_write_reg(client, IMX046_REG_Y_ADDR_END,
920 sensor_settings[isize].frame.y_addr_end, I2C_16BIT);
921
922 imx046_write_reg(client, IMX046_REG_X_OUTPUT_SIZE,
923 sensor_settings[isize].frame.x_output_size, I2C_16BIT);
924
925 imx046_write_reg(client, IMX046_REG_Y_OUTPUT_SIZE,
926 sensor_settings[isize].frame.y_output_size, I2C_16BIT);
927
928 imx046_write_reg(client, IMX046_REG_X_EVEN_INC,
929 sensor_settings[isize].frame.x_even_inc, I2C_16BIT);
930
931 imx046_write_reg(client, IMX046_REG_X_ODD_INC,
932 sensor_settings[isize].frame.x_odd_inc, I2C_16BIT);
933
934 imx046_write_reg(client, IMX046_REG_Y_EVEN_INC,
935 sensor_settings[isize].frame.y_even_inc, I2C_16BIT);
936
937 imx046_write_reg(client, IMX046_REG_Y_ODD_INC,
938 sensor_settings[isize].frame.y_odd_inc, I2C_16BIT);
939
940 imx046_read_reg(client, I2C_8BIT, IMX046_REG_PGACUR_VMODEADD, &val);
941 val &= ~VMODEADD_MASK;
942 val |= sensor_settings[isize].frame.v_mode_add << VMODEADD_SHIFT;
943 imx046_write_reg(client, IMX046_REG_PGACUR_VMODEADD, val, I2C_8BIT);
944
945 imx046_read_reg(client, I2C_8BIT, IMX046_REG_HMODEADD, &val);
946 val &= ~HMODEADD_MASK;
947 val |= sensor_settings[isize].frame.h_mode_add << HMODEADD_SHIFT;
948 imx046_write_reg(client, IMX046_REG_HMODEADD, val, I2C_8BIT);
949
950 imx046_read_reg(client, I2C_8BIT, IMX046_REG_HADDAVE, &val);
951 val &= ~HADDAVE_MASK;
952 val |= sensor_settings[isize].frame.h_add_ave << HADDAVE_SHIFT;
953 imx046_write_reg(client, IMX046_REG_HADDAVE, val, I2C_8BIT);
954
955 return 0;
956 }
957
958 /**
959 * imx046_configure_test_pattern - Configure 3 possible test pattern modes
960 * @ mode: Test pattern mode. Possible modes : 1 , 2 and 4.
961 * @s: pointer to standard V4L2 device structure
962 * @lvc: pointer to V4L2 exposure entry in imx046sensor_video_controls array
963 *
964 * If the requested test pattern mode is within the allowed limits, the HW
965 * is configured for that particular test pattern, and the
966 * imx046sensor_video_control[] array is updated with the new current value.
967 * The function returns 0 upon success. Otherwise an error code is
968 * returned.
969 */
970 int imx046_configure_test_pattern(int mode, struct v4l2_int_device *s,
971 struct vcontrol *lvc)
972 {
973 struct imx046_sensor *sensor = s->priv;
974 struct i2c_client *client = sensor->i2c_client;
975
976 if ((current_power_state == V4L2_POWER_ON) || sensor->resuming) {
977
978 switch (mode) {
979 case IMX046_TEST_PATT_COLOR_BAR:
980 case IMX046_TEST_PATT_PN9:
981 /* red */
982 imx046_write_reg(client, IMX046_REG_TEST_PATT_RED,
983 0x07ff, I2C_16BIT);
984 /* green-red */
985 imx046_write_reg(client, IMX046_REG_TEST_PATT_GREENR,
986 0x00ff, I2C_16BIT);
987 /* blue */
988 imx046_write_reg(client, IMX046_REG_TEST_PATT_BLUE,
989 0x0000, I2C_16BIT);
990 /* green-blue */
991 imx046_write_reg(client, IMX046_REG_TEST_PATT_GREENB,
992 0x0000, I2C_16BIT);
993 break;
994 case IMX046_TEST_PATT_SOLID_COLOR:
995 /* red */
996 imx046_write_reg(client, IMX046_REG_TEST_PATT_RED,
997 (IMX046_BLACK_LEVEL_AVG & 0x00ff), I2C_16BIT);
998 /* green-red */
999 imx046_write_reg(client, IMX046_REG_TEST_PATT_GREENR,
1000 (IMX046_BLACK_LEVEL_AVG & 0x00ff), I2C_16BIT);
1001 /* blue */
1002 imx046_write_reg(client, IMX046_REG_TEST_PATT_BLUE,
1003 (IMX046_BLACK_LEVEL_AVG & 0x00ff), I2C_16BIT);
1004 /* green-blue */
1005 imx046_write_reg(client, IMX046_REG_TEST_PATT_GREENB,
1006 (IMX046_BLACK_LEVEL_AVG & 0x00ff), I2C_16BIT);
1007 break;
1008 }
1009 /* test-pattern mode */
1010 imx046_write_reg(client, IMX046_REG_TEST_PATT_MODE,
1011 (mode & 0x7), I2C_16BIT);
1012 /* Disable sensor ISP processing */
1013 imx046_write_reg(client, IMX046_REG_TESBYPEN,
1014 (mode == 0) ? 0x0 : 0x10, I2C_8BIT);
1015 }
1016 lvc->current_value = mode;
1017 return 0;
1018 }
1019 /**
1020 * imx046_configure - Configure the imx046 for the specified image mode
1021 * @s: pointer to standard V4L2 device structure
1022 *
1023 * Configure the imx046 for a specified image size, pixel format, and frame
1024 * period. xclk is the frequency (in Hz) of the xclk input to the imx046.
1025 * fper is the frame period (in seconds) expressed as a fraction.
1026 * Returns zero if successful, or non-zero otherwise.
1027 * The actual frame period is returned in fper.
1028 */
1029 static int imx046_configure(struct v4l2_int_device *s)
1030 {
1031 struct imx046_sensor *sensor = s->priv;
1032 struct v4l2_pix_format *pix = &sensor->pix;
1033 struct i2c_client *client = sensor->i2c_client;
1034 enum imx046_image_size isize;
1035 int err, i;
1036 struct vcontrol *lvc = NULL;
1037
1038 isize = imx046_find_size(pix->width, pix->height);
1039 isize_current = isize;
1040
1041 err = imx046_write_reg(client, IMX046_REG_SW_RESET, 0x01, I2C_8BIT);
1042 mdelay(5);
1043
1044 imx046_write_regs(client, initial_list);
1045
1046 imx046_update_clocks(xclk_current, isize);
1047 imx046_setup_pll(client, isize);
1048
1049 imx046_setup_mipi(sensor, isize);
1050
1051 /* configure image size and pixel format */
1052 imx046_configure_frame(client, isize);
1053
1054 /* Setting of frame rate */
1055 err = imx046_set_framerate(s, &sensor->timeperframe);
1056
1057 imx046_set_orientation(client, sensor->ver);
1058
1059 sensor->pdata->csi2_cfg_vp_out_ctrl(2);
1060 sensor->pdata->csi2_ctrl_update(false);
1061
1062 sensor->pdata->csi2_cfg_virtual_id(0, IMX046_CSI2_VIRTUAL_ID);
1063 sensor->pdata->csi2_ctx_update(0, false);
1064 imx046_set_virtual_id(client, IMX046_CSI2_VIRTUAL_ID);
1065
1066 /* Set initial exposure and gain */
1067 i = find_vctrl(V4L2_CID_EXPOSURE);
1068 if (i >= 0) {
1069 lvc = &imx046sensor_video_control[i];
1070 imx046sensor_set_exposure_time(lvc->current_value,
1071 sensor->v4l2_int_device, lvc);
1072 }
1073
1074 i = find_vctrl(V4L2_CID_GAIN);
1075 if (i >= 0) {
1076 lvc = &imx046sensor_video_control[i];
1077 imx046sensor_set_gain(lvc->current_value,
1078 sensor->v4l2_int_device, lvc);
1079 }
1080
1081 i = find_vctrl(V4L2_CID_TEST_PATTERN);
1082 if (i >= 0) {
1083 lvc = &imx046sensor_video_control[i];
1084 imx046_configure_test_pattern(lvc->current_value,
1085 sensor->v4l2_int_device, lvc);
1086 }
1087 /* configure streaming ON */
1088 err = imx046_write_reg(client, IMX046_REG_MODE_SELECT, 0x01, I2C_8BIT);
1089 mdelay(1);
1090
1091 return err;
1092 }
1093
1094 /**
1095 * imx046_detect - Detect if an imx046 is present, and if so which revision
1096 * @client: pointer to the i2c client driver structure
1097 *
1098 * Detect if an imx046 is present, and if so which revision.
1099 * A device is considered to be detected if the manufacturer ID (MIDH and MIDL)
1100 * and the product ID (PID) registers match the expected values.
1101 * Any value of the version ID (VER) register is accepted.
1102 * Returns a negative error number if no device is detected, or the
1103 * non-negative value of the version ID register if a device is detected.
1104 */
1105 static int
1106 imx046_detect(struct i2c_client *client)
1107 {
1108 u32 model_id, mfr_id, rev;
1109 struct imx046_sensor *sensor;
1110
1111 if (!client)
1112 return -ENODEV;
1113
1114 sensor = i2c_get_clientdata(client);
1115
1116 if (imx046_read_reg(client, I2C_16BIT, IMX046_REG_MODEL_ID, &model_id))
1117 return -ENODEV;
1118 if (imx046_read_reg(client, I2C_8BIT, IMX046_REG_MFR_ID, &mfr_id))
1119 return -ENODEV;
1120 if (imx046_read_reg(client, I2C_8BIT, IMX046_REG_REV_NUMBER, &rev))
1121 return -ENODEV;
1122
1123 v4l_info(client, "model id detected 0x%x mfr 0x%x, rev# 0x%x\n",
1124 model_id, mfr_id, rev);
1125 if ((model_id != IMX046_MOD_ID) || (mfr_id != IMX046_MFR_ID)) {
1126 /* We didn't read the values we expected, so
1127 * this must not be an IMX046.
1128 */
1129 v4l_warn(client, "model id mismatch 0x%x mfr 0x%x\n",
1130 model_id, mfr_id);
1131
1132 return -ENODEV;
1133 }
1134 return rev;
1135 }
1136
1137 /**
1138 * ioctl_queryctrl - V4L2 sensor interface handler for VIDIOC_QUERYCTRL ioctl
1139 * @s: pointer to standard V4L2 device structure
1140 * @qc: standard V4L2 VIDIOC_QUERYCTRL ioctl structure
1141 *
1142 * If the requested control is supported, returns the control information
1143 * from the imx046sensor_video_control[] array.
1144 * Otherwise, returns -EINVAL if the control is not supported.
1145 */
1146 static int ioctl_queryctrl(struct v4l2_int_device *s,
1147 struct v4l2_queryctrl *qc)
1148 {
1149 int i;
1150
1151 i = find_vctrl(qc->id);
1152 if (i == -EINVAL)
1153 qc->flags = V4L2_CTRL_FLAG_DISABLED;
1154
1155 if (i < 0)
1156 return -EINVAL;
1157
1158 *qc = imx046sensor_video_control[i].qc;
1159 return 0;
1160 }
1161
1162 /**
1163 * ioctl_g_ctrl - V4L2 sensor interface handler for VIDIOC_G_CTRL ioctl
1164 * @s: pointer to standard V4L2 device structure
1165 * @vc: standard V4L2 VIDIOC_G_CTRL ioctl structure
1166 *
1167 * If the requested control is supported, returns the control's current
1168 * value from the imx046sensor_video_control[] array.
1169 * Otherwise, returns -EINVAL if the control is not supported.
1170 */
1171 static int ioctl_g_ctrl(struct v4l2_int_device *s,
1172 struct v4l2_control *vc)
1173 {
1174 struct vcontrol *lvc;
1175 int i;
1176
1177 i = find_vctrl(vc->id);
1178 if (i < 0)
1179 return -EINVAL;
1180 lvc = &imx046sensor_video_control[i];
1181
1182 switch (vc->id) {
1183 case V4L2_CID_EXPOSURE:
1184 vc->value = lvc->current_value;
1185 break;
1186 case V4L2_CID_GAIN:
1187 vc->value = lvc->current_value;
1188 break;
1189 case V4L2_CID_TEST_PATTERN:
1190 vc->value = lvc->current_value;
1191 break;
1192 }
1193
1194 return 0;
1195 }
1196
1197 /**
1198 * ioctl_s_ctrl - V4L2 sensor interface handler for VIDIOC_S_CTRL ioctl
1199 * @s: pointer to standard V4L2 device structure
1200 * @vc: standard V4L2 VIDIOC_S_CTRL ioctl structure
1201 *
1202 * If the requested control is supported, sets the control's current
1203 * value in HW (and updates the imx046sensor_video_control[] array).
1204 * Otherwise, * returns -EINVAL if the control is not supported.
1205 */
1206 static int ioctl_s_ctrl(struct v4l2_int_device *s,
1207 struct v4l2_control *vc)
1208 {
1209 int retval = -EINVAL;
1210 int i;
1211 struct vcontrol *lvc;
1212
1213 i = find_vctrl(vc->id);
1214 if (i < 0)
1215 return -EINVAL;
1216 lvc = &imx046sensor_video_control[i];
1217
1218 switch (vc->id) {
1219 case V4L2_CID_EXPOSURE:
1220 retval = imx046sensor_set_exposure_time(vc->value, s, lvc);
1221 break;
1222 case V4L2_CID_GAIN:
1223 retval = imx046sensor_set_gain(vc->value, s, lvc);
1224 break;
1225 case V4L2_CID_TEST_PATTERN:
1226 retval = imx046_configure_test_pattern(vc->value, s, lvc);
1227 break;
1228 }
1229
1230 return retval;
1231 }
1232
1233 /**
1234 * ioctl_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl
1235 * @s: pointer to standard V4L2 device structure
1236 * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
1237 *
1238 * Implement the VIDIOC_ENUM_FMT ioctl for the CAPTURE buffer type.
1239 */
1240 static int ioctl_enum_fmt_cap(struct v4l2_int_device *s,
1241 struct v4l2_fmtdesc *fmt)
1242 {
1243 int index = fmt->index;
1244 enum v4l2_buf_type type = fmt->type;
1245
1246 memset(fmt, 0, sizeof(*fmt));
1247 fmt->index = index;
1248 fmt->type = type;
1249
1250 switch (fmt->type) {
1251 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1252 if (index >= NUM_CAPTURE_FORMATS)
1253 return -EINVAL;
1254 break;
1255 default:
1256 return -EINVAL;
1257 }
1258
1259 fmt->flags = imx046_formats[index].flags;
1260 strlcpy(fmt->description, imx046_formats[index].description,
1261 sizeof(fmt->description));
1262 fmt->pixelformat = imx046_formats[index].pixelformat;
1263
1264 return 0;
1265 }
1266
1267 /**
1268 * ioctl_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl
1269 * @s: pointer to standard V4L2 device structure
1270 * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
1271 *
1272 * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
1273 * ioctl is used to negotiate the image capture size and pixel format
1274 * without actually making it take effect.
1275 */
1276 static int ioctl_try_fmt_cap(struct v4l2_int_device *s,
1277 struct v4l2_format *f)
1278 {
1279 enum imx046_image_size isize;
1280 int ifmt;
1281 struct v4l2_pix_format *pix = &f->fmt.pix;
1282 struct imx046_sensor *sensor = s->priv;
1283 struct v4l2_pix_format *pix2 = &sensor->pix;
1284
1285 isize = imx046_find_size(pix->width, pix->height);
1286
1287 pix->width = imx046_sizes[isize].width;
1288 pix->height = imx046_sizes[isize].height;
1289 for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) {
1290 if (pix->pixelformat == imx046_formats[ifmt].pixelformat)
1291 break;
1292 }
1293 if (ifmt == NUM_CAPTURE_FORMATS)
1294 ifmt = 0;
1295 pix->pixelformat = imx046_formats[ifmt].pixelformat;
1296 pix->field = V4L2_FIELD_NONE;
1297 pix->bytesperline = pix->width * 2;
1298 pix->sizeimage = pix->bytesperline * pix->height;
1299 pix->priv = 0;
1300 pix->colorspace = V4L2_COLORSPACE_SRGB;
1301 *pix2 = *pix;
1302 return 0;
1303 }
1304
1305 /**
1306 * ioctl_s_fmt_cap - V4L2 sensor interface handler for VIDIOC_S_FMT ioctl
1307 * @s: pointer to standard V4L2 device structure
1308 * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
1309 *
1310 * If the requested format is supported, configures the HW to use that
1311 * format, returns error code if format not supported or HW can't be
1312 * correctly configured.
1313 */
1314 static int ioctl_s_fmt_cap(struct v4l2_int_device *s,
1315 struct v4l2_format *f)
1316 {
1317 struct imx046_sensor *sensor = s->priv;
1318 struct v4l2_pix_format *pix = &f->fmt.pix;
1319 int rval;
1320
1321 rval = ioctl_try_fmt_cap(s, f);
1322 if (rval)
1323 return rval;
1324 else
1325 sensor->pix = *pix;
1326
1327
1328 return rval;
1329 }
1330
1331 /**
1332 * ioctl_g_fmt_cap - V4L2 sensor interface handler for ioctl_g_fmt_cap
1333 * @s: pointer to standard V4L2 device structure
1334 * @f: pointer to standard V4L2 v4l2_format structure
1335 *
1336 * Returns the sensor's current pixel format in the v4l2_format
1337 * parameter.
1338 */
1339 static int ioctl_g_fmt_cap(struct v4l2_int_device *s,
1340 struct v4l2_format *f)
1341 {
1342 struct imx046_sensor *sensor = s->priv;
1343 f->fmt.pix = sensor->pix;
1344
1345 return 0;
1346 }
1347
1348 /**
1349 * ioctl_g_pixclk - V4L2 sensor interface handler for ioctl_g_pixclk
1350 * @s: pointer to standard V4L2 device structure
1351 * @pixclk: pointer to unsigned 32 var to store pixelclk in HZ
1352 *
1353 * Returns the sensor's current pixel clock in HZ
1354 */
1355 static int ioctl_priv_g_pixclk(struct v4l2_int_device *s, u32 *pixclk)
1356 {
1357 *pixclk = xclk_current;
1358
1359 return 0;
1360 }
1361
1362 /**
1363 * ioctl_g_activesize - V4L2 sensor interface handler for ioctl_g_activesize
1364 * @s: pointer to standard V4L2 device structure
1365 * @pix: pointer to standard V4L2 v4l2_pix_format structure
1366 *
1367 * Returns the sensor's current active image basesize.
1368 */
1369 static int ioctl_priv_g_activesize(struct v4l2_int_device *s,
1370 struct v4l2_pix_format *pix)
1371 {
1372 struct imx046_sensor *sensor = s->priv;
1373
1374 pix->width = sensor->pix.width;
1375 pix->height = sensor->pix.height;
1376
1377 return 0;
1378 }
1379
1380 /**
1381 * ioctl_g_fullsize - V4L2 sensor interface handler for ioctl_g_fullsize
1382 * @s: pointer to standard V4L2 device structure
1383 * @pix: pointer to standard V4L2 v4l2_pix_format structure
1384 *
1385 * Returns the sensor's biggest image basesize.
1386 */
1387 static int ioctl_priv_g_fullsize(struct v4l2_int_device *s,
1388 struct v4l2_pix_format *pix)
1389 {
1390 pix->width = imx046_sizes[NUM_IMAGE_SIZES - 1].width;
1391 pix->height = imx046_sizes[NUM_IMAGE_SIZES - 1].height;
1392
1393 return 0;
1394 }
1395
1396 /**
1397 * ioctl_g_parm - V4L2 sensor interface handler for VIDIOC_G_PARM ioctl
1398 * @s: pointer to standard V4L2 device structure
1399 * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
1400 *
1401 * Returns the sensor's video CAPTURE parameters.
1402 */
1403 static int ioctl_g_parm(struct v4l2_int_device *s,
1404 struct v4l2_streamparm *a)
1405 {
1406 struct imx046_sensor *sensor = s->priv;
1407 struct v4l2_captureparm *cparm = &a->parm.capture;
1408
1409 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1410 return -EINVAL;
1411
1412 memset(a, 0, sizeof(*a));
1413 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1414
1415 cparm->capability = V4L2_CAP_TIMEPERFRAME;
1416 cparm->timeperframe = sensor->timeperframe;
1417
1418 return 0;
1419 }
1420
1421 /**
1422 * ioctl_s_parm - V4L2 sensor interface handler for VIDIOC_S_PARM ioctl
1423 * @s: pointer to standard V4L2 device structure
1424 * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
1425 *
1426 * Configures the sensor to use the input parameters, if possible. If
1427 * not possible, reverts to the old parameters and returns the
1428 * appropriate error code.
1429 */
1430 static int ioctl_s_parm(struct v4l2_int_device *s,
1431 struct v4l2_streamparm *a)
1432 {
1433 struct imx046_sensor *sensor = s->priv;
1434 struct v4l2_fract *timeperframe = &a->parm.capture.timeperframe;
1435
1436 sensor->timeperframe = *timeperframe;
1437 imx046sensor_calc_xclk();
1438 *timeperframe = sensor->timeperframe;
1439
1440 return 0;
1441 }
1442
1443
1444 /**
1445 * ioctl_g_priv - V4L2 sensor interface handler for vidioc_int_g_priv_num
1446 * @s: pointer to standard V4L2 device structure
1447 * @p: void pointer to hold sensor's private data address
1448 *
1449 * Returns device's (sensor's) private data area address in p parameter
1450 */
1451 static int ioctl_g_priv(struct v4l2_int_device *s, void *p)
1452 {
1453 struct imx046_sensor *sensor = s->priv;
1454
1455 return sensor->pdata->priv_data_set(s, p);
1456
1457 }
1458
1459 /**
1460 * ioctl_s_power - V4L2 sensor interface handler for vidioc_int_s_power_num
1461 * @s: pointer to standard V4L2 device structure
1462 * @on: power state to which device is to be set
1463 *
1464 * Sets devices power state to requrested state, if possible.
1465 */
1466 static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on)
1467 {
1468 struct imx046_sensor *sensor = s->priv;
1469 struct i2c_client *client = sensor->i2c_client;
1470 struct vcontrol *lvc;
1471 int rval, i;
1472
1473 if ((on == V4L2_POWER_STANDBY) && (sensor->state == SENSOR_DETECTED)) {
1474 /* imx046_write_regs(c, stream_off_list,
1475 I2C_STREAM_OFF_LIST_SIZE); */
1476 }
1477
1478 if (on != V4L2_POWER_ON)
1479 sensor->pdata->set_xclk(s, 0);
1480 else
1481 sensor->pdata->set_xclk(s, xclk_current);
1482
1483 rval = sensor->pdata->power_set(s, on);
1484 if (rval < 0) {
1485 v4l_err(client, "Unable to set the power state: "
1486 IMX046_DRIVER_NAME " sensor\n");
1487 sensor->pdata->set_xclk(s, 0);
1488 return rval;
1489 }
1490
1491 if ((current_power_state == V4L2_POWER_STANDBY) &&
1492 (on == V4L2_POWER_ON) &&
1493 (sensor->state == SENSOR_DETECTED)) {
1494 sensor->resuming = true;
1495 imx046_configure(s);
1496 }
1497
1498 if ((on == V4L2_POWER_ON) && (sensor->state == SENSOR_NOT_DETECTED)) {
1499 rval = imx046_detect(client);
1500 if (rval < 0) {
1501 v4l_err(client, "Unable to detect "
1502 IMX046_DRIVER_NAME " sensor\n");
1503 sensor->state = SENSOR_NOT_DETECTED;
1504 return rval;
1505 }
1506 sensor->state = SENSOR_DETECTED;
1507 sensor->ver = rval;
1508 v4l_info(client, IMX046_DRIVER_NAME
1509 " chip version 0x%02x detected\n", sensor->ver);
1510 }
1511
1512 if (on == V4L2_POWER_OFF) {
1513 /* Reset defaults for controls */
1514 i = find_vctrl(V4L2_CID_GAIN);
1515 if (i >= 0) {
1516 lvc = &imx046sensor_video_control[i];
1517 lvc->current_value = IMX046_EV_DEF_GAIN;
1518 }
1519 i = find_vctrl(V4L2_CID_EXPOSURE);
1520 if (i >= 0) {
1521 lvc = &imx046sensor_video_control[i];
1522 lvc->current_value = IMX046_DEF_EXPOSURE;
1523 }
1524 i = find_vctrl(V4L2_CID_TEST_PATTERN);
1525 if (i >= 0) {
1526 lvc = &imx046sensor_video_control[i];
1527 lvc->current_value = IMX046_MIN_TEST_PATT_MODE;
1528 }
1529 }
1530
1531 sensor->resuming = false;
1532 current_power_state = on;
1533 return 0;
1534 }
1535
1536 /**
1537 * ioctl_init - V4L2 sensor interface handler for VIDIOC_INT_INIT
1538 * @s: pointer to standard V4L2 device structure
1539 *
1540 * Initialize the sensor device (call imx046_configure())
1541 */
1542 static int ioctl_init(struct v4l2_int_device *s)
1543 {
1544 return 0;
1545 }
1546
1547 /**
1548 * ioctl_dev_exit - V4L2 sensor interface handler for vidioc_int_dev_exit_num
1549 * @s: pointer to standard V4L2 device structure
1550 *
1551 * Delinitialise the dev. at slave detach. The complement of ioctl_dev_init.
1552 */
1553 static int ioctl_dev_exit(struct v4l2_int_device *s)
1554 {
1555 return 0;
1556 }
1557
1558 /**
1559 * ioctl_dev_init - V4L2 sensor interface handler for vidioc_int_dev_init_num
1560 * @s: pointer to standard V4L2 device structure
1561 *
1562 * Initialise the device when slave attaches to the master. Returns 0 if
1563 * imx046 device could be found, otherwise returns appropriate error.
1564 */
1565 static int ioctl_dev_init(struct v4l2_int_device *s)
1566 {
1567 struct imx046_sensor *sensor = s->priv;
1568 struct i2c_client *client = sensor->i2c_client;
1569 int err;
1570
1571 err = imx046_detect(client);
1572 if (err < 0) {
1573 v4l_err(client, "Unable to detect " IMX046_DRIVER_NAME
1574 " sensor\n");
1575 return err;
1576 }
1577
1578 sensor->ver = err;
1579 v4l_info(client, IMX046_DRIVER_NAME " chip version "
1580 "0x%02x detected\n", sensor->ver);
1581
1582 return 0;
1583 }
1584
1585 /**
1586 * ioctl_enum_framesizes - V4L2 sensor if handler for vidioc_int_enum_framesizes
1587 * @s: pointer to standard V4L2 device structure
1588 * @frms: pointer to standard V4L2 framesizes enumeration structure
1589 *
1590 * Returns possible framesizes depending on choosen pixel format
1591 **/
1592 static int ioctl_enum_framesizes(struct v4l2_int_device *s,
1593 struct v4l2_frmsizeenum *frms)
1594 {
1595 int ifmt;
1596
1597 for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) {
1598 if (frms->pixel_format == imx046_formats[ifmt].pixelformat)
1599 break;
1600 }
1601 /* Is requested pixelformat not found on sensor? */
1602 if (ifmt == NUM_CAPTURE_FORMATS)
1603 return -EINVAL;
1604
1605 /* Check that the index we are being asked for is not
1606 out of bounds. */
1607 if (frms->index >= ARRAY_SIZE(imx046_sizes))
1608 return -EINVAL;
1609
1610 frms->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1611 frms->discrete.width = imx046_sizes[frms->index].width;
1612 frms->discrete.height = imx046_sizes[frms->index].height;
1613
1614 return 0;
1615 }
1616
1617 const struct v4l2_fract imx046_frameintervals[] = {
1618 { .numerator = 3, .denominator = 30 },
1619 { .numerator = 1, .denominator = 30 },
1620 };
1621
1622 static int ioctl_enum_frameintervals(struct v4l2_int_device *s,
1623 struct v4l2_frmivalenum *frmi)
1624 {
1625 int ifmt;
1626
1627 /* Check that the requested format is one we support */
1628 for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) {
1629 if (frmi->pixel_format == imx046_formats[ifmt].pixelformat)
1630 break;
1631 }
1632
1633 if (ifmt == NUM_CAPTURE_FORMATS)
1634 return -EINVAL;
1635
1636 /* Check that the index we are being asked for is not
1637 out of bounds. */
1638 if (frmi->index >= ARRAY_SIZE(imx046_frameintervals))
1639 return -EINVAL;
1640
1641 /* Make sure that the 8MP size reports a max of 10fps */
1642 if (frmi->width == 3280 && frmi->height == 2464) {
1643 if (frmi->index != 0)
1644 return -EINVAL;
1645 }
1646
1647 frmi->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1648 frmi->discrete.numerator =
1649 imx046_frameintervals[frmi->index].numerator;
1650 frmi->discrete.denominator =
1651 imx046_frameintervals[frmi->index].denominator;
1652
1653 return 0;
1654 }
1655
1656 static struct v4l2_int_ioctl_desc imx046_ioctl_desc[] = {
1657 { .num = vidioc_int_enum_framesizes_num,
1658 .func = (v4l2_int_ioctl_func *)ioctl_enum_framesizes},
1659 { .num = vidioc_int_enum_frameintervals_num,
1660 .func = (v4l2_int_ioctl_func *)ioctl_enum_frameintervals},
1661 { .num = vidioc_int_dev_init_num,
1662 .func = (v4l2_int_ioctl_func *)ioctl_dev_init},
1663 { .num = vidioc_int_dev_exit_num,
1664 .func = (v4l2_int_ioctl_func *)ioctl_dev_exit},
1665 { .num = vidioc_int_s_power_num,
1666 .func = (v4l2_int_ioctl_func *)ioctl_s_power },
1667 { .num = vidioc_int_g_priv_num,
1668 .func = (v4l2_int_ioctl_func *)ioctl_g_priv },
1669 { .num = vidioc_int_init_num,
1670 .func = (v4l2_int_ioctl_func *)ioctl_init },
1671 { .num = vidioc_int_enum_fmt_cap_num,
1672 .func = (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap },
1673 { .num = vidioc_int_try_fmt_cap_num,
1674 .func = (v4l2_int_ioctl_func *)ioctl_try_fmt_cap },
1675 { .num = vidioc_int_g_fmt_cap_num,
1676 .func = (v4l2_int_ioctl_func *)ioctl_g_fmt_cap },
1677 { .num = vidioc_int_s_fmt_cap_num,
1678 .func = (v4l2_int_ioctl_func *)ioctl_s_fmt_cap },
1679 { .num = vidioc_int_g_parm_num,
1680 .func = (v4l2_int_ioctl_func *)ioctl_g_parm },
1681 { .num = vidioc_int_s_parm_num,
1682 .func = (v4l2_int_ioctl_func *)ioctl_s_parm },
1683 { .num = vidioc_int_queryctrl_num,
1684 .func = (v4l2_int_ioctl_func *)ioctl_queryctrl },
1685 { .num = vidioc_int_g_ctrl_num,
1686 .func = (v4l2_int_ioctl_func *)ioctl_g_ctrl },
1687 { .num = vidioc_int_s_ctrl_num,
1688 .func = (v4l2_int_ioctl_func *)ioctl_s_ctrl },
1689 { .num = vidioc_int_priv_g_pixclk_num,
1690 .func = (v4l2_int_ioctl_func *)ioctl_priv_g_pixclk },
1691 { .num = vidioc_int_priv_g_activesize_num,
1692 .func = (v4l2_int_ioctl_func *)ioctl_priv_g_activesize },
1693 { .num = vidioc_int_priv_g_fullsize_num,
1694 .func = (v4l2_int_ioctl_func *)ioctl_priv_g_fullsize },
1695 };
1696
1697 static struct v4l2_int_slave imx046_slave = {
1698 .ioctls = imx046_ioctl_desc,
1699 .num_ioctls = ARRAY_SIZE(imx046_ioctl_desc),
1700 };
1701
1702 static struct v4l2_int_device imx046_int_device = {
1703 .module = THIS_MODULE,
1704 .name = IMX046_DRIVER_NAME,
1705 .priv = &imx046,
1706 .type = v4l2_int_type_slave,
1707 .u = {
1708 .slave = &imx046_slave,
1709 },
1710 };
1711
1712 /**
1713 * imx046_probe - sensor driver i2c probe handler
1714 * @client: i2c driver client device structure
1715 *
1716 * Register sensor as an i2c client device and V4L2
1717 * device.
1718 */
1719 static int __devinit imx046_probe(struct i2c_client *client,
1720 const struct i2c_device_id *id)
1721 {
1722 struct imx046_sensor *sensor = &imx046;
1723 int err;
1724
1725 if (i2c_get_clientdata(client))
1726 return -EBUSY;
1727
1728 sensor->pdata = client->dev.platform_data;
1729
1730 if (!sensor->pdata) {
1731 v4l_err(client, "no platform data?\n");
1732 return -ENODEV;
1733 }
1734
1735 sensor->v4l2_int_device = &imx046_int_device;
1736 sensor->i2c_client = client;
1737
1738 i2c_set_clientdata(client, sensor);
1739
1740 /* Make the default capture format QCIF V4L2_PIX_FMT_SRGGB10 */
1741 sensor->pix.width = IMX046_IMAGE_WIDTH_MAX;
1742 sensor->pix.height = IMX046_IMAGE_HEIGHT_MAX;
1743 sensor->pix.pixelformat = V4L2_PIX_FMT_SRGGB10;
1744
1745 err = v4l2_int_device_register(sensor->v4l2_int_device);
1746 if (err)
1747 i2c_set_clientdata(client, NULL);
1748
1749 return 0;
1750 }
1751
1752 /**
1753 * imx046_remove - sensor driver i2c remove handler
1754 * @client: i2c driver client device structure
1755 *
1756 * Unregister sensor as an i2c client device and V4L2
1757 * device. Complement of imx046_probe().
1758 */
1759 static int __exit
1760 imx046_remove(struct i2c_client *client)
1761 {
1762 struct imx046_sensor *sensor = i2c_get_clientdata(client);
1763
1764 if (!client->adapter)
1765 return -ENODEV; /* our client isn't attached */
1766
1767 v4l2_int_device_unregister(sensor->v4l2_int_device);
1768 i2c_set_clientdata(client, NULL);
1769
1770 return 0;
1771 }
1772
1773 static const struct i2c_device_id imx046_id[] = {
1774 { IMX046_DRIVER_NAME, 0 },
1775 { },
1776 };
1777 MODULE_DEVICE_TABLE(i2c, imx046_id);
1778
1779 static struct i2c_driver imx046sensor_i2c_driver = {
1780 .driver = {
1781 .name = IMX046_DRIVER_NAME,
1782 .owner = THIS_MODULE,
1783 },
1784 .probe = imx046_probe,
1785 .remove = __exit_p(imx046_remove),
1786 .id_table = imx046_id,
1787 };
1788
1789 static struct imx046_sensor imx046 = {
1790 .timeperframe = {
1791 .numerator = 1,
1792 .denominator = 30,
1793 },
1794 .state = SENSOR_NOT_DETECTED,
1795 };
1796
1797 /**
1798 * imx046sensor_init - sensor driver module_init handler
1799 *
1800 * Registers driver as an i2c client driver. Returns 0 on success,
1801 * error code otherwise.
1802 */
1803 static int __init imx046sensor_init(void)
1804 {
1805 int err;
1806
1807 err = i2c_add_driver(&imx046sensor_i2c_driver);
1808 if (err) {
1809 printk(KERN_ERR "Failed to register" IMX046_DRIVER_NAME ".\n");
1810 return err;
1811 }
1812 return 0;
1813 }
1814 late_initcall(imx046sensor_init);
1815
1816 /**
1817 * imx046sensor_cleanup - sensor driver module_exit handler
1818 *
1819 * Unregisters/deletes driver as an i2c client driver.
1820 * Complement of imx046sensor_init.
1821 */
1822 static void __exit imx046sensor_cleanup(void)
1823 {
1824 i2c_del_driver(&imx046sensor_i2c_driver);
1825 }
1826 module_exit(imx046sensor_cleanup);
1827
1828 MODULE_LICENSE("GPL");
1829 MODULE_DESCRIPTION("imx046 camera sensor driver");
Linux for Ginger Game Console