pcd-fio.c

   1
   2 #include "common.h"
   3 #include "picc.h"
   4
   5 struct pcd_param
   6 {
   7     uint8_t *p_iBuf;
   8     uint8_t *p_oBuf;
   9     uint32_t  iDataLen;
  10     uint32_t  oDataLen;
  11     uint32_t statusCode;
  12 };
  13
  14 #define  Card_PowerOn     0x01
  15 #define  Card_PowerOff    0x02
  16 #define  Card_XfrAPDU     0x03
  17
  18
  19 void run_picc_poll(struct work_struct *work);
  20 DECLARE_DELAYED_WORK(card_Poll, run_picc_poll);
  21
  22
  23 struct pcd_common
  24 {
  25         struct pcd_device               pcd;
  26         struct picc_device              picc;
  27
  28         OS_Sem_handle   mutex;
  29         uint8_t sem_inc;
  30         struct workqueue_struct         *polling;
  31
  32         int             (*slot_changed_notify)(void *, uint8_t);
  33         void            *private_data;
  34
  35 };
  36
  37 struct pcd_common  *common = NULL;
  38
  39 #include "picc.c"
  40 #include "ccid_picc.c"
  41
  42
  43 static long pcd_ioctl(struct file *filp, u32 cmd, unsigned long arg)
  44 {
  45         struct pcd_common *common = filp->private_data;
  46     u8 pcd_cmd = (cmd >> 4) & 0xFF;
  47     struct pcd_param KerParam;
  48     struct pcd_param *UsrParam = (struct pcd_param *)arg;
  49     u8 *p_iData;
  50     u8 *p_oData;
  51     u32  ret = 0;
  52     u8 level = 0;
  53
  54
  55     if(down_interruptible(&common->mutex))    // acquire the semaphore
  56     {
  57         ret = -ERESTARTSYS;
  58         goto err;
  59     }
  60
  61     if((!UsrParam) || (copy_from_user(&KerParam, UsrParam, sizeof(KerParam))))
  62     {
  63         ret = -EFAULT;          // bad address
  64         goto err;
  65     }
  66
  67     switch(pcd_cmd)
  68     {
  69         case Card_PowerOn:
  70         {
  71             if(!KerParam.p_oBuf)
  72                         {
  73                 ret = -EFAULT;       // bad address
  74                 goto err;
  75             }
  76
  77             p_oData = kmalloc(KerParam.oDataLen, GFP_KERNEL);
  78
  79             if(!p_oData)
  80                         {
  81                 ret = -EFAULT;       // bad address
  82                 goto err;
  83             }
  84
  85                         if((ret = picc_power_on(&common->picc, p_oData, &KerParam.oDataLen)) != 0)
  86                                 goto err2;
  87
  88                         if(copy_to_user(KerParam.p_oBuf, p_oData, KerParam.oDataLen))
  89                         {
  90                 ret = -EFAULT;       // bad address
  91                 goto err2;
  92             }
  93
  94                         if(copy_to_user(&UsrParam->oDataLen, &KerParam.oDataLen, sizeof(KerParam.oDataLen)))
  95                         {
  96                 ret = -EFAULT;       // bad address
  97                 goto err2;
  98             }
  99
 100                         kfree(p_oData);
 101
 102             break;
 103         }
 104
 105         case Card_PowerOff:
 106         {
 107             picc_power_off(&common->picc);
 108                         ret = 0;
 109             break;
 110         }
 111
 112         case Card_XfrAPDU:
 113         {
 114             if((KerParam.iDataLen <= 0) || (KerParam.oDataLen <= 0) || (!KerParam.p_iBuf) || (!KerParam.p_oBuf))
 115                         {
 116                 ret = -EFAULT;       // bad address
 117                 goto err;
 118             }
 119
 120             p_iData = kmalloc(KerParam.iDataLen, GFP_KERNEL);
 121             p_oData = kmalloc(KerParam.oDataLen, GFP_KERNEL);
 122
 123             if((!p_iData) || (!p_oData) || (copy_from_user(p_iData, KerParam.p_iBuf, KerParam.iDataLen)))
 124             {
 125                 ret = -EFAULT;       // bad address
 126                 goto err1;
 127             }
 128
 129             if((ret = picc_command_exchange(&common->picc, p_iData, KerParam.iDataLen, p_oData, &KerParam.oDataLen, &level)) != 0)
 130                                 goto err;
 131
 132             if((KerParam.oDataLen <= 0) || (copy_to_user(KerParam.p_oBuf, p_oData, (unsigned long)KerParam.oDataLen)))
 133             {
 134                 ret = -EFAULT;       // bad address
 135                 goto err1;
 136             }
 137
 138             if(copy_to_user(&UsrParam->oDataLen, &KerParam.oDataLen, sizeof(KerParam.oDataLen)))
 139             {
 140                 ret = -EFAULT;       // bad address
 141                 goto err1;
 142             }
 143
 144                         kfree(p_iData);
 145                         kfree(p_oData);
 146
 147             break;
 148         }
 149
 150         default:
 151             break;
 152     }
 153
 154         up(&common->mutex);
 155         return(0);
 156
 157
 158 err1:
 159         if(p_iData)             kfree(p_iData);
 160 err2:
 161         if(p_oData)             kfree(p_oData);
 162 err:
 163     up(&common->mutex);                    // release the semaphore
 164     UsrParam->statusCode = ret;
 165     return(ret);
 166 }
 167
 168
 169 static int pcd_open(struct inode *inode, struct file *filp)
 170 {
 171     if(common->sem_inc > 0)    return(-ERESTARTSYS);
 172     common->sem_inc++;
 173
 174     filp->private_data = common;
 175
 176     return(0);
 177 }
 178 static int pcd_release(struct inode *inode, struct file *filp)
 179 {
 180         struct pcd_common *common = filp->private_data;
 181
 182
 183         common->sem_inc--;
 184
 185     return(0);
 186 }
 187
 188 extern int picc_interrput_in(u8 slot_status);
 189
 190 void run_picc_poll(struct work_struct *work)
 191 {
 192
 193
 194     if(down_trylock(&common->mutex))
 195     {
 196         goto done;
 197     }
 198
 199     if(BITISSET(common->pcd.flags_polling, AUTO_POLLING) && BITISSET(common->pcd.flags_polling, POLLING_CARD_ENABLE))
 200     {
 201         picc_polling_tags(&common->picc);
 202
 203                 if(BITISSET(common->picc.status, SLOT_CHANGE))
 204                 {
 205                         if(!picc_interrput_in(common->picc.status & PRESENT))
 206                                 CLEAR_BIT(common->picc.status, SLOT_CHANGE);
 207                 }
 208     }
 209
 210
 211
 212     up(&common->mutex);
 213
 214 done:
 215
 216         queue_delayed_work(common->polling, &card_Poll, (common->pcd.poll_interval * HZ) / 1000);
 217
 218
 219 }
 220
 221
 222 static struct file_operations pcd_fops=
 223 {
 224     .owner = THIS_MODULE,
 225     .open = pcd_open,
 226     .unlocked_ioctl = pcd_ioctl,
 227     .release = pcd_release
 228 };
 229
 230 static struct miscdevice pcd_misc=
 231 {
 232     .minor = 221,
 233     .name = "pcd",
 234     .fops = &pcd_fops
 235 };
 236
 237 static int pcd_init(void)
 238 {
 239         int ret;
 240
 241
 242     TRACE_TO("enter %s\n", __func__);
 243
 244         common = kzalloc(sizeof *common, GFP_KERNEL);
 245         if (!common)
 246         {
 247                 ret = -ENOMEM;
 248                 goto err1;
 249         }
 250
 251     sema_init(&common->mutex, 0);    // initial a semaphore, and lock it
 252
 253         ret = picc_init(common);
 254         if(ret)
 255                 goto err2;
 256
 257         ret = misc_register(&pcd_misc);
 258     if(ret)
 259     {
 260         ERROR_TO("fail to register device\n");
 261         goto err3;
 262     }
 263
 264     common->polling = create_singlethread_workqueue("polling picc");
 265     if(!common->polling)
 266     {
 267         ERROR_TO("can't create work queue 'pcdPoll'\n");
 268                 ret = -EFAULT;
 269         goto err4;
 270     }
 271     run_picc_poll(0);
 272
 273     up(&common->mutex);
 274
 275     TRACE_TO("exit %s\n", __func__);
 276
 277     return (0);
 278
 279 err4:
 280     misc_deregister(&pcd_misc);
 281 err3:
 282         picc_uninit();
 283 err2:
 284     up(&common->mutex);
 285         kfree(common);
 286 err1:
 287
 288         TRACE_TO("exit %s\n", __func__);
 289     return ret;
 290 }
 291
 292 static void pcd_exit(void)
 293 {
 294         TRACE_TO("enter %s\n", __func__);
 295
 296     if (down_interruptible(&common->mutex))
 297     {
 298         return;
 299     }
 300
 301     if(!cancel_delayed_work(&card_Poll))
 302     {
 303         flush_workqueue(common->polling);
 304     }
 305     destroy_workqueue(common->polling);
 306
 307     picc_uninit();
 308
 309     misc_deregister(&pcd_misc);
 310
 311     up(&common->mutex);
 312
 313         kfree(common);
 314
 315         TRACE_TO("exit %s\n", __func__);
 316
 317     return;
 318 }
 319
 320 module_init(pcd_init);
 321 module_exit(pcd_exit);
 322 MODULE_DESCRIPTION("Contactless Card Driver");
 323 MODULE_AUTHOR("Alex Wang");
 324 MODULE_LICENSE("GPL");
 325
 326