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