Lines Matching defs:video
35 #include <uapi/linux/aspeed-video.h>
39 #define DEVICE_NAME "aspeed-video"
267 * flags: holds the state of video
274 * format: holds the video format
279 * frame_bottom: end position of video data in vertical direction
280 * frame_left: start position of video data in horizontal direction
281 * frame_right: end position of video data in horizontal direction
282 * frame_top: start position of video data in vertical direction
491 static bool aspeed_video_alloc_buf(struct aspeed_video *video,
495 static void aspeed_video_free_buf(struct aspeed_video *video,
536 static void aspeed_video_update(struct aspeed_video *video, u32 reg, u32 clear,
539 u32 t = readl(video->base + reg);
544 writel(t, video->base + reg);
545 v4l2_dbg(3, debug, &video->v4l2_dev, "update %03x[%08x -> %08x]\n",
546 reg, before, readl(video->base + reg));
549 static u32 aspeed_video_read(struct aspeed_video *video, u32 reg)
551 u32 t = readl(video->base + reg);
553 v4l2_dbg(3, debug, &video->v4l2_dev, "read %03x[%08x]\n", reg, t);
557 static void aspeed_video_write(struct aspeed_video *video, u32 reg, u32 val)
559 writel(val, video->base + reg);
560 v4l2_dbg(3, debug, &video->v4l2_dev, "write %03x[%08x]\n", reg,
561 readl(video->base + reg));
579 static int aspeed_video_start_frame(struct aspeed_video *video)
584 u32 seq_ctrl = aspeed_video_read(video, VE_SEQ_CTRL);
585 bool bcd_buf_need = (video->format != VIDEO_FMT_STANDARD);
587 if (video->v4l2_input_status) {
588 v4l2_dbg(1, debug, &video->v4l2_dev, "No signal; don't start frame\n");
594 v4l2_dbg(1, debug, &video->v4l2_dev, "Engine busy; don't start frame\n");
598 if (bcd_buf_need && !video->bcd.size) {
599 if (!aspeed_video_alloc_buf(video, &video->bcd,
601 dev_err(video->dev, "Failed to allocate BCD buffer\n");
602 dev_err(video->dev, "don't start frame\n");
605 aspeed_video_write(video, VE_BCD_ADDR, video->bcd.dma);
606 v4l2_dbg(1, debug, &video->v4l2_dev, "bcd addr(%pad) size(%d)\n",
607 &video->bcd.dma, video->bcd.size);
608 } else if (!bcd_buf_need && video->bcd.size) {
609 aspeed_video_free_buf(video, &video->bcd);
612 spin_lock_irqsave(&video->lock, flags);
613 buf = list_first_entry_or_null(&video->buffers,
616 spin_unlock_irqrestore(&video->lock, flags);
617 v4l2_dbg(1, debug, &video->v4l2_dev, "No buffers; don't start frame\n");
621 set_bit(VIDEO_FRAME_INPRG, &video->flags);
623 spin_unlock_irqrestore(&video->lock, flags);
625 aspeed_video_write(video, VE_COMP_PROC_OFFSET, 0);
626 aspeed_video_write(video, VE_COMP_OFFSET, 0);
627 aspeed_video_write(video, VE_COMP_ADDR, addr);
629 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
632 video->perf.last_sample = ktime_get();
634 aspeed_video_update(video, VE_SEQ_CTRL, 0,
640 static void aspeed_video_enable_mode_detect(struct aspeed_video *video)
643 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
647 aspeed_video_update(video, VE_SEQ_CTRL,
651 aspeed_video_update(video, VE_SEQ_CTRL, 0, VE_SEQ_CTRL_TRIG_MODE_DET);
654 static void aspeed_video_off(struct aspeed_video *video)
656 if (!test_bit(VIDEO_CLOCKS_ON, &video->flags))
660 aspeed_video_write(video, VE_INTERRUPT_CTRL, 0);
661 aspeed_video_write(video, VE_INTERRUPT_STATUS, 0xffffffff);
664 clk_disable(video->eclk);
665 clk_disable(video->vclk);
667 clear_bit(VIDEO_CLOCKS_ON, &video->flags);
670 static void aspeed_video_on(struct aspeed_video *video)
672 if (test_bit(VIDEO_CLOCKS_ON, &video->flags))
676 clk_enable(video->vclk);
677 clk_enable(video->eclk);
679 set_bit(VIDEO_CLOCKS_ON, &video->flags);
682 static void aspeed_video_bufs_done(struct aspeed_video *video,
688 spin_lock_irqsave(&video->lock, flags);
689 list_for_each_entry(buf, &video->buffers, link)
691 INIT_LIST_HEAD(&video->buffers);
692 spin_unlock_irqrestore(&video->lock, flags);
695 static void aspeed_video_irq_res_change(struct aspeed_video *video, ulong delay)
697 v4l2_dbg(1, debug, &video->v4l2_dev, "Resolution changed; resetting\n");
699 set_bit(VIDEO_RES_CHANGE, &video->flags);
700 clear_bit(VIDEO_FRAME_INPRG, &video->flags);
702 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
704 aspeed_video_off(video);
705 aspeed_video_bufs_done(video, VB2_BUF_STATE_ERROR);
707 schedule_delayed_work(&video->res_work, delay);
730 struct aspeed_video *video = arg;
731 u32 sts = aspeed_video_read(video, VE_INTERRUPT_STATUS);
737 sts &= aspeed_video_read(video, VE_INTERRUPT_CTRL);
739 v4l2_dbg(2, debug, &video->v4l2_dev, "irq sts=%#x %s%s%s%s\n", sts,
750 aspeed_video_irq_res_change(video, 0);
755 if (test_bit(VIDEO_RES_DETECT, &video->flags)) {
756 aspeed_video_update(video, VE_INTERRUPT_CTRL,
758 aspeed_video_write(video, VE_INTERRUPT_STATUS,
761 set_bit(VIDEO_MODE_DETECT_DONE, &video->flags);
762 wake_up_interruptible_all(&video->wait);
768 aspeed_video_irq_res_change(video,
777 u32 frame_size = aspeed_video_read(video,
778 video->comp_size_read);
780 update_perf(&video->perf);
782 spin_lock(&video->lock);
783 clear_bit(VIDEO_FRAME_INPRG, &video->flags);
784 buf = list_first_entry_or_null(&video->buffers,
795 if (video->format == VIDEO_FMT_STANDARD &&
796 list_is_last(&buf->link, &video->buffers)) {
798 v4l2_dbg(1, debug, &video->v4l2_dev, "skip to keep last frame updated\n");
801 buf->vb.sequence = video->sequence++;
806 empty = list_empty(&video->buffers);
809 spin_unlock(&video->lock);
811 aspeed_video_update(video, VE_SEQ_CTRL,
815 aspeed_video_update(video, VE_INTERRUPT_CTRL,
817 aspeed_video_write(video, VE_INTERRUPT_STATUS,
821 aspeed_video_swap_src_buf(video);
823 if (test_bit(VIDEO_STREAMING, &video->flags) && !empty)
824 aspeed_video_start_frame(video);
830 static void aspeed_video_check_and_set_polarity(struct aspeed_video *video)
838 sts = aspeed_video_read(video, VE_MODE_DETECT_STATUS);
850 ctrl = aspeed_video_read(video, VE_CTRL);
854 video->detected_timings.polarities &=
858 video->detected_timings.polarities |=
864 video->detected_timings.polarities &=
868 video->detected_timings.polarities |=
872 aspeed_video_write(video, VE_CTRL, ctrl);
875 static bool aspeed_video_alloc_buf(struct aspeed_video *video,
879 addr->virt = dma_alloc_coherent(video->dev, size, &addr->dma,
888 static void aspeed_video_free_buf(struct aspeed_video *video,
891 dma_free_coherent(video->dev, addr->size, addr->virt, addr->dma);
903 static void aspeed_video_calc_compressed_size(struct aspeed_video *video,
913 video->max_compressed_size = UINT_MAX;
922 if (size < video->max_compressed_size) {
924 video->max_compressed_size = size;
929 aspeed_video_write(video, VE_STREAM_BUF_SIZE,
932 v4l2_dbg(1, debug, &video->v4l2_dev, "Max compressed size: %#x\n",
933 video->max_compressed_size);
997 * of sync would be larger than video's active area if negative.
1031 static void aspeed_video_get_resolution(struct aspeed_video *video)
1039 struct v4l2_bt_timings *det = &video->detected_timings;
1043 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
1044 memset(&video->perf, 0, sizeof(video->perf));
1053 set_bit(VIDEO_RES_DETECT, &video->flags);
1054 aspeed_video_update(video, VE_CTRL,
1056 aspeed_video_enable_mode_detect(video);
1058 rc = wait_event_interruptible_timeout(video->wait,
1059 res_check(video),
1062 v4l2_dbg(1, debug, &video->v4l2_dev, "Timed out; first mode detect\n");
1063 clear_bit(VIDEO_RES_DETECT, &video->flags);
1067 mds = aspeed_video_read(video, VE_MODE_DETECT_STATUS);
1074 aspeed_video_check_and_set_polarity(video);
1076 aspeed_video_enable_mode_detect(video);
1078 rc = wait_event_interruptible_timeout(video->wait,
1079 res_check(video),
1081 clear_bit(VIDEO_RES_DETECT, &video->flags);
1083 v4l2_dbg(1, debug, &video->v4l2_dev, "Timed out; second mode detect\n");
1087 src_lr_edge = aspeed_video_read(video, VE_SRC_LR_EDGE_DET);
1088 src_tb_edge = aspeed_video_read(video, VE_SRC_TB_EDGE_DET);
1090 video->frame_bottom = FIELD_GET(VE_SRC_TB_EDGE_DET_BOT, src_tb_edge);
1091 video->frame_top = FIELD_GET(VE_SRC_TB_EDGE_DET_TOP, src_tb_edge);
1093 if (video->frame_top > video->frame_bottom)
1096 video->frame_right = FIELD_GET(VE_SRC_LR_EDGE_DET_RT, src_lr_edge);
1097 video->frame_left = FIELD_GET(VE_SRC_LR_EDGE_DET_LEFT, src_lr_edge);
1099 if (video->frame_left > video->frame_right)
1106 v4l2_dbg(1, debug, &video->v4l2_dev, "Invalid resolution detected\n");
1110 det->height = (video->frame_bottom - video->frame_top) + 1;
1111 det->width = (video->frame_right - video->frame_left) + 1;
1112 video->v4l2_input_status = 0;
1114 aspeed_video_get_timings(video, det);
1120 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
1122 aspeed_video_update(video, VE_SEQ_CTRL, 0,
1125 v4l2_dbg(1, debug, &video->v4l2_dev, "Got resolution: %dx%d\n",
1129 static void aspeed_video_set_resolution(struct aspeed_video *video)
1131 struct v4l2_bt_timings *act = &video->active_timings;
1135 aspeed_video_calc_compressed_size(video, size);
1144 * and to get better access speed from video engine.
1148 aspeed_video_write(video, VE_CAP_WINDOW, width << 16 | act->height);
1151 aspeed_video_write(video, VE_CAP_WINDOW,
1154 aspeed_video_write(video, VE_COMP_WINDOW,
1156 aspeed_video_write(video, VE_SRC_SCANLINE_OFFSET, act->width * 4);
1160 v4l2_dbg(1, debug, &video->v4l2_dev, "Capture: Sync Mode\n");
1161 aspeed_video_write(video, VE_TGS_0,
1163 video->frame_left - 1) |
1165 video->frame_right));
1166 aspeed_video_write(video, VE_TGS_1,
1167 FIELD_PREP(VE_TGS_FIRST, video->frame_top) |
1169 video->frame_bottom + 1));
1170 aspeed_video_update(video, VE_CTRL,
1174 v4l2_dbg(1, debug, &video->v4l2_dev, "Capture: Direct Mode\n");
1175 aspeed_video_update(video, VE_CTRL,
1182 if (size != video->srcs[0].size) {
1183 if (video->srcs[0].size)
1184 aspeed_video_free_buf(video, &video->srcs[0]);
1185 if (video->srcs[1].size)
1186 aspeed_video_free_buf(video, &video->srcs[1]);
1188 if (!aspeed_video_alloc_buf(video, &video->srcs[0], size))
1190 if (!aspeed_video_alloc_buf(video, &video->srcs[1], size))
1193 v4l2_dbg(1, debug, &video->v4l2_dev, "src buf0 addr(%pad) size(%d)\n",
1194 &video->srcs[0].dma, video->srcs[0].size);
1195 v4l2_dbg(1, debug, &video->v4l2_dev, "src buf1 addr(%pad) size(%d)\n",
1196 &video->srcs[1].dma, video->srcs[1].size);
1197 aspeed_video_write(video, VE_SRC0_ADDR, video->srcs[0].dma);
1198 aspeed_video_write(video, VE_SRC1_ADDR, video->srcs[1].dma);
1204 dev_err(video->dev, "Failed to allocate source buffers\n");
1206 if (video->srcs[0].size)
1207 aspeed_video_free_buf(video, &video->srcs[0]);
1210 static void aspeed_video_update_regs(struct aspeed_video *video)
1212 u8 jpeg_hq_quality = clamp((int)video->jpeg_hq_quality - 1, 0,
1214 u32 comp_ctrl = FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality) |
1215 FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10) |
1216 FIELD_PREP(VE_COMP_CTRL_EN_HQ, video->hq_mode) |
1222 v4l2_dbg(1, debug, &video->v4l2_dev, "framerate(%d)\n",
1223 video->frame_rate);
1224 v4l2_dbg(1, debug, &video->v4l2_dev, "jpeg format(%s) subsample(%s)\n",
1225 format_str[video->format],
1226 video->yuv420 ? "420" : "444");
1227 v4l2_dbg(1, debug, &video->v4l2_dev, "compression quality(%d)\n",
1228 video->jpeg_quality);
1229 v4l2_dbg(1, debug, &video->v4l2_dev, "hq_mode(%s) hq_quality(%d)\n",
1230 video->hq_mode ? "on" : "off", video->jpeg_hq_quality);
1232 if (video->format == VIDEO_FMT_ASPEED)
1233 aspeed_video_update(video, VE_BCD_CTRL, 0, VE_BCD_CTRL_EN_BCD);
1235 aspeed_video_update(video, VE_BCD_CTRL, VE_BCD_CTRL_EN_BCD, 0);
1237 if (video->frame_rate)
1238 ctrl |= FIELD_PREP(VE_CTRL_FRC, video->frame_rate);
1240 if (video->format == VIDEO_FMT_STANDARD) {
1241 comp_ctrl &= ~FIELD_PREP(VE_COMP_CTRL_EN_HQ, video->hq_mode);
1242 seq_ctrl |= video->jpeg_mode;
1245 if (video->yuv420)
1248 if (video->jpeg.virt)
1249 aspeed_video_update_jpeg_table(video->jpeg.virt, video->yuv420);
1252 aspeed_video_update(video, VE_SEQ_CTRL,
1253 video->jpeg_mode | VE_SEQ_CTRL_YUV420,
1255 aspeed_video_update(video, VE_CTRL, VE_CTRL_FRC, ctrl);
1256 aspeed_video_update(video, VE_COMP_CTRL,
1264 static void aspeed_video_init_regs(struct aspeed_video *video)
1270 aspeed_video_write(video, VE_PROTECTION_KEY, VE_PROTECTION_KEY_UNLOCK);
1273 aspeed_video_write(video, VE_INTERRUPT_CTRL, 0);
1274 aspeed_video_write(video, VE_INTERRUPT_STATUS, 0xffffffff);
1277 aspeed_video_write(video, VE_COMP_PROC_OFFSET, 0);
1278 aspeed_video_write(video, VE_COMP_OFFSET, 0);
1280 aspeed_video_write(video, VE_JPEG_ADDR, video->jpeg.dma);
1283 aspeed_video_write(video, VE_CTRL, ctrl);
1284 aspeed_video_write(video, VE_COMP_CTRL, VE_COMP_CTRL_RSVD);
1287 aspeed_video_write(video, VE_SCALING_FACTOR, 0x10001000);
1288 aspeed_video_write(video, VE_SCALING_FILTER0, 0x00200000);
1289 aspeed_video_write(video, VE_SCALING_FILTER1, 0x00200000);
1290 aspeed_video_write(video, VE_SCALING_FILTER2, 0x00200000);
1291 aspeed_video_write(video, VE_SCALING_FILTER3, 0x00200000);
1294 aspeed_video_write(video, VE_MODE_DETECT,
1301 aspeed_video_write(video, VE_BCD_CTRL, 0);
1304 static void aspeed_video_start(struct aspeed_video *video)
1306 aspeed_video_on(video);
1308 aspeed_video_init_regs(video);
1311 aspeed_video_get_resolution(video);
1314 video->active_timings = video->detected_timings;
1315 aspeed_video_set_resolution(video);
1317 video->pix_fmt.width = video->active_timings.width;
1318 video->pix_fmt.height = video->active_timings.height;
1319 video->pix_fmt.sizeimage = video->max_compressed_size;
1322 static void aspeed_video_stop(struct aspeed_video *video)
1324 set_bit(VIDEO_STOPPED, &video->flags);
1325 cancel_delayed_work_sync(&video->res_work);
1327 aspeed_video_off(video);
1329 if (video->srcs[0].size)
1330 aspeed_video_free_buf(video, &video->srcs[0]);
1332 if (video->srcs[1].size)
1333 aspeed_video_free_buf(video, &video->srcs[1]);
1335 if (video->bcd.size)
1336 aspeed_video_free_buf(video, &video->bcd);
1338 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
1339 video->flags = 0;
1356 struct aspeed_video *video = video_drvdata(file);
1361 f->pixelformat = video->pix_fmt.pixelformat;
1369 struct aspeed_video *video = video_drvdata(file);
1371 f->fmt.pix = video->pix_fmt;
1379 struct aspeed_video *video = video_drvdata(file);
1381 if (vb2_is_busy(&video->queue))
1386 video->format = VIDEO_FMT_STANDARD;
1389 video->format = VIDEO_FMT_ASPEED;
1394 video->pix_fmt.pixelformat = f->fmt.pix.pixelformat;
1402 struct aspeed_video *video = video_drvdata(file);
1410 inp->status = video->v4l2_input_status;
1433 struct aspeed_video *video = video_drvdata(file);
1438 if (!video->frame_rate)
1441 a->parm.capture.timeperframe.denominator = video->frame_rate;
1450 struct aspeed_video *video = video_drvdata(file);
1465 if (video->frame_rate != frame_rate) {
1466 video->frame_rate = frame_rate;
1467 aspeed_video_update(video, VE_CTRL, VE_CTRL_FRC,
1477 struct aspeed_video *video = video_drvdata(file);
1485 fsize->discrete.width = video->pix_fmt.width;
1486 fsize->discrete.height = video->pix_fmt.height;
1495 struct aspeed_video *video = video_drvdata(file);
1500 if (fival->width != video->detected_timings.width ||
1501 fival->height != video->detected_timings.height)
1521 struct aspeed_video *video = video_drvdata(file);
1523 if (timings->bt.width == video->active_timings.width &&
1524 timings->bt.height == video->active_timings.height)
1527 if (vb2_is_busy(&video->queue))
1530 video->active_timings = timings->bt;
1532 aspeed_video_set_resolution(video);
1534 video->pix_fmt.width = timings->bt.width;
1535 video->pix_fmt.height = timings->bt.height;
1536 video->pix_fmt.sizeimage = video->max_compressed_size;
1540 v4l2_dbg(1, debug, &video->v4l2_dev, "set new timings(%dx%d)\n",
1549 struct aspeed_video *video = video_drvdata(file);
1552 timings->bt = video->active_timings;
1561 struct aspeed_video *video = video_drvdata(file);
1569 if (test_bit(VIDEO_RES_CHANGE, &video->flags))
1572 rc = wait_event_interruptible(video->wait,
1574 &video->flags));
1580 timings->bt = video->detected_timings;
1582 return video->v4l2_input_status ? -ENOLINK : 0;
1650 struct aspeed_video *video = container_of(ctrl->handler,
1656 video->jpeg_quality = ctrl->val;
1657 if (test_bit(VIDEO_STREAMING, &video->flags))
1658 aspeed_video_update_regs(video);
1661 video->yuv420 = (ctrl->val == V4L2_JPEG_CHROMA_SUBSAMPLING_420);
1662 if (test_bit(VIDEO_STREAMING, &video->flags))
1663 aspeed_video_update_regs(video);
1666 video->hq_mode = ctrl->val;
1667 if (test_bit(VIDEO_STREAMING, &video->flags))
1668 aspeed_video_update_regs(video);
1671 video->jpeg_hq_quality = ctrl->val;
1672 if (test_bit(VIDEO_STREAMING, &video->flags))
1673 aspeed_video_update_regs(video);
1711 struct aspeed_video *video = container_of(dwork, struct aspeed_video,
1714 aspeed_video_on(video);
1717 if (test_bit(VIDEO_STOPPED, &video->flags))
1720 aspeed_video_init_regs(video);
1722 aspeed_video_update_regs(video);
1724 aspeed_video_get_resolution(video);
1726 if (video->detected_timings.width != video->active_timings.width ||
1727 video->detected_timings.height != video->active_timings.height) {
1733 v4l2_dbg(1, debug, &video->v4l2_dev, "fire source change event\n");
1734 v4l2_event_queue(&video->vdev, &ev);
1735 } else if (test_bit(VIDEO_STREAMING, &video->flags)) {
1737 aspeed_video_start_frame(video);
1741 clear_bit(VIDEO_RES_CHANGE, &video->flags);
1742 wake_up_interruptible_all(&video->wait);
1748 struct aspeed_video *video = video_drvdata(file);
1750 mutex_lock(&video->video_lock);
1754 mutex_unlock(&video->video_lock);
1759 aspeed_video_start(video);
1761 mutex_unlock(&video->video_lock);
1769 struct aspeed_video *video = video_drvdata(file);
1771 mutex_lock(&video->video_lock);
1774 aspeed_video_stop(video);
1778 mutex_unlock(&video->video_lock);
1799 struct aspeed_video *video = vb2_get_drv_priv(q);
1802 if (sizes[0] < video->max_compressed_size)
1809 sizes[0] = video->max_compressed_size;
1816 struct aspeed_video *video = vb2_get_drv_priv(vb->vb2_queue);
1818 if (vb2_plane_size(vb, 0) < video->max_compressed_size)
1828 struct aspeed_video *video = vb2_get_drv_priv(q);
1830 video->sequence = 0;
1831 video->perf.duration_max = 0;
1832 video->perf.duration_min = 0xffffffff;
1834 aspeed_video_update_regs(video);
1836 rc = aspeed_video_start_frame(video);
1838 aspeed_video_bufs_done(video, VB2_BUF_STATE_QUEUED);
1842 set_bit(VIDEO_STREAMING, &video->flags);
1849 struct aspeed_video *video = vb2_get_drv_priv(q);
1851 clear_bit(VIDEO_STREAMING, &video->flags);
1853 rc = wait_event_timeout(video->wait,
1854 !test_bit(VIDEO_FRAME_INPRG, &video->flags),
1857 v4l2_dbg(1, debug, &video->v4l2_dev, "Timed out when stopping streaming\n");
1863 aspeed_video_off(video);
1864 aspeed_video_on(video);
1866 aspeed_video_init_regs(video);
1868 aspeed_video_get_resolution(video);
1871 aspeed_video_bufs_done(video, VB2_BUF_STATE_ERROR);
1877 struct aspeed_video *video = vb2_get_drv_priv(vb->vb2_queue);
1882 spin_lock_irqsave(&video->lock, flags);
1883 empty = list_empty(&video->buffers);
1884 list_add_tail(&avb->link, &video->buffers);
1885 spin_unlock_irqrestore(&video->lock, flags);
1887 if (test_bit(VIDEO_STREAMING, &video->flags) &&
1888 !test_bit(VIDEO_FRAME_INPRG, &video->flags) && empty)
1889 aspeed_video_start_frame(video);
1967 static void aspeed_video_debugfs_remove(struct aspeed_video *video)
1973 static void aspeed_video_debugfs_create(struct aspeed_video *video)
1976 video,
1980 static void aspeed_video_debugfs_remove(struct aspeed_video *video) { }
1981 static void aspeed_video_debugfs_create(struct aspeed_video *video) { }
1984 static int aspeed_video_setup_video(struct aspeed_video *video)
1988 struct v4l2_device *v4l2_dev = &video->v4l2_dev;
1989 struct vb2_queue *vbq = &video->queue;
1990 struct video_device *vdev = &video->vdev;
1991 struct v4l2_ctrl_handler *hdl = &video->ctrl_handler;
1994 video->pix_fmt.pixelformat = V4L2_PIX_FMT_JPEG;
1995 video->pix_fmt.field = V4L2_FIELD_NONE;
1996 video->pix_fmt.colorspace = V4L2_COLORSPACE_SRGB;
1997 video->pix_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
1998 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
2000 rc = v4l2_device_register(video->dev, v4l2_dev);
2002 dev_err(video->dev, "Failed to register v4l2 device\n");
2019 v4l2_ctrl_handler_free(&video->ctrl_handler);
2022 dev_err(video->dev, "Failed to init controls: %d\n", rc);
2031 vbq->lock = &video->video_lock;
2034 vbq->drv_priv = video;
2041 v4l2_ctrl_handler_free(&video->ctrl_handler);
2044 dev_err(video->dev, "Failed to init vb2 queue\n");
2058 vdev->lock = &video->video_lock;
2060 video_set_drvdata(vdev, video);
2063 v4l2_ctrl_handler_free(&video->ctrl_handler);
2066 dev_err(video->dev, "Failed to register video device\n");
2073 static int aspeed_video_init(struct aspeed_video *video)
2077 struct device *dev = video->dev;
2086 IRQF_ONESHOT, DEVICE_NAME, video);
2091 dev_info(video->dev, "irq %d\n", irq);
2093 video->eclk = devm_clk_get(dev, "eclk");
2094 if (IS_ERR(video->eclk)) {
2096 return PTR_ERR(video->eclk);
2099 rc = clk_prepare(video->eclk);
2103 video->vclk = devm_clk_get(dev, "vclk");
2104 if (IS_ERR(video->vclk)) {
2106 rc = PTR_ERR(video->vclk);
2110 rc = clk_prepare(video->vclk);
2122 if (!aspeed_video_alloc_buf(video, &video->jpeg,
2128 dev_info(video->dev, "alloc mem size(%d) at %pad for jpeg header\n",
2129 VE_JPEG_HEADER_SIZE, &video->jpeg.dma);
2131 aspeed_video_init_jpeg_table(video->jpeg.virt, video->yuv420);
2137 clk_unprepare(video->vclk);
2139 clk_unprepare(video->eclk);
2145 { .compatible = "aspeed,ast2400-video-engine", .data = &ast2400_config },
2146 { .compatible = "aspeed,ast2500-video-engine", .data = &ast2500_config },
2147 { .compatible = "aspeed,ast2600-video-engine", .data = &ast2600_config },
2155 struct aspeed_video *video;
2158 video = devm_kzalloc(&pdev->dev, sizeof(*video), GFP_KERNEL);
2159 if (!video)
2162 video->base = devm_platform_ioremap_resource(pdev, 0);
2163 if (IS_ERR(video->base))
2164 return PTR_ERR(video->base);
2170 video->jpeg_mode = config->jpeg_mode;
2171 video->comp_size_read = config->comp_size_read;
2173 video->frame_rate = 30;
2174 video->jpeg_hq_quality = 1;
2175 video->dev = &pdev->dev;
2176 spin_lock_init(&video->lock);
2177 mutex_init(&video->video_lock);
2178 init_waitqueue_head(&video->wait);
2179 INIT_DELAYED_WORK(&video->res_work, aspeed_video_resolution_work);
2180 INIT_LIST_HEAD(&video->buffers);
2182 rc = aspeed_video_init(video);
2186 rc = aspeed_video_setup_video(video);
2188 aspeed_video_free_buf(video, &video->jpeg);
2189 clk_unprepare(video->vclk);
2190 clk_unprepare(video->eclk);
2194 aspeed_video_debugfs_create(video);
2203 struct aspeed_video *video = to_aspeed_video(v4l2_dev);
2205 aspeed_video_off(video);
2207 aspeed_video_debugfs_remove(video);
2209 clk_unprepare(video->vclk);
2210 clk_unprepare(video->eclk);
2212 vb2_video_unregister_device(&video->vdev);
2214 v4l2_ctrl_handler_free(&video->ctrl_handler);
2218 aspeed_video_free_buf(video, &video->jpeg);