Lines Matching refs:video
34 #define DEVICE_NAME "aspeed-video"
427 static void aspeed_video_update(struct aspeed_video *video, u32 reg, u32 clear,
430 u32 t = readl(video->base + reg);
435 writel(t, video->base + reg);
436 dev_dbg(video->dev, "update %03x[%08x -> %08x]\n", reg, before,
437 readl(video->base + reg));
440 static u32 aspeed_video_read(struct aspeed_video *video, u32 reg)
442 u32 t = readl(video->base + reg);
444 dev_dbg(video->dev, "read %03x[%08x]\n", reg, t);
448 static void aspeed_video_write(struct aspeed_video *video, u32 reg, u32 val)
450 writel(val, video->base + reg);
451 dev_dbg(video->dev, "write %03x[%08x]\n", reg,
452 readl(video->base + reg));
455 static int aspeed_video_start_frame(struct aspeed_video *video)
460 u32 seq_ctrl = aspeed_video_read(video, VE_SEQ_CTRL);
462 if (video->v4l2_input_status) {
463 dev_dbg(video->dev, "No signal; don't start frame\n");
469 dev_dbg(video->dev, "Engine busy; don't start frame\n");
473 spin_lock_irqsave(&video->lock, flags);
474 buf = list_first_entry_or_null(&video->buffers,
477 spin_unlock_irqrestore(&video->lock, flags);
478 dev_dbg(video->dev, "No buffers; don't start frame\n");
482 set_bit(VIDEO_FRAME_INPRG, &video->flags);
484 spin_unlock_irqrestore(&video->lock, flags);
486 aspeed_video_write(video, VE_COMP_PROC_OFFSET, 0);
487 aspeed_video_write(video, VE_COMP_OFFSET, 0);
488 aspeed_video_write(video, VE_COMP_ADDR, addr);
490 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
493 aspeed_video_update(video, VE_SEQ_CTRL, 0,
499 static void aspeed_video_enable_mode_detect(struct aspeed_video *video)
502 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
506 aspeed_video_update(video, VE_SEQ_CTRL,
510 aspeed_video_update(video, VE_SEQ_CTRL, 0, VE_SEQ_CTRL_TRIG_MODE_DET);
513 static void aspeed_video_off(struct aspeed_video *video)
515 if (!test_bit(VIDEO_CLOCKS_ON, &video->flags))
519 aspeed_video_write(video, VE_INTERRUPT_CTRL, 0);
520 aspeed_video_write(video, VE_INTERRUPT_STATUS, 0xffffffff);
523 clk_disable(video->eclk);
524 clk_disable(video->vclk);
526 clear_bit(VIDEO_CLOCKS_ON, &video->flags);
529 static void aspeed_video_on(struct aspeed_video *video)
531 if (test_bit(VIDEO_CLOCKS_ON, &video->flags))
535 clk_enable(video->vclk);
536 clk_enable(video->eclk);
538 set_bit(VIDEO_CLOCKS_ON, &video->flags);
541 static void aspeed_video_bufs_done(struct aspeed_video *video,
547 spin_lock_irqsave(&video->lock, flags);
548 list_for_each_entry(buf, &video->buffers, link)
550 INIT_LIST_HEAD(&video->buffers);
551 spin_unlock_irqrestore(&video->lock, flags);
554 static void aspeed_video_irq_res_change(struct aspeed_video *video, ulong delay)
556 dev_dbg(video->dev, "Resolution changed; resetting\n");
558 set_bit(VIDEO_RES_CHANGE, &video->flags);
559 clear_bit(VIDEO_FRAME_INPRG, &video->flags);
561 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
563 aspeed_video_off(video);
564 aspeed_video_bufs_done(video, VB2_BUF_STATE_ERROR);
566 schedule_delayed_work(&video->res_work, delay);
571 struct aspeed_video *video = arg;
572 u32 sts = aspeed_video_read(video, VE_INTERRUPT_STATUS);
579 aspeed_video_irq_res_change(video, 0);
584 if (test_bit(VIDEO_RES_DETECT, &video->flags)) {
585 aspeed_video_update(video, VE_INTERRUPT_CTRL,
587 aspeed_video_write(video, VE_INTERRUPT_STATUS,
590 set_bit(VIDEO_MODE_DETECT_DONE, &video->flags);
591 wake_up_interruptible_all(&video->wait);
597 aspeed_video_irq_res_change(video,
605 u32 frame_size = aspeed_video_read(video,
606 video->comp_size_read);
608 spin_lock(&video->lock);
609 clear_bit(VIDEO_FRAME_INPRG, &video->flags);
610 buf = list_first_entry_or_null(&video->buffers,
616 if (!list_is_last(&buf->link, &video->buffers)) {
618 buf->vb.sequence = video->sequence++;
625 spin_unlock(&video->lock);
627 aspeed_video_update(video, VE_SEQ_CTRL,
631 aspeed_video_update(video, VE_INTERRUPT_CTRL,
633 aspeed_video_write(video, VE_INTERRUPT_STATUS,
636 if (test_bit(VIDEO_STREAMING, &video->flags) && buf)
637 aspeed_video_start_frame(video);
653 static void aspeed_video_check_and_set_polarity(struct aspeed_video *video)
661 sts = aspeed_video_read(video, VE_MODE_DETECT_STATUS);
673 ctrl = aspeed_video_read(video, VE_CTRL);
677 video->detected_timings.polarities &=
681 video->detected_timings.polarities |=
687 video->detected_timings.polarities &=
691 video->detected_timings.polarities |=
695 aspeed_video_write(video, VE_CTRL, ctrl);
698 static bool aspeed_video_alloc_buf(struct aspeed_video *video,
702 addr->virt = dma_alloc_coherent(video->dev, size, &addr->dma,
711 static void aspeed_video_free_buf(struct aspeed_video *video,
714 dma_free_coherent(video->dev, addr->size, addr->virt, addr->dma);
726 static void aspeed_video_calc_compressed_size(struct aspeed_video *video,
736 video->max_compressed_size = UINT_MAX;
745 if (size < video->max_compressed_size) {
747 video->max_compressed_size = size;
752 aspeed_video_write(video, VE_STREAM_BUF_SIZE,
755 dev_dbg(video->dev, "Max compressed size: %x\n",
756 video->max_compressed_size);
761 static void aspeed_video_get_resolution(struct aspeed_video *video)
771 struct v4l2_bt_timings *det = &video->detected_timings;
775 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
784 set_bit(VIDEO_RES_DETECT, &video->flags);
785 aspeed_video_update(video, VE_CTRL,
787 aspeed_video_enable_mode_detect(video);
789 rc = wait_event_interruptible_timeout(video->wait,
790 res_check(video),
793 dev_dbg(video->dev, "Timed out; first mode detect\n");
794 clear_bit(VIDEO_RES_DETECT, &video->flags);
798 aspeed_video_check_and_set_polarity(video);
800 aspeed_video_enable_mode_detect(video);
802 rc = wait_event_interruptible_timeout(video->wait,
803 res_check(video),
805 clear_bit(VIDEO_RES_DETECT, &video->flags);
807 dev_dbg(video->dev, "Timed out; second mode detect\n");
811 src_lr_edge = aspeed_video_read(video, VE_SRC_LR_EDGE_DET);
812 src_tb_edge = aspeed_video_read(video, VE_SRC_TB_EDGE_DET);
813 mds = aspeed_video_read(video, VE_MODE_DETECT_STATUS);
814 sync = aspeed_video_read(video, VE_SYNC_STATUS);
815 htotal = aspeed_video_read(video, VE_H_TOTAL_PIXELS);
817 video->frame_bottom = (src_tb_edge & VE_SRC_TB_EDGE_DET_BOT) >>
819 video->frame_top = src_tb_edge & VE_SRC_TB_EDGE_DET_TOP;
820 det->vfrontporch = video->frame_top;
822 VE_MODE_DETECT_V_LINES_SHF) - video->frame_bottom;
825 if (video->frame_top > video->frame_bottom)
828 video->frame_right = (src_lr_edge & VE_SRC_LR_EDGE_DET_RT) >>
830 video->frame_left = src_lr_edge & VE_SRC_LR_EDGE_DET_LEFT;
831 det->hfrontporch = video->frame_left;
832 det->hbackporch = htotal - video->frame_right;
834 if (video->frame_left > video->frame_right)
841 dev_dbg(video->dev, "Invalid resolution detected\n");
845 det->height = (video->frame_bottom - video->frame_top) + 1;
846 det->width = (video->frame_right - video->frame_left) + 1;
847 video->v4l2_input_status = 0;
853 aspeed_video_update(video, VE_INTERRUPT_CTRL, 0,
855 aspeed_video_update(video, VE_SEQ_CTRL, 0,
858 dev_dbg(video->dev, "Got resolution: %dx%d\n", det->width,
862 static void aspeed_video_set_resolution(struct aspeed_video *video)
864 struct v4l2_bt_timings *act = &video->active_timings;
868 aspeed_video_calc_compressed_size(video, size);
870 if (video->active_timings.width == 1680) {
877 * and to get better access speed from video engine.
879 aspeed_video_write(video, VE_CAP_WINDOW,
881 size += (1728 - 1680) * video->active_timings.height;
883 aspeed_video_write(video, VE_CAP_WINDOW,
886 aspeed_video_write(video, VE_COMP_WINDOW,
888 aspeed_video_write(video, VE_SRC_SCANLINE_OFFSET, act->width * 4);
892 aspeed_video_write(video, VE_TGS_0,
894 video->frame_left - 1) |
896 video->frame_right));
897 aspeed_video_write(video, VE_TGS_1,
898 FIELD_PREP(VE_TGS_FIRST, video->frame_top) |
900 video->frame_bottom + 1));
901 aspeed_video_update(video, VE_CTRL, 0, VE_CTRL_INT_DE);
903 aspeed_video_update(video, VE_CTRL, 0, VE_CTRL_DIRECT_FETCH);
908 if (size != video->srcs[0].size) {
909 if (video->srcs[0].size)
910 aspeed_video_free_buf(video, &video->srcs[0]);
911 if (video->srcs[1].size)
912 aspeed_video_free_buf(video, &video->srcs[1]);
914 if (!aspeed_video_alloc_buf(video, &video->srcs[0], size))
916 if (!aspeed_video_alloc_buf(video, &video->srcs[1], size))
919 aspeed_video_write(video, VE_SRC0_ADDR, video->srcs[0].dma);
920 aspeed_video_write(video, VE_SRC1_ADDR, video->srcs[1].dma);
926 dev_err(video->dev, "Failed to allocate source buffers\n");
928 if (video->srcs[0].size)
929 aspeed_video_free_buf(video, &video->srcs[0]);
932 static void aspeed_video_init_regs(struct aspeed_video *video)
935 FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality) |
936 FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10);
938 u32 seq_ctrl = video->jpeg_mode;
940 if (video->frame_rate)
941 ctrl |= FIELD_PREP(VE_CTRL_FRC, video->frame_rate);
943 if (video->yuv420)
947 aspeed_video_write(video, VE_PROTECTION_KEY, VE_PROTECTION_KEY_UNLOCK);
950 aspeed_video_write(video, VE_INTERRUPT_CTRL, 0);
951 aspeed_video_write(video, VE_INTERRUPT_STATUS, 0xffffffff);
954 aspeed_video_write(video, VE_COMP_PROC_OFFSET, 0);
955 aspeed_video_write(video, VE_COMP_OFFSET, 0);
957 aspeed_video_write(video, VE_JPEG_ADDR, video->jpeg.dma);
960 aspeed_video_write(video, VE_SEQ_CTRL, seq_ctrl);
961 aspeed_video_write(video, VE_CTRL, ctrl);
962 aspeed_video_write(video, VE_COMP_CTRL, comp_ctrl);
965 aspeed_video_write(video, VE_SCALING_FACTOR, 0x10001000);
966 aspeed_video_write(video, VE_SCALING_FILTER0, 0x00200000);
967 aspeed_video_write(video, VE_SCALING_FILTER1, 0x00200000);
968 aspeed_video_write(video, VE_SCALING_FILTER2, 0x00200000);
969 aspeed_video_write(video, VE_SCALING_FILTER3, 0x00200000);
972 aspeed_video_write(video, VE_MODE_DETECT, 0x22666500);
975 static void aspeed_video_start(struct aspeed_video *video)
977 aspeed_video_on(video);
979 aspeed_video_init_regs(video);
982 aspeed_video_get_resolution(video);
985 video->active_timings = video->detected_timings;
986 aspeed_video_set_resolution(video);
988 video->pix_fmt.width = video->active_timings.width;
989 video->pix_fmt.height = video->active_timings.height;
990 video->pix_fmt.sizeimage = video->max_compressed_size;
993 static void aspeed_video_stop(struct aspeed_video *video)
995 set_bit(VIDEO_STOPPED, &video->flags);
996 cancel_delayed_work_sync(&video->res_work);
998 aspeed_video_off(video);
1000 if (video->srcs[0].size)
1001 aspeed_video_free_buf(video, &video->srcs[0]);
1003 if (video->srcs[1].size)
1004 aspeed_video_free_buf(video, &video->srcs[1]);
1006 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
1007 video->flags = 0;
1035 struct aspeed_video *video = video_drvdata(file);
1037 f->fmt.pix = video->pix_fmt;
1045 struct aspeed_video *video = video_drvdata(file);
1053 inp->status = video->v4l2_input_status;
1076 struct aspeed_video *video = video_drvdata(file);
1081 if (!video->frame_rate)
1084 a->parm.capture.timeperframe.denominator = video->frame_rate;
1093 struct aspeed_video *video = video_drvdata(file);
1108 if (video->frame_rate != frame_rate) {
1109 video->frame_rate = frame_rate;
1110 aspeed_video_update(video, VE_CTRL, VE_CTRL_FRC,
1120 struct aspeed_video *video = video_drvdata(file);
1128 fsize->discrete.width = video->pix_fmt.width;
1129 fsize->discrete.height = video->pix_fmt.height;
1138 struct aspeed_video *video = video_drvdata(file);
1143 if (fival->width != video->detected_timings.width ||
1144 fival->height != video->detected_timings.height)
1164 struct aspeed_video *video = video_drvdata(file);
1166 if (timings->bt.width == video->active_timings.width &&
1167 timings->bt.height == video->active_timings.height)
1170 if (vb2_is_busy(&video->queue))
1173 video->active_timings = timings->bt;
1175 aspeed_video_set_resolution(video);
1177 video->pix_fmt.width = timings->bt.width;
1178 video->pix_fmt.height = timings->bt.height;
1179 video->pix_fmt.sizeimage = video->max_compressed_size;
1189 struct aspeed_video *video = video_drvdata(file);
1192 timings->bt = video->active_timings;
1201 struct aspeed_video *video = video_drvdata(file);
1209 if (test_bit(VIDEO_RES_CHANGE, &video->flags))
1212 rc = wait_event_interruptible(video->wait,
1214 &video->flags));
1220 timings->bt = video->detected_timings;
1222 return video->v4l2_input_status ? -ENOLINK : 0;
1288 static void aspeed_video_update_jpeg_quality(struct aspeed_video *video)
1290 u32 comp_ctrl = FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality) |
1291 FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10);
1293 aspeed_video_update(video, VE_COMP_CTRL,
1298 static void aspeed_video_update_subsampling(struct aspeed_video *video)
1300 if (video->jpeg.virt)
1301 aspeed_video_init_jpeg_table(video->jpeg.virt, video->yuv420);
1303 if (video->yuv420)
1304 aspeed_video_update(video, VE_SEQ_CTRL, 0, VE_SEQ_CTRL_YUV420);
1306 aspeed_video_update(video, VE_SEQ_CTRL, VE_SEQ_CTRL_YUV420, 0);
1311 struct aspeed_video *video = container_of(ctrl->handler,
1317 video->jpeg_quality = ctrl->val;
1318 aspeed_video_update_jpeg_quality(video);
1322 video->yuv420 = true;
1323 aspeed_video_update_subsampling(video);
1325 video->yuv420 = false;
1326 aspeed_video_update_subsampling(video);
1343 struct aspeed_video *video = container_of(dwork, struct aspeed_video,
1346 aspeed_video_on(video);
1349 if (test_bit(VIDEO_STOPPED, &video->flags))
1352 aspeed_video_init_regs(video);
1354 aspeed_video_get_resolution(video);
1356 if (video->detected_timings.width != video->active_timings.width ||
1357 video->detected_timings.height != video->active_timings.height) {
1363 v4l2_event_queue(&video->vdev, &ev);
1364 } else if (test_bit(VIDEO_STREAMING, &video->flags)) {
1366 aspeed_video_start_frame(video);
1370 clear_bit(VIDEO_RES_CHANGE, &video->flags);
1371 wake_up_interruptible_all(&video->wait);
1377 struct aspeed_video *video = video_drvdata(file);
1379 mutex_lock(&video->video_lock);
1383 mutex_unlock(&video->video_lock);
1388 aspeed_video_start(video);
1390 mutex_unlock(&video->video_lock);
1398 struct aspeed_video *video = video_drvdata(file);
1400 mutex_lock(&video->video_lock);
1403 aspeed_video_stop(video);
1407 mutex_unlock(&video->video_lock);
1428 struct aspeed_video *video = vb2_get_drv_priv(q);
1431 if (sizes[0] < video->max_compressed_size)
1438 sizes[0] = video->max_compressed_size;
1445 struct aspeed_video *video = vb2_get_drv_priv(vb->vb2_queue);
1447 if (vb2_plane_size(vb, 0) < video->max_compressed_size)
1457 struct aspeed_video *video = vb2_get_drv_priv(q);
1459 video->sequence = 0;
1461 rc = aspeed_video_start_frame(video);
1463 aspeed_video_bufs_done(video, VB2_BUF_STATE_QUEUED);
1467 set_bit(VIDEO_STREAMING, &video->flags);
1474 struct aspeed_video *video = vb2_get_drv_priv(q);
1476 clear_bit(VIDEO_STREAMING, &video->flags);
1478 rc = wait_event_timeout(video->wait,
1479 !test_bit(VIDEO_FRAME_INPRG, &video->flags),
1482 dev_dbg(video->dev, "Timed out when stopping streaming\n");
1488 aspeed_video_off(video);
1489 aspeed_video_on(video);
1491 aspeed_video_init_regs(video);
1493 aspeed_video_get_resolution(video);
1496 aspeed_video_bufs_done(video, VB2_BUF_STATE_ERROR);
1502 struct aspeed_video *video = vb2_get_drv_priv(vb->vb2_queue);
1507 spin_lock_irqsave(&video->lock, flags);
1508 empty = list_empty(&video->buffers);
1509 list_add_tail(&avb->link, &video->buffers);
1510 spin_unlock_irqrestore(&video->lock, flags);
1512 if (test_bit(VIDEO_STREAMING, &video->flags) &&
1513 !test_bit(VIDEO_FRAME_INPRG, &video->flags) && empty)
1514 aspeed_video_start_frame(video);
1527 static int aspeed_video_setup_video(struct aspeed_video *video)
1531 struct v4l2_device *v4l2_dev = &video->v4l2_dev;
1532 struct vb2_queue *vbq = &video->queue;
1533 struct video_device *vdev = &video->vdev;
1536 video->pix_fmt.pixelformat = V4L2_PIX_FMT_JPEG;
1537 video->pix_fmt.field = V4L2_FIELD_NONE;
1538 video->pix_fmt.colorspace = V4L2_COLORSPACE_SRGB;
1539 video->pix_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
1540 video->v4l2_input_status = V4L2_IN_ST_NO_SIGNAL;
1542 rc = v4l2_device_register(video->dev, v4l2_dev);
1544 dev_err(video->dev, "Failed to register v4l2 device\n");
1548 v4l2_ctrl_handler_init(&video->ctrl_handler, 2);
1549 v4l2_ctrl_new_std(&video->ctrl_handler, &aspeed_video_ctrl_ops,
1552 v4l2_ctrl_new_std_menu(&video->ctrl_handler, &aspeed_video_ctrl_ops,
1557 rc = video->ctrl_handler.error;
1559 v4l2_ctrl_handler_free(&video->ctrl_handler);
1562 dev_err(video->dev, "Failed to init controls: %d\n", rc);
1566 v4l2_dev->ctrl_handler = &video->ctrl_handler;
1571 vbq->lock = &video->video_lock;
1574 vbq->drv_priv = video;
1581 v4l2_ctrl_handler_free(&video->ctrl_handler);
1584 dev_err(video->dev, "Failed to init vb2 queue\n");
1598 vdev->lock = &video->video_lock;
1600 video_set_drvdata(vdev, video);
1603 v4l2_ctrl_handler_free(&video->ctrl_handler);
1606 dev_err(video->dev, "Failed to register video device\n");
1613 static int aspeed_video_init(struct aspeed_video *video)
1617 struct device *dev = video->dev;
1626 IRQF_ONESHOT, DEVICE_NAME, video);
1632 video->eclk = devm_clk_get(dev, "eclk");
1633 if (IS_ERR(video->eclk)) {
1635 return PTR_ERR(video->eclk);
1638 rc = clk_prepare(video->eclk);
1642 video->vclk = devm_clk_get(dev, "vclk");
1643 if (IS_ERR(video->vclk)) {
1645 rc = PTR_ERR(video->vclk);
1649 rc = clk_prepare(video->vclk);
1661 if (!aspeed_video_alloc_buf(video, &video->jpeg,
1668 aspeed_video_init_jpeg_table(video->jpeg.virt, video->yuv420);
1674 clk_unprepare(video->vclk);
1676 clk_unprepare(video->eclk);
1682 { .compatible = "aspeed,ast2400-video-engine", .data = &ast2400_config },
1683 { .compatible = "aspeed,ast2500-video-engine", .data = &ast2500_config },
1684 { .compatible = "aspeed,ast2600-video-engine", .data = &ast2600_config },
1693 struct aspeed_video *video;
1696 video = devm_kzalloc(&pdev->dev, sizeof(*video), GFP_KERNEL);
1697 if (!video)
1700 video->base = devm_platform_ioremap_resource(pdev, 0);
1701 if (IS_ERR(video->base))
1702 return PTR_ERR(video->base);
1709 video->jpeg_mode = config->jpeg_mode;
1710 video->comp_size_read = config->comp_size_read;
1712 video->frame_rate = 30;
1713 video->dev = &pdev->dev;
1714 spin_lock_init(&video->lock);
1715 mutex_init(&video->video_lock);
1716 init_waitqueue_head(&video->wait);
1717 INIT_DELAYED_WORK(&video->res_work, aspeed_video_resolution_work);
1718 INIT_LIST_HEAD(&video->buffers);
1720 rc = aspeed_video_init(video);
1724 rc = aspeed_video_setup_video(video);
1726 aspeed_video_free_buf(video, &video->jpeg);
1727 clk_unprepare(video->vclk);
1728 clk_unprepare(video->eclk);
1739 struct aspeed_video *video = to_aspeed_video(v4l2_dev);
1741 aspeed_video_off(video);
1743 clk_unprepare(video->vclk);
1744 clk_unprepare(video->eclk);
1746 vb2_video_unregister_device(&video->vdev);
1748 v4l2_ctrl_handler_free(&video->ctrl_handler);
1752 aspeed_video_free_buf(video, &video->jpeg);