s5pv210 linux hdmi tv输出

最新推荐文章于 2025-01-22 16:38:48 发布
最新推荐文章于 2025-01-22 16:38:48 发布
阅读量4.2k 收藏 6
点赞数
分类专栏： s5pv210 linux应用 Linux与Android系统移植
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hclydao/article/details/42706939
版权

原来本来说是不公开源码的　现在发现也没什么价值了　以下公布的源码支持linux3.0 linux2.6内核　linux3.1内核v4l2构架发生了变化　同时支持hdmi输出与tv输出　使用的板子是　斯道icool210

源码是根据android里的libhdmi库进行整理的 这里是基于linux2.6.35内核测试成功

/*
 * hidmitest.c
 *
 * hclydao<hclydao@163.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>  
#include <fcntl.h>  
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>
#include <linux/videodev2.h>
#include <linux/fb.h>
#include "videodev2_samsung.h"

#define HDMI_DEV	"/dev/video14"
#define TVOUT_DEV0	"/dev/video22"
#define FIMC_DEV	"/dev/video2"

#define CLEAR(x) memset (&(x), 0, sizeof (x))
#define ALIGN(x, a)    (((x) + (a) - 1) & ~((a) - 1))
static int fd = -1;
v4l2_std_id std_id = 0;
static int m_width = 0;
static int m_height = 0;
#define LCD_DEV		"/dev/fb0"
#define S3CFB_GET_LCD_ADDR              _IOR ('F', 311, int)

unsigned int phyLCDAddr = 0;
unsigned int physYAddr = 0;
static int lcd_fd = -1;
static int ov_fd = -1;
static int fimc_fd = -1;
unsigned int mFimcRrvedPhysMemAddr;
unsigned int hwver;
static int out_w = 0;
static int out_h = 0;

struct overlay_param {
	struct v4l2_framebuffer 		overlay_frame;
	struct v4l2_window_s5p_tvout 	overlay_rect;
	struct v4l2_rect				overlay_dst;
};

typedef unsigned int dma_addr_t;
struct fimc_buf {
	dma_addr_t	base[3];
 	size_t		length[3];
};

int lcd_open()
{
	lcd_fd = open(LCD_DEV,O_RDWR, 0);
	if(lcd_fd < 0) {
		printf("++++++open tvout dev error\n");
		return -1;
	}
	return lcd_fd;
}

int lcd_getaddr()
{
	struct fb_var_screeninfo info;
	if (ioctl(lcd_fd, S3CFB_GET_LCD_ADDR, &phyLCDAddr) == -1) {
		printf("%s:ioctl(S3CFB_GET_LCD_ADDR) fail\n", __func__);
		return -1;
	}
	if(phyLCDAddr == 0) {
		printf("%s::S3CFB_GET_LCD_ADDR fail \n", __func__);
		return -1;
	}
           
    if (ioctl(lcd_fd, FBIOGET_VSCREENINFO, &info) == -1) {
    	printf("%s:ioctl(FBIOGET_VSCREENINFO) fail\n", __func__);
        return -1;
    } 
    m_width   =  info.xres;
    m_height  =  info.yres;
	return 0;
}

int hdmi_open()
{
	fd = open(HDMI_DEV, O_RDWR);
	if(fd < 0) {
		printf("++++++open tvout dev error\n");
		return fd;
	}
	return fd;
}

int tvout_v4l2_querycap(void)
{
    struct v4l2_capability cap;
    int ret;

    ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);

    if (ret < 0) {
	    printf("tvout_v4l2_querycap VIDIOC_QUERYCAP failed %d\n", errno);
	    return ret;
    }

    //printf("tvout_v4l2_querycap DRIVER : %s, CARD : %s, CAP.: 0x%08x\n",
		//    cap.driver, cap.card, cap.capabilities);
    return ret;
}

int tvout_v4l2_s_std(void)
{
    int ret;

    ret = ioctl(fd, VIDIOC_S_STD, &std_id);
    if (ret < 0) {
	    printf("tvout_v4l2_s_std" "VIDIOC_S_STD failed %d\n", errno);
	    return ret;
    }
    return ret;
}

int tvout_v4l2_enum_output(struct v4l2_output *output)
{
    int ret;

    ret = ioctl(fd, VIDIOC_ENUMOUTPUT, output);

    return ret;
}

int tvout_v4l2_s_output(int index)
{
    int ret;

    ret = ioctl(fd, VIDIOC_S_OUTPUT, &index);
    if (ret < 0) {
	    printf("tvout_v4l2_s_output" "VIDIOC_S_OUTPUT failed %d\n", errno);
	    return ret;
    }

    return ret;
}

int overlay_open()
{
	ov_fd = open(TVOUT_DEV0, O_RDWR);
	if(ov_fd < 0) {
		printf("++++++open tv out 0 dev error\n");
		return ov_fd;
	}
	return ov_fd;
}

int tvout_ov_s_parm(int fp, int buf_type, void *ptr)
{
    struct v4l2_streamparm parm;
    struct v4l2_window_s5p_tvout *vparm = (struct v4l2_window_s5p_tvout*)ptr;
    int ret;

    parm.type = (enum v4l2_buf_type)buf_type;
    memcpy(parm.parm.raw_data, vparm, sizeof(struct v4l2_window_s5p_tvout));

    ret = ioctl(fp, VIDIOC_S_PARM, &parm);
    if (ret < 0) {
	    printf("tvout_v4l2_s_parm" "VIDIOC_S_PARM failed %d\n", errno);
	    return ret;
    }

    return 0;
}

int tvout_v4l2_s_fbuf(int fp, struct v4l2_framebuffer *frame)
{
    int ret;

    ret = ioctl(fp, VIDIOC_S_FBUF, frame);
    if (ret < 0) {
	    printf("tvout_v4l2_s_fbuf" "VIDIOC_STREAMON failed %d\n", errno);
	    return ret;
    }
    return 0;
}

int tvout_v4l2_cropcap(int fp, struct v4l2_cropcap *a)
{
    struct v4l2_cropcap *cropcap = a;
    int ret;

    ret = ioctl(fp, VIDIOC_CROPCAP, cropcap);

    if (ret < 0) {
        printf("tvout_v4l2_cropcap" "VIDIOC_CROPCAP failed %d\n", errno);
        return ret;
    }

    printf("tvout_v4l2_cropcap" "bound width : %d, bound height : %d,\n",
		    cropcap->bounds.width, cropcap->bounds.height);
    return ret;
}

int tvout_ov_s_crop(int fp, unsigned int type, struct v4l2_rect *rect)
{
    struct v4l2_crop crop;
    int ret;

    crop.type 	= (enum v4l2_buf_type)type;

    crop.c.left 	= rect->left;
    crop.c.top 	    = rect->top;
    crop.c.width 	= rect->width;
    crop.c.height 	= rect->height;

    ret = ioctl(fp, VIDIOC_S_CROP, &crop);
    if (ret < 0) {
	    printf("tvout_v4l2_s_crop" "VIDIOC_S_CROP failed %d\n", errno);
	    return ret;
    }

    return 0;
}

int tvout_v4l2_set_overlay(int fp)
{
    struct overlay_param ov_param;
	struct v4l2_cropcap cropcap;

	int dst_w,dst_h;

	dst_w = out_w;
	dst_h = out_h;

    ov_param.overlay_frame.fmt.pixelformat = V4L2_PIX_FMT_RGB32;
    ov_param.overlay_frame.base            = (void *)mFimcRrvedPhysMemAddr;

    ov_param.overlay_rect.flags            = 0;
    ov_param.overlay_rect.priority         = 0x02;
    ov_param.overlay_rect.win.w.left       = 0;
    ov_param.overlay_rect.win.w.top        = 0;
    ov_param.overlay_rect.win.w.width      = dst_w;
    ov_param.overlay_rect.win.w.height     = dst_h;
    ov_param.overlay_rect.win.global_alpha = 0;

	ov_param.overlay_dst.left   = 0;
    ov_param.overlay_dst.top    = 0;

    ov_param.overlay_dst.width  = dst_w;
    ov_param.overlay_dst.height = dst_h;

	tvout_v4l2_s_fbuf(fp, &(ov_param.overlay_frame));
	tvout_ov_s_parm(fp,V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, &(ov_param.overlay_rect));

    cropcap.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY;
    tvout_v4l2_cropcap(fp, &cropcap);

    if(    ov_param.overlay_dst.width  <= cropcap.bounds.width
        && ov_param.overlay_dst.height <= cropcap.bounds.height)
    {
	    tvout_ov_s_crop(fp, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY,&(ov_param.overlay_dst));
    }
    else
    {
	    printf("[%s] invalid crop size dst.w=%d dst.h=%d bounds.w=%d bounds.h=%d\n", __func__,
                ov_param.overlay_dst.width,
                ov_param.overlay_dst.height,
                cropcap.bounds.width,
                cropcap.bounds.height);
	    return -1;
    }

	return 0;
}

int tvout_v4l2_streamon(int fp, unsigned int type)
{
    int ret;

    ret = ioctl(fp, VIDIOC_STREAMON, &type);
    if (ret < 0) {
	    printf("tvout_v4l2_streamon" "VIDIOC_STREAMON failed %d\n", errno);
	    return ret;
    }

    return 0;
}

int tvout_v4l2_start_overlay(int fp)
{
    int ret, start = 1;

    ret = ioctl(fp, VIDIOC_OVERLAY, &start);
    if (ret < 0) {
	    printf("tvout_v4l2_start_overlay" "VIDIOC_OVERLAY failed\n");
	    return ret;
    }

    return ret;
}

int fimc_open()
{
	fimc_fd = open(FIMC_DEV, O_RDWR);
	if(fimc_fd < 0) {
		printf("++++++open tvout dev error\n");
		return -1;
	}
	return fimc_fd;
}

int fimc_querycap(int fp)
{
    struct v4l2_capability cap;
    int ret;

    ret = ioctl(fp, VIDIOC_QUERYCAP, &cap);

    if (ret < 0) {
	    printf("%s VIDIOC_QUERYCAP failed %d\n",__func__, errno);
	    return ret;
    }

    if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
        printf("%s::%s has no streaming support\n", __func__, FIMC_DEV);
        return -1;
    }

    if (!(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
        printf("%s::%s is no video output\n", __func__, FIMC_DEV);
        return -1;
    }
    return ret;
}

int fimc_gfmt(int fp)
{
	struct v4l2_format fmt;
	int ret;
    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    ret = ioctl(fp, VIDIOC_G_FMT, &fmt);
    if (ret < 0) {
        printf("%s:: Error in video VIDIOC_G_FMT\n", __func__);
        return -1;
    }
	return ret;
}

int fimc_gctrl(int fp)
{
	struct v4l2_control vc;
	int ret;
    vc.id = V4L2_CID_RESERVED_MEM_BASE_ADDR;
    vc.value = 0;

    ret = ioctl(fp, VIDIOC_G_CTRL, &vc);
    if (ret < 0) {
        printf("Error in video VIDIOC_G_CTRL - V4L2_CID_RESERVED_MEM_BAES_ADDR (%d)\n", ret);
        return -1;
    }
	mFimcRrvedPhysMemAddr = (unsigned int)vc.value;

    vc.id = V4L2_CID_FIMC_VERSION;
    vc.value = 0;
    ret = ioctl(fp, VIDIOC_G_CTRL, &vc);
    if (ret < 0) {
        printf("Error in video VIDIOC_G_CTRL - V4L2_CID_FIMC_VERSION (%d), FIMC version is set with default\n", ret);
        vc.value = 0x43;
		return -1;
    }
	hwver = vc.value;
	return ret;
}

int fimc_sctrl(int fp)
{
	struct v4l2_control vc;
	int ret;
    vc.id = V4L2_CID_OVLY_MODE;
    vc.value = 0x3;
    ret = ioctl(fp, VIDIOC_S_CTRL, &vc);
    if (ret < 0) {
        printf("Error in video VIDIOC_S_CTRL - V4L2_CID_OVLY_MODE (%d)\n",ret);
        return -1;
    }
	return ret;
}

int fimc_v4l2_set_src(int fd, unsigned int hw_ver)
{
	struct v4l2_format		fmt;
	struct v4l2_crop		crop;
	int				ret_val;

	fmt.type                = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	fmt.fmt.pix.width       = m_width;
	fmt.fmt.pix.height      = m_height;
	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32;
	fmt.fmt.pix.field       = V4L2_FIELD_NONE;

	ret_val = ioctl (fd, VIDIOC_S_FMT, &fmt);
	if (ret_val < 0) {
		printf("VIDIOC_S_FMT failed : ret=%d\n", ret_val);
		return -1;
	}

	crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;

	if(hw_ver == 0x50) {
		crop.c.left = 0;
		crop.c.top = 0;
	} else {
		crop.c.left   = 0;
		crop.c.top    = 0;
	}

	crop.c.width  = m_width;
	crop.c.height = m_height;

	ret_val = ioctl(fd, VIDIOC_S_CROP, &crop);
	if (ret_val < 0) {
		printf("Error in video VIDIOC_S_CROP (%d)\n",ret_val);
		return -1;
	}

	return ret_val;
}

int fimc_v4l2_req_buf(int fd, int num_bufs, int cacheable_buffers)
{
    struct v4l2_requestbuffers reqbuf;
    int ret;
    reqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    reqbuf.memory = V4L2_MEMORY_USERPTR;
    reqbuf.count  = num_bufs;

    ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuf);
    if (ret < 0) {
        printf("+++++reqbuf ioctl error");
        return ret;
    }

    if (reqbuf.count > num_bufs) {
        printf("++Not enough buffer structs passed to get_buffers");
        return -ENOMEM;
    }
    return 0;
}

int fimc_v4l2_set_dst(int fd,int rotation, unsigned int addr)
{
	struct v4l2_format      sFormat;
	struct v4l2_control     vc;
	struct v4l2_framebuffer fbuf;
	int                     ret_val;

	/*
	 * set rotation configuration
	 */

	vc.id = V4L2_CID_ROTATION;
	vc.value = rotation;

	ret_val = ioctl(fd, VIDIOC_S_CTRL, &vc);
	if (ret_val < 0) {
		printf("Error in video VIDIOC_S_CTRL - rotation (%d)\n",ret_val);
		return -1;
	}

	/*
	 * set size, format & address for destination image (DMA-OUTPUT)
	 */
	ret_val = ioctl(fd, VIDIOC_G_FBUF, &fbuf);
	if (ret_val < 0) {
		printf("Error in video VIDIOC_G_FBUF (%d)\n", ret_val);
		return -1;
	}

	fbuf.base 			= (void *)addr;
	fbuf.fmt.width 			= out_w;
	fbuf.fmt.height 		= out_h;
	fbuf.fmt.pixelformat 		= V4L2_PIX_FMT_RGB32;

	ret_val = ioctl (fd, VIDIOC_S_FBUF, &fbuf);
	if (ret_val < 0) {
		printf("Error in video VIDIOC_S_FBUF (%d)\n",ret_val);
		return -1;
	}

	/*
	 * set destination window
	 */

	sFormat.type 			= V4L2_BUF_TYPE_VIDEO_OVERLAY;
	sFormat.fmt.win.w.left 		= 0;
	sFormat.fmt.win.w.top 		= 0;
	sFormat.fmt.win.w.width 	= out_w;
	sFormat.fmt.win.w.height 	= out_h;

	ret_val = ioctl(fd, VIDIOC_S_FMT, &sFormat);
	if (ret_val < 0) {
		printf("Error in video VIDIOC_S_FMT (%d)\n",ret_val);
		return -1;
	}

	return 0;
}

int fimc_v4l2_queue(int fd, struct fimc_buf *fimc_buf, int index)
{
	struct v4l2_buffer	buf;
	int			ret_val;

	buf.type	= V4L2_BUF_TYPE_VIDEO_OUTPUT;
	buf.memory	= V4L2_MEMORY_USERPTR;
	buf.m.userptr	= (unsigned long)fimc_buf;
	buf.length	= 0;
	buf.index	= index;

	ret_val = ioctl (fd, VIDIOC_QBUF, &buf);
	if (ret_val < 0) {
		printf("Error in VIDIOC_QBUF : (%d) \n", ret_val);
		return -1;
	}

	return 0;
}

int fimc_v4l2_stream_on(int fd, enum v4l2_buf_type type)
{
	if (ioctl (fd, VIDIOC_STREAMON, &type) < 0) {
		printf("Error in VIDIOC_STREAMON\n");
		return -1;
	}

	return 0;
}

int fimc_v4l2_dequeue(int fd)
{
	struct v4l2_buffer	buf;

	buf.type        = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	buf.memory      = V4L2_MEMORY_USERPTR;

	if (ioctl (fd, VIDIOC_DQBUF, &buf) < 0) {
		printf("Error in VIDIOC_DQBUF\n");
		return -1;
	}

	return buf.index;
}

int main(int argc, char *argv[])
{
	struct v4l2_output output;
	unsigned int i=0,ret=0,index;
	struct fimc_buf fimc_sbuf;
	unsigned int mode  = 0;
	unsigned int hdmi_mode = 0;
	unsigned int  y_size = 0;
	if(argc != 2) {
		printf("usage %s mode\n",argv[0]);
		printf("mode is 1080,720,480,tv\n");
		printf("example %s 1080\n",argv[0]);
		return 0;
	}

	mode = strtol(argv[1],NULL,10);

	switch(mode) {
		case 1080:
			std_id = V4L2_STD_1080P_60;
			hdmi_mode = V4L2_OUTPUT_TYPE_DIGITAL;
			out_w = 1920;
			out_h = 1080;
			break;
		case 720:
			std_id = V4L2_STD_720P_60;
			hdmi_mode = V4L2_OUTPUT_TYPE_DIGITAL;
			out_w = 1280;
			out_h = 720;
			break;
		case 480:
			std_id = V4L2_STD_480P_60_16_9;
			hdmi_mode = V4L2_OUTPUT_TYPE_DIGITAL;
			out_w = 720;
			out_h = 480;
			break;
		default:
			std_id = V4L2_STD_PAL_BDGHI;
			hdmi_mode = V4L2_OUTPUT_TYPE_COMPOSITE;
			out_w = 720;
			out_h = 576;
			break;
	}
	y_size =  ALIGN(ALIGN(out_w,128) * ALIGN(out_h, 32), 8*1024);
	lcd_open();
	lcd_getaddr();
	physYAddr = phyLCDAddr;

	hdmi_open();

	tvout_v4l2_querycap();
	tvout_v4l2_s_std();
    do
    {
	    output.index = i;
	    ret = tvout_v4l2_enum_output(&output);
	    if(output.type == hdmi_mode)
			break;
	    i++;

    }while(ret >=0);
	tvout_v4l2_s_output(output.index);

	fimc_open();
	fimc_querycap(fimc_fd);
	fimc_gfmt(fimc_fd);
	fimc_gctrl(fimc_fd);
	fimc_sctrl(fimc_fd);
	fimc_v4l2_set_src(fimc_fd,hwver);
	fimc_v4l2_set_dst(fimc_fd,0,mFimcRrvedPhysMemAddr);
	fimc_v4l2_req_buf(fimc_fd,1,0);

	fimc_v4l2_stream_on(fimc_fd,V4L2_BUF_TYPE_VIDEO_OUTPUT);
	fimc_sbuf.base[0] = phyLCDAddr;
	fimc_sbuf.base[1] = phyLCDAddr + y_size;
	fimc_sbuf.base[2] = 0;
	fimc_v4l2_queue(fimc_fd,&fimc_sbuf,0);
	overlay_open();
	tvout_v4l2_set_overlay(ov_fd);
	tvout_v4l2_start_overlay(ov_fd);

	while(1) {
			index = fimc_v4l2_dequeue(fimc_fd);
		    fimc_sbuf.base[0] = phyLCDAddr;
    		fimc_sbuf.base[1] = phyLCDAddr + y_size;
    		fimc_sbuf.base[2] = 0;
			fimc_v4l2_queue(fimc_fd,&fimc_sbuf,0);
	}

	return 1;
}
编译生成二进制后　执行

hdmitest 480是输出480p

hdmitest 720输出720p

hdmitest 1080输出1080p

hdmitest tv是tv输出　这是默认就是tv输出

时间过的比较久了具体原理也没有完全整明白 大致原理就是获取fb数据后通过fimc转换然后进行overlay(希望没有说错)

整个源码下载地址:http://download.youkuaiyun.com/detail/hclydao/8360065

============================================
作者：hclydao
http://blog.youkuaiyun.com/hclydao
版权没有，但是转载请保留此段声明

============================================


从零开始之驱动发开、linux驱动（二十六、三星平台framebuffer）
To_run_away的博客
10-21 1129
一、总述 本驱动是基于三星的s5pv210处理器分析，对于三星平台所有的framebuffer驱动基本都是一样。对应于s5pv210中的内部外设Display Controller (FIMD)模块。 framefuffer驱动是基于字符设备驱动，在使用platform总线封装编写。 二、驱动源码的分布 1、驱动代码的源文件分布： (1)：drivers/video/fb-dev/s3c...
从零开始之驱动发开、linux驱动（四十一、Linux中旧的时钟管理体系）
To_run_away的博客
11-25 685
老的时钟管理和新的时钟管理并无本质的差别。 这里先列出新的新的common clock framework和老的区别，后面再分析老的实现。 1.老的时钟框架没有区分各种时钟类型，新的框架把时钟分成了五个不同的时钟类型，固定频率的，分频的，开关类型的，多选一类型。 2.老的时钟框架需要厂商自己提供ops函数，新的时钟框架因为已经抽象出了5种时钟，所以这五种时钟的ops内核框架都已经抽象出来实现...
一起来攻克S5pv210 HDMI（作者：gooogleman）
gooogleman#foxmail.com
11-17 4818
//-------------------------------------------------------------------------------------- // 作者：gooogleman // 平台：Sate210（wince6.0 R3） // 日期：2011.11.17 //--------------------------------------------
S5pv210 HDMI 接口在 Linux 3.0.8 驱动框架解析 （By liukun321 咕唧咕唧）
热门推荐
咕唧咕唧shubo.lk的专栏
01-18 2万+
作者：liukun321 咕唧咕唧 日期：2014.1.18 转载请标明作者、出处。 本文主要简述S5pv210处理器的 HDMI 接口在 Linux 3.0.8 内核下的驱动框架。 现在三星的主流处理器基本都支持HDMI，使用HDMI也有段时间了，却一直不知道它是怎么工作的，只知道linux和android下都会有一个HDMI-service的用户服务程序。然后底层会有HDMI驱动。知道
Linux控制HDMI输出方式
最新发布
zhangyihu321的专栏
01-22 1349
1. **使用xrandr命令**（最常用）：```bash# 查看当前显示设备xrandr# 开启HDMI输出# 关闭HDMI输出# 设置HDMI为主显示器# 设置分辨率# 设置刷新率# 扩展显示（右侧）# 镜像显示```2. **使用图形界面工具**：- 系统设置 → 显示设置- arandr（xrandr的图形界面版本）：```bash# 安装arandr```3. **自动检测脚本示例**：```bash。
基于S5PV210的HDMI移植
NoMmmMoN的博客
11-02 1228
内核版本 3.9.11 编译器版本4.51 由于内核中已经有比较完善的HDMI驱动了，所以稍微修改配置一下就能使用HDMI驱动。S5PV210的HDMI驱动文件在\drivers\media\platform\s5p-tv文件夹中 其中 hdmi_drv.c 是作为HDMI平台设备驱动。（主要驱动） hdmiphy_drv.c是通过上面的驱动匹配成功后会自动匹配此设备驱动，该设备驱动实质就
S5pv210 HDMI 接口在 Linux 3.0.8 驱动框架解析
飞天鱼
12-14 838
转载请标明作者、出处：http://blog.youkuaiyun.com/liukun321/article/details/18452663 本文主要简述S5pv210处理器的 HDMI 接口在 Linux 3.0.8 内核下的驱动框架。 现在三星的主流处理器基本都支持HDMI，使用HDMI也有段时间了，却一直不知道它是怎么工作的，只知道linux和android下都会有一个HDMI-service的用户服务程序。然后底层会有HDMI驱动。知道HDMI 和framebuffer有点关系，却不知道...
s5pv210 linux hdmi
01-14
s5pv210 linux hdmi与tvout输出源码
S5PV210的软硬件整体架构
07-10
4. 显示接口：S5PV210支持多种显示接口，如LCD接口、HDMI接口和TV输出接口，可以连接不同类型的显示设备。 5. 外设接口：S5PV210提供了丰富的外设接口，包括多个UART串口、SPI接口、I2C接口、USB接口、以太网接口等...
S5PV210 多媒体预留内存空间
铁甲 - 环形电子
10-13 2615
由于GPU 多媒体解码 camera输入以及overlay显示等操作需要大块的连续物理内存，S5PV210开发板在初始化的过程中，会为这些多媒体相关驱动预留内存，这些预留的物理内存不能再被系统的其他部件使用，因此调整这些预留空间使之既能满足项目的需求，同时把浪费部分最小化，有必要分析每一部分内存需求的计算公式。 在arch/arm/plat-s5p/bootmem.c中，s5p_reserv
s5pv210 HDMI 1080P 高清显示
liujia2100的专栏
03-22 4483
s5pv210 HDMI 1080P@60Hz 显示高清图片测试
Linux内核--设备驱动(七)媒体驱动框架整理--HDMI框架(1)
文艺小少年的博客
05-07 716
V4L2 主要用于处理视频设备（如摄像头、视频采集卡等）的输入和输出，而 DRM 主要用于管理图形硬件设备（如显卡、显示器等）的渲染和显示。 本文主要介绍HDMI驱动框架
Linux驱动学习--HDMI开发(一) 相关协议及传输原理的介绍
文艺小少年的博客
07-31 4250
目录 一、引言 二、HDMI硬件接口及相关协议 -------> TMDS（转换最小化差分信令） -------> CEC（消费电子控制） -------> DDC（显示数据通道） -------> ARC（音频回传通道） -------> HEC（HDMI以太网通道） 三、HDMI上层协议 四、HDMI的基本传输原理 一、引言 最近做的项目有涉及到HDMI，故来整理一下 HDMI（High-Definition Multiface Interface）是Hitach
Linux驱动学习--HDMI开发(三)基于DRM框架的显示控制器与HDMI驱动(音视频)深入分析
文艺小少年的博客
01-25 663
本篇文章会以DRM框架为基础，详细讲解显示控制器(vop)与HDMI驱动
Linux HDMI 驱动移植
weixin_51332399的博客
06-04 762
Linux HDMI 驱动移植
s5pv210 HDMI 显示实现
liujia2100的专栏
03-22 8441
HDMI 显示USB Camera图像 ARM:(S5PV210)Smart210 LINUX:3.9.7 参考文档（http://lwn.net/Articles/449661/） Updated RFC for TV driver: ============== Introduction ============== The purpose of this RFC is to discuss the
Linux驱动学习--DRM框架介绍及基于DRM框架的HDMI开发
文艺小少年的博客
06-11 5771
目录 一、引言 二、DRM框架介绍 三、DRM框架的使用 四、源码分析 一、引言 Android4开始，hdmi等视频输出框架开始由framebuffer想DRM迁移，今天我们就来简单分析下DRM框架 二、DRM框架介绍 DRM是一个内核级的设备驱动，具体的说是显卡驱动的一种架构 源码位置 因为Linux kernel内部接口和数据结构可能随时发生变化，所以DRI模块要针对特定的内核版本进行编译。kernel 2.6.26之后的版本，DRM(DRI kernel模块)源码存放在kernel/drivers/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值