pico/32x/pwm.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
  10 static int pwm_cycles;
  11 static int pwm_mult;
  12 static int pwm_ptr;
  13 static int pwm_irq_reload;
  14
  15 static int timer_cycles[2];
  16 static int timer_tick_cycles[2];
  17
  18 // timers. This includes PWM timer in 32x and internal SH2 timers
  19 void p32x_timers_recalc(void)
  20 {
  21   int control = Pico32x.regs[0x30 / 2];
  22   int cycles = Pico32x.regs[0x32 / 2];
  23   int tmp, i;
  24
  25   cycles = (cycles - 1) & 0x0fff;
  26   pwm_cycles = cycles;
  27   pwm_mult = 0x10000 / cycles;
  28
  29   pwm_irq_reload = (control & 0x0f00) >> 8;
  30   pwm_irq_reload = ((pwm_irq_reload - 1) & 0x0f) + 1;
  31
  32   if (Pico32x.pwm_irq_cnt == 0)
  33     Pico32x.pwm_irq_cnt = pwm_irq_reload;
  34
  35   // SH2 timer step
  36   for (i = 0; i < 2; i++) {
  37     tmp = PREG8(Pico32xMem->sh2_peri_regs[i], 0x80) & 7;
  38     // Sclk cycles per timer tick
  39     if (tmp)
  40       cycles = 0x20 << tmp;
  41     else
  42       cycles = 2;
  43     timer_tick_cycles[i] = cycles;
  44     elprintf(EL_32X, "WDT cycles[%d] = %d", i, cycles);
  45   }
  46 }
  47
  48 static void do_pwm_irq(unsigned int m68k_cycles)
  49 {
  50   Pico32x.sh2irqs |= P32XI_PWM;
  51   p32x_update_irls(NULL);
  52
  53   if (Pico32x.regs[0x30 / 2] & P32XP_RTP) {
  54     p32x_event_schedule(m68k_cycles, P32X_EVENT_PWM, pwm_cycles / 3 + 1);
  55     // note: might recurse
  56     p32x_dreq1_trigger();
  57   }
  58 }
  59
  60 #define consume_fifo(m68k_cycles) { \
  61   int cycles_diff = ((m68k_cycles) * 3) - Pico32x.pwm_cycle_p; \
  62   if (cycles_diff >= pwm_cycles) \
  63     consume_fifo_do(m68k_cycles, cycles_diff); \
  64 }
  65
  66 static void consume_fifo_do(unsigned int m68k_cycles, int sh2_cycles_diff)
  67 {
  68   int do_irq = 0;
  69
  70   if (pwm_cycles == 0)
  71     return;
  72
  73   elprintf(EL_PWM, "pwm: %u: consume %d/%d, %d,%d ptr %d",
  74     m68k_cycles, sh2_cycles_diff, sh2_cycles_diff / pwm_cycles,
  75     Pico32x.pwm_p[0], Pico32x.pwm_p[1], pwm_ptr);
  76
  77   if (sh2_cycles_diff >= pwm_cycles * 17) {
  78     // silence/skip
  79     Pico32x.pwm_cycle_p = m68k_cycles * 3;
  80     Pico32x.pwm_p[0] = Pico32x.pwm_p[1] = 0;
  81     return;
  82   }
  83
  84   while (sh2_cycles_diff >= pwm_cycles) {
  85     struct Pico32xMem *mem = Pico32xMem;
  86     short *fifo_l = mem->pwm_fifo[0];
  87     short *fifo_r = mem->pwm_fifo[1];
  88
  89     if (Pico32x.pwm_p[0] > 0) {
  90       fifo_l[0] = fifo_l[1];
  91       fifo_l[1] = fifo_l[2];
  92       fifo_l[2] = fifo_l[3];
  93       Pico32x.pwm_p[0]--;
  94     }
  95     if (Pico32x.pwm_p[1] > 0) {
  96       fifo_r[0] = fifo_r[1];
  97       fifo_r[1] = fifo_r[2];
  98       fifo_r[2] = fifo_r[3];
  99       Pico32x.pwm_p[1]--;
 100     }
 101
 102     mem->pwm[pwm_ptr * 2    ] = fifo_l[0];
 103     mem->pwm[pwm_ptr * 2 + 1] = fifo_r[0];
 104     pwm_ptr = (pwm_ptr + 1) & (PWM_BUFF_LEN - 1);
 105
 106     sh2_cycles_diff -= pwm_cycles;
 107
 108     if (--Pico32x.pwm_irq_cnt == 0) {
 109       Pico32x.pwm_irq_cnt = pwm_irq_reload;
 110       // irq also does dreq1, so call it after cycle update
 111       do_irq = 1;
 112       break;
 113     }
 114   }
 115   Pico32x.pwm_cycle_p = m68k_cycles * 3 - sh2_cycles_diff;
 116
 117   if (do_irq)
 118     do_pwm_irq(m68k_cycles);
 119 }
 120
 121 void p32x_timers_do(unsigned int m68k_now, unsigned int m68k_slice)
 122 {
 123   unsigned int cycles = m68k_slice * 3;
 124   int cnt, i;
 125
 126   //consume_fifo(m68k_now);
 127
 128   // WDT timers
 129   for (i = 0; i < 2; i++) {
 130     void *pregs = Pico32xMem->sh2_peri_regs[i];
 131     if (PREG8(pregs, 0x80) & 0x20) { // TME
 132       timer_cycles[i] += cycles;
 133       cnt = PREG8(pregs, 0x81);
 134       while (timer_cycles[i] >= timer_tick_cycles[i]) {
 135         timer_cycles[i] -= timer_tick_cycles[i];
 136         cnt++;
 137       }
 138       if (cnt >= 0x100) {
 139         int level = PREG8(pregs, 0xe3) >> 4;
 140         int vector = PREG8(pregs, 0xe4) & 0x7f;
 141         elprintf(EL_32X, "%csh2 WDT irq (%d, %d)",
 142           i ? 's' : 'm', level, vector);
 143         sh2_internal_irq(&sh2s[i], level, vector);
 144         cnt &= 0xff;
 145       }
 146       PREG8(pregs, 0x81) = cnt;
 147     }
 148   }
 149 }
 150
 151 static int p32x_pwm_schedule_(unsigned int m68k_now)
 152 {
 153   unsigned int sh2_now = m68k_now * 3;
 154   int cycles_diff_sh2;
 155
 156   if (pwm_cycles == 0)
 157     return 0;
 158
 159   cycles_diff_sh2 = sh2_now - Pico32x.pwm_cycle_p;
 160   if (cycles_diff_sh2 >= pwm_cycles)
 161     consume_fifo_do(m68k_now, cycles_diff_sh2);
 162
 163   if (Pico32x.sh2irqs & P32XI_PWM)
 164     return 0; // previous not acked
 165   if (!((Pico32x.sh2irq_mask[0] | Pico32x.sh2irq_mask[1]) & 1))
 166     return 0; // masked by everyone
 167
 168   cycles_diff_sh2 = sh2_now - Pico32x.pwm_cycle_p;
 169   return (Pico32x.pwm_irq_cnt * pwm_cycles
 170            - cycles_diff_sh2) / 3 + 1;
 171 }
 172
 173 void p32x_pwm_schedule(unsigned int m68k_now)
 174 {
 175   int after = p32x_pwm_schedule_(m68k_now);
 176   if (after != 0)
 177     p32x_event_schedule(m68k_now, P32X_EVENT_PWM, after);
 178 }
 179
 180 void p32x_pwm_schedule_sh2(SH2 *sh2)
 181 {
 182   int after = p32x_pwm_schedule_(sh2_cycles_done_m68k(sh2));
 183   if (after != 0)
 184     p32x_event_schedule_sh2(sh2, P32X_EVENT_PWM, after);
 185 }
 186
 187 void p32x_pwm_irq_event(unsigned int m68k_now)
 188 {
 189   p32x_pwm_schedule(m68k_now);
 190 }
 191
 192 unsigned int p32x_pwm_read16(unsigned int a, unsigned int m68k_cycles)
 193 {
 194   unsigned int d = 0;
 195
 196   consume_fifo(m68k_cycles);
 197
 198   a &= 0x0e;
 199   switch (a) {
 200     case 0: // control
 201     case 2: // cycle
 202       d = Pico32x.regs[(0x30 + a) / 2];
 203       break;
 204
 205     case 4: // L ch
 206       if (Pico32x.pwm_p[0] == 3)
 207         d |= P32XP_FULL;
 208       else if (Pico32x.pwm_p[0] == 0)
 209         d |= P32XP_EMPTY;
 210       break;
 211
 212     case 6: // R ch
 213     case 8: // MONO
 214       if (Pico32x.pwm_p[1] == 3)
 215         d |= P32XP_FULL;
 216       else if (Pico32x.pwm_p[1] == 0)
 217         d |= P32XP_EMPTY;
 218       break;
 219   }
 220
 221   elprintf(EL_PWM, "pwm: %u: r16 %02x %04x (p %d %d)",
 222     m68k_cycles, a, d, Pico32x.pwm_p[0], Pico32x.pwm_p[1]);
 223   return d;
 224 }
 225
 226 void p32x_pwm_write16(unsigned int a, unsigned int d,
 227   unsigned int m68k_cycles)
 228 {
 229   elprintf(EL_PWM, "pwm: %u: w16 %02x %04x (p %d %d)",
 230     m68k_cycles, a & 0x0e, d, Pico32x.pwm_p[0], Pico32x.pwm_p[1]);
 231
 232   consume_fifo(m68k_cycles);
 233
 234   a &= 0x0e;
 235   if (a == 0) { // control
 236     // supposedly we should stop FIFO when xMd is 0,
 237     // but mars test disagrees
 238     Pico32x.regs[0x30 / 2] = d;
 239     p32x_timers_recalc();
 240     Pico32x.pwm_irq_cnt = pwm_irq_reload; // ?
 241   }
 242   else if (a == 2) { // cycle
 243     Pico32x.regs[0x32 / 2] = d & 0x0fff;
 244     p32x_timers_recalc();
 245   }
 246   else if (a <= 8) {
 247     d = (d - 1) & 0x0fff;
 248     if (d > pwm_cycles)
 249       d = pwm_cycles;
 250     d = (d - pwm_cycles / 2) * pwm_mult;
 251
 252     if (a == 4 || a == 8) { // L ch or MONO
 253       short *fifo = Pico32xMem->pwm_fifo[0];
 254       if (Pico32x.pwm_p[0] < 3)
 255         Pico32x.pwm_p[0]++;
 256       else {
 257         fifo[1] = fifo[2];
 258         fifo[2] = fifo[3];
 259       }
 260       fifo[Pico32x.pwm_p[0]] = d;
 261     }
 262     if (a == 6 || a == 8) { // R ch or MONO
 263       short *fifo = Pico32xMem->pwm_fifo[1];
 264       if (Pico32x.pwm_p[1] < 3)
 265         Pico32x.pwm_p[1]++;
 266       else {
 267         fifo[1] = fifo[2];
 268         fifo[2] = fifo[3];
 269       }
 270       fifo[Pico32x.pwm_p[1]] = d;
 271     }
 272   }
 273 }
 274
 275 void p32x_pwm_update(int *buf32, int length, int stereo)
 276 {
 277   short *pwmb;
 278   int step;
 279   int p = 0;
 280   int xmd;
 281
 282   xmd = Pico32x.regs[0x30 / 2] & 0x0f;
 283   if ((xmd != 0x05 && xmd != 0x0a) || pwm_ptr <= 16)
 284     goto out;
 285
 286   step = (pwm_ptr << 16) / length; // FIXME: division..
 287   pwmb = Pico32xMem->pwm;
 288
 289   if (stereo)
 290   {
 291     if (xmd == 0x0a) {
 292       // channel swap
 293       while (length-- > 0) {
 294         *buf32++ += pwmb[1];
 295         *buf32++ += pwmb[0];
 296
 297         p += step;
 298         pwmb += (p >> 16) * 2;
 299         p &= 0xffff;
 300       }
 301     }
 302     else {
 303       while (length-- > 0) {
 304         *buf32++ += pwmb[0];
 305         *buf32++ += pwmb[1];
 306
 307         p += step;
 308         pwmb += (p >> 16) * 2;
 309         p &= 0xffff;
 310       }
 311     }
 312   }
 313   else
 314   {
 315     while (length-- > 0) {
 316       *buf32++ += pwmb[0];
 317
 318       p += step;
 319       pwmb += (p >> 16) * 2;
 320       p &= 0xffff;
 321     }
 322   }
 323
 324   elprintf(EL_PWM, "pwm_update: pwm_ptr %d, len %d, step %04x, done %d",
 325     pwm_ptr, length, step, (pwmb - Pico32xMem->pwm) / 2);
 326
 327 out:
 328   pwm_ptr = 0;
 329 }
 330
 331 void p32x_pwm_state_loaded(void)
 332 {
 333   int cycles_diff_sh2;
 334
 335   p32x_timers_recalc();
 336
 337   // for old savestates
 338   cycles_diff_sh2 = SekCycleCntT * 3 - Pico32x.pwm_cycle_p;
 339   if (cycles_diff_sh2 >= pwm_cycles || cycles_diff_sh2 < 0) {
 340     Pico32x.pwm_irq_cnt = pwm_irq_reload;
 341     Pico32x.pwm_cycle_p = SekCycleCntT * 3;
 342     p32x_pwm_schedule(SekCycleCntT);
 343   }
 344 }
 345
 346 // vim:shiftwidth=2:ts=2:expandtab