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/types.h>
29 #include <linux/seq_file.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>
35 #include <linux/module.h>
37 #include <asm/bootinfo.h>
38 #include <asm/setup.h>
39 #include <asm/atarihw.h>
40 #include <asm/atariints.h>
41 #include <asm/atari_stram.h>
42 #include <asm/machdep.h>
43 #include <asm/hwtest.h>
46 u_long atari_mch_cookie
;
47 EXPORT_SYMBOL(atari_mch_cookie
);
49 u_long atari_mch_type
;
50 EXPORT_SYMBOL(atari_mch_type
);
52 struct atari_hw_present atari_hw_present
;
53 EXPORT_SYMBOL(atari_hw_present
);
55 u_long atari_switches
;
56 EXPORT_SYMBOL(atari_switches
);
58 int atari_dont_touch_floppy_select
;
59 EXPORT_SYMBOL(atari_dont_touch_floppy_select
);
61 int atari_rtc_year_offset
;
63 /* local function prototypes */
64 static void atari_reset(void);
65 static void atari_get_model(char *model
);
66 static void atari_get_hardware_list(struct seq_file
*m
);
68 /* atari specific irq functions */
69 extern void atari_init_IRQ (void);
70 extern void atari_mksound(unsigned int count
, unsigned int ticks
);
71 #ifdef CONFIG_HEARTBEAT
72 static void atari_heartbeat(int on
);
75 /* atari specific timer functions (in time.c) */
76 extern void atari_sched_init(irq_handler_t
);
77 extern unsigned long atari_gettimeoffset (void);
78 extern int atari_mste_hwclk (int, struct rtc_time
*);
79 extern int atari_tt_hwclk (int, struct rtc_time
*);
80 extern int atari_mste_set_clock_mmss (unsigned long);
81 extern int atari_tt_set_clock_mmss (unsigned long);
84 /* ++roman: This is a more elaborate test for an SCC chip, since the plain
85 * Medusa board generates DTACK at the SCC's standard addresses, but a SCC
86 * board in the Medusa is possible. Also, the addresses where the ST_ESCC
87 * resides generate DTACK without the chip, too.
88 * The method is to write values into the interrupt vector register, that
89 * should be readable without trouble (from channel A!).
92 static int __init
scc_test(volatile char *ctla
)
94 if (!hwreg_present(ctla
))
124 * Parse an Atari-specific record in the bootinfo
127 int __init
atari_parse_bootinfo(const struct bi_record
*record
)
130 const u_long
*data
= record
->data
;
132 switch (record
->tag
) {
133 case BI_ATARI_MCH_COOKIE
:
134 atari_mch_cookie
= *data
;
136 case BI_ATARI_MCH_TYPE
:
137 atari_mch_type
= *data
;
147 /* Parse the Atari-specific switches= option. */
148 static int __init
atari_switches_setup(char *str
)
150 char switches
[strlen(str
) + 1];
153 char *args
= switches
;
158 /* copy string to local array, strsep works destructively... */
159 strcpy(switches
, str
);
162 /* parse the options */
163 while ((p
= strsep(&args
, ",")) != NULL
) {
167 if (strncmp(p
, "ov_", 3) == 0) {
169 ovsc_shift
= ATARI_SWITCH_OVSC_SHIFT
;
172 if (strcmp(p
, "ikbd") == 0) {
173 /* RTS line of IKBD ACIA */
174 atari_switches
|= ATARI_SWITCH_IKBD
<< ovsc_shift
;
175 } else if (strcmp(p
, "midi") == 0) {
176 /* RTS line of MIDI ACIA */
177 atari_switches
|= ATARI_SWITCH_MIDI
<< ovsc_shift
;
178 } else if (strcmp(p
, "snd6") == 0) {
179 atari_switches
|= ATARI_SWITCH_SND6
<< ovsc_shift
;
180 } else if (strcmp(p
, "snd7") == 0) {
181 atari_switches
|= ATARI_SWITCH_SND7
<< ovsc_shift
;
187 early_param("switches", atari_switches_setup
);
191 * Setup the Atari configuration info
194 void __init
config_atari(void)
196 unsigned short tos_version
;
198 memset(&atari_hw_present
, 0, sizeof(atari_hw_present
));
200 /* Change size of I/O space from 64KB to 4GB. */
201 ioport_resource
.end
= 0xFFFFFFFF;
203 mach_sched_init
= atari_sched_init
;
204 mach_init_IRQ
= atari_init_IRQ
;
205 mach_get_model
= atari_get_model
;
206 mach_get_hardware_list
= atari_get_hardware_list
;
207 mach_gettimeoffset
= atari_gettimeoffset
;
208 mach_reset
= atari_reset
;
209 mach_max_dma_address
= 0xffffff;
210 #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE)
211 mach_beep
= atari_mksound
;
213 #ifdef CONFIG_HEARTBEAT
214 mach_heartbeat
= atari_heartbeat
;
217 /* Set switches as requested by the user */
218 if (atari_switches
& ATARI_SWITCH_IKBD
)
219 acia
.key_ctrl
= ACIA_DIV64
| ACIA_D8N1S
| ACIA_RHTID
;
220 if (atari_switches
& ATARI_SWITCH_MIDI
)
221 acia
.mid_ctrl
= ACIA_DIV16
| ACIA_D8N1S
| ACIA_RHTID
;
222 if (atari_switches
& (ATARI_SWITCH_SND6
|ATARI_SWITCH_SND7
)) {
223 sound_ym
.rd_data_reg_sel
= 14;
224 sound_ym
.wd_data
= sound_ym
.rd_data_reg_sel
|
225 ((atari_switches
&ATARI_SWITCH_SND6
) ? 0x40 : 0) |
226 ((atari_switches
&ATARI_SWITCH_SND7
) ? 0x80 : 0);
230 * Determine hardware present
233 printk("Atari hardware found: ");
234 if (MACH_IS_MEDUSA
) {
235 /* There's no Atari video hardware on the Medusa, but all the
236 * addresses below generate a DTACK so no bus error occurs! */
237 } else if (hwreg_present(f030_xreg
)) {
238 ATARIHW_SET(VIDEL_SHIFTER
);
240 /* This is a temporary hack: If there is Falcon video
241 * hardware, we assume that the ST-DMA serves SCSI instead of
242 * ACSI. In the future, there should be a better method for
245 ATARIHW_SET(ST_SCSI
);
246 printk("STDMA-SCSI ");
247 } else if (hwreg_present(tt_palette
)) {
248 ATARIHW_SET(TT_SHIFTER
);
249 printk("TT_SHIFTER ");
250 } else if (hwreg_present(&shifter
.bas_hi
)) {
251 if (hwreg_present(&shifter
.bas_lo
) &&
252 (shifter
.bas_lo
= 0x0aau
, shifter
.bas_lo
== 0x0aau
)) {
253 ATARIHW_SET(EXTD_SHIFTER
);
254 printk("EXTD_SHIFTER ");
256 ATARIHW_SET(STND_SHIFTER
);
257 printk("STND_SHIFTER ");
260 if (hwreg_present(&st_mfp
.par_dt_reg
)) {
264 if (hwreg_present(&tt_mfp
.par_dt_reg
)) {
268 if (hwreg_present(&tt_scsi_dma
.dma_addr_hi
)) {
269 ATARIHW_SET(SCSI_DMA
);
270 printk("TT_SCSI_DMA ");
273 * The ST-DMA address registers aren't readable
274 * on all Medusas, so the test below may fail
276 if (MACH_IS_MEDUSA
||
277 (hwreg_present(&st_dma
.dma_vhi
) &&
278 (st_dma
.dma_vhi
= 0x55) && (st_dma
.dma_hi
= 0xaa) &&
279 st_dma
.dma_vhi
== 0x55 && st_dma
.dma_hi
== 0xaa &&
280 (st_dma
.dma_vhi
= 0xaa) && (st_dma
.dma_hi
= 0x55) &&
281 st_dma
.dma_vhi
== 0xaa && st_dma
.dma_hi
== 0x55)) {
282 ATARIHW_SET(EXTD_DMA
);
285 if (hwreg_present(&tt_scsi
.scsi_data
)) {
286 ATARIHW_SET(TT_SCSI
);
289 if (hwreg_present(&sound_ym
.rd_data_reg_sel
)) {
290 ATARIHW_SET(YM_2149
);
293 if (!MACH_IS_MEDUSA
&& hwreg_present(&tt_dmasnd
.ctrl
)) {
294 ATARIHW_SET(PCM_8BIT
);
297 if (hwreg_present(&falcon_codec
.unused5
)) {
301 if (hwreg_present(&dsp56k_host_interface
.icr
)) {
305 if (hwreg_present(&tt_scc_dma
.dma_ctrl
) &&
307 /* This test sucks! Who knows some better? */
308 (tt_scc_dma
.dma_ctrl
= 0x01, (tt_scc_dma
.dma_ctrl
& 1) == 1) &&
309 (tt_scc_dma
.dma_ctrl
= 0x00, (tt_scc_dma
.dma_ctrl
& 1) == 0)
314 ATARIHW_SET(SCC_DMA
);
317 if (scc_test(&atari_scc
.cha_a_ctrl
)) {
321 if (scc_test(&st_escc
.cha_b_ctrl
)) {
322 ATARIHW_SET(ST_ESCC
);
325 if (hwreg_present(&tt_scu
.sys_mask
)) {
327 /* Assume a VME bus if there's a SCU */
331 if (hwreg_present((void *)(0xffff9210))) {
332 ATARIHW_SET(ANALOG_JOY
);
333 printk("ANALOG_JOY ");
335 if (hwreg_present(blitter
.halftone
)) {
336 ATARIHW_SET(BLITTER
);
339 if (hwreg_present((void *)0xfff00039)) {
343 #if 1 /* This maybe wrong */
344 if (!MACH_IS_MEDUSA
&& hwreg_present(&tt_microwire
.data
) &&
345 hwreg_present(&tt_microwire
.mask
) &&
346 (tt_microwire
.mask
= 0x7ff,
348 tt_microwire
.data
= MW_LM1992_PSG_HIGH
| MW_LM1992_ADDR
,
350 tt_microwire
.data
!= 0)) {
351 ATARIHW_SET(MICROWIRE
);
352 while (tt_microwire
.mask
!= 0x7ff)
354 printk("MICROWIRE ");
357 if (hwreg_present(&tt_rtc
.regsel
)) {
360 mach_hwclk
= atari_tt_hwclk
;
361 mach_set_clock_mmss
= atari_tt_set_clock_mmss
;
363 if (hwreg_present(&mste_rtc
.sec_ones
)) {
364 ATARIHW_SET(MSTE_CLK
);
366 mach_hwclk
= atari_mste_hwclk
;
367 mach_set_clock_mmss
= atari_mste_set_clock_mmss
;
369 if (!MACH_IS_MEDUSA
&& hwreg_present(&dma_wd
.fdc_speed
) &&
370 hwreg_write(&dma_wd
.fdc_speed
, 0)) {
371 ATARIHW_SET(FDCSPEED
);
372 printk("FDC_SPEED ");
374 if (!ATARIHW_PRESENT(ST_SCSI
)) {
380 if (CPU_IS_040_OR_060
)
381 /* Now it seems to be safe to turn of the tt0 transparent
382 * translation (the one that must not be turned off in
388 " movec %%d0,%%itt0\n"
389 " movec %%d0,%%dtt0\n"
395 /* allocator for memory that must reside in st-ram */
398 /* Set up a mapping for the VMEbus address region:
400 * VME is either at phys. 0xfexxxxxx (TT) or 0xa00000..0xdfffff
401 * (MegaSTE) In both cases, the whole 16 MB chunk is mapped at
402 * 0xfe000000 virt., because this can be done with a single
403 * transparent translation. On the 68040, lots of often unused
404 * page tables would be needed otherwise. On a MegaSTE or similar,
405 * the highest byte is stripped off by hardware due to the 24 bit
409 if (CPU_IS_020_OR_030
) {
410 unsigned long tt1_val
;
411 tt1_val
= 0xfe008543; /* Translate 0xfexxxxxx, enable, cache
412 * inhibit, read and write, FDC mask = 3,
413 * FDC val = 4 -> Supervisor only */
426 : "d" (0xfe00a040)); /* Translate 0xfexxxxxx, enable,
427 * supervisor only, non-cacheable/
428 * serialized, writable */
432 /* Fetch tos version at Physical 2 */
434 * We my not be able to access this address if the kernel is
435 * loaded to st ram, since the first page is unmapped. On the
436 * Medusa this is always the case and there is nothing we can do
437 * about this, so we just assume the smaller offset. For the TT
438 * we use the fact that in head.S we have set up a mapping
439 * 0xFFxxxxxx -> 0x00xxxxxx, so that the first 16MB is accessible
440 * in the last 16MB of the address space.
442 tos_version
= (MACH_IS_MEDUSA
) ?
443 0xfff : *(unsigned short *)0xff000002;
444 atari_rtc_year_offset
= (tos_version
< 0x306) ? 70 : 68;
447 #ifdef CONFIG_HEARTBEAT
448 static void atari_heartbeat(int on
)
453 if (atari_dont_touch_floppy_select
)
456 local_irq_save(flags
);
457 sound_ym
.rd_data_reg_sel
= 14; /* Select PSG Port A */
458 tmp
= sound_ym
.rd_data_reg_sel
;
459 sound_ym
.wd_data
= on
? (tmp
& ~0x02) : (tmp
| 0x02);
460 local_irq_restore(flags
);
466 * This function does a reset on machines that lack the ability to
467 * assert the processor's _RESET signal somehow via hardware. It is
468 * based on the fact that you can find the initial SP and PC values
469 * after a reset at physical addresses 0 and 4. This works pretty well
470 * for Atari machines, since the lowest 8 bytes of physical memory are
471 * really ROM (mapped by hardware). For other 680x0 machines: don't
472 * know if it works...
474 * To get the values at addresses 0 and 4, the MMU better is turned
475 * off first. After that, we have to jump into physical address space
476 * (the PC before the pmove statement points to the virtual address of
477 * the code). Getting that physical address is not hard, but the code
478 * becomes a bit complex since I've tried to ensure that the jump
479 * statement after the pmove is in the cache already (otherwise the
480 * processor can't fetch it!). For that, the code first jumps to the
481 * jump statement with the (virtual) address of the pmove section in
482 * an address register . The jump statement is surely in the cache
483 * now. After that, that physical address of the reset code is loaded
484 * into the same address register, pmove is done and the same jump
485 * statements goes to the reset code. Since there are not many
486 * statements between the two jumps, I hope it stays in the cache.
488 * The C code makes heavy use of the GCC features that you can get the
489 * address of a C label. No hope to compile this with another compiler
493 /* ++andreas: no need for complicated code, just depend on prefetch */
495 static void atari_reset(void)
501 * On the Medusa, phys. 0x4 may contain garbage because it's no
502 * ROM. See above for explanation why we cannot use PTOV(4).
504 reset_addr
= MACH_IS_MEDUSA
|| MACH_IS_AB40
? 0xe00030 :
505 *(unsigned long *) 0xff000004;
507 /* reset ACIA for switch off OverScan, if it's active */
508 if (atari_switches
& ATARI_SWITCH_OVSC_IKBD
)
509 acia
.key_ctrl
= ACIA_RESET
;
510 if (atari_switches
& ATARI_SWITCH_OVSC_MIDI
)
511 acia
.mid_ctrl
= ACIA_RESET
;
513 /* processor independent: turn off interrupts and reset the VBR;
514 * the caches must be left enabled, else prefetching the final jump
515 * instruction doesn't work.
518 asm volatile ("movec %0,%%vbr"
521 if (CPU_IS_040_OR_060
) {
522 unsigned long jmp_addr040
= virt_to_phys(&&jmp_addr_label040
);
524 /* 68060: clear PCR to turn off superscalar operation */
534 " and.l #0xff000000,%%d0\n"
535 " or.w #0xe020,%%d0\n" /* map 16 MB, enable, cacheable */
537 " movec %%d0,%%itt0\n"
538 " movec %%d0,%%dtt0\n"
541 : : "a" (jmp_addr040
)
554 /* the following setup of transparent translations is needed on the
555 * Afterburner040 to successfully reboot. Other machines shouldn't
556 * care about a different tt regs setup, they also didn't care in
557 * the past that the regs weren't turned off. */
558 " move.l #0xffc000,%%d0\n" /* whole insn space cacheable */
559 " movec %%d0,%%itt0\n"
560 " movec %%d0,%%itt1\n"
561 " or.w #0x40,%/d0\n" /* whole data space non-cacheable/ser. */
562 " movec %%d0,%%dtt0\n"
563 " movec %%d0,%%dtt1\n"
574 : "m" (tc_val
), "a" (reset_addr
));
578 static void atari_get_model(char *model
)
580 strcpy(model
, "Atari ");
581 switch (atari_mch_cookie
>> 16) {
583 if (ATARIHW_PRESENT(MSTE_CLK
))
584 strcat(model
, "Mega ST");
590 strcat(model
, "Mega STE");
592 strcat(model
, "STE");
596 /* Medusa has TT _MCH cookie */
597 strcat(model
, "Medusa");
601 case ATARI_MCH_FALCON
:
602 strcat(model
, "Falcon");
604 strcat(model
, " (with Afterburner040)");
607 sprintf(model
+ strlen(model
), "(unknown mach cookie 0x%lx)",
614 static void atari_get_hardware_list(struct seq_file
*m
)
618 for (i
= 0; i
< m68k_num_memory
; i
++)
619 seq_printf(m
, "\t%3ld MB at 0x%08lx (%s)\n",
620 m68k_memory
[i
].size
>> 20, m68k_memory
[i
].addr
,
621 (m68k_memory
[i
].addr
& 0xff000000 ?
622 "alternate RAM" : "ST-RAM"));
624 #define ATARIHW_ANNOUNCE(name, str) \
625 if (ATARIHW_PRESENT(name)) \
626 seq_printf(m, "\t%s\n", str)
628 seq_printf(m
, "Detected hardware:\n");
629 ATARIHW_ANNOUNCE(STND_SHIFTER
, "ST Shifter");
630 ATARIHW_ANNOUNCE(EXTD_SHIFTER
, "STe Shifter");
631 ATARIHW_ANNOUNCE(TT_SHIFTER
, "TT Shifter");
632 ATARIHW_ANNOUNCE(VIDEL_SHIFTER
, "Falcon Shifter");
633 ATARIHW_ANNOUNCE(YM_2149
, "Programmable Sound Generator");
634 ATARIHW_ANNOUNCE(PCM_8BIT
, "PCM 8 Bit Sound");
635 ATARIHW_ANNOUNCE(CODEC
, "CODEC Sound");
636 ATARIHW_ANNOUNCE(TT_SCSI
, "SCSI Controller NCR5380 (TT style)");
637 ATARIHW_ANNOUNCE(ST_SCSI
, "SCSI Controller NCR5380 (Falcon style)");
638 ATARIHW_ANNOUNCE(ACSI
, "ACSI Interface");
639 ATARIHW_ANNOUNCE(IDE
, "IDE Interface");
640 ATARIHW_ANNOUNCE(FDCSPEED
, "8/16 Mhz Switch for FDC");
641 ATARIHW_ANNOUNCE(ST_MFP
, "Multi Function Peripheral MFP 68901");
642 ATARIHW_ANNOUNCE(TT_MFP
, "Second Multi Function Peripheral MFP 68901");
643 ATARIHW_ANNOUNCE(SCC
, "Serial Communications Controller SCC 8530");
644 ATARIHW_ANNOUNCE(ST_ESCC
, "Extended Serial Communications Controller SCC 85230");
645 ATARIHW_ANNOUNCE(ANALOG_JOY
, "Paddle Interface");
646 ATARIHW_ANNOUNCE(MICROWIRE
, "MICROWIRE(tm) Interface");
647 ATARIHW_ANNOUNCE(STND_DMA
, "DMA Controller (24 bit)");
648 ATARIHW_ANNOUNCE(EXTD_DMA
, "DMA Controller (32 bit)");
649 ATARIHW_ANNOUNCE(SCSI_DMA
, "DMA Controller for NCR5380");
650 ATARIHW_ANNOUNCE(SCC_DMA
, "DMA Controller for SCC");
651 ATARIHW_ANNOUNCE(TT_CLK
, "Clock Chip MC146818A");
652 ATARIHW_ANNOUNCE(MSTE_CLK
, "Clock Chip RP5C15");
653 ATARIHW_ANNOUNCE(SCU
, "System Control Unit");
654 ATARIHW_ANNOUNCE(BLITTER
, "Blitter");
655 ATARIHW_ANNOUNCE(VME
, "VME Bus");
656 ATARIHW_ANNOUNCE(DSP56K
, "DSP56001 processor");