tda8007.c

tda8007驱动

   
          if(tda_checkpresence(slot) < 0) return NO_CARD_ERR;   
          break;   
        case 3:   
          // Select appropriate smartcard and clear other card selects    
          tda_writeregister(CSR,(val & ~(CSR_SC2_MASK|CSR_SC1_MASK))|CSR_SC3_MASK);   
   
          if(tda_checkpresence(slot) < 0) return NO_CARD_ERR;   
          break;   
        default:   
          return ERR_INVALID_SLOT;   
      }    
      // Set global slot identifier value    
      currentSlot = slot - 1;      
      printk("card selected: %d\n", currentSlot);   
       
      return 0;   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static int iccard_write( unsigned char *buff, int len )      /* the buffer to fill with data */                                 
{                                                            /* the length of the buffer.    */   
    int i;   
    int ret;   
    uchar *txbuf;   
    uchar tmp;   
    txbuf = buff;   
    /*  
    printk("IC COMMAND = \n");  
    for(i = 0;i < len; i++)  
       printk("0x%x ",*(txbuf + i));  
  printk("\n");  
  */   
  delay_us(50);   
    for(i = 0;i < len; i++)   
    {   
        if (i == (len - 1))   
        {   
            tmp = *(txbuf + i);   
            if((ret = writeLastByte(tmp))< 0)return ret;;   
        }   
        else   
        {   
            tmp = *(txbuf + i);   
            if((ret = writeByte(tmp))< 0)return ret;                    
        }   
    }      
    return len;   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static int TDA_iccard_reset(    unsigned char * rec_buf,int  * rec_len,int cardname)               
{      
    int ret;   
    char mode = POWERUP_ISO;   
    if (cardname == SAMCARD)    
    {   
        cardname = card_selected;   
        card_selected = SAMCARD;   
           
        ret = tda_selectcard(card_selected);   
        if(ret < 0)return ret;   
               
        ret = tda_powerup(POWERUP_ISO, POWERUP_5V);   
        if(ret < 0) return ret;     
           
        samcard_err = tda_ATRsequence(mode, rec_buf, rec_len);   
           
        card_selected  = cardname;   
           
        if (samcard_err < 0)    
        {   
            tda_powerdown();   
            return samcard_err;   
        }   
    }   
    else if(cardname == USRCARD)   
    {   
        cardname = card_selected;   
        card_selected = USRCARD;   
           
        ret = tda_selectcard(card_selected);   
        if(ret < 0)return ret;   
           
        ret = tda_powerup(POWERUP_ISO, POWERUP_5V);   
        if(ret < 0) return ret;     
           
        usrcard_err = tda_ATRsequence(mode, rec_buf, rec_len);   
           
        card_selected  = cardname;   
        if (usrcard_err < 0)    
        {   
            tda_powerdown();   
            return  usrcard_err;   
        }   
    }   
    else return NO_CARD_ERR;   
       
    return 0;   
}   
/*----------------------------------------------------------------------------*/   
/* file_operations functions -------------------------------------------------*/   
   
   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static ssize_t TDA_iccard_write (struct file *file,   
                        char *buff,       /* the buffer to fill with data */   
            size_t len,       /* the length of the buffer.    */   
            loff_t *offset)    
{ /* Our offset in the file       */   
   
            int retval = 0;   
            //int ll;    
   
          char txbuf[TDA_ICCARD_BUF_SIZE];   
            if ((len >= sizeof(txbuf))||(len <= 0))   return -EINVAL;   
            copy_from_user( txbuf, buff, len);   
               
             
            if (card_selected == SAMCARD) {   
                tda_selectcard(card_selected);   
                if (samcard_err < 0)    
                {   
                    printk("iccard.c L1209 samcard_err = %d\n",samcard_err);   
                    return -1;   
                }   
            }   
            else if(card_selected == USRCARD){   
                tda_selectcard(card_selected);   
                 
                if(usrcard_err < 0)   
                {   
                     printk("iccard.c L1209 usrcard_err = %d\n",usrcard_err);   
                     return -1;   
                }   
            }   
            else return NO_SELECTED_CARD_ERR;      
            //printk("end write command\n");    
            //delay_cycle(40000);           
            //delay_us(50);     
            retval = TDA_iccard_comm(txbuf,len,iccardfifo.buffer,&iccardfifo.len);//2007-10-22 15:47:17//           
            if(place_err != 0)   
                printk("place_err = %d\n",place_err);   
            //printk("%d jiaoyanerr = %d\n partity = %d\n",card_selected,jiaoyanerr,partity);       
            //for(ll = 0; ll < 10; ll++)    
          //delay_cycle(20000);             
            if (card_selected == SAMCARD)    
            {   
                samcard_err = retval;   
            }   
            else if(card_selected == USRCARD)   
            {   
                usrcard_err = retval;   
            }   
            else return NO_SELECTED_CARD_ERR;      
        #ifdef DEBUG_ICCARD     
                TDA_show_card_err_msg(retval);   
        #endif      
            return retval;   
   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static ssize_t TDA_iccard_read (struct file *file,   
                        char *buff,       /* the buffer to fill with data */   
            size_t len,       /* the length of the buffer.    */   
            loff_t *offset)    
{ /* Our offset in the file       */       
    int retval = 0;   
       
    //sti();        
    if (iccardfifo.len == 0) retval=0;   
    else    
    {   
        retval = iccardfifo.len;   
        printk("iccardfifo.len = %d\n",iccardfifo.len);   
        if ( copy_to_user (buff, iccardfifo.buffer, iccardfifo.len) )   
            retval = -EFAULT;   
    }   
    //printk("iccardfifo.len = %d\n",iccardfifo.len);       
    iccardfifo.len = 0;   
           
  return retval;   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static int TDA_iccard_ioctl(struct inode *inode, struct file *file,   
            unsigned int cmd,     /* the command to the ioctl */   
            unsigned long arg)    
{  /* the parameter to it      */   
       
   int retval;   
   int count = 0;   
   uchar val;   
   switch (cmd)    
   {   
          case TDA_CARD_SELECT:   
                if      ( arg == SAMCARD ) card_selected = SAMCARD;   
                else if ( arg == USRCARD ) card_selected = USRCARD;   
                else      card_selected = NONECARD;   
            break;   
          case TDA_CARD_RESET:   
                if ( card_selected == USRCARD )   
                 if (usrcard_err == NO_CARD_ERR) return -1;                    
                   retval = TDA_iccard_reset( iccardfifo.buffer, &iccardfifo.len, card_selected );   
                   //tda_init();    
                #ifdef DEBUG_ICCARD     
                        TDA_show_card_err_msg(retval);   
                #endif    
                return retval;   
               
            break;     
          case TDA_CARD_STATUS:   
                if( card_selected == SAMCARD )    
                {   
                    if ((retval = put_user(samcard_err, (int *)arg)) < 0)   
                          return retval;   
                }   
                else if ( card_selected == USRCARD )    
                {   
                    if ((retval = put_user(usrcard_err, (int *)arg)) < 0)   
                        return retval;   
              }   
                else               return -EINVAL;   
            break;       
          case TDA_CARD_POWER_OFF:   
            tda_selectcard(card_selected);   
          tda_powerdown();   
            break;   
            case TDA_USR_CARD_ERR:   
            //  printk("usrcard_err = %d\n",usrcard_err);    
              if ((retval = put_user(usrcard_err, (int *)arg)) < 0)   
                    return retval;   
            break;    
            case TDA_SAM_CARD_ERR:   
                //printk("samcard_err = %d\n",samcard_err);    
                if ((retval = put_user(samcard_err, (int *)arg)) < 0)   
                    return retval;   
            break;   
            case 'a':   
                count = 0;   
                tda_selectcard(USRCARD);   
            tda_powerup(POWERUP_ISO, POWERUP_5V);   
                printk("Test Time!\n");   
                tda_writeregister(TOC,0x00);   
            tda_writeregister(TOR3,0x00);   
            tda_writeregister(TOR2,0x78);   
            tda_writeregister(TOR1,0x00);   
            tda_writeregister(TOC,0x61);   
            printk("Start count!\n");   
            do   
              {   
                if(++count >= 5000)   
                {   
                    printk("Time-count dont end\n");   
                    break;   
                }   
                val = tda_readregister(USR);   
              }while (!(val & USR_TOL3_MASK));   
              printk("Time-count is end\n");   
            break;   
            case 'b':   
            break;      
          default:   
                return -EINVAL;   
            break;   
   }   
    return 0;   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static int TDA_iccard_open(struct inode *inode, struct file *file)    
{   
    if(iccard_device_open) return -EBUSY;        
    MOD_INC_USE_COUNT;   
       
    /* And my own counter too */   
    iccard_device_open++;   
   
        card_selected = NONECARD;      
   
    //init buffer    
        iccardfifo.len = 0;    
       
    #ifdef DEBUG_ICCARD     
        printk("iccard open ok\n");   
    #endif     
  return 0;  /* open succeed */   
}   
/*************************************************************************  
    功能：  
    参数：  
              
    返回值：-1: error  
                 0: OK                    
**************************************************************************/   
static int TDA_iccard_release(struct inode *inode, struct file *file)    
{   
   
    tda_selectcard(USRCARD);   
    tda_powerdown();   
    tda_selectcard(SAMCARD);   
    tda_powerdown();   
    card_selected = NONECARD;   
    MOD_DEC_USE_COUNT;   
  /* And my own counter too */   
  iccard_device_open--;   
     
  GPBDAT &= ~(1<<3);//TDA8007 POWER Disable       
  return 0;   
}   
//*******************************************************    
//*******************************************************    
static struct file_operations iccard_fops = {   
    owner:          THIS_MODULE,   
    read:           TDA_iccard_read,   
    ioctl:          TDA_iccard_ioctl,   
    open:           TDA_iccard_open,   
    release:        TDA_iccard_release,   
    write:                  TDA_iccard_write,     
};   
/*************************************************************************   
    功能：   
    参数：   
               
    返回值：-1: error   
                 0: OK                     
**************************************************************************/   
int __init TDA_iccard_init(void)    
{   
  int ret = 0;     
    /* Register the misc device driver */   
  BWSCON = (BWSCON & ~( BWSCO