Changeset 1220


Ignore:
Timestamp:
01/14/10 12:09:19 (12 years ago)
Author:
dingo35
Message:

Move Device_Init and GetStatus functions to ICC_Async, and adding GetStatus to ifd_phoenix.c

Location:
trunk
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/csctapi/Makefile

    r1205 r1220  
    1616            $(LIBFILE1)(ifd_cool.o) \
    1717          $(LIBFILE1)(ifd_sci.o) \
     18          $(LIBFILE1)(ifd_phoenix.o) \
    1819          $(LIBFILE1)(io_serial.o) \
    1920          $(LIBFILE1)(pps.o) \
  • trunk/csctapi/cardterminal.c

    r1208 r1220  
    8484   
    8585    /* Initialise serial port */
    86     if (!IO_Serial_Init (ct->io, reader_type))
     86    if (ICC_Async_Device_Init ()) {
     87        printf("ERROR in initializing device\n");
     88        return ERR_TRANS;
     89    }
     90    if (!IO_Serial_Init(ct->io, reader_type))
    8791    {
    8892        free (ct->io);
  • trunk/csctapi/ct_slot.c

    r1137 r1220  
    9292   
    9393    /* Do first time check */
    94     if (IFD_Towitoko_GetStatus (slot->ifd, &status) != IFD_TOWITOKO_OK)
     94    if (ICC_Async_GetStatus (&status) != ICC_ASYNC_OK)
    9595    {
    9696        return ERR_TRANS;
     
    110110#endif
    111111       
    112         if (IFD_Towitoko_GetStatus (slot->ifd, &status) != IFD_TOWITOKO_OK)
     112        if (ICC_Async_GetStatus (&status) != ICC_ASYNC_OK)
    113113            return ERR_TRANS;
    114114       
  • trunk/csctapi/icc_async.c

    r1219 r1220  
    4444static void ICC_Async_Clear (ICC_Async * icc);
    4545
     46
    4647/*
    4748 * Exported functions definition
     
    5455    /* Allocate memory */
    5556    icc = (ICC_Async *) malloc (sizeof (ICC_Async));
     57printf("NEW ICC: reader_type = %i, cardmhz = %i\n",reader[ridx].typ, reader[ridx].cardmhz);
    5658   
    5759    if (icc != NULL)
     
    6163}
    6264
     65int ICC_Async_Device_Init ()
     66{
     67   
     68#ifdef DEBUG_IO
     69    printf ("IO: Opening serial port %s\n", reader[ridx].device);
     70#endif
     71   
     72#if defined(SCI_DEV) || defined(COOL)
     73    if (reader_type==R_INTERNAL)
     74#ifdef SH4
     75        reader[ridx].handle = open (reader[ridx].device, O_RDWR|O_NONBLOCK|O_NOCTTY);
     76#elif COOL
     77        return Cool_Init();
     78#else
     79        reader[ridx].handle = open (reader[ridx].device, O_RDWR);
     80#endif
     81    else
     82#endif
     83
     84    reader[ridx].handle = open (reader[ridx].device,  O_RDWR | O_NOCTTY| O_NONBLOCK);
     85
     86    if (reader[ridx].handle < 0)
     87        return ICC_ASYNC_IFD_ERROR;
     88
     89#if defined(TUXBOX) && defined(PPC)
     90    if ((reader_type == R_DB2COM1) || (reader_type == R_DB2COM2))
     91        if ((fdmc = open(DEV_MULTICAM, O_RDWR)) < 0)
     92        {
     93            close(reader[ridx].handle);
     94            return ICC_ASYNC_IFD_ERROR;
     95        }
     96#endif
     97       
     98    return ICC_ASYNC_OK;
     99}
     100
     101int ICC_Async_GetStatus (BYTE * result)
     102{
     103    BYTE status[2];
     104//  unsigned int modembits=0;
     105    int in;
     106   
     107//  printf("\n%08X\n", (int)ifd->io);
     108   
     109// status : 0 -start, 1 - card, 2- no card
     110
     111#ifdef SCI_DEV
     112    if(reader[ridx].typ==R_INTERNAL)
     113    {
     114        if(!Sci_GetStatus(reader[ridx].handle, &in))
     115            return IFD_TOWITOKO_IO_ERROR;           
     116    }
     117    else
     118#elif COOL
     119    if(reader[ridx].typ==R_INTERNAL)
     120    {   
     121        if (!Cool_GetStatus(&in))
     122            return IFD_TOWITOKO_IO_ERROR;
     123    }
     124    else
     125#endif
     126
     127#if defined(TUXBOX) && defined(PPC)
     128    if ((reader[ridx].typ==R_DB2COM1) || (ifd->reader[ridx].typ==R_DB2COM2))
     129    {
     130        ushort msr=1;
     131        extern int fdmc;
     132        IO_Serial_Ioctl_Lock(ifd->io, 1);
     133        ioctl(fdmc, GET_PCDAT, &msr);
     134        if (reader[ridx].typ==R_DB2COM2)
     135            in=(!(msr & 1));
     136        else
     137            in=((msr & 0x0f00) == 0x0f00);
     138        IO_Serial_Ioctl_Lock(ifd->io, 0);
     139    }
     140    else
     141#endif
     142#ifdef USE_GPIO
     143    if (gpio_detect)
     144        in=get_gpio();
     145    else
     146#endif
     147  if (!Phoenix_GetStatus(&in))
     148            return IFD_TOWITOKO_IO_ERROR;
     149
     150    if (in)
     151    {       
     152        if(reader[ridx].status == 0)
     153        {
     154            status[0] = IFD_TOWITOKO_CARD_CHANGE;
     155            reader[ridx].status = 1;
     156#ifdef USE_GPIO
     157            if (gpio_detect) set_gpio1(0);
     158#endif
     159        }
     160        else if(reader[ridx].status == 1)
     161        {
     162            status[0] = IFD_TOWITOKO_CARD_NOCHANGE;
     163        }
     164        else
     165        {
     166            status[0] = IFD_TOWITOKO_CARD_CHANGE;
     167            reader[ridx].status = 1;
     168#ifdef USE_GPIO
     169            if (gpio_detect) set_gpio1(0);
     170#endif
     171        }
     172    }
     173    else
     174    {
     175        if(reader[ridx].status == 0)
     176        {
     177            status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
     178            reader[ridx].status = 2;
     179#ifdef USE_GPIO
     180            if (gpio_detect) set_gpio1(1);
     181#endif
     182        }
     183        else if(reader[ridx].status == 1)
     184        {
     185            status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
     186            reader[ridx].status = 2;
     187#ifdef USE_GPIO
     188            if (gpio_detect) set_gpio1(1);
     189#endif
     190        }
     191        else
     192        {
     193            status[0] = IFD_TOWITOKO_NOCARD_NOCHANGE;
     194        }
     195    }
     196   
     197       
     198    (*result) = status[0];
     199   
     200#ifdef DEBUG_IFD
     201    printf ("IFD: com%d Status = %s / %s\n", reader[ridx].typ, IFD_TOWITOKO_CARD(status[0])? "card": "no card", IFD_TOWITOKO_CHANGE(status[0])? "change": "no change");
     202#endif
     203   
     204    return IFD_TOWITOKO_OK;
     205}
     206
    63207int ICC_Async_Init (ICC_Async * icc, IFD * ifd)
    64208{
     
    79223    /* Reset ICC */
    80224#ifdef SCI_DEV
    81     if (ifd->io->reader_type == R_INTERNAL) {
     225    if (ifd->reader[ridx].typ == R_INTERNAL) {
    82226        if (!Sci_Reset(ifd, &(icc->atr)))
    83227        {
     
    89233#endif
    90234#ifdef COOL
    91     if (ifd->io->reader_type == R_INTERNAL) {
     235    if (ifd->reader[ridx].typ == R_INTERNAL) {
    92236        if (!Cool_Reset(&(icc->atr)))
    93237        {
     
    158302    }
    159303#ifdef COOL
    160     if (icc->ifd->io->reader_type != R_INTERNAL)
     304    if (icc->ifd->reader[ridx].typ != R_INTERNAL)
    161305#endif
    162306    IO_Serial_Flush(ifd->io);
     
    182326#include "sci_global.h"
    183327#include "sci_ioctl.h"
    184     if (icc->ifd->io->reader_type == R_INTERNAL) {
     328    if (icc->ifd->reader[ridx].typ == R_INTERNAL) {
    185329        SCI_PARAMETERS params;
    186         if (ioctl(icc->ifd->io->fd, IOCTL_GET_PARAMETERS, &params) < 0 )
     330        if (ioctl(icc->reader[ridx].handle, IOCTL_GET_PARAMETERS, &params) < 0 )
    187331            return ICC_ASYNC_IFD_ERROR;
    188332        switch (icc->protocol_type) {
     
    198342                break;
    199343        }
    200         if (ioctl(icc->ifd->io->fd, IOCTL_SET_PARAMETERS, &params)!=0)
     344        if (ioctl(icc->reader[ridx].handle, IOCTL_SET_PARAMETERS, &params)!=0)
    201345            return ICC_ASYNC_IFD_ERROR;
    202346           
     
    220364{
    221365    icc->baudrate = baudrate;
    222 /*#ifdef COOL
    223     if (icc->ifd->io->reader_type==R_INTERNAL) {
    224     typedef unsigned long u_int32;
    225     u_int32 clk;
    226     //clk = 357*10000; // MHZ
    227         //clk = baudrate * 3570000L / 9600L;
    228           clk = 500*10000;
    229     if (cnxt_smc_set_clock_freq(icc->ifd->io->handle, clk))
    230             return ICC_ASYNC_IFD_ERROR;
    231         printf("set clock to %lu Hz\n", clk);
    232         return ICC_ASYNC_OK;
    233     }
    234     else
    235 #endif*/
    236366    if (IFD_Towitoko_SetBaudrate (icc->ifd, baudrate) !=  IFD_TOWITOKO_OK)
    237367      return ICC_ASYNC_IFD_ERROR;
     
    251381    IFD_Timings timings;
    252382   
    253     if (icc->convention == ATR_CONVENTION_INVERSE && icc->ifd->io->reader_type != R_INTERNAL)
     383    if (icc->convention == ATR_CONVENTION_INVERSE && reader[ridx].typ != R_INTERNAL)
    254384    {
    255385        buffer = (BYTE *) calloc(sizeof (BYTE), size);
     
    267397   
    268398#ifdef COOL
    269     if (icc->ifd->io->reader_type == R_INTERNAL) {
     399    if (reader[ridx].typ == R_INTERNAL) {
    270400        if (!Cool_Transmit(sent, size))
    271401            return ICC_ASYNC_IFD_ERROR;
     
    290420   
    291421#ifdef COOL
    292     if (icc->ifd->io->reader_type == R_INTERNAL) {
     422    if (reader[ridx].typ == R_INTERNAL) {
    293423        if (!Cool_Receive(data, size))
    294424            return ICC_ASYNC_IFD_ERROR;
     
    300430#endif
    301431   
    302     if (icc->convention == ATR_CONVENTION_INVERSE && icc->ifd->io->reader_type!=R_INTERNAL)
     432    if (icc->convention == ATR_CONVENTION_INVERSE && reader[ridx].typ!=R_INTERNAL)
    303433        ICC_Async_InvertBuffer (size, data);
    304434   
     
    336466unsigned long ICC_Async_GetClockRate (ICC_Async * icc)
    337467{
    338     switch (icc->ifd->io->cardmhz) {
     468    switch (reader[ridx].cardmhz) {
    339469        case 357:
    340470        case 358:
     
    343473        return (384L * 9600L);
    344474        default:
    345         return icc->ifd->io->cardmhz * 10000L;
     475        return reader[ridx].cardmhz * 10000L;
    346476    }
    347477}
  • trunk/csctapi/icc_async.h

    r1219 r1220  
    2727
    2828#include "defines.h"
    29 #include "ifd_towitoko.h"
     29#include "ifd_towitoko.h" //FIXME
    3030#include "atr.h"
    3131
  • trunk/csctapi/ifd_towitoko.c

    r1219 r1220  
    343343int IFD_Towitoko_SetLED ()
    344344{   
    345     return IFD_TOWITOKO_OK;
    346 }
    347 
    348 int IFD_Towitoko_GetStatus (IFD * ifd, BYTE * result)
    349 {
    350     BYTE status[2];
    351     unsigned int modembits=0;
    352     int in;
    353    
    354 //  printf("\n%08X\n", (int)ifd->io);
    355    
    356 // status : 0 -start, 1 - card, 2- no card
    357 
    358 #ifdef SCI_DEV
    359     if(ifd->io->reader_type==R_INTERNAL)
    360     {
    361         if(!Sci_GetStatus(ifd->io->fd, &in))
    362             return IFD_TOWITOKO_IO_ERROR;           
    363     }
    364     else
    365 #elif COOL
    366     if(ifd->io->reader_type==R_INTERNAL)
    367     {   
    368         if (!Cool_GetStatus(&in))
    369             return IFD_TOWITOKO_IO_ERROR;
    370     }
    371     else
    372 #endif
    373 
    374 #if defined(TUXBOX) && defined(PPC)
    375     if ((ifd->io->reader_type==R_DB2COM1) || (ifd->io->reader_type==R_DB2COM2))
    376     {
    377         ushort msr=1;
    378         extern int fdmc;
    379         IO_Serial_Ioctl_Lock(ifd->io, 1);
    380         ioctl(fdmc, GET_PCDAT, &msr);
    381         if (ifd->io->reader_type==R_DB2COM2)
    382             in=(!(msr & 1));
    383         else
    384             in=((msr & 0x0f00) == 0x0f00);
    385         IO_Serial_Ioctl_Lock(ifd->io, 0);
    386     }
    387     else
    388 #endif
    389 #ifdef USE_GPIO
    390     if (gpio_detect)
    391         in=get_gpio();
    392     else
    393 #endif
    394     {
    395         extern int oscam_card_detect;
    396         if (ioctl(ifd->io->fd, TIOCMGET,&modembits)<0)
    397             return IFD_TOWITOKO_IO_ERROR;
    398         switch(oscam_card_detect&0x7f)
    399         {
    400             case  0: in=(modembits & TIOCM_CAR);    break;
    401             case  1: in=(modembits & TIOCM_DSR);    break;
    402             case  2: in=(modembits & TIOCM_CTS);    break;
    403             case  3: in=(modembits & TIOCM_RNG);    break;
    404             default: in=0;      // dummy
    405         }
    406         if (!(oscam_card_detect&0x80))
    407             in=!in;
    408     }
    409 
    410     if (in)
    411     {       
    412         if(ifd->status == 0)
    413         {
    414             status[0] = IFD_TOWITOKO_CARD_CHANGE;
    415             ifd->status = 1;
    416 #ifdef USE_GPIO
    417             if (gpio_detect) set_gpio1(0);
    418 #endif
    419         }
    420         else if(ifd->status == 1)
    421         {
    422             status[0] = IFD_TOWITOKO_CARD_NOCHANGE;
    423         }
    424         else
    425         {
    426             status[0] = IFD_TOWITOKO_CARD_CHANGE;
    427             ifd->status = 1;
    428 #ifdef USE_GPIO
    429             if (gpio_detect) set_gpio1(0);
    430 #endif
    431         }
    432     }
    433     else
    434     {
    435         if(ifd->status == 0)
    436         {
    437             status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
    438             ifd->status = 2;
    439 #ifdef USE_GPIO
    440             if (gpio_detect) set_gpio1(1);
    441 #endif
    442         }
    443         else if(ifd->status == 1)
    444         {
    445             status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
    446             ifd->status = 2;
    447 #ifdef USE_GPIO
    448             if (gpio_detect) set_gpio1(1);
    449 #endif
    450         }
    451         else
    452         {
    453             status[0] = IFD_TOWITOKO_NOCARD_NOCHANGE;
    454         }
    455     }
    456    
    457        
    458     (*result) = status[0];
    459    
    460 #ifdef DEBUG_IFD
    461     printf ("IFD: com%d Status = %s / %s\n", ifd->io->reader_type, IFD_TOWITOKO_CARD(status[0])? "card": "no card", IFD_TOWITOKO_CHANGE(status[0])? "change": "no change");
    462 #endif
    463    
    464345    return IFD_TOWITOKO_OK;
    465346}
     
    821702    ifd->type = 0x00;
    822703    ifd->firmware = 0x00;
    823     ifd->status = 0;
    824 }
     704    reader[ridx].status = 0;
     705}
  • trunk/csctapi/ifd_towitoko.h

    r1168 r1220  
    110110  BYTE type;            /* Reader type code */
    111111  BYTE firmware;        /* Reader firmware version */
    112  
    113   unsigned short status;
    114112}
    115113IFD_Towitoko;
     
    134132extern int IFD_Towitoko_SetParity (IFD * ifd, BYTE parity);
    135133extern int IFD_Towitoko_SetLED ();
    136 extern int IFD_Towitoko_GetStatus (IFD * ifd, BYTE * status);
    137134
    138135/* General handling of ICC inserted in this IFD */
  • trunk/csctapi/io_serial.c

    r1209 r1220  
    170170    io->mhz=mhz;
    171171    io->cardmhz=cardmhz;
     172printf("IO_SERIAL_NEW: cardmhz = %i\n",cardmhz);
    172173   
    173174    return io;
     
    176177bool IO_Serial_Init (IO_Serial * io, int reader_type)
    177178{
    178     char filename[IO_SERIAL_FILENAME_LENGTH];
    179    
    180     IO_Serial_DeviceName (filename, IO_SERIAL_FILENAME_LENGTH);
    181    
    182 #ifdef DEBUG_IO
    183     printf ("IO: Opening serial port %s\n", filename);
    184 #endif
    185    
     179printf("IO_SERIAL_INIT\n");
    186180    io->reader_type = reader_type;
    187 
    188 #if defined(SCI_DEV) || defined(COOL)
    189     if (reader_type==R_INTERNAL)
    190 #ifdef SH4
    191         io->fd = open (filename, O_RDWR|O_NONBLOCK|O_NOCTTY);
    192 #elif COOL
    193         return Cool_Init();
    194 #else
    195         io->fd = open (filename, O_RDWR);
    196 #endif
    197     else
    198 #endif
    199 
    200 //#ifdef OS_MACOSX
    201         // on mac os x, make sure you use the /dev/cu.XXXX device in oscam.server
    202         io->fd = open (filename,  O_RDWR | O_NOCTTY| O_NONBLOCK);
    203 //#else
    204 //              with O_SYNC set OSCam is very critical on opening a device, on certain installs
    205 //              (eg virtual Ubuntu with /dev/ttyUSB) it gives "Error activating card"
    206 //              with O_NONBLOCK this problem is solved
    207 //      io->fd = open (filename, O_RDWR | O_NOCTTY | O_SYNC);
    208 //#endif
    209 
    210     if (io->fd < 0)
    211         return FALSE;
    212 
    213 #if defined(TUXBOX) && defined(PPC)
    214     if ((reader_type == R_DB2COM1) || (reader_type == R_DB2COM2))
    215         if ((fdmc = open(DEV_MULTICAM, O_RDWR)) < 0)
    216         {
    217             close(io->fd);
    218             return FALSE;
    219         }
    220 #endif
    221    
     181    io->fd = reader[ridx].handle;
     182
    222183    if (reader_type != R_INTERNAL)
    223184        IO_Serial_InitPnP (io);
  • trunk/globals.h

    r1208 r1220  
    375375  char      label[32];
    376376  char      device[128];
     377  int       handle;   //device handle
    377378  char      pcsc_name[128];
    378379  int       pcsc_has_card;
     
    408409  int       rewritemm;
    409410  int       online;
    410   int       card_status;
     411  int       card_status; //highlevel status
     412  unsigned short status; //lowlevel status: states whether card inserted and/or change of status FIXME look at integration with pcsc_has_card/detect/card_status
    411413  struct    s_module ph;
    412414  uchar     ncd_key[16];
Note: See TracChangeset for help on using the changeset viewer.