source/src/vm/fm7/fm7_mainio.h

   1 /*
   2  * FM-7 Main I/O [fm7_mainio.h]
   3  *
   4  * Author: K.Ohta <whatisthis.sowhat _at_ gmail.com>
   5  * License: GPLv2
   6  * History:
   7  *   Jan 03, 2015 : Initial
   8  *
   9  */
  10
  11 #ifndef _VM_FM7_MAINIO_H_
  12 #define _VM_FM7_MAINIO_H_
  13
  14 #include "../device.h"
  15 #include "../mc6809.h"
  16 #include "../z80.h"
  17 #include "../ym2203.h"
  18 #include "../datarec.h"
  19
  20 #include "fm7_common.h"
  21 #include "./joystick.h"
  22
  23
  24 class MB8877;
  25 #if defined(HAS_DMA)
  26 class HD6844;
  27 #endif
  28
  29 class FM7_MAINIO : public DEVICE {
  30  private:
  31         bool opn_psg_77av;
  32         bool beep_flag;
  33         bool beep_snd;
  34         int event_beep;
  35         int event_beep_oneshot;
  36         int event_timerirq;
  37         int event_fdc_motor;
  38         outputs_t clock_status;
  39         outputs_t printer_reset_bus;
  40         outputs_t printer_strobe_bus;
  41         outputs_t printer_select_bus;
  42  protected:
  43         VM* p_vm;
  44         EMU* p_emu;
  45
  46         //bool irqstat_bak;
  47         //bool firqstat_bak;
  48         uint8 io_w_latch[0x100];
  49
  50         /* FD00: R */
  51         bool clock_fast; // bit0 : maybe dummy
  52         uint16 keycode_7;
  53         /* FD00: W */
  54         bool lpt_strobe;  // bit6 : maybe dummy entry
  55         bool lpt_slctin;  // bit7 : maybe dummy entry
  56         /* FD01: W */
  57         uint8 lpt_outdata; // maybe dummy.
  58
  59         /* FD02 : R */
  60         bool cmt_indat;     // bit7 : Data of casette.
  61         bool cmt_invert;    // Invert signal
  62         bool lpt_det2;      // bit5 : DET2(Normally high).
  63         bool lpt_det1;      // bit4 : DET1(Normally high).
  64         bool lpt_pe;        // bit3 : PAPER EMPTY.
  65         bool lpt_ackng_inv; // bit2 : ACK
  66         bool lpt_error_inv; // bit1 : ERROR
  67         bool lpt_busy;      // bit0 : BUSY.
  68
  69         int lpt_type;
  70         /* FD02 : W */
  71         uint8 irqmask_reg0; // bit7-4, bit2-0 , '1' is enable.  '0' is disable.
  72         // 7-4 :  RS232C / SYNDET,RXRDY,TXRDY,MFD
  73         // 2 : TIMER
  74         // 1 : PRINTER
  75         // 0 : KEYBOARD
  76         bool irqmask_syndet;   // bit7: "0" = mask.
  77         bool irqmask_rxrdy;    // bit6: "0" = mask.
  78         bool irqmask_txrdy;    // bit5: "0" = mask.
  79         bool irqmask_mfd;      // bit4: "0" = mask.
  80         bool irqmask_timer;    // bit2: "0" = mask.
  81         bool irqmask_printer;  // bit1: "0" = mask.
  82         bool irqmask_keyboard; // bit0: "0" = mask.
  83
  84         /* FD03: R */
  85         uint8_t irqstat_reg0; // bit 3-0, '0' is happened, '1' is not happened.
  86         // bit3 : extended interrupt
  87         // bit2-0: Same as FD02 : W .
  88         /* FD03 : W , '1' = ON*/
  89         bool irqstat_timer;
  90         bool irqstat_printer;
  91         bool irqstat_keyboard;
  92
  93         bool irqreq_printer;
  94         bool irqreq_keyboard;
  95
  96         /* FD04 : R */
  97 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
  98         defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
  99         bool stat_kanjirom;    //  R/W : bit5, '0' = sub, '1' = main. FM-77 Only.
 100         bool stat_400linemode; // R/W : bit3, '0' = 400line, '1' = 200line.
 101 #elif defined(_FM77_VARIANTS)
 102         bool stat_fdmode_2hd; //  R/W : bit6, '0' = 2HD, '1' = 2DD. FM-77 Only.
 103         bool stat_kanjirom;    //  R/W : bit5, '0' = sub, '1' = main. FM-77 Only.
 104         bool stat_400linecard;//  R/W : bit4, '0' = connected. FM-77 Only.
 105         //bool stat_400linemode; // R/W : bit3, '0' = 400line, '1' = 200line.
 106 #endif
 107         bool firq_break_key; // bit1, ON = '0'.
 108         bool firq_sub_attention; // bit0, ON = '0'.
 109         /* FD04 : W */
 110         bool intmode_fdc; // bit2, '0' = normal, '1' = SFD.
 111 #if defined(_FM77AV_VARIANTS)
 112         bool hotreset;
 113 #endif
 114         /* FD05 : R */
 115         bool extdet_neg; // bit0 : '1' = none , '0' = exists.
 116         bool sub_busy;
 117         /* FD05 : W */
 118         bool sub_halt; // bit7 : '1' Halt req.
 119         bool sub_cancel; // bit6 : '1' Cancel req.
 120         bool sub_halt_bak; // bit7 : shadow.
 121         bool sub_cancel_bak; // bit6 : shadow.
 122 #if defined(WITH_Z80)
 123         bool z80_sel;    // bit0 : '1' = Z80. Maybe only FM-7/77.
 124 #endif
 125         /* FD06 : R/W : RS-232C */
 126         /* FD07 : R/W : RS-232C */
 127         bool intstat_syndet;
 128         bool intstat_rxrdy;
 129         bool intstat_txrdy;
 130         bool irqreq_syndet;
 131         bool irqreq_rxrdy;
 132         bool irqreq_txrdy;      /* FD08 : Grafic pen, not implemented */
 133         /* FD09 : Grafic pen, not implemented */
 134         /* FD0A : Grafic pen, not implemented */
 135         /* FD0B : R */
 136         uint32_t bootmode;
 137         /* FD0D : W */
 138         /* FD0E : R */
 139
 140         /* FD0F : R/W */
 141         bool stat_romrammode; // R(true) = ROM, W(false) = RAM.
 142 #if defined(_FM77AV_VARIANTS)
 143         /* FD12 : R/W*/
 144         uint8 reg_fd12;
 145         /* FD13 : WO */
 146         uint8 sub_monitor_type; // bit 2 - 0: default = 0.
 147         uint8 sub_monitor_bak; // bit 2 - 0: default = 0.
 148 #endif
 149
 150         /* FD15 / FD46 / FD51 : W */
 151 #if defined(_FM8)
 152         bool connect_psg; // [0]
 153 #else
 154         bool connect_opn; // [0]
 155         bool connect_whg; // [1]
 156         bool connect_thg; // [2]
 157 #endif
 158         uint32 opn_address[4];
 159         uint32 opn_data[4];
 160         uint32 opn_stat[4];
 161         uint8  opn_cmdreg[4]; // OPN register, bit 3-0, maybe dummy.
 162         uint8  opn_ch3mode[4];
 163
 164         /* FD47 */
 165         bool intstat_whg;   // bit3 : OPN interrupt. '0' = happened.
 166         /* FD53 */
 167         bool intstat_thg;   // bit3 : OPN interrupt. '0' = happened.
 168
 169
 170         /* FD17 : R */
 171         bool intstat_opn;   // bit3 : OPN interrupt. '0' = happened.
 172         bool intstat_mouse; // bit2 : Mouse interrupt (not OPN-Mouse?), '0' = happened.
 173         /* FD17 : W */
 174         bool mouse_enable; // bit2 : '1' = enable.
 175
 176         /* FD18 : R */
 177         bool connect_fdc;
 178         uint8_t fdc_statreg;
 179         /* FD18 : W */
 180         uint8_t fdc_cmdreg;
 181         bool fdc_cmd_type1;
 182
 183         /* FD19 : R/W */
 184         uint8_t fdc_trackreg;
 185
 186         /* FD1A : R/W */
 187         uint8_t fdc_sectreg;
 188
 189         /* FD1B : R/W */
 190         uint8_t fdc_datareg;
 191
 192         /* FD1C : R/W */
 193         uint8_t fdc_headreg; // bit0, '0' = side0, '1' = side1
 194
 195         /* FD1D : R/W */
 196         bool fdc_motor; // bit7 : '1' = ON, '0' = OFF
 197         uint8_t fdc_drvsel; // bit 1-0
 198 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)|| \
 199     defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
 200         //bool fdc_2dd;
 201         // FD1E
 202         uint8_t fdc_drive_table[4];
 203         uint8_t fdc_reg_fd1e;
 204 #endif
 205         /* FD1F : R */
 206         uint8_t irqreg_fdc;
 207         bool irqstat_fdc;
 208         bool irqreq_fdc;
 209
 210         /* FD20,FD21 : W */
 211         bool connect_kanjiroml1;
 212 #ifdef _FM77AV_VARIANTS
 213         bool connect_kanjiroml2;
 214 #endif
 215         /* FD20, FD21 : R */
 216
 217         /* FD37 : W */
 218 #if defined(_FM77_VARIANTS) || defined(_FM77AV_VARIANTS)
 219         /* FD93: bit0 */
 220         bool boot_ram;
 221         /* FD10: bit1 */
 222         bool enable_initiator;
 223 #endif
 224 #if defined(HAS_DMA)
 225         bool intstat_dma;
 226         uint32 dma_addr;
 227 #endif
 228         void set_clockmode(uint8 flags);
 229         uint8 get_clockmode(void);
 230         void set_cmt_motor(uint8 flag);
 231         bool get_cmt_motor(void);
 232
 233         virtual uint8 get_port_fd00(void);
 234         virtual void  set_port_fd00(uint8 data);
 235         virtual uint8 get_port_fd02(void);
 236         virtual void set_port_fd02(uint8 val);
 237         virtual uint8 get_irqstat_fd03(void);
 238         virtual uint8 get_extirq_fd17(void);
 239         virtual void set_ext_fd17(uint8 data);
 240
 241         void set_beep(uint32 data); // fd03
 242         void reset_sound(void);
 243         void reset_printer(void);
 244
 245         void reset_fdc(void);
 246         void set_fdc_motor(bool flag);
 247
 248         void do_irq(void);
 249         void set_irq_syndet(bool flag);
 250         void set_irq_rxrdy(bool flag);
 251         void set_irq_txrdy(bool flag);
 252
 253         void set_irq_timer(bool flag);
 254         void set_irq_printer(bool flag);
 255         void set_irq_keyboard(bool flag);
 256         void set_irq_opn(bool flag);
 257         void set_irq_mfd(bool flag);
 258         void set_drq_mfd(bool flag);
 259
 260         // FD04
 261         void do_firq(void);
 262         void do_nmi(bool flag);
 263
 264         void set_break_key(bool pressed);
 265         void set_sub_attention(bool flag);
 266
 267         uint8_t get_fd04(void);
 268         void  set_fd04(uint8_t val);
 269         uint8_t get_fd05(void);
 270         void  set_fd05(uint8_t val);
 271
 272         virtual void set_extdet(bool flag);
 273         // FD0D
 274         void set_psg(uint8_t val);
 275         uint8_t get_psg(void);
 276         // FD0E
 277         void set_psg_cmd(uint8_t cmd);
 278
 279         void write_fd0f(void);
 280         uint8_t read_fd0f(void);
 281         bool get_rommode_fd0f(void);
 282 #if defined(_FM77AV_VARIANTS)
 283         // FD12
 284         uint8_t subsystem_read_status(void);
 285 #endif
 286         // OPN
 287         void opn_note_on(int index);
 288         void set_opn(int index, uint8_t val);
 289         uint8_t get_opn(int index);
 290         void set_opn_cmd(int index, uint8_t cmd);
 291         void write_opn_reg(int index, uint32_t addr, uint32_t data);
 292
 293         uint8_t get_extirq_whg(void);
 294         uint8_t get_extirq_thg(void);
 295
 296         void write_kanjiaddr_lo(uint8_t addr);
 297         void write_kanjiaddr_hi(uint8_t addr);
 298         uint8_t read_kanjidata_left(void);
 299         uint8_t read_kanjidata_right(void);
 300 #if defined(CAPABLE_KANJI_CLASS2)
 301         void write_kanjiaddr_lo_l2(uint8_t addr);
 302         void write_kanjiaddr_hi_l2(uint8_t addr);
 303         uint8_t read_kanjidata_left_l2(void);
 304         uint8_t read_kanjidata_right_l2(void);
 305 #endif
 306           // FDC
 307         uint8_t get_fdc_fd1c(void);
 308         void set_fdc_fd1c(uint8_t val);
 309         void set_fdc_fd1d(uint8_t val);
 310
 311         uint8_t get_fdc_fd1e(void);
 312         void set_fdc_fd1e(uint8_t val);
 313
 314         uint8_t get_fdc_stat(void);
 315         void set_fdc_cmd(uint8_t val);
 316         uint8_t fdc_getdrqirq(void);
 317
 318         virtual void set_fdc_track(uint8_t val);
 319         virtual uint8_t get_fdc_track(void);
 320
 321         uint8_t get_fdc_motor(void);
 322         void set_fdc_sector(uint8_t val);
 323         uint8_t get_fdc_sector(void);
 324
 325         void set_fdc_data(uint8_t val);
 326         uint8_t get_fdc_data(void);
 327
 328         void set_fdc_misc(uint8_t val);
 329         uint8_t get_fdc_misc(void);
 330         /* Signal Handlers */
 331         void set_beep_oneshot(void);
 332
 333         /* Event Handlers */
 334         void event_beep_off(void);
 335         void event_beep_cycle(void);
 336         /* Devices */
 337 #if defined(_FM8)
 338         YM2203* opn[1]; // Optional PSG.
 339 #else
 340         YM2203* opn[4]; // 0=OPN 1=WHG 2=THG 3=PSG
 341 #endif
 342         DATAREC* drec;
 343         DEVICE* pcm1bit;
 344         DEVICE* joystick;
 345
 346         //DEVICE* beep;
 347         MB8877* fdc;
 348 #if defined(HAS_DMA)
 349         HD6844* dmac;
 350 #endif
 351         DEVICE *printer;
 352         //FM7_RS232C *rs232c;
 353         /* */
 354         DEVICE *kanjiclass1;
 355         DEVICE *kanjiclass2;
 356         DEVICE *display;
 357         DEVICE *keyboard;
 358         MC6809 *maincpu;
 359         DEVICE *mainmem;
 360         MC6809 *subcpu;
 361 #ifdef WITH_Z80
 362         Z80 *z80;
 363 #endif
 364  public:
 365         FM7_MAINIO(VM* parent_vm, EMU* parent_emu);
 366         ~FM7_MAINIO();
 367         void event_vline(int v, int clock);
 368
 369         uint8  opn_regs[4][0x100];
 370         uint32 read_io8(uint32 addr); // This is only for debug.
 371
 372         void initialize();
 373
 374         void write_data8(uint32 addr, uint32 data);
 375         void write_dma_data8(uint32 addr, uint32 data);
 376         void write_dma_io8(uint32 addr, uint32 data);
 377
 378         uint32 read_data8(uint32 addr);
 379         uint32 read_dma_data8(uint32 addr);
 380         uint32 read_dma_io8(uint32 addr);
 381
 382         void write_signal(int id, uint32 data, uint32 mask);
 383         uint32 read_signal(int id);
 384
 385         void event_callback(int event_id, int err);
 386         void reset();
 387         void update_config();
 388         void save_state(FILEIO *state_fio);
 389         bool load_state(FILEIO *state_fio);
 390         const _TCHAR *get_device_name(void)
 391         {
 392                 return _T("FM7_MAIN_IO");
 393         }
 394
 395         void set_context_printer(DEVICE *p)
 396         {
 397                 printer = p;
 398         }
 399         void set_context_kanjirom_class1(DEVICE *p)
 400         {
 401                 kanjiclass1 = p;
 402                 if(p != NULL) connect_kanjiroml1 = true;
 403         }
 404         void set_context_kanjirom_class2(DEVICE *p)
 405         {
 406 #if defined(_FM77AV_VARIANTS)
 407                 kanjiclass2 = p;
 408                 if(p != NULL) connect_kanjiroml2 = true;
 409 #endif
 410         }
 411         void set_context_beep(DEVICE *p)
 412         {
 413                 pcm1bit = p;
 414                 //beep = p;
 415         }
 416         void set_context_datarec(DATAREC *p)
 417         {
 418                 drec = p;
 419         }
 420 #if !defined(_FM8)
 421         void set_context_opn(YM2203 *p, int ch)
 422         {
 423                 if((ch < 0) || (ch > 2)) return;
 424                 if(p != NULL) {
 425                         switch(ch) {
 426                                 case 0:
 427                                         connect_opn = true;
 428                                         break;
 429                                 case 1:
 430                                         connect_whg = true;
 431                                         break;
 432                                 case 2:
 433                                         connect_thg = true;
 434                                         break;
 435                         }
 436                 }
 437                 opn[ch] = p;
 438                 extdet_neg = true;
 439         }
 440 #endif
 441 #if !defined(_FM77AV_VARIANTS)
 442         void set_context_psg(YM2203 *p)
 443         {
 444 # if defined(_FM8)
 445                 opn[0] = p;
 446                 connect_psg = true;
 447 # else
 448                 opn[3] = p;
 449 # endif
 450         }
 451 #endif
 452         void set_context_fdc(MB8877 *p){
 453                 if(p == NULL) {
 454                         connect_fdc = false;
 455                 } else {
 456                         connect_fdc = true;
 457                 }
 458                 if(connect_fdc) {
 459                         extdet_neg = true;
 460                 }
 461                 emu->out_debug_log(_T("FDC: connect=%d"), connect_fdc);
 462                 fdc = p;
 463         }
 464         void set_context_maincpu(MC6809 *p){
 465                 maincpu = p;
 466         }
 467         void set_context_mainmem(DEVICE *p){
 468                 mainmem = p;
 469         }
 470         void set_context_subcpu(MC6809 *p){
 471                 subcpu = p;
 472         }
 473         void set_context_display(DEVICE *p){
 474                 display = p;
 475         }
 476         void set_context_keyboard(DEVICE *p){
 477                 keyboard = p;
 478         }
 479         void set_context_joystick(DEVICE *p){
 480                 joystick = p;
 481         }
 482         void set_context_clock_status(DEVICE *p, int id, uint32_t mask) {
 483                 register_output_signal(&clock_status, p, id, mask);
 484         }
 485         void set_context_printer_reset(DEVICE *p, int id, uint32_t mask) {
 486                 register_output_signal(&printer_reset_bus, p, id, mask);
 487         }
 488         void set_context_z80cpu(Z80 *p){
 489 #ifdef WITH_Z80
 490                 z80 = p;
 491 #endif
 492         }
 493 #if defined(HAS_DMA)
 494         void set_context_dmac(HD6844 *p){
 495                 dmac = p;
 496         }
 497 #endif
 498 };
 499 #endif