1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "../include/linux/atomisp.h"
22#include <linux/delay.h>
23#include <linux/firmware.h>
24#include <linux/i2c.h>
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/string.h>
28#include <linux/types.h>
29#include <media/v4l2-ctrls.h>
30#include <media/v4l2-device.h>
31#include "ap1302.h"
32
33#define to_ap1302_device(sub_dev) \
34 container_of(sub_dev, struct ap1302_device, sd)
35
36
37static struct regmap_config ap1302_reg16_config = {
38 .reg_bits = 16,
39 .val_bits = 16,
40 .reg_format_endian = REGMAP_ENDIAN_BIG,
41 .val_format_endian = REGMAP_ENDIAN_BIG,
42};
43
44static struct regmap_config ap1302_reg32_config = {
45 .reg_bits = 16,
46 .val_bits = 32,
47 .reg_format_endian = REGMAP_ENDIAN_BIG,
48 .val_format_endian = REGMAP_ENDIAN_BIG,
49};
50
51static enum ap1302_contexts ap1302_cntx_mapping[] = {
52 CONTEXT_PREVIEW,
53 CONTEXT_VIDEO,
54 CONTEXT_SNAPSHOT,
55 CONTEXT_SNAPSHOT,
56 CONTEXT_PREVIEW,
57};
58
59static struct ap1302_res_struct ap1302_preview_res[] = {
60 {
61 .width = 640,
62 .height = 480,
63 .fps = 30,
64 },
65 {
66 .width = 720,
67 .height = 480,
68 .fps = 30,
69 },
70 {
71 .width = 1280,
72 .height = 720,
73 .fps = 30,
74 },
75 {
76 .width = 1920,
77 .height = 1080,
78 .fps = 30,
79 }
80};
81
82static struct ap1302_res_struct ap1302_snapshot_res[] = {
83 {
84 .width = 640,
85 .height = 480,
86 .fps = 30,
87 },
88 {
89 .width = 720,
90 .height = 480,
91 .fps = 30,
92 },
93 {
94 .width = 1280,
95 .height = 720,
96 .fps = 30,
97 },
98 {
99 .width = 1920,
100 .height = 1080,
101 .fps = 30,
102 }
103};
104
105static struct ap1302_res_struct ap1302_video_res[] = {
106 {
107 .width = 640,
108 .height = 480,
109 .fps = 30,
110 },
111 {
112 .width = 720,
113 .height = 480,
114 .fps = 30,
115 },
116 {
117 .width = 1280,
118 .height = 720,
119 .fps = 30,
120 },
121 {
122 .width = 1920,
123 .height = 1080,
124 .fps = 30,
125 }
126};
127
128static enum ap1302_contexts stream_to_context[] = {
129 CONTEXT_SNAPSHOT,
130 CONTEXT_PREVIEW,
131 CONTEXT_PREVIEW,
132 CONTEXT_VIDEO
133};
134
135static u16 aux_stream_config[CONTEXT_NUM][CONTEXT_NUM] = {
136 {0, 0, 0},
137 {1, 0, 2},
138 {1, 0, 0},
139};
140
141static struct ap1302_context_info context_info[] = {
142 {CNTX_WIDTH, AP1302_REG16, "width"},
143 {CNTX_HEIGHT, AP1302_REG16, "height"},
144 {CNTX_ROI_X0, AP1302_REG16, "roi_x0"},
145 {CNTX_ROI_X1, AP1302_REG16, "roi_x1"},
146 {CNTX_ROI_Y0, AP1302_REG16, "roi_y0"},
147 {CNTX_ROI_Y1, AP1302_REG16, "roi_y1"},
148 {CNTX_ASPECT, AP1302_REG16, "aspect"},
149 {CNTX_LOCK, AP1302_REG16, "lock"},
150 {CNTX_ENABLE, AP1302_REG16, "enable"},
151 {CNTX_OUT_FMT, AP1302_REG16, "out_fmt"},
152 {CNTX_SENSOR_MODE, AP1302_REG16, "sensor_mode"},
153 {CNTX_MIPI_CTRL, AP1302_REG16, "mipi_ctrl"},
154 {CNTX_MIPI_II_CTRL, AP1302_REG16, "mipi_ii_ctrl"},
155 {CNTX_LINE_TIME, AP1302_REG32, "line_time"},
156 {CNTX_MAX_FPS, AP1302_REG16, "max_fps"},
157 {CNTX_AE_USG, AP1302_REG16, "ae_usg"},
158 {CNTX_AE_UPPER_ET, AP1302_REG32, "ae_upper_et"},
159 {CNTX_AE_MAX_ET, AP1302_REG32, "ae_max_et"},
160 {CNTX_SS, AP1302_REG16, "ss"},
161 {CNTX_S1_SENSOR_MODE, AP1302_REG16, "s1_sensor_mode"},
162 {CNTX_HINF_CTRL, AP1302_REG16, "hinf_ctrl"},
163};
164
165
166
167
168static u16 ap1302_ss_list[] = {
169 0xb01c,
170 0x0186,
171 0xb002,
172 0x71c0,
173 0xb010,
174 0x03dc,
175 0xb0a0,
176 0x03e4,
177 0xb020,
178 0x0604,
179 0x0000
180};
181
182
183
184static int ap1302_i2c_read_reg(struct v4l2_subdev *sd,
185 u16 reg, u16 len, void *val)
186{
187 struct ap1302_device *dev = to_ap1302_device(sd);
188 struct i2c_client *client = v4l2_get_subdevdata(sd);
189 int ret;
190
191 if (len == AP1302_REG16)
192 ret = regmap_read(dev->regmap16, reg, val);
193 else if (len == AP1302_REG32)
194 ret = regmap_read(dev->regmap32, reg, val);
195 else
196 ret = -EINVAL;
197 if (ret) {
198 dev_dbg(&client->dev, "Read reg failed. reg=0x%04X\n", reg);
199 return ret;
200 }
201 if (len == AP1302_REG16)
202 dev_dbg(&client->dev, "read_reg[0x%04X] = 0x%04X\n",
203 reg, *(u16 *)val);
204 else
205 dev_dbg(&client->dev, "read_reg[0x%04X] = 0x%08X\n",
206 reg, *(u32 *)val);
207 return ret;
208}
209
210static int ap1302_i2c_write_reg(struct v4l2_subdev *sd,
211 u16 reg, u16 len, u32 val)
212{
213 struct ap1302_device *dev = to_ap1302_device(sd);
214 struct i2c_client *client = v4l2_get_subdevdata(sd);
215 int ret;
216 if (len == AP1302_REG16)
217 ret = regmap_write(dev->regmap16, reg, val);
218 else if (len == AP1302_REG32)
219 ret = regmap_write(dev->regmap32, reg, val);
220 else
221 ret = -EINVAL;
222 if (ret) {
223 dev_dbg(&client->dev, "Write reg failed. reg=0x%04X\n", reg);
224 return ret;
225 }
226 if (len == AP1302_REG16)
227 dev_dbg(&client->dev, "write_reg[0x%04X] = 0x%04X\n",
228 reg, (u16)val);
229 else
230 dev_dbg(&client->dev, "write_reg[0x%04X] = 0x%08X\n",
231 reg, (u32)val);
232 return ret;
233}
234
235static u16
236ap1302_calculate_context_reg_addr(enum ap1302_contexts context, u16 offset)
237{
238 u16 reg_addr;
239
240
241
242
243
244 if (context == CONTEXT_SNAPSHOT) {
245 if (offset == CNTX_S1_SENSOR_MODE)
246 return 0;
247 if (offset > CNTX_S1_SENSOR_MODE)
248 offset -= 2;
249 }
250 if (context == CONTEXT_PREVIEW)
251 reg_addr = REG_PREVIEW_BASE + offset;
252 else if (context == CONTEXT_VIDEO)
253 reg_addr = REG_VIDEO_BASE + offset;
254 else
255 reg_addr = REG_SNAPSHOT_BASE + offset;
256 return reg_addr;
257}
258
259static int ap1302_read_context_reg(struct v4l2_subdev *sd,
260 enum ap1302_contexts context, u16 offset, u16 len)
261{
262 struct ap1302_device *dev = to_ap1302_device(sd);
263 u16 reg_addr = ap1302_calculate_context_reg_addr(context, offset);
264 if (reg_addr == 0)
265 return -EINVAL;
266 return ap1302_i2c_read_reg(sd, reg_addr, len,
267 ((u8 *)&dev->cntx_config[context]) + offset);
268}
269
270static int ap1302_write_context_reg(struct v4l2_subdev *sd,
271 enum ap1302_contexts context, u16 offset, u16 len)
272{
273 struct ap1302_device *dev = to_ap1302_device(sd);
274 u16 reg_addr = ap1302_calculate_context_reg_addr(context, offset);
275 if (reg_addr == 0)
276 return -EINVAL;
277 return ap1302_i2c_write_reg(sd, reg_addr, len,
278 *(u32 *)(((u8 *)&dev->cntx_config[context]) + offset));
279}
280
281static int ap1302_dump_context_reg(struct v4l2_subdev *sd,
282 enum ap1302_contexts context)
283{
284 struct i2c_client *client = v4l2_get_subdevdata(sd);
285 struct ap1302_device *dev = to_ap1302_device(sd);
286 int i;
287 dev_dbg(&client->dev, "Dump registers for context[%d]:\n", context);
288 for (i = 0; i < ARRAY_SIZE(context_info); i++) {
289 struct ap1302_context_info *info = &context_info[i];
290 u8 *var = (u8 *)&dev->cntx_config[context] + info->offset;
291
292 if (context == CONTEXT_SNAPSHOT &&
293 info->offset == CNTX_S1_SENSOR_MODE)
294 continue;
295 ap1302_read_context_reg(sd, context, info->offset, info->len);
296 if (info->len == AP1302_REG16)
297 dev_dbg(&client->dev, "context.%s = 0x%04X (%d)\n",
298 info->name, *(u16 *)var, *(u16 *)var);
299 else
300 dev_dbg(&client->dev, "context.%s = 0x%08X (%d)\n",
301 info->name, *(u32 *)var, *(u32 *)var);
302 }
303 return 0;
304}
305
306static int ap1302_request_firmware(struct v4l2_subdev *sd)
307{
308 struct i2c_client *client = v4l2_get_subdevdata(sd);
309 struct ap1302_device *dev = to_ap1302_device(sd);
310 int ret;
311 ret = request_firmware(&dev->fw, "ap1302_fw.bin", &client->dev);
312 if (ret)
313 dev_err(&client->dev,
314 "ap1302_request_firmware failed. ret=%d\n", ret);
315 return ret;
316}
317
318
319
320
321
322
323
324static int ap1302_write_fw_window(struct v4l2_subdev *sd,
325 u16 *win_pos, const u8 *buf, u32 len)
326{
327 struct ap1302_device *dev = to_ap1302_device(sd);
328 int ret;
329 u32 pos;
330 u32 sub_len;
331 for (pos = 0; pos < len; pos += sub_len) {
332 if (len - pos < AP1302_FW_WINDOW_SIZE - *win_pos)
333 sub_len = len - pos;
334 else
335 sub_len = AP1302_FW_WINDOW_SIZE - *win_pos;
336 ret = regmap_raw_write(dev->regmap16,
337 *win_pos + AP1302_FW_WINDOW_OFFSET,
338 buf + pos, sub_len);
339 if (ret)
340 return ret;
341 *win_pos += sub_len;
342 if (*win_pos >= AP1302_FW_WINDOW_SIZE)
343 *win_pos = 0;
344 }
345 return 0;
346}
347
348static int ap1302_load_firmware(struct v4l2_subdev *sd)
349{
350 struct i2c_client *client = v4l2_get_subdevdata(sd);
351 struct ap1302_device *dev = to_ap1302_device(sd);
352 const struct ap1302_firmware *fw;
353 const u8 *fw_data;
354 u16 reg_val = 0;
355 u16 win_pos = 0;
356 int ret;
357
358 dev_info(&client->dev, "Start to load firmware.\n");
359 if (!dev->fw) {
360 dev_err(&client->dev, "firmware not requested.\n");
361 return -EINVAL;
362 }
363 fw = (const struct ap1302_firmware *) dev->fw->data;
364 if (dev->fw->size != (sizeof(*fw) + fw->total_size)) {
365 dev_err(&client->dev, "firmware size does not match.\n");
366 return -EINVAL;
367 }
368
369
370
371 fw_data = (u8 *)&fw[1];
372
373
374 ret = ap1302_i2c_write_reg(sd, REG_SIP_CRC, AP1302_REG16, 0xFFFF);
375 if (ret)
376 return ret;
377
378
379 ret = ap1302_write_fw_window(sd, &win_pos, fw_data, fw->pll_init_size);
380 if (ret)
381 return ret;
382
383
384
385 ret = ap1302_i2c_write_reg(sd, REG_BOOTDATA_STAGE,
386 AP1302_REG16, 0x0002);
387 if (ret)
388 return ret;
389
390
391 msleep(20);
392
393
394 ret = ap1302_write_fw_window(sd, &win_pos, fw_data + fw->pll_init_size,
395 fw->total_size - fw->pll_init_size);
396 if (ret)
397 return ret;
398
399
400 ret = ap1302_i2c_read_reg(sd, REG_SIP_CRC, AP1302_REG16, ®_val);
401 if (ret)
402 return ret;
403 if (reg_val != fw->crc) {
404 dev_err(&client->dev,
405 "crc does not match. T:0x%04X F:0x%04X\n",
406 fw->crc, reg_val);
407 return -EAGAIN;
408 }
409
410
411
412 ret = ap1302_i2c_write_reg(sd, REG_BOOTDATA_STAGE,
413 AP1302_REG16, 0xFFFF);
414 if (ret)
415 return ret;
416 dev_info(&client->dev, "Load firmware successfully.\n");
417
418 return 0;
419}
420
421static int __ap1302_s_power(struct v4l2_subdev *sd, int on, int load_fw)
422{
423 struct ap1302_device *dev = to_ap1302_device(sd);
424 struct i2c_client *client = v4l2_get_subdevdata(sd);
425 int ret, i;
426 u16 ss_ptr;
427
428 dev_info(&client->dev, "ap1302_s_power is called.\n");
429 ret = dev->platform_data->power_ctrl(sd, on);
430 if (ret) {
431 dev_err(&client->dev,
432 "ap1302_s_power error. on=%d ret=%d\n", on, ret);
433 return ret;
434 }
435 dev->power_on = on;
436 if (!on || !load_fw)
437 return 0;
438
439 ret = ap1302_load_firmware(sd);
440 if (ret) {
441 dev_err(&client->dev,
442 "ap1302_load_firmware failed. ret=%d\n", ret);
443 return ret;
444 }
445 ret = ap1302_i2c_read_reg(sd, REG_SS_HEAD_PT0, AP1302_REG16, &ss_ptr);
446 if (ret)
447 return ret;
448 for (i = 0; i < ARRAY_SIZE(ap1302_ss_list); i++) {
449 ret = ap1302_i2c_write_reg(sd, ss_ptr + i * 2,
450 AP1302_REG16, ap1302_ss_list[i]);
451 if (ret)
452 return ret;
453 }
454 return ret;
455}
456
457static int ap1302_s_power(struct v4l2_subdev *sd, int on)
458{
459 struct ap1302_device *dev = to_ap1302_device(sd);
460 int ret;
461
462 mutex_lock(&dev->input_lock);
463 ret = __ap1302_s_power(sd, on, 1);
464 dev->sys_activated = 0;
465 mutex_unlock(&dev->input_lock);
466
467 return ret;
468}
469
470static int ap1302_s_config(struct v4l2_subdev *sd, void *pdata)
471{
472 struct ap1302_device *dev = to_ap1302_device(sd);
473 struct i2c_client *client = v4l2_get_subdevdata(sd);
474 struct camera_mipi_info *mipi_info;
475 u16 reg_val = 0;
476 int ret;
477
478 dev_info(&client->dev, "ap1302_s_config is called.\n");
479 if (pdata == NULL)
480 return -ENODEV;
481
482 dev->platform_data = pdata;
483
484 mutex_lock(&dev->input_lock);
485
486 if (dev->platform_data->platform_init) {
487 ret = dev->platform_data->platform_init(client);
488 if (ret)
489 goto fail_power;
490 }
491
492 ret = __ap1302_s_power(sd, 1, 0);
493 if (ret)
494 goto fail_power;
495
496
497 ret = ap1302_i2c_read_reg(sd, REG_CHIP_VERSION, AP1302_REG16, ®_val);
498 if (ret || (reg_val != AP1302_CHIP_ID)) {
499 dev_err(&client->dev,
500 "Chip version does no match. ret=%d ver=0x%04x\n",
501 ret, reg_val);
502 goto fail_config;
503 }
504 dev_info(&client->dev, "AP1302 Chip ID is 0x%X\n", reg_val);
505
506
507 ret = ap1302_i2c_read_reg(sd, REG_CHIP_REV, AP1302_REG16, ®_val);
508 if (ret)
509 goto fail_config;
510 dev_info(&client->dev, "AP1302 Chip Rev is 0x%X\n", reg_val);
511 ret = dev->platform_data->csi_cfg(sd, 1);
512 if (ret)
513 goto fail_config;
514
515 mipi_info = v4l2_get_subdev_hostdata(sd);
516 if (!mipi_info)
517 goto fail_config;
518 dev->num_lanes = mipi_info->num_lanes;
519
520 ret = __ap1302_s_power(sd, 0, 0);
521 if (ret)
522 goto fail_power;
523
524 mutex_unlock(&dev->input_lock);
525
526 return ret;
527
528fail_config:
529 __ap1302_s_power(sd, 0, 0);
530fail_power:
531 mutex_unlock(&dev->input_lock);
532 dev_err(&client->dev, "ap1302_s_config failed\n");
533 return ret;
534}
535
536static enum ap1302_contexts ap1302_get_context(struct v4l2_subdev *sd)
537{
538 struct ap1302_device *dev = to_ap1302_device(sd);
539 return dev->cur_context;
540}
541
542static int ap1302_enum_mbus_code(struct v4l2_subdev *sd,
543 struct v4l2_subdev_pad_config *cfg,
544 struct v4l2_subdev_mbus_code_enum *code)
545{
546 if (code->index)
547 return -EINVAL;
548
549 code->code = MEDIA_BUS_FMT_UYVY8_1X16;
550
551 return 0;
552}
553
554static int ap1302_match_resolution(struct ap1302_context_res *res,
555 struct v4l2_mbus_framefmt *fmt)
556{
557 s32 w0, h0, mismatch, distance;
558 s32 w1 = fmt->width;
559 s32 h1 = fmt->height;
560 s32 min_distance = INT_MAX;
561 s32 i, idx = -1;
562
563 if (w1 == 0 || h1 == 0)
564 return -1;
565
566 for (i = 0; i < res->res_num; i++) {
567 w0 = res->res_table[i].width;
568 h0 = res->res_table[i].height;
569 if (w0 < w1 || h0 < h1)
570 continue;
571 mismatch = abs(w0 * h1 - w1 * h0) * 8192 / w1 / h0;
572 if (mismatch > 8192 * AP1302_MAX_RATIO_MISMATCH / 100)
573 continue;
574 distance = (w0 * h1 + w1 * h0) * 8192 / w1 / h1;
575 if (distance < min_distance) {
576 min_distance = distance;
577 idx = i;
578 }
579 }
580
581 return idx;
582}
583
584static s32 ap1302_try_mbus_fmt_locked(struct v4l2_subdev *sd,
585 enum ap1302_contexts context,
586 struct v4l2_mbus_framefmt *fmt)
587{
588 struct ap1302_device *dev = to_ap1302_device(sd);
589 struct ap1302_res_struct *res_table;
590 s32 res_num, idx = -1;
591
592 res_table = dev->cntx_res[context].res_table;
593 res_num = dev->cntx_res[context].res_num;
594
595 if ((fmt->width <= res_table[res_num - 1].width) &&
596 (fmt->height <= res_table[res_num - 1].height))
597 idx = ap1302_match_resolution(&dev->cntx_res[context], fmt);
598 if (idx == -1)
599 idx = res_num - 1;
600
601 fmt->width = res_table[idx].width;
602 fmt->height = res_table[idx].height;
603 fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
604 return idx;
605}
606
607
608static int ap1302_get_fmt(struct v4l2_subdev *sd,
609 struct v4l2_subdev_pad_config *cfg,
610 struct v4l2_subdev_format *format)
611
612{
613 struct v4l2_mbus_framefmt *fmt = &format->format;
614 struct ap1302_device *dev = to_ap1302_device(sd);
615 enum ap1302_contexts context;
616 struct ap1302_res_struct *res_table;
617 s32 cur_res;
618 if (format->pad)
619 return -EINVAL;
620 mutex_lock(&dev->input_lock);
621 context = ap1302_get_context(sd);
622 res_table = dev->cntx_res[context].res_table;
623 cur_res = dev->cntx_res[context].cur_res;
624 fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
625 fmt->width = res_table[cur_res].width;
626 fmt->height = res_table[cur_res].height;
627 mutex_unlock(&dev->input_lock);
628 return 0;
629}
630
631static int ap1302_set_fmt(struct v4l2_subdev *sd,
632 struct v4l2_subdev_pad_config *cfg,
633 struct v4l2_subdev_format *format)
634{
635 struct v4l2_mbus_framefmt *fmt = &format->format;
636 struct ap1302_device *dev = to_ap1302_device(sd);
637 struct i2c_client *client = v4l2_get_subdevdata(sd);
638 struct atomisp_input_stream_info *stream_info =
639 (struct atomisp_input_stream_info *)fmt->reserved;
640 enum ap1302_contexts context, main_context;
641 if (format->pad)
642 return -EINVAL;
643 if (!fmt)
644 return -EINVAL;
645 mutex_lock(&dev->input_lock);
646 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
647 context = ap1302_get_context(sd);
648 ap1302_try_mbus_fmt_locked(sd, context, fmt);
649 cfg->try_fmt = *fmt;
650 mutex_unlock(&dev->input_lock);
651 return 0;
652 }
653 context = stream_to_context[stream_info->stream];
654 dev_dbg(&client->dev, "ap1302_set_mbus_fmt. stream=%d context=%d\n",
655 stream_info->stream, context);
656 dev->cntx_res[context].cur_res =
657 ap1302_try_mbus_fmt_locked(sd, context, fmt);
658 dev->cntx_config[context].width = fmt->width;
659 dev->cntx_config[context].height = fmt->height;
660 ap1302_write_context_reg(sd, context, CNTX_WIDTH, AP1302_REG16);
661 ap1302_write_context_reg(sd, context, CNTX_HEIGHT, AP1302_REG16);
662 ap1302_read_context_reg(sd, context, CNTX_OUT_FMT, AP1302_REG16);
663 dev->cntx_config[context].out_fmt &= ~OUT_FMT_TYPE_MASK;
664 dev->cntx_config[context].out_fmt |= AP1302_FMT_UYVY422;
665 ap1302_write_context_reg(sd, context, CNTX_OUT_FMT, AP1302_REG16);
666
667 main_context = ap1302_get_context(sd);
668 if (context == main_context) {
669 ap1302_read_context_reg(sd, context,
670 CNTX_MIPI_CTRL, AP1302_REG16);
671 dev->cntx_config[context].mipi_ctrl &= ~MIPI_CTRL_IMGVC_MASK;
672 dev->cntx_config[context].mipi_ctrl |=
673 (context << MIPI_CTRL_IMGVC_OFFSET);
674 dev->cntx_config[context].mipi_ctrl &= ~MIPI_CTRL_SSVC_MASK;
675 dev->cntx_config[context].mipi_ctrl |=
676 (context << MIPI_CTRL_SSVC_OFFSET);
677 dev->cntx_config[context].mipi_ctrl &= ~MIPI_CTRL_SSTYPE_MASK;
678 dev->cntx_config[context].mipi_ctrl |=
679 (0x12 << MIPI_CTRL_SSTYPE_OFFSET);
680 ap1302_write_context_reg(sd, context,
681 CNTX_MIPI_CTRL, AP1302_REG16);
682 ap1302_read_context_reg(sd, context,
683 CNTX_SS, AP1302_REG16);
684 dev->cntx_config[context].ss = AP1302_SS_CTRL;
685 ap1302_write_context_reg(sd, context,
686 CNTX_SS, AP1302_REG16);
687 } else {
688
689 ap1302_read_context_reg(sd, context,
690 CNTX_MIPI_II_CTRL, AP1302_REG16);
691 dev->cntx_config[context].mipi_ii_ctrl &= ~MIPI_CTRL_IMGVC_MASK;
692 dev->cntx_config[context].mipi_ii_ctrl |=
693 (context << MIPI_CTRL_IMGVC_OFFSET);
694 ap1302_write_context_reg(sd, context,
695 CNTX_MIPI_II_CTRL, AP1302_REG16);
696 if (stream_info->enable) {
697 ap1302_read_context_reg(sd, main_context,
698 CNTX_OUT_FMT, AP1302_REG16);
699 dev->cntx_config[context].out_fmt |=
700 (aux_stream_config[main_context][context]
701 << OUT_FMT_IIS_OFFSET);
702 ap1302_write_context_reg(sd, main_context,
703 CNTX_OUT_FMT, AP1302_REG16);
704 }
705 }
706 stream_info->ch_id = context;
707 mutex_unlock(&dev->input_lock);
708
709 return 0;
710}
711
712
713static int ap1302_g_frame_interval(struct v4l2_subdev *sd,
714 struct v4l2_subdev_frame_interval *interval)
715{
716 struct ap1302_device *dev = to_ap1302_device(sd);
717 enum ap1302_contexts context;
718 struct ap1302_res_struct *res_table;
719 u32 cur_res;
720
721 mutex_lock(&dev->input_lock);
722 context = ap1302_get_context(sd);
723 res_table = dev->cntx_res[context].res_table;
724 cur_res = dev->cntx_res[context].cur_res;
725 interval->interval.denominator = res_table[cur_res].fps;
726 interval->interval.numerator = 1;
727 mutex_unlock(&dev->input_lock);
728 return 0;
729}
730
731static int ap1302_enum_frame_size(struct v4l2_subdev *sd,
732 struct v4l2_subdev_pad_config *cfg,
733 struct v4l2_subdev_frame_size_enum *fse)
734{
735 struct ap1302_device *dev = to_ap1302_device(sd);
736 enum ap1302_contexts context;
737 struct ap1302_res_struct *res_table;
738 int index = fse->index;
739
740 mutex_lock(&dev->input_lock);
741 context = ap1302_get_context(sd);
742 if (index >= dev->cntx_res[context].res_num) {
743 mutex_unlock(&dev->input_lock);
744 return -EINVAL;
745 }
746
747 res_table = dev->cntx_res[context].res_table;
748 fse->min_width = res_table[index].width;
749 fse->min_height = res_table[index].height;
750 fse->max_width = res_table[index].width;
751 fse->max_height = res_table[index].height;
752 mutex_unlock(&dev->input_lock);
753
754 return 0;
755}
756
757
758static int ap1302_g_skip_frames(struct v4l2_subdev *sd, u32 *frames)
759{
760 *frames = 0;
761 return 0;
762}
763
764static int ap1302_s_stream(struct v4l2_subdev *sd, int enable)
765{
766 struct ap1302_device *dev = to_ap1302_device(sd);
767 struct i2c_client *client = v4l2_get_subdevdata(sd);
768 enum ap1302_contexts context;
769 u32 reg_val;
770 int ret;
771
772 mutex_lock(&dev->input_lock);
773 context = ap1302_get_context(sd);
774 dev_dbg(&client->dev, "ap1302_s_stream. context=%d enable=%d\n",
775 context, enable);
776
777 ap1302_i2c_read_reg(sd, REG_CTRL,
778 AP1302_REG16, ®_val);
779 reg_val &= ~CTRL_CNTX_MASK;
780 reg_val |= (context<<CTRL_CNTX_OFFSET);
781 ap1302_i2c_write_reg(sd, REG_CTRL,
782 AP1302_REG16, reg_val);
783
784 ap1302_i2c_read_reg(sd, REG_SENSOR_SELECT,
785 AP1302_REG16, ®_val);
786 reg_val &= ~SENSOR_SELECT_MASK;
787 reg_val |= (AP1302_SENSOR_PRI<<SENSOR_SELECT_OFFSET);
788 ap1302_i2c_write_reg(sd, REG_SENSOR_SELECT,
789 AP1302_REG16, reg_val);
790 if (enable) {
791 dev_info(&client->dev, "Start stream. context=%d\n", context);
792 ap1302_dump_context_reg(sd, context);
793 if (!dev->sys_activated) {
794 reg_val = AP1302_SYS_ACTIVATE;
795 dev->sys_activated = 1;
796 } else {
797 reg_val = AP1302_SYS_SWITCH;
798 }
799 } else {
800 dev_info(&client->dev, "Stop stream. context=%d\n", context);
801 reg_val = AP1302_SYS_SWITCH;
802 }
803 ret = ap1302_i2c_write_reg(sd, REG_SYS_START, AP1302_REG16, reg_val);
804 if (ret)
805 dev_err(&client->dev,
806 "AP1302 set stream failed. enable=%d\n", enable);
807 mutex_unlock(&dev->input_lock);
808 return ret;
809}
810
811static u16 ap1302_ev_values[] = {0xfd00, 0xfe80, 0x0, 0x180, 0x300};
812
813static int ap1302_set_exposure_off(struct v4l2_subdev *sd, s32 val)
814{
815 val -= AP1302_MIN_EV;
816 return ap1302_i2c_write_reg(sd, REG_AE_BV_OFF, AP1302_REG16,
817 ap1302_ev_values[val]);
818}
819
820static u16 ap1302_wb_values[] = {
821 0,
822 0xf,
823 0x2,
824 0x4,
825 0x5,
826 0x1,
827 0x5,
828 0xf,
829 0x6,
830 0x6,
831};
832
833static int ap1302_set_wb_mode(struct v4l2_subdev *sd, s32 val)
834{
835 int ret = 0;
836 u16 reg_val;
837
838 ret = ap1302_i2c_read_reg(sd, REG_AWB_CTRL, AP1302_REG16, ®_val);
839 if (ret)
840 return ret;
841 reg_val &= ~AWB_CTRL_MODE_MASK;
842 reg_val |= ap1302_wb_values[val] << AWB_CTRL_MODE_OFFSET;
843 if (val == V4L2_WHITE_BALANCE_FLASH)
844 reg_val |= AWB_CTRL_FLASH_MASK;
845 else
846 reg_val &= ~AWB_CTRL_FLASH_MASK;
847 ret = ap1302_i2c_write_reg(sd, REG_AWB_CTRL, AP1302_REG16, reg_val);
848 return ret;
849}
850
851static int ap1302_set_zoom(struct v4l2_subdev *sd, s32 val)
852{
853 ap1302_i2c_write_reg(sd, REG_DZ_TGT_FCT, AP1302_REG16,
854 val * 4 + 0x100);
855 return 0;
856}
857
858static u16 ap1302_sfx_values[] = {
859 0x00,
860 0x03,
861 0x0d,
862 0x07,
863 0x04,
864 0x0f,
865 0x08,
866 0x09,
867 0x0a,
868 0x00,
869 0x00,
870 0x00,
871 0x00,
872 0x10,
873 0x02,
874 0x00,
875};
876
877static int ap1302_set_special_effect(struct v4l2_subdev *sd, s32 val)
878{
879 ap1302_i2c_write_reg(sd, REG_SFX_MODE, AP1302_REG16,
880 ap1302_sfx_values[val]);
881 return 0;
882}
883
884static u16 ap1302_scene_mode_values[] = {
885 0x00,
886 0x07,
887 0x0a,
888 0x06,
889 0x00,
890 0x00,
891 0x0d,
892 0x02,
893 0x05,
894 0x0c,
895 0x01,
896 0x03,
897 0x0e,
898 0x0b,
899};
900
901static int ap1302_set_scene_mode(struct v4l2_subdev *sd, s32 val)
902{
903 ap1302_i2c_write_reg(sd, REG_SCENE_CTRL, AP1302_REG16,
904 ap1302_scene_mode_values[val]);
905 return 0;
906}
907
908static u16 ap1302_flicker_values[] = {
909 0x0,
910 0x3201,
911 0x3c01,
912 0x2
913};
914
915static int ap1302_set_flicker_freq(struct v4l2_subdev *sd, s32 val)
916{
917 ap1302_i2c_write_reg(sd, REG_FLICK_CTRL, AP1302_REG16,
918 ap1302_flicker_values[val]);
919 return 0;
920}
921
922static int ap1302_s_ctrl(struct v4l2_ctrl *ctrl)
923{
924 struct ap1302_device *dev = container_of(
925 ctrl->handler, struct ap1302_device, ctrl_handler);
926
927 switch (ctrl->id) {
928 case V4L2_CID_RUN_MODE:
929 dev->cur_context = ap1302_cntx_mapping[ctrl->val];
930 break;
931 case V4L2_CID_EXPOSURE:
932 ap1302_set_exposure_off(&dev->sd, ctrl->val);
933 break;
934 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
935 ap1302_set_wb_mode(&dev->sd, ctrl->val);
936 break;
937 case V4L2_CID_ZOOM_ABSOLUTE:
938 ap1302_set_zoom(&dev->sd, ctrl->val);
939 break;
940 case V4L2_CID_COLORFX:
941 ap1302_set_special_effect(&dev->sd, ctrl->val);
942 break;
943 case V4L2_CID_SCENE_MODE:
944 ap1302_set_scene_mode(&dev->sd, ctrl->val);
945 break;
946 case V4L2_CID_POWER_LINE_FREQUENCY:
947 ap1302_set_flicker_freq(&dev->sd, ctrl->val);
948 break;
949 default:
950 return -EINVAL;
951 }
952
953 return 0;
954}
955
956static int ap1302_g_register(struct v4l2_subdev *sd,
957 struct v4l2_dbg_register *reg)
958{
959 struct ap1302_device *dev = to_ap1302_device(sd);
960 int ret;
961 u32 reg_val;
962
963 if (reg->size != AP1302_REG16 &&
964 reg->size != AP1302_REG32)
965 return -EINVAL;
966
967 mutex_lock(&dev->input_lock);
968 if (dev->power_on)
969 ret = ap1302_i2c_read_reg(sd, reg->reg, reg->size, ®_val);
970 else
971 ret = -EIO;
972 mutex_unlock(&dev->input_lock);
973 if (ret)
974 return ret;
975
976 reg->val = reg_val;
977
978 return 0;
979}
980
981static int ap1302_s_register(struct v4l2_subdev *sd,
982 const struct v4l2_dbg_register *reg)
983{
984 struct ap1302_device *dev = to_ap1302_device(sd);
985 int ret;
986
987 if (reg->size != AP1302_REG16 &&
988 reg->size != AP1302_REG32)
989 return -EINVAL;
990
991 mutex_lock(&dev->input_lock);
992 if (dev->power_on)
993 ret = ap1302_i2c_write_reg(sd, reg->reg, reg->size, reg->val);
994 else
995 ret = -EIO;
996 mutex_unlock(&dev->input_lock);
997 return ret;
998}
999
1000static long ap1302_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1001{
1002 long ret = 0;
1003 switch (cmd) {
1004 case VIDIOC_DBG_G_REGISTER:
1005 ret = ap1302_g_register(sd, arg);
1006 break;
1007 case VIDIOC_DBG_S_REGISTER:
1008 ret = ap1302_s_register(sd, arg);
1009 break;
1010 default:
1011 ret = -EINVAL;
1012 }
1013 return ret;
1014}
1015
1016static const struct v4l2_ctrl_ops ctrl_ops = {
1017 .s_ctrl = ap1302_s_ctrl,
1018};
1019
1020static const char * const ctrl_run_mode_menu[] = {
1021 NULL,
1022 "Video",
1023 "Still capture",
1024 "Continuous capture",
1025 "Preview",
1026};
1027
1028static const struct v4l2_ctrl_config ctrls[] = {
1029 {
1030 .ops = &ctrl_ops,
1031 .id = V4L2_CID_RUN_MODE,
1032 .name = "Run Mode",
1033 .type = V4L2_CTRL_TYPE_MENU,
1034 .min = 1,
1035 .def = 4,
1036 .max = 4,
1037 .qmenu = ctrl_run_mode_menu,
1038 },
1039 {
1040 .ops = &ctrl_ops,
1041 .id = V4L2_CID_EXPOSURE,
1042 .name = "Exposure",
1043 .type = V4L2_CTRL_TYPE_INTEGER,
1044 .min = AP1302_MIN_EV,
1045 .def = 0,
1046 .max = AP1302_MAX_EV,
1047 .step = 1,
1048 },
1049 {
1050 .ops = &ctrl_ops,
1051 .id = V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
1052 .name = "White Balance",
1053 .type = V4L2_CTRL_TYPE_INTEGER,
1054 .min = 0,
1055 .def = 0,
1056 .max = 9,
1057 .step = 1,
1058 },
1059 {
1060 .ops = &ctrl_ops,
1061 .id = V4L2_CID_ZOOM_ABSOLUTE,
1062 .name = "Zoom Absolute",
1063 .type = V4L2_CTRL_TYPE_INTEGER,
1064 .min = 0,
1065 .def = 0,
1066 .max = 1024,
1067 .step = 1,
1068 },
1069 {
1070 .ops = &ctrl_ops,
1071 .id = V4L2_CID_COLORFX,
1072 .name = "Color Special Effect",
1073 .type = V4L2_CTRL_TYPE_INTEGER,
1074 .min = 0,
1075 .def = 0,
1076 .max = 15,
1077 .step = 1,
1078 },
1079 {
1080 .ops = &ctrl_ops,
1081 .id = V4L2_CID_SCENE_MODE,
1082 .name = "Scene Mode",
1083 .type = V4L2_CTRL_TYPE_INTEGER,
1084 .min = 0,
1085 .def = 0,
1086 .max = 13,
1087 .step = 1,
1088 },
1089 {
1090 .ops = &ctrl_ops,
1091 .id = V4L2_CID_POWER_LINE_FREQUENCY,
1092 .name = "Light frequency filter",
1093 .type = V4L2_CTRL_TYPE_INTEGER,
1094 .min = 0,
1095 .def = 3,
1096 .max = 3,
1097 .step = 1,
1098 },
1099};
1100
1101static struct v4l2_subdev_sensor_ops ap1302_sensor_ops = {
1102 .g_skip_frames = ap1302_g_skip_frames,
1103};
1104
1105static const struct v4l2_subdev_video_ops ap1302_video_ops = {
1106 .s_stream = ap1302_s_stream,
1107 .g_frame_interval = ap1302_g_frame_interval,
1108};
1109
1110static const struct v4l2_subdev_core_ops ap1302_core_ops = {
1111 .s_power = ap1302_s_power,
1112 .ioctl = ap1302_ioctl,
1113#ifdef CONFIG_VIDEO_ADV_DEBUG
1114 .g_register = ap1302_g_register,
1115 .s_register = ap1302_s_register,
1116#endif
1117};
1118
1119static const struct v4l2_subdev_pad_ops ap1302_pad_ops = {
1120 .enum_mbus_code = ap1302_enum_mbus_code,
1121 .enum_frame_size = ap1302_enum_frame_size,
1122 .get_fmt = ap1302_get_fmt,
1123 .set_fmt = ap1302_set_fmt,
1124};
1125
1126static const struct v4l2_subdev_ops ap1302_ops = {
1127 .core = &ap1302_core_ops,
1128 .pad = &ap1302_pad_ops,
1129 .video = &ap1302_video_ops,
1130 .sensor = &ap1302_sensor_ops
1131};
1132
1133static int ap1302_remove(struct i2c_client *client)
1134{
1135 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1136 struct ap1302_device *dev = to_ap1302_device(sd);
1137
1138 if (dev->platform_data->platform_deinit)
1139 dev->platform_data->platform_deinit();
1140
1141 release_firmware(dev->fw);
1142
1143 media_entity_cleanup(&dev->sd.entity);
1144 dev->platform_data->csi_cfg(sd, 0);
1145 v4l2_device_unregister_subdev(sd);
1146
1147 return 0;
1148}
1149
1150static int ap1302_probe(struct i2c_client *client,
1151 const struct i2c_device_id *id)
1152{
1153 struct ap1302_device *dev;
1154 int ret;
1155 unsigned int i;
1156
1157 dev_info(&client->dev, "ap1302 probe called.\n");
1158
1159
1160 dev = devm_kzalloc(&client->dev, sizeof(*dev), GFP_KERNEL);
1161 if (!dev) {
1162 dev_err(&client->dev, "%s: out of memory\n", __func__);
1163 return -ENOMEM;
1164 }
1165
1166 mutex_init(&dev->input_lock);
1167
1168 v4l2_i2c_subdev_init(&(dev->sd), client, &ap1302_ops);
1169
1170 ret = ap1302_request_firmware(&(dev->sd));
1171 if (ret) {
1172 dev_err(&client->dev, "Cannot request ap1302 firmware.\n");
1173 goto out_free;
1174 }
1175
1176 dev->regmap16 = devm_regmap_init_i2c(client, &ap1302_reg16_config);
1177 if (IS_ERR(dev->regmap16)) {
1178 ret = PTR_ERR(dev->regmap16);
1179 dev_err(&client->dev,
1180 "Failed to allocate 16bit register map: %d\n", ret);
1181 return ret;
1182 }
1183
1184 dev->regmap32 = devm_regmap_init_i2c(client, &ap1302_reg32_config);
1185 if (IS_ERR(dev->regmap32)) {
1186 ret = PTR_ERR(dev->regmap32);
1187 dev_err(&client->dev,
1188 "Failed to allocate 32bit register map: %d\n", ret);
1189 return ret;
1190 }
1191
1192 if (client->dev.platform_data) {
1193 ret = ap1302_s_config(&dev->sd, client->dev.platform_data);
1194 if (ret)
1195 goto out_free;
1196 }
1197
1198 dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1199 dev->pad.flags = MEDIA_PAD_FL_SOURCE;
1200 dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1201
1202 dev->cntx_res[CONTEXT_PREVIEW].res_num = ARRAY_SIZE(ap1302_preview_res);
1203 dev->cntx_res[CONTEXT_PREVIEW].res_table = ap1302_preview_res;
1204 dev->cntx_res[CONTEXT_SNAPSHOT].res_num =
1205 ARRAY_SIZE(ap1302_snapshot_res);
1206 dev->cntx_res[CONTEXT_SNAPSHOT].res_table = ap1302_snapshot_res;
1207 dev->cntx_res[CONTEXT_VIDEO].res_num = ARRAY_SIZE(ap1302_video_res);
1208 dev->cntx_res[CONTEXT_VIDEO].res_table = ap1302_video_res;
1209
1210 ret = v4l2_ctrl_handler_init(&dev->ctrl_handler, ARRAY_SIZE(ctrls));
1211 if (ret) {
1212 ap1302_remove(client);
1213 return ret;
1214 }
1215
1216 for (i = 0; i < ARRAY_SIZE(ctrls); i++)
1217 v4l2_ctrl_new_custom(&dev->ctrl_handler, &ctrls[i], NULL);
1218
1219 if (dev->ctrl_handler.error) {
1220 ap1302_remove(client);
1221 return dev->ctrl_handler.error;
1222 }
1223
1224
1225 dev->ctrl_handler.lock = &dev->input_lock;
1226 dev->sd.ctrl_handler = &dev->ctrl_handler;
1227 v4l2_ctrl_handler_setup(&dev->ctrl_handler);
1228
1229 dev->run_mode = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_RUN_MODE);
1230 v4l2_ctrl_s_ctrl(dev->run_mode, ATOMISP_RUN_MODE_PREVIEW);
1231
1232 ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad);
1233 if (ret)
1234 ap1302_remove(client);
1235 return ret;
1236out_free:
1237 v4l2_device_unregister_subdev(&dev->sd);
1238 return ret;
1239}
1240
1241static const struct i2c_device_id ap1302_id[] = {
1242 {AP1302_NAME, 0},
1243 {}
1244};
1245MODULE_DEVICE_TABLE(i2c, ap1302_id);
1246
1247static struct i2c_driver ap1302_driver = {
1248 .driver = {
1249 .name = AP1302_NAME,
1250 },
1251 .probe = ap1302_probe,
1252 .remove = ap1302_remove,
1253 .id_table = ap1302_id,
1254};
1255
1256module_i2c_driver(ap1302_driver);
1257
1258MODULE_AUTHOR("Tianshu Qiu <tian.shu.qiu@intel.com>");
1259MODULE_DESCRIPTION("AP1302 Driver");
1260MODULE_LICENSE("GPL");
1261
