1 /*
2 * TI VIP capture driver
3 *
4 * Copyright (C) 2013 - 2014 Texas Instruments, Inc.
5 * David Griego, <dagriego@biglakesoftware.com>
6 * Dale Farnsworth, <dale@farnsworth.org>
7 * Nikhil Devshatwar, <nikhil.nd@ti.com>
8 * Benoit Parrot, <bparrot@ti.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 */
16 #include <linux/clk.h>
17 #include <linux/delay.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/err.h>
20 #include <linux/fs.h>
21 #include <linux/interrupt.h>
22 #include <linux/io.h>
23 #include <linux/ioctl.h>
24 #include <linux/i2c.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/mfd/syscon.h>
31 #include <linux/regmap.h>
33 #include <linux/pinctrl/consumer.h>
34 #include <linux/of_device.h>
35 #include <linux/of_graph.h>
37 #include <media/v4l2-of.h>
38 #include <media/v4l2-async.h>
40 #include "vip.h"
42 #define VIP_MODULE_NAME "vip"
43 #define VIP_INPUT_NAME "Vin0"
45 static int debug;
46 module_param(debug, int, 0644);
47 MODULE_PARM_DESC(debug, "debug level (0-8)");
49 /*
50 * Minimum and maximum frame sizes
51 */
52 #define MIN_W 128
53 #define MIN_H 128
54 #define MAX_W 1920
55 #define MAX_H 1080
57 /*
58 * Required alignments
59 */
60 #define S_ALIGN 0 /* multiple of 1 */
61 #define H_ALIGN 1 /* multiple of 2 */
62 #define W_ALIGN 1 /* multiple of 2 */
63 #define L_ALIGN 7 /* multiple of 128, line stride, 16 bytes */
65 /*
66 * Need a descriptor entry for each of up to 15 outputs,
67 * and up to 2 control transfers.
68 */
69 #define VIP_DESC_LIST_SIZE (17 * sizeof(struct vpdma_dtd))
71 #define vip_dbg(level, dev, fmt, arg...) \
72 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ##arg)
73 #define vip_err(dev, fmt, arg...) \
74 v4l2_err(&dev->v4l2_dev, fmt, ##arg)
75 #define vip_info(dev, fmt, arg...) \
76 v4l2_info(&dev->v4l2_dev, fmt, ##arg)
78 #define CTRL_CORE_SMA_SW_1 0x534
79 /*
80 * The srce_info structure contains per-srce data.
81 */
82 struct vip_srce_info {
83 u8 base_channel; /* the VPDMA channel nummber */
84 u8 vb_index; /* input frame f, f-1, f-2 index */
85 u8 vb_part; /* identifies section of co-planar formats */
86 };
88 #define VIP_VPDMA_FIFO_SIZE 2
89 #define VIP_DROPQ_SIZE 3
91 /*
92 * Define indices into the srce_info tables
93 */
95 #define VIP_SRCE_MULT_PORT 0
96 #define VIP_SRCE_MULT_ANC 1
97 #define VIP_SRCE_LUMA 2
98 #define VIP_SRCE_CHROMA 3
99 #define VIP_SRCE_RGB 4
101 static struct vip_srce_info srce_info[5] = {
102 [VIP_SRCE_MULT_PORT] = {
103 .base_channel = VIP1_CHAN_NUM_MULT_PORT_A_SRC0,
104 .vb_index = 0,
105 .vb_part = VIP_CHROMA,
106 },
107 [VIP_SRCE_MULT_ANC] = {
108 .base_channel = VIP1_CHAN_NUM_MULT_ANC_A_SRC0,
109 .vb_index = 0,
110 .vb_part = VIP_LUMA,
111 },
112 [VIP_SRCE_LUMA] = {
113 .base_channel = VIP1_CHAN_NUM_PORT_B_LUMA,
114 .vb_index = 1,
115 .vb_part = VIP_LUMA,
116 },
117 [VIP_SRCE_CHROMA] = {
118 .base_channel = VIP1_CHAN_NUM_PORT_B_CHROMA,
119 .vb_index = 1,
120 .vb_part = VIP_CHROMA,
121 },
122 [VIP_SRCE_RGB] = {
123 .base_channel = VIP1_CHAN_NUM_PORT_B_RGB,
124 .vb_part = VIP_LUMA,
125 },
126 };
128 static struct vip_fmt vip_formats[] = {
129 {
130 .name = "YUV 444 co-planar",
131 .fourcc = V4L2_PIX_FMT_NV24,
132 .code = V4L2_MBUS_FMT_YDYUYDYV8_1X16,
133 .colorspace = V4L2_COLORSPACE_SMPTE170M,
134 .coplanar = 1,
135 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_Y444],
136 &vpdma_yuv_fmts[VPDMA_DATA_FMT_C444],
137 },
138 },
139 {
140 .name = "YUV 422 co-planar",
141 .fourcc = V4L2_PIX_FMT_NV16,
142 .code = V4L2_MBUS_FMT_YDYUYDYV8_1X16,
143 .colorspace = V4L2_COLORSPACE_SMPTE170M,
144 .coplanar = 1,
145 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_Y422],
146 &vpdma_yuv_fmts[VPDMA_DATA_FMT_C422],
147 },
148 },
149 {
150 .name = "YUV 420 co-planar",
151 .fourcc = V4L2_PIX_FMT_NV12,
152 .code = V4L2_MBUS_FMT_YDYUYDYV8_1X16,
153 .colorspace = V4L2_COLORSPACE_SMPTE170M,
154 .coplanar = 1,
155 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_Y420],
156 &vpdma_yuv_fmts[VPDMA_DATA_FMT_C420],
157 },
158 },
159 {
160 .name = "UYVY 422 packed",
161 .fourcc = V4L2_PIX_FMT_UYVY,
162 .code = V4L2_MBUS_FMT_UYVY8_2X8,
163 .colorspace = V4L2_COLORSPACE_SMPTE170M,
164 .coplanar = 0,
165 /* bus order is reversed so flip Y and UV bytes */
166 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CBY422],
167 },
168 },
169 {
170 .name = "YUYV 422 packed",
171 .fourcc = V4L2_PIX_FMT_YUYV,
172 .code = V4L2_MBUS_FMT_YUYV8_2X8,
173 .colorspace = V4L2_COLORSPACE_SMPTE170M,
174 .coplanar = 0,
175 /* bus order is reversed so flip Y and UV bytes */
176 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CBY422],
177 },
178 },
179 {
180 .name = "VYUY 422 packed",
181 .fourcc = V4L2_PIX_FMT_VYUY,
182 .code = V4L2_MBUS_FMT_VYUY8_2X8,
183 .colorspace = V4L2_COLORSPACE_SMPTE170M,
184 .coplanar = 0,
185 /* bus order is reversed so flip Y and UV bytes */
186 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CBY422],
187 },
188 },
189 {
190 .name = "YVYU 422 packed",
191 .fourcc = V4L2_PIX_FMT_YVYU,
192 .code = V4L2_MBUS_FMT_YVYU8_2X8,
193 .colorspace = V4L2_COLORSPACE_SMPTE170M,
194 .coplanar = 0,
195 /* bus order is reversed so flip Y and UV bytes */
196 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CBY422],
197 },
198 },
199 {
200 .name = "RGB888 packed",
201 .fourcc = V4L2_PIX_FMT_RGB24,
202 .code = V4L2_MBUS_FMT_RGB888_1X24,
203 .colorspace = V4L2_COLORSPACE_SRGB,
204 .coplanar = 0,
205 .vpdma_fmt = { &vpdma_rgb_fmts[VPDMA_DATA_FMT_RGB24],
206 },
207 },
208 {
209 .name = "ARGB888 packed",
210 .fourcc = V4L2_PIX_FMT_RGB32,
211 .code = V4L2_MBUS_FMT_ARGB8888_1X32,
212 .colorspace = V4L2_COLORSPACE_SRGB,
213 .coplanar = 0,
214 .vpdma_fmt = { &vpdma_rgb_fmts[VPDMA_DATA_FMT_ARGB32],
215 },
216 },
217 };
219 /* Print Four-character-code (FOURCC) */
220 static char *fourcc_to_str(u32 fmt)
221 {
222 static char code[5];
223 code[0] = (unsigned char)(fmt & 0xff);
224 code[1] = (unsigned char)((fmt>>8) & 0xff);
225 code[2] = (unsigned char)((fmt>>16) & 0xff);
226 code[3] = (unsigned char)((fmt>>24) & 0xff);
227 code[4] = '\0';
229 return code;
230 }
232 /*
233 * Find our format description corresponding to the passed v4l2_format
234 */
235 #ifdef DISABLED_FOR_NOW
236 static struct vip_fmt *find_format_by_pix(u32 pixelformat)
237 {
238 struct vip_fmt *fmt;
239 unsigned int k;
241 for (k = 0; k < ARRAY_SIZE(vip_formats); k++) {
242 fmt = &vip_formats[k];
243 if (fmt->fourcc == pixelformat)
244 return fmt;
245 }
247 return NULL;
248 }
249 #endif
251 static struct vip_fmt *find_format_by_code(u32 code)
252 {
253 struct vip_fmt *fmt;
254 unsigned int k;
256 for (k = 0; k < ARRAY_SIZE(vip_formats); k++) {
257 fmt = &vip_formats[k];
258 if (fmt->code == code)
259 return fmt;
260 }
262 return NULL;
263 }
265 static struct vip_fmt *find_active_format_by_pix(struct vip_dev *dev,
266 u32 pixelformat)
267 {
268 struct vip_fmt *fmt;
269 unsigned int k;
271 for (k = 0; k < dev->num_active_fmt; k++) {
272 fmt = dev->active_fmt[k];
273 if (fmt->fourcc == pixelformat)
274 return fmt;
275 }
277 return NULL;
278 }
280 static struct vip_fmt *find_active_format_by_code(struct vip_dev *dev,
281 u32 code)
282 {
283 struct vip_fmt *fmt;
284 unsigned int k;
286 for (k = 0; k < dev->num_active_fmt; k++) {
287 fmt = dev->active_fmt[k];
288 if (fmt->code == code)
289 return fmt;
290 }
292 return NULL;
293 }
295 static LIST_HEAD(vip_shared_list);
297 static inline struct vip_dev *notifier_to_vip_dev(struct v4l2_async_notifier *n)
298 {
299 return container_of(n, struct vip_dev, notifier);
300 }
302 /*
303 * port flag bits
304 */
305 #define FLAG_FRAME_1D (1 << 0)
306 #define FLAG_EVEN_LINE_SKIP (1 << 1)
307 #define FLAG_ODD_LINE_SKIP (1 << 2)
308 #define FLAG_MODE_TILED (1 << 3)
309 #define FLAG_INTERLACED (1 << 4)
310 #define FLAG_MULTIPLEXED (1 << 5)
311 #define FLAG_MULT_PORT (1 << 6)
312 #define FLAG_MULT_ANC (1 << 7)
314 /*
315 * Function prototype declarations
316 */
317 static int alloc_port(struct vip_dev *, int);
318 static void free_port(struct vip_port *);
319 static int vip_setup_parser(struct vip_port *port);
320 static void stop_dma(struct vip_stream *stream);
322 static inline u32 read_sreg(struct vip_shared *shared, int offset)
323 {
324 return ioread32(shared->base + offset);
325 }
327 static inline void write_sreg(struct vip_shared *shared, int offset, u32 value)
328 {
329 iowrite32(value, shared->base + offset);
330 }
332 static inline u32 read_vreg(struct vip_dev *dev, int offset)
333 {
334 return ioread32(dev->base + offset);
335 }
337 static inline void write_vreg(struct vip_dev *dev, int offset, u32 value)
338 {
339 iowrite32(value, dev->base + offset);
340 }
342 /*
343 * Insert a masked field into a 32-bit field
344 */
345 static void insert_field(u32 *valp, u32 field, u32 mask, int shift)
346 {
347 u32 val = *valp;
349 val &= ~(mask << shift);
350 val |= (field & mask) << shift;
351 *valp = val;
352 }
354 /*
355 * Set the system idle mode
356 */
357 static void vip_set_idle_mode(struct vip_shared *shared, int mode)
358 {
359 u32 reg = read_sreg(shared, VIP_SYSCONFIG);
360 insert_field(®, mode, VIP_SYSCONFIG_IDLE_MASK,
361 VIP_SYSCONFIG_IDLE_SHIFT);
362 write_sreg(shared, VIP_SYSCONFIG, reg);
363 }
365 /*
366 * Set the VIP standby mode
367 */
368 static void vip_set_standby_mode(struct vip_shared *shared, int mode)
369 {
370 u32 reg = read_sreg(shared, VIP_SYSCONFIG);
371 insert_field(®, mode, VIP_SYSCONFIG_STANDBY_MASK,
372 VIP_SYSCONFIG_STANDBY_SHIFT);
373 write_sreg(shared, VIP_SYSCONFIG, reg);
374 }
376 /*
377 * Enable or disable the VIP clocks
378 */
379 static void vip_set_clock_enable(struct vip_dev *dev, bool on)
380 {
381 u32 val = 0;
383 val = read_vreg(dev, VIP_CLK_ENABLE);
384 if (on) {
385 val |= VIP_VPDMA_CLK_ENABLE;
386 if (dev->slice_id == VIP_SLICE1)
387 val |= VIP_VIP1_DATA_PATH_CLK_ENABLE;
388 else
389 val |= VIP_VIP2_DATA_PATH_CLK_ENABLE;
390 } else {
391 if (dev->slice_id == VIP_SLICE1)
392 val &= ~VIP_VIP1_DATA_PATH_CLK_ENABLE;
393 else
394 val &= ~VIP_VIP2_DATA_PATH_CLK_ENABLE;
396 /* Both VIP are disabled then shutdown VPDMA also */
397 if (!(val & (VIP_VIP1_DATA_PATH_CLK_ENABLE|
398 VIP_VIP2_DATA_PATH_CLK_ENABLE)))
399 val = 0;
400 }
402 write_vreg(dev, VIP_CLK_ENABLE, val);
403 }
405 /* This helper function is used to enable the clock early on to
406 * enable vpdma firmware loading before the slice device are created
407 */
408 static void vip_shared_set_clock_enable(struct vip_shared *shared, bool on)
409 {
410 u32 val = 0;
412 if (on)
413 val = VIP_VIP1_DATA_PATH_CLK_ENABLE | VIP_VPDMA_CLK_ENABLE;
415 write_sreg(shared, VIP_CLK_ENABLE, val);
416 }
418 static void vip_top_reset(struct vip_dev *dev)
419 {
420 u32 val = 0;
422 val = read_vreg(dev, VIP_CLK_RESET);
424 if (dev->slice_id == VIP_SLICE1)
425 insert_field(&val, 1, VIP_DATA_PATH_CLK_RESET_MASK,
426 VIP_VIP1_DATA_PATH_RESET_SHIFT);
427 else
428 insert_field(&val, 1, VIP_DATA_PATH_CLK_RESET_MASK,
429 VIP_VIP2_DATA_PATH_RESET_SHIFT);
431 write_vreg(dev, VIP_CLK_RESET, val);
433 usleep_range(200, 250);
435 val = read_vreg(dev, VIP_CLK_RESET);
437 if (dev->slice_id == VIP_SLICE1)
438 insert_field(&val, 0, VIP_DATA_PATH_CLK_RESET_MASK,
439 VIP_VIP1_DATA_PATH_RESET_SHIFT);
440 else
441 insert_field(&val, 0, VIP_DATA_PATH_CLK_RESET_MASK,
442 VIP_VIP2_DATA_PATH_RESET_SHIFT);
443 write_vreg(dev, VIP_CLK_RESET, val);
444 }
446 static void vip_top_vpdma_reset(struct vip_shared *shared)
447 {
448 u32 val;
450 val = read_sreg(shared, VIP_CLK_RESET);
451 insert_field(&val, 1, VIP_VPDMA_CLK_RESET_MASK,
452 VIP_VPDMA_CLK_RESET_SHIFT);
453 write_sreg(shared, VIP_CLK_RESET, val);
455 usleep_range(200, 250);
457 val = read_sreg(shared, VIP_CLK_RESET);
458 insert_field(&val, 0, VIP_VPDMA_CLK_RESET_MASK,
459 VIP_VPDMA_CLK_RESET_SHIFT);
460 write_sreg(shared, VIP_CLK_RESET, val);
461 }
463 static void vip_xtra_set_repack_sel(struct vip_port *port, int repack_mode)
464 {
465 u32 val;
467 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
468 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
469 VIP_PARSER_PORTA_1);
470 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
471 VIP_REPACK_SEL_SHFT);
473 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
474 VIP_PARSER_PORTA_1, val);
475 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
476 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
477 VIP_PARSER_PORTA_1);
478 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
479 VIP_REPACK_SEL_SHFT);
481 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
482 VIP_PARSER_PORTA_1, val);
483 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
484 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
485 VIP_PARSER_PORTB_1);
486 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
487 VIP_REPACK_SEL_SHFT);
489 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
490 VIP_PARSER_PORTB_1, val);
491 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
492 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
493 VIP_PARSER_PORTB_1);
494 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
495 VIP_REPACK_SEL_SHFT);
497 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
498 VIP_PARSER_PORTB_1, val);
499 }
500 }
502 static void vip_set_discrete_basic_mode(struct vip_port *port)
503 {
504 u32 val;
506 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
507 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
508 VIP_PARSER_PORTA_0);
509 val |= VIP_DISCRETE_BASIC_MODE;
511 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
512 VIP_PARSER_PORTA_0, val);
513 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
514 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
515 VIP_PARSER_PORTA_0);
516 val |= VIP_DISCRETE_BASIC_MODE;
518 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
519 VIP_PARSER_PORTA_0, val);
520 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
521 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
522 VIP_PARSER_PORTB_0);
523 val |= VIP_DISCRETE_BASIC_MODE;
525 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
526 VIP_PARSER_PORTB_0, val);
527 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
528 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
529 VIP_PARSER_PORTB_0);
530 val |= VIP_DISCRETE_BASIC_MODE;
532 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
533 VIP_PARSER_PORTB_0, val);
534 }
535 }
537 static void vip_set_pclk_polarity(struct vip_port *port, int polarity)
538 {
539 u32 val, ret, offset;
541 if (polarity == 1 && port->dev->syscon) {
543 /*
544 * When the VIP parser is configured to so that the pixel clock
545 * is to be sampled at falling edge, the pixel clock needs to be
546 * inverted before it is given to the VIP module. This is done
547 * by setting a bit in the CTRL_CORE_SMA_SW1 register.
548 */
550 if (port->dev->instance_id == VIP_INSTANCE1)
551 offset = 0 + 2 * port->port_id + port->dev->slice_id;
552 else if (port->dev->instance_id == VIP_INSTANCE2)
553 offset = 4 + 2 * port->port_id + port->dev->slice_id;
554 else if (port->dev->instance_id == VIP_INSTANCE3)
555 offset = 10 - port->dev->slice_id;
556 else
557 BUG();
559 ret = regmap_update_bits(port->dev->syscon,
560 CTRL_CORE_SMA_SW_1, 1 << offset, 1 << offset);
561 }
563 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
564 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
565 VIP_PARSER_PORTA_0);
566 if (polarity)
567 val |= VIP_PIXCLK_EDGE_POLARITY;
568 else
569 val &= ~VIP_PIXCLK_EDGE_POLARITY;
571 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
572 VIP_PARSER_PORTA_0, val);
573 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
574 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET
575 + VIP_PARSER_PORTA_0);
576 if (polarity)
577 val |= VIP_PIXCLK_EDGE_POLARITY;
578 else
579 val &= ~VIP_PIXCLK_EDGE_POLARITY;
580 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
581 VIP_PARSER_PORTA_0, val);
582 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
583 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
584 VIP_PARSER_PORTB_0);
585 if (polarity)
586 val |= VIP_PIXCLK_EDGE_POLARITY;
587 else
588 val &= ~VIP_PIXCLK_EDGE_POLARITY;
589 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
590 VIP_PARSER_PORTB_0, val);
591 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
592 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
593 VIP_PARSER_PORTB_0);
594 if (polarity)
595 val |= VIP_PIXCLK_EDGE_POLARITY;
596 else
597 val &= ~VIP_PIXCLK_EDGE_POLARITY;
599 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
600 VIP_PARSER_PORTB_0, val);
601 }
602 }
604 static void vip_set_vsync_polarity(struct vip_port *port, int polarity)
605 {
606 u32 val;
608 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
609 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
610 VIP_PARSER_PORTA_0);
611 if (polarity)
612 val |= VIP_VSYNC_POLARITY;
613 else
614 val &= ~VIP_VSYNC_POLARITY;
616 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
617 VIP_PARSER_PORTA_0, val);
618 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
619 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
620 VIP_PARSER_PORTA_0);
621 if (polarity)
622 val |= VIP_VSYNC_POLARITY;
623 else
624 val &= ~VIP_VSYNC_POLARITY;
625 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
626 VIP_PARSER_PORTA_0, val);
627 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
628 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
629 VIP_PARSER_PORTB_0);
630 if (polarity)
631 val |= VIP_VSYNC_POLARITY;
632 else
633 val &= ~VIP_VSYNC_POLARITY;
634 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
635 VIP_PARSER_PORTB_0, val);
636 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
637 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
638 VIP_PARSER_PORTB_0);
639 if (polarity)
640 val |= VIP_VSYNC_POLARITY;
641 else
642 val &= ~VIP_VSYNC_POLARITY;
644 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
645 VIP_PARSER_PORTB_0, val);
646 }
647 }
649 static void vip_set_hsync_polarity(struct vip_port *port, int polarity)
650 {
651 u32 val;
653 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
654 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
655 VIP_PARSER_PORTA_0);
656 if (polarity)
657 val |= VIP_HSYNC_POLARITY;
658 else
659 val &= ~VIP_HSYNC_POLARITY;
661 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
662 VIP_PARSER_PORTA_0, val);
663 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
664 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
665 VIP_PARSER_PORTA_0);
666 if (polarity)
667 val |= VIP_HSYNC_POLARITY;
668 else
669 val &= ~VIP_HSYNC_POLARITY;
670 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
671 VIP_PARSER_PORTA_0, val);
672 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
673 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
674 VIP_PARSER_PORTB_0);
675 if (polarity)
676 val |= VIP_HSYNC_POLARITY;
677 else
678 val &= ~VIP_HSYNC_POLARITY;
679 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
680 VIP_PARSER_PORTB_0, val);
681 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
682 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
683 VIP_PARSER_PORTB_0);
684 if (polarity)
685 val |= VIP_HSYNC_POLARITY;
686 else
687 val &= ~VIP_HSYNC_POLARITY;
688 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
689 VIP_PARSER_PORTB_0, val);
690 }
691 }
693 static void vip_set_actvid_polarity(struct vip_port *port, int polarity)
694 {
695 u32 val;
697 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
698 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
699 VIP_PARSER_PORTA_0);
700 if (polarity)
701 val |= VIP_ACTVID_POLARITY;
702 else
703 val &= ~VIP_ACTVID_POLARITY;
705 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
706 VIP_PARSER_PORTA_0, val);
707 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
708 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
709 VIP_PARSER_PORTA_0);
710 if (polarity)
711 val |= VIP_ACTVID_POLARITY;
712 else
713 val &= ~VIP_ACTVID_POLARITY;
714 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
715 VIP_PARSER_PORTA_0, val);
716 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
717 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
718 VIP_PARSER_PORTB_0);
719 if (polarity)
720 val |= VIP_ACTVID_POLARITY;
721 else
722 val &= ~VIP_ACTVID_POLARITY;
723 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
724 VIP_PARSER_PORTB_0, val);
725 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
726 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
727 VIP_PARSER_PORTB_0);
728 if (polarity)
729 val |= VIP_ACTVID_POLARITY;
730 else
731 val &= ~VIP_ACTVID_POLARITY;
733 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
734 VIP_PARSER_PORTB_0, val);
735 }
736 }
738 static void vip_set_actvid_hsync_n(struct vip_port *port, int enable)
739 {
740 u32 val;
742 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
743 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
744 VIP_PARSER_PORTA_0);
745 if (enable)
746 val |= VIP_USE_ACTVID_HSYNC_ONLY;
747 else
748 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
750 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
751 VIP_PARSER_PORTA_0, val);
752 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
753 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
754 VIP_PARSER_PORTA_0);
755 if (enable)
756 val |= VIP_USE_ACTVID_HSYNC_ONLY;
757 else
758 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
759 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
760 VIP_PARSER_PORTA_0, val);
761 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
762 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
763 VIP_PARSER_PORTB_0);
764 if (enable)
765 val |= VIP_USE_ACTVID_HSYNC_ONLY;
766 else
767 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
768 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
769 VIP_PARSER_PORTB_0, val);
770 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
771 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
772 VIP_PARSER_PORTB_0);
773 if (enable)
774 val |= VIP_USE_ACTVID_HSYNC_ONLY;
775 else
776 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
778 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
779 VIP_PARSER_PORTB_0, val);
780 }
781 }
783 static void vip_sync_type(struct vip_port *port, enum sync_types sync)
784 {
785 u32 val;
787 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
788 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
789 VIP_PARSER_PORTA_0);
790 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
791 VIP_SYNC_TYPE_SHFT);
793 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
794 VIP_PARSER_PORTA_0, val);
795 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
796 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
797 VIP_PARSER_PORTA_0);
798 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
799 VIP_SYNC_TYPE_SHFT);
801 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
802 VIP_PARSER_PORTA_0, val);
803 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
804 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
805 VIP_PARSER_PORTB_0);
806 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
807 VIP_SYNC_TYPE_SHFT);
809 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
810 VIP_PARSER_PORTB_0, val);
811 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
812 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
813 VIP_PARSER_PORTB_0);
814 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
815 VIP_SYNC_TYPE_SHFT);
817 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
818 VIP_PARSER_PORTB_0, val);
819 }
820 }
822 static void vip_set_data_interface(struct vip_port *port,
823 enum data_interface_modes mode)
824 {
825 u32 val = 0;
827 if (port->dev->slice_id == VIP_SLICE1) {
828 insert_field(&val, mode, VIP_DATA_INTERFACE_MODE_MASK,
829 VIP_DATA_INTERFACE_MODE_SHFT);
831 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET, val);
832 } else if (port->dev->slice_id == VIP_SLICE2) {
833 insert_field(&val, mode, VIP_DATA_INTERFACE_MODE_MASK,
834 VIP_DATA_INTERFACE_MODE_SHFT);
836 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET, val);
837 }
838 }
840 static void vip_reset_port(struct vip_port *port)
841 {
842 u32 val = 0;
844 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
845 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
846 VIP_PARSER_PORTA_0, VIP_SW_RESET);
848 usleep_range(200, 250);
850 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
851 VIP_PARSER_PORTA_0);
853 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
854 VIP_PARSER_PORTA_0, 0);
855 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
856 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
857 VIP_PARSER_PORTA_0, VIP_SW_RESET);
859 usleep_range(200, 250);
861 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
862 VIP_PARSER_PORTA_0);
864 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
865 VIP_PARSER_PORTA_0, 0);
867 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
868 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
869 VIP_PARSER_PORTB_0, VIP_SW_RESET);
871 usleep_range(200, 250);
873 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
874 VIP_PARSER_PORTB_0);
876 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
877 VIP_PARSER_PORTB_0, 0);
878 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
879 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
880 VIP_PARSER_PORTB_0, VIP_SW_RESET);
882 usleep_range(200, 250);
884 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
885 VIP_PARSER_PORTB_0);
887 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
888 VIP_PARSER_PORTB_0, 0);
889 }
890 }
892 static void vip_set_port_enable(struct vip_port *port, bool on)
893 {
894 u32 val = 0;
896 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
897 if (on)
898 val |= VIP_PORT_ENABLE;
899 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
900 VIP_PARSER_PORTA_0, val);
901 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
902 if (on)
903 val |= VIP_PORT_ENABLE;
904 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
905 VIP_PARSER_PORTA_0, val);
906 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
907 if (on)
908 val |= VIP_PORT_ENABLE;
909 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
910 VIP_PARSER_PORTB_0, val);
911 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
912 if (on)
913 val |= VIP_PORT_ENABLE;
914 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
915 VIP_PARSER_PORTB_0, val);
916 }
917 }
919 static void vip_set_slice_path(struct vip_dev *dev,
920 enum data_path_select data_path)
921 {
922 u32 val = 0;
924 switch (data_path) {
925 case VIP_MULTI_CHANNEL_DATA_SELECT:
926 if (dev->slice_id == VIP_SLICE1) {
927 val |= VIP_MULTI_CHANNEL_SELECT;
928 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
929 VIP_DATAPATH_SELECT_SHFT);
931 write_vreg(dev, VIP_VIP1_DATA_PATH_SELECT, val);
932 } else if (dev->slice_id == VIP_SLICE2) {
933 val |= VIP_MULTI_CHANNEL_SELECT;
934 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
935 VIP_DATAPATH_SELECT_SHFT);
937 write_vreg(dev, VIP_VIP2_DATA_PATH_SELECT, val);
938 }
939 break;
940 case VIP_RGB_OUT_LO_DATA_SELECT:
941 if (dev->slice_id == VIP_SLICE1) {
942 val |= VIP_RGB_OUT_LO_SRC_SELECT;
943 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
944 VIP_DATAPATH_SELECT_SHFT);
946 write_vreg(dev, VIP_VIP1_DATA_PATH_SELECT, val);
947 } else if (dev->slice_id == VIP_SLICE2) {
948 val |= VIP_RGB_OUT_LO_SRC_SELECT;
949 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
950 VIP_DATAPATH_SELECT_SHFT);
952 write_vreg(dev, VIP_VIP2_DATA_PATH_SELECT, val);
953 }
954 break;
955 default:
956 BUG();
957 }
958 }
960 /*
961 * Return the vip_stream structure for a given struct file
962 */
963 static inline struct vip_stream *file2stream(struct file *file)
964 {
965 return video_drvdata(file);
967 }
969 /*
970 * Append a destination descriptor to the current descriptor list,
971 * setting up dma to the given srce.
972 */
973 static int add_out_dtd(struct vip_stream *stream, int srce_type)
974 {
975 struct vip_port *port = stream->port;
976 struct vip_dev *dev = port->dev;
977 struct vip_srce_info *sinfo = &srce_info[srce_type];
978 struct v4l2_rect *c_rect = &port->c_rect;
979 struct vip_fmt *fmt = port->fmt;
980 int channel, plane = 0;
981 int max_width, max_height;
982 dma_addr_t dma_addr;
983 u32 flags;
985 channel = sinfo->base_channel;
987 switch (srce_type) {
988 case VIP_SRCE_MULT_PORT:
989 case VIP_SRCE_MULT_ANC:
990 if (port->port_id == VIP_PORTB)
991 channel += VIP_CHAN_MULT_PORTB_OFFSET;
992 channel += stream->stream_id;
993 flags = 0;
994 break;
995 case VIP_SRCE_CHROMA:
996 plane = 1;
997 case VIP_SRCE_LUMA:
998 if (port->port_id == VIP_PORTB)
999 channel += VIP_CHAN_YUV_PORTB_OFFSET;
1000 flags = port->flags;
1001 break;
1002 case VIP_SRCE_RGB:
1003 if (port->port_id == VIP_PORTB)
1004 channel += VIP_CHAN_RGB_PORTB_OFFSET;
1005 flags = port->flags;
1006 break;
1007 default:
1008 BUG();
1009 }
1011 if (dev->slice_id == VIP_SLICE2)
1012 channel += VIP_CHAN_VIP2_OFFSET;
1014 /* This is just for initialization purposes.
1015 * The actual dma_addr will be configured in vpdma_update_dma_addr
1016 */
1017 dma_addr = (dma_addr_t)NULL;
1019 /*
1020 * Use VPDMA_MAX_SIZE1 or VPDMA_MAX_SIZE2 register for slice0/1
1021 */
1023 if (dev->slice_id == VIP_SLICE1) {
1024 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE1,
1025 stream->width, stream->height);
1027 max_width = MAX_OUT_WIDTH_REG1;
1028 max_height = MAX_OUT_HEIGHT_REG1;
1029 } else {
1030 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE2,
1031 stream->width, stream->height);
1033 max_width = MAX_OUT_WIDTH_REG2;
1034 max_height = MAX_OUT_HEIGHT_REG2;
1035 }
1037 /* Mark this channel to be cleared while cleaning up resources
1038 * This will make sure that an abort descriptor for this channel
1039 * would be submitted to VPDMA causing any ongoing transaction to be
1040 * aborted and cleanup the VPDMA FSM for this channel */
1041 stream->vpdma_channels[channel] = 1;
1043 vpdma_rawchan_add_out_dtd(&stream->desc_list, c_rect->width, c_rect,
1044 fmt->vpdma_fmt[plane], dma_addr, max_width, max_height,
1045 channel, flags);
1047 return 0;
1048 }
1050 /*
1051 * add_stream_dtds - prepares and starts DMA for pending transfers
1052 */
1053 static void add_stream_dtds(struct vip_stream *stream)
1054 {
1055 struct vip_port *port = stream->port;
1056 int srce_type;
1058 if (port->flags & FLAG_MULT_PORT)
1059 srce_type = VIP_SRCE_MULT_PORT;
1060 else if (port->flags & FLAG_MULT_ANC)
1061 srce_type = VIP_SRCE_MULT_ANC;
1062 else if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
1063 srce_type = VIP_SRCE_RGB;
1064 else
1065 srce_type = VIP_SRCE_LUMA;
1067 add_out_dtd(stream, srce_type);
1069 if (srce_type == VIP_SRCE_LUMA && port->fmt->coplanar)
1070 add_out_dtd(stream, VIP_SRCE_CHROMA);
1071 }
1073 static void enable_irqs(struct vip_dev *dev, int irq_num, int list_num)
1074 {
1075 u32 reg_addr = VIP_INT0_ENABLE0_SET +
1076 VIP_INTC_INTX_OFFSET * irq_num;
1078 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1080 vpdma_enable_list_complete_irq(dev->shared->vpdma,
1081 irq_num, list_num, true);
1082 }
1084 static void disable_irqs(struct vip_dev *dev, int irq_num, int list_num)
1085 {
1086 u32 reg_addr = VIP_INT0_ENABLE0_CLR +
1087 VIP_INTC_INTX_OFFSET * irq_num;
1089 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1091 vpdma_enable_list_complete_irq(dev->shared->vpdma,
1092 irq_num, list_num, false);
1093 }
1095 static void clear_irqs(struct vip_dev *dev, int irq_num, int list_num)
1096 {
1097 u32 reg_addr = VIP_INT0_STATUS0_CLR +
1098 VIP_INTC_INTX_OFFSET * irq_num;
1100 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1102 vpdma_clear_list_stat(dev->shared->vpdma, irq_num, dev->slice_id);
1103 }
1105 static void populate_desc_list(struct vip_stream *stream)
1106 {
1107 struct vip_port *port = stream->port;
1108 struct vip_dev *dev = port->dev;
1109 unsigned int list_length;
1111 stream->desc_next = stream->desc_list.buf.addr;
1112 add_stream_dtds(stream);
1114 list_length = stream->desc_next - stream->desc_list.buf.addr;
1115 vpdma_map_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
1116 }
1118 /*
1119 * start_dma - adds descriptors to the dma list and submits them.
1120 * Should be called after a new vb is queued and on a vpdma list
1121 * completion interrupt.
1122 */
1123 static void start_dma(struct vip_stream *stream, struct vip_buffer *buf)
1124 {
1125 struct vip_dev *dev = stream->port->dev;
1126 struct vpdma_data *vpdma = dev->shared->vpdma;
1127 int list_num = stream->list_num;
1128 dma_addr_t dma_addr;
1129 int drop_data;
1131 if (vpdma_list_busy(vpdma, list_num)) {
1132 vip_err(dev, "vpdma list busy, cannot post");
1133 return; /* nothing to do */
1134 }
1136 if (buf) {
1137 dma_addr = vb2_dma_contig_plane_dma_addr(&buf->vb, 0);
1138 drop_data = 0;
1139 vip_dbg(4, dev, "start_dma: buf:0x%08x, vb:0x%08x, dma_addr:0x%08x\n",
1140 (unsigned int)buf, (unsigned int)&buf->vb, dma_addr);
1141 } else {
1142 dma_addr = (dma_addr_t)NULL;
1143 drop_data = 1;
1144 vip_dbg(4, dev, "start_dma: dropped\n");
1145 }
1147 vpdma_update_dma_addr(dev->shared->vpdma, &stream->desc_list,
1148 dma_addr, stream->write_desc, drop_data, 0);
1150 if (stream->port->fmt->coplanar) {
1151 dma_addr += stream->width * stream->height;
1152 vpdma_update_dma_addr(dev->shared->vpdma, &stream->desc_list,
1153 dma_addr, stream->write_desc + 1, drop_data, 1);
1154 }
1156 vpdma_submit_descs(dev->shared->vpdma,
1157 &stream->desc_list, stream->list_num);
1158 }
1160 static void vip_schedule_next_buffer(struct vip_stream *stream)
1161 {
1162 struct vip_dev *dev = stream->port->dev;
1163 struct vip_buffer *buf;
1164 unsigned long flags;
1166 spin_lock_irqsave(&dev->slock, flags);
1167 if (list_empty(&stream->vidq)) {
1168 vip_dbg(4, dev, "Dropping frame\n");
1169 if (list_empty(&stream->dropq)) {
1170 vip_err(dev, "No dropq buffer left!");
1171 spin_unlock_irqrestore(&dev->slock, flags);
1172 return;
1173 }
1174 buf = list_entry(stream->dropq.next,
1175 struct vip_buffer, list);
1177 buf->drop = true;
1178 list_move_tail(&buf->list, &stream->post_bufs);
1179 buf = NULL;
1180 } else if (vb2_is_streaming(&stream->vb_vidq)) {
1181 buf = list_entry(stream->vidq.next,
1182 struct vip_buffer, list);
1183 buf->drop = false;
1184 list_move_tail(&buf->list, &stream->post_bufs);
1185 vip_dbg(4, dev, "added next buffer\n");
1186 } else {
1187 vip_err(dev, "IRQ occurred when not streaming\n");
1188 if (list_empty(&stream->dropq)) {
1189 vip_err(dev, "No dropq buffer left!");
1190 spin_unlock_irqrestore(&dev->slock, flags);
1191 return;
1192 }
1193 buf = list_entry(stream->dropq.next,
1194 struct vip_buffer, list);
1195 buf->drop = true;
1196 list_move_tail(&buf->list, &stream->post_bufs);
1197 buf = NULL;
1198 }
1200 spin_unlock_irqrestore(&dev->slock, flags);
1201 start_dma(stream, buf);
1202 }
1204 static void vip_process_buffer_complete(struct vip_stream *stream)
1205 {
1206 struct vip_dev *dev = stream->port->dev;
1207 struct vip_buffer *buf;
1208 struct vb2_buffer *vb = NULL;
1209 unsigned long flags, fld;
1211 buf = list_first_entry(&stream->post_bufs, struct vip_buffer, list);
1213 if (stream->port->flags & FLAG_INTERLACED) {
1214 vpdma_unmap_desc_buf(dev->shared->vpdma,
1215 &stream->desc_list.buf);
1217 fld = dtd_get_field(stream->write_desc);
1218 stream->field = fld ? V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
1220 vpdma_map_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
1221 }
1223 if (buf) {
1224 vip_dbg(4, dev, "vip buffer complete 0x%x, 0x%x\n",
1225 (unsigned int)buf, buf->drop);
1227 vb = &buf->vb;
1228 vb->v4l2_buf.field = stream->field;
1229 vb->v4l2_buf.sequence = stream->sequence;
1230 v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
1232 if (buf->drop) {
1233 spin_lock_irqsave(&dev->slock, flags);
1234 list_move_tail(&buf->list, &stream->dropq);
1235 spin_unlock_irqrestore(&dev->slock, flags);
1236 } else {
1237 spin_lock_irqsave(&dev->slock, flags);
1238 list_del(&buf->list);
1239 spin_unlock_irqrestore(&dev->slock, flags);
1240 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
1241 }
1242 } else {
1243 BUG();
1244 }
1246 stream->sequence++;
1247 }
1249 static irqreturn_t vip_irq(int irq_vip, void *data)
1250 {
1251 struct vip_dev *dev = (struct vip_dev *)data;
1252 struct vpdma_data *vpdma = dev->shared->vpdma;
1253 struct vip_stream *stream;
1254 int list_num;
1255 int irq_num = dev->slice_id;
1256 u32 irqst, reg_addr;
1258 if (!dev->shared)
1259 return IRQ_HANDLED;
1261 reg_addr = VIP_INT0_STATUS0 +
1262 VIP_INTC_INTX_OFFSET * irq_num;
1263 irqst = read_sreg(dev->shared, reg_addr);
1265 vip_dbg(8, dev, "IRQ %d VIP_INT%d_STATUS0 0x%x\n",
1266 irq_vip, irq_num, irqst);
1267 if (irqst) {
1268 reg_addr = VIP_INT0_STATUS0_CLR +
1269 VIP_INTC_INTX_OFFSET * irq_num;
1270 write_sreg(dev->shared, reg_addr, irqst);
1272 for (list_num = 0; list_num < 8; list_num++) {
1273 /* Check for LIST_COMPLETE IRQ */
1274 if (!(irqst & (1 << list_num * 2)))
1275 continue;
1277 vip_dbg(8, dev, "IRQ %d: handling LIST%d_COMPLETE\n",
1278 irq_num, list_num);
1280 stream = vpdma_hwlist_get_priv(vpdma, list_num);
1281 if (!stream || stream->list_num != list_num) {
1282 vip_err(dev, "IRQ occured for unused list");
1283 continue;
1284 }
1286 vpdma_clear_list_stat(vpdma, irq_num, list_num);
1288 if (dev->num_skip_irq)
1289 dev->num_skip_irq--;
1290 else
1291 vip_process_buffer_complete(stream);
1293 vip_schedule_next_buffer(stream);
1294 irqst &= ~((1 << list_num * 2));
1295 }
1296 }
1298 return IRQ_HANDLED;
1299 }
1301 /*
1302 * video ioctls
1303 */
1304 static struct v4l2_mbus_framefmt *
1305 vip_video_pix_to_mbus(const struct v4l2_pix_format *pix,
1306 struct v4l2_mbus_framefmt *mbus)
1307 {
1308 unsigned int i;
1310 memset(mbus, 0, sizeof(*mbus));
1311 mbus->width = pix->width;
1312 mbus->height = pix->height;
1314 mbus->code = V4L2_MBUS_FMT_YUYV8_2X8;
1315 for (i = 0; i < ARRAY_SIZE(vip_formats) - 1; ++i) {
1316 if (vip_formats[i].fourcc == pix->pixelformat) {
1317 mbus->code = vip_formats[i].code;
1318 break;
1319 }
1320 }
1322 mbus->colorspace = pix->colorspace;
1323 mbus->field = pix->field;
1325 return mbus;
1326 }
1328 static int vip_querycap(struct file *file, void *priv,
1329 struct v4l2_capability *cap)
1330 {
1331 strncpy(cap->driver, VIP_MODULE_NAME, sizeof(cap->driver) - 1);
1332 strncpy(cap->card, VIP_MODULE_NAME, sizeof(cap->card) - 1);
1333 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1334 VIP_MODULE_NAME);
1335 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE;
1336 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1337 return 0;
1338 }
1340 static int vip_enuminput(struct file *file, void *priv,
1341 struct v4l2_input *inp)
1342 {
1343 struct vip_stream *stream = file2stream(file);
1345 if (inp->index)
1346 return -EINVAL;
1348 inp->type = V4L2_INPUT_TYPE_CAMERA;
1349 sprintf(inp->name, "camera %u", stream->vfd->num);
1351 return 0;
1352 }
1354 static int vip_g_input(struct file *file, void *priv, unsigned int *i)
1355 {
1356 *i = 0;
1357 return 0;
1358 }
1360 static int vip_s_input(struct file *file, void *priv, unsigned int i)
1361 {
1362 if (i != 0)
1363 return -EINVAL;
1364 return 0;
1365 }
1367 static int vip_querystd(struct file *file, void *fh, v4l2_std_id *std)
1368 {
1369 struct vip_stream *stream = file2stream(file);
1370 struct vip_dev *dev = stream->port->dev;
1372 v4l2_subdev_call(dev->sensor, video, querystd, std);
1373 return 0;
1374 }
1376 static int vip_g_std(struct file *file, void *fh, v4l2_std_id *std)
1377 {
1378 struct vip_stream *stream = file2stream(file);
1379 struct vip_dev *dev = stream->port->dev;
1381 *std = 0;
1382 v4l2_subdev_call(dev->sensor, video, g_std_output, std);
1383 return 0;
1384 }
1386 static int vip_s_std(struct file *file, void *fh, v4l2_std_id std)
1387 {
1388 struct vip_stream *stream = file2stream(file);
1389 struct vip_dev *dev = stream->port->dev;
1391 v4l2_subdev_call(dev->sensor, video, s_std_output, std);
1392 return 0;
1393 }
1395 static int vip_enum_fmt_vid_cap(struct file *file, void *priv,
1396 struct v4l2_fmtdesc *f)
1397 {
1398 struct vip_stream *stream = file2stream(file);
1399 struct vip_dev *dev = stream->port->dev;
1400 struct vip_fmt *fmt;
1402 vip_dbg(3, dev, "enum_fmt index:%d\n", f->index);
1403 if (f->index >= dev->num_active_fmt)
1404 return -EINVAL;
1406 fmt = dev->active_fmt[f->index];
1408 strncpy(f->description, fmt->name, sizeof(f->description) - 1);
1409 f->pixelformat = fmt->fourcc;
1411 vip_dbg(3, dev, "enum_fmt fourcc:%s description:%s\n",
1412 fourcc_to_str(f->pixelformat), f->description);
1414 return 0;
1415 }
1417 /*
1418 * TODO: Change from hard coding values to reading these through
1419 * IOCTLS directly from sensor
1420 */
1422 static int vip_enum_framesizes(struct file *file, void *priv,
1423 struct v4l2_frmsizeenum *f)
1424 {
1425 struct vip_stream *stream = file2stream(file);
1426 struct vip_dev *dev = stream->port->dev;
1427 struct vip_fmt *fmt;
1428 int ret;
1430 fmt = find_active_format_by_pix(dev, f->pixel_format);
1431 if (!fmt)
1432 return -EINVAL;
1434 ret = v4l2_subdev_call(dev->sensor, video, enum_framesizes, f);
1435 if (ret)
1436 vip_dbg(1, dev, "enum_framesizes failed in subdev\n");
1438 return ret;
1439 }
1441 static int vip_enum_frameintervals(struct file *file, void *priv,
1442 struct v4l2_frmivalenum *f)
1443 {
1444 struct vip_stream *stream = file2stream(file);
1445 struct vip_dev *dev = stream->port->dev;
1446 struct v4l2_frmsizeenum fsize;
1447 struct vip_fmt *fmt;
1448 int ret;
1450 if (f->index)
1451 return -EINVAL;
1453 fmt = find_active_format_by_pix(dev, f->pixel_format);
1454 if (!fmt)
1455 return -EINVAL;
1457 /* check for valid width/height */
1458 ret = 0;
1459 for (fsize.index = 0; ; fsize.index++) {
1460 ret = v4l2_subdev_call(dev->sensor, video,
1461 enum_framesizes, &fsize);
1462 if (ret) {
1463 if (fsize.index == 0)
1464 vip_dbg(1, dev, "enum_frameinterval failed on the first enum_framesize\n");
1465 return -EINVAL;
1466 }
1468 if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
1469 if ((f->width == fsize.discrete.width) &&
1470 (f->height == fsize.discrete.height))
1471 break;
1472 } else if ((fsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) ||
1473 (fsize.type == V4L2_FRMSIZE_TYPE_STEPWISE)) {
1474 if ((f->width >= fsize.stepwise.min_width) &&
1475 (f->width <= fsize.stepwise.max_width) &&
1476 (f->height >= fsize.stepwise.min_height) &&
1477 (f->height <= fsize.stepwise.max_height))
1478 break;
1479 } else
1480 return -EINVAL;
1481 }
1483 f->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1484 f->discrete.numerator = 1;
1485 f->discrete.denominator = 30;
1487 return 0;
1488 }
1490 static int vip_s_parm(struct file *file, void *priv,
1491 struct v4l2_streamparm *parm)
1492 {
1493 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1494 return -EINVAL;
1496 parm->parm.capture.timeperframe.numerator = 1;
1497 parm->parm.capture.timeperframe.denominator = 30;
1499 return 0;
1500 }
1502 static int vip_try_fmt_vid_cap(struct file *file, void *priv,
1503 struct v4l2_format *f)
1504 {
1505 struct vip_stream *stream = file2stream(file);
1506 struct vip_dev *dev = stream->port->dev;
1507 struct vip_fmt *fmt = find_active_format_by_pix(dev,
1508 f->fmt.pix.pixelformat);
1509 enum v4l2_field field;
1511 if (!fmt) {
1512 vip_err(dev,
1513 "Fourcc format (0x%08x) invalid.\n",
1514 f->fmt.pix.pixelformat);
1515 return -EINVAL;
1516 }
1518 field = f->fmt.pix.field;
1520 if (field == V4L2_FIELD_ANY)
1521 field = V4L2_FIELD_NONE;
1522 else if (V4L2_FIELD_NONE != field && V4L2_FIELD_ALTERNATE != field)
1523 return -EINVAL;
1525 f->fmt.pix.field = field;
1527 v4l_bound_align_image(&f->fmt.pix.width, MIN_W, MAX_W, W_ALIGN,
1528 &f->fmt.pix.height, MIN_H, MAX_H, H_ALIGN,
1529 S_ALIGN);
1531 f->fmt.pix.bytesperline = f->fmt.pix.width *
1532 (fmt->vpdma_fmt[0]->depth >> 3);
1533 f->fmt.pix.bytesperline = ALIGN(f->fmt.pix.bytesperline,
1534 VPDMA_STRIDE_ALIGN);
1535 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.width *
1536 (fmt->vpdma_fmt[0]->depth +
1537 (fmt->coplanar ? fmt->vpdma_fmt[1]->depth : 0)) >> 3;
1538 f->fmt.pix.colorspace = fmt->colorspace;
1539 f->fmt.pix.priv = 0;
1541 vip_dbg(3, dev, "try_fmt fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
1542 fourcc_to_str(f->fmt.pix.pixelformat),
1543 f->fmt.pix.width, f->fmt.pix.height,
1544 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1546 return 0;
1547 }
1549 static int vip_g_fmt_vid_cap(struct file *file, void *priv,
1550 struct v4l2_format *f)
1551 {
1552 struct vip_stream *stream = file2stream(file);
1553 struct vip_port *port = stream->port;
1554 struct vip_dev *dev = stream->port->dev;
1555 struct v4l2_mbus_framefmt mbus_fmt;
1556 struct vip_fmt *fmt;
1557 struct v4l2_format try_f;
1558 int ret;
1560 /* Use last known values or defaults */
1561 f->fmt.pix.width = stream->width;
1562 f->fmt.pix.height = stream->height;
1563 f->fmt.pix.pixelformat = port->fmt->fourcc;
1564 f->fmt.pix.field = stream->sup_field;
1565 f->fmt.pix.colorspace = port->fmt->colorspace;
1566 f->fmt.pix.bytesperline = stream->bytesperline;
1567 f->fmt.pix.sizeimage = stream->sizeimage;
1569 /* Check with the subdevice */
1570 ret = v4l2_subdev_call(dev->sensor, video, g_mbus_fmt, &mbus_fmt);
1571 if (ret)
1572 vip_dbg(1, dev, "g_mbus_fmt failed in subdev\n");
1574 fmt = find_active_format_by_code(dev, mbus_fmt.code);
1575 if (!fmt) {
1576 vip_err(dev,
1577 "mbus_code (0x%08x) invalid.\n",
1578 mbus_fmt.code);
1579 return -EINVAL;
1580 }
1582 vip_dbg(3, dev, "g_fmt subdev mbus_code: %04X fourcc:%s size: %dx%d\n",
1583 fmt->code,
1584 fourcc_to_str(fmt->fourcc),
1585 mbus_fmt.width, mbus_fmt.height);
1587 /*
1588 * Run a try_fmt call to properly calculate
1589 * the sizeimage and bytesperline values
1590 * in case the defaults were not accurate.
1591 */
1592 try_f = *f;
1593 try_f.fmt.pix.pixelformat = fmt->fourcc;
1594 try_f.fmt.pix.width = mbus_fmt.width;
1595 try_f.fmt.pix.height = mbus_fmt.height;
1596 try_f.fmt.pix.field = mbus_fmt.field;
1597 try_f.fmt.pix.colorspace = mbus_fmt.colorspace;
1599 ret = vip_try_fmt_vid_cap(file, priv, &try_f);
1600 if (ret)
1601 return ret;
1603 if (port->fmt != fmt) {
1604 vip_dbg(1, dev, "g_fmt fmt mismatch port->fmt:%p fmt:%p\n",
1605 port->fmt, fmt);
1606 vip_dbg(1, dev, "g_fmt port->fmt->fourcc:%s\n",
1607 fourcc_to_str(port->fmt->fourcc));
1608 vip_dbg(1, dev, "fmt->fourcc:%s\n",
1609 fourcc_to_str(fmt->fourcc));
1610 vip_dbg(1, dev, "g_fmt port->fmt->name:%s fmt->name:%s\n",
1611 port->fmt->name, fmt->name);
1612 port->fmt = fmt;
1613 }
1614 /*
1615 * Since everything looks correct update
1616 * the local copy as well to make sure we are consistent
1617 */
1618 *f = try_f;
1619 stream->width = f->fmt.pix.width;
1620 stream->height = f->fmt.pix.height;
1621 stream->sup_field = f->fmt.pix.field;
1622 if (stream->sup_field == V4L2_FIELD_ALTERNATE)
1623 port->flags |= FLAG_INTERLACED;
1624 else
1625 port->flags &= ~FLAG_INTERLACED;
1626 stream->bytesperline = f->fmt.pix.bytesperline;
1627 stream->sizeimage = f->fmt.pix.sizeimage;
1628 port->c_rect.left = 0;
1629 port->c_rect.top = 0;
1630 port->c_rect.width = stream->width;
1631 port->c_rect.height = stream->height;
1633 vip_dbg(3, dev, "g_fmt fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
1634 fourcc_to_str(f->fmt.pix.pixelformat),
1635 f->fmt.pix.width, f->fmt.pix.height,
1636 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1637 vip_dbg(3, dev, "g_fmt vpdma data type: 0x%02X\n",
1638 port->fmt->vpdma_fmt[0]->data_type);
1640 return 0;
1641 }
1643 /*
1644 * Set the registers that are modified when the video format changes.
1645 */
1646 static void set_fmt_params(struct vip_stream *stream)
1647 {
1648 struct vip_dev *dev = stream->port->dev;
1649 int data_path_reg;
1651 stream->sequence = 0;
1652 stream->field = V4L2_FIELD_TOP;
1654 if (stream->port->fmt->colorspace == V4L2_COLORSPACE_SRGB) {
1655 vip_set_slice_path(dev, VIP_RGB_OUT_LO_DATA_SELECT);
1656 /* Set alpha component in background color */
1657 vpdma_set_bg_color(dev->shared->vpdma,
1658 (struct vpdma_data_format *)
1659 stream->port->fmt->vpdma_fmt[0],
1660 0xff);
1661 }
1663 data_path_reg = VIP_VIP1_DATA_PATH_SELECT + 4 * dev->slice_id;
1664 if (stream->port->fmt->coplanar) {
1665 stream->port->flags &= ~FLAG_MULT_PORT;
1666 write_vreg(dev, data_path_reg, 0x600);
1667 } else {
1668 stream->port->flags |= FLAG_MULT_PORT;
1669 write_vreg(dev, data_path_reg, 0x8000);
1670 }
1671 }
1673 int vip_s_fmt_vid_cap(struct file *file, void *priv,
1674 struct v4l2_format *f)
1675 {
1676 struct vip_stream *stream = file2stream(file);
1677 struct vip_port *port = stream->port;
1678 struct vip_dev *dev = port->dev;
1679 struct v4l2_subdev_format sfmt;
1680 struct v4l2_mbus_framefmt *mf;
1681 int ret;
1683 vip_dbg(3, dev, "s_fmt input fourcc:%s size: %dx%d\n",
1684 fourcc_to_str(f->fmt.pix.pixelformat),
1685 f->fmt.pix.width, f->fmt.pix.height);
1687 ret = vip_try_fmt_vid_cap(file, priv, f);
1688 if (ret)
1689 return ret;
1691 vip_dbg(3, dev, "s_fmt try_fmt fourcc:%s size: %dx%d\n",
1692 fourcc_to_str(f->fmt.pix.pixelformat),
1693 f->fmt.pix.width, f->fmt.pix.height);
1695 if (vb2_is_busy(&stream->vb_vidq)) {
1696 vip_err(dev, "%s queue busy\n", __func__);
1697 return -EBUSY;
1698 }
1700 port->fmt = find_active_format_by_pix(dev,
1701 f->fmt.pix.pixelformat);
1702 stream->width = f->fmt.pix.width;
1703 stream->height = f->fmt.pix.height;
1704 if (port->fmt->colorspace != f->fmt.pix.colorspace)
1705 vip_dbg(1, dev, "s_fmt colorspace mismatch port->fmt %d f->fmt %d\n",
1706 port->fmt->colorspace, f->fmt.pix.colorspace);
1708 stream->bytesperline = f->fmt.pix.bytesperline;
1709 stream->sizeimage = f->fmt.pix.sizeimage;
1710 stream->sup_field = f->fmt.pix.field;
1712 port->c_rect.left = 0;
1713 port->c_rect.top = 0;
1714 port->c_rect.width = stream->width;
1715 port->c_rect.height = stream->height;
1717 if (stream->sup_field == V4L2_FIELD_ALTERNATE)
1718 port->flags |= FLAG_INTERLACED;
1719 else
1720 port->flags &= ~FLAG_INTERLACED;
1722 vip_dbg(1, dev,
1723 "Setting format for type %d, wxh: %dx%d, fourcc:%s\n",
1724 f->type, stream->width, stream->height,
1725 fourcc_to_str(port->fmt->fourcc));
1727 vip_dbg(3, dev, "s_fmt fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
1728 fourcc_to_str(f->fmt.pix.pixelformat),
1729 f->fmt.pix.width, f->fmt.pix.height,
1730 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1732 mf = vip_video_pix_to_mbus(&f->fmt.pix, &sfmt.format);
1734 vip_dbg(3, dev, "s_fmt pix_to_mbus mbus_code: %04X size: %dx%d\n",
1735 mf->code,
1736 mf->width, mf->height);
1738 ret = v4l2_subdev_call(dev->sensor, video, try_mbus_fmt, mf);
1739 if (ret) {
1740 vip_dbg(1, dev, "try_mbus_fmt failed in subdev\n");
1741 return ret;
1742 }
1743 vip_dbg(3, dev, "s_fmt subdev try_fmt mbus_code: %04X size: %dx%d\n",
1744 mf->code,
1745 mf->width, mf->height);
1746 ret = v4l2_subdev_call(dev->sensor, video, s_mbus_fmt, mf);
1747 if (ret) {
1748 vip_dbg(1, dev, "s_mbus_fmt failed in subdev\n");
1749 return ret;
1750 }
1751 vip_dbg(3, dev, "s_fmt subdev s_fmt mbus_code: %04X size: %dx%d\n",
1752 mf->code,
1753 mf->width, mf->height);
1754 vip_dbg(3, dev, "s_fmt vpdma data type: 0x%02X\n",
1755 port->fmt->vpdma_fmt[0]->data_type);
1757 return 0;
1758 }
1759 EXPORT_SYMBOL(vip_s_fmt_vid_cap);
1761 static int vip_g_selection(struct file *file, void *fh,
1762 struct v4l2_selection *s)
1763 {
1764 struct vip_stream *stream = file2stream(file);
1766 switch (s->target) {
1767 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1768 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1769 case V4L2_SEL_TGT_CROP_BOUNDS:
1770 case V4L2_SEL_TGT_CROP_DEFAULT:
1771 s->r.left = 0;
1772 s->r.top = 0;
1773 s->r.width = stream->width;
1774 s->r.height = stream->height;
1775 return 0;
1777 case V4L2_SEL_TGT_COMPOSE:
1778 case V4L2_SEL_TGT_CROP:
1779 s->r = stream->port->c_rect;
1780 return 0;
1781 }
1783 return -EINVAL;
1784 }
1786 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1787 {
1788 if (a->left < b->left || a->top < b->top)
1789 return 0;
1790 if (a->left + a->width > b->left + b->width)
1791 return 0;
1792 if (a->top + a->height > b->top + b->height)
1793 return 0;
1795 return 1;
1796 }
1798 static int vip_s_selection(struct file *file, void *fh,
1799 struct v4l2_selection *s)
1800 {
1801 struct vip_stream *stream = file2stream(file);
1802 struct vip_port *port = stream->port;
1803 struct v4l2_rect r = s->r;
1805 v4l_bound_align_image(&r.width, 0, stream->width, 0,
1806 &r.height, 0, stream->height, 0, 0);
1808 r.left = clamp_t(unsigned int, r.left, 0, stream->width - r.width);
1809 r.top = clamp_t(unsigned int, r.top, 0, stream->height - r.height);
1811 if (s->flags & V4L2_SEL_FLAG_LE && !enclosed_rectangle(&r, &s->r))
1812 return -ERANGE;
1814 if (s->flags & V4L2_SEL_FLAG_GE && !enclosed_rectangle(&s->r, &r))
1815 return -ERANGE;
1817 s->r = stream->port->c_rect = r;
1819 set_fmt_params(stream);
1821 vip_dbg(1, port->dev, "cropped (%d,%d)/%dx%d of %dx%d\n",
1822 r.left, r.top, r.width, r.height,
1823 stream->width, stream->height);
1825 return 0;
1826 }
1828 static long vip_ioctl_default(struct file *file, void *fh, bool valid_prio,
1829 unsigned int cmd, void *arg)
1830 {
1831 struct vip_stream *stream = file2stream(file);
1832 struct vip_port *port = stream->port;
1834 if (!valid_prio) {
1835 vip_err(port->dev, "%s device busy\n", __func__);
1836 return -EBUSY;
1837 }
1839 switch (cmd) {
1840 default:
1841 return -ENOTTY;
1842 }
1843 }
1845 static const struct v4l2_ioctl_ops vip_ioctl_ops = {
1846 .vidioc_querycap = vip_querycap,
1847 .vidioc_enum_input = vip_enuminput,
1848 .vidioc_g_input = vip_g_input,
1849 .vidioc_s_input = vip_s_input,
1851 .vidioc_querystd = vip_querystd,
1852 .vidioc_g_std = vip_g_std,
1853 .vidioc_s_std = vip_s_std,
1855 .vidioc_enum_fmt_vid_cap = vip_enum_fmt_vid_cap,
1856 .vidioc_g_fmt_vid_cap = vip_g_fmt_vid_cap,
1857 .vidioc_try_fmt_vid_cap = vip_try_fmt_vid_cap,
1858 .vidioc_s_fmt_vid_cap = vip_s_fmt_vid_cap,
1860 .vidioc_enum_frameintervals = vip_enum_frameintervals,
1861 .vidioc_enum_framesizes = vip_enum_framesizes,
1862 .vidioc_s_parm = vip_s_parm,
1864 .vidioc_g_selection = vip_g_selection,
1865 .vidioc_s_selection = vip_s_selection,
1866 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1867 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1868 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1869 .vidioc_querybuf = vb2_ioctl_querybuf,
1870 .vidioc_qbuf = vb2_ioctl_qbuf,
1871 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1873 .vidioc_streamon = vb2_ioctl_streamon,
1874 .vidioc_streamoff = vb2_ioctl_streamoff,
1875 .vidioc_log_status = v4l2_ctrl_log_status,
1876 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1877 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1878 .vidioc_default = vip_ioctl_default,
1879 };
1881 /*
1882 * Videobuf operations
1883 */
1884 static int vip_queue_setup(struct vb2_queue *vq,
1885 const struct v4l2_format *fmt,
1886 unsigned int *nbuffers, unsigned int *nplanes,
1887 unsigned int sizes[], void *alloc_ctxs[])
1888 {
1889 struct vip_stream *stream = vb2_get_drv_priv(vq);
1890 struct vip_dev *dev = stream->port->dev;
1892 *nplanes = 1;
1893 sizes[0] = stream->sizeimage;
1894 alloc_ctxs[0] = dev->alloc_ctx;
1895 vip_dbg(1, dev, "get %d buffer(s) of size %d each.\n",
1896 *nbuffers, sizes[0]);
1898 return 0;
1899 }
1901 static int vip_buf_prepare(struct vb2_buffer *vb)
1902 {
1903 struct vip_stream *stream = vb2_get_drv_priv(vb->vb2_queue);
1904 struct vip_dev *dev = stream->port->dev;
1906 if (vb2_plane_size(vb, 0) < stream->sizeimage) {
1907 vip_dbg(1, dev,
1908 "%s data will not fit into plane (%lu < %lu)\n",
1909 __func__, vb2_plane_size(vb, 0),
1910 (long)stream->sizeimage);
1911 return -EINVAL;
1912 }
1914 vb2_set_plane_payload(vb, 0, stream->sizeimage);
1916 return 0;
1917 }
1919 static void vip_buf_queue(struct vb2_buffer *vb)
1920 {
1921 struct vip_stream *stream = vb2_get_drv_priv(vb->vb2_queue);
1922 struct vip_dev *dev = stream->port->dev;
1923 struct vip_buffer *buf = container_of(vb, struct vip_buffer, vb);
1924 unsigned long flags;
1926 spin_lock_irqsave(&dev->slock, flags);
1927 list_add_tail(&buf->list, &stream->vidq);
1928 spin_unlock_irqrestore(&dev->slock, flags);
1929 }
1931 static int vip_start_streaming(struct vb2_queue *vq, unsigned int count)
1932 {
1933 struct vip_stream *stream = vb2_get_drv_priv(vq);
1934 struct vip_port *port = stream->port;
1935 struct vip_dev *dev = port->dev;
1936 struct vip_buffer *buf;
1937 unsigned long flags;
1938 int ret;
1940 set_fmt_params(stream);
1941 vip_setup_parser(dev->ports[0]);
1943 buf = list_entry(stream->vidq.next,
1944 struct vip_buffer, list);
1946 vip_dbg(2, dev, "start_streaming: buf 0x%x %d\n",
1947 (unsigned int)buf, count);
1948 buf->drop = false;
1949 stream->sequence = 0;
1950 stream->field = V4L2_FIELD_TOP;
1952 if (dev->sensor) {
1953 ret = v4l2_subdev_call(dev->sensor, video, s_stream, 1);
1954 if (ret) {
1955 vip_dbg(1, dev, "stream on failed in subdev\n");
1956 return ret;
1957 }
1958 }
1960 populate_desc_list(stream);
1962 /* The first few VPDMA ListComplete interrupts fire pretty quiclky
1963 * until the internal VPDMA descriptor fifo is full.
1964 * The subsequent ListComplete interrupts will fire at the actual
1965 * capture frame rate. The first few interrupts are therefore used
1966 * only to queue up descriptors, and then they will also be used
1967 * as End of Frame (EOF) event
1968 */
1969 dev->num_skip_irq = VIP_VPDMA_FIFO_SIZE;
1971 spin_lock_irqsave(&dev->slock, flags);
1972 if (vpdma_list_busy(dev->shared->vpdma, stream->list_num)) {
1973 spin_unlock_irqrestore(&dev->slock, flags);
1974 vpdma_unmap_desc_buf(dev->shared->vpdma,
1975 &stream->desc_list.buf);
1976 vpdma_reset_desc_list(&stream->desc_list);
1977 return -EBUSY;
1978 }
1980 list_move_tail(&buf->list, &stream->post_bufs);
1981 spin_unlock_irqrestore(&dev->slock, flags);
1983 vip_dbg(2, dev, "start_streaming: start_dma buf 0x%x\n",
1984 (unsigned int)buf);
1985 start_dma(stream, buf);
1987 /* We enable the irq after posting the vpdma descriptor
1988 * to prevent sprurious interrupt coming in before the
1989 * vb2 layer is completely ready to handle them
1990 * otherwise the vb2_streaming test would fail early on
1991 */
1992 enable_irqs(dev, dev->slice_id, stream->list_num);
1994 return 0;
1995 }
1997 /*
1998 * Abort streaming and wait for last buffer
1999 */
2000 static int vip_stop_streaming(struct vb2_queue *vq)
2001 {
2002 struct vip_stream *stream = vb2_get_drv_priv(vq);
2003 struct vip_port *port = stream->port;
2004 struct vip_dev *dev = port->dev;
2005 struct vip_buffer *buf;
2006 int ret;
2008 if (dev->sensor) {
2009 ret = v4l2_subdev_call(dev->sensor, video, s_stream, 0);
2010 if (ret)
2011 vip_dbg(1, dev, "stream on failed in subdev\n");
2012 }
2014 disable_irqs(dev, dev->slice_id, stream->list_num);
2015 clear_irqs(dev, dev->slice_id, stream->list_num);
2016 stop_dma(stream);
2018 /* release all active buffers */
2019 while (!list_empty(&stream->post_bufs)) {
2020 buf = list_entry(stream->post_bufs.next,
2021 struct vip_buffer, list);
2022 list_del(&buf->list);
2023 if (buf->drop == 1)
2024 list_add_tail(&buf->list, &stream->dropq);
2025 else
2026 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
2027 }
2028 while (!list_empty(&stream->vidq)) {
2029 buf = list_entry(stream->vidq.next, struct vip_buffer, list);
2030 list_del(&buf->list);
2031 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
2032 }
2034 if (!vb2_is_streaming(vq))
2035 return 0;
2037 vpdma_unmap_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
2038 vpdma_reset_desc_list(&stream->desc_list);
2040 return 0;
2041 }
2043 /*
2044 * Lock access to the device
2045 */
2046 static void vip_lock(struct vb2_queue *vq)
2047 {
2048 struct vip_stream *stream = vb2_get_drv_priv(vq);
2050 mutex_lock(&stream->port->dev->mutex);
2051 }
2053 static void vip_unlock(struct vb2_queue *vq)
2054 {
2055 struct vip_stream *stream = vb2_get_drv_priv(vq);
2056 mutex_unlock(&stream->port->dev->mutex);
2057 }
2059 static struct vb2_ops vip_video_qops = {
2060 .queue_setup = vip_queue_setup,
2061 .buf_prepare = vip_buf_prepare,
2062 .buf_queue = vip_buf_queue,
2063 .start_streaming = vip_start_streaming,
2064 .stop_streaming = vip_stop_streaming,
2065 .wait_prepare = vip_unlock,
2066 .wait_finish = vip_lock,
2067 };
2069 /*
2070 * File operations
2071 */
2073 static int vip_init_dev(struct vip_dev *dev)
2074 {
2075 if (dev->num_ports != 0)
2076 goto done;
2078 vip_set_clock_enable(dev, 1);
2079 done:
2080 dev->num_ports++;
2082 return 0;
2083 }
2085 static int vip_init_port(struct vip_port *port)
2086 {
2087 int ret;
2089 if (port->num_streams != 0)
2090 goto done;
2092 ret = vip_init_dev(port->dev);
2093 if (ret)
2094 goto done;
2096 port->fmt = port->dev->active_fmt[0];
2097 port->src_colorspace = port->fmt->colorspace;
2098 port->c_rect.left = 0;
2099 port->c_rect.top = 0;
2101 done:
2102 port->num_streams++;
2103 return 0;
2104 }
2106 static int vip_init_stream(struct vip_stream *stream)
2107 {
2108 int ret;
2110 ret = vip_init_port(stream->port);
2111 if (ret != 0)
2112 return ret;
2114 ret = vpdma_create_desc_list(&stream->desc_list, VIP_DESC_LIST_SIZE,
2115 VPDMA_LIST_TYPE_NORMAL);
2117 if (ret != 0)
2118 return ret;
2120 stream->write_desc = (struct vpdma_dtd *)stream->desc_list.buf.addr
2121 + 15;
2122 return 0;
2123 }
2125 static void vip_release_dev(struct vip_dev *dev)
2126 {
2127 /*
2128 * On last close, disable clocks to conserve power
2129 */
2131 if (--dev->num_ports == 0)
2132 vip_set_clock_enable(dev, 0);
2133 }
2135 static int vip_setup_parser(struct vip_port *port)
2136 {
2137 struct vip_dev *dev = port->dev;
2138 struct v4l2_of_endpoint *endpoint = dev->endpoint;
2139 int iface = DUAL_8B_INTERFACE;
2140 int sync_type, pclk_type;
2141 unsigned int flags;
2143 flags = endpoint->bus.parallel.flags;
2144 vip_reset_port(port);
2145 vip_set_port_enable(port, 1);
2147 if (endpoint->bus_type == V4L2_MBUS_BT656) {
2148 iface = DUAL_8B_INTERFACE;
2150 /* Ideally, this should come from sensor
2151 port->fmt can be anything once CSC is enabled */
2152 if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
2153 sync_type = EMBEDDED_SYNC_SINGLE_RGB_OR_YUV444;
2154 else {
2155 switch (endpoint->bus.parallel.num_channels) {
2156 case 4:
2157 sync_type = EMBEDDED_SYNC_4X_MULTIPLEXED_YUV422;
2158 break;
2159 case 2:
2160 sync_type = EMBEDDED_SYNC_2X_MULTIPLEXED_YUV422;
2161 break;
2162 case 1:
2163 default:
2164 sync_type =
2165 EMBEDDED_SYNC_LINE_MULTIPLEXED_YUV422;
2166 }
2167 }
2169 } else if (endpoint->bus_type == V4L2_MBUS_PARALLEL) {
2170 switch (endpoint->bus.parallel.bus_width) {
2171 case 24:
2172 iface = SINGLE_24B_INTERFACE;
2173 break;
2174 case 16:
2175 iface = SINGLE_16B_INTERFACE;
2176 break;
2177 case 8:
2178 default:
2179 iface = DUAL_8B_INTERFACE;
2180 }
2182 if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
2183 sync_type = DISCRETE_SYNC_SINGLE_RGB_24B;
2184 else
2185 sync_type = DISCRETE_SYNC_SINGLE_YUV422;
2187 if (flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH |
2188 V4L2_MBUS_HSYNC_ACTIVE_LOW))
2189 vip_set_vsync_polarity(port,
2190 flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH ? 1 : 0);
2192 if (flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH |
2193 V4L2_MBUS_VSYNC_ACTIVE_LOW))
2194 vip_set_hsync_polarity(port,
2195 flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH ? 1 : 0);
2197 vip_xtra_set_repack_sel(port, 0);
2198 vip_set_actvid_hsync_n(port, 0);
2199 vip_set_actvid_polarity(port, 1);
2200 vip_set_discrete_basic_mode(port);
2202 } else {
2203 vip_err(dev, "Device doesn't support CSI2");
2204 return -EINVAL;
2205 }
2207 pclk_type = flags & V4L2_MBUS_PCLK_SAMPLE_RISING ? 0 : 1;
2208 vip_set_pclk_polarity(port, pclk_type);
2209 vip_set_data_interface(port, iface);
2210 vip_sync_type(port, sync_type);
2211 return 0;
2212 }
2214 static void vip_release_stream(struct vip_stream *stream)
2215 {
2216 struct vip_dev *dev = stream->port->dev;
2218 vpdma_unmap_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
2219 vpdma_free_desc_buf(&stream->desc_list.buf);
2220 vpdma_free_desc_list(&stream->desc_list);
2221 }
2223 static void stop_dma(struct vip_stream *stream)
2224 {
2225 struct vip_dev *dev = stream->port->dev;
2226 int ch, size = 0;
2228 /* Create a list of channels to be cleared */
2229 for (ch = 0; ch < VPDMA_MAX_CHANNELS; ch++) {
2230 if (stream->vpdma_channels[ch] == 1) {
2231 stream->vpdma_channels[size++] = ch;
2232 vip_dbg(2, dev, "Clear channel no: %d\n", ch);
2233 }
2234 }
2236 /* Clear all the used channels for the list */
2237 vpdma_list_cleanup(dev->shared->vpdma, stream->list_num,
2238 stream->vpdma_channels, size);
2240 for (ch = 0; ch < VPDMA_MAX_CHANNELS; ch++)
2241 stream->vpdma_channels[ch] = 0;
2242 }
2244 int vip_open(struct file *file)
2245 {
2246 struct vip_stream *stream = video_drvdata(file);
2247 struct vip_port *port = stream->port;
2248 struct vip_dev *dev = port->dev;
2249 struct v4l2_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
2250 int ret = 0;
2252 vip_dbg(2, dev, "vip_open\n");
2254 file->private_data = fh;
2255 if (fh == NULL)
2256 return -ENOMEM;
2258 mutex_lock(&dev->mutex);
2260 v4l2_fh_init(fh, video_devdata(file));
2261 v4l2_fh_add(fh);
2263 /*
2264 * If this is the first open file.
2265 * Then initialize hw module.
2266 */
2267 if (v4l2_fh_is_singular_file(file)) {
2268 if (vip_init_stream(stream)) {
2269 goto free_fh;
2270 ret = -ENODEV;
2271 }
2272 stream->width = 1280;
2273 stream->height = 720;
2274 stream->sizeimage = stream->width * stream->height *
2275 (port->fmt->vpdma_fmt[0]->depth +
2276 (port->fmt->coplanar ?
2277 port->fmt->vpdma_fmt[1]->depth : 0)) >> 3;
2278 stream->bytesperline = round_up((stream->width *
2279 port->fmt->vpdma_fmt[0]->depth) >> 3,
2280 1 << L_ALIGN);
2281 stream->sup_field = V4L2_FIELD_NONE;
2282 port->c_rect.width = stream->width;
2283 port->c_rect.height = stream->height;
2284 vip_dbg(1, dev, "Created stream instance %p\n", stream);
2285 }
2287 mutex_unlock(&dev->mutex);
2288 return 0;
2290 free_fh:
2291 mutex_unlock(&dev->mutex);
2292 if (fh) {
2293 v4l2_fh_del(fh);
2294 v4l2_fh_exit(fh);
2295 kfree(fh);
2296 }
2297 return ret;
2298 }
2299 EXPORT_SYMBOL(vip_open);
2301 int vip_release(struct file *file)
2302 {
2303 struct vip_stream *stream = video_drvdata(file);
2304 struct vip_port *port = stream->port;
2305 struct vip_dev *dev = port->dev;
2306 struct vb2_queue *q = &stream->vb_vidq;
2308 vip_dbg(2, dev, "vip_release\n");
2310 /*
2311 * If this is the last open file.
2312 * Then de-initialize hw module.
2313 */
2314 if (v4l2_fh_is_singular_file(file)) {
2315 mutex_lock(&dev->mutex);
2317 vip_stop_streaming(q);
2318 vip_release_stream(stream);
2320 if (--port->num_streams == 0)
2321 vip_release_dev(port->dev);
2323 mutex_unlock(&dev->mutex);
2324 vip_dbg(1, dev, "Releasing stream instance %p\n", stream);
2325 }
2327 return vb2_fop_release(file);
2328 }
2329 EXPORT_SYMBOL(vip_release);
2331 static const struct v4l2_file_operations vip_fops = {
2332 .owner = THIS_MODULE,
2333 .open = vip_open,
2334 .release = vip_release,
2335 .poll = vb2_fop_poll,
2336 .unlocked_ioctl = video_ioctl2,
2337 .mmap = vb2_fop_mmap,
2338 };
2340 static struct video_device vip_videodev = {
2341 .name = VIP_MODULE_NAME,
2342 .fops = &vip_fops,
2343 .ioctl_ops = &vip_ioctl_ops,
2344 .minor = -1,
2345 .release = video_device_release,
2346 };
2348 static int alloc_stream(struct vip_port *port, int stream_id, int vfl_type)
2349 {
2350 struct vip_stream *stream;
2351 struct vip_dev *dev = port->dev;
2352 struct vb2_queue *q;
2353 struct video_device *vfd;
2354 struct vip_buffer *buf;
2355 int ret, i;
2357 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
2358 if (!stream)
2359 return -ENOMEM;
2361 stream->port = port;
2362 stream->stream_id = stream_id;
2363 stream->vfl_type = vfl_type;
2365 stream->list_num = vpdma_hwlist_alloc(dev->shared->vpdma, stream);
2366 if (stream->list_num < 0) {
2367 vip_err(dev, "Could not get VPDMA hwlist");
2368 ret = -ENODEV;
2369 goto do_free_stream;
2370 }
2372 INIT_LIST_HEAD(&stream->post_bufs);
2374 if (vfl_type == VFL_TYPE_GRABBER)
2375 port->cap_streams[stream_id] = stream;
2376 else
2377 port->vbi_streams[stream_id] = stream;
2379 /*
2380 * Initialize queue
2381 */
2382 q = &stream->vb_vidq;
2383 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2384 q->io_modes = VB2_MMAP | VB2_DMABUF;
2385 q->drv_priv = stream;
2386 q->buf_struct_size = sizeof(struct vip_buffer);
2387 q->ops = &vip_video_qops;
2388 q->mem_ops = &vb2_dma_contig_memops;
2389 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
2391 /* Feature not back-ported yet. Enable when available */
2392 /* q->min_buffers_needed = 3; */
2394 ret = vb2_queue_init(q);
2395 if (ret)
2396 goto do_free_stream;
2398 INIT_LIST_HEAD(&stream->vidq);
2400 /* Allocate/populate Drop queue entries */
2401 INIT_LIST_HEAD(&stream->dropq);
2402 for (i = 0; i < VIP_DROPQ_SIZE; i++) {
2404 buf = kzalloc(sizeof(*buf), GFP_ATOMIC);
2405 if (!buf) {
2406 vip_err(dev, "No memory!!");
2407 ret = -ENOMEM;
2408 goto do_free_stream;
2409 }
2410 buf->drop = true;
2411 list_add(&buf->list, &stream->dropq);
2412 }
2414 vfd = &stream->vdev;
2415 *vfd = vip_videodev;
2416 vfd->v4l2_dev = &dev->v4l2_dev;
2417 vfd->queue = q;
2418 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
2420 vfd->lock = &dev->mutex;
2421 video_set_drvdata(vfd, stream);
2423 ret = video_register_device(vfd, vfl_type, -1);
2424 if (ret) {
2425 vip_err(dev, "Failed to register video device\n");
2426 goto do_free_stream;
2427 }
2429 snprintf(vfd->name, sizeof(vfd->name), "%s", vip_videodev.name);
2430 stream->vfd = vfd;
2432 vip_info(dev, VIP_MODULE_NAME
2433 " Device registered as /dev/video%d\n", vfd->num);
2434 return 0;
2436 do_free_stream:
2437 kfree(stream);
2438 return ret;
2439 }
2441 static void free_stream(struct vip_stream *stream)
2442 {
2443 struct vip_dev *dev = stream->port->dev;
2444 struct vip_buffer *buf;
2445 struct list_head *pos, *q;
2447 if (!stream)
2448 return;
2450 /* Free up the Drop queue */
2451 list_for_each_safe(pos, q, &stream->dropq) {
2452 buf = list_entry(stream->dropq.next,
2453 struct vip_buffer, list);
2454 vip_dbg(1, dev, "dropq buffer\n");
2455 list_del(pos);
2456 kfree(buf);
2457 }
2459 video_unregister_device(stream->vfd);
2460 video_device_release(stream->vfd);
2461 vpdma_hwlist_release(dev->shared->vpdma, stream->list_num);
2462 kfree(stream);
2463 }
2465 static int alloc_port(struct vip_dev *dev, int id)
2466 {
2467 struct vip_port *port;
2468 int ret;
2470 port = kzalloc(sizeof(*port), GFP_KERNEL);
2471 if (!port)
2472 return -ENOMEM;
2474 dev->ports[id] = port;
2475 port->dev = dev;
2476 port->port_id = id;
2477 port->num_streams = 0;
2478 port->flags |= FLAG_MULT_PORT;
2480 ret = alloc_stream(port, 0, VFL_TYPE_GRABBER);
2482 if (dev->endpoint->bus_type == V4L2_MBUS_BT656) {
2483 /* Allocate streams for 4 channels */
2484 ret = alloc_stream(port, 2, VFL_TYPE_GRABBER);
2485 ret = alloc_stream(port, 4, VFL_TYPE_GRABBER);
2486 ret = alloc_stream(port, 6, VFL_TYPE_GRABBER);
2487 }
2489 return 0;
2490 }
2492 static void free_port(struct vip_port *port)
2493 {
2494 if (!port)
2495 return;
2497 free_stream(port->cap_streams[0]);
2499 kfree(port);
2500 }
2502 static int get_field(u32 value, u32 mask, int shift)
2503 {
2504 return (value & (mask << shift)) >> shift;
2505 }
2507 static int vip_of_probe(struct platform_device *pdev, struct vip_dev *dev);
2508 static void vip_vpdma_fw_cb(struct platform_device *pdev)
2509 {
2510 struct vip_shared *shared = platform_get_drvdata(pdev);
2511 struct vip_dev *dev;
2512 int slice, ret;
2514 dev_info(&pdev->dev, "VPDMA firmware loaded\n");
2516 for (slice = 0; slice < atomic_read(&shared->devs_allocated); slice++) {
2517 dev = shared->devs[slice];
2519 if (pdev->dev.of_node) {
2520 ret = vip_of_probe(pdev, dev);
2521 if (ret)
2522 goto free_port;
2523 }
2524 }
2526 return;
2528 free_port:
2529 free_port(dev->ports[0]);
2530 }
2532 static void remove_shared(struct vip_shared *shared)
2533 {
2534 if (atomic_dec_return(&shared->devs_allocated) != 0)
2535 return;
2537 iounmap(shared->base);
2538 release_mem_region(shared->res->start, resource_size(shared->res));
2539 kfree(shared);
2540 }
2542 static int vip_runtime_get(struct platform_device *pdev)
2543 {
2544 int r;
2546 r = pm_runtime_get_sync(&pdev->dev);
2547 WARN_ON(r < 0);
2548 return r < 0 ? r : 0;
2549 }
2551 static int get_subdev_active_format(struct vip_dev *dev,
2552 struct v4l2_subdev *subdev)
2553 {
2554 struct vip_fmt *fmt;
2555 enum v4l2_mbus_pixelcode code;
2556 int ret = 0;
2557 unsigned int k;
2559 /* first find how many formats to allocate the correct size */
2560 dev->num_active_fmt = 0;
2561 for (k = 0;
2562 (ret != -EINVAL) && (dev->num_active_fmt < VIP_MAX_ACTIVE_FMT);
2563 k++) {
2564 ret = v4l2_subdev_call(subdev, video, enum_mbus_fmt, k, &code);
2565 if (ret == 0) {
2566 fmt = find_format_by_code(code);
2567 if (fmt) {
2568 dev->active_fmt[dev->num_active_fmt] = fmt;
2569 dev->num_active_fmt++;
2570 }
2571 }
2572 }
2574 if (find_active_format_by_pix(dev, V4L2_PIX_FMT_YUYV))
2575 /* When YUYV format is supported, NV12 can also be supported */
2576 dev->active_fmt[dev->num_active_fmt++] = &vip_formats[2];
2578 if (dev->num_active_fmt == 0) {
2580 vip_err(dev, "No suitable format reported by subdev %s\n",
2581 subdev->name);
2582 return -EINVAL;
2583 }
2585 return 0;
2586 }
2588 static int vip_async_bound(struct v4l2_async_notifier *notifier,
2589 struct v4l2_subdev *subdev,
2590 struct v4l2_async_subdev *asd)
2591 {
2592 struct vip_dev *dev = notifier_to_vip_dev(notifier);
2593 unsigned int idx = asd - &dev->config->asd[0];
2595 vip_dbg(1, dev, "vip_async_bound\n");
2596 if (idx > dev->config->asd_sizes)
2597 return -EINVAL;
2599 if (get_subdev_active_format(dev, subdev))
2600 return 0;
2602 if (dev->sensor) {
2603 if (asd < dev->sensor->asd) {
2604 /* Notified of a subdev earlier in the array */
2605 dev->sensor = subdev;
2606 dev->endpoint = &dev->config->endpoints[idx];
2607 vip_info(dev, "Switching to subdev %s (High priority)",
2608 subdev->name);
2610 } else
2611 vip_info(dev, "Rejecting subdev %s (Low priority)",
2612 subdev->name);
2613 return 0;
2614 }
2616 dev->sensor = subdev;
2617 dev->endpoint = &dev->config->endpoints[idx];
2618 vip_info(dev, "Using sensor %s for capture\n", subdev->name);
2619 alloc_port(dev, 0);
2621 return 0;
2622 }
2624 static int vip_async_complete(struct v4l2_async_notifier *notifier)
2625 {
2626 struct vip_dev *dev = notifier_to_vip_dev(notifier);
2627 vip_dbg(1, dev, "vip_async_complete\n");
2628 return 0;
2629 }
2631 static struct device_node *
2632 of_get_next_port(const struct device_node *parent,
2633 struct device_node *prev)
2634 {
2635 struct device_node *port = NULL;
2637 if (!parent)
2638 return NULL;
2640 if (!prev) {
2641 struct device_node *ports;
2642 /*
2643 * It's the first call, we have to find a port subnode
2644 * within this node or within an optional 'ports' node.
2645 */
2646 ports = of_get_child_by_name(parent, "ports");
2647 if (ports)
2648 parent = ports;
2650 port = of_get_child_by_name(parent, "port");
2652 /* release the 'ports' node */
2653 of_node_put(ports);
2654 } else {
2655 struct device_node *ports;
2657 ports = of_get_parent(prev);
2658 if (!ports)
2659 return NULL;
2661 do {
2662 port = of_get_next_child(ports, prev);
2663 if (!port) {
2664 of_node_put(ports);
2665 return NULL;
2666 }
2667 prev = port;
2668 } while (of_node_cmp(port->name, "port") != 0);
2669 }
2671 return port;
2672 }
2674 static struct device_node *
2675 of_get_next_endpoint(const struct device_node *parent,
2676 struct device_node *prev)
2677 {
2678 struct device_node *ep = NULL;
2680 if (!parent)
2681 return NULL;
2683 do {
2684 ep = of_get_next_child(parent, prev);
2685 if (!ep)
2686 return NULL;
2687 prev = ep;
2688 } while (of_node_cmp(ep->name, "endpoint") != 0);
2690 return ep;
2691 }
2693 static int vip_of_probe(struct platform_device *pdev, struct vip_dev *dev)
2694 {
2695 struct device_node *ep_node = NULL, *port, *remote_ep,
2696 *sensor_node, *parent;
2697 struct device_node *syscon_np;
2698 struct v4l2_of_endpoint *endpoint;
2699 struct v4l2_async_subdev *asd;
2700 u32 regval = 0;
2701 int ret, slice, i = 0, found_port = 0;
2703 parent = pdev->dev.of_node;
2705 syscon_np = of_parse_phandle(pdev->dev.of_node, "syscon", 0);
2706 dev->syscon = syscon_node_to_regmap(syscon_np);
2707 of_node_put(syscon_np);
2709 dev->config = kzalloc(sizeof(struct vip_config), GFP_KERNEL);
2710 if (!dev->config)
2711 return -ENOMEM;
2713 dev->config->card_name = "VIP Driver";
2715 port = NULL;
2716 vip_dbg(3, dev, "Scanning Port node for slice id: %d\n", dev->slice_id);
2717 for (slice = 0; slice < VIP_NUM_SLICES; slice++) {
2718 port = of_get_next_port(parent, port);
2719 if (!port) {
2720 vip_dbg(1, dev, "No port node found for slice_id:%d\n",
2721 slice);
2722 ret = -EINVAL;
2723 goto free_config;
2724 }
2726 /* Match the slice number with <REG> */
2727 of_property_read_u32(port, "reg", ®val);
2728 vip_dbg(3, dev, "slice:%d dev->slice_id:%d <reg>:%d\n",
2729 slice, dev->slice_id, regval);
2730 if ((regval == dev->slice_id) && (slice == dev->slice_id)) {
2731 found_port = 1;
2732 break;
2733 }
2734 }
2736 if (!found_port) {
2737 if (!port)
2738 of_node_put(port);
2739 vip_dbg(1, dev, "No port node matches slice_id:%d\n",
2740 dev->slice_id);
2741 ret = -EINVAL;
2742 goto free_config;
2743 }
2745 vip_dbg(3, dev, "Scanning sub-device(s) for slice id: %d\n",
2746 dev->slice_id);
2747 while (i < VIP_MAX_SUBDEV) {
2749 asd = &dev->config->asd[i];
2750 endpoint = &dev->config->endpoints[i];
2752 remote_ep = NULL;
2753 sensor_node = NULL;
2755 ep_node = of_get_next_endpoint(port, ep_node);
2756 if (!ep_node) {
2757 vip_dbg(3, dev, "can't get next endpoint: loop: %d\n",
2758 i);
2759 break;
2760 }
2762 sensor_node = of_graph_get_remote_port_parent(ep_node);
2763 if (!sensor_node) {
2764 vip_dbg(3, dev, "can't get remote parent: loop: %d\n",
2765 i);
2766 goto of_node_cleanup;
2767 }
2768 asd->match_type = V4L2_ASYNC_MATCH_OF;
2769 asd->match.of.node = sensor_node;
2771 remote_ep = of_parse_phandle(ep_node, "remote-endpoint", 0);
2772 if (!remote_ep) {
2773 vip_dbg(3, dev, "can't get remote-endpoint: loop: %d\n",
2774 i);
2775 goto of_node_cleanup;
2776 }
2777 v4l2_of_parse_endpoint(remote_ep, endpoint);
2779 dev->config->asd_list[i++] = asd;
2781 of_node_cleanup:
2782 if (!remote_ep)
2783 of_node_put(remote_ep);
2784 if (!sensor_node)
2785 of_node_put(sensor_node);
2786 }
2788 if (!ep_node)
2789 of_node_put(ep_node);
2790 if (!port)
2791 of_node_put(port);
2793 vip_dbg(1, dev, "Found %d sub-device(s) for slice id: %d\n",
2794 i, dev->slice_id);
2795 if (i > 0) {
2796 dev->config->asd_sizes = i;
2797 dev->notifier.subdevs = dev->config->asd_list;
2798 dev->notifier.num_subdevs = dev->config->asd_sizes;
2799 dev->notifier.bound = vip_async_bound;
2800 dev->notifier.complete = vip_async_complete;
2802 vip_dbg(1, dev, "registering the sync notifier for sensors %d",
2803 i);
2804 ret = v4l2_async_notifier_register(&dev->v4l2_dev,
2805 &dev->notifier);
2806 if (ret) {
2807 vip_dbg(1, dev, "Error registering async notifier\n");
2808 ret = -EINVAL;
2809 goto free_config;
2810 }
2811 }
2813 return 0;
2814 free_config:
2815 kfree(dev->config);
2816 return ret;
2817 }
2819 static const struct of_device_id vip_of_match[];
2820 static int vip_probe(struct platform_device *pdev)
2821 {
2822 struct vip_dev *dev;
2823 struct vip_shared *shared;
2824 const struct of_device_id *of_dev_id;
2825 struct pinctrl *pinctrl;
2826 int ret, slice = VIP_SLICE1;
2827 u32 tmp, pid;
2828 struct v4l2_ctrl_handler *hdl;
2830 pm_runtime_enable(&pdev->dev);
2832 ret = vip_runtime_get(pdev);
2833 if (ret)
2834 goto err_runtime_get;
2836 of_dev_id = of_match_device(vip_of_match, &pdev->dev);
2837 if (!of_dev_id) {
2838 dev_err(&pdev->dev, "%s: Unable to match device\n", __func__);
2839 return -ENODEV;
2840 }
2842 shared = kzalloc(sizeof(*shared), GFP_KERNEL);
2843 if (!shared)
2844 return -ENOMEM;
2846 shared->res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vip");
2847 if (shared->res == NULL) {
2848 dev_err(&pdev->dev, "Missing platform resources data\n");
2849 ret = -ENODEV;
2850 goto free_shared;
2851 }
2853 pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
2854 if (IS_ERR(pinctrl)) {
2855 dev_warn(&pdev->dev, "No explicit pinctrl resources data.\n");
2856 }
2858 if (devm_request_mem_region(&pdev->dev, shared->res->start,
2859 resource_size(shared->res), VIP_MODULE_NAME) == NULL) {
2860 ret = -ENOMEM;
2861 goto free_shared;
2862 }
2864 shared->base = devm_ioremap(&pdev->dev, shared->res->start,
2865 resource_size(shared->res));
2866 if (!shared->base) {
2867 dev_err(&pdev->dev, "failed to ioremap\n");
2868 ret = -ENOMEM;
2869 goto rel_mem_region;
2870 }
2872 /* Make sure H/W module has the right functionality */
2873 pid = read_sreg(shared, VIP_PID);
2874 tmp = get_field(pid, VIP_PID_FUNC_MASK, VIP_PID_FUNC_SHIFT);
2876 if (tmp != VIP_PID_FUNC) {
2877 dev_info(&pdev->dev, "vip: unexpected PID function: 0x%x\n",
2878 tmp);
2879 ret = -ENODEV;
2880 goto do_iounmap;
2881 }
2883 /* enable clocks, so the firmware will load properly */
2884 vip_shared_set_clock_enable(shared, 1);
2885 vip_top_vpdma_reset(shared);
2887 list_add_tail(&shared->list, &vip_shared_list);
2888 platform_set_drvdata(pdev, shared);
2889 atomic_set(&shared->devs_allocated, 0);
2891 vip_set_idle_mode(shared, VIP_SMART_IDLE_MODE);
2892 vip_set_standby_mode(shared, VIP_SMART_STANDBY_MODE);
2894 for (slice = VIP_SLICE1; slice < VIP_NUM_SLICES; slice++) {
2895 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2896 if (!dev)
2897 return -ENOMEM;
2899 dev->instance_id = (int)of_dev_id->data;
2900 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
2901 "%s%d-s%d", VIP_MODULE_NAME, dev->instance_id, slice);
2903 dev->irq = platform_get_irq(pdev, slice);
2904 if (!dev->irq) {
2905 dev_err(&pdev->dev, "Could not get IRQ");
2906 goto err_runtime_get;
2907 }
2909 if (devm_request_irq(&pdev->dev, dev->irq, vip_irq,
2910 0, dev->v4l2_dev.name, dev) < 0) {
2911 ret = -ENOMEM;
2912 goto dev_unreg;
2913 }
2915 spin_lock_init(&dev->slock);
2916 spin_lock_init(&dev->lock);
2918 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
2919 if (ret)
2920 goto err_runtime_get;
2922 mutex_init(&dev->mutex);
2924 hdl = &dev->ctrl_handler;
2925 v4l2_ctrl_handler_init(hdl, 11);
2926 dev->v4l2_dev.ctrl_handler = hdl;
2928 dev->slice_id = slice;
2929 dev->pdev = pdev;
2930 dev->res = shared->res;
2931 dev->base = shared->base;
2933 dev->shared = shared;
2934 shared->devs[slice] = dev;
2936 atomic_inc(&shared->devs_allocated);
2938 dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
2939 if (IS_ERR(dev->alloc_ctx)) {
2940 vip_err(dev, "Failed to alloc vb2 context\n");
2941 ret = PTR_ERR(dev->alloc_ctx);
2942 goto dev_unreg;
2943 }
2945 vip_top_reset(dev);
2946 vip_set_slice_path(dev, VIP_MULTI_CHANNEL_DATA_SELECT);
2947 }
2949 shared->vpdma = vpdma_create(pdev, vip_vpdma_fw_cb);
2950 if (!shared->vpdma) {
2951 dev_err(&pdev->dev, "Creating VPDMA failed");
2952 goto dev_unreg;
2953 }
2955 return 0;
2957 dev_unreg:
2958 v4l2_device_unregister(&dev->v4l2_dev);
2959 do_iounmap:
2960 iounmap(shared->base);
2961 rel_mem_region:
2962 release_mem_region(shared->res->start, resource_size(shared->res));
2963 free_shared:
2964 kfree(shared);
2965 err_runtime_get:
2966 if (slice == VIP_SLICE1) {
2967 pm_runtime_disable(&pdev->dev);
2968 return ret;
2969 } else
2970 return 0;
2971 }
2973 static int vip_remove(struct platform_device *pdev)
2974 {
2975 struct vip_shared *shared = platform_get_drvdata(pdev);
2976 struct vip_dev *dev;
2977 int slice;
2979 for (slice = 0; slice < atomic_read(&shared->devs_allocated); slice++) {
2980 dev = shared->devs[slice];
2981 if (!dev)
2982 continue;
2983 vip_info(dev, "Removing " VIP_MODULE_NAME);
2984 free_port(dev->ports[0]);
2985 v4l2_async_notifier_unregister(&dev->notifier);
2986 vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
2987 free_irq(dev->irq, dev);
2988 kfree(dev);
2989 }
2990 remove_shared(shared);
2992 return 0;
2993 }
2995 #if defined(CONFIG_OF)
2996 static const struct of_device_id vip_of_match[] = {
2997 {
2998 .compatible = "ti,vip1", .data = (void *) VIP_INSTANCE1,
2999 },
3001 {
3002 .compatible = "ti,vip2", .data = (void *) VIP_INSTANCE2,
3003 },
3005 {
3006 .compatible = "ti,vip3", .data = (void *) VIP_INSTANCE3,
3007 },
3008 {},
3009 };
3010 MODULE_DEVICE_TABLE(of, vip_of_match);
3011 #else
3012 #define vip_of_match NULL
3013 #endif
3015 static struct platform_driver vip_pdrv = {
3016 .probe = vip_probe,
3017 .remove = vip_remove,
3018 .driver = {
3019 .name = VIP_MODULE_NAME,
3020 .owner = THIS_MODULE,
3021 .of_match_table = vip_of_match,
3022 },
3023 };
3025 module_platform_driver(vip_pdrv);
3027 MODULE_DESCRIPTION("TI VIP driver");
3028 MODULE_AUTHOR("Texas Instruments");
3029 MODULE_LICENSE("GPL v2");