移植ads7846驱动到tiny6410（tiny6410）（ads7846）（移植）（触摸屏）（抖动）

原文链接：http://www.cnblogs.com/liu_xf/archive/2011/06/23/2088417.html

摘要：

       目前，市面上很多6410开发板都存在触摸屏抖动的问题，tiny6410也不例外，友善的解决方法是采用一线触摸，即在LCD板上，用一个单片机控制ADS7846芯片AD转换，再将数据通过单总线的方式与6410通讯。可是，我这里没有一线触摸板，于是就开始移植ADS7846驱动到tiny6410。

介绍：

        可能有人会问，6410的触摸屏为什么会抖动呢，是不是滤波没做好，或者是硬件走线的原因？是不是硬件的原因，我无法验证。我尝试过通过滤波来改善，但效果一般。不说别的，我在单独测试AD的时候，发现在输入不变的情况下，AD采样的跳幅最大达到25（0～1024范围），可见，跳动还是很大的，这样的情况下，即使再滤波也只是浪费时间。

        mini6410-ts.c触摸屏驱动见：

       （原创）6410触摸屏驱动分析（s3c-ts.c）（Linux）（分析）

        先说说我的硬件：

            TS_PEN   ----- GPN9   EINT9

            TS_MISO  ----  GPC0   MISO0

            TS_MOSI  ----   GPC2  MOSI0

            TS_SCK    -----  GPC1  SCK0

            TS_CS      -----  GPC3   CS0

           这些端子在核心板的CON1上可以找到，我这里是用的IO模拟的SPI。

        下面的开始介绍移植的过程，代码，我在下面会全部帖出来，里面注释也很详细，一般都能看明白。

         1、复制/opt/FriendlyARM/mini6410/linux-2.6.38/drivers/input/touchscreen/mini6410-ts.c为mini6410-ads7846.c。

         修改后，如下：

view sourceprint?

001	/* linux/drivers/input/touchscreen/s3c-ts.c

002

*

003	* This program is free software; you can redistribute it and/or modify

004	* it under the terms of the GNU General Public License as published by

005	* the Free Software Foundation; either version 2 of the License, or

006	* (at your option) any later version.

007

*

008	* This program is distributed in the hope that it will be useful,

009	* but WITHOUT ANY WARRANTY; without even the implied warranty of

010	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

011	* GNU General Public License for more details.

012

*

013	* You should have received a copy of the GNU General Public License

014	* along with this program; if not, write to the Free Software

015	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

016

*

017	* a misc driver for mini6410 touch screen

018	*  by FriendlyARM 2010

019

*

020	* Based on following software:

021

*

022	** Copyright (c) 2004 Arnaud Patard <arnaud.patard@rtp-net.org>

023	** iPAQ H1940 touchscreen support

024

**

025	** ChangeLog

026

**

027	** 2004-09-05: Herbert Potzl <herbert@13thfloor.at>

028	** - added clock (de-)allocation code

029

**

030	** 2005-03-06: Arnaud Patard <arnaud.patard@rtp-net.org>

031	**      - h1940_ -> s3c24xx (this driver is now also used on the n30

032	**        machines :P)

033	**      - Debug messages are now enabled with the config option

034	**        TOUCHSCREEN_S3C_DEBUG

035	**      - Changed the way the value are read

036	**      - Input subsystem should now work

037	**      - Use ioremap and readl/writel

038

**

039	** 2005-03-23: Arnaud Patard <arnaud.patard@rtp-net.org>

040	**      - Make use of some undocumented features of the touchscreen

041	**        controller

042

**

043	** 2006-09-05: Ryu Euiyoul <ryu.real@gmail.com>

044	**      - added power management suspend and resume code

045

*

046	* 2011-6-23: ADS7846触摸屏驱动程序 by liu_xf

047	*           http://www.cnblogs.com/liu_xf

048

*

049	* 2011-6-29 改进滤波，并将AD连续转换8次的间隔缩小了

050

*/

051

052	#include <linux/errno.h>

053	#include <linux/kernel.h>

054	#include <linux/module.h>

055	#include <linux/slab.h>

056	#include <linux/input.h>

057	#include <linux/init.h>

058	#include <linux/serio.h>

059	#include <linux/delay.h>

060	#include <linux/platform_device.h>

061	#include <linux/clk.h>

062	#include <linux/fs.h>

063	#include <linux/poll.h>

064	#include <linux/irq.h>

065	#include <linux/interrupt.h>

066	#include <linux/cdev.h>

067	#include <linux/miscdevice.h>

068

069	#include <asm/uaccess.h>

070	#include <asm/io.h>

071	#include <asm/irq.h>

072	#include <mach/hardware.h>

073

074

075	//#include <mach/irqs.h>

076	#include <mach/map.h>

077	#include <mach/regs-clock.h>

078	#include <mach/regs-gpio.h>

079	#include <plat/gpio-cfg.h>

080	#include <mach/gpio-bank-n.h>

081	#include <mach/gpio-bank-c.h>

082

083

084	#define CONFIG_TOUCHSCREEN_ADS7846_DEBUG

085	#undef CONFIG_TOUCHSCREEN_ADS7846_DEBUG

086	#define DEBUG_LVL       KERN_DEBUG

087

088

089

/*

090	* Definitions & global arrays.

091

*/

092	#define DEVICE_NAME     "touchscreen"

093	static DECLARE_WAIT_QUEUE_HEAD(ts_waitq); //定义并初始化一个等待队列

094

095	typedef unsigned        TS_EVENT;

096	#define NR_EVENTS       64     //触摸屏fifo大小

097

098

099	static TS_EVENT         events[NR_EVENTS];

100	static int              evt_head, evt_tail; //fifo的头的尾

101	//驱动写fifo时evt_head++，应用读fifo时 evt_tail++

102

103	#define ts_evt_pending()    ((volatile u8)(evt_head != evt_tail))   //相等就表示满了

104	#define ts_evt_get()        (events + evt_tail)

105	#define ts_evt_pull()       (evt_tail = (evt_tail + 1) & (NR_EVENTS - 1))

106	#define ts_evt_clear()      (evt_head = evt_tail = 0)

107

108	#define ADS7846_CNV_NBR  8  //ADC连续转换的次数

109	struct ads7846_ts_info {

110

111	struct input_dev *dev;

112

113	unsigned int xp; //x方向位置

114	unsigned int yp; //y方向位置

115	unsigned int count; //adc转换次数

116	unsigned int cnv_nbr;

117	unsigned int x_buf[ADS7846_CNV_NBR];  //ad转换buf

118	unsigned int y_buf[ADS7846_CNV_NBR];

119

120

};

121

122	static struct ads7846_ts_info   *ts;

123

124

125

126

127	//ADS7846底层操作========================================================================

128	#define ADS7846_GPIO_MISO   0   //gpc0

129	#define ADS7846_GPIO_MOSI   2     //gpc2

130	#define ADS7846_GPIO_CLK   1       //gpc1

131	#define ADS7846_GPIO_CS   3       //gpc3

132

133	// ADS7846 Control Byte bit defines

134	#define ADS7846_CMD_START   0x0080

135	#define ADS7846_ADDR_BIT    4

136	#define ADS7846_ADDR_MASK   (0x7<<ADS7846_ADDR_BIT)

137	#define ADS7846_MEASURE_X   (0x5<<ADS7846_ADDR_BIT)

138	#define ADS7846_MEASURE_Y   (0x1<<ADS7846_ADDR_BIT)

139	#define ADS7846_MEASURE_Z1  (0x3<<ADS7846_ADDR_BIT)

140	#define ADS7846_MEASURE_Z2  (0x4<<ADS7846_ADDR_BIT)

141	#define ADS7846_8BITS       (1<<3)

142	#define ADS7846_12BITS      0

143	#define ADS7846_SER         (1<<2)

144	#define ADS7846_DFR         0

145	#define ADS7846_PWR_BIT     0

146	#define ADS7846_PD          0

147	#define ADS7846_ADC_ON      (0x1<<ADS7846_PWR_BIT)

148	#define ADS7846_REF_ON      (0x2<<ADS7846_PWR_BIT)

149	#define ADS7846_REF_ADC_ON  (0x3<<ADS7846_PWR_BIT)

150

151	#define MEASURE_8BIT_X\

152	(unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_X | ADS7846_8BITS | ADS7846_DFR | ADS7846_PD)

153	#define MEASURE_8BIT_Y\

154	(unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_Y | ADS7846_8BITS | ADS7846_DFR | ADS7846_PD)

155

156	#define MEASURE_12BIT_X \

157	(unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_X | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)

158	#define MEASURE_12BIT_Y \

159	(unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_Y | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)

160	#define MEASURE_12BIT_Z1 \

161	(unsigned char)(ADS7846_MEASURE_Z1 | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)

162	#define MEASURE_12BIT_Z2 \

163	(unsigned char)(ADS7846_MEASURE_Z2 | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)

164

165	// Pin access

166

//

167	static inline void set_miso_as_up(void)//gpc0

168

{

169	unsigned long tmp;

170	tmp = readl(S3C64XX_GPCPUD);

171	tmp &= ~(3U <<0);

172	tmp |= (2U << 0);

173	writel(tmp, S3C64XX_GPCPUD);

174

}

175

176	static inline void set_miso_as_input(void)//gpc0

177

{

178	unsigned long tmp;

179	tmp = readl(S3C64XX_GPCCON);

180	tmp &= ~(0xf << 0);

181	writel(tmp, S3C64XX_GPCCON);

182

}

183

184	static inline void set_cs_mosi_clk_as_output(void)//gpc1 2 3

185

{

186	unsigned long tmp;

187	tmp = readl(S3C64XX_GPCCON);

188	tmp = (tmp & ~0xfff0) | (0x1110);

189	writel(tmp, S3C64XX_GPCCON);

190

}

191

192	static inline void set_cs_mosi_clk_as_up(void)//gpc1 2 3

193

{

194	unsigned long tmp;

195	tmp = readl(S3C64XX_GPCPUD);

196	tmp &= ~((3U <<2)|(3U <<4)|(3U <<6));

197	tmp |= (2U << 2) | (2U << 4) | (2U << 6);

198	writel(tmp, S3C64XX_GPCPUD);

199

}

200

201

202	static inline void set_gpcx_value(int pinx ,int v)

203

{

204	unsigned long tmp;

205	tmp = readl(S3C64XX_GPCDAT);

206

if (v) {

207	tmp |= (1 << pinx);

208

} else {

209	tmp &= ~(1<<pinx);

210

}

211	writel(tmp, S3C64XX_GPCDAT);

212

}

213

214	static inline int get_gpcx_value(int pinx)

215

{

216

int v;

217	unsigned long tmp;

218	tmp = readl(S3C64XX_GPCDAT);

219	v = !!(tmp & (1<<pinx));

220

return v;

221

}

222

223

//读12bit

224	static unsigned int ads7846_Read_Data(void)

225

{

226	unsigned int i,temp=0x00;

227	for(i=0;i<12;i++)

228

{

229	temp <<=1;

230	set_gpcx_value(ADS7846_GPIO_CLK, 1); udelay(10);

231	set_gpcx_value(ADS7846_GPIO_CLK, 0); udelay(10);

232	if(get_gpcx_value(ADS7846_GPIO_MISO) != 0)temp++;

233

}

234	return (temp);

235

}

236

//写8bit

237	static void ads7846_Write_Data(unsigned int n)

238

{

239	unsigned char i;

240	set_gpcx_value(ADS7846_GPIO_CLK, 0);

241	for(i=0;i<8;i++)

242

{

243	if((n&0x80)==0x80)

244	set_gpcx_value(ADS7846_GPIO_MOSI, 1);

245

else

246	set_gpcx_value(ADS7846_GPIO_MOSI, 0);

247

248

n <<= 1;

249	set_gpcx_value(ADS7846_GPIO_CLK, 1);  udelay(10);

250	set_gpcx_value(ADS7846_GPIO_CLK, 0); udelay(10);

251

}

252

}

253

254

255	//ADS7846转换==

256	//保存在ts->buf 当中

257	static void ads7846_conver_start(void)

258

{

259

int i;

260	unsigned int cmd[2];

261	unsigned int data[2];

262

263	set_gpcx_value(ADS7846_GPIO_CS, 0);

264

//开读

265	cmd[0] = MEASURE_12BIT_X;

266	cmd[1] = MEASURE_12BIT_Y;

267

268	/* CS# Low */

269	set_gpcx_value(ADS7846_GPIO_CS, 0);

270

271

//连续转换

272	for(ts->count=0; ts->count<ts->cnv_nbr;)

273

{

274	//分别读出x y坐标＝＝

275	for(i=0; i<2; i++){

276	ads7846_Write_Data(cmd[i]);

277	udelay(40);

278	data[i] = ads7846_Read_Data();

279

}

280

281

282

283

//保存转换结果

284	ts->x_buf[ts->count]= data[0];

285	ts->y_buf[ts->count]= data[1];

286	ts->count++;

287

}

288	/* CS# High */

289	set_gpcx_value(ADS7846_GPIO_CS, 1);

290

291	#ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG

292	//printk("ts read pos: x = %d, y = %d\n", data[0], data[1]);

293

#endif

294

295

}

296

297

298	//-----------------------------------------------------------------------------

299

300	//触摸屏数据滤波算法

301	//触摸屏AD连续转换N次后，按升序排列，再取中间几位值求平均

302	#define  TS_AD_NBR_PJ    4       //取中间4位求平均值

303	#define  TS_AD_NBR_MAX_CZ    10       //最大与最小的差值

304	static inline bool touch_ad_data_filter(unsigned int *buf0, unsigned int *buf1)

305

{

306	unsigned int i,j,k,temp,temp1,nbr=(ADS7846_CNV_NBR);

307	//将转换结果升序排列

308

//buf0

309	for (j= 0; j< nbr; j++)

310	for (i = 0; i < nbr; i++)

311

{

312	if(buf0[i]>buf0[i+1])//升序排列

313

{

314	temp=buf0[i+1];

315	buf0[i+1]=buf0[i];

316	buf0[i]=temp;

317

}

318

}

319

320

//buf1

321	for (j= 0; j< nbr; j++)

322	for (i = 0; i < nbr; i++)

323

{

324	if(buf1[i]>buf1[i+1])//升序排列

325

{

326	temp=buf1[i+1];

327	buf1[i+1]=buf1[i];

328	buf1[i]=temp;

329

}

330

}

331

332	//串口调试查看结果

333	//for (j= 0; j< nbr; j++)

334	// printk("buf0[%2d]=%4d, buf1[%2d]=%4d,\r\n",j,buf0[j],j,buf1[j]);

335	//取中间值求平均==

336	k=((nbr-TS_AD_NBR_PJ)>>1);

337	temp = 0;temp1 = 0;

338	//检查值是否有效==

339	if((buf0[k+TS_AD_NBR_PJ-1]-buf0[k]>TS_AD_NBR_MAX_CZ)||(buf1[k+TS_AD_NBR_PJ-1]-buf1[k]>TS_AD_NBR_MAX_CZ)) //无效值

340

{

341

342

return 0;

343

}

344

//--

345	//将中间指定位数累加

346	for(i=0;i<TS_AD_NBR_PJ;i++)

347

{

348	temp += buf0[k+i];

349	temp1 += buf1[k+i];

350

}

351	//求平均值,将结果保存在最低位

352	buf0[0]=temp/TS_AD_NBR_PJ;

353	buf1[0] = temp1/TS_AD_NBR_PJ;

354

//--

355

return 1;

356

357

}

358

359

360	//将AD转换的值放入FIFO

361	//这里是一个先进先出的fifo

362	//只要有数据被添加进来，就会唤醒ts_waitq进程

363	static void ts_evt_add(unsigned x, unsigned y, unsigned down) {

364	unsigned ts_event;

365	int next_head;

366

367	ts_event = ((x << 16) | (y)) | (down << 31);

368	next_head = (evt_head + 1) & (NR_EVENTS - 1);

369

//没满就装入

370	if (next_head != evt_tail) {

371	events[evt_head] = ts_event;

372	evt_head = next_head;

373	#ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG

374	printk("====>Add ... [ %4d,  %4d ]%s\n", x, y, down ? "":" ~~~");

375

#endif

376	/* wake up any read call */

377	if (waitqueue_active(&ts_waitq)) { //判斷等待隊列是否有進程睡眠

378	wake_up_interruptible(&ts_waitq);  //唤醒ts_waitq等待队列中所有interruptible类型的进程

379

}

380

} else {

381	/* drop the event and try to wakeup readers */

382	printk(KERN_WARNING "mini6410-ads7846: touch event buffer full");

383	wake_up_interruptible(&ts_waitq);

384

}

385

}

386

387	static unsigned int ads7846_ts_poll( struct file *file, struct poll_table_struct *wait)

388

{

389	unsigned int mask = 0;

390

391	//将ts_waitq等待队列添加到poll_table里去

392	poll_wait(file, &ts_waitq, wait);

393

//返回掩码

394	if (ts_evt_pending())

395	mask |= POLLIN | POLLRDNORM;  //返回设备可读

396

397	return mask;

398

}

399

400	//读 系统调用==

401	static int ads7846_ts_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

402

{

403	DECLARE_WAITQUEUE(wait, current); //把当前进程加到定义的等待队列头wait中

404	char *ptr = buff;

405	int err = 0;

406

407	add_wait_queue(&ts_waitq, &wait); //把wait入到等待队列头中。该队列会在进程等待的条件满足时唤醒它。

408	//我们必须在其他地方写相关代码，在事件发生时，对等的队列执行wake_up()操作。

409	//这里是在ts_evt_add里wake_up

410	while (count >= sizeof(TS_EVENT)) {

411	err = -ERESTARTSYS;

412	if (signal_pending(current)) //如果是信号唤醒    参考http://www.360doc.com/content/10/1009/17/1317564_59632874.shtml

413

break;

414

415	if (ts_evt_pending()) {

416	TS_EVENT *evt = ts_evt_get();

417

418	err = copy_to_user(ptr, evt, sizeof(TS_EVENT));

419	ts_evt_pull();

420

421

if (err)

422

break;

423

424	ptr += sizeof(TS_EVENT);

425	count -= sizeof(TS_EVENT);

426

continue;

427

}

428

429	set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为可中断的睡眠

430	err = -EAGAIN;

431	if (filp->f_flags & O_NONBLOCK) //如果上层调用是非阻塞方式，则不阻塞该进程，直接返回EAGAIN

432

break;

433	schedule();  //本进程在此处交出CPU控制权，等待被唤醒

434	//进程调度的意思侧重于把当前任务从CPU拿掉，再从就绪队列中按照调度算法取一就绪进程占用CPU

435

}

436	current->state = TASK_RUNNING;

437	remove_wait_queue(&ts_waitq, &wait);

438

439	return ptr == buff ? err : ptr - buff;

440

}

441

//--

442

443	static int ads7846_ts_open(struct inode *inode, struct file *filp) {

444	/* flush event queue */

445	ts_evt_clear();

446

447

return 0;

448

}

449

450	//当应用程序操作设备文件时调用的open read等函数，最终会调用这个结构体中对应的函数

451	static struct file_operations dev_fops = {

452	.owner              = THIS_MODULE,

453	.read               = ads7846_ts_read,

454	.poll               = ads7846_ts_poll,  //select系统调用

455	.open               = ads7846_ts_open,

456

};

457

458	//设备号，设备名，注册的时候用到这个数组

459	//混杂设备主设备号为10

460	static struct miscdevice misc = {

461	.minor              = MISC_DYNAMIC_MINOR, //自动分配次设置号

462	//.minor                = 180,

463	.name               = DEVICE_NAME,

464	.fops               = &dev_fops,

465

};

466

467

468

469

470

471

472

/**

473	* get_down - return the down state of the pen

474	* 获取pen引脚状态，为0表示down

475	* GPN9 EINT9 TS_PEN

476

*/

477	static inline bool get_down(void)

478

{

479	int tmp,down;

480	tmp = readl(S3C64XX_GPNDAT);

481	down = !(tmp & (1<<9));

482	return (down);

483

}

484

485

486	/*===========================================================================================

487	touch_timer_get_value这个函数的调用：

488

489	1、  触摸笔开始点击的时候， 在中断函数touch_down里面被调用，不是直接调用，而是设置定时器超时后调用

490

这样是为了去抖动

491

492	2、  touch_timer_get_value被调用一次后，如果pendown信号有效，则touch_timer_get_value会被持续调用

493	也是通过定时器实现的

494

495	touch_timer_get_value这个函数的功能：

496	启动7846转换，直到连续转换8次后，再滤波处理，获得有效值，并向上报告触摸屏事件

497

498	============================================================================================*/

499	static void touch_timer_get_value(unsigned long data);

500

501	static DEFINE_TIMER(touch_timer, touch_timer_get_value, 0, 0);

502

503	static void touch_timer_get_value(unsigned long data) {

504

505	int pendown;

506

507	pendown = get_down();

508

509	#ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG

510	//  if(pendown)

511

//  {

512	//    printk("touch is down!\n");

513

//  }

514

//  else

515	//    printk("touch is up!\n");

516

#endif

517

518	if (pendown) {

519

520

//关中断===

521	disable_irq(IRQ_EINT(9));

522

//--

523	//启动ADS7846转换==

524	ads7846_conver_start();

525

//开中断==

526	enable_irq(IRQ_EINT(9));

527

//--

528	//如果转换了8次，就写入FIFO保存

529	//if (ts->count == ( ts->cnv_nbr)) {

530	if(touch_ad_data_filter(ts->x_buf,ts->y_buf)) //滤波处理

531

{

532

533	ts->xp = ts->x_buf[0];

534	ts->yp = ts->y_buf[0];

535

536	ts_evt_add(ts->xp, ts->yp, 1);  //向上报告触摸屏事件

537

}

538

539

540	ts->xp = 0;

541	ts->yp = 0;

542	ts->count = 0;

543

//}

544

//--

545

546	mod_timer(&touch_timer, jiffies + 2);   //重新设置系统定时器，超时后，又会调用touch_timer_get_value

547	//jiffies变量记录了系统启动以来，系统定时器已经触发的次数。内核每秒钟将jiffies变量增加HZ次。

548	//因此，对于HZ值为100的系统，1个jiffy等于10ms，而对于HZ为1000的系统，1个jiffy仅为1ms

549	//这里系统配置提HZ是100

550

551	} else {  //如果是松开，报告其触摸笔状态

552	ts->xp = 0;

553	ts->yp = 0;

554	ts->count = 0;

555

556	ts_evt_add(0, 0, 0);

557

558

559

}

560

561

}

562

563

564

565	//触摸屏按下中断服务==

566

//双边沿中断

567	static irqreturn_t touch_down(int irqno, void *param)

568

{

569

570

571	/* Clear  interrupt */

572	//__raw_writel(0x0, ts_base + S3C_ADCCLRWK);

573	//__raw_writel(0x0, ts_base + S3C_ADCCLRINT);

574

575	//稍后调用touch_timer_get_value，去抖动

576	mod_timer(&touch_timer, jiffies + 2);  //等ADS7846转换完成了再读

577	//同时还可以防抖动，如果定时器没有超时的这段时间里，发生了抬起和按下中断，则定时器的值会被重设，不会超时

578	//内核配置时HZ值设为100，即1个jiffy等于10ms，

579	//touch_timer_get_value(1);  //直接调用会有抖动

580

581	return IRQ_RETVAL(IRQ_HANDLED);

582

}

583

584

585

586

587	//-------------------------------------------

588

589

590

/*

591	* The functions for inserting/removing us as a module.

592

*/

593	static int __init ads7846_ts_probe(struct platform_device *pdev)

594

{

595	struct device *dev;

596	int ret = 0;

597

598	dev = &pdev->dev;

599	#ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG

600	printk("ads7846_ts_probe start!\n");

601

#endif

602	//给ads7846_ts_info指针分配内存==

603	ts = kzalloc(sizeof(struct ads7846_ts_info), GFP_KERNEL);

604	ts->cnv_nbr = ADS7846_CNV_NBR;

605	ts->xp = 0;

606	ts->yp = 0;

607	ts->count = 0;

608

609

610

//申请中断==

611	//TS_PEN双边沿触发 EINT9  GPN9

612	ret = request_irq(IRQ_EINT(9), touch_down,IRQ_TYPE_EDGE_BOTH,

613	"ads7864_touch", ts);

614

615	if (ret != 0) {

616	dev_err(dev,"ads7846_ts.c: Could not allocate ts IRQ_EINT !\n");

617	ret = -EIO;

618	goto fail;

619

}

620

621

622

623

624	ret = misc_register(&misc);  //注册这混杂字符设备

625

</code