2 * linux/arch/m68k/atari/config.c
4 * Copyright (C) 1994 Bjoern Brauel
7 * Added setting of time_adj to get a better clock.
12 * 5/15/94 Roman Hodek:
13 * hard_reset_now() for Atari (and others?)
15 * 94/12/30 Andreas Schwab:
16 * atari_sched_init fixed to get precise clock.
18 * This file is subject to the terms and conditions of the GNU General Public
19 * License. See the file COPYING in the main directory of this archive
24 * Miscellaneous atari stuff
27 #include <linux/config.h>
28 #include <linux/types.h>
30 #include <linux/console.h>
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/ioport.h>
34 #include <linux/vt_kern.h>
36 #include <asm/bootinfo.h>
37 #include <asm/setup.h>
38 #include <asm/atarihw.h>
39 #include <asm/atariints.h>
40 #include <asm/atari_stram.h>
41 #include <asm/system.h>
42 #include <asm/machdep.h>
43 #include <asm/hwtest.h>
46 u_long atari_mch_cookie;
47 u_long atari_mch_type;
48 struct atari_hw_present atari_hw_present;
49 u_long atari_switches;
50 int atari_dont_touch_floppy_select;
51 int atari_rtc_year_offset;
53 /* local function prototypes */
54 static void atari_reset( void );
55 static void atari_get_model(char *model);
56 static int atari_get_hardware_list(char *buffer);
58 /* atari specific irq functions */
59 extern void atari_init_IRQ (void);
60 extern void atari_mksound( unsigned int count, unsigned int ticks );
61 #ifdef CONFIG_HEARTBEAT
62 static void atari_heartbeat( int on );
65 /* atari specific timer functions (in time.c) */
66 extern void atari_sched_init(irqreturn_t (*)(int, void *, struct pt_regs *));
67 extern unsigned long atari_gettimeoffset (void);
68 extern int atari_mste_hwclk (int, struct rtc_time *);
69 extern int atari_tt_hwclk (int, struct rtc_time *);
70 extern int atari_mste_set_clock_mmss (unsigned long);
71 extern int atari_tt_set_clock_mmss (unsigned long);
73 /* atari specific debug functions (in debug.c) */
74 extern void atari_debug_init(void);
77 /* I've moved hwreg_present() and hwreg_present_bywrite() out into
78 * mm/hwtest.c, to avoid having multiple copies of the same routine
79 * in the kernel [I wanted them in hp300 and they were already used
80 * in the nubus code. NB: I don't have an Atari so this might (just
81 * conceivably) break something.
82 * I've preserved the #if 0 version of hwreg_present_bywrite() here
84 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk>, 05/1998
89 hwreg_present_bywrite(volatile void *regp, unsigned char val)
92 long save_sp, save_vbr;
93 static long tmp_vectors[3] = { [2] = (long)&&after_test };
96 ( "movec %/vbr,%2\n\t" /* save vbr value */
97 "movec %4,%/vbr\n\t" /* set up temporary vectors */
98 "movel %/sp,%1\n\t" /* save sp */
99 "moveq #0,%0\n\t" /* assume not present */
100 "moveb %5,%3@\n\t" /* write the hardware reg */
101 "cmpb %3@,%5\n\t" /* compare it */
102 "seq %0" /* comes here only if reg */
104 : "=d&" (ret), "=r&" (save_sp), "=r&" (save_vbr)
105 : "a" (regp), "r" (tmp_vectors), "d" (val)
109 ( "movel %0,%/sp\n\t" /* restore sp */
110 "movec %1,%/vbr" /* restore vbr */
111 : : "r" (save_sp), "r" (save_vbr) : "sp"
119 /* ++roman: This is a more elaborate test for an SCC chip, since the plain
120 * Medusa board generates DTACK at the SCC's standard addresses, but a SCC
121 * board in the Medusa is possible. Also, the addresses where the ST_ESCC
122 * resides generate DTACK without the chip, too.
123 * The method is to write values into the interrupt vector register, that
124 * should be readable without trouble (from channel A!).
127 static int __init scc_test( volatile char *ctla )
129 if (!hwreg_present( ctla ))
133 *ctla = 2; MFPDELAY();
134 *ctla = 0x40; MFPDELAY();
136 *ctla = 2; MFPDELAY();
137 if (*ctla != 0x40) return( 0 );
140 *ctla = 2; MFPDELAY();
141 *ctla = 0x60; MFPDELAY();
143 *ctla = 2; MFPDELAY();
144 if (*ctla != 0x60) return( 0 );
151 * Parse an Atari-specific record in the bootinfo
154 int __init atari_parse_bootinfo(const struct bi_record *record)
157 const u_long *data = record->data;
159 switch (record->tag) {
160 case BI_ATARI_MCH_COOKIE:
161 atari_mch_cookie = *data;
163 case BI_ATARI_MCH_TYPE:
164 atari_mch_type = *data;
173 /* Parse the Atari-specific switches= option. */
174 void __init atari_switches_setup( const char *str, unsigned len )
176 char switches[len+1];
179 char *args = switches;
181 /* copy string to local array, strsep works destructively... */
182 strlcpy( switches, str, sizeof(switches) );
185 /* parse the options */
186 while ((p = strsep(&args, ",")) != NULL) {
189 if (strncmp( p, "ov_", 3 ) == 0) {
191 ovsc_shift = ATARI_SWITCH_OVSC_SHIFT;
194 if (strcmp( p, "ikbd" ) == 0) {
195 /* RTS line of IKBD ACIA */
196 atari_switches |= ATARI_SWITCH_IKBD << ovsc_shift;
198 else if (strcmp( p, "midi" ) == 0) {
199 /* RTS line of MIDI ACIA */
200 atari_switches |= ATARI_SWITCH_MIDI << ovsc_shift;
202 else if (strcmp( p, "snd6" ) == 0) {
203 atari_switches |= ATARI_SWITCH_SND6 << ovsc_shift;
205 else if (strcmp( p, "snd7" ) == 0) {
206 atari_switches |= ATARI_SWITCH_SND7 << ovsc_shift;
213 * Setup the Atari configuration info
216 void __init config_atari(void)
218 unsigned short tos_version;
220 memset(&atari_hw_present, 0, sizeof(atari_hw_present));
224 ioport_resource.end = 0xFFFFFFFF; /* Change size of I/O space from 64KB
227 mach_sched_init = atari_sched_init;
228 mach_init_IRQ = atari_init_IRQ;
229 mach_get_model = atari_get_model;
230 mach_get_hardware_list = atari_get_hardware_list;
231 mach_gettimeoffset = atari_gettimeoffset;
232 mach_reset = atari_reset;
233 mach_max_dma_address = 0xffffff;
234 #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE)
235 mach_beep = atari_mksound;
237 #ifdef CONFIG_HEARTBEAT
238 mach_heartbeat = atari_heartbeat;
241 /* Set switches as requested by the user */
242 if (atari_switches & ATARI_SWITCH_IKBD)
243 acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID;
244 if (atari_switches & ATARI_SWITCH_MIDI)
245 acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
246 if (atari_switches & (ATARI_SWITCH_SND6|ATARI_SWITCH_SND7)) {
247 sound_ym.rd_data_reg_sel = 14;
248 sound_ym.wd_data = sound_ym.rd_data_reg_sel |
249 ((atari_switches&ATARI_SWITCH_SND6) ? 0x40 : 0) |
250 ((atari_switches&ATARI_SWITCH_SND7) ? 0x80 : 0);
254 * Determine hardware present
257 printk( "Atari hardware found: " );
258 if (MACH_IS_MEDUSA || MACH_IS_HADES) {
259 /* There's no Atari video hardware on the Medusa, but all the
260 * addresses below generate a DTACK so no bus error occurs! */
262 else if (hwreg_present( f030_xreg )) {
263 ATARIHW_SET(VIDEL_SHIFTER);
265 /* This is a temporary hack: If there is Falcon video
266 * hardware, we assume that the ST-DMA serves SCSI instead of
267 * ACSI. In the future, there should be a better method for
270 ATARIHW_SET(ST_SCSI);
271 printk( "STDMA-SCSI " );
273 else if (hwreg_present( tt_palette )) {
274 ATARIHW_SET(TT_SHIFTER);
275 printk( "TT_SHIFTER " );
277 else if (hwreg_present( &shifter.bas_hi )) {
278 if (hwreg_present( &shifter.bas_lo ) &&
279 (shifter.bas_lo = 0x0aau, shifter.bas_lo == 0x0aau)) {
280 ATARIHW_SET(EXTD_SHIFTER);
281 printk( "EXTD_SHIFTER " );
284 ATARIHW_SET(STND_SHIFTER);
285 printk( "STND_SHIFTER " );
288 if (hwreg_present( &mfp.par_dt_reg )) {
292 if (hwreg_present( &tt_mfp.par_dt_reg )) {
296 if (hwreg_present( &tt_scsi_dma.dma_addr_hi )) {
297 ATARIHW_SET(SCSI_DMA);
298 printk( "TT_SCSI_DMA " );
300 if (!MACH_IS_HADES && hwreg_present( &st_dma.dma_hi )) {
301 ATARIHW_SET(STND_DMA);
302 printk( "STND_DMA " );
304 if (MACH_IS_MEDUSA || /* The ST-DMA address registers aren't readable
305 * on all Medusas, so the test below may fail */
306 (hwreg_present( &st_dma.dma_vhi ) &&
307 (st_dma.dma_vhi = 0x55) && (st_dma.dma_hi = 0xaa) &&
308 st_dma.dma_vhi == 0x55 && st_dma.dma_hi == 0xaa &&
309 (st_dma.dma_vhi = 0xaa) && (st_dma.dma_hi = 0x55) &&
310 st_dma.dma_vhi == 0xaa && st_dma.dma_hi == 0x55)) {
311 ATARIHW_SET(EXTD_DMA);
312 printk( "EXTD_DMA " );
314 if (hwreg_present( &tt_scsi.scsi_data )) {
315 ATARIHW_SET(TT_SCSI);
316 printk( "TT_SCSI " );
318 if (hwreg_present( &sound_ym.rd_data_reg_sel )) {
319 ATARIHW_SET(YM_2149);
322 if (!MACH_IS_MEDUSA && !MACH_IS_HADES &&
323 hwreg_present( &tt_dmasnd.ctrl )) {
324 ATARIHW_SET(PCM_8BIT);
327 if (!MACH_IS_HADES && hwreg_present( &falcon_codec.unused5 )) {
331 if (hwreg_present( &dsp56k_host_interface.icr )) {
335 if (hwreg_present( &tt_scc_dma.dma_ctrl ) &&
337 /* This test sucks! Who knows some better? */
338 (tt_scc_dma.dma_ctrl = 0x01, (tt_scc_dma.dma_ctrl & 1) == 1) &&
339 (tt_scc_dma.dma_ctrl = 0x00, (tt_scc_dma.dma_ctrl & 1) == 0)
341 !MACH_IS_MEDUSA && !MACH_IS_HADES
344 ATARIHW_SET(SCC_DMA);
345 printk( "SCC_DMA " );
347 if (scc_test( &scc.cha_a_ctrl )) {
351 if (scc_test( &st_escc.cha_b_ctrl )) {
352 ATARIHW_SET( ST_ESCC );
353 printk( "ST_ESCC " );
360 else if (hwreg_present( &tt_scu.sys_mask )) {
362 /* Assume a VME bus if there's a SCU */
364 printk( "VME SCU " );
366 if (hwreg_present( (void *)(0xffff9210) )) {
367 ATARIHW_SET(ANALOG_JOY);
368 printk( "ANALOG_JOY " );
370 if (!MACH_IS_HADES && hwreg_present( blitter.halftone )) {
371 ATARIHW_SET(BLITTER);
372 printk( "BLITTER " );
374 if (hwreg_present((void *)0xfff00039)) {
378 #if 1 /* This maybe wrong */
379 if (!MACH_IS_MEDUSA && !MACH_IS_HADES &&
380 hwreg_present( &tt_microwire.data ) &&
381 hwreg_present( &tt_microwire.mask ) &&
382 (tt_microwire.mask = 0x7ff,
384 tt_microwire.data = MW_LM1992_PSG_HIGH | MW_LM1992_ADDR,
386 tt_microwire.data != 0)) {
387 ATARIHW_SET(MICROWIRE);
388 while (tt_microwire.mask != 0x7ff) ;
389 printk( "MICROWIRE " );
392 if (hwreg_present( &tt_rtc.regsel )) {
395 mach_hwclk = atari_tt_hwclk;
396 mach_set_clock_mmss = atari_tt_set_clock_mmss;
398 if (!MACH_IS_HADES && hwreg_present( &mste_rtc.sec_ones)) {
399 ATARIHW_SET(MSTE_CLK);
400 printk( "MSTE_CLK ");
401 mach_hwclk = atari_mste_hwclk;
402 mach_set_clock_mmss = atari_mste_set_clock_mmss;
404 if (!MACH_IS_MEDUSA && !MACH_IS_HADES &&
405 hwreg_present( &dma_wd.fdc_speed ) &&
406 hwreg_write( &dma_wd.fdc_speed, 0 )) {
407 ATARIHW_SET(FDCSPEED);
408 printk( "FDC_SPEED ");
410 if (!MACH_IS_HADES && !ATARIHW_PRESENT(ST_SCSI)) {
416 if (CPU_IS_040_OR_060)
417 /* Now it seems to be safe to turn of the tt0 transparent
418 * translation (the one that must not be turned off in
421 __asm__ volatile ("moveq #0,%/d0\n\t"
423 "movec %%d0,%%itt0\n\t"
424 "movec %%d0,%%dtt0\n\t"
430 /* allocator for memory that must reside in st-ram */
433 /* Set up a mapping for the VMEbus address region:
435 * VME is either at phys. 0xfexxxxxx (TT) or 0xa00000..0xdfffff
436 * (MegaSTE) In both cases, the whole 16 MB chunk is mapped at
437 * 0xfe000000 virt., because this can be done with a single
438 * transparent translation. On the 68040, lots of often unused
439 * page tables would be needed otherwise. On a MegaSTE or similar,
440 * the highest byte is stripped off by hardware due to the 24 bit
444 if (CPU_IS_020_OR_030) {
445 unsigned long tt1_val;
446 tt1_val = 0xfe008543; /* Translate 0xfexxxxxx, enable, cache
447 * inhibit, read and write, FDC mask = 3,
448 * FDC val = 4 -> Supervisor only */
449 __asm__ __volatile__ ( ".chip 68030\n\t"
450 "pmove %0@,%/tt1\n\t"
452 : : "a" (&tt1_val) );
456 ( "movel %0,%/d0\n\t"
458 "movec %%d0,%%itt1\n\t"
459 "movec %%d0,%%dtt1\n\t"
462 : "g" (0xfe00a040) /* Translate 0xfexxxxxx, enable,
463 * supervisor only, non-cacheable/
464 * serialized, writable */
469 /* Fetch tos version at Physical 2 */
470 /* We my not be able to access this address if the kernel is
471 loaded to st ram, since the first page is unmapped. On the
472 Medusa this is always the case and there is nothing we can do
473 about this, so we just assume the smaller offset. For the TT
474 we use the fact that in head.S we have set up a mapping
475 0xFFxxxxxx -> 0x00xxxxxx, so that the first 16MB is accessible
476 in the last 16MB of the address space. */
477 tos_version = (MACH_IS_MEDUSA || MACH_IS_HADES) ?
478 0xfff : *(unsigned short *)0xff000002;
479 atari_rtc_year_offset = (tos_version < 0x306) ? 70 : 68;
482 #ifdef CONFIG_HEARTBEAT
483 static void atari_heartbeat( int on )
488 if (atari_dont_touch_floppy_select)
491 local_irq_save(flags);
492 sound_ym.rd_data_reg_sel = 14; /* Select PSG Port A */
493 tmp = sound_ym.rd_data_reg_sel;
494 sound_ym.wd_data = on ? (tmp & ~0x02) : (tmp | 0x02);
495 local_irq_restore(flags);
501 * This function does a reset on machines that lack the ability to
502 * assert the processor's _RESET signal somehow via hardware. It is
503 * based on the fact that you can find the initial SP and PC values
504 * after a reset at physical addresses 0 and 4. This works pretty well
505 * for Atari machines, since the lowest 8 bytes of physical memory are
506 * really ROM (mapped by hardware). For other 680x0 machines: don't
507 * know if it works...
509 * To get the values at addresses 0 and 4, the MMU better is turned
510 * off first. After that, we have to jump into physical address space
511 * (the PC before the pmove statement points to the virtual address of
512 * the code). Getting that physical address is not hard, but the code
513 * becomes a bit complex since I've tried to ensure that the jump
514 * statement after the pmove is in the cache already (otherwise the
515 * processor can't fetch it!). For that, the code first jumps to the
516 * jump statement with the (virtual) address of the pmove section in
517 * an address register . The jump statement is surely in the cache
518 * now. After that, that physical address of the reset code is loaded
519 * into the same address register, pmove is done and the same jump
520 * statements goes to the reset code. Since there are not many
521 * statements between the two jumps, I hope it stays in the cache.
523 * The C code makes heavy use of the GCC features that you can get the
524 * address of a C label. No hope to compile this with another compiler
528 /* ++andreas: no need for complicated code, just depend on prefetch */
530 static void atari_reset (void)
535 /* On the Medusa, phys. 0x4 may contain garbage because it's no
536 ROM. See above for explanation why we cannot use PTOV(4). */
537 reset_addr = MACH_IS_HADES ? 0x7fe00030 :
538 MACH_IS_MEDUSA || MACH_IS_AB40 ? 0xe00030 :
539 *(unsigned long *) 0xff000004;
541 /* reset ACIA for switch off OverScan, if it's active */
542 if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
543 acia.key_ctrl = ACIA_RESET;
544 if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
545 acia.mid_ctrl = ACIA_RESET;
547 /* processor independent: turn off interrupts and reset the VBR;
548 * the caches must be left enabled, else prefetching the final jump
549 * instruction doesn't work. */
556 if (CPU_IS_040_OR_060) {
557 unsigned long jmp_addr040 = virt_to_phys(&&jmp_addr_label040);
559 /* 68060: clear PCR to turn off superscalar operation */
563 "movec %%d0,%%pcr\n\t"
570 "andl #0xff000000,%/d0\n\t"
571 "orw #0xe020,%/d0\n\t" /* map 16 MB, enable, cacheable */
573 "movec %%d0,%%itt0\n\t"
574 "movec %%d0,%%dtt0\n\t"
589 "movec %%d0,%%tc\n\t"
591 /* the following setup of transparent translations is needed on the
592 * Afterburner040 to successfully reboot. Other machines shouldn't
593 * care about a different tt regs setup, they also didn't care in
594 * the past that the regs weren't turned off. */
595 "movel #0xffc000,%%d0\n\t" /* whole insn space cacheable */
596 "movec %%d0,%%itt0\n\t"
597 "movec %%d0,%%itt1\n\t"
598 "orw #0x40,%/d0\n\t" /* whole data space non-cacheable/ser. */
599 "movec %%d0,%%dtt0\n\t"
600 "movec %%d0,%%dtt1\n\t"
609 ("pmove %0@,%/tc\n\t"
612 : "a" (&tc_val), "a" (reset_addr));
616 static void atari_get_model(char *model)
618 strcpy(model, "Atari ");
619 switch (atari_mch_cookie >> 16) {
621 if (ATARIHW_PRESENT(MSTE_CLK))
622 strcat (model, "Mega ST");
624 strcat (model, "ST");
628 strcat (model, "Mega STE");
630 strcat (model, "STE");
634 /* Medusa has TT _MCH cookie */
635 strcat (model, "Medusa");
636 else if (MACH_IS_HADES)
637 strcat(model, "Hades");
639 strcat (model, "TT");
641 case ATARI_MCH_FALCON:
642 strcat (model, "Falcon");
644 strcat (model, " (with Afterburner040)");
647 sprintf (model + strlen (model), "(unknown mach cookie 0x%lx)",
654 static int atari_get_hardware_list(char *buffer)
658 for (i = 0; i < m68k_num_memory; i++)
659 len += sprintf (buffer+len, "\t%3ld MB at 0x%08lx (%s)\n",
660 m68k_memory[i].size >> 20, m68k_memory[i].addr,
661 (m68k_memory[i].addr & 0xff000000 ?
662 "alternate RAM" : "ST-RAM"));
664 #define ATARIHW_ANNOUNCE(name,str) \
665 if (ATARIHW_PRESENT(name)) \
666 len += sprintf (buffer + len, "\t%s\n", str)
668 len += sprintf (buffer + len, "Detected hardware:\n");
669 ATARIHW_ANNOUNCE(STND_SHIFTER, "ST Shifter");
670 ATARIHW_ANNOUNCE(EXTD_SHIFTER, "STe Shifter");
671 ATARIHW_ANNOUNCE(TT_SHIFTER, "TT Shifter");
672 ATARIHW_ANNOUNCE(VIDEL_SHIFTER, "Falcon Shifter");
673 ATARIHW_ANNOUNCE(YM_2149, "Programmable Sound Generator");
674 ATARIHW_ANNOUNCE(PCM_8BIT, "PCM 8 Bit Sound");
675 ATARIHW_ANNOUNCE(CODEC, "CODEC Sound");
676 ATARIHW_ANNOUNCE(TT_SCSI, "SCSI Controller NCR5380 (TT style)");
677 ATARIHW_ANNOUNCE(ST_SCSI, "SCSI Controller NCR5380 (Falcon style)");
678 ATARIHW_ANNOUNCE(ACSI, "ACSI Interface");
679 ATARIHW_ANNOUNCE(IDE, "IDE Interface");
680 ATARIHW_ANNOUNCE(FDCSPEED, "8/16 Mhz Switch for FDC");
681 ATARIHW_ANNOUNCE(ST_MFP, "Multi Function Peripheral MFP 68901");
682 ATARIHW_ANNOUNCE(TT_MFP, "Second Multi Function Peripheral MFP 68901");
683 ATARIHW_ANNOUNCE(SCC, "Serial Communications Controller SCC 8530");
684 ATARIHW_ANNOUNCE(ST_ESCC, "Extended Serial Communications Controller SCC 85230");
685 ATARIHW_ANNOUNCE(ANALOG_JOY, "Paddle Interface");
686 ATARIHW_ANNOUNCE(MICROWIRE, "MICROWIRE(tm) Interface");
687 ATARIHW_ANNOUNCE(STND_DMA, "DMA Controller (24 bit)");
688 ATARIHW_ANNOUNCE(EXTD_DMA, "DMA Controller (32 bit)");
689 ATARIHW_ANNOUNCE(SCSI_DMA, "DMA Controller for NCR5380");
690 ATARIHW_ANNOUNCE(SCC_DMA, "DMA Controller for SCC");
691 ATARIHW_ANNOUNCE(TT_CLK, "Clock Chip MC146818A");
692 ATARIHW_ANNOUNCE(MSTE_CLK, "Clock Chip RP5C15");
693 ATARIHW_ANNOUNCE(SCU, "System Control Unit");
694 ATARIHW_ANNOUNCE(BLITTER, "Blitter");
695 ATARIHW_ANNOUNCE(VME, "VME Bus");
696 ATARIHW_ANNOUNCE(DSP56K, "DSP56001 processor");