1: //========================================================================================
     2: //  IOInterrupt.java
     3: //    en:I/O Interrupt
     4: //    ja:I/O割り込み
     5: //  Copyright (C) 2003-2022 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: package xeij;
    14: 
    15: public class IOInterrupt {
    16: 
    17:   //デバッグ
    18:   public static final boolean IOI_DEBUG_TRACE = false;
    19: 
    20:   //ポート
    21:   public static final int IOI_STATUS = 0x00e9c001;
    22:   public static final int IOI_VECTOR = 0x00e9c003;
    23: 
    24:   //割り込み信号
    25:   public static final int IOI_SPC_SIGNAL = 0x4000;
    26:   public static final int IOI_FDC_SIGNAL = 0x0080;
    27:   public static final int IOI_FDD_SIGNAL = 0x0040;
    28:   public static final int IOI_PRN_SIGNAL = 0x0020;
    29:   public static final int IOI_HDC_SIGNAL = 0x0010;
    30: 
    31:   //割り込み要求
    32:   public static final int IOI_SPC_REQUEST = 0x4000;
    33:   public static final int IOI_HDC_REQUEST = 0x0008;
    34:   public static final int IOI_FDC_REQUEST = 0x0004;
    35:   public static final int IOI_FDD_REQUEST = 0x0002;
    36:   public static final int IOI_PRN_REQUEST = 0x0001;
    37: 
    38:   //割り込みベクタ
    39:   public static final int IOI_SPC_VECTOR = 0x6c;  //内蔵SCSI
    40:   public static final int IOI_FDC_VECTOR = 0x00;
    41:   public static final int IOI_FDD_VECTOR = 0x01;
    42:   public static final int IOI_HDC_VECTOR = 0x02;
    43:   public static final int IOI_PRN_VECTOR = 0x03;
    44: 
    45:   //割り込み許可
    46:   //  割り込みステータスレジスタの下位4ビット
    47:   //  0b00010000_00000000  1=SPC割り込み許可。SPC割り込みは常に許可
    48:   //  0b00000000_00001000  1=HDC割り込み許可
    49:   //  0b00000000_00000100  1=FDC割り込み許可
    50:   //  0b00000000_00000010  1=FDD割り込み許可
    51:   //  0b00000000_00000001  1=PRN割り込み許可
    52:   public static int ioiEnable;  //割り込み許可
    53: 
    54:   //割り込み処理中
    55:   //  現在処理中の割り込みを示す
    56:   //  0b00010000_00000000  1=SPC割り込み処理中
    57:   //  0b00000000_00001000  1=HDC割り込み処理中
    58:   //  0b00000000_00000100  1=FDC割り込み処理中
    59:   //  0b00000000_00000010  1=FDD割り込み処理中
    60:   //  0b00000000_00000001  1=PRN割り込み処理中
    61:   public static int ioiInService;  //割り込み処理中
    62: 
    63:   //割り込み要求
    64:   //  0b00010000_00000000  1=SPC割り込み要求あり
    65:   //  0b00000000_00001000  1=HDC割り込み要求あり
    66:   //  0b00000000_00000100  1=FDC割り込み要求あり
    67:   //  0b00000000_00000010  1=FDD割り込み要求あり
    68:   //  0b00000000_00000001  1=PRN割り込み要求あり
    69:   public static int ioiRequest;  //割り込み要求
    70: 
    71:   //割り込み信号
    72:   //  割り込みステータスレジスタの上位4ビット
    73:   //  0b00010000_00000000  1=SPC割り込み要求あり
    74:   //  0b00000000_10000000  1=FDC割り込み要求あり。リザルトステータス読み取り要求、コマンド起動要求
    75:   //  0b00000000_01000000  1=FDD割り込み要求あり。メディア挿入、メディア排出
    76:   //  0b00000000_00100000  1=プリンタレディ。1のとき0x00e8c001にデータをセットしてプリンタストローブ(0x00e8c003のbit0)を0→1で出力
    77:   //  0b00000000_00010000  1=HDC割り込み要求あり。コマンド終了
    78:   public static int ioiSignal;  //割り込み信号
    79: 
    80:   //割り込みベクタ
    81:   //  下位2ビットは常に0
    82:   public static int ioiVector;  //割り込みベクタ
    83: 
    84:   //ioiInit ()
    85:   public static void ioiInit () {
    86:   }
    87: 
    88:   //ioiReset ()
    89:   //  I/O割り込みをリセットする
    90:   public static void ioiReset () {
    91:     if (IOI_DEBUG_TRACE) {
    92:       System.out.printf ("%08x ioiReset()\n", XEiJ.regPC0);
    93:     }
    94:     ioiEnable = IOI_SPC_REQUEST;  //SPC割り込みは常に許可
    95:     if (IOI_DEBUG_TRACE) {
    96:       System.out.printf ("\tioiEnable=0x%04x\n", ioiEnable);
    97:     }
    98:     ioiInService = 0;
    99:     if (IOI_DEBUG_TRACE) {
   100:       System.out.printf ("\tioiInService=0x%04x\n", ioiInService);
   101:     }
   102:     ioiRequest = 0;
   103:     if (IOI_DEBUG_TRACE) {
   104:       System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   105:     }
   106:     ioiSignal = PrinterPort.prnOnlineOn ? IOI_PRN_SIGNAL : 0;  //オンラインのときはレディ、オフラインのときはビジー
   107:     if (IOI_DEBUG_TRACE) {
   108:       System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   109:     }
   110:     ioiVector = 0;
   111:     if (IOI_DEBUG_TRACE) {
   112:       System.out.printf ("\tioiVector=0x%04x\n", ioiVector);
   113:     }
   114:   }  //ioiReset()
   115: 
   116:   //  割り込み信号が変化したとき
   117:   //    デバイスがfallとriseで割り込み信号を操作する
   118:   //    割り込み信号が0→1のとき割り込み許可が1ならば割り込み要求を1にする
   119:   //    割り込み要求が0→1のデバイスがあるときMPUに割り込みを要求する
   120:   //
   121:   //  MPUが割り込みを受け付けたとき
   122:   //    SPC→FDC→FDD→HDC→PRNの優先順位で割り込み要求が1のデバイスを選択する
   123:   //    選択したデバイスの割り込み要求を0にする
   124:   //    選択したデバイスの割り込み処理中を1にする
   125:   //    選択したデバイスの割り込みベクタを返す
   126:   //
   127:   //  MPUの割り込み処理が終了したとき
   128:   //    割り込み処理中のデバイスを選択する
   129:   //    選択したデバイスの割り込み処理中を0にする
   130:   //    割り込み要求が1のデバイスが残っていたら再度MPUに割り込みを要求する
   131:   //
   132:   //  割り込み許可が変化したとき
   133:   //    割り込み許可が1→0のデバイスの割り込み要求を0にする
   134:   //    割り込み許可が0→1のデバイスの割り込み信号が1のとき割り込み要求を1にする
   135:   //    割り込み要求が0→1のデバイスがあるときMPUに割り込みを要求する
   136: 
   137:   //ioiSpcFall ()
   138:   //  SPCの割り込み信号を0にする
   139:   public static void ioiSpcFall () {
   140:     if ((ioiSignal & IOI_SPC_SIGNAL) != 0) {  //割り込み信号が1
   141:       if (IOI_DEBUG_TRACE) {
   142:         System.out.printf ("%08x ioiSpcFall()\n", XEiJ.regPC0);
   143:       }
   144:       ioiSignal &= ~IOI_SPC_SIGNAL;  //割り込み信号を1→0
   145:       if (IOI_DEBUG_TRACE) {
   146:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   147:       }
   148:     }
   149:   }  //ioiSpcFall()
   150: 
   151:   //ioiFdcFall ()
   152:   //  FDCの割り込み信号を0にする
   153:   public static void ioiFdcFall () {
   154:     if ((ioiSignal & IOI_FDC_SIGNAL) != 0) {  //割り込み信号が1
   155:       if (IOI_DEBUG_TRACE) {
   156:         System.out.printf ("%08x ioiFdcFall()\n", XEiJ.regPC0);
   157:       }
   158:       ioiSignal &= ~IOI_FDC_SIGNAL;  //割り込み信号を1→0
   159:       if (IOI_DEBUG_TRACE) {
   160:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   161:       }
   162:     }
   163:   }  //ioiFdcFall()
   164: 
   165:   //ioiFddFall ()
   166:   //  FDDの割り込み信号を0にする
   167:   public static void ioiFddFall () {
   168:     if ((ioiSignal & IOI_FDD_SIGNAL) != 0) {  //割り込み信号が1
   169:       if (IOI_DEBUG_TRACE) {
   170:         System.out.printf ("%08x ioiFddFall()\n", XEiJ.regPC0);
   171:       }
   172:       ioiSignal &= ~IOI_FDD_SIGNAL;  //割り込み信号を1→0
   173:       if (IOI_DEBUG_TRACE) {
   174:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   175:       }
   176:     }
   177:   }  //ioiFddFall()
   178: 
   179:   //ioiHdcFall ()
   180:   //  HDCの割り込み信号を0にする
   181:   public static void ioiHdcFall () {
   182:     if ((ioiSignal & IOI_HDC_SIGNAL) != 0) {  //割り込み信号が1
   183:       if (IOI_DEBUG_TRACE) {
   184:         System.out.printf ("%08x ioiHdcFall()\n", XEiJ.regPC0);
   185:       }
   186:       ioiSignal &= ~IOI_HDC_SIGNAL;  //割り込み信号を1→0
   187:       if (IOI_DEBUG_TRACE) {
   188:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   189:       }
   190:     }
   191:   }  //ioiHdcFall()
   192: 
   193:   //ioiPrnFall ()
   194:   //  PRNの割り込み信号を0にする
   195:   public static void ioiPrnFall () {
   196:     if ((ioiSignal & IOI_PRN_SIGNAL) != 0) {  //割り込み信号が1
   197:       if (IOI_DEBUG_TRACE) {
   198:         System.out.printf ("%08x ioiPrnFall()\n", XEiJ.regPC0);
   199:       }
   200:       ioiSignal &= ~IOI_PRN_SIGNAL;  //割り込み信号を1→0
   201:       if (IOI_DEBUG_TRACE) {
   202:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   203:       }
   204:     }
   205:   }  //ioiPrnFall()
   206: 
   207:   //ioiSpcRise ()
   208:   //  SPCの割り込み信号を1にする
   209:   public static void ioiSpcRise () {
   210:     if ((ioiSignal & IOI_SPC_SIGNAL) == 0) {  //割り込み信号が0
   211:       if (IOI_DEBUG_TRACE) {
   212:         System.out.printf ("%08x ioiSpcRise()\n", XEiJ.regPC0);
   213:       }
   214:       ioiSignal |= IOI_SPC_SIGNAL;  //割り込み信号を0→1
   215:       if (IOI_DEBUG_TRACE) {
   216:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   217:       }
   218:       if ((ioiEnable & IOI_SPC_REQUEST) != 0 &&  //割り込み許可が1
   219:           (ioiRequest & IOI_SPC_REQUEST) == 0) {  //割り込み要求が0
   220:         ioiRequest |= IOI_SPC_REQUEST;  //割り込み要求を0→1
   221:         if (IOI_DEBUG_TRACE) {
   222:           System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   223:         }
   224:         XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //MPUに割り込みを要求する
   225:       }
   226:     }
   227:   }  //ioiSpcRise()
   228: 
   229:   //ioiFdcRise ()
   230:   //  FDCの割り込み信号を1にする
   231:   public static void ioiFdcRise () {
   232:     if ((ioiSignal & IOI_FDC_SIGNAL) == 0) {  //割り込み信号が0
   233:       if (IOI_DEBUG_TRACE) {
   234:         System.out.printf ("%08x ioiFdcRise()\n", XEiJ.regPC0);
   235:       }
   236:       ioiSignal |= IOI_FDC_SIGNAL;  //割り込み信号を0→1
   237:       if (IOI_DEBUG_TRACE) {
   238:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   239:       }
   240:       if ((ioiEnable & IOI_FDC_REQUEST) != 0 &&  //割り込み許可が1
   241:           (ioiRequest & IOI_FDC_REQUEST) == 0) {  //割り込み要求が0
   242:         ioiRequest |= IOI_FDC_REQUEST;  //割り込み要求を0→1
   243:         if (IOI_DEBUG_TRACE) {
   244:           System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   245:         }
   246:         XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //MPUに割り込みを要求する
   247:       }
   248:     }
   249:   }  //ioiFdcRise()
   250: 
   251:   //ioiFddRise ()
   252:   //  FDDの割り込み信号を1にする
   253:   public static void ioiFddRise () {
   254:     if ((ioiSignal & IOI_FDD_SIGNAL) == 0) {  //割り込み信号が0
   255:       if (IOI_DEBUG_TRACE) {
   256:         System.out.printf ("%08x ioiFddRise()\n", XEiJ.regPC0);
   257:       }
   258:       ioiSignal |= IOI_FDD_SIGNAL;  //割り込み信号を0→1
   259:       if (IOI_DEBUG_TRACE) {
   260:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   261:       }
   262:       if ((ioiEnable & IOI_FDD_REQUEST) != 0 &&  //割り込み許可が1
   263:           (ioiRequest & IOI_FDD_REQUEST) == 0) {  //割り込み要求が0
   264:         ioiRequest |= IOI_FDD_REQUEST;  //割り込み要求を0→1
   265:         if (IOI_DEBUG_TRACE) {
   266:           System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   267:         }
   268:         XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //MPUに割り込みを要求する
   269:       }
   270:     }
   271:   }  //ioiFddRise()
   272: 
   273:   //ioiHdcRise ()
   274:   //  HDCの割り込み信号を1にする
   275:   public static void ioiHdcRise () {
   276:     if ((ioiSignal & IOI_HDC_SIGNAL) == 0) {  //割り込み信号が0
   277:       if (IOI_DEBUG_TRACE) {
   278:         System.out.printf ("%08x ioiHdcRise()\n", XEiJ.regPC0);
   279:       }
   280:       ioiSignal |= IOI_HDC_SIGNAL;  //割り込み信号を0→1
   281:       if (IOI_DEBUG_TRACE) {
   282:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   283:       }
   284:       if ((ioiEnable & IOI_HDC_REQUEST) != 0 &&  //割り込み許可が1
   285:           (ioiRequest & IOI_HDC_REQUEST) == 0) {  //割り込み要求が0
   286:         ioiRequest |= IOI_HDC_REQUEST;  //割り込み要求を0→1
   287:         if (IOI_DEBUG_TRACE) {
   288:           System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   289:         }
   290:         XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //MPUに割り込みを要求する
   291:       }
   292:     }
   293:   }  //ioiHdcRise()
   294: 
   295:   //ioiPrnRise ()
   296:   //  PRNの割り込み信号を1にする
   297:   public static void ioiPrnRise () {
   298:     if ((ioiSignal & IOI_PRN_SIGNAL) == 0) {  //割り込み信号が0
   299:       if (IOI_DEBUG_TRACE) {
   300:         System.out.printf ("%08x ioiPrnRise()\n", XEiJ.regPC0);
   301:       }
   302:       ioiSignal |= IOI_PRN_SIGNAL;  //割り込み信号を0→1
   303:       if (IOI_DEBUG_TRACE) {
   304:         System.out.printf ("\tioiSignal=0x%04x\n", ioiSignal);
   305:       }
   306:       if ((ioiEnable & IOI_PRN_REQUEST) != 0 &&  //割り込み許可が1
   307:           (ioiRequest & IOI_PRN_REQUEST) == 0) {  //割り込み要求が0
   308:         ioiRequest |= IOI_PRN_REQUEST;  //割り込み要求を0→1
   309:         if (IOI_DEBUG_TRACE) {
   310:           System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   311:         }
   312:         XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //MPUに割り込みを要求する
   313:       }
   314:     }
   315:   }  //ioiPrnRise()
   316: 
   317:   //vector = ioiAcknowledge ()
   318:   //  MPUが割り込み要求を受け付けたときに呼び出す
   319:   //  割り込みベクタ番号を返す
   320:   //  割り込み要求を取り下げる場合は0を返す
   321:   //  オートベクタを使用するデバイスはオートベクタの番号を返す
   322:   public static int ioiAcknowledge () {
   323:     int vector = 0;
   324:     if (IOI_DEBUG_TRACE) {
   325:       System.out.printf ("%08x ioiAcknowledge()\n", XEiJ.regPC0);
   326:     }
   327:     if ((ioiRequest & IOI_SPC_REQUEST) != 0) {  //SPCの割り込み要求が1のとき
   328:       ioiInService = IOI_SPC_REQUEST;  //SPCの割り込み処理中を1にする
   329:       vector = IOI_SPC_VECTOR;  //SPCの割り込みベクタを返す
   330:     } else if ((ioiRequest & IOI_FDC_REQUEST) != 0) {  //FDCの割り込み要求が1のとき
   331:       ioiInService = IOI_FDC_REQUEST;  //FDCの割り込み処理中を1にする
   332:       vector = ioiVector | IOI_FDC_VECTOR;  //FDCの割り込みベクタを返す
   333:     } else if ((ioiRequest & IOI_FDD_REQUEST) != 0) {  //FDDの割り込み要求が1のとき
   334:       ioiInService = IOI_FDD_REQUEST;  //FDDの割り込み処理中を1にする
   335:       vector = ioiVector | IOI_FDD_VECTOR;  //FDDの割り込みベクタを返す
   336:     } else if ((ioiRequest & IOI_HDC_REQUEST) != 0) {  //HDCの割り込み要求が1のとき
   337:       ioiInService = IOI_HDC_REQUEST;  //HDCの割り込み処理中を1にする
   338:       vector = ioiVector | IOI_HDC_VECTOR;  //HDCの割り込みベクタを返す
   339:     } else if ((ioiRequest & IOI_PRN_REQUEST) != 0) {  //PRNの割り込み要求が1のとき
   340:       ioiInService = IOI_PRN_REQUEST;  //PRNの割り込み処理中を1にする
   341:       vector = ioiVector | IOI_PRN_VECTOR;  //PRNの割り込みベクタを返す
   342:     }
   343:     if (IOI_DEBUG_TRACE) {
   344:       System.out.printf ("\tioiInService=0x%04x\n", ioiInService);
   345:     }
   346:     if (true) {
   347:       ioiRequest &= ~ioiInService;  //割り込み要求を0にする
   348:       if (IOI_DEBUG_TRACE) {
   349:         System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   350:       }
   351:     }
   352:     if (IOI_DEBUG_TRACE) {
   353:       System.out.printf ("\tvector=0x%02x\n", vector);
   354:     }
   355:     return vector;
   356:   }  //ioiAcknowledge()
   357: 
   358:   //ioiDone ()
   359:   //  MPUが割り込み処理を終了したときに呼び出す
   360:   //  まだ処理されていない割り込みが残っていたら再度割り込み要求を出す
   361:   public static void ioiDone () {
   362:     if (IOI_DEBUG_TRACE) {
   363:       System.out.printf ("%08x ioiDone()\n", XEiJ.regPC0);
   364:     }
   365:     if (false) {
   366:       ioiRequest &= ~ioiInService;  //割り込み要求を0にする
   367:       if (IOI_DEBUG_TRACE) {
   368:         System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   369:       }
   370:     }
   371:     ioiInService = 0;  //割り込み処理中を0にする
   372:     if (IOI_DEBUG_TRACE) {
   373:       System.out.printf ("\tioiInService=0x%04x\n", ioiInService);
   374:     }
   375:     if (ioiRequest != 0) {  //割り込み要求が1のデバイスが残っている
   376:       XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;  //再度MPUに割り込みを要求する
   377:     }
   378:   }  //ioiDone()
   379: 
   380:   //d = ioiReadStatus ()
   381:   //  リードステータスレジスタ
   382:   //  0x00e9c001
   383:   public static int ioiReadStatus () {
   384:     if (IOI_DEBUG_TRACE) {
   385:       System.out.printf ("%08x ioiReadStatus()\n", XEiJ.regPC0);
   386:     }
   387:     int d = (ioiSignal | ioiEnable) & 255;
   388:     if (IOI_DEBUG_TRACE) {
   389:       System.out.printf ("\tstatus=0x%02x\n", d);
   390:     }
   391:     return d;
   392:   }  //ioiReadStatus()
   393: 
   394:   //d = ioiReadVector ()
   395:   //  リードベクタレジスタ
   396:   //  0x00e9c003
   397:   public static int ioiReadVector () {
   398:     if (IOI_DEBUG_TRACE) {
   399:       System.out.printf ("%08x ioiReadVector()\n", XEiJ.regPC0);
   400:     }
   401:     int d = ioiVector;
   402:     if (IOI_DEBUG_TRACE) {
   403:       System.out.printf ("\tvector=0x%02x\n", d);
   404:     }
   405:     return d;
   406:   }  //ioiReadVector()
   407: 
   408:   //ioiWriteEnable (d)
   409:   //  ライトイネーブルレジスタ
   410:   //  0x00e9c001
   411:   public static void ioiWriteEnable (int d) {
   412:     if (IOI_DEBUG_TRACE) {
   413:       System.out.printf ("%08x ioiWriteEnable(0x%02x)\n", XEiJ.regPC0, d & 255);
   414:     }
   415:     int enable = ioiEnable & ~0x0f | d & 0x0f;
   416:     int falled = ioiEnable & ~enable;  //1=1→0
   417:     int raised = ~ioiEnable & enable;  //1=0→1
   418:     ioiEnable = enable;
   419:     if (IOI_DEBUG_TRACE) {
   420:       System.out.printf ("\tioiEnable=0x%04x\n", ioiEnable);
   421:     }
   422:     int request = ioiRequest;
   423:     if ((falled & IOI_FDC_REQUEST) != 0) {
   424:       request &= ~IOI_FDC_REQUEST;
   425:     } else if ((raised & IOI_FDC_REQUEST) != 0 && (ioiSignal & IOI_FDC_SIGNAL) != 0) {
   426:       request |= IOI_FDC_REQUEST;
   427:     }
   428:     if ((falled & IOI_FDD_REQUEST) != 0) {
   429:       request &= ~IOI_FDD_REQUEST;
   430:     } else if ((raised & IOI_FDD_REQUEST) != 0 && (ioiSignal & IOI_FDD_SIGNAL) != 0) {
   431:       request |= IOI_FDD_REQUEST;
   432:     }
   433:     if ((falled & IOI_HDC_REQUEST) != 0) {
   434:       request &= ~IOI_HDC_REQUEST;
   435:     } else if ((raised & IOI_HDC_REQUEST) != 0 && (ioiSignal & IOI_HDC_SIGNAL) != 0) {
   436:       request |= IOI_HDC_REQUEST;
   437:     }
   438:     if ((falled & IOI_PRN_REQUEST) != 0) {
   439:       request &= ~IOI_PRN_REQUEST;
   440:     } else if ((raised & IOI_PRN_REQUEST) != 0 && (ioiSignal & IOI_PRN_SIGNAL) != 0) {
   441:       request |= IOI_PRN_REQUEST;
   442:     }
   443:     if (ioiRequest != request) {
   444:       ioiRequest = request;  //ここで割り込み要求が増えないことはない
   445:       if (IOI_DEBUG_TRACE) {
   446:         System.out.printf ("\tioiRequest=0x%04x\n", ioiRequest);
   447:       }
   448:       XEiJ.mpuIRR |= XEiJ.MPU_IOI_INTERRUPT_MASK;
   449:     }
   450:   }  //ioiWriteEnable(int)
   451: 
   452:   //ioiWriteVector (d)
   453:   //  ライトベクタレジスタ
   454:   //  0x00e9c003
   455:   //  割り込みベクタを設定する
   456:   public static void ioiWriteVector (int d) {
   457:     if (IOI_DEBUG_TRACE) {
   458:       System.out.printf ("%08x ioiWriteVector(0x%02x)\n", XEiJ.regPC0, d & 255);
   459:     }
   460:     ioiVector = d & 0xfc;
   461:     if (IOI_DEBUG_TRACE) {
   462:       System.out.printf ("\tioiVector=0x%02x\n", ioiVector);
   463:     }
   464:   }  //ioiWriteVector(int)
   465: 
   466: }  //class IOInterrupt