]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/media/atomisp/i2c/atomisp-mt9m114.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


706eea52e36fa077d60d0d6f73cd0ddd20e9d5e7
[mirror_ubuntu-bionic-kernel.git] / drivers / staging / media / atomisp / i2c / atomisp-mt9m114.c
1 /*
2 * Support for mt9m114 Camera Sensor.
3 *
4 * Copyright (c) 2010 Intel Corporation. All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 *
20 */
21
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
25 #include <linux/mm.h>
26 #include <linux/string.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/kmod.h>
30 #include <linux/device.h>
31 #include <linux/fs.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34 #include <linux/i2c.h>
35 #include <linux/acpi.h>
36 #include "../include/linux/atomisp_gmin_platform.h"
37 #include <media/v4l2-device.h>
38
39 #include "mt9m114.h"
40
41 #define to_mt9m114_sensor(sd) container_of(sd, struct mt9m114_device, sd)
42
43 /*
44 * TODO: use debug parameter to actually define when debug messages should
45 * be printed.
46 */
47 static int debug;
48 static int aaalock;
49 module_param(debug, int, 0644);
50 MODULE_PARM_DESC(debug, "Debug level (0-1)");
51
52 static int mt9m114_t_vflip(struct v4l2_subdev *sd, int value);
53 static int mt9m114_t_hflip(struct v4l2_subdev *sd, int value);
54 static int mt9m114_wait_state(struct i2c_client *client, int timeout);
55
56 static int
57 mt9m114_read_reg(struct i2c_client *client, u16 data_length, u32 reg, u32 *val)
58 {
59 int err;
60 struct i2c_msg msg[2];
61 unsigned char data[4];
62
63 if (!client->adapter) {
64 v4l2_err(client, "%s error, no client->adapter\n", __func__);
65 return -ENODEV;
66 }
67
68 if (data_length != MISENSOR_8BIT && data_length != MISENSOR_16BIT
69 && data_length != MISENSOR_32BIT) {
70 v4l2_err(client, "%s error, invalid data length\n", __func__);
71 return -EINVAL;
72 }
73
74 msg[0].addr = client->addr;
75 msg[0].flags = 0;
76 msg[0].len = MSG_LEN_OFFSET;
77 msg[0].buf = data;
78
79 /* high byte goes out first */
80 data[0] = (u16) (reg >> 8);
81 data[1] = (u16) (reg & 0xff);
82
83 msg[1].addr = client->addr;
84 msg[1].len = data_length;
85 msg[1].flags = I2C_M_RD;
86 msg[1].buf = data;
87
88 err = i2c_transfer(client->adapter, msg, 2);
89
90 if (err >= 0) {
91 *val = 0;
92 /* high byte comes first */
93 if (data_length == MISENSOR_8BIT)
94 *val = data[0];
95 else if (data_length == MISENSOR_16BIT)
96 *val = data[1] + (data[0] << 8);
97 else
98 *val = data[3] + (data[2] << 8) +
99 (data[1] << 16) + (data[0] << 24);
100
101 return 0;
102 }
103
104 dev_err(&client->dev, "read from offset 0x%x error %d", reg, err);
105 return err;
106 }
107
108 static int
109 mt9m114_write_reg(struct i2c_client *client, u16 data_length, u16 reg, u32 val)
110 {
111 int num_msg;
112 struct i2c_msg msg;
113 unsigned char data[6] = {0};
114 u16 *wreg;
115 int retry = 0;
116
117 if (!client->adapter) {
118 v4l2_err(client, "%s error, no client->adapter\n", __func__);
119 return -ENODEV;
120 }
121
122 if (data_length != MISENSOR_8BIT && data_length != MISENSOR_16BIT
123 && data_length != MISENSOR_32BIT) {
124 v4l2_err(client, "%s error, invalid data_length\n", __func__);
125 return -EINVAL;
126 }
127
128 memset(&msg, 0, sizeof(msg));
129
130 again:
131 msg.addr = client->addr;
132 msg.flags = 0;
133 msg.len = 2 + data_length;
134 msg.buf = data;
135
136 /* high byte goes out first */
137 wreg = (u16 *)data;
138 *wreg = cpu_to_be16(reg);
139
140 if (data_length == MISENSOR_8BIT) {
141 data[2] = (u8)(val);
142 } else if (data_length == MISENSOR_16BIT) {
143 u16 *wdata = (u16 *)&data[2];
144 *wdata = be16_to_cpu((u16)val);
145 } else {
146 /* MISENSOR_32BIT */
147 u32 *wdata = (u32 *)&data[2];
148 *wdata = be32_to_cpu(val);
149 }
150
151 num_msg = i2c_transfer(client->adapter, &msg, 1);
152
153 /*
154 * HACK: Need some delay here for Rev 2 sensors otherwise some
155 * registers do not seem to load correctly.
156 */
157 mdelay(1);
158
159 if (num_msg >= 0)
160 return 0;
161
162 dev_err(&client->dev, "write error: wrote 0x%x to offset 0x%x error %d",
163 val, reg, num_msg);
164 if (retry <= I2C_RETRY_COUNT) {
165 dev_dbg(&client->dev, "retrying... %d", retry);
166 retry++;
167 msleep(20);
168 goto again;
169 }
170
171 return num_msg;
172 }
173
174 /**
175 * misensor_rmw_reg - Read/Modify/Write a value to a register in the sensor
176 * device
177 * @client: i2c driver client structure
178 * @data_length: 8/16/32-bits length
179 * @reg: register address
180 * @mask: masked out bits
181 * @set: bits set
182 *
183 * Read/modify/write a value to a register in the sensor device.
184 * Returns zero if successful, or non-zero otherwise.
185 */
186 static int
187 misensor_rmw_reg(struct i2c_client *client, u16 data_length, u16 reg,
188 u32 mask, u32 set)
189 {
190 int err;
191 u32 val;
192
193 /* Exit when no mask */
194 if (mask == 0)
195 return 0;
196
197 /* @mask must not exceed data length */
198 switch (data_length) {
199 case MISENSOR_8BIT:
200 if (mask & ~0xff)
201 return -EINVAL;
202 break;
203 case MISENSOR_16BIT:
204 if (mask & ~0xffff)
205 return -EINVAL;
206 break;
207 case MISENSOR_32BIT:
208 break;
209 default:
210 /* Wrong @data_length */
211 return -EINVAL;
212 }
213
214 err = mt9m114_read_reg(client, data_length, reg, &val);
215 if (err) {
216 v4l2_err(client, "misensor_rmw_reg error exit, read failed\n");
217 return -EINVAL;
218 }
219
220 val &= ~mask;
221
222 /*
223 * Perform the OR function if the @set exists.
224 * Shift @set value to target bit location. @set should set only
225 * bits included in @mask.
226 *
227 * REVISIT: This function expects @set to be non-shifted. Its shift
228 * value is then defined to be equal to mask's LSB position.
229 * How about to inform values in their right offset position and avoid
230 * this unneeded shift operation?
231 */
232 set <<= ffs(mask) - 1;
233 val |= set & mask;
234
235 err = mt9m114_write_reg(client, data_length, reg, val);
236 if (err) {
237 v4l2_err(client, "misensor_rmw_reg error exit, write failed\n");
238 return -EINVAL;
239 }
240
241 return 0;
242 }
243
244
245 static int __mt9m114_flush_reg_array(struct i2c_client *client,
246 struct mt9m114_write_ctrl *ctrl)
247 {
248 struct i2c_msg msg;
249 const int num_msg = 1;
250 int ret;
251 int retry = 0;
252
253 if (ctrl->index == 0)
254 return 0;
255
256 again:
257 msg.addr = client->addr;
258 msg.flags = 0;
259 msg.len = 2 + ctrl->index;
260 ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
261 msg.buf = (u8 *)&ctrl->buffer;
262
263 ret = i2c_transfer(client->adapter, &msg, num_msg);
264 if (ret != num_msg) {
265 if (++retry <= I2C_RETRY_COUNT) {
266 dev_dbg(&client->dev, "retrying... %d\n", retry);
267 msleep(20);
268 goto again;
269 }
270 dev_err(&client->dev, "%s: i2c transfer error\n", __func__);
271 return -EIO;
272 }
273
274 ctrl->index = 0;
275
276 /*
277 * REVISIT: Previously we had a delay after writing data to sensor.
278 * But it was removed as our tests have shown it is not necessary
279 * anymore.
280 */
281
282 return 0;
283 }
284
285 static int __mt9m114_buf_reg_array(struct i2c_client *client,
286 struct mt9m114_write_ctrl *ctrl,
287 const struct misensor_reg *next)
288 {
289 u16 *data16;
290 u32 *data32;
291 int err;
292
293 /* Insufficient buffer? Let's flush and get more free space. */
294 if (ctrl->index + next->length >= MT9M114_MAX_WRITE_BUF_SIZE) {
295 err = __mt9m114_flush_reg_array(client, ctrl);
296 if (err)
297 return err;
298 }
299
300 switch (next->length) {
301 case MISENSOR_8BIT:
302 ctrl->buffer.data[ctrl->index] = (u8)next->val;
303 break;
304 case MISENSOR_16BIT:
305 data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
306 *data16 = cpu_to_be16((u16)next->val);
307 break;
308 case MISENSOR_32BIT:
309 data32 = (u32 *)&ctrl->buffer.data[ctrl->index];
310 *data32 = cpu_to_be32(next->val);
311 break;
312 default:
313 return -EINVAL;
314 }
315
316 /* When first item is added, we need to store its starting address */
317 if (ctrl->index == 0)
318 ctrl->buffer.addr = next->reg;
319
320 ctrl->index += next->length;
321
322 return 0;
323 }
324
325 static int
326 __mt9m114_write_reg_is_consecutive(struct i2c_client *client,
327 struct mt9m114_write_ctrl *ctrl,
328 const struct misensor_reg *next)
329 {
330 if (ctrl->index == 0)
331 return 1;
332
333 return ctrl->buffer.addr + ctrl->index == next->reg;
334 }
335
336 /*
337 * mt9m114_write_reg_array - Initializes a list of mt9m114 registers
338 * @client: i2c driver client structure
339 * @reglist: list of registers to be written
340 * @poll: completion polling requirement
341 * This function initializes a list of registers. When consecutive addresses
342 * are found in a row on the list, this function creates a buffer and sends
343 * consecutive data in a single i2c_transfer().
344 *
345 * __mt9m114_flush_reg_array, __mt9m114_buf_reg_array() and
346 * __mt9m114_write_reg_is_consecutive() are internal functions to
347 * mt9m114_write_reg_array() and should be not used anywhere else.
348 *
349 */
350 static int mt9m114_write_reg_array(struct i2c_client *client,
351 const struct misensor_reg *reglist,
352 int poll)
353 {
354 const struct misensor_reg *next = reglist;
355 struct mt9m114_write_ctrl ctrl;
356 int err;
357
358 if (poll == PRE_POLLING) {
359 err = mt9m114_wait_state(client, MT9M114_WAIT_STAT_TIMEOUT);
360 if (err)
361 return err;
362 }
363
364 ctrl.index = 0;
365 for (; next->length != MISENSOR_TOK_TERM; next++) {
366 switch (next->length & MISENSOR_TOK_MASK) {
367 case MISENSOR_TOK_DELAY:
368 err = __mt9m114_flush_reg_array(client, &ctrl);
369 if (err)
370 return err;
371 msleep(next->val);
372 break;
373 case MISENSOR_TOK_RMW:
374 err = __mt9m114_flush_reg_array(client, &ctrl);
375 err |= misensor_rmw_reg(client,
376 next->length &
377 ~MISENSOR_TOK_RMW,
378 next->reg, next->val,
379 next->val2);
380 if (err) {
381 dev_err(&client->dev, "%s read err. aborted\n",
382 __func__);
383 return -EINVAL;
384 }
385 break;
386 default:
387 /*
388 * If next address is not consecutive, data needs to be
389 * flushed before proceed.
390 */
391 if (!__mt9m114_write_reg_is_consecutive(client, &ctrl,
392 next)) {
393 err = __mt9m114_flush_reg_array(client, &ctrl);
394 if (err)
395 return err;
396 }
397 err = __mt9m114_buf_reg_array(client, &ctrl, next);
398 if (err) {
399 v4l2_err(client, "%s: write error, aborted\n",
400 __func__);
401 return err;
402 }
403 break;
404 }
405 }
406
407 err = __mt9m114_flush_reg_array(client, &ctrl);
408 if (err)
409 return err;
410
411 if (poll == POST_POLLING)
412 return mt9m114_wait_state(client, MT9M114_WAIT_STAT_TIMEOUT);
413
414 return 0;
415 }
416
417 static int mt9m114_wait_state(struct i2c_client *client, int timeout)
418 {
419 int ret;
420 unsigned int val;
421
422 while (timeout-- > 0) {
423 ret = mt9m114_read_reg(client, MISENSOR_16BIT, 0x0080, &val);
424 if (ret)
425 return ret;
426 if ((val & 0x2) == 0)
427 return 0;
428 msleep(20);
429 }
430
431 return -EINVAL;
432
433 }
434
435 static int mt9m114_set_suspend(struct v4l2_subdev *sd)
436 {
437 struct i2c_client *client = v4l2_get_subdevdata(sd);
438 return mt9m114_write_reg_array(client,
439 mt9m114_standby_reg, POST_POLLING);
440 }
441
442 static int mt9m114_init_common(struct v4l2_subdev *sd)
443 {
444 struct i2c_client *client = v4l2_get_subdevdata(sd);
445
446 return mt9m114_write_reg_array(client, mt9m114_common, PRE_POLLING);
447 }
448
449 static int power_ctrl(struct v4l2_subdev *sd, bool flag)
450 {
451 int ret;
452 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
453
454 if (!dev || !dev->platform_data)
455 return -ENODEV;
456
457 if (flag) {
458 ret = dev->platform_data->v2p8_ctrl(sd, 1);
459 if (ret == 0) {
460 ret = dev->platform_data->v1p8_ctrl(sd, 1);
461 if (ret)
462 ret = dev->platform_data->v2p8_ctrl(sd, 0);
463 }
464 } else {
465 ret = dev->platform_data->v2p8_ctrl(sd, 0);
466 ret = dev->platform_data->v1p8_ctrl(sd, 0);
467 }
468 return ret;
469 }
470
471 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag)
472 {
473 int ret;
474 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
475
476 if (!dev || !dev->platform_data)
477 return -ENODEV;
478
479 /* Note: current modules wire only one GPIO signal (RESET#),
480 * but the schematic wires up two to the connector. BIOS
481 * versions have been unfortunately inconsistent with which
482 * ACPI index RESET# is on, so hit both */
483
484 if (flag) {
485 ret = dev->platform_data->gpio0_ctrl(sd, 0);
486 ret = dev->platform_data->gpio1_ctrl(sd, 0);
487 msleep(60);
488 ret |= dev->platform_data->gpio0_ctrl(sd, 1);
489 ret |= dev->platform_data->gpio1_ctrl(sd, 1);
490 } else {
491 ret = dev->platform_data->gpio0_ctrl(sd, 0);
492 ret = dev->platform_data->gpio1_ctrl(sd, 0);
493 }
494 return ret;
495 }
496
497 static int power_up(struct v4l2_subdev *sd)
498 {
499 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
500 struct i2c_client *client = v4l2_get_subdevdata(sd);
501 int ret;
502
503 if (NULL == dev->platform_data) {
504 dev_err(&client->dev, "no camera_sensor_platform_data");
505 return -ENODEV;
506 }
507
508 /* power control */
509 ret = power_ctrl(sd, 1);
510 if (ret)
511 goto fail_power;
512
513 /* flis clock control */
514 ret = dev->platform_data->flisclk_ctrl(sd, 1);
515 if (ret)
516 goto fail_clk;
517
518 /* gpio ctrl */
519 ret = gpio_ctrl(sd, 1);
520 if (ret)
521 dev_err(&client->dev, "gpio failed 1\n");
522 /*
523 * according to DS, 44ms is needed between power up and first i2c
524 * commend
525 */
526 msleep(50);
527
528 return 0;
529
530 fail_clk:
531 dev->platform_data->flisclk_ctrl(sd, 0);
532 fail_power:
533 power_ctrl(sd, 0);
534 dev_err(&client->dev, "sensor power-up failed\n");
535
536 return ret;
537 }
538
539 static int power_down(struct v4l2_subdev *sd)
540 {
541 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
542 struct i2c_client *client = v4l2_get_subdevdata(sd);
543 int ret;
544
545 if (NULL == dev->platform_data) {
546 dev_err(&client->dev, "no camera_sensor_platform_data");
547 return -ENODEV;
548 }
549
550 ret = dev->platform_data->flisclk_ctrl(sd, 0);
551 if (ret)
552 dev_err(&client->dev, "flisclk failed\n");
553
554 /* gpio ctrl */
555 ret = gpio_ctrl(sd, 0);
556 if (ret)
557 dev_err(&client->dev, "gpio failed 1\n");
558
559 /* power control */
560 ret = power_ctrl(sd, 0);
561 if (ret)
562 dev_err(&client->dev, "vprog failed.\n");
563
564 /*according to DS, 20ms is needed after power down*/
565 msleep(20);
566
567 return ret;
568 }
569
570 static int mt9m114_s_power(struct v4l2_subdev *sd, int power)
571 {
572 if (power == 0)
573 return power_down(sd);
574 else {
575 if (power_up(sd))
576 return -EINVAL;
577
578 return mt9m114_init_common(sd);
579 }
580 }
581
582 /*
583 * distance - calculate the distance
584 * @res: resolution
585 * @w: width
586 * @h: height
587 *
588 * Get the gap between resolution and w/h.
589 * res->width/height smaller than w/h wouldn't be considered.
590 * Returns the value of gap or -1 if fail.
591 */
592 #define LARGEST_ALLOWED_RATIO_MISMATCH 600
593 static int distance(struct mt9m114_res_struct const *res, u32 w, u32 h)
594 {
595 unsigned int w_ratio;
596 unsigned int h_ratio;
597 int match;
598
599 if (w == 0)
600 return -1;
601 w_ratio = (res->width << 13) / w;
602 if (h == 0)
603 return -1;
604 h_ratio = (res->height << 13) / h;
605 if (h_ratio == 0)
606 return -1;
607 match = abs(((w_ratio << 13) / h_ratio) - 8192);
608
609 if ((w_ratio < 8192) || (h_ratio < 8192) ||
610 (match > LARGEST_ALLOWED_RATIO_MISMATCH))
611 return -1;
612
613 return w_ratio + h_ratio;
614 }
615
616 /* Return the nearest higher resolution index */
617 static int nearest_resolution_index(int w, int h)
618 {
619 int i;
620 int idx = -1;
621 int dist;
622 int min_dist = INT_MAX;
623 const struct mt9m114_res_struct *tmp_res = NULL;
624
625 for (i = 0; i < ARRAY_SIZE(mt9m114_res); i++) {
626 tmp_res = &mt9m114_res[i];
627 dist = distance(tmp_res, w, h);
628 if (dist == -1)
629 continue;
630 if (dist < min_dist) {
631 min_dist = dist;
632 idx = i;
633 }
634 }
635
636 return idx;
637 }
638
639 static int mt9m114_try_res(u32 *w, u32 *h)
640 {
641 int idx = 0;
642
643 if ((*w > MT9M114_RES_960P_SIZE_H)
644 || (*h > MT9M114_RES_960P_SIZE_V)) {
645 *w = MT9M114_RES_960P_SIZE_H;
646 *h = MT9M114_RES_960P_SIZE_V;
647 } else {
648 idx = nearest_resolution_index(*w, *h);
649
650 /*
651 * nearest_resolution_index() doesn't return smaller
652 * resolutions. If it fails, it means the requested
653 * resolution is higher than wecan support. Fallback
654 * to highest possible resolution in this case.
655 */
656 if (idx == -1)
657 idx = ARRAY_SIZE(mt9m114_res) - 1;
658
659 *w = mt9m114_res[idx].width;
660 *h = mt9m114_res[idx].height;
661 }
662
663 return 0;
664 }
665
666 static struct mt9m114_res_struct *mt9m114_to_res(u32 w, u32 h)
667 {
668 int index;
669
670 for (index = 0; index < N_RES; index++) {
671 if ((mt9m114_res[index].width == w) &&
672 (mt9m114_res[index].height == h))
673 break;
674 }
675
676 /* No mode found */
677 if (index >= N_RES)
678 return NULL;
679
680 return &mt9m114_res[index];
681 }
682
683 static int mt9m114_res2size(struct v4l2_subdev *sd, int *h_size, int *v_size)
684 {
685 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
686 unsigned short hsize;
687 unsigned short vsize;
688
689 switch (dev->res) {
690 case MT9M114_RES_736P:
691 hsize = MT9M114_RES_736P_SIZE_H;
692 vsize = MT9M114_RES_736P_SIZE_V;
693 break;
694 case MT9M114_RES_864P:
695 hsize = MT9M114_RES_864P_SIZE_H;
696 vsize = MT9M114_RES_864P_SIZE_V;
697 break;
698 case MT9M114_RES_960P:
699 hsize = MT9M114_RES_960P_SIZE_H;
700 vsize = MT9M114_RES_960P_SIZE_V;
701 break;
702 default:
703 v4l2_err(sd, "%s: Resolution 0x%08x unknown\n", __func__,
704 dev->res);
705 return -EINVAL;
706 }
707
708 if (h_size != NULL)
709 *h_size = hsize;
710 if (v_size != NULL)
711 *v_size = vsize;
712
713 return 0;
714 }
715
716 static int mt9m114_get_intg_factor(struct i2c_client *client,
717 struct camera_mipi_info *info,
718 const struct mt9m114_res_struct *res)
719 {
720 struct atomisp_sensor_mode_data *buf = &info->data;
721 u32 reg_val;
722 int ret;
723
724 if (info == NULL)
725 return -EINVAL;
726
727 ret = mt9m114_read_reg(client, MISENSOR_32BIT,
728 REG_PIXEL_CLK, &reg_val);
729 if (ret)
730 return ret;
731 buf->vt_pix_clk_freq_mhz = reg_val;
732
733 /* get integration time */
734 buf->coarse_integration_time_min = MT9M114_COARSE_INTG_TIME_MIN;
735 buf->coarse_integration_time_max_margin =
736 MT9M114_COARSE_INTG_TIME_MAX_MARGIN;
737
738 buf->fine_integration_time_min = MT9M114_FINE_INTG_TIME_MIN;
739 buf->fine_integration_time_max_margin =
740 MT9M114_FINE_INTG_TIME_MAX_MARGIN;
741
742 buf->fine_integration_time_def = MT9M114_FINE_INTG_TIME_MIN;
743
744 buf->frame_length_lines = res->lines_per_frame;
745 buf->line_length_pck = res->pixels_per_line;
746 buf->read_mode = res->bin_mode;
747
748 /* get the cropping and output resolution to ISP for this mode. */
749 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
750 REG_H_START, &reg_val);
751 if (ret)
752 return ret;
753 buf->crop_horizontal_start = reg_val;
754
755 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
756 REG_V_START, &reg_val);
757 if (ret)
758 return ret;
759 buf->crop_vertical_start = reg_val;
760
761 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
762 REG_H_END, &reg_val);
763 if (ret)
764 return ret;
765 buf->crop_horizontal_end = reg_val;
766
767 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
768 REG_V_END, &reg_val);
769 if (ret)
770 return ret;
771 buf->crop_vertical_end = reg_val;
772
773 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
774 REG_WIDTH, &reg_val);
775 if (ret)
776 return ret;
777 buf->output_width = reg_val;
778
779 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
780 REG_HEIGHT, &reg_val);
781 if (ret)
782 return ret;
783 buf->output_height = reg_val;
784
785 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
786 REG_TIMING_HTS, &reg_val);
787 if (ret)
788 return ret;
789 buf->line_length_pck = reg_val;
790
791 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
792 REG_TIMING_VTS, &reg_val);
793 if (ret)
794 return ret;
795 buf->frame_length_lines = reg_val;
796
797 buf->binning_factor_x = res->bin_factor_x ?
798 res->bin_factor_x : 1;
799 buf->binning_factor_y = res->bin_factor_y ?
800 res->bin_factor_y : 1;
801 return 0;
802 }
803
804 static int mt9m114_get_fmt(struct v4l2_subdev *sd,
805 struct v4l2_subdev_pad_config *cfg,
806 struct v4l2_subdev_format *format)
807 {
808 struct v4l2_mbus_framefmt *fmt = &format->format;
809 int width, height;
810 int ret;
811 if (format->pad)
812 return -EINVAL;
813 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
814
815 ret = mt9m114_res2size(sd, &width, &height);
816 if (ret)
817 return ret;
818 fmt->width = width;
819 fmt->height = height;
820
821 return 0;
822 }
823
824 static int mt9m114_set_fmt(struct v4l2_subdev *sd,
825 struct v4l2_subdev_pad_config *cfg,
826 struct v4l2_subdev_format *format)
827 {
828 struct v4l2_mbus_framefmt *fmt = &format->format;
829 struct i2c_client *c = v4l2_get_subdevdata(sd);
830 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
831 struct mt9m114_res_struct *res_index;
832 u32 width = fmt->width;
833 u32 height = fmt->height;
834 struct camera_mipi_info *mt9m114_info = NULL;
835
836 int ret;
837 if (format->pad)
838 return -EINVAL;
839 dev->streamon = 0;
840 dev->first_exp = MT9M114_DEFAULT_FIRST_EXP;
841
842 mt9m114_info = v4l2_get_subdev_hostdata(sd);
843 if (mt9m114_info == NULL)
844 return -EINVAL;
845
846 mt9m114_try_res(&width, &height);
847 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
848 cfg->try_fmt = *fmt;
849 return 0;
850 }
851 res_index = mt9m114_to_res(width, height);
852
853 /* Sanity check */
854 if (unlikely(!res_index)) {
855 WARN_ON(1);
856 return -EINVAL;
857 }
858
859 switch (res_index->res) {
860 case MT9M114_RES_736P:
861 ret = mt9m114_write_reg_array(c, mt9m114_736P_init, NO_POLLING);
862 ret += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
863 MISENSOR_R_MODE_MASK, MISENSOR_NORMAL_SET);
864 break;
865 case MT9M114_RES_864P:
866 ret = mt9m114_write_reg_array(c, mt9m114_864P_init, NO_POLLING);
867 ret += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
868 MISENSOR_R_MODE_MASK, MISENSOR_NORMAL_SET);
869 break;
870 case MT9M114_RES_960P:
871 ret = mt9m114_write_reg_array(c, mt9m114_976P_init, NO_POLLING);
872 /* set sensor read_mode to Normal */
873 ret += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
874 MISENSOR_R_MODE_MASK, MISENSOR_NORMAL_SET);
875 break;
876 default:
877 v4l2_err(sd, "set resolution: %d failed!\n", res_index->res);
878 return -EINVAL;
879 }
880
881 if (ret)
882 return -EINVAL;
883
884 ret = mt9m114_write_reg_array(c, mt9m114_chgstat_reg, POST_POLLING);
885 if (ret < 0)
886 return ret;
887
888 if (mt9m114_set_suspend(sd))
889 return -EINVAL;
890
891 if (dev->res != res_index->res) {
892 int index;
893
894 /* Switch to different size */
895 if (width <= 640) {
896 dev->nctx = 0x00; /* Set for context A */
897 } else {
898 /*
899 * Context B is used for resolutions larger than 640x480
900 * Using YUV for Context B.
901 */
902 dev->nctx = 0x01; /* set for context B */
903 }
904
905 /*
906 * Marked current sensor res as being "used"
907 *
908 * REVISIT: We don't need to use an "used" field on each mode
909 * list entry to know which mode is selected. If this
910 * information is really necessary, how about to use a single
911 * variable on sensor dev struct?
912 */
913 for (index = 0; index < N_RES; index++) {
914 if ((width == mt9m114_res[index].width) &&
915 (height == mt9m114_res[index].height)) {
916 mt9m114_res[index].used = true;
917 continue;
918 }
919 mt9m114_res[index].used = false;
920 }
921 }
922 ret = mt9m114_get_intg_factor(c, mt9m114_info,
923 &mt9m114_res[res_index->res]);
924 if (ret) {
925 dev_err(&c->dev, "failed to get integration_factor\n");
926 return -EINVAL;
927 }
928 /*
929 * mt9m114 - we don't poll for context switch
930 * because it does not happen with streaming disabled.
931 */
932 dev->res = res_index->res;
933
934 fmt->width = width;
935 fmt->height = height;
936 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
937 return 0;
938 }
939
940 /* TODO: Update to SOC functions, remove exposure and gain */
941 static int mt9m114_g_focal(struct v4l2_subdev *sd, s32 *val)
942 {
943 *val = (MT9M114_FOCAL_LENGTH_NUM << 16) | MT9M114_FOCAL_LENGTH_DEM;
944 return 0;
945 }
946
947 static int mt9m114_g_fnumber(struct v4l2_subdev *sd, s32 *val)
948 {
949 /*const f number for mt9m114*/
950 *val = (MT9M114_F_NUMBER_DEFAULT_NUM << 16) | MT9M114_F_NUMBER_DEM;
951 return 0;
952 }
953
954 static int mt9m114_g_fnumber_range(struct v4l2_subdev *sd, s32 *val)
955 {
956 *val = (MT9M114_F_NUMBER_DEFAULT_NUM << 24) |
957 (MT9M114_F_NUMBER_DEM << 16) |
958 (MT9M114_F_NUMBER_DEFAULT_NUM << 8) | MT9M114_F_NUMBER_DEM;
959 return 0;
960 }
961
962 /* Horizontal flip the image. */
963 static int mt9m114_g_hflip(struct v4l2_subdev *sd, s32 *val)
964 {
965 struct i2c_client *c = v4l2_get_subdevdata(sd);
966 int ret;
967 u32 data;
968 ret = mt9m114_read_reg(c, MISENSOR_16BIT,
969 (u32)MISENSOR_READ_MODE, &data);
970 if (ret)
971 return ret;
972 *val = !!(data & MISENSOR_HFLIP_MASK);
973
974 return 0;
975 }
976
977 static int mt9m114_g_vflip(struct v4l2_subdev *sd, s32 *val)
978 {
979 struct i2c_client *c = v4l2_get_subdevdata(sd);
980 int ret;
981 u32 data;
982
983 ret = mt9m114_read_reg(c, MISENSOR_16BIT,
984 (u32)MISENSOR_READ_MODE, &data);
985 if (ret)
986 return ret;
987 *val = !!(data & MISENSOR_VFLIP_MASK);
988
989 return 0;
990 }
991
992 static long mt9m114_s_exposure(struct v4l2_subdev *sd,
993 struct atomisp_exposure *exposure)
994 {
995 struct i2c_client *client = v4l2_get_subdevdata(sd);
996 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
997 int ret = 0;
998 unsigned int coarse_integration = 0;
999 unsigned int fine_integration = 0;
1000 unsigned int FLines = 0;
1001 unsigned int FrameLengthLines = 0; /* ExposureTime.FrameLengthLines; */
1002 unsigned int AnalogGain, DigitalGain;
1003 u32 AnalogGainToWrite = 0;
1004 u16 exposure_local[3];
1005
1006 dev_dbg(&client->dev, "%s(0x%X 0x%X 0x%X)\n", __func__,
1007 exposure->integration_time[0], exposure->gain[0],
1008 exposure->gain[1]);
1009
1010 coarse_integration = exposure->integration_time[0];
1011 /* fine_integration = ExposureTime.FineIntegrationTime; */
1012 /* FrameLengthLines = ExposureTime.FrameLengthLines; */
1013 FLines = mt9m114_res[dev->res].lines_per_frame;
1014 AnalogGain = exposure->gain[0];
1015 DigitalGain = exposure->gain[1];
1016 if (!dev->streamon) {
1017 /*Save the first exposure values while stream is off*/
1018 dev->first_exp = coarse_integration;
1019 dev->first_gain = AnalogGain;
1020 dev->first_diggain = DigitalGain;
1021 }
1022 /* DigitalGain = 0x400 * (((u16) DigitalGain) >> 8) +
1023 ((unsigned int)(0x400 * (((u16) DigitalGain) & 0xFF)) >>8); */
1024
1025 /* set frame length */
1026 if (FLines < coarse_integration + 6)
1027 FLines = coarse_integration + 6;
1028 if (FLines < FrameLengthLines)
1029 FLines = FrameLengthLines;
1030 ret = mt9m114_write_reg(client, MISENSOR_16BIT, 0x300A, FLines);
1031 if (ret) {
1032 v4l2_err(client, "%s: fail to set FLines\n", __func__);
1033 return -EINVAL;
1034 }
1035
1036 /* set coarse/fine integration */
1037 exposure_local[0] = REG_EXPO_COARSE;
1038 exposure_local[1] = (u16)coarse_integration;
1039 exposure_local[2] = (u16)fine_integration;
1040 /* 3A provide real exposure time.
1041 should not translate to any value here. */
1042 ret = mt9m114_write_reg(client, MISENSOR_16BIT,
1043 REG_EXPO_COARSE, (u16)(coarse_integration));
1044 if (ret) {
1045 v4l2_err(client, "%s: fail to set exposure time\n", __func__);
1046 return -EINVAL;
1047 }
1048
1049 /*
1050 // set analog/digital gain
1051 switch(AnalogGain)
1052 {
1053 case 0:
1054 AnalogGainToWrite = 0x0;
1055 break;
1056 case 1:
1057 AnalogGainToWrite = 0x20;
1058 break;
1059 case 2:
1060 AnalogGainToWrite = 0x60;
1061 break;
1062 case 4:
1063 AnalogGainToWrite = 0xA0;
1064 break;
1065 case 8:
1066 AnalogGainToWrite = 0xE0;
1067 break;
1068 default:
1069 AnalogGainToWrite = 0x20;
1070 break;
1071 }
1072 */
1073 if (DigitalGain >= 16 || DigitalGain <= 1)
1074 DigitalGain = 1;
1075 /* AnalogGainToWrite =
1076 (u16)((DigitalGain << 12) | AnalogGainToWrite); */
1077 AnalogGainToWrite = (u16)((DigitalGain << 12) | (u16)AnalogGain);
1078 ret = mt9m114_write_reg(client, MISENSOR_16BIT,
1079 REG_GAIN, AnalogGainToWrite);
1080 if (ret) {
1081 v4l2_err(client, "%s: fail to set AnalogGainToWrite\n",
1082 __func__);
1083 return -EINVAL;
1084 }
1085
1086 return ret;
1087 }
1088
1089 static long mt9m114_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1090 {
1091
1092 switch (cmd) {
1093 case ATOMISP_IOC_S_EXPOSURE:
1094 return mt9m114_s_exposure(sd, arg);
1095 default:
1096 return -EINVAL;
1097 }
1098
1099 return 0;
1100 }
1101
1102 /* This returns the exposure time being used. This should only be used
1103 for filling in EXIF data, not for actual image processing. */
1104 static int mt9m114_g_exposure(struct v4l2_subdev *sd, s32 *value)
1105 {
1106 struct i2c_client *client = v4l2_get_subdevdata(sd);
1107 u32 coarse;
1108 int ret;
1109
1110 /* the fine integration time is currently not calculated */
1111 ret = mt9m114_read_reg(client, MISENSOR_16BIT,
1112 REG_EXPO_COARSE, &coarse);
1113 if (ret)
1114 return ret;
1115
1116 *value = coarse;
1117 return 0;
1118 }
1119 #ifndef CSS15
1120 /*
1121 * This function will return the sensor supported max exposure zone number.
1122 * the sensor which supports max exposure zone number is 1.
1123 */
1124 static int mt9m114_g_exposure_zone_num(struct v4l2_subdev *sd, s32 *val)
1125 {
1126 *val = 1;
1127
1128 return 0;
1129 }
1130
1131 /*
1132 * set exposure metering, average/center_weighted/spot/matrix.
1133 */
1134 static int mt9m114_s_exposure_metering(struct v4l2_subdev *sd, s32 val)
1135 {
1136 struct i2c_client *client = v4l2_get_subdevdata(sd);
1137 int ret;
1138
1139 switch (val) {
1140 case V4L2_EXPOSURE_METERING_SPOT:
1141 ret = mt9m114_write_reg_array(client, mt9m114_exp_average,
1142 NO_POLLING);
1143 if (ret) {
1144 dev_err(&client->dev, "write exp_average reg err.\n");
1145 return ret;
1146 }
1147 break;
1148 case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
1149 default:
1150 ret = mt9m114_write_reg_array(client, mt9m114_exp_center,
1151 NO_POLLING);
1152 if (ret) {
1153 dev_err(&client->dev, "write exp_default reg err");
1154 return ret;
1155 }
1156 }
1157
1158 return 0;
1159 }
1160
1161 /*
1162 * This function is for touch exposure feature.
1163 */
1164 static int mt9m114_s_exposure_selection(struct v4l2_subdev *sd,
1165 struct v4l2_subdev_pad_config *cfg,
1166 struct v4l2_subdev_selection *sel)
1167 {
1168 struct i2c_client *client = v4l2_get_subdevdata(sd);
1169 struct misensor_reg exp_reg;
1170 int width, height;
1171 int grid_width, grid_height;
1172 int grid_left, grid_top, grid_right, grid_bottom;
1173 int win_left, win_top, win_right, win_bottom;
1174 int i, j;
1175 int ret;
1176
1177 if (sel->which != V4L2_SUBDEV_FORMAT_TRY &&
1178 sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
1179 return -EINVAL;
1180
1181 grid_left = sel->r.left;
1182 grid_top = sel->r.top;
1183 grid_right = sel->r.left + sel->r.width - 1;
1184 grid_bottom = sel->r.top + sel->r.height - 1;
1185
1186 ret = mt9m114_res2size(sd, &width, &height);
1187 if (ret)
1188 return ret;
1189
1190 grid_width = width / 5;
1191 grid_height = height / 5;
1192
1193 if (grid_width && grid_height) {
1194 win_left = grid_left / grid_width;
1195 win_top = grid_top / grid_height;
1196 win_right = grid_right / grid_width;
1197 win_bottom = grid_bottom / grid_height;
1198 } else {
1199 dev_err(&client->dev, "Incorrect exp grid.\n");
1200 return -EINVAL;
1201 }
1202
1203 win_left = clamp_t(int, win_left, 0, 4);
1204 win_top = clamp_t(int, win_top, 0, 4);
1205 win_right = clamp_t(int, win_right, 0, 4);
1206 win_bottom = clamp_t(int, win_bottom, 0, 4);
1207
1208 ret = mt9m114_write_reg_array(client, mt9m114_exp_average, NO_POLLING);
1209 if (ret) {
1210 dev_err(&client->dev, "write exp_average reg err.\n");
1211 return ret;
1212 }
1213
1214 for (i = win_top; i <= win_bottom; i++) {
1215 for (j = win_left; j <= win_right; j++) {
1216 exp_reg = mt9m114_exp_win[i][j];
1217
1218 ret = mt9m114_write_reg(client, exp_reg.length,
1219 exp_reg.reg, exp_reg.val);
1220 if (ret) {
1221 dev_err(&client->dev, "write exp_reg err.\n");
1222 return ret;
1223 }
1224 }
1225 }
1226
1227 return 0;
1228 }
1229 #endif
1230
1231 static int mt9m114_g_bin_factor_x(struct v4l2_subdev *sd, s32 *val)
1232 {
1233 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1234
1235 *val = mt9m114_res[dev->res].bin_factor_x;
1236
1237 return 0;
1238 }
1239
1240 static int mt9m114_g_bin_factor_y(struct v4l2_subdev *sd, s32 *val)
1241 {
1242 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1243
1244 *val = mt9m114_res[dev->res].bin_factor_y;
1245
1246 return 0;
1247 }
1248
1249 static int mt9m114_s_ev(struct v4l2_subdev *sd, s32 val)
1250 {
1251 struct i2c_client *c = v4l2_get_subdevdata(sd);
1252 s32 luma = 0x37;
1253 int err;
1254
1255 /* EV value only support -2 to 2
1256 * 0: 0x37, 1:0x47, 2:0x57, -1:0x27, -2:0x17
1257 */
1258 if (val < -2 || val > 2)
1259 return -EINVAL;
1260 luma += 0x10 * val;
1261 dev_dbg(&c->dev, "%s val:%d luma:0x%x\n", __func__, val, luma);
1262 err = mt9m114_write_reg(c, MISENSOR_16BIT, 0x098E, 0xC87A);
1263 if (err) {
1264 dev_err(&c->dev, "%s logic addr access error\n", __func__);
1265 return err;
1266 }
1267 err = mt9m114_write_reg(c, MISENSOR_8BIT, 0xC87A, (u32)luma);
1268 if (err) {
1269 dev_err(&c->dev, "%s write target_average_luma failed\n",
1270 __func__);
1271 return err;
1272 }
1273 udelay(10);
1274
1275 return 0;
1276 }
1277
1278 static int mt9m114_g_ev(struct v4l2_subdev *sd, s32 *val)
1279 {
1280 struct i2c_client *c = v4l2_get_subdevdata(sd);
1281 int err;
1282 u32 luma;
1283
1284 err = mt9m114_write_reg(c, MISENSOR_16BIT, 0x098E, 0xC87A);
1285 if (err) {
1286 dev_err(&c->dev, "%s logic addr access error\n", __func__);
1287 return err;
1288 }
1289 err = mt9m114_read_reg(c, MISENSOR_8BIT, 0xC87A, &luma);
1290 if (err) {
1291 dev_err(&c->dev, "%s read target_average_luma failed\n",
1292 __func__);
1293 return err;
1294 }
1295 luma -= 0x17;
1296 luma /= 0x10;
1297 *val = (s32)luma - 2;
1298 dev_dbg(&c->dev, "%s val:%d\n", __func__, *val);
1299
1300 return 0;
1301 }
1302
1303 /* Fake interface
1304 * mt9m114 now can not support 3a_lock
1305 */
1306 static int mt9m114_s_3a_lock(struct v4l2_subdev *sd, s32 val)
1307 {
1308 aaalock = val;
1309 return 0;
1310 }
1311
1312 static int mt9m114_g_3a_lock(struct v4l2_subdev *sd, s32 *val)
1313 {
1314 if (aaalock)
1315 return V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE
1316 | V4L2_LOCK_FOCUS;
1317 return 0;
1318 }
1319
1320 static int mt9m114_s_ctrl(struct v4l2_ctrl *ctrl)
1321 {
1322 struct mt9m114_device *dev =
1323 container_of(ctrl->handler, struct mt9m114_device, ctrl_handler);
1324 struct i2c_client *client = v4l2_get_subdevdata(&dev->sd);
1325 int ret = 0;
1326
1327 switch (ctrl->id) {
1328 case V4L2_CID_VFLIP:
1329 dev_dbg(&client->dev, "%s: CID_VFLIP:%d.\n",
1330 __func__, ctrl->val);
1331 ret = mt9m114_t_vflip(&dev->sd, ctrl->val);
1332 break;
1333 case V4L2_CID_HFLIP:
1334 dev_dbg(&client->dev, "%s: CID_HFLIP:%d.\n",
1335 __func__, ctrl->val);
1336 ret = mt9m114_t_hflip(&dev->sd, ctrl->val);
1337 break;
1338 #ifndef CSS15
1339 case V4L2_CID_EXPOSURE_METERING:
1340 ret = mt9m114_s_exposure_metering(&dev->sd, ctrl->val);
1341 break;
1342 #endif
1343 case V4L2_CID_EXPOSURE:
1344 ret = mt9m114_s_ev(&dev->sd, ctrl->val);
1345 break;
1346 case V4L2_CID_3A_LOCK:
1347 ret = mt9m114_s_3a_lock(&dev->sd, ctrl->val);
1348 break;
1349 default:
1350 ret = -EINVAL;
1351 }
1352 return ret;
1353 }
1354
1355 static int mt9m114_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1356 {
1357 struct mt9m114_device *dev =
1358 container_of(ctrl->handler, struct mt9m114_device, ctrl_handler);
1359 int ret = 0;
1360
1361 switch (ctrl->id) {
1362 case V4L2_CID_VFLIP:
1363 ret = mt9m114_g_vflip(&dev->sd, &ctrl->val);
1364 break;
1365 case V4L2_CID_HFLIP:
1366 ret = mt9m114_g_hflip(&dev->sd, &ctrl->val);
1367 break;
1368 case V4L2_CID_FOCAL_ABSOLUTE:
1369 ret = mt9m114_g_focal(&dev->sd, &ctrl->val);
1370 break;
1371 case V4L2_CID_FNUMBER_ABSOLUTE:
1372 ret = mt9m114_g_fnumber(&dev->sd, &ctrl->val);
1373 break;
1374 case V4L2_CID_FNUMBER_RANGE:
1375 ret = mt9m114_g_fnumber_range(&dev->sd, &ctrl->val);
1376 break;
1377 case V4L2_CID_EXPOSURE_ABSOLUTE:
1378 ret = mt9m114_g_exposure(&dev->sd, &ctrl->val);
1379 break;
1380 #ifndef CSS15
1381 case V4L2_CID_EXPOSURE_ZONE_NUM:
1382 ret = mt9m114_g_exposure_zone_num(&dev->sd, &ctrl->val);
1383 break;
1384 #endif
1385 case V4L2_CID_BIN_FACTOR_HORZ:
1386 ret = mt9m114_g_bin_factor_x(&dev->sd, &ctrl->val);
1387 break;
1388 case V4L2_CID_BIN_FACTOR_VERT:
1389 ret = mt9m114_g_bin_factor_y(&dev->sd, &ctrl->val);
1390 break;
1391 case V4L2_CID_EXPOSURE:
1392 ret = mt9m114_g_ev(&dev->sd, &ctrl->val);
1393 break;
1394 case V4L2_CID_3A_LOCK:
1395 ret = mt9m114_g_3a_lock(&dev->sd, &ctrl->val);
1396 break;
1397 default:
1398 ret = -EINVAL;
1399 }
1400
1401 return ret;
1402 }
1403
1404 static const struct v4l2_ctrl_ops ctrl_ops = {
1405 .s_ctrl = mt9m114_s_ctrl,
1406 .g_volatile_ctrl = mt9m114_g_volatile_ctrl
1407 };
1408
1409 static struct v4l2_ctrl_config mt9m114_controls[] = {
1410 {
1411 .ops = &ctrl_ops,
1412 .id = V4L2_CID_VFLIP,
1413 .name = "Image v-Flip",
1414 .type = V4L2_CTRL_TYPE_INTEGER,
1415 .min = 0,
1416 .max = 1,
1417 .step = 1,
1418 .def = 0,
1419 },
1420 {
1421 .ops = &ctrl_ops,
1422 .id = V4L2_CID_HFLIP,
1423 .name = "Image h-Flip",
1424 .type = V4L2_CTRL_TYPE_INTEGER,
1425 .min = 0,
1426 .max = 1,
1427 .step = 1,
1428 .def = 0,
1429 },
1430 {
1431 .ops = &ctrl_ops,
1432 .id = V4L2_CID_FOCAL_ABSOLUTE,
1433 .name = "focal length",
1434 .type = V4L2_CTRL_TYPE_INTEGER,
1435 .min = MT9M114_FOCAL_LENGTH_DEFAULT,
1436 .max = MT9M114_FOCAL_LENGTH_DEFAULT,
1437 .step = 1,
1438 .def = MT9M114_FOCAL_LENGTH_DEFAULT,
1439 .flags = 0,
1440 },
1441 {
1442 .ops = &ctrl_ops,
1443 .id = V4L2_CID_FNUMBER_ABSOLUTE,
1444 .name = "f-number",
1445 .type = V4L2_CTRL_TYPE_INTEGER,
1446 .min = MT9M114_F_NUMBER_DEFAULT,
1447 .max = MT9M114_F_NUMBER_DEFAULT,
1448 .step = 1,
1449 .def = MT9M114_F_NUMBER_DEFAULT,
1450 .flags = 0,
1451 },
1452 {
1453 .ops = &ctrl_ops,
1454 .id = V4L2_CID_FNUMBER_RANGE,
1455 .name = "f-number range",
1456 .type = V4L2_CTRL_TYPE_INTEGER,
1457 .min = MT9M114_F_NUMBER_RANGE,
1458 .max = MT9M114_F_NUMBER_RANGE,
1459 .step = 1,
1460 .def = MT9M114_F_NUMBER_RANGE,
1461 .flags = 0,
1462 },
1463 {
1464 .ops = &ctrl_ops,
1465 .id = V4L2_CID_EXPOSURE_ABSOLUTE,
1466 .name = "exposure",
1467 .type = V4L2_CTRL_TYPE_INTEGER,
1468 .min = 0,
1469 .max = 0xffff,
1470 .step = 1,
1471 .def = 0,
1472 .flags = 0,
1473 },
1474 #ifndef CSS15
1475 {
1476 .ops = &ctrl_ops,
1477 .id = V4L2_CID_EXPOSURE_ZONE_NUM,
1478 .name = "one-time exposure zone number",
1479 .type = V4L2_CTRL_TYPE_INTEGER,
1480 .min = 0,
1481 .max = 0xffff,
1482 .step = 1,
1483 .def = 0,
1484 .flags = 0,
1485 },
1486 {
1487 .ops = &ctrl_ops,
1488 .id = V4L2_CID_EXPOSURE_METERING,
1489 .name = "metering",
1490 .type = V4L2_CTRL_TYPE_MENU,
1491 .min = 0,
1492 .max = 3,
1493 .step = 0,
1494 .def = 1,
1495 .flags = 0,
1496 },
1497 #endif
1498 {
1499 .ops = &ctrl_ops,
1500 .id = V4L2_CID_BIN_FACTOR_HORZ,
1501 .name = "horizontal binning factor",
1502 .type = V4L2_CTRL_TYPE_INTEGER,
1503 .min = 0,
1504 .max = MT9M114_BIN_FACTOR_MAX,
1505 .step = 1,
1506 .def = 0,
1507 .flags = 0,
1508 },
1509 {
1510 .ops = &ctrl_ops,
1511 .id = V4L2_CID_BIN_FACTOR_VERT,
1512 .name = "vertical binning factor",
1513 .type = V4L2_CTRL_TYPE_INTEGER,
1514 .min = 0,
1515 .max = MT9M114_BIN_FACTOR_MAX,
1516 .step = 1,
1517 .def = 0,
1518 .flags = 0,
1519 },
1520 {
1521 .ops = &ctrl_ops,
1522 .id = V4L2_CID_EXPOSURE,
1523 .name = "exposure biasx",
1524 .type = V4L2_CTRL_TYPE_INTEGER,
1525 .min = -2,
1526 .max = 2,
1527 .step = 1,
1528 .def = 0,
1529 .flags = 0,
1530 },
1531 {
1532 .ops = &ctrl_ops,
1533 .id = V4L2_CID_3A_LOCK,
1534 .name = "3a lock",
1535 .type = V4L2_CTRL_TYPE_BITMASK,
1536 .min = 0,
1537 .max = V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE | V4L2_LOCK_FOCUS,
1538 .step = 1,
1539 .def = 0,
1540 .flags = 0,
1541 },
1542 };
1543
1544 static int mt9m114_detect(struct mt9m114_device *dev, struct i2c_client *client)
1545 {
1546 struct i2c_adapter *adapter = client->adapter;
1547 u32 retvalue;
1548
1549 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
1550 dev_err(&client->dev, "%s: i2c error", __func__);
1551 return -ENODEV;
1552 }
1553 mt9m114_read_reg(client, MISENSOR_16BIT, (u32)MT9M114_PID, &retvalue);
1554 dev->real_model_id = retvalue;
1555
1556 if (retvalue != MT9M114_MOD_ID) {
1557 dev_err(&client->dev, "%s: failed: client->addr = %x\n",
1558 __func__, client->addr);
1559 return -ENODEV;
1560 }
1561
1562 return 0;
1563 }
1564
1565 static int
1566 mt9m114_s_config(struct v4l2_subdev *sd, int irq, void *platform_data)
1567 {
1568 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1569 struct i2c_client *client = v4l2_get_subdevdata(sd);
1570 int ret;
1571
1572 if (NULL == platform_data)
1573 return -ENODEV;
1574
1575 dev->platform_data =
1576 (struct camera_sensor_platform_data *)platform_data;
1577
1578 ret = power_up(sd);
1579 if (ret) {
1580 v4l2_err(client, "mt9m114 power-up err");
1581 return ret;
1582 }
1583
1584 /* config & detect sensor */
1585 ret = mt9m114_detect(dev, client);
1586 if (ret) {
1587 v4l2_err(client, "mt9m114_detect err s_config.\n");
1588 goto fail_detect;
1589 }
1590
1591 ret = dev->platform_data->csi_cfg(sd, 1);
1592 if (ret)
1593 goto fail_csi_cfg;
1594
1595 ret = mt9m114_set_suspend(sd);
1596 if (ret) {
1597 v4l2_err(client, "mt9m114 suspend err");
1598 return ret;
1599 }
1600
1601 ret = power_down(sd);
1602 if (ret) {
1603 v4l2_err(client, "mt9m114 power down err");
1604 return ret;
1605 }
1606
1607 return ret;
1608
1609 fail_csi_cfg:
1610 dev->platform_data->csi_cfg(sd, 0);
1611 fail_detect:
1612 power_down(sd);
1613 dev_err(&client->dev, "sensor power-gating failed\n");
1614 return ret;
1615 }
1616
1617 /* Horizontal flip the image. */
1618 static int mt9m114_t_hflip(struct v4l2_subdev *sd, int value)
1619 {
1620 struct i2c_client *c = v4l2_get_subdevdata(sd);
1621 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1622 int err;
1623 /* set for direct mode */
1624 err = mt9m114_write_reg(c, MISENSOR_16BIT, 0x098E, 0xC850);
1625 if (value) {
1626 /* enable H flip ctx A */
1627 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC850, 0x01, 0x01);
1628 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC851, 0x01, 0x01);
1629 /* ctx B */
1630 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC888, 0x01, 0x01);
1631 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC889, 0x01, 0x01);
1632
1633 err += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
1634 MISENSOR_HFLIP_MASK, MISENSOR_FLIP_EN);
1635
1636 dev->bpat = MT9M114_BPAT_GRGRBGBG;
1637 } else {
1638 /* disable H flip ctx A */
1639 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC850, 0x01, 0x00);
1640 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC851, 0x01, 0x00);
1641 /* ctx B */
1642 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC888, 0x01, 0x00);
1643 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC889, 0x01, 0x00);
1644
1645 err += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
1646 MISENSOR_HFLIP_MASK, MISENSOR_FLIP_DIS);
1647
1648 dev->bpat = MT9M114_BPAT_BGBGGRGR;
1649 }
1650
1651 err += mt9m114_write_reg(c, MISENSOR_8BIT, 0x8404, 0x06);
1652 udelay(10);
1653
1654 return !!err;
1655 }
1656
1657 /* Vertically flip the image */
1658 static int mt9m114_t_vflip(struct v4l2_subdev *sd, int value)
1659 {
1660 struct i2c_client *c = v4l2_get_subdevdata(sd);
1661 int err;
1662 /* set for direct mode */
1663 err = mt9m114_write_reg(c, MISENSOR_16BIT, 0x098E, 0xC850);
1664 if (value >= 1) {
1665 /* enable H flip - ctx A */
1666 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC850, 0x02, 0x01);
1667 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC851, 0x02, 0x01);
1668 /* ctx B */
1669 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC888, 0x02, 0x01);
1670 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC889, 0x02, 0x01);
1671
1672 err += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
1673 MISENSOR_VFLIP_MASK, MISENSOR_FLIP_EN);
1674 } else {
1675 /* disable H flip - ctx A */
1676 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC850, 0x02, 0x00);
1677 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC851, 0x02, 0x00);
1678 /* ctx B */
1679 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC888, 0x02, 0x00);
1680 err += misensor_rmw_reg(c, MISENSOR_8BIT, 0xC889, 0x02, 0x00);
1681
1682 err += misensor_rmw_reg(c, MISENSOR_16BIT, MISENSOR_READ_MODE,
1683 MISENSOR_VFLIP_MASK, MISENSOR_FLIP_DIS);
1684 }
1685
1686 err += mt9m114_write_reg(c, MISENSOR_8BIT, 0x8404, 0x06);
1687 udelay(10);
1688
1689 return !!err;
1690 }
1691 static int mt9m114_s_parm(struct v4l2_subdev *sd,
1692 struct v4l2_streamparm *param)
1693 {
1694 return 0;
1695 }
1696
1697 static int mt9m114_g_frame_interval(struct v4l2_subdev *sd,
1698 struct v4l2_subdev_frame_interval *interval)
1699 {
1700 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1701
1702 interval->interval.numerator = 1;
1703 interval->interval.denominator = mt9m114_res[dev->res].fps;
1704
1705 return 0;
1706 }
1707
1708 static int mt9m114_s_stream(struct v4l2_subdev *sd, int enable)
1709 {
1710 int ret;
1711 struct i2c_client *c = v4l2_get_subdevdata(sd);
1712 struct mt9m114_device *dev = to_mt9m114_sensor(sd);
1713 struct atomisp_exposure exposure;
1714
1715 if (enable) {
1716 ret = mt9m114_write_reg_array(c, mt9m114_chgstat_reg,
1717 POST_POLLING);
1718 if (ret < 0)
1719 return ret;
1720
1721 if (dev->first_exp > MT9M114_MAX_FIRST_EXP) {
1722 exposure.integration_time[0] = dev->first_exp;
1723 exposure.gain[0] = dev->first_gain;
1724 exposure.gain[1] = dev->first_diggain;
1725 mt9m114_s_exposure(sd, &exposure);
1726 }
1727 dev->streamon = 1;
1728
1729 } else {
1730 dev->streamon = 0;
1731 ret = mt9m114_set_suspend(sd);
1732 }
1733
1734 return ret;
1735 }
1736
1737 static int mt9m114_enum_mbus_code(struct v4l2_subdev *sd,
1738 struct v4l2_subdev_pad_config *cfg,
1739 struct v4l2_subdev_mbus_code_enum *code)
1740 {
1741 if (code->index)
1742 return -EINVAL;
1743 code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
1744
1745 return 0;
1746 }
1747
1748 static int mt9m114_enum_frame_size(struct v4l2_subdev *sd,
1749 struct v4l2_subdev_pad_config *cfg,
1750 struct v4l2_subdev_frame_size_enum *fse)
1751 {
1752
1753 unsigned int index = fse->index;
1754
1755 if (index >= N_RES)
1756 return -EINVAL;
1757
1758 fse->min_width = mt9m114_res[index].width;
1759 fse->min_height = mt9m114_res[index].height;
1760 fse->max_width = mt9m114_res[index].width;
1761 fse->max_height = mt9m114_res[index].height;
1762
1763 return 0;
1764 }
1765
1766 static int mt9m114_g_skip_frames(struct v4l2_subdev *sd, u32 *frames)
1767 {
1768 int index;
1769 struct mt9m114_device *snr = to_mt9m114_sensor(sd);
1770
1771 if (frames == NULL)
1772 return -EINVAL;
1773
1774 for (index = 0; index < N_RES; index++) {
1775 if (mt9m114_res[index].res == snr->res)
1776 break;
1777 }
1778
1779 if (index >= N_RES)
1780 return -EINVAL;
1781
1782 *frames = mt9m114_res[index].skip_frames;
1783
1784 return 0;
1785 }
1786
1787 static const struct v4l2_subdev_video_ops mt9m114_video_ops = {
1788 .s_parm = mt9m114_s_parm,
1789 .s_stream = mt9m114_s_stream,
1790 .g_frame_interval = mt9m114_g_frame_interval,
1791 };
1792
1793 static const struct v4l2_subdev_sensor_ops mt9m114_sensor_ops = {
1794 .g_skip_frames = mt9m114_g_skip_frames,
1795 };
1796
1797 static const struct v4l2_subdev_core_ops mt9m114_core_ops = {
1798 .s_power = mt9m114_s_power,
1799 .ioctl = mt9m114_ioctl,
1800 };
1801
1802 /* REVISIT: Do we need pad operations? */
1803 static const struct v4l2_subdev_pad_ops mt9m114_pad_ops = {
1804 .enum_mbus_code = mt9m114_enum_mbus_code,
1805 .enum_frame_size = mt9m114_enum_frame_size,
1806 .get_fmt = mt9m114_get_fmt,
1807 .set_fmt = mt9m114_set_fmt,
1808 #ifndef CSS15
1809 .set_selection = mt9m114_s_exposure_selection,
1810 #endif
1811 };
1812
1813 static const struct v4l2_subdev_ops mt9m114_ops = {
1814 .core = &mt9m114_core_ops,
1815 .video = &mt9m114_video_ops,
1816 .pad = &mt9m114_pad_ops,
1817 .sensor = &mt9m114_sensor_ops,
1818 };
1819
1820 static const struct media_entity_operations mt9m114_entity_ops = {
1821 .link_setup = NULL,
1822 };
1823
1824 static int mt9m114_remove(struct i2c_client *client)
1825 {
1826 struct mt9m114_device *dev;
1827 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1828
1829 dev = container_of(sd, struct mt9m114_device, sd);
1830 dev->platform_data->csi_cfg(sd, 0);
1831 v4l2_device_unregister_subdev(sd);
1832 media_entity_cleanup(&dev->sd.entity);
1833 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1834 kfree(dev);
1835 return 0;
1836 }
1837
1838 static int mt9m114_probe(struct i2c_client *client)
1839 {
1840 struct mt9m114_device *dev;
1841 int ret = 0;
1842 unsigned int i;
1843 void *pdata;
1844
1845 /* Setup sensor configuration structure */
1846 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1847 if (!dev)
1848 return -ENOMEM;
1849
1850 v4l2_i2c_subdev_init(&dev->sd, client, &mt9m114_ops);
1851 pdata = client->dev.platform_data;
1852 if (ACPI_COMPANION(&client->dev))
1853 pdata = gmin_camera_platform_data(&dev->sd,
1854 ATOMISP_INPUT_FORMAT_RAW_10,
1855 atomisp_bayer_order_grbg);
1856 if (pdata)
1857 ret = mt9m114_s_config(&dev->sd, client->irq, pdata);
1858 if (!pdata || ret) {
1859 v4l2_device_unregister_subdev(&dev->sd);
1860 kfree(dev);
1861 return ret;
1862 }
1863
1864 ret = atomisp_register_i2c_module(&dev->sd, pdata, RAW_CAMERA);
1865 if (ret) {
1866 v4l2_device_unregister_subdev(&dev->sd);
1867 kfree(dev);
1868 /* Coverity CID 298095 - return on error */
1869 return ret;
1870 }
1871
1872 /*TODO add format code here*/
1873 dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1874 dev->pad.flags = MEDIA_PAD_FL_SOURCE;
1875 dev->format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
1876 dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1877
1878 ret =
1879 v4l2_ctrl_handler_init(&dev->ctrl_handler,
1880 ARRAY_SIZE(mt9m114_controls));
1881 if (ret) {
1882 mt9m114_remove(client);
1883 return ret;
1884 }
1885
1886 for (i = 0; i < ARRAY_SIZE(mt9m114_controls); i++)
1887 v4l2_ctrl_new_custom(&dev->ctrl_handler, &mt9m114_controls[i],
1888 NULL);
1889
1890 if (dev->ctrl_handler.error) {
1891 mt9m114_remove(client);
1892 return dev->ctrl_handler.error;
1893 }
1894
1895 /* Use same lock for controls as for everything else. */
1896 dev->ctrl_handler.lock = &dev->input_lock;
1897 dev->sd.ctrl_handler = &dev->ctrl_handler;
1898
1899 /* REVISIT: Do we need media controller? */
1900 ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad);
1901 if (ret) {
1902 mt9m114_remove(client);
1903 return ret;
1904 }
1905 return 0;
1906 }
1907
1908 static const struct acpi_device_id mt9m114_acpi_match[] = {
1909 { "INT33F0" },
1910 { "CRMT1040" },
1911 {},
1912 };
1913 MODULE_DEVICE_TABLE(acpi, mt9m114_acpi_match);
1914
1915 static struct i2c_driver mt9m114_driver = {
1916 .driver = {
1917 .name = "mt9m114",
1918 .acpi_match_table = mt9m114_acpi_match,
1919 },
1920 .probe_new = mt9m114_probe,
1921 .remove = mt9m114_remove,
1922 };
1923 module_i2c_driver(mt9m114_driver);
1924
1925 MODULE_AUTHOR("Shuguang Gong <Shuguang.gong@intel.com>");
1926 MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror