[BACK]Return to serial.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / io

Diff for /np2/io/serial.c between versions 1.1 and 1.7

version 1.1, 2003/10/16 17:57:57 version 1.7, 2003/12/08 00:55:32
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "dosio.h"  
 #include        "commng.h"  #include        "commng.h"
 #include        "memory.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   
   
 static const BYTE joykeytable[12] = {  static const UINT8 joykeytable[12] = {
                                 0x2a,   0x34,                                  0x2a,   0x34,
                                 0x29,   0x1c,                                  0x29,   0x1c,
                                 0x3c,   0x48,                                  0x3c,   0x48,
Line 14  static const BYTE joykeytable[12] = { Line 12  static const BYTE joykeytable[12] = {
                                 0x3d,   0x4b,                                  0x3d,   0x4b,
                                 0x3a,   0x43};                                  0x3a,   0x43};
   
 static const BYTE kbexflag[0x80] = {  static const UINT8 kbexflag[0x80] = {
                 //       ESC,  １,  ２,  ３,  ４,  ５,  ６,  ７         ; 00h                  //       ESC,  １,  ２,  ３,  ４,  ５,  ６,  ７         ; 00h
                            0,   0,   0,   0,   0,   0,   0,   0,                             0,   0,   0,   0,   0,   0,   0,   0,
                 //        ８,  ９,  ０,  −,  ＾,  ￥,  BS, TAB         ; 08h                  //        ８,  ９,  ０,  −,  ＾,  ￥,  BS, TAB         ; 08h
Line 74  void keyb_callback(NEVENTITEM item) { Line 72  void keyb_callback(NEVENTITEM item) {
         }          }
 }  }
   
 static void keyb_out(BYTE data) {  static void keyb_out(REG8 data) {
   
         if (keyb.buffers < KB_BUF) {          if (keyb.buffers < KB_BUF) {
                 keyb.buf[(keyb.pos + keyb.buffers) & KB_BUFMASK] = data;                  keyb.buf[(keyb.pos + keyb.buffers) & KB_BUFMASK] = data;
Line 91  static void keyb_out(BYTE data) { Line 89  static void keyb_out(BYTE data) {
   
 // ----  // ----
   
         BYTE    keystat[0x80];          UINT8   keystat[0x80];
   
 void keystat_reset(void) {  void keystat_reset(void) {
   
         ZeroMemory(keystat, sizeof(keystat));          ZeroMemory(keystat, sizeof(keystat));
 }  }
   
 void keystat_senddata(BYTE data) {  
   
         BYTE    key = data & 0x7f;  void keystat_senddata(REG8 data) {
         BOOL    keynochange = FALSE;  
   
           REG8    key;
           BOOL    keynochange;
   
           key = data & 0x7f;
           keynochange = FALSE;
   
           // CTRL:カナ 0x71,0x72 bit7==0でトグル処理 (標準処理)
         if ((key == 0x71) || (key == 0x72)) {          if ((key == 0x71) || (key == 0x72)) {
                 if (data & 0x80) {                  if (data & 0x80) {
                         return;                          return;
Line 112  void keystat_senddata(BYTE data) { Line 115  void keystat_senddata(BYTE data) {
         }          }
         else {          else {
                 if ((np2cfg.XSHIFT) &&                  if ((np2cfg.XSHIFT) &&
                         ((key == 0x70) && (np2cfg.XSHIFT & 1)) ||                          (((key == 0x70) && (np2cfg.XSHIFT & 1)) ||
                         ((key == 0x74) && (np2cfg.XSHIFT & 2)) ||                          ((key == 0x74) && (np2cfg.XSHIFT & 2)) ||
                         ((key == 0x73) && (np2cfg.XSHIFT & 4))) {                          ((key == 0x73) && (np2cfg.XSHIFT & 4)))) {
                         if (data & 0x80) {                          if (data & 0x80) {
                                 return;                                  return;
                         }                          }
Line 122  void keystat_senddata(BYTE data) { Line 125  void keystat_senddata(BYTE data) {
                         keystat[key] ^= 0x80;                          keystat[key] ^= 0x80;
                 }                  }
                 else {                  else {
                           // CTRL:カナ 0x79,0x7a bit7をそのまま通知
                           // (ハードウェアでメカニカル処理してる場合)
                           if ((key == 0x79) || (key == 0x7a)) {
                                   key -= 0x08;
                                   data -= 0x08;
                           }
                         if (!((keystat[key] ^ data) & 0x80)) {                          if (!((keystat[key] ^ data) & 0x80)) {
                                 keystat[key] ^= 0x80;                                  keystat[key] ^= 0x80;
                         }                          }
Line 138  void keystat_senddata(BYTE data) { Line 147  void keystat_senddata(BYTE data) {
                         if (data & 0x80) {                                              // ver0.30                          if (data & 0x80) {                                              // ver0.30
                                 return;                                  return;
                         }                          }
                         keyb_out((BYTE)(data ^ 0x80));                          keyb_out((REG8)(data ^ 0x80));
                 }                  }
                 keyb_out(data);                  keyb_out(data);
         }          }
Line 146  void keystat_senddata(BYTE data) { Line 155  void keystat_senddata(BYTE data) {
   
 void keystat_resetcopyhelp(void) {  void keystat_resetcopyhelp(void) {
   
         BYTE    i;          REG8    i;
   
         for (i=0x60; i<0x62; i++) {          for (i=0x60; i<0x62; i++) {
                 if (keystat[i] & 0x80) {                  if (keystat[i] & 0x80) {
                         keystat[i] &= 0x7f;                          keystat[i] &= 0x7f;
                         keyb_out((BYTE)(i | 0x80));                          keyb_out((REG8)(i | 0x80));
                   }
           }
   }
   
   void keystat_allrelease(void) {
   
           REG8    i;
   
           for (i=0; i<0x80; i++) {
                   if (keystat[i] & 0x80) {
                           keystat[i] &= ~0x80;
                           keyb_out((REG8)(i | 0x80));
                 }                  }
         }          }
 }  }
   
 void keystat_forcerelease(BYTE value) {  void keystat_forcerelease(REG8 value) {
   
         if (keystat[value & 0x7f] & 0x80) {          if (keystat[value & 0x7f] & 0x80) {
                 keystat[value & 0x7f] &= ~0x80;                  keystat[value & 0x7f] &= ~0x80;
                 keyb_out((BYTE)(value | 0x80));                  keyb_out((REG8)(value | 0x80));
         }          }
 }  }
   
 void keystat_resetjoykey(void) {  void keystat_resetjoykey(void) {
   
         int             i;          int             i;
         BYTE    key;          REG8    key;
   
         for (i=0; i<12; i++) {          for (i=0; i<12; i++) {
                 key = joykeytable[i];                  key = joykeytable[i];
                 if (keystat[key] & 0x80) {                  if (keystat[key] & 0x80) {
                         keystat[key] &= 0x7f;                          keystat[key] &= 0x7f;
                         keyb_out((BYTE)(key | 0x80));                          keyb_out((REG8)(key | 0x80));
                 }                  }
         }          }
 }  }
   
 BYTE keystat_getjoy(void) {  
   
         BYTE    ret = 0xff;  // ----
         BYTE    *p = (BYTE *)joykeytable;  
   typedef struct {
           UINT8   joysync;
           UINT8   joylast;
           UINT8   mouselast;
           UINT8   padding;
           UINT8   d_up;
           UINT8   d_dn;
           UINT8   d_lt;
           UINT8   d_rt;
   } KEYEXT;
   
   static  KEYEXT  keyext;
   static const UINT8 mousedelta[] = {1, 1, 1, 1,
                                                                           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4};
   #define MOUSESTEPMAX ((sizeof(mousedelta) / sizeof(UINT8)) - 1)
   
   void keyext_flash(void) {
   
           keyext.joysync = 0;
   }
   
   BYTE keyext_getjoy(void) {
   
           BYTE    flg;
   const BYTE      *p;
         BYTE    bit;          BYTE    bit;
   
         for (bit=0x20; bit; bit>>=1, p+=2) {          if (!keyext.joysync) {
                 if ((keystat[*p] & 0x80) || (keystat[*(p+1)] & 0x80)) {                  keyext.joysync = 1;
                         ret &= ~bit;                  flg = 0xff;
                   p = joykeytable;
                   for (bit=0x20; bit; bit>>=1) {
                           if ((keystat[p[0]] & 0x80) || (keystat[p[1]] & 0x80)) {
                                   flg ^= bit;
                           }
                           p += 2;
                   }
                   keyext.joylast = flg;
           }
           return(keyext.joylast);
   }
   
   BYTE keyext_getmouse(SINT16 *x, SINT16 *y) {
   
           BYTE    btn;
           BYTE    acc;
           SINT16  tmp;
           BYTE    ret;
   
           btn = keyext_getjoy();
           acc = btn | keyext.mouselast;
           keyext.mouselast = btn;
           tmp = 0;
           if (!(btn & 1)) {
                   tmp -= mousedelta[keyext.d_up];
           }
           if (!(acc & 1)) {
                   if (keyext.d_up < MOUSESTEPMAX) {
                           keyext.d_up++;
                   }
           }
           else {
                   keyext.d_up = 0;
           }
           if (!(btn & 2)) {
                   tmp += mousedelta[keyext.d_dn];
           }
           if (!(acc & 2)) {
                   if (keyext.d_dn < MOUSESTEPMAX) {
                           keyext.d_dn++;
                   }
           }
           else {
                   keyext.d_dn = 0;
           }
           *y += tmp;
   
           tmp = 0;
           if (!(btn & 4)) {
                   tmp -= mousedelta[keyext.d_lt];
           }
           if (!(acc & 4)) {
                   if (keyext.d_lt < MOUSESTEPMAX) {
                           keyext.d_lt++;
                 }                  }
         }          }
           else {
                   keyext.d_lt = 0;
           }
           if (!(btn & 8)) {
                   tmp += mousedelta[keyext.d_rt];
           }
           if (!(acc & 8)) {
                   if (keyext.d_rt < MOUSESTEPMAX) {
                           keyext.d_rt++;
                   }
           }
           else {
                   keyext.d_rt = 0;
           }
           *x += tmp;
   
           ret = 0x5f;
           ret += (btn & 0x10) << 3;
           ret += (btn & 0x20);
         return(ret);          return(ret);
 }  }
   
   
 // ----  // ----
   
 static void IOOUTCALL keyb_o41(UINT port, BYTE dat) {  static void IOOUTCALL keyb_o41(UINT port, REG8 dat) {
   
         keyb.mode = dat;          keyb.mode = dat;
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL keyb_o43(UINT port, BYTE dat) {  static void IOOUTCALL keyb_o43(UINT port, REG8 dat) {
   
         if ((!(dat & 0x08)) && (keyb.cmd & 0x08)) {          if ((!(dat & 0x08)) && (keyb.cmd & 0x08)) {
                 keyboard_resetsignal();                  keyboard_resetsignal();
Line 213  static void IOOUTCALL keyb_o43(UINT port Line 331  static void IOOUTCALL keyb_o43(UINT port
         (void)port;          (void)port;
 }  }
   
 static BYTE IOINPCALL keyb_i41(UINT port) {  static REG8 IOINPCALL keyb_i41(UINT port) {
   
         (void)port;          (void)port;
         return(keyb.data);          return(keyb.data);
 }  }
   
 static BYTE IOINPCALL keyb_i43(UINT port) {  static REG8 IOINPCALL keyb_i43(UINT port) {
   
         (void)port;          (void)port;
         return(keyb.status);          return(keyb.status);
Line 255  void keyboard_resetsignal(void) {        Line 373  void keyboard_resetsignal(void) {       
         keyboard_reset();          keyboard_reset();
         for (i=0; i<0x80; i++) {          for (i=0; i<0x80; i++) {
                 if (keystat[i]) {                  if (keystat[i]) {
                         keyb_out((BYTE)i);                          keyb_out((REG8)i);
                 }                  }
         }          }
 }  }
Line 288  void rs232c_callback(void) { Line 406  void rs232c_callback(void) {
   
         BOOL    interrupt;          BOOL    interrupt;
   
           interrupt = FALSE;
         if ((cm_rs232c) && (cm_rs232c->read(cm_rs232c, &rs232c.data))) {          if ((cm_rs232c) && (cm_rs232c->read(cm_rs232c, &rs232c.data))) {
                 rs232c.result |= 2;                  rs232c.result |= 2;
                 if (sysport.c & 1) {                  if (sysport.c & 1) {
Line 326  void rs232c_midipanic(void) { Line 445  void rs232c_midipanic(void) {
   
 // ----  // ----
   
 static void IOOUTCALL rs232c_o30(UINT port, BYTE dat) {  static void IOOUTCALL rs232c_o30(UINT port, REG8 dat) {
   
         if (cm_rs232c) {          if (cm_rs232c) {
                 cm_rs232c->write(cm_rs232c, dat);                  cm_rs232c->write(cm_rs232c, (UINT8)dat);
         }          }
         if (sysport.c & 4) {          if (sysport.c & 4) {
                 rs232c.send = 0;                  rs232c.send = 0;
Line 341  static void IOOUTCALL rs232c_o30(UINT po Line 460  static void IOOUTCALL rs232c_o30(UINT po
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL rs232c_o32(UINT port, BYTE dat) {  static void IOOUTCALL rs232c_o32(UINT port, REG8 dat) {
   
         if (!(dat & 0xfd)) {          if (!(dat & 0xfd)) {
                 rs232c.dummyinst++;                  rs232c.dummyinst++;
Line 399  static void IOOUTCALL rs232c_o32(UINT po Line 518  static void IOOUTCALL rs232c_o32(UINT po
         (void)port;          (void)port;
 }  }
   
 static BYTE IOINPCALL rs232c_i30(UINT port) {  static REG8 IOINPCALL rs232c_i30(UINT port) {
   
         (void)port;          (void)port;
         return(rs232c.data);          return(rs232c.data);
 }  }
   
 static BYTE IOINPCALL rs232c_i32(UINT port) {  static REG8 IOINPCALL rs232c_i32(UINT port) {
   
         if (!(rs232c_stat() & 0x20)) {          if (!(rs232c_stat() & 0x20)) {
                 return(rs232c.result | 0x80);                  return(rs232c.result | 0x80);
Removed from v.1.1  
changed lines
  Added in v.1.7

RetroPC.NET-CVS <cvs@retropc.net>