Changeset 1271


Ignore:
Timestamp:
01/17/10 20:38:50 (11 years ago)
Author:
rorothetroll
Message:

resync with trunk

Location:
branches/smartreader
Files:
2 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • branches/smartreader/csctapi/Makefile

    r1225 r1271  
    1313          $(LIBFILE1)(ctapi.o) \
    1414          $(LIBFILE1)(icc_async.o) \
    15           $(LIBFILE1)(ifd_towitoko.o) \
    1615            $(LIBFILE1)(ifd_cool.o) \
    1716          $(LIBFILE1)(ifd_sci.o) \
  • branches/smartreader/csctapi/ct_slot.c

    r1255 r1271  
    2525#include "defines.h"
    2626#include "ct_slot.h"
    27 #include "ifd_towitoko.h"
    2827#include "icc_async.h"
    2928#include "protocol_t0.h"
     
    3837#endif
    3938
     39/* Card status *///FIXME simplify this + duplicate in icc_async.h
     40#define IFD_TOWITOKO_CARD(status)       (((status) & 0x40) == 0x40)
     41#define IFD_TOWITOKO_CHANGE(status)     (((status) & 0x80) == 0x80)
     42
    4043/* Try first asynchronous init and if it fails try synchronous */
    4144//#undef ICC_PROBE_ASYNC_FIRST
     
    6669char CT_Slot_Init (CT_Slot * slot, int sn)
    6770{
    68     slot->ifd = IFD_Towitoko_New();
    69    
    70     if (slot->ifd == NULL)
    71         return ERR_MEMORY;
    72    
    73     if (IFD_Towitoko_Init (slot->ifd, sn) != IFD_TOWITOKO_OK)
    74     {
    75         IFD_Towitoko_Delete (slot->ifd);
    76         slot->ifd = NULL;
     71    if (!Phoenix_Init())
    7772        return ERR_TRANS;
    78     }
    7973   
    8074    return OK;
     
    133127        return ERR_MEMORY;
    134128   
    135     if (ICC_Async_Init (slot->icc, slot->ifd) != ICC_ASYNC_OK)
     129    if (ICC_Async_Init (slot->icc) != ICC_ASYNC_OK)
    136130    {
    137131        ICC_Async_Delete (slot->icc);
     
    303297bool CT_Slot_IsLast (CT_Slot * slot)
    304298{
    305     return (IFD_Towitoko_GetSlot(slot->ifd) >= IFD_Towitoko_GetNumSlots()-1);
     299    //return (IFD_Towitoko_GetSlot(slot->ifd) >= IFD_Towitoko_GetNumSlots()-1);
     300    return 1; //GetSlot always returns 0, and GetNumSlots returns always 1
    306301}
    307302
    308303void CT_Slot_GetType (CT_Slot * slot, BYTE * buffer, int len)
    309304{
    310     IFD_Towitoko_GetDescription (slot->ifd, buffer, len);
     305    //IFD_Towitoko_GetDescription (slot->ifd, buffer, len)
     306    buffer="dummy";
     307    len=5;
    311308}
    312309
     
    347344    }
    348345   
    349     if (slot->ifd != NULL)
    350     {
    351         if (IFD_Towitoko_Close (slot->ifd) != IFD_TOWITOKO_OK)
    352             ret = ERR_TRANS;
    353        
    354         IFD_Towitoko_Delete (slot->ifd);
    355     }
     346        if (!Phoenix_Close ())
     347            ret = ERR_TRANS;
    356348   
    357349    CT_Slot_Clear (slot);
     
    371363static void CT_Slot_Clear (CT_Slot * slot)
    372364{
    373     slot->ifd = NULL;
    374365    slot->icc = NULL;
    375366    slot->protocol = NULL;
  • branches/smartreader/csctapi/ct_slot.h

    r1255 r1271  
    3131#include "ctapi.h"
    3232#include "ctbcs.h"
    33 #include "ifd_towitoko.h"
    3433
    3534
     
    5352typedef struct
    5453{
    55   IFD * ifd;        /* Interface device */
    5654  void * icc;       /* Integrated circuit card */
    5755  void * protocol;  /* Protocol handler */
  • branches/smartreader/csctapi/ctapi.c

    r1255 r1271  
    115115   
    116116#ifdef DEBUG_CTAPI
    117     printf ("CTAPI: CT_init(ctn=%u, pn=%u)=%d\n", ctn, pn, ret);
     117    printf ("CTAPI: CT_init(ctn=%u)=%d\n", ctn, ret);
    118118#endif
    119119   
  • branches/smartreader/csctapi/icc_async.c

    r1255 r1271  
    3030#include <string.h>
    3131#include "ifd.h"
     32#include "mc_global.h"
    3233
    3334/*
     
    7374#if defined(SCI_DEV) || defined(COOL)
    7475    if (reader[ridx].typ == R_INTERNAL)
    75 #ifdef SH4
     76#if defined(SH4) || defined(STB04SCI)
    7677        reader[ridx].handle = open (reader[ridx].device, O_RDWR|O_NONBLOCK|O_NOCTTY);
    7778#elif COOL
     
    120121    {
    121122        if(!Sci_GetStatus(reader[ridx].handle, &in))
    122             return IFD_TOWITOKO_IO_ERROR;           
     123            return ICC_ASYNC_IFD_ERROR;         
    123124    }
    124125    else
     
    127128    {   
    128129        if (!Cool_GetStatus(&in))
    129             return IFD_TOWITOKO_IO_ERROR;
     130            return ICC_ASYNC_IFD_ERROR;
    130131    }
    131132    else
     
    147148    else
    148149#endif
    149 #ifdef USE_GPIO
    150     if (gpio_detect)
    151         in=get_gpio();
    152     else
    153 #endif
    154150  if (!Phoenix_GetStatus(&in))
    155             return IFD_TOWITOKO_IO_ERROR;
     151            return ICC_ASYNC_IFD_ERROR;
    156152
    157153    if (in)
     
    161157            status[0] = IFD_TOWITOKO_CARD_CHANGE;
    162158            reader[ridx].status = 1;
    163 #ifdef USE_GPIO
    164             if (gpio_detect) set_gpio1(0);
    165 #endif
    166159        }
    167160        else if(reader[ridx].status == 1)
     
    173166            status[0] = IFD_TOWITOKO_CARD_CHANGE;
    174167            reader[ridx].status = 1;
    175 #ifdef USE_GPIO
    176             if (gpio_detect) set_gpio1(0);
    177 #endif
    178168        }
    179169    }
     
    184174            status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
    185175            reader[ridx].status = 2;
    186 #ifdef USE_GPIO
    187             if (gpio_detect) set_gpio1(1);
    188 #endif
    189176        }
    190177        else if(reader[ridx].status == 1)
     
    192179            status[0] = IFD_TOWITOKO_NOCARD_CHANGE;
    193180            reader[ridx].status = 2;
    194 #ifdef USE_GPIO
    195             if (gpio_detect) set_gpio1(1);
    196 #endif
    197181        }
    198182        else
     
    209193#endif
    210194   
    211     return IFD_TOWITOKO_OK;
    212 }
    213 
    214 int ICC_Async_Init (ICC_Async * icc, IFD * ifd)
     195    return ICC_ASYNC_OK;
     196}
     197
     198int ICC_Async_Init (ICC_Async * icc)
    215199{
    216200#ifndef ICC_TYPE_SYNC
     
    221205        return ICC_ASYNC_IFD_ERROR;
    222206   
     207#ifdef SCI_DEV
    223208    /* Activate ICC */
    224     if (IFD_Towitoko_ActivateICC (ifd) != IFD_TOWITOKO_OK)
     209    if (!Sci_Activate())
    225210        return ICC_ASYNC_IFD_ERROR;
    226211    /* Reset ICC */
    227 #ifdef SCI_DEV
    228212    if (reader[ridx].typ == R_INTERNAL) {
    229213        if (!Sci_Reset(&(icc->atr)))
     
    278262    /* Initialize member variables */
    279263    icc->baudrate = ICC_ASYNC_BAUDRATE;
    280     icc->ifd = ifd;
    281264   
    282265    if (icc->convention == ATR_CONVENTION_INVERSE)
     
    435418}
    436419
    437 IFD * ICC_Async_GetIFD (ICC_Async * icc)
    438 {
    439     return icc->ifd;
    440 }
    441 
    442420int ICC_Async_Close (ICC_Async * icc)
    443421{
     422#ifdef SCI_DEV
    444423    /* Dectivate ICC */
    445     if (IFD_Towitoko_DeactivateICC (icc->ifd) != IFD_TOWITOKO_OK)
    446         return ICC_ASYNC_IFD_ERROR;
     424    if (!Sci_Deactivate())
     425        return ICC_ASYNC_IFD_ERROR;
     426#endif
    447427   
    448428    /* Delete atr */
     
    486466static void ICC_Async_Clear (ICC_Async * icc)
    487467{
    488     icc->ifd = NULL;
    489468    icc->atr = NULL;
    490469    icc->baudrate = 0L;
  • branches/smartreader/csctapi/icc_async.h

    r1225 r1271  
    2727
    2828#include "defines.h"
    29 #include "ifd_towitoko.h" //FIXME
    3029#include "atr.h"
    3130
     
    3837#define ICC_ASYNC_IFD_ERROR     1
    3938#define ICC_ASYNC_ATR_ERROR     2
     39
     40/* Card status */
     41#define IFD_TOWITOKO_NOCARD_NOCHANGE    0x00
     42#define IFD_TOWITOKO_CARD_NOCHANGE      0x40
     43#define IFD_TOWITOKO_NOCARD_CHANGE      0x80
     44#define IFD_TOWITOKO_CARD_CHANGE        0xC0
     45#define IFD_TOWITOKO_CARD(status)       (((status) & 0x40) == 0x40)
     46#define IFD_TOWITOKO_CHANGE(status)     (((status) & 0x80) == 0x80)
    4047
    4148/*
     
    5461typedef struct
    5562{
    56   IFD *ifd;                     /* Interface device */
    5763  ATR *atr;                     /* Answer to reset of this ICC */
    5864  int convention;               /* Convention of this ICC */
     
    7278
    7379/* Initialization and Deactivation */
    74 extern int ICC_Async_Init (ICC_Async * icc, IFD * ifd);
     80extern int ICC_Async_Init (ICC_Async * icc);
    7581extern int ICC_Async_Close (ICC_Async * icc);
    7682
     
    8187extern int ICC_Async_GetBaudrate (ICC_Async * icc, unsigned long * baudrate);
    8288extern ATR *ICC_Async_GetAtr (ICC_Async * icc);
    83 extern IFD *ICC_Async_GetIFD (ICC_Async * icc);
    8489extern unsigned long ICC_Async_GetClockRate ();
    8590
  • branches/smartreader/csctapi/ifd.h

    r1186 r1271  
    55
    66#include "ifd_cool.h"
     7
     8typedef struct
     9{
     10  unsigned block_delay;     /* Delay (ms) after starting to transmit */
     11  unsigned char_delay;      /* Delay (ms) after transmiting sucesive chars */
     12  unsigned block_timeout;   /* Max timeout (ms) to receive firtst char */
     13  unsigned char_timeout;    /* Max timeout (ms) to receive sucesive characters */
     14}
     15IFD_Timings; //FIXME kill this
  • branches/smartreader/csctapi/ifd_phoenix.c

    r1255 r1271  
    1010#include "../globals.h"
    1111#include "atr.h"
    12 #include "ifd_towitoko.h" //FIXME
    1312#include <termios.h>
     13#include "ifd.h" //FIXME kill this after IFD timings
    1414
    1515#define OK      1
     
    1818#define IFD_TOWITOKO_MAX_TRANSMIT 255
    1919#define IFD_TOWITOKO_ATR_TIMEOUT   800
     20#define IFD_TOWITOKO_BAUDRATE            9600
     21
     22#ifdef USE_GPIO //felix: definition of gpio functions
     23int gpio_outen,gpio_out,gpio_in;
     24unsigned int pin,gpio;
     25int gpio_detect=0;
     26
     27static void set_gpio(int level)
     28{       
     29    read(gpio_outen, &gpio, sizeof(gpio));
     30    gpio |= pin;
     31    write(gpio_outen, &gpio, sizeof(gpio));
     32
     33    read(gpio_out, &gpio, sizeof(gpio));
     34    if (level>0)
     35        gpio|=pin;
     36    else
     37        gpio&=~pin;
     38    write(gpio_out, &gpio, sizeof(gpio));
     39}
     40
     41static void set_gpio_input(void)
     42{
     43    read(gpio_outen, &gpio, sizeof(gpio));         
     44    gpio &= ~pin;
     45    write(gpio_outen, &gpio, sizeof(gpio));
     46}
     47
     48static int get_gpio(void)
     49{
     50    set_gpio_input();
     51    read(gpio_in, &gpio, sizeof(gpio));
     52    return ((int)((gpio&pin)?1:0));
     53}
     54#endif
     55
    2056
    2157int Phoenix_Init ()
    2258{
     59#ifdef USE_GPIO //felix: define gpio number used for card detect and reset. ref to globals.h               
     60    extern int oscam_card_detect;
     61    if (oscam_card_detect>4)
     62    {
     63        gpio_detect=oscam_card_detect-4;
     64        pin = 1<<gpio_detect;
     65        gpio_outen=open("/dev/gpio/outen",O_RDWR);
     66        gpio_out=open("/dev/gpio/out",O_RDWR);
     67        gpio_in=open("/dev/gpio/in",O_RDWR);
     68        set_gpio_input();
     69    }
     70#endif
     71   
     72#ifdef DEBUG_IFD
     73    printf ("IFD: Initializing slot number %d, com=%d\n", slot, reader[ridx].typ);
     74#endif
     75   
     76    if(reader[ridx].typ == R_INTERNAL) //not sure whether this should be moved in front of GPIO part
     77        return OK;
     78   
     79    /* Default serial port settings */
     80    if (!IO_Serial_SetParams (IFD_TOWITOKO_BAUDRATE, 8, PARITY_EVEN, 2, IO_SERIAL_HIGH, IO_SERIAL_LOW))
     81    {
     82        reader[ridx].status = 0;//added this one because it seemed logical
     83        return ERROR;
     84    }
     85       
     86    if (!Phoenix_SetBaudrate(IFD_TOWITOKO_BAUDRATE))
     87    {
     88        reader[ridx].status = 0;
     89        return ERROR;
     90    }
     91   
     92    if (!IO_Serial_SetParity (PARITY_EVEN))
     93    {
     94        reader[ridx].status = 0;
     95        return ERROR;
     96    }
     97   
     98    IO_Serial_Flush();
    2399    return OK;
    24100}
     
    26102int Phoenix_GetStatus (int * status)
    27103{
    28     int in;
     104#ifdef USE_GPIO  //felix: detect card via defined gpio
     105 if (gpio_detect)
     106        *status=get_gpio();
     107 else
     108#endif
     109 {
    29110    unsigned int modembits=0;
    30111    extern int oscam_card_detect; //FIXME kill global variable
     
    33114    switch(oscam_card_detect&0x7f)
    34115    {
    35         case    0: in=(modembits & TIOCM_CAR);  break;
    36         case    1: in=(modembits & TIOCM_DSR);  break;
    37         case    2: in=(modembits & TIOCM_CTS);  break;
    38         case    3: in=(modembits & TIOCM_RNG);  break;
    39         default: in=0;      // dummy
     116        case    0: *status=(modembits & TIOCM_CAR); break;
     117        case    1: *status=(modembits & TIOCM_DSR); break;
     118        case    2: *status=(modembits & TIOCM_CTS); break;
     119        case    3: *status=(modembits & TIOCM_RNG); break;
     120        default: *status=0;     // dummy
    40121    }
    41122    if (!(oscam_card_detect&0x80))
    42         in=!in;
    43     *status = in;
    44     return OK;
     123        *status=!*status;
     124 }
     125 return OK;
    45126}
    46127
     
    70151            IO_Serial_Ioctl_Lock(1);
    71152#ifdef USE_GPIO
    72             if (gpio_detect){
     153            if (gpio_detect)
    73154                set_gpio(0);
    74                 set_gpio1(0);
    75             }
    76155            else
    77156#endif
     
    82161            usleep (50000L);
    83162#endif
    84 #ifdef USE_GPIO
     163#ifdef USE_GPIO  //felix: set card reset hi (inactive)
    85164            if (gpio_detect) {
    86165                set_gpio_input();
    87                 set_gpio1(1);
    88166            }
    89167            else
     
    101179                ATR_Delete (*atr);
    102180                (*atr) = NULL;
    103 #ifdef USE_GPIO
    104                 if (gpio_detect) set_gpio1(0);
    105 #endif
    106181            }
    107182        }
     
    141216    block_delay = IFD_TOWITOKO_DELAY + timings->block_delay;
    142217
    143 #ifdef USE_GPIO
    144     if (gpio_detect) set_gpio1(0);
    145 #endif
    146218    for (sent = 0; sent < size; sent = sent + to_send)
    147219    {
     
    164236        }
    165237    }
    166 #ifdef USE_GPIO
    167     if (gpio_detect) set_gpio1(1);
    168 #endif
    169238    return OK;
    170239}
     
    182251    char_timeout = IFD_TOWITOKO_TIMEOUT + timings->char_timeout;
    183252    block_timeout = IFD_TOWITOKO_TIMEOUT + timings->block_timeout;
    184 #ifdef USE_GPIO
    185     if (gpio_detect) set_gpio1(0);
    186 #endif
    187253    if (block_timeout != char_timeout)
    188254    {
     
    204270            return ERROR;
    205271    }
    206 #ifdef USE_GPIO
    207     if (gpio_detect) set_gpio1(1);
    208 #endif
    209272   
    210273#ifdef DEBUG_IFD
     
    245308    return OK;
    246309}
     310
     311int Phoenix_Close ()
     312{
     313#ifdef USE_GPIO //felix: close dev if card detected
     314    if(gpio_detect)
     315    {
     316        close(gpio_outen);
     317        close(gpio_out);
     318        close(gpio_in);
     319    }
     320#endif
     321   
     322#ifdef DEBUG_IFD
     323    printf ("IFD: Closing slot\n");
     324#endif
     325   
     326    reader[ridx].status = 0;
     327    return OK;
     328}
  • branches/smartreader/csctapi/ifd_sci.c

    r1239 r1271  
    2020#include "../globals.h"
    2121
    22 #include "ifd_towitoko.h"
    2322#define IFD_TOWITOKO_ATR_TIMEOUT     800
    2423
     
    142141}
    143142
    144 #endif
     143int Sci_Activate ()
     144{
     145#ifdef DEBUG_IFD
     146        printf ("IFD: Activating card\n");
     147#endif
     148#ifdef SCI_DEV
     149    if(reader[ridx].typ == R_INTERNAL)
     150    {
     151        int in;
     152
     153#if defined(TUXBOX) && (defined(MIPSEL) || defined(PPC) || defined(SH4))
     154        if(ioctl(reader[ridx].handle, IOCTL_GET_IS_CARD_PRESENT, &in)<0)
     155#else
     156        if(ioctl(reader[ridx].handle, IOCTL_GET_IS_CARD_ACTIVATED, &in)<0)
     157#endif
     158            return ERROR;
     159           
     160        if(in)
     161        {
     162            struct timespec req_ts;
     163            req_ts.tv_sec = 0;
     164            req_ts.tv_nsec = 50000000;
     165            nanosleep (&req_ts, NULL);
     166            return OK;
     167        }
     168        else
     169            return ERROR;
     170    }
     171    else
     172#endif
     173    {
     174        return OK;
     175    }
     176}
     177
     178int Sci_Deactivate ()
     179{
     180#ifdef DEBUG_IFD
     181        printf ("IFD: Deactivating card\n");
     182#endif
     183
     184#ifdef SCI_DEV
     185    if(reader[ridx].typ == R_INTERNAL)
     186    {
     187        int in;
     188       
     189#if defined(TUXBOX) && (defined(MIPSEL) || defined(PPC) || defined(SH4))
     190        if(ioctl(reader[ridx].handle, IOCTL_GET_IS_CARD_PRESENT, &in)<0)
     191#else
     192        if(ioctl(reader[ridx].handle, IOCTL_GET_IS_CARD_ACTIVATED, &in)<0)
     193#endif
     194            return ERROR;
     195           
     196        if(in)
     197        {
     198            if(ioctl(reader[ridx].handle, IOCTL_SET_DEACTIVATE)<0)
     199                return ERROR;
     200        }
     201       
     202       
     203    }
     204#endif
     205   
     206    return OK;
     207}
     208
     209#endif
  • branches/smartreader/csctapi/sci_ioctl.h

    r8 r1271  
    99#define SCI_IOW_MAGIC           's'
    1010
    11 #ifndef OS_CYGWIN32
     11#ifdef STB04SCI
     12//--------------------------------------------------------------------------
     13// reset sci_parameters are optional, i.e. may be NULL
     14// (but not: ioctl (fd, STB04SCI_RESET),
     15// rather ioctl (fd, STB04SCI_RESET, NULL))
     16//--------------------------------------------------------------------------
     17
     18#define IOCTL_SET_RESET                         _IO (0x64,  1)
     19#define IOCTL_SET_MODES                         _IOW(0x64,  2, SCI_MODES)
     20#define IOCTL_GET_MODES                         _IOR(0x64,  3, SCI_MODES)
     21#define IOCTL_SET_PARAMETERS                _IOW(0x64,  4, SCI_PARAMETERS)
     22#define IOCTL_GET_PARAMETERS                _IOR(0x64,  5, SCI_PARAMETERS)
     23#define IOCTL_CLOCK_START                       _IO (0x64,  6)
     24#define IOCTL_CLOCK_STOP                        _IO (0x64,  7)
     25#define IOCTL_GET_IS_CARD_PRESENT       _IO (0x64,  8)
     26#define IOCTL_GET_IS_CARD_ACTIVATED _IO (0x64,  9)
     27#define IOCTL_SET_DEACTIVATE                _IO (0x64, 10)
     28#define IOCTL_SET_ATR_READY                 _IO (0x64, 11)
     29#define IOCTL_GET_ATR_STATUS                _IO (0x64, 12)
     30#define IOCTL_DUMP_REGS                         _IO (0x64, 20)
     31
     32#elif defined(OS_CYGWIN32)
    1233/* ioctl cmd table */
    13 #define IOCTL_SET_RESET         _IOW(SCI_IOW_MAGIC, 1,  unsigned long)
    14 #define IOCTL_SET_MODES         _IOW(SCI_IOW_MAGIC, 2,  SCI_MODES)
    15 #define IOCTL_GET_MODES         _IOW(SCI_IOW_MAGIC, 3,  SCI_MODES)
    16 #define IOCTL_SET_PARAMETERS        _IOW(SCI_IOW_MAGIC, 4,  SCI_PARAMETERS)
    17 #define IOCTL_GET_PARAMETERS        _IOW(SCI_IOW_MAGIC, 5,  SCI_PARAMETERS)
    18 #define IOCTL_SET_CLOCK_START       _IOW(SCI_IOW_MAGIC, 6,  unsigned long)
    19 #define IOCTL_SET_CLOCK_STOP        _IOW(SCI_IOW_MAGIC, 7,  unsigned long)
    20 #define IOCTL_GET_IS_CARD_PRESENT   _IOW(SCI_IOW_MAGIC, 8,  unsigned long)
    21 #define IOCTL_GET_IS_CARD_ACTIVATED _IOW(SCI_IOW_MAGIC, 9,  unsigned long)
    22 #define IOCTL_SET_DEACTIVATE        _IOW(SCI_IOW_MAGIC, 10, unsigned long)
    23 #define IOCTL_SET_ATR_READY     _IOW(SCI_IOW_MAGIC, 11, unsigned long)
    24 #define IOCTL_GET_ATR_STATUS        _IOW(SCI_IOW_MAGIC, 12, unsigned long)
    25 #define IOCTL_DUMP_REGS         _IOW(SCI_IOW_MAGIC, 20, unsigned long)
     34#define IOCTL_SET_RESET                         1
     35#define IOCTL_SET_MODES                         2
     36#define IOCTL_GET_MODES                         3
     37#define IOCTL_SET_PARAMETERS                4
     38#define IOCTL_GET_PARAMETERS                5
     39#define IOCTL_SET_CLOCK_START               6
     40#define IOCTL_SET_CLOCK_STOP                7
     41#define IOCTL_GET_IS_CARD_PRESENT       8
     42#define IOCTL_GET_IS_CARD_ACTIVATED 9
     43#define IOCTL_SET_DEACTIVATE                10
     44#define IOCTL_SET_ATR_READY                 11
     45#define IOCTL_GET_ATR_STATUS                12
     46#define IOCTL_DUMP_REGS                         13
    2647#else
    27 #define IOCTL_SET_RESET         1
    28 #define IOCTL_SET_MODES         2
    29 #define IOCTL_GET_MODES         3
    30 #define IOCTL_SET_PARAMETERS        4
    31 #define IOCTL_GET_PARAMETERS        5
    32 #define IOCTL_SET_CLOCK_START       6
    33 #define IOCTL_SET_CLOCK_STOP        7
    34 #define IOCTL_GET_IS_CARD_PRESENT   8
    35 #define IOCTL_GET_IS_CARD_ACTIVATED 9
    36 #define IOCTL_SET_DEACTIVATE        10
    37 #define IOCTL_SET_ATR_READY     11
    38 #define IOCTL_GET_ATR_STATUS        12
    39 #define IOCTL_DUMP_REGS         13
     48#define IOCTL_SET_RESET                         _IOW(SCI_IOW_MAGIC, 1,  unsigned long)
     49#define IOCTL_SET_MODES                         _IOW(SCI_IOW_MAGIC, 2,  SCI_MODES)
     50#define IOCTL_GET_MODES                         _IOW(SCI_IOW_MAGIC, 3,  SCI_MODES)
     51#define IOCTL_SET_PARAMETERS                _IOW(SCI_IOW_MAGIC, 4,  SCI_PARAMETERS)
     52#define IOCTL_GET_PARAMETERS                _IOW(SCI_IOW_MAGIC, 5,  SCI_PARAMETERS)
     53#define IOCTL_SET_CLOCK_START               _IOW(SCI_IOW_MAGIC, 6,  unsigned long)
     54#define IOCTL_SET_CLOCK_STOP                _IOW(SCI_IOW_MAGIC, 7,  unsigned long)
     55#define IOCTL_GET_IS_CARD_PRESENT       _IOW(SCI_IOW_MAGIC, 8,  unsigned long)
     56#define IOCTL_GET_IS_CARD_ACTIVATED _IOW(SCI_IOW_MAGIC, 9,  unsigned long)
     57#define IOCTL_SET_DEACTIVATE                _IOW(SCI_IOW_MAGIC, 10, unsigned long)
     58#define IOCTL_SET_ATR_READY                 _IOW(SCI_IOW_MAGIC, 11, unsigned long)
     59#define IOCTL_GET_ATR_STATUS                _IOW(SCI_IOW_MAGIC, 12, unsigned long)
     60#define IOCTL_DUMP_REGS                         _IOW(SCI_IOW_MAGIC, 20, unsigned long)
    4061#endif
    4162
  • branches/smartreader/globals.h

    r1254 r1271  
    152152char *RDR_CD_TXT[] = { "cd", "dsr", "cts", "ring", "none",
    153153#ifdef USE_GPIO
    154                        "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7",
     154                       "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", //felix: changed so that gpio can be used
    155155#endif
    156156                       NULL };
  • branches/smartreader/reader-nagra.c

    r1239 r1271  
    233233    cs_debug("[nagra-reader] ------------------------------------------");
    234234   
    235     memcpy(reader[ridx].hexserial, parte_fija+15, 4);
     235    memcpy(reader[ridx].hexserial+2, parte_fija+15, 4);
    236236    memcpy(irdId, parte_fija+19, 4);
    237237    memcpy(d1_rsa_modulo,parte_fija+23,88);
     
    725725    else
    726726    {
     727        //check ECM prov id
     728        if (memcmp(&reader[ridx].prid[0][2], er->ecm+5, 2))
     729            return (0);
     730   
    727731        //                  ecm_data: 80 30 89 D3 87 54 11 10 DA A6 0F 4B 92 05 34 00 ...
    728732        //serial_data: A0 CA 00 00 8C D3 8A 00 00 00 00 00 10 DA A6 0F .
     
    751755int nagra2_do_emm(EMM_PACKET *ep)
    752756{
    753     cs_debug("[nagra-reader] do_emm #########################################################");
    754     cs_debug("[nagra-reader] do_emm #########################################################");
    755     if(!do_cmd(ep->emm[8],ep->emm[9]+2,0x84,0x02,ep->emm+8+2))
    756     {
    757         cs_debug("[nagra-reader] nagra2_do_emm failed");
    758         return (0);
    759     }
    760     cs_sleepms(300);
    761     nagra2_post_process();
     757    if (!is_tiger)
     758    {
     759        if(!do_cmd(ep->emm[8],ep->emm[9]+2,0x84,0x02,ep->emm+8+2))
     760        {
     761            cs_debug("[nagra-reader] nagra2_do_emm failed");
     762            return (0);
     763        }
     764        cs_sleepms(300);
     765        nagra2_post_process();
     766    }
     767    else
     768    {
     769        //check EMM prov id
     770        if (memcmp(&reader[ridx].prid[0][2], ep->emm+10, 2))
     771            return (0);
     772   
     773        //   emm_data: 82 70 8E 00 00 00 00 00 D3 87 8D 11 C0 F4 B1 27 2C 3D 25 94 ...
     774        //serial_data: A0 CA 00 00 8C D3 8A 01 00 00 00 00 C0 F4 B1 27 2C 3D 25 94 ...
     775        unsigned char emm_trim[150];
     776        memset(emm_trim, 0, 150);
     777        memcpy(&emm_trim[5], ep->emm+3+5+2+2, ep->emm[9]+2);
     778        if(!do_cmd(ep->emm[8],ep->emm[9]+5,0x53,0x16, emm_trim))
     779        {
     780            cs_debug("[nagra-reader] nagra2_do_emm failed");
     781            return (0);
     782        }
     783        cs_sleepms(300);
     784    }
    762785    return 1;
    763786}
Note: See TracChangeset for help on using the changeset viewer.