pico/32x/32x.c

   1 /*
   2  * PicoDrive
   3  * (C) notaz, 2009,2010,2013
   4  *
   5  * This work is licensed under the terms of MAME license.
   6  * See COPYING file in the top-level directory.
   7  */
   8 #include "../pico_int.h"
   9 #include "../sound/ym2612.h"
  10 #include "../../cpu/sh2/compiler.h"
  11
  12 struct Pico32x Pico32x;
  13 SH2 sh2s[2];
  14
  15 #define SH2_IDLE_STATES (SH2_STATE_CPOLL|SH2_STATE_VPOLL|SH2_STATE_SLEEP)
  16
  17 static int REGPARM(2) sh2_irq_cb(SH2 *sh2, int level)
  18 {
  19   if (sh2->pending_irl > sh2->pending_int_irq) {
  20     elprintf_sh2(sh2, EL_32X, "ack/irl %d @ %08x",
  21       level, sh2_pc(sh2));
  22     return 64 + sh2->pending_irl / 2;
  23   } else {
  24     elprintf_sh2(sh2, EL_32X, "ack/int %d/%d @ %08x",
  25       level, sh2->pending_int_vector, sh2_pc(sh2));
  26     sh2->pending_int_irq = 0; // auto-clear
  27     sh2->pending_level = sh2->pending_irl;
  28     return sh2->pending_int_vector;
  29   }
  30 }
  31
  32 // MUST specify active_sh2 when called from sh2 memhandlers
  33 void p32x_update_irls(SH2 *active_sh2, int m68k_cycles)
  34 {
  35   int irqs, mlvl = 0, slvl = 0;
  36   int mrun, srun;
  37
  38   if (active_sh2 != NULL)
  39     m68k_cycles = sh2_cycles_done_m68k(active_sh2);
  40
  41   // msh2
  42   irqs = Pico32x.sh2irqs | Pico32x.sh2irqi[0];
  43   while ((irqs >>= 1))
  44     mlvl++;
  45   mlvl *= 2;
  46
  47   // ssh2
  48   irqs = Pico32x.sh2irqs | Pico32x.sh2irqi[1];
  49   while ((irqs >>= 1))
  50     slvl++;
  51   slvl *= 2;
  52
  53   mrun = sh2_irl_irq(&msh2, mlvl, active_sh2 == &msh2);
  54   if (mrun) {
  55     p32x_sh2_poll_event(&msh2, SH2_IDLE_STATES, m68k_cycles);
  56     if (active_sh2 == &msh2)
  57       sh2_end_run(active_sh2, 1);
  58   }
  59
  60   srun = sh2_irl_irq(&ssh2, slvl, active_sh2 == &ssh2);
  61   if (srun) {
  62     p32x_sh2_poll_event(&ssh2, SH2_IDLE_STATES, m68k_cycles);
  63     if (active_sh2 == &ssh2)
  64       sh2_end_run(active_sh2, 1);
  65   }
  66
  67   elprintf(EL_32X, "update_irls: m %d/%d, s %d/%d", mlvl, mrun, slvl, srun);
  68 }
  69
  70 // the mask register is inconsistent, CMD is supposed to be a mask,
  71 // while others are actually irq trigger enables?
  72 // TODO: test on hw..
  73 void p32x_trigger_irq(SH2 *sh2, int m68k_cycles, unsigned int mask)
  74 {
  75   Pico32x.sh2irqs |= mask & P32XI_VRES;
  76   Pico32x.sh2irqi[0] |= mask & (Pico32x.sh2irq_mask[0] << 3);
  77   Pico32x.sh2irqi[1] |= mask & (Pico32x.sh2irq_mask[1] << 3);
  78
  79   p32x_update_irls(sh2, m68k_cycles);
  80 }
  81
  82 void p32x_update_cmd_irq(SH2 *sh2, int m68k_cycles)
  83 {
  84   if ((Pico32x.sh2irq_mask[0] & 2) && (Pico32x.regs[2 / 2] & 1))
  85     Pico32x.sh2irqi[0] |= P32XI_CMD;
  86   else
  87     Pico32x.sh2irqi[0] &= ~P32XI_CMD;
  88
  89   if ((Pico32x.sh2irq_mask[1] & 2) && (Pico32x.regs[2 / 2] & 2))
  90     Pico32x.sh2irqi[1] |= P32XI_CMD;
  91   else
  92     Pico32x.sh2irqi[1] &= ~P32XI_CMD;
  93
  94   p32x_update_irls(sh2, m68k_cycles);
  95 }
  96
  97 void Pico32xStartup(void)
  98 {
  99   elprintf(EL_STATUS|EL_32X, "32X startup");
 100
 101   // TODO: OOM handling
 102   PicoAHW |= PAHW_32X;
 103   sh2_init(&msh2, 0, &ssh2);
 104   msh2.irq_callback = sh2_irq_cb;
 105   sh2_init(&ssh2, 1, &msh2);
 106   ssh2.irq_callback = sh2_irq_cb;
 107
 108   PicoMemSetup32x();
 109   p32x_pwm_ctl_changed();
 110   p32x_timers_recalc();
 111
 112   Pico32x.sh2_regs[0] = P32XS2_ADEN;
 113   if (Pico.m.ncart_in)
 114     Pico32x.sh2_regs[0] |= P32XS_nCART;
 115
 116   if (!Pico.m.pal)
 117     Pico32x.vdp_regs[0] |= P32XV_nPAL;
 118
 119   rendstatus_old = -1;
 120
 121   emu_32x_startup();
 122 }
 123
 124 #define HWSWAP(x) (((x) << 16) | ((x) >> 16))
 125 void p32x_reset_sh2s(void)
 126 {
 127   elprintf(EL_32X, "sh2 reset");
 128
 129   sh2_reset(&msh2);
 130   sh2_reset(&ssh2);
 131   sh2_peripheral_reset(&msh2);
 132   sh2_peripheral_reset(&ssh2);
 133
 134   // if we don't have BIOS set, perform it's work here.
 135   // MSH2
 136   if (p32x_bios_m == NULL) {
 137     unsigned int idl_src, idl_dst, idl_size; // initial data load
 138     unsigned int vbr;
 139
 140     // initial data
 141     idl_src = HWSWAP(*(unsigned int *)(Pico.rom + 0x3d4)) & ~0xf0000000;
 142     idl_dst = HWSWAP(*(unsigned int *)(Pico.rom + 0x3d8)) & ~0xf0000000;
 143     idl_size= HWSWAP(*(unsigned int *)(Pico.rom + 0x3dc));
 144     if (idl_size > Pico.romsize || idl_src + idl_size > Pico.romsize ||
 145         idl_size > 0x40000 || idl_dst + idl_size > 0x40000 || (idl_src & 3) || (idl_dst & 3)) {
 146       elprintf(EL_STATUS|EL_ANOMALY, "32x: invalid initial data ptrs: %06x -> %06x, %06x",
 147         idl_src, idl_dst, idl_size);
 148     }
 149     else
 150       memcpy(Pico32xMem->sdram + idl_dst, Pico.rom + idl_src, idl_size);
 151
 152     // GBR/VBR
 153     vbr = HWSWAP(*(unsigned int *)(Pico.rom + 0x3e8));
 154     sh2_set_gbr(0, 0x20004000);
 155     sh2_set_vbr(0, vbr);
 156
 157     // checksum and M_OK
 158     Pico32x.regs[0x28 / 2] = *(unsigned short *)(Pico.rom + 0x18e);
 159     // program will set M_OK
 160   }
 161
 162   // SSH2
 163   if (p32x_bios_s == NULL) {
 164     unsigned int vbr;
 165
 166     // GBR/VBR
 167     vbr = HWSWAP(*(unsigned int *)(Pico.rom + 0x3ec));
 168     sh2_set_gbr(1, 0x20004000);
 169     sh2_set_vbr(1, vbr);
 170     // program will set S_OK
 171   }
 172
 173   msh2.m68krcycles_done = ssh2.m68krcycles_done = SekCyclesDone();
 174 }
 175
 176 void Pico32xInit(void)
 177 {
 178   if (msh2.mult_m68k_to_sh2 == 0 || msh2.mult_sh2_to_m68k == 0)
 179     Pico32xSetClocks(PICO_MSH2_HZ, 0);
 180   if (ssh2.mult_m68k_to_sh2 == 0 || ssh2.mult_sh2_to_m68k == 0)
 181     Pico32xSetClocks(0, PICO_MSH2_HZ);
 182 }
 183
 184 void PicoPower32x(void)
 185 {
 186   memset(&Pico32x, 0, sizeof(Pico32x));
 187
 188   Pico32x.regs[0] = P32XS_REN|P32XS_nRES; // verified
 189   Pico32x.vdp_regs[0x0a/2] = P32XV_VBLK|P32XV_PEN;
 190 }
 191
 192 void PicoUnload32x(void)
 193 {
 194   if (Pico32xMem != NULL)
 195     plat_munmap(Pico32xMem, sizeof(*Pico32xMem));
 196   Pico32xMem = NULL;
 197   sh2_finish(&msh2);
 198   sh2_finish(&ssh2);
 199
 200   PicoAHW &= ~PAHW_32X;
 201 }
 202
 203 void PicoReset32x(void)
 204 {
 205   if (PicoAHW & PAHW_32X) {
 206     msh2.m68krcycles_done = ssh2.m68krcycles_done = SekCyclesDone();
 207     p32x_trigger_irq(NULL, SekCyclesDone(), P32XI_VRES);
 208     p32x_sh2_poll_event(&msh2, SH2_IDLE_STATES, 0);
 209     p32x_sh2_poll_event(&ssh2, SH2_IDLE_STATES, 0);
 210     p32x_pwm_ctl_changed();
 211     p32x_timers_recalc();
 212   }
 213 }
 214
 215 static void p32x_start_blank(void)
 216 {
 217   if (Pico32xDrawMode != PDM32X_OFF && !PicoSkipFrame) {
 218     int offs, lines;
 219
 220     pprof_start(draw);
 221
 222     offs = 8; lines = 224;
 223     if ((Pico.video.reg[1] & 8) && !(PicoOpt & POPT_ALT_RENDERER)) {
 224       offs = 0;
 225       lines = 240;
 226     }
 227
 228     // XXX: no proper handling of 32col mode..
 229     if ((Pico32x.vdp_regs[0] & P32XV_Mx) != 0 && // 32x not blanking
 230         (Pico.video.reg[12] & 1) && // 40col mode
 231         (PicoDrawMask & PDRAW_32X_ON))
 232     {
 233       int md_bg = Pico.video.reg[7] & 0x3f;
 234
 235       // we draw full layer (not line-by-line)
 236       PicoDraw32xLayer(offs, lines, md_bg);
 237     }
 238     else if (Pico32xDrawMode != PDM32X_32X_ONLY)
 239       PicoDraw32xLayerMdOnly(offs, lines);
 240
 241     pprof_end(draw);
 242   }
 243
 244   // enter vblank
 245   Pico32x.vdp_regs[0x0a/2] |= P32XV_VBLK|P32XV_PEN;
 246
 247   // FB swap waits until vblank
 248   if ((Pico32x.vdp_regs[0x0a/2] ^ Pico32x.pending_fb) & P32XV_FS) {
 249     Pico32x.vdp_regs[0x0a/2] &= ~P32XV_FS;
 250     Pico32x.vdp_regs[0x0a/2] |= Pico32x.pending_fb;
 251     Pico32xSwapDRAM(Pico32x.pending_fb ^ 1);
 252   }
 253
 254   p32x_trigger_irq(NULL, SekCyclesDone(), P32XI_VINT);
 255   p32x_sh2_poll_event(&msh2, SH2_STATE_VPOLL, 0);
 256   p32x_sh2_poll_event(&ssh2, SH2_STATE_VPOLL, 0);
 257 }
 258
 259 void p32x_schedule_hint(SH2 *sh2, int m68k_cycles)
 260 {
 261   // rather rough, 32x hint is useless in practice
 262   int after;
 263
 264   if (!((Pico32x.sh2irq_mask[0] | Pico32x.sh2irq_mask[1]) & 4))
 265     return; // nobody cares
 266   // note: when Pico.m.scanline is 224, SH2s might
 267   // still be at scanline 93 (or so)
 268   if (!(Pico32x.sh2_regs[0] & 0x80) && Pico.m.scanline > 224)
 269     return;
 270
 271   after = (Pico32x.sh2_regs[4 / 2] + 1) * 488;
 272   if (sh2 != NULL)
 273     p32x_event_schedule_sh2(sh2, P32X_EVENT_HINT, after);
 274   else
 275     p32x_event_schedule(m68k_cycles, P32X_EVENT_HINT, after);
 276 }
 277
 278 /* events */
 279 static void fillend_event(unsigned int now)
 280 {
 281   Pico32x.vdp_regs[0x0a/2] &= ~P32XV_nFEN;
 282   p32x_sh2_poll_event(&msh2, SH2_STATE_VPOLL, now);
 283   p32x_sh2_poll_event(&ssh2, SH2_STATE_VPOLL, now);
 284 }
 285
 286 static void hint_event(unsigned int now)
 287 {
 288   p32x_trigger_irq(NULL, now, P32XI_HINT);
 289   p32x_schedule_hint(NULL, now);
 290 }
 291
 292 typedef void (event_cb)(unsigned int now);
 293
 294 /* times are in m68k (7.6MHz) cycles */
 295 unsigned int p32x_event_times[P32X_EVENT_COUNT];
 296 static unsigned int event_time_next;
 297 static event_cb *p32x_event_cbs[P32X_EVENT_COUNT] = {
 298   [P32X_EVENT_PWM]      = p32x_pwm_irq_event,
 299   [P32X_EVENT_FILLEND]  = fillend_event,
 300   [P32X_EVENT_HINT]     = hint_event,
 301 };
 302
 303 // schedule event at some time 'after', in m68k clocks
 304 void p32x_event_schedule(unsigned int now, enum p32x_event event, int after)
 305 {
 306   unsigned int when;
 307
 308   when = (now + after) | 1;
 309
 310   elprintf(EL_32X, "32x: new event #%u %u->%u", event, now, when);
 311   p32x_event_times[event] = when;
 312
 313   if (event_time_next == 0 || CYCLES_GT(event_time_next, when))
 314     event_time_next = when;
 315 }
 316
 317 void p32x_event_schedule_sh2(SH2 *sh2, enum p32x_event event, int after)
 318 {
 319   unsigned int now = sh2_cycles_done_m68k(sh2);
 320   int left_to_next;
 321
 322   p32x_event_schedule(now, event, after);
 323
 324   left_to_next = (event_time_next - now) * 3;
 325   sh2_end_run(sh2, left_to_next);
 326 }
 327
 328 static void p32x_run_events(unsigned int until)
 329 {
 330   int oldest, oldest_diff, time;
 331   int i, diff;
 332
 333   while (1) {
 334     oldest = -1, oldest_diff = 0x7fffffff;
 335
 336     for (i = 0; i < P32X_EVENT_COUNT; i++) {
 337       if (p32x_event_times[i]) {
 338         diff = p32x_event_times[i] - until;
 339         if (diff < oldest_diff) {
 340           oldest_diff = diff;
 341           oldest = i;
 342         }
 343       }
 344     }
 345
 346     if (oldest_diff <= 0) {
 347       time = p32x_event_times[oldest];
 348       p32x_event_times[oldest] = 0;
 349       elprintf(EL_32X, "32x: run event #%d %u", oldest, time);
 350       p32x_event_cbs[oldest](time);
 351     }
 352     else if (oldest_diff < 0x7fffffff) {
 353       event_time_next = p32x_event_times[oldest];
 354       break;
 355     }
 356     else {
 357       event_time_next = 0;
 358       break;
 359     }
 360   }
 361
 362   if (oldest != -1)
 363     elprintf(EL_32X, "32x: next event #%d at %u",
 364       oldest, event_time_next);
 365 }
 366
 367 static inline void run_sh2(SH2 *sh2, int m68k_cycles)
 368 {
 369   int cycles, done;
 370
 371   pevt_log_sh2_o(sh2, EVT_RUN_START);
 372   sh2->state |= SH2_STATE_RUN;
 373   cycles = C_M68K_TO_SH2(*sh2, m68k_cycles);
 374   elprintf_sh2(sh2, EL_32X, "+run %u %d @%08x",
 375     sh2->m68krcycles_done, cycles, sh2->pc);
 376
 377   done = sh2_execute(sh2, cycles, PicoOpt & POPT_EN_DRC);
 378
 379   sh2->m68krcycles_done += C_SH2_TO_M68K(*sh2, done);
 380   sh2->state &= ~SH2_STATE_RUN;
 381   pevt_log_sh2_o(sh2, EVT_RUN_END);
 382   elprintf_sh2(sh2, EL_32X, "-run %u %d",
 383     sh2->m68krcycles_done, done);
 384 }
 385
 386 // sync other sh2 to this one
 387 // note: recursive call
 388 void p32x_sync_other_sh2(SH2 *sh2, unsigned int m68k_target)
 389 {
 390   SH2 *osh2 = sh2->other_sh2;
 391   int left_to_event;
 392   int m68k_cycles;
 393
 394   if (osh2->state & SH2_STATE_RUN)
 395     return;
 396
 397   m68k_cycles = m68k_target - osh2->m68krcycles_done;
 398   if (m68k_cycles < 200)
 399     return;
 400
 401   if (osh2->state & SH2_IDLE_STATES) {
 402     osh2->m68krcycles_done = m68k_target;
 403     return;
 404   }
 405
 406   elprintf_sh2(osh2, EL_32X, "sync to %u %d",
 407     m68k_target, m68k_cycles);
 408
 409   run_sh2(osh2, m68k_cycles);
 410
 411   // there might be new event to schedule current sh2 to
 412   if (event_time_next) {
 413     left_to_event = event_time_next - m68k_target;
 414     left_to_event *= 3;
 415     if (sh2_cycles_left(sh2) > left_to_event) {
 416       if (left_to_event < 1)
 417         left_to_event = 1;
 418       sh2_end_run(sh2, left_to_event);
 419     }
 420   }
 421 }
 422
 423 #define sync_sh2s_normal p32x_sync_sh2s
 424 //#define sync_sh2s_lockstep p32x_sync_sh2s
 425
 426 /* most timing is in 68k clock */
 427 void sync_sh2s_normal(unsigned int m68k_target)
 428 {
 429   unsigned int now, target, timer_cycles;
 430   int cycles;
 431
 432   elprintf(EL_32X, "sh2 sync to %u", m68k_target);
 433
 434   if (!(Pico32x.regs[0] & P32XS_nRES)) {
 435     msh2.m68krcycles_done = ssh2.m68krcycles_done = m68k_target;
 436     return; // rare
 437   }
 438
 439   now = msh2.m68krcycles_done;
 440   if (CYCLES_GT(now, ssh2.m68krcycles_done))
 441     now = ssh2.m68krcycles_done;
 442   timer_cycles = now;
 443
 444   while (CYCLES_GT(m68k_target, now))
 445   {
 446     if (event_time_next && CYCLES_GE(now, event_time_next))
 447       p32x_run_events(now);
 448
 449     target = m68k_target;
 450     if (event_time_next && CYCLES_GT(target, event_time_next))
 451       target = event_time_next;
 452
 453     while (CYCLES_GT(target, now))
 454     {
 455       elprintf(EL_32X, "sh2 exec to %u %d,%d/%d, flags %x", target,
 456         target - msh2.m68krcycles_done, target - ssh2.m68krcycles_done,
 457         m68k_target - now, Pico32x.emu_flags);
 458
 459       if (!(ssh2.state & SH2_IDLE_STATES)) {
 460         cycles = target - ssh2.m68krcycles_done;
 461         if (cycles > 0) {
 462           run_sh2(&ssh2, cycles);
 463
 464           if (event_time_next && CYCLES_GT(target, event_time_next))
 465             target = event_time_next;
 466         }
 467       }
 468
 469       if (!(msh2.state & SH2_IDLE_STATES)) {
 470         cycles = target - msh2.m68krcycles_done;
 471         if (cycles > 0) {
 472           run_sh2(&msh2, cycles);
 473
 474           if (event_time_next && CYCLES_GT(target, event_time_next))
 475             target = event_time_next;
 476         }
 477       }
 478
 479       now = target;
 480       if (!(msh2.state & SH2_IDLE_STATES)) {
 481         if (CYCLES_GT(now, msh2.m68krcycles_done))
 482           now = msh2.m68krcycles_done;
 483       }
 484       if (!(ssh2.state & SH2_IDLE_STATES)) {
 485         if (CYCLES_GT(now, ssh2.m68krcycles_done))
 486           now = ssh2.m68krcycles_done;
 487       }
 488     }
 489
 490     p32x_timers_do(now - timer_cycles);
 491     timer_cycles = now;
 492   }
 493
 494   // advance idle CPUs
 495   if (msh2.state & SH2_IDLE_STATES) {
 496     if (CYCLES_GT(m68k_target, msh2.m68krcycles_done))
 497       msh2.m68krcycles_done = m68k_target;
 498   }
 499   if (ssh2.state & SH2_IDLE_STATES) {
 500     if (CYCLES_GT(m68k_target, ssh2.m68krcycles_done))
 501       ssh2.m68krcycles_done = m68k_target;
 502   }
 503 }
 504
 505 #define STEP_68K 24
 506
 507 void sync_sh2s_lockstep(unsigned int m68k_target)
 508 {
 509   unsigned int mcycles;
 510
 511   mcycles = msh2.m68krcycles_done;
 512   if (ssh2.m68krcycles_done < mcycles)
 513     mcycles = ssh2.m68krcycles_done;
 514
 515   while (mcycles < m68k_target) {
 516     mcycles += STEP_68K;
 517     sync_sh2s_normal(mcycles);
 518   }
 519 }
 520
 521 #define CPUS_RUN(m68k_cycles) do { \
 522   if (PicoAHW & PAHW_MCD) \
 523     pcd_run_cpus(m68k_cycles); \
 524   else \
 525     SekRunM68k(m68k_cycles); \
 526   \
 527   if ((Pico32x.emu_flags & P32XF_Z80_32X_IO) && Pico.m.z80Run \
 528       && !Pico.m.z80_reset && (PicoOpt & POPT_EN_Z80)) \
 529     PicoSyncZ80(SekCyclesDone()); \
 530   if (Pico32x.emu_flags & (P32XF_68KCPOLL|P32XF_68KVPOLL)) \
 531     p32x_sync_sh2s(SekCyclesDone()); \
 532 } while (0)
 533
 534 #define PICO_32X
 535 #define PICO_CD
 536 #include "../pico_cmn.c"
 537
 538 void PicoFrame32x(void)
 539 {
 540   Pico.m.scanline = 0;
 541
 542   Pico32x.vdp_regs[0x0a/2] &= ~P32XV_VBLK; // get out of vblank
 543   if ((Pico32x.vdp_regs[0] & P32XV_Mx) != 0) // no forced blanking
 544     Pico32x.vdp_regs[0x0a/2] &= ~P32XV_PEN; // no palette access
 545
 546   if (!(Pico32x.sh2_regs[0] & 0x80))
 547     p32x_schedule_hint(NULL, SekCyclesDone());
 548   p32x_sh2_poll_event(&msh2, SH2_STATE_VPOLL, 0);
 549   p32x_sh2_poll_event(&ssh2, SH2_STATE_VPOLL, 0);
 550
 551   PicoFrameStart();
 552   PicoFrameHints();
 553   sh2_drc_frame();
 554
 555   elprintf(EL_32X, "poll: %02x %02x %02x",
 556     Pico32x.emu_flags & 3, msh2.state, ssh2.state);
 557 }
 558
 559 // calculate multipliers against 68k clock (7670442)
 560 // normally * 3, but effectively slower due to high latencies everywhere
 561 // however using something lower breaks MK2 animations
 562 void Pico32xSetClocks(int msh2_hz, int ssh2_hz)
 563 {
 564   float m68k_clk = (float)(OSC_NTSC / 7);
 565   if (msh2_hz > 0) {
 566     msh2.mult_m68k_to_sh2 = (int)((float)msh2_hz * (1 << CYCLE_MULT_SHIFT) / m68k_clk);
 567     msh2.mult_sh2_to_m68k = (int)(m68k_clk * (1 << CYCLE_MULT_SHIFT) / (float)msh2_hz);
 568   }
 569   if (ssh2_hz > 0) {
 570     ssh2.mult_m68k_to_sh2 = (int)((float)ssh2_hz * (1 << CYCLE_MULT_SHIFT) / m68k_clk);
 571     ssh2.mult_sh2_to_m68k = (int)(m68k_clk * (1 << CYCLE_MULT_SHIFT) / (float)ssh2_hz);
 572   }
 573 }
 574
 575 void Pico32xStateLoaded(int is_early)
 576 {
 577   if (is_early) {
 578     Pico32xMemStateLoaded();
 579     return;
 580   }
 581
 582   sh2s[0].m68krcycles_done = sh2s[1].m68krcycles_done = SekCyclesDone();
 583   p32x_update_irls(NULL, SekCyclesDone());
 584   p32x_pwm_state_loaded();
 585   p32x_run_events(SekCyclesDone());
 586 }
 587
 588 // vim:shiftwidth=2:ts=2:expandtab