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_UYVY8_2X8,
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_UYVY8_2X8,
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_UYVY8_2X8,
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 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CBY422],
166 },
167 },
168 {
169 .name = "YUYV 422 packed",
170 .fourcc = V4L2_PIX_FMT_YUYV,
171 .code = V4L2_MBUS_FMT_UYVY8_2X8,
172 .colorspace = V4L2_COLORSPACE_SMPTE170M,
173 .coplanar = 0,
174 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_YCB422],
175 },
176 },
177 {
178 .name = "VYUY 422 packed",
179 .fourcc = V4L2_PIX_FMT_VYUY,
180 .code = V4L2_MBUS_FMT_UYVY8_2X8,
181 .colorspace = V4L2_COLORSPACE_SMPTE170M,
182 .coplanar = 0,
183 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_CY422],
184 },
185 },
186 {
187 .name = "YVYU 422 packed",
188 .fourcc = V4L2_PIX_FMT_YVYU,
189 .code = V4L2_MBUS_FMT_UYVY8_2X8,
190 .colorspace = V4L2_COLORSPACE_SMPTE170M,
191 .coplanar = 0,
192 .vpdma_fmt = { &vpdma_yuv_fmts[VPDMA_DATA_FMT_YC422],
193 },
194 },
195 {
196 .name = "RGB888 packed",
197 .fourcc = V4L2_PIX_FMT_RGB24,
198 .code = V4L2_MBUS_FMT_RGB888_1X24,
199 .colorspace = V4L2_COLORSPACE_SRGB,
200 .coplanar = 0,
201 .vpdma_fmt = { &vpdma_rgb_fmts[VPDMA_DATA_FMT_RGB24],
202 },
203 },
204 {
205 .name = "ARGB888 packed",
206 .fourcc = V4L2_PIX_FMT_RGB32,
207 .code = V4L2_MBUS_FMT_ARGB8888_1X32,
208 .colorspace = V4L2_COLORSPACE_SRGB,
209 .coplanar = 0,
210 .vpdma_fmt = { &vpdma_rgb_fmts[VPDMA_DATA_FMT_ARGB32],
211 },
212 },
213 };
215 /* Print Four-character-code (FOURCC) */
216 static char *fourcc_to_str(u32 fmt)
217 {
218 static char code[5];
219 code[0] = (unsigned char)(fmt & 0xff);
220 code[1] = (unsigned char)((fmt>>8) & 0xff);
221 code[2] = (unsigned char)((fmt>>16) & 0xff);
222 code[3] = (unsigned char)((fmt>>24) & 0xff);
223 code[4] = '\0';
225 return code;
226 }
228 /*
229 * Find our format description corresponding to the passed v4l2_format
230 */
232 static struct vip_fmt *find_port_format_by_pix(struct vip_port *port,
233 u32 pixelformat)
234 {
235 struct vip_dev *dev = port->dev;
236 struct vip_fmt *fmt;
237 unsigned int k;
239 for (k = 0; k < dev->num_active_fmt; k++) {
240 fmt = dev->active_fmt[k];
241 if (fmt->fourcc == pixelformat)
242 return fmt;
243 }
245 return NULL;
246 }
248 static LIST_HEAD(vip_shared_list);
250 static inline struct vip_dev *notifier_to_vip_dev(struct v4l2_async_notifier *n)
251 {
252 return container_of(n, struct vip_dev, notifier);
253 }
255 /*
256 * port flag bits
257 */
258 #define FLAG_FRAME_1D (1 << 0)
259 #define FLAG_EVEN_LINE_SKIP (1 << 1)
260 #define FLAG_ODD_LINE_SKIP (1 << 2)
261 #define FLAG_MODE_TILED (1 << 3)
262 #define FLAG_INTERLACED (1 << 4)
263 #define FLAG_MULTIPLEXED (1 << 5)
264 #define FLAG_MULT_PORT (1 << 6)
265 #define FLAG_MULT_ANC (1 << 7)
267 /*
268 * Function prototype declarations
269 */
270 static int alloc_port(struct vip_dev *, int);
271 static void free_port(struct vip_port *);
272 static int vip_setup_parser(struct vip_port *port);
273 static void stop_dma(struct vip_stream *stream);
275 static inline u32 read_sreg(struct vip_shared *shared, int offset)
276 {
277 return ioread32(shared->base + offset);
278 }
280 static inline void write_sreg(struct vip_shared *shared, int offset, u32 value)
281 {
282 iowrite32(value, shared->base + offset);
283 }
285 static inline u32 read_vreg(struct vip_dev *dev, int offset)
286 {
287 return ioread32(dev->base + offset);
288 }
290 static inline void write_vreg(struct vip_dev *dev, int offset, u32 value)
291 {
292 iowrite32(value, dev->base + offset);
293 }
295 /*
296 * Insert a masked field into a 32-bit field
297 */
298 static void insert_field(u32 *valp, u32 field, u32 mask, int shift)
299 {
300 u32 val = *valp;
302 val &= ~(mask << shift);
303 val |= (field & mask) << shift;
304 *valp = val;
305 }
307 /*
308 * Set the system idle mode
309 */
310 static void vip_set_idle_mode(struct vip_shared *shared, int mode)
311 {
312 u32 reg = read_sreg(shared, VIP_SYSCONFIG);
313 insert_field(®, mode, VIP_SYSCONFIG_IDLE_MASK,
314 VIP_SYSCONFIG_IDLE_SHIFT);
315 write_sreg(shared, VIP_SYSCONFIG, reg);
316 }
318 /*
319 * Set the VIP standby mode
320 */
321 static void vip_set_standby_mode(struct vip_shared *shared, int mode)
322 {
323 u32 reg = read_sreg(shared, VIP_SYSCONFIG);
324 insert_field(®, mode, VIP_SYSCONFIG_STANDBY_MASK,
325 VIP_SYSCONFIG_STANDBY_SHIFT);
326 write_sreg(shared, VIP_SYSCONFIG, reg);
327 }
329 /*
330 * Enable or disable the VIP clocks
331 */
332 static void vip_set_clock_enable(struct vip_dev *dev, bool on)
333 {
334 u32 val = 0;
336 val = read_vreg(dev, VIP_CLK_ENABLE);
337 if (on) {
338 val |= VIP_VPDMA_CLK_ENABLE;
339 if (dev->slice_id == VIP_SLICE1)
340 val |= VIP_VIP1_DATA_PATH_CLK_ENABLE;
341 else
342 val |= VIP_VIP2_DATA_PATH_CLK_ENABLE;
343 } else {
344 if (dev->slice_id == VIP_SLICE1)
345 val &= ~VIP_VIP1_DATA_PATH_CLK_ENABLE;
346 else
347 val &= ~VIP_VIP2_DATA_PATH_CLK_ENABLE;
349 /* Both VIP are disabled then shutdown VPDMA also */
350 if (!(val & (VIP_VIP1_DATA_PATH_CLK_ENABLE|
351 VIP_VIP2_DATA_PATH_CLK_ENABLE)))
352 val = 0;
353 }
355 write_vreg(dev, VIP_CLK_ENABLE, val);
356 }
358 /* This helper function is used to enable the clock early on to
359 * enable vpdma firmware loading before the slice device are created
360 */
361 static void vip_shared_set_clock_enable(struct vip_shared *shared, bool on)
362 {
363 u32 val = 0;
365 if (on)
366 val = VIP_VIP1_DATA_PATH_CLK_ENABLE | VIP_VPDMA_CLK_ENABLE;
368 write_sreg(shared, VIP_CLK_ENABLE, val);
369 }
371 static void vip_top_reset(struct vip_dev *dev)
372 {
373 u32 val = 0;
375 val = read_vreg(dev, VIP_CLK_RESET);
377 if (dev->slice_id == VIP_SLICE1)
378 insert_field(&val, 1, VIP_DATA_PATH_CLK_RESET_MASK,
379 VIP_VIP1_DATA_PATH_RESET_SHIFT);
380 else
381 insert_field(&val, 1, VIP_DATA_PATH_CLK_RESET_MASK,
382 VIP_VIP2_DATA_PATH_RESET_SHIFT);
384 write_vreg(dev, VIP_CLK_RESET, val);
386 usleep_range(200, 250);
388 val = read_vreg(dev, VIP_CLK_RESET);
390 if (dev->slice_id == VIP_SLICE1)
391 insert_field(&val, 0, VIP_DATA_PATH_CLK_RESET_MASK,
392 VIP_VIP1_DATA_PATH_RESET_SHIFT);
393 else
394 insert_field(&val, 0, VIP_DATA_PATH_CLK_RESET_MASK,
395 VIP_VIP2_DATA_PATH_RESET_SHIFT);
396 write_vreg(dev, VIP_CLK_RESET, val);
397 }
399 static void vip_top_vpdma_reset(struct vip_shared *shared)
400 {
401 u32 val;
403 val = read_sreg(shared, VIP_CLK_RESET);
404 insert_field(&val, 1, VIP_VPDMA_CLK_RESET_MASK,
405 VIP_VPDMA_CLK_RESET_SHIFT);
406 write_sreg(shared, VIP_CLK_RESET, val);
408 usleep_range(200, 250);
410 val = read_sreg(shared, VIP_CLK_RESET);
411 insert_field(&val, 0, VIP_VPDMA_CLK_RESET_MASK,
412 VIP_VPDMA_CLK_RESET_SHIFT);
413 write_sreg(shared, VIP_CLK_RESET, val);
414 }
416 static void vip_xtra_set_repack_sel(struct vip_port *port, int repack_mode)
417 {
418 u32 val;
420 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
421 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
422 VIP_PARSER_PORTA_1);
423 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
424 VIP_REPACK_SEL_SHFT);
426 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
427 VIP_PARSER_PORTA_1, val);
428 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
429 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
430 VIP_PARSER_PORTA_1);
431 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
432 VIP_REPACK_SEL_SHFT);
434 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
435 VIP_PARSER_PORTA_1, val);
436 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
437 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
438 VIP_PARSER_PORTB_1);
439 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
440 VIP_REPACK_SEL_SHFT);
442 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
443 VIP_PARSER_PORTB_1, val);
444 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
445 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
446 VIP_PARSER_PORTB_1);
447 insert_field(&val, repack_mode, VIP_REPACK_SEL_MASK,
448 VIP_REPACK_SEL_SHFT);
450 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
451 VIP_PARSER_PORTB_1, val);
452 }
453 }
455 static void vip_set_discrete_basic_mode(struct vip_port *port)
456 {
457 u32 val;
459 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
460 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
461 VIP_PARSER_PORTA_0);
462 val |= VIP_DISCRETE_BASIC_MODE;
464 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
465 VIP_PARSER_PORTA_0, val);
466 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
467 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
468 VIP_PARSER_PORTA_0);
469 val |= VIP_DISCRETE_BASIC_MODE;
471 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
472 VIP_PARSER_PORTA_0, val);
473 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
474 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
475 VIP_PARSER_PORTB_0);
476 val |= VIP_DISCRETE_BASIC_MODE;
478 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
479 VIP_PARSER_PORTB_0, val);
480 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
481 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
482 VIP_PARSER_PORTB_0);
483 val |= VIP_DISCRETE_BASIC_MODE;
485 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
486 VIP_PARSER_PORTB_0, val);
487 }
488 }
490 static void vip_set_pclk_polarity(struct vip_port *port, int polarity)
491 {
492 u32 val, ret, offset;
494 if (polarity == 1 && port->dev->syscon) {
496 /*
497 * When the VIP parser is configured to so that the pixel clock
498 * is to be sampled at falling edge, the pixel clock needs to be
499 * inverted before it is given to the VIP module. This is done
500 * by setting a bit in the CTRL_CORE_SMA_SW1 register.
501 */
503 if (port->dev->instance_id == VIP_INSTANCE1)
504 offset = 0 + 2 * port->port_id + port->dev->slice_id;
505 else if (port->dev->instance_id == VIP_INSTANCE2)
506 offset = 4 + 2 * port->port_id + port->dev->slice_id;
507 else if (port->dev->instance_id == VIP_INSTANCE3)
508 offset = 10 - port->dev->slice_id;
509 else
510 BUG();
512 ret = regmap_update_bits(port->dev->syscon,
513 CTRL_CORE_SMA_SW_1, 1 << offset, 1 << offset);
514 }
516 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
517 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
518 VIP_PARSER_PORTA_0);
519 if (polarity)
520 val |= VIP_PIXCLK_EDGE_POLARITY;
521 else
522 val &= ~VIP_PIXCLK_EDGE_POLARITY;
524 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
525 VIP_PARSER_PORTA_0, val);
526 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
527 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET
528 + VIP_PARSER_PORTA_0);
529 if (polarity)
530 val |= VIP_PIXCLK_EDGE_POLARITY;
531 else
532 val &= ~VIP_PIXCLK_EDGE_POLARITY;
533 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
534 VIP_PARSER_PORTA_0, val);
535 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
536 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
537 VIP_PARSER_PORTB_0);
538 if (polarity)
539 val |= VIP_PIXCLK_EDGE_POLARITY;
540 else
541 val &= ~VIP_PIXCLK_EDGE_POLARITY;
542 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
543 VIP_PARSER_PORTB_0, val);
544 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
545 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
546 VIP_PARSER_PORTB_0);
547 if (polarity)
548 val |= VIP_PIXCLK_EDGE_POLARITY;
549 else
550 val &= ~VIP_PIXCLK_EDGE_POLARITY;
552 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
553 VIP_PARSER_PORTB_0, val);
554 }
555 }
557 static void vip_set_vsync_polarity(struct vip_port *port, int polarity)
558 {
559 u32 val;
561 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
562 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
563 VIP_PARSER_PORTA_0);
564 if (polarity)
565 val |= VIP_VSYNC_POLARITY;
566 else
567 val &= ~VIP_VSYNC_POLARITY;
569 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
570 VIP_PARSER_PORTA_0, val);
571 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
572 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
573 VIP_PARSER_PORTA_0);
574 if (polarity)
575 val |= VIP_VSYNC_POLARITY;
576 else
577 val &= ~VIP_VSYNC_POLARITY;
578 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
579 VIP_PARSER_PORTA_0, val);
580 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
581 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
582 VIP_PARSER_PORTB_0);
583 if (polarity)
584 val |= VIP_VSYNC_POLARITY;
585 else
586 val &= ~VIP_VSYNC_POLARITY;
587 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
588 VIP_PARSER_PORTB_0, val);
589 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
590 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
591 VIP_PARSER_PORTB_0);
592 if (polarity)
593 val |= VIP_VSYNC_POLARITY;
594 else
595 val &= ~VIP_VSYNC_POLARITY;
597 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
598 VIP_PARSER_PORTB_0, val);
599 }
600 }
602 static void vip_set_hsync_polarity(struct vip_port *port, int polarity)
603 {
604 u32 val;
606 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
607 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
608 VIP_PARSER_PORTA_0);
609 if (polarity)
610 val |= VIP_HSYNC_POLARITY;
611 else
612 val &= ~VIP_HSYNC_POLARITY;
614 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
615 VIP_PARSER_PORTA_0, val);
616 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
617 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
618 VIP_PARSER_PORTA_0);
619 if (polarity)
620 val |= VIP_HSYNC_POLARITY;
621 else
622 val &= ~VIP_HSYNC_POLARITY;
623 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
624 VIP_PARSER_PORTA_0, val);
625 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
626 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
627 VIP_PARSER_PORTB_0);
628 if (polarity)
629 val |= VIP_HSYNC_POLARITY;
630 else
631 val &= ~VIP_HSYNC_POLARITY;
632 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
633 VIP_PARSER_PORTB_0, val);
634 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
635 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
636 VIP_PARSER_PORTB_0);
637 if (polarity)
638 val |= VIP_HSYNC_POLARITY;
639 else
640 val &= ~VIP_HSYNC_POLARITY;
641 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
642 VIP_PARSER_PORTB_0, val);
643 }
644 }
646 static void vip_set_actvid_polarity(struct vip_port *port, int polarity)
647 {
648 u32 val;
650 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
651 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
652 VIP_PARSER_PORTA_0);
653 if (polarity)
654 val |= VIP_ACTVID_POLARITY;
655 else
656 val &= ~VIP_ACTVID_POLARITY;
658 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
659 VIP_PARSER_PORTA_0, val);
660 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
661 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
662 VIP_PARSER_PORTA_0);
663 if (polarity)
664 val |= VIP_ACTVID_POLARITY;
665 else
666 val &= ~VIP_ACTVID_POLARITY;
667 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
668 VIP_PARSER_PORTA_0, val);
669 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
670 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
671 VIP_PARSER_PORTB_0);
672 if (polarity)
673 val |= VIP_ACTVID_POLARITY;
674 else
675 val &= ~VIP_ACTVID_POLARITY;
676 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
677 VIP_PARSER_PORTB_0, val);
678 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
679 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
680 VIP_PARSER_PORTB_0);
681 if (polarity)
682 val |= VIP_ACTVID_POLARITY;
683 else
684 val &= ~VIP_ACTVID_POLARITY;
686 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
687 VIP_PARSER_PORTB_0, val);
688 }
689 }
691 static void vip_set_actvid_hsync_n(struct vip_port *port, int enable)
692 {
693 u32 val;
695 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
696 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
697 VIP_PARSER_PORTA_0);
698 if (enable)
699 val |= VIP_USE_ACTVID_HSYNC_ONLY;
700 else
701 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
703 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
704 VIP_PARSER_PORTA_0, val);
705 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
706 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
707 VIP_PARSER_PORTA_0);
708 if (enable)
709 val |= VIP_USE_ACTVID_HSYNC_ONLY;
710 else
711 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
712 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
713 VIP_PARSER_PORTA_0, val);
714 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
715 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
716 VIP_PARSER_PORTB_0);
717 if (enable)
718 val |= VIP_USE_ACTVID_HSYNC_ONLY;
719 else
720 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
721 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
722 VIP_PARSER_PORTB_0, val);
723 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
724 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
725 VIP_PARSER_PORTB_0);
726 if (enable)
727 val |= VIP_USE_ACTVID_HSYNC_ONLY;
728 else
729 val &= ~VIP_USE_ACTVID_HSYNC_ONLY;
731 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
732 VIP_PARSER_PORTB_0, val);
733 }
734 }
736 static void vip_sync_type(struct vip_port *port, enum sync_types sync)
737 {
738 u32 val;
740 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
741 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
742 VIP_PARSER_PORTA_0);
743 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
744 VIP_SYNC_TYPE_SHFT);
746 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
747 VIP_PARSER_PORTA_0, val);
748 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
749 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
750 VIP_PARSER_PORTA_0);
751 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
752 VIP_SYNC_TYPE_SHFT);
754 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
755 VIP_PARSER_PORTA_0, val);
756 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
757 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
758 VIP_PARSER_PORTB_0);
759 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
760 VIP_SYNC_TYPE_SHFT);
762 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
763 VIP_PARSER_PORTB_0, val);
764 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
765 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
766 VIP_PARSER_PORTB_0);
767 insert_field(&val, sync, VIP_SYNC_TYPE_MASK,
768 VIP_SYNC_TYPE_SHFT);
770 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
771 VIP_PARSER_PORTB_0, val);
772 }
773 }
775 static void vip_set_data_interface(struct vip_port *port,
776 enum data_interface_modes mode)
777 {
778 u32 val = 0;
780 if (port->dev->slice_id == VIP_SLICE1) {
781 insert_field(&val, mode, VIP_DATA_INTERFACE_MODE_MASK,
782 VIP_DATA_INTERFACE_MODE_SHFT);
784 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET, val);
785 } else if (port->dev->slice_id == VIP_SLICE2) {
786 insert_field(&val, mode, VIP_DATA_INTERFACE_MODE_MASK,
787 VIP_DATA_INTERFACE_MODE_SHFT);
789 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET, val);
790 }
791 }
793 static void vip_reset_port(struct vip_port *port)
794 {
795 u32 val = 0;
797 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
798 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
799 VIP_PARSER_PORTA_0, VIP_SW_RESET);
801 usleep_range(200, 250);
803 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
804 VIP_PARSER_PORTA_0);
806 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
807 VIP_PARSER_PORTA_0, 0);
808 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
809 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
810 VIP_PARSER_PORTA_0, VIP_SW_RESET);
812 usleep_range(200, 250);
814 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
815 VIP_PARSER_PORTA_0);
817 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
818 VIP_PARSER_PORTA_0, 0);
820 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
821 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
822 VIP_PARSER_PORTB_0, VIP_SW_RESET);
824 usleep_range(200, 250);
826 val = read_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
827 VIP_PARSER_PORTB_0);
829 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
830 VIP_PARSER_PORTB_0, 0);
831 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
832 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
833 VIP_PARSER_PORTB_0, VIP_SW_RESET);
835 usleep_range(200, 250);
837 val = read_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
838 VIP_PARSER_PORTB_0);
840 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
841 VIP_PARSER_PORTB_0, 0);
842 }
843 }
845 static void vip_set_port_enable(struct vip_port *port, bool on)
846 {
847 u32 val = 0;
849 if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE1) {
850 if (on)
851 val |= VIP_PORT_ENABLE;
852 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
853 VIP_PARSER_PORTA_0, val);
854 } else if (port->port_id == 0 && port->dev->slice_id == VIP_SLICE2) {
855 if (on)
856 val |= VIP_PORT_ENABLE;
857 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
858 VIP_PARSER_PORTA_0, val);
859 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE1) {
860 if (on)
861 val |= VIP_PORT_ENABLE;
862 write_vreg(port->dev, VIP1_PARSER_REG_OFFSET +
863 VIP_PARSER_PORTB_0, val);
864 } else if (port->port_id == 1 && port->dev->slice_id == VIP_SLICE2) {
865 if (on)
866 val |= VIP_PORT_ENABLE;
867 write_vreg(port->dev, VIP2_PARSER_REG_OFFSET +
868 VIP_PARSER_PORTB_0, val);
869 }
870 }
872 static void vip_set_slice_path(struct vip_dev *dev,
873 enum data_path_select data_path)
874 {
875 u32 val = 0;
877 switch (data_path) {
878 case VIP_MULTI_CHANNEL_DATA_SELECT:
879 if (dev->slice_id == VIP_SLICE1) {
880 val |= VIP_MULTI_CHANNEL_SELECT;
881 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
882 VIP_DATAPATH_SELECT_SHFT);
884 write_vreg(dev, VIP_VIP1_DATA_PATH_SELECT, val);
885 } else if (dev->slice_id == VIP_SLICE2) {
886 val |= VIP_MULTI_CHANNEL_SELECT;
887 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
888 VIP_DATAPATH_SELECT_SHFT);
890 write_vreg(dev, VIP_VIP2_DATA_PATH_SELECT, val);
891 }
892 break;
893 case VIP_RGB_OUT_LO_DATA_SELECT:
894 if (dev->slice_id == VIP_SLICE1) {
895 val |= VIP_RGB_OUT_LO_SRC_SELECT;
896 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
897 VIP_DATAPATH_SELECT_SHFT);
899 write_vreg(dev, VIP_VIP1_DATA_PATH_SELECT, val);
900 } else if (dev->slice_id == VIP_SLICE2) {
901 val |= VIP_RGB_OUT_LO_SRC_SELECT;
902 insert_field(&val, data_path, VIP_DATAPATH_SELECT_MASK,
903 VIP_DATAPATH_SELECT_SHFT);
905 write_vreg(dev, VIP_VIP2_DATA_PATH_SELECT, val);
906 }
907 break;
908 default:
909 BUG();
910 }
911 }
913 /*
914 * Return the vip_stream structure for a given struct file
915 */
916 static inline struct vip_stream *file2stream(struct file *file)
917 {
918 return video_drvdata(file);
920 }
922 /*
923 * Append a destination descriptor to the current descriptor list,
924 * setting up dma to the given srce.
925 */
926 static int add_out_dtd(struct vip_stream *stream, int srce_type)
927 {
928 struct vip_port *port = stream->port;
929 struct vip_dev *dev = port->dev;
930 struct vip_srce_info *sinfo = &srce_info[srce_type];
931 struct v4l2_rect *c_rect = &port->c_rect;
932 struct vip_fmt *fmt = port->fmt;
933 int channel, plane = 0;
934 int max_width, max_height;
935 dma_addr_t dma_addr;
936 u32 flags;
938 channel = sinfo->base_channel;
940 switch (srce_type) {
941 case VIP_SRCE_MULT_PORT:
942 case VIP_SRCE_MULT_ANC:
943 if (port->port_id == VIP_PORTB)
944 channel += VIP_CHAN_MULT_PORTB_OFFSET;
945 channel += stream->stream_id;
946 flags = 0;
947 break;
948 case VIP_SRCE_CHROMA:
949 plane = 1;
950 case VIP_SRCE_LUMA:
951 if (port->port_id == VIP_PORTB)
952 channel += VIP_CHAN_YUV_PORTB_OFFSET;
953 flags = port->flags;
954 break;
955 case VIP_SRCE_RGB:
956 if (port->port_id == VIP_PORTB)
957 channel += VIP_CHAN_RGB_PORTB_OFFSET;
958 flags = port->flags;
959 break;
960 default:
961 BUG();
962 }
964 if (dev->slice_id == VIP_SLICE2)
965 channel += VIP_CHAN_VIP2_OFFSET;
967 /* This is just for initialization purposes.
968 * The actual dma_addr will be configured in vpdma_update_dma_addr
969 */
970 dma_addr = (dma_addr_t)NULL;
972 /*
973 * Use VPDMA_MAX_SIZE1 or VPDMA_MAX_SIZE2 register for slice0/1
974 */
976 if (dev->slice_id == VIP_SLICE1) {
977 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE1,
978 stream->width, stream->height);
980 max_width = MAX_OUT_WIDTH_REG1;
981 max_height = MAX_OUT_HEIGHT_REG1;
982 } else {
983 vpdma_set_max_size(dev->shared->vpdma, VPDMA_MAX_SIZE2,
984 stream->width, stream->height);
986 max_width = MAX_OUT_WIDTH_REG2;
987 max_height = MAX_OUT_HEIGHT_REG2;
988 }
990 /* Mark this channel to be cleared while cleaning up resources
991 * This will make sure that an abort descriptor for this channel
992 * would be submitted to VPDMA causing any ongoing transaction to be
993 * aborted and cleanup the VPDMA FSM for this channel */
994 stream->vpdma_channels[channel] = 1;
996 vpdma_rawchan_add_out_dtd(&stream->desc_list, c_rect->width, c_rect,
997 fmt->vpdma_fmt[plane], dma_addr, max_width, max_height,
998 channel, flags);
1000 return 0;
1001 }
1003 /*
1004 * add_stream_dtds - prepares and starts DMA for pending transfers
1005 */
1006 static void add_stream_dtds(struct vip_stream *stream)
1007 {
1008 struct vip_port *port = stream->port;
1009 int srce_type;
1011 if (port->flags & FLAG_MULT_PORT)
1012 srce_type = VIP_SRCE_MULT_PORT;
1013 else if (port->flags & FLAG_MULT_ANC)
1014 srce_type = VIP_SRCE_MULT_ANC;
1015 else if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
1016 srce_type = VIP_SRCE_RGB;
1017 else
1018 srce_type = VIP_SRCE_LUMA;
1020 add_out_dtd(stream, srce_type);
1022 if (srce_type == VIP_SRCE_LUMA && port->fmt->coplanar)
1023 add_out_dtd(stream, VIP_SRCE_CHROMA);
1024 }
1026 static void enable_irqs(struct vip_dev *dev, int irq_num, int list_num)
1027 {
1028 u32 reg_addr = VIP_INT0_ENABLE0_SET +
1029 VIP_INTC_INTX_OFFSET * irq_num;
1031 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1033 vpdma_enable_list_complete_irq(dev->shared->vpdma,
1034 irq_num, list_num, true);
1035 }
1037 static void disable_irqs(struct vip_dev *dev, int irq_num, int list_num)
1038 {
1039 u32 reg_addr = VIP_INT0_ENABLE0_CLR +
1040 VIP_INTC_INTX_OFFSET * irq_num;
1042 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1044 vpdma_enable_list_complete_irq(dev->shared->vpdma,
1045 irq_num, list_num, false);
1046 }
1048 static void clear_irqs(struct vip_dev *dev, int irq_num, int list_num)
1049 {
1050 u32 reg_addr = VIP_INT0_STATUS0_CLR +
1051 VIP_INTC_INTX_OFFSET * irq_num;
1053 write_sreg(dev->shared, reg_addr, 1 << (list_num * 2));
1055 vpdma_clear_list_stat(dev->shared->vpdma, irq_num, dev->slice_id);
1056 }
1058 static void populate_desc_list(struct vip_stream *stream)
1059 {
1060 struct vip_port *port = stream->port;
1061 struct vip_dev *dev = port->dev;
1062 unsigned int list_length;
1064 stream->desc_next = stream->desc_list.buf.addr;
1065 add_stream_dtds(stream);
1067 list_length = stream->desc_next - stream->desc_list.buf.addr;
1068 vpdma_map_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
1069 }
1071 /*
1072 * start_dma - adds descriptors to the dma list and submits them.
1073 * Should be called after a new vb is queued and on a vpdma list
1074 * completion interrupt.
1075 */
1076 static void start_dma(struct vip_stream *stream, struct vip_buffer *buf)
1077 {
1078 struct vip_dev *dev = stream->port->dev;
1079 struct vpdma_data *vpdma = dev->shared->vpdma;
1080 int list_num = stream->list_num;
1081 dma_addr_t dma_addr;
1082 int drop_data;
1084 if (vpdma_list_busy(vpdma, list_num)) {
1085 vip_err(dev, "vpdma list busy, cannot post");
1086 return; /* nothing to do */
1087 }
1089 if (buf) {
1090 dma_addr = vb2_dma_contig_plane_dma_addr(&buf->vb, 0);
1091 drop_data = 0;
1092 vip_dbg(4, dev, "start_dma: buf:0x%08x, vb:0x%08x, dma_addr:0x%08x\n",
1093 (unsigned int)buf, (unsigned int)&buf->vb, dma_addr);
1094 } else {
1095 dma_addr = (dma_addr_t)NULL;
1096 drop_data = 1;
1097 vip_dbg(4, dev, "start_dma: dropped\n");
1098 }
1100 vpdma_update_dma_addr(dev->shared->vpdma, &stream->desc_list,
1101 dma_addr, stream->write_desc, drop_data, 0);
1103 if (stream->port->fmt->coplanar) {
1104 dma_addr += stream->width * stream->height;
1105 vpdma_update_dma_addr(dev->shared->vpdma, &stream->desc_list,
1106 dma_addr, stream->write_desc + 1, drop_data, 1);
1107 }
1109 vpdma_submit_descs(dev->shared->vpdma,
1110 &stream->desc_list, stream->list_num);
1111 }
1113 static void vip_schedule_next_buffer(struct vip_stream *stream)
1114 {
1115 struct vip_dev *dev = stream->port->dev;
1116 struct vip_buffer *buf;
1117 unsigned long flags;
1119 spin_lock_irqsave(&dev->slock, flags);
1120 if (list_empty(&stream->vidq)) {
1121 vip_dbg(4, dev, "Dropping frame\n");
1122 if (list_empty(&stream->dropq)) {
1123 vip_err(dev, "No dropq buffer left!");
1124 spin_unlock_irqrestore(&dev->slock, flags);
1125 return;
1126 }
1127 buf = list_entry(stream->dropq.next,
1128 struct vip_buffer, list);
1130 buf->drop = true;
1131 list_move_tail(&buf->list, &stream->post_bufs);
1132 buf = NULL;
1133 } else if (vb2_is_streaming(&stream->vb_vidq)) {
1134 buf = list_entry(stream->vidq.next,
1135 struct vip_buffer, list);
1136 buf->drop = false;
1137 list_move_tail(&buf->list, &stream->post_bufs);
1138 vip_dbg(4, dev, "added next buffer\n");
1139 } else {
1140 vip_err(dev, "IRQ occurred when not streaming\n");
1141 if (list_empty(&stream->dropq)) {
1142 vip_err(dev, "No dropq buffer left!");
1143 spin_unlock_irqrestore(&dev->slock, flags);
1144 return;
1145 }
1146 buf = list_entry(stream->dropq.next,
1147 struct vip_buffer, list);
1148 buf->drop = true;
1149 list_move_tail(&buf->list, &stream->post_bufs);
1150 buf = NULL;
1151 }
1153 spin_unlock_irqrestore(&dev->slock, flags);
1154 start_dma(stream, buf);
1155 }
1157 static void vip_process_buffer_complete(struct vip_stream *stream)
1158 {
1159 struct vip_dev *dev = stream->port->dev;
1160 struct vip_buffer *buf;
1161 struct vb2_buffer *vb = NULL;
1162 unsigned long flags, fld;
1164 buf = list_first_entry(&stream->post_bufs, struct vip_buffer, list);
1166 if (stream->port->flags & FLAG_INTERLACED) {
1167 vpdma_unmap_desc_buf(dev->shared->vpdma,
1168 &stream->desc_list.buf);
1170 fld = dtd_get_field(stream->write_desc);
1171 stream->field = fld ? V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
1173 vpdma_map_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
1174 }
1176 if (buf) {
1177 vip_dbg(4, dev, "vip buffer complete 0x%x, 0x%x\n",
1178 (unsigned int)buf, buf->drop);
1180 vb = &buf->vb;
1181 vb->v4l2_buf.field = stream->field;
1182 vb->v4l2_buf.sequence = stream->sequence;
1183 v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
1185 if (buf->drop) {
1186 spin_lock_irqsave(&dev->slock, flags);
1187 list_move_tail(&buf->list, &stream->dropq);
1188 spin_unlock_irqrestore(&dev->slock, flags);
1189 } else {
1190 spin_lock_irqsave(&dev->slock, flags);
1191 list_del(&buf->list);
1192 spin_unlock_irqrestore(&dev->slock, flags);
1193 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
1194 }
1195 } else {
1196 BUG();
1197 }
1199 stream->sequence++;
1200 }
1202 static irqreturn_t vip_irq(int irq_vip, void *data)
1203 {
1204 struct vip_dev *dev = (struct vip_dev *)data;
1205 struct vpdma_data *vpdma = dev->shared->vpdma;
1206 struct vip_stream *stream;
1207 int list_num;
1208 int irq_num = dev->slice_id;
1209 u32 irqst, reg_addr;
1211 if (!dev->shared)
1212 return IRQ_HANDLED;
1214 reg_addr = VIP_INT0_STATUS0 +
1215 VIP_INTC_INTX_OFFSET * irq_num;
1216 irqst = read_sreg(dev->shared, reg_addr);
1218 vip_dbg(8, dev, "IRQ %d VIP_INT%d_STATUS0 0x%x\n",
1219 irq_vip, irq_num, irqst);
1220 if (irqst) {
1221 reg_addr = VIP_INT0_STATUS0_CLR +
1222 VIP_INTC_INTX_OFFSET * irq_num;
1223 write_sreg(dev->shared, reg_addr, irqst);
1225 for (list_num = 0; list_num < 8; list_num++) {
1226 /* Check for LIST_COMPLETE IRQ */
1227 if (!(irqst & (1 << list_num * 2)))
1228 continue;
1230 vip_dbg(8, dev, "IRQ %d: handling LIST%d_COMPLETE\n",
1231 irq_num, list_num);
1233 stream = vpdma_hwlist_get_priv(vpdma, list_num);
1234 if (!stream || stream->list_num != list_num) {
1235 vip_err(dev, "IRQ occured for unused list");
1236 continue;
1237 }
1239 vpdma_clear_list_stat(vpdma, irq_num, list_num);
1241 if (dev->num_skip_irq)
1242 dev->num_skip_irq--;
1243 else
1244 vip_process_buffer_complete(stream);
1246 vip_schedule_next_buffer(stream);
1247 irqst &= ~((1 << list_num * 2));
1248 }
1249 }
1251 return IRQ_HANDLED;
1252 }
1254 /*
1255 * video ioctls
1256 */
1257 static int vip_querycap(struct file *file, void *priv,
1258 struct v4l2_capability *cap)
1259 {
1260 strncpy(cap->driver, VIP_MODULE_NAME, sizeof(cap->driver) - 1);
1261 strncpy(cap->card, VIP_MODULE_NAME, sizeof(cap->card) - 1);
1262 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1263 VIP_MODULE_NAME);
1264 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE;
1265 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1266 return 0;
1267 }
1269 static int vip_enuminput(struct file *file, void *priv,
1270 struct v4l2_input *inp)
1271 {
1272 struct vip_stream *stream = file2stream(file);
1274 if (inp->index)
1275 return -EINVAL;
1277 inp->type = V4L2_INPUT_TYPE_CAMERA;
1278 sprintf(inp->name, "camera %u", stream->vfd->num);
1280 return 0;
1281 }
1283 static int vip_g_input(struct file *file, void *priv, unsigned int *i)
1284 {
1285 *i = 0;
1286 return 0;
1287 }
1289 static int vip_s_input(struct file *file, void *priv, unsigned int i)
1290 {
1291 if (i != 0)
1292 return -EINVAL;
1293 return 0;
1294 }
1296 static int vip_querystd(struct file *file, void *fh, v4l2_std_id *std)
1297 {
1298 struct vip_stream *stream = file2stream(file);
1299 struct vip_dev *dev = stream->port->dev;
1301 v4l2_subdev_call(dev->sensor, video, querystd, std);
1302 return 0;
1303 }
1305 static int vip_g_std(struct file *file, void *fh, v4l2_std_id *std)
1306 {
1307 struct vip_stream *stream = file2stream(file);
1308 struct vip_dev *dev = stream->port->dev;
1310 *std = 0;
1311 v4l2_subdev_call(dev->sensor, video, g_std_output, std);
1312 return 0;
1313 }
1315 static int vip_s_std(struct file *file, void *fh, v4l2_std_id std)
1316 {
1317 struct vip_stream *stream = file2stream(file);
1318 struct vip_dev *dev = stream->port->dev;
1320 v4l2_subdev_call(dev->sensor, video, s_std_output, std);
1321 return 0;
1322 }
1324 static int vip_enum_fmt_vid_cap(struct file *file, void *priv,
1325 struct v4l2_fmtdesc *f)
1326 {
1327 struct vip_stream *stream = file2stream(file);
1328 struct vip_dev *dev = stream->port->dev;
1329 struct vip_fmt *fmt = NULL;
1331 vip_dbg(3, dev, "enum_fmt index:%d\n", f->index);
1333 if (f->index >= dev->num_active_fmt)
1334 return -EINVAL;
1336 fmt = dev->active_fmt[f->index];
1338 strncpy(f->description, fmt->name, sizeof(f->description) - 1);
1339 f->pixelformat = fmt->fourcc;
1341 vip_dbg(3, dev, "enum_fmt fourcc:%s description:%s\n",
1342 fourcc_to_str(f->pixelformat), f->description);
1344 return 0;
1345 }
1347 /*
1348 * TODO: Change from hard coding values to reading these through
1349 * IOCTLS directly from sensor
1350 */
1352 static int vip_enum_framesizes(struct file *file, void *priv,
1353 struct v4l2_frmsizeenum *f)
1354 {
1355 struct vip_stream *stream = file2stream(file);
1356 struct vip_dev *dev = stream->port->dev;
1357 struct vip_port *port = stream->port;
1358 struct vip_fmt *fmt;
1360 fmt = find_port_format_by_pix(port, f->pixel_format);
1361 if (!fmt)
1362 return -EINVAL;
1364 return v4l2_subdev_call(dev->sensor, video, enum_framesizes, f);
1365 }
1367 static int vip_enum_frameintervals(struct file *file, void *priv,
1368 struct v4l2_frmivalenum *f)
1369 {
1370 struct vip_stream *stream = file2stream(file);
1371 struct vip_dev *dev = stream->port->dev;
1372 struct vip_port *port = stream->port;
1373 struct v4l2_frmsizeenum fsize;
1374 struct vip_fmt *fmt;
1375 int ret;
1377 if (f->index)
1378 return -EINVAL;
1380 fmt = find_port_format_by_pix(port, f->pixel_format);
1381 if (!fmt)
1382 return -EINVAL;
1384 /* check for valid width/height */
1385 ret = 0;
1386 for (fsize.index = 0; ; fsize.index++) {
1387 ret = v4l2_subdev_call(dev->sensor, video,
1388 enum_framesizes, &fsize);
1389 if (ret) {
1390 return -EINVAL;
1391 }
1393 if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
1394 if ((f->width == fsize.discrete.width) &&
1395 (f->height == fsize.discrete.height))
1396 break;
1397 } else if ((fsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) ||
1398 (fsize.type == V4L2_FRMSIZE_TYPE_STEPWISE)) {
1399 if ((f->width >= fsize.stepwise.min_width) &&
1400 (f->width <= fsize.stepwise.max_width) &&
1401 (f->height >= fsize.stepwise.min_height) &&
1402 (f->height <= fsize.stepwise.max_height))
1403 break;
1404 } else {
1405 return -EINVAL;
1406 }
1407 }
1409 f->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1410 f->discrete.numerator = 1;
1411 f->discrete.denominator = 30;
1413 return 0;
1414 }
1416 static int vip_s_parm(struct file *file, void *priv,
1417 struct v4l2_streamparm *parm)
1418 {
1419 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1420 return -EINVAL;
1422 parm->parm.capture.timeperframe.numerator = 1;
1423 parm->parm.capture.timeperframe.denominator = 30;
1425 return 0;
1426 }
1428 static int vip_calc_format_size(struct vip_port *port,
1429 struct vip_fmt *fmt,
1430 struct v4l2_format *f)
1431 {
1432 struct vip_dev *dev = port->dev;
1433 enum v4l2_field *field;
1435 if (!fmt) {
1436 vip_dbg(2, dev,
1437 "no vip_fmt format provided!\n");
1438 return -EINVAL;
1439 }
1441 field = &f->fmt.pix.field;
1442 if (*field == V4L2_FIELD_ANY)
1443 *field = V4L2_FIELD_NONE;
1444 else if (V4L2_FIELD_NONE != *field && V4L2_FIELD_ALTERNATE != *field)
1445 return -EINVAL;
1447 v4l_bound_align_image(&f->fmt.pix.width, MIN_W, MAX_W, W_ALIGN,
1448 &f->fmt.pix.height, MIN_H, MAX_H, H_ALIGN,
1449 S_ALIGN);
1451 f->fmt.pix.bytesperline = f->fmt.pix.width *
1452 (fmt->vpdma_fmt[0]->depth >> 3);
1453 f->fmt.pix.bytesperline = ALIGN(f->fmt.pix.bytesperline,
1454 VPDMA_STRIDE_ALIGN);
1455 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.width *
1456 (fmt->vpdma_fmt[0]->depth +
1457 (fmt->coplanar ? fmt->vpdma_fmt[1]->depth : 0)) >> 3;
1458 f->fmt.pix.colorspace = fmt->colorspace;
1459 f->fmt.pix.priv = 0;
1461 vip_dbg(3, dev, "calc_format_size: fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
1462 fourcc_to_str(f->fmt.pix.pixelformat),
1463 f->fmt.pix.width, f->fmt.pix.height,
1464 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1466 return 0;
1467 }
1469 static int vip_try_fmt_vid_cap(struct file *file, void *priv,
1470 struct v4l2_format *f)
1471 {
1472 struct vip_stream *stream = file2stream(file);
1473 struct vip_port *port = stream->port;
1474 struct vip_dev *dev = port->dev;
1475 struct vip_fmt *fmt;
1477 vip_dbg(3, dev, "try_fmt fourcc:%s size: %dx%d\n",
1478 fourcc_to_str(f->fmt.pix.pixelformat),
1479 f->fmt.pix.width, f->fmt.pix.height);
1481 fmt = find_port_format_by_pix(port, f->fmt.pix.pixelformat);
1482 if (!fmt) {
1483 vip_dbg(2, dev,
1484 "Fourcc format (0x%08x) not found.\n",
1485 f->fmt.pix.pixelformat);
1487 /* Just get the first one enumerated */
1488 fmt = dev->active_fmt[0];
1489 f->fmt.pix.pixelformat = fmt->fourcc;
1490 }
1492 /* That we have a fmt calculate imagesize and bytesperline */
1493 return vip_calc_format_size(port, fmt, f);
1494 }
1496 static int vip_g_fmt_vid_cap(struct file *file, void *priv,
1497 struct v4l2_format *f)
1498 {
1499 struct vip_stream *stream = file2stream(file);
1500 struct vip_port *port = stream->port;
1501 struct vip_dev *dev = stream->port->dev;
1502 struct vip_fmt *fmt = port->fmt;
1504 /* Use last known values or defaults */
1505 f->fmt.pix.width = stream->width;
1506 f->fmt.pix.height = stream->height;
1507 f->fmt.pix.pixelformat = port->fmt->fourcc;
1508 f->fmt.pix.field = stream->sup_field;
1509 f->fmt.pix.colorspace = port->fmt->colorspace;
1510 f->fmt.pix.bytesperline = stream->bytesperline;
1511 f->fmt.pix.sizeimage = stream->sizeimage;
1513 vip_dbg(3, dev,
1514 "g_fmt fourcc:%s code: %04x size: %dx%d bpl:%d img_size:%d\n",
1515 fourcc_to_str(f->fmt.pix.pixelformat),
1516 fmt->code,
1517 f->fmt.pix.width, f->fmt.pix.height,
1518 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1519 vip_dbg(3, dev, "g_fmt vpdma data type: 0x%02X\n",
1520 port->fmt->vpdma_fmt[0]->data_type);
1522 return 0;
1523 }
1525 static int vip_s_fmt_vid_cap(struct file *file, void *priv,
1526 struct v4l2_format *f)
1527 {
1528 struct vip_stream *stream = file2stream(file);
1529 struct vip_port *port = stream->port;
1530 struct vip_dev *dev = port->dev;
1531 struct v4l2_subdev_format sfmt;
1532 struct v4l2_mbus_framefmt *mf;
1533 int ret;
1535 vip_dbg(3, dev, "s_fmt input fourcc:%s size: %dx%d\n",
1536 fourcc_to_str(f->fmt.pix.pixelformat),
1537 f->fmt.pix.width, f->fmt.pix.height);
1539 ret = vip_try_fmt_vid_cap(file, priv, f);
1540 if (ret)
1541 return ret;
1543 vip_dbg(3, dev, "s_fmt try_fmt fourcc:%s size: %dx%d\n",
1544 fourcc_to_str(f->fmt.pix.pixelformat),
1545 f->fmt.pix.width, f->fmt.pix.height);
1547 if (vb2_is_busy(&stream->vb_vidq)) {
1548 vip_err(dev, "%s queue busy\n", __func__);
1549 return -EBUSY;
1550 }
1552 port->fmt = find_port_format_by_pix(port,
1553 f->fmt.pix.pixelformat);
1554 stream->width = f->fmt.pix.width;
1555 stream->height = f->fmt.pix.height;
1556 stream->bytesperline = f->fmt.pix.bytesperline;
1557 stream->sizeimage = f->fmt.pix.sizeimage;
1558 stream->sup_field = f->fmt.pix.field;
1560 port->c_rect.left = 0;
1561 port->c_rect.top = 0;
1562 port->c_rect.width = stream->width;
1563 port->c_rect.height = stream->height;
1565 if (stream->sup_field == V4L2_FIELD_ALTERNATE)
1566 port->flags |= FLAG_INTERLACED;
1567 else
1568 port->flags &= ~FLAG_INTERLACED;
1570 vip_dbg(3, dev, "s_fmt fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
1571 fourcc_to_str(f->fmt.pix.pixelformat),
1572 f->fmt.pix.width, f->fmt.pix.height,
1573 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
1575 mf = &sfmt.format;
1576 v4l2_fill_mbus_format(mf, &f->fmt.pix, port->fmt->code);
1578 /* Save it */
1579 port->mbus_framefmt = *mf;
1581 vip_dbg(3, dev, "s_fmt pix_to_mbus mbus_code: %04X size: %dx%d\n",
1582 mf->code,
1583 mf->width, mf->height);
1585 ret = v4l2_subdev_call(dev->sensor, video, try_mbus_fmt, mf);
1586 if (ret) {
1587 vip_dbg(1, dev, "try_mbus_fmt failed in subdev\n");
1588 return ret;
1589 }
1590 vip_dbg(3, dev, "s_fmt subdev try_fmt mbus_code: %04X size: %dx%d\n",
1591 mf->code,
1592 mf->width, mf->height);
1593 ret = v4l2_subdev_call(dev->sensor, video, s_mbus_fmt, mf);
1594 if (ret) {
1595 vip_dbg(1, dev, "s_mbus_fmt failed in subdev\n");
1596 return ret;
1597 }
1598 vip_dbg(3, dev, "s_fmt subdev s_fmt mbus_code: %04X size: %dx%d\n",
1599 mf->code,
1600 mf->width, mf->height);
1601 vip_dbg(3, dev, "s_fmt vpdma data type: 0x%02X\n",
1602 port->fmt->vpdma_fmt[0]->data_type);
1604 return 0;
1605 }
1607 /*
1608 * Set the registers that are modified when the video format changes.
1609 */
1610 static void set_fmt_params(struct vip_stream *stream)
1611 {
1612 struct vip_dev *dev = stream->port->dev;
1613 int data_path_reg;
1615 stream->sequence = 0;
1616 stream->field = V4L2_FIELD_TOP;
1618 if (stream->port->fmt->colorspace == V4L2_COLORSPACE_SRGB) {
1619 vip_set_slice_path(dev, VIP_RGB_OUT_LO_DATA_SELECT);
1620 /* Set alpha component in background color */
1621 vpdma_set_bg_color(dev->shared->vpdma,
1622 (struct vpdma_data_format *)
1623 stream->port->fmt->vpdma_fmt[0],
1624 0xff);
1625 }
1627 data_path_reg = VIP_VIP1_DATA_PATH_SELECT + 4 * dev->slice_id;
1628 if (stream->port->fmt->coplanar) {
1629 stream->port->flags &= ~FLAG_MULT_PORT;
1630 write_vreg(dev, data_path_reg, 0x600);
1631 } else {
1632 stream->port->flags |= FLAG_MULT_PORT;
1633 write_vreg(dev, data_path_reg, 0x8000);
1634 }
1635 }
1637 static int vip_g_selection(struct file *file, void *fh,
1638 struct v4l2_selection *s)
1639 {
1640 struct vip_stream *stream = file2stream(file);
1642 switch (s->target) {
1643 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1644 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1645 case V4L2_SEL_TGT_CROP_BOUNDS:
1646 case V4L2_SEL_TGT_CROP_DEFAULT:
1647 s->r.left = 0;
1648 s->r.top = 0;
1649 s->r.width = stream->width;
1650 s->r.height = stream->height;
1651 return 0;
1653 case V4L2_SEL_TGT_COMPOSE:
1654 case V4L2_SEL_TGT_CROP:
1655 s->r = stream->port->c_rect;
1656 return 0;
1657 }
1659 return -EINVAL;
1660 }
1662 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1663 {
1664 if (a->left < b->left || a->top < b->top)
1665 return 0;
1666 if (a->left + a->width > b->left + b->width)
1667 return 0;
1668 if (a->top + a->height > b->top + b->height)
1669 return 0;
1671 return 1;
1672 }
1674 static int vip_s_selection(struct file *file, void *fh,
1675 struct v4l2_selection *s)
1676 {
1677 struct vip_stream *stream = file2stream(file);
1678 struct vip_port *port = stream->port;
1679 struct v4l2_rect r = s->r;
1681 v4l_bound_align_image(&r.width, 0, stream->width, 0,
1682 &r.height, 0, stream->height, 0, 0);
1684 r.left = clamp_t(unsigned int, r.left, 0, stream->width - r.width);
1685 r.top = clamp_t(unsigned int, r.top, 0, stream->height - r.height);
1687 if (s->flags & V4L2_SEL_FLAG_LE && !enclosed_rectangle(&r, &s->r))
1688 return -ERANGE;
1690 if (s->flags & V4L2_SEL_FLAG_GE && !enclosed_rectangle(&s->r, &r))
1691 return -ERANGE;
1693 s->r = stream->port->c_rect = r;
1695 set_fmt_params(stream);
1697 vip_dbg(1, port->dev, "cropped (%d,%d)/%dx%d of %dx%d\n",
1698 r.left, r.top, r.width, r.height,
1699 stream->width, stream->height);
1701 return 0;
1702 }
1704 static long vip_ioctl_default(struct file *file, void *fh, bool valid_prio,
1705 unsigned int cmd, void *arg)
1706 {
1707 struct vip_stream *stream = file2stream(file);
1708 struct vip_port *port = stream->port;
1710 if (!valid_prio) {
1711 vip_err(port->dev, "%s device busy\n", __func__);
1712 return -EBUSY;
1713 }
1715 switch (cmd) {
1716 default:
1717 return -ENOTTY;
1718 }
1719 }
1721 static const struct v4l2_ioctl_ops vip_ioctl_ops = {
1722 .vidioc_querycap = vip_querycap,
1723 .vidioc_enum_input = vip_enuminput,
1724 .vidioc_g_input = vip_g_input,
1725 .vidioc_s_input = vip_s_input,
1727 .vidioc_querystd = vip_querystd,
1728 .vidioc_g_std = vip_g_std,
1729 .vidioc_s_std = vip_s_std,
1731 .vidioc_enum_fmt_vid_cap = vip_enum_fmt_vid_cap,
1732 .vidioc_g_fmt_vid_cap = vip_g_fmt_vid_cap,
1733 .vidioc_try_fmt_vid_cap = vip_try_fmt_vid_cap,
1734 .vidioc_s_fmt_vid_cap = vip_s_fmt_vid_cap,
1736 .vidioc_enum_frameintervals = vip_enum_frameintervals,
1737 .vidioc_enum_framesizes = vip_enum_framesizes,
1738 .vidioc_s_parm = vip_s_parm,
1740 .vidioc_g_selection = vip_g_selection,
1741 .vidioc_s_selection = vip_s_selection,
1742 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1743 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1744 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1745 .vidioc_querybuf = vb2_ioctl_querybuf,
1746 .vidioc_qbuf = vb2_ioctl_qbuf,
1747 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1749 .vidioc_streamon = vb2_ioctl_streamon,
1750 .vidioc_streamoff = vb2_ioctl_streamoff,
1751 .vidioc_log_status = v4l2_ctrl_log_status,
1752 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1753 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1754 .vidioc_default = vip_ioctl_default,
1755 };
1757 /*
1758 * Videobuf operations
1759 */
1760 static int vip_queue_setup(struct vb2_queue *vq,
1761 const struct v4l2_format *fmt,
1762 unsigned int *nbuffers, unsigned int *nplanes,
1763 unsigned int sizes[], void *alloc_ctxs[])
1764 {
1765 struct vip_stream *stream = vb2_get_drv_priv(vq);
1766 struct vip_dev *dev = stream->port->dev;
1768 *nplanes = 1;
1769 sizes[0] = stream->sizeimage;
1770 alloc_ctxs[0] = dev->alloc_ctx;
1771 vip_dbg(1, dev, "get %d buffer(s) of size %d each.\n",
1772 *nbuffers, sizes[0]);
1774 return 0;
1775 }
1777 static int vip_buf_prepare(struct vb2_buffer *vb)
1778 {
1779 struct vip_stream *stream = vb2_get_drv_priv(vb->vb2_queue);
1780 struct vip_dev *dev = stream->port->dev;
1782 if (vb2_plane_size(vb, 0) < stream->sizeimage) {
1783 vip_dbg(1, dev,
1784 "%s data will not fit into plane (%lu < %lu)\n",
1785 __func__, vb2_plane_size(vb, 0),
1786 (long)stream->sizeimage);
1787 return -EINVAL;
1788 }
1790 vb2_set_plane_payload(vb, 0, stream->sizeimage);
1792 return 0;
1793 }
1795 static void vip_buf_queue(struct vb2_buffer *vb)
1796 {
1797 struct vip_stream *stream = vb2_get_drv_priv(vb->vb2_queue);
1798 struct vip_dev *dev = stream->port->dev;
1799 struct vip_buffer *buf = container_of(vb, struct vip_buffer, vb);
1800 unsigned long flags;
1802 spin_lock_irqsave(&dev->slock, flags);
1803 list_add_tail(&buf->list, &stream->vidq);
1804 spin_unlock_irqrestore(&dev->slock, flags);
1805 }
1807 static int vip_start_streaming(struct vb2_queue *vq, unsigned int count)
1808 {
1809 struct vip_stream *stream = vb2_get_drv_priv(vq);
1810 struct vip_port *port = stream->port;
1811 struct vip_dev *dev = port->dev;
1812 struct vip_buffer *buf;
1813 unsigned long flags;
1814 int ret;
1816 set_fmt_params(stream);
1817 vip_setup_parser(dev->ports[0]);
1819 buf = list_entry(stream->vidq.next,
1820 struct vip_buffer, list);
1822 vip_dbg(2, dev, "start_streaming: buf 0x%x %d\n",
1823 (unsigned int)buf, count);
1824 buf->drop = false;
1825 stream->sequence = 0;
1826 stream->field = V4L2_FIELD_TOP;
1828 if (dev->sensor) {
1829 ret = v4l2_subdev_call(dev->sensor, video, s_stream, 1);
1830 if (ret) {
1831 vip_dbg(1, dev, "stream on failed in subdev\n");
1832 return ret;
1833 }
1834 }
1836 populate_desc_list(stream);
1838 /* The first few VPDMA ListComplete interrupts fire pretty quiclky
1839 * until the internal VPDMA descriptor fifo is full.
1840 * The subsequent ListComplete interrupts will fire at the actual
1841 * capture frame rate. The first few interrupts are therefore used
1842 * only to queue up descriptors, and then they will also be used
1843 * as End of Frame (EOF) event
1844 */
1845 dev->num_skip_irq = VIP_VPDMA_FIFO_SIZE;
1847 spin_lock_irqsave(&dev->slock, flags);
1848 if (vpdma_list_busy(dev->shared->vpdma, stream->list_num)) {
1849 spin_unlock_irqrestore(&dev->slock, flags);
1850 vpdma_unmap_desc_buf(dev->shared->vpdma,
1851 &stream->desc_list.buf);
1852 vpdma_reset_desc_list(&stream->desc_list);
1853 return -EBUSY;
1854 }
1856 list_move_tail(&buf->list, &stream->post_bufs);
1857 spin_unlock_irqrestore(&dev->slock, flags);
1859 vip_dbg(2, dev, "start_streaming: start_dma buf 0x%x\n",
1860 (unsigned int)buf);
1861 start_dma(stream, buf);
1863 /* We enable the irq after posting the vpdma descriptor
1864 * to prevent sprurious interrupt coming in before the
1865 * vb2 layer is completely ready to handle them
1866 * otherwise the vb2_streaming test would fail early on
1867 */
1868 enable_irqs(dev, dev->slice_id, stream->list_num);
1870 return 0;
1871 }
1873 /*
1874 * Abort streaming and wait for last buffer
1875 */
1876 static int vip_stop_streaming(struct vb2_queue *vq)
1877 {
1878 struct vip_stream *stream = vb2_get_drv_priv(vq);
1879 struct vip_port *port = stream->port;
1880 struct vip_dev *dev = port->dev;
1881 struct vip_buffer *buf;
1882 int ret;
1884 if (dev->sensor) {
1885 ret = v4l2_subdev_call(dev->sensor, video, s_stream, 0);
1886 if (ret)
1887 vip_dbg(1, dev, "stream on failed in subdev\n");
1888 }
1890 disable_irqs(dev, dev->slice_id, stream->list_num);
1891 clear_irqs(dev, dev->slice_id, stream->list_num);
1892 stop_dma(stream);
1894 /* release all active buffers */
1895 while (!list_empty(&stream->post_bufs)) {
1896 buf = list_entry(stream->post_bufs.next,
1897 struct vip_buffer, list);
1898 list_del(&buf->list);
1899 if (buf->drop == 1)
1900 list_add_tail(&buf->list, &stream->dropq);
1901 else
1902 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1903 }
1904 while (!list_empty(&stream->vidq)) {
1905 buf = list_entry(stream->vidq.next, struct vip_buffer, list);
1906 list_del(&buf->list);
1907 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1908 }
1910 if (!vb2_is_streaming(vq))
1911 return 0;
1913 vpdma_unmap_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
1914 vpdma_reset_desc_list(&stream->desc_list);
1916 return 0;
1917 }
1919 /*
1920 * Lock access to the device
1921 */
1922 static void vip_lock(struct vb2_queue *vq)
1923 {
1924 struct vip_stream *stream = vb2_get_drv_priv(vq);
1926 mutex_lock(&stream->port->dev->mutex);
1927 }
1929 static void vip_unlock(struct vb2_queue *vq)
1930 {
1931 struct vip_stream *stream = vb2_get_drv_priv(vq);
1932 mutex_unlock(&stream->port->dev->mutex);
1933 }
1935 static struct vb2_ops vip_video_qops = {
1936 .queue_setup = vip_queue_setup,
1937 .buf_prepare = vip_buf_prepare,
1938 .buf_queue = vip_buf_queue,
1939 .start_streaming = vip_start_streaming,
1940 .stop_streaming = vip_stop_streaming,
1941 .wait_prepare = vip_unlock,
1942 .wait_finish = vip_lock,
1943 };
1945 /*
1946 * File operations
1947 */
1949 static int vip_init_dev(struct vip_dev *dev)
1950 {
1951 if (dev->num_ports != 0)
1952 goto done;
1954 vip_set_clock_enable(dev, 1);
1955 done:
1956 dev->num_ports++;
1958 return 0;
1959 }
1961 static int vip_init_port(struct vip_port *port)
1962 {
1963 int ret;
1964 struct vip_dev *dev = port->dev;
1965 struct vip_fmt *fmt;
1966 struct v4l2_mbus_framefmt *mbus_fmt = &port->mbus_framefmt;
1968 if (port->num_streams != 0)
1969 goto done;
1971 ret = vip_init_dev(port->dev);
1972 if (ret)
1973 goto done;
1975 /* Get subdevice current frame format */
1976 ret = v4l2_subdev_call(dev->sensor, video, g_mbus_fmt, mbus_fmt);
1977 if (ret)
1978 vip_dbg(1, dev, "init_port g_mbus_fmt failed in subdev\n");
1980 /* try to find one that matches */
1981 fmt = find_port_format_by_pix(port, mbus_fmt->code);
1982 if (!fmt) {
1983 vip_dbg(1, dev, "subdev default mbus_fmt %04x is not matched.\n",
1984 mbus_fmt->code);
1985 /* if all else fails just pick the first one */
1986 fmt = dev->active_fmt[0];
1988 mbus_fmt->code = fmt->code;
1989 ret = v4l2_subdev_call(dev->sensor, video,
1990 s_mbus_fmt, mbus_fmt);
1991 if (ret)
1992 vip_dbg(1, dev, "init_port s_mbus_fmt failed in subdev\n");
1993 }
1995 /* Assign current format */
1996 port->fmt = fmt;
1998 vip_dbg(3, dev, "vip_init_port: g_mbus_fmt subdev mbus_code: %04X fourcc:%s size: %dx%d\n",
1999 fmt->code,
2000 fourcc_to_str(fmt->fourcc),
2001 mbus_fmt->width, mbus_fmt->height);
2003 if (mbus_fmt->field == V4L2_FIELD_ALTERNATE)
2004 port->flags |= FLAG_INTERLACED;
2005 else
2006 port->flags &= ~FLAG_INTERLACED;
2008 port->c_rect.left = 0;
2009 port->c_rect.top = 0;
2010 port->c_rect.width = mbus_fmt->width;
2011 port->c_rect.height = mbus_fmt->height;
2013 done:
2014 port->num_streams++;
2015 return 0;
2016 }
2018 static int vip_init_stream(struct vip_stream *stream)
2019 {
2020 struct vip_port *port = stream->port;
2021 struct vip_dev *dev = port->dev;
2022 struct vip_fmt *fmt;
2023 struct v4l2_mbus_framefmt *mbus_fmt;
2024 struct v4l2_format f;
2025 int ret;
2027 ret = vip_init_port(port);
2028 if (ret != 0)
2029 return ret;
2031 fmt = port->fmt;
2032 mbus_fmt = &port->mbus_framefmt;
2034 /* Properly calculate the sizeimage and bytesperline values. */
2035 v4l2_fill_pix_format(&f.fmt.pix, mbus_fmt);
2036 f.fmt.pix.pixelformat = fmt->fourcc;
2037 ret = vip_calc_format_size(port, fmt, &f);
2038 if (ret)
2039 return ret;
2041 stream->width = f.fmt.pix.width;
2042 stream->height = f.fmt.pix.height;
2043 stream->sup_field = f.fmt.pix.field;
2044 stream->bytesperline = f.fmt.pix.bytesperline;
2045 stream->sizeimage = f.fmt.pix.sizeimage;
2047 vip_dbg(3, dev, "init_stream fourcc:%s size: %dx%d bpl:%d img_size:%d\n",
2048 fourcc_to_str(f.fmt.pix.pixelformat),
2049 f.fmt.pix.width, f.fmt.pix.height,
2050 f.fmt.pix.bytesperline, f.fmt.pix.sizeimage);
2051 vip_dbg(3, dev, "init_stream vpdma data type: 0x%02X\n",
2052 port->fmt->vpdma_fmt[0]->data_type);
2054 ret = vpdma_create_desc_list(&stream->desc_list, VIP_DESC_LIST_SIZE,
2055 VPDMA_LIST_TYPE_NORMAL);
2057 if (ret != 0)
2058 return ret;
2060 stream->write_desc = (struct vpdma_dtd *)stream->desc_list.buf.addr
2061 + 15;
2062 return 0;
2063 }
2065 static void vip_release_dev(struct vip_dev *dev)
2066 {
2067 /*
2068 * On last close, disable clocks to conserve power
2069 */
2071 if (--dev->num_ports == 0)
2072 vip_set_clock_enable(dev, 0);
2073 }
2075 static int vip_setup_parser(struct vip_port *port)
2076 {
2077 struct vip_dev *dev = port->dev;
2078 struct v4l2_of_endpoint *endpoint = dev->endpoint;
2079 int iface = DUAL_8B_INTERFACE;
2080 int sync_type, pclk_type;
2081 unsigned int flags;
2083 flags = endpoint->bus.parallel.flags;
2084 vip_reset_port(port);
2085 vip_set_port_enable(port, 1);
2087 if (endpoint->bus_type == V4L2_MBUS_BT656) {
2088 iface = DUAL_8B_INTERFACE;
2090 /* Ideally, this should come from sensor
2091 port->fmt can be anything once CSC is enabled */
2092 if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
2093 sync_type = EMBEDDED_SYNC_SINGLE_RGB_OR_YUV444;
2094 else {
2095 switch (endpoint->bus.parallel.num_channels) {
2096 case 4:
2097 sync_type = EMBEDDED_SYNC_4X_MULTIPLEXED_YUV422;
2098 break;
2099 case 2:
2100 sync_type = EMBEDDED_SYNC_2X_MULTIPLEXED_YUV422;
2101 break;
2102 case 1:
2103 default:
2104 sync_type =
2105 EMBEDDED_SYNC_LINE_MULTIPLEXED_YUV422;
2106 }
2107 }
2109 } else if (endpoint->bus_type == V4L2_MBUS_PARALLEL) {
2110 switch (endpoint->bus.parallel.bus_width) {
2111 case 24:
2112 iface = SINGLE_24B_INTERFACE;
2113 break;
2114 case 16:
2115 iface = SINGLE_16B_INTERFACE;
2116 break;
2117 case 8:
2118 default:
2119 iface = DUAL_8B_INTERFACE;
2120 }
2122 if (port->fmt->colorspace == V4L2_COLORSPACE_SRGB)
2123 sync_type = DISCRETE_SYNC_SINGLE_RGB_24B;
2124 else
2125 sync_type = DISCRETE_SYNC_SINGLE_YUV422;
2127 if (flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH |
2128 V4L2_MBUS_HSYNC_ACTIVE_LOW))
2129 vip_set_vsync_polarity(port,
2130 flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH ? 1 : 0);
2132 if (flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH |
2133 V4L2_MBUS_VSYNC_ACTIVE_LOW))
2134 vip_set_hsync_polarity(port,
2135 flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH ? 1 : 0);
2137 vip_xtra_set_repack_sel(port, 0);
2138 vip_set_actvid_hsync_n(port, 0);
2139 vip_set_actvid_polarity(port, 1);
2140 vip_set_discrete_basic_mode(port);
2142 } else {
2143 vip_err(dev, "Device doesn't support CSI2");
2144 return -EINVAL;
2145 }
2147 pclk_type = flags & V4L2_MBUS_PCLK_SAMPLE_RISING ? 0 : 1;
2148 vip_set_pclk_polarity(port, pclk_type);
2149 vip_set_data_interface(port, iface);
2150 vip_sync_type(port, sync_type);
2151 return 0;
2152 }
2154 static void vip_release_stream(struct vip_stream *stream)
2155 {
2156 struct vip_dev *dev = stream->port->dev;
2158 vpdma_unmap_desc_buf(dev->shared->vpdma, &stream->desc_list.buf);
2159 vpdma_free_desc_buf(&stream->desc_list.buf);
2160 vpdma_free_desc_list(&stream->desc_list);
2161 }
2163 static void stop_dma(struct vip_stream *stream)
2164 {
2165 struct vip_dev *dev = stream->port->dev;
2166 int ch, size = 0;
2168 /* Create a list of channels to be cleared */
2169 for (ch = 0; ch < VPDMA_MAX_CHANNELS; ch++) {
2170 if (stream->vpdma_channels[ch] == 1) {
2171 stream->vpdma_channels[size++] = ch;
2172 vip_dbg(2, dev, "Clear channel no: %d\n", ch);
2173 }
2174 }
2176 /* Clear all the used channels for the list */
2177 vpdma_list_cleanup(dev->shared->vpdma, stream->list_num,
2178 stream->vpdma_channels, size);
2180 for (ch = 0; ch < VPDMA_MAX_CHANNELS; ch++)
2181 stream->vpdma_channels[ch] = 0;
2182 }
2184 static int vip_open(struct file *file)
2185 {
2186 struct vip_stream *stream = video_drvdata(file);
2187 struct vip_port *port = stream->port;
2188 struct vip_dev *dev = port->dev;
2189 struct v4l2_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
2190 int ret = 0;
2192 vip_dbg(2, dev, "vip_open\n");
2194 file->private_data = fh;
2195 if (fh == NULL)
2196 return -ENOMEM;
2198 mutex_lock(&dev->mutex);
2200 v4l2_fh_init(fh, video_devdata(file));
2201 v4l2_fh_add(fh);
2203 /*
2204 * If this is the first open file.
2205 * Then initialize hw module.
2206 */
2207 if (v4l2_fh_is_singular_file(file)) {
2208 if (vip_init_stream(stream)) {
2209 ret = -ENODEV;
2210 goto free_fh;
2211 }
2212 vip_dbg(1, dev, "Created stream instance %p\n", stream);
2213 }
2215 mutex_unlock(&dev->mutex);
2216 return 0;
2218 free_fh:
2219 mutex_unlock(&dev->mutex);
2220 if (fh) {
2221 v4l2_fh_del(fh);
2222 v4l2_fh_exit(fh);
2223 kfree(fh);
2224 }
2225 return ret;
2226 }
2228 static int vip_release(struct file *file)
2229 {
2230 struct vip_stream *stream = video_drvdata(file);
2231 struct vip_port *port = stream->port;
2232 struct vip_dev *dev = port->dev;
2233 struct vb2_queue *q = &stream->vb_vidq;
2235 vip_dbg(2, dev, "vip_release\n");
2237 /*
2238 * If this is the last open file.
2239 * Then de-initialize hw module.
2240 */
2241 if (v4l2_fh_is_singular_file(file)) {
2242 mutex_lock(&dev->mutex);
2244 vip_stop_streaming(q);
2245 vip_release_stream(stream);
2247 if (--port->num_streams == 0)
2248 vip_release_dev(port->dev);
2250 mutex_unlock(&dev->mutex);
2251 vip_dbg(1, dev, "Releasing stream instance %p\n", stream);
2252 }
2254 return vb2_fop_release(file);
2255 }
2257 static const struct v4l2_file_operations vip_fops = {
2258 .owner = THIS_MODULE,
2259 .open = vip_open,
2260 .release = vip_release,
2261 .poll = vb2_fop_poll,
2262 .unlocked_ioctl = video_ioctl2,
2263 .mmap = vb2_fop_mmap,
2264 };
2266 static struct video_device vip_videodev = {
2267 .name = VIP_MODULE_NAME,
2268 .fops = &vip_fops,
2269 .ioctl_ops = &vip_ioctl_ops,
2270 .minor = -1,
2271 .release = video_device_release,
2272 };
2274 static int alloc_stream(struct vip_port *port, int stream_id, int vfl_type)
2275 {
2276 struct vip_stream *stream;
2277 struct vip_dev *dev = port->dev;
2278 struct vb2_queue *q;
2279 struct video_device *vfd;
2280 struct vip_buffer *buf;
2281 int ret, i;
2283 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
2284 if (!stream)
2285 return -ENOMEM;
2287 stream->port = port;
2288 stream->stream_id = stream_id;
2289 stream->vfl_type = vfl_type;
2291 stream->list_num = vpdma_hwlist_alloc(dev->shared->vpdma, stream);
2292 if (stream->list_num < 0) {
2293 vip_err(dev, "Could not get VPDMA hwlist");
2294 ret = -ENODEV;
2295 goto do_free_stream;
2296 }
2298 INIT_LIST_HEAD(&stream->post_bufs);
2300 if (vfl_type == VFL_TYPE_GRABBER)
2301 port->cap_streams[stream_id] = stream;
2302 else
2303 port->vbi_streams[stream_id] = stream;
2305 /*
2306 * Initialize queue
2307 */
2308 q = &stream->vb_vidq;
2309 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2310 q->io_modes = VB2_MMAP | VB2_DMABUF;
2311 q->drv_priv = stream;
2312 q->buf_struct_size = sizeof(struct vip_buffer);
2313 q->ops = &vip_video_qops;
2314 q->mem_ops = &vb2_dma_contig_memops;
2315 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
2317 /* Feature not back-ported yet. Enable when available */
2318 /* q->min_buffers_needed = 3; */
2320 ret = vb2_queue_init(q);
2321 if (ret)
2322 goto do_free_stream;
2324 INIT_LIST_HEAD(&stream->vidq);
2326 /* Allocate/populate Drop queue entries */
2327 INIT_LIST_HEAD(&stream->dropq);
2328 for (i = 0; i < VIP_DROPQ_SIZE; i++) {
2330 buf = kzalloc(sizeof(*buf), GFP_ATOMIC);
2331 if (!buf) {
2332 vip_err(dev, "No memory!!");
2333 ret = -ENOMEM;
2334 goto do_free_stream;
2335 }
2336 buf->drop = true;
2337 list_add(&buf->list, &stream->dropq);
2338 }
2340 vfd = &stream->vdev;
2341 *vfd = vip_videodev;
2342 vfd->v4l2_dev = &dev->v4l2_dev;
2343 vfd->queue = q;
2344 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
2346 vfd->lock = &dev->mutex;
2347 video_set_drvdata(vfd, stream);
2349 ret = video_register_device(vfd, vfl_type, -1);
2350 if (ret) {
2351 vip_err(dev, "Failed to register video device\n");
2352 goto do_free_stream;
2353 }
2355 snprintf(vfd->name, sizeof(vfd->name), "%s", vip_videodev.name);
2356 stream->vfd = vfd;
2358 vip_info(dev, VIP_MODULE_NAME
2359 " Device registered as /dev/video%d\n", vfd->num);
2360 return 0;
2362 do_free_stream:
2363 kfree(stream);
2364 return ret;
2365 }
2367 static void free_stream(struct vip_stream *stream)
2368 {
2369 struct vip_dev *dev = stream->port->dev;
2370 struct vip_buffer *buf;
2371 struct list_head *pos, *q;
2373 if (!stream)
2374 return;
2376 /* Free up the Drop queue */
2377 list_for_each_safe(pos, q, &stream->dropq) {
2378 buf = list_entry(stream->dropq.next,
2379 struct vip_buffer, list);
2380 vip_dbg(1, dev, "dropq buffer\n");
2381 list_del(pos);
2382 kfree(buf);
2383 }
2385 video_unregister_device(stream->vfd);
2386 video_device_release(stream->vfd);
2387 vpdma_hwlist_release(dev->shared->vpdma, stream->list_num);
2388 kfree(stream);
2389 }
2391 static int get_subdev_active_format(struct vip_port *port,
2392 struct v4l2_subdev *subdev)
2393 {
2394 struct vip_dev *dev = port->dev;
2395 struct vip_fmt *fmt;
2396 enum v4l2_mbus_pixelcode code;
2397 int ret = 0;
2398 unsigned int k, i, j;
2400 /* Enumerate sub device formats and enable all matching local formats */
2401 dev->num_active_fmt = 0;
2402 for (k = 0, i = 0;
2403 (ret != -EINVAL);
2404 k++) {
2405 ret = v4l2_subdev_call(subdev, video, enum_mbus_fmt, k, &code);
2406 if (ret == 0) {
2407 vip_dbg(2, dev,
2408 "subdev %s: code: %04x idx: %d\n",
2409 subdev->name, code, k);
2411 for (j = 0; j < ARRAY_SIZE(vip_formats); j++) {
2412 fmt = &vip_formats[j];
2413 if (code == fmt->code) {
2414 dev->active_fmt[i] = fmt;
2415 dev->num_active_fmt = i++;
2416 vip_dbg(2, dev,
2417 "matched fourcc: %s: code: %04x idx: %d\n",
2418 fourcc_to_str(fmt->fourcc),
2419 fmt->code,
2420 dev->num_active_fmt);
2421 }
2422 }
2423 }
2424 }
2426 if (i == 0) {
2427 vip_err(dev, "No suitable format reported by subdev %s\n",
2428 subdev->name);
2429 return -EINVAL;
2430 }
2431 return 0;
2432 }
2434 static int alloc_port(struct vip_dev *dev, int id)
2435 {
2436 struct vip_port *port;
2437 int ret;
2439 port = kzalloc(sizeof(*port), GFP_KERNEL);
2440 if (!port)
2441 return -ENOMEM;
2443 dev->ports[id] = port;
2444 port->dev = dev;
2445 port->port_id = id;
2446 port->num_streams = 0;
2447 port->flags |= FLAG_MULT_PORT;
2449 ret = alloc_stream(port, 0, VFL_TYPE_GRABBER);
2451 if (dev->endpoint->bus_type == V4L2_MBUS_BT656) {
2452 /* Allocate streams for 4 channels */
2453 ret = alloc_stream(port, 2, VFL_TYPE_GRABBER);
2454 ret = alloc_stream(port, 4, VFL_TYPE_GRABBER);
2455 ret = alloc_stream(port, 6, VFL_TYPE_GRABBER);
2456 }
2458 return get_subdev_active_format(port, dev->sensor);
2459 }
2461 static void free_port(struct vip_port *port)
2462 {
2463 if (!port)
2464 return;
2466 free_stream(port->cap_streams[0]);
2468 kfree(port);
2469 }
2471 static int get_field(u32 value, u32 mask, int shift)
2472 {
2473 return (value & (mask << shift)) >> shift;
2474 }
2476 static int vip_of_probe(struct platform_device *pdev, struct vip_dev *dev);
2477 static void vip_vpdma_fw_cb(struct platform_device *pdev)
2478 {
2479 struct vip_shared *shared = platform_get_drvdata(pdev);
2480 struct vip_dev *dev;
2481 int slice, ret;
2483 dev_info(&pdev->dev, "VPDMA firmware loaded\n");
2485 for (slice = 0; slice < atomic_read(&shared->devs_allocated); slice++) {
2486 dev = shared->devs[slice];
2488 if (pdev->dev.of_node) {
2489 ret = vip_of_probe(pdev, dev);
2490 if (ret)
2491 goto free_port;
2492 }
2493 }
2495 return;
2497 free_port:
2498 free_port(dev->ports[0]);
2499 }
2501 static void remove_shared(struct vip_shared *shared)
2502 {
2503 if (atomic_dec_return(&shared->devs_allocated) != 0)
2504 return;
2506 iounmap(shared->base);
2507 release_mem_region(shared->res->start, resource_size(shared->res));
2508 kfree(shared);
2509 }
2511 static int vip_runtime_get(struct platform_device *pdev)
2512 {
2513 int r;
2515 r = pm_runtime_get_sync(&pdev->dev);
2516 WARN_ON(r < 0);
2517 return r < 0 ? r : 0;
2518 }
2521 static int vip_async_bound(struct v4l2_async_notifier *notifier,
2522 struct v4l2_subdev *subdev,
2523 struct v4l2_async_subdev *asd)
2524 {
2525 struct vip_dev *dev = notifier_to_vip_dev(notifier);
2526 unsigned int idx = asd - &dev->config->asd[0];
2527 int ret;
2529 vip_dbg(1, dev, "vip_async_bound\n");
2530 if (idx > dev->config->asd_sizes)
2531 return -EINVAL;
2533 if (dev->sensor) {
2534 if (asd < dev->sensor->asd) {
2535 /* Notified of a subdev earlier in the array */
2536 dev->sensor = subdev;
2537 dev->endpoint = &dev->config->endpoints[idx];
2538 vip_info(dev, "Switching to subdev %s (High priority)",
2539 subdev->name);
2541 } else
2542 vip_info(dev, "Rejecting subdev %s (Low priority)",
2543 subdev->name);
2544 return 0;
2545 }
2547 dev->sensor = subdev;
2548 dev->endpoint = &dev->config->endpoints[idx];
2549 ret = alloc_port(dev, 0);
2550 if (!ret)
2551 vip_info(dev, "Using sensor %s for capture\n", subdev->name);
2553 return ret;
2554 }
2556 static int vip_async_complete(struct v4l2_async_notifier *notifier)
2557 {
2558 struct vip_dev *dev = notifier_to_vip_dev(notifier);
2559 vip_dbg(1, dev, "vip_async_complete\n");
2560 return 0;
2561 }
2563 static struct device_node *
2564 of_get_next_port(const struct device_node *parent,
2565 struct device_node *prev)
2566 {
2567 struct device_node *port = NULL;
2569 if (!parent)
2570 return NULL;
2572 if (!prev) {
2573 struct device_node *ports;
2574 /*
2575 * It's the first call, we have to find a port subnode
2576 * within this node or within an optional 'ports' node.
2577 */
2578 ports = of_get_child_by_name(parent, "ports");
2579 if (ports)
2580 parent = ports;
2582 port = of_get_child_by_name(parent, "port");
2584 /* release the 'ports' node */
2585 of_node_put(ports);
2586 } else {
2587 struct device_node *ports;
2589 ports = of_get_parent(prev);
2590 if (!ports)
2591 return NULL;
2593 do {
2594 port = of_get_next_child(ports, prev);
2595 if (!port) {
2596 of_node_put(ports);
2597 return NULL;
2598 }
2599 prev = port;
2600 } while (of_node_cmp(port->name, "port") != 0);
2601 }
2603 return port;
2604 }
2606 static struct device_node *
2607 of_get_next_endpoint(const struct device_node *parent,
2608 struct device_node *prev)
2609 {
2610 struct device_node *ep = NULL;
2612 if (!parent)
2613 return NULL;
2615 do {
2616 ep = of_get_next_child(parent, prev);
2617 if (!ep)
2618 return NULL;
2619 prev = ep;
2620 } while (of_node_cmp(ep->name, "endpoint") != 0);
2622 return ep;
2623 }
2625 static int vip_of_probe(struct platform_device *pdev, struct vip_dev *dev)
2626 {
2627 struct device_node *ep_node = NULL, *port, *remote_ep,
2628 *sensor_node, *parent;
2629 struct device_node *syscon_np;
2630 struct v4l2_of_endpoint *endpoint;
2631 struct v4l2_async_subdev *asd;
2632 u32 regval = 0;
2633 int ret, slice, i = 0, found_port = 0;
2635 parent = pdev->dev.of_node;
2637 syscon_np = of_parse_phandle(pdev->dev.of_node, "syscon", 0);
2638 dev->syscon = syscon_node_to_regmap(syscon_np);
2639 of_node_put(syscon_np);
2641 dev->config = kzalloc(sizeof(struct vip_config), GFP_KERNEL);
2642 if (!dev->config)
2643 return -ENOMEM;
2645 dev->config->card_name = "VIP Driver";
2647 port = NULL;
2648 vip_dbg(3, dev, "Scanning Port node for slice id: %d\n", dev->slice_id);
2649 for (slice = 0; slice < VIP_NUM_SLICES; slice++) {
2650 port = of_get_next_port(parent, port);
2651 if (!port) {
2652 vip_dbg(1, dev, "No port node found for slice_id:%d\n",
2653 slice);
2654 ret = -EINVAL;
2655 goto free_config;
2656 }
2658 /* Match the slice number with <REG> */
2659 of_property_read_u32(port, "reg", ®val);
2660 vip_dbg(3, dev, "slice:%d dev->slice_id:%d <reg>:%d\n",
2661 slice, dev->slice_id, regval);
2662 if ((regval == dev->slice_id) && (slice == dev->slice_id)) {
2663 found_port = 1;
2664 break;
2665 }
2666 }
2668 if (!found_port) {
2669 if (!port)
2670 of_node_put(port);
2671 vip_dbg(1, dev, "No port node matches slice_id:%d\n",
2672 dev->slice_id);
2673 ret = -EINVAL;
2674 goto free_config;
2675 }
2677 vip_dbg(3, dev, "Scanning sub-device(s) for slice id: %d\n",
2678 dev->slice_id);
2679 while (i < VIP_MAX_SUBDEV) {
2681 asd = &dev->config->asd[i];
2682 endpoint = &dev->config->endpoints[i];
2684 remote_ep = NULL;
2685 sensor_node = NULL;
2687 ep_node = of_get_next_endpoint(port, ep_node);
2688 if (!ep_node) {
2689 vip_dbg(3, dev, "can't get next endpoint: loop: %d\n",
2690 i);
2691 break;
2692 }
2694 sensor_node = of_graph_get_remote_port_parent(ep_node);
2695 if (!sensor_node) {
2696 vip_dbg(3, dev, "can't get remote parent: loop: %d\n",
2697 i);
2698 goto of_node_cleanup;
2699 }
2700 asd->match_type = V4L2_ASYNC_MATCH_OF;
2701 asd->match.of.node = sensor_node;
2703 remote_ep = of_parse_phandle(ep_node, "remote-endpoint", 0);
2704 if (!remote_ep) {
2705 vip_dbg(3, dev, "can't get remote-endpoint: loop: %d\n",
2706 i);
2707 goto of_node_cleanup;
2708 }
2709 v4l2_of_parse_endpoint(remote_ep, endpoint);
2711 dev->config->asd_list[i++] = asd;
2713 of_node_cleanup:
2714 if (!remote_ep)
2715 of_node_put(remote_ep);
2716 if (!sensor_node)
2717 of_node_put(sensor_node);
2718 }
2720 if (!ep_node)
2721 of_node_put(ep_node);
2722 if (!port)
2723 of_node_put(port);
2725 vip_dbg(1, dev, "Found %d sub-device(s) for slice id: %d\n",
2726 i, dev->slice_id);
2727 if (i > 0) {
2728 dev->config->asd_sizes = i;
2729 dev->notifier.subdevs = dev->config->asd_list;
2730 dev->notifier.num_subdevs = dev->config->asd_sizes;
2731 dev->notifier.bound = vip_async_bound;
2732 dev->notifier.complete = vip_async_complete;
2734 vip_dbg(1, dev, "registering the sync notifier for sensors %d",
2735 i);
2736 ret = v4l2_async_notifier_register(&dev->v4l2_dev,
2737 &dev->notifier);
2738 if (ret) {
2739 vip_dbg(1, dev, "Error registering async notifier\n");
2740 ret = -EINVAL;
2741 goto free_config;
2742 }
2743 }
2745 return 0;
2746 free_config:
2747 kfree(dev->config);
2748 return ret;
2749 }
2751 static const struct of_device_id vip_of_match[];
2752 static int vip_probe(struct platform_device *pdev)
2753 {
2754 struct vip_dev *dev;
2755 struct vip_shared *shared;
2756 const struct of_device_id *of_dev_id;
2757 struct pinctrl *pinctrl;
2758 int ret, slice = VIP_SLICE1;
2759 u32 tmp, pid;
2760 struct v4l2_ctrl_handler *hdl;
2762 pm_runtime_enable(&pdev->dev);
2764 ret = vip_runtime_get(pdev);
2765 if (ret)
2766 goto err_runtime_get;
2768 of_dev_id = of_match_device(vip_of_match, &pdev->dev);
2769 if (!of_dev_id) {
2770 dev_err(&pdev->dev, "%s: Unable to match device\n", __func__);
2771 return -ENODEV;
2772 }
2774 shared = kzalloc(sizeof(*shared), GFP_KERNEL);
2775 if (!shared)
2776 return -ENOMEM;
2778 shared->res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vip");
2779 if (shared->res == NULL) {
2780 dev_err(&pdev->dev, "Missing platform resources data\n");
2781 ret = -ENODEV;
2782 goto free_shared;
2783 }
2785 pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
2786 if (IS_ERR(pinctrl)) {
2787 dev_warn(&pdev->dev, "No explicit pinctrl resources data.\n");
2788 }
2790 if (devm_request_mem_region(&pdev->dev, shared->res->start,
2791 resource_size(shared->res), VIP_MODULE_NAME) == NULL) {
2792 ret = -ENOMEM;
2793 goto free_shared;
2794 }
2796 shared->base = devm_ioremap(&pdev->dev, shared->res->start,
2797 resource_size(shared->res));
2798 if (!shared->base) {
2799 dev_err(&pdev->dev, "failed to ioremap\n");
2800 ret = -ENOMEM;
2801 goto rel_mem_region;
2802 }
2804 /* Make sure H/W module has the right functionality */
2805 pid = read_sreg(shared, VIP_PID);
2806 tmp = get_field(pid, VIP_PID_FUNC_MASK, VIP_PID_FUNC_SHIFT);
2808 if (tmp != VIP_PID_FUNC) {
2809 dev_info(&pdev->dev, "vip: unexpected PID function: 0x%x\n",
2810 tmp);
2811 ret = -ENODEV;
2812 goto do_iounmap;
2813 }
2815 /* enable clocks, so the firmware will load properly */
2816 vip_shared_set_clock_enable(shared, 1);
2817 vip_top_vpdma_reset(shared);
2819 list_add_tail(&shared->list, &vip_shared_list);
2820 platform_set_drvdata(pdev, shared);
2821 atomic_set(&shared->devs_allocated, 0);
2823 vip_set_idle_mode(shared, VIP_SMART_IDLE_MODE);
2824 vip_set_standby_mode(shared, VIP_SMART_STANDBY_MODE);
2826 for (slice = VIP_SLICE1; slice < VIP_NUM_SLICES; slice++) {
2827 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2828 if (!dev)
2829 return -ENOMEM;
2831 dev->instance_id = (int)of_dev_id->data;
2832 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
2833 "%s%d-s%d", VIP_MODULE_NAME, dev->instance_id, slice);
2835 dev->irq = platform_get_irq(pdev, slice);
2836 if (!dev->irq) {
2837 dev_err(&pdev->dev, "Could not get IRQ");
2838 goto err_runtime_get;
2839 }
2841 if (devm_request_irq(&pdev->dev, dev->irq, vip_irq,
2842 0, dev->v4l2_dev.name, dev) < 0) {
2843 ret = -ENOMEM;
2844 goto dev_unreg;
2845 }
2847 spin_lock_init(&dev->slock);
2848 spin_lock_init(&dev->lock);
2850 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
2851 if (ret)
2852 goto err_runtime_get;
2854 mutex_init(&dev->mutex);
2856 hdl = &dev->ctrl_handler;
2857 v4l2_ctrl_handler_init(hdl, 11);
2858 dev->v4l2_dev.ctrl_handler = hdl;
2860 dev->slice_id = slice;
2861 dev->pdev = pdev;
2862 dev->res = shared->res;
2863 dev->base = shared->base;
2865 dev->shared = shared;
2866 shared->devs[slice] = dev;
2868 atomic_inc(&shared->devs_allocated);
2870 dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
2871 if (IS_ERR(dev->alloc_ctx)) {
2872 vip_err(dev, "Failed to alloc vb2 context\n");
2873 ret = PTR_ERR(dev->alloc_ctx);
2874 goto dev_unreg;
2875 }
2877 vip_top_reset(dev);
2878 vip_set_slice_path(dev, VIP_MULTI_CHANNEL_DATA_SELECT);
2879 }
2881 shared->vpdma = &shared->vpdma_data;
2882 ret = vpdma_create(pdev, shared->vpdma, vip_vpdma_fw_cb);
2883 if (ret) {
2884 dev_err(&pdev->dev, "Creating VPDMA failed");
2885 goto dev_unreg;
2886 }
2888 return 0;
2890 dev_unreg:
2891 v4l2_device_unregister(&dev->v4l2_dev);
2892 do_iounmap:
2893 iounmap(shared->base);
2894 rel_mem_region:
2895 release_mem_region(shared->res->start, resource_size(shared->res));
2896 free_shared:
2897 kfree(shared);
2898 err_runtime_get:
2899 if (slice == VIP_SLICE1) {
2900 pm_runtime_disable(&pdev->dev);
2901 return ret;
2902 } else
2903 return 0;
2904 }
2906 static int vip_remove(struct platform_device *pdev)
2907 {
2908 struct vip_shared *shared = platform_get_drvdata(pdev);
2909 struct vip_dev *dev;
2910 int slice;
2912 for (slice = 0; slice < atomic_read(&shared->devs_allocated); slice++) {
2913 dev = shared->devs[slice];
2914 if (!dev)
2915 continue;
2916 vip_info(dev, "Removing " VIP_MODULE_NAME);
2917 free_port(dev->ports[0]);
2918 v4l2_async_notifier_unregister(&dev->notifier);
2919 vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
2920 free_irq(dev->irq, dev);
2921 kfree(dev);
2922 }
2923 remove_shared(shared);
2925 return 0;
2926 }
2928 #if defined(CONFIG_OF)
2929 static const struct of_device_id vip_of_match[] = {
2930 {
2931 .compatible = "ti,vip1", .data = (void *) VIP_INSTANCE1,
2932 },
2934 {
2935 .compatible = "ti,vip2", .data = (void *) VIP_INSTANCE2,
2936 },
2938 {
2939 .compatible = "ti,vip3", .data = (void *) VIP_INSTANCE3,
2940 },
2941 {},
2942 };
2943 MODULE_DEVICE_TABLE(of, vip_of_match);
2944 #else
2945 #define vip_of_match NULL
2946 #endif
2948 static struct platform_driver vip_pdrv = {
2949 .probe = vip_probe,
2950 .remove = vip_remove,
2951 .driver = {
2952 .name = VIP_MODULE_NAME,
2953 .owner = THIS_MODULE,
2954 .of_match_table = vip_of_match,
2955 },
2956 };
2958 module_platform_driver(vip_pdrv);
2960 MODULE_DESCRIPTION("TI VIP driver");
2961 MODULE_AUTHOR("Texas Instruments");
2962 MODULE_LICENSE("GPL v2");