Changeset 1419
- Timestamp:
- 02/05/10 11:22:01 (14 years ago)
- Location:
- trunk
- Files:
-
- 1 added
- 2 deleted
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/CMakeLists.txt
r1389 r1419 160 160 endif (HAVE_SHA) 161 161 162 check_include_file (" usb.h" HAVE_LIBUSB)162 check_include_file ("libusb-1.0/libusb.h" HAVE_LIBUSB) 163 163 if (HAVE_LIBUSB) 164 164 message(STATUS " libusb found. Adding smartreader support ") 165 165 add_definitions ("-DLIBUSB") 166 add_definitions ("-I/usr/local/include") 167 168 add_library(imp_libusb STATIC IMPORTED) 169 set_property(TARGET imp_libusb PROPERTY 170 IMPORTED_LOCATION /usr/local/lib/libusb-1.0.a) 166 171 elseif (HAVE_LIBUSB) 167 172 message(STATUS " no libusb found. No smartreader ") … … 227 232 228 233 if (HAVE_LIBUSB) 229 target_link_libraries (${exe_name} usb) 234 target_link_libraries (${exe_name} imp_libusb) 235 if (NOT OSCamOperatingSystem MATCHES "Mac OS X") 236 target_link_libraries (${exe_name} rt) 237 endif (NOT OSCamOperatingSystem MATCHES "Mac OS X") 230 238 endif (HAVE_LIBUSB) 231 239 … … 240 248 target_link_libraries ( ${exe_name} ${PCSC_LIBRARY}) 241 249 set (HAVE_PCSC "1") 242 243 FIND_PATH( USB_INCLUDE usb.h) 244 if( ${USB_INCLUDE} MATCHES "USB_INCLUDE-NOTFOUND" ) 245 set (HAVE_LIBUSB "0") 246 message (STATUS "OS X libusb includes not found .. no smartreader support") 247 else ( ${USB_INCLUDE} MATCHES "USB_INCLUDE-NOTFOUND" ) 248 message (STATUS "OS X libusb include : ${USB_INCLUDE}") 249 FIND_LIBRARY (USB_LIBRARY usb) 250 message (STATUS "OS X libusb : ${USB_LIBRARY}") 251 target_link_libraries ( ${exe_name} ${USB_LIBRARY}) 252 include_directories( SYSTEM ${USB_INCLUDE}) 253 set (HAVE_LIBUSB "1") 254 add_definitions ("-DLIBUSB") 255 message (STATUS "OS X libusb found .. adding smartreader support") 256 endif ( ${USB_INCLUDE} MATCHES "USB_INCLUDE-NOTFOUND" ) 250 FIND_LIBRARY (IOKit_LIBRARY IOKit) 251 target_link_libraries ( ${exe_name} ${IOKit_LIBRARY}) 252 FIND_LIBRARY (CoreFoundation_LIBRARY CoreFoundation) 253 target_link_libraries ( ${exe_name} ${CoreFoundation_LIBRARY}) 254 if (HAVE_LIBUSB) 255 endif (HAVE_LIBUSB) 257 256 elseif (OSCamOperatingSystem MATCHES "Tuxbox") 258 257 target_link_libraries ( ${exe_name} dl) -
trunk/Makefile
r1389 r1419 85 85 @-$(MAKE) --no-print-directory \ 86 86 -f Maketype TYP=$(subst i386,$(shell uname --machine),$(subst cross-,,$@)) \ 87 OS_LIBS="-lcrypto -lm" \ 88 OS_CULI="-lncurses" \ 89 OS_PTLI="-lpthread" \ 90 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)\""' `libusb-config --cflags`" \ 87 LIBUSB="/usr/local/lib/libusb-1.0.a" \ 88 OS_LIBS="-lcrypto -lm" \ 89 OS_CULI="-lncurses" \ 90 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 92 DS_CFLAGS="-c" \ 92 93 DS_LDFLAGS="`libusb-config --libs`" \ … … 127 128 @-$(MAKE) --no-print-directory \ 128 129 -f Maketype TYP=$(subst i386,$(shell uname --machine),$(subst cross-,,$@)) \ 130 LIBUSB="/usr/local/lib/libusb-1.0.a" \ 129 131 OS_LIBS="-lcrypto -lm" \ 130 132 OS_CULI="-lncurses" \ 131 133 OS_PTLI="-lpthread -lpcsclite" \ 132 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)\""' `libusb-config --cflags`" \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" \ 133 135 DS_CFLAGS="-c" \ 134 136 DS_LDFLAGS="`libusb-config --libs`" \ … … 169 171 @-$(MAKE) --no-print-directory \ 170 172 -f Maketype TYP=$(subst cross-,,$@) \ 173 LIBUSB="/usr/local/lib/libusb-1.0.a" \a 171 174 OS_LIBS="-lcrypto -lm " \ 172 175 OS_CULI="-lncurses" \ 173 176 OS_PTLI="-lpthread" \ 174 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)\""' `libusb-config --cflags`" \175 DS_CFLAGS="-c" \ 176 DS_LDFLAGS="-framework PCSC `libusb-config --libs`" \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" \ 178 DS_CFLAGS="-c" \ 179 DS_LDFLAGS="-framework PCSC -Wl,-framework -Wl,IOKit -Wl,-framework -Wl,CoreFoundation -Wl,-prebind -no-undefined" \ 177 180 DS_ARFLAGS="-rvsl" \ 178 181 DS_CC=gcc \ -
trunk/Maketype
r1000 r1419 79 79 80 80 $(EXEFILE1): oscam.c $(LIBFILE1) $(LIBFILE2) $(LIBFILE3) $(GENERAL) 81 $(CC) $(LDFLAGS) oscam.c $(LIBFILE1) $(LIBFILE2) $(LIBFILE3) -o "$@" $(LIBS)81 $(CC) $(LDFLAGS) oscam.c $(LIBFILE1) $(LIBFILE2) $(LIBFILE3) $(LIBUSB) -o "$@" $(LIBS) 82 82 $(STRIP) $@ 83 83 -
trunk/csctapi/Makefile
r1399 r1419 16 16 $(LIBFILE1)(protocol_t1.o) \ 17 17 $(LIBFILE1)(t1_block.o) \ 18 $(LIBFILE1)(ftdi.o) \19 18 $(LIBFILE1)(ifd_smartreader.o) 20 19 -
trunk/csctapi/icc_async.c
r1399 r1419 55 55 56 56 static void ICC_Async_InvertBuffer (unsigned size, BYTE * buffer); 57 static int Parse_ATR (ATR * atr );57 static int Parse_ATR (ATR * atr, unsigned short deprecated); 58 58 static int PPS_Exchange (BYTE * params, unsigned *length); 59 59 static unsigned PPS_GetLength (BYTE * block); 60 static int InitCard (ATR * atr, BYTE FI, double d, double n );60 static int InitCard (ATR * atr, BYTE FI, double d, double n, unsigned short deprecated); 61 61 static unsigned int ETU_to_ms(unsigned long WWT); 62 62 static BYTE PPS_GetPCK (BYTE * block, unsigned length); … … 184 184 } 185 185 186 int ICC_Async_Activate (ATR * atr )186 int ICC_Async_Activate (ATR * atr, unsigned short deprecated) 187 187 { 188 188 cs_debug_mask (D_IFD, "IFD: Activating card in reader %s\n", reader[ridx].label); … … 249 249 unsigned short cs_ptyp_orig=cs_ptyp; 250 250 cs_ptyp=D_ATR; 251 int ret = Parse_ATR(atr );251 int ret = Parse_ATR(atr, deprecated); 252 252 cs_ptyp=cs_ptyp_orig; 253 253 if (ret) … … 497 497 } 498 498 499 static int Parse_ATR (ATR * atr )499 static int Parse_ATR (ATR * atr, unsigned short deprecated) 500 500 { 501 501 BYTE FI = ATR_DEFAULT_FI; … … 511 511 if ((tx & 0xF0) == 0) 512 512 numprot--; 513 cs_debug("ATR reports %i protocol lines:",numprot);514 513 int i,point; 515 514 char txt[50]; … … 583 582 bool PPS_success = FALSE; 584 583 bool NeedsPTS = ((protocol_type != ATR_PROTOCOL_TYPE_T14) && (numprottype > 1 || (atr->ib[0][ATR_INTERFACE_BYTE_TA].present == TRUE && atr->ib[0][ATR_INTERFACE_BYTE_TA].value != 0x11) || n == 255)); //needs PTS according to ISO 7816 , SCI gets stuck on our PTS 585 if (NeedsPTS && reader[ridx].deprecated == 0) {584 if (NeedsPTS && deprecated == 0) { 586 585 // PTSS PTS0 PTS1 PTS2 PTS3 PCK 587 586 // PTSS PTS0 PTS1 PCK … … 636 635 } 637 636 638 if (reader[ridx].deprecated == 0) 639 return InitCard (atr, FI, d, n); 640 else { 641 cs_log("Warning: entering Deprecated Mode"); 642 return InitCard (atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, n); 643 } 637 if (deprecated == 0) 638 return InitCard (atr, FI, d, n, deprecated); 639 else 640 return InitCard (atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, n, deprecated); 644 641 } 645 642 … … 774 771 } 775 772 776 static int InitCard (ATR * atr, BYTE FI, double d, double n) 777 { 778 unsigned long baudrate; 773 static int InitCard (ATR * atr, BYTE FI, double d, double n, unsigned short deprecated) 774 { 779 775 double P,I; 780 776 double F; … … 813 809 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); 814 810 F = (double) atr_f_table[FI]; 815 if (protocol_type == ATR_PROTOCOL_TYPE_T14)816 baudrate = 9600;817 else818 baudrate = d * ICC_Async_GetClockRate () / F;819 811 #if defined(LIBUSB) 820 812 } … … 822 814 823 815 #if defined(LIBUSB) 824 if ( reader[ridx].deprecated == 0 && reader[ridx].typ != R_SMART)816 if (deprecated == 0 && reader[ridx].typ != R_SMART) 825 817 #else 826 if (reader[ridx].deprecated == 0) 827 #endif 828 if (ICC_Async_SetBaudrate (baudrate)) 829 return ERROR; 818 if (deprecated == 0) 819 #endif 820 if (protocol_type != ATR_PROTOCOL_TYPE_T14) //dont switch for T14 821 if (ICC_Async_SetBaudrate ( d * ICC_Async_GetClockRate () / F)) 822 return ERROR; 830 823 //set timings according to ATR 831 824 read_timeout = 0; … … 939 932 unsigned long ETU = 0; 940 933 //for Irdeto T14 cards, do not set ETU 941 if (!(atr->hbn >= 6 && !memcmp(atr->hb, "IRDETO", 6) && protocol_type == 14))934 if (!(atr->hbn >= 6 && !memcmp(atr->hb, "IRDETO", 6) && protocol_type == ATR_PROTOCOL_TYPE_T14)) 942 935 ETU = F / d; 943 936 if (Sci_WriteSettings (protocol_type, reader[ridx].mhz / 100, ETU, WWT, BWT, CWT, EGT, (unsigned char)P, (unsigned char)I)) -
trunk/csctapi/icc_async.h
r1389 r1419 62 62 63 63 /* Initialization and Deactivation */ 64 extern int ICC_Async_Activate (ATR * newatr );64 extern int ICC_Async_Activate (ATR * newatr, unsigned short deprecated); 65 65 extern int ICC_Async_Close (void); 66 66 int ICC_Async_Device_Init (void); -
trunk/csctapi/ifd_cool.c
r1400 r1419 96 96 cardbuflen -= size; 97 97 memmove(cardbuffer,cardbuffer+size,cardbuflen); 98 cs_d ump(data, size, "COOL IO: Receive: ");98 cs_ddump(data, size, "COOL IO: Receive: "); 99 99 return OK; 100 100 } -
trunk/csctapi/ifd_smartreader.c
r1413 r1419 15 15 #define HIBYTE(w) ((BYTE)((w) >> 8)) 16 16 17 static struct usb_device * find_smartreader(const char *devname, const char*busname, struct ftdi_context* ftdic); 18 static void smart_flush(struct s_reader *reader); 19 static unsigned int smart_read(struct s_reader *reader, unsigned char* buff, int size, int timeout_sec); 20 static unsigned int smart_write(struct s_reader *reader, unsigned char* buff, int size, int udelay); 21 static void EnableSmartReader(struct s_reader *reader, int clock, unsigned short Fi, unsigned char Di, unsigned char Ni, unsigned char T,unsigned char inv, int parity); 22 static void ResetSmartReader(struct s_reader *reader); 17 18 typedef struct s_reader S_READER; 19 20 21 static struct libusb_device* find_smartreader(const char*busname,const char *devname); 22 static void smartreader_init(S_READER *reader); 23 static unsigned int smartreader_determine_max_packet_size(S_READER *reader); 24 static int smartreader_usb_close_internal (S_READER *reader); 25 static int smartreader_usb_reset(S_READER *reader); 26 static int smartreader_usb_open_dev(S_READER *reader); 27 static int smartreader_usb_purge_rx_buffer(S_READER *reader); 28 static int smartreader_usb_purge_tx_buffer(S_READER *reader); 29 static int smartreader_usb_purge_buffers(S_READER *reader); 30 static int smartreader_convert_baudrate(int baudrate, S_READER *reader, unsigned short *value, unsigned short *index); 31 static int smartreader_set_baudrate(S_READER *reader, int baudrate); 32 static int smartreader_setdtr_rts(S_READER *reader, int dtr, int rts); 33 static int smartreader_setflowctrl(S_READER *reader, int flowctrl); 34 static int smartreader_set_line_property2(S_READER *reader, enum smartreader_bits_type bits, 35 enum smartreader_stopbits_type sbit, enum smartreader_parity_type parity, 36 enum smartreader_break_type break_type); 37 static int smartreader_set_line_property(S_READER *reader, enum smartreader_bits_type bits, 38 enum smartreader_stopbits_type sbit, enum smartreader_parity_type parity); 39 static void smart_flush(S_READER *reader); 40 static int smart_read(S_READER *reader, unsigned char* buff, unsigned int size, int timeout_sec); 41 static int smartreader_write_data(S_READER *reader, unsigned char *buf, unsigned int size); 42 static int smart_write(S_READER *reader, unsigned char* buff, unsigned int size, int udelay); 43 static int smartreader_set_latency_timer(S_READER *reader, unsigned short latency); 44 static void EnableSmartReader(S_READER *reader, int clock, unsigned short Fi, unsigned char Di, unsigned char Ni, unsigned char T,unsigned char inv, int parity); 45 static void ResetSmartReader(S_READER *reader); 23 46 static void* ReaderThread(void *p); 24 static bool smartreader_check_endpoint(struct usb_device *dev); 25 26 #ifdef DEBUG_USB_IO 27 static void sr_hexdump(const unsigned char* data, size_t size, bool single); 28 #endif 29 30 extern int usb_debug; 47 48 #ifdef DEBUG_USB_IO 49 static void sr_hexdump(const unsigned char* data, unsigned int size, bool single); 50 #endif 31 51 32 52 int SR_Init (struct s_reader *reader) … … 47 67 } 48 68 #ifdef DEBUG_USB_IO 49 usb_debug=0;50 69 cs_log("looking for device %s on bus %s",devname,busname); 51 70 #endif 52 reader->smartreader_usb_dev=find_smartreader((const char *)devname,(const char *)busname, &reader->ftdic); 53 if(!reader->smartreader_usb_dev) 54 return ERROR; 71 72 ret = libusb_init(NULL); 73 if (ret < 0) 74 return ret; 75 76 smartreader_init(reader); 77 78 reader->sr_config.usb_dev=find_smartreader(busname,devname); 79 if(!reader->sr_config.usb_dev) 80 return EXIT_FAILURE; 81 55 82 //The smartreader has different endpoint addresses 56 83 //compared to a real FT232 device, so change them here, 57 84 //also a good way to compare a real FT232 with a smartreader 58 85 //if you enumarate usb devices 59 reader->ftdic.in_ep = 0x1; 60 reader->ftdic.out_ep = 0x82; 61 62 ftdi_write_data_set_chunksize(&reader->ftdic,64); 63 64 //open the smartreader device if found by find_smartreader 65 if ((ret = ftdi_usb_open_dev(&reader->ftdic,reader->smartreader_usb_dev)) < 0) { 66 cs_log("unable to open ftdi device %s:%s (ret=%d error=%s)",busname,devname, ret, ftdi_get_error_string(&reader->ftdic)); 67 return ERROR; 68 } 69 86 reader->sr_config.in_ep = 0x1; 87 reader->sr_config.out_ep = 0x82; 88 89 //open the first smartreader found in the system, this 90 //would need to be changed to an enumerate function 91 //of some sort using the ftdi library. /dev/ttyUSB0 wont exist 92 //as we are accessing the device directly so you will have 93 //to have some other way of addressing the smartreader within 94 //OSCam config files etc... 95 if ((ret=smartreader_usb_open_dev(reader))) { 96 cs_log("unable to open smartreader device %s in bus %s (ret=%d)\n", devname,busname,ret); 97 return EXIT_FAILURE; 98 } 99 70 100 #ifdef DEBUG_USB_IO 71 101 cs_log("IO:SR: Setting smartreader latency timer to 1ms"); 72 102 #endif 73 103 //Set the FTDI latency timer to 1ms 74 ret = ftdi_set_latency_timer(&reader->ftdic, 1); 75 if(ret) 76 cs_log("IO:SR: ERROR Setting smartreader latency timer to 1ms"); 104 ret = smartreader_set_latency_timer(reader, 1); 77 105 78 106 //Set databits to 8o2 79 ret = ftdi_set_line_property(&reader->ftdic, BITS_8, STOP_BIT_2, ODD);80 81 //Set the DTR LOWand RTS LOW82 ftdi_setdtr_rts(&reader->ftdic, 0, 0);107 ret = smartreader_set_line_property(reader, BITS_8, STOP_BIT_2, ODD); 108 109 //Set the DTR HIGH and RTS LOW 110 ret=smartreader_setdtr_rts(reader, 0, 0); 83 111 84 112 //Disable flow control 85 ftdi_setflowctrl(&reader->ftdic, 0);86 87 // star the reading thread113 ret=smartreader_setflowctrl(reader, 0); 114 115 // start the reading thread 88 116 reader->g_read_buffer_size = 0; 89 117 reader->modem_status = 0 ; … … 114 142 else 115 143 *in = 0; //NOCARD 144 116 145 return OK; 117 146 } … … 122 151 int ret; 123 152 int atr_ok; 124 int i;153 unsigned int i; 125 154 int parity[4] = {EVEN, ODD, NONE, EVEN}; // the last EVEN is to try with different F, D values for irdeto card. 126 155 #ifdef DEBUG_USB_IO … … 163 192 164 193 //Set the DTR HIGH and RTS HIGH 165 ftdi_setdtr_rts(&reader->ftdic, 1, 1);194 smartreader_setdtr_rts(reader, 1, 1); 166 195 // A card with an active low reset is reset by maintaining RST in state L for at least 40 000 clock cycles 167 196 // so if we have a base freq of 3.5712MHz : 40000/3690000 = .0112007168458781 seconds, aka 11ms … … 171 200 172 201 //Set the DTR HIGH and RTS LOW 173 ftdi_setdtr_rts(&reader->ftdic, 1, 0);202 smartreader_setdtr_rts(reader, 1, 0); 174 203 175 204 usleep(200000); … … 242 271 //baud rate not really used in native mode since 243 272 //it's handled by the card, so just set to maximum 3Mb/s 244 ftdi_set_baudrate(&reader->ftdic, 3000000);273 smartreader_set_baudrate(reader, 3000000); 245 274 sched_yield(); 246 275 … … 255 284 cs_log("IO:SR: Setting parity to %s",parity_str[reader->sr_config.parity]); 256 285 #endif 257 ret = ftdi_set_line_property(&reader->ftdic, (enum ftdi_bits_type) 8, STOP_BIT_2, reader->sr_config.parity);286 ret = smartreader_set_line_property(reader, (enum smartreader_bits_type) 8, STOP_BIT_2, reader->sr_config.parity); 258 287 if(ret) 259 288 return ERROR; … … 267 296 { 268 297 #ifdef DEBUG_USB_IO 269 printf ("IO:SR: Closing smarteader\n"); 270 #endif 271 272 ftdi_deinit(&reader->ftdic); 298 cs_log ("IO:SR: Closing smarteader\n"); 299 #endif 300 301 reader->sr_config.running=FALSE; 302 pthread_join(reader->rt,NULL); 303 libusb_close(reader->sr_config.usb_dev_handle); 273 304 reader[ridx].status = 0; 274 305 return OK; … … 276 307 } 277 308 278 static struct usb_device * find_smartreader(const char *devname, const char*busname, struct ftdi_context* ftdic) 279 { 280 bool dev_found; 281 struct usb_bus *bus; 282 struct usb_device *dev; 283 284 if (ftdi_init(ftdic) < 0) { 285 cs_log("ftdi_init failed"); 286 return NULL; 287 } 288 usb_init(); 289 if (usb_find_busses() < 0) { 290 cs_log("usb_find_busses() failed"); 291 return NULL; 292 } 293 if (usb_find_devices() < 0) { 294 cs_log("usb_find_devices() failed"); 295 return NULL; 296 } 297 298 299 dev_found=FALSE; 300 for (bus = usb_get_busses(); bus; bus = bus->next) { 301 for (dev = bus->devices; dev; dev = dev->next) { 302 if ( (dev->descriptor.idVendor != 0x0403) || (dev->descriptor.idProduct != 0x6001)) 303 continue; 304 #ifdef DEBUG_USB_IO 305 cs_log("IO:SR: Checking FTDI device: %s on bus %s", dev->filename,dev->bus->dirname); 306 #endif 307 if(smartreader_check_endpoint(dev)) { 308 // compare devname and bussname 309 if(strcmp(dev->filename,devname)==0 && strcmp(dev->bus->dirname,busname)==0) { 310 dev_found=TRUE; 311 break; 312 } 313 } 314 } 315 if(dev_found) { 316 cs_log("Found smartreader device %s:%s",busname,devname); 317 break; 318 } 319 } 320 321 if(!dev_found) { 322 cs_log("Smartreader device %s:%s not found",busname,devname); 323 ftdi_deinit(ftdic); 324 return NULL; 325 } 326 327 return dev; 328 } 329 330 static void smart_flush(struct s_reader *reader) 331 { 332 333 ftdi_usb_purge_buffers(&reader->ftdic); 334 335 pthread_mutex_lock(&reader->g_read_mutex); 336 reader->g_read_buffer_size = 0; 337 pthread_mutex_unlock(&reader->g_read_mutex); 338 sched_yield(); 339 } 340 341 static unsigned int smart_read(struct s_reader *reader, unsigned char* buff, int size, int timeout_sec) 342 { 309 310 static void EnableSmartReader(S_READER *reader, int clock, unsigned short Fi, unsigned char Di, unsigned char Ni, unsigned char T, unsigned char inv,int parity) { 343 311 344 312 int ret = 0; 345 int total_read = 0;346 struct timeval start, now, dif = {0,0};347 gettimeofday(&start,NULL);348 349 350 while(total_read < (int)size && dif.tv_sec < timeout_sec) {351 352 pthread_mutex_lock(&reader->g_read_mutex);353 if(reader->g_read_buffer_size > 0) {354 355 ret = reader->g_read_buffer_size > size-total_read ? size-total_read : reader->g_read_buffer_size;356 #ifdef DEBUG_IO357 if(usb_debug) {358 cs_log("IO:SR: %d byte to read %d, %d bytes read",size, total_read);359 }360 #endif361 362 memcpy(buff+total_read,reader->g_read_buffer,ret);363 reader->g_read_buffer_size -= ret;364 total_read+=ret;365 }366 pthread_mutex_unlock(&reader->g_read_mutex);367 368 gettimeofday(&now,NULL);369 timersub(&now, &start, &dif);370 usleep(50);371 sched_yield();372 }373 374 375 return total_read;376 }377 378 static unsigned int smart_write(struct s_reader *reader, unsigned char* buff, int size, int udelay)379 {380 381 int ret = 0;382 int idx;383 384 if (udelay == 0) {385 ret = ftdi_write_data(&reader->ftdic, buff, size);386 if(ret<0) {387 #ifdef DEBUG_USB_IO388 cs_log("IO:SR: USB write error : %d , %s",ret,reader->ftdic.error_str );389 #endif390 }391 }392 else {393 for (idx = 0; idx < size; idx++) {394 if ((ret = ftdi_write_data(&reader->ftdic, &buff[idx], 1)) < 0){395 break;396 }397 usleep(udelay);398 }399 }400 sched_yield();401 return ret;402 }403 404 static void EnableSmartReader(struct s_reader *reader, int clock, unsigned short Fi, unsigned char Di, unsigned char Ni, unsigned char T, unsigned char inv,int parity) {405 406 int ret = 0;407 int delay=50000;408 313 unsigned char FiDi[4]; 409 314 unsigned short freqk; … … 414 319 415 320 416 ret = ftdi_set_baudrate(&reader->ftdic, 9600); 417 ftdi_setflowctrl(&reader->ftdic, 0); 418 ret = ftdi_set_line_property(&reader->ftdic, (enum ftdi_bits_type) 5, STOP_BIT_2, parity); 419 usleep(delay); 321 ret = smartreader_set_baudrate(reader, 9600); 322 smartreader_setflowctrl(reader, 0); 323 ret = smartreader_set_line_property(reader, (enum smartreader_bits_type) 5, STOP_BIT_2, NONE); 420 324 421 325 // command 1, set F and D parameter … … 430 334 FiDi[3]=Di; 431 335 ret = smart_write(reader,FiDi, sizeof (FiDi),0); 432 usleep(delay);433 336 } 434 337 else { … … 449 352 Freq[2]=LOBYTE(freqk); 450 353 ret = smart_write(reader, Freq, sizeof (Freq),0); 451 usleep(delay);452 354 453 355 // command 3, set paramter N … … 458 360 N[1]=Ni; 459 361 ret = smart_write(reader, N, sizeof (N),0); 460 usleep(delay);461 362 462 363 // command 4 , set parameter T … … 477 378 Prot[1]=T; 478 379 ret = smart_write(reader, Prot, sizeof (Prot),0); 479 usleep(delay);480 380 481 381 // command 5, set invert y/n … … 486 386 Invert[1]=inv; 487 387 ret = smart_write(reader, Invert, sizeof (Invert),0); 488 usleep(delay); 489 490 ret = ftdi_set_line_property2(&reader->ftdic, BITS_8, STOP_BIT_2, parity, BREAK_ON); 388 389 ret = smartreader_set_line_property2(reader, BITS_8, STOP_BIT_2, parity, BREAK_ON); 491 390 // send break for 350ms, also comes from JoePub debugging. 492 391 usleep(350000); 493 ret = ftdi_set_line_property2(&reader->ftdic, BITS_8, STOP_BIT_2, parity, BREAK_OFF);392 ret = smartreader_set_line_property2(reader, BITS_8, STOP_BIT_2, parity, BREAK_OFF); 494 393 495 394 smart_flush(reader); 496 395 } 497 396 498 static void ResetSmartReader( struct s_reader*reader)397 static void ResetSmartReader(S_READER *reader) 499 398 { 500 399 … … 515 414 516 415 } 517 518 static void* ReaderThread(void *p) 519 { 520 521 struct s_reader *reader; 522 bool running = TRUE; 523 int ret; 524 int copy_size; 525 unsigned char local_buffer[64]; //64 is max transfer size of FTDI bulk pipe 526 527 reader = (struct s_reader *)p; 528 529 while(running){ 530 531 if(reader->g_read_buffer_size == sizeof(reader->g_read_buffer)){ 532 //if out read buffer is full then delay 533 //slightly and go around again 534 usleep(20000); 535 continue; 536 } 537 538 ret = usb_bulk_read(reader->ftdic.usb_dev,reader->ftdic.out_ep,(char*)local_buffer,4,10000); 539 if(ret<0) { 540 #ifdef DEBUG_USB_IO 541 cs_log("IO:SR: usb_bulk_read read error %d",ret); 542 #endif 543 } 544 sched_yield(); 545 #ifdef DEBUG_USB_IO 546 if(usb_debug) { 547 cs_log("IO:SR: usb_bulk_read read %d bytes",ret); 548 } 549 #endif 550 if(ret>2) { //FTDI always sends modem status bytes as first 2 chars with the 232BM 551 pthread_mutex_lock(&reader->g_read_mutex); 552 reader->modem_status=local_buffer[0]; 553 copy_size = (int)sizeof(reader->g_read_buffer) - reader->g_read_buffer_size > ret-2 ? ret-2 : (int)sizeof(reader->g_read_buffer) - reader->g_read_buffer_size; 554 memcpy(reader->g_read_buffer+reader->g_read_buffer_size,local_buffer+2,copy_size); 555 reader->g_read_buffer_size += copy_size; 556 pthread_mutex_unlock(&reader->g_read_mutex); 557 } 558 else { 559 if(ret==2) { 560 pthread_mutex_lock(&reader->g_read_mutex); 561 reader->modem_status=local_buffer[0]; 562 pthread_mutex_unlock(&reader->g_read_mutex); 563 } 564 } 565 } 566 567 pthread_exit(NULL); 568 } 569 416 /* 570 417 571 418 static bool smartreader_check_endpoint(struct usb_device *dev) … … 611 458 } 612 459 613 #ifdef DEBUG_USB_IO 614 static void sr_hexdump(const unsigned char* data, size_t size, bool single) 460 */ 461 462 #ifdef DEBUG_USB_IO 463 static void sr_hexdump(const unsigned char* data, unsigned int size, bool single) 615 464 { 616 465 unsigned int idx; … … 638 487 #endif 639 488 489 490 /////////////////////// 491 static struct libusb_device* find_smartreader(const char *busname,const char *devname) 492 { 493 int dev_found; 494 libusb_device *dev; 495 libusb_device_handle *usb_dev_handle; 496 libusb_device **devs; 497 ssize_t cnt; 498 int i = 0; 499 int ret; 500 struct libusb_device_descriptor desc; 501 502 cnt = libusb_get_device_list(NULL, &devs); 503 if (cnt < 0) 504 return NULL; 505 506 while ((dev = devs[i++]) != NULL) { 507 dev_found=FALSE; 508 ret = libusb_get_device_descriptor(dev, &desc); 509 if (ret < 0) { 510 cs_log("failed to get device descriptor for device %s on bus %s\n",devname,busname); 511 return NULL; 512 } 513 514 if (desc.idVendor==0x0403 && desc.idProduct==0x6001) { 515 ret=libusb_open(dev,&usb_dev_handle); 516 if (ret) { 517 cs_log ("coulnd't open device %03d:%03d\n", libusb_get_bus_number(dev), libusb_get_device_address(dev)); 518 continue; 519 } 520 521 if(libusb_get_bus_number(dev)==atoi(busname) && libusb_get_device_address(dev)==atoi(devname)) { 522 cs_log("IO:SR: Checking FTDI device: %03d on bus %03d",libusb_get_device_address(dev),libusb_get_bus_number(dev)); 523 // check for smargo endpoints. 524 525 dev_found=TRUE; 526 } 527 528 529 libusb_close(usb_dev_handle); 530 } 531 532 if (dev_found) 533 break; 534 } 535 536 if(!dev_found) { 537 cs_log("Smartreader device %s:%s not found",busname,devname); 538 return NULL; 539 } 540 else 541 cs_log("Found smartreader device %s:%s",busname,devname); 542 543 return dev; 544 } 545 546 void smartreader_init(S_READER *reader) 547 { 548 reader->sr_config.usb_dev = NULL; 549 reader->sr_config.usb_dev_handle=NULL; 550 reader->sr_config.usb_read_timeout = 5000; 551 reader->sr_config.usb_write_timeout = 5000; 552 553 reader->sr_config.type = TYPE_BM; /* chip type */ 554 reader->sr_config.baudrate = -1; 555 reader->sr_config.bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */ 556 557 reader->sr_config.writebuffer_chunksize = 64; 558 reader->sr_config.max_packet_size = 0; 559 560 reader->sr_config.interface = 0; 561 reader->sr_config.index = 0; 562 reader->sr_config.in_ep = 0x02; 563 reader->sr_config.out_ep = 0x82; 564 // reader->sr_config.bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */ 565 566 // reader->sr_config.async_usb_buffer_size=0; 567 // reader->sr_config.async_usb_buffer = NULL; 568 } 569 570 571 static unsigned int smartreader_determine_max_packet_size(S_READER *reader) 572 { 573 unsigned int packet_size; 574 struct libusb_device_descriptor desc; 575 struct libusb_config_descriptor *configDesc; 576 struct libusb_interface interface; 577 struct libusb_interface_descriptor intDesc; 578 int config; 579 int ret; 580 // Determine maximum packet size. Init with default value. 581 // New hi-speed devices from FTDI use a packet size of 512 bytes 582 // but could be connected to a normal speed USB hub -> 64 bytes packet size. 583 if (reader->sr_config.type == TYPE_2232H || reader->sr_config.type == TYPE_4232H) 584 packet_size = 512; 585 else 586 packet_size = 64; 587 588 ret = libusb_get_device_descriptor(reader->sr_config.usb_dev, &desc); 589 if (ret < 0) { 590 cs_log("Smartreader : failed to get device descriptor"); 591 return (-1); 592 } 593 594 if (desc.bNumConfigurations) 595 { 596 ret=libusb_get_configuration(reader->sr_config.usb_dev_handle,&config); 597 ret=libusb_get_config_descriptor(reader->sr_config.usb_dev,config,&configDesc); 598 599 if (reader->sr_config.interface < configDesc->bNumInterfaces) 600 { 601 interface=configDesc->interface[reader->sr_config.interface]; 602 if (interface.num_altsetting > 0) 603 { 604 intDesc = interface.altsetting[0]; 605 if (intDesc.bNumEndpoints > 0) 606 { 607 packet_size = intDesc.endpoint[0].wMaxPacketSize; 608 } 609 } 610 } 611 } 612 613 return packet_size; 614 } 615 616 617 static int smartreader_usb_close_internal (S_READER *reader) 618 { 619 int ret = 0; 620 621 if (reader->sr_config.usb_dev_handle) 622 { 623 libusb_close (reader->sr_config.usb_dev_handle); 624 reader->sr_config.usb_dev_handle=NULL; 625 } 626 627 return ret; 628 } 629 630 631 int smartreader_usb_reset(S_READER *reader) 632 { 633 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 634 FTDI_DEVICE_OUT_REQTYPE, 635 SIO_RESET_REQUEST, 636 SIO_RESET_SIO, 637 reader->sr_config.index, 638 NULL, 639 0, 640 reader->sr_config.usb_write_timeout) != 0) { 641 cs_log("Smartreader reset failed"); 642 return (-1); 643 } 644 645 // Invalidate data in the readbuffer 646 // ftdi->readbuffer_offset = 0; 647 // ftdi->readbuffer_remaining = 0; 648 649 return 0; 650 } 651 652 653 int smartreader_usb_open_dev(S_READER *reader) 654 { 655 int detach_errno = 0; 656 struct libusb_device_descriptor desc; 657 int ret; 658 659 #ifdef __WIN32__ 660 int config; 661 int config_val = 1; 662 #endif 663 664 ret=libusb_open(reader->sr_config.usb_dev,&reader->sr_config.usb_dev_handle); 665 if (ret) { 666 cs_log("Smartreader usb_open() failed"); 667 return (-4); 668 } 669 #if defined(OS_LINUX) 670 // Try to detach smartreader_sio kernel module. 671 // Returns ENODATA if driver is not loaded. 672 // 673 // The return code is kept in a separate variable and only parsed 674 // if usb_set_configuration() or usb_claim_interface() fails as the 675 // detach operation might be denied and everything still works fine. 676 // Likely scenario is a static smartreader_sio kernel module. 677 if (libusb_detach_kernel_driver(reader->sr_config.usb_dev_handle, reader->sr_config.interface) != 0 && errno != ENODATA) { 678 detach_errno = errno; 679 cs_log("Couldn't detach interface from kernel. Please unload the FTDI drivers"); 680 return(LIBUSB_ERROR_NOT_SUPPORTED); 681 } 682 #endif 683 ret = libusb_get_device_descriptor(reader->sr_config.usb_dev, &desc); 684 685 #ifdef __WIN32__ 686 // set configuration (needed especially for windows) 687 // tolerate EBUSY: one device with one configuration, but two interfaces 688 // and libftdi sessions to both interfaces (e.g. FT2232) 689 690 if (desc.bNumConfigurations > 0) 691 { 692 ret=libusb_get_configuration(&reader->sr_config.usb_dev_handle,&config); 693 694 // libusb-win32 on Windows 64 can return a null pointer for a valid device 695 if (libusb_set_configuration(&reader->sr_config.usb_dev_handle, config) && 696 errno != EBUSY) 697 { 698 smartreader_usb_close_internal (reader); 699 if (detach_errno == EPERM) { 700 cs_log("inappropriate permissions on device!"); 701 return(-8); 702 } 703 else { 704 cs_log("unable to set usb configuration. Make sure smartreader_sio is unloaded!"); 705 return (-3); 706 } 707 } 708 } 709 #endif 710 711 ret=libusb_claim_interface(reader->sr_config.usb_dev_handle, reader->sr_config.interface) ; 712 if (ret!= 0) 713 { 714 cs_log("WTF !!! ret=%d",ret); 715 smartreader_usb_close_internal (reader); 716 if (detach_errno == EPERM) { 717 cs_log("inappropriate permissions on device!"); 718 return (-8); 719 } 720 else { 721 cs_log("unable to claim usb device. Make sure smartreader_sio is unloaded!"); 722 return (-5); 723 } 724 } 725 726 if (smartreader_usb_reset (reader) != 0) { 727 smartreader_usb_close_internal (reader); 728 cs_log("smartreader_usb_reset failed"); 729 return (-6); 730 } 731 732 // Try to guess chip type 733 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0 734 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200 735 && desc.iSerialNumber == 0)) 736 reader->sr_config.type = TYPE_BM; 737 else if (desc.bcdDevice == 0x200) 738 reader->sr_config.type = TYPE_AM; 739 else if (desc.bcdDevice == 0x500) 740 reader->sr_config.type = TYPE_2232C; 741 else if (desc.bcdDevice == 0x600) 742 reader->sr_config.type = TYPE_R; 743 else if (desc.bcdDevice == 0x700) 744 reader->sr_config.type = TYPE_2232H; 745 else if (desc.bcdDevice == 0x800) 746 reader->sr_config.type = TYPE_4232H; 747 748 // Set default interface on dual/quad type chips 749 switch(reader->sr_config.type) { 750 case TYPE_2232C: 751 case TYPE_2232H: 752 case TYPE_4232H: 753 if (!reader->sr_config.index) 754 reader->sr_config.index = INTERFACE_A; 755 break; 756 default: 757 break; 758 } 759 760 // Determine maximum packet size 761 reader->sr_config.max_packet_size = smartreader_determine_max_packet_size(reader); 762 763 if (smartreader_set_baudrate (reader, 9600) != 0) { 764 smartreader_usb_close_internal (reader); 765 cs_log("set baudrate failed"); 766 return (-7); 767 } 768 769 return (0); 770 } 771 772 773 int smartreader_usb_purge_rx_buffer(S_READER *reader) 774 { 775 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 776 FTDI_DEVICE_OUT_REQTYPE, 777 SIO_RESET_REQUEST, 778 SIO_RESET_PURGE_RX, 779 reader->sr_config.index, 780 NULL, 781 0, 782 reader->sr_config.usb_write_timeout) != 0) { 783 cs_log("FTDI purge of RX buffer failed"); 784 return (-1); 785 } 786 787 788 return 0; 789 } 790 791 int smartreader_usb_purge_tx_buffer(S_READER *reader) 792 { 793 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 794 FTDI_DEVICE_OUT_REQTYPE, 795 SIO_RESET_REQUEST, 796 SIO_RESET_PURGE_TX, 797 reader->sr_config.index, 798 NULL, 799 0, 800 reader->sr_config.usb_write_timeout) != 0) { 801 cs_log("FTDI purge of TX buffer failed"); 802 return (-1); 803 } 804 805 return 0; 806 } 807 808 int smartreader_usb_purge_buffers(S_READER *reader) 809 { 810 int result; 811 812 result = smartreader_usb_purge_rx_buffer(reader); 813 if (result < 0) 814 return -1; 815 816 result = smartreader_usb_purge_tx_buffer(reader); 817 if (result < 0) 818 return -2; 819 820 return 0; 821 } 822 823 static int smartreader_convert_baudrate(int baudrate, S_READER *reader, unsigned short *value, unsigned short *index) 824 { 825 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1}; 826 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3}; 827 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7}; 828 int divisor, best_divisor, best_baud, best_baud_diff; 829 unsigned long encoded_divisor; 830 int i; 831 832 if (baudrate <= 0) 833 { 834 // Return error 835 return -1; 836 } 837 838 divisor = 24000000 / baudrate; 839 840 if (reader->sr_config.type == TYPE_AM) 841 { 842 // Round down to supported fraction (AM only) 843 divisor -= am_adjust_dn[divisor & 7]; 844 } 845 846 // Try this divisor and the one above it (because division rounds down) 847 best_divisor = 0; 848 best_baud = 0; 849 best_baud_diff = 0; 850 for (i = 0; i < 2; i++) 851 { 852 int try_divisor = divisor + i; 853 int baud_estimate; 854 int baud_diff; 855 856 // Round up to supported divisor value 857 if (try_divisor <= 8) 858 { 859 // Round up to minimum supported divisor 860 try_divisor = 8; 861 } 862 else if (reader->sr_config.type != TYPE_AM && try_divisor < 12) 863 { 864 // BM doesn't support divisors 9 through 11 inclusive 865 try_divisor = 12; 866 } 867 else if (divisor < 16) 868 { 869 // AM doesn't support divisors 9 through 15 inclusive 870 try_divisor = 16; 871 } 872 else 873 { 874 if (reader->sr_config.type == TYPE_AM) 875 { 876 // Round up to supported fraction (AM only) 877 try_divisor += am_adjust_up[try_divisor & 7]; 878 if (try_divisor > 0x1FFF8) 879 { 880 // Round down to maximum supported divisor value (for AM) 881 try_divisor = 0x1FFF8; 882 } 883 } 884 else 885 { 886 if (try_divisor > 0x1FFFF) 887 { 888 // Round down to maximum supported divisor value (for BM) 889 try_divisor = 0x1FFFF; 890 } 891 } 892 } 893 // Get estimated baud rate (to nearest integer) 894 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor; 895 // Get absolute difference from requested baud rate 896 if (baud_estimate < baudrate) 897 { 898 baud_diff = baudrate - baud_estimate; 899 } 900 else 901 { 902 baud_diff = baud_estimate - baudrate; 903 } 904 if (i == 0 || baud_diff < best_baud_diff) 905 { 906 // Closest to requested baud rate so far 907 best_divisor = try_divisor; 908 best_baud = baud_estimate; 909 best_baud_diff = baud_diff; 910 if (baud_diff == 0) 911 { 912 // Spot on! No point trying 913 break; 914 } 915 } 916 } 917 // Encode the best divisor value 918 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14); 919 // Deal with special cases for encoded value 920 if (encoded_divisor == 1) 921 { 922 encoded_divisor = 0; // 3000000 baud 923 } 924 else if (encoded_divisor == 0x4001) 925 { 926 encoded_divisor = 1; // 2000000 baud (BM only) 927 } 928 // Split into "value" and "index" values 929 *value = (unsigned short)(encoded_divisor & 0xFFFF); 930 if (reader->sr_config.type == TYPE_2232C || reader->sr_config.type == TYPE_2232H || reader->sr_config.type == TYPE_4232H) 931 { 932 *index = (unsigned short)(encoded_divisor >> 8); 933 *index &= 0xFF00; 934 *index |= reader->sr_config.index; 935 } 936 else 937 *index = (unsigned short)(encoded_divisor >> 16); 938 939 // Return the nearest baud rate 940 return best_baud; 941 } 942 943 int smartreader_set_baudrate(S_READER *reader, int baudrate) 944 { 945 unsigned short value, index; 946 int actual_baudrate; 947 948 if (reader->sr_config.bitbang_enabled) 949 { 950 baudrate = baudrate*4; 951 } 952 953 actual_baudrate = smartreader_convert_baudrate(baudrate, reader, &value, &index); 954 if (actual_baudrate <= 0) { 955 cs_log("Silly baudrate <= 0."); 956 return (-1); 957 } 958 959 // Check within tolerance (about 5%) 960 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ ) 961 || ((actual_baudrate < baudrate) 962 ? (actual_baudrate * 21 < baudrate * 20) 963 : (baudrate * 21 < actual_baudrate * 20))) { 964 cs_log("Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4"); 965 return (-1); 966 } 967 968 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 969 FTDI_DEVICE_OUT_REQTYPE, 970 SIO_SET_BAUDRATE_REQUEST, 971 value, 972 index, 973 NULL, 974 0, 975 reader->sr_config.usb_write_timeout) != 0) { 976 cs_log("Setting new baudrate failed"); 977 return (-2); 978 } 979 980 reader->sr_config.baudrate = baudrate; 981 return 0; 982 } 983 984 int smartreader_setdtr_rts(S_READER *reader, int dtr, int rts) 985 { 986 unsigned short usb_val; 987 988 if (dtr) 989 usb_val = SIO_SET_DTR_HIGH; 990 else 991 usb_val = SIO_SET_DTR_LOW; 992 993 if (rts) 994 usb_val |= SIO_SET_RTS_HIGH; 995 else 996 usb_val |= SIO_SET_RTS_LOW; 997 998 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 999 FTDI_DEVICE_OUT_REQTYPE, 1000 SIO_SET_MODEM_CTRL_REQUEST, 1001 usb_val, 1002 reader->sr_config.index, 1003 NULL, 1004 0, 1005 reader->sr_config.usb_write_timeout) != 0) { 1006 cs_log("set of rts/dtr failed"); 1007 return (-1); 1008 } 1009 1010 return 0; 1011 } 1012 1013 int smartreader_setflowctrl(S_READER *reader, int flowctrl) 1014 { 1015 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 1016 FTDI_DEVICE_OUT_REQTYPE, 1017 SIO_SET_FLOW_CTRL_REQUEST, 1018 0, 1019 (flowctrl | reader->sr_config.index), 1020 NULL, 1021 0, 1022 reader->sr_config.usb_write_timeout) != 0) { 1023 cs_log("set flow control failed"); 1024 return (-1); 1025 } 1026 1027 return 0; 1028 } 1029 1030 int smartreader_set_line_property2(S_READER *reader, enum smartreader_bits_type bits, 1031 enum smartreader_stopbits_type sbit, enum smartreader_parity_type parity, 1032 enum smartreader_break_type break_type) 1033 { 1034 unsigned short value = bits; 1035 1036 switch (parity) 1037 { 1038 case NONE: 1039 value |= (0x00 << 8); 1040 break; 1041 case ODD: 1042 value |= (0x01 << 8); 1043 break; 1044 case EVEN: 1045 value |= (0x02 << 8); 1046 break; 1047 case MARK: 1048 value |= (0x03 << 8); 1049 break; 1050 case SPACE: 1051 value |= (0x04 << 8); 1052 break; 1053 } 1054 1055 switch (sbit) 1056 { 1057 case STOP_BIT_1: 1058 value |= (0x00 << 11); 1059 break; 1060 case STOP_BIT_15: 1061 value |= (0x01 << 11); 1062 break; 1063 case STOP_BIT_2: 1064 value |= (0x02 << 11); 1065 break; 1066 } 1067 1068 switch (break_type) 1069 { 1070 case BREAK_OFF: 1071 value |= (0x00 << 14); 1072 break; 1073 case BREAK_ON: 1074 value |= (0x01 << 14); 1075 break; 1076 } 1077 1078 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 1079 FTDI_DEVICE_OUT_REQTYPE, 1080 SIO_SET_DATA_REQUEST, 1081 value, 1082 reader->sr_config.index, 1083 NULL, 1084 0, 1085 reader->sr_config.usb_write_timeout) != 0) { 1086 cs_log("Setting new line property failed"); 1087 return (-1); 1088 } 1089 1090 return 0; 1091 } 1092 1093 1094 int smartreader_set_line_property(S_READER *reader, enum smartreader_bits_type bits, 1095 enum smartreader_stopbits_type sbit, enum smartreader_parity_type parity) 1096 { 1097 return smartreader_set_line_property2(reader, bits, sbit, parity, BREAK_OFF); 1098 } 1099 1100 1101 1102 void smart_flush(S_READER *reader) 1103 { 1104 1105 smartreader_usb_purge_buffers(reader); 1106 1107 pthread_mutex_lock(&reader->g_read_mutex); 1108 reader->g_read_buffer_size = 0; 1109 pthread_mutex_unlock(&reader->g_read_mutex); 1110 sched_yield(); 1111 } 1112 1113 static int smart_read(S_READER *reader, unsigned char* buff, unsigned int size, int timeout_sec) 1114 { 1115 1116 int ret = 0; 1117 unsigned int total_read = 0; 1118 struct timeval start, now, dif = {0,0}; 1119 gettimeofday(&start,NULL); 1120 1121 while(total_read < size && dif.tv_sec < timeout_sec) { 1122 pthread_mutex_lock(&reader->g_read_mutex); 1123 1124 if(reader->g_read_buffer_size > 0) { 1125 1126 ret = reader->g_read_buffer_size > size-total_read ? size-total_read : reader->g_read_buffer_size; 1127 memcpy(buff+total_read,reader->g_read_buffer,ret); 1128 reader->g_read_buffer_size -= ret; 1129 total_read+=ret; 1130 } 1131 pthread_mutex_unlock(&reader->g_read_mutex); 1132 1133 gettimeofday(&now,NULL); 1134 timersub(&now, &start, &dif); 1135 usleep(50); 1136 sched_yield(); 1137 } 1138 1139 1140 return total_read; 1141 } 1142 1143 int smartreader_write_data(S_READER *reader, unsigned char *buf, unsigned int size) 1144 { 1145 int ret; 1146 int write_size; 1147 unsigned int offset = 0; 1148 int total_written = 0; 1149 int written; 1150 1151 if(size<reader->sr_config.writebuffer_chunksize) 1152 write_size=size; 1153 else 1154 write_size = reader->sr_config.writebuffer_chunksize; 1155 1156 while (offset < size) 1157 { 1158 1159 if (offset+write_size > size) 1160 write_size = size-offset; 1161 1162 ret = libusb_bulk_transfer(reader->sr_config.usb_dev_handle, 1163 reader->sr_config.in_ep, 1164 buf+offset, 1165 write_size, 1166 &written, 1167 reader->sr_config.usb_write_timeout); 1168 if (ret < 0) { 1169 cs_log("usb bulk write failed : ret = %d",ret); 1170 return(ret); 1171 } 1172 1173 total_written += written; 1174 offset += write_size; 1175 } 1176 1177 return total_written; 1178 } 1179 1180 static int smartreader_set_latency_timer(S_READER *reader, unsigned short latency) 1181 { 1182 unsigned short usb_val; 1183 1184 if (latency < 1) { 1185 cs_log("latency out of range. Only valid for 1-255"); 1186 return (-1); 1187 } 1188 1189 usb_val = latency; 1190 if (libusb_control_transfer(reader->sr_config.usb_dev_handle, 1191 FTDI_DEVICE_OUT_REQTYPE, 1192 SIO_SET_LATENCY_TIMER_REQUEST, 1193 usb_val, 1194 reader->sr_config.index, 1195 NULL, 1196 0, 1197 reader->sr_config.usb_write_timeout) != 0) { 1198 cs_log("unable to set latency timer"); 1199 return (-2); 1200 } 1201 1202 return 0; 1203 } 1204 1205 static int smart_write(S_READER *reader, unsigned char* buff, unsigned int size, int udelay) 1206 { 1207 1208 int ret = 0; 1209 unsigned int idx; 1210 1211 if (udelay == 0) { 1212 ret = smartreader_write_data(reader, buff, size); 1213 if(ret<0) { 1214 #ifdef DEBUG_USB_IO 1215 cs_log("IO:SR: USB write error : %d",ret); 1216 #endif 1217 } 1218 } 1219 else { 1220 for (idx = 0; idx < size; idx++) { 1221 if ((ret = smartreader_write_data(reader, &buff[idx], 1)) < 0){ 1222 break; 1223 } 1224 usleep(udelay); 1225 } 1226 } 1227 sched_yield(); 1228 return ret; 1229 } 1230 1231 1232 static void* ReaderThread(void *p) 1233 { 1234 1235 struct s_reader *reader; 1236 int ret; 1237 int read; 1238 unsigned int copy_size; 1239 unsigned char local_buffer[64]; //64 is max transfer size of FTDI bulk pipe 1240 1241 reader = (struct s_reader *)p; 1242 reader->sr_config.running=TRUE; 1243 1244 1245 1246 while(reader->sr_config.running){ 1247 if(reader->g_read_buffer_size == sizeof(reader->g_read_buffer)){ 1248 cs_log("buffer full"); 1249 //if out read buffer is full then delay 1250 //slightly and go around again 1251 usleep(20000); 1252 continue; 1253 } 1254 1255 ret = libusb_bulk_transfer(reader->sr_config.usb_dev_handle, 1256 reader->sr_config.out_ep, 1257 local_buffer, 1258 4, 1259 &read, 1260 reader->sr_config.usb_read_timeout); 1261 if(ret<0) { 1262 #ifdef DEBUG_USB_IO 1263 cs_log("IO:SR: usb_bulk_read read error %d",ret); 1264 #endif 1265 } 1266 sched_yield(); 1267 if(read>2) { //FTDI always sends modem status bytes as first 2 chars with the 232BM 1268 pthread_mutex_lock(&reader->g_read_mutex); 1269 reader->modem_status= local_buffer[0]; 1270 copy_size = sizeof(reader->g_read_buffer) - reader->g_read_buffer_size > (unsigned int)read-2 ? (unsigned int)read-2: sizeof(reader->g_read_buffer) - reader->g_read_buffer_size; 1271 memcpy(reader->g_read_buffer+reader->g_read_buffer_size,local_buffer+2,copy_size); 1272 reader->g_read_buffer_size += copy_size; 1273 pthread_mutex_unlock(&reader->g_read_mutex); 1274 } 1275 else { 1276 if(read==2) { 1277 pthread_mutex_lock(&reader->g_read_mutex); 1278 reader->modem_status=local_buffer[0]; 1279 pthread_mutex_unlock(&reader->g_read_mutex); 1280 } 1281 } 1282 } 1283 1284 pthread_exit(NULL); 1285 } 1286 640 1287 #endif // HAVE_LIBUSB && USE_PTHREAD -
trunk/csctapi/ifd_smartreader.h
r1406 r1419 17 17 #include <pthread.h> 18 18 #include <memory.h> 19 19 #include <libusb-1.0/libusb.h> 20 20 #include "../globals.h" 21 #include "ftdi.h"22 21 #include "atr.h" 23 22 23 #include "smartreader_types.h" 24 24 25 25 int SR_Init (struct s_reader *reader); -
trunk/globals.h
r1415 r1419 54 54 55 55 #if defined(LIBUSB) 56 #include "csctapi/ftdi.h" 56 #include <libusb-1.0/libusb.h> 57 #include "csctapi/smartreader_types.h" 57 58 #endif 58 59 … … 274 275 int parity; 275 276 int irdeto; 277 int running; 278 libusb_device *usb_dev; 279 libusb_device_handle *usb_dev_handle; 280 int in_ep; // 0x01 281 int out_ep; // 0x82 282 int index; 283 /** usb read timeout */ 284 int usb_read_timeout; 285 /** usb write timeout */ 286 int usb_write_timeout; 287 unsigned int writebuffer_chunksize; 288 unsigned char bitbang_enabled; 289 int baudrate; 290 enum smartreader_chip_type type; 291 int interface; // 0 or 1 292 /** maximum packet size. Needed for filtering modem status bytes every n packets. */ 293 unsigned int max_packet_size; 276 294 } SR_CONFIG; 295 277 296 278 297 struct s_ecm … … 481 500 #if defined(LIBUSB) 482 501 unsigned char g_read_buffer[4096]; 483 int g_read_buffer_size;502 unsigned int g_read_buffer_size; 484 503 pthread_mutex_t g_read_mutex; 485 504 pthread_mutex_t g_usb_mutex; 486 struct ftdi_context ftdic;487 505 struct usb_device *smartreader_usb_dev; 488 506 pthread_t rt; … … 490 508 SR_CONFIG sr_config; 491 509 #endif 492 493 510 }; 494 511 -
trunk/reader-common.c
r1399 r1419 9 9 extern int ICC_Async_Device_Init (); 10 10 extern int ICC_Async_CardWrite (unsigned char *cmd, unsigned short lc, unsigned char *rsp, unsigned short *lr); 11 extern int ICC_Async_Activate (ATR * atr );11 extern int ICC_Async_Activate (ATR * atr, unsigned short deprecated); 12 12 extern int ICC_Async_GetStatus (int * card); 13 13 #define SC_IRDETO 1 … … 112 112 } 113 113 114 static int reader_activate_card(ATR * atr )114 static int reader_activate_card(ATR * atr, unsigned short deprecated) 115 115 { 116 116 int i; … … 132 132 cs_ptyp=D_DEVICE; 133 133 for (i=0; i<5; i++) { 134 if (!ICC_Async_Activate(atr )) {134 if (!ICC_Async_Activate(atr, deprecated)) { 135 135 i = 100; 136 136 break; … … 239 239 static int reader_reset(void) 240 240 { 241 241 reader_nullcard(); 242 242 ATR atr; 243 if (!reader_activate_card(&atr)) return(0); 244 return(reader_get_cardsystem(atr)); 243 unsigned short int ret, deprecated; 244 for (deprecated = reader[ridx].deprecated; deprecated < 2; deprecated++) { 245 if (!reader_activate_card(&atr, deprecated)) return(0); 246 ret =reader_get_cardsystem(atr); 247 if (ret) 248 break; 249 if (!deprecated) 250 cs_log("Normal mode failed, reverting to Deprecated Mode"); 251 } 252 return(ret); 245 253 } 246 254
Note:
See TracChangeset
for help on using the changeset viewer.