Lines Matching refs:sdr
131 #define to_rcar_drif_buf_pair(sdr, ch_num, idx) \
132 (&((sdr)->ch[!(ch_num)]->buf[(idx)]))
138 #define rdrif_dbg(sdr, fmt, arg...) \
139 dev_dbg(sdr->v4l2_dev.dev, fmt, ## arg)
141 #define rdrif_err(sdr, fmt, arg...) \
142 dev_err(sdr->v4l2_dev.dev, fmt, ## arg)
198 struct rcar_drif_sdr *sdr; /* Group device */
241 u32 produced; /* Buffers produced by sdr dev */
256 static void rcar_drif_release_dmachannels(struct rcar_drif_sdr *sdr)
260 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask)
261 if (sdr->ch[i]->dmach) {
262 dma_release_channel(sdr->ch[i]->dmach);
263 sdr->ch[i]->dmach = NULL;
268 static int rcar_drif_alloc_dmachannels(struct rcar_drif_sdr *sdr)
274 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
275 struct rcar_drif *ch = sdr->ch[i];
281 rdrif_err(sdr,
294 rdrif_err(sdr, "ch%u: dma slave config failed\n", i);
301 rcar_drif_release_dmachannels(sdr);
306 static void rcar_drif_release_queued_bufs(struct rcar_drif_sdr *sdr,
312 spin_lock_irqsave(&sdr->queued_bufs_lock, flags);
313 list_for_each_entry_safe(fbuf, tmp, &sdr->queued_bufs, list) {
317 spin_unlock_irqrestore(&sdr->queued_bufs_lock, flags);
321 static inline void rcar_drif_set_mdr1(struct rcar_drif_sdr *sdr)
326 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
328 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SITMDR1,
332 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SIRMDR1, sdr->mdr1);
334 rdrif_dbg(sdr, "ch%u: mdr1 = 0x%08x",
335 i, rcar_drif_read(sdr->ch[i], RCAR_DRIF_SIRMDR1));
340 static int rcar_drif_set_format(struct rcar_drif_sdr *sdr)
344 rdrif_dbg(sdr, "setfmt: bitlen %u wdcnt %u num_ch %u\n",
345 sdr->fmt->bitlen, sdr->fmt->wdcnt, sdr->fmt->num_ch);
348 if (sdr->fmt->num_ch > sdr->num_cur_ch) {
349 rdrif_err(sdr, "fmt num_ch %u cur_ch %u mismatch\n",
350 sdr->fmt->num_ch, sdr->num_cur_ch);
355 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
360 RCAR_DRIF_MDR_BITLEN(sdr->fmt->bitlen) |
361 RCAR_DRIF_MDR_WDCNT(sdr->fmt->wdcnt);
362 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SIRMDR2, mdr);
364 mdr = RCAR_DRIF_MDR_BITLEN(sdr->fmt->bitlen) |
365 RCAR_DRIF_MDR_WDCNT(sdr->fmt->wdcnt);
366 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SIRMDR3, mdr);
368 rdrif_dbg(sdr, "ch%u: new mdr[2,3] = 0x%08x, 0x%08x\n",
369 i, rcar_drif_read(sdr->ch[i], RCAR_DRIF_SIRMDR2),
370 rcar_drif_read(sdr->ch[i], RCAR_DRIF_SIRMDR3));
376 static void rcar_drif_release_buf(struct rcar_drif_sdr *sdr)
380 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
381 struct rcar_drif *ch = sdr->ch[i];
386 sdr->hwbuf_size * RCAR_DRIF_NUM_HWBUFS,
394 static int rcar_drif_request_buf(struct rcar_drif_sdr *sdr)
400 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
401 struct rcar_drif *ch = sdr->ch[i];
405 sdr->hwbuf_size * RCAR_DRIF_NUM_HWBUFS,
408 rdrif_err(sdr,
410 i, RCAR_DRIF_NUM_HWBUFS, sdr->hwbuf_size);
416 ch->buf[j].addr = addr + (j * sdr->hwbuf_size);
430 struct rcar_drif_sdr *sdr = vb2_get_drv_priv(vq);
437 sizes[0] = PAGE_ALIGN(sdr->fmt->buffersize);
438 rdrif_dbg(sdr, "num_bufs %d sizes[0] %d\n", *num_buffers, sizes[0]);
447 struct rcar_drif_sdr *sdr = vb2_get_drv_priv(vb->vb2_queue);
452 rdrif_dbg(sdr, "buf_queue idx %u\n", vb->index);
453 spin_lock_irqsave(&sdr->queued_bufs_lock, flags);
454 list_add_tail(&fbuf->list, &sdr->queued_bufs);
455 spin_unlock_irqrestore(&sdr->queued_bufs_lock, flags);
460 rcar_drif_get_fbuf(struct rcar_drif_sdr *sdr)
465 spin_lock_irqsave(&sdr->queued_bufs_lock, flags);
466 fbuf = list_first_entry_or_null(&sdr->queued_bufs, struct
473 rdrif_dbg(sdr, "\napp late: prod %u\n", sdr->produced);
474 spin_unlock_irqrestore(&sdr->queued_bufs_lock, flags);
478 spin_unlock_irqrestore(&sdr->queued_bufs_lock, flags);
525 struct rcar_drif_sdr *sdr = ch->sdr;
532 spin_lock(&sdr->dma_lock);
535 if (!vb2_is_streaming(&sdr->vb_queue)) {
536 spin_unlock(&sdr->dma_lock);
540 idx = sdr->produced % RCAR_DRIF_NUM_HWBUFS;
543 if (sdr->num_cur_ch == RCAR_DRIF_MAX_CHANNEL) {
544 buf[0] = ch->num ? to_rcar_drif_buf_pair(sdr, ch->num, idx) :
547 to_rcar_drif_buf_pair(sdr, ch->num, idx);
551 spin_unlock(&sdr->dma_lock);
573 produced = sdr->produced++;
574 spin_unlock(&sdr->dma_lock);
576 rdrif_dbg(sdr, "ch%u: prod %u\n", ch->num, produced);
579 fbuf = rcar_drif_get_fbuf(sdr);
585 i * sdr->hwbuf_size, buf[i]->addr, sdr->hwbuf_size);
590 vb2_set_plane_payload(&fbuf->vb.vb2_buf, 0, sdr->fmt->buffersize);
599 struct rcar_drif_sdr *sdr = ch->sdr;
607 sdr->hwbuf_size * RCAR_DRIF_NUM_HWBUFS,
608 sdr->hwbuf_size, DMA_DEV_TO_MEM,
611 rdrif_err(sdr, "ch%u: prep dma cyclic failed\n", ch->num);
620 rdrif_err(sdr, "ch%u: dma submit failed\n", ch->num);
629 static int rcar_drif_enable_rx(struct rcar_drif_sdr *sdr)
641 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
642 ctr = rcar_drif_read(sdr->ch[i], RCAR_DRIF_SICTR);
645 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SICTR, ctr);
649 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
650 ret = readl_poll_timeout(sdr->ch[i]->base + RCAR_DRIF_SICTR,
653 rdrif_err(sdr, "ch%u: rx en failed. ctr 0x%08x\n", i,
654 rcar_drif_read(sdr->ch[i], RCAR_DRIF_SICTR));
662 static void rcar_drif_disable_rx(struct rcar_drif_sdr *sdr)
669 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
670 ctr = rcar_drif_read(sdr->ch[i], RCAR_DRIF_SICTR);
672 rcar_drif_write(sdr->ch[i], RCAR_DRIF_SICTR, ctr);
676 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
677 ret = readl_poll_timeout(sdr->ch[i]->base + RCAR_DRIF_SICTR,
680 dev_warn(&sdr->vdev->dev,
682 i, rcar_drif_read(sdr->ch[i], RCAR_DRIF_SICTR));
697 static void rcar_drif_stop(struct rcar_drif_sdr *sdr)
702 rcar_drif_disable_rx(sdr);
704 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask)
705 rcar_drif_stop_channel(sdr->ch[i]);
711 struct rcar_drif_sdr *sdr = ch->sdr;
720 rdrif_err(sdr, "ch%u: failed to reset rx. ctr 0x%08x\n",
742 static int rcar_drif_start(struct rcar_drif_sdr *sdr)
748 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
749 ret = rcar_drif_start_channel(sdr->ch[i]);
755 ret = rcar_drif_enable_rx(sdr);
759 sdr->produced = 0;
763 rcar_drif_disable_rx(sdr);
766 rcar_drif_stop_channel(sdr->ch[i]);
774 struct rcar_drif_sdr *sdr = vb2_get_drv_priv(vq);
779 mutex_lock(&sdr->v4l2_mutex);
781 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask) {
782 ret = clk_prepare_enable(sdr->ch[i]->clk);
789 rcar_drif_set_mdr1(sdr);
792 ret = rcar_drif_set_format(sdr);
796 if (sdr->num_cur_ch == RCAR_DRIF_MAX_CHANNEL)
797 sdr->hwbuf_size = sdr->fmt->buffersize / RCAR_DRIF_MAX_CHANNEL;
799 sdr->hwbuf_size = sdr->fmt->buffersize;
801 rdrif_dbg(sdr, "num hwbufs %u, hwbuf_size %u\n",
802 RCAR_DRIF_NUM_HWBUFS, sdr->hwbuf_size);
805 ret = rcar_drif_alloc_dmachannels(sdr);
810 ret = rcar_drif_request_buf(sdr);
815 ret = rcar_drif_start(sdr);
819 mutex_unlock(&sdr->v4l2_mutex);
824 rcar_drif_release_queued_bufs(sdr, VB2_BUF_STATE_QUEUED);
825 rcar_drif_release_buf(sdr);
826 rcar_drif_release_dmachannels(sdr);
828 clk_disable_unprepare(sdr->ch[i]->clk);
830 mutex_unlock(&sdr->v4l2_mutex);
838 struct rcar_drif_sdr *sdr = vb2_get_drv_priv(vq);
841 mutex_lock(&sdr->v4l2_mutex);
844 rcar_drif_stop(sdr);
847 rcar_drif_release_queued_bufs(sdr, VB2_BUF_STATE_ERROR);
850 rcar_drif_release_buf(sdr);
853 rcar_drif_release_dmachannels(sdr);
855 for_each_rcar_drif_channel(i, &sdr->cur_ch_mask)
856 clk_disable_unprepare(sdr->ch[i]->clk);
858 mutex_unlock(&sdr->v4l2_mutex);
874 struct rcar_drif_sdr *sdr = video_drvdata(file);
877 strscpy(cap->card, sdr->vdev->name, sizeof(cap->card));
879 sdr->vdev->name);
884 static int rcar_drif_set_default_format(struct rcar_drif_sdr *sdr)
890 if (sdr->num_hw_ch == formats[i].num_ch) {
891 sdr->fmt = &formats[i];
892 sdr->cur_ch_mask = sdr->hw_ch_mask;
893 sdr->num_cur_ch = sdr->num_hw_ch;
894 dev_dbg(sdr->dev, "default fmt[%u]: mask %lu num %u\n",
895 i, sdr->cur_ch_mask, sdr->num_cur_ch);
916 struct rcar_drif_sdr *sdr = video_drvdata(file);
918 f->fmt.sdr.pixelformat = sdr->fmt->pixelformat;
919 f->fmt.sdr.buffersize = sdr->fmt->buffersize;
927 struct rcar_drif_sdr *sdr = video_drvdata(file);
928 struct vb2_queue *q = &sdr->vb_queue;
935 if (formats[i].pixelformat == f->fmt.sdr.pixelformat)
942 sdr->fmt = &formats[i];
943 f->fmt.sdr.pixelformat = sdr->fmt->pixelformat;
944 f->fmt.sdr.buffersize = formats[i].buffersize;
945 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
951 if (formats[i].num_ch < sdr->num_hw_ch) {
952 sdr->cur_ch_mask = BIT(0);
953 sdr->num_cur_ch = formats[i].num_ch;
955 sdr->cur_ch_mask = sdr->hw_ch_mask;
956 sdr->num_cur_ch = sdr->num_hw_ch;
959 rdrif_dbg(sdr, "cur: idx %u mask %lu num %u\n",
960 i, sdr->cur_ch_mask, sdr->num_cur_ch);
971 if (formats[i].pixelformat == f->fmt.sdr.pixelformat) {
972 f->fmt.sdr.buffersize = formats[i].buffersize;
977 f->fmt.sdr.pixelformat = formats[0].pixelformat;
978 f->fmt.sdr.buffersize = formats[0].buffersize;
979 memset(f->fmt.sdr.reserved, 0, sizeof(f->fmt.sdr.reserved));
988 struct rcar_drif_sdr *sdr = video_drvdata(file);
990 return v4l2_subdev_call(sdr->ep.subdev, tuner, enum_freq_bands, band);
996 struct rcar_drif_sdr *sdr = video_drvdata(file);
998 return v4l2_subdev_call(sdr->ep.subdev, tuner, g_frequency, f);
1004 struct rcar_drif_sdr *sdr = video_drvdata(file);
1006 return v4l2_subdev_call(sdr->ep.subdev, tuner, s_frequency, f);
1012 struct rcar_drif_sdr *sdr = video_drvdata(file);
1014 return v4l2_subdev_call(sdr->ep.subdev, tuner, g_tuner, vt);
1020 struct rcar_drif_sdr *sdr = video_drvdata(file);
1022 return v4l2_subdev_call(sdr->ep.subdev, tuner, s_tuner, vt);
1063 static int rcar_drif_sdr_register(struct rcar_drif_sdr *sdr)
1068 sdr->vdev = video_device_alloc();
1069 if (!sdr->vdev)
1072 snprintf(sdr->vdev->name, sizeof(sdr->vdev->name), "R-Car DRIF");
1073 sdr->vdev->fops = &rcar_drif_fops;
1074 sdr->vdev->ioctl_ops = &rcar_drif_ioctl_ops;
1075 sdr->vdev->release = video_device_release;
1076 sdr->vdev->lock = &sdr->v4l2_mutex;
1077 sdr->vdev->queue = &sdr->vb_queue;
1078 sdr->vdev->queue->lock = &sdr->vb_queue_mutex;
1079 sdr->vdev->ctrl_handler = &sdr->ctrl_hdl;
1080 sdr->vdev->v4l2_dev = &sdr->v4l2_dev;
1081 sdr->vdev->device_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER |
1083 video_set_drvdata(sdr->vdev, sdr);
1086 ret = video_register_device(sdr->vdev, VFL_TYPE_SDR, -1);
1088 video_device_release(sdr->vdev);
1089 sdr->vdev = NULL;
1090 dev_err(sdr->dev, "failed video_register_device (%d)\n", ret);
1096 static void rcar_drif_sdr_unregister(struct rcar_drif_sdr *sdr)
1098 video_unregister_device(sdr->vdev);
1099 sdr->vdev = NULL;
1107 struct rcar_drif_sdr *sdr =
1110 v4l2_set_subdev_hostdata(subdev, sdr);
1111 sdr->ep.subdev = subdev;
1112 rdrif_dbg(sdr, "bound asd %s\n", subdev->name);
1122 struct rcar_drif_sdr *sdr =
1125 if (sdr->ep.subdev != subdev) {
1126 rdrif_err(sdr, "subdev %s is not bound\n", subdev->name);
1131 v4l2_ctrl_handler_free(&sdr->ctrl_hdl);
1132 sdr->v4l2_dev.ctrl_handler = NULL;
1133 sdr->ep.subdev = NULL;
1135 rcar_drif_sdr_unregister(sdr);
1136 rdrif_dbg(sdr, "unbind asd %s\n", subdev->name);
1142 struct rcar_drif_sdr *sdr =
1152 ret = v4l2_ctrl_handler_init(&sdr->ctrl_hdl, 10);
1156 sdr->v4l2_dev.ctrl_handler = &sdr->ctrl_hdl;
1157 ret = v4l2_device_register_subdev_nodes(&sdr->v4l2_dev);
1159 rdrif_err(sdr, "failed: register subdev nodes ret %d\n", ret);
1163 ret = v4l2_ctrl_add_handler(&sdr->ctrl_hdl,
1164 sdr->ep.subdev->ctrl_handler, NULL, true);
1166 rdrif_err(sdr, "failed: ctrl add hdlr ret %d\n", ret);
1170 ret = rcar_drif_sdr_register(sdr);
1177 v4l2_ctrl_handler_free(&sdr->ctrl_hdl);
1189 static void rcar_drif_get_ep_properties(struct rcar_drif_sdr *sdr,
1195 sdr->mdr1 = RCAR_DRIF_SIRMDR1_SYNCMD_LR | RCAR_DRIF_SIRMDR1_MSB_FIRST |
1200 sdr->mdr1 |= val ? RCAR_DRIF_SIRMDR1_SYNCAC_POL_HIGH :
1203 sdr->mdr1 |= RCAR_DRIF_SIRMDR1_SYNCAC_POL_HIGH; /* default */
1205 dev_dbg(sdr->dev, "mdr1 0x%08x\n", sdr->mdr1);
1209 static int rcar_drif_parse_subdevs(struct rcar_drif_sdr *sdr)
1211 struct v4l2_async_notifier *notifier = &sdr->notifier;
1217 ep = fwnode_graph_get_next_endpoint(of_fwnode_handle(sdr->dev->of_node),
1223 rcar_drif_get_ep_properties(sdr, ep);
1228 dev_warn(sdr->dev, "bad remote port parent\n");
1260 static int rcar_drif_bond_available(struct rcar_drif_sdr *sdr,
1269 dev_err(sdr->dev, "failed to get bonded device from node\n");
1276 /* Update sdr data in the bonded device */
1277 ch->sdr = sdr;
1279 /* Update sdr with bonded device data */
1280 sdr->ch[ch->num] = ch;
1281 sdr->hw_ch_mask |= BIT(ch->num);
1284 dev_info(sdr->dev, "defer probe\n");
1295 static int rcar_drif_sdr_probe(struct rcar_drif_sdr *sdr)
1300 ret = rcar_drif_set_default_format(sdr);
1302 dev_err(sdr->dev, "failed to set default format\n");
1307 sdr->hwbuf_size = RCAR_DRIF_DEFAULT_HWBUF_SIZE;
1309 mutex_init(&sdr->v4l2_mutex);
1310 mutex_init(&sdr->vb_queue_mutex);
1311 spin_lock_init(&sdr->queued_bufs_lock);
1312 spin_lock_init(&sdr->dma_lock);
1313 INIT_LIST_HEAD(&sdr->queued_bufs);
1316 sdr->vb_queue.type = V4L2_BUF_TYPE_SDR_CAPTURE;
1317 sdr->vb_queue.io_modes = VB2_READ | VB2_MMAP | VB2_DMABUF;
1318 sdr->vb_queue.drv_priv = sdr;
1319 sdr->vb_queue.buf_struct_size = sizeof(struct rcar_drif_frame_buf);
1320 sdr->vb_queue.ops = &rcar_drif_vb2_ops;
1321 sdr->vb_queue.mem_ops = &vb2_vmalloc_memops;
1322 sdr->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1325 ret = vb2_queue_init(&sdr->vb_queue);
1327 dev_err(sdr->dev, "failed: vb2_queue_init ret %d\n", ret);
1332 ret = v4l2_device_register(sdr->dev, &sdr->v4l2_dev);
1334 dev_err(sdr->dev, "failed: v4l2_device_register ret %d\n", ret);
1342 ret = rcar_drif_parse_subdevs(sdr);
1346 sdr->notifier.ops = &rcar_drif_notify_ops;
1349 ret = v4l2_async_notifier_register(&sdr->v4l2_dev, &sdr->notifier);
1351 dev_err(sdr->dev, "failed: notifier register ret %d\n", ret);
1358 v4l2_async_notifier_cleanup(&sdr->notifier);
1360 v4l2_device_unregister(&sdr->v4l2_dev);
1366 static void rcar_drif_sdr_remove(struct rcar_drif_sdr *sdr)
1368 v4l2_async_notifier_unregister(&sdr->notifier);
1369 v4l2_async_notifier_cleanup(&sdr->notifier);
1370 v4l2_device_unregister(&sdr->v4l2_dev);
1376 struct rcar_drif_sdr *sdr;
1418 sdr = devm_kzalloc(&pdev->dev, sizeof(*sdr), GFP_KERNEL);
1419 if (!sdr) {
1423 ch->sdr = sdr;
1424 sdr->dev = &pdev->dev;
1427 sdr->ch[ch->num] = ch;
1428 sdr->hw_ch_mask = BIT(ch->num);
1431 ret = rcar_drif_bond_available(sdr, np);
1436 sdr->num_hw_ch = hweight_long(sdr->hw_ch_mask);
1438 return rcar_drif_sdr_probe(sdr);
1445 struct rcar_drif_sdr *sdr = ch->sdr;
1452 rcar_drif_sdr_remove(sdr);