source/src/vm/fmtowns/towns_crtc.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Kyuma Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2016.12.28 -
   6
   7         [ FM-Towns CRTC ]
   8         History: 2016.12.28 Initial from HD46505 .
   9 */
  10
  11 #include "towns_crtc.h"
  12
  13 enum {
  14         EVENT_CRTC_VSTART = 0,
  15         EVENT_CRTC_VST1   = 2,
  16         EVENT_CRTC_VST2   = 4,
  17         EVENT_CRTC_VDS    = 6,
  18         EVENT_CRTC_VDE    = 8,
  19         EVENT_CRTC_HSTART = 10,
  20         EVENT_CRTC_HEND   = 12,
  21         EVENT_CRTC_HSW    = 14,
  22 };
  23
  24
  25 void TOWNS_CRTC::initialize()
  26 {
  27         memset(regs, 0, sizeof(regs));
  28         memset(regs_written, 0, sizeof(regs_written));
  29
  30         line_count[0] = line_count[1] = 0;
  31         for(int i = 0; i < TOWNS_CRTC_MAX_LINES; i++) {
  32                 line_changed[0][i] = true;
  33                 line_changed[1][i] = true;
  34         }
  35         event_id_hsync = -1;
  36         event_id_hsw = -1;
  37         event_id_vsync = -1;
  38         event_id_vstart = -1;
  39         event_id_vst1 = -1;
  40         event_id_vst2 = -1;
  41         event_id_vblank = -1;
  42
  43         // register events
  44         //register_frame_event(this);
  45         //register_vline_event(this);
  46
  47 }
  48
  49 void TOWNS_CRTC::reset()
  50 {
  51         // initialize
  52         display = false;
  53         vblank = vsync = hsync = true;
  54
  55 //      memset(regs, 0, sizeof(regs));
  56         ch = 0;
  57
  58         // initial settings for 1st frame
  59 #ifdef CHARS_PER_LINE
  60         hz_total = (CHARS_PER_LINE > 54) ? CHARS_PER_LINE : 54;
  61 #else
  62         hz_total = 54;
  63 #endif
  64         hz_disp = (hz_total > 80) ? 80 : 40;
  65         hs_start = hz_disp + 4;
  66         hs_end = hs_start + 4;
  67
  68         vt_total = LINES_PER_FRAME;
  69         vt_disp = (SCREEN_HEIGHT > LINES_PER_FRAME) ? (SCREEN_HEIGHT >> 1) : SCREEN_HEIGHT;
  70         vs_start = vt_disp + 16;
  71         vs_end = vs_start + 16;
  72
  73         timing_changed = false;
  74         disp_end_clock = 0;
  75
  76 #if defined(TOWNS_CRTC_CHAR_CLOCK)
  77         char_clock = 0;
  78         next_char_clock = TOWNS_CRTC_CHAR_CLOCK;
  79 #elif defined(TOWNS_CRTC_HORIZ_FREQ)
  80         horiz_freq = 0;
  81         next_horiz_freq = TOWNS_CRTC_HORIZ_FREQ;
  82 #endif
  83
  84         line_count[0] = line_count[1] = 0;
  85         for(int i = 0; i < TOWNS_CRTC_MAX_LINES; i++) {
  86                 line_changed[0][i] = true;
  87                 line_rendered[0][i] = false;
  88                 line_changed[1][i] = true;
  89                 line_rendered[1][i] = false;
  90         }
  91         if(event_id_hsync  >= 0) cancel_event(this, event_id_hsync);
  92         if(event_id_hsw    >= 0) cancel_event(this, event_id_hsw);
  93         if(event_id_vsync  >= 0) cancel_event(this, event_id_vsync);
  94         if(event_id_vstart >= 0) cancel_event(this, event_id_vstart);
  95         if(event_id_vst1   >= 0) cancel_event(this, event_id_vst1);
  96         if(event_id_vst2   >= 0) cancel_event(this, event_id_vst2);
  97         if(event_id_vblank >= 0) cancel_event(this, event_id_vblank);
  98
  99         event_id_hsw = -1;
 100         event_id_vsync = -1;
 101         event_id_vstart = -1;
 102         event_id_vst1 = -1;
 103         event_id_vst2 = -1;
 104         event_id_vblank = -1;
 105
 106         // Register vstart
 107         register_event(this, EVENT_CRTC_VSTART, vstart_us, false, &event_id_vstart);
 108 }
 109 // CRTC register #29
 110 void TOWNS_CRTC::set_crtc_clock(uint16_t val)
 111 {
 112         scsel = (val & 0x0c) >> 2;
 113         clksel = val & 0x03;
 114         const double clocks[] = {
 115                 28.6363e6, 24.5454e6, 25.175e6, 21.0525e6
 116         };
 117         if(crtc_clock[clksel] != crtc_clock) {
 118                 crtc_clock = crtc_clock[clksel];
 119                 force_recalc_crtc_param(-1);
 120         }
 121 }
 122
 123 void TOWNS_CRTC::set_crtc_hsw1(void)
 124 {
 125         int val = (int)(regs[ch + TOWNS_CRTC_REG_HSW1] & 0x0fff);
 126         horiz_width_posi_us = horiz_us * (double)val;
 127         // Update
 128 }
 129 void TOWNS_CRTC::set_crtc_hsw2(void)
 130 {
 131         int val = (int)(regs[TOWNS_CRTC_REG_HSW2] & 0x0fff);
 132         horiz_width_nega_us = horiz_us * (double)val;
 133         // Update
 134 }
 135
 136 void TOWNS_CRTC::set_crtc_hst(void)
 137 {
 138         int val = (int)(regs[TOWNS_CRTC_REG_HST] & 0x07ff) | 1;
 139         next_horiz_us = (double)(val + 1) * 1.0 / crtc_clock;
 140         // Update
 141 }
 142
 143 void TOWNS_CRTC::set_crtc_vst1(void)
 144 {
 145         int val = (int)regs[TOWNS_CRTC_REG_VST1];
 146         vert_sync_pre_us = ((double)val * horiz_us) / 2.0;
 147 }
 148
 149 void TOWNS_CRTC::set_crtc_vst2(void)
 150 {
 151         int val = (int)regs[TOWNS_CRTC_REG_VST2];
 152         vert_sync_end_us = ((double)val * horiz_us) / 2.0;
 153 }
 154
 155 void TOWNS_CRTC::set_crtc_vst2(void)
 156 {
 157         int val = (int)regs[TOWNS_CRTC_REG_VST];
 158         next_vert_us = ((double)val * horiz_us) / 2.0;
 159 }
 160
 161 void TOWNS_CRTC::write_io8(uint32_t addr, uint32_t data)
 162 {
 163         if(addr & 1) {
 164                 if(ch < 32) {
 165                         if(ch < 16 && regs[ch] != data) {
 166                                 timing_changed = true;
 167                         }
 168                         regs[ch] = data;
 169                         regs_written[ch] = true;
 170                 }
 171         } else {
 172                 ch = data;
 173         }
 174 }
 175
 176 uint32_t TOWNS_CRTC::read_io8(uint32_t addr)
 177 {
 178         if(addr & 1) {
 179                 return (12 <= ch && ch < 18) ? regs[ch] : 0xff;
 180         } else {
 181                 return ch;
 182         }
 183 }
 184
 185
 186 void TOWNS_CRTC::event_pre_frame()
 187 {
 188         if(timing_changed) {
 189                 if(regs_written[0] && regs_written[1] && regs_written[2] && regs_written[3] && regs_written[4] && regs_written[5] && regs_written[6] && regs_written[7] && regs_written[9]) {
 190                         int ch_height = (regs[9] & 0x1f) + 1;
 191
 192                         hz_total = regs[0] + 1;
 193                         hz_disp = regs[1];
 194                         hs_start = regs[2];
 195                         hs_end = hs_start + (regs[3] & 0x0f);
 196
 197                         int new_vt_total = ((regs[4] & 0x7f) + 1) * ch_height + (regs[5] & 0x1f);
 198                         vt_disp = (regs[6] & 0x7f) * ch_height;
 199                         vs_start = ((regs[7] & 0x7f) + 1) * ch_height;
 200                         vs_end = vs_start + ((regs[3] & 0xf0) ? (regs[3] >> 4) : 16);
 201
 202                         if(vt_total != new_vt_total) {
 203                                 vt_total = new_vt_total;
 204                                 set_lines_per_frame(vt_total);
 205                         }
 206                         timing_changed = false;
 207                         disp_end_clock = 0;
 208 #if defined(TOWNS_CRTC_CHAR_CLOCK)
 209                         char_clock = 0;
 210 #elif defined(TOWNS_CRTC_HORIZ_FREQ)
 211                         horiz_freq = 0;
 212 #endif
 213                 }
 214         }
 215 #if defined(TOWNS_CRTC_CHAR_CLOCK)
 216         if(char_clock != next_char_clock) {
 217                 char_clock = next_char_clock;
 218                 frames_per_sec = char_clock / (double)vt_total / (double)hz_total;
 219                 if(regs[8] & 1) {
 220                         frames_per_sec *= 2; // interlace mode
 221                 }
 222                 set_frames_per_sec(frames_per_sec);
 223         }
 224 #elif defined(TOWNS_CRTC_HORIZ_FREQ)
 225         if(horiz_freq != next_horiz_freq) {
 226                 horiz_freq = next_horiz_freq;
 227                 frames_per_sec = horiz_freq / (double)vt_total;
 228                 if(regs[8] & 1) {
 229                         frames_per_sec *= 2; // interlace mode
 230                 }
 231                 set_frames_per_sec(frames_per_sec);
 232         }
 233 #endif
 234 }
 235
 236 void TOWNS_CRTC::update_timing(int new_clocks, double new_frames_per_sec, int new_lines_per_frame)
 237 {
 238         cpu_clocks = new_clocks;
 239 #if !defined(TOWNS_CRTC_CHAR_CLOCK) && !defined(TOWNS_CRTC_HORIZ_FREQ)
 240         frames_per_sec = new_frames_per_sec;
 241 #endif
 242
 243         // update event clocks
 244         disp_end_clock = 0;
 245 }
 246
 247 void TOWNS_CRTC::event_callback(int event_id, int err)
 248 {
 249         /*
 250          * Related CRTC registers:
 251          * HST, HSW1, HSW2 : HSYNC
 252          * VST, VST1, VST2 : VSYNC
 253          * (EET: for interlace : still not implement)
 254          * VDS0, VDE0, HDS0, HDE0 : Display timing for Layer0
 255          * VDS1, VDE1, HDS1, HDE1 : Display timing for Layer1
 256          * FA0, HAJ0, LO0, FO0  : ToDo (For calculating address)
 257          * FA1, HAJ1, LO1, FO1  : ToDo (For calculating address)
 258          * ZOOM (#27) : ToDo
 259          */
 260         int eid2 = (event_id / 2) * 2;
 261         if(eid2 == EVENT_CRTC_VSTART) {
 262                 line_count[0] = line_count[1] = 0;
 263                 if((horiz_us != next_horiz_us) || (vert_us != next_vert_us)) {
 264                         horiz_us = next_horiz_us;
 265                         vert_us = next_vert_us;
 266                         force_recalc_crtc_param(-1);
 267                         if(event_id_vsync >= 0) cancel_event(this, event_id_vsync);
 268                         if(event_id_hsw >= 0) cancel_event(this, event_id_hsw);
 269
 270                         register_event(this, EVENT_CRTC_HSTART + 0, vert_sync_pre_us, false, &event_id_hsw); // HSW = HSYNC
 271                         register_event(this, EVENT_CRTC_VSTART + 0, vert_us, true, &event_id_vsync); // VST
 272                 }
 273                 frame_in[0] = frame_in[1] = false;
 274                 line_count[0] = line_count[1] = 0;
 275                 line_count_mod[0] = line_count_mod[1] = 0;
 276                 hsync = false;
 277                 hdisp = false;
 278                 vdisp = true;
 279                 vblank = true;
 280                 vsync = false;
 281                 major_line_count = -1;
 282                 register_event(this, EVENT_CRTC_VST1 + 0, vert_sync_pre_us, false, &event_id_vstn); // VST1
 283                 register_event(this, EVENT_CRTC_VDS + 0, vert_start_us[0], false, &event_id_vstart[0]); // VDS0 : Layer1
 284                 register_event(this, EVENT_CRTC_VDS + 1, vert_start_us[1], false, &event_id_vstart[1]); // VDS1 : Layer2
 285         } else if(eid2 == EVENT_CRTC_VST1) {
 286                 vsync = true;
 287                 if(vert_sync_end_us > 0.0) {
 288                         register_event(this, EVENT_CRTC_VST2 + 0, vert_sync_end_us, false, &event_id_vstn); // VST2 - VST1.
 289                 } else {
 290                         vsync = false;
 291                 }
 292         } else if (eid2 == EVENT_CRTC_VST2) {
 293                 vsync = false;
 294                 vblank = false;
 295                 event_id_vstn = -1;
 296         } else if(eid2 == EVENT_CRTC_VDS) { // Display start
 297                 int layer = event_id & 1;
 298                 frame_in[layer] = true;
 299                 // DO ofset line?
 300                 if(event_id_vend[layer] >= 0) cancel_event(this, event_id_vend[layer]);
 301                 register_event(this, EVENT_CRTC_VDE + layer, vert_start_us[0], false, &event_id_vend[layer]); // VDEx
 302                 event_id_vstart[layer] = -1;
 303         } else if(eid2 == EVENT_CRTC_VDE) { // Display end
 304                 int layer = event_id & 1;
 305                 frame_in[layer] = false;
 306                 if(event_id_vstart[layer] >= 0) cancel_event(this, event_id_vstart[layer]);
 307                 event_id_vstart[layer] = -1;
 308                 event_id_vend[layer] = -1;
 309                 // DO ofset line?
 310         } else if(eid2 == EVENT_CRTC_HSTART) {
 311                 // Do render
 312                 hsync = true;
 313                 hdisp = false;
 314                 major_line_count++;
 315                 if(vsync) { // in VSYNC. Not Display.
 316                         if(event_id_hswn >= 0) cancel_event(this, event_id_hswn);
 317                         register_event(this, EVENT_CRTC_HSW + 0, hsw2_us, false, &event_id_hswn); // Indicate HSYNC
 318                 } else { // Not in VSYNC. May be displaied.
 319                         for(layer = 0; layer < 2; layer++) {
 320                                 if(frame_in[layer] && (major_line_count >= 0) && (major_line_count < TOWNS_CRTC_MAX_LINES)) {
 321                                         if((vstart_lines[layer] <= major_line_count) && (vend_lines[layer] => major_line_count)) {
 322                                                 // Proccessing zooming by ZOOM register(reg #27).
 323                                                 {
 324                                                         // If zoom is not supported by hardware, if first line : render.
 325                                                         // Not first: copy (put here?)
 326                                                 } // else {
 327                                                 if(line_changed[layer][line_count[layer]]) {
 328                                                         {
 329                                                                 // Do rendering.
 330                                                                 line_changed[layer][line_count[layer]] = false;
 331                                                                 line_rendered[layer][line_count[layer]] = true;
 332                                                         }
 333                                                 }
 334                                         }
 335                                         {
 336                                                 // If zoom by hardware
 337                                                 line_count_mod[layer] += line_count_factor[layer]; // line_count_factor[n] = 2048 / VZOOM_FACTOR[01]
 338                                                 if(line_count_mod[layer] >= 2048) {
 339                                                         line_count[layer]++;
 340                                                         line_count_mod[layer] -= 2048;
 341                                                 }
 342                                         }
 343                                 }
 344                         }
 345                         if(event_id_hswn >= 0) cancel_event(this, event_id_hswn);
 346                         register_event(this, EVENT_CRTC_HSW + 0, hsw1_us, false, &event_id_hswn); // Indicate HSYNC
 347                 }
 348         } else if(eid2 == EVENT_CRTC_HSW) {
 349                 if(!vsync) {
 350                         hdisp = true;
 351                 }
 352                 hsync = false;
 353         }
 354
 355 }
 356
 357 void TOWNS_CRTC::set_display(bool val)
 358 {
 359         if(display != val) {
 360                 write_signals(&outputs_disp, val ? 0xffffffff : 0);
 361                 display = val;
 362         }
 363 }
 364
 365 void TOWNS_CRTC::set_vblank(bool val)
 366 {
 367         if(vblank != val) {
 368                 write_signals(&outputs_vblank, val ? 0xffffffff : 0);
 369                 vblank = val;
 370         }
 371 }
 372
 373
 374
 375 #define STATE_VERSION   1
 376
 377 void TOWNS_CRTC::save_state(FILEIO* state_fio)
 378 {
 379         state_fio->FputUint32(STATE_VERSION);
 380         state_fio->FputInt32(this_device_id);
 381         state_fio->Fwrite(regs, sizeof(regs), 1);
 382         state_fio->Fwrite(regs_written, sizeof(regs_written), 1);
 383         state_fio->FputInt32(ch);
 384         state_fio->FputBool(timing_changed);
 385         state_fio->FputInt32(cpu_clocks);
 386 #if defined(TOWNS_CRTC_CHAR_CLOCK)
 387         state_fio->FputDouble(char_clock);
 388         state_fio->FputDouble(next_char_clock);
 389 #elif defined(TOWNS_CRTC_HORIZ_FREQ)
 390         state_fio->FputDouble(horiz_freq);
 391         state_fio->FputDouble(next_horiz_freq);
 392 #endif
 393         state_fio->FputDouble(frames_per_sec);
 394         state_fio->FputInt32(hz_total);
 395         state_fio->FputInt32(hz_disp);
 396         state_fio->FputInt32(hs_start);
 397         state_fio->FputInt32(hs_end);
 398         state_fio->FputInt32(vt_total);
 399         state_fio->FputInt32(vt_disp);
 400         state_fio->FputInt32(vs_start);
 401         state_fio->FputInt32(vs_end);
 402         state_fio->FputInt32(disp_end_clock);
 403         state_fio->FputInt32(hs_start_clock);
 404         state_fio->FputInt32(hs_end_clock);
 405         state_fio->FputBool(display);
 406         state_fio->FputBool(vblank);
 407         state_fio->FputBool(vsync);
 408         state_fio->FputBool(hsync);
 409 }
 410
 411 bool TOWNS_CRTC::load_state(FILEIO* state_fio)
 412 {
 413         if(state_fio->FgetUint32() != STATE_VERSION) {
 414                 return false;
 415         }
 416         if(state_fio->FgetInt32() != this_device_id) {
 417                 return false;
 418         }
 419         state_fio->Fread(regs, sizeof(regs), 1);
 420         state_fio->Fread(regs_written, sizeof(regs_written), 1);
 421         ch = state_fio->FgetInt32();
 422         timing_changed = state_fio->FgetBool();
 423         cpu_clocks = state_fio->FgetInt32();
 424 #if defined(TOWNS_CRTC_CHAR_CLOCK)
 425         char_clock = state_fio->FgetDouble();
 426         next_char_clock = state_fio->FgetDouble();
 427 #elif defined(TOWNS_CRTC_HORIZ_FREQ)
 428         horiz_freq = state_fio->FgetDouble();
 429         next_horiz_freq = state_fio->FgetDouble();
 430 #endif
 431         frames_per_sec = state_fio->FgetDouble();
 432         hz_total = state_fio->FgetInt32();
 433         hz_disp = state_fio->FgetInt32();
 434         hs_start = state_fio->FgetInt32();
 435         hs_end = state_fio->FgetInt32();
 436         vt_total = state_fio->FgetInt32();
 437         vt_disp = state_fio->FgetInt32();
 438         vs_start = state_fio->FgetInt32();
 439         vs_end = state_fio->FgetInt32();
 440         disp_end_clock = state_fio->FgetInt32();
 441         hs_start_clock = state_fio->FgetInt32();
 442         hs_end_clock = state_fio->FgetInt32();
 443         display = state_fio->FgetBool();
 444         vblank = state_fio->FgetBool();
 445         vsync = state_fio->FgetBool();
 446         hsync = state_fio->FgetBool();
 447
 448         return true;
 449 }