![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cia.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to cia.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * CIA chip support
5: *
6: * Copyright 1995 Bernd Schmidt, Alessandro Bissacco
7: * Copyright 1996 Stefan Reinauer
8: */
9:
10: #include "sysconfig.h"
11: #include "sysdeps.h"
12: #include <assert.h>
13:
14: #include "config.h"
15: #include "options.h"
16: #include "events.h"
17: #include "memory.h"
18: #include "custom.h"
19: #include "cia.h"
20: #include "disk.h"
21: #include "xwin.h"
22: #include "keybuf.h"
23: #include "gui.h"
24:
25: #define DIV10 5 /* Yes, a bad identifier. */
26:
27: /* battclock stuff */
28: #define RTC_D_ADJ 8
29: #define RTC_D_IRQ 4
30: #define RTC_D_BUSY 2
31: #define RTC_D_HOLD 1
32: #define RTC_E_t1 8
33: #define RTC_E_t0 4
34: #define RTC_E_INTR 2
35: #define RTC_E_MASK 1
36: #define RTC_F_TEST 8
37: #define RTC_F_24_12 4
38: #define RTC_F_STOP 2
39: #define RTC_F_RSET 1
40:
41: static UBYTE clock_control_d = RTC_D_ADJ + RTC_D_HOLD;
42: static UBYTE clock_control_e = 0;
43: static UBYTE clock_control_f = RTC_F_24_12;
44:
45: static UBYTE ciaaicr,ciaaimask,ciabicr,ciabimask;
46: static UBYTE ciaacra,ciaacrb,ciabcra,ciabcrb;
47: static ULONG ciaata,ciaatb,ciabta,ciabtb;
48: static UWORD ciaala,ciaalb,ciabla,ciablb;
49: static ULONG ciaatod,ciabtod,ciaatol,ciabtol,ciaaalarm,ciabalarm;
50: static int ciaatodon, ciabtodon;
51: static int ciaatlatch,ciabtlatch;
52: static UBYTE ciaapra,ciaaprb,ciaadra,ciaadrb,ciaasdr;
53: static UBYTE ciabpra,ciabprb,ciabdra,ciabdrb,ciabsdr;
54: static int div10;
55: static int kbstate, kback;
56:
57: static int prtopen;
58: static FILE *prttmp;
59:
60: static void setclr(UBYTE *p, UBYTE val)
61: {
62: if (val & 0x80) {
63: *p |= val & 0x7F;
64: } else {
65: *p &= ~val;
66: }
67: }
68:
69: static void RethinkICRA(void)
70: {
71: if (ciaaimask & ciaaicr) {
72: ciaaicr |= 0x80;
73: custom_bank.wput(0xDFF09C,0x8008);
74: } else {
75: ciaaicr &= 0x7F;
76: /* custom_bank.wput(0xDFF09C,0x0008);*/
77: }
78: }
79:
80: static void RethinkICRB(void)
81: {
82: #if 0 /* ??? What's this then? */
83: if (ciabicr & 0x10) {
84: custom_bank.wput(0xDFF09C,0x9000);
85: }
86: #endif
87: if (ciabimask & ciabicr) {
88: ciabicr |= 0x80;
89: custom_bank.wput(0xDFF09C,0xA000);
90: } else {
91: ciabicr &= 0x7F;
92: /* custom_bank.wput(0xDFF09C,0x2000);*/
93: }
94: }
95:
96: static int lastdiv10;
97:
98: static void CIA_update(void)
99: {
100: unsigned long int ccount = cycles - eventtab[ev_cia].oldcycles + lastdiv10;
101: unsigned long int ciaclocks = ccount / DIV10;
102:
103: int aovfla = 0, aovflb = 0, bovfla = 0, bovflb = 0;
104:
105: lastdiv10 = div10;
106: div10 = ccount % DIV10;
107:
108: /* CIA A timers */
109: if ((ciaacra & 0x21) == 0x01) {
110: assert((ciaata+1) >= ciaclocks);
111: if ((ciaata+1) == ciaclocks) {
112: aovfla = 1;
113: if ((ciaacrb & 0x61) == 0x41) {
114: if (ciaatb-- == 0) aovflb = 1;
115: }
116: }
117: ciaata -= ciaclocks;
118: }
119: if ((ciaacrb & 0x61) == 0x01) {
120: assert((ciaatb+1) >= ciaclocks);
121: if ((ciaatb+1) == ciaclocks) aovflb = 1;
122: ciaatb -= ciaclocks;
123: }
124:
125: /* CIA B timers */
126: if ((ciabcra & 0x21) == 0x01) {
127: assert((ciabta+1) >= ciaclocks);
128: if ((ciabta+1) == ciaclocks) {
129: bovfla = 1;
130: if ((ciabcrb & 0x61) == 0x41) {
131: if (ciabtb-- == 0) bovflb = 1;
132: }
133: }
134: ciabta -= ciaclocks;
135: }
136: if ((ciabcrb & 0x61) == 0x01) {
137: assert ((ciabtb+1) >= ciaclocks);
138: if ((ciabtb+1) == ciaclocks) bovflb = 1;
139: ciabtb -= ciaclocks;
140: }
141: if (aovfla) {
142: ciaaicr |= 1; RethinkICRA();
143: ciaata = ciaala;
144: if (ciaacra & 0x8) ciaacra &= ~1;
145: }
146: if (aovflb) {
147: ciaaicr |= 2; RethinkICRA();
148: ciaatb = ciaalb;
149: if (ciaacrb & 0x8) ciaacrb &= ~1;
150: }
151: if (bovfla) {
152: ciabicr |= 1; RethinkICRB();
153: ciabta = ciabla;
154: if (ciabcra & 0x8) ciabcra &= ~1;
155: }
156: if (bovflb) {
157: ciabicr |= 2; RethinkICRB();
158: ciabtb = ciablb;
159: if (ciabcrb & 0x8) ciabcrb &= ~1;
160: }
161: }
162:
163: static void CIA_calctimers(void)
164: {
165: int ciaatimea = -1, ciaatimeb = -1, ciabtimea = -1, ciabtimeb = -1;
166:
167: eventtab[ev_cia].oldcycles = cycles;
168:
169: if ((ciaacra & 0x21) == 0x01) {
170: ciaatimea = (DIV10-div10) + DIV10*ciaata;
171: }
172: if ((ciaacrb & 0x61) == 0x41) {
173: /* Timer B will not get any pulses if Timer A is off. */
174: if (ciaatimea >= 0) {
175: /* If Timer A is in one-shot mode, and Timer B needs more than
176: * one pulse, it will not underflow. */
177: if (ciaatb == 0 || (ciaacra & 0x8) == 0) {
178: /* Otherwise, we can determine the time of the underflow. */
179: ciaatimeb = ciaatimea + ciaala * DIV10 * ciaatb;
180: }
181: }
182: }
183: if ((ciaacrb & 0x61) == 0x01) {
184: ciaatimeb = (DIV10-div10) + DIV10*ciaatb;
185: }
186:
187: if ((ciabcra & 0x21) == 0x01) {
188: ciabtimea = (DIV10-div10) + DIV10*ciabta;
189: }
190: if ((ciabcrb & 0x61) == 0x41) {
191: /* Timer B will not get any pulses if Timer A is off. */
192: if (ciabtimea >= 0) {
193: /* If Timer A is in one-shot mode, and Timer B needs more than
194: * one pulse, it will not underflow. */
195: if (ciabtb == 0 || (ciabcra & 0x8) == 0) {
196: /* Otherwise, we can determine the time of the underflow. */
197: ciabtimeb = ciabtimea + ciabla * DIV10 * ciabtb;
198: }
199: }
200: }
201: if ((ciabcrb & 0x61) == 0x01) {
202: ciabtimeb = (DIV10-div10) + DIV10*ciabtb;
203: }
204: eventtab[ev_cia].active = (ciaatimea != -1 || ciaatimeb != -1
205: || ciabtimea != -1 || ciabtimeb != -1);
206: if (eventtab[ev_cia].active) {
207: unsigned long int ciatime = ~0L;
208: if (ciaatimea != -1) ciatime = ciaatimea;
209: if (ciaatimeb != -1 && ciaatimeb < ciatime) ciatime = ciaatimeb;
210: if (ciabtimea != -1 && ciabtimea < ciatime) ciatime = ciabtimea;
211: if (ciabtimeb != -1 && ciabtimeb < ciatime) ciatime = ciabtimeb;
212: eventtab[ev_cia].evtime = ciatime + cycles;
213: }
214: events_schedule();
215: }
216:
217: void CIA_handler(void)
218: {
219: CIA_update();
220: CIA_calctimers();
221: }
222:
223: void diskindex_handler(void)
224: {
225: eventtab[ev_diskindex].evtime += cycles - eventtab[ev_diskindex].oldcycles;
226: eventtab[ev_diskindex].oldcycles = cycles;
227: /* printf(".\n");*/
228: ciabicr |= 0x10;
229: RethinkICRB();
230: }
231:
232: void CIA_hsync_handler(void)
233: {
234: static int keytime = 0;
235:
236: if (ciabtodon)
237: ciabtod++;
238: ciabtod &= 0xFFFFFF;
239:
240: if (ciabtod == ciabalarm) {
241: ciabicr |= 4; RethinkICRB();
242: }
243: if (keys_available() && kback && (++keytime & 15) == 0) {
244: switch(kbstate) {
245: case 0:
246: ciaasdr = (BYTE)~0xFB; /* aaarghh... stupid compiler */
247: kbstate++;
248: break;
249: case 1:
250: kbstate++;
251: ciaasdr = (BYTE)~0xFD;
252: break;
253: case 2:
254: ciaasdr = ~get_next_key();
255: break;
256: }
257: ciaaicr |= 8; RethinkICRA();
258: }
259: }
260:
261: void CIA_vsync_handler()
262: {
263: if (ciaatodon)
264: ciaatod++;
265: ciaatod &= 0xFFFFFF;
266: if (ciaatod == ciaaalarm) {
267: ciaaicr |= 4; RethinkICRA();
268: }
269: }
270:
271: static UBYTE ReadCIAA(UWORD addr)
272: {
273: UBYTE tmp;
274:
275: switch(addr & 0xf){
276: case 0:
277: tmp = (DISK_status() & 0x3C);
278: if (!buttonstate[0]) tmp |= 0x40;
279: if (!joy0button) tmp |= 0x80;
280: return tmp;
281: case 1:
282: return ciaaprb;
283: case 2:
284: return ciaadra;
285: case 3:
286: return ciaadrb;
287: case 4:
288: return ciaata & 0xff;
289: case 5:
290: return ciaata >> 8;
291: case 6:
292: return ciaatb & 0xff;
293: case 7:
294: return ciaatb >> 8;
295: case 8:
296: if (ciaatlatch) {
297: ciaatlatch = 0;
298: return ciaatol & 0xff;
299: } else return ciaatod & 0xff;
300: case 9:
301: if (ciaatlatch) return (ciaatol >> 8) & 0xff;
302: else return (ciaatod >> 8) & 0xff;
303: case 10:
304: ciaatlatch = 1; ciaatol = ciaatod; /* ??? only if not already latched? */
305: return (ciaatol >> 16) & 0xff;
306: case 12:
307: return ciaasdr;
308: case 13:
309: tmp = ciaaicr; ciaaicr = 0; RethinkICRA(); return tmp;
310: case 14:
311: return ciaacra;
312: case 15:
313: return ciaacrb;
314: }
315: return 0;
316: }
317:
318: static UBYTE ReadCIAB(UWORD addr)
319: {
320: UBYTE tmp;
321:
322: switch(addr & 0xf){
323: case 0:
324: fprintf (stderr,"ciabpra (Modem Register) read: 0x%02x\n",ciabpra);
325: return ciabpra;
326: case 1:
327: return ciabprb;
328: case 2:
329: return ciabdra;
330: case 3:
331: return ciabdrb;
332: case 4:
333: return ciabta & 0xff;
334: case 5:
335: return ciabta >> 8;
336: case 6:
337: return ciabtb & 0xff;
338: case 7:
339: return ciabtb >> 8;
340: case 8:
341: if (ciabtlatch) {
342: ciabtlatch = 0;
343: return ciabtol & 0xff;
344: } else return ciabtod & 0xff;
345: case 9:
346: if (ciabtlatch) return (ciabtol >> 8) & 0xff;
347: else return (ciabtod >> 8) & 0xff;
348: case 10:
349: ciabtlatch = 1; ciabtol = ciabtod;
350: return (ciabtol >> 16) & 0xff;
351: case 12:
352: return ciabsdr;
353: case 13:
354: tmp = ciabicr; ciabicr = 0; RethinkICRB();
355: return tmp;
356: case 14:
357: return ciabcra;
358: case 15:
359: return ciabcrb;
360: }
361: return 0;
362: }
363:
364: static void WriteCIAA(UWORD addr,UBYTE val)
365: {
366: int oldled;
367: switch(addr & 0xf){
368: case 0:
369: oldled = ciaapra & 2;
370: ciaapra = (ciaapra & ~0x3) | (val & 0x3); LED(ciaapra & 0x2);
371: if ((ciaapra & 2) != oldled)
372: gui_led (0, !(ciaapra & 2));
373: break;
374: case 1:
375: ciaaprb = val;
376: if (prtopen==1) {
377: #ifndef __DOS__
378: fprintf (prttmp,"%c",val);
379: #else
380: fputc (val, prttmp);
381: fflush (prttmp);
382: #endif
383: if (val==0x04) {
384: #if defined(__unix) && !defined(__bebox__) && !defined(__DOS__)
385: pclose (prttmp);
386: #else
387: fclose (prttmp);
388: #endif
389: prtopen = 0;
390: }
391: } else {
392: #if defined(__unix) && !defined(__bebox__) && !defined(__DOS__)
393: prttmp=(FILE *)popen ((char *)prtname,"w");
394: #else
395: prttmp=(FILE *)fopen ((char *)prtname,"wb");
396: #endif
397: if (prttmp != NULL) {
398: prtopen = 1;
399: #ifndef __DOS__
400: fprintf (prttmp,"%c",val);
401: #else
402: fputc (val, prttmp);
403: fflush (prttmp);
404: #endif
405: }
406: }
407: ciaaicr |= 0x10;
408: break;
409: case 2:
410: ciaadra = val; break;
411: case 3:
412: ciaadrb = val; break;
413: case 4:
414: CIA_update();
415: ciaala = (ciaala & 0xff00) | val;
416: CIA_calctimers();
417: break;
418: case 5:
419: CIA_update();
420: ciaala = (ciaala & 0xff) | (val << 8);
421: if ((ciaacra & 1) == 0)
422: ciaata = ciaala;
423: if (ciaacra & 8) {
424: ciaata = ciaala;
425: ciaacra |= 1;
426: }
427: CIA_calctimers();
428: break;
429: case 6:
430: CIA_update();
431: ciaalb = (ciaalb & 0xff00) | val;
432: CIA_calctimers();
433: break;
434: case 7:
435: CIA_update();
436: ciaalb = (ciaalb & 0xff) | (val << 8);
437: if ((ciaacrb & 1) == 0)
438: ciaatb = ciaalb;
439: if (ciaacrb & 8) {
440: ciaatb = ciaalb;
441: ciaacrb |= 1;
442: }
443: CIA_calctimers();
444: break;
445: case 8:
446: if (ciaacrb & 0x80){
447: ciaaalarm = (ciaaalarm & ~0xff) | val;
448: } else {
449: ciaatod = (ciaatod & ~0xff) | val;
450: ciaatodon = 1;
451: }
452: break;
453: case 9:
454: if (ciaacrb & 0x80){
455: ciaaalarm = (ciaaalarm & ~0xff00) | (val << 8);
456: } else {
457: ciaatod = (ciaatod & ~0xff00) | (val << 8);
458: ciaatodon = 0;
459: }
460: break;
461: case 10:
462: if (ciaacrb & 0x80){
463: ciaaalarm = (ciaaalarm & ~0xff0000) | (val << 16);
464: } else {
465: ciaatod = (ciaatod & ~0xff0000) | (val << 16);
466: ciaatodon = 0;
467: }
468: break;
469: case 12:
470: ciaasdr = val; break;
471: case 13:
472: setclr(&ciaaimask,val); break; /* ??? call RethinkICR() ? */
473: case 14:
474: CIA_update();
475: ciaacra = val;
476: if (ciaacra & 0x10){
477: ciaacra &= ~0x10;
478: ciaata = ciaala;
479: }
480: if (ciaacra & 0x40) {
481: kback = 1;
482: }
483: CIA_calctimers();
484: break;
485: case 15:
486: CIA_update();
487: ciaacrb = val;
488: if (ciaacrb & 0x10){
489: ciaacrb &= ~0x10;
490: ciaatb = ciaalb;
491: }
492: CIA_calctimers();
493: break;
494: }
495: }
496:
497: static void WriteCIAB(UWORD addr,UBYTE val)
498: {
499: switch(addr & 0xf){
500: case 0:
501: ciabpra = (ciabpra & ~0x3) | (val & 0x3); break;
502: case 1:
503: ciabprb = val; DISK_select(val); break;
504: case 2:
505: ciabdra = val; break;
506: case 3:
507: ciabdrb = val; break;
508: case 4:
509: CIA_update();
510: ciabla = (ciabla & 0xff00) | val;
511: CIA_calctimers();
512: break;
513: case 5:
514: CIA_update();
515: ciabla = (ciabla & 0xff) | (val << 8);
516: if ((ciabcra & 1) == 0)
517: ciabta = ciabla;
518: if (ciabcra & 8) {
519: ciabta = ciabla;
520: ciabcra |= 1;
521: }
522: CIA_calctimers();
523: break;
524: case 6:
525: CIA_update();
526: ciablb = (ciablb & 0xff00) | val;
527: CIA_calctimers();
528: break;
529: case 7:
530: CIA_update();
531: ciablb = (ciablb & 0xff) | (val << 8);
532: if ((ciabcrb & 1) == 0)
533: ciabtb = ciablb;
534: if (ciabcrb & 8) {
535: ciabtb = ciablb;
536: ciabcrb |= 1;
537: }
538: CIA_calctimers();
539: break;
540: case 8:
541: if (ciabcrb & 0x80){
542: ciabalarm = (ciabalarm & ~0xff) | val;
543: } else {
544: ciabtod = (ciabtod & ~0xff) | val;
545: ciabtodon = 1;
546: }
547: break;
548: case 9:
549: if (ciabcrb & 0x80){
550: ciabalarm = (ciabalarm & ~0xff00) | (val << 8);
551: } else {
552: ciabtod = (ciabtod & ~0xff00) | (val << 8);
553: ciabtodon = 0;
554: }
555: break;
556: case 10:
557: if (ciabcrb & 0x80){
558: ciabalarm = (ciabalarm & ~0xff0000) | (val << 16);
559: } else {
560: ciabtod = (ciabtod & ~0xff0000) | (val << 16);
561: ciabtodon = 0;
562: }
563: break;
564: case 12:
565: ciabsdr = val;
566: break;
567: case 13:
568: setclr(&ciabimask,val);
569: break;
570: case 14:
571: CIA_update();
572: ciabcra = val;
573: if (ciabcra & 0x10){
574: ciabcra &= ~0x10;
575: ciabta = ciabla;
576: }
577: CIA_calctimers();
578: break;
579: case 15:
580: CIA_update();
581: ciabcrb = val;
582: if (ciabcrb & 0x10){
583: ciabcrb &= ~0x10;
584: ciabtb = ciablb;
585: }
586: CIA_calctimers();
587: break;
588: }
589: }
590:
591: void CIA_reset(void)
592: {
593: kback = 1;
594: kbstate = 0;
595:
596: ciaatlatch = ciabtlatch = 0;
597: ciaatod = ciabtod = 0; ciaatodon = ciabtodon = 0;
598: ciaaicr = ciabicr = ciaaimask = ciabimask = 0;
599: ciaacra = ciaacrb = ciabcra = ciabcrb = 0x4; /* outmode = toggle; */
600: ciaala = ciaalb = ciabla = ciablb = ciaata = ciaatb = ciabta = ciabtb = 0xFFFF;
601: div10 = 0;
602: lastdiv10 = 0;
603: CIA_calctimers();
604:
605: ciabpra = 0xDC;
606: }
607:
608: void dumpcia(void)
609: {
610: printf("A: CRA: %02x, CRB: %02x, IMASK: %02x, TOD: %08lx %7s TA: %04lx, TB: %04lx\n",
611: (int)ciaacra, (int)ciaacrb, (int)ciaaimask, ciaatod,
612: ciaatlatch ? " latched" : "", ciaata, ciaatb);
613: printf("B: CRA: %02x, CRB: %02x, IMASK: %02x, TOD: %08lx %7s TA: %04lx, TB: %04lx\n",
614: (int)ciabcra, (int)ciabcrb, (int)ciabimask, ciabtod,
615: ciabtlatch ? " latched" : "", ciabta, ciabtb);
616: }
617:
618: /* CIA memory access */
619:
620: static ULONG cia_lget(CPTR) REGPARAM;
621: static UWORD cia_wget(CPTR) REGPARAM;
622: static UBYTE cia_bget(CPTR) REGPARAM;
623: static void cia_lput(CPTR, ULONG) REGPARAM;
624: static void cia_wput(CPTR, UWORD) REGPARAM;
625: static void cia_bput(CPTR, UBYTE) REGPARAM;
626:
627: addrbank cia_bank = {
628: default_alget, default_awget,
629: cia_lget, cia_wget, cia_bget,
630: cia_lput, cia_wput, cia_bput,
631: default_xlate, default_check
632: };
633:
634: ULONG cia_lget(CPTR addr)
635: {
636: return cia_bget(addr+3);
637: }
638:
639: UWORD cia_wget(CPTR addr)
640: {
641: return cia_bget(addr+1);
642: }
643:
644: UBYTE cia_bget(CPTR addr)
645: {
646: if ((addr & 0x3001) == 0x2001)
647: return ReadCIAA((addr & 0xF00) >> 8);
648: if ((addr & 0x3001) == 0x1000)
649: return ReadCIAB((addr & 0xF00) >> 8);
650: return 0;
651: }
652:
653: void cia_lput(CPTR addr, ULONG value)
654: {
655: cia_bput(addr+3,value); /* FIXME ? */
656: }
657:
658: void cia_wput(CPTR addr, UWORD value)
659: {
660: cia_bput(addr+1,value);
661: }
662:
663: void cia_bput(CPTR addr, UBYTE value)
664: {
665: if ((addr & 0x3001) == 0x2001)
666: WriteCIAA((addr & 0xF00) >> 8,value);
667: if ((addr & 0x3001) == 0x1000)
668: WriteCIAB((addr & 0xF00) >> 8,value);
669: }
670:
671: /* battclock memory access */
672:
673: static ULONG clock_lget(CPTR) REGPARAM;
674: static UWORD clock_wget(CPTR) REGPARAM;
675: static UBYTE clock_bget(CPTR) REGPARAM;
676: static void clock_lput(CPTR, ULONG) REGPARAM;
677: static void clock_wput(CPTR, UWORD) REGPARAM;
678: static void clock_bput(CPTR, UBYTE) REGPARAM;
679:
680: addrbank clock_bank = {
681: default_alget, default_awget,
682: clock_lget, clock_wget, clock_bget,
683: clock_lput, clock_wput, clock_bput,
684: default_xlate, default_check
685: };
686:
687: ULONG clock_lget(CPTR addr)
688: {
689: return clock_bget(addr+3);
690: }
691:
692: UWORD clock_wget(CPTR addr)
693: {
694: return clock_bget(addr+1);
695: }
696:
697: UBYTE clock_bget(CPTR addr)
698: {
699: time_t t=time(0);
700: struct tm *ct;
701: ct=localtime(&t);
702: switch (addr & 0x3f)
703: {
704: case 0x03: return ct->tm_sec % 10;
705: case 0x07: return ct->tm_sec / 10;
706: case 0x0b: return ct->tm_min % 10;
707: case 0x0f: return ct->tm_min / 10;
708: case 0x13: return ct->tm_hour % 10;
709: case 0x17: return ct->tm_hour / 10;
710: case 0x1b: return ct->tm_mday % 10;
711: case 0x1f: return ct->tm_mday / 10;
712: case 0x23: return (ct->tm_mon+1) % 10;
713: case 0x27: return (ct->tm_mon+1) / 10;
714: case 0x2b: return ct->tm_year % 10;
715: case 0x2f: return ct->tm_year / 10;
716:
717: case 0x33: return ct->tm_wday; /*Hack by -=SR=- */
718: case 0x37: return clock_control_d;
719: case 0x3b: return clock_control_e;
720: case 0x3f: return clock_control_f;
721: }
722: return 0;
723: }
724:
725: void clock_lput(CPTR addr, ULONG value)
726: {
727: /* No way */
728: }
729:
730: void clock_wput(CPTR addr, UWORD value)
731: {
732: /* No way */
733: }
734:
735: void clock_bput(CPTR addr, UBYTE value)
736: {
737: switch (addr & 0x3f)
738: {
739: case 0x37: clock_control_d=value; break;
740: case 0x3b: clock_control_e=value; break;
741: case 0x3f: clock_control_f=value; break;
742: }
743: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.