IC卡驱动程序开发

淩亂°似流年 2022-03-26 15:16 329阅读 0赞

IC卡又称集成电路卡，它是在大小和普通 [信用卡][Link 1]相同的塑料 [卡片][Link 2]上嵌置一个或多个集成电路构成的。集成电路芯片可以是存储器或向处理器。作为一种身份验证的工具，IC卡经常出现于各种电子设备中，作为一种身份的确认的工具。

下面以笔者参与的会议系统开发中的ICcard驱动程序为例，介绍linux系统下是如何进行IC card驱动程序开发的。

1、是ic\_card.h文件：

\#ifndef IC\_CARD  
 \#define  IC\_CARD   
  
\#include  < mach / regs \- gpio.h >   
\#include  < linux / wait.h >   
\#include  < linux / ioctl.h >   
  
 \#define  IC\_CARD\_MAJOR 231   
  
\#ifndef ICCARD\_NR\_DEVS  
 \#define  ICCARD\_NR\_DEVS 1 /\*设备数\*/   
 \#endif   
  
 \#define  IC\_RMM\_CMD 0x30  // 读主存命令字   
 \#define  IC\_WMM\_CMD 0x38  // 写主存命令字   
 \#define  IC\_VER\_CMD 0x33  // 校验密码   
 \#define  IC\_RSM\_CMD 0x31  // 读密码存储区   
 \#define  IC\_WSM\_CMD 0x39  // 写密码存储区   
 \#define  IC\_RPM\_CMD 0x34  // 读保护存储区   
 \#define  IC\_WPM\_CMD 0x3c  // 写保护存储区   
  
  
 \#define  IC\_RDSTART\_ADDR (volatile unsigned char\*)0X26   
 \#define  IC\_WRSTART\_ADDR (volatile unsigned char\*)0X26   
  
  
 \#define  IC\_IOCTL\_MAGIC 'i'   
  
 \#define  CFG\_RD\_COUNT \_IOW(IC\_IOCTL\_MAGIC,0,unsigned int)   
 \#define  CFG\_WR\_COUNT \_IOW(IC\_IOCTL\_MAGIC,1,unsigned int)   
  
  
 \#define  SETB\_CARD\_CLK() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)|(1<<0),S3C2410\_GPGDAT)   
 \#define  CLR\_CARD\_CLK() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)&(~(1<<0)),S3C2410\_GPGDAT)   
  
 \#define  SETB\_CARD\_RESRT() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)|(1<<1),S3C2410\_GPGDAT)   
 \#define  CLR\_CARD\_RESRT() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)&(~(1<<1)),S3C2410\_GPGDAT)   
  
 \#define  SETB\_CARD\_IO() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)|(1<<3),S3C2410\_GPGDAT)   
 \#define  CLR\_CARD\_IO() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)&(~(1<<3)),S3C2410\_GPGDAT)   
  
 \#define  SETB\_CARD\_POWER() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)|(1<<7),S3C2410\_GPGDAT)   
 \#define  CLR\_CARD\_POWER() \_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGDAT)&(~(1<<7)),S3C2410\_GPGDAT)   
  
wait\_queue\_head\_t r\_wait;  // 读等待队列   
 wait\_queue\_head\_t w\_wait;  // 写等待队列   
   
typedef  struct  \_ic\_card\_dev  
\{  
unsigned  char \*  readbufstart;  // 读入数据缓冲区首指针  
 //  char\* readbufend;  // 读入数据缓冲区末指针    
 unsigned  char \*  writebufstart;  // 写入数据缓冲区首指针  
 //  char\* writebufend;  // 写入数据缓冲区末指针   
  int  readcount;  // 读入数据量   
  int  writecount;  // 写入数据量   
  char \*  readp;  // 读人数据当前指针   
  int  readnum;  // 已经读入量   
  char \*  writep;  // 当前写入数据指针   
  int  writenum;  // 当前写入量   
  int  ic\_state;  // 卡当前状态，O为无卡，1为有卡   
  int  statechange;  // 卡状态变化标志    
  int  irqno;  
 int  r\_press;  
 int  w\_press;  
  
\}ic\_card\_dev;  
  
 \#endif  /\*IC\_CARD\*/

2、实现模块的加载和卸载函数：

1 /\* 注册设备驱动程序 \*/   
 2   static  int  ic\_card\_init( void )  
 3 \{  
 4  int  ret;  
 5 dev\_t devno;  
 6 ICDEBUG(KERN\_ALERT  " init ic card\\n " );  
 7 devno  =  MKDEV(ic\_major,  0 );  
 8  if (IC\_CARD\_MAJOR)  
 9 \{  
 10 ret  =  register\_chrdev\_region(devno,  1 , DEV\_NAME);  
 11 ICDEBUG(KERN\_ALERT  " register\_chrdev\_region ret:%d\\n " ,ret);  
 12 \}  
 13  else   
 14 \{  
 15 ret = alloc\_chrdev\_region( & devno,  0 ,  2 , DEV\_NAME);  
 16 ic\_major = MAJOR(devno);  
 17 ICDEBUG(KERN\_ALERT  " alloc\_chrdev\_region ret:%d,major:%d\\n " ,ret,ic\_major);  
 18 \}  
 19  if (ret < 0 )  
 20 \{  
 21 ICDEBUG(KERN\_ALERT  " if ret<0 ret:%d\\n " ,ret);  
 22  return  ret;  
 23 \}  
 24   
 25 cdev\_init( & cdev\_ic,  & ic\_fops);  
 26 cdev\_ic.owner = THIS\_MODULE;  
 27 cdev\_ic.ops =  & ic\_fops;  
 28   
 29  // 向系统注册该字符设备   
 30    ret  =  cdev\_add( & cdev\_ic, devno, ICCARD\_NR\_DEVS);  
 31 ICDEBUG(KERN\_ALERT  " cdev\_add ret:%d\\n " ,ret);  
 32   
 33  if  (ret)  
 34 \{  
 35 ICDEBUG( " iccard init error\\r\\n " );  
 36 unregister\_chrdev\_region(devno, 1 );  
 37  goto  failregion;  
 38 \}  
 39   
 40   
 41 ic\_card\_class  =  class\_create(THIS\_MODULE, DEV\_NAME);  
 42  if (IS\_ERR(ic\_card\_class))  
 43 \{  
 44 ICDEBUG( " can not creat a ic\_card\_class class!\\n " );  
 45  goto  failcls;  
 46 \}  
 47 device\_create(ic\_card\_class, NULL, MKDEV(IC\_CARD\_MAJOR,  0 ), NULL, DEV\_NAME);  
 48   
 49  /\* 注册中断 \*/   
 50 ret = ic\_request\_irqs();  
 51  if (ret < 0 )  
 52 \{  
 53 ICDEBUG(KERN\_ALERT  " ic\_card\_request\_irqs:ret:%d\\n " ,ret);  
 54  goto  faildev;  
 55 \}  
 56   
 57  /\* 初始化时钟 \*/   
 58 init\_timer( & ic\_timer);  
 59 ic\_timer.function = ic\_timer\_handler;  
 60   
 61 spin\_lock\_init( & lock );  
 62   
 63   /\*  ic\_dev\_info=kmalloc(ICCARD\_NR\_DEVS\*sizeof(struct ic\_card\_dev),GFP\_KERNEL);  
 64 if(!ic\_dev\_info)  
 65 \{  
 66 ret = -ENOMEM;  
 67 goto fail;  
 68 \}  
 69   \*/   
 70  // 初始化等待对列   
 71    init\_waitqueue\_head( & r\_wait);  
 72 init\_waitqueue\_head( & w\_wait);  
 73 ICDEBUG( " ic card init success!\\r\\n " );  
 74   
 75  return  0 ;  
 76 faildev:  
 77 ICDEBUG(KERN\_ALERT  " init ic card fail\\n " );  
 78 device\_destroy(ic\_card\_class, MKDEV(IC\_CARD\_MAJOR,  0 ));  
 79 failcls:  
 80 class\_destroy(ic\_card\_class);  
 81 failregion:  
 82 unregister\_chrdev\_region(devno,  1 );  
 83  return  ret;  
 84   
 85 \}  
 86   
 87   /\* 注销设备驱动程序 \*/   
 88   static  void  ic\_card\_exit( void )  
 89 \{  
 90  /\* 释放中断 \*/   
 91 ic\_free\_irqs();  
 92   
 93 cdev\_del( & cdev\_ic);  
 94  //  kfree(ic\_dev\_info);   
 95  device\_destroy(ic\_card\_class, MKDEV(IC\_CARD\_MAJOR,  0 ));  
 96 class\_destroy(ic\_card\_class);  
 97 unregister\_chrdev\_region(MKDEV(ic\_major, 0 ),  1 );  
 98 ICDEBUG(KERN\_ALERT  " ic card unregister\\n " );  
 99   
 100 \}  
 101   
 102 module\_init(ic\_card\_init);  
 103 module\_exit(ic\_card\_exit);

首先，判断IC\_CARD\_MAJOR,即是否为设备指定了主设备号，如果IC\_CARD\_MAJOR不为0，则调用 register\_chrdev\_region（）函数注册设备驱动程序。通过register\_chrdev\_region（）函数用于分配指定的设备编号范围。如果申请的设备编号范围跨越了主设备号，它会把分配范围内的编号按主设备号分割成较小的子范围，并在每个子范围上调用 \_\_register\_chrdev\_region() 。如果其中有一次分配失败的话，那会把之前成功分配的都全部退回。

如果IC\_CARD\_MAJOR为0，则调用 alloc\_chrdev\_region（）动态分配主设备号给驱动程序。

linux 2.6 内核采用struct cdev来记录字符设备的信息，通过cdev\_init初始化一个静态分配的cdev对象，详细请参考[http://www.360doc.com/content/11/0228/12/6030028\_96836815.shtml][http_www.360doc.com_content_11_0228_12_6030028_96836815.shtml]

调用cdev\_add()函数向系统注册该字符设备.

class\_create()函数及device\_create()函数使得module被加载时，udev daemon就会自动在/dev下创建IC\_CARD设备文件。  
　　然后申请中断，初始化定时器，定时器ic\_timer用于消除插卡中的抖动问题，再调用init\_waitqueue\_head()初始化等待队列。

至此，ic\_card驱动程序加载完成。

3、各IC\_card操作函数：

static  struct  file\_operations ic\_fops = \{  
.open  = ic\_open,  
.write  = ic\_card\_wrtie,  
.read  = ic\_card\_read,  
.poll  = ic\_poll,  
.ioctl  = ic\_ioctl,  
.release = ic\_release,  
.fsync  = NULL,  
\};

具体实现如下：

/\* 调用ic\_request\_irqs注册中断处理程序  
\*配置引脚  
 \*/   
 int  ic\_open ( struct  inode  \* inode,  struct  file  \* filp)  
\{  
 int  num;  
 int  ret = 0 ;  
unsigned  long  flags;  
  
ICDEBUG(KERN\_ALERT  " open ic card\\n " );  
 // 获取次设备号   
 num  =  MINOR(inode \-> i\_rdev);  
ICDEBUG(KERN\_ALERT  " MINOR:%d\\n " ,num);  
 if  (num  >=  ICCARD\_NR\_DEVS)  
 return  \- ENODEV;  
  
spin\_lock\_irqsave( & lock ,flags);  
filp \-> private\_data =& ic\_dev\_info\[num\];  
  
 // 检测IC卡是否已插入设备   
 s3c2410\_gpio\_cfgpin(S3C2410\_GPG6,S3C2410\_GPG6\_INP);  // ICCARD\_INTEREPT   
  if ((\_\_raw\_readw(S3C2410\_GPGDAT) & ( 1 << 6 )) == 0 << 6 )  
\{  
ic\_dev\_info\[num\].ic\_state = 1 ;  // 代表卡已插入   
 ic\_dev\_info\[num\].r\_press = 1 ;  // 设备可读   
 ic\_dev\_info\[num\].w\_press = 1 ;  // 设备可写   
 ICDEBUG(KERN\_ALERT  " has ic card device\\n " );  
\}  
 else   
\{  
ic\_dev\_info\[num\].ic\_state = 0 ;  // 代表卡已插入   
 ic\_dev\_info\[num\].r\_press = 0 ;  // 设备可读   
 ic\_dev\_info\[num\].w\_press = 0 ;  // 设备可写   
 ICDEBUG(KERN\_ALERT  " no found ic card device\\n " );  
\}  
spin\_unlock\_irqrestore( & lock ,flags);  
  
 // 初始化输入输出引脚   
 init\_gpio();  
  
ICDEBUG(KERN\_ALERT  " open ic card success\\n " );  
 return  ret;  
\}  
  
 int  ic\_release( struct  inode  \* inode,  struct  file  \* filp)  
\{  
 // ic\_free\_irqs();   
  return  0 ;  
\}  
  
 /\*   
\*从ic卡中读出一个字节的数据  
 \*/   
  
 int  ic\_card\_read\_byte( char  \* ch)  
\{  
 int  ret = 0 ;  
 int  ii;  
 for (ii  =  8 ; ii > 0 ; ii \-- )  
\{  
CLR\_CARD\_CLK();  
udelay( 5 );  
 \* ch = ( \* ch) >> 1 ;  // 从低位读起  
 // if((\_\_raw\_readw(S3C2410\_GPGDAT)&0x0008)==0x0008)   
  if ((\_\_raw\_readw(S3C2410\_GPGDAT) & ( 1 << 3 )) == 1 << 3 )  
\{  
 \* ch |= 0x80 ;  
ICDEBUG(KERN\_ALERT  " <------------->\\n " );  
\}  
 else   
\{  
ICDEBUG(KERN\_ALERT  " <|||||||||||||>\\n " );  
\}  
udelay( 5 );  
SETB\_CARD\_CLK();  
\}  
  
ICDEBUG(KERN\_ALERT  " ic\_card\_read\_byte:ch is>>>>>(%c)\\n " , \* ch);  
 return  ret;  
\}  
  
  
 int  ic\_card\_write\_byte( char  \* ch)  
\{  
 int  ret = 0 ;  
 int  ii;  
  
ICDEBUG(KERN\_ALERT  " enter ic\_card\_write\_byte,ch is %c\\n " , \* ch);  
 for (ii =  0 ; ii < 8 ; ii \++ )  
\{  
CLR\_CARD\_CLK();  
udelay( 5 );  
 if ( \* ch & 0x01 )  
\{  
ICDEBUG(KERN\_ALERT  " \[+++++$++++++++\]\\n " );  
SETB\_CARD\_IO();  // 输入1   
 \}  
 else   
\{  
ICDEBUG(KERN\_ALERT  " \[-----$--------\]\\n " );  
CLR\_CARD\_IO();  // 输入0   
 \}  
udelay( 5 );  
SETB\_CARD\_CLK();  
udelay( 10 );  
 \* ch =\* ch >> 1 ;  
  
\}  
 return  ret;  
  
\}  
  
 /\*   
\*复位和复位应答  
 \*/   
 static  int  ic\_card\_reset( void )  
\{  
unsigned  char  temp\_ch;  
 int  temp\_i  =  4 ;  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_OUTP);  // OUT   
 udelay( 5 );  
CLR\_CARD\_RESRT();  
CLR\_CARD\_CLK();  
SETB\_CARD\_IO();  
udelay( 5 );  
SETB\_CARD\_RESRT();  
udelay( 5 );  
SETB\_CARD\_CLK();  
udelay( 30 );  
CLR\_CARD\_CLK();  
udelay( 5 );  
CLR\_CARD\_RESRT();  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_INP);  // IN   
 udelay( 10 );  
 do \{  
 // temp\_ch = ic\_card\_read\_byte();   
 ic\_card\_read\_byte( & temp\_ch);  
ICDEBUG(KERN\_ALERT  " ic\_card\_reset:temp\_ch is(%c)\\n " ,temp\_ch);  
\} while ( \-- temp\_i > 0 );  
  
CLR\_CARD\_CLK();  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_OUTP);  // IN   
 udelay( 5 );  
SETB\_CARD\_IO();  
udelay( 5 );  
CLR\_CARD\_CLK();  
udelay( 5 );  
 return  0 ;  
\}  
  
 /\*   
\*命令开始条件  
 \*/   
 void  ic\_card\_start\_cmd( void )  
\{  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_OUTP);  // out   
 CLR\_CARD\_CLK();  
SETB\_CARD\_IO();  
udelay( 5 );  
SETB\_CARD\_CLK();  
udelay( 5 );  
CLR\_CARD\_IO();  
udelay( 5 );  
\}  
  
 /\*   
\*命令结束条件  
 \*/   
 void  ic\_card\_end\_cmd( void )  
\{  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_OUTP);  
CLR\_CARD\_CLK();  
CLR\_CARD\_IO();  
udelay( 5 );  
SETB\_CARD\_CLK();  
udelay( 5 );  
SETB\_CARD\_IO();  
udelay( 5 );  
\}  
  
 /\* 发送命令 \*/   
 void  ic\_card\_send\_cmd( const  char  cmd, const  char  addr, const  char  count)  
\{  
ICDEBUG(KERN\_ALERT  " enter ic\_card\_read:cmd is %c,addr is %c,count is %c\\n " ,cmd,addr,count);  
ic\_card\_start\_cmd();  
ic\_card\_write\_byte( & cmd);  
ic\_card\_write\_byte( & addr);  
ic\_card\_write\_byte( & count);  
ic\_card\_end\_cmd();  
\}  
  
 void  ic\_card\_breakoperator( void )  
\{  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_OUTP);  
CLR\_CARD\_CLK();  
CLR\_CARD\_RESRT();  
CLR\_CARD\_IO();  
udelay( 5 );  
SETB\_CARD\_RESRT();  
SETB\_CARD\_IO();  
udelay( 5 );  
CLR\_CARD\_RESRT();  
udelay( 5 );  
\}  
  
  
 /\* 从设备中读取指定长度的数据 \*/   
ssize\_t ic\_dev\_read( struct  file  \* filep, const  char  \* buf, size\_t count, loff\_t  \* offset)  
\{  
 int  ret = 0 ;  
 //  wait\_event\_interruptible();  
 // char \*kbuf;   
  int  istate;  
 int  sizetmp;  
 char \*  pbuf;  
 // unsigned char ch=0;   
   
ic\_card\_dev \*  icdev = (ic\_card\_dev \* )filep \-> private\_data;  
ICDEBUG(KERN\_ALERT  " enter ic\_dev\_read\\n " );  
istate  =  icdev \-> ic\_state;  
ICDEBUG(KERN\_ALERT  " ic\_dev\_istate:%d\\n " ,istate);  
pbuf = buf;  
 if ( ! istate)  
\{  
 return  \- ENODEV;  
\}  
  
 if ( ! pbuf)  
\{  
 return  \- 1 ;  
\}  
  
sizetmp = count;  
  
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3,S3C2410\_GPG3\_INP);  // 将GPG3配置成输入引脚   
   
CLR\_CARD\_CLK();  
udelay( 5 );  
 do \{  
ic\_card\_read\_byte(pbuf \++ );  
 // \*buf++ = ic\_card\_read\_byte();   
 ret \++ ;  
ICDEBUG(KERN\_ALERT  " \[ic\_card\_read:buf is (%c) ret:%d\]\\n " , \* (pbuf \- 1 ),ret);  
\} while ( \-- sizetmp);  
  
  
 return  ret;  
  
\}  
  
 /\* 往设备中写入数据 \*/   
ssize\_t ic\_dev\_wrtie( struct  file  \* filep,  char  \* buf, size\_t count, loff\_t  \* offset)  
\{  
 int  ret  =  0 ;  
 int  istate;  
unsigned  long  flags;  
 int  sizetmp;  
  
ICDEBUG(KERN\_ALERT  " enter ic\_dev\_wrtie\\n " );  
spin\_lock\_irqsave( & lock ,flags);  
istate  =  ((ic\_card\_dev \* )(filep \-> private\_data)) \-> ic\_state;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
 if ( ! istate)  
\{  
 return  \- ENODEV;  
\}  
 if ( ! buf)  
 return  \- 1 ;  
 //  wait\_event\_interruptible();   
   
s3c2410\_gpio\_cfgpin(S3C2410\_GPG3, S3C2410\_GPG3\_OUTP); // 将GPG3配置成输出引脚   
   
sizetmp = count;  
 do   
\{  
ic\_card\_write\_byte(buf \++ );  // 按字节发送至ic卡   
 \} while ( \-- sizetmp);  
 return  ret;  
\}  
  
 /\* file\_operations read \*/   
ssize\_t ic\_card\_read( struct  file  \* filep,  char  \_\_user  \* buf, size\_t count, loff\_t  \* offset)  
\{  
 // int ii;   
  int  ret;  
 char \*  kbuf;  
unsigned  long  flags;  
 int  r\_press;  
  
ICDEBUG(KERN\_ALERT  " enter ic\_card\_read\\n " );  
  
spin\_lock\_irqsave( & lock ,flags);  
r\_press = ((ic\_card\_dev \* )filep \-> private\_data) \-> r\_press;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
ICDEBUG(KERN\_ALERT  " ic\_card\_read:r\_press is:%d\\n " ,r\_press);  
  
wait\_event\_interruptible(r\_wait, r\_press != 0 );  
  
  
kbuf = kmalloc(count,GFP\_KERNEL);  
 if ( ! kbuf)  
\{  
 return  \- ENOMEM;  
\}  
spin\_lock\_irqsave( & lock ,flags);  
((ic\_card\_dev \* )filep \-> private\_data) \-> w\_press = 0 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
ic\_card\_reset();  
  
ic\_card\_send\_cmd(( const  char )IC\_RMM\_CMD,( const  char )((ic\_card\_dev \* )(filep \-> private\_data)) \-> readbufstart, 0xff );  
  
ret  =  ic\_dev\_read(filep, kbuf, count, offset);  
  
ICDEBUG(KERN\_ALERT  " \[ic\_card\_read kbuf is:%s\]\\n " ,kbuf);  
 if (ret >= 0 )  
\{  
ret  =  copy\_to\_user(buf,kbuf,count);  
\}  
  
ICDEBUG(KERN\_ALERT  " <ic\_dev\_read kbuf:(%s),buf:(%s)ret:%d;count:%d>\\n " ,kbuf,buf,ret,count);  
ic\_card\_breakoperator();  
  
spin\_lock\_irqsave( & lock ,flags);  
((ic\_card\_dev \* )filep \-> private\_data) \-> w\_press = 1 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
kfree(kbuf);  
 return  ret;  
\}  
  
 /\* file\_operations write \*/   
ssize\_t ic\_card\_wrtie( struct  file  \* filep,  char  \_\_user  \* buf, size\_t count, loff\_t  \* offset)  
\{  
 int  ret;  
 char \*  kbuf;  
unsigned  long  flags;  
 int  w\_press;  
  
ICDEBUG(KERN\_ALERT  " enter ic\_card\_wrtie\\n " );  
  
spin\_lock\_irqsave( & lock ,flags);  
w\_press = ((ic\_card\_dev \* )filep \-> private\_data) \-> w\_press;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
kbuf = kmalloc(count,GFP\_KERNEL);  
 if ( ! kbuf)  
\{  
 return  \- ENOMEM;  
\}  
wait\_event\_interruptible(r\_wait, w\_press != 0 );  
  
 // if(w\_press)  
 // \{    
 spin\_lock\_irqsave( & lock ,flags);  
((ic\_card\_dev \* )filep \-> private\_data) \-> r\_press = 0 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
ic\_card\_reset();  
ic\_card\_send\_cmd(( const  char )IC\_WMM\_CMD,( const  char )((ic\_card\_dev \* )(filep \-> private\_data)) \-> writebufstart,count);  
  
 if (copy\_from\_user(kbuf, buf, count))  
\{  
kfree(kbuf);  
 return  \- EFAULT;  
\}  
ICDEBUG(KERN\_ALERT  " copy\_from\_user kbuf------------->:%s\\n " ,kbuf);  
  
ret  =  ic\_dev\_wrtie(filep, kbuf, count, offset);  
printk(KERN\_ALERT  " ic\_dev\_wrtie ret : %d\\n " ,ret);  
ic\_card\_breakoperator();  
  
spin\_lock\_irqsave( & lock ,flags);  
((ic\_card\_dev \* )filep \-> private\_data) \-> w\_press = 1 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
  
kfree(kbuf);  
ICDEBUG(KERN\_ALERT  " ic\_card\_wrtie success\\n " );  
 return  ret;  
\}  
  
  
 int  ic\_ioctl( struct  inode  \* inode,  struct  file  \* filep, unsigned  int  cmd, unsigned  long  arg)  
\{  
unsigned  int  icount;  
unsigned  long  flags;  
spin\_lock\_irqsave( & lock ,flags);  
 switch (cmd)  
\{  
 case  CFG\_RD\_COUNT:  
icount  =  (unsigned  int )arg;  
((ic\_card\_dev \* )filep \-> private\_data) \-> readcount = icount;  
 break ;  
 case  CFG\_WR\_COUNT:  
icount = (unsigned  int )arg;  
((ic\_card\_dev \* )filep \-> private\_data) \-> writecount = icount;  
 break ;  
 default :  
 break ;  
  
\}  
spin\_unlock\_irqrestore( & lock ,flags);  
 return  0 ;  
\}  
  
 /\*   
\#define POLLIN 0x0001 //有数据可以读入,read不会阻塞,注意:select的请情况下,即使到EOF也是ready的.  
\#define POLLPRI 0x0002 //紧急数据,比如TCP,或者packet模式的peseudo-terminal发现slave的状态有变化.  
\#define POLLOUT 0x0004 //写入不会阻塞.  
\#define POLLERR 0x0008 //输出出错  
\#define POLLHUP 0x0010 //Hang up (output only).  
\#define POLLNVAL 0x0020 //Invalid request: fd not open (output only).  
The rest seem to be more-or-less nonstandard. Check them!  
\#define POLLRDNORM 0x0040 //POLLIN.  
\#define POLLRDBAND 0x0080 //高优先级的数据read for read (generally unused on Linux).  
\#define POLLWRNORM 0x0100 //Equivalent to POLLOUT.  
\#define POLLWRBAND 0x0200 //Priority data may be written.  
\#define POLLMSG 0x0400  
\#define POLLREMOVE 0x1000  
 \*/   
unsigned  int  ic\_poll ( struct  file  \* filep,  struct  poll\_table\_struct  \* wait)  
\{  
  
 int  ic\_num = 0 ; // test   
 unsigned  int  mask  =  0 ;  
unsigned  long  flags;  
  
 // 加入这句话是为了在读写状态发生变化的时候，通知核心层，让核心层重新调用poll函数查询信息。

也就是说这两句只会在select阻塞的时候用到  
 // 当利用select函数发现既不能读又不能写时，select函数会阻塞，但是此时的阻塞并不是轮询，

而是睡眠，通过下面两个队列发生变化时通知select   
 poll\_wait(filep,  & r\_wait, wait);  
poll\_wait(filep,  & w\_wait, wait);  
  
spin\_lock\_irqsave( & lock ,flags);  
 if (ic\_dev\_info\[ic\_num\].r\_press  !=  0 )  
mask  |=  POLLIN  |  POLLRDNORM;  // 可读，同时写上POLLRDNORM   
   
 if (ic\_dev\_info\[ic\_num\].w\_press  != 0 )  
mask  |=  POLLOUT  |  POLLWRNORM;  
spin\_unlock\_irqrestore( & lock ,flags);  
 return  mask;  
  
\}

// \#define ICDEBUG   
 \#ifdef ICDEBUG  
\#ifdef \_\_KERNEL\_\_  
 \#define  ICDEBUG(fmt,args...) printk(KERN\_ALERT "ic card:"fmt,\#\#args)   
 \#else   
 \#define  ICDEBUG(fmt,args...) fprintf(stderr,fmt,\#\#args)   
 \#endif   
 \#else   
 \#define  ICDEBUG(fmt,args...)   
 \#endif   
  
 \#define  DEV\_NAME "ic\_card"   
 \#define  IC\_TIMER\_DELAY (HZ/50)   
 \#define  ICCARD\_INT\_NAME "ic\_irq\_handler"   
  
 static  int  ic\_major = IC\_CARD\_MAJOR;  
  
 static  struct  class \*  ic\_card\_class;  
 /\* linux 内核定时器  
struct timer\_list \{  
struct list\_head list;  
unsigned long expires;  
unsigned long data;  
void (\*function)(unsigned long);  
\};  
 \*/   
 static  struct  timer\_list ic\_timer;  
  
 /\* 自旋锁基本API:  
  
头文件: <linux/spinlock.h>  
数据类型: spinlock\_t  
初始化, 以下两种方法:  
静态: spinlock\_t my\_lock = SPIN\_LOCK\_UNLOCKED;  
动态: void spin\_lock\_init(spinlock\_t \*lock);  
获得锁: void spin\_lock(spinlock\_t \*lock);  
释放锁: void spin\_unlock(spinlock\_t \*lock);  
 \*/   
spinlock\_t  lock ;  
  
 /\*   
内核中每个字符设备都对应一个 cdev 结构的变量，下面是它的定义：  
struct cdev \{  
struct kobject kobj; // 每个 cdev 都是一个 kobject  
struct module \*owner; // 指向实现驱动的模块  
const struct file\_operations \*ops; // 操纵这个字符设备文件的方法  
struct list\_head list; // 与 cdev 对应的字符设备文件的 inode->i\_devices 的链表头  
dev\_t dev; // 起始设备编号  
unsigned int count; // 设备范围号大小  
\};  
一个 cdev 一般它有两种定义初始化方式：静态的和动态的。  
静态内存定义初始化：  
struct cdev my\_cdev;  
cdev\_init(&my\_cdev, &fops);  
my\_cdev.owner = THIS\_MODULE;  
  
动态内存定义初始化：  
struct cdev \*my\_cdev = cdev\_alloc();  
my\_cdev->ops = &fops;  
my\_cdev->owner = THIS\_MODULE;  
  
两种使用方式的功能是一样的，只是使用的内存区不一样，一般视实际的数据结构需求而定。 \*/   
 struct  cdev cdev\_ic;  
  
 /\* IC\_CARD设备结构体 \*/   
 static  ic\_card\_dev ic\_dev\_info\[ICCARD\_NR\_DEVS\] =   
\{  
\{  
IC\_RDSTART\_ADDR,  /\* readbufstart \*/   
IC\_WRSTART\_ADDR,  /\* writebufstart \*/   
 0 ,  /\* readcount \*/   
 0 ,  /\* writecount \*/   
NULL,  /\* readp \*/   
 0 ,  /\* readnum \*/   
NULL,  /\* writep \*/   
 0 ,  /\* writenum \*/   
  
 0 ,  /\* ic\_state \*/   
 0 ,  /\* statechange \*/   
IRQ\_EINT14,  /\* irqno \*/   
 0 ,  /\* r\_press \*/   
 0 ,  /\* w\_press \*/   
\},  
\};  
  
 /\* 将输入引脚配置成中断引脚 \*/   
 static  void  pin\_input\_to\_int( void )  
\{  
\_\_raw\_writel((\_\_raw\_readl(S3C2410\_GPGCON)  &  ( ~ ( 0x03 << 12 )))  |  ( 0x02 << 12 ),S3C2410\_GPGCON);  
\_\_raw\_writel((\_\_raw\_readl(S3C2410\_EXTINT1)  &  ( ~ ( 0x07 << 24 )))  | ( 0x06 << 24 ),S3C2410\_EXTINT1);  
\}  
  
 /\* 将中断引脚配置成输入引脚 \*/   
 static  void  pin\_int\_to\_input( void )  
\{  
\_\_raw\_writel(\_\_raw\_readl(S3C2410\_GPGCON) & ( ~ ( 0x03 << 12 )),S3C2410\_GPGCON);  
\}  
  
 /\* \*中断服务程序，通知ic卡已插入 \*/   
 static  irqreturn\_t ic\_interrupt\_proc( int  irq, void  \* dev\_id)  
\{  
unsigned  long  flags;  
spin\_lock\_irqsave( & lock ,flags);  
 if (ic\_dev\_info\[ 0 \].statechange == 0 )  
\{  
ic\_dev\_info\[ 0 \].statechange = 1 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
\}  
 else   
\{  
spin\_unlock\_irqrestore( & lock ,flags);  
 return  IRQ\_HANDLED;  
\}  
ICDEBUG(KERN\_ALERT  " \+++++++++++++++++++++++++++++++\\n " );  
 /\* 将中断引脚配置成为输入引脚，消除抖动 \*/   
pin\_int\_to\_input();  
  
ic\_timer.expires  =  jiffies  \+  IC\_TIMER\_DELAY;  // delay 20 ms

// 全局变量jiffies用来记录自系统启动以来产生的节拍的总数   
 add\_timer( & ic\_timer);  
  
 return  IRQ\_HANDLED;  
\}  
  
 /\* 定时器回调函数，当设定时间到来时，自动调用本程序 \*/   
 static  void  ic\_timer\_handler(unsigned  long  time)  
\{  
 int  ic\_num = 0 ; // test   
 unsigned  long  flags;  
  
ICDEBUG(KERN\_ALERT  " enter ic\_interrupt\_proc\\n " );  
spin\_lock\_irqsave( & lock ,flags);  
 if (ic\_dev\_info\[ic\_num\].ic\_state == 0 )  
\{  
ic\_dev\_info\[ic\_num\].ic\_state = 1 ;  // 代表卡已插入   
 ic\_dev\_info\[ic\_num\].r\_press = 1 ;  // 设备可读   
 ic\_dev\_info\[ic\_num\].w\_press = 1 ;  // 设备可写   
 wake\_up\_interruptible( & r\_wait);  
wake\_up\_interruptible( & w\_wait);  
ICDEBUG(KERN\_ALERT  " ic device enter,wake up interrupt ic\_interrupt\_proc\\n " );  
\}  
 else   
\{  
ic\_dev\_info\[ic\_num\].ic\_state = 0 ;  // 代表卡已拔出   
 ic\_dev\_info\[ic\_num\].r\_press = 0 ;  // 设备不可读   
 ic\_dev\_info\[ic\_num\].w\_press = 0 ;  // 设备不可写   
 ICDEBUG(KERN\_ALERT  " ic device leave,wake up interrupt ic\_interrupt\_proc\\n " );  
\}  
  
del\_timer( & ic\_timer);  
 /\* 重新配置中断引脚 \*/   
pin\_input\_to\_int();  
  
ic\_dev\_info\[ 0 \].statechange = 0 ;  
spin\_unlock\_irqrestore( & lock ,flags);  
\}  
  
  
 /\* ic卡插入时和拔出时（下降沿/上升沿）产生的中断处理程序的注册 \*/   
 static  int  ic\_request\_irqs( void )  
\{  
 int  ret,i;  
 for (i = 0 ;i < ICCARD\_NR\_DEVS;i \++ )  
\{  
ret  =  request\_irq(ic\_dev\_info\[i\].irqno,ic\_interrupt\_proc,IRQ\_TYPE\_EDGE\_BOTH,DEV\_NAME,NULL);  
ICDEBUG(KERN\_ALERT  " interrupt:number:%d\\n " ,ic\_dev\_info\[i\].irqno);  
\}  
 return  ret;  
\}  
  
 static  void  ic\_free\_irqs( void )

[Link 1]: http://www.cnblogs.cc2/view/8153.htm
[Link 2]: http://www.cnblogs.cc2/view/724169.htm
[http_www.360doc.com_content_11_0228_12_6030028_96836815.shtml]: http://www.360doc.com/content/11/0228/12/6030028_96836815.shtml