source: buchla-68k/ram/lcdlbls.c @ 8c8b4e5

Last change on this file since 8c8b4e5 was 8c8b4e5, checked in by Thomas Lopatic <thomas@…>, 2 years ago

More volatile hardware accesses.

  • Property mode set to 100644
File size: 37.3 KB
Line 
1/*
2   =============================================================================
3        lcdlbls.c -- MIDAS-VII front panel support functions
4        Version 48 -- 1989-12-19 -- D.N. Lynx Crowe
5   =============================================================================
6*/
7
8#define ROMPOK          1               /* non-zero enables the ROMP switch */
9
10#include "ram.h"
11
12#define ARTIVAL(x)      (x << 5)
13#define SL2GAIN(x)      (sl2gain[(x >> 11) + 16])
14
15#if     ROMPOK
16#define ROMPFN  trapper         /* ROMP switch table entry */
17#else
18#define ROMPFN  l_none          /* ROMP switch table entry */
19#endif
20
21#define PCHMAX  21920L          /* maximum pitch value */
22
23/* initialized stuff */
24
25/* BarType -- LCD slider bar graph type table -- 0 = bottom, 1 = centered */
26
27int16_t BarType[14] = { 1, 0,   0, 0, 0,   1, 1, 1, 1,   0, 0, 0,   1, 0 };
28
29int16_t artitab[] = {           /* articulation pot initialization values */
30
31        ARTIVAL(500),   /* locn  */
32        ARTIVAL(0),     /* level */
33        ARTIVAL(0),     /* ind 1 */
34        ARTIVAL(0),     /* ind 2 */
35        ARTIVAL(0),     /* ind 3 */
36        ARTIVAL(500),   /* frq 1 */
37        ARTIVAL(500),   /* frq 2 */
38        ARTIVAL(500),   /* frq 3 */
39        ARTIVAL(500),   /* frq 4 */
40        ARTIVAL(0),     /* ind 4 */
41        ARTIVAL(0),     /* ind 5 */
42        ARTIVAL(0),     /* ind 6 */
43        ARTIVAL(500),   /* filtr */
44        ARTIVAL(0)      /* reson */
45};
46
47/* arpar[] -- articulation parameter map */
48/*         sigtab[ 25  26  27  28  29  30  31  32  33  34  35  36  37  38] */
49
50int16_t arpar[] = { 4,  2,  9, 11, 12,  1,  3,  5,  7, 13, 14, 15, 10,  6};
51
52int16_t sl2gain[32] = {         /* slider value to EQ gain conversion table */
53
54        -12, -12, -12, -12, -12, -11, -10, -9 ,-8 ,-7, -6, -5, -4, -3, -2, -1,
55          0,   1,   2,   3,   4,   5,   6,  7,  8,  9, 10, 11, 12, 12, 12, 12
56};
57
58uint16_t        vmasks[16] = {          /* variable resolution masks */
59
60        0x8000, 0xC000, 0xE000, 0xF000,
61        0xF800, 0xFC00, 0xFE00, 0xFF00,
62        0xFF80, 0xFFC0, 0xFFE0, 0xFFF0,
63        0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF
64};
65
66int16_t src2var[14] = {         /* source number to analog variable number map */
67
68        -1, -1,  3, -1, -1, -1,  5, -1,  4, -1, -1,  0,  1,  2 };
69
70int8_t  *potlbls[] = {          /* LCD pot labels */
71
72        /* Pot:  25    26    27    28    29    30    31    32    33    34    35    36    37    38 */
73
74        /* 0 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson",
75        /* 1 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson",
76        /* 2 */ "      Aux   Depth Rate  Inten CV 1  CV 2  CV 3  CV 4                               ",
77        /* 3 */ " 50    150   400    1k  2.5k    6k   15k   50    150   400    1k  2.5k    6k   15k ",
78        /* 4 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson",
79        /* 5 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson",
80        /* 6 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson",
81        /* 7 */ "Locn  Level Ind 1 Ind 2 Ind 3 Frq 1 Frq 2 Frq 3 Frq 4 Ind 4 Ind 5 Ind 6 Filtr Reson"
82};
83
84#if     ROMPOK
85int8_t  *swtlbls[] = {          /* LCD switch labels -- ROMP ENABLED */
86
87        /* 0 */ "Quiet ROMP  Lamp  Clock  P/R  Go To Instr Asgmt Load              Other Voice Init ",
88        /* 1 */ "                                                                        Voice Init ",
89        /* 2 */ "Quiet ROMP  Lamp  Clock  P/R  Go To Instr Asgmt Load               EQ   Voice Init ",
90        /* 3 */ "Quiet ROMP  Lamp  Clock  P/R  Go To Instr Asgmt Load              Prmtr Voice Init ",
91        /* 4 */ "                                                                         +00  Deflt",
92        /* 5 */ "Quiet ROMP  Lamp  Clock  P/R  Go To Instr Asgmt Load              Other Voice Deflt",
93        /* 6 */ "Quiet ROMP  Lamp  Clock  P/R                                                       ",
94        /* 7 */ "Quiet ROMP  Lamp                                Load                               "
95};
96#else
97char    *swtlbls[] = {          /* LCD switch labels -- ROMP DISABLED */
98
99        /* 0 */ "Quiet       Lamp  Clock  P/R  Go To Instr Asgmt Load              Other Voice Init ",
100        /* 1 */ "                                                                        Voice Init ",
101        /* 2 */ "Quiet       Lamp  Clock  P/R  Go To Instr Asgmt Load               EQ   Voice Init ",
102        /* 3 */ "Quiet       Lamp  Clock  P/R  Go To Instr Asgmt Load              Prmtr Voice Init ",
103        /* 4 */ "                                                                         +00  Deflt",
104        /* 5 */ "Quiet       Lamp  Clock  P/R  Go To Instr Asgmt Load              Other Voice Deflt",
105        /* 6 */ "Quiet       Lamp  Clock  P/R                                                       ",
106        /* 7 */ "Quiet       Lamp                                Load                               "
107};
108#endif
109
110int8_t  *aslbls[] = {           /* Assignment select key labels */
111
112        "Asgmt",        /* 0 */
113        " +00 ",        /* 1 */
114        " +20 ",        /* 2 */
115        " +40 ",        /* 3 */
116        " +60 ",        /* 4 */
117        " +80 "         /* 5 */
118};
119
120LPF     t_prmtr[] = {   /* switch assignments for LS_PRMTR */
121
122        quiet,          /*  0: Quiet */
123        ROMPFN,         /*  1: ROMP */
124
125        setlamp,        /*  2: Lamp */
126        l_clock,        /*  3: Clock */
127        rpctl,          /*  4: R/P */
128
129        l_goto,         /*  5: Go To */
130        l_inst,         /*  6: Instr */
131        l_asgn,         /*  7: Asgmt */
132        l_load,         /*  8: Load */
133
134        l_none,         /*  9: -unused- */
135        l_none,         /* 10: -unused- */
136        l_other,        /* 11: Other */
137
138        l_prmtr,        /* 12: Prmtr */
139        l_init          /* 13: Init */
140};
141
142LPF     t_voice[] = {   /* switch assignments for LS_VOICE */
143
144        l_voice,        /*  0: toggle voice status */
145        l_voice,        /*  1: toggle voice status */
146
147        l_voice,        /*  2: toggle voice status */
148        l_voice,        /*  3: toggle voice status */
149        l_voice,        /*  4: toggle voice status */
150
151        l_voice,        /*  5: toggle voice status */
152        l_voice,        /*  6: toggle voice status */
153        l_voice,        /*  7: toggle voice status */
154        l_voice,        /*  8: toggle voice status */
155
156        l_voice,        /*  9: toggle voice status */
157        l_voice,        /* 10: toggle voice status */
158        l_voice,        /* 11: toggle voice status */
159
160        l_prmtr,        /* 12: Prmtr */
161        l_init          /* 13: Init */
162};
163
164LPF     t_other[] = {   /* switch assignments for LS_OTHER */
165
166        quiet,          /*  0: Quiet */
167        ROMPFN,         /*  1: ROMP */
168
169        setlamp,        /*  2: Lamp */
170        l_clock,        /*  3: Clock */
171        rpctl,          /*  4: R/P */
172
173        l_goto,         /*  5: Go To */
174        l_inst,         /*  6: Instr */
175        l_asgn,         /*  7: Asgmt */
176        l_load,         /*  8: Load */
177
178        l_none,         /*  9: -unused- */
179        l_none,         /* 10: -unused- */
180        l_eq,           /* 11: EQ */
181
182        l_prmtr,        /* 12: Prmtr */
183        l_init          /* 13: Init */
184};
185
186LPF     t_eq[] = {      /* switch assignments for LS_EQ */
187
188        quiet,          /*  0: Quiet */
189        ROMPFN,         /*  1: ROMP */
190
191        setlamp,        /*  2: Lamp */
192        l_clock,        /*  3: Clock */
193        rpctl,          /*  4: R/P */
194
195        l_goto,         /*  5: Go To */
196        l_inst,         /*  6: Instr */
197        l_asgn,         /*  7: Asgmt */
198        l_load,         /*  8: Load */
199
200        l_none,         /*  9: -unused- */
201        l_none,         /* 10: -unused- */
202        l_eq,           /* 11: Prmtr */
203
204        l_prmtr,        /* 12: Voice */
205        l_init          /* 13: Init */
206};
207
208LPF     t_inst[] = {    /* switch assignments for LS_INST */
209
210        l_group,        /*  0: toggle group status */
211        l_group,        /*  1: toggle group status */
212
213        l_group,        /*  2: toggle group status */
214        l_group,        /*  3: toggle group status */
215        l_group,        /*  4: toggle group status */
216
217        l_group,        /*  5: toggle group status */
218        l_group,        /*  6: toggle group status */
219        l_group,        /*  7: toggle group status */
220        l_group,        /*  8: toggle group status */
221
222        l_group,        /*  9: toggle group status */
223        l_group,        /* 10: toggle group status */
224        l_group,        /* 11: toggle group status */
225
226        l_inst,         /* 12: 01-20 / 21-40 */
227        l_dflt          /* 13: Deflt */
228};
229
230LPF     t_libr[] = {    /* switch assignments for LS_LIBR */
231
232        quiet,          /*  0: Quiet */
233        ROMPFN,         /*  1: ROMP */
234
235        setlamp,        /*  2: Lamp */
236        l_clock,        /*  3: Clock */
237        rpctl,          /*  4: R/P */
238
239        l_none,         /*  5: -unused- */
240        l_none,         /*  6: -unused- */
241        l_none,         /*  7: -unused- */
242        l_none,         /*  8: -unused- */
243
244        l_none,         /*  9: -unused- */
245        l_none,         /* 10: -unused- */
246        l_none,         /* 11: -unused- */
247
248        l_none,         /* 12: -unused- */
249        l_none          /* 13: -unused- */
250};
251
252LPF     t_ngrp[] = {    /* switch assignments for LS_NGRP */
253
254        quiet,          /*  0: Quiet */
255        ROMPFN,         /*  1: ROMP */
256
257        setlamp,        /*  2: Lamp */
258        l_clock,        /*  3: Clock */
259        rpctl,          /*  4: R/P */
260
261        l_none,         /*  5: -unused- */
262        l_none,         /*  6: -unused- */
263        l_none,         /*  7: -unused- */
264        l_none,         /*  8: -unused- */
265
266        l_none,         /*  9: -unused- */
267        l_none,         /* 10: -unused- */
268        l_none,         /* 11: -unused- */
269
270        l_none,         /* 12: -unused- */
271        l_none          /* 13: -unused- */
272};
273
274LPF     t_load[] = {    /* switch assignments for LS_LOAD */
275
276        quiet,          /*  0: Quiet */
277        ROMPFN,         /*  1: ROMP */
278
279        setlamp,        /*  2: Lamp */
280        l_none,         /*  3: -unused- */
281        l_none,         /*  4: -unused- */
282
283        l_none,         /*  5: -unused- */
284        l_none,         /*  6: -unused- */
285        l_none,         /*  7: -unused- */
286        l_load,         /*  8: Load */
287
288        l_none,         /*  9: -unused- */
289        l_none,         /* 10: -unused- */
290        l_none,         /* 11: -unused- */
291
292        l_none,         /* 12: -unused- */
293        l_none          /* 13: -unused- */
294};
295
296/*
297   =============================================================================
298        l_none() -- null function
299   =============================================================================
300*/
301
302void l_none(int16_t _1, int16_t _2)
303{
304        (void)_1;
305        (void)_2;
306}
307
308/*
309   =============================================================================
310        quiet() -- quiet the instrument
311   =============================================================================
312*/
313
314void quiet(int16_t _1, int16_t _2)
315{
316        register int16_t vce;
317
318        (void)_1;
319        (void)_2;
320
321        for (vce = 0; vce < 12; vce++)          /* for each voice ... */
322                sendval(vce, 2, 0);             /* ... set level = 0 */
323
324        memsetw(seqflag, 0, 16);                /* stop the sequences */
325        memsetw(seqtime, 0, 16);                /* ... */
326
327        memsetw(trstate, 0, 16);                /* reset the triggers */
328
329        seqdupd = 0xFFFF;                       /* request display update */
330
331        stmproc(NULL_DEF);                      /* trigger the blank definer */
332}
333
334/*
335   =============================================================================
336        rpctl() -- toggle record/play switch
337   =============================================================================
338*/
339
340void rpctl(int16_t stat, int16_t _2)
341{
342        (void)_2;
343
344        if (NOT stat)
345                return;
346
347        recsw = NOT recsw;
348        dsrpmod();
349}
350
351/*
352   =============================================================================
353        trapper() -- trap to ROMP
354   =============================================================================
355*/
356
357void trapper(int16_t stat, int16_t _2)
358{
359        (void)_2;
360
361        if (stat)
362                xtrap15();
363}
364
365/*
366   =============================================================================
367        l_clock() -- process 'Clock' switch
368   =============================================================================
369*/
370
371void l_clock(int16_t stat, int16_t _2)
372{
373        (void)_2;
374
375        if (NOT stat)
376                return;
377
378        clkset(NOT clkrun);
379        dclkmd();
380}
381
382/*
383   =============================================================================
384        ulamp() -- underline lamp if forced on
385   =============================================================================
386*/
387
388void ulamp(void)
389{
390        if ((sliders EQ LS_VOICE) OR (sliders EQ LS_INST))
391                return;
392
393        point = GLCplot;        /* setup to draw line */
394        GLCcurs(G_ON);
395
396        if (lampsw)
397                lseg (LAMP_XL, LAMP_Y, LAMP_XR, LAMP_Y, 1);
398        else
399                lseg (LAMP_XL, LAMP_Y, LAMP_XR, LAMP_Y, 0);
400
401        GLCcurs(G_OFF);
402}
403
404/*
405   =============================================================================
406        preio() -- turn off LCD backlight before disk I/O
407   =============================================================================
408*/
409
410void preio(void)
411{
412        int16_t oldipl;
413
414        oldipl = setipl(TIM_DI);
415
416        lampio  = lampsw;
417        iotime  = lcdtime;
418        lampsw  = FALSE;
419        io_leds = 0x1F;
420
421        setipl(oldipl);
422}
423
424/*
425   =============================================================================
426        postio() -- restore LCD backlight state after disk I/O
427   =============================================================================
428*/
429
430void postio(void)
431{
432        int16_t oldipl;
433
434        oldipl = setipl(TIM_DI);
435
436        lampsw = lampio;
437
438        if (iotime OR lampsw) {
439
440                lcdtime = lcdontm;
441                io_leds = 0x9F;
442        }
443
444        setipl(oldipl);
445}
446
447/*
448   =============================================================================
449        setlamp() -- toggle LCD backlight mode
450   =============================================================================
451*/
452
453void setlamp(int16_t stat, int16_t _2)
454{
455        register int16_t oldi;
456
457        (void)_2;
458
459        if (NOT stat)           /* only act on key closures */
460                return;
461
462        oldi = setipl(TIM_DI);  /* disable interrupts to keep out the timer */
463
464        lcdtime = lcdontm;      /* set the LCD backlight timer */
465
466        if (lampsw) {
467
468                lampsw = FALSE;         /* enable LCD timeouts */
469                io_leds = 0x1F;         /* turn off the LCD backlight */
470
471        } else {
472
473                lampsw = TRUE;          /* disable LCD timeouts */
474                io_leds = 0x9F;         /* turn on the LCD backlight */
475        }
476
477        setipl(oldi);           /* turn interrupts back on */
478
479        ulamp();                /* update underline on lamp key label */
480}
481
482/*
483   =============================================================================
484        lcd_on() -- turn on the LCD backlight
485   =============================================================================
486*/
487
488void lcd_on(void)
489{
490        register int16_t oldi;
491
492        oldi = setipl(TIM_DI);  /* disable interrupts to keep out the timer */
493
494        lcdtime = lcdontm;      /* set the LCD backlight timer */
495        io_leds = 0x9F;         /* turn on the LCD backlight */
496
497        setipl(oldi);           /* turn interrupts back on */
498}
499
500/*
501   =============================================================================
502        loadkey() -- process data keys in load mode
503   =============================================================================
504*/
505
506void loadkey(int16_t key)
507{
508        if (NOT astat)
509                return;
510
511        if (loadsw) {                           /* if it's load time */
512
513                if (key < 7) {                  /* ... and the key is valid */
514
515                        loadem(key + 'A');      /* ... load the files */
516
517                        loadsw  = FALSE;
518                        ltagged = FALSE;
519                        d_key = olddkey;
520                        x_key = oldxkey;
521                        e_key = oldekey;
522                        m_key = oldmkey;
523                        pkctrl  = oldpk;
524                        sliders = oldsl;
525                        swpt    = oldsw;
526                        lcdlbls();
527                }
528
529                return;
530        }
531}
532
533/*
534   =============================================================================
535        pcancel() -- cancel panel modes
536   =============================================================================
537*/
538
539void pcancel(int16_t pm)
540{
541        point = GLCplot;                /* setup to plot on LCD */
542        GLCcurs(G_ON);
543
544        if ((pm NE 0) AND asmode) {
545
546                /* cancel assignment mode */
547
548                asmode = 0;
549                pkctrl = oldpk;
550                swpt   = oldsw;
551                lseg(ASGN_XL, ASGN_Y, ASGN_XR, ASGN_Y, 0);
552        }
553
554        if ((pm NE 1) AND (gomode NE GO_NULL)) {
555
556                /* cancel Go To mode */
557
558                gomode = GO_NULL;
559                pkctrl = oldpk;
560                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 0);
561        }
562
563        if ((pm NE 2) AND (ismode NE IS_NULL)) {
564
565                /* cancel instrument select mode */
566
567                ismode  = IS_NULL;
568                pkctrl  = oldpk;
569                sliders = oldsl;
570                swpt    = oldsw;
571                lcdlbls();
572        }
573
574        GLCcurs(G_OFF);
575        setleds();
576}
577
578/*
579   =============================================================================
580        l_load() -- process "Load" key
581   =============================================================================
582*/
583
584void l_load(int16_t stat, int16_t _2)
585{
586        (void)_2;
587
588        if (NOT stat)
589                return;
590
591        pcancel(3);                     /* cancel panel selections */
592        lcancel(3);                     /* cancel librarian selections */
593
594        point = GLCplot;                /* setup to plot on LCD */
595        GLCcurs(G_ON);
596
597        if (loadsw) {           /* if load is selected, deselect */
598
599                d_key   = olddkey;
600                e_key   = oldekey;
601                m_key   = oldmkey;
602                x_key   = oldxkey;
603
604                pkctrl  = oldpk;
605                sliders = oldsl;
606                swpt    = oldsw;
607
608                loadsw  = FALSE;
609
610                lcdlbls();
611
612        } else {                /* setup for load mode */
613
614                clkset(0);      /* stop the clock */
615
616                if (ltagged) {  /* cancel tag mode */
617
618                        dslslot(tagslot, exp_c(LCFBX01), loadrow);
619                        ltagged = FALSE;
620                }
621
622                if ((pkctrl EQ PK_PFRM) OR (pkctrl EQ PK_NOTE))
623                        oldpk = pkctrl;
624
625                if (sliders NE LS_LOAD)
626                        oldsl = sliders;
627
628                pkctrl  = PK_LOAD;
629                sliders = LS_LOAD;
630                oldsw   = swpt;
631                swpt    = &t_load;
632
633                olddkey = d_key;
634                oldxkey = x_key;
635                oldekey = e_key;
636                oldmkey = m_key;
637                d_key   = loadkey;
638                x_key   = l_load;
639                e_key   = l_load;
640                m_key   = l_load;
641
642                loadsw = TRUE;
643
644                lcdlbls();
645                lseg(LOAD_XL, LOAD_Y, LOAD_XR, LOAD_Y, 1);
646        }
647
648        GLCcurs(G_OFF);
649        setleds();
650}
651
652/*
653   =============================================================================
654        lcdlbls() -- put up the labels on the LCD display
655   =============================================================================
656*/
657
658void lcdlbls(void)
659{
660        register int16_t i, barval;
661        int8_t buf[8];
662        int8_t dsp[86];
663
664        point = GLCplot;                /* set up to plot on the LCD */
665
666        GLCinit();                      /* clear the LCD display */
667        GLCcurs(G_ON);
668
669        /* label the switches */
670
671        switch (sliders) {
672
673        case LS_PRMTR:          /* parameter articulation */
674        case LS_OTHER:          /* other stuff */
675        case LS_EQ:             /* equalization */
676
677                GLCtext(0, 1, swtlbls[sliders]);
678
679                switch (gomode) {
680
681                case GO_SECT:
682
683                        GLCtext(0, 31, "Sectn");
684                        lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 1);
685                        break;
686
687                case GO_SCOR:
688
689                        GLCtext(0, 31, "Score");
690                        lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 1);
691                        break;
692
693                default:
694
695                        GLCtext(0, 31, "Go To");
696                        lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 0);
697                        break;
698                }
699
700                break;
701
702        case LS_VOICE:          /* voice selection */
703
704                dsp[0] = '\0';
705
706                for (i = 0; i < 12; i++) {
707
708                        sprintf(buf, "%c%2d %c ",
709                                (articen[i] ? '\176' : ' '), i + 1,
710                                (articen[i] ? '\177' : ' '));
711
712                        strcat(dsp, buf);
713                }
714
715                strcat(dsp, "Voice Init ");
716
717                GLCtext(0, 1, dsp);
718                break;
719
720        case LS_INST:           /* instrument selection */
721
722                dsp[0] = '\0';
723
724                for (i = 0; i < 12; i++) {
725
726                        sprintf(buf, "%c%2d %c ",
727                                (grpsel[i] ? '\176' : ' '), i + 1,
728                                (grpsel[i] ? '\177' : ' '));
729
730                        strcat(dsp, buf);
731                }
732
733                if (ismode EQ IS_HORC)
734                        strcat(dsp, " +20 ");   /* hi orc */
735                else
736                        strcat(dsp, " +00 ");   /* lo orc */
737
738                strcat(dsp, " Deflt");
739
740                GLCtext(0, 1, dsp);
741                break;
742
743        case LS_LIBR:
744        case LS_NGRP:
745        case LS_LOAD:
746
747                GLCtext(0, 1, swtlbls[sliders]);
748                break;
749        }
750
751
752        GLCtext(7, 1, potlbls[sliders]);        /* label the pots */
753
754        for (i = 0; i < 13; i++)
755                lseg(39 + (i * 36), 0, 39 + (i * 36), 63, 1);
756
757        switch (sliders) {                      /* draw the slider bars */
758
759        case LS_PRMTR:  /* parameter articulation */
760        case LS_VOICE:  /* voice articulation enable */
761        case LS_INST:   /* instrument select */
762        case LS_LIBR:   /* library select */
763        case LS_NGRP:   /* group select */
764        case LS_LOAD:   /* load select */
765
766                for (i = 0; i < 14; i++) {
767
768                        if (BarType[i]) {
769
770                                barval = (((BGprmtr[i] >> 5) - 500) << 6) / 252;
771                                BarCset(i, barval);
772
773                        } else {
774
775                                barval = BGprmtr[i] / 252;
776                                BarBset(i, barval);
777                        }
778                }
779
780                break;
781
782        case LS_OTHER:
783
784                for (i = 0; i < 14; i++)
785                        BarBset(i, (BGother[i] / 252));
786
787                break;
788
789        case LS_EQ:
790
791                for (i = 0; i < 14; i++)
792                        BarCset(i, BGeq[i]);
793
794                break;
795
796        default:
797
798                break;
799        }
800
801        GLCcurs(G_OFF);
802        dsrpmod();
803        dclkmd();
804        ulamp();
805}
806
807/*
808   =============================================================================
809        selasg() -- select assignment table
810   =============================================================================
811*/
812
813void selasg(int16_t n)
814{
815        register struct s_entry *ep;
816
817        getasg(curasg = n);     /* set the assignment */
818
819        if (recsw) {            /* if we're recording ... */
820
821                if (E_NULL NE (ep = findev(p_cur, t_cur, EV_ASGN, -1, -1))) {
822
823                        ep->e_data1 = n;        /* update old event */
824
825                } else if (E_NULL NE (ep = e_alc(E_SIZE2))) {
826
827                        ep->e_type  = EV_ASGN;  /* create new event */
828                        ep->e_data1 = n;
829                        ep->e_time  = t_cur;
830                        p_cur = e_ins(ep, ep_adj(p_cur, 0, t_cur))->e_fwd;
831                        eh_ins(ep, EH_ASGN);
832
833                        if (ndisp EQ 2) {       /* if the score is up ... */
834
835                                ctrsw = TRUE;
836                                se_disp(ep, D_FWD, gdstbc, 1);
837                                scupd();
838                        }
839                }
840        }
841
842        asmode = 0;                     /* drop out of assignment mode */
843        pkctrl = oldpk;                 /* restore previous mode */
844        swpt   = oldsw;
845
846        point = GLCplot;                /* update the LCD */
847        GLCcurs(G_ON);
848        lseg(ASGN_XL, ASGN_Y, ASGN_XR, ASGN_Y, 0);
849        GLCtext(0, 1, swtlbls[sliders]);
850        GLCcurs(G_OFF);
851
852        mpcupd();                       /* update the video display ... */
853        setleds();                      /* ... and the LEDs */
854}
855
856/*
857   =============================================================================
858        l_adfl() -- select default assignment table
859   =============================================================================
860*/
861
862void l_adfl(int16_t stat, int16_t _2)
863{
864        (void)_2;
865
866        if (NOT stat)
867                return;
868
869        selasg(0);
870}
871
872/*
873   =============================================================================
874        l_asgn() -- select assignment
875   =============================================================================
876*/
877
878void l_asgn(int16_t stat, int16_t _2)
879{
880        (void)_2;
881
882        if (NOT stat)                   /* only do this on key closure */
883                return;
884
885        point = GLCplot;                /* set up to plot on the LCD */
886        GLCcurs(G_ON);
887
888        if (ismode NE IS_NULL) {        /* cancel instrument select mode */
889
890                ismode  = IS_NULL;
891                pkctrl  = oldpk;
892                sliders = oldsl;
893                swpt    = oldsw;
894                lcdlbls();
895        }
896
897        if (gomode NE GO_NULL) {        /* cancel Go To mode */
898
899                gomode = GO_NULL;
900                pkctrl = oldpk;
901                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 0);
902        }
903
904        switch (asmode) {
905
906        case 0:                 /* initial actuation */
907
908                if ((pkctrl EQ PK_PFRM) OR (pkctrl EQ PK_NOTE))
909                        oldpk = pkctrl;
910
911                asmode = (curasg ? ((curasg - 1) / 20) : 0) + 1;
912                pkctrl = PK_ASGN;
913                memcpy(aswtbl, swpt, sizeof t_prmtr);
914                oldsw = swpt;
915                swpt  = &aswtbl;
916                aswtbl[13] = l_adfl;
917                lseg(ASGN_XL, ASGN_Y, ASGN_XR, ASGN_Y, 1);
918                GLCtext(0, 79, "Deflt");
919                break;
920
921        case 1:                 /* +00 -- 01..20 to +20 */
922        case 2:                 /* +20 -- 21..40 to +40 */
923        case 3:                 /* +40 -- 41..60 to +60 */
924        case 4:                 /* +60 -- 61..80 to +80 */
925
926                ++asmode;
927                break;
928
929        case 5:                 /* +80 -- 81..99 to +00 */
930
931                asmode = 1;
932                break;
933
934        }
935
936        GLCtext(0, 43, aslbls[asmode]);
937        GLCcurs(G_OFF);
938        setleds();
939}
940
941/*
942   =============================================================================
943        l_inst() -- set select instrument mode
944   =============================================================================
945*/
946
947void l_inst(int16_t stat, int16_t _2)
948{
949        (void)_2;
950
951        if (NOT stat)
952                return;
953
954        point = GLCplot;                /* set up to plot on the LCD */
955        GLCcurs(G_ON);
956
957        if (asmode) {                   /* cancel assignment mode */
958
959                asmode = 0;
960                pkctrl = oldpk;
961                swpt   = oldsw;
962                lseg(ASGN_XL, ASGN_Y, ASGN_XR, ASGN_Y, 0);
963        }
964
965        if (gomode NE GO_NULL) {        /* cancel Go To mode */
966
967                gomode = GO_NULL;
968                pkctrl = oldpk;
969                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 0);
970        }
971
972        GLCcurs(G_OFF);
973
974        switch (ismode) {
975
976        case IS_NULL:           /* select +00 -- low orchestra */
977
978                if ((pkctrl EQ PK_PFRM) OR (pkctrl EQ PK_NOTE))
979                        oldpk = pkctrl;
980
981                if (sliders NE LS_INST)
982                        oldsl = sliders;
983
984                oldsw   = swpt;
985                swpt    = &t_inst;
986                pkctrl  = PK_INST;
987                ismode  = IS_LORC;
988                sliders = LS_INST;
989                lcdlbls();
990                break;
991
992        case IS_LORC:           /* select +20 -- high orchestra */
993
994                ismode  = IS_HORC;
995                GLCcurs(G_ON);
996                GLCtext(0, 73, " +20 ");
997                GLCcurs(G_OFF);
998                break;
999
1000        case IS_HORC:           /* deselect */
1001        default:
1002
1003                ismode  = IS_NULL;
1004                pkctrl  = oldpk;
1005                sliders = oldsl;
1006                swpt    = oldsw;
1007                lcdlbls();
1008                break;
1009        }
1010
1011        setleds();
1012}
1013
1014/*
1015   =============================================================================
1016        selins() -- select an instrument
1017   =============================================================================
1018*/
1019
1020void selins(int16_t ival)
1021{
1022        register int16_t n;
1023        register struct s_entry *ep;
1024
1025        for (n = 0; n < 12; n++) {
1026
1027                if (FALSE EQ grpsel[n])
1028                        continue;
1029
1030                ins2grp[n] = ival | (ins2grp[n] & 0xFF00);
1031                setv2gi(n);
1032
1033                if (recsw AND grpstat[n] AND (2 EQ grpmode[n])) {
1034
1035                        if (E_NULL NE (ep = findev(p_cur, t_cur, EV_INST, n, -1))) {
1036
1037                                ep->e_data2 = ival;
1038
1039                        } else if (E_NULL NE (ep = e_alc(E_SIZE2))) {
1040
1041                                ep->e_type  = EV_INST;
1042                                ep->e_data1 = n;
1043                                ep->e_data2 = ival;
1044                                ep->e_time  = t_cur;
1045                                p_cur = e_ins(ep, ep_adj(p_cur, 0, t_cur))->e_fwd;
1046                                eh_ins(ep, EH_INST);
1047
1048                                if (ndisp EQ 2) {
1049
1050                                        ctrsw = TRUE;
1051                                        se_disp(ep, D_FWD, gdstbc, 1);
1052                                        scupd();
1053                                }
1054                        }
1055                }
1056        }
1057
1058        setinst();
1059
1060
1061        ismode  = IS_NULL;
1062        pkctrl  = oldpk;
1063        sliders = oldsl;
1064        swpt    = oldsw;
1065        lcdlbls();
1066        setleds();
1067        mpcupd();
1068}
1069
1070/*
1071   =============================================================================
1072        l_dflt() -- select default isntrument
1073   =============================================================================
1074*/
1075
1076void l_dflt(int16_t stat, int16_t _2)
1077{
1078        (void)_2;
1079
1080        if (NOT stat)
1081                return;
1082
1083        selins(0);
1084}
1085
1086/*
1087   =============================================================================
1088        l_goto() -- go to (section / score)
1089   =============================================================================
1090*/
1091
1092void l_goto(int16_t stat, int16_t _2)
1093{
1094        (void)_2;
1095
1096        if (NOT stat)                   /* only do this on key closure */
1097                return;
1098
1099        point = GLCplot;                /* set up to plot on the LCD */
1100        GLCcurs(G_ON);
1101
1102        if (asmode) {                   /* cancel assignment mode */
1103
1104                asmode = 0;
1105                pkctrl = oldpk;
1106                swpt = oldsw;
1107                lseg(ASGN_XL, ASGN_Y, ASGN_XR, ASGN_Y, 0);
1108        }
1109
1110        if (ismode NE IS_NULL) {        /* cancel instrument select mode */
1111
1112                ismode  = IS_NULL;
1113                sliders = oldsl;
1114                pkctrl  = oldpk;
1115                swpt    = oldsw;
1116                lcdlbls();
1117        }
1118
1119        recsw = FALSE;                  /* force play mode */
1120        dsrpmod();
1121
1122        switch (gomode) {               /* select Go To mode */
1123
1124        case GO_NULL:
1125
1126                if ((pkctrl EQ PK_PFRM) OR (pkctrl EQ PK_NOTE))
1127                        oldpk = pkctrl;
1128
1129                pkctrl = PK_GOTO;
1130                gomode = GO_SECT;
1131                GLCtext(0, 31, "Sectn");
1132                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 1);
1133                break;
1134
1135        case GO_SECT:
1136
1137                gomode = GO_SCOR;
1138                GLCtext(0, 31, "Score");
1139                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 1);
1140                break;
1141
1142        case GO_SCOR:
1143        default:
1144
1145                pkctrl = oldpk;
1146                gomode = GO_NULL;
1147                GLCtext(0, 31, "Go To");
1148                lseg(GOTO_XL, GOTO_Y, GOTO_XR, GOTO_Y, 0);
1149                break;
1150        }
1151
1152        GLCcurs(G_OFF);
1153        setleds();
1154}
1155
1156/*
1157   =============================================================================
1158        newpps() -- send out new polyphonic pressure source value
1159   =============================================================================
1160*/
1161
1162void newpps(int16_t trg, int16_t grp, int16_t src, int16_t ival)
1163{
1164        struct sment *smf, *smp;
1165        volatile uint16_t *fpu;
1166        int32_t ltmp;
1167        int16_t val;
1168        int16_t vce;
1169        int16_t gs, oldi;
1170
1171        gs = (grp << 4) | src;          /* calculate group/source index */
1172        fpu = io_fpu + FPU_OFNC;        /* point at FPU base */
1173        valents[gs].val = ival;         /* update value in table */
1174        smp = smf = (struct sment *)&valents[gs];
1175
1176
1177        while (smf NE (smp = smp->nxt)) {       /* for each function ... */
1178
1179                vce = (smp->vp >> 4) & 0x0F;    /* extract voice number */
1180
1181                if (vce2trg[vce] EQ trg) {      /* for each key that matches ... */
1182
1183                        switch (smp->vp & 0x000F) {
1184
1185                        case 1:         /* frq 1 */
1186                        case 3:         /* frq 2 */
1187                        case 5:         /* frq 3 */
1188                        case 7:         /* frq 4 */
1189
1190                                val = ival >> 3;
1191                                break;
1192
1193                        case 10:        /* filtr */
1194
1195                                ltmp = ((int32_t)ival >> 1) + ((int32_t)ival >> 2);
1196
1197                                if (ltmp > (int32_t)VALMAX)
1198                                        ltmp = (int32_t)VALMAX;
1199                                else if (ltmp < (int32_t)VALMIN)
1200                                        ltmp = (int32_t)VALMIN;
1201
1202                                val = (int16_t)ltmp;
1203                                break;
1204
1205                        default:
1206
1207                                val = ival;
1208                        }
1209
1210                        oldi = setipl(FPU_DI);
1211
1212/* ++++++++++++++++++++++++++++ FPU interrupts disabled +++++++++++++++++++++ */
1213
1214                        *(fpu + (smp->vp << 4) + FPU_TCV1) = val;
1215
1216                        setipl(oldi);
1217
1218/* ++++++++++++++++++++++++++++ Interrupts restored +++++++++++++++++++++++++ */
1219
1220                }
1221        }
1222}
1223
1224/*
1225   =============================================================================
1226        newsv() -- send out new source value if it's changed
1227   =============================================================================
1228*/
1229
1230int16_t newsv(int16_t grp, int16_t src, int16_t ival)
1231{
1232        struct sment *smf, *smp;
1233        volatile uint16_t *fpu;
1234        int32_t ltmp;
1235        int16_t val;
1236        int16_t gs;
1237        int16_t oldi;
1238        int16_t vmask, var;
1239
1240        gs  = (grp << 4) | src;                 /* calculate grp/src index */
1241
1242        if (-1 NE (var = src2var[src])) {       /* see if its a variable */
1243
1244                vmask = vmasks[anrs[var][grp]]; /* setup resolution mask */
1245
1246                /* see if we have a change in the selected significant bits */
1247
1248                if (((val = valents[gs].val) & vmask) EQ (ival & vmask)) {
1249
1250                        /* make sure we always see a change to zero */
1251
1252                        if (NOT ((ival EQ 0) AND val))  /* if not becoming zero */
1253                                return(FALSE);  /* ... it didn't change enough */
1254                }
1255        }
1256
1257        fpu = io_fpu + FPU_OFNC;                /* point to FPU */
1258
1259        valents[gs].val = ival;                 /* update value in table */
1260
1261        smf = (struct sment *)&valents[gs];     /* point at value table */
1262        smp = smf;
1263
1264
1265        while (smf NE (smp = smp->nxt)) {       /* update functions */
1266
1267                switch (smp->vp & 0x000F) {
1268
1269                case 1:         /* frq 1 */
1270                case 3:         /* frq 2 */
1271                case 5:         /* frq 3 */
1272                case 7:         /* frq 4 */
1273
1274                        val = ival >> 3;
1275                        break;
1276
1277                case 10:        /* filtr */
1278
1279                        ltmp = ((int32_t)ival >> 1) + ((int32_t)ival >> 2);
1280
1281                        if (ltmp > (int32_t)VALMAX)
1282                                ltmp = (int32_t)VALMAX;
1283                        else if (ltmp < (int32_t)VALMIN)
1284                                ltmp = (int32_t)VALMIN;
1285
1286                        val = (int16_t)ltmp;
1287                        break;
1288
1289                default:
1290
1291                        val = ival;
1292                }
1293
1294                oldi = setipl(FPU_DI);
1295
1296/* ++++++++++++++++++++++++++++ FPU interrupts disabled +++++++++++++++++++++ */
1297
1298                *(fpu + (smp->vp << 4) + FPU_TCV1) = val;
1299
1300                setipl(oldi);
1301
1302/* ++++++++++++++++++++++++++++ Interrupts restored +++++++++++++++++++++++++ */
1303
1304        }
1305
1306        return(TRUE);
1307}
1308
1309/*
1310   =============================================================================
1311        setsv() -- unconditionally send out new source value
1312   =============================================================================
1313*/
1314
1315void setsv(int16_t grp, int16_t src, int16_t ival)
1316{
1317        struct sment *smf, *smp;
1318        volatile uint16_t *fpu;
1319        int32_t ltmp;
1320        int16_t val;
1321        int16_t gs;
1322        int16_t oldi;
1323
1324        gs  = (grp << 4) | src;                 /* calculate grp/src index */
1325        fpu = io_fpu + FPU_OFNC;                /* point to FPU */
1326
1327        valents[gs].val = ival;                 /* update value in table */
1328
1329        smf = (struct sment *)&valents[gs];     /* point at value table */
1330        smp = smf;
1331
1332
1333        while (smf NE (smp = smp->nxt)) {       /* update functions */
1334
1335                switch (smp->vp & 0x000F) {
1336
1337                case 1:         /* frq 1 */
1338                case 3:         /* frq 2 */
1339                case 5:         /* frq 3 */
1340                case 7:         /* frq 4 */
1341
1342                        val = ival >> 3;
1343                        break;
1344
1345                case 10:        /* filtr */
1346
1347                        ltmp = ((int32_t)ival >> 1) + ((int32_t)ival >> 2);
1348
1349                        if (ltmp > (int32_t)VALMAX)
1350                                ltmp = (int32_t)VALMAX;
1351                        else if (ltmp < (int32_t)VALMIN)
1352                                ltmp = (int32_t)VALMIN;
1353
1354                        val = (int16_t)ltmp;
1355                        break;
1356
1357                default:
1358
1359                        val = ival;
1360                }
1361
1362                oldi = setipl(FPU_DI);
1363
1364/* ++++++++++++++++++++++++++++ FPU interrupts disabled +++++++++++++++++++++ */
1365
1366                *(fpu + (smp->vp << 4) + FPU_TCV1) = val;
1367
1368                setipl(oldi);
1369
1370/* ++++++++++++++++++++++++++++ Interrupts restored +++++++++++++++++++++++++ */
1371
1372        }
1373}
1374
1375/*
1376   =============================================================================
1377        l_prmtr() -- set parameter articulation status
1378   =============================================================================
1379*/
1380
1381void l_prmtr(int16_t stat, int16_t _2)
1382{
1383        (void)_2;
1384
1385        if (NOT stat)
1386                return;
1387
1388        switch (sliders) {
1389
1390        case LS_PRMTR:
1391        case LS_OTHER:
1392        case LS_EQ:
1393
1394                sliders = LS_VOICE;
1395                swpt    = &t_voice;
1396                break;
1397
1398        case LS_VOICE:
1399        default:
1400
1401                sliders = LS_PRMTR;
1402                swpt    = &t_prmtr;
1403                break;
1404        }
1405
1406        lcdlbls();
1407        setleds();
1408}
1409
1410/*
1411   =============================================================================
1412        l_voice() -- set voice selection status
1413   =============================================================================
1414*/
1415
1416void l_voice(int16_t stat, int16_t vce)
1417{
1418        int16_t ap, j, par;
1419        volatile uint16_t *fpu;
1420
1421        int8_t buf[8];
1422
1423        if (NOT stat)
1424                return;
1425
1426        articen[vce] = NOT articen[vce];        /* toggle voice enable */
1427
1428        sprintf(buf, "%c%2d %c", (articen[vce] ? '\176' : ' '), vce + 1,
1429                (articen[vce] ? '\177' : ' '));
1430
1431        GLCcurs(G_ON);
1432        GLCtext(0, (1 + (6 * vce)), buf);
1433        GLCcurs(G_OFF);
1434
1435        if (articen[vce]) {     /* turn articulation on if voice is enabled */
1436
1437                for (ap = 0; ap < 14; ap++) {
1438
1439                        par = arpar[ap];
1440                        sendart(vce, par, lastart[par]);
1441                }
1442
1443        } else {        /* ... or turn it off if voice is disabled */
1444
1445                fpu = io_fpu + FPU_OFNC + (vce << 8);
1446
1447                for (j = 1; j < 16; j++)
1448                        *(fpu + (j << 4) + FPU_TSF2) = 0;
1449        }
1450}
1451
1452/*
1453   =============================================================================
1454        l_group() -- set group selection status
1455   =============================================================================
1456*/
1457
1458void l_group(int16_t stat, int16_t grp)
1459{
1460        int8_t buf[8];
1461
1462        if (NOT stat)
1463                return;
1464
1465        grpsel[grp] = NOT grpsel[grp];  /* toggle voice enable */
1466
1467        sprintf(buf, "%c%2d %c", (grpsel[grp] ? '\176' : ' '), grp + 1,
1468                (grpsel[grp] ? '\177' : ' '));
1469
1470        GLCcurs(G_ON);
1471        GLCtext(0, (1 + (6 * grp)), buf);
1472        GLCcurs(G_OFF);
1473}
1474
1475/*
1476   =============================================================================
1477        l_other -- set aux function status
1478   =============================================================================
1479*/
1480
1481void l_other(int16_t stat, int16_t _2)
1482{
1483        (void)_2;
1484
1485        if (NOT stat)
1486                return;
1487
1488        sliders = LS_OTHER;
1489        swpt    = &t_other;
1490
1491        lcdlbls();
1492}
1493
1494/*
1495   =============================================================================
1496        l_eq -- set eq mode
1497   =============================================================================
1498*/
1499
1500void l_eq(int16_t stat, int16_t _2)
1501{
1502        (void)_2;
1503
1504        if (NOT stat)
1505                return;
1506
1507        if (sliders EQ LS_EQ) {
1508
1509                sliders = LS_PRMTR;
1510                swpt    = &t_prmtr;
1511
1512        } else {
1513
1514                sliders = LS_EQ;
1515                swpt    = &t_eq;
1516        }
1517
1518        lcdlbls();
1519}
1520
1521/*
1522   =============================================================================
1523        artclr() -- clear the articulation pot values
1524   =============================================================================
1525*/
1526
1527void artclr(void)
1528{
1529        register int16_t i;
1530
1531        for (i = 0; i < 14; i++)
1532                lastart[arpar[i]] = artitab[i];
1533}
1534
1535/*
1536   =============================================================================
1537        l_init() -- initialize articulation values  (reset the sliders)
1538   =============================================================================
1539*/
1540
1541void l_init(int16_t stat, int16_t _2)
1542{
1543        volatile uint16_t *fpu;
1544        int16_t barval, i, j;
1545
1546        (void)_2;
1547
1548        if (NOT stat)
1549                return;
1550
1551        fpu = io_fpu + FPU_OFNC;
1552
1553        switch (sliders) {
1554
1555        case LS_PRMTR:
1556        case LS_VOICE:
1557        case LS_INST:
1558        case LS_LIBR:
1559        case LS_NGRP:
1560        case LS_LOAD:
1561
1562                /* clear all but spares in voices 1..12 */
1563
1564                for (i = 0; i < 12; i++)
1565                        for (j = 1; j < 16; j++)
1566                                *(fpu + (i << 8) + (j << 4) + FPU_TSF2) = 0;
1567
1568                artclr();
1569
1570                for (i = 0; i < 14; i++) {
1571
1572                        BGprmtr[i] = artitab[i];
1573
1574                        if (BarType[i]) {
1575
1576                                barval = (((artitab[i] >> 5) - 500) << 6) / 252;
1577                                BarCset(i, barval);
1578
1579                        } else {
1580
1581                                barval = artitab[i] / 252;
1582                                BarBset(i, barval);
1583                        }
1584                }
1585
1586                break;
1587
1588        case LS_OTHER:
1589
1590                /* clear spares in voices 2..12 */
1591
1592                for (i = 1; i < 12; i++)
1593                        *(fpu + (i << 8) + FPU_TSF2) = 0;
1594
1595                for (i = 0; i < 14; i++)
1596                        BarBset(i, BGother[i] = 0);
1597
1598                break;
1599
1600        case LS_EQ:
1601
1602                for (i = 0; i < 14; i++) {
1603
1604                        sendeq(i, gain2eq(0));
1605                        BarCset(i, BGeq[i] = 0);
1606                }
1607
1608                break;
1609        }
1610}
1611
1612/*
1613   =============================================================================
1614        sendart() -- send out an articulation value
1615   =============================================================================
1616*/
1617
1618void sendart(int16_t vce, int16_t par, int16_t ival)
1619{
1620        volatile uint16_t *fpu;
1621        int16_t val, oldi, mult;
1622        int16_t nop;
1623
1624        lastart[par] = ival;
1625
1626        fpu = io_fpu + FPU_OFNC + (vce << 8) + (par << 4);
1627        mult = 0x7FFF;
1628
1629        switch (par) {
1630
1631        case 1:         /* freq 1 */
1632        case 3:         /* freq 2 */
1633        case 5:         /* freq 3 */
1634        case 7:         /* freq 4 */
1635
1636                val = addpch(ival, 0);
1637                break;
1638
1639        case 10:        /* filter */
1640
1641                val = ((ival >> 5) - 500) << 5;
1642                break;
1643
1644        case 2:         /* level */
1645
1646                val = ival;
1647                mult = 0xFFFF;
1648                break;
1649
1650        case 4:         /* location */
1651
1652                val = ((ival >> 5) - 500) << 5;
1653                mult = 0xFFFF;
1654                break;
1655
1656        default:
1657
1658                val = ival;
1659        }
1660
1661        oldi = setipl(FPU_DI);
1662
1663/* ++++++++++++++++++++++++++++ FPU interrupts disabled +++++++++++++++++++++ */
1664
1665        *(fpu + FPU_TCV2) = val;
1666        ++nop;  ++nop;  ++nop;
1667        *(fpu + FPU_TSF2) = mult;
1668
1669        setipl(oldi);
1670
1671/* ++++++++++++++++++++++++++++ Interrupts restored +++++++++++++++++++++++++ */
1672
1673}
1674
1675/*
1676   =============================================================================
1677        doslide() -- update a changed slider value
1678   =============================================================================
1679*/
1680
1681void doslide(void)
1682{
1683        register int16_t arp, bar, barval, i, slval;
1684
1685        slval = ART_VAL(aval);  /* scaled articulation value */
1686        bar   = asig - 25;      /* bar number */
1687
1688        switch (sliders) {
1689
1690        case LS_PRMTR:          /* parameter articulation */
1691        case LS_VOICE:
1692        case LS_INST:
1693        case LS_LIBR:
1694        case LS_NGRP:
1695        case LS_LOAD:
1696
1697                BGprmtr[bar] = slval;
1698                arp = arpar[bar];
1699
1700                for (i = 0; i < 12; i++)
1701                        if (articen[i])
1702                                sendart(i, arp, slval);
1703
1704                if (BarType[bar]) {             /* center-zero bar */
1705
1706                        barval = (((slval >> 5) - 500) << 6) / 252;
1707                        BarCadj(bar, barval);
1708
1709                } else {                        /* bottom-zero bar */
1710
1711                        barval = slval / 252;
1712                        BarBadj(bar, barval);
1713                }
1714
1715                return;
1716
1717        case LS_OTHER:          /* aux, dome, cv control */
1718
1719                switch (asig) {
1720
1721                case 26:        /* aux mod */
1722                        sendart(9, 0, slval);
1723                        break;
1724
1725                case 27:        /* depth */
1726                        sendart(3, 0, slval);
1727                        break;
1728
1729                case 28:        /* rate */
1730                        sendart(2, 0, slval);
1731                        break;
1732
1733                case 29:        /* intensity */
1734                        sendart(1, 0, slval);
1735                        break;
1736
1737                case 30:        /* cv1 */
1738                        sendart(11, 0, slval);
1739                        break;
1740
1741                case 31:        /* cv2 */
1742                        sendart(10, 0, slval);
1743                        break;
1744
1745                case 32:        /* cv3 */
1746                        sendart(6, 0, slval);
1747                        break;
1748
1749                case 33:        /* cv4 */
1750                        sendart(8, 0, slval);
1751                        break;
1752
1753                default:
1754                        slval = 0;      /* force unused pots to stay zero */
1755                        break;
1756                }
1757
1758                BGother[bar] = slval;
1759                barval = slval / 252;
1760                BarBadj(bar, barval);
1761
1762                return;
1763
1764
1765        case LS_EQ:             /* eq control */
1766
1767                barval = (((slval >> 5) - 500) << 6) / 252;
1768                BGeq[bar] = barval;
1769                sendeq(bar, gain2eq(SL2GAIN(slval)));
1770                BarCadj(bar, barval);
1771
1772                return;
1773
1774        default:
1775                return;
1776        }
1777}
1778
1779/*
1780   =============================================================================
1781        settmpo() -- set the tempo
1782   =============================================================================
1783*/
1784
1785void settmpo(int16_t val)
1786{
1787        register int16_t timeval;
1788
1789        tmpoval  = val;
1790        timeval  = ( ( (tmpomlt + 50) * tmpoval) / 100);
1791        timeval  = (int16_t)( (192000L / timeval) - 1);
1792        TIME_T2H = timeval >> 8;
1793        TIME_T2L = timeval & 0x00FF;
1794}
1795
1796/*
1797   =============================================================================
1798        settune() -- send the fine tuning from tuneval to the FPU
1799   =============================================================================
1800*/
1801
1802void settune(void)
1803{
1804        int16_t oldi, i, grp;
1805        volatile uint16_t *fpu;
1806        int32_t trval, trmax;
1807        int16_t nop;
1808
1809        trmax = PCHMAX;
1810
1811        oldi = setsr(0x2200);
1812
1813/* +++++++++++++++++++++++ FPU interrupts disabled ++++++++++++++++++++++++++ */
1814
1815        for (i = 0; i < 12; i++) {
1816
1817                if (-1 NE (grp = vce2grp[i])) {
1818
1819                        trval = (int32_t)tuneval + ((int32_t)s_trns[grp - 1] << 1);
1820
1821                        if (trval > trmax)
1822                                trval = trmax;
1823
1824                } else {
1825
1826                        trval = (int32_t)tuneval;
1827                }
1828
1829                fpu = io_fpu + FPU_OFNC + (i << 8) + 0x0010;    /* freq 1 */
1830
1831                *(fpu + FPU_TCV3) = (uint16_t)(0x0000FFFFL & trval);
1832                ++nop;  ++nop;  ++nop;
1833                *(fpu + FPU_TSF3) = 0x7FFF;
1834        }
1835
1836        setsr(oldi);
1837
1838/* ++++++++++++++++++++++++++++ Interrupts restored +++++++++++++++++++++++++ */
1839
1840}
1841
Note: See TracBrowser for help on using the repository browser.