AT32F435: Reduce sample clock to 72MHz, same as 105/415 build.

It provides plkenty high enough resolution, while reducing risk of
unexpected tick overflows.

Author: keirf

inc/floppy.h

@@ -9,6 +9,13 @@
  * See the file COPYING for more details, or visit <http://unlicense.org>.
  */
 
+#define SAMPLECLK_MHZ 72
+#define sampleclk_ns(x) (((x) * SAMPLECLK_MHZ) / 1000)
+#define sampleclk_us(x) ((x) * SAMPLECLK_MHZ)
+#define sampleclk_ms(x) ((x) * SAMPLECLK_MHZ * 1000)
+#define sampleclk_stk(x) ((x) * (SAMPLECLK_MHZ / STK_MHZ))
+#define stk_sampleclk(x) ((x) / (SAMPLECLK_MHZ / STK_MHZ))
+
 #ifdef QUICKDISK
 #define is_quickdisk TRUE
 #else
@@ -179,7 +186,7 @@ struct image {
 
     /* Info about current track. */
     uint16_t cur_track;
-    uint16_t write_bc_ticks; /* Nr SYSCLK ticks per bitcell in write stream */
+    uint16_t write_bc_ticks; /* SAMPLECLK ticks per bitcell in write stream */
     uint32_t ticks_per_cell; /* Nr 'ticks' per bitcell in read stream. */
     uint32_t tracklen_bc, cur_bc; /* Track length and cursor, in bitcells */
     uint32_t tracklen_ticks; /* Timing of previous revolution, in 'ticks' */
@@ -232,7 +239,7 @@ void image_open(struct image *im, struct slot *slot, DWORD *cltbl);
 void image_extend(struct image *im);
 
 /* Seek to given track and start reading track data at specified rotational
- * position (specified as number of SYSCLK ticks past the index mark).
+ * position (specified as number of SAMPLECLK ticks past the index mark).
  * 
  * If start_pos is NULL then the caller is in write mode and thus is not
  * interested in fetching data from a particular rotational position.
@@ -252,7 +259,7 @@ uint16_t bc_rdata_flux(struct image *im, uint16_t *tbuf, uint16_t nr);
  * was completed for the write at the tail of the pipeline. */
 bool_t image_write_track(struct image *im);
 
-/* Rotational position of last-generated flux (SYSCLK ticks past index). */
+/* Rotational position of last-generated flux (SAMPLECLK ticks past index). */
 uint32_t image_ticks_since_index(struct image *im);
 
 /* MFM conversion. */

src/floppy.c

@@ -327,7 +327,7 @@ void floppy_insert(unsigned int unit, struct slot *slot)
     floppy_mount(slot);
     im = image;
 
-    if (im->write_bc_ticks < sysclk_ns(1500))
+    if (im->write_bc_ticks < sampleclk_ns(1500))
         drive_change_output(drv, outp_hden, TRUE);
 
     timer_dma_init();
@@ -417,8 +417,7 @@ static void floppy_sync_flux(void)
 
         /* If we crossed the index mark while filling the DMA buffer then we
          * need to set up the index pulse (usually done by IRQ_rdata_dma). */
-        if (image_ticks_since_index(drv->image)
-            < (sync_pos*(SYSCLK_MHZ/STK_MHZ))) {
+        if (image_ticks_since_index(drv->image) < sampleclk_stk(sync_pos)) {
 
             /* Sum all flux timings in the DMA buffer. */
             const uint16_t buf_mask = ARRAY_SIZE(dma_rd->buf) - 1;
@@ -430,7 +429,7 @@ static void floppy_sync_flux(void)
             ticks -= image_ticks_since_index(drv->image);
 
             /* Calculate deadline for index timer. */
-            ticks /= SYSCLK_MHZ/TIME_MHZ;
+            ticks /= SAMPLECLK_MHZ/TIME_MHZ;
             timer_set(&index.timer, time_now() + ticks);
         }
 
@@ -472,7 +471,7 @@ static bool_t dma_rd_handle(struct drive *drv)
         read_start_pos %= im->stk_per_rev;
         /* Seek to the new track. */
         track = drive_calc_track(drv);
-        read_start_pos *= SYSCLK_MHZ/STK_MHZ;
+        read_start_pos *= SAMPLECLK_MHZ/STK_MHZ;
         if (in_da_mode(im, track>>1) && (drv->outp & m(outp_wrprot))
             && !volume_readonly()) {
             /* Remove write-protect when driven into D-A mode. */
@@ -481,7 +480,7 @@ static bool_t dma_rd_handle(struct drive *drv)
         if (image_setup_track(im, track, &read_start_pos))
             return TRUE;
         prefetch_start_time = time_now();
-        read_start_pos /= SYSCLK_MHZ/STK_MHZ;
+        read_start_pos /= SAMPLECLK_MHZ/STK_MHZ;
         sync_pos = read_start_pos;
         if (!drv->index_suppressed) {
             /* Set the deadline to match existing index timing. */

src/floppy_generic.c

@@ -251,17 +251,17 @@ static void timer_dma_init(void)
     IRQx_enable(dma_wdata_irq);
 
     /* RDATA Timer setup:
-     * The counter is incremented at full SYSCLK rate. 
+     * The counter is incremented at SAMPLECLK rate. 
      *  
      * Ch.2 (RDATA) is in PWM mode 1. It outputs O_TRUE for 400ns and then 
      * O_FALSE until the counter reloads. By changing the ARR via DMA we alter
      * the time between (fixed-width) O_TRUE pulses, mimicking floppy drive 
      * timings. */
-    tim_rdata->psc = 0;
+    tim_rdata->psc = (SYSCLK_MHZ/SAMPLECLK_MHZ) - 1;
     tim_rdata->ccmr1 = (TIM_CCMR1_CC2S(TIM_CCS_OUTPUT) |
                         TIM_CCMR1_OC2M(TIM_OCM_PWM1));
     tim_rdata->ccer = TIM_CCER_CC2E | ((O_TRUE==0) ? TIM_CCER_CC2P : 0);
-    tim_rdata->ccr2 = sysclk_ns(400);
+    tim_rdata->ccr2 = sampleclk_ns(400);
     tim_rdata->dier = TIM_DIER_UDE;
     tim_rdata->cr2 = 0;
 
@@ -280,13 +280,13 @@ static void timer_dma_init(void)
                      DMA_CCR_EN);
 
     /* WDATA Timer setup: 
-     * The counter runs from 0x0000-0xFFFF inclusive at full SYSCLK rate.
+     * The counter runs from 0x0000-0xFFFF inclusive at SAMPLECLK rate.
      *  
      * Ch.1 (WDATA) is in Input Capture mode, sampling on every clock and with
      * no input prescaling or filtering. Samples are captured on the falling 
      * edge of the input (CCxP=1). DMA is used to copy the sample into a ring
      * buffer for batch processing in the DMA-completion ISR. */
-    tim_wdata->psc = 0;
+    tim_wdata->psc = (SYSCLK_MHZ/SAMPLECLK_MHZ) - 1;
     tim_wdata->arr = 0xffff;
     tim_wdata->ccmr1 = TIM_CCMR1_CC1S(TIM_CCS_INPUT_TI1);
     tim_wdata->dier = TIM_DIER_CC1DE;
@@ -407,10 +407,10 @@ static void wdata_start(void)
     tim_wdata->ccer = TIM_CCER_CC1E | TIM_CCER_CC1P;
     tim_wdata->cr1 = TIM_CR1_CEN;
 
-    /* Find rotational start position of the write, in SYSCLK ticks. */
+    /* Find rotational start position of the write, in SAMPLECLK ticks. */
     start_pos = max_t(int32_t, 0, time_diff(index.prev_time, time_now()));
     start_pos %= drive.image->stk_per_rev;
-    start_pos *= SYSCLK_MHZ / STK_MHZ;
+    start_pos *= SAMPLECLK_MHZ / STK_MHZ;
     write = get_write(image, image->wr_prod);
     write->start = start_pos;
     write->track = drive_calc_track(&drive);
@@ -635,7 +635,7 @@ static void IRQ_rdata_dma(void)
     /* Subtract current flux offset beyond the index. */
     ticks -= image_ticks_since_index(drv->image);
     /* Calculate deadline for index timer. */
-    ticks /= SYSCLK_MHZ/TIME_MHZ;
+    ticks /= SAMPLECLK_MHZ/TIME_MHZ;
     timer_set(&index.timer, now + ticks);
 }
 

src/image/adf.c

@@ -39,7 +39,8 @@ static bool_t adf_open(struct image *im)
     im->nr_sides = 2;
     im->adf.nr_secs = 11;
     im->tracklen_bc = DD_TRACKLEN_BC;
-    im->ticks_per_cell = (sysclk_stk(im->stk_per_rev) * 16u) / im->tracklen_bc;
+    im->ticks_per_cell = ((sampleclk_stk(im->stk_per_rev) * 16u)
+                          / im->tracklen_bc);
 
     im->nr_cyls = f_size(&im->fp) / (2 * 11 * 512);
 
@@ -66,7 +67,7 @@ static void adf_setup_track(
 {
     struct image_buf *rd = &im->bufs.read_data;
     struct image_buf *bc = &im->bufs.read_bc;
-    uint32_t decode_off, sector, sys_ticks = start_pos ? *start_pos : 0;
+    uint32_t decode_off, sector, start_ticks = start_pos ? *start_pos : 0;
 
     if ((im->cur_track ^ track) & ~1) {
         /* New cylinder: Refresh the sector maps (ordered by sector #). */
@@ -78,7 +79,7 @@ static void adf_setup_track(
     im->adf.trk_off = track * im->adf.nr_secs * 512;
     im->cur_track = track;
 
-    im->cur_bc = (sys_ticks * 16) / im->ticks_per_cell;
+    im->cur_bc = (start_ticks * 16) / im->ticks_per_cell;
     if (im->cur_bc >= im->tracklen_bc)
         im->cur_bc = 0;
     im->cur_ticks = im->cur_bc * im->ticks_per_cell;

src/image/da.c

@@ -78,12 +78,12 @@ static void da_seek_track(struct image *im, uint16_t track)
     case DA_SD_FM_CYL:
         dass->nr_sec = 4;
         im->sync = SYNC_fm;
-        im->write_bc_ticks = sysclk_us(4);
+        im->write_bc_ticks = sampleclk_us(4);
         break;
     default:
         dass->nr_sec = 8;
         im->sync = SYNC_mfm;
-        im->write_bc_ticks = sysclk_us(2);
+        im->write_bc_ticks = sampleclk_us(2);
         break;
     }
 
@@ -95,7 +95,7 @@ static void da_setup_track(
 {
     struct image_buf *rd = &im->bufs.read_data;
     struct image_buf *bc = &im->bufs.read_bc;
-    uint32_t decode_off, sys_ticks = start_pos ? *start_pos : 0;
+    uint32_t decode_off, start_ticks = start_pos ? *start_pos : 0;
     unsigned int nsec;
 
     da_seek_track(im, track);
@@ -120,11 +120,11 @@ static void da_setup_track(
     im->tracklen_bc += im->da.idx_sz;
     im->tracklen_bc *= 16;
 
-    im->stk_per_rev = stk_sysclk(im->tracklen_bc * im->write_bc_ticks);
+    im->stk_per_rev = stk_sampleclk(im->tracklen_bc * im->write_bc_ticks);
 
     im->da.trk_sec = 0;
 
-    im->cur_bc = (sys_ticks * 16) / im->ticks_per_cell;
+    im->cur_bc = (start_ticks * 16) / im->ticks_per_cell;
     im->cur_bc &= ~15;
     if (im->cur_bc >= im->tracklen_bc)
         im->cur_bc = 0;
@@ -157,7 +157,7 @@ static void da_setup_track(
     if (start_pos) {
         image_read_track(im);
         bc->cons = decode_off * 16;
-        *start_pos = sys_ticks;
+        *start_pos = start_ticks;
     }
 }
 

src/image/dsk.c

@@ -183,7 +183,7 @@ static void dsk_seek_track(
     im->dsk.gap4 = (im->tracklen_bc - tracklen) / 16;
 
     /* Calculate ticks per revolution */
-    im->stk_per_rev = stk_sysclk(im->tracklen_bc * im->write_bc_ticks);
+    im->stk_per_rev = stk_sampleclk(im->tracklen_bc * im->write_bc_ticks);
 }
 
 static uint32_t calc_start_pos(struct image *im)
@@ -251,7 +251,7 @@ static void dsk_setup_track(
 {
     struct image_buf *rd = &im->bufs.read_data;
     struct image_buf *bc = &im->bufs.read_bc;
-    uint32_t decode_off, sys_ticks = start_pos ? *start_pos : 0;
+    uint32_t decode_off, start_ticks = start_pos ? *start_pos : 0;
     uint8_t cyl = track/2, side = track & (im->nr_sides - 1);
 
     track = cyl*2 + side;
@@ -260,7 +260,7 @@ static void dsk_setup_track(
 
     im->dsk.write_sector = -1;
 
-    im->cur_bc = (sys_ticks * 16) / im->ticks_per_cell;
+    im->cur_bc = (start_ticks * 16) / im->ticks_per_cell;
     im->cur_bc &= ~15;
     if (im->cur_bc >= im->tracklen_bc)
         im->cur_bc = 0;
@@ -275,7 +275,7 @@ static void dsk_setup_track(
     if (start_pos) {
         image_read_track(im);
         bc->cons = decode_off * 16;
-        *start_pos = sys_ticks;
+        *start_pos = start_ticks;
     }
 }
 

src/image/dummy.c

@@ -21,7 +21,7 @@ static void dummy_setup_track(
 {
     im->cur_track = track;
     im->cur_ticks = (start_pos ? *start_pos : 0) * 16;
-    im->tracklen_ticks = sysclk_stk(im->stk_per_rev) * 16;
+    im->tracklen_ticks = sampleclk_stk(im->stk_per_rev) * 16;
     im->ticks_since_flux = 0;
 }
 

src/image/hfe.c

@@ -102,7 +102,7 @@ static bool_t hfe_open(struct image *im)
     im->nr_cyls = dhdr.nr_tracks;
     im->step = im->hfe.double_step ? 2 : 1;
     im->nr_sides = dhdr.nr_sides;
-    im->write_bc_ticks = sysclk_us(500) / bitrate;
+    im->write_bc_ticks = sampleclk_us(500) / bitrate;
     im->ticks_per_cell = im->write_bc_ticks * 16;
     im->sync = SYNC_none;
 
@@ -128,7 +128,7 @@ static void hfe_seek_track(struct image *im, uint16_t track)
     im->hfe.trk_off = le16toh(thdr.offset);
     im->hfe.trk_len = le16toh(thdr.len) / 2;
     im->tracklen_bc = im->hfe.trk_len * 8;
-    im->stk_per_rev = stk_sysclk(im->tracklen_bc * im->write_bc_ticks);
+    im->stk_per_rev = stk_sampleclk(im->tracklen_bc * im->write_bc_ticks);
 
     im->cur_track = track;
 }
@@ -138,36 +138,36 @@ static void hfe_setup_track(
 {
     struct image_buf *rd = &im->bufs.read_data;
     struct image_buf *bc = &im->bufs.read_bc;
-    uint32_t sys_ticks;
+    uint32_t start_ticks;
     uint8_t cyl = track >> (im->hfe.double_step ? 2 : 1);
     uint8_t side = track & (im->nr_sides - 1);
 
     track = cyl*2 + side;
     if (track != im->cur_track)
         hfe_seek_track(im, track);
 
-    sys_ticks = start_pos ? *start_pos : get_write(im, im->wr_cons)->start;
-    im->cur_bc = (sys_ticks * 16) / im->ticks_per_cell;
+    start_ticks = start_pos ? *start_pos : get_write(im, im->wr_cons)->start;
+    im->cur_bc = (start_ticks * 16) / im->ticks_per_cell;
     if (im->cur_bc >= im->tracklen_bc)
         im->cur_bc = 0;
     im->cur_ticks = im->cur_bc * im->ticks_per_cell;
     im->ticks_since_flux = 0;
 
-    sys_ticks = im->cur_ticks / 16;
+    start_ticks = im->cur_ticks / 16;
 
     rd->prod = rd->cons = 0;
     bc->prod = bc->cons = 0;
 
     /* Aggressively batch our reads at HD data rate, as that can be faster 
      * than some USB drives will serve up a single block.*/
-    im->hfe.batch_secs = (im->write_bc_ticks > sysclk_ns(1500)) ? 2 : 8;
+    im->hfe.batch_secs = (im->write_bc_ticks > sampleclk_ns(1500)) ? 2 : 8;
 
     if (start_pos) {
         /* Read mode. */
         im->hfe.trk_pos = (im->cur_bc/8) & ~255;
         image_read_track(im);
         bc->cons = im->cur_bc & 2047;
-        *start_pos = sys_ticks;
+        *start_pos = start_ticks;
     } else {
         /* Write mode. */
         im->hfe.trk_pos = im->cur_bc / 8;
@@ -260,7 +260,7 @@ static uint16_t hfe_rdata_flux(struct image *im, uint16_t *tbuf, uint16_t nr)
             case OP_bitrate:
                 x = _rbit32(bc_b[(bc_c/8+1) & bc_mask]) >> 24;
                 im->ticks_per_cell = ticks_per_cell = 
-                    (sysclk_us(2) * 16 * x) / 72;
+                    (sampleclk_us(2) * 16 * x) / 72;
                 bc_c += 2*8;
                 im->cur_bc += 2*8;
                 y = 8;

src/image/image.c

@@ -116,7 +116,7 @@ static bool_t try_handler(struct image *im, struct slot *slot,
 
     /* Sensible defaults. */
     im->sync = SYNC_mfm;
-    im->write_bc_ticks = sysclk_us(2);
+    im->write_bc_ticks = sampleclk_us(2);
     im->stk_per_rev = stk_ms(200);
 
     im->disk_handler = im->track_handler = handler;

src/image/img.c

@@ -1808,7 +1808,7 @@ static void raw_setup_track(
 {
     struct image_buf *rd = &im->bufs.read_data;
     struct image_buf *bc = &im->bufs.read_bc;
-    uint32_t decode_off, sys_ticks = start_pos ? *start_pos : 0;
+    uint32_t decode_off, start_ticks = start_pos ? *start_pos : 0;
     uint8_t cyl = track/(2*im->step), side = track & (im->nr_sides - 1);
 
     track = cyl*2 + side;
@@ -1817,7 +1817,7 @@ static void raw_setup_track(
 
     im->img.write_sector = -1;
 
-    im->cur_bc = (sys_ticks * 16) / im->ticks_per_cell;
+    im->cur_bc = (start_ticks * 16) / im->ticks_per_cell;
     im->cur_bc &= ~15;
     if (im->cur_bc >= im->tracklen_bc)
         im->cur_bc = 0;
@@ -1832,7 +1832,7 @@ static void raw_setup_track(
     if (start_pos) {
         image_read_track(im);
         bc->cons = decode_off * 16;
-        *start_pos = sys_ticks;
+        *start_pos = start_ticks;
     }
 }
 
@@ -2344,11 +2344,11 @@ static void mfm_prep_track(struct image *im)
     im->tracklen_bc = max_t(uint32_t, im->tracklen_bc, tracklen);
     im->tracklen_bc = (im->tracklen_bc + 31) & ~31;
 
-    im->ticks_per_cell = ((sysclk_stk(im->stk_per_rev) * 16u)
+    im->ticks_per_cell = ((sampleclk_stk(im->stk_per_rev) * 16u)
                           / im->tracklen_bc);
     im->img.gap_4 = (im->tracklen_bc - tracklen) / 16;
 
-    im->write_bc_ticks = sysclk_us(500) / trk->data_rate;
+    im->write_bc_ticks = sampleclk_us(500) / trk->data_rate;
 
     im->sync = SYNC_mfm;
 
@@ -2562,11 +2562,11 @@ static void fm_prep_track(struct image *im)
     im->tracklen_bc = max_t(uint32_t, im->tracklen_bc, tracklen);
     im->tracklen_bc = (im->tracklen_bc + 31) & ~31;
 
-    im->ticks_per_cell = ((sysclk_stk(im->stk_per_rev) * 16u)
+    im->ticks_per_cell = ((sampleclk_stk(im->stk_per_rev) * 16u)
                           / im->tracklen_bc);
     im->img.gap_4 = (im->tracklen_bc - tracklen) / 16;
 
-    im->write_bc_ticks = sysclk_us(500) / trk->data_rate;
+    im->write_bc_ticks = sampleclk_us(500) / trk->data_rate;
 
     im->sync = SYNC_fm;