emuio.c
上传用户:caisangzi8
上传日期:2013-10-25
资源大小:15756k
文件大小:4k
源码类别:

DVD

开发平台:

C/C++

  1. /*
  2. ** FILE
  3. ** emuio.c
  4. ** DESCRIPTION
  5. */
  6. #include "config.h"
  7. #include "regmap.h"
  8. #include "global.h"
  9. #include "emuiodrv.h"
  10. #include "emuio.h"
  11. #ifdef DVDRELEASE
  12. //#define IOWRITE_NOWAIT
  13. #endif
  14. #ifndef DVDRELEASE
  15. #define EMUIO_DBG     1
  16. #endif
  17. #define IOWRITE_WAIT_SLOW 20000
  18. #define IOWRITE_WAIT_MAX (0x4000000)
  19. #ifdef IOWRITE_NOWAIT
  20. #undef IOWRITE_WAIT_MAX
  21. #define IOWRITE_WAIT_MAX 10000
  22. #endif
  23. //
  24. // FUNCTION
  25. // io_getc(c)
  26. //
  27. int
  28. io_getc(void)
  29. {
  30.    int c;
  31.    if (!IsEPPRxEmpty())
  32.       c = EPP_GETC();
  33.    else
  34.       c = 0;
  35.    return c;
  36. }
  37. //
  38. // FUNCTION
  39. // polling_io()
  40. //
  41. // DESCRIPTION
  42. // check IO interface for incoming command
  43. //
  44. #ifdef SUPPORT_EPP
  45. #if EMUIO_DBG
  46. BYTE key_trick=0;
  47. #endif
  48. int polling_io(void)
  49. {
  50. #ifndef SUPPORT_UART_UPGRADE
  51.     while (!IsEPPRxEmpty())
  52.     {
  53.         int c = EPP_GETC();
  54. #if EMUIO_DBG
  55.         if (c == 'm')
  56.             key_trick = 1;
  57.         else if (c == 'o')
  58.             key_trick = (key_trick == 1) ? 2 : 0;
  59.         else if (c == 'n' && key_trick == 2)
  60.         {
  61.             key_trick = 0;
  62.             return 1;
  63.         }
  64.         else key_trick = 0;
  65. #endif
  66.     }
  67. #endif
  68.     return 0;
  69. }
  70. //
  71. // FUNCTION
  72. // reset_io
  73. //
  74. void reset_io(void)
  75. {
  76.     RESET_EPP();
  77. #ifdef EMUIO_DBG
  78.     io_write("EMUIOn");
  79. #endif
  80. }
  81. #define IO_WAIT()
  82. do {
  83.   int timeout = IOWRITE_WAIT_MAX;
  84.        do {
  85.     if (!IsEPPTxFull()) break;
  86.   } while (--timeout>0);
  87. } while (0)
  88. #define IO_WAIT_EMPTY()
  89. do {
  90.   int timeout = IOWRITE_WAIT_MAX;
  91.        do {
  92.     if (IsEPPTxEmpty()) break;
  93.   } while (--timeout>0);
  94. } while (0)
  95. #define IO_PUTC(c)
  96.    do {
  97.   EPP_PUTC(c);
  98.   if ((c)==0x0a) EPP_PUTC(0x0d);
  99. } while (0)
  100. #define IO_PUTC_WAIT(c)
  101. do {
  102.   IO_WAIT();
  103.   EPP_PUTC(c);
  104.   if ((c)==0x0a) {
  105.     IO_WAIT();
  106.     EPP_PUTC(0x0d);
  107.   }
  108. } while (0)
  109. #define IO_PUTC_EXACT(c) 
  110. do {
  111.   EPP_PUTC_EXACT(c);
  112.   if ((c)==0x0a) {
  113.     IO_WAIT();
  114.     EPP_PUTC_EXACT(0x0d);
  115.   }
  116. } while (0)
  117. //
  118. // FUNCTION
  119. // io_write_flush
  120. //
  121. // DESCRIPTION
  122. // Wait until output fifo empty
  123. //
  124. // *NOTE*
  125. // this might hang the system if IO system failed.
  126. //
  127. void
  128. io_write_flush(void)
  129. {
  130.   IO_WAIT_EMPTY();
  131. }
  132. //
  133. // FUNCTION
  134. // io_putc(c)
  135. //
  136. void
  137. io_putc(int c)
  138. {
  139.     IO_PUTC(c);
  140. }
  141. void
  142. io_putc_wait(int c)
  143. {
  144.     IO_PUTC_WAIT(c);
  145. }
  146. void
  147. io_puthex4(unsigned x)
  148. {
  149.     IO_PUTC(radix_table[(x>>12)&0x0f]);
  150.     IO_PUTC(radix_table[(x>>8)&0x0f]);
  151.     IO_PUTC(radix_table[(x>>4)&0x0f]);
  152.     IO_PUTC(radix_table[(x>>0)&0x0f]);
  153. }
  154. void
  155. io_puthex(unsigned x)
  156. {
  157.     IO_PUTC(radix_table[(x>>28)&0x0f]);
  158.     IO_PUTC(radix_table[(x>>24)&0x0f]);
  159.     IO_PUTC(radix_table[(x>>20)&0x0f]);
  160.     IO_PUTC(radix_table[(x>>16)&0x0f]);
  161.     IO_PUTC(radix_table[(x>>12)&0x0f]);
  162.     IO_PUTC(radix_table[(x>>8)&0x0f]);
  163.     IO_PUTC(radix_table[(x>>4)&0x0f]);
  164.     IO_PUTC(radix_table[(x>>0)&0x0f]);
  165. }
  166. //
  167. // FUNCTION
  168. // io_write(s)
  169. //
  170. // DESCRIPTION
  171. // write to EPP port without waiting for FIFO.
  172. // will reset EPP port when FIFO fulled.
  173. //
  174. void
  175. io_write(const char *s)
  176. {
  177.   int c;
  178.   while ((c=*s++))
  179.   {
  180.     IO_PUTC(c);
  181.   }
  182. }
  183. //
  184. // FUNCTION
  185. // io_write_slow
  186. //
  187. // DESCRIPTION
  188. // wait a specific time (or until FIFO not full) before write.
  189. //
  190. void
  191. io_write_slow(const char *s)
  192. {
  193.   int  c;
  194.   while ((c=*s++)!=0)
  195.   {
  196.     int  timeout = IOWRITE_WAIT_SLOW;
  197.     do {
  198.       if (!IsEPPTxFull()) break;
  199.     } while (--timeout);
  200.     IO_PUTC(c);
  201.   } while (1);  
  202. }
  203. //
  204. // FUNCTION
  205. // io_write_wait
  206. //
  207. // DESCRIPTION
  208. // write and wait
  209. //
  210. // *NOTE*
  211. // we might have a timeout on this, like for a second..
  212. //
  213. void
  214. io_write_wait(const char *s)
  215. {
  216.   int  c;
  217.   while ((c=*s++)!=0)
  218.   {
  219.     IO_PUTC_WAIT(c);
  220.   }
  221. }
  222. //
  223. // FUNCTION
  224. // io_write_exact(s)
  225. //
  226. void
  227. io_write_exact(const char *s)
  228. {
  229.   int c;
  230.   while ((c=*s++)!=0)
  231.   {
  232.     EPP_PUTC_EXACT(c);
  233.     if (c==0x0a)
  234.     {
  235.       EPP_PUTC_EXACT(0x0d);
  236.     }
  237.   } 
  238. }
  239. void
  240. mon_polling_break(UINT8 flg)
  241. {
  242.     if (monflg == flg)
  243.     {
  244.         monflg = 1;
  245.         while (monflg == 1)
  246.             polling();
  247.     }
  248. }
  249. void
  250. mon_break(UINT8 flg)
  251. {
  252.     if (monflg == flg)
  253.     {
  254.         monflg = 1;
  255.         while (monflg == 1)
  256.             ;
  257.     }
  258. }
  259. #endif