开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
m6845Vga.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：45k
源码类别：

VxWorks

开发平台：

C/C++

m6845Vga.c：源码内容
  1. /* m6845Vga.c - motorola 6845 vga console driver routines */
  3. /* Copyright 1993-1993 Wind River System, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01e,12feb97,hdn  fixed the bug causes workQ panic. (SPR#7923)
  10. 01d,03aug95,myz  fixed the warning message
  11. 01c,14jun95,hdn  removed function declarations defined in sysLib.h.
  12. 01b,30mar94,hdn  changed CONSOLE_TTY to PC_CONSOLE.
  13. 01a,20oct93,vin  created
  14. */
  16. /*
  17. DESCRIPTION
  18. This is the driver fo Video Contoroller Chip (6845) normally  used in the
  19. 386/486 personal computers.
  21. USER CALLABLE ROUTINES
  22. The routines in this driver are accessed from a generic console
  23. driver through the hook routine, the pointer to which is initialized
  24. in the VGA_CON_DEV structure at the time of initialization.
  25. This makes the access to these routines more generic without declaring
  26. these functions as external. 
  28. The routines in this driver which are accessed from an external module
  29. are vgaWriteString() and vgaHrdInit(). vgaWriteString() is installed
  30. as a device transmit start-up routine in tyDevInit(). vgaHrdInit() is
  31. called to initialize the device descriptors and the vga console.
  33. All virtual consoles are mapped to the same screen buffer. This is a 
  34. very basic implementation of virtual consoles. Multiple screen
  35. buffers are not used to switch between consoles. This implementation
  36. is left for the future. Mutual exclusion for the screen buffer is 
  37. guaranteed within the same console but it is not implemented across multiple
  38. virtual consoles because all virtual consoles use the same screen buffer. If
  39. multiple screen buffers are implemented then the mutual exclusion between
  40. virtual consoles can be implemented.
  42. Before using the driver, it must be initialized by calling vgaHrdInit(). 
  43. This routine should be called exactly once. Normally, it is called from 
  44. a generic driver for eg. from tyCoDrv() which is called before tyCoDevCreate.
  47. SEE ALSO
  48. tyLib
  50. NOTES
  51. The macro N_VIRTUAL_CONSOLES should be defined in config.h file.
  52. This refers to the number of virtual consoles which the user wishes to have.
  53. The user should define INCLUDE_ANSI_ESC_SEQUENCE in <target>.h file if
  54. the ansi escape sequences are required. Special processing in the vga
  55. driver is done if an escape sequence exists.
  56. */
  58. /* includes */
  60. #include "vxWorks.h"
  61. #include "iv.h"
  62. #include "ioLib.h"
  63. #include "iosLib.h"
  64. #include "memLib.h"
  65. #include "rngLib.h"
  66. #include "tyLib.h"
  67. #include "private/funcBindP.h"
  68. #include "intLib.h"
  69. #include "taskLib.h"
  70. #include "errnoLib.h"
  71. #include "stdio.h"
  72. #include "string.h"
  73. #include "config.h"
  74. #include "drv/serial/pcConsole.h"
  77. /* externals */
  79. IMPORT PC_CON_DEV pcConDv [N_VIRTUAL_CONSOLES] ;
  82. /* locals */
  84. LOCAL VGA_CON_DEV vgaConDv [N_VIRTUAL_CONSOLES];
  85. LOCAL UCHAR curSt,curEd; /* current cursor mode */
  86. LOCAL int  tyWrtThreshold  = 20; /* min bytes free in output 
  87.  * buffer before the next 
  88.  * writer will be enabled */
  89. LOCAL int  jobaddThreshold = 20; /* bytes processed in int lvl */
  90. LOCAL UCHAR * vgaCharTable [] = 
  91.     {
  92.     /* 8-bit Latin-1 mapped to the PC charater set: '' means non-printable */
  93.     (unsigned char *)
  94.     ""
  95.     ""
  96.     " !"#$%&'()*+,-./0123456789:;<=>?"
  97.     "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_"
  98.     "`abcdefghijklmnopqrstuvwxyz{|}~"
  99.     ""
  100.     ""
  101.     "402552332343762351742537637624625625255376376"
  102.     "37036137537637634624371376376247257254253376250"
  103.     "376376376376216217222200376220376376376376376376"
  104.     "376245376376376376231376235376376376232376376341"
  105.     "205240203376204206221207212202210211215241214213"
  106.     "376244225242223376224366233227243226201376376230",
  107.     /* vt100 graphics */
  108.     (unsigned char *)
  109.     ""
  110.     ""
  111.     " !"#$%&'()*+,-./0123456789:;<=>?"
  112.     "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ "
  113.     "0426107070707370361400733127733230030507"
  114.     "0730407073032643013022630707070707234"
  115.     ""
  116.     ""
  117.     "402552332343762351742537637624625625255376376"
  118.     "37036137537637634624371376376247257254253376250"
  119.     "376376376376216217222200376220376376376376376376"
  120.     "376245376376376376231376376376376376232376376341"
  121.     "205240203376204206221207212202210211215241214213"
  122.     "376244225242223376224366376227243226201376376230",
  123.     /* IBM graphics: minimal translations (CR, LF, LL, SO, SI and ESC) */
  124.     (unsigned char *)
  125.     "00010203040506071011001300000000"
  126.     "20212223242526273031320034353637"
  127.     "40414243444546475051525354555657"
  128.     "60616263646566677071727374757677"
  129.     "100101102103104105106107110111112113114115116117"
  130.     "120121122123124125126127130131132133134135136137"
  131.     "140141142143144145146147150151152153154155156157"
  132.     "160161162163164165166167170171172173174175176177"
  133.     "200201202203204205206207210211212213214215216217"
  134.     "220221222223224225226227230231232233234235236237"
  135.     "240241242243244245246247250251252253254255256257"
  136.     "260261262263264265266267270271272273274275276277"
  137.     "300301302303304305306307310311312313314315316317"
  138.     "320321322323324325326327330331332333334335336337"
  139.     "340341342343344345346347350351352353354355356357"
  140.     "360361362363364365366367370371372373374375376377"
  141.     };
  144. /* forward declarations */
  146. LOCAL void vgaStatInit (void);
  147. LOCAL void vgaHook (FAST VGA_CON_DEV *  pVgaConDv, int arg, int opCode);
  148. LOCAL void vgaClear (FAST VGA_CON_DEV *  pVgaConDv, int position, 
  149.   UCHAR eraseChar);
  150. LOCAL void vgaScroll (FAST VGA_CON_DEV *  pVgaConDv, int pos, int line, 
  151.    BOOL upDn, FAST UCHAR atr);
  152. LOCAL void vgaInsertChar (FAST VGA_CON_DEV *  pVgaConDv, 
  153.        FAST int nInsChar);
  154. LOCAL void  vgaCursorOn (void);
  155. LOCAL void vgaCursorOff (void);
  156. LOCAL void vgaCursorPos (FAST UINT16 pos);
  157. LOCAL void vgaScreenRev (FAST VGA_CON_DEV * pVgaConDv);
  158. LOCAL void vgaDelLeftChar (FAST VGA_CON_DEV *  pVgaConDv);
  159. LOCAL void vgaCarriageReturn (FAST VGA_CON_DEV *  pVgaConDv);
  160. LOCAL void vgaBackSpace (FAST VGA_CON_DEV *  pVgaConDv);
  161. LOCAL void vgaLineFeed (FAST VGA_CON_DEV *  pVgaConDv);
  162. LOCAL void vgaTab (FAST VGA_CON_DEV *  pVgaConDv);
  163. LOCAL void vgaConBeep (BOOL mode);
  165. #ifdef INCLUDE_ANSI_ESC_SEQUENCE
  167. LOCAL UCHAR vgaColorTable [] = 
  168.     {
  169.     /* black, red, green, brown, blue, magenta, cyan, light grey */
  170.            0,   4,     2,     6,    1,       5,    3,          7
  171.     };
  172. LOCAL void vgaEscResponse (FAST PC_CON_DEV * pPcCoDv, int  responseId );
  173. LOCAL void vgaPutCursor (FAST VGA_CON_DEV *  pVgaConDv);
  174. LOCAL void vgaSaveCurAttrib (FAST VGA_CON_DEV *  pVgaConDv);
  175. LOCAL void vgaRestAttrib (FAST VGA_CON_DEV *  pVgaConDv);
  176. LOCAL void vgaSetMode (FAST  PC_CON_DEV *  pPcCoDv, BOOL onOff);
  177. LOCAL void vgaClearLine (FAST VGA_CON_DEV *  pVgaConDv);
  178. LOCAL void vgaInsertLine (FAST VGA_CON_DEV *  pVgaConDv);
  179. LOCAL void vgaSetAttrib (FAST VGA_CON_DEV *  pVgaConDv);
  180. LOCAL void vgaDelLines (FAST VGA_CON_DEV *  pVgaConDv);
  181. LOCAL void vgaDelRightChars (FAST VGA_CON_DEV *  pVgaConDv, int nDelChar);
  183. #endif /* INCLUDE_ANSI_ESC_SEQUENCE */
  185. /*******************************************************************************
  186. *
  187. * vgaConBeep - sound beep function (using timer 2 for tone)
  188. * 
  189. * This function is responsible for producing the beep 
  190. *
  191. * RETURNS: N/A
  192. *
  193. * NOMANUAL
  194. */
  196. LOCAL void vgaConBeep 
  197.     (
  198.     BOOL mode /* TRUE:long beep  FALSE:short beep */
  199.     )
  200.     {
  201.     int beepTime;
  202.     int beepPitch;
  203.     FAST int  oldlevel;
  205.     if (mode)
  206.         { 
  207.         beepPitch = BEEP_PITCH_L;
  208.         beepTime  = BEEP_TIME_L; /* long beep */
  209.         }
  210.     else
  211.         { 
  212.         beepPitch = BEEP_PITCH_S;
  213.         beepTime  = BEEP_TIME_S; /* short beep */
  214.         }
  216.     oldlevel = intLock ();
  218.     /* set command for counter 2, 2 byte write */
  220.     sysOutByte (PIT_BASE_ADR + 3, 0xb6);
  221.     sysOutByte (PIT_BASE_ADR + 2, (beepPitch & 0xff));
  222.     sysOutByte (PIT_BASE_ADR + 2, (beepPitch >> 8));
  224.     /* enable counter 2 */
  225.     sysOutByte (DIAG_CTRL, sysInByte (DIAG_CTRL) | 0x03);
  227.     taskDelay (beepTime);
  229.     /* desable counter 2 */
  230.     sysOutByte (DIAG_CTRL, sysInByte (DIAG_CTRL) & ~0x03);
  232.     intUnlock (oldlevel);
  233.     return;
  234.     }
  236. /******************************************************************************
  237. *
  238. * vgaHrdInit - initialize the VGA Display
  239. *
  240. * This function is called externally to initialize the vga display
  241. *
  242. * RETURNS: N/A
  243. *
  244. * NOMANUAL
  245. */
  247. void vgaHrdInit (void)
  248.     {
  250.     /* get cursor shape and mode */
  252.     sysOutByte ((int) CTRL_SEL_REG, 0x0a);
  253.     curSt = sysInByte ((int) CTRL_VAL_REG);
  254.     sysOutByte ((int) CTRL_SEL_REG, 0x0b);
  255.     curEd = sysInByte ((int) CTRL_VAL_REG);
  257.     vgaStatInit ();
  259.     /* clear screen and position cursor at 0,0 */
  261.     vgaClear (pcConDv [PC_CONSOLE].vs, 2,' ');
  262.     vgaCursorOn ();
  263.     return;
  264.     } 
  266. /*******************************************************************************
  267. *
  268. * vgaStatInit - initialize the VGA Display state
  269. *
  270. * RETURNS: N/A
  271. */
  273. LOCAL void vgaStatInit (void)
  274.     {
  275.     int ix; /* to hold the index */
  276.     FAST VGA_CON_DEV * pVgaConDv; /* pointer to hold vga descriptor */
  278.     for (ix = 0; ix < N_VIRTUAL_CONSOLES; ix++)
  279. {
  280. pcConDv [ix].vs = pVgaConDv = &vgaConDv [ix];
  282. /* (VGA) Display status initialization */
  283. pVgaConDv->memBase  = CTRL_MEM_BASE;
  284. pVgaConDv->colorMode     = COLOR_MODE;      /* color mode */   
  285. pVgaConDv->sv_col        = pVgaConDv->col   = 0;
  286. pVgaConDv->sv_row        = pVgaConDv->row   = 0;
  287. pVgaConDv->sv_curAttrib  = pVgaConDv->curAttrib = DEFAULT_ATR;
  288. pVgaConDv->defAttrib     = DEFAULT_ATR;
  289. pVgaConDv->curChrPos     = pVgaConDv->memBase;  /* current  position */
  290. pVgaConDv->sv_rev        = pVgaConDv->rev   = FALSE;
  291. pVgaConDv->ncol          = 80;                /* Number of columns */
  292. pVgaConDv->nrow          = 25;                /* Number of text rows */
  293. pVgaConDv->scst          = 0;                 /* scroll start */
  294. pVgaConDv->sced          = 24;                /* scroll end */
  295. pVgaConDv->autoWrap      = TRUE;              /* auto Wrap mode */
  296. pVgaConDv->scrollCheck   = FALSE;             /* scroll  flag off */
  297. pVgaConDv->charSet       = vgaCharTable [TEXT_SET]; /* character set */
  298. pVgaConDv->vgaMode       = TEXT_MODE;         /* video mode  */
  299. pVgaConDv->insMode       = INSERT_MODE_OFF;   /* insert mode */
  300. pVgaConDv->escFlags      = ESC_NORMAL;        /* normal character */
  301. pVgaConDv->escParaCount  = 0;                 /* zero parameters */
  302. pVgaConDv->escQuestion   = FALSE;             /* ? flag set to false */
  303. bzero ((char *)pVgaConDv->escPara, sizeof(pVgaConDv->escPara));
  304. bzero (pVgaConDv->tab_stop, sizeof(pVgaConDv->tab_stop));
  305. pVgaConDv->tab_stop [ 0] = 1;
  306. pVgaConDv->tab_stop [ 8] = 1;
  307. pVgaConDv->tab_stop [16] = 1;
  308. pVgaConDv->tab_stop [24] = 1;
  309. pVgaConDv->tab_stop [32] = 1;
  310. pVgaConDv->tab_stop [40] = 1;
  311. pVgaConDv->tab_stop [48] = 1;
  312. pVgaConDv->tab_stop [56] = 1;
  313. pVgaConDv->tab_stop [64] = 1;
  314. pVgaConDv->tab_stop [72] = 1;
  315. pVgaConDv->vgaHook  = (FUNCPTR) vgaHook; /* install the hook */
  316. }
  317.     return;
  318.     } 
  320. /******************************************************************************
  321. *
  322. * vgaHook - hook called from an external module
  323. * 
  324. * This function performs various functions depending on the opCode.
  325. * Typically this hook is to facilitate the user to add any additional
  326. * routines which can be accessed externally through the vga console
  327. * descriptor.
  328. *
  329. * RETURNS: N/A
  330. */
  332. LOCAL void vgaHook 
  333.     (
  334.     FAST VGA_CON_DEV *  pVgaConDv,      /* pointer to the vga descriptor */
  335.     int arg, /* argument */
  336.     int opCode /* operation to perform */
  337.     )
  338.     {
  339.     switch (opCode)
  340. {
  341. case 0:
  342.       vgaScreenRev (pVgaConDv); /* reverse screen */
  343.       break;
  344. case 1:
  345.       vgaConBeep (arg); /* produce beep */
  346.       break;
  347. case 2:
  348.       vgaCursorOn (); /* turn the cursor on */
  349.       break;
  350. case 3:
  351.       vgaCursorOff (); /* turn the cursor Off */
  352.       break;
  353. case 4: /* position the cursor */
  354.       pVgaConDv->row = (arg >> 8) & 0xff;
  355.       pVgaConDv->col = arg & 0xff;
  356.       if (pVgaConDv->row >= pVgaConDv->nrow)
  357.       pVgaConDv->row = pVgaConDv->nrow - 1;
  358.       if (pVgaConDv->col >= pVgaConDv->ncol)
  359.       pVgaConDv->col = pVgaConDv->ncol - 1;
  360.       vgaCursorPos ((UINT16) (pVgaConDv->row * pVgaConDv->ncol 
  361.       + pVgaConDv->col));
  362.       break;
  363. default:
  364.       break;
  365. }
  366.     }
  368. /******************************************************************************
  369. *
  370. * vgaClear - Clear Screen
  371. *
  372. * This routine clears the screen depending on the value of position.
  373. * If position is 2 then it clears the whole screen and moves the cursor to 
  374. * location 0,0. If position is 1 then the screen is erased from the cursor to
  375. * until the end of display. If position is equal to any other value then 
  376. * the screen is erased until the cursor.
  377. *
  378. * RETURNS: N/A
  379. */
  381. LOCAL void vgaClear 
  382.     (
  383.     FAST VGA_CON_DEV * pVgaConDv, /* pointer to the vga descriptor */
  384.     int position, /* cursor position  0 or 1 or 2 */
  385.     UCHAR eraseChar /* erase character eg space is  0x20 */
  386.     )
  387.     {
  388.     FAST UINT16 * cp; /* hold the beginning position */
  389.     FAST UINT16 * end; /* hold the end position */
  390.     FAST UINT16  erase; /* erase character with attribute */
  392.     erase = (pVgaConDv->defAttrib << 8) + eraseChar;
  393.     if ( position == 2 )
  394. { 
  395. cp  = (UINT16 *) pVgaConDv->memBase;
  396. end = (UINT16 *) (pVgaConDv->memBase + 2048 * CHR);
  397. pVgaConDv->col = pVgaConDv->row = 0;
  398. pVgaConDv->curChrPos = (UCHAR *) pVgaConDv->memBase;
  399. }
  400.     else if ( position == 0 )
  401. { 
  402. cp  = (UINT16 *)pVgaConDv->curChrPos;
  403. end = (UINT16 *)(pVgaConDv->memBase + 2048 * CHR);
  404. }
  405.     else  
  406. {
  407. cp  = (UINT16 *) pVgaConDv->memBase;
  408. end = (UINT16 *) (pVgaConDv->curChrPos + CHR);
  409. }
  410.     for (; cp < end; cp++ )
  411.         {
  412.         *cp     = erase;  
  413.         }
  414.     }
  416. /******************************************************************************
  417. *
  418. * vgaScreenRev - Reverse Screen
  419. *
  420. * RETURNS: N/A
  421. */
  423. LOCAL void vgaScreenRev 
  424.     (
  425.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  426.     )
  427.     {
  428.     UCHAR * cp; /* to hold the current pointer */
  429.     UCHAR atr; /* to hold the attribute character */
  431.     for (cp = pVgaConDv->memBase; cp < pVgaConDv->memBase + 2000 * CHR; 
  432.  cp += CHR)
  433.         {
  434.         atr = *(cp+1);
  435.         *(cp+1)  = atr & INT_BLINK_MASK;
  436.         *(cp+1) |= (atr << 4) & BG_ATTR_MASK;
  437.         *(cp+1) |= (atr >> 4) & FG_ATTR_MASK;
  438.         }
  439.     }
  441. /*******************************************************************************
  442. *
  443. * vgaScroll - Scroll Screen
  444. *
  445. * This function scrolls the screen according to the scroll direction.
  446. * scroll direction FORWARD or BACKWARD 
  447. *
  448. * RETURNS: N/A
  449. */
  451. LOCAL void vgaScroll 
  452.     (
  453.     FAST VGA_CON_DEV * pVgaConDv, /* pointer to the vga descriptor */
  454.     int pos, /* scroll start line position */
  455.     int lines, /* scroll line count */
  456.     BOOL upDn, /* scroll direction  */
  457.     FAST UCHAR atr /* atrribute for char */
  458.     )
  459.     {
  460.     FAST UCHAR * dest; /* to hold the destination pointer */
  461.     FAST UCHAR * src; /* to hold the source pointer */
  463.     if (pos < pVgaConDv->scst || pos > pVgaConDv->sced)
  464.         return;
  466.     if (upDn)
  467.         {
  468. /* scroll direction is forward */
  470.         if (pVgaConDv->scst + lines > pVgaConDv->sced + 1)
  471.             lines = pVgaConDv->sced - pVgaConDv->scst + 1;
  473.         for (dest = pVgaConDv->memBase + pVgaConDv->ncol * CHR * 
  474.      pVgaConDv->scst, src = pVgaConDv->memBase + pVgaConDv->ncol * 
  475.      CHR * (pVgaConDv->scst + lines); src < pVgaConDv->memBase + 
  476.      pVgaConDv->ncol * CHR * (pos + 1); *dest++ = *src++ );
  478.         for (dest = pVgaConDv->memBase + pVgaConDv->ncol * CHR * 
  479.      (pos - (lines - 1)); dest < pVgaConDv->memBase + pVgaConDv->ncol *
  480.      CHR * (pos + 1); dest += CHR )
  481.             {
  482.             *dest     = ' ';
  483.             *(dest+1) = atr;
  484.             }
  485.         }
  486.     else
  487.         {
  488. /* scroll direction is backward */
  490.         if (pVgaConDv->scst + lines > pVgaConDv->sced + 1)
  491.             lines = pVgaConDv->sced - pVgaConDv->scst + 1;
  493.         for (dest = pVgaConDv->memBase + pVgaConDv->ncol * CHR * 
  494.      (pVgaConDv->sced + 1) - 1, src = pVgaConDv->memBase + 
  495.      pVgaConDv->ncol * CHR * (pVgaConDv->sced - (lines - 1)) - 1;
  496.              src > pVgaConDv->memBase + pVgaConDv->ncol * CHR * pos - 1;
  497.              *dest-- = *src-- );
  499.         for (dest = pVgaConDv->memBase + pVgaConDv->ncol * CHR * 
  500.      (pos + lines) - 1; dest > pVgaConDv->memBase + pVgaConDv->ncol * 
  501.      CHR * pos - 1;
  502.              dest -= CHR )
  503.             {
  504.             *dest     = atr;
  505.             *(dest-1) = ' ';
  506.             }
  507.         }
  508.     return;
  509.     }
  511. /*****************************************************************************
  512. *
  513. * vgaInsertChar - insert the character at the current cursor location
  514. *
  515. * RETURNS: N/A
  516. */
  518. LOCAL void vgaInsertChar
  519.     (
  520.     FAST VGA_CON_DEV * pVgaConDv, /* pointer to the vga descriptor */
  521.     FAST int nInsChar /* number of insert Characters */
  522.     )
  523.     {
  524.     FAST int xPos ;  /* to hold the horizontal position  */
  525.     FAST UINT16    erase; /* to hold erase character with attribute */
  526.     FAST UINT16    swap; /* to hold old x position */
  527.     FAST UINT16 * chrPos; /* to hold actual address of character */
  529.     if (nInsChar > pVgaConDv->ncol)
  530. nInsChar = pVgaConDv->ncol;
  532.     else if (nInsChar == 0) 
  533. nInsChar = 1;
  534.     
  535.     while (nInsChar-- != 0)
  536. {
  537. xPos   = pVgaConDv->col;
  538. chrPos = (UINT16 *) pVgaConDv->curChrPos;
  539. erase  = (pVgaConDv->defAttrib << 8) + ' ' ; 
  541. while (xPos++ < pVgaConDv->ncol)
  542.     {
  543.     /* make the current character as next erase */
  545.     swap    = *chrPos;
  546.     *chrPos = erase ; 
  547.     erase   = swap;   
  548.     chrPos++;
  549.     }
  550. }
  551.     }
  553. /*****************************************************************************
  554. *
  555. * vgaDelLeftChar - delete the character to the left side of the cursor
  556. *
  557. * RETURNS: N/A
  558. */
  560. LOCAL void vgaDelLeftChar 
  561.     (
  562.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  563.     )
  564.     {
  565.     FAST UINT16 erase; /* erase character with attributes */
  567.     erase = (pVgaConDv->defAttrib << 8) + ' ' ;
  568.     if (pVgaConDv->autoWrap || pVgaConDv->ncol > 0)
  569. {
  570. pVgaConDv->col--;
  571. pVgaConDv->curChrPos -= CHR;
  572. }
  573.     *(UINT16 *)pVgaConDv->curChrPos = erase;
  575.     }
  577. /*****************************************************************************
  578. *
  579. * vgaCarriageReturn - do a carriage return on the monitor
  580. *
  581. * RETURNS: N/A
  582. */
  584. LOCAL void vgaCarriageReturn 
  585.     (
  586.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  587.     )
  588.     {
  590.     pVgaConDv->curChrPos -= pVgaConDv->col * CHR;
  591.     pVgaConDv->col = 0;
  593.     }
  595. /*****************************************************************************
  596. *
  597. * vgaBackSpace - do a back space on the monitor
  598. *
  599. * RETURNS: N/A
  600. */
  602. LOCAL void vgaBackSpace 
  603.     (
  604.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  605.     )
  606.     {
  608.     if (pVgaConDv->autoWrap || pVgaConDv->ncol > 0)
  609. {
  610. pVgaConDv->col--;
  611. pVgaConDv->curChrPos -= CHR;
  612. }
  613.     if (pVgaConDv->col < 0)
  614. {
  615. pVgaConDv->col = pVgaConDv->ncol - 1;
  616. pVgaConDv->row--;
  617. pVgaConDv->scrollCheck = TRUE;
  618. }
  619.     }
  621. /*****************************************************************************
  622. *
  623. * vgaTab - do a tab on the monitor
  624. *
  625. * RETURNS: N/A
  626. */
  628. LOCAL void vgaTab 
  629.     (
  630.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  631.     )
  632.     {
  633.     int ix;
  635.     for (ix = pVgaConDv->col + 1; ix < 80; ix++)
  636. {
  637. if (pVgaConDv->tab_stop [ix])
  638.     {
  639.     pVgaConDv->col = ix;
  640.     break;
  641.     }
  642. }
  643.     if (pVgaConDv->autoWrap && ix >= 80)
  644. {
  645. pVgaConDv->col = 0;
  646. pVgaConDv->row++;
  647. pVgaConDv->scrollCheck = TRUE;
  648. }
  649.     pVgaConDv->curChrPos = ( pVgaConDv->memBase + 
  650.     pVgaConDv->row * pVgaConDv->ncol * CHR + 
  651.     pVgaConDv->col * CHR) ;
  652.     }
  654. /******************************************************************************
  655. *
  656. * vgaLineFeed - do a line feed on the monitor
  657. *
  658. * RETURNS: N/A
  659. */
  661. LOCAL void vgaLineFeed 
  662.     (
  663.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  664.     )
  665.     {
  666.     pVgaConDv->curChrPos += pVgaConDv->ncol * CHR;
  667.     pVgaConDv->row++;
  668.     pVgaConDv->scrollCheck = TRUE;
  670.     }
  672. /******************************************************************************
  673. *
  674. * vgaCursorPos - Put the cursor at a specified location
  675. *
  676. * RETURNS: N/A
  677. */
  679. LOCAL void vgaCursorPos 
  680.     (
  681.     FAST UINT16 pos /* position of the cursor */
  682.     )
  683.     {
  685.     sysOutByte ((int) CTRL_SEL_REG, 0x0e);
  686.     sysOutByte ((int) CTRL_VAL_REG, (pos >> 8) & 0xff);
  687.     sysOutByte ((int) CTRL_SEL_REG, 0x0f);
  688.     sysOutByte ((int) CTRL_VAL_REG, pos & 0xff);
  689.     return;
  690.     }
  692. /******************************************************************************
  693. *
  694. * vgaCursorOn - switch the cursor on
  695. *
  696. * RETURNS: N/A
  697. */
  699. LOCAL void vgaCursorOn (void)
  700.     {
  701.     sysOutByte ((int) CTRL_SEL_REG, 0x0a);
  702.     sysOutByte ((int) CTRL_VAL_REG, curSt & ~0x20);
  703.     sysOutByte ((int) CTRL_SEL_REG, 0x0b);
  704.     sysOutByte ((int) CTRL_VAL_REG, curEd);
  705.     return;
  706.     }
  708. /******************************************************************************
  709. *
  710. * vgacursoroff - swith the cursor off
  711. *
  712. * RETURNS: N/A
  713. */
  715. LOCAL void vgaCursorOff (void)
  716.     {
  717.     sysOutByte ((int) CTRL_SEL_REG, 0x0a);
  718.     sysOutByte ((int) CTRL_VAL_REG, 0x20);
  719.     sysOutByte ((int) CTRL_SEL_REG, 0x0b);
  720.     sysOutByte ((int) CTRL_VAL_REG, 0x00);
  721.     return;
  722.     }
  724. /*******************************************************************************
  725. *
  726. * vgaWriteString - Write Character string  to VGA Display
  727. * 
  728. * This function does the write to the vga routine. This routine is provided as
  729. * transmitter startup routine when tyDevInit is called.
  730. *
  731. * RETURNS: number of bytes written to the screen
  732. *
  733. * NOMANUAL
  734. */
  736. int vgaWriteString
  737.     (
  738.     FAST PC_CON_DEV * pPcCoDv /* pointer to the console descriptor */
  739.     )
  740.     {
  741.     int dummy;
  742.     UCHAR ch;
  743.     FAST int nBytes;
  744.     FAST UCHAR atr;
  745.     FAST RING_ID        ringId = pPcCoDv->tyDev.wrtBuf;
  746.     FAST VGA_CON_DEV * pVgaConDv = pPcCoDv->vs;
  747.     
  748.     pPcCoDv->tyDev.wrtState.busy = TRUE;
  749.     atr = pVgaConDv->curAttrib;
  750.     nBytes = 0;
  751.     
  752.     /* check if we need to output XON/XOFF for the read side */
  754.     if (pPcCoDv->tyDev.wrtState.xoff || pPcCoDv->tyDev.wrtState.flushingWrtBuf)
  755. {
  756.      pPcCoDv->tyDev.wrtState.busy = FALSE;
  757. return nBytes;
  758. }
  760.     while (RNG_ELEM_GET (ringId,&ch,dummy) != 0)
  761.         {
  762. nBytes++; /* increment the number of bytes */
  764. /* If character is normal and printable */
  766. if ( (pVgaConDv->escFlags == ESC_NORMAL) && (pVgaConDv->charSet [ch]
  767.      != 0))
  768.     {
  769.     *(UINT16 *)pVgaConDv->curChrPos = (atr << 8) + 
  770.                                   pVgaConDv->charSet [ch];
  771.     if (pVgaConDv->col == pVgaConDv->ncol - 1)
  772. { 
  773. if (pVgaConDv->autoWrap)
  774.     { 
  775.     vgaCarriageReturn (pVgaConDv); /* time to wrap */
  776.     vgaLineFeed (pVgaConDv);
  777.     goto VGA_CHECK; /* go do the wrap check */
  778.     }
  779. }
  780.     else
  781. {
  782. pVgaConDv->col++;
  783. pVgaConDv->curChrPos += CHR;
  784. continue;
  785. }
  786.     }
  788. switch (ch)
  789.     {
  790.     case 0x07: /* BEL */
  791.          vgaConBeep (FALSE);
  792.  continue;
  793.     
  794.     case 0x08: /* Back Space */
  795.  vgaBackSpace (pVgaConDv);
  796.  continue;
  798.             case 't': /* TAB code */
  799.  vgaTab (pVgaConDv);
  800.  continue;
  802.             case 'n': /* LF code */
  803.  if ((pPcCoDv->tyDev.options & OPT_CRMOD) == OPT_CRMOD)
  804.     vgaCarriageReturn (pVgaConDv);
  805.  vgaLineFeed (pVgaConDv);
  806.  goto VGA_CHECK;
  808.             case 0x0b: /* VT code */
  809.  vgaLineFeed (pVgaConDv);
  810.  goto VGA_CHECK;
  812.             case 0x0c: /* Clear Screen code */
  813.  vgaClear (pVgaConDv, 2, ' ');
  814.  continue;
  816.     case 0x0d: /* CR code */
  817.  vgaCarriageReturn (pVgaConDv);
  818.  continue;
  820. #ifdef INCLUDE_ANSI_ESC_SEQUENCE
  822.     case 0x1b: /* escape character */
  823.  pVgaConDv->escFlags = ESC_ESC;
  824.  continue; 
  826.             case 0x9b: /* escape brace */
  827.  pVgaConDv->escFlags = ESC_BRACE;
  828.  continue;
  829. #endif /* INCLUDE_ANSI_ESC_SEQUENCE */
  831.     case 0x0e: /* set the character set to VT100 graphics */
  832.  pVgaConDv->charSet = vgaCharTable [GRAPHICS_VT100_SET];
  833.  continue;
  835.             case 0x0f: /* set the character set to normal text set */
  836.  pVgaConDv->charSet = vgaCharTable [TEXT_SET];
  837.  continue;
  839.     case 0x7f: /* special character for del */
  840.  vgaDelLeftChar (pVgaConDv);
  841.  continue;
  842.   }
  844. #ifdef INCLUDE_ANSI_ESC_SEQUENCE
  845. switch (pVgaConDv->escFlags)
  846.     {
  847.     int  ix; /* to hold temp data */
  849.     case ESC_ESC:
  850.             pVgaConDv->escFlags = ESC_NORMAL;
  851.     switch (ch)
  852. {
  853. case '[': /* escape brace */
  854. pVgaConDv->escFlags = ESC_BRACE;
  855. continue;
  857. case 'E': /* cr lf */
  858. vgaCarriageReturn (pVgaConDv);
  859. vgaLineFeed (pVgaConDv);
  860. goto VGA_CHECK;
  862. case 'M': /* cursor up */
  863. pVgaConDv->row --;
  864. vgaPutCursor (pVgaConDv);
  865. continue;
  867. case 'D': /* generate a linefeed */
  868. vgaLineFeed (pVgaConDv);
  869. goto VGA_CHECK;
  871. case 'H': /* give tab */
  872. vgaTab (pVgaConDv);
  873. continue;
  875. case 'Z': /* get device attribute */
  876. vgaEscResponse (pPcCoDv,2);
  877. continue;
  879. case '7': /* save current attributes */
  880. vgaSaveCurAttrib (pVgaConDv);
  881. continue;
  883. case '8': /* restore current attributes */
  884. vgaRestAttrib (pVgaConDv);
  885. continue;
  887. case '(': /* set character set to text */
  888. pVgaConDv->escFlags = ESC_SET_TEXT;
  889. continue;
  891. case ')': /* set character set to grapics set */
  892. pVgaConDv->escFlags = ESC_SET_GPRAHICS;
  893. continue;
  895. case '#': /* goto ESC_HASH state */
  896. pVgaConDv->escFlags = ESC_HASH;
  897. continue;
  899. case 'c': /* reset display */
  900. pPcCoDv->ks->kbdHook (0);
  901. vgaStatInit ();
  902. vgaClear (pVgaConDv, 2, ' ');
  903. vgaCursorOn ();
  904. continue;
  906. case '>': /* set numeric mode */
  907. pPcCoDv->ks->kbdFlags |= NUM;
  908. pPcCoDv->ks->kbdHook (1);
  909. continue;
  911. case '=': /* set non numeric mode */
  912. pPcCoDv->ks->kbdFlags &= ~NUM;
  913. pPcCoDv->ks->kbdHook (1);
  914. continue;
  915.             }
  916.     continue;
  918.     case ESC_BRACE: /* Got ESC [ */
  919.             for (ix = 0; ix < NPARS; ix++)
  920.         pVgaConDv->escPara [ix] = 0;
  921.     pVgaConDv->escParaCount = 0;
  922.             pVgaConDv->escFlags = ESC_GET_PARAMS;
  923.     if ( ch == '[')
  924. {
  925. pVgaConDv->escFlags = ESC_FUNC_KEY;
  926. continue;
  927. }
  929.             /* if received ? in the escape sequence */
  931.     if ( (pVgaConDv->escQuestion = (ch == '?')) )
  932.        continue;
  934.     case ESC_GET_PARAMS: /* get parameters */
  935.     if ( (ch == ';') && (pVgaConDv->escParaCount < NPARS -1))
  936. {
  937. pVgaConDv->escParaCount++;
  938. continue;
  939. }
  940.     else if (ch >= '0' && ch <= '9')
  941. {
  942. pVgaConDv->escPara[pVgaConDv->escParaCount] *= 10;
  943. pVgaConDv->escPara[pVgaConDv->escParaCount] += ch -'0';
  944. continue;
  945. }
  946.     else
  947.         pVgaConDv->escFlags = ESC_GOT_PARAMS;
  949.     case ESC_GOT_PARAMS:
  950.     pVgaConDv->escFlags = ESC_NORMAL;
  951.     switch (ch)
  952. {
  953. case 'h': /* set vga modes  ESC [ n h */
  954.         vgaSetMode (pPcCoDv, TRUE);
  955. continue;
  957. case 'l': /* reset vga mode  ESC [ n l */
  958. vgaSetMode (pPcCoDv, FALSE);
  959. continue;
  961. case 'n':
  962. if (!pVgaConDv->escQuestion)
  963.     {
  964.     if (pVgaConDv->escPara [0] == 5)
  965. { /* status report */
  966. vgaEscResponse (pPcCoDv,1);
  967. }
  968.     else if ( pVgaConDv->escPara [0] == 6)
  969. { /* cursor position report */
  970. vgaEscResponse (pPcCoDv,0);
  971. }
  972.     continue;
  973.     }
  974. }
  975.     if (pVgaConDv->escQuestion) 
  976. {
  977. pVgaConDv->escQuestion = FALSE;
  978. continue;
  979. }
  980.     switch (ch)
  981. {
  982. case 'G': /* ESC [ n G :move cursor by columns */
  983.         if (pVgaConDv->escPara [0] > 0)
  984.     pVgaConDv->escPara [0]--;
  986. pVgaConDv->col = pVgaConDv->escPara [0];
  987. vgaPutCursor (pVgaConDv);
  988. continue;
  990. case 'A': /* ESC [ n A :cursor move up */
  991.         if (pVgaConDv->escPara [0] == 0)
  992.     pVgaConDv->escPara [0]++;
  994. pVgaConDv->row -= pVgaConDv->escPara [0];
  995. vgaPutCursor (pVgaConDv);
  996.                                 continue;
  998. case 'B': /* ESC [ n B :cursor move down */
  999.         if (pVgaConDv->escPara [0] == 0)
  1000.     pVgaConDv->escPara [0]++;
  1002. pVgaConDv->row += pVgaConDv->escPara [0];
  1003. vgaPutCursor (pVgaConDv);
  1004. continue;
  1006. case 'C': /* ESC [ n C :cursor move right */
  1007.         if (pVgaConDv->escPara [0] == 0)
  1008.     pVgaConDv->escPara [0]++;
  1010. pVgaConDv->col += pVgaConDv->escPara [0];
  1011. vgaPutCursor (pVgaConDv);
  1012. continue;
  1014. case 'D': /* ESC [ n D :cursor move left */
  1015.         if (pVgaConDv->escPara [0] == 0)
  1016.     pVgaConDv->escPara [0]++;
  1018. pVgaConDv->col -= pVgaConDv->escPara [0];
  1019. vgaPutCursor (pVgaConDv);
  1020. continue;
  1022. case 'E': /* ESC [ n E :cursor move by n rows */
  1023.         if (pVgaConDv->escPara [0] == 0)
  1024.     pVgaConDv->escPara [0]++;
  1026. pVgaConDv->row += pVgaConDv->escPara [0];
  1027. pVgaConDv->col = 0;
  1028. vgaPutCursor (pVgaConDv);
  1029. continue;
  1031. case 'F': /* ESC [ n F :move cursor laterally */
  1032.         if (pVgaConDv->escPara [0] == 0)
  1033.     pVgaConDv->escPara [0]++;
  1035. pVgaConDv->row -= pVgaConDv->escPara [0];
  1036. pVgaConDv->col = 0;
  1037. vgaPutCursor (pVgaConDv);
  1038. continue;
  1040. case 'd': /* ESC [ n d :move cursor vertically */
  1041.         if (pVgaConDv->escPara [0] > 0)
  1042.     pVgaConDv->escPara [0]--;
  1044. pVgaConDv->row = pVgaConDv->escPara [0];
  1045. vgaPutCursor (pVgaConDv);
  1046. continue;
  1048. case 'H': /* ESC [ n;n H :position the cursor */
  1049.                         case 'f': /* ESC [ n;n f :position the cursor */
  1050.         if (pVgaConDv->escPara [0] > 0)
  1051.     pVgaConDv->escPara [0]--;
  1053.         if (pVgaConDv->escPara [1] > 0)
  1054.     pVgaConDv->escPara [1]--;
  1056. pVgaConDv->row = pVgaConDv->escPara [0];
  1057. pVgaConDv->col = pVgaConDv->escPara [1];
  1058. vgaPutCursor (pVgaConDv);
  1059. continue;
  1061. case 'J': /* ESC [ n J :clear display */
  1062. vgaClear (pVgaConDv, pVgaConDv->escPara [0],
  1063.   ' ');
  1064. continue;
  1066. case 'K': /* ESC [ n K :clear Line */
  1067. vgaClearLine (pVgaConDv);
  1068. continue;
  1069.    
  1070. case 'L': /* ESC [ n L :insert Lines */
  1071. vgaInsertLine (pVgaConDv);
  1072. continue;
  1074. case 'M': /* ESC [ n M :delete lines */
  1075. vgaDelLines (pVgaConDv);
  1076. continue;
  1078. case 'P': /* ESC [ n P :delete on right side */
  1079. vgaDelRightChars (pVgaConDv, 
  1080.   pVgaConDv->escPara [0]);
  1081. continue;
  1083. case 'c': /* ESC [ n c :get response from term */
  1084. if ( pVgaConDv->escPara [0] == 0 )
  1085.     vgaEscResponse (pPcCoDv,2);
  1087. continue;
  1089. case 'g': /* ESC [ n g :give tabs */
  1090. if ( pVgaConDv->escPara [0] == 0 )
  1091.     {
  1092.     vgaTab (pVgaConDv);
  1093.     }
  1094. else if ( pVgaConDv->escPara [0] == 3)
  1095.     {
  1096.     pVgaConDv->tab_stop [0] = 0; 
  1097.     pVgaConDv->tab_stop [1] = 0;
  1098.     pVgaConDv->tab_stop [2] = 0;
  1099.     pVgaConDv->tab_stop [3] = 0;
  1100.     pVgaConDv->tab_stop [4] = 0;
  1101.     }
  1102. continue;
  1104. case 'm': /* ESC [ m :set the attributes */
  1105. vgaSetAttrib (pVgaConDv);
  1106. continue;
  1108. case 'r': /* ESC [ n;n r : set scroll limits */
  1109. if (pVgaConDv->escPara [0] == 0)
  1110.     pVgaConDv->escPara [0]++;
  1112. if (pVgaConDv->escPara [1] == 0)
  1113.     pVgaConDv->escPara[1] = pVgaConDv->ncol-1;
  1115. if ((pVgaConDv->escPara [0] < 
  1116.     pVgaConDv->escPara [1]) && 
  1117.     (pVgaConDv->escPara [1] < pVgaConDv->ncol))
  1118.     {
  1119.     pVgaConDv->scst = pVgaConDv->escPara [0] -
  1120.            1;
  1121.     pVgaConDv->sced = pVgaConDv->escPara [1];
  1122.     pVgaConDv->row = 0;
  1123.     vgaPutCursor (pVgaConDv);
  1124.     }
  1125. continue;
  1127. case 's': /* ESC [ s :save attributes */
  1128. vgaSaveCurAttrib (pVgaConDv);
  1129. continue;
  1131. case 'u': /* ESC [ u :restore attributes */
  1132. vgaRestAttrib (pVgaConDv);
  1133. continue;
  1135. case '@': /* ESC [ n @ :insert n characters */
  1136. vgaInsertChar (pVgaConDv, 
  1137.        pVgaConDv->escPara [0]);
  1138. continue;
  1139. }
  1140.     
  1141.     continue;
  1143.     case ESC_FUNC_KEY:
  1144.     pVgaConDv->escFlags = ESC_NORMAL;
  1145.     continue;
  1147.     case ESC_HASH:
  1148.     pVgaConDv->escFlags = ESC_NORMAL;
  1149.     if ( ch == '8' )
  1150.        vgaClear (pVgaConDv, 2, 'E'); /* erase char to 'E' */
  1151.     continue;
  1152.     
  1153.     case ESC_SET_TEXT:
  1154.     case ESC_SET_GPRAHICS:
  1155.     if ( ch == 'O' )
  1156.        pVgaConDv->charSet = vgaCharTable [GRAPHICS_VT100_SET];
  1157.     else if ( ch == 'B')
  1158. {
  1159. pVgaConDv->charSet = vgaCharTable [TEXT_SET];
  1160. pVgaConDv->escFlags = ESC_NORMAL;
  1161. }
  1162.     else if ( ch == 'U')
  1163. {
  1164. pVgaConDv->charSet = vgaCharTable [IBM_GRAPHICS_SET];
  1165. pVgaConDv->escFlags = ESC_NORMAL;
  1166. }
  1167.     continue;
  1169.     default:
  1170.     pVgaConDv->escFlags = ESC_NORMAL;
  1171.     }
  1172. #endif /* INCLUDE_ANSI_ESC_SEQUENCE */
  1174. VGA_CHECK: /* label for checking at the end of the loop */
  1175.     {
  1176.     if (pVgaConDv->scrollCheck && pVgaConDv->curChrPos >= 
  1177. pVgaConDv->memBase + pVgaConDv->ncol * CHR * (pVgaConDv->sced 
  1178.       + 1))
  1179. { 
  1180. /* forward scroll check */
  1182. pVgaConDv->row = pVgaConDv->sced;
  1183. vgaScroll (pVgaConDv, pVgaConDv->row, pVgaConDv->scrollCheck,
  1184.    FORWARD, pVgaConDv->defAttrib);
  1185. while (pVgaConDv->curChrPos >= pVgaConDv->memBase + 
  1186.        pVgaConDv->ncol * CHR * (pVgaConDv->sced + 1))
  1187. pVgaConDv->curChrPos -= pVgaConDv->ncol * CHR;
  1188. }
  1189.     else if (pVgaConDv->scrollCheck && pVgaConDv->curChrPos < 
  1190.      pVgaConDv->memBase + pVgaConDv->col * CHR * 
  1191.      pVgaConDv->scst)
  1192. {
  1193. /* rearword scroll check */
  1195. pVgaConDv->row = pVgaConDv->scst;
  1196. vgaScroll (pVgaConDv, pVgaConDv->row, pVgaConDv->scrollCheck,
  1197.    BACKWARD, pVgaConDv->defAttrib);
  1198. while (pVgaConDv->curChrPos < pVgaConDv->memBase + 
  1199.        pVgaConDv->col * CHR * pVgaConDv->scst)
  1200. pVgaConDv->curChrPos += pVgaConDv->ncol * CHR;
  1201. }
  1202.     else if (pVgaConDv->curChrPos > pVgaConDv->memBase + 
  1203.      pVgaConDv->ncol * CHR * pVgaConDv->nrow)
  1204. { 
  1205. /* out of range check (over) */
  1207. while (pVgaConDv->curChrPos > pVgaConDv->memBase + 
  1208.        pVgaConDv->ncol * CHR * pVgaConDv->nrow)
  1209.     {
  1210.     pVgaConDv->curChrPos -= pVgaConDv->ncol * CHR;
  1211.     pVgaConDv->row--;
  1212.     }
  1213. }
  1214.     else if (pVgaConDv->curChrPos < pVgaConDv->memBase)
  1215. { 
  1216. /* out of range check (under) */
  1218. while (pVgaConDv->curChrPos < pVgaConDv->memBase)
  1219.     {
  1220.     pVgaConDv->curChrPos += pVgaConDv->ncol * CHR;
  1221.     pVgaConDv->row++;
  1222.     }
  1223. }
  1224.     } /* VGA_CHECK: */
  1226. /* this line prevents the workQ panic */
  1228. if ((intContext()) && (nBytes >= jobaddThreshold))
  1229.     {
  1230.     excJobAdd ((VOIDFUNCPTR)vgaWriteString, (int)pPcCoDv, 0,0,0,0,0);
  1231.     return (nBytes);
  1232.     }
  1233. } /* end of the main for loop */
  1235.     vgaCursorPos ((pVgaConDv->curChrPos - pVgaConDv->memBase) / CHR );
  1236.     pPcCoDv->tyDev.wrtState.busy = FALSE;
  1238.     /* when we pass the write threshhold, give write synchonization
  1239.      * and release tasks pended in select */
  1240.     
  1241.     if (rngFreeBytes (ringId) >= tyWrtThreshold)
  1242.             {
  1243.             semGive (&pPcCoDv->tyDev.wrtSyncSem);
  1244.             if (_func_selWakeupAll != NULL)
  1245.                 (* _func_selWakeupAll) (&pPcCoDv->tyDev.selWakeupList, 
  1246. SELWRITE);
  1247.     }
  1248.     return nBytes; /* return the number of characters processed */
  1249.     }
  1251. #ifdef INCLUDE_ANSI_ESC_SEQUENCE
  1252.     
  1253. /*****************************************************************************
  1254. *
  1255. * vgaEscResponse - This function gives back a response to an escape sequence.
  1256. *                  The valid response Ids are 
  1257. *                  0 for cursor position, 1 for terminal status, 
  1258. *                  2 for terminal device attributes.
  1259. *
  1260. * RETURNS: N/A
  1261. */
  1263. LOCAL void vgaEscResponse
  1264.     (
  1265.     FAST PC_CON_DEV * pPcCoDv, /* pointer to the console descriptor */
  1266.     int responseId /* response Id */
  1267.     )
  1268.     {
  1269.     FAST VGA_CON_DEV * pVgaConDv; /* pointer to the vga descriptor */
  1270.     pVgaConDv = pPcCoDv->vs;
  1271.     tyIoctl (&pPcCoDv->tyDev, FIORFLUSH, 0);
  1272.     if ( responseId == 0)
  1273. {
  1274. sprintf (pVgaConDv->escResp, "33[%d;%dR",pVgaConDv->row, 
  1275.  pVgaConDv->col );
  1276. }
  1277.     else if ( responseId == 1) 
  1278. {
  1279. sprintf (pVgaConDv->escResp, "33[0n");
  1280. }
  1281.     else if ( responseId == 2)
  1282. {
  1283. sprintf (pVgaConDv->escResp, "33[?1;0c");
  1284. }
  1285.     else
  1286. {
  1287. pVgaConDv->escResp[0] = '';
  1288. }
  1289.     
  1290.     rngBufPut (pPcCoDv->tyDev.rdBuf, pVgaConDv->escResp, 
  1291.        strlen (pVgaConDv->escResp) );
  1292.     semGive (&pPcCoDv->tyDev.rdSyncSem);
  1293.     selWakeupAll (&pPcCoDv->tyDev.selWakeupList, SELREAD);
  1295.     }
  1297. /*****************************************************************************
  1298. *
  1299. * vgaSaveCurAttrib - saves all the current attributes, cursor position
  1300. *                    screen reverse mode.
  1301. *
  1302. * RETURNS: N/A
  1303. */
  1305. LOCAL void vgaSaveCurAttrib 
  1306.     (
  1307.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1308.     )
  1309.     {
  1310.     pVgaConDv->sv_rev       = pVgaConDv->rev;
  1311.     pVgaConDv->sv_col       = pVgaConDv->col;
  1312.     pVgaConDv->sv_row       = pVgaConDv->row;
  1313.     pVgaConDv->sv_curAttrib = pVgaConDv->curAttrib;
  1315.     }
  1316.     
  1317. /*****************************************************************************
  1318. *
  1319. * vgaRestAttrib - restores all the saved attributes, cursor position
  1320. *                    screen reverse mode.
  1321. *
  1322. * RETURNS: N/A
  1323. */
  1325. LOCAL void vgaRestAttrib 
  1326.     (
  1327.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1328.     )
  1329.     {
  1330.     pVgaConDv->rev       = pVgaConDv->sv_rev;
  1331.     pVgaConDv->col       = pVgaConDv->sv_col;
  1332.     pVgaConDv->row       = pVgaConDv->sv_row;
  1333.     pVgaConDv->curAttrib = pVgaConDv->sv_curAttrib;
  1334.     
  1335.     }
  1337. /*****************************************************************************
  1338. *
  1339. * vgaSetAttrib - sets various attributes 
  1340. *
  1341. * RETURNS: N/A
  1342. */
  1344. LOCAL void vgaSetAttrib 
  1345.     (
  1346.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1347.     )  
  1348.     {
  1349.     FAST int ix; /* register to hold the index */
  1350.     FAST UCHAR attr; /* register to hold the current attribute */
  1351.     
  1352.     attr = pVgaConDv->curAttrib;
  1353.     for (ix = 0 ; ix <= pVgaConDv->escParaCount; ix++)
  1354. {
  1355. switch (pVgaConDv->escPara [ix])
  1356.     {
  1357.     case 0:
  1358.           attr =  DEFAULT_ATR;
  1359.   break;
  1360.   
  1361.             case 1:
  1362.   attr |= ATRB_BRIGHT; /* set intensity */
  1363.   break;
  1364.        
  1365.     case 4:
  1366.   if (!pVgaConDv->colorMode)
  1367.       {
  1368.       attr |= UNDERLINE;
  1369.       }
  1370.   break;
  1371.   
  1372.     case 5:
  1373.   attr |= ATRB_BLINK; /* toggle blinking */
  1374.   break;
  1376.     case 7:
  1377.   pVgaConDv->rev = TRUE; /* set reverse mode */
  1378.   attr = (attr & 0x88) | (((attr >> 4) | ((attr << 4) & 0x7)));
  1379.   break;
  1380.   
  1381.     case 21:
  1382.     case 22:
  1383.   attr &= ~ATRB_BRIGHT; /* reset brightness */
  1384.   break;
  1385.   
  1386.     case 24:
  1387.   if (!pVgaConDv->colorMode)
  1388.       {
  1389.       attr &= ~UNDERLINE; /* reset underline mode */
  1390.       }
  1391.   break;
  1392.   
  1393.     case 25:
  1394.   attr &= ~ATRB_BLINK;
  1395.   break;
  1397.     case 27:
  1398.   pVgaConDv->rev = FALSE;  /* reset reverse mode */
  1399.   break;
  1401.     default:
  1402.   /* set foreground and background attribute */
  1404.   if ((pVgaConDv->escPara [ix] >= 30) && 
  1405.       (pVgaConDv->escPara [ix] <= 37) )
  1406.       {
  1407.       attr = (attr & 0xf8) | 
  1408.              (vgaColorTable [pVgaConDv->escPara [ix] - 30]) ;
  1409.       }
  1410.   else if ((pVgaConDv->escPara [ix] >= 40) &&
  1411.    (pVgaConDv->escPara [ix] <= 47))
  1412.       {
  1413.       attr = (attr & 0x8f) |
  1414.              vgaColorTable [pVgaConDv->escPara [ix] - 40] << 4;
  1415.       }
  1416.   break;
  1417.             }
  1418. }
  1419.     pVgaConDv->curAttrib = attr;   /* set the current attribute */
  1420.     }
  1422. /*****************************************************************************
  1423. *
  1424. * vgaSetMode - set various special modes according to the input onOff
  1425. *
  1426. * RETURNS: N/A
  1427. */
  1429. LOCAL void vgaSetMode
  1430.     (
  1431.     FAST  PC_CON_DEV * pPcCoDv, /* pointer to the vga descriptor */
  1432.     BOOL          onOff /* on or off */
  1433.     )
  1434.     {
  1435.     FAST int ix;
  1436.     FAST VGA_CON_DEV * pVgaConDv; /* pointer to the vga descriptor */
  1437.     
  1438.     pVgaConDv = pPcCoDv->vs;
  1439.     for ( ix =0; ix <= pVgaConDv->escParaCount; ix++ )
  1440. {
  1441. if ( pVgaConDv->escQuestion )
  1442.     {
  1443.     switch (pVgaConDv->escPara [ix])
  1444. { /* modes set reset */
  1445. case 1:
  1446.       pPcCoDv->ks->curMode = (onOff) ?  FALSE : TRUE;
  1447.       break;
  1448.       
  1449.                 case 3: /* 80/132 mode switch unimplemented */
  1450.       vgaClear (pVgaConDv, 2, ' ');
  1451.       break;
  1452.       
  1453.                 case 5:
  1454.       pVgaConDv->rev = (pVgaConDv->rev) ? FALSE : TRUE;
  1455.       vgaScreenRev (pVgaConDv);
  1456.       break;
  1457.       
  1458.                 case 7:
  1459.       pVgaConDv->autoWrap = onOff;
  1460.       break;
  1461.       
  1462.                 case 25:
  1463.       (onOff) ?  vgaCursorOn() : vgaCursorOff() ;
  1464.       break;
  1465. }
  1466.     }
  1467. else if ( pVgaConDv->escPara [ix] == 4)
  1468.     {
  1469.     pVgaConDv->insMode = onOff;
  1470.     }
  1471. }
  1472.     }
  1474. /*****************************************************************************
  1475. *
  1476. * vgaPutCursor - place the cursor in the specified location
  1477. *
  1478. * RETURNS: N/A
  1479. */
  1481. LOCAL void vgaPutCursor 
  1482.     (
  1483.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1484.     )
  1485.     {
  1486.     if ( pVgaConDv->col  < 0)
  1487. pVgaConDv->col = 0;
  1489.     else if (pVgaConDv->col >= pVgaConDv->ncol)
  1490. pVgaConDv->col = pVgaConDv->ncol - 1;
  1492.     if ( pVgaConDv->row < pVgaConDv->scst)
  1493. pVgaConDv->row = pVgaConDv->scst;
  1495.     else if ( pVgaConDv->row >= pVgaConDv->sced )
  1496. pVgaConDv->row = pVgaConDv->sced;
  1497.     
  1498.     pVgaConDv->curChrPos = (pVgaConDv->memBase + pVgaConDv->row *
  1499.     pVgaConDv->ncol * CHR + pVgaConDv->col * CHR );
  1500.     
  1501.     }
  1503. /*****************************************************************************
  1504. *
  1505. * vgaClearLine - clear the line according to the position passed.
  1506. *
  1507. * RETURNS: N/A
  1508. */
  1510. LOCAL void vgaClearLine 
  1511.     (
  1512.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1513.     )
  1514.     {
  1515.     FAST UINT16 * cp; /* hold the beginning value */
  1516.     FAST UINT16 * end; /* hold the end value */
  1517.     FAST UINT16 erase; /* hold the erase character */
  1519.     erase = (pVgaConDv->defAttrib << 8 ) + ' ';
  1520.     
  1521.     if (pVgaConDv->escPara [0] == 0 )
  1522. {
  1523. cp  = (UINT16 *) (pVgaConDv->curChrPos + CHR );
  1524. end = (UINT16 *) (pVgaConDv->memBase + pVgaConDv->row  * 
  1525.   pVgaConDv->ncol * CHR + (pVgaConDv->ncol - 1) * CHR);
  1526. }
  1527.     else if (pVgaConDv->escPara [0] == 1)
  1528. {
  1529. cp  = (UINT16 *) (pVgaConDv->memBase + pVgaConDv->row * 
  1530.  pVgaConDv->ncol * CHR);
  1531. end = (UINT16 *) (pVgaConDv->curChrPos);
  1532. }
  1533.     else 
  1534. {
  1535. cp  = (UINT16 *) (pVgaConDv->memBase + pVgaConDv->row * 
  1536.   pVgaConDv->ncol * CHR);
  1537. end = (UINT16 *) (cp + (pVgaConDv->ncol - 1) * CHR);
  1538. pVgaConDv->curChrPos = (UCHAR *) cp ;
  1539. pVgaConDv->col = 0;
  1540. }
  1541.     for (; cp <= end; cp ++)
  1542. {
  1543. *cp = erase;
  1544. }
  1545.     }
  1547. /******************************************************************************
  1548. *
  1549. * vgaInsertLine - inserts as many number of lines as passed in the escape
  1550. *                  parameter
  1551. *
  1552. * RETURNS: N/A
  1553. */
  1555. LOCAL void vgaInsertLine 
  1556.     (
  1557.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1558.     )
  1559.     {
  1560.     int ix;
  1561.     int start;
  1562.     int end;
  1564.     start = pVgaConDv->scst;
  1565.     end   = pVgaConDv->sced;
  1566.     pVgaConDv->scst = pVgaConDv->row;
  1567.     pVgaConDv->sced = pVgaConDv->nrow - 1 ;
  1568.     ix = pVgaConDv->escPara [0];
  1569.     if (pVgaConDv->escPara [0] == 0)
  1570. {
  1571. ix = 1;
  1572. }
  1573.     if (pVgaConDv->row + ix >= pVgaConDv->nrow)
  1574. {
  1575. ix = pVgaConDv->nrow - pVgaConDv->row - 1;
  1576. }
  1577.     vgaScroll (pVgaConDv, pVgaConDv->row, ix, BACKWARD, pVgaConDv->defAttrib);
  1578.     pVgaConDv->curChrPos -= pVgaConDv->col * CHR;
  1579.     pVgaConDv->col = 0;
  1580.     pVgaConDv->scst = start;
  1581.     pVgaConDv->sced = end ;
  1582.     
  1583.     }
  1584.      
  1585. /******************************************************************************
  1586. *
  1587. * vgaDelLines - deletes as many as lines as passed in the escape 
  1588. *               parameter
  1589. *
  1590. * RETURNS: N/A
  1591. */
  1593. LOCAL void vgaDelLines 
  1594.     (
  1595.     FAST VGA_CON_DEV * pVgaConDv /* pointer to the vga descriptor */
  1596.     )
  1597.     {
  1598.     int ix;
  1599.     int start;
  1600.     int end;
  1602.     start = pVgaConDv->scst;
  1603.     end = pVgaConDv->sced;
  1604.     pVgaConDv->scst = pVgaConDv->row;
  1605.     pVgaConDv->sced = pVgaConDv->nrow - 1;
  1606.     ix = pVgaConDv->escPara [0];
  1607.     if (ix == 0)
  1608. {
  1609. ix = 1;
  1610. }
  1611.     if (pVgaConDv->row + ix > pVgaConDv->nrow) 
  1612. {
  1613. ix = pVgaConDv->row;
  1614. }
  1615.     vgaScroll (pVgaConDv, pVgaConDv->sced, ix, FORWARD, pVgaConDv->defAttrib);
  1616.     pVgaConDv->curChrPos -= pVgaConDv->col * CHR;
  1617.     pVgaConDv->col = 0;
  1618.     pVgaConDv->scst = start;
  1619.     pVgaConDv->sced = end;
  1621.     }
  1623. /******************************************************************************
  1624. *
  1625. * vgaDelRightChars - deletes character right of the cursor
  1626. *
  1627. * RETURNS: N/A
  1628. */
  1630. LOCAL void vgaDelRightChars
  1631.     (
  1632.     FAST VGA_CON_DEV * pVgaConDv, /* pointer to the vga descriptor */
  1633.     int nDelChar /* number of Deletes to do */
  1634.     )
  1635.     {
  1636.     FAST int xPos; /* current position in columns */
  1637.     FAST UINT16 * cp; /* current pointer */
  1638.     FAST UINT16 erase; /* to hold erase character with Attribute */
  1639.     
  1640.     erase = (pVgaConDv->defAttrib << 8 ) + ' ';
  1642.     if (nDelChar + pVgaConDv->col  >=  pVgaConDv->ncol )
  1643. {
  1644. nDelChar = pVgaConDv->ncol - pVgaConDv->col - 1;
  1645. }
  1646.     else if (nDelChar == 0)
  1647. {
  1648. nDelChar = 1;
  1649. }
  1650.     while ( nDelChar-- )
  1651. {
  1652. xPos = pVgaConDv->col;
  1653. cp   = (unsigned short *) pVgaConDv->curChrPos;
  1654. while (++xPos < pVgaConDv->ncol)
  1655.     {
  1656.     *cp = *(cp +1);
  1657.     cp++;
  1658.     }
  1659. *cp =  erase;           /* erase the last character */
  1660. }
  1661.     }
  1663. #endif /* INCLUDE_ANSI_ESC_SEQUENCE */