?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390/ptrace: get rid of long longs in psw_bits
[linux/fpc-iii.git] / drivers / media / pci / cobalt / cobalt-v4l2.c
blobff46e424262f04d5c6aca7a55ccda9743b803483
1 /*
2 * cobalt V4L2 API
3 *
4 * Derived from ivtv-ioctl.c and cx18-fileops.c
5 *
6 * Copyright 2012-2015 Cisco Systems, Inc. and/or its affiliates.
7 * All rights reserved.
8 *
9 * This program is free software; you may redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
17 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #include <linux/dma-mapping.h>
24 #include <linux/delay.h>
25 #include <linux/math64.h>
26 #include <linux/pci.h>
27 #include <linux/v4l2-dv-timings.h>
28
29 #include <media/v4l2-ctrls.h>
30 #include <media/v4l2-event.h>
31 #include <media/v4l2-dv-timings.h>
32 #include <media/adv7604.h>
33 #include <media/adv7842.h>
34
35 #include "cobalt-alsa.h"
36 #include "cobalt-cpld.h"
37 #include "cobalt-driver.h"
38 #include "cobalt-v4l2.h"
39 #include "cobalt-irq.h"
40 #include "cobalt-omnitek.h"
41
42 static const struct v4l2_dv_timings cea1080p60 = V4L2_DV_BT_CEA_1920X1080P60;
43
44 /* vb2 DMA streaming ops */
45
46 static int cobalt_queue_setup(struct vb2_queue *q, const void *parg,
47 unsigned int *num_buffers, unsigned int *num_planes,
48 unsigned int sizes[], void *alloc_ctxs[])
49 {
50 const struct v4l2_format *fmt = parg;
51 struct cobalt_stream *s = q->drv_priv;
52 unsigned size = s->stride * s->height;
53
54 if (*num_buffers < 3)
55 *num_buffers = 3;
56 if (*num_buffers > NR_BUFS)
57 *num_buffers = NR_BUFS;
58 *num_planes = 1;
59 if (fmt) {
60 if (fmt->fmt.pix.sizeimage < size)
61 return -EINVAL;
62 size = fmt->fmt.pix.sizeimage;
63 }
64 sizes[0] = size;
65 alloc_ctxs[0] = s->cobalt->alloc_ctx;
66 return 0;
67 }
68
69 static int cobalt_buf_init(struct vb2_buffer *vb)
70 {
71 struct cobalt_stream *s = vb->vb2_queue->drv_priv;
72 struct cobalt *cobalt = s->cobalt;
73 const size_t max_pages_per_line =
74 (COBALT_MAX_WIDTH * COBALT_MAX_BPP) / PAGE_SIZE + 2;
75 const size_t bytes =
76 COBALT_MAX_HEIGHT * max_pages_per_line * 0x20;
77 const size_t audio_bytes = ((1920 * 4) / PAGE_SIZE + 1) * 0x20;
78 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index];
79 struct sg_table *sg_desc = vb2_dma_sg_plane_desc(vb, 0);
80 unsigned size;
81 int ret;
82
83 size = s->stride * s->height;
84 if (vb2_plane_size(vb, 0) < size) {
85 cobalt_info("data will not fit into plane (%lu < %u)\n",
86 vb2_plane_size(vb, 0), size);
87 return -EINVAL;
88 }
89
90 if (desc->virt == NULL) {
91 desc->dev = &cobalt->pci_dev->dev;
92 descriptor_list_allocate(desc,
93 s->is_audio ? audio_bytes : bytes);
94 if (desc->virt == NULL)
95 return -ENOMEM;
96 }
97 ret = descriptor_list_create(cobalt, sg_desc->sgl,
98 !s->is_output, sg_desc->nents, size,
99 s->width * s->bpp, s->stride, desc);
100 if (ret)
101 descriptor_list_free(desc);
102 return ret;
103 }
104
105 static void cobalt_buf_cleanup(struct vb2_buffer *vb)
106 {
107 struct cobalt_stream *s = vb->vb2_queue->drv_priv;
108 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index];
109
110 descriptor_list_free(desc);
111 }
112
113 static int cobalt_buf_prepare(struct vb2_buffer *vb)
114 {
115 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
116 struct cobalt_stream *s = vb->vb2_queue->drv_priv;
117
118 vb2_set_plane_payload(vb, 0, s->stride * s->height);
119 vbuf->field = V4L2_FIELD_NONE;
120 return 0;
121 }
122
123 static void chain_all_buffers(struct cobalt_stream *s)
124 {
125 struct sg_dma_desc_info *desc[NR_BUFS];
126 struct cobalt_buffer *cb;
127 struct list_head *p;
128 int i = 0;
129
130 list_for_each(p, &s->bufs) {
131 cb = list_entry(p, struct cobalt_buffer, list);
132 desc[i] = &s->dma_desc_info[cb->vb.vb2_buf.index];
133 if (i > 0)
134 descriptor_list_chain(desc[i-1], desc[i]);
135 i++;
136 }
137 }
138
139 static void cobalt_buf_queue(struct vb2_buffer *vb)
140 {
141 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
142 struct vb2_queue *q = vb->vb2_queue;
143 struct cobalt_stream *s = q->drv_priv;
144 struct cobalt_buffer *cb = to_cobalt_buffer(vbuf);
145 struct sg_dma_desc_info *desc = &s->dma_desc_info[vb->index];
146 unsigned long flags;
147
148 /* Prepare new buffer */
149 descriptor_list_loopback(desc);
150 descriptor_list_interrupt_disable(desc);
151
152 spin_lock_irqsave(&s->irqlock, flags);
153 list_add_tail(&cb->list, &s->bufs);
154 chain_all_buffers(s);
155 spin_unlock_irqrestore(&s->irqlock, flags);
156 }
157
158 static void cobalt_enable_output(struct cobalt_stream *s)
159 {
160 struct cobalt *cobalt = s->cobalt;
161 struct v4l2_bt_timings *bt = &s->timings.bt;
162 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo =
163 COBALT_TX_BASE(cobalt);
164 unsigned fmt = s->pixfmt != V4L2_PIX_FMT_BGR32 ?
165 M00514_CONTROL_BITMAP_FORMAT_16_BPP_MSK : 0;
166 struct v4l2_subdev_format sd_fmt = {
167 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
168 };
169
170 if (!cobalt_cpld_set_freq(cobalt, bt->pixelclock)) {
171 cobalt_err("pixelclock out of range\n");
172 return;
173 }
174
175 sd_fmt.format.colorspace = s->colorspace;
176 sd_fmt.format.xfer_func = s->xfer_func;
177 sd_fmt.format.ycbcr_enc = s->ycbcr_enc;
178 sd_fmt.format.quantization = s->quantization;
179 sd_fmt.format.width = bt->width;
180 sd_fmt.format.height = bt->height;
181
182 /* Set up FDMA packer */
183 switch (s->pixfmt) {
184 case V4L2_PIX_FMT_YUYV:
185 sd_fmt.format.code = MEDIA_BUS_FMT_UYVY8_1X16;
186 break;
187 case V4L2_PIX_FMT_BGR32:
188 sd_fmt.format.code = MEDIA_BUS_FMT_RGB888_1X24;
189 break;
190 }
191 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, &sd_fmt);
192
193 iowrite32(0, &vo->control);
194 /* 1080p60 */
195 iowrite32(bt->hsync, &vo->sync_generator_h_sync_length);
196 iowrite32(bt->hbackporch, &vo->sync_generator_h_backporch_length);
197 iowrite32(bt->width, &vo->sync_generator_h_active_length);
198 iowrite32(bt->hfrontporch, &vo->sync_generator_h_frontporch_length);
199 iowrite32(bt->vsync, &vo->sync_generator_v_sync_length);
200 iowrite32(bt->vbackporch, &vo->sync_generator_v_backporch_length);
201 iowrite32(bt->height, &vo->sync_generator_v_active_length);
202 iowrite32(bt->vfrontporch, &vo->sync_generator_v_frontporch_length);
203 iowrite32(0x9900c1, &vo->error_color);
204
205 iowrite32(M00514_CONTROL_BITMAP_SYNC_GENERATOR_LOAD_PARAM_MSK | fmt,
206 &vo->control);
207 iowrite32(M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK | fmt, &vo->control);
208 iowrite32(M00514_CONTROL_BITMAP_SYNC_GENERATOR_ENABLE_MSK |
209 M00514_CONTROL_BITMAP_FLOW_CTRL_OUTPUT_ENABLE_MSK |
210 fmt, &vo->control);
211 }
212
213 static void cobalt_enable_input(struct cobalt_stream *s)
214 {
215 struct cobalt *cobalt = s->cobalt;
216 int ch = (int)s->video_channel;
217 struct m00235_fdma_packer_regmap __iomem *packer;
218 struct v4l2_subdev_format sd_fmt_yuyv = {
219 .pad = s->pad_source,
220 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
221 .format.code = MEDIA_BUS_FMT_YUYV8_1X16,
222 };
223 struct v4l2_subdev_format sd_fmt_rgb = {
224 .pad = s->pad_source,
225 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
226 .format.code = MEDIA_BUS_FMT_RGB888_1X24,
227 };
228
229 cobalt_dbg(1, "video_channel %d (%s, %s)\n",
230 s->video_channel,
231 s->input == 0 ? "hdmi" : "generator",
232 "YUYV");
233
234 packer = COBALT_CVI_PACKER(cobalt, ch);
235
236 /* Set up FDMA packer */
237 switch (s->pixfmt) {
238 case V4L2_PIX_FMT_YUYV:
239 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK |
240 (1 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST),
241 &packer->control);
242 v4l2_subdev_call(s->sd, pad, set_fmt, NULL,
243 &sd_fmt_yuyv);
244 break;
245 case V4L2_PIX_FMT_RGB24:
246 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK |
247 (2 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST),
248 &packer->control);
249 v4l2_subdev_call(s->sd, pad, set_fmt, NULL,
250 &sd_fmt_rgb);
251 break;
252 case V4L2_PIX_FMT_BGR32:
253 iowrite32(M00235_CONTROL_BITMAP_ENABLE_MSK |
254 M00235_CONTROL_BITMAP_ENDIAN_FORMAT_MSK |
255 (3 << M00235_CONTROL_BITMAP_PACK_FORMAT_OFST),
256 &packer->control);
257 v4l2_subdev_call(s->sd, pad, set_fmt, NULL,
258 &sd_fmt_rgb);
259 break;
260 }
261 }
262
263 static void cobalt_dma_start_streaming(struct cobalt_stream *s)
264 {
265 struct cobalt *cobalt = s->cobalt;
266 int rx = s->video_channel;
267 struct m00460_evcnt_regmap __iomem *evcnt =
268 COBALT_CVI_EVCNT(cobalt, rx);
269 struct cobalt_buffer *cb;
270 unsigned long flags;
271
272 spin_lock_irqsave(&s->irqlock, flags);
273 if (!s->is_output) {
274 iowrite32(M00460_CONTROL_BITMAP_CLEAR_MSK, &evcnt->control);
275 iowrite32(M00460_CONTROL_BITMAP_ENABLE_MSK, &evcnt->control);
276 } else {
277 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo =
278 COBALT_TX_BASE(cobalt);
279 u32 ctrl = ioread32(&vo->control);
280
281 ctrl &= ~(M00514_CONTROL_BITMAP_EVCNT_ENABLE_MSK |
282 M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK);
283 iowrite32(ctrl | M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK,
284 &vo->control);
285 iowrite32(ctrl | M00514_CONTROL_BITMAP_EVCNT_ENABLE_MSK,
286 &vo->control);
287 }
288 cb = list_first_entry(&s->bufs, struct cobalt_buffer, list);
289 omni_sg_dma_start(s, &s->dma_desc_info[cb->vb.vb2_buf.index]);
290 spin_unlock_irqrestore(&s->irqlock, flags);
291 }
292
293 static int cobalt_start_streaming(struct vb2_queue *q, unsigned int count)
294 {
295 struct cobalt_stream *s = q->drv_priv;
296 struct cobalt *cobalt = s->cobalt;
297 struct m00233_video_measure_regmap __iomem *vmr;
298 struct m00473_freewheel_regmap __iomem *fw;
299 struct m00479_clk_loss_detector_regmap __iomem *clkloss;
300 int rx = s->video_channel;
301 struct m00389_cvi_regmap __iomem *cvi = COBALT_CVI(cobalt, rx);
302 struct m00460_evcnt_regmap __iomem *evcnt = COBALT_CVI_EVCNT(cobalt, rx);
303 struct v4l2_bt_timings *bt = &s->timings.bt;
304 u64 tot_size;
305 u32 clk_freq;
306
307 if (s->is_audio)
308 goto done;
309 if (s->is_output) {
310 s->unstable_frame = false;
311 cobalt_enable_output(s);
312 goto done;
313 }
314
315 cobalt_enable_input(s);
316
317 fw = COBALT_CVI_FREEWHEEL(cobalt, rx);
318 vmr = COBALT_CVI_VMR(cobalt, rx);
319 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx);
320
321 iowrite32(M00460_CONTROL_BITMAP_CLEAR_MSK, &evcnt->control);
322 iowrite32(M00460_CONTROL_BITMAP_ENABLE_MSK, &evcnt->control);
323 iowrite32(bt->width, &cvi->frame_width);
324 iowrite32(bt->height, &cvi->frame_height);
325 tot_size = V4L2_DV_BT_FRAME_WIDTH(bt) * V4L2_DV_BT_FRAME_HEIGHT(bt);
326 iowrite32(div_u64((u64)V4L2_DV_BT_FRAME_WIDTH(bt) * COBALT_CLK * 4,
327 bt->pixelclock), &vmr->hsync_timeout_val);
328 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control);
329 clk_freq = ioread32(&fw->clk_freq);
330 iowrite32(clk_freq / 1000000, &clkloss->ref_clk_cnt_val);
331 /* The lower bound for the clock frequency is 0.5% lower as is
332 * allowed by the spec */
333 iowrite32(div_u64(bt->pixelclock * 995, 1000000000),
334 &clkloss->test_clk_cnt_val);
335 /* will be enabled after the first frame has been received */
336 iowrite32(bt->width * bt->height, &fw->active_length);
337 iowrite32(div_u64((u64)clk_freq * tot_size, bt->pixelclock),
338 &fw->total_length);
339 iowrite32(M00233_IRQ_TRIGGERS_BITMAP_VACTIVE_AREA_MSK |
340 M00233_IRQ_TRIGGERS_BITMAP_HACTIVE_AREA_MSK,
341 &vmr->irq_triggers);
342 iowrite32(0, &cvi->control);
343 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control);
344
345 iowrite32(0xff, &fw->output_color);
346 iowrite32(M00479_CTRL_BITMAP_ENABLE_MSK, &clkloss->ctrl);
347 iowrite32(M00473_CTRL_BITMAP_ENABLE_MSK |
348 M00473_CTRL_BITMAP_FORCE_FREEWHEEL_MODE_MSK, &fw->ctrl);
349 s->unstable_frame = true;
350 s->enable_freewheel = false;
351 s->enable_cvi = false;
352 s->skip_first_frames = 0;
353
354 done:
355 s->sequence = 0;
356 cobalt_dma_start_streaming(s);
357 return 0;
358 }
359
360 static void cobalt_dma_stop_streaming(struct cobalt_stream *s)
361 {
362 struct cobalt *cobalt = s->cobalt;
363 struct sg_dma_desc_info *desc;
364 struct cobalt_buffer *cb;
365 struct list_head *p;
366 unsigned long flags;
367 int timeout_msec = 100;
368 int rx = s->video_channel;
369 struct m00460_evcnt_regmap __iomem *evcnt =
370 COBALT_CVI_EVCNT(cobalt, rx);
371
372 if (!s->is_output) {
373 iowrite32(0, &evcnt->control);
374 } else if (!s->is_audio) {
375 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo =
376 COBALT_TX_BASE(cobalt);
377
378 iowrite32(M00514_CONTROL_BITMAP_EVCNT_CLEAR_MSK, &vo->control);
379 iowrite32(0, &vo->control);
380 }
381
382 /* Try to stop the DMA engine gracefully */
383 spin_lock_irqsave(&s->irqlock, flags);
384 list_for_each(p, &s->bufs) {
385 cb = list_entry(p, struct cobalt_buffer, list);
386 desc = &s->dma_desc_info[cb->vb.vb2_buf.index];
387 /* Stop DMA after this descriptor chain */
388 descriptor_list_end_of_chain(desc);
389 }
390 spin_unlock_irqrestore(&s->irqlock, flags);
391
392 /* Wait 100 milisecond for DMA to finish, abort on timeout. */
393 if (!wait_event_timeout(s->q.done_wq, is_dma_done(s),
394 msecs_to_jiffies(timeout_msec))) {
395 omni_sg_dma_abort_channel(s);
396 pr_warn("aborted\n");
397 }
398 cobalt_write_bar0(cobalt, DMA_INTERRUPT_STATUS_REG,
399 1 << s->dma_channel);
400 }
401
402 static void cobalt_stop_streaming(struct vb2_queue *q)
403 {
404 struct cobalt_stream *s = q->drv_priv;
405 struct cobalt *cobalt = s->cobalt;
406 int rx = s->video_channel;
407 struct m00233_video_measure_regmap __iomem *vmr;
408 struct m00473_freewheel_regmap __iomem *fw;
409 struct m00479_clk_loss_detector_regmap __iomem *clkloss;
410 struct cobalt_buffer *cb;
411 struct list_head *p, *safe;
412 unsigned long flags;
413
414 cobalt_dma_stop_streaming(s);
415
416 /* Return all buffers to user space */
417 spin_lock_irqsave(&s->irqlock, flags);
418 list_for_each_safe(p, safe, &s->bufs) {
419 cb = list_entry(p, struct cobalt_buffer, list);
420 list_del(&cb->list);
421 vb2_buffer_done(&cb->vb.vb2_buf, VB2_BUF_STATE_ERROR);
422 }
423 spin_unlock_irqrestore(&s->irqlock, flags);
424
425 if (s->is_audio || s->is_output)
426 return;
427
428 fw = COBALT_CVI_FREEWHEEL(cobalt, rx);
429 vmr = COBALT_CVI_VMR(cobalt, rx);
430 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx);
431 iowrite32(0, &vmr->control);
432 iowrite32(M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK, &vmr->control);
433 iowrite32(0, &fw->ctrl);
434 iowrite32(0, &clkloss->ctrl);
435 }
436
437 static const struct vb2_ops cobalt_qops = {
438 .queue_setup = cobalt_queue_setup,
439 .buf_init = cobalt_buf_init,
440 .buf_cleanup = cobalt_buf_cleanup,
441 .buf_prepare = cobalt_buf_prepare,
442 .buf_queue = cobalt_buf_queue,
443 .start_streaming = cobalt_start_streaming,
444 .stop_streaming = cobalt_stop_streaming,
445 .wait_prepare = vb2_ops_wait_prepare,
446 .wait_finish = vb2_ops_wait_finish,
447 };
448
449 /* V4L2 ioctls */
450
451 #ifdef CONFIG_VIDEO_ADV_DEBUG
452 static int cobalt_cobaltc(struct cobalt *cobalt, unsigned int cmd, void *arg)
453 {
454 struct v4l2_dbg_register *regs = arg;
455 void __iomem *adrs = cobalt->bar1 + regs->reg;
456
457 cobalt_info("cobalt_cobaltc: adrs = %p\n", adrs);
458
459 if (!capable(CAP_SYS_ADMIN))
460 return -EPERM;
461
462 regs->size = 4;
463 if (cmd == VIDIOC_DBG_S_REGISTER)
464 iowrite32(regs->val, adrs);
465 else
466 regs->val = ioread32(adrs);
467 return 0;
468 }
469
470 static int cobalt_g_register(struct file *file, void *priv_fh,
471 struct v4l2_dbg_register *reg)
472 {
473 struct cobalt_stream *s = video_drvdata(file);
474 struct cobalt *cobalt = s->cobalt;
475
476 return cobalt_cobaltc(cobalt, VIDIOC_DBG_G_REGISTER, reg);
477 }
478
479 static int cobalt_s_register(struct file *file, void *priv_fh,
480 const struct v4l2_dbg_register *reg)
481 {
482 struct cobalt_stream *s = video_drvdata(file);
483 struct cobalt *cobalt = s->cobalt;
484
485 return cobalt_cobaltc(cobalt, VIDIOC_DBG_S_REGISTER,
486 (struct v4l2_dbg_register *)reg);
487 }
488 #endif
489
490 static int cobalt_querycap(struct file *file, void *priv_fh,
491 struct v4l2_capability *vcap)
492 {
493 struct cobalt_stream *s = video_drvdata(file);
494 struct cobalt *cobalt = s->cobalt;
495
496 strlcpy(vcap->driver, "cobalt", sizeof(vcap->driver));
497 strlcpy(vcap->card, "cobalt", sizeof(vcap->card));
498 snprintf(vcap->bus_info, sizeof(vcap->bus_info),
499 "PCIe:%s", pci_name(cobalt->pci_dev));
500 vcap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
501 if (s->is_output)
502 vcap->device_caps |= V4L2_CAP_VIDEO_OUTPUT;
503 else
504 vcap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
505 vcap->capabilities = vcap->device_caps | V4L2_CAP_DEVICE_CAPS |
506 V4L2_CAP_VIDEO_CAPTURE;
507 if (cobalt->have_hsma_tx)
508 vcap->capabilities |= V4L2_CAP_VIDEO_OUTPUT;
509 return 0;
510 }
511
512 static void cobalt_video_input_status_show(struct cobalt_stream *s)
513 {
514 struct m00389_cvi_regmap __iomem *cvi;
515 struct m00233_video_measure_regmap __iomem *vmr;
516 struct m00473_freewheel_regmap __iomem *fw;
517 struct m00479_clk_loss_detector_regmap __iomem *clkloss;
518 struct m00235_fdma_packer_regmap __iomem *packer;
519 int rx = s->video_channel;
520 struct cobalt *cobalt = s->cobalt;
521 u32 cvi_ctrl, cvi_stat;
522 u32 vmr_ctrl, vmr_stat;
523
524 cvi = COBALT_CVI(cobalt, rx);
525 vmr = COBALT_CVI_VMR(cobalt, rx);
526 fw = COBALT_CVI_FREEWHEEL(cobalt, rx);
527 clkloss = COBALT_CVI_CLK_LOSS(cobalt, rx);
528 packer = COBALT_CVI_PACKER(cobalt, rx);
529 cvi_ctrl = ioread32(&cvi->control);
530 cvi_stat = ioread32(&cvi->status);
531 vmr_ctrl = ioread32(&vmr->control);
532 vmr_stat = ioread32(&vmr->control);
533 cobalt_info("rx%d: cvi resolution: %dx%d\n", rx,
534 ioread32(&cvi->frame_width), ioread32(&cvi->frame_height));
535 cobalt_info("rx%d: cvi control: %s%s%s\n", rx,
536 (cvi_ctrl & M00389_CONTROL_BITMAP_ENABLE_MSK) ?
537 "enable " : "disable ",
538 (cvi_ctrl & M00389_CONTROL_BITMAP_HSYNC_POLARITY_LOW_MSK) ?
539 "HSync- " : "HSync+ ",
540 (cvi_ctrl & M00389_CONTROL_BITMAP_VSYNC_POLARITY_LOW_MSK) ?
541 "VSync- " : "VSync+ ");
542 cobalt_info("rx%d: cvi status: %s%s\n", rx,
543 (cvi_stat & M00389_STATUS_BITMAP_LOCK_MSK) ?
544 "lock " : "no-lock ",
545 (cvi_stat & M00389_STATUS_BITMAP_ERROR_MSK) ?
546 "error " : "no-error ");
547
548 cobalt_info("rx%d: Measurements: %s%s%s%s%s%s%s\n", rx,
549 (vmr_ctrl & M00233_CONTROL_BITMAP_HSYNC_POLARITY_LOW_MSK) ?
550 "HSync- " : "HSync+ ",
551 (vmr_ctrl & M00233_CONTROL_BITMAP_VSYNC_POLARITY_LOW_MSK) ?
552 "VSync- " : "VSync+ ",
553 (vmr_ctrl & M00233_CONTROL_BITMAP_ENABLE_MEASURE_MSK) ?
554 "enabled " : "disabled ",
555 (vmr_ctrl & M00233_CONTROL_BITMAP_ENABLE_INTERRUPT_MSK) ?
556 "irq-enabled " : "irq-disabled ",
557 (vmr_ctrl & M00233_CONTROL_BITMAP_UPDATE_ON_HSYNC_MSK) ?
558 "update-on-hsync " : "",
559 (vmr_stat & M00233_STATUS_BITMAP_HSYNC_TIMEOUT_MSK) ?
560 "hsync-timeout " : "",
561 (vmr_stat & M00233_STATUS_BITMAP_INIT_DONE_MSK) ?
562 "init-done" : "");
563 cobalt_info("rx%d: irq_status: 0x%02x irq_triggers: 0x%02x\n", rx,
564 ioread32(&vmr->irq_status) & 0xff,
565 ioread32(&vmr->irq_triggers) & 0xff);
566 cobalt_info("rx%d: vsync: %d\n", rx, ioread32(&vmr->vsync_time));
567 cobalt_info("rx%d: vbp: %d\n", rx, ioread32(&vmr->vback_porch));
568 cobalt_info("rx%d: vact: %d\n", rx, ioread32(&vmr->vactive_area));
569 cobalt_info("rx%d: vfb: %d\n", rx, ioread32(&vmr->vfront_porch));
570 cobalt_info("rx%d: hsync: %d\n", rx, ioread32(&vmr->hsync_time));
571 cobalt_info("rx%d: hbp: %d\n", rx, ioread32(&vmr->hback_porch));
572 cobalt_info("rx%d: hact: %d\n", rx, ioread32(&vmr->hactive_area));
573 cobalt_info("rx%d: hfb: %d\n", rx, ioread32(&vmr->hfront_porch));
574 cobalt_info("rx%d: Freewheeling: %s%s%s\n", rx,
575 (ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_ENABLE_MSK) ?
576 "enabled " : "disabled ",
577 (ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_FORCE_FREEWHEEL_MODE_MSK) ?
578 "forced " : "",
579 (ioread32(&fw->status) & M00473_STATUS_BITMAP_FREEWHEEL_MODE_MSK) ?
580 "freewheeling " : "video-passthrough ");
581 iowrite32(0xff, &vmr->irq_status);
582 cobalt_info("rx%d: Clock Loss Detection: %s%s\n", rx,
583 (ioread32(&clkloss->ctrl) & M00479_CTRL_BITMAP_ENABLE_MSK) ?
584 "enabled " : "disabled ",
585 (ioread32(&clkloss->status) & M00479_STATUS_BITMAP_CLOCK_MISSING_MSK) ?
586 "clock-missing " : "found-clock ");
587 cobalt_info("rx%d: Packer: %x\n", rx, ioread32(&packer->control));
588 }
589
590 static int cobalt_log_status(struct file *file, void *priv_fh)
591 {
592 struct cobalt_stream *s = video_drvdata(file);
593 struct cobalt *cobalt = s->cobalt;
594 struct m00514_syncgen_flow_evcnt_regmap __iomem *vo =
595 COBALT_TX_BASE(cobalt);
596 u8 stat;
597
598 cobalt_info("%s", cobalt->hdl_info);
599 cobalt_info("sysctrl: %08x, sysstat: %08x\n",
600 cobalt_g_sysctrl(cobalt),
601 cobalt_g_sysstat(cobalt));
602 cobalt_info("dma channel: %d, video channel: %d\n",
603 s->dma_channel, s->video_channel);
604 cobalt_pcie_status_show(cobalt);
605 cobalt_cpld_status(cobalt);
606 cobalt_irq_log_status(cobalt);
607 v4l2_subdev_call(s->sd, core, log_status);
608 if (!s->is_output) {
609 cobalt_video_input_status_show(s);
610 return 0;
611 }
612
613 stat = ioread32(&vo->rd_status);
614
615 cobalt_info("tx: status: %s%s\n",
616 (stat & M00514_RD_STATUS_BITMAP_FLOW_CTRL_NO_DATA_ERROR_MSK) ?
617 "no_data " : "",
618 (stat & M00514_RD_STATUS_BITMAP_READY_BUFFER_FULL_MSK) ?
619 "ready_buffer_full " : "");
620 cobalt_info("tx: evcnt: %d\n", ioread32(&vo->rd_evcnt_count));
621 return 0;
622 }
623
624 static int cobalt_enum_dv_timings(struct file *file, void *priv_fh,
625 struct v4l2_enum_dv_timings *timings)
626 {
627 struct cobalt_stream *s = video_drvdata(file);
628
629 if (s->input == 1) {
630 if (timings->index)
631 return -EINVAL;
632 memset(timings->reserved, 0, sizeof(timings->reserved));
633 timings->timings = cea1080p60;
634 return 0;
635 }
636 timings->pad = 0;
637 return v4l2_subdev_call(s->sd,
638 pad, enum_dv_timings, timings);
639 }
640
641 static int cobalt_s_dv_timings(struct file *file, void *priv_fh,
642 struct v4l2_dv_timings *timings)
643 {
644 struct cobalt_stream *s = video_drvdata(file);
645 int err;
646
647 if (s->input == 1) {
648 *timings = cea1080p60;
649 return 0;
650 }
651
652 if (v4l2_match_dv_timings(timings, &s->timings, 0))
653 return 0;
654
655 if (vb2_is_busy(&s->q))
656 return -EBUSY;
657
658 err = v4l2_subdev_call(s->sd,
659 video, s_dv_timings, timings);
660 if (!err) {
661 s->timings = *timings;
662 s->width = timings->bt.width;
663 s->height = timings->bt.height;
664 s->stride = timings->bt.width * s->bpp;
665 }
666 return err;
667 }
668
669 static int cobalt_g_dv_timings(struct file *file, void *priv_fh,
670 struct v4l2_dv_timings *timings)
671 {
672 struct cobalt_stream *s = video_drvdata(file);
673
674 if (s->input == 1) {
675 *timings = cea1080p60;
676 return 0;
677 }
678 return v4l2_subdev_call(s->sd,
679 video, g_dv_timings, timings);
680 }
681
682 static int cobalt_query_dv_timings(struct file *file, void *priv_fh,
683 struct v4l2_dv_timings *timings)
684 {
685 struct cobalt_stream *s = video_drvdata(file);
686
687 if (s->input == 1) {
688 *timings = cea1080p60;
689 return 0;
690 }
691 return v4l2_subdev_call(s->sd,
692 video, query_dv_timings, timings);
693 }
694
695 static int cobalt_dv_timings_cap(struct file *file, void *priv_fh,
696 struct v4l2_dv_timings_cap *cap)
697 {
698 struct cobalt_stream *s = video_drvdata(file);
699
700 cap->pad = 0;
701 return v4l2_subdev_call(s->sd,
702 pad, dv_timings_cap, cap);
703 }
704
705 static int cobalt_enum_fmt_vid_cap(struct file *file, void *priv_fh,
706 struct v4l2_fmtdesc *f)
707 {
708 switch (f->index) {
709 case 0:
710 strlcpy(f->description, "YUV 4:2:2", sizeof(f->description));
711 f->pixelformat = V4L2_PIX_FMT_YUYV;
712 break;
713 case 1:
714 strlcpy(f->description, "RGB24", sizeof(f->description));
715 f->pixelformat = V4L2_PIX_FMT_RGB24;
716 break;
717 case 2:
718 strlcpy(f->description, "RGB32", sizeof(f->description));
719 f->pixelformat = V4L2_PIX_FMT_BGR32;
720 break;
721 default:
722 return -EINVAL;
723 }
724
725 return 0;
726 }
727
728 static int cobalt_g_fmt_vid_cap(struct file *file, void *priv_fh,
729 struct v4l2_format *f)
730 {
731 struct cobalt_stream *s = video_drvdata(file);
732 struct v4l2_pix_format *pix = &f->fmt.pix;
733 struct v4l2_subdev_format sd_fmt;
734
735 pix->width = s->width;
736 pix->height = s->height;
737 pix->bytesperline = s->stride;
738 pix->field = V4L2_FIELD_NONE;
739
740 if (s->input == 1) {
741 pix->colorspace = V4L2_COLORSPACE_SRGB;
742 } else {
743 sd_fmt.pad = s->pad_source;
744 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
745 v4l2_subdev_call(s->sd, pad, get_fmt, NULL, &sd_fmt);
746 v4l2_fill_pix_format(pix, &sd_fmt.format);
747 }
748
749 pix->pixelformat = s->pixfmt;
750 pix->sizeimage = pix->bytesperline * pix->height;
751
752 return 0;
753 }
754
755 static int cobalt_try_fmt_vid_cap(struct file *file, void *priv_fh,
756 struct v4l2_format *f)
757 {
758 struct cobalt_stream *s = video_drvdata(file);
759 struct v4l2_pix_format *pix = &f->fmt.pix;
760 struct v4l2_subdev_format sd_fmt;
761
762 /* Check for min (QCIF) and max (Full HD) size */
763 if ((pix->width < 176) || (pix->height < 144)) {
764 pix->width = 176;
765 pix->height = 144;
766 }
767
768 if ((pix->width > 1920) || (pix->height > 1080)) {
769 pix->width = 1920;
770 pix->height = 1080;
771 }
772
773 /* Make width multiple of 4 */
774 pix->width &= ~0x3;
775
776 /* Make height multiple of 2 */
777 pix->height &= ~0x1;
778
779 if (s->input == 1) {
780 /* Generator => fixed format only */
781 pix->width = 1920;
782 pix->height = 1080;
783 pix->colorspace = V4L2_COLORSPACE_SRGB;
784 } else {
785 sd_fmt.pad = s->pad_source;
786 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
787 v4l2_subdev_call(s->sd, pad, get_fmt, NULL, &sd_fmt);
788 v4l2_fill_pix_format(pix, &sd_fmt.format);
789 }
790
791 switch (pix->pixelformat) {
792 case V4L2_PIX_FMT_YUYV:
793 default:
794 pix->bytesperline = max(pix->bytesperline & ~0x3,
795 pix->width * COBALT_BYTES_PER_PIXEL_YUYV);
796 pix->pixelformat = V4L2_PIX_FMT_YUYV;
797 break;
798 case V4L2_PIX_FMT_RGB24:
799 pix->bytesperline = max(pix->bytesperline & ~0x3,
800 pix->width * COBALT_BYTES_PER_PIXEL_RGB24);
801 break;
802 case V4L2_PIX_FMT_BGR32:
803 pix->bytesperline = max(pix->bytesperline & ~0x3,
804 pix->width * COBALT_BYTES_PER_PIXEL_RGB32);
805 break;
806 }
807
808 pix->sizeimage = pix->bytesperline * pix->height;
809 pix->field = V4L2_FIELD_NONE;
810 pix->priv = 0;
811
812 return 0;
813 }
814
815 static int cobalt_s_fmt_vid_cap(struct file *file, void *priv_fh,
816 struct v4l2_format *f)
817 {
818 struct cobalt_stream *s = video_drvdata(file);
819 struct v4l2_pix_format *pix = &f->fmt.pix;
820
821 if (vb2_is_busy(&s->q))
822 return -EBUSY;
823
824 if (cobalt_try_fmt_vid_cap(file, priv_fh, f))
825 return -EINVAL;
826
827 s->width = pix->width;
828 s->height = pix->height;
829 s->stride = pix->bytesperline;
830 switch (pix->pixelformat) {
831 case V4L2_PIX_FMT_YUYV:
832 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV;
833 break;
834 case V4L2_PIX_FMT_RGB24:
835 s->bpp = COBALT_BYTES_PER_PIXEL_RGB24;
836 break;
837 case V4L2_PIX_FMT_BGR32:
838 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32;
839 break;
840 default:
841 return -EINVAL;
842 }
843 s->pixfmt = pix->pixelformat;
844 cobalt_enable_input(s);
845
846 return 0;
847 }
848
849 static int cobalt_try_fmt_vid_out(struct file *file, void *priv_fh,
850 struct v4l2_format *f)
851 {
852 struct v4l2_pix_format *pix = &f->fmt.pix;
853
854 /* Check for min (QCIF) and max (Full HD) size */
855 if ((pix->width < 176) || (pix->height < 144)) {
856 pix->width = 176;
857 pix->height = 144;
858 }
859
860 if ((pix->width > 1920) || (pix->height > 1080)) {
861 pix->width = 1920;
862 pix->height = 1080;
863 }
864
865 /* Make width multiple of 4 */
866 pix->width &= ~0x3;
867
868 /* Make height multiple of 2 */
869 pix->height &= ~0x1;
870
871 switch (pix->pixelformat) {
872 case V4L2_PIX_FMT_YUYV:
873 default:
874 pix->bytesperline = max(pix->bytesperline & ~0x3,
875 pix->width * COBALT_BYTES_PER_PIXEL_YUYV);
876 pix->pixelformat = V4L2_PIX_FMT_YUYV;
877 break;
878 case V4L2_PIX_FMT_BGR32:
879 pix->bytesperline = max(pix->bytesperline & ~0x3,
880 pix->width * COBALT_BYTES_PER_PIXEL_RGB32);
881 break;
882 }
883
884 pix->sizeimage = pix->bytesperline * pix->height;
885 pix->field = V4L2_FIELD_NONE;
886
887 return 0;
888 }
889
890 static int cobalt_g_fmt_vid_out(struct file *file, void *priv_fh,
891 struct v4l2_format *f)
892 {
893 struct cobalt_stream *s = video_drvdata(file);
894 struct v4l2_pix_format *pix = &f->fmt.pix;
895
896 pix->width = s->width;
897 pix->height = s->height;
898 pix->bytesperline = s->stride;
899 pix->field = V4L2_FIELD_NONE;
900 pix->pixelformat = s->pixfmt;
901 pix->colorspace = s->colorspace;
902 pix->xfer_func = s->xfer_func;
903 pix->ycbcr_enc = s->ycbcr_enc;
904 pix->quantization = s->quantization;
905 pix->sizeimage = pix->bytesperline * pix->height;
906
907 return 0;
908 }
909
910 static int cobalt_enum_fmt_vid_out(struct file *file, void *priv_fh,
911 struct v4l2_fmtdesc *f)
912 {
913 switch (f->index) {
914 case 0:
915 strlcpy(f->description, "YUV 4:2:2", sizeof(f->description));
916 f->pixelformat = V4L2_PIX_FMT_YUYV;
917 break;
918 case 1:
919 strlcpy(f->description, "RGB32", sizeof(f->description));
920 f->pixelformat = V4L2_PIX_FMT_BGR32;
921 break;
922 default:
923 return -EINVAL;
924 }
925
926 return 0;
927 }
928
929 static int cobalt_s_fmt_vid_out(struct file *file, void *priv_fh,
930 struct v4l2_format *f)
931 {
932 struct cobalt_stream *s = video_drvdata(file);
933 struct v4l2_pix_format *pix = &f->fmt.pix;
934 struct v4l2_subdev_format sd_fmt = { 0 };
935 u32 code;
936
937 if (cobalt_try_fmt_vid_out(file, priv_fh, f))
938 return -EINVAL;
939
940 if (vb2_is_busy(&s->q) && (pix->pixelformat != s->pixfmt ||
941 pix->width != s->width || pix->height != s->height ||
942 pix->bytesperline != s->stride))
943 return -EBUSY;
944
945 switch (pix->pixelformat) {
946 case V4L2_PIX_FMT_YUYV:
947 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV;
948 code = MEDIA_BUS_FMT_UYVY8_1X16;
949 break;
950 case V4L2_PIX_FMT_BGR32:
951 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32;
952 code = MEDIA_BUS_FMT_RGB888_1X24;
953 break;
954 default:
955 return -EINVAL;
956 }
957 s->width = pix->width;
958 s->height = pix->height;
959 s->stride = pix->bytesperline;
960 s->pixfmt = pix->pixelformat;
961 s->colorspace = pix->colorspace;
962 s->xfer_func = pix->xfer_func;
963 s->ycbcr_enc = pix->ycbcr_enc;
964 s->quantization = pix->quantization;
965 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
966 v4l2_fill_mbus_format(&sd_fmt.format, pix, code);
967 v4l2_subdev_call(s->sd, pad, set_fmt, NULL, &sd_fmt);
968 return 0;
969 }
970
971 static int cobalt_enum_input(struct file *file, void *priv_fh,
972 struct v4l2_input *inp)
973 {
974 struct cobalt_stream *s = video_drvdata(file);
975
976 if (inp->index > 1)
977 return -EINVAL;
978 if (inp->index == 0)
979 snprintf(inp->name, sizeof(inp->name),
980 "HDMI-%d", s->video_channel);
981 else
982 snprintf(inp->name, sizeof(inp->name),
983 "Generator-%d", s->video_channel);
984 inp->type = V4L2_INPUT_TYPE_CAMERA;
985 inp->capabilities = V4L2_IN_CAP_DV_TIMINGS;
986 if (inp->index == 1)
987 return 0;
988 return v4l2_subdev_call(s->sd,
989 video, g_input_status, &inp->status);
990 }
991
992 static int cobalt_g_input(struct file *file, void *priv_fh, unsigned int *i)
993 {
994 struct cobalt_stream *s = video_drvdata(file);
995
996 *i = s->input;
997 return 0;
998 }
999
1000 static int cobalt_s_input(struct file *file, void *priv_fh, unsigned int i)
1001 {
1002 struct cobalt_stream *s = video_drvdata(file);
1003
1004 if (i >= 2)
1005 return -EINVAL;
1006 if (vb2_is_busy(&s->q))
1007 return -EBUSY;
1008 s->input = i;
1009
1010 cobalt_enable_input(s);
1011
1012 if (s->input == 1) /* Test Pattern Generator */
1013 return 0;
1014
1015 return v4l2_subdev_call(s->sd, video, s_routing,
1016 ADV76XX_PAD_HDMI_PORT_A, 0, 0);
1017 }
1018
1019 static int cobalt_enum_output(struct file *file, void *priv_fh,
1020 struct v4l2_output *out)
1021 {
1022 if (out->index)
1023 return -EINVAL;
1024 snprintf(out->name, sizeof(out->name), "HDMI-%d", out->index);
1025 out->type = V4L2_OUTPUT_TYPE_ANALOG;
1026 out->capabilities = V4L2_OUT_CAP_DV_TIMINGS;
1027 return 0;
1028 }
1029
1030 static int cobalt_g_output(struct file *file, void *priv_fh, unsigned int *i)
1031 {
1032 *i = 0;
1033 return 0;
1034 }
1035
1036 static int cobalt_s_output(struct file *file, void *priv_fh, unsigned int i)
1037 {
1038 return i ? -EINVAL : 0;
1039 }
1040
1041 static int cobalt_g_edid(struct file *file, void *fh, struct v4l2_edid *edid)
1042 {
1043 struct cobalt_stream *s = video_drvdata(file);
1044 u32 pad = edid->pad;
1045 int ret;
1046
1047 if (edid->pad >= (s->is_output ? 1 : 2))
1048 return -EINVAL;
1049 edid->pad = 0;
1050 ret = v4l2_subdev_call(s->sd, pad, get_edid, edid);
1051 edid->pad = pad;
1052 return ret;
1053 }
1054
1055 static int cobalt_s_edid(struct file *file, void *fh, struct v4l2_edid *edid)
1056 {
1057 struct cobalt_stream *s = video_drvdata(file);
1058 u32 pad = edid->pad;
1059 int ret;
1060
1061 if (edid->pad >= 2)
1062 return -EINVAL;
1063 edid->pad = 0;
1064 ret = v4l2_subdev_call(s->sd, pad, set_edid, edid);
1065 edid->pad = pad;
1066 return ret;
1067 }
1068
1069 static int cobalt_subscribe_event(struct v4l2_fh *fh,
1070 const struct v4l2_event_subscription *sub)
1071 {
1072 switch (sub->type) {
1073 case V4L2_EVENT_SOURCE_CHANGE:
1074 return v4l2_event_subscribe(fh, sub, 4, NULL);
1075 }
1076 return v4l2_ctrl_subscribe_event(fh, sub);
1077 }
1078
1079 static int cobalt_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
1080 {
1081 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1082 return -EINVAL;
1083 a->parm.capture.timeperframe.numerator = 1;
1084 a->parm.capture.timeperframe.denominator = 60;
1085 a->parm.capture.readbuffers = 3;
1086 return 0;
1087 }
1088
1089 static const struct v4l2_ioctl_ops cobalt_ioctl_ops = {
1090 .vidioc_querycap = cobalt_querycap,
1091 .vidioc_g_parm = cobalt_g_parm,
1092 .vidioc_log_status = cobalt_log_status,
1093 .vidioc_streamon = vb2_ioctl_streamon,
1094 .vidioc_streamoff = vb2_ioctl_streamoff,
1095 .vidioc_enum_input = cobalt_enum_input,
1096 .vidioc_g_input = cobalt_g_input,
1097 .vidioc_s_input = cobalt_s_input,
1098 .vidioc_enum_fmt_vid_cap = cobalt_enum_fmt_vid_cap,
1099 .vidioc_g_fmt_vid_cap = cobalt_g_fmt_vid_cap,
1100 .vidioc_s_fmt_vid_cap = cobalt_s_fmt_vid_cap,
1101 .vidioc_try_fmt_vid_cap = cobalt_try_fmt_vid_cap,
1102 .vidioc_enum_output = cobalt_enum_output,
1103 .vidioc_g_output = cobalt_g_output,
1104 .vidioc_s_output = cobalt_s_output,
1105 .vidioc_enum_fmt_vid_out = cobalt_enum_fmt_vid_out,
1106 .vidioc_g_fmt_vid_out = cobalt_g_fmt_vid_out,
1107 .vidioc_s_fmt_vid_out = cobalt_s_fmt_vid_out,
1108 .vidioc_try_fmt_vid_out = cobalt_try_fmt_vid_out,
1109 .vidioc_s_dv_timings = cobalt_s_dv_timings,
1110 .vidioc_g_dv_timings = cobalt_g_dv_timings,
1111 .vidioc_query_dv_timings = cobalt_query_dv_timings,
1112 .vidioc_enum_dv_timings = cobalt_enum_dv_timings,
1113 .vidioc_dv_timings_cap = cobalt_dv_timings_cap,
1114 .vidioc_g_edid = cobalt_g_edid,
1115 .vidioc_s_edid = cobalt_s_edid,
1116 .vidioc_subscribe_event = cobalt_subscribe_event,
1117 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1118 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1119 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1120 .vidioc_querybuf = vb2_ioctl_querybuf,
1121 .vidioc_qbuf = vb2_ioctl_qbuf,
1122 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1123 .vidioc_expbuf = vb2_ioctl_expbuf,
1124 #ifdef CONFIG_VIDEO_ADV_DEBUG
1125 .vidioc_g_register = cobalt_g_register,
1126 .vidioc_s_register = cobalt_s_register,
1127 #endif
1128 };
1129
1130 static const struct v4l2_ioctl_ops cobalt_ioctl_empty_ops = {
1131 #ifdef CONFIG_VIDEO_ADV_DEBUG
1132 .vidioc_g_register = cobalt_g_register,
1133 .vidioc_s_register = cobalt_s_register,
1134 #endif
1135 };
1136
1137 /* Register device nodes */
1138
1139 static const struct v4l2_file_operations cobalt_fops = {
1140 .owner = THIS_MODULE,
1141 .open = v4l2_fh_open,
1142 .unlocked_ioctl = video_ioctl2,
1143 .release = vb2_fop_release,
1144 .poll = vb2_fop_poll,
1145 .mmap = vb2_fop_mmap,
1146 .read = vb2_fop_read,
1147 };
1148
1149 static const struct v4l2_file_operations cobalt_out_fops = {
1150 .owner = THIS_MODULE,
1151 .open = v4l2_fh_open,
1152 .unlocked_ioctl = video_ioctl2,
1153 .release = vb2_fop_release,
1154 .poll = vb2_fop_poll,
1155 .mmap = vb2_fop_mmap,
1156 .write = vb2_fop_write,
1157 };
1158
1159 static const struct v4l2_file_operations cobalt_empty_fops = {
1160 .owner = THIS_MODULE,
1161 .open = v4l2_fh_open,
1162 .unlocked_ioctl = video_ioctl2,
1163 .release = v4l2_fh_release,
1164 };
1165
1166 static int cobalt_node_register(struct cobalt *cobalt, int node)
1167 {
1168 static const struct v4l2_dv_timings dv1080p60 =
1169 V4L2_DV_BT_CEA_1920X1080P60;
1170 struct cobalt_stream *s = cobalt->streams + node;
1171 struct video_device *vdev = &s->vdev;
1172 struct vb2_queue *q = &s->q;
1173 int ret;
1174
1175 mutex_init(&s->lock);
1176 spin_lock_init(&s->irqlock);
1177
1178 snprintf(vdev->name, sizeof(vdev->name),
1179 "%s-%d", cobalt->v4l2_dev.name, node);
1180 s->width = 1920;
1181 /* Audio frames are just 4 lines of 1920 bytes */
1182 s->height = s->is_audio ? 4 : 1080;
1183
1184 if (s->is_audio) {
1185 s->bpp = 1;
1186 s->pixfmt = V4L2_PIX_FMT_GREY;
1187 } else if (s->is_output) {
1188 s->bpp = COBALT_BYTES_PER_PIXEL_RGB32;
1189 s->pixfmt = V4L2_PIX_FMT_BGR32;
1190 } else {
1191 s->bpp = COBALT_BYTES_PER_PIXEL_YUYV;
1192 s->pixfmt = V4L2_PIX_FMT_YUYV;
1193 }
1194 s->colorspace = V4L2_COLORSPACE_SRGB;
1195 s->stride = s->width * s->bpp;
1196
1197 if (!s->is_audio) {
1198 if (s->is_dummy)
1199 cobalt_warn("Setting up dummy video node %d\n", node);
1200 vdev->v4l2_dev = &cobalt->v4l2_dev;
1201 if (s->is_dummy)
1202 vdev->fops = &cobalt_empty_fops;
1203 else
1204 vdev->fops = s->is_output ? &cobalt_out_fops :
1205 &cobalt_fops;
1206 vdev->release = video_device_release_empty;
1207 vdev->vfl_dir = s->is_output ? VFL_DIR_TX : VFL_DIR_RX;
1208 vdev->lock = &s->lock;
1209 if (s->sd)
1210 vdev->ctrl_handler = s->sd->ctrl_handler;
1211 s->timings = dv1080p60;
1212 v4l2_subdev_call(s->sd, video, s_dv_timings, &s->timings);
1213 if (!s->is_output && s->sd)
1214 cobalt_enable_input(s);
1215 vdev->ioctl_ops = s->is_dummy ? &cobalt_ioctl_empty_ops :
1216 &cobalt_ioctl_ops;
1217 }
1218
1219 INIT_LIST_HEAD(&s->bufs);
1220 q->type = s->is_output ? V4L2_BUF_TYPE_VIDEO_OUTPUT :
1221 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1222 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1223 q->io_modes |= s->is_output ? VB2_WRITE : VB2_READ;
1224 q->drv_priv = s;
1225 q->buf_struct_size = sizeof(struct cobalt_buffer);
1226 q->ops = &cobalt_qops;
1227 q->mem_ops = &vb2_dma_sg_memops;
1228 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1229 q->min_buffers_needed = 2;
1230 q->lock = &s->lock;
1231 vdev->queue = q;
1232
1233 video_set_drvdata(vdev, s);
1234 ret = vb2_queue_init(q);
1235 if (!s->is_audio && ret == 0)
1236 ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1237 else if (!s->is_dummy)
1238 ret = cobalt_alsa_init(s);
1239
1240 if (ret < 0) {
1241 if (!s->is_audio)
1242 cobalt_err("couldn't register v4l2 device node %d\n",
1243 node);
1244 return ret;
1245 }
1246 cobalt_info("registered node %d\n", node);
1247 return 0;
1248 }
1249
1250 /* Initialize v4l2 variables and register v4l2 devices */
1251 int cobalt_nodes_register(struct cobalt *cobalt)
1252 {
1253 int node, ret;
1254
1255 /* Setup V4L2 Devices */
1256 for (node = 0; node < COBALT_NUM_STREAMS; node++) {
1257 ret = cobalt_node_register(cobalt, node);
1258 if (ret)
1259 return ret;
1260 }
1261 return 0;
1262 }
1263
1264 /* Unregister v4l2 devices */
1265 void cobalt_nodes_unregister(struct cobalt *cobalt)
1266 {
1267 int node;
1268
1269 /* Teardown all streams */
1270 for (node = 0; node < COBALT_NUM_STREAMS; node++) {
1271 struct cobalt_stream *s = cobalt->streams + node;
1272 struct video_device *vdev = &s->vdev;
1273
1274 if (!s->is_audio)
1275 video_unregister_device(vdev);
1276 else if (!s->is_dummy)
1277 cobalt_alsa_exit(s);
1278 }
1279 }
Linux with added FPC-III support