Changeset 1252


Ignore:
Timestamp:
01/16/10 17:09:51 (11 years ago)
Author:
dingo35
Message:

New SetBaudrate in ifd_phoenix.c eliminates lot of stuff

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/csctapi/icc_async.c

    r1245 r1252  
    211211
    212212    /* Initialize Baudrate */
    213     if (IFD_Towitoko_SetBaudrate (ifd, ICC_ASYNC_BAUDRATE)!= IFD_TOWITOKO_OK)
     213    if (!Phoenix_SetBaudrate (ICC_ASYNC_BAUDRATE))
    214214        return ICC_ASYNC_IFD_ERROR;
    215215   
    … …  
    354354{
    355355    icc->baudrate = baudrate;
    356     if (IFD_Towitoko_SetBaudrate (icc->ifd, baudrate) !=  IFD_TOWITOKO_OK)
     356    if (!Phoenix_SetBaudrate (baudrate))
    357357      return ICC_ASYNC_IFD_ERROR;
    358358   

  • trunk/csctapi/ifd_phoenix.c

    r1224 r1252  
    1111#include "atr.h"
    1212#include "ifd_towitoko.h" //FIXME
     13#include <termios.h>
    1314
    1415#define OK      1
    … …  
    143144}
    144145
    145 int Phoenix_SetBaudrate (int mhz)
     146int Phoenix_SetBaudrate (unsigned long baudrate)
    146147{
     148    if(reader[ridx].typ == R_INTERNAL)
     149        return OK;
     150
     151#ifdef DEBUG_IFD
     152    printf ("IFD: Setting baudrate to %lu\n", baudrate);
     153#endif
     154    if (reader[ridx].baudrate   == baudrate)
     155        return OK;
     156
     157    /* Get current settings */
     158    struct termios tio;
     159    if (tcgetattr (reader[ridx].handle, &tio) != 0)
     160        return ERROR;
     161   
     162    //write baudrate here!
     163    if (!IO_Serial_SetBitrate (baudrate, &tio))
     164        return ERROR;
     165   
     166    if (!IO_Serial_SetProperties(tio))
     167        return ERROR;
     168   
     169    reader[ridx].baudrate = baudrate;
     170   
    147171    return OK;
    148172}

  • trunk/csctapi/ifd_towitoko.c

    r1236 r1252  
    181181   
    182182    /* Default serial port settings */
    183     io->input_bitrate = IFD_TOWITOKO_BAUDRATE;
    184     io->output_bitrate = IFD_TOWITOKO_BAUDRATE;
    185     io->bits = 8;
    186     io->stopbits = 2;
    187     io->parity = PARITY_EVEN;
    188     io->dtr = IO_SERIAL_HIGH;
    189 //  io->dtr = IO_SERIAL_LOW;
    190 //  io->rts = IO_SERIAL_HIGH;
    191     io->rts = IO_SERIAL_LOW;
    192    
    193        
    194     if (!IO_Serial_SetPropertiesOld (io))
    195         return IFD_TOWITOKO_IO_ERROR;
     183    if (!IO_Serial_SetParams (IFD_TOWITOKO_BAUDRATE, 8, PARITY_EVEN, 2, IO_SERIAL_HIGH, IO_SERIAL_LOW))
     184        return FALSE;
    196185       
    197186    /* Default ifd settings */
    … …  
    201190    ifd->type = IFD_TOWITOKO_MULTICAM;
    202191   
    203     ret = IFD_Towitoko_SetBaudrate (ifd, IFD_TOWITOKO_BAUDRATE);
    204    
    205     if (ret != IFD_TOWITOKO_OK)
     192    if (!Phoenix_SetBaudrate(IFD_TOWITOKO_BAUDRATE))
    206193    {
    207194        IFD_Towitoko_Clear (ifd);
    208         return ret;
     195        return IFD_TOWITOKO_IO_ERROR;
    209196    }
    210197   
    … …  
    251238    IFD_Towitoko_Clear (ifd);
    252239   
    253    
    254     return IFD_TOWITOKO_OK;
    255 }
    256 
    257 int IFD_Towitoko_SetBaudrate (IFD * ifd, unsigned long baudrate)
    258 {
    259     if(reader[ridx].typ == R_INTERNAL)
    260     {
    261         return IFD_TOWITOKO_OK;
    262     }
    263 #ifdef DEBUG_IFD
    264     printf ("IFD: Setting baudrate to %lu\n", baudrate);
    265 #endif
    266     /* Get current settings */
    267     if (!IO_Serial_GetPropertiesOld (ifd->io))
    268         return IFD_TOWITOKO_IO_ERROR;
    269    
    270     if (ifd->io->output_bitrate == baudrate)
    271         return IFD_TOWITOKO_OK;
    272 
    273    
    274     /* Set serial device bitrate */
    275     ifd->io->output_bitrate = baudrate;
    276     ifd->io->input_bitrate = baudrate;
    277    
    278     if (!IO_Serial_SetPropertiesOld (ifd->io))
    279         return IFD_TOWITOKO_IO_ERROR;
    280    
    281     return IFD_TOWITOKO_OK;
    282 }
    283 
    284 int IFD_Towitoko_GetBaudrate (IFD * ifd, unsigned long *baudrate)
    285 {
    286     if(reader[ridx].typ == R_INTERNAL)
    287     {
    288         return IFD_TOWITOKO_OK;
    289     }
    290    
    291     /* Get current settings */
    292     if (!IO_Serial_GetPropertiesOld (ifd->io))
    293         return IFD_TOWITOKO_IO_ERROR;
    294    
    295     (*baudrate) = ifd->io->output_bitrate;
    296240   
    297241    return IFD_TOWITOKO_OK;

  • trunk/csctapi/ifd_towitoko.h

    r1236 r1252  
    116116/* Handling of this IFD */
    117117extern int IFD_Towitoko_SetBaudrate (IFD * ifd, unsigned long baudrate);
    118 extern int IFD_Towitoko_GetBaudrate (IFD * ifd, unsigned long *baudrate);
    119118
    120119/* General handling of ICC inserted in this IFD */

  • trunk/csctapi/io_serial.c

    r1249 r1252  
    180180}
    181181
    182 bool IO_Serial_GetPropertiesOld (IO_Serial * io)
    183 {
    184     struct termios currtio;
    185     speed_t i_speed, o_speed;
    186     unsigned int mctl;
    187 
    188 #ifdef SCI_DEV
    189     if(reader[ridx].typ == R_INTERNAL)
    190         return FALSE;
    191 #endif
    192 
    193     if (io->input_bitrate != 0 && io->output_bitrate != 0) //properties are already filled
    194       return TRUE;
    195    
    196     if (tcgetattr (reader[ridx].handle, &currtio) != 0)
    197         return FALSE;
    198 
    199     o_speed = cfgetospeed (&currtio);
    200    
    201     switch (o_speed)
    202     {
    203 #ifdef B0
    204         case B0:
    205             io->output_bitrate = 0;
    206             break;
    207 #endif
    208 #ifdef B50
    209         case B50:
    210             io->output_bitrate = 50;
    211             break;
    212 #endif
    213 #ifdef B75
    214         case B75:
    215             io->output_bitrate = 75;
    216             break;
    217 #endif
    218 #ifdef B110
    219         case B110:
    220             io->output_bitrate = 110;
    221             break;
    222 #endif
    223 #ifdef B134
    224         case B134:
    225             io->output_bitrate = 134;
    226             break;
    227 #endif
    228 #ifdef B150
    229         case B150:
    230             io->output_bitrate = 150;
    231             break;
    232 #endif
    233 #ifdef B200
    234         case B200:
    235             io->output_bitrate = 200;
    236             break;
    237 #endif
    238 #ifdef B300
    239         case B300:
    240             io->output_bitrate = 300;
    241             break;
    242 #endif
    243 #ifdef B600
    244         case B600:
    245             io->output_bitrate = 600;
    246             break;
    247 #endif
    248 #ifdef B1200
    249         case B1200:
    250             io->output_bitrate = 1200;
    251             break;
    252 #endif
    253 #ifdef B1800
    254         case B1800:
    255             io->output_bitrate = 1800;
    256             break;
    257 #endif
    258 #ifdef B2400
    259         case B2400:
    260             io->output_bitrate = 2400;
    261             break;
    262 #endif
    263 #ifdef B4800
    264         case B4800:
    265             io->output_bitrate = 4800;
    266             break;
    267 #endif
    268 #ifdef B9600
    269         case B9600:
    270             io->output_bitrate = 9600;
    271             break;
    272 #endif
    273 #ifdef B19200
    274         case B19200:
    275             io->output_bitrate = 19200;
    276             break;
    277 #endif
    278 #ifdef B38400
    279         case B38400:
    280             io->output_bitrate = 38400;
    281             break;
    282 #endif
    283 #ifdef B57600
    284         case B57600:
    285             io->output_bitrate = 57600;
    286             break;
    287 #endif
    288 #ifdef B115200
    289         case B115200:
    290             io->output_bitrate = 115200;
    291             break;
    292 #endif
    293 #ifdef B230400
    294         case B230400:
    295             io->output_bitrate = 230400;
    296             break;
    297 #endif
    298         default:
    299             io->output_bitrate = 1200;
    300             break;
    301     }
    302 
    303     i_speed = cfgetispeed (&currtio);
    304    
    305     switch (i_speed)
    306     {
    307 #ifdef B0
    308         case B0:
    309             io->input_bitrate = 0;
    310             break;
    311 #endif
    312 #ifdef B50
    313         case B50:
    314             io->input_bitrate = 50;
    315             break;
    316 #endif
    317 #ifdef B75
    318         case B75:
    319             io->input_bitrate = 75;
    320             break;
    321 #endif
    322 #ifdef B110
    323         case B110:
    324             io->input_bitrate = 110;
    325             break;
    326 #endif
    327 #ifdef B134
    328         case B134:
    329             io->input_bitrate = 134;
    330             break;
    331 #endif
    332 #ifdef B150
    333         case B150:
    334             io->input_bitrate = 150;
    335             break;
    336 #endif
    337 #ifdef B200
    338         case B200:
    339             io->input_bitrate = 200;
    340             break;
    341 #endif
    342 #ifdef B300
    343         case B300:
    344             io->input_bitrate = 300;
    345             break;
    346 #endif
    347 #ifdef B600
    348         case B600:
    349             io->input_bitrate = 600;
    350             break;
    351 #endif
    352 #ifdef B1200
    353         case B1200:
    354             io->input_bitrate = 1200;
    355             break;
    356 #endif
    357 #ifdef B1800
    358         case B1800:
    359             io->input_bitrate = 1800;
    360             break;
    361 #endif
    362 #ifdef B2400
    363         case B2400:
    364             io->input_bitrate = 2400;
    365             break;
    366 #endif
    367 #ifdef B4800
    368         case B4800:
    369             io->input_bitrate = 4800;
    370             break;
    371 #endif
    372 #ifdef B9600
    373         case B9600:
    374             io->input_bitrate = 9600;
    375             break;
    376 #endif
    377 #ifdef B19200
    378         case B19200:
    379             io->input_bitrate = 19200;
    380             break;
    381 #endif
    382 #ifdef B38400
    383         case B38400:
    384             io->input_bitrate = 38400;
    385             break;
    386 #endif
    387 #ifdef B57600
    388         case B57600:
    389             io->input_bitrate = 57600;
    390             break;
    391 #endif
    392 #ifdef B115200
    393         case B115200:
    394             io->input_bitrate = 115200;
    395             break;
    396 #endif
    397 #ifdef B230400
    398         case B230400:
    399             io->input_bitrate = 230400;
    400             break;
    401 #endif
    402         default:
    403             io->input_bitrate = 1200;
    404             break;
    405     }
    406    
    407     switch (currtio.c_cflag & CSIZE)
    408     {
    409         case CS5:
    410             io->bits = 5;
    411             break;
    412         case CS6:
    413             io->bits = 6;
    414             break;
    415         case CS7:
    416             io->bits = 7;
    417             break;
    418         case CS8:
    419             io->bits = 8;
    420             break;
    421     }
    422    
    423     if (((currtio.c_cflag) & PARENB) == PARENB)
    424     {
    425         if (((currtio.c_cflag) & PARODD) == PARODD)
    426             io->parity = PARITY_ODD;
    427         else
    428             io->parity = PARITY_EVEN;
    429     }
    430     else
    431     {
    432         io->parity = PARITY_NONE;
    433     }
    434    
    435     if (((currtio.c_cflag) & CSTOPB) == CSTOPB)
    436         io->stopbits = 2;
    437     else
    438         io->stopbits = 1;
    439    
    440     if (ioctl (reader[ridx].handle, TIOCMGET, &mctl) < 0)
    441         return FALSE;
    442    
    443     io->dtr = ((mctl & TIOCM_DTR) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    444     io->rts = ((mctl & TIOCM_RTS) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    445    
    446 #ifdef DEBUG_IO
    447     printf("IO: Getting properties: %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
    448 #endif
    449    
    450     return TRUE;
    451 }
    452 
    453 bool IO_Serial_SetPropertiesOld (IO_Serial * io)
    454 {
    455    struct termios newtio;
    456    
    457 #ifdef SCI_DEV
    458    if(reader[ridx].typ == R_INTERNAL)
    459       return FALSE;
    460 #endif
    461    
    462    //   printf("IO: Setting properties: reader_type%d, %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", reader[ridx].typ, io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
    463    memset (&newtio, 0, sizeof (newtio));
    464 
    465 
     182bool IO_Serial_SetBitrate (unsigned long bitrate, struct termios * tio)
     183{
    466184   /* Set the bitrate */
    467185#ifdef OS_LINUX
    468186   if (reader[ridx].mhz == reader[ridx].cardmhz)
    469187#endif
    470    { //no overclocking
    471      cfsetospeed(&newtio, IO_Serial_Bitrate(io->output_bitrate));
    472      cfsetispeed(&newtio, IO_Serial_Bitrate(io->input_bitrate));
    473      cs_debug("standard baudrate: cardmhz=%d mhz=%d -> effective baudrate %lu", reader[ridx].cardmhz, reader[ridx].mhz, io->output_bitrate);
     188   { //no overcloking
     189     cfsetospeed(tio, IO_Serial_Bitrate(bitrate));
     190     cfsetispeed(tio, IO_Serial_Bitrate(bitrate));
     191     cs_debug("standard baudrate: cardmhz=%d mhz=%d -> effective baudrate %lu", reader[ridx].cardmhz, reader[ridx].mhz, bitrate);
    474192   }
    475193#ifdef OS_LINUX
    … …  
    478196    struct serial_struct nuts;
    479197    ioctl(reader[ridx].handle, TIOCGSERIAL, &nuts);
    480     int custom_baud = io->output_bitrate * reader[ridx].mhz / reader[ridx].cardmhz;
     198    int custom_baud = bitrate * reader[ridx].mhz / reader[ridx].cardmhz;
    481199    nuts.custom_divisor = (nuts.baud_base + (custom_baud/2))/ custom_baud;
    482200    cs_debug("custom baudrate: cardmhz=%d mhz=%d custom_baud=%d baud_base=%d divisor=%d -> effective baudrate %d",
    … …  
    485203    nuts.flags |= ASYNC_SPD_CUST;
    486204    ioctl(reader[ridx].handle, TIOCSSERIAL, &nuts);
    487     cfsetospeed(&newtio, IO_Serial_Bitrate(38400));
    488     cfsetispeed(&newtio, IO_Serial_Bitrate(38400));
     205    cfsetospeed(tio, IO_Serial_Bitrate(38400));
     206    cfsetispeed(tio, IO_Serial_Bitrate(38400));
    489207   }
    490208#endif
    491        
    492    /* Set the character size */
    493    switch (io->bits)
    494    {
     209    return TRUE;
     210}
     211
     212bool IO_Serial_SetParams (unsigned long bitrate, unsigned bits, int parity, unsigned stopbits, int dtr, int rts)
     213{
     214     struct termios newtio;
     215   
     216     if(reader[ridx].typ == R_INTERNAL)
     217            return FALSE;
     218     
     219     // printf("IO: Setting properties: reader_type%d, %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", reader[ridx].typ, bitrate, bits, parity == PARITY_EVEN ? "Even" : parity == PARITY_ODD ? "Odd" : "None", stopbits, dtr, rts);
     220     memset (&newtio, 0, sizeof (newtio));
     221
     222    if (!IO_Serial_SetBitrate (bitrate, & newtio))
     223        return FALSE;
     224               
     225     /* Set the character size */
     226     switch (bits)
     227     {
    495228        case 5:
    496229            newtio.c_cflag |= CS5;
    … …  
    511244   
    512245    /* Set the parity */
    513     switch (io->parity)
     246    switch (parity)
    514247    {
    515248        case PARITY_ODD:
    … …  
    529262   
    530263    /* Set the number of stop bits */
    531     switch (io->stopbits)
     264    switch (stopbits)
    532265    {
    533266        case 1:
    … …  
    553286    newtio.c_cc[VTIME] = 0;
    554287
    555 //  tcdrain(reader[ridx].handle);
    556     if (tcsetattr (reader[ridx].handle, TCSANOW, &newtio) < 0)
    557         return FALSE;
    558 //  tcflush(reader[ridx].handle, TCIOFLUSH);
    559 //  if (tcsetattr (reader[ridx].handle, TCSAFLUSH, &newtio) < 0)
    560 //      return FALSE;
    561 
    562     IO_Serial_Ioctl_Lock(1);
    563     IO_Serial_DTR_RTS(0, io->rts == IO_SERIAL_HIGH);
    564     IO_Serial_DTR_RTS(1, io->dtr == IO_SERIAL_HIGH);
    565     IO_Serial_Ioctl_Lock(0);
    566    
    567 #ifdef DEBUG_IO
    568     printf("IO: Setting properties: reader_type%d, %ld bps; %d bits/byte; %s parity; %d stopbits; dtr=%d; rts=%d\n", reader[ridx].typ, io->input_bitrate, io->bits, io->parity == PARITY_EVEN ? "Even" : io->parity == PARITY_ODD ? "Odd" : "None", io->stopbits, io->dtr, io->rts);
    569 #endif
    570     return TRUE;
    571 }
    572 
    573 bool IO_Serial_SetProperties (struct termios newtio)
    574 {
    575    if(reader[ridx].typ == R_INTERNAL)
    576       return FALSE;
    577 
    578     if (tcsetattr (reader[ridx].handle, TCSANOW, &newtio) < 0)
    579         return FALSE;
    580 //  tcflush(reader[ridx].handle, TCIOFLUSH);
    581 //  if (tcsetattr (reader[ridx].handle, TCSAFLUSH, &newtio) < 0)
    582 //      return FALSE;
    583 
    584     unsigned int mctl;
    585     if (ioctl (reader[ridx].handle, TIOCMGET, &mctl) < 0)
    586         return FALSE;
    587    
    588     int dtr = ((mctl & TIOCM_DTR) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
    589     int rts = ((mctl & TIOCM_RTS) ? IO_SERIAL_HIGH : IO_SERIAL_LOW);
     288    if (!IO_Serial_SetProperties(newtio))
     289        return FALSE;
     290
     291    reader[ridx].baudrate = bitrate;
    590292
    591293    IO_Serial_Ioctl_Lock(1);
    … …  
    594296    IO_Serial_Ioctl_Lock(0);
    595297
     298    return TRUE;
     299}
     300
     301bool IO_Serial_SetProperties (struct termios newtio)
     302{
     303   if(reader[ridx].typ == R_INTERNAL)
     304      return FALSE;
     305
     306    if (tcsetattr (reader[ridx].handle, TCSANOW, &newtio) < 0)
     307        return FALSE;
     308//  tcflush(reader[ridx].handle, TCIOFLUSH);
     309//  if (tcsetattr (reader[ridx].handle, TCSAFLUSH, &newtio) < 0)
     310//      return FALSE;
     311
     312    unsigned int mctl;
     313    if (ioctl (reader[ridx].handle, TIOCMGET, &mctl) < 0)
     314        return FALSE;
     315   
    596316#ifdef DEBUG_IO
    597317    printf("IO: Setting properties\n");
    … …  
    1048768{
    1049769    int i = 0;
    1050     io->input_bitrate = 1200;
    1051     io->output_bitrate = 1200;
    1052     io->parity = PARITY_NONE;
    1053     io->bits = 7;
    1054     io->stopbits = 1;
    1055     io->dtr = IO_SERIAL_HIGH;
    1056     io->rts = IO_SERIAL_LOW;
    1057    
    1058     if (!IO_Serial_SetPropertiesOld (io))
     770  if (!IO_Serial_SetParams (1200, 7, PARITY_NONE, 1, IO_SERIAL_HIGH, IO_SERIAL_LOW))
    1059771        return FALSE;
    1060772

  • trunk/csctapi/io_serial.h

    r1236 r1252  
    8686
    8787/* Transmission properties */
    88 extern bool IO_Serial_SetPropertiesOld (IO_Serial * io);
    89 extern bool IO_Serial_GetPropertiesOld (IO_Serial * io);
    9088extern bool IO_Serial_DTR_RTS(int, int);
    9189#if defined(TUXBOX) && defined(PPC)

  • trunk/globals.h

    r1237 r1252  
    411411  int       card_status; //highlevel status
    412412  unsigned short status; //lowlevel status: states whether card inserted and/or change of status FIXME look at integration with pcsc_has_card/detect/card_status
    413     unsigned long baudrate; //we are storing baudrate to prevent unnecessary conversions from/to termios structure
     413    unsigned long baudrate; //we are storing the (for overclocking uncorrected) baudrate to prevent unnecessary conversions from/to termios structure
    414414  struct    s_module ph;
    415415  uchar     ncd_key[16];
Note: See TracChangeset for help on using the changeset viewer.