1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/errno.h>
21#include <linux/firmware.h>
22#include <linux/pci.h>
23#include <linux/interrupt.h>
24#include <linux/io.h>
25#include <linux/kernel.h>
26#include <linux/kfifo.h>
27#include <linux/pm_runtime.h>
28#include <linux/timer.h>
29
30#include <asm/iosf_mbi.h>
31
32#include <media/v4l2-event.h>
33#include <media/videobuf-vmalloc.h>
34
35#define CREATE_TRACE_POINTS
36#include "atomisp_trace_event.h"
37
38#include "atomisp_cmd.h"
39#include "atomisp_common.h"
40#include "atomisp_fops.h"
41#include "atomisp_internal.h"
42#include "atomisp_ioctl.h"
43#include "atomisp-regs.h"
44#include "atomisp_tables.h"
45#include "atomisp_acc.h"
46#include "atomisp_compat.h"
47#include "atomisp_subdev.h"
48#include "atomisp_dfs_tables.h"
49
50#include <hmm/hmm.h>
51
52#include "sh_css_hrt.h"
53#include "sh_css_defs.h"
54#include "system_global.h"
55#include "sh_css_internal.h"
56#include "sh_css_sp.h"
57#include "gp_device.h"
58#include "device_access.h"
59#include "irq.h"
60
61#include "ia_css_types.h"
62#include "ia_css_stream.h"
63#include "ia_css_debug.h"
64#include "bits.h"
65
66
67
68
69
70
71#define FLASH_TIMEOUT 800
72
73union host {
74 struct {
75 void *kernel_ptr;
76 void __user *user_ptr;
77 int size;
78 } scalar;
79 struct {
80 void *hmm_ptr;
81 } ptr;
82};
83
84
85
86
87
88struct camera_mipi_info *atomisp_to_sensor_mipi_info(struct v4l2_subdev *sd)
89{
90 return (struct camera_mipi_info *)v4l2_get_subdev_hostdata(sd);
91}
92
93
94
95
96struct atomisp_video_pipe *atomisp_to_video_pipe(struct video_device *dev)
97{
98 return (struct atomisp_video_pipe *)
99 container_of(dev, struct atomisp_video_pipe, vdev);
100}
101
102
103
104
105struct atomisp_acc_pipe *atomisp_to_acc_pipe(struct video_device *dev)
106{
107 return (struct atomisp_acc_pipe *)
108 container_of(dev, struct atomisp_acc_pipe, vdev);
109}
110
111static unsigned short atomisp_get_sensor_fps(struct atomisp_sub_device *asd)
112{
113 struct v4l2_subdev_frame_interval fi = { 0 };
114 struct atomisp_device *isp = asd->isp;
115
116 unsigned short fps = 0;
117 int ret;
118
119 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
120 video, g_frame_interval, &fi);
121
122 if (!ret && fi.interval.numerator)
123 fps = fi.interval.denominator / fi.interval.numerator;
124
125 return fps;
126}
127
128
129
130
131
132
133
134
135
136
137
138
139static int write_target_freq_to_hw(struct atomisp_device *isp,
140 unsigned int new_freq)
141{
142 unsigned int ratio, timeout, guar_ratio;
143 u32 isp_sspm1 = 0;
144 int i;
145
146 if (!isp->hpll_freq) {
147 dev_err(isp->dev, "failed to get hpll_freq. no change to freq\n");
148 return -EINVAL;
149 }
150
151 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
152 if (isp_sspm1 & ISP_FREQ_VALID_MASK) {
153 dev_dbg(isp->dev, "clearing ISPSSPM1 valid bit.\n");
154 iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, ISPSSPM1,
155 isp_sspm1 & ~(1 << ISP_FREQ_VALID_OFFSET));
156 }
157
158 ratio = (2 * isp->hpll_freq + new_freq / 2) / new_freq - 1;
159 guar_ratio = (2 * isp->hpll_freq + 200 / 2) / 200 - 1;
160
161 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
162 isp_sspm1 &= ~(0x1F << ISP_REQ_FREQ_OFFSET);
163
164 for (i = 0; i < ISP_DFS_TRY_TIMES; i++) {
165 iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE, ISPSSPM1,
166 isp_sspm1
167 | ratio << ISP_REQ_FREQ_OFFSET
168 | 1 << ISP_FREQ_VALID_OFFSET
169 | guar_ratio << ISP_REQ_GUAR_FREQ_OFFSET);
170
171 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
172 timeout = 20;
173 while ((isp_sspm1 & ISP_FREQ_VALID_MASK) && timeout) {
174 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
175 dev_dbg(isp->dev, "waiting for ISPSSPM1 valid bit to be 0.\n");
176 udelay(100);
177 timeout--;
178 }
179
180 if (timeout != 0)
181 break;
182 }
183
184 if (timeout == 0) {
185 dev_err(isp->dev, "DFS failed due to HW error.\n");
186 return -EINVAL;
187 }
188
189 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
190 timeout = 10;
191 while (((isp_sspm1 >> ISP_FREQ_STAT_OFFSET) != ratio) && timeout) {
192 iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ, ISPSSPM1, &isp_sspm1);
193 dev_dbg(isp->dev, "waiting for ISPSSPM1 status bit to be 0x%x.\n",
194 new_freq);
195 udelay(100);
196 timeout--;
197 }
198 if (timeout == 0) {
199 dev_err(isp->dev, "DFS target freq is rejected by HW.\n");
200 return -EINVAL;
201 }
202
203 return 0;
204}
205
206int atomisp_freq_scaling(struct atomisp_device *isp,
207 enum atomisp_dfs_mode mode,
208 bool force)
209{
210 struct pci_dev *pdev = to_pci_dev(isp->dev);
211
212 struct atomisp_sub_device *asd = &isp->asd[0];
213 const struct atomisp_dfs_config *dfs;
214 unsigned int new_freq;
215 struct atomisp_freq_scaling_rule curr_rules;
216 int i, ret;
217 unsigned short fps = 0;
218
219 if (isp->sw_contex.power_state != ATOM_ISP_POWER_UP) {
220 dev_err(isp->dev, "DFS cannot proceed due to no power.\n");
221 return -EINVAL;
222 }
223
224 if ((pdev->device & ATOMISP_PCI_DEVICE_SOC_MASK) ==
225 ATOMISP_PCI_DEVICE_SOC_CHT && ATOMISP_USE_YUVPP(asd))
226 isp->dfs = &dfs_config_cht_soc;
227
228 dfs = isp->dfs;
229
230 if (dfs->lowest_freq == 0 || dfs->max_freq_at_vmin == 0 ||
231 dfs->highest_freq == 0 || dfs->dfs_table_size == 0 ||
232 !dfs->dfs_table) {
233 dev_err(isp->dev, "DFS configuration is invalid.\n");
234 return -EINVAL;
235 }
236
237 if (mode == ATOMISP_DFS_MODE_LOW) {
238 new_freq = dfs->lowest_freq;
239 goto done;
240 }
241
242 if (mode == ATOMISP_DFS_MODE_MAX) {
243 new_freq = dfs->highest_freq;
244 goto done;
245 }
246
247 fps = atomisp_get_sensor_fps(asd);
248 if (fps == 0) {
249 dev_info(isp->dev,
250 "Sensor didn't report FPS. Using DFS max mode.\n");
251 new_freq = dfs->highest_freq;
252 goto done;
253 }
254
255 curr_rules.width = asd->fmt[asd->capture_pad].fmt.width;
256 curr_rules.height = asd->fmt[asd->capture_pad].fmt.height;
257 curr_rules.fps = fps;
258 curr_rules.run_mode = asd->run_mode->val;
259
260
261
262
263
264 if (asd->continuous_mode->val) {
265 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
266 curr_rules.run_mode = ATOMISP_RUN_MODE_SDV;
267 else
268 curr_rules.run_mode =
269 ATOMISP_RUN_MODE_CONTINUOUS_CAPTURE;
270 }
271
272
273 for (i = 0; i < dfs->dfs_table_size; i++) {
274 if (curr_rules.width != dfs->dfs_table[i].width &&
275 dfs->dfs_table[i].width != ISP_FREQ_RULE_ANY)
276 continue;
277 if (curr_rules.height != dfs->dfs_table[i].height &&
278 dfs->dfs_table[i].height != ISP_FREQ_RULE_ANY)
279 continue;
280 if (curr_rules.fps != dfs->dfs_table[i].fps &&
281 dfs->dfs_table[i].fps != ISP_FREQ_RULE_ANY)
282 continue;
283 if (curr_rules.run_mode != dfs->dfs_table[i].run_mode &&
284 dfs->dfs_table[i].run_mode != ISP_FREQ_RULE_ANY)
285 continue;
286 break;
287 }
288
289 if (i == dfs->dfs_table_size)
290 new_freq = dfs->max_freq_at_vmin;
291 else
292 new_freq = dfs->dfs_table[i].isp_freq;
293
294done:
295 dev_dbg(isp->dev, "DFS target frequency=%d.\n", new_freq);
296
297 if ((new_freq == isp->sw_contex.running_freq) && !force)
298 return 0;
299
300 dev_dbg(isp->dev, "Programming DFS frequency to %d\n", new_freq);
301
302 ret = write_target_freq_to_hw(isp, new_freq);
303 if (!ret) {
304 isp->sw_contex.running_freq = new_freq;
305 trace_ipu_pstate(new_freq, -1);
306 }
307 return ret;
308}
309
310
311
312
313int atomisp_reset(struct atomisp_device *isp)
314{
315
316 int ret = 0;
317
318 dev_dbg(isp->dev, "%s\n", __func__);
319 atomisp_css_suspend(isp);
320 ret = atomisp_runtime_suspend(isp->dev);
321 if (ret < 0)
322 dev_err(isp->dev, "atomisp_runtime_suspend failed, %d\n", ret);
323 ret = atomisp_mrfld_power_down(isp);
324 if (ret < 0) {
325 dev_err(isp->dev, "can not disable ISP power\n");
326 } else {
327 ret = atomisp_mrfld_power_up(isp);
328 if (ret < 0)
329 dev_err(isp->dev, "can not enable ISP power\n");
330 ret = atomisp_runtime_resume(isp->dev);
331 if (ret < 0)
332 dev_err(isp->dev, "atomisp_runtime_resume failed, %d\n", ret);
333 }
334 ret = atomisp_css_resume(isp);
335 if (ret)
336 isp->isp_fatal_error = true;
337
338 return ret;
339}
340
341
342
343
344static void disable_isp_irq(enum hrt_isp_css_irq irq)
345{
346 irq_disable_channel(IRQ0_ID, irq);
347
348 if (irq != hrt_isp_css_irq_sp)
349 return;
350
351 cnd_sp_irq_enable(SP0_ID, false);
352}
353
354
355
356
357static void clear_isp_irq(enum hrt_isp_css_irq irq)
358{
359 irq_clear_all(IRQ0_ID);
360}
361
362void atomisp_msi_irq_init(struct atomisp_device *isp)
363{
364 struct pci_dev *pdev = to_pci_dev(isp->dev);
365 u32 msg32;
366 u16 msg16;
367
368 pci_read_config_dword(pdev, PCI_MSI_CAPID, &msg32);
369 msg32 |= 1 << MSI_ENABLE_BIT;
370 pci_write_config_dword(pdev, PCI_MSI_CAPID, msg32);
371
372 msg32 = (1 << INTR_IER) | (1 << INTR_IIR);
373 pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg32);
374
375 pci_read_config_word(pdev, PCI_COMMAND, &msg16);
376 msg16 |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
377 PCI_COMMAND_INTX_DISABLE);
378 pci_write_config_word(pdev, PCI_COMMAND, msg16);
379}
380
381void atomisp_msi_irq_uninit(struct atomisp_device *isp)
382{
383 struct pci_dev *pdev = to_pci_dev(isp->dev);
384 u32 msg32;
385 u16 msg16;
386
387 pci_read_config_dword(pdev, PCI_MSI_CAPID, &msg32);
388 msg32 &= ~(1 << MSI_ENABLE_BIT);
389 pci_write_config_dword(pdev, PCI_MSI_CAPID, msg32);
390
391 msg32 = 0x0;
392 pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg32);
393
394 pci_read_config_word(pdev, PCI_COMMAND, &msg16);
395 msg16 &= ~(PCI_COMMAND_MASTER);
396 pci_write_config_word(pdev, PCI_COMMAND, msg16);
397}
398
399static void atomisp_sof_event(struct atomisp_sub_device *asd)
400{
401 struct v4l2_event event = {0};
402
403 event.type = V4L2_EVENT_FRAME_SYNC;
404 event.u.frame_sync.frame_sequence = atomic_read(&asd->sof_count);
405
406 v4l2_event_queue(asd->subdev.devnode, &event);
407}
408
409void atomisp_eof_event(struct atomisp_sub_device *asd, uint8_t exp_id)
410{
411 struct v4l2_event event = {0};
412
413 event.type = V4L2_EVENT_FRAME_END;
414 event.u.frame_sync.frame_sequence = exp_id;
415
416 v4l2_event_queue(asd->subdev.devnode, &event);
417}
418
419static void atomisp_3a_stats_ready_event(struct atomisp_sub_device *asd,
420 uint8_t exp_id)
421{
422 struct v4l2_event event = {0};
423
424 event.type = V4L2_EVENT_ATOMISP_3A_STATS_READY;
425 event.u.frame_sync.frame_sequence = exp_id;
426
427 v4l2_event_queue(asd->subdev.devnode, &event);
428}
429
430static void atomisp_metadata_ready_event(struct atomisp_sub_device *asd,
431 enum atomisp_metadata_type md_type)
432{
433 struct v4l2_event event = {0};
434
435 event.type = V4L2_EVENT_ATOMISP_METADATA_READY;
436 event.u.data[0] = md_type;
437
438 v4l2_event_queue(asd->subdev.devnode, &event);
439}
440
441static void atomisp_reset_event(struct atomisp_sub_device *asd)
442{
443 struct v4l2_event event = {0};
444
445 event.type = V4L2_EVENT_ATOMISP_CSS_RESET;
446
447 v4l2_event_queue(asd->subdev.devnode, &event);
448}
449
450static void print_csi_rx_errors(enum mipi_port_id port,
451 struct atomisp_device *isp)
452{
453 u32 infos = 0;
454
455 atomisp_css_rx_get_irq_info(port, &infos);
456
457 dev_err(isp->dev, "CSI Receiver port %d errors:\n", port);
458 if (infos & IA_CSS_RX_IRQ_INFO_BUFFER_OVERRUN)
459 dev_err(isp->dev, " buffer overrun");
460 if (infos & IA_CSS_RX_IRQ_INFO_ERR_SOT)
461 dev_err(isp->dev, " start-of-transmission error");
462 if (infos & IA_CSS_RX_IRQ_INFO_ERR_SOT_SYNC)
463 dev_err(isp->dev, " start-of-transmission sync error");
464 if (infos & IA_CSS_RX_IRQ_INFO_ERR_CONTROL)
465 dev_err(isp->dev, " control error");
466 if (infos & IA_CSS_RX_IRQ_INFO_ERR_ECC_DOUBLE)
467 dev_err(isp->dev, " 2 or more ECC errors");
468 if (infos & IA_CSS_RX_IRQ_INFO_ERR_CRC)
469 dev_err(isp->dev, " CRC mismatch");
470 if (infos & IA_CSS_RX_IRQ_INFO_ERR_UNKNOWN_ID)
471 dev_err(isp->dev, " unknown error");
472 if (infos & IA_CSS_RX_IRQ_INFO_ERR_FRAME_SYNC)
473 dev_err(isp->dev, " frame sync error");
474 if (infos & IA_CSS_RX_IRQ_INFO_ERR_FRAME_DATA)
475 dev_err(isp->dev, " frame data error");
476 if (infos & IA_CSS_RX_IRQ_INFO_ERR_DATA_TIMEOUT)
477 dev_err(isp->dev, " data timeout");
478 if (infos & IA_CSS_RX_IRQ_INFO_ERR_UNKNOWN_ESC)
479 dev_err(isp->dev, " unknown escape command entry");
480 if (infos & IA_CSS_RX_IRQ_INFO_ERR_LINE_SYNC)
481 dev_err(isp->dev, " line sync error");
482}
483
484
485static void clear_irq_reg(struct atomisp_device *isp)
486{
487 struct pci_dev *pdev = to_pci_dev(isp->dev);
488 u32 msg_ret;
489
490 pci_read_config_dword(pdev, PCI_INTERRUPT_CTRL, &msg_ret);
491 msg_ret |= 1 << INTR_IIR;
492 pci_write_config_dword(pdev, PCI_INTERRUPT_CTRL, msg_ret);
493}
494
495static struct atomisp_sub_device *
496__get_asd_from_port(struct atomisp_device *isp, enum mipi_port_id port)
497{
498 int i;
499
500
501 for (i = 0; i < isp->num_of_streams; i++) {
502 struct atomisp_sub_device *asd = &isp->asd[i];
503 struct camera_mipi_info *mipi_info;
504
505 mipi_info = atomisp_to_sensor_mipi_info(
506 isp->inputs[asd->input_curr].camera);
507
508 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED &&
509 __get_mipi_port(isp, mipi_info->port) == port) {
510 return asd;
511 }
512 }
513
514 return NULL;
515}
516
517
518irqreturn_t atomisp_isr(int irq, void *dev)
519{
520 struct atomisp_device *isp = (struct atomisp_device *)dev;
521 struct atomisp_sub_device *asd;
522 struct atomisp_css_event eof_event;
523 unsigned int irq_infos = 0;
524 unsigned long flags;
525 unsigned int i;
526 int err;
527
528 spin_lock_irqsave(&isp->lock, flags);
529 if (isp->sw_contex.power_state != ATOM_ISP_POWER_UP ||
530 !isp->css_initialized) {
531 spin_unlock_irqrestore(&isp->lock, flags);
532 return IRQ_HANDLED;
533 }
534 err = atomisp_css_irq_translate(isp, &irq_infos);
535 if (err) {
536 spin_unlock_irqrestore(&isp->lock, flags);
537 return IRQ_NONE;
538 }
539
540 clear_irq_reg(isp);
541
542 if (!atomisp_streaming_count(isp) && !atomisp_is_acc_enabled(isp))
543 goto out_nowake;
544
545 for (i = 0; i < isp->num_of_streams; i++) {
546 asd = &isp->asd[i];
547
548 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
549 continue;
550
551
552
553
554 if (irq_infos & IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF) {
555 atomic_inc(&asd->sof_count);
556 atomisp_sof_event(asd);
557
558
559
560
561
562
563
564
565
566 if (atomic_read(&asd->sequence) == atomic_read(
567 &asd->sequence_temp))
568 atomic_set(&asd->sequence_temp,
569 atomic_read(&asd->sof_count));
570 }
571 if (irq_infos & IA_CSS_IRQ_INFO_EVENTS_READY)
572 atomic_set(&asd->sequence,
573 atomic_read(&asd->sequence_temp));
574 }
575
576 if (irq_infos & IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF) {
577 dev_dbg_ratelimited(isp->dev,
578 "irq:0x%x (SOF)\n",
579 irq_infos);
580 irq_infos &= ~IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF;
581 }
582
583 if ((irq_infos & IA_CSS_IRQ_INFO_INPUT_SYSTEM_ERROR) ||
584 (irq_infos & IA_CSS_IRQ_INFO_IF_ERROR)) {
585
586 u32 rx_infos;
587 enum mipi_port_id port;
588
589 for (port = MIPI_PORT0_ID; port <= MIPI_PORT2_ID;
590 port++) {
591 print_csi_rx_errors(port, isp);
592 atomisp_css_rx_get_irq_info(port, &rx_infos);
593 atomisp_css_rx_clear_irq_info(port, rx_infos);
594 }
595 }
596
597 if (irq_infos & IA_CSS_IRQ_INFO_ISYS_EVENTS_READY) {
598 while (ia_css_dequeue_isys_event(&eof_event.event) ==
599 0) {
600
601 asd = __get_asd_from_port(isp, eof_event.event.port);
602 if (!asd) {
603 dev_err(isp->dev, "%s: ISYS event, but no subdev.event:%d",
604 __func__, eof_event.event.type);
605 continue;
606 }
607
608 atomisp_eof_event(asd, eof_event.event.exp_id);
609 dev_dbg_ratelimited(isp->dev,
610 "%s ISYS event: EOF exp_id %d, asd %d\n",
611 __func__, eof_event.event.exp_id,
612 asd->index);
613 }
614
615 irq_infos &= ~IA_CSS_IRQ_INFO_ISYS_EVENTS_READY;
616 if (irq_infos == 0)
617 goto out_nowake;
618 }
619
620 spin_unlock_irqrestore(&isp->lock, flags);
621
622 dev_dbg_ratelimited(isp->dev, "irq:0x%x (unhandled)\n", irq_infos);
623
624 return IRQ_WAKE_THREAD;
625
626out_nowake:
627 spin_unlock_irqrestore(&isp->lock, flags);
628
629 if (irq_infos)
630 dev_dbg_ratelimited(isp->dev, "irq:0x%x (ignored, as not streaming anymore)\n",
631 irq_infos);
632
633 return IRQ_HANDLED;
634}
635
636void atomisp_clear_css_buffer_counters(struct atomisp_sub_device *asd)
637{
638 int i;
639
640 memset(asd->s3a_bufs_in_css, 0, sizeof(asd->s3a_bufs_in_css));
641 for (i = 0; i < ATOMISP_INPUT_STREAM_NUM; i++)
642 memset(asd->metadata_bufs_in_css[i], 0,
643 sizeof(asd->metadata_bufs_in_css[i]));
644 asd->dis_bufs_in_css = 0;
645 asd->video_out_capture.buffers_in_css = 0;
646 asd->video_out_vf.buffers_in_css = 0;
647 asd->video_out_preview.buffers_in_css = 0;
648 asd->video_out_video_capture.buffers_in_css = 0;
649}
650
651
652bool atomisp_buffers_queued(struct atomisp_sub_device *asd)
653{
654 return asd->video_out_capture.buffers_in_css ||
655 asd->video_out_vf.buffers_in_css ||
656 asd->video_out_preview.buffers_in_css ||
657 asd->video_out_video_capture.buffers_in_css;
658}
659
660
661bool atomisp_buffers_queued_pipe(struct atomisp_video_pipe *pipe)
662{
663 return pipe->buffers_in_css ? true : false;
664}
665
666
667#define SP_DMEM_BASE 0x100000
668
669void dump_sp_dmem(struct atomisp_device *isp, unsigned int addr,
670 unsigned int size)
671{
672 unsigned int data = 0;
673 unsigned int size32 = DIV_ROUND_UP(size, sizeof(u32));
674
675 dev_dbg(isp->dev, "atomisp mmio base: %p\n", isp->base);
676 dev_dbg(isp->dev, "%s, addr:0x%x, size: %d, size32: %d\n", __func__,
677 addr, size, size32);
678 if (size32 * 4 + addr > 0x4000) {
679 dev_err(isp->dev, "illegal size (%d) or addr (0x%x)\n",
680 size32, addr);
681 return;
682 }
683 addr += SP_DMEM_BASE;
684 addr &= 0x003FFFFF;
685 do {
686 data = readl(isp->base + addr);
687 dev_dbg(isp->dev, "%s, \t [0x%x]:0x%x\n", __func__, addr, data);
688 addr += sizeof(u32);
689 } while (--size32);
690}
691
692static struct videobuf_buffer *atomisp_css_frame_to_vbuf(
693 struct atomisp_video_pipe *pipe, struct ia_css_frame *frame)
694{
695 struct videobuf_vmalloc_memory *vm_mem;
696 struct ia_css_frame *handle;
697 int i;
698
699 for (i = 0; pipe->capq.bufs[i]; i++) {
700 vm_mem = pipe->capq.bufs[i]->priv;
701 handle = vm_mem->vaddr;
702 if (handle && handle->data == frame->data)
703 return pipe->capq.bufs[i];
704 }
705
706 return NULL;
707}
708
709static void atomisp_flush_video_pipe(struct atomisp_sub_device *asd,
710 struct atomisp_video_pipe *pipe)
711{
712 unsigned long irqflags;
713 int i;
714
715 if (!pipe->users)
716 return;
717
718 for (i = 0; pipe->capq.bufs[i]; i++) {
719 spin_lock_irqsave(&pipe->irq_lock, irqflags);
720 if (pipe->capq.bufs[i]->state == VIDEOBUF_ACTIVE ||
721 pipe->capq.bufs[i]->state == VIDEOBUF_QUEUED) {
722 pipe->capq.bufs[i]->ts = ktime_get_ns();
723 pipe->capq.bufs[i]->field_count =
724 atomic_read(&asd->sequence) << 1;
725 dev_dbg(asd->isp->dev, "release buffers on device %s\n",
726 pipe->vdev.name);
727 if (pipe->capq.bufs[i]->state == VIDEOBUF_QUEUED)
728 list_del_init(&pipe->capq.bufs[i]->queue);
729 pipe->capq.bufs[i]->state = VIDEOBUF_ERROR;
730 wake_up(&pipe->capq.bufs[i]->done);
731 }
732 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
733 }
734}
735
736
737void atomisp_flush_bufs_and_wakeup(struct atomisp_sub_device *asd)
738{
739 atomisp_flush_video_pipe(asd, &asd->video_out_capture);
740 atomisp_flush_video_pipe(asd, &asd->video_out_vf);
741 atomisp_flush_video_pipe(asd, &asd->video_out_preview);
742 atomisp_flush_video_pipe(asd, &asd->video_out_video_capture);
743}
744
745
746void atomisp_flush_params_queue(struct atomisp_video_pipe *pipe)
747{
748 struct atomisp_css_params_with_list *param;
749
750 while (!list_empty(&pipe->per_frame_params)) {
751 param = list_entry(pipe->per_frame_params.next,
752 struct atomisp_css_params_with_list, list);
753 list_del(¶m->list);
754 atomisp_free_css_parameters(¶m->params);
755 kvfree(param);
756 }
757}
758
759
760static void atomisp_recover_params_queue(struct atomisp_video_pipe *pipe)
761{
762 struct atomisp_css_params_with_list *param;
763 int i;
764
765 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
766 param = pipe->frame_params[i];
767 if (param)
768 list_add_tail(¶m->list, &pipe->per_frame_params);
769 pipe->frame_params[i] = NULL;
770 }
771 atomisp_handle_parameter_and_buffer(pipe);
772}
773
774
775static struct atomisp_video_pipe *__atomisp_get_pipe(
776 struct atomisp_sub_device *asd,
777 enum atomisp_input_stream_id stream_id,
778 enum ia_css_pipe_id css_pipe_id,
779 enum ia_css_buffer_type buf_type)
780{
781 struct atomisp_device *isp = asd->isp;
782
783 if (css_pipe_id == IA_CSS_PIPE_ID_COPY &&
784 isp->inputs[asd->input_curr].camera_caps->
785 sensor[asd->sensor_curr].stream_num > 1) {
786 switch (stream_id) {
787 case ATOMISP_INPUT_STREAM_PREVIEW:
788 return &asd->video_out_preview;
789 case ATOMISP_INPUT_STREAM_POSTVIEW:
790 return &asd->video_out_vf;
791 case ATOMISP_INPUT_STREAM_VIDEO:
792 return &asd->video_out_video_capture;
793 case ATOMISP_INPUT_STREAM_CAPTURE:
794 default:
795 return &asd->video_out_capture;
796 }
797 }
798
799
800 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT) {
801
802
803
804
805
806 return &asd->video_out_capture;
807 } else if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) {
808
809
810
811
812
813 return &asd->video_out_video_capture;
814 } else if (css_pipe_id == IA_CSS_PIPE_ID_YUVPP) {
815
816
817
818 if (asd->continuous_mode->val) {
819 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
820
821 switch (buf_type) {
822 case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
823 return &asd->video_out_video_capture;
824 case IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME:
825 return &asd->video_out_preview;
826 case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
827 return &asd->video_out_capture;
828 default:
829 return &asd->video_out_vf;
830 }
831 } else if (asd->run_mode->val == ATOMISP_RUN_MODE_PREVIEW) {
832
833 switch (buf_type) {
834 case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
835 return &asd->video_out_preview;
836 case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
837 return &asd->video_out_capture;
838 default:
839 return &asd->video_out_vf;
840 }
841 }
842 } else if (buf_type == IA_CSS_BUFFER_TYPE_OUTPUT_FRAME) {
843 switch (asd->run_mode->val) {
844 case ATOMISP_RUN_MODE_VIDEO:
845 return &asd->video_out_video_capture;
846 case ATOMISP_RUN_MODE_PREVIEW:
847 return &asd->video_out_preview;
848 default:
849 return &asd->video_out_capture;
850 }
851 } else if (buf_type == IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME) {
852 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
853 return &asd->video_out_preview;
854 else
855 return &asd->video_out_vf;
856 }
857 } else if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
858
859 if (css_pipe_id == IA_CSS_PIPE_ID_VIDEO ||
860 css_pipe_id == IA_CSS_PIPE_ID_COPY) {
861 if (buf_type == IA_CSS_BUFFER_TYPE_OUTPUT_FRAME)
862 return &asd->video_out_video_capture;
863 return &asd->video_out_preview;
864 }
865 } else if (asd->run_mode->val == ATOMISP_RUN_MODE_PREVIEW) {
866
867 if (css_pipe_id == IA_CSS_PIPE_ID_PREVIEW ||
868 css_pipe_id == IA_CSS_PIPE_ID_COPY)
869 return &asd->video_out_preview;
870 }
871
872 if (buf_type == IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME)
873 return &asd->video_out_vf;
874 return &asd->video_out_capture;
875}
876
877enum atomisp_metadata_type
878atomisp_get_metadata_type(struct atomisp_sub_device *asd,
879 enum ia_css_pipe_id pipe_id)
880{
881 if (!asd->continuous_mode->val)
882 return ATOMISP_MAIN_METADATA;
883
884 if (pipe_id == IA_CSS_PIPE_ID_CAPTURE)
885 return ATOMISP_SEC_METADATA;
886 else
887 return ATOMISP_MAIN_METADATA;
888}
889
890void atomisp_buf_done(struct atomisp_sub_device *asd, int error,
891 enum ia_css_buffer_type buf_type,
892 enum ia_css_pipe_id css_pipe_id,
893 bool q_buffers, enum atomisp_input_stream_id stream_id)
894{
895 struct videobuf_buffer *vb = NULL;
896 struct atomisp_video_pipe *pipe = NULL;
897 struct atomisp_css_buffer buffer;
898 bool requeue = false;
899 int err;
900 unsigned long irqflags;
901 struct ia_css_frame *frame = NULL;
902 struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf_tmp;
903 struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf_tmp;
904 struct atomisp_metadata_buf *md_buf = NULL, *_md_buf_tmp;
905 enum atomisp_metadata_type md_type;
906 struct atomisp_device *isp = asd->isp;
907 struct v4l2_control ctrl;
908 bool reset_wdt_timer = false;
909
910 if (
911 buf_type != IA_CSS_BUFFER_TYPE_METADATA &&
912 buf_type != IA_CSS_BUFFER_TYPE_3A_STATISTICS &&
913 buf_type != IA_CSS_BUFFER_TYPE_DIS_STATISTICS &&
914 buf_type != IA_CSS_BUFFER_TYPE_OUTPUT_FRAME &&
915 buf_type != IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME &&
916 buf_type != IA_CSS_BUFFER_TYPE_RAW_OUTPUT_FRAME &&
917 buf_type != IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME &&
918 buf_type != IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME) {
919 dev_err(isp->dev, "%s, unsupported buffer type: %d\n",
920 __func__, buf_type);
921 return;
922 }
923
924 memset(&buffer, 0, sizeof(struct atomisp_css_buffer));
925 buffer.css_buffer.type = buf_type;
926 err = atomisp_css_dequeue_buffer(asd, stream_id, css_pipe_id,
927 buf_type, &buffer);
928 if (err) {
929 dev_err(isp->dev,
930 "atomisp_css_dequeue_buffer failed: 0x%x\n", err);
931 return;
932 }
933
934
935 pipe = __atomisp_get_pipe(asd, stream_id, css_pipe_id, buf_type);
936 if (!pipe) {
937 dev_err(isp->dev, "error getting atomisp pipe\n");
938 return;
939 }
940
941 switch (buf_type) {
942 case IA_CSS_BUFFER_TYPE_3A_STATISTICS:
943 list_for_each_entry_safe(s3a_buf, _s3a_buf_tmp,
944 &asd->s3a_stats_in_css, list) {
945 if (s3a_buf->s3a_data ==
946 buffer.css_buffer.data.stats_3a) {
947 list_del_init(&s3a_buf->list);
948 list_add_tail(&s3a_buf->list,
949 &asd->s3a_stats_ready);
950 break;
951 }
952 }
953
954 asd->s3a_bufs_in_css[css_pipe_id]--;
955 atomisp_3a_stats_ready_event(asd, buffer.css_buffer.exp_id);
956 dev_dbg(isp->dev, "%s: s3a stat with exp_id %d is ready\n",
957 __func__, s3a_buf->s3a_data->exp_id);
958 break;
959 case IA_CSS_BUFFER_TYPE_METADATA:
960 if (error)
961 break;
962
963 md_type = atomisp_get_metadata_type(asd, css_pipe_id);
964 list_for_each_entry_safe(md_buf, _md_buf_tmp,
965 &asd->metadata_in_css[md_type], list) {
966 if (md_buf->metadata ==
967 buffer.css_buffer.data.metadata) {
968 list_del_init(&md_buf->list);
969 list_add_tail(&md_buf->list,
970 &asd->metadata_ready[md_type]);
971 break;
972 }
973 }
974 asd->metadata_bufs_in_css[stream_id][css_pipe_id]--;
975 atomisp_metadata_ready_event(asd, md_type);
976 dev_dbg(isp->dev, "%s: metadata with exp_id %d is ready\n",
977 __func__, md_buf->metadata->exp_id);
978 break;
979 case IA_CSS_BUFFER_TYPE_DIS_STATISTICS:
980 list_for_each_entry_safe(dis_buf, _dis_buf_tmp,
981 &asd->dis_stats_in_css, list) {
982 if (dis_buf->dis_data ==
983 buffer.css_buffer.data.stats_dvs) {
984 spin_lock_irqsave(&asd->dis_stats_lock,
985 irqflags);
986 list_del_init(&dis_buf->list);
987 list_add(&dis_buf->list, &asd->dis_stats);
988 asd->params.dis_proj_data_valid = true;
989 spin_unlock_irqrestore(&asd->dis_stats_lock,
990 irqflags);
991 break;
992 }
993 }
994 asd->dis_bufs_in_css--;
995 dev_dbg(isp->dev, "%s: dis stat with exp_id %d is ready\n",
996 __func__, dis_buf->dis_data->exp_id);
997 break;
998 case IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME:
999 case IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME:
1000 if (IS_ISP2401)
1001 reset_wdt_timer = true;
1002
1003 pipe->buffers_in_css--;
1004 frame = buffer.css_buffer.data.frame;
1005 if (!frame) {
1006 WARN_ON(1);
1007 break;
1008 }
1009 if (!frame->valid)
1010 error = true;
1011
1012
1013
1014
1015
1016 if (IS_BYT && buf_type == IA_CSS_BUFFER_TYPE_SEC_VF_OUTPUT_FRAME &&
1017 asd->continuous_mode->val && ATOMISP_USE_YUVPP(asd))
1018 frame->exp_id = (asd->postview_exp_id++) %
1019 (ATOMISP_MAX_EXP_ID + 1);
1020
1021 dev_dbg(isp->dev, "%s: vf frame with exp_id %d is ready\n",
1022 __func__, frame->exp_id);
1023 if (asd->params.flash_state == ATOMISP_FLASH_ONGOING) {
1024 if (frame->flash_state
1025 == IA_CSS_FRAME_FLASH_STATE_PARTIAL)
1026 dev_dbg(isp->dev, "%s thumb partially flashed\n",
1027 __func__);
1028 else if (frame->flash_state
1029 == IA_CSS_FRAME_FLASH_STATE_FULL)
1030 dev_dbg(isp->dev, "%s thumb completely flashed\n",
1031 __func__);
1032 else
1033 dev_dbg(isp->dev, "%s thumb no flash in this frame\n",
1034 __func__);
1035 }
1036 vb = atomisp_css_frame_to_vbuf(pipe, frame);
1037 WARN_ON(!vb);
1038 if (vb)
1039 pipe->frame_config_id[vb->i] = frame->isp_config_id;
1040 if (css_pipe_id == IA_CSS_PIPE_ID_CAPTURE &&
1041 asd->pending_capture_request > 0) {
1042 err = atomisp_css_offline_capture_configure(asd,
1043 asd->params.offline_parm.num_captures,
1044 asd->params.offline_parm.skip_frames,
1045 asd->params.offline_parm.offset);
1046
1047 asd->pending_capture_request--;
1048
1049 if (IS_ISP2401)
1050 asd->re_trigger_capture = false;
1051
1052 dev_dbg(isp->dev, "Trigger capture again for new buffer. err=%d\n",
1053 err);
1054 } else if (IS_ISP2401) {
1055 asd->re_trigger_capture = true;
1056 }
1057 break;
1058 case IA_CSS_BUFFER_TYPE_OUTPUT_FRAME:
1059 case IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME:
1060 if (IS_ISP2401)
1061 reset_wdt_timer = true;
1062
1063 pipe->buffers_in_css--;
1064 frame = buffer.css_buffer.data.frame;
1065 if (!frame) {
1066 WARN_ON(1);
1067 break;
1068 }
1069
1070 if (!frame->valid)
1071 error = true;
1072
1073
1074
1075
1076
1077 if (IS_BYT && buf_type == IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME &&
1078 asd->continuous_mode->val && ATOMISP_USE_YUVPP(asd))
1079 frame->exp_id = (asd->preview_exp_id++) %
1080 (ATOMISP_MAX_EXP_ID + 1);
1081
1082 dev_dbg(isp->dev, "%s: main frame with exp_id %d is ready\n",
1083 __func__, frame->exp_id);
1084 vb = atomisp_css_frame_to_vbuf(pipe, frame);
1085 if (!vb) {
1086 WARN_ON(1);
1087 break;
1088 }
1089
1090
1091 if (pipe->frame_params[vb->i]) {
1092 if (asd->params.dvs_6axis ==
1093 pipe->frame_params[vb->i]->params.dvs_6axis)
1094 asd->params.dvs_6axis = NULL;
1095 atomisp_free_css_parameters(
1096 &pipe->frame_params[vb->i]->params);
1097 kvfree(pipe->frame_params[vb->i]);
1098 pipe->frame_params[vb->i] = NULL;
1099 }
1100
1101 pipe->frame_config_id[vb->i] = frame->isp_config_id;
1102 ctrl.id = V4L2_CID_FLASH_MODE;
1103 if (asd->params.flash_state == ATOMISP_FLASH_ONGOING) {
1104 if (frame->flash_state
1105 == IA_CSS_FRAME_FLASH_STATE_PARTIAL) {
1106 asd->frame_status[vb->i] =
1107 ATOMISP_FRAME_STATUS_FLASH_PARTIAL;
1108 dev_dbg(isp->dev, "%s partially flashed\n",
1109 __func__);
1110 } else if (frame->flash_state
1111 == IA_CSS_FRAME_FLASH_STATE_FULL) {
1112 asd->frame_status[vb->i] =
1113 ATOMISP_FRAME_STATUS_FLASH_EXPOSED;
1114 asd->params.num_flash_frames--;
1115 dev_dbg(isp->dev, "%s completely flashed\n",
1116 __func__);
1117 } else {
1118 asd->frame_status[vb->i] =
1119 ATOMISP_FRAME_STATUS_OK;
1120 dev_dbg(isp->dev,
1121 "%s no flash in this frame\n",
1122 __func__);
1123 }
1124
1125
1126 if (asd->frame_status[vb->i] ==
1127 ATOMISP_FRAME_STATUS_FLASH_EXPOSED)
1128 asd->params.flash_state = ATOMISP_FLASH_DONE;
1129 } else if (isp->flash) {
1130 if (v4l2_g_ctrl(isp->flash->ctrl_handler, &ctrl) ==
1131 0 && ctrl.value == ATOMISP_FLASH_MODE_TORCH) {
1132 ctrl.id = V4L2_CID_FLASH_TORCH_INTENSITY;
1133 if (v4l2_g_ctrl(isp->flash->ctrl_handler, &ctrl)
1134 == 0 && ctrl.value > 0) {
1135 asd->frame_status[vb->i] =
1136 ATOMISP_FRAME_STATUS_FLASH_EXPOSED;
1137 } else {
1138 asd->frame_status[vb->i] =
1139 ATOMISP_FRAME_STATUS_OK;
1140 }
1141 } else {
1142 asd->frame_status[vb->i] =
1143 ATOMISP_FRAME_STATUS_OK;
1144 }
1145 } else {
1146 asd->frame_status[vb->i] = ATOMISP_FRAME_STATUS_OK;
1147 }
1148
1149 asd->params.last_frame_status = asd->frame_status[vb->i];
1150
1151 if (asd->continuous_mode->val) {
1152 if (css_pipe_id == IA_CSS_PIPE_ID_PREVIEW ||
1153 css_pipe_id == IA_CSS_PIPE_ID_VIDEO) {
1154 asd->latest_preview_exp_id = frame->exp_id;
1155 } else if (css_pipe_id ==
1156 IA_CSS_PIPE_ID_CAPTURE) {
1157 if (asd->run_mode->val ==
1158 ATOMISP_RUN_MODE_VIDEO)
1159 dev_dbg(isp->dev, "SDV capture raw buffer id: %u\n",
1160 frame->exp_id);
1161 else
1162 dev_dbg(isp->dev, "ZSL capture raw buffer id: %u\n",
1163 frame->exp_id);
1164 }
1165 }
1166
1167
1168
1169
1170
1171
1172 if (((css_pipe_id == IA_CSS_PIPE_ID_PREVIEW) ||
1173 (css_pipe_id == IA_CSS_PIPE_ID_VIDEO)) &&
1174 asd->enable_raw_buffer_lock->val &&
1175 asd->continuous_mode->val) {
1176 atomisp_set_raw_buffer_bitmap(asd, frame->exp_id);
1177 WARN_ON(frame->exp_id > ATOMISP_MAX_EXP_ID);
1178 }
1179
1180 if (asd->params.css_update_params_needed) {
1181 atomisp_apply_css_parameters(asd,
1182 &asd->params.css_param);
1183 if (asd->params.css_param.update_flag.dz_config)
1184 asd->params.config.dz_config = &asd->params.css_param.dz_config;
1185
1186
1187
1188
1189
1190
1191
1192
1193 if (asd->params.dvs_6axis)
1194 atomisp_css_set_dvs_6axis(asd,
1195 asd->params.dvs_6axis);
1196 else
1197 asd->params.css_update_params_needed = false;
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209 atomisp_css_update_isp_params(asd);
1210 }
1211 break;
1212 default:
1213 break;
1214 }
1215 if (vb) {
1216 vb->ts = ktime_get_ns();
1217 vb->field_count = atomic_read(&asd->sequence) << 1;
1218
1219 spin_lock_irqsave(&pipe->irq_lock, irqflags);
1220 vb->state = !error ? VIDEOBUF_DONE : VIDEOBUF_ERROR;
1221 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1222
1223
1224
1225
1226
1227
1228 wake_up(&vb->done);
1229 }
1230 if (IS_ISP2401)
1231 atomic_set(&pipe->wdt_count, 0);
1232
1233
1234
1235
1236
1237 if (requeue) {
1238 err = atomisp_css_queue_buffer(asd,
1239 stream_id, css_pipe_id,
1240 buf_type, &buffer);
1241 if (err)
1242 dev_err(isp->dev, "%s, q to css fails: %d\n",
1243 __func__, err);
1244 return;
1245 }
1246 if (!error && q_buffers)
1247 atomisp_qbuffers_to_css(asd);
1248
1249 if (IS_ISP2401) {
1250
1251
1252 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1253 return;
1254 if (!atomisp_buffers_queued_pipe(pipe))
1255 atomisp_wdt_stop_pipe(pipe, false);
1256 else if (reset_wdt_timer)
1257
1258 atomisp_wdt_refresh_pipe(pipe,
1259 ATOMISP_WDT_KEEP_CURRENT_DELAY);
1260 }
1261}
1262
1263void atomisp_delayed_init_work(struct work_struct *work)
1264{
1265 struct atomisp_sub_device *asd = container_of(work,
1266 struct atomisp_sub_device,
1267 delayed_init_work);
1268
1269
1270
1271 if (!ATOMISP_USE_YUVPP(asd)) {
1272 struct v4l2_event event = {0};
1273 struct ia_css_stream *stream;
1274
1275 stream = asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream;
1276
1277
1278 if (ia_css_alloc_continuous_frame_remain(stream))
1279 return;
1280
1281 ia_css_update_continuous_frames(stream);
1282
1283 event.type = V4L2_EVENT_ATOMISP_RAW_BUFFERS_ALLOC_DONE;
1284 v4l2_event_queue(asd->subdev.devnode, &event);
1285 }
1286
1287
1288 asd->delayed_init = ATOMISP_DELAYED_INIT_DONE;
1289 complete(&asd->init_done);
1290}
1291
1292static void __atomisp_css_recover(struct atomisp_device *isp, bool isp_timeout)
1293{
1294 struct pci_dev *pdev = to_pci_dev(isp->dev);
1295 enum ia_css_pipe_id css_pipe_id;
1296 bool stream_restart[MAX_STREAM_NUM] = {0};
1297 bool depth_mode = false;
1298 int i, ret, depth_cnt = 0;
1299
1300 if (!isp->sw_contex.file_input)
1301 atomisp_css_irq_enable(isp,
1302 IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF, false);
1303
1304 BUG_ON(isp->num_of_streams > MAX_STREAM_NUM);
1305
1306 for (i = 0; i < isp->num_of_streams; i++) {
1307 struct atomisp_sub_device *asd = &isp->asd[i];
1308 struct ia_css_pipeline *acc_pipeline;
1309 struct ia_css_pipe *acc_pipe = NULL;
1310
1311 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED &&
1312 !asd->stream_prepared)
1313 continue;
1314
1315
1316
1317
1318
1319
1320 acc_pipe = asd->stream_env[i].pipes[IA_CSS_PIPE_ID_ACC];
1321 if (acc_pipe) {
1322 acc_pipeline = ia_css_pipe_get_pipeline(acc_pipe);
1323 if (acc_pipeline) {
1324 struct ia_css_pipeline_stage *stage;
1325
1326 for (stage = acc_pipeline->stages; stage;
1327 stage = stage->next) {
1328 const struct ia_css_fw_info *fw;
1329
1330 fw = stage->firmware;
1331 atomisp_acc_done(asd, fw->handle);
1332 }
1333 }
1334 }
1335
1336 depth_cnt++;
1337
1338 if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED)
1339 cancel_work_sync(&asd->delayed_init_work);
1340
1341 complete(&asd->init_done);
1342 asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED;
1343
1344 stream_restart[asd->index] = true;
1345
1346 asd->streaming = ATOMISP_DEVICE_STREAMING_STOPPING;
1347
1348
1349 ret = v4l2_subdev_call(
1350 isp->inputs[asd->input_curr].
1351 camera, video, s_stream, 0);
1352 if (ret)
1353 dev_warn(isp->dev,
1354 "can't stop streaming on sensor!\n");
1355
1356 atomisp_acc_unload_extensions(asd);
1357
1358 atomisp_clear_css_buffer_counters(asd);
1359
1360 css_pipe_id = atomisp_get_css_pipe_id(asd);
1361 atomisp_css_stop(asd, css_pipe_id, true);
1362
1363 asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED;
1364
1365 asd->preview_exp_id = 1;
1366 asd->postview_exp_id = 1;
1367
1368 dev_dbg(isp->dev,
1369 "send reset event to %s\n", asd->subdev.devnode->name);
1370 atomisp_reset_event(asd);
1371 }
1372
1373
1374 disable_isp_irq(hrt_isp_css_irq_sp);
1375 clear_isp_irq(hrt_isp_css_irq_sp);
1376
1377
1378 pci_write_config_dword(pdev, PCI_I_CONTROL,
1379 isp->saved_regs.i_control | MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK);
1380
1381
1382 isp->isp_timeout = true;
1383 atomisp_reset(isp);
1384 isp->isp_timeout = false;
1385
1386 if (!isp_timeout) {
1387 for (i = 0; i < isp->num_of_streams; i++) {
1388 if (isp->asd[i].depth_mode->val)
1389 return;
1390 }
1391 }
1392
1393 for (i = 0; i < isp->num_of_streams; i++) {
1394 struct atomisp_sub_device *asd = &isp->asd[i];
1395
1396 if (!stream_restart[i])
1397 continue;
1398
1399 if (isp->inputs[asd->input_curr].type != FILE_INPUT)
1400 atomisp_css_input_set_mode(asd,
1401 IA_CSS_INPUT_MODE_BUFFERED_SENSOR);
1402
1403 css_pipe_id = atomisp_get_css_pipe_id(asd);
1404 if (atomisp_css_start(asd, css_pipe_id, true))
1405 dev_warn(isp->dev,
1406 "start SP failed, so do not set streaming to be enable!\n");
1407 else
1408 asd->streaming = ATOMISP_DEVICE_STREAMING_ENABLED;
1409
1410 atomisp_csi2_configure(asd);
1411 }
1412
1413 if (!isp->sw_contex.file_input) {
1414 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
1415 atomisp_css_valid_sof(isp));
1416
1417 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_AUTO, true) < 0)
1418 dev_dbg(isp->dev, "DFS auto failed while recovering!\n");
1419 } else {
1420 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, true) < 0)
1421 dev_dbg(isp->dev, "DFS max failed while recovering!\n");
1422 }
1423
1424 for (i = 0; i < isp->num_of_streams; i++) {
1425 struct atomisp_sub_device *asd;
1426
1427 asd = &isp->asd[i];
1428
1429 if (!stream_restart[i])
1430 continue;
1431
1432 if (asd->continuous_mode->val &&
1433 asd->delayed_init == ATOMISP_DELAYED_INIT_NOT_QUEUED) {
1434 reinit_completion(&asd->init_done);
1435 asd->delayed_init = ATOMISP_DELAYED_INIT_QUEUED;
1436 queue_work(asd->delayed_init_workq,
1437 &asd->delayed_init_work);
1438 }
1439
1440
1441
1442
1443 atomisp_flush_bufs_and_wakeup(asd);
1444
1445
1446 atomisp_recover_params_queue(&asd->video_out_capture);
1447 atomisp_recover_params_queue(&asd->video_out_preview);
1448 atomisp_recover_params_queue(&asd->video_out_video_capture);
1449
1450 if ((asd->depth_mode->val) &&
1451 (depth_cnt == ATOMISP_DEPTH_SENSOR_STREAMON_COUNT)) {
1452 depth_mode = true;
1453 continue;
1454 }
1455
1456 ret = v4l2_subdev_call(
1457 isp->inputs[asd->input_curr].camera, video,
1458 s_stream, 1);
1459 if (ret)
1460 dev_warn(isp->dev,
1461 "can't start streaming on sensor!\n");
1462 }
1463
1464 if (depth_mode) {
1465 if (atomisp_stream_on_master_slave_sensor(isp, true))
1466 dev_warn(isp->dev,
1467 "master slave sensor stream on failed!\n");
1468 }
1469}
1470
1471void atomisp_wdt_work(struct work_struct *work)
1472{
1473 struct atomisp_device *isp = container_of(work, struct atomisp_device,
1474 wdt_work);
1475 int i;
1476 unsigned int pipe_wdt_cnt[MAX_STREAM_NUM][4] = { {0} };
1477 bool css_recover = false;
1478
1479 rt_mutex_lock(&isp->mutex);
1480 if (!atomisp_streaming_count(isp)) {
1481 atomic_set(&isp->wdt_work_queued, 0);
1482 rt_mutex_unlock(&isp->mutex);
1483 return;
1484 }
1485
1486 if (!IS_ISP2401) {
1487 dev_err(isp->dev, "timeout %d of %d\n",
1488 atomic_read(&isp->wdt_count) + 1,
1489 ATOMISP_ISP_MAX_TIMEOUT_COUNT);
1490
1491 if (atomic_inc_return(&isp->wdt_count) < ATOMISP_ISP_MAX_TIMEOUT_COUNT)
1492 css_recover = true;
1493 } else {
1494 css_recover = true;
1495
1496 for (i = 0; i < isp->num_of_streams; i++) {
1497 struct atomisp_sub_device *asd = &isp->asd[i];
1498
1499 pipe_wdt_cnt[i][0] +=
1500 atomic_read(&asd->video_out_capture.wdt_count);
1501 pipe_wdt_cnt[i][1] +=
1502 atomic_read(&asd->video_out_vf.wdt_count);
1503 pipe_wdt_cnt[i][2] +=
1504 atomic_read(&asd->video_out_preview.wdt_count);
1505 pipe_wdt_cnt[i][3] +=
1506 atomic_read(&asd->video_out_video_capture.wdt_count);
1507 css_recover =
1508 (pipe_wdt_cnt[i][0] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1509 pipe_wdt_cnt[i][1] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1510 pipe_wdt_cnt[i][2] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT &&
1511 pipe_wdt_cnt[i][3] <= ATOMISP_ISP_MAX_TIMEOUT_COUNT)
1512 ? true : false;
1513 dev_err(isp->dev,
1514 "pipe on asd%d timeout cnt: (%d, %d, %d, %d) of %d, recover = %d\n",
1515 asd->index, pipe_wdt_cnt[i][0], pipe_wdt_cnt[i][1],
1516 pipe_wdt_cnt[i][2], pipe_wdt_cnt[i][3],
1517 ATOMISP_ISP_MAX_TIMEOUT_COUNT, css_recover);
1518 }
1519 }
1520
1521 if (css_recover) {
1522 ia_css_debug_dump_sp_sw_debug_info();
1523 ia_css_debug_dump_debug_info(__func__);
1524 for (i = 0; i < isp->num_of_streams; i++) {
1525 struct atomisp_sub_device *asd = &isp->asd[i];
1526
1527 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1528 continue;
1529 dev_err(isp->dev, "%s, vdev %s buffers in css: %d\n",
1530 __func__,
1531 asd->video_out_capture.vdev.name,
1532 asd->video_out_capture.
1533 buffers_in_css);
1534 dev_err(isp->dev,
1535 "%s, vdev %s buffers in css: %d\n",
1536 __func__,
1537 asd->video_out_vf.vdev.name,
1538 asd->video_out_vf.
1539 buffers_in_css);
1540 dev_err(isp->dev,
1541 "%s, vdev %s buffers in css: %d\n",
1542 __func__,
1543 asd->video_out_preview.vdev.name,
1544 asd->video_out_preview.
1545 buffers_in_css);
1546 dev_err(isp->dev,
1547 "%s, vdev %s buffers in css: %d\n",
1548 __func__,
1549 asd->video_out_video_capture.vdev.name,
1550 asd->video_out_video_capture.
1551 buffers_in_css);
1552 dev_err(isp->dev,
1553 "%s, s3a buffers in css preview pipe:%d\n",
1554 __func__,
1555 asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_PREVIEW]);
1556 dev_err(isp->dev,
1557 "%s, s3a buffers in css capture pipe:%d\n",
1558 __func__,
1559 asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_CAPTURE]);
1560 dev_err(isp->dev,
1561 "%s, s3a buffers in css video pipe:%d\n",
1562 __func__,
1563 asd->s3a_bufs_in_css[IA_CSS_PIPE_ID_VIDEO]);
1564 dev_err(isp->dev,
1565 "%s, dis buffers in css: %d\n",
1566 __func__, asd->dis_bufs_in_css);
1567 dev_err(isp->dev,
1568 "%s, metadata buffers in css preview pipe:%d\n",
1569 __func__,
1570 asd->metadata_bufs_in_css
1571 [ATOMISP_INPUT_STREAM_GENERAL]
1572 [IA_CSS_PIPE_ID_PREVIEW]);
1573 dev_err(isp->dev,
1574 "%s, metadata buffers in css capture pipe:%d\n",
1575 __func__,
1576 asd->metadata_bufs_in_css
1577 [ATOMISP_INPUT_STREAM_GENERAL]
1578 [IA_CSS_PIPE_ID_CAPTURE]);
1579 dev_err(isp->dev,
1580 "%s, metadata buffers in css video pipe:%d\n",
1581 __func__,
1582 asd->metadata_bufs_in_css
1583 [ATOMISP_INPUT_STREAM_GENERAL]
1584 [IA_CSS_PIPE_ID_VIDEO]);
1585 if (asd->enable_raw_buffer_lock->val) {
1586 unsigned int j;
1587
1588 dev_err(isp->dev, "%s, raw_buffer_locked_count %d\n",
1589 __func__, asd->raw_buffer_locked_count);
1590 for (j = 0; j <= ATOMISP_MAX_EXP_ID / 32; j++)
1591 dev_err(isp->dev, "%s, raw_buffer_bitmap[%d]: 0x%x\n",
1592 __func__, j,
1593 asd->raw_buffer_bitmap[j]);
1594 }
1595 }
1596
1597
1598
1599 } else {
1600 for (i = 0; i < isp->num_of_streams; i++) {
1601 struct atomisp_sub_device *asd = &isp->asd[i];
1602
1603 if (asd->streaming ==
1604 ATOMISP_DEVICE_STREAMING_ENABLED) {
1605 atomisp_clear_css_buffer_counters(asd);
1606 atomisp_flush_bufs_and_wakeup(asd);
1607 complete(&asd->init_done);
1608 }
1609 if (IS_ISP2401)
1610 atomisp_wdt_stop(asd, false);
1611 }
1612
1613 if (!IS_ISP2401) {
1614 atomic_set(&isp->wdt_count, 0);
1615 } else {
1616 isp->isp_fatal_error = true;
1617 atomic_set(&isp->wdt_work_queued, 0);
1618
1619 rt_mutex_unlock(&isp->mutex);
1620 return;
1621 }
1622 }
1623
1624 __atomisp_css_recover(isp, true);
1625 if (IS_ISP2401) {
1626 for (i = 0; i < isp->num_of_streams; i++) {
1627 struct atomisp_sub_device *asd = &isp->asd[i];
1628
1629 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1630 continue;
1631
1632 atomisp_wdt_refresh(asd,
1633 isp->sw_contex.file_input ?
1634 ATOMISP_ISP_FILE_TIMEOUT_DURATION :
1635 ATOMISP_ISP_TIMEOUT_DURATION);
1636 }
1637 }
1638
1639 dev_err(isp->dev, "timeout recovery handling done\n");
1640 atomic_set(&isp->wdt_work_queued, 0);
1641
1642 rt_mutex_unlock(&isp->mutex);
1643}
1644
1645void atomisp_css_flush(struct atomisp_device *isp)
1646{
1647 int i;
1648
1649 if (!atomisp_streaming_count(isp))
1650 return;
1651
1652
1653 for (i = 0; i < isp->num_of_streams; i++) {
1654 struct atomisp_sub_device *asd = &isp->asd[i];
1655
1656 atomisp_wdt_stop(asd, true);
1657 }
1658
1659
1660 __atomisp_css_recover(isp, false);
1661
1662 for (i = 0; i < isp->num_of_streams; i++) {
1663 struct atomisp_sub_device *asd = &isp->asd[i];
1664
1665 if (asd->streaming !=
1666 ATOMISP_DEVICE_STREAMING_ENABLED)
1667 continue;
1668
1669 atomisp_wdt_refresh(asd,
1670 isp->sw_contex.file_input ?
1671 ATOMISP_ISP_FILE_TIMEOUT_DURATION :
1672 ATOMISP_ISP_TIMEOUT_DURATION);
1673 }
1674 dev_dbg(isp->dev, "atomisp css flush done\n");
1675}
1676
1677void atomisp_wdt(struct timer_list *t)
1678{
1679 struct atomisp_sub_device *asd;
1680 struct atomisp_device *isp;
1681
1682 if (!IS_ISP2401) {
1683 asd = from_timer(asd, t, wdt);
1684 isp = asd->isp;
1685 } else {
1686 struct atomisp_video_pipe *pipe = from_timer(pipe, t, wdt);
1687
1688 asd = pipe->asd;
1689 isp = asd->isp;
1690
1691 atomic_inc(&pipe->wdt_count);
1692 dev_warn(isp->dev,
1693 "[WARNING]asd %d pipe %s ISP timeout %d!\n",
1694 asd->index, pipe->vdev.name,
1695 atomic_read(&pipe->wdt_count));
1696 }
1697
1698 if (atomic_read(&isp->wdt_work_queued)) {
1699 dev_dbg(isp->dev, "ISP watchdog was put into workqueue\n");
1700 return;
1701 }
1702 atomic_set(&isp->wdt_work_queued, 1);
1703 queue_work(isp->wdt_work_queue, &isp->wdt_work);
1704}
1705
1706
1707void atomisp_wdt_start(struct atomisp_sub_device *asd)
1708{
1709 atomisp_wdt_refresh(asd, ATOMISP_ISP_TIMEOUT_DURATION);
1710}
1711
1712
1713void atomisp_wdt_refresh_pipe(struct atomisp_video_pipe *pipe,
1714 unsigned int delay)
1715{
1716 unsigned long next;
1717
1718 if (delay != ATOMISP_WDT_KEEP_CURRENT_DELAY)
1719 pipe->wdt_duration = delay;
1720
1721 next = jiffies + pipe->wdt_duration;
1722
1723
1724 if (atomisp_is_wdt_running(pipe) && time_after(pipe->wdt_expires, next))
1725 next = pipe->wdt_expires;
1726
1727 pipe->wdt_expires = next;
1728
1729 if (atomisp_is_wdt_running(pipe))
1730 dev_dbg(pipe->asd->isp->dev, "WDT will hit after %d ms (%s)\n",
1731 ((int)(next - jiffies) * 1000 / HZ), pipe->vdev.name);
1732 else
1733 dev_dbg(pipe->asd->isp->dev, "WDT starts with %d ms period (%s)\n",
1734 ((int)(next - jiffies) * 1000 / HZ), pipe->vdev.name);
1735
1736 mod_timer(&pipe->wdt, next);
1737}
1738
1739void atomisp_wdt_refresh(struct atomisp_sub_device *asd, unsigned int delay)
1740{
1741 if (!IS_ISP2401) {
1742 unsigned long next;
1743
1744 if (delay != ATOMISP_WDT_KEEP_CURRENT_DELAY)
1745 asd->wdt_duration = delay;
1746
1747 next = jiffies + asd->wdt_duration;
1748
1749
1750 if (atomisp_is_wdt_running(asd) && time_after(asd->wdt_expires, next))
1751 next = asd->wdt_expires;
1752
1753 asd->wdt_expires = next;
1754
1755 if (atomisp_is_wdt_running(asd))
1756 dev_dbg(asd->isp->dev, "WDT will hit after %d ms\n",
1757 ((int)(next - jiffies) * 1000 / HZ));
1758 else
1759 dev_dbg(asd->isp->dev, "WDT starts with %d ms period\n",
1760 ((int)(next - jiffies) * 1000 / HZ));
1761
1762 mod_timer(&asd->wdt, next);
1763 atomic_set(&asd->isp->wdt_count, 0);
1764 } else {
1765 dev_dbg(asd->isp->dev, "WDT refresh all:\n");
1766 if (atomisp_is_wdt_running(&asd->video_out_capture))
1767 atomisp_wdt_refresh_pipe(&asd->video_out_capture, delay);
1768 if (atomisp_is_wdt_running(&asd->video_out_preview))
1769 atomisp_wdt_refresh_pipe(&asd->video_out_preview, delay);
1770 if (atomisp_is_wdt_running(&asd->video_out_vf))
1771 atomisp_wdt_refresh_pipe(&asd->video_out_vf, delay);
1772 if (atomisp_is_wdt_running(&asd->video_out_video_capture))
1773 atomisp_wdt_refresh_pipe(&asd->video_out_video_capture, delay);
1774 }
1775}
1776
1777
1778void atomisp_wdt_stop_pipe(struct atomisp_video_pipe *pipe, bool sync)
1779{
1780 if (!atomisp_is_wdt_running(pipe))
1781 return;
1782
1783 dev_dbg(pipe->asd->isp->dev,
1784 "WDT stop asd %d (%s)\n", pipe->asd->index, pipe->vdev.name);
1785
1786 if (sync) {
1787 del_timer_sync(&pipe->wdt);
1788 cancel_work_sync(&pipe->asd->isp->wdt_work);
1789 } else {
1790 del_timer(&pipe->wdt);
1791 }
1792}
1793
1794
1795void atomisp_wdt_start_pipe(struct atomisp_video_pipe *pipe)
1796{
1797 atomisp_wdt_refresh_pipe(pipe, ATOMISP_ISP_TIMEOUT_DURATION);
1798}
1799
1800void atomisp_wdt_stop(struct atomisp_sub_device *asd, bool sync)
1801{
1802 dev_dbg(asd->isp->dev, "WDT stop:\n");
1803
1804 if (!IS_ISP2401) {
1805 if (sync) {
1806 del_timer_sync(&asd->wdt);
1807 cancel_work_sync(&asd->isp->wdt_work);
1808 } else {
1809 del_timer(&asd->wdt);
1810 }
1811 } else {
1812 atomisp_wdt_stop_pipe(&asd->video_out_capture, sync);
1813 atomisp_wdt_stop_pipe(&asd->video_out_preview, sync);
1814 atomisp_wdt_stop_pipe(&asd->video_out_vf, sync);
1815 atomisp_wdt_stop_pipe(&asd->video_out_video_capture, sync);
1816 }
1817}
1818
1819void atomisp_setup_flash(struct atomisp_sub_device *asd)
1820{
1821 struct atomisp_device *isp = asd->isp;
1822 struct v4l2_control ctrl;
1823
1824 if (!isp->flash)
1825 return;
1826
1827 if (asd->params.flash_state != ATOMISP_FLASH_REQUESTED &&
1828 asd->params.flash_state != ATOMISP_FLASH_DONE)
1829 return;
1830
1831 if (asd->params.num_flash_frames) {
1832
1833 ctrl.id = V4L2_CID_FLASH_TIMEOUT;
1834 ctrl.value = FLASH_TIMEOUT;
1835
1836 if (v4l2_s_ctrl(NULL, isp->flash->ctrl_handler, &ctrl)) {
1837 dev_err(isp->dev, "flash timeout configure failed\n");
1838 return;
1839 }
1840
1841 ia_css_stream_request_flash(asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream);
1842
1843 asd->params.flash_state = ATOMISP_FLASH_ONGOING;
1844 } else {
1845 asd->params.flash_state = ATOMISP_FLASH_IDLE;
1846 }
1847}
1848
1849irqreturn_t atomisp_isr_thread(int irq, void *isp_ptr)
1850{
1851 struct atomisp_device *isp = isp_ptr;
1852 unsigned long flags;
1853 bool frame_done_found[MAX_STREAM_NUM] = {0};
1854 bool css_pipe_done[MAX_STREAM_NUM] = {0};
1855 unsigned int i;
1856 struct atomisp_sub_device *asd;
1857
1858 dev_dbg(isp->dev, ">%s\n", __func__);
1859
1860 spin_lock_irqsave(&isp->lock, flags);
1861
1862 if (!atomisp_streaming_count(isp) && !atomisp_is_acc_enabled(isp)) {
1863 spin_unlock_irqrestore(&isp->lock, flags);
1864 return IRQ_HANDLED;
1865 }
1866
1867 spin_unlock_irqrestore(&isp->lock, flags);
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894 rt_mutex_lock(&isp->mutex);
1895 if (atomisp_css_isr_thread(isp, frame_done_found, css_pipe_done))
1896 goto out;
1897
1898 for (i = 0; i < isp->num_of_streams; i++) {
1899 asd = &isp->asd[i];
1900 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
1901 continue;
1902 atomisp_setup_flash(asd);
1903 }
1904out:
1905 rt_mutex_unlock(&isp->mutex);
1906 for (i = 0; i < isp->num_of_streams; i++) {
1907 asd = &isp->asd[i];
1908 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED
1909 && css_pipe_done[asd->index]
1910 && isp->sw_contex.file_input)
1911 v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1912 video, s_stream, 1);
1913
1914 if (asd->acc.pipeline && css_pipe_done[asd->index])
1915 atomisp_css_acc_done(asd);
1916 }
1917 dev_dbg(isp->dev, "<%s\n", __func__);
1918
1919 return IRQ_HANDLED;
1920}
1921
1922
1923
1924
1925
1926int atomisp_get_frame_pgnr(struct atomisp_device *isp,
1927 const struct ia_css_frame *frame, u32 *p_pgnr)
1928{
1929 if (!frame) {
1930 dev_err(isp->dev, "%s: NULL frame pointer ERROR.\n", __func__);
1931 return -EINVAL;
1932 }
1933
1934 *p_pgnr = DIV_ROUND_UP(frame->data_bytes, PAGE_SIZE);
1935 return 0;
1936}
1937
1938
1939
1940
1941static enum ia_css_frame_format
1942v4l2_fmt_to_sh_fmt(u32 fmt)
1943{
1944 switch (fmt) {
1945 case V4L2_PIX_FMT_YUV420:
1946 return IA_CSS_FRAME_FORMAT_YUV420;
1947 case V4L2_PIX_FMT_YVU420:
1948 return IA_CSS_FRAME_FORMAT_YV12;
1949 case V4L2_PIX_FMT_YUV422P:
1950 return IA_CSS_FRAME_FORMAT_YUV422;
1951 case V4L2_PIX_FMT_YUV444:
1952 return IA_CSS_FRAME_FORMAT_YUV444;
1953 case V4L2_PIX_FMT_NV12:
1954 return IA_CSS_FRAME_FORMAT_NV12;
1955 case V4L2_PIX_FMT_NV21:
1956 return IA_CSS_FRAME_FORMAT_NV21;
1957 case V4L2_PIX_FMT_NV16:
1958 return IA_CSS_FRAME_FORMAT_NV16;
1959 case V4L2_PIX_FMT_NV61:
1960 return IA_CSS_FRAME_FORMAT_NV61;
1961 case V4L2_PIX_FMT_UYVY:
1962 return IA_CSS_FRAME_FORMAT_UYVY;
1963 case V4L2_PIX_FMT_YUYV:
1964 return IA_CSS_FRAME_FORMAT_YUYV;
1965 case V4L2_PIX_FMT_RGB24:
1966 return IA_CSS_FRAME_FORMAT_PLANAR_RGB888;
1967 case V4L2_PIX_FMT_RGB32:
1968 return IA_CSS_FRAME_FORMAT_RGBA888;
1969 case V4L2_PIX_FMT_RGB565:
1970 return IA_CSS_FRAME_FORMAT_RGB565;
1971 case V4L2_PIX_FMT_JPEG:
1972 case V4L2_PIX_FMT_CUSTOM_M10MO_RAW:
1973 return IA_CSS_FRAME_FORMAT_BINARY_8;
1974 case V4L2_PIX_FMT_SBGGR16:
1975 case V4L2_PIX_FMT_SBGGR10:
1976 case V4L2_PIX_FMT_SGBRG10:
1977 case V4L2_PIX_FMT_SGRBG10:
1978 case V4L2_PIX_FMT_SRGGB10:
1979 case V4L2_PIX_FMT_SBGGR12:
1980 case V4L2_PIX_FMT_SGBRG12:
1981 case V4L2_PIX_FMT_SGRBG12:
1982 case V4L2_PIX_FMT_SRGGB12:
1983 case V4L2_PIX_FMT_SBGGR8:
1984 case V4L2_PIX_FMT_SGBRG8:
1985 case V4L2_PIX_FMT_SGRBG8:
1986 case V4L2_PIX_FMT_SRGGB8:
1987 return IA_CSS_FRAME_FORMAT_RAW;
1988 default:
1989 return -EINVAL;
1990 }
1991}
1992
1993
1994
1995
1996static int raw_output_format_match_input(u32 input, u32 output)
1997{
1998 if ((input == ATOMISP_INPUT_FORMAT_RAW_12) &&
1999 ((output == V4L2_PIX_FMT_SRGGB12) ||
2000 (output == V4L2_PIX_FMT_SGRBG12) ||
2001 (output == V4L2_PIX_FMT_SBGGR12) ||
2002 (output == V4L2_PIX_FMT_SGBRG12)))
2003 return 0;
2004
2005 if ((input == ATOMISP_INPUT_FORMAT_RAW_10) &&
2006 ((output == V4L2_PIX_FMT_SRGGB10) ||
2007 (output == V4L2_PIX_FMT_SGRBG10) ||
2008 (output == V4L2_PIX_FMT_SBGGR10) ||
2009 (output == V4L2_PIX_FMT_SGBRG10)))
2010 return 0;
2011
2012 if ((input == ATOMISP_INPUT_FORMAT_RAW_8) &&
2013 ((output == V4L2_PIX_FMT_SRGGB8) ||
2014 (output == V4L2_PIX_FMT_SGRBG8) ||
2015 (output == V4L2_PIX_FMT_SBGGR8) ||
2016 (output == V4L2_PIX_FMT_SGBRG8)))
2017 return 0;
2018
2019 if ((input == ATOMISP_INPUT_FORMAT_RAW_16) && (output == V4L2_PIX_FMT_SBGGR16))
2020 return 0;
2021
2022 return -EINVAL;
2023}
2024
2025static u32 get_pixel_depth(u32 pixelformat)
2026{
2027 switch (pixelformat) {
2028 case V4L2_PIX_FMT_YUV420:
2029 case V4L2_PIX_FMT_NV12:
2030 case V4L2_PIX_FMT_NV21:
2031 case V4L2_PIX_FMT_YVU420:
2032 return 12;
2033 case V4L2_PIX_FMT_YUV422P:
2034 case V4L2_PIX_FMT_YUYV:
2035 case V4L2_PIX_FMT_UYVY:
2036 case V4L2_PIX_FMT_NV16:
2037 case V4L2_PIX_FMT_NV61:
2038 case V4L2_PIX_FMT_RGB565:
2039 case V4L2_PIX_FMT_SBGGR16:
2040 case V4L2_PIX_FMT_SBGGR12:
2041 case V4L2_PIX_FMT_SGBRG12:
2042 case V4L2_PIX_FMT_SGRBG12:
2043 case V4L2_PIX_FMT_SRGGB12:
2044 case V4L2_PIX_FMT_SBGGR10:
2045 case V4L2_PIX_FMT_SGBRG10:
2046 case V4L2_PIX_FMT_SGRBG10:
2047 case V4L2_PIX_FMT_SRGGB10:
2048 return 16;
2049 case V4L2_PIX_FMT_RGB24:
2050 case V4L2_PIX_FMT_YUV444:
2051 return 24;
2052 case V4L2_PIX_FMT_RGB32:
2053 return 32;
2054 case V4L2_PIX_FMT_JPEG:
2055 case V4L2_PIX_FMT_CUSTOM_M10MO_RAW:
2056 case V4L2_PIX_FMT_SBGGR8:
2057 case V4L2_PIX_FMT_SGBRG8:
2058 case V4L2_PIX_FMT_SGRBG8:
2059 case V4L2_PIX_FMT_SRGGB8:
2060 return 8;
2061 default:
2062 return 8 * 2;
2063 }
2064}
2065
2066bool atomisp_is_mbuscode_raw(uint32_t code)
2067{
2068 return code >= 0x3000 && code < 0x4000;
2069}
2070
2071
2072
2073
2074
2075
2076
2077
2078static void atomisp_update_capture_mode(struct atomisp_sub_device *asd)
2079{
2080 if (asd->params.gdc_cac_en)
2081 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_ADVANCED);
2082 else if (asd->params.low_light)
2083 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_LOW_LIGHT);
2084 else if (asd->video_out_capture.sh_fmt == IA_CSS_FRAME_FORMAT_RAW)
2085 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_RAW);
2086 else
2087 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_PRIMARY);
2088}
2089
2090
2091int atomisp_set_sensor_runmode(struct atomisp_sub_device *asd,
2092 struct atomisp_s_runmode *runmode)
2093{
2094 struct atomisp_device *isp = asd->isp;
2095 struct v4l2_ctrl *c;
2096 int ret = 0;
2097
2098 if (!(runmode && (runmode->mode & RUNMODE_MASK)))
2099 return -EINVAL;
2100
2101 mutex_lock(asd->ctrl_handler.lock);
2102 c = v4l2_ctrl_find(isp->inputs[asd->input_curr].camera->ctrl_handler,
2103 V4L2_CID_RUN_MODE);
2104
2105 if (c)
2106 ret = v4l2_ctrl_s_ctrl(c, runmode->mode);
2107
2108 mutex_unlock(asd->ctrl_handler.lock);
2109 return ret;
2110}
2111
2112
2113
2114
2115
2116int atomisp_gdc_cac(struct atomisp_sub_device *asd, int flag,
2117 __s32 *value)
2118{
2119 if (flag == 0) {
2120 *value = asd->params.gdc_cac_en;
2121 return 0;
2122 }
2123
2124 asd->params.gdc_cac_en = !!*value;
2125 if (asd->params.gdc_cac_en) {
2126 asd->params.config.morph_table = asd->params.css_param.morph_table;
2127 } else {
2128 asd->params.config.morph_table = NULL;
2129 }
2130 asd->params.css_update_params_needed = true;
2131 atomisp_update_capture_mode(asd);
2132 return 0;
2133}
2134
2135
2136
2137
2138int atomisp_low_light(struct atomisp_sub_device *asd, int flag,
2139 __s32 *value)
2140{
2141 if (flag == 0) {
2142 *value = asd->params.low_light;
2143 return 0;
2144 }
2145
2146 asd->params.low_light = (*value != 0);
2147 atomisp_update_capture_mode(asd);
2148 return 0;
2149}
2150
2151
2152
2153
2154
2155int atomisp_xnr(struct atomisp_sub_device *asd, int flag,
2156 int *xnr_enable)
2157{
2158 if (flag == 0) {
2159 *xnr_enable = asd->params.xnr_en;
2160 return 0;
2161 }
2162
2163 atomisp_css_capture_enable_xnr(asd, !!*xnr_enable);
2164
2165 return 0;
2166}
2167
2168
2169
2170
2171int atomisp_nr(struct atomisp_sub_device *asd, int flag,
2172 struct atomisp_nr_config *arg)
2173{
2174 if (flag == 0) {
2175
2176 if (atomisp_css_get_nr_config(asd, arg))
2177 return -EINVAL;
2178 } else {
2179
2180 memcpy(&asd->params.css_param.nr_config, arg,
2181 sizeof(struct ia_css_nr_config));
2182 asd->params.config.nr_config = &asd->params.css_param.nr_config;
2183 asd->params.css_update_params_needed = true;
2184 }
2185 return 0;
2186}
2187
2188
2189
2190
2191int atomisp_tnr(struct atomisp_sub_device *asd, int flag,
2192 struct atomisp_tnr_config *config)
2193{
2194
2195 if (flag == 0) {
2196
2197 if (atomisp_css_get_tnr_config(asd, config))
2198 return -EINVAL;
2199 } else {
2200
2201 memcpy(&asd->params.css_param.tnr_config, config,
2202 sizeof(struct ia_css_tnr_config));
2203 asd->params.config.tnr_config = &asd->params.css_param.tnr_config;
2204 asd->params.css_update_params_needed = true;
2205 }
2206
2207 return 0;
2208}
2209
2210
2211
2212
2213int atomisp_black_level(struct atomisp_sub_device *asd, int flag,
2214 struct atomisp_ob_config *config)
2215{
2216 if (flag == 0) {
2217
2218 if (atomisp_css_get_ob_config(asd, config))
2219 return -EINVAL;
2220 } else {
2221
2222 memcpy(&asd->params.css_param.ob_config, config,
2223 sizeof(struct ia_css_ob_config));
2224 asd->params.config.ob_config = &asd->params.css_param.ob_config;
2225 asd->params.css_update_params_needed = true;
2226 }
2227
2228 return 0;
2229}
2230
2231
2232
2233
2234int atomisp_ee(struct atomisp_sub_device *asd, int flag,
2235 struct atomisp_ee_config *config)
2236{
2237 if (flag == 0) {
2238
2239 if (atomisp_css_get_ee_config(asd, config))
2240 return -EINVAL;
2241 } else {
2242
2243 memcpy(&asd->params.css_param.ee_config, config,
2244 sizeof(asd->params.css_param.ee_config));
2245 asd->params.config.ee_config = &asd->params.css_param.ee_config;
2246 asd->params.css_update_params_needed = true;
2247 }
2248
2249 return 0;
2250}
2251
2252
2253
2254
2255int atomisp_gamma(struct atomisp_sub_device *asd, int flag,
2256 struct atomisp_gamma_table *config)
2257{
2258 if (flag == 0) {
2259
2260 if (atomisp_css_get_gamma_table(asd, config))
2261 return -EINVAL;
2262 } else {
2263
2264 memcpy(&asd->params.css_param.gamma_table, config,
2265 sizeof(asd->params.css_param.gamma_table));
2266 asd->params.config.gamma_table = &asd->params.css_param.gamma_table;
2267 }
2268
2269 return 0;
2270}
2271
2272
2273
2274
2275int atomisp_ctc(struct atomisp_sub_device *asd, int flag,
2276 struct atomisp_ctc_table *config)
2277{
2278 if (flag == 0) {
2279
2280 if (atomisp_css_get_ctc_table(asd, config))
2281 return -EINVAL;
2282 } else {
2283
2284 memcpy(&asd->params.css_param.ctc_table, config,
2285 sizeof(asd->params.css_param.ctc_table));
2286 atomisp_css_set_ctc_table(asd, &asd->params.css_param.ctc_table);
2287 }
2288
2289 return 0;
2290}
2291
2292
2293
2294
2295int atomisp_gamma_correction(struct atomisp_sub_device *asd, int flag,
2296 struct atomisp_gc_config *config)
2297{
2298 if (flag == 0) {
2299
2300 if (atomisp_css_get_gc_config(asd, config))
2301 return -EINVAL;
2302 } else {
2303
2304 memcpy(&asd->params.css_param.gc_config, config,
2305 sizeof(asd->params.css_param.gc_config));
2306 asd->params.config.gc_config = &asd->params.css_param.gc_config;
2307 asd->params.css_update_params_needed = true;
2308 }
2309
2310 return 0;
2311}
2312
2313
2314
2315
2316int atomisp_formats(struct atomisp_sub_device *asd, int flag,
2317 struct atomisp_formats_config *config)
2318{
2319 if (flag == 0) {
2320
2321 if (atomisp_css_get_formats_config(asd, config))
2322 return -EINVAL;
2323 } else {
2324
2325 memcpy(&asd->params.css_param.formats_config, config,
2326 sizeof(asd->params.css_param.formats_config));
2327 asd->params.config.formats_config = &asd->params.css_param.formats_config;
2328 }
2329
2330 return 0;
2331}
2332
2333void atomisp_free_internal_buffers(struct atomisp_sub_device *asd)
2334{
2335 atomisp_free_css_parameters(&asd->params.css_param);
2336
2337 if (asd->raw_output_frame) {
2338 ia_css_frame_free(asd->raw_output_frame);
2339 asd->raw_output_frame = NULL;
2340 }
2341}
2342
2343static void atomisp_update_grid_info(struct atomisp_sub_device *asd,
2344 enum ia_css_pipe_id pipe_id,
2345 int source_pad)
2346{
2347 struct atomisp_device *isp = asd->isp;
2348 int err;
2349 u16 stream_id = atomisp_source_pad_to_stream_id(asd, source_pad);
2350
2351 if (atomisp_css_get_grid_info(asd, pipe_id, source_pad))
2352 return;
2353
2354
2355
2356 atomisp_css_free_stat_buffers(asd);
2357
2358 err = atomisp_alloc_css_stat_bufs(asd, stream_id);
2359 if (err) {
2360 dev_err(isp->dev, "stat_buf allocate error\n");
2361 goto err;
2362 }
2363
2364 if (atomisp_alloc_3a_output_buf(asd)) {
2365
2366 if (asd->params.s3a_output_bytes != 0) {
2367
2368
2369 dev_err(isp->dev, "Failed to allocate memory for 3A statistics\n");
2370 }
2371 goto err;
2372 }
2373
2374 if (atomisp_alloc_dis_coef_buf(asd)) {
2375 dev_err(isp->dev,
2376 "Failed to allocate memory for DIS statistics\n");
2377 goto err;
2378 }
2379
2380 if (atomisp_alloc_metadata_output_buf(asd)) {
2381 dev_err(isp->dev, "Failed to allocate memory for metadata\n");
2382 goto err;
2383 }
2384
2385 return;
2386
2387err:
2388 atomisp_css_free_stat_buffers(asd);
2389 return;
2390}
2391
2392static void atomisp_curr_user_grid_info(struct atomisp_sub_device *asd,
2393 struct atomisp_grid_info *info)
2394{
2395 memcpy(info, &asd->params.curr_grid_info.s3a_grid,
2396 sizeof(struct ia_css_3a_grid_info));
2397}
2398
2399int atomisp_compare_grid(struct atomisp_sub_device *asd,
2400 struct atomisp_grid_info *atomgrid)
2401{
2402 struct atomisp_grid_info tmp = {0};
2403
2404 atomisp_curr_user_grid_info(asd, &tmp);
2405 return memcmp(atomgrid, &tmp, sizeof(tmp));
2406}
2407
2408
2409
2410
2411int atomisp_gdc_cac_table(struct atomisp_sub_device *asd, int flag,
2412 struct atomisp_morph_table *config)
2413{
2414 int ret;
2415 int i;
2416 struct atomisp_device *isp = asd->isp;
2417
2418 if (flag == 0) {
2419
2420 struct ia_css_morph_table tab = {0};
2421
2422 atomisp_css_get_morph_table(asd, &tab);
2423
2424 config->width = tab.width;
2425 config->height = tab.height;
2426
2427 for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
2428 ret = copy_to_user(config->coordinates_x[i],
2429 tab.coordinates_x[i], tab.height *
2430 tab.width * sizeof(*tab.coordinates_x[i]));
2431 if (ret) {
2432 dev_err(isp->dev,
2433 "Failed to copy to User for x\n");
2434 return -EFAULT;
2435 }
2436 ret = copy_to_user(config->coordinates_y[i],
2437 tab.coordinates_y[i], tab.height *
2438 tab.width * sizeof(*tab.coordinates_y[i]));
2439 if (ret) {
2440 dev_err(isp->dev,
2441 "Failed to copy to User for y\n");
2442 return -EFAULT;
2443 }
2444 }
2445 } else {
2446 struct ia_css_morph_table *tab =
2447 asd->params.css_param.morph_table;
2448
2449
2450 if (tab) {
2451 atomisp_css_morph_table_free(tab);
2452 asd->params.css_param.morph_table = NULL;
2453 }
2454
2455
2456 tab = atomisp_css_morph_table_allocate(config->width,
2457 config->height);
2458
2459 if (!tab) {
2460 dev_err(isp->dev, "out of memory\n");
2461 return -EINVAL;
2462 }
2463
2464 for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
2465 ret = copy_from_user(tab->coordinates_x[i],
2466 config->coordinates_x[i],
2467 config->height * config->width *
2468 sizeof(*config->coordinates_x[i]));
2469 if (ret) {
2470 dev_err(isp->dev,
2471 "Failed to copy from User for x, ret %d\n",
2472 ret);
2473 atomisp_css_morph_table_free(tab);
2474 return -EFAULT;
2475 }
2476 ret = copy_from_user(tab->coordinates_y[i],
2477 config->coordinates_y[i],
2478 config->height * config->width *
2479 sizeof(*config->coordinates_y[i]));
2480 if (ret) {
2481 dev_err(isp->dev,
2482 "Failed to copy from User for y, ret is %d\n",
2483 ret);
2484 atomisp_css_morph_table_free(tab);
2485 return -EFAULT;
2486 }
2487 }
2488 asd->params.css_param.morph_table = tab;
2489 if (asd->params.gdc_cac_en)
2490 asd->params.config.morph_table = tab;
2491 }
2492
2493 return 0;
2494}
2495
2496int atomisp_macc_table(struct atomisp_sub_device *asd, int flag,
2497 struct atomisp_macc_config *config)
2498{
2499 struct ia_css_macc_table *macc_table;
2500
2501 switch (config->color_effect) {
2502 case V4L2_COLORFX_NONE:
2503 macc_table = &asd->params.css_param.macc_table;
2504 break;
2505 case V4L2_COLORFX_SKY_BLUE:
2506 macc_table = &blue_macc_table;
2507 break;
2508 case V4L2_COLORFX_GRASS_GREEN:
2509 macc_table = &green_macc_table;
2510 break;
2511 case V4L2_COLORFX_SKIN_WHITEN_LOW:
2512 macc_table = &skin_low_macc_table;
2513 break;
2514 case V4L2_COLORFX_SKIN_WHITEN:
2515 macc_table = &skin_medium_macc_table;
2516 break;
2517 case V4L2_COLORFX_SKIN_WHITEN_HIGH:
2518 macc_table = &skin_high_macc_table;
2519 break;
2520 default:
2521 return -EINVAL;
2522 }
2523
2524 if (flag == 0) {
2525
2526 memcpy(&config->table, macc_table,
2527 sizeof(struct ia_css_macc_table));
2528 } else {
2529 memcpy(macc_table, &config->table,
2530 sizeof(struct ia_css_macc_table));
2531 if (config->color_effect == asd->params.color_effect)
2532 asd->params.config.macc_table = macc_table;
2533 }
2534
2535 return 0;
2536}
2537
2538int atomisp_set_dis_vector(struct atomisp_sub_device *asd,
2539 struct atomisp_dis_vector *vector)
2540{
2541 atomisp_css_video_set_dis_vector(asd, vector);
2542
2543 asd->params.dis_proj_data_valid = false;
2544 asd->params.css_update_params_needed = true;
2545 return 0;
2546}
2547
2548
2549
2550
2551int atomisp_get_dis_stat(struct atomisp_sub_device *asd,
2552 struct atomisp_dis_statistics *stats)
2553{
2554 return atomisp_css_get_dis_stat(asd, stats);
2555}
2556
2557
2558
2559
2560int atomisp_set_array_res(struct atomisp_sub_device *asd,
2561 struct atomisp_resolution *config)
2562{
2563 dev_dbg(asd->isp->dev, ">%s start\n", __func__);
2564 if (!config) {
2565 dev_err(asd->isp->dev, "Set sensor array size is not valid\n");
2566 return -EINVAL;
2567 }
2568
2569 asd->sensor_array_res.width = config->width;
2570 asd->sensor_array_res.height = config->height;
2571 return 0;
2572}
2573
2574
2575
2576
2577int atomisp_get_dvs2_bq_resolutions(struct atomisp_sub_device *asd,
2578 struct atomisp_dvs2_bq_resolutions *bq_res)
2579{
2580 struct ia_css_pipe_config *pipe_cfg = NULL;
2581 struct ia_css_stream_config *stream_cfg = NULL;
2582 struct ia_css_stream_input_config *input_config = NULL;
2583
2584 struct ia_css_stream *stream =
2585 asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream;
2586 if (!stream) {
2587 dev_warn(asd->isp->dev, "stream is not created");
2588 return -EAGAIN;
2589 }
2590
2591 pipe_cfg = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL]
2592 .pipe_configs[IA_CSS_PIPE_ID_VIDEO];
2593 stream_cfg = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL]
2594 .stream_config;
2595 input_config = &stream_cfg->input_config;
2596
2597 if (!bq_res)
2598 return -EINVAL;
2599
2600
2601 bq_res->output_bq.width_bq = pipe_cfg->output_info[0].res.width / 2;
2602 bq_res->output_bq.height_bq = pipe_cfg->output_info[0].res.height / 2;
2603
2604 bq_res->envelope_bq.width_bq = 0;
2605 bq_res->envelope_bq.height_bq = 0;
2606
2607 if (!asd->continuous_mode->val) {
2608 bq_res->source_bq.width_bq = bq_res->output_bq.width_bq +
2609 pipe_cfg->dvs_envelope.width / 2;
2610 bq_res->source_bq.height_bq = bq_res->output_bq.height_bq +
2611 pipe_cfg->dvs_envelope.height / 2;
2612
2613
2614
2615
2616
2617
2618 bq_res->ispfilter_bq.width_bq = 12 / 2;
2619 bq_res->ispfilter_bq.height_bq = 12 / 2;
2620
2621 bq_res->gdc_shift_bq.width_bq = 4 / 2;
2622 bq_res->gdc_shift_bq.height_bq = 4 / 2;
2623
2624 if (asd->params.video_dis_en) {
2625 bq_res->envelope_bq.width_bq = pipe_cfg->dvs_envelope.width
2626 / 2 - bq_res->ispfilter_bq.width_bq;
2627 bq_res->envelope_bq.height_bq = pipe_cfg->dvs_envelope.height
2628 / 2 - bq_res->ispfilter_bq.height_bq;
2629 }
2630 } else {
2631 unsigned int w_padding;
2632 unsigned int gdc_effective_input = 0;
2633
2634
2635
2636
2637
2638
2639
2640
2641 bq_res->source_bq.width_bq =
2642 (input_config->effective_res.width *
2643 pipe_cfg->bayer_ds_out_res.width /
2644 input_config->effective_res.width + 1) / 2;
2645 bq_res->source_bq.height_bq =
2646 (input_config->effective_res.height *
2647 pipe_cfg->bayer_ds_out_res.height /
2648 input_config->effective_res.height + 1) / 2;
2649
2650 if (!asd->params.video_dis_en) {
2651
2652
2653
2654
2655
2656
2657 bq_res->ispfilter_bq.width_bq = 128 *
2658 pipe_cfg->bayer_ds_out_res.width /
2659 input_config->effective_res.width / 2;
2660 bq_res->ispfilter_bq.height_bq = 128 *
2661 pipe_cfg->bayer_ds_out_res.width /
2662 input_config->effective_res.width / 2;
2663
2664 if (IS_HWREVISION(asd->isp, ATOMISP_HW_REVISION_ISP2401)) {
2665
2666 bq_res->gdc_shift_bq.width_bq = 4 / 2;
2667 bq_res->gdc_shift_bq.height_bq = 4 / 2;
2668 } else {
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679 gdc_effective_input =
2680 input_config->effective_res.width +
2681 pipe_cfg->dvs_envelope.width;
2682 w_padding = roundup(gdc_effective_input, 128) -
2683 input_config->effective_res.width;
2684 w_padding = w_padding *
2685 pipe_cfg->bayer_ds_out_res.width /
2686 input_config->effective_res.width + 1;
2687 w_padding = roundup(w_padding / 2, 1);
2688
2689 bq_res->gdc_shift_bq.width_bq = bq_res->ispfilter_bq.width_bq / 2
2690 + w_padding;
2691 bq_res->gdc_shift_bq.height_bq = 4 / 2;
2692 }
2693 } else {
2694 unsigned int dvs_w, dvs_h, dvs_w_max, dvs_h_max;
2695
2696 bq_res->ispfilter_bq.width_bq = 8 / 2;
2697 bq_res->ispfilter_bq.height_bq = 8 / 2;
2698
2699 if (IS_HWREVISION(asd->isp, ATOMISP_HW_REVISION_ISP2401)) {
2700
2701 bq_res->gdc_shift_bq.width_bq = 4 / 2;
2702 bq_res->gdc_shift_bq.height_bq = 4 / 2;
2703 } else {
2704 w_padding =
2705 roundup(input_config->effective_res.width, 128) -
2706 input_config->effective_res.width;
2707 if (w_padding < 12)
2708 w_padding = 12;
2709 bq_res->gdc_shift_bq.width_bq = 4 / 2 +
2710 ((w_padding - 12) *
2711 pipe_cfg->bayer_ds_out_res.width /
2712 input_config->effective_res.width + 1) / 2;
2713 bq_res->gdc_shift_bq.height_bq = 4 / 2;
2714 }
2715
2716 dvs_w = pipe_cfg->bayer_ds_out_res.width -
2717 pipe_cfg->output_info[0].res.width;
2718 dvs_h = pipe_cfg->bayer_ds_out_res.height -
2719 pipe_cfg->output_info[0].res.height;
2720 dvs_w_max = rounddown(
2721 pipe_cfg->output_info[0].res.width / 5,
2722 ATOM_ISP_STEP_WIDTH);
2723 dvs_h_max = rounddown(
2724 pipe_cfg->output_info[0].res.height / 5,
2725 ATOM_ISP_STEP_HEIGHT);
2726 bq_res->envelope_bq.width_bq =
2727 min((dvs_w / 2), (dvs_w_max / 2)) -
2728 bq_res->ispfilter_bq.width_bq;
2729 bq_res->envelope_bq.height_bq =
2730 min((dvs_h / 2), (dvs_h_max / 2)) -
2731 bq_res->ispfilter_bq.height_bq;
2732 }
2733 }
2734
2735 dev_dbg(asd->isp->dev,
2736 "source_bq.width_bq %d, source_bq.height_bq %d,\nispfilter_bq.width_bq %d, ispfilter_bq.height_bq %d,\ngdc_shift_bq.width_bq %d, gdc_shift_bq.height_bq %d,\nenvelope_bq.width_bq %d, envelope_bq.height_bq %d,\noutput_bq.width_bq %d, output_bq.height_bq %d\n",
2737 bq_res->source_bq.width_bq, bq_res->source_bq.height_bq,
2738 bq_res->ispfilter_bq.width_bq, bq_res->ispfilter_bq.height_bq,
2739 bq_res->gdc_shift_bq.width_bq, bq_res->gdc_shift_bq.height_bq,
2740 bq_res->envelope_bq.width_bq, bq_res->envelope_bq.height_bq,
2741 bq_res->output_bq.width_bq, bq_res->output_bq.height_bq);
2742
2743 return 0;
2744}
2745
2746int atomisp_set_dis_coefs(struct atomisp_sub_device *asd,
2747 struct atomisp_dis_coefficients *coefs)
2748{
2749 return atomisp_css_set_dis_coefs(asd, coefs);
2750}
2751
2752
2753
2754
2755int atomisp_3a_stat(struct atomisp_sub_device *asd, int flag,
2756 struct atomisp_3a_statistics *config)
2757{
2758 struct atomisp_device *isp = asd->isp;
2759 struct atomisp_s3a_buf *s3a_buf;
2760 unsigned long ret;
2761
2762 if (flag != 0)
2763 return -EINVAL;
2764
2765
2766 if (asd->params.s3a_output_bytes == 0)
2767 return -EINVAL;
2768
2769 if (atomisp_compare_grid(asd, &config->grid_info) != 0) {
2770
2771
2772
2773 return -EAGAIN;
2774 }
2775
2776 if (list_empty(&asd->s3a_stats_ready)) {
2777 dev_err(isp->dev, "3a statistics is not valid.\n");
2778 return -EAGAIN;
2779 }
2780
2781 s3a_buf = list_entry(asd->s3a_stats_ready.next,
2782 struct atomisp_s3a_buf, list);
2783 if (s3a_buf->s3a_map)
2784 ia_css_translate_3a_statistics(
2785 asd->params.s3a_user_stat, s3a_buf->s3a_map);
2786 else
2787 ia_css_get_3a_statistics(asd->params.s3a_user_stat,
2788 s3a_buf->s3a_data);
2789
2790 config->exp_id = s3a_buf->s3a_data->exp_id;
2791 config->isp_config_id = s3a_buf->s3a_data->isp_config_id;
2792
2793 ret = copy_to_user(config->data, asd->params.s3a_user_stat->data,
2794 asd->params.s3a_output_bytes);
2795 if (ret) {
2796 dev_err(isp->dev, "copy to user failed: copied %lu bytes\n",
2797 ret);
2798 return -EFAULT;
2799 }
2800
2801
2802 list_del_init(&s3a_buf->list);
2803 list_add_tail(&s3a_buf->list, &asd->s3a_stats);
2804 dev_dbg(isp->dev, "%s: finish getting exp_id %d 3a stat, isp_config_id %d\n",
2805 __func__,
2806 config->exp_id, config->isp_config_id);
2807 return 0;
2808}
2809
2810int atomisp_get_metadata(struct atomisp_sub_device *asd, int flag,
2811 struct atomisp_metadata *md)
2812{
2813 struct atomisp_device *isp = asd->isp;
2814 struct ia_css_stream_info *stream_info;
2815 struct camera_mipi_info *mipi_info;
2816 struct atomisp_metadata_buf *md_buf;
2817 enum atomisp_metadata_type md_type = ATOMISP_MAIN_METADATA;
2818 int ret, i;
2819
2820 if (flag != 0)
2821 return -EINVAL;
2822
2823 stream_info = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].
2824 stream_info;
2825
2826
2827
2828
2829 md->width = stream_info->metadata_info.resolution.width;
2830 md->height = stream_info->metadata_info.resolution.height;
2831 md->stride = stream_info->metadata_info.stride;
2832
2833
2834
2835
2836 if (md->width == 0 || md->height == 0 || !md->data)
2837 return 0;
2838
2839
2840 if (list_empty(&asd->metadata_ready[md_type])) {
2841 dev_warn(isp->dev, "Metadata queue is empty now!\n");
2842 return -EAGAIN;
2843 }
2844
2845 mipi_info = atomisp_to_sensor_mipi_info(
2846 isp->inputs[asd->input_curr].camera);
2847 if (!mipi_info)
2848 return -EINVAL;
2849
2850 if (mipi_info->metadata_effective_width) {
2851 for (i = 0; i < md->height; i++)
2852 md->effective_width[i] =
2853 mipi_info->metadata_effective_width[i];
2854 }
2855
2856 md_buf = list_entry(asd->metadata_ready[md_type].next,
2857 struct atomisp_metadata_buf, list);
2858 md->exp_id = md_buf->metadata->exp_id;
2859 if (md_buf->md_vptr) {
2860 ret = copy_to_user(md->data,
2861 md_buf->md_vptr,
2862 stream_info->metadata_info.size);
2863 } else {
2864 hmm_load(md_buf->metadata->address,
2865 asd->params.metadata_user[md_type],
2866 stream_info->metadata_info.size);
2867
2868 ret = copy_to_user(md->data,
2869 asd->params.metadata_user[md_type],
2870 stream_info->metadata_info.size);
2871 }
2872 if (ret) {
2873 dev_err(isp->dev, "copy to user failed: copied %d bytes\n",
2874 ret);
2875 return -EFAULT;
2876 }
2877
2878 list_del_init(&md_buf->list);
2879 list_add_tail(&md_buf->list, &asd->metadata[md_type]);
2880
2881 dev_dbg(isp->dev, "%s: HAL de-queued metadata type %d with exp_id %d\n",
2882 __func__, md_type, md->exp_id);
2883 return 0;
2884}
2885
2886int atomisp_get_metadata_by_type(struct atomisp_sub_device *asd, int flag,
2887 struct atomisp_metadata_with_type *md)
2888{
2889 struct atomisp_device *isp = asd->isp;
2890 struct ia_css_stream_info *stream_info;
2891 struct camera_mipi_info *mipi_info;
2892 struct atomisp_metadata_buf *md_buf;
2893 enum atomisp_metadata_type md_type;
2894 int ret, i;
2895
2896 if (flag != 0)
2897 return -EINVAL;
2898
2899 stream_info = &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].
2900 stream_info;
2901
2902
2903
2904
2905 md->width = stream_info->metadata_info.resolution.width;
2906 md->height = stream_info->metadata_info.resolution.height;
2907 md->stride = stream_info->metadata_info.stride;
2908
2909
2910
2911
2912 if (md->width == 0 || md->height == 0 || !md->data)
2913 return 0;
2914
2915 md_type = md->type;
2916 if (md_type < 0 || md_type >= ATOMISP_METADATA_TYPE_NUM)
2917 return -EINVAL;
2918
2919
2920 if (list_empty(&asd->metadata_ready[md_type])) {
2921 dev_warn(isp->dev, "Metadata queue is empty now!\n");
2922 return -EAGAIN;
2923 }
2924
2925 mipi_info = atomisp_to_sensor_mipi_info(
2926 isp->inputs[asd->input_curr].camera);
2927 if (!mipi_info)
2928 return -EINVAL;
2929
2930 if (mipi_info->metadata_effective_width) {
2931 for (i = 0; i < md->height; i++)
2932 md->effective_width[i] =
2933 mipi_info->metadata_effective_width[i];
2934 }
2935
2936 md_buf = list_entry(asd->metadata_ready[md_type].next,
2937 struct atomisp_metadata_buf, list);
2938 md->exp_id = md_buf->metadata->exp_id;
2939 if (md_buf->md_vptr) {
2940 ret = copy_to_user(md->data,
2941 md_buf->md_vptr,
2942 stream_info->metadata_info.size);
2943 } else {
2944 hmm_load(md_buf->metadata->address,
2945 asd->params.metadata_user[md_type],
2946 stream_info->metadata_info.size);
2947
2948 ret = copy_to_user(md->data,
2949 asd->params.metadata_user[md_type],
2950 stream_info->metadata_info.size);
2951 }
2952 if (ret) {
2953 dev_err(isp->dev, "copy to user failed: copied %d bytes\n",
2954 ret);
2955 return -EFAULT;
2956 } else {
2957 list_del_init(&md_buf->list);
2958 list_add_tail(&md_buf->list, &asd->metadata[md_type]);
2959 }
2960 dev_dbg(isp->dev, "%s: HAL de-queued metadata type %d with exp_id %d\n",
2961 __func__, md_type, md->exp_id);
2962 return 0;
2963}
2964
2965
2966
2967
2968int atomisp_calculate_real_zoom_region(struct atomisp_sub_device *asd,
2969 struct ia_css_dz_config *dz_config,
2970 enum ia_css_pipe_id css_pipe_id)
2971
2972{
2973 struct atomisp_stream_env *stream_env =
2974 &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL];
2975 struct atomisp_resolution eff_res, out_res;
2976 int w_offset, h_offset;
2977
2978 memset(&eff_res, 0, sizeof(eff_res));
2979 memset(&out_res, 0, sizeof(out_res));
2980
2981 if (dz_config->dx || dz_config->dy)
2982 return 0;
2983
2984 if (css_pipe_id != IA_CSS_PIPE_ID_PREVIEW
2985 && css_pipe_id != IA_CSS_PIPE_ID_CAPTURE) {
2986 dev_err(asd->isp->dev, "%s the set pipe no support crop region"
2987 , __func__);
2988 return -EINVAL;
2989 }
2990
2991 eff_res.width =
2992 stream_env->stream_config.input_config.effective_res.width;
2993 eff_res.height =
2994 stream_env->stream_config.input_config.effective_res.height;
2995 if (eff_res.width == 0 || eff_res.height == 0) {
2996 dev_err(asd->isp->dev, "%s err effective resolution"
2997 , __func__);
2998 return -EINVAL;
2999 }
3000
3001 if (dz_config->zoom_region.resolution.width
3002 == asd->sensor_array_res.width
3003 || dz_config->zoom_region.resolution.height
3004 == asd->sensor_array_res.height) {
3005
3006 dz_config->zoom_region.origin.x = 0;
3007 dz_config->zoom_region.origin.y = 0;
3008 dz_config->zoom_region.resolution.width = eff_res.width;
3009 dz_config->zoom_region.resolution.height = eff_res.height;
3010 return 0;
3011 }
3012
3013
3014
3015
3016
3017
3018
3019 if (!IS_ISP2401) {
3020 dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x
3021 * eff_res.width
3022 / asd->sensor_array_res.width;
3023 dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y
3024 * eff_res.height
3025 / asd->sensor_array_res.height;
3026 dz_config->zoom_region.resolution.width = dz_config->zoom_region.resolution.width
3027 * eff_res.width
3028 / asd->sensor_array_res.width;
3029 dz_config->zoom_region.resolution.height = dz_config->zoom_region.resolution.height
3030 * eff_res.height
3031 / asd->sensor_array_res.height;
3032
3033
3034
3035
3036 out_res.width = stream_env->pipe_configs[css_pipe_id].output_info[0].res.width;
3037 out_res.height = stream_env->pipe_configs[css_pipe_id].output_info[0].res.height;
3038 if (out_res.width == 0 || out_res.height == 0) {
3039 dev_err(asd->isp->dev, "%s err current pipe output resolution"
3040 , __func__);
3041 return -EINVAL;
3042 }
3043 } else {
3044 out_res.width = stream_env->pipe_configs[css_pipe_id].output_info[0].res.width;
3045 out_res.height = stream_env->pipe_configs[css_pipe_id].output_info[0].res.height;
3046 if (out_res.width == 0 || out_res.height == 0) {
3047 dev_err(asd->isp->dev, "%s err current pipe output resolution"
3048 , __func__);
3049 return -EINVAL;
3050 }
3051
3052 if (asd->sensor_array_res.width * out_res.height
3053 < out_res.width * asd->sensor_array_res.height) {
3054 h_offset = asd->sensor_array_res.height
3055 - asd->sensor_array_res.width
3056 * out_res.height / out_res.width;
3057 h_offset = h_offset / 2;
3058 if (dz_config->zoom_region.origin.y < h_offset)
3059 dz_config->zoom_region.origin.y = 0;
3060 else
3061 dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y - h_offset;
3062 w_offset = 0;
3063 } else {
3064 w_offset = asd->sensor_array_res.width
3065 - asd->sensor_array_res.height
3066 * out_res.width / out_res.height;
3067 w_offset = w_offset / 2;
3068 if (dz_config->zoom_region.origin.x < w_offset)
3069 dz_config->zoom_region.origin.x = 0;
3070 else
3071 dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x - w_offset;
3072 h_offset = 0;
3073 }
3074 dz_config->zoom_region.origin.x = dz_config->zoom_region.origin.x
3075 * eff_res.width
3076 / (asd->sensor_array_res.width - 2 * w_offset);
3077 dz_config->zoom_region.origin.y = dz_config->zoom_region.origin.y
3078 * eff_res.height
3079 / (asd->sensor_array_res.height - 2 * h_offset);
3080 dz_config->zoom_region.resolution.width = dz_config->zoom_region.resolution.width
3081 * eff_res.width
3082 / (asd->sensor_array_res.width - 2 * w_offset);
3083 dz_config->zoom_region.resolution.height = dz_config->zoom_region.resolution.height
3084 * eff_res.height
3085 / (asd->sensor_array_res.height - 2 * h_offset);
3086 }
3087
3088 if (out_res.width * dz_config->zoom_region.resolution.height
3089 > dz_config->zoom_region.resolution.width * out_res.height) {
3090 dz_config->zoom_region.resolution.height =
3091 dz_config->zoom_region.resolution.width
3092 * out_res.height / out_res.width;
3093 } else {
3094 dz_config->zoom_region.resolution.width =
3095 dz_config->zoom_region.resolution.height
3096 * out_res.width / out_res.height;
3097 }
3098 dev_dbg(asd->isp->dev,
3099 "%s crop region:(%d,%d),(%d,%d) eff_res(%d, %d) array_size(%d,%d) out_res(%d, %d)\n",
3100 __func__, dz_config->zoom_region.origin.x,
3101 dz_config->zoom_region.origin.y,
3102 dz_config->zoom_region.resolution.width,
3103 dz_config->zoom_region.resolution.height,
3104 eff_res.width, eff_res.height,
3105 asd->sensor_array_res.width,
3106 asd->sensor_array_res.height,
3107 out_res.width, out_res.height);
3108
3109 if ((dz_config->zoom_region.origin.x +
3110 dz_config->zoom_region.resolution.width
3111 > eff_res.width) ||
3112 (dz_config->zoom_region.origin.y +
3113 dz_config->zoom_region.resolution.height
3114 > eff_res.height))
3115 return -EINVAL;
3116
3117 return 0;
3118}
3119
3120
3121
3122
3123static bool atomisp_check_zoom_region(
3124 struct atomisp_sub_device *asd,
3125 struct ia_css_dz_config *dz_config)
3126{
3127 struct atomisp_resolution config;
3128 bool flag = false;
3129 unsigned int w, h;
3130
3131 memset(&config, 0, sizeof(struct atomisp_resolution));
3132
3133 if (dz_config->dx && dz_config->dy)
3134 return true;
3135
3136 config.width = asd->sensor_array_res.width;
3137 config.height = asd->sensor_array_res.height;
3138 w = dz_config->zoom_region.origin.x +
3139 dz_config->zoom_region.resolution.width;
3140 h = dz_config->zoom_region.origin.y +
3141 dz_config->zoom_region.resolution.height;
3142
3143 if ((w <= config.width) && (h <= config.height) && w > 0 && h > 0)
3144 flag = true;
3145 else
3146
3147 dev_err(asd->isp->dev,
3148 "%s zoom region ERROR:dz_config:(%d,%d),(%d,%d)array_res(%d, %d)\n",
3149 __func__, dz_config->zoom_region.origin.x,
3150 dz_config->zoom_region.origin.y,
3151 dz_config->zoom_region.resolution.width,
3152 dz_config->zoom_region.resolution.height,
3153 config.width, config.height);
3154
3155 return flag;
3156}
3157
3158void atomisp_apply_css_parameters(
3159 struct atomisp_sub_device *asd,
3160 struct atomisp_css_params *css_param)
3161{
3162 if (css_param->update_flag.wb_config)
3163 asd->params.config.wb_config = &css_param->wb_config;
3164
3165 if (css_param->update_flag.ob_config)
3166 asd->params.config.ob_config = &css_param->ob_config;
3167
3168 if (css_param->update_flag.dp_config)
3169 asd->params.config.dp_config = &css_param->dp_config;
3170
3171 if (css_param->update_flag.nr_config)
3172 asd->params.config.nr_config = &css_param->nr_config;
3173
3174 if (css_param->update_flag.ee_config)
3175 asd->params.config.ee_config = &css_param->ee_config;
3176
3177 if (css_param->update_flag.tnr_config)
3178 asd->params.config.tnr_config = &css_param->tnr_config;
3179
3180 if (css_param->update_flag.a3a_config)
3181 asd->params.config.s3a_config = &css_param->s3a_config;
3182
3183 if (css_param->update_flag.ctc_config)
3184 asd->params.config.ctc_config = &css_param->ctc_config;
3185
3186 if (css_param->update_flag.cnr_config)
3187 asd->params.config.cnr_config = &css_param->cnr_config;
3188
3189 if (css_param->update_flag.ecd_config)
3190 asd->params.config.ecd_config = &css_param->ecd_config;
3191
3192 if (css_param->update_flag.ynr_config)
3193 asd->params.config.ynr_config = &css_param->ynr_config;
3194
3195 if (css_param->update_flag.fc_config)
3196 asd->params.config.fc_config = &css_param->fc_config;
3197
3198 if (css_param->update_flag.macc_config)
3199 asd->params.config.macc_config = &css_param->macc_config;
3200
3201 if (css_param->update_flag.aa_config)
3202 asd->params.config.aa_config = &css_param->aa_config;
3203
3204 if (css_param->update_flag.anr_config)
3205 asd->params.config.anr_config = &css_param->anr_config;
3206
3207 if (css_param->update_flag.xnr_config)
3208 asd->params.config.xnr_config = &css_param->xnr_config;
3209
3210 if (css_param->update_flag.yuv2rgb_cc_config)
3211 asd->params.config.yuv2rgb_cc_config = &css_param->yuv2rgb_cc_config;
3212
3213 if (css_param->update_flag.rgb2yuv_cc_config)
3214 asd->params.config.rgb2yuv_cc_config = &css_param->rgb2yuv_cc_config;
3215
3216 if (css_param->update_flag.macc_table)
3217 asd->params.config.macc_table = &css_param->macc_table;
3218
3219 if (css_param->update_flag.xnr_table)
3220 asd->params.config.xnr_table = &css_param->xnr_table;
3221
3222 if (css_param->update_flag.r_gamma_table)
3223 asd->params.config.r_gamma_table = &css_param->r_gamma_table;
3224
3225 if (css_param->update_flag.g_gamma_table)
3226 asd->params.config.g_gamma_table = &css_param->g_gamma_table;
3227
3228 if (css_param->update_flag.b_gamma_table)
3229 asd->params.config.b_gamma_table = &css_param->b_gamma_table;
3230
3231 if (css_param->update_flag.anr_thres)
3232 atomisp_css_set_anr_thres(asd, &css_param->anr_thres);
3233
3234 if (css_param->update_flag.shading_table)
3235 asd->params.config.shading_table = css_param->shading_table;
3236
3237 if (css_param->update_flag.morph_table && asd->params.gdc_cac_en)
3238 asd->params.config.morph_table = css_param->morph_table;
3239
3240 if (css_param->update_flag.dvs2_coefs) {
3241 struct ia_css_dvs_grid_info *dvs_grid_info =
3242 atomisp_css_get_dvs_grid_info(
3243 &asd->params.curr_grid_info);
3244
3245 if (dvs_grid_info && dvs_grid_info->enable)
3246 atomisp_css_set_dvs2_coefs(asd, css_param->dvs2_coeff);
3247 }
3248
3249 if (css_param->update_flag.dvs_6axis_config)
3250 atomisp_css_set_dvs_6axis(asd, css_param->dvs_6axis);
3251
3252 atomisp_css_set_isp_config_id(asd, css_param->isp_config_id);
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264}
3265
3266static unsigned int long copy_from_compatible(void *to, const void *from,
3267 unsigned long n, bool from_user)
3268{
3269 if (from_user)
3270 return copy_from_user(to, (void __user *)from, n);
3271 else
3272 memcpy(to, from, n);
3273 return 0;
3274}
3275
3276int atomisp_cp_general_isp_parameters(struct atomisp_sub_device *asd,
3277 struct atomisp_parameters *arg,
3278 struct atomisp_css_params *css_param,
3279 bool from_user)
3280{
3281 struct atomisp_parameters *cur_config = &css_param->update_flag;
3282
3283 if (!arg || !asd || !css_param)
3284 return -EINVAL;
3285
3286 if (arg->wb_config && (from_user || !cur_config->wb_config)) {
3287 if (copy_from_compatible(&css_param->wb_config, arg->wb_config,
3288 sizeof(struct ia_css_wb_config),
3289 from_user))
3290 return -EFAULT;
3291 css_param->update_flag.wb_config =
3292 (struct atomisp_wb_config *)&css_param->wb_config;
3293 }
3294
3295 if (arg->ob_config && (from_user || !cur_config->ob_config)) {
3296 if (copy_from_compatible(&css_param->ob_config, arg->ob_config,
3297 sizeof(struct ia_css_ob_config),
3298 from_user))
3299 return -EFAULT;
3300 css_param->update_flag.ob_config =
3301 (struct atomisp_ob_config *)&css_param->ob_config;
3302 }
3303
3304 if (arg->dp_config && (from_user || !cur_config->dp_config)) {
3305 if (copy_from_compatible(&css_param->dp_config, arg->dp_config,
3306 sizeof(struct ia_css_dp_config),
3307 from_user))
3308 return -EFAULT;
3309 css_param->update_flag.dp_config =
3310 (struct atomisp_dp_config *)&css_param->dp_config;
3311 }
3312
3313 if (asd->run_mode->val != ATOMISP_RUN_MODE_VIDEO) {
3314 if (arg->dz_config && (from_user || !cur_config->dz_config)) {
3315 if (copy_from_compatible(&css_param->dz_config,
3316 arg->dz_config,
3317 sizeof(struct ia_css_dz_config),
3318 from_user))
3319 return -EFAULT;
3320 if (!atomisp_check_zoom_region(asd,
3321 &css_param->dz_config)) {
3322 dev_err(asd->isp->dev, "crop region error!");
3323 return -EINVAL;
3324 }
3325 css_param->update_flag.dz_config =
3326 (struct atomisp_dz_config *)
3327 &css_param->dz_config;
3328 }
3329 }
3330
3331 if (arg->nr_config && (from_user || !cur_config->nr_config)) {
3332 if (copy_from_compatible(&css_param->nr_config, arg->nr_config,
3333 sizeof(struct ia_css_nr_config),
3334 from_user))
3335 return -EFAULT;
3336 css_param->update_flag.nr_config =
3337 (struct atomisp_nr_config *)&css_param->nr_config;
3338 }
3339
3340 if (arg->ee_config && (from_user || !cur_config->ee_config)) {
3341 if (copy_from_compatible(&css_param->ee_config, arg->ee_config,
3342 sizeof(struct ia_css_ee_config),
3343 from_user))
3344 return -EFAULT;
3345 css_param->update_flag.ee_config =
3346 (struct atomisp_ee_config *)&css_param->ee_config;
3347 }
3348
3349 if (arg->tnr_config && (from_user || !cur_config->tnr_config)) {
3350 if (copy_from_compatible(&css_param->tnr_config,
3351 arg->tnr_config,
3352 sizeof(struct ia_css_tnr_config),
3353 from_user))
3354 return -EFAULT;
3355 css_param->update_flag.tnr_config =
3356 (struct atomisp_tnr_config *)
3357 &css_param->tnr_config;
3358 }
3359
3360 if (arg->a3a_config && (from_user || !cur_config->a3a_config)) {
3361 if (copy_from_compatible(&css_param->s3a_config,
3362 arg->a3a_config,
3363 sizeof(struct ia_css_3a_config),
3364 from_user))
3365 return -EFAULT;
3366 css_param->update_flag.a3a_config =
3367 (struct atomisp_3a_config *)&css_param->s3a_config;
3368 }
3369
3370 if (arg->ctc_config && (from_user || !cur_config->ctc_config)) {
3371 if (copy_from_compatible(&css_param->ctc_config,
3372 arg->ctc_config,
3373 sizeof(struct ia_css_ctc_config),
3374 from_user))
3375 return -EFAULT;
3376 css_param->update_flag.ctc_config =
3377 (struct atomisp_ctc_config *)
3378 &css_param->ctc_config;
3379 }
3380
3381 if (arg->cnr_config && (from_user || !cur_config->cnr_config)) {
3382 if (copy_from_compatible(&css_param->cnr_config,
3383 arg->cnr_config,
3384 sizeof(struct ia_css_cnr_config),
3385 from_user))
3386 return -EFAULT;
3387 css_param->update_flag.cnr_config =
3388 (struct atomisp_cnr_config *)
3389 &css_param->cnr_config;
3390 }
3391
3392 if (arg->ecd_config && (from_user || !cur_config->ecd_config)) {
3393 if (copy_from_compatible(&css_param->ecd_config,
3394 arg->ecd_config,
3395 sizeof(struct ia_css_ecd_config),
3396 from_user))
3397 return -EFAULT;
3398 css_param->update_flag.ecd_config =
3399 (struct atomisp_ecd_config *)
3400 &css_param->ecd_config;
3401 }
3402
3403 if (arg->ynr_config && (from_user || !cur_config->ynr_config)) {
3404 if (copy_from_compatible(&css_param->ynr_config,
3405 arg->ynr_config,
3406 sizeof(struct ia_css_ynr_config),
3407 from_user))
3408 return -EFAULT;
3409 css_param->update_flag.ynr_config =
3410 (struct atomisp_ynr_config *)
3411 &css_param->ynr_config;
3412 }
3413
3414 if (arg->fc_config && (from_user || !cur_config->fc_config)) {
3415 if (copy_from_compatible(&css_param->fc_config,
3416 arg->fc_config,
3417 sizeof(struct ia_css_fc_config),
3418 from_user))
3419 return -EFAULT;
3420 css_param->update_flag.fc_config =
3421 (struct atomisp_fc_config *)&css_param->fc_config;
3422 }
3423
3424 if (arg->macc_config && (from_user || !cur_config->macc_config)) {
3425 if (copy_from_compatible(&css_param->macc_config,
3426 arg->macc_config,
3427 sizeof(struct ia_css_macc_config),
3428 from_user))
3429 return -EFAULT;
3430 css_param->update_flag.macc_config =
3431 (struct atomisp_macc_config *)
3432 &css_param->macc_config;
3433 }
3434
3435 if (arg->aa_config && (from_user || !cur_config->aa_config)) {
3436 if (copy_from_compatible(&css_param->aa_config, arg->aa_config,
3437 sizeof(struct ia_css_aa_config),
3438 from_user))
3439 return -EFAULT;
3440 css_param->update_flag.aa_config =
3441 (struct atomisp_aa_config *)&css_param->aa_config;
3442 }
3443
3444 if (arg->anr_config && (from_user || !cur_config->anr_config)) {
3445 if (copy_from_compatible(&css_param->anr_config,
3446 arg->anr_config,
3447 sizeof(struct ia_css_anr_config),
3448 from_user))
3449 return -EFAULT;
3450 css_param->update_flag.anr_config =
3451 (struct atomisp_anr_config *)
3452 &css_param->anr_config;
3453 }
3454
3455 if (arg->xnr_config && (from_user || !cur_config->xnr_config)) {
3456 if (copy_from_compatible(&css_param->xnr_config,
3457 arg->xnr_config,
3458 sizeof(struct ia_css_xnr_config),
3459 from_user))
3460 return -EFAULT;
3461 css_param->update_flag.xnr_config =
3462 (struct atomisp_xnr_config *)
3463 &css_param->xnr_config;
3464 }
3465
3466 if (arg->yuv2rgb_cc_config &&
3467 (from_user || !cur_config->yuv2rgb_cc_config)) {
3468 if (copy_from_compatible(&css_param->yuv2rgb_cc_config,
3469 arg->yuv2rgb_cc_config,
3470 sizeof(struct ia_css_cc_config),
3471 from_user))
3472 return -EFAULT;
3473 css_param->update_flag.yuv2rgb_cc_config =
3474 (struct atomisp_cc_config *)
3475 &css_param->yuv2rgb_cc_config;
3476 }
3477
3478 if (arg->rgb2yuv_cc_config &&
3479 (from_user || !cur_config->rgb2yuv_cc_config)) {
3480 if (copy_from_compatible(&css_param->rgb2yuv_cc_config,
3481 arg->rgb2yuv_cc_config,
3482 sizeof(struct ia_css_cc_config),
3483 from_user))
3484 return -EFAULT;
3485 css_param->update_flag.rgb2yuv_cc_config =
3486 (struct atomisp_cc_config *)
3487 &css_param->rgb2yuv_cc_config;
3488 }
3489
3490 if (arg->macc_table && (from_user || !cur_config->macc_table)) {
3491 if (copy_from_compatible(&css_param->macc_table,
3492 arg->macc_table,
3493 sizeof(struct ia_css_macc_table),
3494 from_user))
3495 return -EFAULT;
3496 css_param->update_flag.macc_table =
3497 (struct atomisp_macc_table *)
3498 &css_param->macc_table;
3499 }
3500
3501 if (arg->xnr_table && (from_user || !cur_config->xnr_table)) {
3502 if (copy_from_compatible(&css_param->xnr_table,
3503 arg->xnr_table,
3504 sizeof(struct ia_css_xnr_table),
3505 from_user))
3506 return -EFAULT;
3507 css_param->update_flag.xnr_table =
3508 (struct atomisp_xnr_table *)&css_param->xnr_table;
3509 }
3510
3511 if (arg->r_gamma_table && (from_user || !cur_config->r_gamma_table)) {
3512 if (copy_from_compatible(&css_param->r_gamma_table,
3513 arg->r_gamma_table,
3514 sizeof(struct ia_css_rgb_gamma_table),
3515 from_user))
3516 return -EFAULT;
3517 css_param->update_flag.r_gamma_table =
3518 (struct atomisp_rgb_gamma_table *)
3519 &css_param->r_gamma_table;
3520 }
3521
3522 if (arg->g_gamma_table && (from_user || !cur_config->g_gamma_table)) {
3523 if (copy_from_compatible(&css_param->g_gamma_table,
3524 arg->g_gamma_table,
3525 sizeof(struct ia_css_rgb_gamma_table),
3526 from_user))
3527 return -EFAULT;
3528 css_param->update_flag.g_gamma_table =
3529 (struct atomisp_rgb_gamma_table *)
3530 &css_param->g_gamma_table;
3531 }
3532
3533 if (arg->b_gamma_table && (from_user || !cur_config->b_gamma_table)) {
3534 if (copy_from_compatible(&css_param->b_gamma_table,
3535 arg->b_gamma_table,
3536 sizeof(struct ia_css_rgb_gamma_table),
3537 from_user))
3538 return -EFAULT;
3539 css_param->update_flag.b_gamma_table =
3540 (struct atomisp_rgb_gamma_table *)
3541 &css_param->b_gamma_table;
3542 }
3543
3544 if (arg->anr_thres && (from_user || !cur_config->anr_thres)) {
3545 if (copy_from_compatible(&css_param->anr_thres, arg->anr_thres,
3546 sizeof(struct ia_css_anr_thres),
3547 from_user))
3548 return -EFAULT;
3549 css_param->update_flag.anr_thres =
3550 (struct atomisp_anr_thres *)&css_param->anr_thres;
3551 }
3552
3553 if (from_user)
3554 css_param->isp_config_id = arg->isp_config_id;
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566 return 0;
3567}
3568
3569int atomisp_cp_lsc_table(struct atomisp_sub_device *asd,
3570 struct atomisp_shading_table *source_st,
3571 struct atomisp_css_params *css_param,
3572 bool from_user)
3573{
3574 unsigned int i;
3575 unsigned int len_table;
3576 struct ia_css_shading_table *shading_table;
3577 struct ia_css_shading_table *old_table;
3578 struct atomisp_shading_table *st, dest_st;
3579
3580 if (!source_st)
3581 return 0;
3582
3583 if (!css_param)
3584 return -EINVAL;
3585
3586 if (!from_user && css_param->update_flag.shading_table)
3587 return 0;
3588
3589 if (IS_ISP2401) {
3590 if (copy_from_compatible(&dest_st, source_st,
3591 sizeof(struct atomisp_shading_table),
3592 from_user)) {
3593 dev_err(asd->isp->dev, "copy shading table failed!");
3594 return -EFAULT;
3595 }
3596 st = &dest_st;
3597 } else {
3598 st = source_st;
3599 }
3600
3601 old_table = css_param->shading_table;
3602
3603
3604 if (!st->enable) {
3605
3606 shading_table = atomisp_css_shading_table_alloc(1, 1);
3607 if (!shading_table)
3608 return -ENOMEM;
3609 shading_table->enable = 0;
3610 goto set_lsc;
3611 }
3612
3613
3614 for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3615 if (!st->data[i]) {
3616 dev_err(asd->isp->dev, "shading table validate failed");
3617 return -EINVAL;
3618 }
3619 }
3620
3621
3622 if (!IS_ISP2401) {
3623 if (st->width > ISP2400_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
3624 st->height > ISP2400_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR) {
3625 dev_err(asd->isp->dev, "shading table w/h validate failed!");
3626 return -EINVAL;
3627 }
3628 } else {
3629 if (st->width > ISP2401_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
3630 st->height > ISP2401_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR) {
3631 dev_err(asd->isp->dev, "shading table w/h validate failed!");
3632 return -EINVAL;
3633 }
3634 }
3635
3636 shading_table = atomisp_css_shading_table_alloc(st->width, st->height);
3637 if (!shading_table)
3638 return -ENOMEM;
3639
3640 len_table = st->width * st->height * ATOMISP_SC_TYPE_SIZE;
3641 for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3642 if (copy_from_compatible(shading_table->data[i],
3643 st->data[i], len_table, from_user)) {
3644 atomisp_css_shading_table_free(shading_table);
3645 return -EFAULT;
3646 }
3647 }
3648 shading_table->sensor_width = st->sensor_width;
3649 shading_table->sensor_height = st->sensor_height;
3650 shading_table->fraction_bits = st->fraction_bits;
3651 shading_table->enable = st->enable;
3652
3653
3654 if (old_table &&
3655 old_table->sensor_width == shading_table->sensor_width &&
3656 old_table->sensor_height == shading_table->sensor_height &&
3657 old_table->width == shading_table->width &&
3658 old_table->height == shading_table->height &&
3659 old_table->fraction_bits == shading_table->fraction_bits &&
3660 old_table->enable == shading_table->enable) {
3661 bool data_is_same = true;
3662
3663 for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
3664 if (memcmp(shading_table->data[i], old_table->data[i],
3665 len_table) != 0) {
3666 data_is_same = false;
3667 break;
3668 }
3669 }
3670
3671 if (data_is_same) {
3672 atomisp_css_shading_table_free(shading_table);
3673 return 0;
3674 }
3675 }
3676
3677set_lsc:
3678
3679 css_param->shading_table = shading_table;
3680 css_param->update_flag.shading_table = (struct atomisp_shading_table *)shading_table;
3681 asd->params.sc_en = shading_table;
3682
3683 if (old_table)
3684 atomisp_css_shading_table_free(old_table);
3685
3686 return 0;
3687}
3688
3689int atomisp_css_cp_dvs2_coefs(struct atomisp_sub_device *asd,
3690 struct ia_css_dvs2_coefficients *coefs,
3691 struct atomisp_css_params *css_param,
3692 bool from_user)
3693{
3694 struct ia_css_dvs_grid_info *cur =
3695 atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
3696 int dvs_hor_coef_bytes, dvs_ver_coef_bytes;
3697 struct ia_css_dvs2_coefficients dvs2_coefs;
3698
3699 if (!coefs || !cur)
3700 return 0;
3701
3702 if (!from_user && css_param->update_flag.dvs2_coefs)
3703 return 0;
3704
3705 if (!IS_ISP2401) {
3706 if (sizeof(*cur) != sizeof(coefs->grid) ||
3707 memcmp(&coefs->grid, cur, sizeof(coefs->grid))) {
3708 dev_err(asd->isp->dev, "dvs grid mis-match!\n");
3709
3710
3711
3712 return -EAGAIN;
3713 }
3714
3715 if (!coefs->hor_coefs.odd_real ||
3716 !coefs->hor_coefs.odd_imag ||
3717 !coefs->hor_coefs.even_real ||
3718 !coefs->hor_coefs.even_imag ||
3719 !coefs->ver_coefs.odd_real ||
3720 !coefs->ver_coefs.odd_imag ||
3721 !coefs->ver_coefs.even_real ||
3722 !coefs->ver_coefs.even_imag)
3723 return -EINVAL;
3724
3725 if (!css_param->dvs2_coeff) {
3726
3727 css_param->dvs2_coeff = ia_css_dvs2_coefficients_allocate(cur);
3728 if (!css_param->dvs2_coeff)
3729 return -ENOMEM;
3730 }
3731
3732 dvs_hor_coef_bytes = asd->params.dvs_hor_coef_bytes;
3733 dvs_ver_coef_bytes = asd->params.dvs_ver_coef_bytes;
3734 if (copy_from_compatible(css_param->dvs2_coeff->hor_coefs.odd_real,
3735 coefs->hor_coefs.odd_real, dvs_hor_coef_bytes, from_user) ||
3736 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.odd_imag,
3737 coefs->hor_coefs.odd_imag, dvs_hor_coef_bytes, from_user) ||
3738 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.even_real,
3739 coefs->hor_coefs.even_real, dvs_hor_coef_bytes, from_user) ||
3740 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.even_imag,
3741 coefs->hor_coefs.even_imag, dvs_hor_coef_bytes, from_user) ||
3742 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.odd_real,
3743 coefs->ver_coefs.odd_real, dvs_ver_coef_bytes, from_user) ||
3744 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.odd_imag,
3745 coefs->ver_coefs.odd_imag, dvs_ver_coef_bytes, from_user) ||
3746 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.even_real,
3747 coefs->ver_coefs.even_real, dvs_ver_coef_bytes, from_user) ||
3748 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.even_imag,
3749 coefs->ver_coefs.even_imag, dvs_ver_coef_bytes, from_user)) {
3750 ia_css_dvs2_coefficients_free(css_param->dvs2_coeff);
3751 css_param->dvs2_coeff = NULL;
3752 return -EFAULT;
3753 }
3754 } else {
3755 if (copy_from_compatible(&dvs2_coefs, coefs,
3756 sizeof(struct ia_css_dvs2_coefficients),
3757 from_user)) {
3758 dev_err(asd->isp->dev, "copy dvs2 coef failed");
3759 return -EFAULT;
3760 }
3761
3762 if (sizeof(*cur) != sizeof(dvs2_coefs.grid) ||
3763 memcmp(&dvs2_coefs.grid, cur, sizeof(dvs2_coefs.grid))) {
3764 dev_err(asd->isp->dev, "dvs grid mis-match!\n");
3765
3766
3767
3768 return -EAGAIN;
3769 }
3770
3771 if (!dvs2_coefs.hor_coefs.odd_real ||
3772 !dvs2_coefs.hor_coefs.odd_imag ||
3773 !dvs2_coefs.hor_coefs.even_real ||
3774 !dvs2_coefs.hor_coefs.even_imag ||
3775 !dvs2_coefs.ver_coefs.odd_real ||
3776 !dvs2_coefs.ver_coefs.odd_imag ||
3777 !dvs2_coefs.ver_coefs.even_real ||
3778 !dvs2_coefs.ver_coefs.even_imag)
3779 return -EINVAL;
3780
3781 if (!css_param->dvs2_coeff) {
3782
3783 css_param->dvs2_coeff = ia_css_dvs2_coefficients_allocate(cur);
3784 if (!css_param->dvs2_coeff)
3785 return -ENOMEM;
3786 }
3787
3788 dvs_hor_coef_bytes = asd->params.dvs_hor_coef_bytes;
3789 dvs_ver_coef_bytes = asd->params.dvs_ver_coef_bytes;
3790 if (copy_from_compatible(css_param->dvs2_coeff->hor_coefs.odd_real,
3791 dvs2_coefs.hor_coefs.odd_real, dvs_hor_coef_bytes, from_user) ||
3792 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.odd_imag,
3793 dvs2_coefs.hor_coefs.odd_imag, dvs_hor_coef_bytes, from_user) ||
3794 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.even_real,
3795 dvs2_coefs.hor_coefs.even_real, dvs_hor_coef_bytes, from_user) ||
3796 copy_from_compatible(css_param->dvs2_coeff->hor_coefs.even_imag,
3797 dvs2_coefs.hor_coefs.even_imag, dvs_hor_coef_bytes, from_user) ||
3798 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.odd_real,
3799 dvs2_coefs.ver_coefs.odd_real, dvs_ver_coef_bytes, from_user) ||
3800 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.odd_imag,
3801 dvs2_coefs.ver_coefs.odd_imag, dvs_ver_coef_bytes, from_user) ||
3802 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.even_real,
3803 dvs2_coefs.ver_coefs.even_real, dvs_ver_coef_bytes, from_user) ||
3804 copy_from_compatible(css_param->dvs2_coeff->ver_coefs.even_imag,
3805 dvs2_coefs.ver_coefs.even_imag, dvs_ver_coef_bytes, from_user)) {
3806 ia_css_dvs2_coefficients_free(css_param->dvs2_coeff);
3807 css_param->dvs2_coeff = NULL;
3808 return -EFAULT;
3809 }
3810 }
3811
3812 css_param->update_flag.dvs2_coefs =
3813 (struct atomisp_dis_coefficients *)css_param->dvs2_coeff;
3814 return 0;
3815}
3816
3817int atomisp_cp_dvs_6axis_config(struct atomisp_sub_device *asd,
3818 struct atomisp_dvs_6axis_config *source_6axis_config,
3819 struct atomisp_css_params *css_param,
3820 bool from_user)
3821{
3822 struct ia_css_dvs_6axis_config *dvs_6axis_config;
3823 struct ia_css_dvs_6axis_config *old_6axis_config;
3824 struct ia_css_stream *stream =
3825 asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream;
3826 struct ia_css_dvs_grid_info *dvs_grid_info =
3827 atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
3828 int ret = -EFAULT;
3829
3830 if (!stream) {
3831 dev_err(asd->isp->dev, "%s: internal error!", __func__);
3832 return -EINVAL;
3833 }
3834
3835 if (!source_6axis_config || !dvs_grid_info)
3836 return 0;
3837
3838 if (!dvs_grid_info->enable)
3839 return 0;
3840
3841 if (!from_user && css_param->update_flag.dvs_6axis_config)
3842 return 0;
3843
3844
3845 old_6axis_config = css_param->dvs_6axis;
3846 dvs_6axis_config = old_6axis_config;
3847
3848 if (IS_ISP2401) {
3849 struct ia_css_dvs_6axis_config t_6axis_config;
3850
3851 if (copy_from_compatible(&t_6axis_config, source_6axis_config,
3852 sizeof(struct atomisp_dvs_6axis_config),
3853 from_user)) {
3854 dev_err(asd->isp->dev, "copy morph table failed!");
3855 return -EFAULT;
3856 }
3857
3858 if (old_6axis_config &&
3859 (old_6axis_config->width_y != t_6axis_config.width_y ||
3860 old_6axis_config->height_y != t_6axis_config.height_y ||
3861 old_6axis_config->width_uv != t_6axis_config.width_uv ||
3862 old_6axis_config->height_uv != t_6axis_config.height_uv)) {
3863 ia_css_dvs2_6axis_config_free(css_param->dvs_6axis);
3864 css_param->dvs_6axis = NULL;
3865
3866 dvs_6axis_config = ia_css_dvs2_6axis_config_allocate(stream);
3867 if (!dvs_6axis_config)
3868 return -ENOMEM;
3869 } else if (!dvs_6axis_config) {
3870 dvs_6axis_config = ia_css_dvs2_6axis_config_allocate(stream);
3871 if (!dvs_6axis_config)
3872 return -ENOMEM;
3873 }
3874
3875 dvs_6axis_config->exp_id = t_6axis_config.exp_id;
3876
3877 if (copy_from_compatible(dvs_6axis_config->xcoords_y,
3878 t_6axis_config.xcoords_y,
3879 t_6axis_config.width_y *
3880 t_6axis_config.height_y *
3881 sizeof(*dvs_6axis_config->xcoords_y),
3882 from_user))
3883 goto error;
3884 if (copy_from_compatible(dvs_6axis_config->ycoords_y,
3885 t_6axis_config.ycoords_y,
3886 t_6axis_config.width_y *
3887 t_6axis_config.height_y *
3888 sizeof(*dvs_6axis_config->ycoords_y),
3889 from_user))
3890 goto error;
3891 if (copy_from_compatible(dvs_6axis_config->xcoords_uv,
3892 t_6axis_config.xcoords_uv,
3893 t_6axis_config.width_uv *
3894 t_6axis_config.height_uv *
3895 sizeof(*dvs_6axis_config->xcoords_uv),
3896 from_user))
3897 goto error;
3898 if (copy_from_compatible(dvs_6axis_config->ycoords_uv,
3899 t_6axis_config.ycoords_uv,
3900 t_6axis_config.width_uv *
3901 t_6axis_config.height_uv *
3902 sizeof(*dvs_6axis_config->ycoords_uv),
3903 from_user))
3904 goto error;
3905 } else {
3906 if (old_6axis_config &&
3907 (old_6axis_config->width_y != source_6axis_config->width_y ||
3908 old_6axis_config->height_y != source_6axis_config->height_y ||
3909 old_6axis_config->width_uv != source_6axis_config->width_uv ||
3910 old_6axis_config->height_uv != source_6axis_config->height_uv)) {
3911 ia_css_dvs2_6axis_config_free(css_param->dvs_6axis);
3912 css_param->dvs_6axis = NULL;
3913
3914 dvs_6axis_config = ia_css_dvs2_6axis_config_allocate(stream);
3915 if (!dvs_6axis_config)
3916 return -ENOMEM;
3917 } else if (!dvs_6axis_config) {
3918 dvs_6axis_config = ia_css_dvs2_6axis_config_allocate(stream);
3919 if (!dvs_6axis_config)
3920 return -ENOMEM;
3921 }
3922
3923 dvs_6axis_config->exp_id = source_6axis_config->exp_id;
3924
3925 if (copy_from_compatible(dvs_6axis_config->xcoords_y,
3926 source_6axis_config->xcoords_y,
3927 source_6axis_config->width_y *
3928 source_6axis_config->height_y *
3929 sizeof(*source_6axis_config->xcoords_y),
3930 from_user))
3931 goto error;
3932 if (copy_from_compatible(dvs_6axis_config->ycoords_y,
3933 source_6axis_config->ycoords_y,
3934 source_6axis_config->width_y *
3935 source_6axis_config->height_y *
3936 sizeof(*source_6axis_config->ycoords_y),
3937 from_user))
3938 goto error;
3939 if (copy_from_compatible(dvs_6axis_config->xcoords_uv,
3940 source_6axis_config->xcoords_uv,
3941 source_6axis_config->width_uv *
3942 source_6axis_config->height_uv *
3943 sizeof(*source_6axis_config->xcoords_uv),
3944 from_user))
3945 goto error;
3946 if (copy_from_compatible(dvs_6axis_config->ycoords_uv,
3947 source_6axis_config->ycoords_uv,
3948 source_6axis_config->width_uv *
3949 source_6axis_config->height_uv *
3950 sizeof(*source_6axis_config->ycoords_uv),
3951 from_user))
3952 goto error;
3953 }
3954 css_param->dvs_6axis = dvs_6axis_config;
3955 css_param->update_flag.dvs_6axis_config =
3956 (struct atomisp_dvs_6axis_config *)dvs_6axis_config;
3957 return 0;
3958
3959error:
3960 if (dvs_6axis_config)
3961 ia_css_dvs2_6axis_config_free(dvs_6axis_config);
3962 return ret;
3963}
3964
3965int atomisp_cp_morph_table(struct atomisp_sub_device *asd,
3966 struct atomisp_morph_table *source_morph_table,
3967 struct atomisp_css_params *css_param,
3968 bool from_user)
3969{
3970 int ret = -EFAULT;
3971 unsigned int i;
3972 struct ia_css_morph_table *morph_table;
3973 struct ia_css_morph_table *old_morph_table;
3974
3975 if (!source_morph_table)
3976 return 0;
3977
3978 if (!from_user && css_param->update_flag.morph_table)
3979 return 0;
3980
3981 old_morph_table = css_param->morph_table;
3982
3983 if (IS_ISP2401) {
3984 struct ia_css_morph_table mtbl;
3985
3986 if (copy_from_compatible(&mtbl, source_morph_table,
3987 sizeof(struct atomisp_morph_table),
3988 from_user)) {
3989 dev_err(asd->isp->dev, "copy morph table failed!");
3990 return -EFAULT;
3991 }
3992
3993 morph_table = atomisp_css_morph_table_allocate(
3994 mtbl.width,
3995 mtbl.height);
3996 if (!morph_table)
3997 return -ENOMEM;
3998
3999 for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
4000 if (copy_from_compatible(morph_table->coordinates_x[i],
4001 (__force void *)source_morph_table->coordinates_x[i],
4002 mtbl.height * mtbl.width *
4003 sizeof(*morph_table->coordinates_x[i]),
4004 from_user))
4005 goto error;
4006
4007 if (copy_from_compatible(morph_table->coordinates_y[i],
4008 (__force void *)source_morph_table->coordinates_y[i],
4009 mtbl.height * mtbl.width *
4010 sizeof(*morph_table->coordinates_y[i]),
4011 from_user))
4012 goto error;
4013 }
4014 } else {
4015 morph_table = atomisp_css_morph_table_allocate(
4016 source_morph_table->width,
4017 source_morph_table->height);
4018 if (!morph_table)
4019 return -ENOMEM;
4020
4021 for (i = 0; i < IA_CSS_MORPH_TABLE_NUM_PLANES; i++) {
4022 if (copy_from_compatible(morph_table->coordinates_x[i],
4023 (__force void *)source_morph_table->coordinates_x[i],
4024 source_morph_table->height * source_morph_table->width *
4025 sizeof(*source_morph_table->coordinates_x[i]),
4026 from_user))
4027 goto error;
4028
4029 if (copy_from_compatible(morph_table->coordinates_y[i],
4030 (__force void *)source_morph_table->coordinates_y[i],
4031 source_morph_table->height * source_morph_table->width *
4032 sizeof(*source_morph_table->coordinates_y[i]),
4033 from_user))
4034 goto error;
4035 }
4036 }
4037
4038 css_param->morph_table = morph_table;
4039 if (old_morph_table)
4040 atomisp_css_morph_table_free(old_morph_table);
4041 css_param->update_flag.morph_table =
4042 (struct atomisp_morph_table *)morph_table;
4043 return 0;
4044
4045error:
4046 if (morph_table)
4047 atomisp_css_morph_table_free(morph_table);
4048 return ret;
4049}
4050
4051int atomisp_makeup_css_parameters(struct atomisp_sub_device *asd,
4052 struct atomisp_parameters *arg,
4053 struct atomisp_css_params *css_param)
4054{
4055 int ret;
4056
4057 ret = atomisp_cp_general_isp_parameters(asd, arg, css_param, false);
4058 if (ret)
4059 return ret;
4060 ret = atomisp_cp_lsc_table(asd, arg->shading_table, css_param, false);
4061 if (ret)
4062 return ret;
4063 ret = atomisp_cp_morph_table(asd, arg->morph_table, css_param, false);
4064 if (ret)
4065 return ret;
4066 ret = atomisp_css_cp_dvs2_coefs(asd,
4067 (struct ia_css_dvs2_coefficients *)arg->dvs2_coefs,
4068 css_param, false);
4069 if (ret)
4070 return ret;
4071 ret = atomisp_cp_dvs_6axis_config(asd, arg->dvs_6axis_config,
4072 css_param, false);
4073 return ret;
4074}
4075
4076void atomisp_free_css_parameters(struct atomisp_css_params *css_param)
4077{
4078 if (css_param->dvs_6axis) {
4079 ia_css_dvs2_6axis_config_free(css_param->dvs_6axis);
4080 css_param->dvs_6axis = NULL;
4081 }
4082 if (css_param->dvs2_coeff) {
4083 ia_css_dvs2_coefficients_free(css_param->dvs2_coeff);
4084 css_param->dvs2_coeff = NULL;
4085 }
4086 if (css_param->shading_table) {
4087 ia_css_shading_table_free(css_param->shading_table);
4088 css_param->shading_table = NULL;
4089 }
4090 if (css_param->morph_table) {
4091 ia_css_morph_table_free(css_param->morph_table);
4092 css_param->morph_table = NULL;
4093 }
4094}
4095
4096
4097
4098
4099
4100
4101
4102
4103void atomisp_handle_parameter_and_buffer(struct atomisp_video_pipe *pipe)
4104{
4105 struct atomisp_sub_device *asd = pipe->asd;
4106 struct videobuf_buffer *vb = NULL, *vb_tmp;
4107 struct atomisp_css_params_with_list *param = NULL, *param_tmp;
4108 struct videobuf_vmalloc_memory *vm_mem = NULL;
4109 unsigned long irqflags;
4110 bool need_to_enqueue_buffer = false;
4111
4112 if (atomisp_is_vf_pipe(pipe))
4113 return;
4114
4115
4116
4117
4118
4119 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
4120 return;
4121
4122 if (list_empty(&pipe->per_frame_params) ||
4123 list_empty(&pipe->buffers_waiting_for_param))
4124 return;
4125
4126 list_for_each_entry_safe(vb, vb_tmp,
4127 &pipe->buffers_waiting_for_param, queue) {
4128 if (pipe->frame_request_config_id[vb->i]) {
4129 list_for_each_entry_safe(param, param_tmp,
4130 &pipe->per_frame_params, list) {
4131 if (pipe->frame_request_config_id[vb->i] !=
4132 param->params.isp_config_id)
4133 continue;
4134
4135 list_del(¶m->list);
4136 list_del(&vb->queue);
4137
4138
4139
4140
4141 pipe->frame_request_config_id[vb->i] = 0;
4142 pipe->frame_params[vb->i] = param;
4143 vm_mem = vb->priv;
4144 BUG_ON(!vm_mem);
4145 break;
4146 }
4147
4148 if (vm_mem) {
4149 spin_lock_irqsave(&pipe->irq_lock, irqflags);
4150 list_add_tail(&vb->queue, &pipe->activeq);
4151 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
4152 vm_mem = NULL;
4153 need_to_enqueue_buffer = true;
4154 } else {
4155
4156 break;
4157 }
4158 } else {
4159 list_del(&vb->queue);
4160 pipe->frame_params[vb->i] = NULL;
4161 spin_lock_irqsave(&pipe->irq_lock, irqflags);
4162 list_add_tail(&vb->queue, &pipe->activeq);
4163 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
4164 need_to_enqueue_buffer = true;
4165 }
4166 }
4167
4168 if (!need_to_enqueue_buffer)
4169 return;
4170
4171 atomisp_qbuffers_to_css(asd);
4172
4173 if (!IS_ISP2401) {
4174 if (!atomisp_is_wdt_running(asd) && atomisp_buffers_queued(asd))
4175 atomisp_wdt_start(asd);
4176 } else {
4177 if (atomisp_buffers_queued_pipe(pipe)) {
4178 if (!atomisp_is_wdt_running(pipe))
4179 atomisp_wdt_start_pipe(pipe);
4180 else
4181 atomisp_wdt_refresh_pipe(pipe,
4182 ATOMISP_WDT_KEEP_CURRENT_DELAY);
4183 }
4184 }
4185}
4186
4187
4188
4189
4190int atomisp_set_parameters(struct video_device *vdev,
4191 struct atomisp_parameters *arg)
4192{
4193 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
4194 struct atomisp_sub_device *asd = pipe->asd;
4195 struct atomisp_css_params_with_list *param = NULL;
4196 struct atomisp_css_params *css_param = &asd->params.css_param;
4197 int ret;
4198
4199 if (!asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream) {
4200 dev_err(asd->isp->dev, "%s: internal error!\n", __func__);
4201 return -EINVAL;
4202 }
4203
4204 dev_dbg(asd->isp->dev,
4205 "%s: set parameter(per_frame_setting %d) for asd%d with isp_config_id %d of %s\n",
4206 __func__, arg->per_frame_setting, asd->index,
4207 arg->isp_config_id, vdev->name);
4208
4209 if (IS_ISP2401) {
4210 if (atomisp_is_vf_pipe(pipe) && arg->per_frame_setting) {
4211 dev_err(asd->isp->dev, "%s: vf pipe not support per_frame_setting",
4212 __func__);
4213 return -EINVAL;
4214 }
4215 }
4216
4217 if (arg->per_frame_setting && !atomisp_is_vf_pipe(pipe)) {
4218
4219
4220
4221
4222
4223
4224 param = kvzalloc(sizeof(*param), GFP_KERNEL);
4225 if (!param) {
4226 dev_err(asd->isp->dev, "%s: failed to alloc params buffer\n",
4227 __func__);
4228 return -ENOMEM;
4229 }
4230 css_param = ¶m->params;
4231 }
4232
4233 ret = atomisp_cp_general_isp_parameters(asd, arg, css_param, true);
4234 if (ret)
4235 goto apply_parameter_failed;
4236
4237 ret = atomisp_cp_lsc_table(asd, arg->shading_table, css_param, true);
4238 if (ret)
4239 goto apply_parameter_failed;
4240
4241 ret = atomisp_cp_morph_table(asd, arg->morph_table, css_param, true);
4242 if (ret)
4243 goto apply_parameter_failed;
4244
4245 ret = atomisp_css_cp_dvs2_coefs(asd,
4246 (struct ia_css_dvs2_coefficients *)arg->dvs2_coefs,
4247 css_param, true);
4248 if (ret)
4249 goto apply_parameter_failed;
4250
4251 ret = atomisp_cp_dvs_6axis_config(asd, arg->dvs_6axis_config,
4252 css_param, true);
4253 if (ret)
4254 goto apply_parameter_failed;
4255
4256 if (!(arg->per_frame_setting && !atomisp_is_vf_pipe(pipe))) {
4257
4258 asd->params.css_update_params_needed = true;
4259 } else {
4260 list_add_tail(¶m->list, &pipe->per_frame_params);
4261 atomisp_handle_parameter_and_buffer(pipe);
4262 }
4263
4264 return 0;
4265
4266apply_parameter_failed:
4267 if (css_param)
4268 atomisp_free_css_parameters(css_param);
4269 kvfree(param);
4270
4271 return ret;
4272}
4273
4274
4275
4276
4277int atomisp_param(struct atomisp_sub_device *asd, int flag,
4278 struct atomisp_parm *config)
4279{
4280 struct ia_css_pipe_config *vp_cfg =
4281 &asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].
4282 pipe_configs[IA_CSS_PIPE_ID_VIDEO];
4283
4284
4285 if (flag == 0) {
4286 struct ia_css_dvs_grid_info *dvs_grid_info =
4287 atomisp_css_get_dvs_grid_info(
4288 &asd->params.curr_grid_info);
4289
4290 atomisp_curr_user_grid_info(asd, &config->info);
4291
4292
4293
4294
4295 config->metadata_config.metadata_height = asd->
4296 stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream_info.
4297 metadata_info.resolution.height;
4298 config->metadata_config.metadata_stride = asd->
4299 stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream_info.
4300 metadata_info.stride;
4301
4302
4303 if (dvs_grid_info)
4304 memcpy(&config->dvs_grid,
4305 dvs_grid_info,
4306 sizeof(struct ia_css_dvs_grid_info));
4307
4308 if (asd->run_mode->val != ATOMISP_RUN_MODE_VIDEO) {
4309 config->dvs_envelop.width = 0;
4310 config->dvs_envelop.height = 0;
4311 return 0;
4312 }
4313
4314
4315 if (!asd->continuous_mode->val) {
4316 config->dvs_envelop.width = vp_cfg->dvs_envelope.width;
4317 config->dvs_envelop.height =
4318 vp_cfg->dvs_envelope.height;
4319 } else {
4320 unsigned int dvs_w, dvs_h, dvs_w_max, dvs_h_max;
4321
4322 dvs_w = vp_cfg->bayer_ds_out_res.width -
4323 vp_cfg->output_info[0].res.width;
4324 dvs_h = vp_cfg->bayer_ds_out_res.height -
4325 vp_cfg->output_info[0].res.height;
4326 dvs_w_max = rounddown(
4327 vp_cfg->output_info[0].res.width / 5,
4328 ATOM_ISP_STEP_WIDTH);
4329 dvs_h_max = rounddown(
4330 vp_cfg->output_info[0].res.height / 5,
4331 ATOM_ISP_STEP_HEIGHT);
4332
4333 config->dvs_envelop.width = min(dvs_w, dvs_w_max);
4334 config->dvs_envelop.height = min(dvs_h, dvs_h_max);
4335 }
4336
4337 return 0;
4338 }
4339
4340 memcpy(&asd->params.css_param.wb_config, &config->wb_config,
4341 sizeof(struct ia_css_wb_config));
4342 memcpy(&asd->params.css_param.ob_config, &config->ob_config,
4343 sizeof(struct ia_css_ob_config));
4344 memcpy(&asd->params.css_param.dp_config, &config->dp_config,
4345 sizeof(struct ia_css_dp_config));
4346 memcpy(&asd->params.css_param.de_config, &config->de_config,
4347 sizeof(struct ia_css_de_config));
4348 memcpy(&asd->params.css_param.dz_config, &config->dz_config,
4349 sizeof(struct ia_css_dz_config));
4350 memcpy(&asd->params.css_param.ce_config, &config->ce_config,
4351 sizeof(struct ia_css_ce_config));
4352 memcpy(&asd->params.css_param.nr_config, &config->nr_config,
4353 sizeof(struct ia_css_nr_config));
4354 memcpy(&asd->params.css_param.ee_config, &config->ee_config,
4355 sizeof(struct ia_css_ee_config));
4356 memcpy(&asd->params.css_param.tnr_config, &config->tnr_config,
4357 sizeof(struct ia_css_tnr_config));
4358
4359 if (asd->params.color_effect == V4L2_COLORFX_NEGATIVE) {
4360 asd->params.css_param.cc_config.matrix[3] = -config->cc_config.matrix[3];
4361 asd->params.css_param.cc_config.matrix[4] = -config->cc_config.matrix[4];
4362 asd->params.css_param.cc_config.matrix[5] = -config->cc_config.matrix[5];
4363 asd->params.css_param.cc_config.matrix[6] = -config->cc_config.matrix[6];
4364 asd->params.css_param.cc_config.matrix[7] = -config->cc_config.matrix[7];
4365 asd->params.css_param.cc_config.matrix[8] = -config->cc_config.matrix[8];
4366 }
4367
4368 if (asd->params.color_effect != V4L2_COLORFX_SEPIA &&
4369 asd->params.color_effect != V4L2_COLORFX_BW) {
4370 memcpy(&asd->params.css_param.cc_config, &config->cc_config,
4371 sizeof(struct ia_css_cc_config));
4372 asd->params.config.cc_config = &asd->params.css_param.cc_config;
4373 }
4374
4375 asd->params.config.wb_config = &asd->params.css_param.wb_config;
4376 asd->params.config.ob_config = &asd->params.css_param.ob_config;
4377 asd->params.config.de_config = &asd->params.css_param.de_config;
4378 asd->params.config.dz_config = &asd->params.css_param.dz_config;
4379 asd->params.config.ce_config = &asd->params.css_param.ce_config;
4380 asd->params.config.dp_config = &asd->params.css_param.dp_config;
4381 asd->params.config.nr_config = &asd->params.css_param.nr_config;
4382 asd->params.config.ee_config = &asd->params.css_param.ee_config;
4383 asd->params.config.tnr_config = &asd->params.css_param.tnr_config;
4384 asd->params.css_update_params_needed = true;
4385
4386 return 0;
4387}
4388
4389
4390
4391
4392int atomisp_color_effect(struct atomisp_sub_device *asd, int flag,
4393 __s32 *effect)
4394{
4395 struct ia_css_cc_config *cc_config = NULL;
4396 struct ia_css_macc_table *macc_table = NULL;
4397 struct ia_css_ctc_table *ctc_table = NULL;
4398 int ret = 0;
4399 struct v4l2_control control;
4400 struct atomisp_device *isp = asd->isp;
4401
4402 if (flag == 0) {
4403 *effect = asd->params.color_effect;
4404 return 0;
4405 }
4406
4407 control.id = V4L2_CID_COLORFX;
4408 control.value = *effect;
4409 ret =
4410 v4l2_s_ctrl(NULL, isp->inputs[asd->input_curr].camera->ctrl_handler,
4411 &control);
4412
4413
4414
4415
4416 if (!ret) {
4417 asd->params.color_effect = (u32)*effect;
4418 return 0;
4419 }
4420
4421 if (*effect == asd->params.color_effect)
4422 return 0;
4423
4424
4425
4426
4427 asd->params.macc_en = false;
4428
4429 switch (*effect) {
4430 case V4L2_COLORFX_NONE:
4431 macc_table = &asd->params.css_param.macc_table;
4432 asd->params.macc_en = true;
4433 break;
4434 case V4L2_COLORFX_SEPIA:
4435 cc_config = &sepia_cc_config;
4436 break;
4437 case V4L2_COLORFX_NEGATIVE:
4438 cc_config = &nega_cc_config;
4439 break;
4440 case V4L2_COLORFX_BW:
4441 cc_config = &mono_cc_config;
4442 break;
4443 case V4L2_COLORFX_SKY_BLUE:
4444 macc_table = &blue_macc_table;
4445 asd->params.macc_en = true;
4446 break;
4447 case V4L2_COLORFX_GRASS_GREEN:
4448 macc_table = &green_macc_table;
4449 asd->params.macc_en = true;
4450 break;
4451 case V4L2_COLORFX_SKIN_WHITEN_LOW:
4452 macc_table = &skin_low_macc_table;
4453 asd->params.macc_en = true;
4454 break;
4455 case V4L2_COLORFX_SKIN_WHITEN:
4456 macc_table = &skin_medium_macc_table;
4457 asd->params.macc_en = true;
4458 break;
4459 case V4L2_COLORFX_SKIN_WHITEN_HIGH:
4460 macc_table = &skin_high_macc_table;
4461 asd->params.macc_en = true;
4462 break;
4463 case V4L2_COLORFX_VIVID:
4464 ctc_table = &vivid_ctc_table;
4465 break;
4466 default:
4467 return -EINVAL;
4468 }
4469 atomisp_update_capture_mode(asd);
4470
4471 if (cc_config)
4472 asd->params.config.cc_config = cc_config;
4473 if (macc_table)
4474 asd->params.config.macc_table = macc_table;
4475 if (ctc_table)
4476 atomisp_css_set_ctc_table(asd, ctc_table);
4477 asd->params.color_effect = (u32)*effect;
4478 asd->params.css_update_params_needed = true;
4479 return 0;
4480}
4481
4482
4483
4484
4485int atomisp_bad_pixel(struct atomisp_sub_device *asd, int flag,
4486 __s32 *value)
4487{
4488 if (flag == 0) {
4489 *value = asd->params.bad_pixel_en;
4490 return 0;
4491 }
4492 asd->params.bad_pixel_en = !!*value;
4493
4494 return 0;
4495}
4496
4497
4498
4499
4500int atomisp_bad_pixel_param(struct atomisp_sub_device *asd, int flag,
4501 struct atomisp_dp_config *config)
4502{
4503 if (flag == 0) {
4504
4505 if (atomisp_css_get_dp_config(asd, config))
4506 return -EINVAL;
4507 } else {
4508
4509 memcpy(&asd->params.css_param.dp_config, config,
4510 sizeof(asd->params.css_param.dp_config));
4511 asd->params.config.dp_config = &asd->params.css_param.dp_config;
4512 asd->params.css_update_params_needed = true;
4513 }
4514
4515 return 0;
4516}
4517
4518
4519
4520
4521int atomisp_video_stable(struct atomisp_sub_device *asd, int flag,
4522 __s32 *value)
4523{
4524 if (flag == 0)
4525 *value = asd->params.video_dis_en;
4526 else
4527 asd->params.video_dis_en = !!*value;
4528
4529 return 0;
4530}
4531
4532
4533
4534
4535int atomisp_fixed_pattern(struct atomisp_sub_device *asd, int flag,
4536 __s32 *value)
4537{
4538 if (flag == 0) {
4539 *value = asd->params.fpn_en;
4540 return 0;
4541 }
4542
4543 if (*value == 0) {
4544 asd->params.fpn_en = false;
4545 return 0;
4546 }
4547
4548
4549 return 0;
4550}
4551
4552static unsigned int
4553atomisp_bytesperline_to_padded_width(unsigned int bytesperline,
4554 enum ia_css_frame_format format)
4555{
4556 switch (format) {
4557 case IA_CSS_FRAME_FORMAT_UYVY:
4558 case IA_CSS_FRAME_FORMAT_YUYV:
4559 case IA_CSS_FRAME_FORMAT_RAW:
4560 case IA_CSS_FRAME_FORMAT_RGB565:
4561 return bytesperline / 2;
4562 case IA_CSS_FRAME_FORMAT_RGBA888:
4563 return bytesperline / 4;
4564
4565
4566 case IA_CSS_FRAME_FORMAT_NV11:
4567 case IA_CSS_FRAME_FORMAT_NV12:
4568 case IA_CSS_FRAME_FORMAT_NV16:
4569 case IA_CSS_FRAME_FORMAT_NV21:
4570 case IA_CSS_FRAME_FORMAT_NV61:
4571 case IA_CSS_FRAME_FORMAT_YV12:
4572 case IA_CSS_FRAME_FORMAT_YV16:
4573 case IA_CSS_FRAME_FORMAT_YUV420:
4574 case IA_CSS_FRAME_FORMAT_YUV420_16:
4575 case IA_CSS_FRAME_FORMAT_YUV422:
4576 case IA_CSS_FRAME_FORMAT_YUV422_16:
4577 case IA_CSS_FRAME_FORMAT_YUV444:
4578 case IA_CSS_FRAME_FORMAT_YUV_LINE:
4579 case IA_CSS_FRAME_FORMAT_PLANAR_RGB888:
4580 case IA_CSS_FRAME_FORMAT_QPLANE6:
4581 case IA_CSS_FRAME_FORMAT_BINARY_8:
4582 default:
4583 return bytesperline;
4584 }
4585}
4586
4587static int
4588atomisp_v4l2_framebuffer_to_css_frame(const struct v4l2_framebuffer *arg,
4589 struct ia_css_frame **result)
4590{
4591 struct ia_css_frame *res = NULL;
4592 unsigned int padded_width;
4593 enum ia_css_frame_format sh_format;
4594 char *tmp_buf = NULL;
4595 int ret = 0;
4596
4597 sh_format = v4l2_fmt_to_sh_fmt(arg->fmt.pixelformat);
4598 padded_width = atomisp_bytesperline_to_padded_width(
4599 arg->fmt.bytesperline, sh_format);
4600
4601
4602
4603
4604 if (ia_css_frame_allocate(&res, arg->fmt.width, arg->fmt.height,
4605 sh_format, padded_width, 0)) {
4606 ret = -ENOMEM;
4607 goto err;
4608 }
4609
4610 tmp_buf = vmalloc(arg->fmt.sizeimage);
4611 if (!tmp_buf) {
4612 ret = -ENOMEM;
4613 goto err;
4614 }
4615 if (copy_from_user(tmp_buf, (void __user __force *)arg->base,
4616 arg->fmt.sizeimage)) {
4617 ret = -EFAULT;
4618 goto err;
4619 }
4620
4621 if (hmm_store(res->data, tmp_buf, arg->fmt.sizeimage)) {
4622 ret = -EINVAL;
4623 goto err;
4624 }
4625
4626err:
4627 if (ret && res)
4628 ia_css_frame_free(res);
4629 vfree(tmp_buf);
4630 if (ret == 0)
4631 *result = res;
4632 return ret;
4633}
4634
4635
4636
4637
4638int atomisp_fixed_pattern_table(struct atomisp_sub_device *asd,
4639 struct v4l2_framebuffer *arg)
4640{
4641 struct ia_css_frame *raw_black_frame = NULL;
4642 int ret;
4643
4644 if (!arg)
4645 return -EINVAL;
4646
4647 ret = atomisp_v4l2_framebuffer_to_css_frame(arg, &raw_black_frame);
4648 if (ret)
4649 return ret;
4650
4651 if (sh_css_set_black_frame(asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].stream,
4652 raw_black_frame) != 0)
4653 return -ENOMEM;
4654
4655 ia_css_frame_free(raw_black_frame);
4656 return ret;
4657}
4658
4659
4660
4661
4662int atomisp_false_color(struct atomisp_sub_device *asd, int flag,
4663 __s32 *value)
4664{
4665
4666 if (flag == 0) {
4667 *value = asd->params.false_color;
4668 return 0;
4669 }
4670
4671
4672 if (*value) {
4673 asd->params.config.de_config = NULL;
4674 } else {
4675 asd->params.css_param.de_config.pixelnoise = 0;
4676 asd->params.config.de_config = &asd->params.css_param.de_config;
4677 }
4678 asd->params.css_update_params_needed = true;
4679 asd->params.false_color = *value;
4680 return 0;
4681}
4682
4683
4684
4685
4686int atomisp_false_color_param(struct atomisp_sub_device *asd, int flag,
4687 struct atomisp_de_config *config)
4688{
4689 if (flag == 0) {
4690
4691 if (atomisp_css_get_de_config(asd, config))
4692 return -EINVAL;
4693 } else {
4694
4695 memcpy(&asd->params.css_param.de_config, config,
4696 sizeof(asd->params.css_param.de_config));
4697 asd->params.config.de_config = &asd->params.css_param.de_config;
4698 asd->params.css_update_params_needed = true;
4699 }
4700
4701 return 0;
4702}
4703
4704
4705
4706
4707int atomisp_white_balance_param(struct atomisp_sub_device *asd, int flag,
4708 struct atomisp_wb_config *config)
4709{
4710 if (flag == 0) {
4711
4712 if (atomisp_css_get_wb_config(asd, config))
4713 return -EINVAL;
4714 } else {
4715
4716 memcpy(&asd->params.css_param.wb_config, config,
4717 sizeof(asd->params.css_param.wb_config));
4718 asd->params.config.wb_config = &asd->params.css_param.wb_config;
4719 asd->params.css_update_params_needed = true;
4720 }
4721
4722 return 0;
4723}
4724
4725int atomisp_3a_config_param(struct atomisp_sub_device *asd, int flag,
4726 struct atomisp_3a_config *config)
4727{
4728 struct atomisp_device *isp = asd->isp;
4729
4730 dev_dbg(isp->dev, ">%s %d\n", __func__, flag);
4731
4732 if (flag == 0) {
4733
4734 if (atomisp_css_get_3a_config(asd, config))
4735 return -EINVAL;
4736 } else {
4737
4738 memcpy(&asd->params.css_param.s3a_config, config,
4739 sizeof(asd->params.css_param.s3a_config));
4740 asd->params.config.s3a_config = &asd->params.css_param.s3a_config;
4741 asd->params.css_update_params_needed = true;
4742 }
4743
4744 dev_dbg(isp->dev, "<%s %d\n", __func__, flag);
4745 return 0;
4746}
4747
4748
4749
4750
4751int atomisp_digital_zoom(struct atomisp_sub_device *asd, int flag,
4752 __s32 *value)
4753{
4754 u32 zoom;
4755 struct atomisp_device *isp = asd->isp;
4756
4757 unsigned int max_zoom = MRFLD_MAX_ZOOM_FACTOR;
4758
4759 if (flag == 0) {
4760 atomisp_css_get_zoom_factor(asd, &zoom);
4761 *value = max_zoom - zoom;
4762 } else {
4763 if (*value < 0)
4764 return -EINVAL;
4765
4766 zoom = max_zoom - min_t(u32, max_zoom - 1, *value);
4767 atomisp_css_set_zoom_factor(asd, zoom);
4768
4769 dev_dbg(isp->dev, "%s, zoom: %d\n", __func__, zoom);
4770 asd->params.css_update_params_needed = true;
4771 }
4772
4773 return 0;
4774}
4775
4776
4777
4778
4779
4780int atomisp_get_sensor_mode_data(struct atomisp_sub_device *asd,
4781 struct atomisp_sensor_mode_data *config)
4782{
4783 struct camera_mipi_info *mipi_info;
4784 struct atomisp_device *isp = asd->isp;
4785
4786 mipi_info = atomisp_to_sensor_mipi_info(
4787 isp->inputs[asd->input_curr].camera);
4788 if (!mipi_info)
4789 return -EINVAL;
4790
4791 memcpy(config, &mipi_info->data, sizeof(*config));
4792 return 0;
4793}
4794
4795int atomisp_get_fmt(struct video_device *vdev, struct v4l2_format *f)
4796{
4797 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
4798
4799 f->fmt.pix = pipe->pix;
4800
4801 return 0;
4802}
4803
4804static void __atomisp_update_stream_env(struct atomisp_sub_device *asd,
4805 u16 stream_index, struct atomisp_input_stream_info *stream_info)
4806{
4807 int i;
4808
4809
4810 asd->stream_env[stream_index].ch_id = stream_info->ch_id;
4811 asd->stream_env[stream_index].isys_configs = stream_info->isys_configs;
4812 for (i = 0; i < stream_info->isys_configs; i++) {
4813 asd->stream_env[stream_index].isys_info[i].input_format =
4814 stream_info->isys_info[i].input_format;
4815 asd->stream_env[stream_index].isys_info[i].width =
4816 stream_info->isys_info[i].width;
4817 asd->stream_env[stream_index].isys_info[i].height =
4818 stream_info->isys_info[i].height;
4819 }
4820}
4821
4822static void __atomisp_init_stream_info(u16 stream_index,
4823 struct atomisp_input_stream_info *stream_info)
4824{
4825 int i;
4826
4827 stream_info->enable = 1;
4828 stream_info->stream = stream_index;
4829 stream_info->ch_id = 0;
4830 stream_info->isys_configs = 0;
4831 for (i = 0; i < MAX_STREAMS_PER_CHANNEL; i++) {
4832 stream_info->isys_info[i].input_format = 0;
4833 stream_info->isys_info[i].width = 0;
4834 stream_info->isys_info[i].height = 0;
4835 }
4836}
4837
4838
4839int atomisp_try_fmt(struct video_device *vdev, struct v4l2_pix_format *f,
4840 bool *res_overflow)
4841{
4842 struct atomisp_device *isp = video_get_drvdata(vdev);
4843 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
4844 struct v4l2_subdev_pad_config pad_cfg;
4845 struct v4l2_subdev_state pad_state = {
4846 .pads = &pad_cfg
4847 };
4848 struct v4l2_subdev_format format = {
4849 .which = V4L2_SUBDEV_FORMAT_TRY,
4850 };
4851
4852 struct v4l2_mbus_framefmt *snr_mbus_fmt = &format.format;
4853 const struct atomisp_format_bridge *fmt;
4854 struct atomisp_input_stream_info *stream_info =
4855 (struct atomisp_input_stream_info *)snr_mbus_fmt->reserved;
4856 u16 stream_index;
4857 int source_pad = atomisp_subdev_source_pad(vdev);
4858 int ret;
4859
4860 if (!isp->inputs[asd->input_curr].camera)
4861 return -EINVAL;
4862
4863 stream_index = atomisp_source_pad_to_stream_id(asd, source_pad);
4864 fmt = atomisp_get_format_bridge(f->pixelformat);
4865 if (!fmt) {
4866 dev_err(isp->dev, "unsupported pixelformat!\n");
4867 fmt = atomisp_output_fmts;
4868 }
4869
4870 if (f->width <= 0 || f->height <= 0)
4871 return -EINVAL;
4872
4873 snr_mbus_fmt->code = fmt->mbus_code;
4874 snr_mbus_fmt->width = f->width;
4875 snr_mbus_fmt->height = f->height;
4876
4877 __atomisp_init_stream_info(stream_index, stream_info);
4878
4879 dev_dbg(isp->dev, "try_mbus_fmt: asking for %ux%u\n",
4880 snr_mbus_fmt->width, snr_mbus_fmt->height);
4881
4882 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
4883 pad, set_fmt, &pad_state, &format);
4884 if (ret)
4885 return ret;
4886
4887 dev_dbg(isp->dev, "try_mbus_fmt: got %ux%u\n",
4888 snr_mbus_fmt->width, snr_mbus_fmt->height);
4889
4890 fmt = atomisp_get_format_bridge_from_mbus(snr_mbus_fmt->code);
4891 if (!fmt) {
4892 dev_err(isp->dev, "unknown sensor format 0x%8.8x\n",
4893 snr_mbus_fmt->code);
4894 return -EINVAL;
4895 }
4896
4897 f->pixelformat = fmt->pixelformat;
4898
4899
4900
4901
4902
4903
4904
4905 if (f->pixelformat == V4L2_PIX_FMT_JPEG ||
4906 f->pixelformat == V4L2_PIX_FMT_CUSTOM_M10MO_RAW) {
4907 f->width = snr_mbus_fmt->width;
4908 f->height = snr_mbus_fmt->height;
4909 return 0;
4910 }
4911
4912 if (snr_mbus_fmt->width < f->width
4913 && snr_mbus_fmt->height < f->height) {
4914 f->width = snr_mbus_fmt->width;
4915 f->height = snr_mbus_fmt->height;
4916
4917
4918
4919 if (res_overflow)
4920 *res_overflow = true;
4921 }
4922
4923
4924 f->width = rounddown(clamp_t(u32, f->width, ATOM_ISP_MIN_WIDTH,
4925 ATOM_ISP_MAX_WIDTH), ATOM_ISP_STEP_WIDTH);
4926 f->height = rounddown(clamp_t(u32, f->height, ATOM_ISP_MIN_HEIGHT,
4927 ATOM_ISP_MAX_HEIGHT), ATOM_ISP_STEP_HEIGHT);
4928
4929 return 0;
4930}
4931
4932static int
4933atomisp_try_fmt_file(struct atomisp_device *isp, struct v4l2_format *f)
4934{
4935 u32 width = f->fmt.pix.width;
4936 u32 height = f->fmt.pix.height;
4937 u32 pixelformat = f->fmt.pix.pixelformat;
4938 enum v4l2_field field = f->fmt.pix.field;
4939 u32 depth;
4940
4941 if (!atomisp_get_format_bridge(pixelformat)) {
4942 dev_err(isp->dev, "Wrong output pixelformat\n");
4943 return -EINVAL;
4944 }
4945
4946 depth = get_pixel_depth(pixelformat);
4947
4948 if (field == V4L2_FIELD_ANY) {
4949 field = V4L2_FIELD_NONE;
4950 } else if (field != V4L2_FIELD_NONE) {
4951 dev_err(isp->dev, "Wrong output field\n");
4952 return -EINVAL;
4953 }
4954
4955 f->fmt.pix.field = field;
4956 f->fmt.pix.width = clamp_t(u32,
4957 rounddown(width, (u32)ATOM_ISP_STEP_WIDTH),
4958 ATOM_ISP_MIN_WIDTH, ATOM_ISP_MAX_WIDTH);
4959 f->fmt.pix.height = clamp_t(u32, rounddown(height,
4960 (u32)ATOM_ISP_STEP_HEIGHT),
4961 ATOM_ISP_MIN_HEIGHT, ATOM_ISP_MAX_HEIGHT);
4962 f->fmt.pix.bytesperline = (width * depth) >> 3;
4963
4964 return 0;
4965}
4966
4967enum mipi_port_id __get_mipi_port(struct atomisp_device *isp,
4968 enum atomisp_camera_port port)
4969{
4970 switch (port) {
4971 case ATOMISP_CAMERA_PORT_PRIMARY:
4972 return MIPI_PORT0_ID;
4973 case ATOMISP_CAMERA_PORT_SECONDARY:
4974 return MIPI_PORT1_ID;
4975 case ATOMISP_CAMERA_PORT_TERTIARY:
4976 if (MIPI_PORT1_ID + 1 != N_MIPI_PORT_ID)
4977 return MIPI_PORT1_ID + 1;
4978 fallthrough;
4979 default:
4980 dev_err(isp->dev, "unsupported port: %d\n", port);
4981 return MIPI_PORT0_ID;
4982 }
4983}
4984
4985static inline int atomisp_set_sensor_mipi_to_isp(
4986 struct atomisp_sub_device *asd,
4987 enum atomisp_input_stream_id stream_id,
4988 struct camera_mipi_info *mipi_info)
4989{
4990 struct v4l2_control ctrl;
4991 struct atomisp_device *isp = asd->isp;
4992 const struct atomisp_in_fmt_conv *fc;
4993 int mipi_freq = 0;
4994 unsigned int input_format, bayer_order;
4995
4996 ctrl.id = V4L2_CID_LINK_FREQ;
4997 if (v4l2_g_ctrl
4998 (isp->inputs[asd->input_curr].camera->ctrl_handler, &ctrl) == 0)
4999 mipi_freq = ctrl.value;
5000
5001 if (asd->stream_env[stream_id].isys_configs == 1) {
5002 input_format =
5003 asd->stream_env[stream_id].isys_info[0].input_format;
5004 atomisp_css_isys_set_format(asd, stream_id,
5005 input_format, IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX);
5006 } else if (asd->stream_env[stream_id].isys_configs == 2) {
5007 atomisp_css_isys_two_stream_cfg_update_stream1(
5008 asd, stream_id,
5009 asd->stream_env[stream_id].isys_info[0].input_format,
5010 asd->stream_env[stream_id].isys_info[0].width,
5011 asd->stream_env[stream_id].isys_info[0].height);
5012
5013 atomisp_css_isys_two_stream_cfg_update_stream2(
5014 asd, stream_id,
5015 asd->stream_env[stream_id].isys_info[1].input_format,
5016 asd->stream_env[stream_id].isys_info[1].width,
5017 asd->stream_env[stream_id].isys_info[1].height);
5018 }
5019
5020
5021
5022 if (mipi_info->input_format != -1) {
5023 bayer_order = mipi_info->raw_bayer_order;
5024
5025
5026
5027 fc = atomisp_find_in_fmt_conv_by_atomisp_in_fmt(
5028 mipi_info->input_format);
5029 if (!fc)
5030 return -EINVAL;
5031 input_format = fc->atomisp_in_fmt;
5032 } else {
5033 struct v4l2_mbus_framefmt *sink;
5034
5035 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
5036 V4L2_SUBDEV_FORMAT_ACTIVE,
5037 ATOMISP_SUBDEV_PAD_SINK);
5038 fc = atomisp_find_in_fmt_conv(sink->code);
5039 if (!fc)
5040 return -EINVAL;
5041 input_format = fc->atomisp_in_fmt;
5042 bayer_order = fc->bayer_order;
5043 }
5044
5045 atomisp_css_input_set_format(asd, stream_id, input_format);
5046 atomisp_css_input_set_bayer_order(asd, stream_id, bayer_order);
5047
5048 fc = atomisp_find_in_fmt_conv_by_atomisp_in_fmt(
5049 mipi_info->metadata_format);
5050 if (!fc)
5051 return -EINVAL;
5052 input_format = fc->atomisp_in_fmt;
5053 atomisp_css_input_configure_port(asd,
5054 __get_mipi_port(asd->isp, mipi_info->port),
5055 mipi_info->num_lanes,
5056 0xffff4, mipi_freq,
5057 input_format,
5058 mipi_info->metadata_width,
5059 mipi_info->metadata_height);
5060 return 0;
5061}
5062
5063static int __enable_continuous_mode(struct atomisp_sub_device *asd,
5064 bool enable)
5065{
5066 struct atomisp_device *isp = asd->isp;
5067
5068 dev_dbg(isp->dev,
5069 "continuous mode %d, raw buffers %d, stop preview %d\n",
5070 enable, asd->continuous_raw_buffer_size->val,
5071 !asd->continuous_viewfinder->val);
5072
5073 if (!IS_ISP2401)
5074 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_PRIMARY);
5075 else
5076 atomisp_update_capture_mode(asd);
5077
5078
5079 atomisp_css_capture_enable_online(asd, ATOMISP_INPUT_STREAM_GENERAL,
5080 asd->params.low_light ? false : !enable);
5081 atomisp_css_preview_enable_online(asd, ATOMISP_INPUT_STREAM_GENERAL,
5082 !enable);
5083 atomisp_css_enable_continuous(asd, enable);
5084 atomisp_css_enable_cvf(asd, asd->continuous_viewfinder->val);
5085
5086 atomisp_css_continuous_set_num_raw_frames(asd,
5087 asd->continuous_raw_buffer_size->val);
5088
5089 if (!enable) {
5090 atomisp_css_enable_raw_binning(asd, false);
5091 atomisp_css_input_set_two_pixels_per_clock(asd, false);
5092 }
5093
5094 if (isp->inputs[asd->input_curr].type != FILE_INPUT)
5095 atomisp_css_input_set_mode(asd, IA_CSS_INPUT_MODE_BUFFERED_SENSOR);
5096
5097 return atomisp_update_run_mode(asd);
5098}
5099
5100static int configure_pp_input_nop(struct atomisp_sub_device *asd,
5101 unsigned int width, unsigned int height)
5102{
5103 return 0;
5104}
5105
5106static int configure_output_nop(struct atomisp_sub_device *asd,
5107 unsigned int width, unsigned int height,
5108 unsigned int min_width,
5109 enum ia_css_frame_format sh_fmt)
5110{
5111 return 0;
5112}
5113
5114static int get_frame_info_nop(struct atomisp_sub_device *asd,
5115 struct ia_css_frame_info *finfo)
5116{
5117 return 0;
5118}
5119
5120
5121
5122
5123
5124
5125
5126
5127static int css_input_resolution_changed(struct atomisp_sub_device *asd,
5128 struct v4l2_mbus_framefmt *ffmt)
5129{
5130 struct atomisp_metadata_buf *md_buf = NULL, *_md_buf;
5131 unsigned int i;
5132
5133 dev_dbg(asd->isp->dev, "css_input_resolution_changed to %ux%u\n",
5134 ffmt->width, ffmt->height);
5135
5136#if defined(ISP2401_NEW_INPUT_SYSTEM)
5137 atomisp_css_input_set_two_pixels_per_clock(asd, false);
5138#else
5139 atomisp_css_input_set_two_pixels_per_clock(asd, true);
5140#endif
5141 if (asd->continuous_mode->val) {
5142
5143 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO ||
5144 (ffmt->width >= 2048 || ffmt->height >= 1536)) {
5145
5146
5147
5148
5149 atomisp_css_enable_raw_binning(asd, true);
5150 }
5151 }
5152
5153
5154
5155
5156
5157 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
5158 list_for_each_entry_safe(md_buf, _md_buf, &asd->metadata[i],
5159 list) {
5160 atomisp_css_free_metadata_buffer(md_buf);
5161 list_del(&md_buf->list);
5162 kfree(md_buf);
5163 }
5164 }
5165 return 0;
5166
5167
5168
5169
5170
5171}
5172
5173static int atomisp_set_fmt_to_isp(struct video_device *vdev,
5174 struct ia_css_frame_info *output_info,
5175 struct ia_css_frame_info *raw_output_info,
5176 struct v4l2_pix_format *pix,
5177 unsigned int source_pad)
5178{
5179 struct camera_mipi_info *mipi_info;
5180 struct atomisp_device *isp = video_get_drvdata(vdev);
5181 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
5182 const struct atomisp_format_bridge *format;
5183 struct v4l2_rect *isp_sink_crop;
5184 enum ia_css_pipe_id pipe_id;
5185 struct v4l2_subdev_fh fh;
5186 int (*configure_output)(struct atomisp_sub_device *asd,
5187 unsigned int width, unsigned int height,
5188 unsigned int min_width,
5189 enum ia_css_frame_format sh_fmt) =
5190 configure_output_nop;
5191 int (*get_frame_info)(struct atomisp_sub_device *asd,
5192 struct ia_css_frame_info *finfo) =
5193 get_frame_info_nop;
5194 int (*configure_pp_input)(struct atomisp_sub_device *asd,
5195 unsigned int width, unsigned int height) =
5196 configure_pp_input_nop;
5197 u16 stream_index = atomisp_source_pad_to_stream_id(asd, source_pad);
5198 const struct atomisp_in_fmt_conv *fc;
5199 int ret, i;
5200
5201 v4l2_fh_init(&fh.vfh, vdev);
5202
5203 isp_sink_crop = atomisp_subdev_get_rect(
5204 &asd->subdev, NULL, V4L2_SUBDEV_FORMAT_ACTIVE,
5205 ATOMISP_SUBDEV_PAD_SINK, V4L2_SEL_TGT_CROP);
5206
5207 format = atomisp_get_format_bridge(pix->pixelformat);
5208 if (!format)
5209 return -EINVAL;
5210
5211 if (isp->inputs[asd->input_curr].type != TEST_PATTERN &&
5212 isp->inputs[asd->input_curr].type != FILE_INPUT) {
5213 mipi_info = atomisp_to_sensor_mipi_info(
5214 isp->inputs[asd->input_curr].camera);
5215 if (!mipi_info) {
5216 dev_err(isp->dev, "mipi_info is NULL\n");
5217 return -EINVAL;
5218 }
5219 if (atomisp_set_sensor_mipi_to_isp(asd, stream_index,
5220 mipi_info))
5221 return -EINVAL;
5222 fc = atomisp_find_in_fmt_conv_by_atomisp_in_fmt(
5223 mipi_info->input_format);
5224 if (!fc)
5225 fc = atomisp_find_in_fmt_conv(
5226 atomisp_subdev_get_ffmt(&asd->subdev,
5227 NULL, V4L2_SUBDEV_FORMAT_ACTIVE,
5228 ATOMISP_SUBDEV_PAD_SINK)->code);
5229 if (!fc)
5230 return -EINVAL;
5231 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW &&
5232 raw_output_format_match_input(fc->atomisp_in_fmt,
5233 pix->pixelformat))
5234 return -EINVAL;
5235 }
5236
5237
5238
5239
5240
5241 if (asd->fmt_auto->val ||
5242 asd->vfpp->val != ATOMISP_VFPP_ENABLE) {
5243 struct v4l2_rect vf_size = {0};
5244 struct v4l2_mbus_framefmt vf_ffmt = {0};
5245
5246 if (pix->width < 640 || pix->height < 480) {
5247 vf_size.width = pix->width;
5248 vf_size.height = pix->height;
5249 } else {
5250 vf_size.width = 640;
5251 vf_size.height = 480;
5252 }
5253
5254
5255
5256 vf_ffmt.code = V4L2_MBUS_FMT_CUSTOM_YUV420;
5257
5258 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5259 V4L2_SUBDEV_FORMAT_ACTIVE,
5260 ATOMISP_SUBDEV_PAD_SOURCE_VF,
5261 V4L2_SEL_TGT_COMPOSE, 0, &vf_size);
5262 atomisp_subdev_set_ffmt(&asd->subdev, fh.state,
5263 V4L2_SUBDEV_FORMAT_ACTIVE,
5264 ATOMISP_SUBDEV_PAD_SOURCE_VF, &vf_ffmt);
5265 asd->video_out_vf.sh_fmt = IA_CSS_FRAME_FORMAT_NV12;
5266
5267 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) {
5268 atomisp_css_video_configure_viewfinder(asd,
5269 vf_size.width, vf_size.height, 0,
5270 asd->video_out_vf.sh_fmt);
5271 } else if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
5272 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW ||
5273 source_pad == ATOMISP_SUBDEV_PAD_SOURCE_VIDEO)
5274 atomisp_css_video_configure_viewfinder(asd,
5275 vf_size.width, vf_size.height, 0,
5276 asd->video_out_vf.sh_fmt);
5277 else
5278 atomisp_css_capture_configure_viewfinder(asd,
5279 vf_size.width, vf_size.height, 0,
5280 asd->video_out_vf.sh_fmt);
5281 } else if (source_pad != ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW ||
5282 asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT) {
5283 atomisp_css_capture_configure_viewfinder(asd,
5284 vf_size.width, vf_size.height, 0,
5285 asd->video_out_vf.sh_fmt);
5286 }
5287 }
5288
5289 if (asd->continuous_mode->val) {
5290 ret = __enable_continuous_mode(asd, true);
5291 if (ret)
5292 return -EINVAL;
5293 }
5294
5295 atomisp_css_input_set_mode(asd, IA_CSS_INPUT_MODE_BUFFERED_SENSOR);
5296
5297 for (i = 0; i < IA_CSS_PIPE_ID_NUM; i++)
5298 asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].pipe_extra_configs[i].disable_vf_pp = asd->vfpp->val != ATOMISP_VFPP_ENABLE;
5299
5300
5301 if (asd->copy_mode) {
5302 pipe_id = IA_CSS_PIPE_ID_COPY;
5303 atomisp_css_capture_enable_online(asd, stream_index, false);
5304 } else if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) {
5305
5306 configure_output = atomisp_css_video_configure_output;
5307 get_frame_info = atomisp_css_video_get_output_frame_info;
5308 pipe_id = IA_CSS_PIPE_ID_VIDEO;
5309 } else if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
5310 if (!asd->continuous_mode->val) {
5311 configure_output = atomisp_css_video_configure_output;
5312 get_frame_info =
5313 atomisp_css_video_get_output_frame_info;
5314 pipe_id = IA_CSS_PIPE_ID_VIDEO;
5315 } else {
5316 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW ||
5317 source_pad == ATOMISP_SUBDEV_PAD_SOURCE_VIDEO) {
5318 configure_output =
5319 atomisp_css_video_configure_output;
5320 get_frame_info =
5321 atomisp_css_video_get_output_frame_info;
5322 configure_pp_input =
5323 atomisp_css_video_configure_pp_input;
5324 pipe_id = IA_CSS_PIPE_ID_VIDEO;
5325 } else {
5326 configure_output =
5327 atomisp_css_capture_configure_output;
5328 get_frame_info =
5329 atomisp_css_capture_get_output_frame_info;
5330 configure_pp_input =
5331 atomisp_css_capture_configure_pp_input;
5332 pipe_id = IA_CSS_PIPE_ID_CAPTURE;
5333
5334 atomisp_update_capture_mode(asd);
5335 atomisp_css_capture_enable_online(asd, stream_index, false);
5336 }
5337 }
5338 } else if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW) {
5339 configure_output = atomisp_css_preview_configure_output;
5340 get_frame_info = atomisp_css_preview_get_output_frame_info;
5341 configure_pp_input = atomisp_css_preview_configure_pp_input;
5342 pipe_id = IA_CSS_PIPE_ID_PREVIEW;
5343 } else {
5344
5345
5346
5347
5348 if (isp->inputs[asd->input_curr].type == SOC_CAMERA)
5349 asd->params.low_light = false;
5350
5351 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW) {
5352 atomisp_css_capture_set_mode(asd, IA_CSS_CAPTURE_MODE_RAW);
5353 atomisp_css_enable_dz(asd, false);
5354 } else {
5355 atomisp_update_capture_mode(asd);
5356 }
5357
5358 if (!asd->continuous_mode->val)
5359
5360 atomisp_css_capture_enable_online(asd, stream_index,
5361 asd->params.low_light ?
5362 false : asd->params.online_process);
5363
5364 configure_output = atomisp_css_capture_configure_output;
5365 get_frame_info = atomisp_css_capture_get_output_frame_info;
5366 configure_pp_input = atomisp_css_capture_configure_pp_input;
5367 pipe_id = IA_CSS_PIPE_ID_CAPTURE;
5368
5369 if (!asd->params.online_process &&
5370 !asd->continuous_mode->val) {
5371 ret = atomisp_css_capture_get_output_raw_frame_info(asd,
5372 raw_output_info);
5373 if (ret)
5374 return ret;
5375 }
5376 if (!asd->continuous_mode->val && asd->run_mode->val
5377 != ATOMISP_RUN_MODE_STILL_CAPTURE) {
5378 dev_err(isp->dev,
5379 "Need to set the running mode first\n");
5380 asd->run_mode->val = ATOMISP_RUN_MODE_STILL_CAPTURE;
5381 }
5382 }
5383
5384
5385
5386
5387 if (ATOMISP_USE_YUVPP(asd))
5388 pipe_id = IA_CSS_PIPE_ID_YUVPP;
5389
5390 if (asd->copy_mode)
5391 ret = atomisp_css_copy_configure_output(asd, stream_index,
5392 pix->width, pix->height,
5393 format->planar ? pix->bytesperline :
5394 pix->bytesperline * 8 / format->depth,
5395 format->sh_fmt);
5396 else
5397 ret = configure_output(asd, pix->width, pix->height,
5398 format->planar ? pix->bytesperline :
5399 pix->bytesperline * 8 / format->depth,
5400 format->sh_fmt);
5401 if (ret) {
5402 dev_err(isp->dev, "configure_output %ux%u, format %8.8x\n",
5403 pix->width, pix->height, format->sh_fmt);
5404 return -EINVAL;
5405 }
5406
5407 ret = configure_pp_input(asd, isp_sink_crop->width, isp_sink_crop->height);
5408 if (ret) {
5409 dev_err(isp->dev, "configure_pp_input %ux%u\n",
5410 isp_sink_crop->width,
5411 isp_sink_crop->height);
5412 return -EINVAL;
5413 }
5414 if (asd->copy_mode)
5415 ret = atomisp_css_copy_get_output_frame_info(asd, stream_index,
5416 output_info);
5417 else
5418 ret = get_frame_info(asd, output_info);
5419 if (ret) {
5420 dev_err(isp->dev, "get_frame_info %ux%u (padded to %u)\n",
5421 pix->width, pix->height, pix->bytesperline);
5422 return -EINVAL;
5423 }
5424
5425 atomisp_update_grid_info(asd, pipe_id, source_pad);
5426
5427
5428 ia_css_frame_free(asd->raw_output_frame);
5429 asd->raw_output_frame = NULL;
5430
5431 if (!asd->continuous_mode->val &&
5432 !asd->params.online_process && !isp->sw_contex.file_input &&
5433 ia_css_frame_allocate_from_info(&asd->raw_output_frame,
5434 raw_output_info))
5435 return -ENOMEM;
5436
5437 return 0;
5438}
5439
5440static void atomisp_get_dis_envelop(struct atomisp_sub_device *asd,
5441 unsigned int width, unsigned int height,
5442 unsigned int *dvs_env_w, unsigned int *dvs_env_h)
5443{
5444 struct atomisp_device *isp = asd->isp;
5445
5446
5447 if (isp->inputs[asd->input_curr].type == SOC_CAMERA)
5448 asd->params.video_dis_en = false;
5449
5450 if (asd->params.video_dis_en &&
5451 asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
5452
5453
5454
5455
5456
5457 *dvs_env_w = rounddown(width / 5, ATOM_ISP_STEP_WIDTH);
5458 *dvs_env_h = rounddown(height / 5, ATOM_ISP_STEP_HEIGHT);
5459 }
5460
5461 asd->params.dis_proj_data_valid = false;
5462 asd->params.css_update_params_needed = true;
5463}
5464
5465static void atomisp_check_copy_mode(struct atomisp_sub_device *asd,
5466 int source_pad, struct v4l2_pix_format *f)
5467{
5468#if defined(ISP2401_NEW_INPUT_SYSTEM)
5469 struct v4l2_mbus_framefmt *sink, *src;
5470
5471 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
5472 V4L2_SUBDEV_FORMAT_ACTIVE, ATOMISP_SUBDEV_PAD_SINK);
5473 src = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
5474 V4L2_SUBDEV_FORMAT_ACTIVE, source_pad);
5475
5476 if ((sink->code == src->code &&
5477 sink->width == f->width &&
5478 sink->height == f->height) ||
5479 ((asd->isp->inputs[asd->input_curr].type == SOC_CAMERA) &&
5480 (asd->isp->inputs[asd->input_curr].camera_caps->
5481 sensor[asd->sensor_curr].stream_num > 1)))
5482 asd->copy_mode = true;
5483 else
5484#endif
5485
5486 asd->copy_mode = false;
5487
5488 dev_dbg(asd->isp->dev, "copy_mode: %d\n", asd->copy_mode);
5489}
5490
5491static int atomisp_set_fmt_to_snr(struct video_device *vdev,
5492 struct v4l2_pix_format *f, unsigned int pixelformat,
5493 unsigned int padding_w, unsigned int padding_h,
5494 unsigned int dvs_env_w, unsigned int dvs_env_h)
5495{
5496 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
5497 const struct atomisp_format_bridge *format;
5498 struct v4l2_subdev_pad_config pad_cfg;
5499 struct v4l2_subdev_state pad_state = {
5500 .pads = &pad_cfg
5501 };
5502 struct v4l2_subdev_format vformat = {
5503 .which = V4L2_SUBDEV_FORMAT_TRY,
5504 };
5505 struct v4l2_mbus_framefmt *ffmt = &vformat.format;
5506 struct v4l2_mbus_framefmt *req_ffmt;
5507 struct atomisp_device *isp = asd->isp;
5508 struct atomisp_input_stream_info *stream_info =
5509 (struct atomisp_input_stream_info *)ffmt->reserved;
5510 u16 stream_index = ATOMISP_INPUT_STREAM_GENERAL;
5511 int source_pad = atomisp_subdev_source_pad(vdev);
5512 struct v4l2_subdev_fh fh;
5513 int ret;
5514
5515 v4l2_fh_init(&fh.vfh, vdev);
5516
5517 stream_index = atomisp_source_pad_to_stream_id(asd, source_pad);
5518
5519 format = atomisp_get_format_bridge(pixelformat);
5520 if (!format)
5521 return -EINVAL;
5522
5523 v4l2_fill_mbus_format(ffmt, f, format->mbus_code);
5524 ffmt->height += padding_h + dvs_env_h;
5525 ffmt->width += padding_w + dvs_env_w;
5526
5527 dev_dbg(isp->dev, "s_mbus_fmt: ask %ux%u (padding %ux%u, dvs %ux%u)\n",
5528 ffmt->width, ffmt->height, padding_w, padding_h,
5529 dvs_env_w, dvs_env_h);
5530
5531 __atomisp_init_stream_info(stream_index, stream_info);
5532
5533 req_ffmt = ffmt;
5534
5535
5536 if (asd->params.video_dis_en &&
5537 source_pad == ATOMISP_SUBDEV_PAD_SOURCE_VIDEO) {
5538 vformat.which = V4L2_SUBDEV_FORMAT_TRY;
5539 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
5540 pad, set_fmt, &pad_state, &vformat);
5541 if (ret)
5542 return ret;
5543 if (ffmt->width < req_ffmt->width ||
5544 ffmt->height < req_ffmt->height) {
5545 req_ffmt->height -= dvs_env_h;
5546 req_ffmt->width -= dvs_env_w;
5547 ffmt = req_ffmt;
5548 dev_warn(isp->dev,
5549 "can not enable video dis due to sensor limitation.");
5550 asd->params.video_dis_en = false;
5551 }
5552 }
5553 dev_dbg(isp->dev, "sensor width: %d, height: %d\n",
5554 ffmt->width, ffmt->height);
5555 vformat.which = V4L2_SUBDEV_FORMAT_ACTIVE;
5556 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, pad,
5557 set_fmt, NULL, &vformat);
5558 if (ret)
5559 return ret;
5560
5561 __atomisp_update_stream_env(asd, stream_index, stream_info);
5562
5563 dev_dbg(isp->dev, "sensor width: %d, height: %d\n",
5564 ffmt->width, ffmt->height);
5565
5566 if (ffmt->width < ATOM_ISP_STEP_WIDTH ||
5567 ffmt->height < ATOM_ISP_STEP_HEIGHT)
5568 return -EINVAL;
5569
5570 if (asd->params.video_dis_en &&
5571 source_pad == ATOMISP_SUBDEV_PAD_SOURCE_VIDEO &&
5572 (ffmt->width < req_ffmt->width || ffmt->height < req_ffmt->height)) {
5573 dev_warn(isp->dev,
5574 "can not enable video dis due to sensor limitation.");
5575 asd->params.video_dis_en = false;
5576 }
5577
5578 atomisp_subdev_set_ffmt(&asd->subdev, fh.state,
5579 V4L2_SUBDEV_FORMAT_ACTIVE,
5580 ATOMISP_SUBDEV_PAD_SINK, ffmt);
5581
5582 return css_input_resolution_changed(asd, ffmt);
5583}
5584
5585int atomisp_set_fmt(struct video_device *vdev, struct v4l2_format *f)
5586{
5587 struct atomisp_device *isp = video_get_drvdata(vdev);
5588 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
5589 struct atomisp_sub_device *asd = pipe->asd;
5590 const struct atomisp_format_bridge *format_bridge;
5591 const struct atomisp_format_bridge *snr_format_bridge;
5592 struct ia_css_frame_info output_info, raw_output_info;
5593 struct v4l2_pix_format snr_fmt = f->fmt.pix;
5594 struct v4l2_pix_format backup_fmt = snr_fmt, s_fmt;
5595 unsigned int dvs_env_w = 0, dvs_env_h = 0;
5596 unsigned int padding_w = pad_w, padding_h = pad_h;
5597 bool res_overflow = false, crop_needs_override = false;
5598 struct v4l2_mbus_framefmt *isp_sink_fmt;
5599 struct v4l2_mbus_framefmt isp_source_fmt = {0};
5600 struct v4l2_rect isp_sink_crop;
5601 u16 source_pad = atomisp_subdev_source_pad(vdev);
5602 struct v4l2_subdev_fh fh;
5603 int ret;
5604
5605 if (source_pad >= ATOMISP_SUBDEV_PADS_NUM)
5606 return -EINVAL;
5607
5608 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
5609 dev_warn(isp->dev, "ISP does not support set format while at streaming!\n");
5610 return -EBUSY;
5611 }
5612
5613 dev_dbg(isp->dev,
5614 "setting resolution %ux%u on pad %u for asd%d, bytesperline %u\n",
5615 f->fmt.pix.width, f->fmt.pix.height, source_pad,
5616 asd->index, f->fmt.pix.bytesperline);
5617
5618 v4l2_fh_init(&fh.vfh, vdev);
5619
5620 format_bridge = atomisp_get_format_bridge(f->fmt.pix.pixelformat);
5621 if (!format_bridge)
5622 return -EINVAL;
5623
5624 pipe->sh_fmt = format_bridge->sh_fmt;
5625 pipe->pix.pixelformat = f->fmt.pix.pixelformat;
5626
5627 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_VF ||
5628 (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW
5629 && asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)) {
5630 if (asd->fmt_auto->val) {
5631 struct v4l2_rect *capture_comp;
5632 struct v4l2_rect r = {0};
5633
5634 r.width = f->fmt.pix.width;
5635 r.height = f->fmt.pix.height;
5636
5637 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW)
5638 capture_comp = atomisp_subdev_get_rect(
5639 &asd->subdev, NULL,
5640 V4L2_SUBDEV_FORMAT_ACTIVE,
5641 ATOMISP_SUBDEV_PAD_SOURCE_VIDEO,
5642 V4L2_SEL_TGT_COMPOSE);
5643 else
5644 capture_comp = atomisp_subdev_get_rect(
5645 &asd->subdev, NULL,
5646 V4L2_SUBDEV_FORMAT_ACTIVE,
5647 ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE,
5648 V4L2_SEL_TGT_COMPOSE);
5649
5650 if (capture_comp->width < r.width
5651 || capture_comp->height < r.height) {
5652 r.width = capture_comp->width;
5653 r.height = capture_comp->height;
5654 }
5655
5656 atomisp_subdev_set_selection(
5657 &asd->subdev, fh.state,
5658 V4L2_SUBDEV_FORMAT_ACTIVE, source_pad,
5659 V4L2_SEL_TGT_COMPOSE, 0, &r);
5660
5661 f->fmt.pix.width = r.width;
5662 f->fmt.pix.height = r.height;
5663 }
5664
5665 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW &&
5666 (asd->isp->inputs[asd->input_curr].type == SOC_CAMERA) &&
5667 (asd->isp->inputs[asd->input_curr].camera_caps->
5668 sensor[asd->sensor_curr].stream_num > 1)) {
5669
5670 u16 video_index =
5671 atomisp_source_pad_to_stream_id(asd,
5672 ATOMISP_SUBDEV_PAD_SOURCE_VIDEO);
5673
5674 ret = atomisp_css_copy_get_output_frame_info(asd,
5675 video_index, &output_info);
5676 if (ret) {
5677 dev_err(isp->dev,
5678 "copy_get_output_frame_info ret %i", ret);
5679 return -EINVAL;
5680 }
5681 if (!asd->yuvpp_mode) {
5682
5683
5684
5685
5686 asd->yuvpp_mode = true;
5687 ret = atomisp_css_copy_configure_output(
5688 asd, video_index, 0, 0, 0, 0);
5689 if (ret) {
5690 dev_err(isp->dev,
5691 "failed to disable copy pipe");
5692 return -EINVAL;
5693 }
5694 ret = atomisp_css_yuvpp_configure_output(
5695 asd, video_index,
5696 output_info.res.width,
5697 output_info.res.height,
5698 output_info.padded_width,
5699 output_info.format);
5700 if (ret) {
5701 dev_err(isp->dev,
5702 "failed to set up yuvpp pipe\n");
5703 return -EINVAL;
5704 }
5705 atomisp_css_video_enable_online(asd, false);
5706 atomisp_css_preview_enable_online(asd,
5707 ATOMISP_INPUT_STREAM_GENERAL, false);
5708 }
5709 atomisp_css_yuvpp_configure_viewfinder(asd, video_index,
5710 f->fmt.pix.width, f->fmt.pix.height,
5711 format_bridge->planar ? f->fmt.pix.bytesperline
5712 : f->fmt.pix.bytesperline * 8
5713 / format_bridge->depth, format_bridge->sh_fmt);
5714 atomisp_css_yuvpp_get_viewfinder_frame_info(
5715 asd, video_index, &output_info);
5716 } else if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW) {
5717 atomisp_css_video_configure_viewfinder(asd,
5718 f->fmt.pix.width, f->fmt.pix.height,
5719 format_bridge->planar ? f->fmt.pix.bytesperline
5720 : f->fmt.pix.bytesperline * 8
5721 / format_bridge->depth, format_bridge->sh_fmt);
5722 atomisp_css_video_get_viewfinder_frame_info(asd,
5723 &output_info);
5724 asd->copy_mode = false;
5725 } else {
5726 atomisp_css_capture_configure_viewfinder(asd,
5727 f->fmt.pix.width, f->fmt.pix.height,
5728 format_bridge->planar ? f->fmt.pix.bytesperline
5729 : f->fmt.pix.bytesperline * 8
5730 / format_bridge->depth, format_bridge->sh_fmt);
5731 atomisp_css_capture_get_viewfinder_frame_info(asd,
5732 &output_info);
5733 asd->copy_mode = false;
5734 }
5735
5736 goto done;
5737 }
5738
5739
5740
5741
5742
5743 if (source_pad == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE) {
5744 struct v4l2_rect *r;
5745
5746 r = atomisp_subdev_get_rect(
5747 &asd->subdev, NULL,
5748 V4L2_SUBDEV_FORMAT_ACTIVE,
5749 ATOMISP_SUBDEV_PAD_SOURCE_VF, V4L2_SEL_TGT_COMPOSE);
5750
5751 if (r->width && r->height
5752 && (r->width > f->fmt.pix.width
5753 || r->height > f->fmt.pix.height))
5754 dev_warn(isp->dev,
5755 "Main Resolution config smaller then Vf Resolution. Force to be equal with Vf Resolution.");
5756 }
5757
5758
5759 if (!asd->fmt_auto->val)
5760 goto set_fmt_to_isp;
5761
5762
5763 ret = atomisp_try_fmt(vdev, &snr_fmt, &res_overflow);
5764 if (ret) {
5765 dev_warn(isp->dev, "Try format failed with error %d\n", ret);
5766 return ret;
5767 }
5768 f->fmt.pix.width = snr_fmt.width;
5769 f->fmt.pix.height = snr_fmt.height;
5770
5771 snr_format_bridge = atomisp_get_format_bridge(snr_fmt.pixelformat);
5772 if (!snr_format_bridge) {
5773 dev_warn(isp->dev, "Can't find bridge format\n");
5774 return -EINVAL;
5775 }
5776
5777 atomisp_subdev_get_ffmt(&asd->subdev, NULL,
5778 V4L2_SUBDEV_FORMAT_ACTIVE,
5779 ATOMISP_SUBDEV_PAD_SINK)->code =
5780 snr_format_bridge->mbus_code;
5781
5782 isp_sink_fmt = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
5783 V4L2_SUBDEV_FORMAT_ACTIVE,
5784 ATOMISP_SUBDEV_PAD_SINK);
5785
5786 isp_source_fmt.code = format_bridge->mbus_code;
5787 atomisp_subdev_set_ffmt(&asd->subdev, fh.state,
5788 V4L2_SUBDEV_FORMAT_ACTIVE,
5789 source_pad, &isp_source_fmt);
5790
5791 if (!atomisp_subdev_format_conversion(asd, source_pad)) {
5792 padding_w = 0;
5793 padding_h = 0;
5794 } else if (IS_BYT) {
5795 padding_w = 12;
5796 padding_h = 12;
5797 }
5798
5799
5800 if (res_overflow && !asd->continuous_mode->val) {
5801 f->fmt.pix.width = rounddown(
5802 clamp_t(u32, f->fmt.pix.width - padding_w,
5803 ATOM_ISP_MIN_WIDTH,
5804 ATOM_ISP_MAX_WIDTH), ATOM_ISP_STEP_WIDTH);
5805 f->fmt.pix.height = rounddown(
5806 clamp_t(u32, f->fmt.pix.height - padding_h,
5807 ATOM_ISP_MIN_HEIGHT,
5808 ATOM_ISP_MAX_HEIGHT), ATOM_ISP_STEP_HEIGHT);
5809 }
5810
5811 atomisp_get_dis_envelop(asd, f->fmt.pix.width, f->fmt.pix.height,
5812 &dvs_env_w, &dvs_env_h);
5813
5814 if (asd->continuous_mode->val) {
5815 struct v4l2_rect *r;
5816
5817 r = atomisp_subdev_get_rect(
5818 &asd->subdev, NULL,
5819 V4L2_SUBDEV_FORMAT_ACTIVE,
5820 ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE,
5821 V4L2_SEL_TGT_COMPOSE);
5822
5823
5824
5825
5826 if (r->width && r->height)
5827 asd->capture_pad = ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE;
5828 else
5829 asd->capture_pad = source_pad;
5830 } else {
5831 asd->capture_pad = source_pad;
5832 }
5833
5834
5835
5836
5837
5838
5839 if (!asd->continuous_mode->val ||
5840 isp_sink_fmt->width < (f->fmt.pix.width + padding_w + dvs_env_w) ||
5841 isp_sink_fmt->height < (f->fmt.pix.height + padding_h +
5842 dvs_env_h)) {
5843
5844
5845
5846
5847
5848
5849
5850
5851
5852 s_fmt = f->fmt.pix;
5853 if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG ||
5854 f->fmt.pix.pixelformat == V4L2_PIX_FMT_CUSTOM_M10MO_RAW) {
5855 s_fmt.width = backup_fmt.width;
5856 s_fmt.height = backup_fmt.height;
5857 }
5858 ret = atomisp_set_fmt_to_snr(vdev, &s_fmt,
5859 f->fmt.pix.pixelformat, padding_w,
5860 padding_h, dvs_env_w, dvs_env_h);
5861 if (ret) {
5862 dev_warn(isp->dev,
5863 "Set format to sensor failed with %d\n", ret);
5864 return -EINVAL;
5865 }
5866
5867 atomisp_csi_lane_config(isp);
5868 crop_needs_override = true;
5869 }
5870
5871 atomisp_check_copy_mode(asd, source_pad, &backup_fmt);
5872 asd->yuvpp_mode = false;
5873
5874 isp_sink_crop = *atomisp_subdev_get_rect(&asd->subdev, NULL,
5875 V4L2_SUBDEV_FORMAT_ACTIVE,
5876 ATOMISP_SUBDEV_PAD_SINK,
5877 V4L2_SEL_TGT_CROP);
5878
5879
5880
5881 if (isp_sink_crop.width * 9 / 10 < f->fmt.pix.width ||
5882 isp_sink_crop.height * 9 / 10 < f->fmt.pix.height ||
5883 (atomisp_subdev_format_conversion(asd, source_pad) &&
5884 ((asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO &&
5885 !asd->continuous_mode->val) ||
5886 asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER))) {
5887
5888
5889
5890
5891
5892 if (asd->continuous_mode->val
5893 && source_pad == ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW
5894 && !crop_needs_override) {
5895 isp_sink_crop.width =
5896 max_t(unsigned int, f->fmt.pix.width,
5897 isp_sink_crop.width);
5898 isp_sink_crop.height =
5899 max_t(unsigned int, f->fmt.pix.height,
5900 isp_sink_crop.height);
5901 } else {
5902 isp_sink_crop.width = f->fmt.pix.width;
5903 isp_sink_crop.height = f->fmt.pix.height;
5904 }
5905
5906 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5907 V4L2_SUBDEV_FORMAT_ACTIVE,
5908 ATOMISP_SUBDEV_PAD_SINK,
5909 V4L2_SEL_TGT_CROP,
5910 V4L2_SEL_FLAG_KEEP_CONFIG,
5911 &isp_sink_crop);
5912 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5913 V4L2_SUBDEV_FORMAT_ACTIVE,
5914 source_pad, V4L2_SEL_TGT_COMPOSE,
5915 0, &isp_sink_crop);
5916 } else if (IS_MOFD) {
5917 struct v4l2_rect main_compose = {0};
5918
5919 main_compose.width = isp_sink_crop.width;
5920 main_compose.height =
5921 DIV_ROUND_UP(main_compose.width * f->fmt.pix.height,
5922 f->fmt.pix.width);
5923 if (main_compose.height > isp_sink_crop.height) {
5924 main_compose.height = isp_sink_crop.height;
5925 main_compose.width =
5926 DIV_ROUND_UP(main_compose.height *
5927 f->fmt.pix.width,
5928 f->fmt.pix.height);
5929 }
5930
5931 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5932 V4L2_SUBDEV_FORMAT_ACTIVE,
5933 source_pad,
5934 V4L2_SEL_TGT_COMPOSE, 0,
5935 &main_compose);
5936 } else {
5937 struct v4l2_rect sink_crop = {0};
5938 struct v4l2_rect main_compose = {0};
5939
5940 main_compose.width = f->fmt.pix.width;
5941 main_compose.height = f->fmt.pix.height;
5942
5943
5944
5945
5946
5947
5948 if (!IS_ISP2401 || crop_needs_override) {
5949 if (isp_sink_crop.width * main_compose.height >
5950 isp_sink_crop.height * main_compose.width) {
5951 sink_crop.height = isp_sink_crop.height;
5952 sink_crop.width = DIV_NEAREST_STEP(
5953 sink_crop.height *
5954 f->fmt.pix.width,
5955 f->fmt.pix.height,
5956 ATOM_ISP_STEP_WIDTH);
5957 } else {
5958 sink_crop.width = isp_sink_crop.width;
5959 sink_crop.height = DIV_NEAREST_STEP(
5960 sink_crop.width *
5961 f->fmt.pix.height,
5962 f->fmt.pix.width,
5963 ATOM_ISP_STEP_HEIGHT);
5964 }
5965 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5966 V4L2_SUBDEV_FORMAT_ACTIVE,
5967 ATOMISP_SUBDEV_PAD_SINK,
5968 V4L2_SEL_TGT_CROP,
5969 V4L2_SEL_FLAG_KEEP_CONFIG,
5970 &sink_crop);
5971 }
5972 atomisp_subdev_set_selection(&asd->subdev, fh.state,
5973 V4L2_SUBDEV_FORMAT_ACTIVE,
5974 source_pad,
5975 V4L2_SEL_TGT_COMPOSE, 0,
5976 &main_compose);
5977 }
5978
5979set_fmt_to_isp:
5980 ret = atomisp_set_fmt_to_isp(vdev, &output_info, &raw_output_info,
5981 &f->fmt.pix, source_pad);
5982 if (ret) {
5983 dev_warn(isp->dev, "Can't set format on ISP. Error %d\n", ret);
5984 return -EINVAL;
5985 }
5986done:
5987 pipe->pix.width = f->fmt.pix.width;
5988 pipe->pix.height = f->fmt.pix.height;
5989 pipe->pix.pixelformat = f->fmt.pix.pixelformat;
5990 if (format_bridge->planar) {
5991 pipe->pix.bytesperline = output_info.padded_width;
5992 pipe->pix.sizeimage = PAGE_ALIGN(f->fmt.pix.height *
5993 DIV_ROUND_UP(format_bridge->depth *
5994 output_info.padded_width, 8));
5995 } else {
5996 pipe->pix.bytesperline =
5997 DIV_ROUND_UP(format_bridge->depth *
5998 output_info.padded_width, 8);
5999 pipe->pix.sizeimage =
6000 PAGE_ALIGN(f->fmt.pix.height * pipe->pix.bytesperline);
6001 }
6002 dev_dbg(isp->dev, "%s: image size: %d, %d bytes per line\n",
6003 __func__, pipe->pix.sizeimage, pipe->pix.bytesperline);
6004
6005 if (f->fmt.pix.field == V4L2_FIELD_ANY)
6006 f->fmt.pix.field = V4L2_FIELD_NONE;
6007 pipe->pix.field = f->fmt.pix.field;
6008
6009 f->fmt.pix = pipe->pix;
6010 f->fmt.pix.priv = PAGE_ALIGN(pipe->pix.width *
6011 pipe->pix.height * 2);
6012
6013 pipe->capq.field = f->fmt.pix.field;
6014
6015
6016
6017
6018 if (asd->run_mode->val == ATOMISP_SUBDEV_PAD_SOURCE_VIDEO &&
6019 f->fmt.pix.width == 720 && f->fmt.pix.height == 480)
6020 isp->need_gfx_throttle = false;
6021 else
6022 isp->need_gfx_throttle = true;
6023
6024 return 0;
6025}
6026
6027int atomisp_set_fmt_file(struct video_device *vdev, struct v4l2_format *f)
6028{
6029 struct atomisp_device *isp = video_get_drvdata(vdev);
6030 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
6031 struct atomisp_sub_device *asd = pipe->asd;
6032 struct v4l2_mbus_framefmt ffmt = {0};
6033 const struct atomisp_format_bridge *format_bridge;
6034 struct v4l2_subdev_fh fh;
6035 int ret;
6036
6037 v4l2_fh_init(&fh.vfh, vdev);
6038
6039 dev_dbg(isp->dev, "setting fmt %ux%u 0x%x for file inject\n",
6040 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat);
6041 ret = atomisp_try_fmt_file(isp, f);
6042 if (ret) {
6043 dev_err(isp->dev, "atomisp_try_fmt_file err: %d\n", ret);
6044 return ret;
6045 }
6046
6047 format_bridge = atomisp_get_format_bridge(f->fmt.pix.pixelformat);
6048 if (!format_bridge) {
6049 dev_dbg(isp->dev, "atomisp_get_format_bridge err! fmt:0x%x\n",
6050 f->fmt.pix.pixelformat);
6051 return -EINVAL;
6052 }
6053
6054 pipe->pix = f->fmt.pix;
6055 atomisp_css_input_set_mode(asd, IA_CSS_INPUT_MODE_FIFO);
6056 atomisp_css_input_configure_port(asd,
6057 __get_mipi_port(isp, ATOMISP_CAMERA_PORT_PRIMARY), 2, 0xffff4,
6058 0, 0, 0, 0);
6059 ffmt.width = f->fmt.pix.width;
6060 ffmt.height = f->fmt.pix.height;
6061 ffmt.code = format_bridge->mbus_code;
6062
6063 atomisp_subdev_set_ffmt(&asd->subdev, fh.state,
6064 V4L2_SUBDEV_FORMAT_ACTIVE,
6065 ATOMISP_SUBDEV_PAD_SINK, &ffmt);
6066
6067 return 0;
6068}
6069
6070int atomisp_set_shading_table(struct atomisp_sub_device *asd,
6071 struct atomisp_shading_table *user_shading_table)
6072{
6073 struct ia_css_shading_table *shading_table;
6074 struct ia_css_shading_table *free_table;
6075 unsigned int len_table;
6076 int i;
6077 int ret = 0;
6078
6079 if (!user_shading_table)
6080 return -EINVAL;
6081
6082 if (!user_shading_table->enable) {
6083 asd->params.config.shading_table = NULL;
6084 asd->params.sc_en = false;
6085 return 0;
6086 }
6087
6088
6089 for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
6090 if (!user_shading_table->data[i])
6091 return -EINVAL;
6092 }
6093
6094
6095 if (!IS_ISP2401) {
6096 if (user_shading_table->width > ISP2400_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
6097 user_shading_table->height > ISP2400_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR)
6098 return -EINVAL;
6099 } else {
6100 if (user_shading_table->width > ISP2401_SH_CSS_MAX_SCTBL_WIDTH_PER_COLOR ||
6101 user_shading_table->height > ISP2401_SH_CSS_MAX_SCTBL_HEIGHT_PER_COLOR)
6102 return -EINVAL;
6103 }
6104
6105 shading_table = atomisp_css_shading_table_alloc(
6106 user_shading_table->width, user_shading_table->height);
6107 if (!shading_table)
6108 return -ENOMEM;
6109
6110 len_table = user_shading_table->width * user_shading_table->height *
6111 ATOMISP_SC_TYPE_SIZE;
6112 for (i = 0; i < ATOMISP_NUM_SC_COLORS; i++) {
6113 ret = copy_from_user(shading_table->data[i],
6114 (void __user *)user_shading_table->data[i],
6115 len_table);
6116 if (ret) {
6117 free_table = shading_table;
6118 ret = -EFAULT;
6119 goto out;
6120 }
6121 }
6122 shading_table->sensor_width = user_shading_table->sensor_width;
6123 shading_table->sensor_height = user_shading_table->sensor_height;
6124 shading_table->fraction_bits = user_shading_table->fraction_bits;
6125
6126 free_table = asd->params.css_param.shading_table;
6127 asd->params.css_param.shading_table = shading_table;
6128 asd->params.config.shading_table = shading_table;
6129 asd->params.sc_en = true;
6130
6131out:
6132 if (free_table)
6133 atomisp_css_shading_table_free(free_table);
6134
6135 return ret;
6136}
6137
6138
6139int atomisp_ospm_dphy_down(struct atomisp_device *isp)
6140{
6141 struct pci_dev *pdev = to_pci_dev(isp->dev);
6142 unsigned long flags;
6143 u32 reg;
6144
6145 dev_dbg(isp->dev, "%s\n", __func__);
6146
6147
6148 if (isp->isp_timeout)
6149 goto done;
6150
6151 if (!atomisp_dev_users(isp))
6152 goto done;
6153
6154 spin_lock_irqsave(&isp->lock, flags);
6155 isp->sw_contex.power_state = ATOM_ISP_POWER_DOWN;
6156 spin_unlock_irqrestore(&isp->lock, flags);
6157done:
6158
6159
6160
6161
6162
6163 pci_read_config_dword(pdev, MRFLD_PCI_CSI_CONTROL, ®);
6164 reg |= MRFLD_ALL_CSI_PORTS_OFF_MASK;
6165 pci_write_config_dword(pdev, MRFLD_PCI_CSI_CONTROL, reg);
6166 return 0;
6167}
6168
6169
6170int atomisp_ospm_dphy_up(struct atomisp_device *isp)
6171{
6172 unsigned long flags;
6173
6174 dev_dbg(isp->dev, "%s\n", __func__);
6175
6176 spin_lock_irqsave(&isp->lock, flags);
6177 isp->sw_contex.power_state = ATOM_ISP_POWER_UP;
6178 spin_unlock_irqrestore(&isp->lock, flags);
6179
6180 return 0;
6181}
6182
6183int atomisp_exif_makernote(struct atomisp_sub_device *asd,
6184 struct atomisp_makernote_info *config)
6185{
6186 struct v4l2_control ctrl;
6187 struct atomisp_device *isp = asd->isp;
6188
6189 ctrl.id = V4L2_CID_FOCAL_ABSOLUTE;
6190 if (v4l2_g_ctrl
6191 (isp->inputs[asd->input_curr].camera->ctrl_handler, &ctrl)) {
6192 dev_warn(isp->dev, "failed to g_ctrl for focal length\n");
6193 return -EINVAL;
6194 } else {
6195 config->focal_length = ctrl.value;
6196 }
6197
6198 ctrl.id = V4L2_CID_FNUMBER_ABSOLUTE;
6199 if (v4l2_g_ctrl
6200 (isp->inputs[asd->input_curr].camera->ctrl_handler, &ctrl)) {
6201 dev_warn(isp->dev, "failed to g_ctrl for f-number\n");
6202 return -EINVAL;
6203 } else {
6204 config->f_number_curr = ctrl.value;
6205 }
6206
6207 ctrl.id = V4L2_CID_FNUMBER_RANGE;
6208 if (v4l2_g_ctrl
6209 (isp->inputs[asd->input_curr].camera->ctrl_handler, &ctrl)) {
6210 dev_warn(isp->dev, "failed to g_ctrl for f number range\n");
6211 return -EINVAL;
6212 } else {
6213 config->f_number_range = ctrl.value;
6214 }
6215
6216 return 0;
6217}
6218
6219int atomisp_offline_capture_configure(struct atomisp_sub_device *asd,
6220 struct atomisp_cont_capture_conf *cvf_config)
6221{
6222 struct v4l2_ctrl *c;
6223
6224
6225
6226
6227
6228 c = v4l2_ctrl_find(
6229 asd->isp->inputs[asd->input_curr].camera->ctrl_handler,
6230 V4L2_CID_START_ZSL_CAPTURE);
6231 if (c) {
6232 int ret;
6233
6234 dev_dbg(asd->isp->dev, "%s trigger ZSL capture request\n",
6235 __func__);
6236
6237 ret = v4l2_ctrl_s_ctrl(c, 1);
6238 if (ret)
6239 return ret;
6240
6241 return v4l2_ctrl_s_ctrl(c, 0);
6242 }
6243
6244 asd->params.offline_parm = *cvf_config;
6245
6246 if (asd->params.offline_parm.num_captures) {
6247 if (asd->streaming == ATOMISP_DEVICE_STREAMING_DISABLED) {
6248 unsigned int init_raw_num;
6249
6250 if (asd->enable_raw_buffer_lock->val) {
6251 init_raw_num =
6252 ATOMISP_CSS2_NUM_OFFLINE_INIT_CONTINUOUS_FRAMES_LOCK_EN;
6253 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO &&
6254 asd->params.video_dis_en)
6255 init_raw_num +=
6256 ATOMISP_CSS2_NUM_DVS_FRAME_DELAY;
6257 } else {
6258 init_raw_num =
6259 ATOMISP_CSS2_NUM_OFFLINE_INIT_CONTINUOUS_FRAMES;
6260 }
6261
6262
6263
6264 asd->continuous_raw_buffer_size->val =
6265 max_t(int,
6266 asd->continuous_raw_buffer_size->val,
6267 asd->params.offline_parm.
6268 num_captures + init_raw_num);
6269 asd->continuous_raw_buffer_size->val =
6270 min_t(int, ATOMISP_CONT_RAW_FRAMES,
6271 asd->continuous_raw_buffer_size->val);
6272 }
6273 asd->continuous_mode->val = true;
6274 } else {
6275 asd->continuous_mode->val = false;
6276 __enable_continuous_mode(asd, false);
6277 }
6278
6279 return 0;
6280}
6281
6282
6283
6284
6285int atomisp_s_ae_window(struct atomisp_sub_device *asd,
6286 struct atomisp_ae_window *arg)
6287{
6288 struct atomisp_device *isp = asd->isp;
6289
6290 struct v4l2_subdev_selection sel = { 0 };
6291
6292 sel.r.left = arg->x_left;
6293 sel.r.top = arg->y_top;
6294 sel.r.width = arg->x_right - arg->x_left + 1;
6295 sel.r.height = arg->y_bottom - arg->y_top + 1;
6296
6297 if (v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
6298 pad, set_selection, NULL, &sel)) {
6299 dev_err(isp->dev, "failed to call sensor set_selection.\n");
6300 return -EINVAL;
6301 }
6302
6303 return 0;
6304}
6305
6306int atomisp_flash_enable(struct atomisp_sub_device *asd, int num_frames)
6307{
6308 struct atomisp_device *isp = asd->isp;
6309
6310 if (num_frames < 0) {
6311 dev_dbg(isp->dev, "%s ERROR: num_frames: %d\n", __func__,
6312 num_frames);
6313 return -EINVAL;
6314 }
6315
6316 if (num_frames && asd->params.flash_state != ATOMISP_FLASH_IDLE) {
6317 dev_dbg(isp->dev, "%s flash busy: %d frames left: %d\n",
6318 __func__, asd->params.flash_state,
6319 asd->params.num_flash_frames);
6320 return -EBUSY;
6321 }
6322
6323 asd->params.num_flash_frames = num_frames;
6324 asd->params.flash_state = ATOMISP_FLASH_REQUESTED;
6325 return 0;
6326}
6327
6328int atomisp_source_pad_to_stream_id(struct atomisp_sub_device *asd,
6329 uint16_t source_pad)
6330{
6331 int stream_id;
6332 struct atomisp_device *isp = asd->isp;
6333
6334 if (isp->inputs[asd->input_curr].camera_caps->
6335 sensor[asd->sensor_curr].stream_num == 1)
6336 return ATOMISP_INPUT_STREAM_GENERAL;
6337
6338 switch (source_pad) {
6339 case ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE:
6340 stream_id = ATOMISP_INPUT_STREAM_CAPTURE;
6341 break;
6342 case ATOMISP_SUBDEV_PAD_SOURCE_VF:
6343 stream_id = ATOMISP_INPUT_STREAM_POSTVIEW;
6344 break;
6345 case ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW:
6346 stream_id = ATOMISP_INPUT_STREAM_PREVIEW;
6347 break;
6348 case ATOMISP_SUBDEV_PAD_SOURCE_VIDEO:
6349 stream_id = ATOMISP_INPUT_STREAM_VIDEO;
6350 break;
6351 default:
6352 stream_id = ATOMISP_INPUT_STREAM_GENERAL;
6353 }
6354
6355 return stream_id;
6356}
6357
6358bool atomisp_is_vf_pipe(struct atomisp_video_pipe *pipe)
6359{
6360 struct atomisp_sub_device *asd = pipe->asd;
6361
6362 if (pipe == &asd->video_out_vf)
6363 return true;
6364
6365 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO &&
6366 pipe == &asd->video_out_preview)
6367 return true;
6368
6369 return false;
6370}
6371
6372static int __checking_exp_id(struct atomisp_sub_device *asd, int exp_id)
6373{
6374 struct atomisp_device *isp = asd->isp;
6375
6376 if (!asd->enable_raw_buffer_lock->val) {
6377 dev_warn(isp->dev, "%s Raw Buffer Lock is disable.\n", __func__);
6378 return -EINVAL;
6379 }
6380 if (asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED) {
6381 dev_err(isp->dev, "%s streaming %d invalid exp_id %d.\n",
6382 __func__, exp_id, asd->streaming);
6383 return -EINVAL;
6384 }
6385 if ((exp_id > ATOMISP_MAX_EXP_ID) || (exp_id <= 0)) {
6386 dev_err(isp->dev, "%s exp_id %d invalid.\n", __func__, exp_id);
6387 return -EINVAL;
6388 }
6389 return 0;
6390}
6391
6392void atomisp_init_raw_buffer_bitmap(struct atomisp_sub_device *asd)
6393{
6394 unsigned long flags;
6395
6396 spin_lock_irqsave(&asd->raw_buffer_bitmap_lock, flags);
6397 memset(asd->raw_buffer_bitmap, 0, sizeof(asd->raw_buffer_bitmap));
6398 asd->raw_buffer_locked_count = 0;
6399 spin_unlock_irqrestore(&asd->raw_buffer_bitmap_lock, flags);
6400}
6401
6402int atomisp_set_raw_buffer_bitmap(struct atomisp_sub_device *asd, int exp_id)
6403{
6404 int *bitmap, bit;
6405 unsigned long flags;
6406
6407 if (__checking_exp_id(asd, exp_id))
6408 return -EINVAL;
6409
6410 bitmap = asd->raw_buffer_bitmap + exp_id / 32;
6411 bit = exp_id % 32;
6412 spin_lock_irqsave(&asd->raw_buffer_bitmap_lock, flags);
6413 (*bitmap) |= (1 << bit);
6414 asd->raw_buffer_locked_count++;
6415 spin_unlock_irqrestore(&asd->raw_buffer_bitmap_lock, flags);
6416
6417 dev_dbg(asd->isp->dev, "%s: exp_id %d, raw_buffer_locked_count %d\n",
6418 __func__, exp_id, asd->raw_buffer_locked_count);
6419
6420
6421 exp_id += 2;
6422 if (exp_id > ATOMISP_MAX_EXP_ID)
6423 exp_id -= ATOMISP_MAX_EXP_ID;
6424 bitmap = asd->raw_buffer_bitmap + exp_id / 32;
6425 bit = exp_id % 32;
6426 if ((*bitmap) & (1 << bit)) {
6427 int ret;
6428
6429
6430 ret = atomisp_css_exp_id_unlock(asd, exp_id);
6431 if (ret) {
6432 dev_err(asd->isp->dev,
6433 "%s exp_id is wrapping back to %d but force unlock failed,, err %d.\n",
6434 __func__, exp_id, ret);
6435 return ret;
6436 }
6437
6438 spin_lock_irqsave(&asd->raw_buffer_bitmap_lock, flags);
6439 (*bitmap) &= ~(1 << bit);
6440 asd->raw_buffer_locked_count--;
6441 spin_unlock_irqrestore(&asd->raw_buffer_bitmap_lock, flags);
6442 dev_warn(asd->isp->dev,
6443 "%s exp_id is wrapping back to %d but it is still locked so force unlock it, raw_buffer_locked_count %d\n",
6444 __func__, exp_id, asd->raw_buffer_locked_count);
6445 }
6446 return 0;
6447}
6448
6449static int __is_raw_buffer_locked(struct atomisp_sub_device *asd, int exp_id)
6450{
6451 int *bitmap, bit;
6452 unsigned long flags;
6453 int ret;
6454
6455 if (__checking_exp_id(asd, exp_id))
6456 return -EINVAL;
6457
6458 bitmap = asd->raw_buffer_bitmap + exp_id / 32;
6459 bit = exp_id % 32;
6460 spin_lock_irqsave(&asd->raw_buffer_bitmap_lock, flags);
6461 ret = ((*bitmap) & (1 << bit));
6462 spin_unlock_irqrestore(&asd->raw_buffer_bitmap_lock, flags);
6463 return !ret;
6464}
6465
6466static int __clear_raw_buffer_bitmap(struct atomisp_sub_device *asd, int exp_id)
6467{
6468 int *bitmap, bit;
6469 unsigned long flags;
6470
6471 if (__is_raw_buffer_locked(asd, exp_id))
6472 return -EINVAL;
6473
6474 bitmap = asd->raw_buffer_bitmap + exp_id / 32;
6475 bit = exp_id % 32;
6476 spin_lock_irqsave(&asd->raw_buffer_bitmap_lock, flags);
6477 (*bitmap) &= ~(1 << bit);
6478 asd->raw_buffer_locked_count--;
6479 spin_unlock_irqrestore(&asd->raw_buffer_bitmap_lock, flags);
6480
6481 dev_dbg(asd->isp->dev, "%s: exp_id %d, raw_buffer_locked_count %d\n",
6482 __func__, exp_id, asd->raw_buffer_locked_count);
6483 return 0;
6484}
6485
6486int atomisp_exp_id_capture(struct atomisp_sub_device *asd, int *exp_id)
6487{
6488 struct atomisp_device *isp = asd->isp;
6489 int value = *exp_id;
6490 int ret;
6491
6492 ret = __is_raw_buffer_locked(asd, value);
6493 if (ret) {
6494 dev_err(isp->dev, "%s exp_id %d invalid %d.\n", __func__, value, ret);
6495 return -EINVAL;
6496 }
6497
6498 dev_dbg(isp->dev, "%s exp_id %d\n", __func__, value);
6499 ret = atomisp_css_exp_id_capture(asd, value);
6500 if (ret) {
6501 dev_err(isp->dev, "%s exp_id %d failed.\n", __func__, value);
6502 return -EIO;
6503 }
6504 return 0;
6505}
6506
6507int atomisp_exp_id_unlock(struct atomisp_sub_device *asd, int *exp_id)
6508{
6509 struct atomisp_device *isp = asd->isp;
6510 int value = *exp_id;
6511 int ret;
6512
6513 ret = __clear_raw_buffer_bitmap(asd, value);
6514 if (ret) {
6515 dev_err(isp->dev, "%s exp_id %d invalid %d.\n", __func__, value, ret);
6516 return -EINVAL;
6517 }
6518
6519 dev_dbg(isp->dev, "%s exp_id %d\n", __func__, value);
6520 ret = atomisp_css_exp_id_unlock(asd, value);
6521 if (ret)
6522 dev_err(isp->dev, "%s exp_id %d failed, err %d.\n",
6523 __func__, value, ret);
6524
6525 return ret;
6526}
6527
6528int atomisp_enable_dz_capt_pipe(struct atomisp_sub_device *asd,
6529 unsigned int *enable)
6530{
6531 bool value;
6532
6533 if (!enable)
6534 return -EINVAL;
6535
6536 value = *enable > 0;
6537
6538 atomisp_en_dz_capt_pipe(asd, value);
6539
6540 return 0;
6541}
6542
6543int atomisp_inject_a_fake_event(struct atomisp_sub_device *asd, int *event)
6544{
6545 if (!event || asd->streaming != ATOMISP_DEVICE_STREAMING_ENABLED)
6546 return -EINVAL;
6547
6548 dev_dbg(asd->isp->dev, "%s: trying to inject a fake event 0x%x\n",
6549 __func__, *event);
6550
6551 switch (*event) {
6552 case V4L2_EVENT_FRAME_SYNC:
6553 atomisp_sof_event(asd);
6554 break;
6555 case V4L2_EVENT_FRAME_END:
6556 atomisp_eof_event(asd, 0);
6557 break;
6558 case V4L2_EVENT_ATOMISP_3A_STATS_READY:
6559 atomisp_3a_stats_ready_event(asd, 0);
6560 break;
6561 case V4L2_EVENT_ATOMISP_METADATA_READY:
6562 atomisp_metadata_ready_event(asd, 0);
6563 break;
6564 default:
6565 return -EINVAL;
6566 }
6567
6568 return 0;
6569}
6570
6571static int atomisp_get_pipe_id(struct atomisp_video_pipe *pipe)
6572{
6573 struct atomisp_sub_device *asd = pipe->asd;
6574
6575 if (ATOMISP_USE_YUVPP(asd)) {
6576 return IA_CSS_PIPE_ID_YUVPP;
6577 } else if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) {
6578 return IA_CSS_PIPE_ID_VIDEO;
6579 } else if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT) {
6580 return IA_CSS_PIPE_ID_CAPTURE;
6581 } else if (pipe == &asd->video_out_video_capture) {
6582 return IA_CSS_PIPE_ID_VIDEO;
6583 } else if (pipe == &asd->video_out_vf) {
6584 return IA_CSS_PIPE_ID_CAPTURE;
6585 } else if (pipe == &asd->video_out_preview) {
6586 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
6587 return IA_CSS_PIPE_ID_VIDEO;
6588 else
6589 return IA_CSS_PIPE_ID_PREVIEW;
6590 } else if (pipe == &asd->video_out_capture) {
6591 if (asd->copy_mode)
6592 return IA_CSS_PIPE_ID_COPY;
6593 else
6594 return IA_CSS_PIPE_ID_CAPTURE;
6595 }
6596
6597
6598 dev_warn(asd->isp->dev, "%s failed to find proper pipe\n",
6599 __func__);
6600 return IA_CSS_PIPE_ID_CAPTURE;
6601}
6602
6603int atomisp_get_invalid_frame_num(struct video_device *vdev,
6604 int *invalid_frame_num)
6605{
6606 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
6607 struct atomisp_sub_device *asd = pipe->asd;
6608 enum ia_css_pipe_id pipe_id;
6609 struct ia_css_pipe_info p_info;
6610 int ret;
6611
6612 if (asd->isp->inputs[asd->input_curr].camera_caps->
6613 sensor[asd->sensor_curr].stream_num > 1) {
6614
6615 *invalid_frame_num = 0;
6616 return 0;
6617 }
6618
6619 pipe_id = atomisp_get_pipe_id(pipe);
6620 if (!asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL].pipes[pipe_id]) {
6621 dev_warn(asd->isp->dev,
6622 "%s pipe %d has not been created yet, do SET_FMT first!\n",
6623 __func__, pipe_id);
6624 return -EINVAL;
6625 }
6626
6627 ret = ia_css_pipe_get_info(
6628 asd->stream_env[ATOMISP_INPUT_STREAM_GENERAL]
6629 .pipes[pipe_id], &p_info);
6630 if (!ret) {
6631 *invalid_frame_num = p_info.num_invalid_frames;
6632 return 0;
6633 } else {
6634 dev_warn(asd->isp->dev, "%s get pipe infor failed %d\n",
6635 __func__, ret);
6636 return -EINVAL;
6637 }
6638}
6639
