Linux-2.6.30.4在2440上的移植之触摸屏驱动

一、移植环境

主 机：VMWare--Fedora 9

开发板：Mini2440--64MB Nand

编译器：arm-linux-gcc-4.3.2

二、移植步骤

1. 准备驱动源码。因为linux-2.6.30.4内核中没有提供合适的ADC驱动和触摸屏驱动，所以这里就直接用友善提供的驱动

s3c24xx-adc.h

#ifndef_S3C2410_ADC_H_
#define_S3C2410_ADC_H_

#defineADC_WRITE(ch,prescale)((ch)<<16|(prescale))

#defineADC_WRITE_GETCH(data)(((data)>>16)&0x7)
#defineADC_WRITE_GETPRE(data)((data)&0xff)

#endif/* _S3C2410_ADC_H_ */DE>

mini2440_adc.c

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include
#include
#include
#include

#include"s3c24xx-adc.h"

#undefDEBUG
//#define DEBUG

#ifdefDEBUG
#defineDPRINTK(x...){printk(__FUNCTION__"(%d): ",__LINE__);printk(##x);}
#else
#defineDPRINTK(x...)(void)(0)
#endif

#defineDEVICE_NAME"adc"

staticvoid__iomem*base_addr;

typedefstruct{
wait_queue_head_t wait;
intchannel;
intprescale;
}ADC_DEV;

DECLARE_MUTEX(ADC_LOCK);
staticintOwnADC=0;

staticADC_DEV adcdev;
staticvolatileintev_adc=0;
staticintadc_data;

staticstructclk*adc_clock;

#defineADCCON(*(volatileunsignedlong*)(base_addr+S3C2410_ADCCON))//ADC control

#defineADCTSC(*(volatileunsignedlong*)(base_addr+S3C2410_ADCTSC))//ADC touch screen control

#defineADCDLY(*(volatileunsignedlong*)(base_addr+S3C2410_ADCDLY))//ADC start or Interval Delay

#defineADCDAT0(*(volatileunsignedlong*)(base_addr+S3C2410_ADCDAT0))//ADC conversion data 0

#defineADCDAT1(*(volatileunsignedlong*)(base_addr+S3C2410_ADCDAT1))//ADC conversion data 1

#defineADCUPDN(*(volatileunsignedlong*)(base_addr+0x14))//Stylus Up/Down interrupt status

#definePRESCALE_DIS(0<<14)
#definePRESCALE_EN(1<<14)
#definePRSCVL(x)((x)<<6)
#defineADC_INPUT(x)((x)<<3)
#defineADC_START(1<<0)
#defineADC_ENDCVT(1<<15)

#defineSTART_ADC_AIN(ch,prescale)
do{
ADCCON=PRESCALE_EN|PRSCVL(prescale)|ADC_INPUT((ch));
ADCCON|=ADC_START;
}while(0)

staticirqreturn_t adcdone_int_handler(intirq,void*dev_id)
{
if(OwnADC){
adc_data=ADCDAT0&0x3ff;

ev_adc=1;
wake_up_interruptible(&adcdev.wait);
}

returnIRQ_HANDLED;
}

staticssize_t s3c2410_adc_read(structfile*filp,char*buffer,size_tcount,loff_t*ppos)
{
charstr[20];
intvalue;
size_tlen;
if(down_trylock(&ADC_LOCK)==0){
OwnADC=1;
START_ADC_AIN(adcdev.channel,adcdev.prescale);
wait_event_interruptible(adcdev.wait,ev_adc);

ev_adc=0;

DPRINTK("AIN[%d] = 0x%04x, %dn",adcdev.channel,adc_data,ADCCON&0x80?1:0);

value=adc_data;
sprintf(str,"%5d",adc_data);
copy_to_user(buffer,(char*)&adc_data,sizeof(adc_data));

OwnADC=0;
up(&ADC_LOCK);
}else{
value=-1;
}

len=sprintf(str,"%dn",value);
if(count>=len){
intr=copy_to_user(buffer,str,len);
returnr?r:len;
}else{
return-EINVAL;
}
}

staticints3c2410_adc_open(structinode*inode,structfile*filp)
{
init_waitqueue_head(&(adcdev.wait));

adcdev.channel=0;
adcdev.prescale=0xff;

DPRINTK("adc openedn");
return0;
}

staticints3c2410_adc_release(structinode*inode,structfile*filp)
{
DPRINTK("adc closedn");
return0;
}

staticstructfile_operations dev_fops={
owner:THIS_MODULE,
open:s3c2410_adc_open,
read:s3c2410_adc_read,
release:s3c2410_adc_release,
};

staticstructmiscdevice misc={
.minor=MISC_DYNAMIC_MINOR,
.name=DEVICE_NAME,
.fops=&dev_fops,
};

staticint__init dev_init(void)
{
intret;

base_addr=ioremap(S3C2410_PA_ADC,0x20);
if(base_addr==NULL){
printk(KERN_ERR"Failed to remap register blockn");
return-ENOMEM;
}

adc_clock=clk_get(NULL,"adc");
if(!adc_clock){
printk(KERN_ERR"failed to get adc clock sourcen");
return-ENOENT;
}
clk_enable(adc_clock);

/* normal ADC */
ADCTSC=0;

ret=request_irq(IRQ_ADC,adcdone_int_handler,IRQF_SHARED,DEVICE_NAME,&adcdev);
if(ret){
iounmap(base_addr);
returnret;
}

ret=misc_register(&misc);

printk(DEVICE_NAME"tinitializedn");
returnret;
}

staticvoid__exit dev_exit(void)
{
free_irq(IRQ_ADC,&adcdev);
iounmap(base_addr);

if(adc_clock){
clk_disable(adc_clock);
clk_put(adc_clock);
adc_clock=NULL;
}

misc_deregister(&misc);
}

EXPORT_SYMBOL(ADC_LOCK);
module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");
DE>

s3c2410_ts.c

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include
#include

/* For ts.dev.id.version */
#defineS3C2410TSVERSION0x0101

#defineWAIT4INT(x)(((x)<<8)|
S3C2410_ADCTSC_YM_SEN|S3C2410_ADCTSC_YP_SEN|S3C2410_ADCTSC_XP_SEN|
S3C2410_ADCTSC_XY_PST(3))

#defineAUTOPST(S3C2410_ADCTSC_YM_SEN|S3C2410_ADCTSC_YP_SEN|S3C2410_ADCTSC_XP_SEN|
S3C2410_ADCTSC_AUTO_PST|S3C2410_ADCTSC_XY_PST(0))

staticchar*s3c2410ts_name="s3c2410 TouchScreen";

staticstructinput_dev*dev;
staticlongxp;
staticlongyp;
staticintcount;

externstructsemaphore ADC_LOCK;
staticintOwnADC=0;

staticvoid__iomem*base_addr;

staticinlinevoids3c2410_ts_connect(void)
{
s3c2410_gpio_cfgpin(S3C2410_GPG12,S3C2410_GPG12_XMON);
s3c2410_gpio_cfgpin(S3C2410_GPG13,S3C2410_GPG13_nXPON);
s3c2410_gpio_cfgpin(S3C2410_GPG14,S3C2410_GPG14_YMON);
s3c2410_gpio_cfgpin(S3C2410_GPG15,S3C2410_GPG15_nYPON);
}

staticvoidtouch_timer_fire(unsignedlongdata)
{
unsignedlongdata0;
unsignedlongdata1;
intupdown;

data0=ioread32(base_addr+S3C2410_ADCDAT0);
data1=ioread32(base_addr+S3C2410_ADCDAT1);

updown=(!(data0&S3C2410_ADCDAT0_UPDOWN))&&(!(data1&S3C2410_ADCDAT0_UPDOWN));

if(updown){
if(count!=0){
longtmp;

tmp=xp;
xp=yp;
yp=tmp;

xp>>=2;
yp>>=2;

#ifdefCONFIG_TOUCHSCREEN_MY2440_DEBUG
structtimevaltv;
do_gettimeofday(&tv);
printk(KERN_DEBUG"T: %06d, X: %03ld, Y: %03ldn",(int)tv.tv_usec,xp,yp);
#endif

input_report_abs(dev,ABS_X,xp);
input_report_abs(dev,ABS_Y,yp);

input_report_key(dev,BTN_TOUCH,1);
input_report_abs(dev,ABS_PRESSURE,1);
input_sync(dev);
}

xp=0;
yp=0;
count=0;

iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE|AUTOPST,base_addr+S3C2410_ADCTSC);
iowrite32(ioread32(base_addr+S3C2410_ADCCON)|S3C2410_ADCCON_ENABLE_START,base_addr+S3C2410_ADCCON);
}else{
count=0;

input_report_key(dev,BTN_TOUCH,0);
input_report_abs(dev,ABS_PRESSURE,0);
input_sync(dev);

iowrite32(WAIT4INT(0),base_addr+S3C2410_ADCTSC);
if(OwnADC){
OwnADC=0;
up(&ADC_LOCK);
}
}
}

staticstructtimer_list touch_timer=
TIMER_INITIALIZER(touch_timer_fire,0,0);

staticirqreturn_t stylus_updown(intirq,void*dev_id)
{
unsignedlongdata0;
unsignedlongdata1;
intupdown;

if(down_trylock(&ADC_LOCK)==0){
OwnADC=1;
data0=ioread32(base_addr+S3C2410_ADCDAT0);
data1=ioread32(base_addr+S3C2410_ADCDAT1);

updown=(!(data0&S3C2410_ADCDAT0_UPDOWN))&&(!(data1&S3C2410_ADCDAT0_UPDOWN));

if(updown){
touch_timer_fire(0);
}else{
OwnADC=0;
up(&ADC_LOCK);
}
}

returnIRQ_HANDLED;
}

staticirqreturn_t stylus_action(intirq,void*dev_id)
{
unsignedlongdata0;
unsignedlongdata1;

if(OwnADC){
data0=ioread32(base_addr+S3C2410_ADCDAT0);
data1=ioread32(base_addr+S3C2410_ADCDAT1);

xp+=data0&S3C2410_ADCDAT0_XPDATA_MASK;
yp+=data1&S3C2410_ADCDAT1_YPDATA_MASK;
count++;

if(count<(1<<2)){
iowrite32(S3C2410_ADCTSC_PULL_UP_DISABLE|AUTOPST,base_addr+S3C2410_ADCTSC);
iowrite32(ioread32(base_addr+S3C2410_ADCCON)|S3C2410_ADCCON_ENABLE_START,base_addr+S3C2410_ADCCON);
}else{
mod_timer(&touch_timer,jiffies+1);
iowrite32(WAIT4INT(1),base_addr+S3C2410_ADCTSC);
}
}

returnIRQ_HANDLED;
}

staticstructclk*adc_clock;

staticint__init s3c2410ts_init(void)
{
structinput_dev*input_dev;

adc_clock=clk_get(NULL,"adc");
if(!adc_clock){
printk(KERN_ERR"failed to get adc clock sourcen");
return-ENOENT;
}
clk_enable(adc_clock);

base_addr=ioremap(S3C2410_PA_ADC,0x20);
if(base_addr==NULL){
printk(KERN_ERR"Failed to remap register blockn");
return-ENOMEM;
}

/* Configure GPIOs */
s3c2410_ts_connect();

iowrite32(S3C2410_ADCCON_PRSCEN|S3C2410_ADCCON_PRSCVL(0xFF),
base_addr+S3C2410_ADCCON);
iowrite32(0xffff,base_addr+S3C2410_ADCDLY);
iowrite32(WAIT4INT(0),base_addr+S3C2410_ADCTSC);

/* Initialise input stuff */
input_dev=input_allocate_device();

if(!input_dev){
printk(KERN_ERR"Unable to allocate the input device !!n");
return-ENOMEM;
}

dev=input_dev;
dev->evbit[0]=BIT(EV_SYN)|BIT(EV_KEY)|BIT(EV_ABS);
dev->keybit[BITS_TO_LONGS(BTN_TOUCH)]=BIT(BTN_TOUCH);
input_set_abs_params(dev,ABS_X,0,0x3FF,0,0);
input_set_abs_params(dev,ABS_Y,0,0x3FF,0,0);
input_set_abs_params(dev,ABS_PRESSURE,0,1,0,0);

dev->name=s3c2410ts_name;
dev->id.bustype=BUS_RS232;
dev->id.vendor=0xDEAD;
dev->id.product=0xBEEF;
dev->id.version=S3C2410TSVERSION;

/* Get irqs */
if(request_irq(IRQ_ADC,stylus_action,IRQF_SHARED|IRQF_SAMPLE_RANDOM,
"s3c2410_action",dev)){
printk(KERN_ERR"s3c2410_ts.c: Could not allocate ts IRQ_ADC !n");
iounmap(base_addr);
return-EIO;
}
if(request_irq(IRQ_TC,stylus_updown,IRQF_SAMPLE_RANDOM,
"s3c2410_action",dev)){
printk(KERN_ERR"s3c2410_ts.c: Could not allocate ts IRQ_TC !n");
iounmap(base_addr);
return-EIO;
}

printk(KERN_INFO"%s successfully loadedn",s3c2410ts_name);

/* All went ok, so register to the input system */
input_register_device(dev);

return0;
}

staticvoid__exit s3c2410ts_exit(void)
{
disable_irq(IRQ_ADC);
disable_irq(IRQ_TC);
free_irq(IRQ_TC,dev);
free_irq(IRQ_ADC,dev);

if(adc_clock){
clk_disable(adc_clock);
clk_put(adc_clock);
adc_clock=NULL;
}

input_unregister_device(dev);
iounmap(base_addr);
}

module_init(s3c2410ts_init);
module_exit(s3c2410ts_exit);
DE>