kernel与用户层接口之字符设备接口:
两种方法：
1. register_chrdev方法
2. platform_driver方法
platform_driver方法原理：
platform_driver和platform_device的name名字名字必须匹配才能实现device和driver的绑定？
（1）在内核初始化时kernel_init()->do_basic_setup()->driver_init()->platform_bus_init()初始化platform_bus(虚拟总线)；
（2）设备注册的时候platform_device_register()->platform_device_add()->(pdev->dev.bus = &platform_bus_type)把设备挂在虚拟的platform bus下；
（3）驱动注册的时候platform_driver_register()->driver_register()->bus_add_driver()->driver_attach()->bus_for_each_dev()，对每个挂在虚拟的platform bus的设备作__driver_attach()->driver_probe_device()，判断drv->bus->match()是否存在并且是否执行成功，此时通过指针执行platform_match，比较strncmp(pdev->name, drv->name, BUS_ID_SIZE)，如果相符就调用really_probe（实际就是执行的相应设备的platform_driver->probe(platform_device)，注意platform_drv_probe的_dev参数是由bus_for_each_dev的next_device获得）开始真正的探测加载，如果probe成功则绑定该设备到该驱动。
当进入probe函数后，需要获取设备的资源信息，根据参数type所指定类型，例如IORESOURCE_MEM，来分别获取指定的资源。
struct resource * platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);当然，也可以固定资源类型，如获取资源中的中断号：struct int platform_get_irq(struct platform_device *dev, unsigned int num);
probe函数一般完成硬件设备使能，struct resource的获取以及虚拟地址的动态映射和具体类型设备的注册（因为平台设备只是一种虚拟的设备类型);remove函数完成硬件设备的关闭，struct resource以及虚拟地址的动态映射的释放和具体类型设备的注销。只要和内核本身运行依赖性不大的外围设备 ( 换句话说只要不在内核运行所需的一个最小系统之内的设备 ), 相对独立的拥有各自独自的资源 (addresses and IRQs) ，都可以用platform_driver 实现。如：lcd,usb,uart 等，都可以用platfrom_driver 写，而timer,irq等最小系统之内的设备则最好不用platfrom_driver 机制，实际上内核实现也是这样的。
从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代。提醒一点，udev是应用层的，不要试图在内核的配置选项里找到它;加入对udev的支持很简单，在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用device_create创建对应的设备。
大致用法如下：
struct class *myclass ；
class_create(THIS_MODULE, “my_device_driver”);
device_create(myclass, NULL, MKDEV(major_num, minor_num), NULL, “my_device”);
这样的module被加载时，udev daemon就会自动在/dev下创建my_device设备文件。
我们在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在 /dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。
内核中定义了struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用device_create(…)函数来在/dev目录下创建相应的设备节点。
这样，加载模块的时候，用户空间中的udev会自动响应 device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。
struct class和device_create(…) 以及device_create(…)都定义在/include/linux/device.h中，使用的时候一定要包含这个头文件.
/*
* drivers/video/Tcc_overlay.c
*
* Copyright (C) 2004 Telechips, Inc.
*
* Video-for-Linux (Version 2) graphic capture driver
*
*
* This package 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.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/wait.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/videodev.h>
#include <linux/miscdevice.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/div64.h>
#include <asm/mach/map.h>
#include <linux/poll.h>
#include <mach/bsp.h>
#include <mach/tcc_fb.h>
#include <mach/tcc_overlay_ioctl.h>
#include <mach/tccfb_ioctrl.h>
#if 0
static int debug = 1;
#else
static int debug = 0;
#endif
#define dprintk(msg...) if (debug) { printk( "tcc_overlay: " msg); }
#define PLATFORM_DEVICE
#define DEVICE_NAME "overlay"
#ifdef PLATFORM_DEVICE
#define DEV_MINOR 202
#else
#define MAJOR_ID 202
#define MINOR_ID 1
#endif
//#define OVERLAY_CNT_DEFAULT 2
static struct clk *overlay_lcdc_clk;
static overlay_config_t overlay_cfg;
static struct v4l2_format overlay_fmt;
/* LCD Overlay Setting*/
#define IMG_INTL 0
#define IMG_AEN 0
#define IMG_CEN 0
#define IMG_IEN 1
#define IMG_AOPT 2
#define IMG_ASEL 0
#define IMG_PD 0
#define IMG_Y2RMD 1
#define IMG_Y2R 1
#define IMG_BR 0
#define IMG_RGB565_FMT 10 //RGB888
#define IMG_RGB888_FMT 12 //RGB888
#define IMG_RGBYUV420_FMT 24 //RGB888
#define IMG_RGBYUV422SP_FMT 25 //RGB888
#define IMG_RGBYUV422SQ_FMT 26 //RGB888
#define IMG_RGBYUV420I_FMT 28 //YUV420_INTERLEAVED
#define IMG_POSITION_Y 0
#define IMG_POSITION_X 0
#define IMG_HEIGHT LCD_HEIGHT
#define IMG_WIDTH LCD_WIDTH
#define IMG_AVAL0 95
#define IMG_AVAL1 95
static PLCDC pLCDC1;
static volatile PLCDC_CHANNEL pLCDC1_CH0;
static unsigned char start_en = 0;
static unsigned char wait_restart = 0;
static unsigned char pos_reset = 0;
static unsigned char overlay_en_count = 0;
unsigned char tcc_overlay_use = 0;
//#define VC_OVERLAY_PROFILE // CAM_28pin, GPIO_D24
#ifdef VC_OVERLAY_PROFILE
static unsigned char toggle_int = 0;
#endif
extern struct display_platform_data tcc_display_data;
extern OUTPUT_SELECT_MODE Output_SelectMode;
void tccxxx_overlay_check_priority(void);
unsigned char tccxxx_overlay_use(void)
{
return tcc_overlay_use;
}
EXPORT_SYMBOL(tccxxx_overlay_use);
void tccxxx_overlay_start(void)
{
tccxxx_overlay_check_priority();
if(!start_en){
dprintk("call start en \n");
start_en = 1;
}
}
EXPORT_SYMBOL(tccxxx_overlay_start);
extern int range_is_allowed(unsigned long pfn, unsigned long size);
static int tccxxx_overlay_mmap(struct file *file, struct vm_area_struct *vma)
{
if(range_is_allowed(vma->vm_pgoff, vma->vm_end - vma->vm_start) < 0){
printk(KERN_ERR "overlay: this address is not allowed \n");
return -EAGAIN;
}
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
if(remap_pfn_range(vma,vma->vm_start, vma->vm_pgoff , vma->vm_end - vma->vm_start, vma->vm_page_prot))
{
return -EAGAIN;
}
vma->vm_ops = NULL;
vma->vm_flags |= VM_IO;
vma->vm_flags |= VM_RESERVED;
return 0;
}
DECLARE_WAIT_QUEUE_HEAD(overlay_wait);
static unsigned int tccxxx_overlay_poll(struct file *file, struct poll_table_struct *wait)
{
dprintk(" tccxxx_overlay_poll wait[%d][%d]!!!\n", (unsigned)wait, (unsigned)&overlay_wait);
poll_wait(file, &(overlay_wait), wait);
dprintk(" tccxxx_overlay_poll finish[%d][%d]!!!\n", (unsigned)wait, (unsigned)&overlay_wait);
return POLLIN;
}
static int tccxxx_overlay_get_pos(overlay_config_t * arg )
{
overlay_config_t pos;
pos.sx = overlay_cfg.sx;
pos.sy = overlay_cfg.sy;
pos.width = overlay_cfg.width;
pos.height = overlay_cfg.height;
dprintk(" Overlay -> Get Position :: (%d,%d) | (%d,%d) \n", overlay_cfg.sx, overlay_cfg.sy, overlay_cfg.width, overlay_cfg.height);
if(copy_to_user((overlay_config_t *)arg, &pos, sizeof(overlay_config_t)))
return -EFAULT;
return 0;
}
static int tccxxx_overlay_get_screenInfo(overlay_config_t * arg )
{
struct lcd_panel *panel;
unsigned int screen_width, screen_height;
overlay_config_t screen_info;
panel = tccfb_get_panel();
screen_width = panel->xres;
screen_height = panel->yres;
#if defined(CONFIG_TCC_HDMI_UI_SIZE_1280_720)
if(tcc_display_data.resolution == 1)
{
screen_width = 720;
screen_height = 576;
}
else if(tcc_display_data.resolution == 2)
{
screen_width = 800;
screen_height = 480;
}
#endif
screen_info.sx = 0;
screen_info.sy = 0;
screen_info.width = screen_width;
screen_info.height = screen_height;
dprintk(" Overlay -> Get ScreenInfo :: (%d,%d) | (%d,%d) \n", screen_info.sx, screen_info.sy, screen_info.width, screen_info.height);
if(copy_to_user((overlay_config_t *)arg, &screen_info, sizeof(overlay_config_t)))
return -EFAULT;
return 0;
}
void tccxxx_overlay_fmt_set(unsigned int fmt)
{
dprintk(" Overlay -> S_FMT :: format = 0x%x(RGB565-0x%x, YUV420-0x%x, YUV420inter-0x%x) \n", fmt, V4L2_PIX_FMT_RGB565,V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_NV12);
if(fmt == V4L2_PIX_FMT_RGB565)
{
BITCSET (pLCDC1->LI0C, 0x1f<< 0, (IMG_RGB565_FMT) << 0); // format
BITCSET (pLCDC1->LI0O, 0x0000FFFF, overlay_cfg.width * 2); // format
BITCSET (pLCDC1->LI0C, 0x1<< 8, (0) << 8); // y2r converter enable
}
else if(fmt == V4L2_PIX_FMT_NV12)
{
BITCSET (pLCDC1->LI0C, 0x1f<< 0, (IMG_RGBYUV420I_FMT) << 0); // format
BITCSET (pLCDC1->LI0O, 0xFFFFFFFF, ((overlay_cfg.width)<<16) | (overlay_cfg.width)); // format
BITCSET (pLCDC1->LI0C, 0x1<< 8, (IMG_Y2R) << 8); // y2r converter enable
}
else if(fmt == V4L2_PIX_FMT_YUV422P)
{
BITCSET (pLCDC1->LI0C, 0x1f<< 0, (IMG_RGBYUV422SQ_FMT) << 0); // format
BITCSET (pLCDC1->LI0O, 0x0000FFFF, overlay_cfg.width * 2); // format
BITCSET (pLCDC1->LI0C, 0x1<< 8, (IMG_Y2R) << 8); // y2r converter enable
}
else
{
BITCSET (pLCDC1->LI0C, 0x1f<< 0, (IMG_RGBYUV420_FMT) << 0); // format
BITCSET (pLCDC1->LI0O, 0xFFFFFFFF, ((overlay_cfg.width/2)<<16) | (overlay_cfg.width)); // format
BITCSET (pLCDC1->LI0C, 0x1<< 8, (IMG_Y2R) << 8); // y2r converter enable
}
}
void tccxxx_overlay_check_priority(void)
{
unsigned int ch0_region, ch1_region;
PLCDC pLCD;
#if !defined(CONFIG_ARCH_TCC92XX)
if(Output_SelectMode != OUTPUT_SELECT_NONE)
{
pLCD = (volatile PLCDC)tcc_p2v(HwLCDC0_BASE);
}
else
#endif
{
pLCD = (volatile PLCDC)tcc_p2v(HwLCDC1_BASE);
}
if((pLCD->LI1C & Hw28) && (pLCD->LI0C & Hw28))
{
ch0_region = (pLCD->LI0S&0xFFFF) * ((pLCD->LI0S >> 16)&0xFFFF);
ch1_region = (pLCD->LI1S&0xFFFF) * ((pLCD->LI1S >> 16)&0xFFFF);
if(ch0_region < ch1_region)
{
// 2 > 0 > 1
dprintk(" CH_priority :%d: (2 > 0 > 1) %d x %d < %d x %d \n", Output_SelectMode,
(pLCD->LI0S&0xFFFF), ((pLCD->LI0S >> 16)&0xFFFF), (pLCD->LI1S&0xFFFF), ((pLCD->LI1S >> 16)&0xFFFF));
BITCSET (pLCD->LCTRL, HwLCTRL_OVP, 0x3<<1);
}
else
{
// 2 > 1 > 0
dprintk(" CH_priority :: (2 > 1 > 0) %d x %d < %d x %d \n", Output_SelectMode,
(pLCD->LI0S&0xFFFF), ((pLCD->LI0S >> 16)&0xFFFF), (pLCD->LI1S&0xFFFF), ((pLCD->LI1S >> 16)&0xFFFF));
BITCSET (pLCD->LCTRL, HwLCTRL_OVP, 0x5<<1);
}
}
else
{
BITCSET (pLCD->LCTRL, HwLCTRL_OVP, 0x5<<1);
}
return;
}
void tccxxx_overlay_common_enable(void)
{
unsigned int reg = 0, alpha_type = 0;
unsigned int chroma_en;
unsigned int alpha_blending_en;
unsigned int chromaR, chromaG, chromaB, alpha_value;
if(!overlay_en_count)
{
reg = pLCDC1->LI2C;
reg= (reg & 0x1F);//RGB888
if(reg == 0xC) // RGB888
{
chroma_en = 0;
alpha_value = 200;
alpha_type = 1;
alpha_blending_en = 1;//1;
chromaR = chromaG = chromaB = 0x00;
}
else
{
chroma_en = 1;
alpha_value = 200;
alpha_type = 0;
alpha_blending_en = 0;//1;
chromaR = chromaG = chromaB = 0x00;
}
// overlay �Ӽ�
BITCSET (pLCDC1->LI2C, 0x1<< 30, (alpha_blending_en) << 30); // alpha enable
BITCSET (pLCDC1->LI2C, 0x1<< 29, (chroma_en) << 29); // chroma-keying
BITCSET (pLCDC1->LI2KR, 0xff << 0, (chromaR) << 0); // key
BITCSET (pLCDC1->LI2KR, 0xff << 16, (0xF8) << 16); // keymask
BITCSET (pLCDC1->LI2KG, 0xff << 0, (chromaG) << 0); // key
BITCSET (pLCDC1->LI2KG, 0xff << 16, (0xFC) << 16); // keymask
BITCSET (pLCDC1->LI2KB, 0xff << 0, (chromaB) << 0); // key
BITCSET (pLCDC1->LI2KB, 0xff << 16, (0xF8) << 16); // keymask
// alpha_value 0~255 -- 0~100% ����
BITCSET (pLCDC1->LI2A, 0xffff <<16, (alpha_value)<< 16); // alpha1
BITCSET (pLCDC1->LI2A, 0xffff << 0, (alpha_value)<< 0); // alpha0
BITCSET (pLCDC1->LI2C, 0x3<< 25, (IMG_AOPT) << 25); // alpha opt
BITCSET (pLCDC1->LI2C, 0x1<< 24, (alpha_type) << 24); // alpha select
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI2C, HwLCT_RU, HwLCT_RU); //Image update
#endif
}
if(overlay_en_count < 2) //max overlay is 2.
overlay_en_count++;
dprintk("Enable :: overlay_en_count = %d \n", overlay_en_count);
}
EXPORT_SYMBOL(tccxxx_overlay_common_enable);
void tccxxx_overlay_common_disable(int channel)
{
dprintk("overlay disable ch:%d output mode:%d \n", channel, Output_SelectMode);
if(channel == 0)
{
#if !defined(CONFIG_ARCH_TCC92XX)
if(Output_SelectMode != OUTPUT_SELECT_NONE)
{
PLCDC pLCDC0 = (volatile PLCDC)tcc_p2v(HwLCDC0_BASE);
if(pLCDC0->LI0C & Hw28)
{
BITCSET (pLCDC0->LI0C, 0x1<< 28, (0)<<28); // lcdc channel enable
BITCSET (pLCDC0->LI0C, HwLCT_RU, HwLCT_RU); //Image update
}
}
#endif
if(!(pLCDC1->LI0C & Hw28))
return;
}
else if(channel == 1)
{
if(!(pLCDC1->LI1C & Hw28))
return;
}
else
{
//to do
}
if(overlay_en_count > 0)
overlay_en_count--;
if((!overlay_en_count)
#if defined(CONFIG_ARCH_TCC92XX)
&& (Output_SelectMode == OUTPUT_SELECT_NONE)
#endif
)
{
#if !defined(CONFIG_TCC_EXCLUSIVE_UI_LAYER)
BITCSET (pLCDC1->LI2C, 0x1<< 30, (0) << 30); // alpha enable
BITCSET (pLCDC1->LI2C, 0x1<< 29, (0) << 29); // chroma-keying
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI2C, HwLCT_RU, HwLCT_RU); //Image update
#endif
#endif
}
#if defined(CONFIG_ARCH_TCC92XX)
if(Output_SelectMode == OUTPUT_SELECT_NONE)
#endif
{
if(channel == 0)
{
BITCSET (pLCDC1->LI0C, 0x1<< 28, (0) << 28); // lcdc channel enable
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI0C, HwLCT_RU, HwLCT_RU); //Image update
#endif
}
else if(channel == 1)
{
BITCSET (pLCDC1->LI1C, 0x1<< 28, (0) << 28); // lcdc channel enable
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI1C, HwLCT_RU, HwLCT_RU); //Image update
#endif
}
else
{
}
}
dprintk("Disable :: overlay_en_count = %d \n", overlay_en_count);
}
EXPORT_SYMBOL(tccxxx_overlay_common_disable);
int tccxxx_overlay_q_buffer(unsigned int* arg )
{
unsigned int curY_phyAddr, curU_phyAddr, curV_phyAddr;
if(copy_from_user(&curY_phyAddr, (unsigned int *)arg, sizeof(unsigned int)))
return -EFAULT;
// dprintk(" Overlay -> Q_Buffer :: buffer = 0x%x pos_reset:%d start_en:%d\n", curY_phyAddr, pos_reset, start_en);
#ifdef VC_OVERLAY_PROFILE
if(toggle_int)
{
(HwGPIOD->GPEN |= Hw24); (HwGPIOD->GPDAT |= Hw24);
toggle_int = 0;
}
else
{
(HwGPIOD->GPEN |= Hw24); (HwGPIOD->GPDAT &= ~Hw24);
toggle_int = 1;
}
#endif
//in case position reset in streamming.
if(pos_reset)
{
pos_reset = 0;
// position
BITCSET (pLCDC1->LI0P, 0xffff<< 16, (overlay_cfg.sy) << 16); // position y
BITCSET (pLCDC1->LI0P, 0xffff<< 0, (overlay_cfg.sx) << 0); // position x
// size
BITCSET (pLCDC1->LI0S, 0xffff<< 16, (overlay_cfg.height) << 16); // height
BITCSET (pLCDC1->LI0S, 0xffff<< 0, (overlay_cfg.width) << 0); // width
tccxxx_overlay_fmt_set(overlay_fmt.fmt.pix.pixelformat);
}
// image address
curU_phyAddr = GET_ADDR_YUV42X_spU(curY_phyAddr, overlay_cfg.width, overlay_cfg.height);
curV_phyAddr = GET_ADDR_YUV420_spV(curU_phyAddr, overlay_cfg.width, overlay_cfg.height);
BITCSET (pLCDC1->LI0BA0, 0xFFFFFFFF, curY_phyAddr); // address0
BITCSET (pLCDC1->LI0BA1, 0xFFFFFFFF, curU_phyAddr); // address1
BITCSET (pLCDC1->LI0BA2, 0xFFFFFFFF, curV_phyAddr); // address2
if(!start_en)
{
tccxxx_overlay_common_enable();
tccxxx_overlay_fmt_set(overlay_fmt.fmt.pix.pixelformat);
BITCLR (pLCDC1->LI0C, HwLIC_INTL); // not interlace format
BITSET(pLCDC1->LCTRL, Hw0);
start_en = 1;
}
if(!(pLCDC1->LI0C & Hw28)){
BITCSET (pLCDC1->LI0C, 0x1<<28, (1) << 28); // Enable Image
}
tccxxx_overlay_check_priority();
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI0C, HwLCT_RU, HwLCT_RU); //Image update
#endif
return 0;
}
static int tccxxx_overlay_disable(void)
{
BITSCLR (pLCDC1->LI0C, 0x1<<28, (1) << 28); // Disable Image
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI0C, HwLCT_RU, HwLCT_RU); //Image update
#endif
wait_restart = 1;
return 0;
}
static int tccxxx_overlay_set_pos(overlay_config_t * arg )
{
struct lcd_panel *panel = tccfb_get_panel();
unsigned int screen_width, screen_height;
overlay_config_t pos;
if(copy_from_user(&pos, (overlay_config_t *)arg, sizeof(overlay_config_t)))
return -EFAULT;
if(!start_en)
{
BITSCLR (pLCDC1->LI0C, 0x1<<28, (1) << 28); // Disable Image
wait_restart = 1;
}
overlay_cfg.sx = pos.sx;
overlay_cfg.sy = pos.sy;
overlay_cfg.width = pos.width;
if(overlay_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565 || overlay_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P)
overlay_cfg.width = ((overlay_cfg.width+3) >> 2)<<2;
else
overlay_cfg.width = ((overlay_cfg.width+15) >> 4)<<4;
overlay_cfg.height = pos.height;
screen_width = panel->xres;
screen_height = panel->yres;
#if defined(CONFIG_TCC_HDMI_UI_SIZE_1280_720)
if(tcc_display_data.resolution == 1)
{
screen_width = 720;
screen_height = 576;
}
else if(tcc_display_data.resolution == 2)
{
screen_width = 800;
screen_height = 480;
}
#endif
if(overlay_cfg.sx + overlay_cfg.width > screen_width)
{
if(overlay_cfg.width > screen_width)
{
overlay_cfg.sx = 0;
overlay_cfg.width = screen_width;
}
else
{
overlay_cfg.sx = (screen_width - overlay_cfg.width)/2;
}
}
if(overlay_cfg.sy + overlay_cfg.height > screen_height)
{
if(overlay_cfg.height > screen_height)
{
overlay_cfg.sy = 0;
overlay_cfg.height = screen_height;
}
else
{
overlay_cfg.sy = (screen_height - overlay_cfg.height)/2;
}
}
dprintk(" Overlay -> Set Position adjust :: (%d,%d) | (%d,%d) \n", overlay_cfg.sx, overlay_cfg.sy, overlay_cfg.width, overlay_cfg.height);
//in case position reset in streamming.
if(start_en)
{
pos_reset = 1;
return 0;
}
// position
BITCSET (pLCDC1->LI0P, 0xffff<< 16, (overlay_cfg.sy) << 16); // position y
BITCSET (pLCDC1->LI0P, 0xffff<< 0, (overlay_cfg.sx) << 0); // position x
// size
BITCSET (pLCDC1->LI0S, 0xffff<< 16, (overlay_cfg.height) << 16); // height
BITCSET (pLCDC1->LI0S, 0xffff<< 0, (overlay_cfg.width) << 0); // width
tccxxx_overlay_fmt_set(overlay_fmt.fmt.pix.pixelformat);
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI0C, HwLCT_RU, HwLCT_RU); //Image update
#endif
return 0;
}
static int tccxxx_overlay_set_configure(overlay_config_t* arg)
{
unsigned int screen_width, screen_height;
struct lcd_panel *panel = tccfb_get_panel();
overlay_config_t config;
if(copy_from_user(&config, (overlay_config_t *)arg, sizeof(overlay_config_t)))
return -EFAULT;
overlay_fmt.fmt.pix.width = config.width;
overlay_fmt.fmt.pix.height = config.height ;
overlay_fmt.fmt.pix.pixelformat = config.format;
dprintk(" Overlay -> S_FMT :: size(%d,%d), format = 0x%x(RGB565-0x%x, YUV420-0x%x, YUV420inter-0x%x) \n", overlay_fmt.fmt.pix.width, overlay_fmt.fmt.pix.height, overlay_fmt.fmt.pix.pixelformat, V4L2_PIX_FMT_RGB565,V4L2_PIX_FMT_YVU420, V4L2_PIX_FMT_NV12);
overlay_cfg.sx = config.sx;
overlay_cfg.sy = config.sy;
overlay_cfg.width = overlay_fmt.fmt.pix.width;
if(overlay_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565 || overlay_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P)
overlay_cfg.width = ((overlay_cfg.width+3) >> 2)<<2;
else
overlay_cfg.width = ((overlay_cfg.width+15) >> 4)<<4;
overlay_cfg.height = overlay_fmt.fmt.pix.height;
screen_width = panel->xres;
screen_height = panel->yres;
#if defined(CONFIG_TCC_HDMI_UI_SIZE_1280_720)
if(tcc_display_data.resolution == 1)
{
screen_width = 720;
screen_height = 576;
}
else if(tcc_display_data.resolution == 2)
{
screen_width = 800;
screen_height = 480;
}
#endif
if(overlay_cfg.sx + overlay_cfg.width > screen_width)
{
if(overlay_cfg.width > screen_width)
{
overlay_cfg.sx = 0;
overlay_cfg.width = screen_width;
}
else
{
overlay_cfg.sx = (screen_width - overlay_cfg.width)/2;
}
}
if(overlay_cfg.sy + overlay_cfg.height > screen_height)
{
if(overlay_cfg.height > screen_height)
{
overlay_cfg.sy = 0;
overlay_cfg.height = screen_height;
}
else
{
overlay_cfg.sy = (screen_height - overlay_cfg.height)/2;
}
}
dprintk(" Overlay -> S_FMT :: Real => size(%d,%d ~ %d,%d) \n", overlay_cfg.sx, overlay_cfg.sy, overlay_cfg.width, overlay_cfg.height);
// position
BITCSET (pLCDC1->LI0P, 0xffff<< 16, (overlay_cfg.sy) << 16); // position y
BITCSET (pLCDC1->LI0P, 0xffff<< 0, (overlay_cfg.sx) << 0); // position x
// size
BITCSET (pLCDC1->LI0S, 0xffff<< 16, (overlay_cfg.height) << 16); // height
BITCSET (pLCDC1->LI0S, 0xffff<< 0, (overlay_cfg.width) << 0); // width
tccxxx_overlay_fmt_set(overlay_fmt.fmt.pix.pixelformat);
BITCLR(pLCDC1->LI0C, HwLIC_SRC);
#if !defined(CONFIG_ARCH_TCC92XX)
BITCSET (pLCDC1->LI0C, HwLCT_RU, HwLCT_RU); //Image update
#endif
return 0;
}
static int overlay_forbid;
static int tccxxx_overlay_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int intArg;
#if 0
if(Output_SelectMode != OUTPUT_SELECT_NONE)
return 0;
//if(overlay_forbid && (cmd != OVERLAY_FORBID))
// return 0;
#endif//
switch(cmd)
{
case OVERLAY_FORBID:
if(copy_from_user(&intArg, (int *)arg, sizeof(int)))
return -EFAULT;
overlay_forbid = intArg;
return 0;
case OVERLAY_GET_POSITION:
return tccxxx_overlay_get_pos((overlay_config_t*)arg);
case OVERLAY_GET_SCREEN_INFO:
return tccxxx_overlay_get_screenInfo((overlay_config_t*)arg);
case OVERLAY_SET_POSITION:
return tccxxx_overlay_set_pos((overlay_config_t*)arg);
case OVERLAY_QUEUE_BUFFER:
return tccxxx_overlay_q_buffer((unsigned int*)arg);
case OVERLAY_SET_CONFIGURE:
return tccxxx_overlay_set_configure((overlay_config_t*)arg);
case OVERLAY_SET_DISABLE:
return tccxxx_overlay_disable();
default:
dprintk(" Unsupported IOCTL(%d)!!!\n", cmd);
break;
}
return 0;
}
static int tccxxx_overlay_release(struct inode *inode, struct file *file)
{
start_en = 0;
wait_restart = 0;
tcc_overlay_use--;
dprintk(" ===========> tccxxx_overlay_release num:%d \n", tcc_overlay_use);
tccxxx_overlay_common_disable(0);
clk_disable(overlay_lcdc_clk);
return 0;
}
static int tccxxx_overlay_open(struct inode *inode, struct file *file)
{
tcc_overlay_use++;
clk_enable(overlay_lcdc_clk);
if(tcc_overlay_use > 1)
{
start_en = 0;
wait_restart = 0;
tcc_overlay_use--;
dprintk(" ===========> forced close num:%d \n", tcc_overlay_use);
tccxxx_overlay_common_disable(0);
clk_disable(overlay_lcdc_clk);
}
dprintk(" ===========> tccxxx_overlay_open num:%d \n", tcc_overlay_use);
return 0;
}
static struct file_operations tcc_overlay_fops =
{
.owner = THIS_MODULE,
.poll = tccxxx_overlay_poll,
.ioctl = tccxxx_overlay_ioctl,
.mmap = tccxxx_overlay_mmap,
.open = tccxxx_overlay_open,
.release = tccxxx_overlay_release,
};
#ifdef PLATFORM_DEVICE
static struct miscdevice overlay_misc_device =
{
DEV_MINOR,
DEVICE_NAME,
&tcc_overlay_fops,
};
static int __init tcc_overlay_probe(struct platform_device *pdev)
{
overlay_lcdc_clk = clk_get(0, "lcdc1");
BUG_ON(overlay_lcdc_clk == NULL);
pLCDC1 = (volatile PLCDC)tcc_p2v(HwLCDC1_BASE);
#ifdef CONFIG_ARCH_TCC92XX
pLCDC1_CH0 = (volatile PLCDC_CHANNEL)tcc_p2v(pLCDC1->LI0C);
#else
pLCDC1_CH0 = (volatile PLCDC_CHANNEL)tcc_p2v(HwLCDC1_CH_BASE(0));
#endif//
if (misc_register(&overlay_misc_device))
{
dprintk(KERN_WARNING "OVERLAY: Couldn't register device %d.\n", DEV_MINOR);
return -EBUSY;
}
return 0;
}
static int tcc_overlay_remove(struct platform_device *pdev)
{
misc_deregister(&overlay_misc_device);
return 0;
}
#ifdef CONFIG_PM
static volatile LCDC_CHANNEL LCDC1_CH0_BackUp;
static int tcc_overlay_suspend(struct platform_device *pdev, pm_message_t state)
{
if(tcc_overlay_use != 0)
{
printk("tcc_overlay_suspend %d opened\n", tcc_overlay_use);
LCDC1_CH0_BackUp = *pLCDC1_CH0;
clk_disable(overlay_lcdc_clk);
}
return 0;
}
static int tcc_overlay_resume(struct platform_device *pdev)
{
if(tcc_overlay_use != 0)
{
printk("tcc_overlay_resume %d opened\n", tcc_overlay_use);
clk_enable(overlay_lcdc_clk);
*pLCDC1_CH0 = LCDC1_CH0_BackUp;
}
return 0;
}
#else //CONFIG_PM
#define tcc_overlay_suspend NULL
#define tcc_overlay_resume NULL
#endif //CONFIG_PM
static struct platform_device tcc_overlay_device = {
.name = "tcc_overlay",
.dev = {
.release = NULL,
},
.id = 0,
};
static struct platform_driver tcc_overlay_driver = {
.driver = {
.name = "tcc_overlay",
.owner = THIS_MODULE,
},
.probe = tcc_overlay_probe,
.remove = tcc_overlay_remove,
.suspend = tcc_overlay_suspend,
.resume = tcc_overlay_resume,
};
#endif
static void __exit
tccxxx_overlay_cleanup(void)
{
#ifdef PLATFORM_DEVICE
platform_driver_unregister(&tcc_overlay_driver);
platform_device_unregister(&tcc_overlay_device);
#else
unregister_chrdev(MAJOR_ID, DEVICE_NAME);
#endif
dprintk(" ===========> tccxxx_overlay_cleanup \n");
return;
}
static char banner[] __initdata = KERN_INFO "TCC Overlay driver initializing\n";
#ifndef PLATFORM_DEVICE
static struct class *overlay_class;
#endif
static int __init
tccxxx_overlay_init(void)
{
printk(banner);
#ifdef PLATFORM_DEVICE
platform_device_register(&tcc_overlay_device);
platform_driver_register(&tcc_overlay_driver);
#else
register_chrdev(MAJOR_ID, DEVICE_NAME, &tcc_overlay_fops);
overlay_class = class_create(THIS_MODULE, DEVICE_NAME);
device_create(overlay_class,NULL,MKDEV(MAJOR_ID,MINOR_ID),NULL,DEVICE_NAME);
overlay_lcdc_clk = clk_get(0, "lcdc1");
BUG_ON(overlay_lcdc_clk == NULL);
pLCDC1 = (volatile PLCDC)tcc_p2v(HwLCDC1_BASE);
#endif
return 0;
}
MODULE_AUTHOR("Telechips.");
MODULE_DESCRIPTION("TCC Video for Linux overlay driver");
MODULE_LICENSE("GPL");
module_init(tccxxx_overlay_init);
module_exit(tccxxx_overlay_cleanup);
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
