Changeset 1723


Ignore:
Timestamp:
02/26/10 19:05:09 (11 years ago)
Author:
merek
Message:

Merge from UMP r1794

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Makefile

    r1722 r1723  
    6868        OS_CULI="-lncurses" \
    6969        OS_PTLI="-lpthread" \
    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)\""'" \
     70        DS_OPTS="-O2 -DOS_LINUX -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="" \
     
    8989        OS_CULI="-lncurses" \
    9090        OS_PTLI="-lpthread" \
    91         DS_OPTS="-O2 -DOS_LINUX -DUSE_PTHREAD -DLIBUSB -DCS_CONFDIR=${CS_CONFDIR} -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
     91        DS_OPTS="-O2 -DOS_LINUX -DLIBUSB -DCS_CONFDIR=${CS_CONFDIR} -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
    9292        DS_CFLAGS="-c" \
    9393        DS_LDFLAGS="" \
     
    132132        OS_CULI="-lncurses" \
    133133        OS_PTLI="-lpthread -lpcsclite" \
    134         DS_OPTS="-O2 -DOS_LINUX -DUSE_PTHREAD -DLIBUSB -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -I/usr/include/PCSC -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
     134        DS_OPTS="-O2 -DOS_LINUX -DLIBUSB -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -I/usr/include/PCSC -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
    135135        DS_CFLAGS="-c" \
    136136        DS_LDFLAGS="" \
     
    153153        OS_CULI="-lncurses" \
    154154        OS_PTLI="-lpthread" \
    155         DS_OPTS="-O2 -DOS_MACOSX -DNEED_DAEMON -DCS_NOSHM -DHAVE_PTHREAD_H -DUSE_PTHREAD -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -m32 -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""'" \
     155        DS_OPTS="-O2 -DOS_MACOSX -DNEED_DAEMON -DCS_NOSHM -DHAVE_PTHREAD_H -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -m32 -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""'" \
    156156        DS_CFLAGS="-c" \
    157157        DS_LDFLAGS="-framework PCSC" \
     
    175175        OS_CULI="-lncurses" \
    176176        OS_PTLI="-lpthread" \
    177         DS_OPTS="-O2 -DOS_MACOSX -DNEED_DAEMON -DCS_NOSHM -DHAVE_PTHREAD_H -DUSE_PTHREAD -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -DLIBUSB -m32 -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
     177        DS_OPTS="-O2 -DOS_MACOSX -DNEED_DAEMON -DCS_NOSHM -DHAVE_PTHREAD_H -DCS_CONFDIR=${CS_CONFDIR} -DHAVE_PCSC=1 -DLIBUSB -m32 -Winline -Wall -Wextra -finline-functions -fomit-frame-pointer -D'CS_SVN_VERSION="\"$(SVN_REV)\""' -I/usr/local/include" \
    178178        DS_CFLAGS="-c" \
    179179        DS_LDFLAGS="-framework PCSC -Wl,-framework -Wl,IOKit -Wl,-framework -Wl,CoreFoundation -Wl,-prebind -no-undefined" \
  • trunk/csctapi/ifd_smartreader.c

    r1719 r1723  
    1616
    1717//local globals
    18 unsigned char g_read_buffer[4096];
    19 unsigned int g_read_buffer_size;
    20 pthread_mutex_t g_read_mutex;
    21 pthread_mutex_t g_usb_mutex;
    22 //struct usb_device *smartreader_usb_dev;
    23 pthread_t rt;
    24 unsigned char modem_status;
    2518SR_CONFIG sr_config;
    2619
     
    7366        return ERROR;
    7467    }
    75 
     68    reader->sr_config=malloc(sizeof(SR_CONFIG));
     69    if(!reader) {
     70        cs_log("Couldn't allocate memory for Device=%s config",reader->device);
     71        return ERROR;
     72    }
    7673    cs_debug_mask (D_IFD,"IO:SR: Looking for device %s on bus %s",devname,busname);
    7774
     
    8481    smartreader_init(reader);
    8582
    86     sr_config.usb_dev=find_smartreader(busname,devname);
    87     if(!sr_config.usb_dev)
     83    reader->sr_config->usb_dev=find_smartreader(busname,devname);
     84    if(!reader->sr_config->usb_dev)
    8885        return ERROR;
    8986
     
    9390    //also a good way to compare a real FT232 with a smartreader
    9491    //if you enumarate usb devices
    95     sr_config.in_ep = 0x1;
    96     sr_config.out_ep = 0x82;
     92    reader->sr_config->in_ep = 0x1;
     93    reader->sr_config->out_ep = 0x82;
    9794
    9895    //open the first smartreader found in the system, this
     
    122119
    123120    // start the reading thread
    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));
     121    reader->sr_config->g_read_buffer_size = 0;
     122    reader->sr_config->modem_status = 0 ;
     123    pthread_mutex_init(&reader->sr_config->g_read_mutex,NULL);
     124    pthread_mutex_init(&reader->sr_config->g_usb_mutex,NULL);
     125    ret = pthread_create(&reader->sr_config->rt, NULL, ReaderThread, (void *)(reader));
    129126    if (ret) {
    130127        cs_log("ERROR; return code from pthread_create() is %d", ret);
     
    140137    int state;
    141138
    142     pthread_mutex_lock(&g_read_mutex);
    143     state =(modem_status & 0x80) == 0x80 ? 0 : 2;
    144     pthread_mutex_unlock(&g_read_mutex);
     139    pthread_mutex_lock(&reader->sr_config->g_read_mutex);
     140    state =(reader->sr_config->modem_status & 0x80) == 0x80 ? 0 : 2;
     141    pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    145142
    146143   
     
    166163   
    167164    if(reader->mhz==reader->cardmhz && reader->cardmhz*10000 > 3690000)
    168         sr_config.fs=reader->cardmhz*10000;
     165        reader->sr_config->fs=reader->cardmhz*10000;
    169166    else   
    170         sr_config.fs=3690000;
     167        reader->sr_config->fs=3690000;
    171168
    172169    smart_flush(reader);
    173170    // set smartreader+ default values
    174     sr_config.F=372;
    175     sr_config.D=1.0;
     171    reader->sr_config->F=372;
     172    reader->sr_config->D=1.0;
    176173    if(reader->mhz==reader->cardmhz && reader->cardmhz*10000 > 3690000)
    177         sr_config.fs=reader->cardmhz*10000;
     174        reader->sr_config->fs=reader->cardmhz*10000;
    178175    else   
    179         sr_config.fs=3690000;
    180     sr_config.N=0;
    181     sr_config.T=0;
    182     sr_config.inv=0;
     176        reader->sr_config->fs=3690000;
     177    reader->sr_config->N=0;
     178    reader->sr_config->T=0;
     179    reader->sr_config->inv=0;
    183180
    184181    for(i=0 ; i < 4 ;i++) {
    185         sr_config.irdeto=FALSE;
     182        reader->sr_config->irdeto=FALSE;
    186183        atr_ok=ERROR;
    187184        memset(data,0,sizeof(data));
     
    192189        if(i==3) {
    193190            cs_debug_mask (D_IFD,"IO:SR: Trying irdeto");
    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;
     191            reader->sr_config->F=618; /// magic smartreader value
     192            reader->sr_config->D=1;
     193            reader->sr_config->T=2; // will be set to T=1 in EnableSmartReader
     194            reader->sr_config->irdeto=TRUE;
    198195        }
    199196       
    200197        smart_flush(reader);
    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]);
     198        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,parity[i]);
    202199        sched_yield();
    203200        cs_sleepms(500); //smartreader in mouse mode needs this, so it might also be needed in native mode.
     
    226223
    227224        if(data[0]!=0x3B && data[0]!=0x03 && data[0]!=0x3F) {
    228             sr_config.irdeto=FALSE;
     225            reader->sr_config->irdeto=FALSE;
    229226            continue; // this is not a valid ATR.
    230227        }
     
    233230            cs_debug_mask (D_IFD,"IO:SR: Inverse convention detected, setting smartreader inv to 1");
    234231
    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]);
     232            reader->sr_config->inv=1;
     233            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,parity[i]);
    237234        }
    238235        // parse atr
     
    242239            if(i==3) {
    243240                cs_debug_mask (D_IFD,"IO:SR: Locking F and D for Irdeto mode");
    244                 sr_config.irdeto=TRUE;
     241                reader->sr_config->irdeto=TRUE;
    245242            }
    246243        }
     
    278275{
    279276//      maintaining all this admin seems overdone, since after this init the values are nowhere needed
    280 //      reader[ridx].sr_config.F=F;
    281 //      reader[ridx].sr_config.D=D;
    282 //      reader[ridx].sr_config.N=N;
    283 //      reader[ridx].sr_config.T=T;
    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);
     277//      reader[ridx].reader->sr_config->F=F;
     278//      reader[ridx].reader->sr_config->D=D;
     279//      reader[ridx].reader->sr_config->N=N;
     280//      reader[ridx].reader->sr_config->T=T;
     281//   reader->sr_config->fs=reader->mhz*10000; //freq in Hz */
     282//    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);
    286283       
    287284    // 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 
     285        reader->sr_config->inv = convention;//FIXME this one is set by icc_async and local smartreader reset routine 
    289286        if (reader->mhz >=1600) reader->mhz = 1600; else
    290287        if (reader->mhz >=1200) reader->mhz = 1200; else
     
    300297        if (reader->mhz >=343)  reader->mhz =  343; else
    301298            reader->mhz =  320;
    302     EnableSmartReader(reader, reader->mhz, F, D, N, T, sr_config.inv,sr_config.parity);
     299    EnableSmartReader(reader, reader->mhz, F, D, N, T, reader->sr_config->inv,reader->sr_config->parity);
    303300
    304301    //baud rate not really used in native mode since
     
    331328    cs_debug_mask(D_IFD,"IO:SR: Closing smarteader\n");
    332329
    333     sr_config.running=FALSE;
    334     pthread_join(rt,NULL);
    335     libusb_close(sr_config.usb_dev_handle);
     330    reader->sr_config->running=FALSE;
     331    pthread_join(reader->sr_config->rt,NULL);
     332    libusb_close(reader->sr_config->usb_dev_handle);
    336333    libusb_exit(NULL);
     334    free(reader->sr_config);
    337335    return OK;
    338336
     
    355353
    356354    // command 1, set F and D parameter
    357     if(!sr_config.irdeto) {
     355    if(!reader->sr_config->irdeto) {
    358356        cs_debug_mask (D_IFD,"IO:SR: sending F=%04X (%d) to smartreader",Fi,Fi);
    359357        cs_debug_mask (D_IFD,"IO:SR: sending D=%02X (%d) to smartreader",Di,Di);
     
    384382
    385383    // command 4 , set parameter T
    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
     384    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
    387385        {
    388386        T=1;
    389         sr_config.T=1;
     387        reader->sr_config->T=1;
    390388        }
    391389    else if (T==1)
     
    505503void smartreader_init(S_READER *reader)
    506504{
    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;
     505    reader->sr_config->usb_dev = NULL;
     506    reader->sr_config->usb_dev_handle=NULL;
     507    reader->sr_config->usb_read_timeout = 10000;
     508    reader->sr_config->usb_write_timeout = 10000;
     509
     510    reader->sr_config->type = TYPE_BM;    /* chip type */
     511    reader->sr_config->baudrate = -1;
     512    reader->sr_config->bitbang_enabled = 0;  /* 0: normal mode 1: any of the bitbang modes enabled */
     513
     514    reader->sr_config->writebuffer_chunksize = 64;
     515    reader->sr_config->max_packet_size = 0;
     516
     517    reader->sr_config->interface = INTERFACE_ANY;
     518    reader->sr_config->index = INTERFACE_A;
     519    reader->sr_config->in_ep = 0x02;
     520    reader->sr_config->out_ep = 0x82;
    523521}
    524522
     
    536534    // New hi-speed devices from FTDI use a packet size of 512 bytes
    537535    // but could be connected to a normal speed USB hub -> 64 bytes packet size.
    538     if (sr_config.type == TYPE_2232H || sr_config.type == TYPE_4232H)
     536    if (reader->sr_config->type == TYPE_2232H || reader->sr_config->type == TYPE_4232H)
    539537        packet_size = 512;
    540538    else
    541539        packet_size = 64;
    542540
    543     ret = libusb_get_device_descriptor(sr_config.usb_dev, &desc);
     541    ret = libusb_get_device_descriptor(reader->sr_config->usb_dev, &desc);
    544542    if (ret < 0) {
    545543        cs_log("Smartreader : couldn't read device descriptor , using default packet size");
     
    548546    if (desc.bNumConfigurations)
    549547    {
    550         ret=libusb_get_active_config_descriptor(sr_config.usb_dev,&configDesc);
     548        ret=libusb_get_active_config_descriptor(reader->sr_config->usb_dev,&configDesc);
    551549        if(ret) {
    552550            cs_log("Smartreader : couldn't read config descriptor , using default packet size");
     
    554552        }
    555553
    556         if (sr_config.interface < configDesc->bNumInterfaces)
     554        if (reader->sr_config->interface < configDesc->bNumInterfaces)
    557555        {
    558             interface=configDesc->interface[sr_config.interface];
     556            interface=configDesc->interface[reader->sr_config->interface];
    559557            if (interface.num_altsetting > 0)
    560558            {
     
    576574    int ret = 0;
    577575
    578     if (sr_config.usb_dev_handle)
    579     {
    580        libusb_close (sr_config.usb_dev_handle);
    581        sr_config.usb_dev_handle=NULL;
     576    if (reader->sr_config->usb_dev_handle)
     577    {
     578       libusb_close (reader->sr_config->usb_dev_handle);
     579       reader->sr_config->usb_dev_handle=NULL;
    582580    }
    583581
     
    588586int smartreader_usb_reset(S_READER *reader)
    589587{
    590     if (libusb_control_transfer(sr_config.usb_dev_handle,
     588    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    591589                                FTDI_DEVICE_OUT_REQTYPE,
    592590                                SIO_RESET_REQUEST,
    593591                                SIO_RESET_SIO,
    594                                 sr_config.index,
     592                                reader->sr_config->index,
    595593                                NULL,
    596594                                0,
    597                                 sr_config.usb_write_timeout) != 0) {
     595                                reader->sr_config->usb_write_timeout) != 0) {
    598596        cs_log("Smartreader reset failed");
    599597        return (-1);
     
    619617#endif
    620618
    621     ret=libusb_open(sr_config.usb_dev,&sr_config.usb_dev_handle);
     619    ret=libusb_open(reader->sr_config->usb_dev,&reader->sr_config->usb_dev_handle);
    622620    if (ret) {
    623621        cs_log("Smartreader usb_open() failed");
     
    632630    // detach operation might be denied and everything still works fine.
    633631    // Likely scenario is a static smartreader_sio kernel module.
    634     if (libusb_detach_kernel_driver(sr_config.usb_dev_handle, sr_config.interface) != 0 && errno != ENODATA) {
     632    if (libusb_detach_kernel_driver(reader->sr_config->usb_dev_handle, reader->sr_config->interface) != 0 && errno != ENODATA) {
    635633        detach_errno = errno;
    636634        cs_log("Couldn't detach interface from kernel. Please unload the FTDI drivers");
     
    638636    }
    639637#endif
    640     ret = libusb_get_device_descriptor(sr_config.usb_dev, &desc);
     638    ret = libusb_get_device_descriptor(reader->sr_config->usb_dev, &desc);
    641639
    642640#ifdef __WIN32__
     
    647645    if (desc.bNumConfigurations > 0)
    648646    {
    649         ret=libusb_get_configuration(sr_config.usb_dev_handle,&config);
     647        ret=libusb_get_configuration(reader->sr_config->usb_dev_handle,&config);
    650648       
    651649        // libusb-win32 on Windows 64 can return a null pointer for a valid device
    652         if (libusb_set_configuration(sr_config.usb_dev_handle, config) &&
     650        if (libusb_set_configuration(reader->sr_config->usb_dev_handle, config) &&
    653651            errno != EBUSY)
    654652        {
     
    666664#endif
    667665
    668     ret=libusb_claim_interface(sr_config.usb_dev_handle, sr_config.interface) ;
     666    ret=libusb_claim_interface(reader->sr_config->usb_dev_handle, reader->sr_config->interface) ;
    669667    if (ret!= 0)
    670668    {
     
    690688    if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
    691689            && desc.iSerialNumber == 0))
    692         sr_config.type = TYPE_BM;
     690        reader->sr_config->type = TYPE_BM;
    693691    else if (desc.bcdDevice == 0x200)
    694         sr_config.type = TYPE_AM;
     692        reader->sr_config->type = TYPE_AM;
    695693    else if (desc.bcdDevice == 0x500)
    696         sr_config.type = TYPE_2232C;
     694        reader->sr_config->type = TYPE_2232C;
    697695    else if (desc.bcdDevice == 0x600)
    698         sr_config.type = TYPE_R;
     696        reader->sr_config->type = TYPE_R;
    699697    else if (desc.bcdDevice == 0x700)
    700         sr_config.type = TYPE_2232H;
     698        reader->sr_config->type = TYPE_2232H;
    701699    else if (desc.bcdDevice == 0x800)
    702         sr_config.type = TYPE_4232H;
     700        reader->sr_config->type = TYPE_4232H;
    703701
    704702    // Set default interface on dual/quad type chips
    705     switch(sr_config.type) {
     703    switch(reader->sr_config->type) {
    706704        case TYPE_2232C:
    707705        case TYPE_2232H:
    708706        case TYPE_4232H:
    709             if (!sr_config.index)
    710                 sr_config.index = INTERFACE_A;
     707            if (!reader->sr_config->index)
     708                reader->sr_config->index = INTERFACE_A;
    711709            break;
    712710        default:
     
    715713
    716714    // Determine maximum packet size
    717     sr_config.max_packet_size = smartreader_determine_max_packet_size(reader);
     715    reader->sr_config->max_packet_size = smartreader_determine_max_packet_size(reader);
    718716
    719717    if (smartreader_set_baudrate (reader, 9600) != 0) {
     
    729727int smartreader_usb_purge_rx_buffer(S_READER *reader)
    730728{
    731     if (libusb_control_transfer(sr_config.usb_dev_handle,
     729    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    732730                                FTDI_DEVICE_OUT_REQTYPE,
    733731                                SIO_RESET_REQUEST,
    734732                                SIO_RESET_PURGE_RX,
    735                                 sr_config.index,
     733                                reader->sr_config->index,
    736734                                NULL,
    737735                                0,
    738                                 sr_config.usb_write_timeout) != 0) {
     736                                reader->sr_config->usb_write_timeout) != 0) {
    739737        cs_log("FTDI purge of RX buffer failed");
    740738        return (-1);
     
    747745int smartreader_usb_purge_tx_buffer(S_READER *reader)
    748746{
    749     if (libusb_control_transfer(sr_config.usb_dev_handle,
     747    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    750748                                FTDI_DEVICE_OUT_REQTYPE,
    751749                                SIO_RESET_REQUEST,
    752750                                SIO_RESET_PURGE_TX,
    753                                 sr_config.index,
     751                                reader->sr_config->index,
    754752                                NULL,
    755753                                0,
    756                                 sr_config.usb_write_timeout) != 0) {
     754                                reader->sr_config->usb_write_timeout) != 0) {
    757755        cs_log("FTDI purge of TX buffer failed");
    758756        return (-1);
     
    794792    divisor = 24000000 / baudrate;
    795793
    796     if (sr_config.type == TYPE_AM)
     794    if (reader->sr_config->type == TYPE_AM)
    797795    {
    798796        // Round down to supported fraction (AM only)
     
    816814            try_divisor = 8;
    817815        }
    818         else if (sr_config.type != TYPE_AM && try_divisor < 12)
     816        else if (reader->sr_config->type != TYPE_AM && try_divisor < 12)
    819817        {
    820818            // BM doesn't support divisors 9 through 11 inclusive
     
    828826        else
    829827        {
    830             if (sr_config.type == TYPE_AM)
     828            if (reader->sr_config->type == TYPE_AM)
    831829            {
    832830                // Round up to supported fraction (AM only)
     
    884882    // Split into "value" and "index" values
    885883    *value = (unsigned short)(encoded_divisor & 0xFFFF);
    886     if (sr_config.type == TYPE_2232C || sr_config.type == TYPE_2232H || sr_config.type == TYPE_4232H)
     884    if (reader->sr_config->type == TYPE_2232C || reader->sr_config->type == TYPE_2232H || reader->sr_config->type == TYPE_4232H)
    887885    {
    888886        *index = (unsigned short)(encoded_divisor >> 8);
    889887        *index &= 0xFF00;
    890         *index |= sr_config.index;
     888        *index |= reader->sr_config->index;
    891889    }
    892890    else
     
    902900    int actual_baudrate;
    903901
    904     if (sr_config.bitbang_enabled)
     902    if (reader->sr_config->bitbang_enabled)
    905903    {
    906904        baudrate = baudrate*4;
     
    922920    }
    923921
    924     if (libusb_control_transfer(sr_config.usb_dev_handle,
     922    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    925923                                FTDI_DEVICE_OUT_REQTYPE,
    926924                                SIO_SET_BAUDRATE_REQUEST,
     
    929927                                NULL,
    930928                                0,
    931                                 sr_config.usb_write_timeout) != 0) {
     929                                reader->sr_config->usb_write_timeout) != 0) {
    932930        cs_log("Setting new baudrate failed");
    933931        return (-2);
    934932    }
    935933
    936     sr_config.baudrate = baudrate;
     934    reader->sr_config->baudrate = baudrate;
    937935    return 0;
    938936}
     
    952950        usb_val |= SIO_SET_RTS_LOW;
    953951
    954     if (libusb_control_transfer(sr_config.usb_dev_handle,
     952    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    955953                                FTDI_DEVICE_OUT_REQTYPE,
    956954                                SIO_SET_MODEM_CTRL_REQUEST,
    957955                                usb_val,
    958                                 sr_config.index,
     956                                reader->sr_config->index,
    959957                                NULL,
    960958                                0,
    961                                 sr_config.usb_write_timeout) != 0) {
     959                                reader->sr_config->usb_write_timeout) != 0) {
    962960        cs_log("set of rts/dtr failed");
    963961        return (-1);
     
    969967int smartreader_setflowctrl(S_READER *reader, int flowctrl)
    970968{
    971     if (libusb_control_transfer(sr_config.usb_dev_handle,
     969    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    972970                                FTDI_DEVICE_OUT_REQTYPE,
    973971                                SIO_SET_FLOW_CTRL_REQUEST,
    974972                                0,
    975                                 (flowctrl | sr_config.index),
     973                                (flowctrl | reader->sr_config->index),
    976974                                NULL,
    977975                                0,
    978                                 sr_config.usb_write_timeout) != 0) {
     976                                reader->sr_config->usb_write_timeout) != 0) {
    979977        cs_log("set flow control failed");
    980978        return (-1);
     
    10321030    }
    10331031
    1034     if (libusb_control_transfer(sr_config.usb_dev_handle,
     1032    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    10351033                                FTDI_DEVICE_OUT_REQTYPE,
    10361034                                SIO_SET_DATA_REQUEST,
    10371035                                value,
    1038                                 sr_config.index,
     1036                                reader->sr_config->index,
    10391037                                NULL,
    10401038                                0,
    1041                                 sr_config.usb_write_timeout) != 0) {
     1039                                reader->sr_config->usb_write_timeout) != 0) {
    10421040        cs_log("Setting new line property failed");
    10431041        return (-1);
     
    10611059    smartreader_usb_purge_buffers(reader);
    10621060
    1063     pthread_mutex_lock(&g_read_mutex);
    1064     g_read_buffer_size = 0;
    1065     pthread_mutex_unlock(&g_read_mutex);
     1061    pthread_mutex_lock(&reader->sr_config->g_read_mutex);
     1062    reader->sr_config->g_read_buffer_size = 0;
     1063    pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    10661064    sched_yield();
    10671065}
     
    10761074   
    10771075    while(total_read < size && dif.tv_sec < timeout_sec) {
    1078         pthread_mutex_lock(&g_read_mutex);
     1076        pthread_mutex_lock(&reader->sr_config->g_read_mutex);
    10791077       
    1080         if(g_read_buffer_size > 0) {
     1078        if(reader->sr_config->g_read_buffer_size > 0) {
    10811079       
    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);
     1080            ret = reader->sr_config->g_read_buffer_size > size-total_read ? size-total_read : reader->sr_config->g_read_buffer_size;
     1081            memcpy(buff+total_read,reader->sr_config->g_read_buffer,ret);
     1082            reader->sr_config->g_read_buffer_size -= ret;
     1083
     1084        if(reader->sr_config->g_read_buffer_size > 0){
     1085        memcpy(reader->sr_config->g_read_buffer, reader->sr_config->g_read_buffer + ret, reader->sr_config->g_read_buffer_size);
    10881086        }
    10891087
    10901088            total_read+=ret;
    10911089        }
    1092         pthread_mutex_unlock(&g_read_mutex);
     1090        pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    10931091       
    10941092        gettimeofday(&now,NULL);
     
    11141112    int written;
    11151113     
    1116     if(size<sr_config.writebuffer_chunksize)
     1114    if(size<reader->sr_config->writebuffer_chunksize)
    11171115        write_size=size;
    11181116    else
    1119         write_size = sr_config.writebuffer_chunksize;
     1117        write_size = reader->sr_config->writebuffer_chunksize;
    11201118
    11211119    while (offset < size)
     
    11251123            write_size = size-offset;
    11261124
    1127         ret = libusb_bulk_transfer(sr_config.usb_dev_handle,
    1128                                     sr_config.in_ep,
     1125        ret = libusb_bulk_transfer(reader->sr_config->usb_dev_handle,
     1126                                    reader->sr_config->in_ep,
    11291127                                    buf+offset,
    11301128                                    write_size,
    11311129                                    &written,
    1132                                     sr_config.usb_write_timeout);
     1130                                    reader->sr_config->usb_write_timeout);
    11331131        if (ret < 0) {
    11341132            cs_log("usb bulk write failed : ret = %d",ret);
     
    11531151
    11541152    usb_val = latency;
    1155     if (libusb_control_transfer(sr_config.usb_dev_handle,
     1153    if (libusb_control_transfer(reader->sr_config->usb_dev_handle,
    11561154                        FTDI_DEVICE_OUT_REQTYPE,
    11571155                        SIO_SET_LATENCY_TIMER_REQUEST,
    11581156                        usb_val,
    1159                         sr_config.index,
     1157                        reader->sr_config->index,
    11601158                        NULL,
    11611159                        0,
    1162                         sr_config.usb_write_timeout) != 0) {
     1160                        reader->sr_config->usb_write_timeout) != 0) {
    11631161        cs_log("unable to set latency timer");
    11641162        return (-2);
     
    12051203        if(transfer->actual_length > 2) {  //FTDI always sends modem status bytes as first 2 chars with the 232BM
    12061204
    1207             pthread_mutex_lock(&g_read_mutex);
    1208 
    1209             if(g_read_buffer_size == sizeof(g_read_buffer)) {
     1205            pthread_mutex_lock(&reader->sr_config->g_read_mutex);
     1206
     1207            if(reader->sr_config->g_read_buffer_size == sizeof(reader->sr_config->g_read_buffer)) {
    12101208                cs_log("IO:SR: buffer full\n");
    12111209                //if out read buffer is full then delay
     
    12141212                if(ret!=0)
    12151213                    cs_log("IO:SR: submit async transfer failed with error %d\n",ret);         
    1216                 pthread_mutex_unlock(&g_read_mutex);
     1214                pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    12171215                return;
    12181216             }
    12191217
    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);
     1218            reader->sr_config->modem_status = transfer->buffer[1];
     1219            copy_size = sizeof(reader->sr_config->g_read_buffer) - reader->sr_config->g_read_buffer_size > (unsigned int)transfer->actual_length-2 ? (unsigned int)transfer->actual_length-2: sizeof(reader->sr_config->g_read_buffer) - reader->sr_config->g_read_buffer_size;
     1220            memcpy(reader->sr_config->g_read_buffer+reader->sr_config->g_read_buffer_size,transfer->buffer+2,copy_size);
     1221            reader->sr_config->g_read_buffer_size += copy_size;
     1222            pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    12251223        }
    12261224        else {
    12271225            if(transfer->actual_length==2) {
    1228                 pthread_mutex_lock(&g_read_mutex);
    1229                 modem_status=transfer->buffer[1];
    1230                 pthread_mutex_unlock(&g_read_mutex);
     1226                pthread_mutex_lock(&reader->sr_config->g_read_mutex);
     1227                reader->sr_config->modem_status=transfer->buffer[1];
     1228                pthread_mutex_unlock(&reader->sr_config->g_read_mutex);
    12311229            }
    12321230        }
     
    12531251   
    12541252    reader = (struct s_reader *)p;
    1255     sr_config.running=TRUE;
     1253    reader->sr_config->running=TRUE;
    12561254
    12571255    for(idx=0; idx<NUM_TXFERS; idx++) {
     
    12591257
    12601258         libusb_fill_bulk_transfer( usbt[idx],
    1261                                     sr_config.usb_dev_handle,
    1262                                     sr_config.out_ep,
     1259                                    reader->sr_config->usb_dev_handle,
     1260                                    reader->sr_config->out_ep,
    12631261                                    usb_buffers[idx],
    12641262                                    64,
     
    12701268    }
    12711269
    1272     while(sr_config.running) {
     1270    while(reader->sr_config->running) {
    12731271        ret = libusb_handle_events(NULL);
    12741272        if(ret!=0)
     
    12791277}
    12801278
    1281 #endif // HAVE_LIBUSB && USE_PTHREAD
     1279#endif // HAVE_LIBUSB
  • trunk/csctapi/ifd_smartreader.h

    r1719 r1723  
    3333
    3434#endif // __SMARTREADER__
    35 #endif // HAVE_LIBUSB && USE_PTHREAD
     35#endif // HAVE_LIBUSB
  • trunk/globals.h

    r1722 r1723  
    306306    /** maximum packet size. Needed for filtering modem status bytes every n packets. */
    307307    unsigned int max_packet_size;
     308    unsigned char g_read_buffer[4096];
     309    unsigned int g_read_buffer_size;
     310    pthread_mutex_t g_read_mutex;
     311    pthread_mutex_t g_usb_mutex;
     312    pthread_t rt;
     313    unsigned char modem_status;
    308314} SR_CONFIG;
    309315#endif
     
    524530  DWORD dwActiveProtocol;
    525531#endif
     532#ifdef LIBUSB
     533  SR_CONFIG *sr_config;
     534#endif
    526535};
    527536
Note: See TracChangeset for help on using the changeset viewer.