?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
blk-mq: always free hctx after request queue is freed
[linux/fpc-iii.git] / drivers / media / platform / qcom / camss / camss-vfe.c
bloba8c542fa647db185fcce25807cac4fe931a5c412
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * camss-vfe.c
4 *
5 * Qualcomm MSM Camera Subsystem - VFE (Video Front End) Module
6 *
7 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
8 * Copyright (C) 2015-2018 Linaro Ltd.
9 */
10 #include <linux/clk.h>
11 #include <linux/completion.h>
12 #include <linux/interrupt.h>
13 #include <linux/iommu.h>
14 #include <linux/mutex.h>
15 #include <linux/of.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/spinlock_types.h>
19 #include <linux/spinlock.h>
20 #include <media/media-entity.h>
21 #include <media/v4l2-device.h>
22 #include <media/v4l2-subdev.h>
23
24 #include "camss-vfe.h"
25 #include "camss.h"
26
27 #define MSM_VFE_NAME "msm_vfe"
28
29 #define vfe_line_array(ptr_line) \
30 ((const struct vfe_line (*)[]) &(ptr_line[-(ptr_line->id)]))
31
32 #define to_vfe(ptr_line) \
33 container_of(vfe_line_array(ptr_line), struct vfe_device, line)
34
35 /* VFE reset timeout */
36 #define VFE_RESET_TIMEOUT_MS 50
37 /* VFE halt timeout */
38 #define VFE_HALT_TIMEOUT_MS 100
39 /* Max number of frame drop updates per frame */
40 #define VFE_FRAME_DROP_UPDATES 2
41 /* Frame drop value. VAL + UPDATES - 1 should not exceed 31 */
42 #define VFE_FRAME_DROP_VAL 30
43
44 #define VFE_NEXT_SOF_MS 500
45
46 #define SCALER_RATIO_MAX 16
47
48 struct vfe_format {
49 u32 code;
50 u8 bpp;
51 };
52
53 static const struct vfe_format formats_rdi_8x16[] = {
54 { MEDIA_BUS_FMT_UYVY8_2X8, 8 },
55 { MEDIA_BUS_FMT_VYUY8_2X8, 8 },
56 { MEDIA_BUS_FMT_YUYV8_2X8, 8 },
57 { MEDIA_BUS_FMT_YVYU8_2X8, 8 },
58 { MEDIA_BUS_FMT_SBGGR8_1X8, 8 },
59 { MEDIA_BUS_FMT_SGBRG8_1X8, 8 },
60 { MEDIA_BUS_FMT_SGRBG8_1X8, 8 },
61 { MEDIA_BUS_FMT_SRGGB8_1X8, 8 },
62 { MEDIA_BUS_FMT_SBGGR10_1X10, 10 },
63 { MEDIA_BUS_FMT_SGBRG10_1X10, 10 },
64 { MEDIA_BUS_FMT_SGRBG10_1X10, 10 },
65 { MEDIA_BUS_FMT_SRGGB10_1X10, 10 },
66 { MEDIA_BUS_FMT_SBGGR12_1X12, 12 },
67 { MEDIA_BUS_FMT_SGBRG12_1X12, 12 },
68 { MEDIA_BUS_FMT_SGRBG12_1X12, 12 },
69 { MEDIA_BUS_FMT_SRGGB12_1X12, 12 },
70 { MEDIA_BUS_FMT_Y10_1X10, 10 },
71 };
72
73 static const struct vfe_format formats_pix_8x16[] = {
74 { MEDIA_BUS_FMT_UYVY8_2X8, 8 },
75 { MEDIA_BUS_FMT_VYUY8_2X8, 8 },
76 { MEDIA_BUS_FMT_YUYV8_2X8, 8 },
77 { MEDIA_BUS_FMT_YVYU8_2X8, 8 },
78 };
79
80 static const struct vfe_format formats_rdi_8x96[] = {
81 { MEDIA_BUS_FMT_UYVY8_2X8, 8 },
82 { MEDIA_BUS_FMT_VYUY8_2X8, 8 },
83 { MEDIA_BUS_FMT_YUYV8_2X8, 8 },
84 { MEDIA_BUS_FMT_YVYU8_2X8, 8 },
85 { MEDIA_BUS_FMT_SBGGR8_1X8, 8 },
86 { MEDIA_BUS_FMT_SGBRG8_1X8, 8 },
87 { MEDIA_BUS_FMT_SGRBG8_1X8, 8 },
88 { MEDIA_BUS_FMT_SRGGB8_1X8, 8 },
89 { MEDIA_BUS_FMT_SBGGR10_1X10, 10 },
90 { MEDIA_BUS_FMT_SGBRG10_1X10, 10 },
91 { MEDIA_BUS_FMT_SGRBG10_1X10, 10 },
92 { MEDIA_BUS_FMT_SRGGB10_1X10, 10 },
93 { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, 16 },
94 { MEDIA_BUS_FMT_SBGGR12_1X12, 12 },
95 { MEDIA_BUS_FMT_SGBRG12_1X12, 12 },
96 { MEDIA_BUS_FMT_SGRBG12_1X12, 12 },
97 { MEDIA_BUS_FMT_SRGGB12_1X12, 12 },
98 { MEDIA_BUS_FMT_SBGGR14_1X14, 14 },
99 { MEDIA_BUS_FMT_SGBRG14_1X14, 14 },
100 { MEDIA_BUS_FMT_SGRBG14_1X14, 14 },
101 { MEDIA_BUS_FMT_SRGGB14_1X14, 14 },
102 { MEDIA_BUS_FMT_Y10_1X10, 10 },
103 { MEDIA_BUS_FMT_Y10_2X8_PADHI_LE, 16 },
104 };
105
106 static const struct vfe_format formats_pix_8x96[] = {
107 { MEDIA_BUS_FMT_UYVY8_2X8, 8 },
108 { MEDIA_BUS_FMT_VYUY8_2X8, 8 },
109 { MEDIA_BUS_FMT_YUYV8_2X8, 8 },
110 { MEDIA_BUS_FMT_YVYU8_2X8, 8 },
111 };
112
113 /*
114 * vfe_get_bpp - map media bus format to bits per pixel
115 * @formats: supported media bus formats array
116 * @nformats: size of @formats array
117 * @code: media bus format code
118 *
119 * Return number of bits per pixel
120 */
121 static u8 vfe_get_bpp(const struct vfe_format *formats,
122 unsigned int nformats, u32 code)
123 {
124 unsigned int i;
125
126 for (i = 0; i < nformats; i++)
127 if (code == formats[i].code)
128 return formats[i].bpp;
129
130 WARN(1, "Unknown format\n");
131
132 return formats[0].bpp;
133 }
134
135 static u32 vfe_find_code(u32 *code, unsigned int n_code,
136 unsigned int index, u32 req_code)
137 {
138 int i;
139
140 if (!req_code && (index >= n_code))
141 return 0;
142
143 for (i = 0; i < n_code; i++)
144 if (req_code) {
145 if (req_code == code[i])
146 return req_code;
147 } else {
148 if (i == index)
149 return code[i];
150 }
151
152 return code[0];
153 }
154
155 static u32 vfe_src_pad_code(struct vfe_line *line, u32 sink_code,
156 unsigned int index, u32 src_req_code)
157 {
158 struct vfe_device *vfe = to_vfe(line);
159
160 if (vfe->camss->version == CAMSS_8x16)
161 switch (sink_code) {
162 case MEDIA_BUS_FMT_YUYV8_2X8:
163 {
164 u32 src_code[] = {
165 MEDIA_BUS_FMT_YUYV8_2X8,
166 MEDIA_BUS_FMT_YUYV8_1_5X8,
167 };
168
169 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
170 index, src_req_code);
171 }
172 case MEDIA_BUS_FMT_YVYU8_2X8:
173 {
174 u32 src_code[] = {
175 MEDIA_BUS_FMT_YVYU8_2X8,
176 MEDIA_BUS_FMT_YVYU8_1_5X8,
177 };
178
179 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
180 index, src_req_code);
181 }
182 case MEDIA_BUS_FMT_UYVY8_2X8:
183 {
184 u32 src_code[] = {
185 MEDIA_BUS_FMT_UYVY8_2X8,
186 MEDIA_BUS_FMT_UYVY8_1_5X8,
187 };
188
189 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
190 index, src_req_code);
191 }
192 case MEDIA_BUS_FMT_VYUY8_2X8:
193 {
194 u32 src_code[] = {
195 MEDIA_BUS_FMT_VYUY8_2X8,
196 MEDIA_BUS_FMT_VYUY8_1_5X8,
197 };
198
199 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
200 index, src_req_code);
201 }
202 default:
203 if (index > 0)
204 return 0;
205
206 return sink_code;
207 }
208 else if (vfe->camss->version == CAMSS_8x96)
209 switch (sink_code) {
210 case MEDIA_BUS_FMT_YUYV8_2X8:
211 {
212 u32 src_code[] = {
213 MEDIA_BUS_FMT_YUYV8_2X8,
214 MEDIA_BUS_FMT_YVYU8_2X8,
215 MEDIA_BUS_FMT_UYVY8_2X8,
216 MEDIA_BUS_FMT_VYUY8_2X8,
217 MEDIA_BUS_FMT_YUYV8_1_5X8,
218 };
219
220 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
221 index, src_req_code);
222 }
223 case MEDIA_BUS_FMT_YVYU8_2X8:
224 {
225 u32 src_code[] = {
226 MEDIA_BUS_FMT_YVYU8_2X8,
227 MEDIA_BUS_FMT_YUYV8_2X8,
228 MEDIA_BUS_FMT_UYVY8_2X8,
229 MEDIA_BUS_FMT_VYUY8_2X8,
230 MEDIA_BUS_FMT_YVYU8_1_5X8,
231 };
232
233 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
234 index, src_req_code);
235 }
236 case MEDIA_BUS_FMT_UYVY8_2X8:
237 {
238 u32 src_code[] = {
239 MEDIA_BUS_FMT_UYVY8_2X8,
240 MEDIA_BUS_FMT_YUYV8_2X8,
241 MEDIA_BUS_FMT_YVYU8_2X8,
242 MEDIA_BUS_FMT_VYUY8_2X8,
243 MEDIA_BUS_FMT_UYVY8_1_5X8,
244 };
245
246 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
247 index, src_req_code);
248 }
249 case MEDIA_BUS_FMT_VYUY8_2X8:
250 {
251 u32 src_code[] = {
252 MEDIA_BUS_FMT_VYUY8_2X8,
253 MEDIA_BUS_FMT_YUYV8_2X8,
254 MEDIA_BUS_FMT_YVYU8_2X8,
255 MEDIA_BUS_FMT_UYVY8_2X8,
256 MEDIA_BUS_FMT_VYUY8_1_5X8,
257 };
258
259 return vfe_find_code(src_code, ARRAY_SIZE(src_code),
260 index, src_req_code);
261 }
262 default:
263 if (index > 0)
264 return 0;
265
266 return sink_code;
267 }
268 else
269 return 0;
270 }
271
272 /*
273 * vfe_reset - Trigger reset on VFE module and wait to complete
274 * @vfe: VFE device
275 *
276 * Return 0 on success or a negative error code otherwise
277 */
278 static int vfe_reset(struct vfe_device *vfe)
279 {
280 unsigned long time;
281
282 reinit_completion(&vfe->reset_complete);
283
284 vfe->ops->global_reset(vfe);
285
286 time = wait_for_completion_timeout(&vfe->reset_complete,
287 msecs_to_jiffies(VFE_RESET_TIMEOUT_MS));
288 if (!time) {
289 dev_err(vfe->camss->dev, "VFE reset timeout\n");
290 return -EIO;
291 }
292
293 return 0;
294 }
295
296 /*
297 * vfe_halt - Trigger halt on VFE module and wait to complete
298 * @vfe: VFE device
299 *
300 * Return 0 on success or a negative error code otherwise
301 */
302 static int vfe_halt(struct vfe_device *vfe)
303 {
304 unsigned long time;
305
306 reinit_completion(&vfe->halt_complete);
307
308 vfe->ops->halt_request(vfe);
309
310 time = wait_for_completion_timeout(&vfe->halt_complete,
311 msecs_to_jiffies(VFE_HALT_TIMEOUT_MS));
312 if (!time) {
313 dev_err(vfe->camss->dev, "VFE halt timeout\n");
314 return -EIO;
315 }
316
317 return 0;
318 }
319
320 static void vfe_init_outputs(struct vfe_device *vfe)
321 {
322 int i;
323
324 for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
325 struct vfe_output *output = &vfe->line[i].output;
326
327 output->state = VFE_OUTPUT_OFF;
328 output->buf[0] = NULL;
329 output->buf[1] = NULL;
330 INIT_LIST_HEAD(&output->pending_bufs);
331 }
332 }
333
334 static void vfe_reset_output_maps(struct vfe_device *vfe)
335 {
336 int i;
337
338 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++)
339 vfe->wm_output_map[i] = VFE_LINE_NONE;
340 }
341
342 static void vfe_output_init_addrs(struct vfe_device *vfe,
343 struct vfe_output *output, u8 sync)
344 {
345 u32 ping_addr;
346 u32 pong_addr;
347 unsigned int i;
348
349 output->active_buf = 0;
350
351 for (i = 0; i < output->wm_num; i++) {
352 if (output->buf[0])
353 ping_addr = output->buf[0]->addr[i];
354 else
355 ping_addr = 0;
356
357 if (output->buf[1])
358 pong_addr = output->buf[1]->addr[i];
359 else
360 pong_addr = ping_addr;
361
362 vfe->ops->wm_set_ping_addr(vfe, output->wm_idx[i], ping_addr);
363 vfe->ops->wm_set_pong_addr(vfe, output->wm_idx[i], pong_addr);
364 if (sync)
365 vfe->ops->bus_reload_wm(vfe, output->wm_idx[i]);
366 }
367 }
368
369 static void vfe_output_update_ping_addr(struct vfe_device *vfe,
370 struct vfe_output *output, u8 sync)
371 {
372 u32 addr;
373 unsigned int i;
374
375 for (i = 0; i < output->wm_num; i++) {
376 if (output->buf[0])
377 addr = output->buf[0]->addr[i];
378 else
379 addr = 0;
380
381 vfe->ops->wm_set_ping_addr(vfe, output->wm_idx[i], addr);
382 if (sync)
383 vfe->ops->bus_reload_wm(vfe, output->wm_idx[i]);
384 }
385 }
386
387 static void vfe_output_update_pong_addr(struct vfe_device *vfe,
388 struct vfe_output *output, u8 sync)
389 {
390 u32 addr;
391 unsigned int i;
392
393 for (i = 0; i < output->wm_num; i++) {
394 if (output->buf[1])
395 addr = output->buf[1]->addr[i];
396 else
397 addr = 0;
398
399 vfe->ops->wm_set_pong_addr(vfe, output->wm_idx[i], addr);
400 if (sync)
401 vfe->ops->bus_reload_wm(vfe, output->wm_idx[i]);
402 }
403
404 }
405
406 static int vfe_reserve_wm(struct vfe_device *vfe, enum vfe_line_id line_id)
407 {
408 int ret = -EBUSY;
409 int i;
410
411 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++) {
412 if (vfe->wm_output_map[i] == VFE_LINE_NONE) {
413 vfe->wm_output_map[i] = line_id;
414 ret = i;
415 break;
416 }
417 }
418
419 return ret;
420 }
421
422 static int vfe_release_wm(struct vfe_device *vfe, u8 wm)
423 {
424 if (wm >= ARRAY_SIZE(vfe->wm_output_map))
425 return -EINVAL;
426
427 vfe->wm_output_map[wm] = VFE_LINE_NONE;
428
429 return 0;
430 }
431
432 static void vfe_output_frame_drop(struct vfe_device *vfe,
433 struct vfe_output *output,
434 u32 drop_pattern)
435 {
436 u8 drop_period;
437 unsigned int i;
438
439 /* We need to toggle update period to be valid on next frame */
440 output->drop_update_idx++;
441 output->drop_update_idx %= VFE_FRAME_DROP_UPDATES;
442 drop_period = VFE_FRAME_DROP_VAL + output->drop_update_idx;
443
444 for (i = 0; i < output->wm_num; i++) {
445 vfe->ops->wm_set_framedrop_period(vfe, output->wm_idx[i],
446 drop_period);
447 vfe->ops->wm_set_framedrop_pattern(vfe, output->wm_idx[i],
448 drop_pattern);
449 }
450 vfe->ops->reg_update(vfe,
451 container_of(output, struct vfe_line, output)->id);
452 }
453
454 static struct camss_buffer *vfe_buf_get_pending(struct vfe_output *output)
455 {
456 struct camss_buffer *buffer = NULL;
457
458 if (!list_empty(&output->pending_bufs)) {
459 buffer = list_first_entry(&output->pending_bufs,
460 struct camss_buffer,
461 queue);
462 list_del(&buffer->queue);
463 }
464
465 return buffer;
466 }
467
468 /*
469 * vfe_buf_add_pending - Add output buffer to list of pending
470 * @output: VFE output
471 * @buffer: Video buffer
472 */
473 static void vfe_buf_add_pending(struct vfe_output *output,
474 struct camss_buffer *buffer)
475 {
476 INIT_LIST_HEAD(&buffer->queue);
477 list_add_tail(&buffer->queue, &output->pending_bufs);
478 }
479
480 /*
481 * vfe_buf_flush_pending - Flush all pending buffers.
482 * @output: VFE output
483 * @state: vb2 buffer state
484 */
485 static void vfe_buf_flush_pending(struct vfe_output *output,
486 enum vb2_buffer_state state)
487 {
488 struct camss_buffer *buf;
489 struct camss_buffer *t;
490
491 list_for_each_entry_safe(buf, t, &output->pending_bufs, queue) {
492 vb2_buffer_done(&buf->vb.vb2_buf, state);
493 list_del(&buf->queue);
494 }
495 }
496
497 static void vfe_buf_update_wm_on_next(struct vfe_device *vfe,
498 struct vfe_output *output)
499 {
500 switch (output->state) {
501 case VFE_OUTPUT_CONTINUOUS:
502 vfe_output_frame_drop(vfe, output, 3);
503 break;
504 case VFE_OUTPUT_SINGLE:
505 default:
506 dev_err_ratelimited(vfe->camss->dev,
507 "Next buf in wrong state! %d\n",
508 output->state);
509 break;
510 }
511 }
512
513 static void vfe_buf_update_wm_on_last(struct vfe_device *vfe,
514 struct vfe_output *output)
515 {
516 switch (output->state) {
517 case VFE_OUTPUT_CONTINUOUS:
518 output->state = VFE_OUTPUT_SINGLE;
519 vfe_output_frame_drop(vfe, output, 1);
520 break;
521 case VFE_OUTPUT_SINGLE:
522 output->state = VFE_OUTPUT_STOPPING;
523 vfe_output_frame_drop(vfe, output, 0);
524 break;
525 default:
526 dev_err_ratelimited(vfe->camss->dev,
527 "Last buff in wrong state! %d\n",
528 output->state);
529 break;
530 }
531 }
532
533 static void vfe_buf_update_wm_on_new(struct vfe_device *vfe,
534 struct vfe_output *output,
535 struct camss_buffer *new_buf)
536 {
537 int inactive_idx;
538
539 switch (output->state) {
540 case VFE_OUTPUT_SINGLE:
541 inactive_idx = !output->active_buf;
542
543 if (!output->buf[inactive_idx]) {
544 output->buf[inactive_idx] = new_buf;
545
546 if (inactive_idx)
547 vfe_output_update_pong_addr(vfe, output, 0);
548 else
549 vfe_output_update_ping_addr(vfe, output, 0);
550
551 vfe_output_frame_drop(vfe, output, 3);
552 output->state = VFE_OUTPUT_CONTINUOUS;
553 } else {
554 vfe_buf_add_pending(output, new_buf);
555 dev_err_ratelimited(vfe->camss->dev,
556 "Inactive buffer is busy\n");
557 }
558 break;
559
560 case VFE_OUTPUT_IDLE:
561 if (!output->buf[0]) {
562 output->buf[0] = new_buf;
563
564 vfe_output_init_addrs(vfe, output, 1);
565
566 vfe_output_frame_drop(vfe, output, 1);
567 output->state = VFE_OUTPUT_SINGLE;
568 } else {
569 vfe_buf_add_pending(output, new_buf);
570 dev_err_ratelimited(vfe->camss->dev,
571 "Output idle with buffer set!\n");
572 }
573 break;
574
575 case VFE_OUTPUT_CONTINUOUS:
576 default:
577 vfe_buf_add_pending(output, new_buf);
578 break;
579 }
580 }
581
582 static int vfe_get_output(struct vfe_line *line)
583 {
584 struct vfe_device *vfe = to_vfe(line);
585 struct vfe_output *output;
586 struct v4l2_format *f = &line->video_out.active_fmt;
587 unsigned long flags;
588 int i;
589 int wm_idx;
590
591 spin_lock_irqsave(&vfe->output_lock, flags);
592
593 output = &line->output;
594 if (output->state != VFE_OUTPUT_OFF) {
595 dev_err(vfe->camss->dev, "Output is running\n");
596 goto error;
597 }
598 output->state = VFE_OUTPUT_RESERVED;
599
600 output->active_buf = 0;
601
602 switch (f->fmt.pix_mp.pixelformat) {
603 case V4L2_PIX_FMT_NV12:
604 case V4L2_PIX_FMT_NV21:
605 case V4L2_PIX_FMT_NV16:
606 case V4L2_PIX_FMT_NV61:
607 output->wm_num = 2;
608 break;
609 default:
610 output->wm_num = 1;
611 break;
612 }
613
614 for (i = 0; i < output->wm_num; i++) {
615 wm_idx = vfe_reserve_wm(vfe, line->id);
616 if (wm_idx < 0) {
617 dev_err(vfe->camss->dev, "Can not reserve wm\n");
618 goto error_get_wm;
619 }
620 output->wm_idx[i] = wm_idx;
621 }
622
623 output->drop_update_idx = 0;
624
625 spin_unlock_irqrestore(&vfe->output_lock, flags);
626
627 return 0;
628
629 error_get_wm:
630 for (i--; i >= 0; i--)
631 vfe_release_wm(vfe, output->wm_idx[i]);
632 output->state = VFE_OUTPUT_OFF;
633 error:
634 spin_unlock_irqrestore(&vfe->output_lock, flags);
635
636 return -EINVAL;
637 }
638
639 static int vfe_put_output(struct vfe_line *line)
640 {
641 struct vfe_device *vfe = to_vfe(line);
642 struct vfe_output *output = &line->output;
643 unsigned long flags;
644 unsigned int i;
645
646 spin_lock_irqsave(&vfe->output_lock, flags);
647
648 for (i = 0; i < output->wm_num; i++)
649 vfe_release_wm(vfe, output->wm_idx[i]);
650
651 output->state = VFE_OUTPUT_OFF;
652
653 spin_unlock_irqrestore(&vfe->output_lock, flags);
654 return 0;
655 }
656
657 static int vfe_enable_output(struct vfe_line *line)
658 {
659 struct vfe_device *vfe = to_vfe(line);
660 struct vfe_output *output = &line->output;
661 const struct vfe_hw_ops *ops = vfe->ops;
662 struct media_entity *sensor;
663 unsigned long flags;
664 unsigned int frame_skip = 0;
665 unsigned int i;
666 u16 ub_size;
667
668 ub_size = ops->get_ub_size(vfe->id);
669 if (!ub_size)
670 return -EINVAL;
671
672 sensor = camss_find_sensor(&line->subdev.entity);
673 if (sensor) {
674 struct v4l2_subdev *subdev =
675 media_entity_to_v4l2_subdev(sensor);
676
677 v4l2_subdev_call(subdev, sensor, g_skip_frames, &frame_skip);
678 /* Max frame skip is 29 frames */
679 if (frame_skip > VFE_FRAME_DROP_VAL - 1)
680 frame_skip = VFE_FRAME_DROP_VAL - 1;
681 }
682
683 spin_lock_irqsave(&vfe->output_lock, flags);
684
685 ops->reg_update_clear(vfe, line->id);
686
687 if (output->state != VFE_OUTPUT_RESERVED) {
688 dev_err(vfe->camss->dev, "Output is not in reserved state %d\n",
689 output->state);
690 spin_unlock_irqrestore(&vfe->output_lock, flags);
691 return -EINVAL;
692 }
693 output->state = VFE_OUTPUT_IDLE;
694
695 output->buf[0] = vfe_buf_get_pending(output);
696 output->buf[1] = vfe_buf_get_pending(output);
697
698 if (!output->buf[0] && output->buf[1]) {
699 output->buf[0] = output->buf[1];
700 output->buf[1] = NULL;
701 }
702
703 if (output->buf[0])
704 output->state = VFE_OUTPUT_SINGLE;
705
706 if (output->buf[1])
707 output->state = VFE_OUTPUT_CONTINUOUS;
708
709 switch (output->state) {
710 case VFE_OUTPUT_SINGLE:
711 vfe_output_frame_drop(vfe, output, 1 << frame_skip);
712 break;
713 case VFE_OUTPUT_CONTINUOUS:
714 vfe_output_frame_drop(vfe, output, 3 << frame_skip);
715 break;
716 default:
717 vfe_output_frame_drop(vfe, output, 0);
718 break;
719 }
720
721 output->sequence = 0;
722 output->wait_sof = 0;
723 output->wait_reg_update = 0;
724 reinit_completion(&output->sof);
725 reinit_completion(&output->reg_update);
726
727 vfe_output_init_addrs(vfe, output, 0);
728
729 if (line->id != VFE_LINE_PIX) {
730 ops->set_cgc_override(vfe, output->wm_idx[0], 1);
731 ops->enable_irq_wm_line(vfe, output->wm_idx[0], line->id, 1);
732 ops->bus_connect_wm_to_rdi(vfe, output->wm_idx[0], line->id);
733 ops->wm_set_subsample(vfe, output->wm_idx[0]);
734 ops->set_rdi_cid(vfe, line->id, 0);
735 ops->wm_set_ub_cfg(vfe, output->wm_idx[0],
736 (ub_size + 1) * output->wm_idx[0], ub_size);
737 ops->wm_frame_based(vfe, output->wm_idx[0], 1);
738 ops->wm_enable(vfe, output->wm_idx[0], 1);
739 ops->bus_reload_wm(vfe, output->wm_idx[0]);
740 } else {
741 ub_size /= output->wm_num;
742 for (i = 0; i < output->wm_num; i++) {
743 ops->set_cgc_override(vfe, output->wm_idx[i], 1);
744 ops->wm_set_subsample(vfe, output->wm_idx[i]);
745 ops->wm_set_ub_cfg(vfe, output->wm_idx[i],
746 (ub_size + 1) * output->wm_idx[i],
747 ub_size);
748 ops->wm_line_based(vfe, output->wm_idx[i],
749 &line->video_out.active_fmt.fmt.pix_mp,
750 i, 1);
751 ops->wm_enable(vfe, output->wm_idx[i], 1);
752 ops->bus_reload_wm(vfe, output->wm_idx[i]);
753 }
754 ops->enable_irq_pix_line(vfe, 0, line->id, 1);
755 ops->set_module_cfg(vfe, 1);
756 ops->set_camif_cfg(vfe, line);
757 ops->set_realign_cfg(vfe, line, 1);
758 ops->set_xbar_cfg(vfe, output, 1);
759 ops->set_demux_cfg(vfe, line);
760 ops->set_scale_cfg(vfe, line);
761 ops->set_crop_cfg(vfe, line);
762 ops->set_clamp_cfg(vfe);
763 ops->set_camif_cmd(vfe, 1);
764 }
765
766 ops->reg_update(vfe, line->id);
767
768 spin_unlock_irqrestore(&vfe->output_lock, flags);
769
770 return 0;
771 }
772
773 static int vfe_disable_output(struct vfe_line *line)
774 {
775 struct vfe_device *vfe = to_vfe(line);
776 struct vfe_output *output = &line->output;
777 const struct vfe_hw_ops *ops = vfe->ops;
778 unsigned long flags;
779 unsigned long time;
780 unsigned int i;
781
782 spin_lock_irqsave(&vfe->output_lock, flags);
783
784 output->wait_sof = 1;
785 spin_unlock_irqrestore(&vfe->output_lock, flags);
786
787 time = wait_for_completion_timeout(&output->sof,
788 msecs_to_jiffies(VFE_NEXT_SOF_MS));
789 if (!time)
790 dev_err(vfe->camss->dev, "VFE sof timeout\n");
791
792 spin_lock_irqsave(&vfe->output_lock, flags);
793 for (i = 0; i < output->wm_num; i++)
794 ops->wm_enable(vfe, output->wm_idx[i], 0);
795
796 ops->reg_update(vfe, line->id);
797 output->wait_reg_update = 1;
798 spin_unlock_irqrestore(&vfe->output_lock, flags);
799
800 time = wait_for_completion_timeout(&output->reg_update,
801 msecs_to_jiffies(VFE_NEXT_SOF_MS));
802 if (!time)
803 dev_err(vfe->camss->dev, "VFE reg update timeout\n");
804
805 spin_lock_irqsave(&vfe->output_lock, flags);
806
807 if (line->id != VFE_LINE_PIX) {
808 ops->wm_frame_based(vfe, output->wm_idx[0], 0);
809 ops->bus_disconnect_wm_from_rdi(vfe, output->wm_idx[0],
810 line->id);
811 ops->enable_irq_wm_line(vfe, output->wm_idx[0], line->id, 0);
812 ops->set_cgc_override(vfe, output->wm_idx[0], 0);
813 spin_unlock_irqrestore(&vfe->output_lock, flags);
814 } else {
815 for (i = 0; i < output->wm_num; i++) {
816 ops->wm_line_based(vfe, output->wm_idx[i], NULL, i, 0);
817 ops->set_cgc_override(vfe, output->wm_idx[i], 0);
818 }
819
820 ops->enable_irq_pix_line(vfe, 0, line->id, 0);
821 ops->set_module_cfg(vfe, 0);
822 ops->set_realign_cfg(vfe, line, 0);
823 ops->set_xbar_cfg(vfe, output, 0);
824
825 ops->set_camif_cmd(vfe, 0);
826 spin_unlock_irqrestore(&vfe->output_lock, flags);
827
828 ops->camif_wait_for_stop(vfe, vfe->camss->dev);
829 }
830
831 return 0;
832 }
833
834 /*
835 * vfe_enable - Enable streaming on VFE line
836 * @line: VFE line
837 *
838 * Return 0 on success or a negative error code otherwise
839 */
840 static int vfe_enable(struct vfe_line *line)
841 {
842 struct vfe_device *vfe = to_vfe(line);
843 int ret;
844
845 mutex_lock(&vfe->stream_lock);
846
847 if (!vfe->stream_count) {
848 vfe->ops->enable_irq_common(vfe);
849
850 vfe->ops->bus_enable_wr_if(vfe, 1);
851
852 vfe->ops->set_qos(vfe);
853
854 vfe->ops->set_ds(vfe);
855 }
856
857 vfe->stream_count++;
858
859 mutex_unlock(&vfe->stream_lock);
860
861 ret = vfe_get_output(line);
862 if (ret < 0)
863 goto error_get_output;
864
865 ret = vfe_enable_output(line);
866 if (ret < 0)
867 goto error_enable_output;
868
869 vfe->was_streaming = 1;
870
871 return 0;
872
873
874 error_enable_output:
875 vfe_put_output(line);
876
877 error_get_output:
878 mutex_lock(&vfe->stream_lock);
879
880 if (vfe->stream_count == 1)
881 vfe->ops->bus_enable_wr_if(vfe, 0);
882
883 vfe->stream_count--;
884
885 mutex_unlock(&vfe->stream_lock);
886
887 return ret;
888 }
889
890 /*
891 * vfe_disable - Disable streaming on VFE line
892 * @line: VFE line
893 *
894 * Return 0 on success or a negative error code otherwise
895 */
896 static int vfe_disable(struct vfe_line *line)
897 {
898 struct vfe_device *vfe = to_vfe(line);
899
900 vfe_disable_output(line);
901
902 vfe_put_output(line);
903
904 mutex_lock(&vfe->stream_lock);
905
906 if (vfe->stream_count == 1)
907 vfe->ops->bus_enable_wr_if(vfe, 0);
908
909 vfe->stream_count--;
910
911 mutex_unlock(&vfe->stream_lock);
912
913 return 0;
914 }
915
916 /*
917 * vfe_isr_sof - Process start of frame interrupt
918 * @vfe: VFE Device
919 * @line_id: VFE line
920 */
921 static void vfe_isr_sof(struct vfe_device *vfe, enum vfe_line_id line_id)
922 {
923 struct vfe_output *output;
924 unsigned long flags;
925
926 spin_lock_irqsave(&vfe->output_lock, flags);
927 output = &vfe->line[line_id].output;
928 if (output->wait_sof) {
929 output->wait_sof = 0;
930 complete(&output->sof);
931 }
932 spin_unlock_irqrestore(&vfe->output_lock, flags);
933 }
934
935 /*
936 * vfe_isr_reg_update - Process reg update interrupt
937 * @vfe: VFE Device
938 * @line_id: VFE line
939 */
940 static void vfe_isr_reg_update(struct vfe_device *vfe, enum vfe_line_id line_id)
941 {
942 struct vfe_output *output;
943 unsigned long flags;
944
945 spin_lock_irqsave(&vfe->output_lock, flags);
946 vfe->ops->reg_update_clear(vfe, line_id);
947
948 output = &vfe->line[line_id].output;
949
950 if (output->wait_reg_update) {
951 output->wait_reg_update = 0;
952 complete(&output->reg_update);
953 spin_unlock_irqrestore(&vfe->output_lock, flags);
954 return;
955 }
956
957 if (output->state == VFE_OUTPUT_STOPPING) {
958 /* Release last buffer when hw is idle */
959 if (output->last_buffer) {
960 vb2_buffer_done(&output->last_buffer->vb.vb2_buf,
961 VB2_BUF_STATE_DONE);
962 output->last_buffer = NULL;
963 }
964 output->state = VFE_OUTPUT_IDLE;
965
966 /* Buffers received in stopping state are queued in */
967 /* dma pending queue, start next capture here */
968
969 output->buf[0] = vfe_buf_get_pending(output);
970 output->buf[1] = vfe_buf_get_pending(output);
971
972 if (!output->buf[0] && output->buf[1]) {
973 output->buf[0] = output->buf[1];
974 output->buf[1] = NULL;
975 }
976
977 if (output->buf[0])
978 output->state = VFE_OUTPUT_SINGLE;
979
980 if (output->buf[1])
981 output->state = VFE_OUTPUT_CONTINUOUS;
982
983 switch (output->state) {
984 case VFE_OUTPUT_SINGLE:
985 vfe_output_frame_drop(vfe, output, 2);
986 break;
987 case VFE_OUTPUT_CONTINUOUS:
988 vfe_output_frame_drop(vfe, output, 3);
989 break;
990 default:
991 vfe_output_frame_drop(vfe, output, 0);
992 break;
993 }
994
995 vfe_output_init_addrs(vfe, output, 1);
996 }
997
998 spin_unlock_irqrestore(&vfe->output_lock, flags);
999 }
1000
1001 /*
1002 * vfe_isr_wm_done - Process write master done interrupt
1003 * @vfe: VFE Device
1004 * @wm: Write master id
1005 */
1006 static void vfe_isr_wm_done(struct vfe_device *vfe, u8 wm)
1007 {
1008 struct camss_buffer *ready_buf;
1009 struct vfe_output *output;
1010 dma_addr_t *new_addr;
1011 unsigned long flags;
1012 u32 active_index;
1013 u64 ts = ktime_get_ns();
1014 unsigned int i;
1015
1016 active_index = vfe->ops->wm_get_ping_pong_status(vfe, wm);
1017
1018 spin_lock_irqsave(&vfe->output_lock, flags);
1019
1020 if (vfe->wm_output_map[wm] == VFE_LINE_NONE) {
1021 dev_err_ratelimited(vfe->camss->dev,
1022 "Received wm done for unmapped index\n");
1023 goto out_unlock;
1024 }
1025 output = &vfe->line[vfe->wm_output_map[wm]].output;
1026
1027 if (output->active_buf == active_index) {
1028 dev_err_ratelimited(vfe->camss->dev,
1029 "Active buffer mismatch!\n");
1030 goto out_unlock;
1031 }
1032 output->active_buf = active_index;
1033
1034 ready_buf = output->buf[!active_index];
1035 if (!ready_buf) {
1036 dev_err_ratelimited(vfe->camss->dev,
1037 "Missing ready buf %d %d!\n",
1038 !active_index, output->state);
1039 goto out_unlock;
1040 }
1041
1042 ready_buf->vb.vb2_buf.timestamp = ts;
1043 ready_buf->vb.sequence = output->sequence++;
1044
1045 /* Get next buffer */
1046 output->buf[!active_index] = vfe_buf_get_pending(output);
1047 if (!output->buf[!active_index]) {
1048 /* No next buffer - set same address */
1049 new_addr = ready_buf->addr;
1050 vfe_buf_update_wm_on_last(vfe, output);
1051 } else {
1052 new_addr = output->buf[!active_index]->addr;
1053 vfe_buf_update_wm_on_next(vfe, output);
1054 }
1055
1056 if (active_index)
1057 for (i = 0; i < output->wm_num; i++)
1058 vfe->ops->wm_set_ping_addr(vfe, output->wm_idx[i],
1059 new_addr[i]);
1060 else
1061 for (i = 0; i < output->wm_num; i++)
1062 vfe->ops->wm_set_pong_addr(vfe, output->wm_idx[i],
1063 new_addr[i]);
1064
1065 spin_unlock_irqrestore(&vfe->output_lock, flags);
1066
1067 if (output->state == VFE_OUTPUT_STOPPING)
1068 output->last_buffer = ready_buf;
1069 else
1070 vb2_buffer_done(&ready_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
1071
1072 return;
1073
1074 out_unlock:
1075 spin_unlock_irqrestore(&vfe->output_lock, flags);
1076 }
1077
1078 /*
1079 * vfe_isr_wm_done - Process composite image done interrupt
1080 * @vfe: VFE Device
1081 * @comp: Composite image id
1082 */
1083 static void vfe_isr_comp_done(struct vfe_device *vfe, u8 comp)
1084 {
1085 unsigned int i;
1086
1087 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++)
1088 if (vfe->wm_output_map[i] == VFE_LINE_PIX) {
1089 vfe_isr_wm_done(vfe, i);
1090 break;
1091 }
1092 }
1093
1094 static inline void vfe_isr_reset_ack(struct vfe_device *vfe)
1095 {
1096 complete(&vfe->reset_complete);
1097 }
1098
1099 static inline void vfe_isr_halt_ack(struct vfe_device *vfe)
1100 {
1101 complete(&vfe->halt_complete);
1102 vfe->ops->halt_clear(vfe);
1103 }
1104
1105 /*
1106 * vfe_set_clock_rates - Calculate and set clock rates on VFE module
1107 * @vfe: VFE device
1108 *
1109 * Return 0 on success or a negative error code otherwise
1110 */
1111 static int vfe_set_clock_rates(struct vfe_device *vfe)
1112 {
1113 struct device *dev = vfe->camss->dev;
1114 u32 pixel_clock[MSM_VFE_LINE_NUM];
1115 int i, j;
1116 int ret;
1117
1118 for (i = VFE_LINE_RDI0; i <= VFE_LINE_PIX; i++) {
1119 ret = camss_get_pixel_clock(&vfe->line[i].subdev.entity,
1120 &pixel_clock[i]);
1121 if (ret)
1122 pixel_clock[i] = 0;
1123 }
1124
1125 for (i = 0; i < vfe->nclocks; i++) {
1126 struct camss_clock *clock = &vfe->clock[i];
1127
1128 if (!strcmp(clock->name, "vfe0") ||
1129 !strcmp(clock->name, "vfe1")) {
1130 u64 min_rate = 0;
1131 long rate;
1132
1133 for (j = VFE_LINE_RDI0; j <= VFE_LINE_PIX; j++) {
1134 u32 tmp;
1135 u8 bpp;
1136
1137 if (j == VFE_LINE_PIX) {
1138 tmp = pixel_clock[j];
1139 } else {
1140 struct vfe_line *l = &vfe->line[j];
1141
1142 bpp = vfe_get_bpp(l->formats,
1143 l->nformats,
1144 l->fmt[MSM_VFE_PAD_SINK].code);
1145 tmp = pixel_clock[j] * bpp / 64;
1146 }
1147
1148 if (min_rate < tmp)
1149 min_rate = tmp;
1150 }
1151
1152 camss_add_clock_margin(&min_rate);
1153
1154 for (j = 0; j < clock->nfreqs; j++)
1155 if (min_rate < clock->freq[j])
1156 break;
1157
1158 if (j == clock->nfreqs) {
1159 dev_err(dev,
1160 "Pixel clock is too high for VFE");
1161 return -EINVAL;
1162 }
1163
1164 /* if sensor pixel clock is not available */
1165 /* set highest possible VFE clock rate */
1166 if (min_rate == 0)
1167 j = clock->nfreqs - 1;
1168
1169 rate = clk_round_rate(clock->clk, clock->freq[j]);
1170 if (rate < 0) {
1171 dev_err(dev, "clk round rate failed: %ld\n",
1172 rate);
1173 return -EINVAL;
1174 }
1175
1176 ret = clk_set_rate(clock->clk, rate);
1177 if (ret < 0) {
1178 dev_err(dev, "clk set rate failed: %d\n", ret);
1179 return ret;
1180 }
1181 }
1182 }
1183
1184 return 0;
1185 }
1186
1187 /*
1188 * vfe_check_clock_rates - Check current clock rates on VFE module
1189 * @vfe: VFE device
1190 *
1191 * Return 0 if current clock rates are suitable for a new pipeline
1192 * or a negative error code otherwise
1193 */
1194 static int vfe_check_clock_rates(struct vfe_device *vfe)
1195 {
1196 u32 pixel_clock[MSM_VFE_LINE_NUM];
1197 int i, j;
1198 int ret;
1199
1200 for (i = VFE_LINE_RDI0; i <= VFE_LINE_PIX; i++) {
1201 ret = camss_get_pixel_clock(&vfe->line[i].subdev.entity,
1202 &pixel_clock[i]);
1203 if (ret)
1204 pixel_clock[i] = 0;
1205 }
1206
1207 for (i = 0; i < vfe->nclocks; i++) {
1208 struct camss_clock *clock = &vfe->clock[i];
1209
1210 if (!strcmp(clock->name, "vfe0") ||
1211 !strcmp(clock->name, "vfe1")) {
1212 u64 min_rate = 0;
1213 unsigned long rate;
1214
1215 for (j = VFE_LINE_RDI0; j <= VFE_LINE_PIX; j++) {
1216 u32 tmp;
1217 u8 bpp;
1218
1219 if (j == VFE_LINE_PIX) {
1220 tmp = pixel_clock[j];
1221 } else {
1222 struct vfe_line *l = &vfe->line[j];
1223
1224 bpp = vfe_get_bpp(l->formats,
1225 l->nformats,
1226 l->fmt[MSM_VFE_PAD_SINK].code);
1227 tmp = pixel_clock[j] * bpp / 64;
1228 }
1229
1230 if (min_rate < tmp)
1231 min_rate = tmp;
1232 }
1233
1234 camss_add_clock_margin(&min_rate);
1235
1236 rate = clk_get_rate(clock->clk);
1237 if (rate < min_rate)
1238 return -EBUSY;
1239 }
1240 }
1241
1242 return 0;
1243 }
1244
1245 /*
1246 * vfe_get - Power up and reset VFE module
1247 * @vfe: VFE Device
1248 *
1249 * Return 0 on success or a negative error code otherwise
1250 */
1251 static int vfe_get(struct vfe_device *vfe)
1252 {
1253 int ret;
1254
1255 mutex_lock(&vfe->power_lock);
1256
1257 if (vfe->power_count == 0) {
1258 ret = camss_pm_domain_on(vfe->camss, vfe->id);
1259 if (ret < 0)
1260 goto error_pm_domain;
1261
1262 ret = pm_runtime_get_sync(vfe->camss->dev);
1263 if (ret < 0)
1264 goto error_pm_runtime_get;
1265
1266 ret = vfe_set_clock_rates(vfe);
1267 if (ret < 0)
1268 goto error_clocks;
1269
1270 ret = camss_enable_clocks(vfe->nclocks, vfe->clock,
1271 vfe->camss->dev);
1272 if (ret < 0)
1273 goto error_clocks;
1274
1275 ret = vfe_reset(vfe);
1276 if (ret < 0)
1277 goto error_reset;
1278
1279 vfe_reset_output_maps(vfe);
1280
1281 vfe_init_outputs(vfe);
1282 } else {
1283 ret = vfe_check_clock_rates(vfe);
1284 if (ret < 0)
1285 goto error_clocks;
1286 }
1287 vfe->power_count++;
1288
1289 mutex_unlock(&vfe->power_lock);
1290
1291 return 0;
1292
1293 error_reset:
1294 camss_disable_clocks(vfe->nclocks, vfe->clock);
1295
1296 error_clocks:
1297 pm_runtime_put_sync(vfe->camss->dev);
1298
1299 error_pm_runtime_get:
1300 camss_pm_domain_off(vfe->camss, vfe->id);
1301
1302 error_pm_domain:
1303 mutex_unlock(&vfe->power_lock);
1304
1305 return ret;
1306 }
1307
1308 /*
1309 * vfe_put - Power down VFE module
1310 * @vfe: VFE Device
1311 */
1312 static void vfe_put(struct vfe_device *vfe)
1313 {
1314 mutex_lock(&vfe->power_lock);
1315
1316 if (vfe->power_count == 0) {
1317 dev_err(vfe->camss->dev, "vfe power off on power_count == 0\n");
1318 goto exit;
1319 } else if (vfe->power_count == 1) {
1320 if (vfe->was_streaming) {
1321 vfe->was_streaming = 0;
1322 vfe_halt(vfe);
1323 }
1324 camss_disable_clocks(vfe->nclocks, vfe->clock);
1325 pm_runtime_put_sync(vfe->camss->dev);
1326 camss_pm_domain_off(vfe->camss, vfe->id);
1327 }
1328
1329 vfe->power_count--;
1330
1331 exit:
1332 mutex_unlock(&vfe->power_lock);
1333 }
1334
1335 /*
1336 * vfe_queue_buffer - Add empty buffer
1337 * @vid: Video device structure
1338 * @buf: Buffer to be enqueued
1339 *
1340 * Add an empty buffer - depending on the current number of buffers it will be
1341 * put in pending buffer queue or directly given to the hardware to be filled.
1342 *
1343 * Return 0 on success or a negative error code otherwise
1344 */
1345 static int vfe_queue_buffer(struct camss_video *vid,
1346 struct camss_buffer *buf)
1347 {
1348 struct vfe_line *line = container_of(vid, struct vfe_line, video_out);
1349 struct vfe_device *vfe = to_vfe(line);
1350 struct vfe_output *output;
1351 unsigned long flags;
1352
1353 output = &line->output;
1354
1355 spin_lock_irqsave(&vfe->output_lock, flags);
1356
1357 vfe_buf_update_wm_on_new(vfe, output, buf);
1358
1359 spin_unlock_irqrestore(&vfe->output_lock, flags);
1360
1361 return 0;
1362 }
1363
1364 /*
1365 * vfe_flush_buffers - Return all vb2 buffers
1366 * @vid: Video device structure
1367 * @state: vb2 buffer state of the returned buffers
1368 *
1369 * Return all buffers to vb2. This includes queued pending buffers (still
1370 * unused) and any buffers given to the hardware but again still not used.
1371 *
1372 * Return 0 on success or a negative error code otherwise
1373 */
1374 static int vfe_flush_buffers(struct camss_video *vid,
1375 enum vb2_buffer_state state)
1376 {
1377 struct vfe_line *line = container_of(vid, struct vfe_line, video_out);
1378 struct vfe_device *vfe = to_vfe(line);
1379 struct vfe_output *output;
1380 unsigned long flags;
1381
1382 output = &line->output;
1383
1384 spin_lock_irqsave(&vfe->output_lock, flags);
1385
1386 vfe_buf_flush_pending(output, state);
1387
1388 if (output->buf[0])
1389 vb2_buffer_done(&output->buf[0]->vb.vb2_buf, state);
1390
1391 if (output->buf[1])
1392 vb2_buffer_done(&output->buf[1]->vb.vb2_buf, state);
1393
1394 if (output->last_buffer) {
1395 vb2_buffer_done(&output->last_buffer->vb.vb2_buf, state);
1396 output->last_buffer = NULL;
1397 }
1398
1399 spin_unlock_irqrestore(&vfe->output_lock, flags);
1400
1401 return 0;
1402 }
1403
1404 /*
1405 * vfe_set_power - Power on/off VFE module
1406 * @sd: VFE V4L2 subdevice
1407 * @on: Requested power state
1408 *
1409 * Return 0 on success or a negative error code otherwise
1410 */
1411 static int vfe_set_power(struct v4l2_subdev *sd, int on)
1412 {
1413 struct vfe_line *line = v4l2_get_subdevdata(sd);
1414 struct vfe_device *vfe = to_vfe(line);
1415 int ret;
1416
1417 if (on) {
1418 ret = vfe_get(vfe);
1419 if (ret < 0)
1420 return ret;
1421
1422 vfe->ops->hw_version_read(vfe, vfe->camss->dev);
1423 } else {
1424 vfe_put(vfe);
1425 }
1426
1427 return 0;
1428 }
1429
1430 /*
1431 * vfe_set_stream - Enable/disable streaming on VFE module
1432 * @sd: VFE V4L2 subdevice
1433 * @enable: Requested streaming state
1434 *
1435 * Main configuration of VFE module is triggered here.
1436 *
1437 * Return 0 on success or a negative error code otherwise
1438 */
1439 static int vfe_set_stream(struct v4l2_subdev *sd, int enable)
1440 {
1441 struct vfe_line *line = v4l2_get_subdevdata(sd);
1442 struct vfe_device *vfe = to_vfe(line);
1443 int ret;
1444
1445 if (enable) {
1446 ret = vfe_enable(line);
1447 if (ret < 0)
1448 dev_err(vfe->camss->dev,
1449 "Failed to enable vfe outputs\n");
1450 } else {
1451 ret = vfe_disable(line);
1452 if (ret < 0)
1453 dev_err(vfe->camss->dev,
1454 "Failed to disable vfe outputs\n");
1455 }
1456
1457 return ret;
1458 }
1459
1460 /*
1461 * __vfe_get_format - Get pointer to format structure
1462 * @line: VFE line
1463 * @cfg: V4L2 subdev pad configuration
1464 * @pad: pad from which format is requested
1465 * @which: TRY or ACTIVE format
1466 *
1467 * Return pointer to TRY or ACTIVE format structure
1468 */
1469 static struct v4l2_mbus_framefmt *
1470 __vfe_get_format(struct vfe_line *line,
1471 struct v4l2_subdev_pad_config *cfg,
1472 unsigned int pad,
1473 enum v4l2_subdev_format_whence which)
1474 {
1475 if (which == V4L2_SUBDEV_FORMAT_TRY)
1476 return v4l2_subdev_get_try_format(&line->subdev, cfg, pad);
1477
1478 return &line->fmt[pad];
1479 }
1480
1481 /*
1482 * __vfe_get_compose - Get pointer to compose selection structure
1483 * @line: VFE line
1484 * @cfg: V4L2 subdev pad configuration
1485 * @which: TRY or ACTIVE format
1486 *
1487 * Return pointer to TRY or ACTIVE compose rectangle structure
1488 */
1489 static struct v4l2_rect *
1490 __vfe_get_compose(struct vfe_line *line,
1491 struct v4l2_subdev_pad_config *cfg,
1492 enum v4l2_subdev_format_whence which)
1493 {
1494 if (which == V4L2_SUBDEV_FORMAT_TRY)
1495 return v4l2_subdev_get_try_compose(&line->subdev, cfg,
1496 MSM_VFE_PAD_SINK);
1497
1498 return &line->compose;
1499 }
1500
1501 /*
1502 * __vfe_get_crop - Get pointer to crop selection structure
1503 * @line: VFE line
1504 * @cfg: V4L2 subdev pad configuration
1505 * @which: TRY or ACTIVE format
1506 *
1507 * Return pointer to TRY or ACTIVE crop rectangle structure
1508 */
1509 static struct v4l2_rect *
1510 __vfe_get_crop(struct vfe_line *line,
1511 struct v4l2_subdev_pad_config *cfg,
1512 enum v4l2_subdev_format_whence which)
1513 {
1514 if (which == V4L2_SUBDEV_FORMAT_TRY)
1515 return v4l2_subdev_get_try_crop(&line->subdev, cfg,
1516 MSM_VFE_PAD_SRC);
1517
1518 return &line->crop;
1519 }
1520
1521 /*
1522 * vfe_try_format - Handle try format by pad subdev method
1523 * @line: VFE line
1524 * @cfg: V4L2 subdev pad configuration
1525 * @pad: pad on which format is requested
1526 * @fmt: pointer to v4l2 format structure
1527 * @which: wanted subdev format
1528 */
1529 static void vfe_try_format(struct vfe_line *line,
1530 struct v4l2_subdev_pad_config *cfg,
1531 unsigned int pad,
1532 struct v4l2_mbus_framefmt *fmt,
1533 enum v4l2_subdev_format_whence which)
1534 {
1535 unsigned int i;
1536 u32 code;
1537
1538 switch (pad) {
1539 case MSM_VFE_PAD_SINK:
1540 /* Set format on sink pad */
1541
1542 for (i = 0; i < line->nformats; i++)
1543 if (fmt->code == line->formats[i].code)
1544 break;
1545
1546 /* If not found, use UYVY as default */
1547 if (i >= line->nformats)
1548 fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
1549
1550 fmt->width = clamp_t(u32, fmt->width, 1, 8191);
1551 fmt->height = clamp_t(u32, fmt->height, 1, 8191);
1552
1553 fmt->field = V4L2_FIELD_NONE;
1554 fmt->colorspace = V4L2_COLORSPACE_SRGB;
1555
1556 break;
1557
1558 case MSM_VFE_PAD_SRC:
1559 /* Set and return a format same as sink pad */
1560 code = fmt->code;
1561
1562 *fmt = *__vfe_get_format(line, cfg, MSM_VFE_PAD_SINK, which);
1563
1564 fmt->code = vfe_src_pad_code(line, fmt->code, 0, code);
1565
1566 if (line->id == VFE_LINE_PIX) {
1567 struct v4l2_rect *rect;
1568
1569 rect = __vfe_get_crop(line, cfg, which);
1570
1571 fmt->width = rect->width;
1572 fmt->height = rect->height;
1573 }
1574
1575 break;
1576 }
1577
1578 fmt->colorspace = V4L2_COLORSPACE_SRGB;
1579 }
1580
1581 /*
1582 * vfe_try_compose - Handle try compose selection by pad subdev method
1583 * @line: VFE line
1584 * @cfg: V4L2 subdev pad configuration
1585 * @rect: pointer to v4l2 rect structure
1586 * @which: wanted subdev format
1587 */
1588 static void vfe_try_compose(struct vfe_line *line,
1589 struct v4l2_subdev_pad_config *cfg,
1590 struct v4l2_rect *rect,
1591 enum v4l2_subdev_format_whence which)
1592 {
1593 struct v4l2_mbus_framefmt *fmt;
1594
1595 fmt = __vfe_get_format(line, cfg, MSM_VFE_PAD_SINK, which);
1596
1597 if (rect->width > fmt->width)
1598 rect->width = fmt->width;
1599
1600 if (rect->height > fmt->height)
1601 rect->height = fmt->height;
1602
1603 if (fmt->width > rect->width * SCALER_RATIO_MAX)
1604 rect->width = (fmt->width + SCALER_RATIO_MAX - 1) /
1605 SCALER_RATIO_MAX;
1606
1607 rect->width &= ~0x1;
1608
1609 if (fmt->height > rect->height * SCALER_RATIO_MAX)
1610 rect->height = (fmt->height + SCALER_RATIO_MAX - 1) /
1611 SCALER_RATIO_MAX;
1612
1613 if (rect->width < 16)
1614 rect->width = 16;
1615
1616 if (rect->height < 4)
1617 rect->height = 4;
1618 }
1619
1620 /*
1621 * vfe_try_crop - Handle try crop selection by pad subdev method
1622 * @line: VFE line
1623 * @cfg: V4L2 subdev pad configuration
1624 * @rect: pointer to v4l2 rect structure
1625 * @which: wanted subdev format
1626 */
1627 static void vfe_try_crop(struct vfe_line *line,
1628 struct v4l2_subdev_pad_config *cfg,
1629 struct v4l2_rect *rect,
1630 enum v4l2_subdev_format_whence which)
1631 {
1632 struct v4l2_rect *compose;
1633
1634 compose = __vfe_get_compose(line, cfg, which);
1635
1636 if (rect->width > compose->width)
1637 rect->width = compose->width;
1638
1639 if (rect->width + rect->left > compose->width)
1640 rect->left = compose->width - rect->width;
1641
1642 if (rect->height > compose->height)
1643 rect->height = compose->height;
1644
1645 if (rect->height + rect->top > compose->height)
1646 rect->top = compose->height - rect->height;
1647
1648 /* wm in line based mode writes multiple of 16 horizontally */
1649 rect->left += (rect->width & 0xf) >> 1;
1650 rect->width &= ~0xf;
1651
1652 if (rect->width < 16) {
1653 rect->left = 0;
1654 rect->width = 16;
1655 }
1656
1657 if (rect->height < 4) {
1658 rect->top = 0;
1659 rect->height = 4;
1660 }
1661 }
1662
1663 /*
1664 * vfe_enum_mbus_code - Handle pixel format enumeration
1665 * @sd: VFE V4L2 subdevice
1666 * @cfg: V4L2 subdev pad configuration
1667 * @code: pointer to v4l2_subdev_mbus_code_enum structure
1668 *
1669 * return -EINVAL or zero on success
1670 */
1671 static int vfe_enum_mbus_code(struct v4l2_subdev *sd,
1672 struct v4l2_subdev_pad_config *cfg,
1673 struct v4l2_subdev_mbus_code_enum *code)
1674 {
1675 struct vfe_line *line = v4l2_get_subdevdata(sd);
1676
1677 if (code->pad == MSM_VFE_PAD_SINK) {
1678 if (code->index >= line->nformats)
1679 return -EINVAL;
1680
1681 code->code = line->formats[code->index].code;
1682 } else {
1683 struct v4l2_mbus_framefmt *sink_fmt;
1684
1685 sink_fmt = __vfe_get_format(line, cfg, MSM_VFE_PAD_SINK,
1686 code->which);
1687
1688 code->code = vfe_src_pad_code(line, sink_fmt->code,
1689 code->index, 0);
1690 if (!code->code)
1691 return -EINVAL;
1692 }
1693
1694 return 0;
1695 }
1696
1697 /*
1698 * vfe_enum_frame_size - Handle frame size enumeration
1699 * @sd: VFE V4L2 subdevice
1700 * @cfg: V4L2 subdev pad configuration
1701 * @fse: pointer to v4l2_subdev_frame_size_enum structure
1702 *
1703 * Return -EINVAL or zero on success
1704 */
1705 static int vfe_enum_frame_size(struct v4l2_subdev *sd,
1706 struct v4l2_subdev_pad_config *cfg,
1707 struct v4l2_subdev_frame_size_enum *fse)
1708 {
1709 struct vfe_line *line = v4l2_get_subdevdata(sd);
1710 struct v4l2_mbus_framefmt format;
1711
1712 if (fse->index != 0)
1713 return -EINVAL;
1714
1715 format.code = fse->code;
1716 format.width = 1;
1717 format.height = 1;
1718 vfe_try_format(line, cfg, fse->pad, &format, fse->which);
1719 fse->min_width = format.width;
1720 fse->min_height = format.height;
1721
1722 if (format.code != fse->code)
1723 return -EINVAL;
1724
1725 format.code = fse->code;
1726 format.width = -1;
1727 format.height = -1;
1728 vfe_try_format(line, cfg, fse->pad, &format, fse->which);
1729 fse->max_width = format.width;
1730 fse->max_height = format.height;
1731
1732 return 0;
1733 }
1734
1735 /*
1736 * vfe_get_format - Handle get format by pads subdev method
1737 * @sd: VFE V4L2 subdevice
1738 * @cfg: V4L2 subdev pad configuration
1739 * @fmt: pointer to v4l2 subdev format structure
1740 *
1741 * Return -EINVAL or zero on success
1742 */
1743 static int vfe_get_format(struct v4l2_subdev *sd,
1744 struct v4l2_subdev_pad_config *cfg,
1745 struct v4l2_subdev_format *fmt)
1746 {
1747 struct vfe_line *line = v4l2_get_subdevdata(sd);
1748 struct v4l2_mbus_framefmt *format;
1749
1750 format = __vfe_get_format(line, cfg, fmt->pad, fmt->which);
1751 if (format == NULL)
1752 return -EINVAL;
1753
1754 fmt->format = *format;
1755
1756 return 0;
1757 }
1758
1759 static int vfe_set_selection(struct v4l2_subdev *sd,
1760 struct v4l2_subdev_pad_config *cfg,
1761 struct v4l2_subdev_selection *sel);
1762
1763 /*
1764 * vfe_set_format - Handle set format by pads subdev method
1765 * @sd: VFE V4L2 subdevice
1766 * @cfg: V4L2 subdev pad configuration
1767 * @fmt: pointer to v4l2 subdev format structure
1768 *
1769 * Return -EINVAL or zero on success
1770 */
1771 static int vfe_set_format(struct v4l2_subdev *sd,
1772 struct v4l2_subdev_pad_config *cfg,
1773 struct v4l2_subdev_format *fmt)
1774 {
1775 struct vfe_line *line = v4l2_get_subdevdata(sd);
1776 struct v4l2_mbus_framefmt *format;
1777
1778 format = __vfe_get_format(line, cfg, fmt->pad, fmt->which);
1779 if (format == NULL)
1780 return -EINVAL;
1781
1782 vfe_try_format(line, cfg, fmt->pad, &fmt->format, fmt->which);
1783 *format = fmt->format;
1784
1785 if (fmt->pad == MSM_VFE_PAD_SINK) {
1786 struct v4l2_subdev_selection sel = { 0 };
1787 int ret;
1788
1789 /* Propagate the format from sink to source */
1790 format = __vfe_get_format(line, cfg, MSM_VFE_PAD_SRC,
1791 fmt->which);
1792
1793 *format = fmt->format;
1794 vfe_try_format(line, cfg, MSM_VFE_PAD_SRC, format,
1795 fmt->which);
1796
1797 if (line->id != VFE_LINE_PIX)
1798 return 0;
1799
1800 /* Reset sink pad compose selection */
1801 sel.which = fmt->which;
1802 sel.pad = MSM_VFE_PAD_SINK;
1803 sel.target = V4L2_SEL_TGT_COMPOSE;
1804 sel.r.width = fmt->format.width;
1805 sel.r.height = fmt->format.height;
1806 ret = vfe_set_selection(sd, cfg, &sel);
1807 if (ret < 0)
1808 return ret;
1809 }
1810
1811 return 0;
1812 }
1813
1814 /*
1815 * vfe_get_selection - Handle get selection by pads subdev method
1816 * @sd: VFE V4L2 subdevice
1817 * @cfg: V4L2 subdev pad configuration
1818 * @sel: pointer to v4l2 subdev selection structure
1819 *
1820 * Return -EINVAL or zero on success
1821 */
1822 static int vfe_get_selection(struct v4l2_subdev *sd,
1823 struct v4l2_subdev_pad_config *cfg,
1824 struct v4l2_subdev_selection *sel)
1825 {
1826 struct vfe_line *line = v4l2_get_subdevdata(sd);
1827 struct v4l2_subdev_format fmt = { 0 };
1828 struct v4l2_rect *rect;
1829 int ret;
1830
1831 if (line->id != VFE_LINE_PIX)
1832 return -EINVAL;
1833
1834 if (sel->pad == MSM_VFE_PAD_SINK)
1835 switch (sel->target) {
1836 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1837 fmt.pad = sel->pad;
1838 fmt.which = sel->which;
1839 ret = vfe_get_format(sd, cfg, &fmt);
1840 if (ret < 0)
1841 return ret;
1842
1843 sel->r.left = 0;
1844 sel->r.top = 0;
1845 sel->r.width = fmt.format.width;
1846 sel->r.height = fmt.format.height;
1847 break;
1848 case V4L2_SEL_TGT_COMPOSE:
1849 rect = __vfe_get_compose(line, cfg, sel->which);
1850 if (rect == NULL)
1851 return -EINVAL;
1852
1853 sel->r = *rect;
1854 break;
1855 default:
1856 return -EINVAL;
1857 }
1858 else if (sel->pad == MSM_VFE_PAD_SRC)
1859 switch (sel->target) {
1860 case V4L2_SEL_TGT_CROP_BOUNDS:
1861 rect = __vfe_get_compose(line, cfg, sel->which);
1862 if (rect == NULL)
1863 return -EINVAL;
1864
1865 sel->r.left = rect->left;
1866 sel->r.top = rect->top;
1867 sel->r.width = rect->width;
1868 sel->r.height = rect->height;
1869 break;
1870 case V4L2_SEL_TGT_CROP:
1871 rect = __vfe_get_crop(line, cfg, sel->which);
1872 if (rect == NULL)
1873 return -EINVAL;
1874
1875 sel->r = *rect;
1876 break;
1877 default:
1878 return -EINVAL;
1879 }
1880
1881 return 0;
1882 }
1883
1884 /*
1885 * vfe_set_selection - Handle set selection by pads subdev method
1886 * @sd: VFE V4L2 subdevice
1887 * @cfg: V4L2 subdev pad configuration
1888 * @sel: pointer to v4l2 subdev selection structure
1889 *
1890 * Return -EINVAL or zero on success
1891 */
1892 static int vfe_set_selection(struct v4l2_subdev *sd,
1893 struct v4l2_subdev_pad_config *cfg,
1894 struct v4l2_subdev_selection *sel)
1895 {
1896 struct vfe_line *line = v4l2_get_subdevdata(sd);
1897 struct v4l2_rect *rect;
1898 int ret;
1899
1900 if (line->id != VFE_LINE_PIX)
1901 return -EINVAL;
1902
1903 if (sel->target == V4L2_SEL_TGT_COMPOSE &&
1904 sel->pad == MSM_VFE_PAD_SINK) {
1905 struct v4l2_subdev_selection crop = { 0 };
1906
1907 rect = __vfe_get_compose(line, cfg, sel->which);
1908 if (rect == NULL)
1909 return -EINVAL;
1910
1911 vfe_try_compose(line, cfg, &sel->r, sel->which);
1912 *rect = sel->r;
1913
1914 /* Reset source crop selection */
1915 crop.which = sel->which;
1916 crop.pad = MSM_VFE_PAD_SRC;
1917 crop.target = V4L2_SEL_TGT_CROP;
1918 crop.r = *rect;
1919 ret = vfe_set_selection(sd, cfg, &crop);
1920 } else if (sel->target == V4L2_SEL_TGT_CROP &&
1921 sel->pad == MSM_VFE_PAD_SRC) {
1922 struct v4l2_subdev_format fmt = { 0 };
1923
1924 rect = __vfe_get_crop(line, cfg, sel->which);
1925 if (rect == NULL)
1926 return -EINVAL;
1927
1928 vfe_try_crop(line, cfg, &sel->r, sel->which);
1929 *rect = sel->r;
1930
1931 /* Reset source pad format width and height */
1932 fmt.which = sel->which;
1933 fmt.pad = MSM_VFE_PAD_SRC;
1934 ret = vfe_get_format(sd, cfg, &fmt);
1935 if (ret < 0)
1936 return ret;
1937
1938 fmt.format.width = rect->width;
1939 fmt.format.height = rect->height;
1940 ret = vfe_set_format(sd, cfg, &fmt);
1941 } else {
1942 ret = -EINVAL;
1943 }
1944
1945 return ret;
1946 }
1947
1948 /*
1949 * vfe_init_formats - Initialize formats on all pads
1950 * @sd: VFE V4L2 subdevice
1951 * @fh: V4L2 subdev file handle
1952 *
1953 * Initialize all pad formats with default values.
1954 *
1955 * Return 0 on success or a negative error code otherwise
1956 */
1957 static int vfe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1958 {
1959 struct v4l2_subdev_format format = {
1960 .pad = MSM_VFE_PAD_SINK,
1961 .which = fh ? V4L2_SUBDEV_FORMAT_TRY :
1962 V4L2_SUBDEV_FORMAT_ACTIVE,
1963 .format = {
1964 .code = MEDIA_BUS_FMT_UYVY8_2X8,
1965 .width = 1920,
1966 .height = 1080
1967 }
1968 };
1969
1970 return vfe_set_format(sd, fh ? fh->pad : NULL, &format);
1971 }
1972
1973 /*
1974 * msm_vfe_subdev_init - Initialize VFE device structure and resources
1975 * @vfe: VFE device
1976 * @res: VFE module resources table
1977 *
1978 * Return 0 on success or a negative error code otherwise
1979 */
1980 int msm_vfe_subdev_init(struct camss *camss, struct vfe_device *vfe,
1981 const struct resources *res, u8 id)
1982 {
1983 struct device *dev = camss->dev;
1984 struct platform_device *pdev = to_platform_device(dev);
1985 struct resource *r;
1986 int i, j;
1987 int ret;
1988
1989 vfe->isr_ops.reset_ack = vfe_isr_reset_ack;
1990 vfe->isr_ops.halt_ack = vfe_isr_halt_ack;
1991 vfe->isr_ops.reg_update = vfe_isr_reg_update;
1992 vfe->isr_ops.sof = vfe_isr_sof;
1993 vfe->isr_ops.comp_done = vfe_isr_comp_done;
1994 vfe->isr_ops.wm_done = vfe_isr_wm_done;
1995
1996 if (camss->version == CAMSS_8x16)
1997 vfe->ops = &vfe_ops_4_1;
1998 else if (camss->version == CAMSS_8x96)
1999 vfe->ops = &vfe_ops_4_7;
2000 else
2001 return -EINVAL;
2002
2003 /* Memory */
2004
2005 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, res->reg[0]);
2006 vfe->base = devm_ioremap_resource(dev, r);
2007 if (IS_ERR(vfe->base)) {
2008 dev_err(dev, "could not map memory\n");
2009 return PTR_ERR(vfe->base);
2010 }
2011
2012 /* Interrupt */
2013
2014 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
2015 res->interrupt[0]);
2016 if (!r) {
2017 dev_err(dev, "missing IRQ\n");
2018 return -EINVAL;
2019 }
2020
2021 vfe->irq = r->start;
2022 snprintf(vfe->irq_name, sizeof(vfe->irq_name), "%s_%s%d",
2023 dev_name(dev), MSM_VFE_NAME, vfe->id);
2024 ret = devm_request_irq(dev, vfe->irq, vfe->ops->isr,
2025 IRQF_TRIGGER_RISING, vfe->irq_name, vfe);
2026 if (ret < 0) {
2027 dev_err(dev, "request_irq failed: %d\n", ret);
2028 return ret;
2029 }
2030
2031 /* Clocks */
2032
2033 vfe->nclocks = 0;
2034 while (res->clock[vfe->nclocks])
2035 vfe->nclocks++;
2036
2037 vfe->clock = devm_kcalloc(dev, vfe->nclocks, sizeof(*vfe->clock),
2038 GFP_KERNEL);
2039 if (!vfe->clock)
2040 return -ENOMEM;
2041
2042 for (i = 0; i < vfe->nclocks; i++) {
2043 struct camss_clock *clock = &vfe->clock[i];
2044
2045 clock->clk = devm_clk_get(dev, res->clock[i]);
2046 if (IS_ERR(clock->clk))
2047 return PTR_ERR(clock->clk);
2048
2049 clock->name = res->clock[i];
2050
2051 clock->nfreqs = 0;
2052 while (res->clock_rate[i][clock->nfreqs])
2053 clock->nfreqs++;
2054
2055 if (!clock->nfreqs) {
2056 clock->freq = NULL;
2057 continue;
2058 }
2059
2060 clock->freq = devm_kcalloc(dev,
2061 clock->nfreqs,
2062 sizeof(*clock->freq),
2063 GFP_KERNEL);
2064 if (!clock->freq)
2065 return -ENOMEM;
2066
2067 for (j = 0; j < clock->nfreqs; j++)
2068 clock->freq[j] = res->clock_rate[i][j];
2069 }
2070
2071 mutex_init(&vfe->power_lock);
2072 vfe->power_count = 0;
2073
2074 mutex_init(&vfe->stream_lock);
2075 vfe->stream_count = 0;
2076
2077 spin_lock_init(&vfe->output_lock);
2078
2079 vfe->camss = camss;
2080 vfe->id = id;
2081 vfe->reg_update = 0;
2082
2083 for (i = VFE_LINE_RDI0; i <= VFE_LINE_PIX; i++) {
2084 struct vfe_line *l = &vfe->line[i];
2085
2086 l->video_out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
2087 l->video_out.camss = camss;
2088 l->id = i;
2089 init_completion(&l->output.sof);
2090 init_completion(&l->output.reg_update);
2091
2092 if (camss->version == CAMSS_8x16) {
2093 if (i == VFE_LINE_PIX) {
2094 l->formats = formats_pix_8x16;
2095 l->nformats = ARRAY_SIZE(formats_pix_8x16);
2096 } else {
2097 l->formats = formats_rdi_8x16;
2098 l->nformats = ARRAY_SIZE(formats_rdi_8x16);
2099 }
2100 } else if (camss->version == CAMSS_8x96) {
2101 if (i == VFE_LINE_PIX) {
2102 l->formats = formats_pix_8x96;
2103 l->nformats = ARRAY_SIZE(formats_pix_8x96);
2104 } else {
2105 l->formats = formats_rdi_8x96;
2106 l->nformats = ARRAY_SIZE(formats_rdi_8x96);
2107 }
2108 } else {
2109 return -EINVAL;
2110 }
2111 }
2112
2113 init_completion(&vfe->reset_complete);
2114 init_completion(&vfe->halt_complete);
2115
2116 return 0;
2117 }
2118
2119 /*
2120 * msm_vfe_get_vfe_id - Get VFE HW module id
2121 * @entity: Pointer to VFE media entity structure
2122 * @id: Return CSID HW module id here
2123 */
2124 void msm_vfe_get_vfe_id(struct media_entity *entity, u8 *id)
2125 {
2126 struct v4l2_subdev *sd;
2127 struct vfe_line *line;
2128 struct vfe_device *vfe;
2129
2130 sd = media_entity_to_v4l2_subdev(entity);
2131 line = v4l2_get_subdevdata(sd);
2132 vfe = to_vfe(line);
2133
2134 *id = vfe->id;
2135 }
2136
2137 /*
2138 * msm_vfe_get_vfe_line_id - Get VFE line id by media entity
2139 * @entity: Pointer to VFE media entity structure
2140 * @id: Return VFE line id here
2141 */
2142 void msm_vfe_get_vfe_line_id(struct media_entity *entity, enum vfe_line_id *id)
2143 {
2144 struct v4l2_subdev *sd;
2145 struct vfe_line *line;
2146
2147 sd = media_entity_to_v4l2_subdev(entity);
2148 line = v4l2_get_subdevdata(sd);
2149
2150 *id = line->id;
2151 }
2152
2153 /*
2154 * vfe_link_setup - Setup VFE connections
2155 * @entity: Pointer to media entity structure
2156 * @local: Pointer to local pad
2157 * @remote: Pointer to remote pad
2158 * @flags: Link flags
2159 *
2160 * Return 0 on success
2161 */
2162 static int vfe_link_setup(struct media_entity *entity,
2163 const struct media_pad *local,
2164 const struct media_pad *remote, u32 flags)
2165 {
2166 if (flags & MEDIA_LNK_FL_ENABLED)
2167 if (media_entity_remote_pad(local))
2168 return -EBUSY;
2169
2170 return 0;
2171 }
2172
2173 static const struct v4l2_subdev_core_ops vfe_core_ops = {
2174 .s_power = vfe_set_power,
2175 };
2176
2177 static const struct v4l2_subdev_video_ops vfe_video_ops = {
2178 .s_stream = vfe_set_stream,
2179 };
2180
2181 static const struct v4l2_subdev_pad_ops vfe_pad_ops = {
2182 .enum_mbus_code = vfe_enum_mbus_code,
2183 .enum_frame_size = vfe_enum_frame_size,
2184 .get_fmt = vfe_get_format,
2185 .set_fmt = vfe_set_format,
2186 .get_selection = vfe_get_selection,
2187 .set_selection = vfe_set_selection,
2188 };
2189
2190 static const struct v4l2_subdev_ops vfe_v4l2_ops = {
2191 .core = &vfe_core_ops,
2192 .video = &vfe_video_ops,
2193 .pad = &vfe_pad_ops,
2194 };
2195
2196 static const struct v4l2_subdev_internal_ops vfe_v4l2_internal_ops = {
2197 .open = vfe_init_formats,
2198 };
2199
2200 static const struct media_entity_operations vfe_media_ops = {
2201 .link_setup = vfe_link_setup,
2202 .link_validate = v4l2_subdev_link_validate,
2203 };
2204
2205 static const struct camss_video_ops camss_vfe_video_ops = {
2206 .queue_buffer = vfe_queue_buffer,
2207 .flush_buffers = vfe_flush_buffers,
2208 };
2209
2210 void msm_vfe_stop_streaming(struct vfe_device *vfe)
2211 {
2212 int i;
2213
2214 for (i = 0; i < ARRAY_SIZE(vfe->line); i++)
2215 msm_video_stop_streaming(&vfe->line[i].video_out);
2216 }
2217
2218 /*
2219 * msm_vfe_register_entities - Register subdev node for VFE module
2220 * @vfe: VFE device
2221 * @v4l2_dev: V4L2 device
2222 *
2223 * Initialize and register a subdev node for the VFE module. Then
2224 * call msm_video_register() to register the video device node which
2225 * will be connected to this subdev node. Then actually create the
2226 * media link between them.
2227 *
2228 * Return 0 on success or a negative error code otherwise
2229 */
2230 int msm_vfe_register_entities(struct vfe_device *vfe,
2231 struct v4l2_device *v4l2_dev)
2232 {
2233 struct device *dev = vfe->camss->dev;
2234 struct v4l2_subdev *sd;
2235 struct media_pad *pads;
2236 struct camss_video *video_out;
2237 int ret;
2238 int i;
2239
2240 for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
2241 char name[32];
2242
2243 sd = &vfe->line[i].subdev;
2244 pads = vfe->line[i].pads;
2245 video_out = &vfe->line[i].video_out;
2246
2247 v4l2_subdev_init(sd, &vfe_v4l2_ops);
2248 sd->internal_ops = &vfe_v4l2_internal_ops;
2249 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2250 if (i == VFE_LINE_PIX)
2251 snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s",
2252 MSM_VFE_NAME, vfe->id, "pix");
2253 else
2254 snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s%d",
2255 MSM_VFE_NAME, vfe->id, "rdi", i);
2256
2257 v4l2_set_subdevdata(sd, &vfe->line[i]);
2258
2259 ret = vfe_init_formats(sd, NULL);
2260 if (ret < 0) {
2261 dev_err(dev, "Failed to init format: %d\n", ret);
2262 goto error_init;
2263 }
2264
2265 pads[MSM_VFE_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
2266 pads[MSM_VFE_PAD_SRC].flags = MEDIA_PAD_FL_SOURCE;
2267
2268 sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER;
2269 sd->entity.ops = &vfe_media_ops;
2270 ret = media_entity_pads_init(&sd->entity, MSM_VFE_PADS_NUM,
2271 pads);
2272 if (ret < 0) {
2273 dev_err(dev, "Failed to init media entity: %d\n", ret);
2274 goto error_init;
2275 }
2276
2277 ret = v4l2_device_register_subdev(v4l2_dev, sd);
2278 if (ret < 0) {
2279 dev_err(dev, "Failed to register subdev: %d\n", ret);
2280 goto error_reg_subdev;
2281 }
2282
2283 video_out->ops = &camss_vfe_video_ops;
2284 video_out->bpl_alignment = 8;
2285 video_out->line_based = 0;
2286 if (i == VFE_LINE_PIX) {
2287 video_out->bpl_alignment = 16;
2288 video_out->line_based = 1;
2289 }
2290 snprintf(name, ARRAY_SIZE(name), "%s%d_%s%d",
2291 MSM_VFE_NAME, vfe->id, "video", i);
2292 ret = msm_video_register(video_out, v4l2_dev, name,
2293 i == VFE_LINE_PIX ? 1 : 0);
2294 if (ret < 0) {
2295 dev_err(dev, "Failed to register video node: %d\n",
2296 ret);
2297 goto error_reg_video;
2298 }
2299
2300 ret = media_create_pad_link(
2301 &sd->entity, MSM_VFE_PAD_SRC,
2302 &video_out->vdev.entity, 0,
2303 MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
2304 if (ret < 0) {
2305 dev_err(dev, "Failed to link %s->%s entities: %d\n",
2306 sd->entity.name, video_out->vdev.entity.name,
2307 ret);
2308 goto error_link;
2309 }
2310 }
2311
2312 return 0;
2313
2314 error_link:
2315 msm_video_unregister(video_out);
2316
2317 error_reg_video:
2318 v4l2_device_unregister_subdev(sd);
2319
2320 error_reg_subdev:
2321 media_entity_cleanup(&sd->entity);
2322
2323 error_init:
2324 for (i--; i >= 0; i--) {
2325 sd = &vfe->line[i].subdev;
2326 video_out = &vfe->line[i].video_out;
2327
2328 msm_video_unregister(video_out);
2329 v4l2_device_unregister_subdev(sd);
2330 media_entity_cleanup(&sd->entity);
2331 }
2332
2333 return ret;
2334 }
2335
2336 /*
2337 * msm_vfe_unregister_entities - Unregister VFE module subdev node
2338 * @vfe: VFE device
2339 */
2340 void msm_vfe_unregister_entities(struct vfe_device *vfe)
2341 {
2342 int i;
2343
2344 mutex_destroy(&vfe->power_lock);
2345 mutex_destroy(&vfe->stream_lock);
2346
2347 for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
2348 struct v4l2_subdev *sd = &vfe->line[i].subdev;
2349 struct camss_video *video_out = &vfe->line[i].video_out;
2350
2351 msm_video_unregister(video_out);
2352 v4l2_device_unregister_subdev(sd);
2353 media_entity_cleanup(&sd->entity);
2354 }
2355 }
Linux with added FPC-III support