Changeset 1719


Ignore:
Timestamp:
02/26/10 17:04:59 (11 years ago)
Author:
merek
Message:

Merge from UMP r1791/1792

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Makefile

    r1524 r1719  
    6868        OS_CULI="-lncurses" \
    6969        OS_PTLI="-lpthread" \
    70         DS_OPTS="-O2 -DOS_LINUX -DCS_CONFDIR=${CS_CONFDIR} -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""'" \
     70        DS_OPTS="-O2 -DOS_LINUX -DWEBIF -DCS_CONFDIR=${CS_CONFDIR} -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""'" \
    7171        DS_CFLAGS="-c" \
    7272        DS_LDFLAGS="" \
  • trunk/csctapi/icc_async.c

    r1658 r1719  
    661661#if defined(LIBUSB)
    662662        case R_SMART:
    663             reader[ridx].sr_config.inv= (convention == ATR_CONVENTION_INVERSE) ? 1: 0;
    664             reader[ridx].sr_config.parity=parity;
    665             call (SR_SetParity(&reader[ridx]));
     663            call (SR_SetParity(&reader[ridx], parity));
    666664            break;
    667665#endif
     
    855853#if defined(LIBUSB)
    856854    if (reader[ridx].typ == R_SMART)
    857         SR_WriteSettings(&reader[ridx], (unsigned short) atr_f_table[FI], (BYTE)d, (BYTE)EGT, (BYTE)protocol_type);
     855        SR_WriteSettings(&reader[ridx], (unsigned short) atr_f_table[FI], (BYTE)d, (BYTE)EGT, (BYTE)protocol_type, convention);
    858856#endif
    859857    cs_log("Maximum frequency for this card is formally %i Mhz, clocking it to %.2f Mhz", atr_fs_table[FI] / 1000000, (float) reader[ridx].mhz / 100);
  • trunk/csctapi/ifd_smartreader.c

    r1650 r1719  
    1414#define LOBYTE(w) ((BYTE)((w) & 0xff))
    1515#define HIBYTE(w) ((BYTE)((w) >> 8))
     16
     17//local globals
     18unsigned char g_read_buffer[4096];
     19unsigned int g_read_buffer_size;
     20pthread_mutex_t g_read_mutex;
     21pthread_mutex_t g_usb_mutex;
     22//struct usb_device *smartreader_usb_dev;
     23pthread_t rt;
     24unsigned char modem_status;
     25SR_CONFIG sr_config;
    1626
    1727//The number of concurrent bulk reads to queue onto the smartreader
     
    4555static int smartreader_set_latency_timer(S_READER *reader, unsigned short latency);
    4656static void EnableSmartReader(S_READER *reader, int clock, unsigned short Fi, unsigned char Di, unsigned char Ni, unsigned char T,unsigned char inv, int parity);
    47 static void ResetSmartReader(S_READER *reader);
    4857static void *ReaderThread(void *p);
    4958
     
    7584    smartreader_init(reader);
    7685
    77     reader->sr_config.usb_dev=find_smartreader(busname,devname);
    78     if(!reader->sr_config.usb_dev)
     86    sr_config.usb_dev=find_smartreader(busname,devname);
     87    if(!sr_config.usb_dev)
    7988        return ERROR;
    8089
     
    8493    //also a good way to compare a real FT232 with a smartreader
    8594    //if you enumarate usb devices
    86     reader->sr_config.in_ep = 0x1;
    87     reader->sr_config.out_ep = 0x82;
     95    sr_config.in_ep = 0x1;
     96    sr_config.out_ep = 0x82;
    8897
    8998    //open the first smartreader found in the system, this
     
    113122
    114123    // start the reading thread
    115     reader->g_read_buffer_size = 0;
    116     reader->modem_status = 0 ;
    117     pthread_mutex_init(&reader->g_read_mutex,NULL);
    118     pthread_mutex_init(&reader->g_usb_mutex,NULL);
    119     ret = pthread_create(&reader->rt, NULL, ReaderThread, (void *)(reader));
     124    g_read_buffer_size = 0;
     125    modem_status = 0 ;
     126    pthread_mutex_init(&g_read_mutex,NULL);
     127    pthread_mutex_init(&g_usb_mutex,NULL);
     128    ret = pthread_create(&rt, NULL, ReaderThread, (void *)(reader));
    120129    if (ret) {
    121130        cs_log("ERROR; return code from pthread_create() is %d", ret);
     
    131140    int state;
    132141
    133     pthread_mutex_lock(&reader->g_read_mutex);
    134     state =(reader->modem_status & 0x80) == 0x80 ? 0 : 2;
    135     pthread_mutex_unlock(&reader->g_read_mutex);
     142    pthread_mutex_lock(&g_read_mutex);
     143    state =(modem_status & 0x80) == 0x80 ? 0 : 2;
     144    pthread_mutex_unlock(&g_read_mutex);
    136145
    137146   
     
    157166   
    158167    if(reader->mhz==reader->cardmhz && reader->cardmhz*10000 > 3690000)
    159         reader->sr_config.fs=reader->cardmhz*10000;
     168        sr_config.fs=reader->cardmhz*10000;
    160169    else   
    161         reader->sr_config.fs=3690000;
    162 
    163     ResetSmartReader(reader);
     170        sr_config.fs=3690000;
     171
     172    smart_flush(reader);
     173    // set smartreader+ default values
     174    sr_config.F=372;
     175    sr_config.D=1.0;
     176    if(reader->mhz==reader->cardmhz && reader->cardmhz*10000 > 3690000)
     177        sr_config.fs=reader->cardmhz*10000;
     178    else   
     179        sr_config.fs=3690000;
     180    sr_config.N=0;
     181    sr_config.T=0;
     182    sr_config.inv=0;
     183
    164184    for(i=0 ; i < 4 ;i++) {
    165         reader->sr_config.irdeto=FALSE;
     185        sr_config.irdeto=FALSE;
    166186        atr_ok=ERROR;
    167187        memset(data,0,sizeof(data));
    168         reader->sr_config.parity=parity[i];
    169 
    170         cs_debug_mask (D_IFD,"IO:SR: Trying with parity %s",parity_str[reader->sr_config.parity]);
     188        cs_debug_mask (D_IFD,"IO:SR: Trying with parity %s",parity_str[parity[i]]);
    171189
    172190
     
    174192        if(i==3) {
    175193            cs_debug_mask (D_IFD,"IO:SR: Trying irdeto");
    176 
    177             reader->sr_config.F=618; /// magic smartreader value
    178             reader->sr_config.D=1;
    179             reader->sr_config.T=2; // will be set to T=1 in EnableSmartReader
    180             reader->sr_config.irdeto=TRUE;
     194            sr_config.F=618; /// magic smartreader value
     195            sr_config.D=1;
     196            sr_config.T=2; // will be set to T=1 in EnableSmartReader
     197            sr_config.irdeto=TRUE;
    181198        }
    182199       
    183200        smart_flush(reader);
    184         EnableSmartReader(reader, reader->sr_config.fs/10000, reader->sr_config.F, (BYTE)reader->sr_config.D, reader->sr_config.N, reader->sr_config.T, reader->sr_config.inv,reader->sr_config.parity);
     201        EnableSmartReader(reader, sr_config.fs/10000, sr_config.F, (BYTE)sr_config.D, sr_config.N, sr_config.T, sr_config.inv,parity[i]);
    185202        sched_yield();
    186203        cs_sleepms(500); //smartreader in mouse mode needs this, so it might also be needed in native mode.
     
    209226
    210227        if(data[0]!=0x3B && data[0]!=0x03 && data[0]!=0x3F) {
    211             reader->sr_config.irdeto=FALSE;
     228            sr_config.irdeto=FALSE;
    212229            continue; // this is not a valid ATR.
    213230        }
     
    216233            cs_debug_mask (D_IFD,"IO:SR: Inverse convention detected, setting smartreader inv to 1");
    217234
    218             reader->sr_config.inv=1;
    219             EnableSmartReader(reader, reader->sr_config.fs/10000, reader->sr_config.F, (BYTE)reader->sr_config.D, reader->sr_config.N, reader->sr_config.T, reader->sr_config.inv,reader->sr_config.parity);
     235            sr_config.inv=1;
     236            EnableSmartReader(reader, sr_config.fs/10000, sr_config.F, (BYTE)sr_config.D, sr_config.N, sr_config.T, sr_config.inv,parity[i]);
    220237        }
    221238        // parse atr
     
    225242            if(i==3) {
    226243                cs_debug_mask (D_IFD,"IO:SR: Locking F and D for Irdeto mode");
    227                 reader->sr_config.irdeto=TRUE;
     244                sr_config.irdeto=TRUE;
    228245            }
    229246        }
     
    258275}   
    259276
    260 int SR_WriteSettings (struct s_reader *reader, unsigned short F, BYTE D, BYTE N, BYTE T)
     277int SR_WriteSettings (struct s_reader *reader, unsigned short F, BYTE D, BYTE N, BYTE T, unsigned short convention)
    261278{
    262279//      maintaining all this admin seems overdone, since after this init the values are nowhere needed
     
    265282//      reader[ridx].sr_config.N=N;
    266283//      reader[ridx].sr_config.T=T;
    267 //   reader->sr_config.fs=reader->mhz*10000; //freq in Hz */
    268 //    EnableSmartReader(reader, reader->sr_config.fs, reader->sr_config.F, (BYTE)reader->sr_config.D, reader->sr_config.N, reader->sr_config.T, reader->sr_config.inv,reader->sr_config.parity);
     284//   sr_config.fs=reader->mhz*10000; //freq in Hz */
     285//    EnableSmartReader(reader, sr_config.fs, sr_config.F, (BYTE)sr_config.D, sr_config.N, sr_config.T, sr_config.inv,sr_config.parity);
    269286       
    270287    // smartreader supports 3.20, 3.43, 3.69, 4.00, 4.36, 4.80, 5.34, 6.00, 6.86, 8.00, 9.61, 12.0, 16.0 Mhz
     288        sr_config.inv = convention;//FIXME this one is set by icc_async and local smartreader reset routine 
    271289        if (reader->mhz >=1600) reader->mhz = 1600; else
    272290        if (reader->mhz >=1200) reader->mhz = 1200; else
     
    282300        if (reader->mhz >=343)  reader->mhz =  343; else
    283301            reader->mhz =  320;
    284     EnableSmartReader(reader, reader->mhz, F, D, N, T, reader->sr_config.inv,reader->sr_config.parity);
     302    EnableSmartReader(reader, reader->mhz, F, D, N, T, sr_config.inv,sr_config.parity);
    285303
    286304    //baud rate not really used in native mode since
     
    292310}
    293311
    294 int SR_SetParity (struct s_reader *reader)
     312int SR_SetParity (struct s_reader *reader, unsigned short parity)
    295313{
    296314    int ret;
    297315
    298     char *parity_str[5]={"NONE", "ODD", "EVEN", "MARK", "SPACE"};
    299     cs_debug_mask (D_IFD,"IO:SR: Setting parity to %s",parity_str[reader->sr_config.parity]);
    300 
    301     ret = smartreader_set_line_property(reader, (enum smartreader_bits_type) 8, STOP_BIT_2, reader->sr_config.parity);
     316        char *parity_str[5]={"NONE", "ODD", "EVEN", "MARK", "SPACE"};
     317    cs_debug_mask (D_IFD,"IO:SR: Setting parity to %s",parity_str[parity]);
     318
     319    ret = smartreader_set_line_property(reader, (enum smartreader_bits_type) 8, STOP_BIT_2, parity);
    302320    if(ret)
    303321        return ERROR;
     
    313331    cs_debug_mask(D_IFD,"IO:SR: Closing smarteader\n");
    314332
    315     reader->sr_config.running=FALSE;
    316     pthread_join(reader->rt,NULL);
    317     libusb_close(reader->sr_config.usb_dev_handle);
     333    sr_config.running=FALSE;
     334    pthread_join(rt,NULL);
     335    libusb_close(sr_config.usb_dev_handle);
    318336    libusb_exit(NULL);
    319337    return OK;
     
    337355
    338356    // command 1, set F and D parameter
    339     if(!reader->sr_config.irdeto) {
     357    if(!sr_config.irdeto) {
    340358        cs_debug_mask (D_IFD,"IO:SR: sending F=%04X (%d) to smartreader",Fi,Fi);
    341359        cs_debug_mask (D_IFD,"IO:SR: sending D=%02X (%d) to smartreader",Di,Di);
     
    366384
    367385    // command 4 , set parameter T
    368     if(reader->sr_config.irdeto && T==2) // special trick to get ATR for Irdeto card, we need T=1 at reset, after that oscam takes care of T1 protocol, so we need T=0
     386    if(sr_config.irdeto && T==2) // special trick to get ATR for Irdeto card, we need T=1 at reset, after that oscam takes care of T1 protocol, so we need T=0
    369387        {
    370388        T=1;
    371         reader->sr_config.T=1;
     389        sr_config.T=1;
    372390        }
    373391    else if (T==1)
     
    391409
    392410    smart_flush(reader);
    393 }
    394 
    395 static void ResetSmartReader(S_READER *reader)
    396 {
    397 
    398     smart_flush(reader);
    399     // set smartreader+ default values
    400     reader->sr_config.F=372;
    401     reader->sr_config.D=1.0;
    402     if(reader->mhz==reader->cardmhz && reader->cardmhz*10000 > 3690000)
    403         reader->sr_config.fs=reader->cardmhz*10000;
    404     else   
    405         reader->sr_config.fs=3690000;
    406     reader->sr_config.N=0;
    407     reader->sr_config.T=0;
    408     reader->sr_config.inv=0;
    409    
    410     EnableSmartReader(reader, reader->sr_config.fs/10000, reader->sr_config.F, (BYTE)reader->sr_config.D, reader->sr_config.N, reader->sr_config.T, reader->sr_config.inv,reader->sr_config.parity);
    411     sched_yield();
    412 
    413411}
    414412
     
    507505void smartreader_init(S_READER *reader)
    508506{
    509     reader->sr_config.usb_dev = NULL;
    510     reader->sr_config.usb_dev_handle=NULL;
    511     reader->sr_config.usb_read_timeout = 10000;
    512     reader->sr_config.usb_write_timeout = 10000;
    513 
    514     reader->sr_config.type = TYPE_BM;    /* chip type */
    515     reader->sr_config.baudrate = -1;
    516     reader->sr_config.bitbang_enabled = 0;  /* 0: normal mode 1: any of the bitbang modes enabled */
    517 
    518     reader->sr_config.writebuffer_chunksize = 64;
    519     reader->sr_config.max_packet_size = 0;
    520 
    521     reader->sr_config.interface = INTERFACE_ANY;
    522     reader->sr_config.index = INTERFACE_A;
    523     reader->sr_config.in_ep = 0x02;
    524     reader->sr_config.out_ep = 0x82;
     507    sr_config.usb_dev = NULL;
     508    sr_config.usb_dev_handle=NULL;
     509    sr_config.usb_read_timeout = 10000;
     510    sr_config.usb_write_timeout = 10000;
     511
     512    sr_config.type = TYPE_BM;    /* chip type */
     513    sr_config.baudrate = -1;
     514    sr_config.bitbang_enabled = 0;  /* 0: normal mode 1: any of the bitbang modes enabled */
     515
     516    sr_config.writebuffer_chunksize = 64;
     517    sr_config.max_packet_size = 0;
     518
     519    sr_config.interface = INTERFACE_ANY;
     520    sr_config.index = INTERFACE_A;
     521    sr_config.in_ep = 0x02;
     522    sr_config.out_ep = 0x82;
    525523}
    526524
     
    538536    // New hi-speed devices from FTDI use a packet size of 512 bytes
    539537    // but could be connected to a normal speed USB hub -> 64 bytes packet size.
    540     if (reader->sr_config.type == TYPE_2232H || reader->sr_config.type == TYPE_4232H)
     538    if (sr_config.type == TYPE_2232H || sr_config.type == TYPE_4232H)
    541539        packet_size = 512;
    542540    else
    543541        packet_size = 64;
    544542
    545     ret = libusb_get_device_descriptor(reader->sr_config.usb_dev, &desc);
     543    ret = libusb_get_device_descriptor(sr_config.usb_dev, &desc);
    546544    if (ret < 0) {
    547545        cs_log("Smartreader : couldn't read device descriptor , using default packet size");
     
    550548    if (desc.bNumConfigurations)
    551549    {
    552         ret=libusb_get_active_config_descriptor(reader->sr_config.usb_dev,&configDesc);
     550        ret=libusb_get_active_config_descriptor(sr_config.usb_dev,&configDesc);
    553551        if(ret) {
    554552            cs_log("Smartreader : couldn't read config descriptor , using default packet size");
     
    556554        }
    557555
    558         if (reader->sr_config.interface < configDesc->bNumInterfaces)
     556        if (sr_config.interface < configDesc->bNumInterfaces)
    559557        {
    560             interface=configDesc->interface[reader->sr_config.interface];
     558            interface=configDesc->interface[sr_config.interface];
    561559            if (interface.num_altsetting > 0)
    562560            {
     
    578576    int ret = 0;
    579577
    580     if (reader->sr_config.usb_dev_handle)
    581     {
    582        libusb_close (reader->sr_config.usb_dev_handle);
    583        reader->sr_config.usb_dev_handle=NULL;
     578    if (sr_config.usb_dev_handle)
     579    {
     580       libusb_close (sr_config.usb_dev_handle);
     581       sr_config.usb_dev_handle=NULL;
    584582    }
    585583
     
    590588int smartreader_usb_reset(S_READER *reader)
    591589{
    592     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     590    if (libusb_control_transfer(sr_config.usb_dev_handle,
    593591                                FTDI_DEVICE_OUT_REQTYPE,
    594592                                SIO_RESET_REQUEST,
    595593                                SIO_RESET_SIO,
    596                                 reader->sr_config.index,
     594                                sr_config.index,
    597595                                NULL,
    598596                                0,
    599                                 reader->sr_config.usb_write_timeout) != 0) {
     597                                sr_config.usb_write_timeout) != 0) {
    600598        cs_log("Smartreader reset failed");
    601599        return (-1);
     
    621619#endif
    622620
    623     ret=libusb_open(reader->sr_config.usb_dev,&reader->sr_config.usb_dev_handle);
     621    ret=libusb_open(sr_config.usb_dev,&sr_config.usb_dev_handle);
    624622    if (ret) {
    625623        cs_log("Smartreader usb_open() failed");
     
    634632    // detach operation might be denied and everything still works fine.
    635633    // Likely scenario is a static smartreader_sio kernel module.
    636     if (libusb_detach_kernel_driver(reader->sr_config.usb_dev_handle, reader->sr_config.interface) != 0 && errno != ENODATA) {
     634    if (libusb_detach_kernel_driver(sr_config.usb_dev_handle, sr_config.interface) != 0 && errno != ENODATA) {
    637635        detach_errno = errno;
    638636        cs_log("Couldn't detach interface from kernel. Please unload the FTDI drivers");
     
    640638    }
    641639#endif
    642     ret = libusb_get_device_descriptor(reader->sr_config.usb_dev, &desc);
     640    ret = libusb_get_device_descriptor(sr_config.usb_dev, &desc);
    643641
    644642#ifdef __WIN32__
     
    649647    if (desc.bNumConfigurations > 0)
    650648    {
    651         ret=libusb_get_configuration(reader->sr_config.usb_dev_handle,&config);
     649        ret=libusb_get_configuration(sr_config.usb_dev_handle,&config);
    652650       
    653651        // libusb-win32 on Windows 64 can return a null pointer for a valid device
    654         if (libusb_set_configuration(reader->sr_config.usb_dev_handle, config) &&
     652        if (libusb_set_configuration(sr_config.usb_dev_handle, config) &&
    655653            errno != EBUSY)
    656654        {
     
    668666#endif
    669667
    670     ret=libusb_claim_interface(reader->sr_config.usb_dev_handle, reader->sr_config.interface) ;
     668    ret=libusb_claim_interface(sr_config.usb_dev_handle, sr_config.interface) ;
    671669    if (ret!= 0)
    672670    {
     
    692690    if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
    693691            && desc.iSerialNumber == 0))
    694         reader->sr_config.type = TYPE_BM;
     692        sr_config.type = TYPE_BM;
    695693    else if (desc.bcdDevice == 0x200)
    696         reader->sr_config.type = TYPE_AM;
     694        sr_config.type = TYPE_AM;
    697695    else if (desc.bcdDevice == 0x500)
    698         reader->sr_config.type = TYPE_2232C;
     696        sr_config.type = TYPE_2232C;
    699697    else if (desc.bcdDevice == 0x600)
    700         reader->sr_config.type = TYPE_R;
     698        sr_config.type = TYPE_R;
    701699    else if (desc.bcdDevice == 0x700)
    702         reader->sr_config.type = TYPE_2232H;
     700        sr_config.type = TYPE_2232H;
    703701    else if (desc.bcdDevice == 0x800)
    704         reader->sr_config.type = TYPE_4232H;
     702        sr_config.type = TYPE_4232H;
    705703
    706704    // Set default interface on dual/quad type chips
    707     switch(reader->sr_config.type) {
     705    switch(sr_config.type) {
    708706        case TYPE_2232C:
    709707        case TYPE_2232H:
    710708        case TYPE_4232H:
    711             if (!reader->sr_config.index)
    712                 reader->sr_config.index = INTERFACE_A;
     709            if (!sr_config.index)
     710                sr_config.index = INTERFACE_A;
    713711            break;
    714712        default:
     
    717715
    718716    // Determine maximum packet size
    719     reader->sr_config.max_packet_size = smartreader_determine_max_packet_size(reader);
     717    sr_config.max_packet_size = smartreader_determine_max_packet_size(reader);
    720718
    721719    if (smartreader_set_baudrate (reader, 9600) != 0) {
     
    731729int smartreader_usb_purge_rx_buffer(S_READER *reader)
    732730{
    733     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     731    if (libusb_control_transfer(sr_config.usb_dev_handle,
    734732                                FTDI_DEVICE_OUT_REQTYPE,
    735733                                SIO_RESET_REQUEST,
    736734                                SIO_RESET_PURGE_RX,
    737                                 reader->sr_config.index,
     735                                sr_config.index,
    738736                                NULL,
    739737                                0,
    740                                 reader->sr_config.usb_write_timeout) != 0) {
     738                                sr_config.usb_write_timeout) != 0) {
    741739        cs_log("FTDI purge of RX buffer failed");
    742740        return (-1);
     
    749747int smartreader_usb_purge_tx_buffer(S_READER *reader)
    750748{
    751     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     749    if (libusb_control_transfer(sr_config.usb_dev_handle,
    752750                                FTDI_DEVICE_OUT_REQTYPE,
    753751                                SIO_RESET_REQUEST,
    754752                                SIO_RESET_PURGE_TX,
    755                                 reader->sr_config.index,
     753                                sr_config.index,
    756754                                NULL,
    757755                                0,
    758                                 reader->sr_config.usb_write_timeout) != 0) {
     756                                sr_config.usb_write_timeout) != 0) {
    759757        cs_log("FTDI purge of TX buffer failed");
    760758        return (-1);
     
    796794    divisor = 24000000 / baudrate;
    797795
    798     if (reader->sr_config.type == TYPE_AM)
     796    if (sr_config.type == TYPE_AM)
    799797    {
    800798        // Round down to supported fraction (AM only)
     
    818816            try_divisor = 8;
    819817        }
    820         else if (reader->sr_config.type != TYPE_AM && try_divisor < 12)
     818        else if (sr_config.type != TYPE_AM && try_divisor < 12)
    821819        {
    822820            // BM doesn't support divisors 9 through 11 inclusive
     
    830828        else
    831829        {
    832             if (reader->sr_config.type == TYPE_AM)
     830            if (sr_config.type == TYPE_AM)
    833831            {
    834832                // Round up to supported fraction (AM only)
     
    886884    // Split into "value" and "index" values
    887885    *value = (unsigned short)(encoded_divisor & 0xFFFF);
    888     if (reader->sr_config.type == TYPE_2232C || reader->sr_config.type == TYPE_2232H || reader->sr_config.type == TYPE_4232H)
     886    if (sr_config.type == TYPE_2232C || sr_config.type == TYPE_2232H || sr_config.type == TYPE_4232H)
    889887    {
    890888        *index = (unsigned short)(encoded_divisor >> 8);
    891889        *index &= 0xFF00;
    892         *index |= reader->sr_config.index;
     890        *index |= sr_config.index;
    893891    }
    894892    else
     
    904902    int actual_baudrate;
    905903
    906     if (reader->sr_config.bitbang_enabled)
     904    if (sr_config.bitbang_enabled)
    907905    {
    908906        baudrate = baudrate*4;
     
    924922    }
    925923
    926     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     924    if (libusb_control_transfer(sr_config.usb_dev_handle,
    927925                                FTDI_DEVICE_OUT_REQTYPE,
    928926                                SIO_SET_BAUDRATE_REQUEST,
     
    931929                                NULL,
    932930                                0,
    933                                 reader->sr_config.usb_write_timeout) != 0) {
     931                                sr_config.usb_write_timeout) != 0) {
    934932        cs_log("Setting new baudrate failed");
    935933        return (-2);
    936934    }
    937935
    938     reader->sr_config.baudrate = baudrate;
     936    sr_config.baudrate = baudrate;
    939937    return 0;
    940938}
     
    954952        usb_val |= SIO_SET_RTS_LOW;
    955953
    956     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     954    if (libusb_control_transfer(sr_config.usb_dev_handle,
    957955                                FTDI_DEVICE_OUT_REQTYPE,
    958956                                SIO_SET_MODEM_CTRL_REQUEST,
    959957                                usb_val,
    960                                 reader->sr_config.index,
     958                                sr_config.index,
    961959                                NULL,
    962960                                0,
    963                                 reader->sr_config.usb_write_timeout) != 0) {
     961                                sr_config.usb_write_timeout) != 0) {
    964962        cs_log("set of rts/dtr failed");
    965963        return (-1);
     
    971969int smartreader_setflowctrl(S_READER *reader, int flowctrl)
    972970{
    973     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     971    if (libusb_control_transfer(sr_config.usb_dev_handle,
    974972                                FTDI_DEVICE_OUT_REQTYPE,
    975973                                SIO_SET_FLOW_CTRL_REQUEST,
    976974                                0,
    977                                 (flowctrl | reader->sr_config.index),
     975                                (flowctrl | sr_config.index),
    978976                                NULL,
    979977                                0,
    980                                 reader->sr_config.usb_write_timeout) != 0) {
     978                                sr_config.usb_write_timeout) != 0) {
    981979        cs_log("set flow control failed");
    982980        return (-1);
     
    10341032    }
    10351033
    1036     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     1034    if (libusb_control_transfer(sr_config.usb_dev_handle,
    10371035                                FTDI_DEVICE_OUT_REQTYPE,
    10381036                                SIO_SET_DATA_REQUEST,
    10391037                                value,
    1040                                 reader->sr_config.index,
     1038                                sr_config.index,
    10411039                                NULL,
    10421040                                0,
    1043                                 reader->sr_config.usb_write_timeout) != 0) {
     1041                                sr_config.usb_write_timeout) != 0) {
    10441042        cs_log("Setting new line property failed");
    10451043        return (-1);
     
    10631061    smartreader_usb_purge_buffers(reader);
    10641062
    1065     pthread_mutex_lock(&reader->g_read_mutex);
    1066     reader->g_read_buffer_size = 0;
    1067     pthread_mutex_unlock(&reader->g_read_mutex);
     1063    pthread_mutex_lock(&g_read_mutex);
     1064    g_read_buffer_size = 0;
     1065    pthread_mutex_unlock(&g_read_mutex);
    10681066    sched_yield();
    10691067}
     
    10781076   
    10791077    while(total_read < size && dif.tv_sec < timeout_sec) {
    1080         pthread_mutex_lock(&reader->g_read_mutex);
     1078        pthread_mutex_lock(&g_read_mutex);
    10811079       
    1082         if(reader->g_read_buffer_size > 0) {
     1080        if(g_read_buffer_size > 0) {
    10831081       
    1084             ret = reader->g_read_buffer_size > size-total_read ? size-total_read : reader->g_read_buffer_size;
    1085             memcpy(buff+total_read,reader->g_read_buffer,ret);
    1086             reader->g_read_buffer_size -= ret;
    1087 
    1088         if(reader->g_read_buffer_size > 0){
    1089         memcpy(reader->g_read_buffer, reader->g_read_buffer + ret, reader->g_read_buffer_size);
     1082            ret = g_read_buffer_size > size-total_read ? size-total_read : g_read_buffer_size;
     1083            memcpy(buff+total_read,g_read_buffer,ret);
     1084            g_read_buffer_size -= ret;
     1085
     1086        if(g_read_buffer_size > 0){
     1087        memcpy(g_read_buffer, g_read_buffer + ret, g_read_buffer_size);
    10901088        }
    10911089
    10921090            total_read+=ret;
    10931091        }
    1094         pthread_mutex_unlock(&reader->g_read_mutex);
     1092        pthread_mutex_unlock(&g_read_mutex);
    10951093       
    10961094        gettimeofday(&now,NULL);
     
    11161114    int written;
    11171115     
    1118     if(size<reader->sr_config.writebuffer_chunksize)
     1116    if(size<sr_config.writebuffer_chunksize)
    11191117        write_size=size;
    11201118    else
    1121         write_size = reader->sr_config.writebuffer_chunksize;
     1119        write_size = sr_config.writebuffer_chunksize;
    11221120
    11231121    while (offset < size)
     
    11271125            write_size = size-offset;
    11281126
    1129         ret = libusb_bulk_transfer(reader->sr_config.usb_dev_handle,
    1130                                     reader->sr_config.in_ep,
     1127        ret = libusb_bulk_transfer(sr_config.usb_dev_handle,
     1128                                    sr_config.in_ep,
    11311129                                    buf+offset,
    11321130                                    write_size,
    11331131                                    &written,
    1134                                     reader->sr_config.usb_write_timeout);
     1132                                    sr_config.usb_write_timeout);
    11351133        if (ret < 0) {
    11361134            cs_log("usb bulk write failed : ret = %d",ret);
     
    11551153
    11561154    usb_val = latency;
    1157     if (libusb_control_transfer(reader->sr_config.usb_dev_handle,
     1155    if (libusb_control_transfer(sr_config.usb_dev_handle,
    11581156                        FTDI_DEVICE_OUT_REQTYPE,
    11591157                        SIO_SET_LATENCY_TIMER_REQUEST,
    11601158                        usb_val,
    1161                         reader->sr_config.index,
     1159                        sr_config.index,
    11621160                        NULL,
    11631161                        0,
    1164                         reader->sr_config.usb_write_timeout) != 0) {
     1162                        sr_config.usb_write_timeout) != 0) {
    11651163        cs_log("unable to set latency timer");
    11661164        return (-2);
     
    12071205        if(transfer->actual_length > 2) {  //FTDI always sends modem status bytes as first 2 chars with the 232BM
    12081206
    1209             pthread_mutex_lock(&reader->g_read_mutex);
    1210 
    1211             if(reader->g_read_buffer_size == sizeof(reader->g_read_buffer)) {
     1207            pthread_mutex_lock(&g_read_mutex);
     1208
     1209            if(g_read_buffer_size == sizeof(g_read_buffer)) {
    12121210                cs_log("IO:SR: buffer full\n");
    12131211                //if out read buffer is full then delay
     
    12161214                if(ret!=0)
    12171215                    cs_log("IO:SR: submit async transfer failed with error %d\n",ret);         
    1218                 pthread_mutex_unlock(&reader->g_read_mutex);
     1216                pthread_mutex_unlock(&g_read_mutex);
    12191217                return;
    12201218             }
    12211219
    1222             reader->modem_status = transfer->buffer[1];
    1223             copy_size = sizeof(reader->g_read_buffer) - reader->g_read_buffer_size > (unsigned int)transfer->actual_length-2 ? (unsigned int)transfer->actual_length-2: sizeof(reader->g_read_buffer) - reader->g_read_buffer_size;
    1224             memcpy(reader->g_read_buffer+reader->g_read_buffer_size,transfer->buffer+2,copy_size);
    1225             reader->g_read_buffer_size += copy_size;
    1226             pthread_mutex_unlock(&reader->g_read_mutex);
     1220            modem_status = transfer->buffer[1];
     1221            copy_size = sizeof(g_read_buffer) - g_read_buffer_size > (unsigned int)transfer->actual_length-2 ? (unsigned int)transfer->actual_length-2: sizeof(g_read_buffer) - g_read_buffer_size;
     1222            memcpy(g_read_buffer+g_read_buffer_size,transfer->buffer+2,copy_size);
     1223            g_read_buffer_size += copy_size;
     1224            pthread_mutex_unlock(&g_read_mutex);
    12271225        }
    12281226        else {
    12291227            if(transfer->actual_length==2) {
    1230                 pthread_mutex_lock(&reader->g_read_mutex);
    1231                 reader->modem_status=transfer->buffer[1];
    1232                 pthread_mutex_unlock(&reader->g_read_mutex);
     1228                pthread_mutex_lock(&g_read_mutex);
     1229                modem_status=transfer->buffer[1];
     1230                pthread_mutex_unlock(&g_read_mutex);
    12331231            }
    12341232        }
     
    12551253   
    12561254    reader = (struct s_reader *)p;
    1257     reader->sr_config.running=TRUE;
     1255    sr_config.running=TRUE;
    12581256
    12591257    for(idx=0; idx<NUM_TXFERS; idx++) {
     
    12611259
    12621260         libusb_fill_bulk_transfer( usbt[idx],
    1263                                     reader->sr_config.usb_dev_handle,
    1264                                     reader->sr_config.out_ep,
     1261                                    sr_config.usb_dev_handle,
     1262                                    sr_config.out_ep,
    12651263                                    usb_buffers[idx],
    12661264                                    64,
     
    12721270    }
    12731271
    1274     while(reader->sr_config.running) {
     1272    while(sr_config.running) {
    12751273        ret = libusb_handle_events(NULL);
    12761274        if(ret!=0)
  • trunk/csctapi/ifd_smartreader.h

    r1419 r1719  
    2929int SR_Receive (struct s_reader *reader, BYTE * buffer, unsigned size);
    3030int SR_SetBaudrate (struct s_reader *reader);
    31 int SR_SetParity (struct s_reader *reader);
     31int SR_SetParity (struct s_reader *reader, unsigned short parity);
    3232int SR_Close (struct s_reader *reader);
    3333
  • trunk/globals.h

    r1718 r1719  
    524524  DWORD dwActiveProtocol;
    525525#endif
    526 #if defined(LIBUSB)
    527     unsigned char g_read_buffer[4096];
    528     unsigned int g_read_buffer_size;
    529     pthread_mutex_t g_read_mutex;
    530     pthread_mutex_t g_usb_mutex;
    531     struct usb_device *smartreader_usb_dev;
    532     pthread_t rt;
    533     unsigned char modem_status;
    534     SR_CONFIG sr_config;
    535 #endif
    536526};
    537527
Note: See TracChangeset for help on using the changeset viewer.