Ignore:
Timestamp:
01/14/10 19:07:30 (13 years ago)
Author:
alno
Message:

WebIf:

  • Command: Merging revisions 1212-1227 of trunk
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/monitor-improvement/csctapi/io_serial.c

    r1210 r1228  
    6060static int IO_Serial_Bitrate(int bitrate);
    6161
    62 static bool IO_Serial_WaitToRead (int hnd, unsigned delay_ms, unsigned timeout_ms);
    63 
    64 static bool IO_Serial_WaitToWrite (IO_Serial *io, unsigned delay_ms, unsigned timeout_ms);
     62static bool IO_Serial_WaitToRead (unsigned delay_ms, unsigned timeout_ms);
     63
     64static bool IO_Serial_WaitToWrite (unsigned delay_ms, unsigned timeout_ms);
    6565
    6666static void IO_Serial_DeviceName (char * filename, unsigned length);
     
    7373int io_serial_need_dummy_char = 0;
    7474
    75 int fdmc=(-1);
     75extern int fdmc;
    7676
    7777#if defined(TUXBOX) && defined(PPC)
    78 void IO_Serial_Ioctl_Lock(IO_Serial * io, int flag)
     78void IO_Serial_Ioctl_Lock(int flag)
    7979{
    8080  extern int *oscam_sem;
    81   if ((io->reader_type!=R_DB2COM1) && (io->reader_type!=R_DB2COM2)) return;
     81  if ((reader[ridx].typ != R_DB2COM1) && (reader[ridx].typ != R_DB2COM2)) return;
    8282  if (!flag)
    8383    *oscam_sem=0;
    84   else while (*oscam_sem!=io->reader_type)
     84  else while (*oscam_sem!=reader[ridx].typ)
    8585  {
    8686    while (*oscam_sem)
    87     usleep((io->reader_type)*2000);
    88     *oscam_sem=io->reader_type;
     87    usleep((reader[ridx].typ)*2000); //FIXME is this right ?!?!
     88    *oscam_sem=reader[ridx].typ;
    8989    usleep(1000);
    9090  }
     
    176176bool IO_Serial_Init (IO_Serial * io, int reader_type)
    177177{
    178     char filename[IO_SERIAL_FILENAME_LENGTH];
    179    
    180     IO_Serial_DeviceName (filename, IO_SERIAL_FILENAME_LENGTH);
    181    
    182 #ifdef DEBUG_IO
    183     printf ("IO: Opening serial port %s\n", filename);
    184 #endif
    185    
    186178    io->reader_type = reader_type;
    187 
    188 #if defined(SCI_DEV) || defined(COOL)
    189     if (reader_type==R_INTERNAL)
    190 #ifdef SH4
    191         io->fd = open (filename, O_RDWR|O_NONBLOCK|O_NOCTTY);
    192 #elif COOL
    193         return Cool_Init();
    194 #else
    195         io->fd = open (filename, O_RDWR);
    196 #endif
    197     else
    198 #endif
    199 
    200 //#ifdef OS_MACOSX
    201         // on mac os x, make sure you use the /dev/cu.XXXX device in oscam.server
    202         io->fd = open (filename,  O_RDWR | O_NOCTTY| O_NONBLOCK);
    203 //#else
    204 //              with O_SYNC set OSCam is very critical on opening a device, on certain installs
    205 //              (eg virtual Ubuntu with /dev/ttyUSB) it gives "Error activating card"
    206 //              with O_NONBLOCK this problem is solved
    207 //      io->fd = open (filename, O_RDWR | O_NOCTTY | O_SYNC);
    208 //#endif
    209 
    210     if (io->fd < 0)
    211         return FALSE;
    212 
    213 #if defined(TUXBOX) && defined(PPC)
    214     if ((reader_type == R_DB2COM1) || (reader_type == R_DB2COM2))
    215         if ((fdmc = open(DEV_MULTICAM, O_RDWR)) < 0)
    216         {
    217             close(io->fd);
    218             return FALSE;
    219         }
    220 #endif
    221    
     179    io->fd = reader[ridx].handle;
     180
    222181    if (reader_type != R_INTERNAL)
    223182        IO_Serial_InitPnP (io);
    224183   
    225184    if(io->reader_type!=R_INTERNAL)
    226         IO_Serial_Flush(io);
     185        IO_Serial_Flush();
    227186       
    228187    return TRUE;
     
    609568//      return FALSE;
    610569
    611     IO_Serial_Ioctl_Lock(io, 1);
     570    IO_Serial_Ioctl_Lock(1);
    612571    IO_Serial_DTR_RTS(io, 0, io->rts == IO_SERIAL_HIGH);
    613572    IO_Serial_DTR_RTS(io, 1, io->dtr == IO_SERIAL_HIGH);
    614     IO_Serial_Ioctl_Lock(io, 0);
     573    IO_Serial_Ioctl_Lock(0);
    615574   
    616575#ifdef DEBUG_IO
     
    620579}
    621580
    622 void IO_Serial_Flush (IO_Serial * io)
     581void IO_Serial_Flush ()
    623582{
    624583    BYTE b;
    625     while(IO_Serial_Read(io, 1000, 1, &b));
     584    while(IO_Serial_Read(1000, 1, &b));
    626585}
    627586
     
    639598
    640599
    641 bool IO_Serial_Read (IO_Serial * io, unsigned timeout, unsigned size, BYTE * data)
     600bool IO_Serial_Read (unsigned timeout, unsigned size, BYTE * data)
    642601{
    643602    BYTE c;
     
    648607#endif
    649608   
    650     if((io->reader_type!=R_INTERNAL) && (io->wr>0))
     609    if((reader[ridx].typ != R_INTERNAL) && (wr>0))
    651610    {
    652611        BYTE buf[256];
    653         int n = io->wr;
    654         io->wr = 0;
    655    
    656         if(!IO_Serial_Read (io, timeout, n, buf))
     612        int n = wr;
     613        wr = 0;
     614   
     615        if(!IO_Serial_Read (timeout, n, buf))
    657616        {
    658617            return FALSE;
     
    672631        while( (((tv_spent.tv_sec-tv.tv_sec)*1000) + ((tv_spent.tv_usec-tv.tv_usec)/1000L))<timeout )
    673632        {
    674             if (read (io->fd, &c, 1) == 1)
     633            if (read (reader[ridx].handle, &c, 1) == 1)
    675634            {
    676635                readed=TRUE;
     
    687646#endif
    688647#else
    689         if (IO_Serial_WaitToRead (io->fd, 0, timeout))
     648        if (IO_Serial_WaitToRead (0, timeout))
    690649        {
    691             if (read (io->fd, &c, 1) != 1)
     650            if (read (reader[ridx].handle, &c, 1) != 1)
    692651            {
    693652#ifdef DEBUG_IO
     
    710669            fflush (stdout);
    711670#endif
    712             tcflush (io->fd, TCIFLUSH);
     671            tcflush (reader[ridx].handle, TCIFLUSH);
    713672            return FALSE;
    714673        }
     
    729688
    730689
    731 bool IO_Serial_Write (IO_Serial * io, unsigned delay, unsigned size, BYTE * data)
     690bool IO_Serial_Write (unsigned delay, unsigned size, BYTE * data)
    732691{
    733692    unsigned count, to_send, i_w;
     
    749708            to_send = (delay? 1: size);
    750709       
    751         if (IO_Serial_WaitToWrite (io, delay, 1000))
     710        if (IO_Serial_WaitToWrite (delay, 1000))
    752711        {
    753712            for (i_w=0; i_w < to_send; i_w++) {
     
    757716              }
    758717            }
    759             unsigned int u = write (io->fd, data_w, (1+io_serial_need_dummy_char)*to_send);
     718            unsigned int u = write (reader[ridx].handle, data_w, (1+io_serial_need_dummy_char)*to_send);
    760719            _in_echo_read = 1;
    761720            if (u != (1+io_serial_need_dummy_char)*to_send)
     
    765724                fflush (stdout);
    766725#endif
    767                 if(io->reader_type!=R_INTERNAL)
    768                     io->wr += u;
     726                if(reader[ridx].typ != R_INTERNAL)
     727                    wr += u;
    769728                return FALSE;
    770729            }
    771730           
    772             if(io->reader_type!=R_INTERNAL)
    773                 io->wr += to_send;
     731            if(reader[ridx].typ != R_INTERNAL)
     732                wr += to_send;
    774733           
    775734#ifdef DEBUG_IO
     
    885844}
    886845
    887 static bool IO_Serial_WaitToRead (int hnd, unsigned delay_ms, unsigned timeout_ms)
     846static bool IO_Serial_WaitToRead (unsigned delay_ms, unsigned timeout_ms)
    888847{
    889848   fd_set rfds;
     
    906865   }
    907866   
    908    in_fd=hnd;
     867   in_fd=reader[ridx].handle;
    909868   
    910869   FD_ZERO(&rfds);
     
    936895}
    937896
    938 static bool IO_Serial_WaitToWrite (IO_Serial *io, unsigned delay_ms, unsigned timeout_ms)
     897static bool IO_Serial_WaitToWrite (unsigned delay_ms, unsigned timeout_ms)
    939898{
    940899   fd_set wfds;
     
    945904   
    946905#ifdef SCI_DEV
    947    if(io->reader_type==R_INTERNAL)
     906   if(reader[ridx].typ == R_INTERNAL)
    948907      return TRUE;
    949908#endif
     
    962921   }
    963922
    964    out_fd=io->fd;
     923   out_fd=reader[ridx].handle;
    965924   
    966925   FD_ZERO(&wfds);
     
    1001960    memset (io->PnP_id, 0, IO_SERIAL_PNPID_SIZE);
    1002961    io->PnP_id_size = 0;
    1003     io->wr = 0;
     962    wr = 0;
    1004963    //modifyable properties:
    1005964    io->input_bitrate = 0;
     
    1033992        return FALSE;
    1034993
    1035     while ((i < IO_SERIAL_PNPID_SIZE) && IO_Serial_Read (io, 200, 1, &(io->PnP_id[i])))
     994    while ((i < IO_SERIAL_PNPID_SIZE) && IO_Serial_Read (200, 1, &(io->PnP_id[i])))
    1036995      i++;
    1037996
Note: See TracChangeset for help on using the changeset viewer.