mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
This cleans up two ancient timer features that were never completed in the past, CONFIG_GENERIC_CLOCKEVENTS and CONFIG_ARCH_USES_GETTIMEOFFSET. There was only one user left for the ARCH_USES_GETTIMEOFFSET variant of clocksource implementations, the ARM EBSA110 platform. Rather than changing to use modern timekeeping, we remove the platform entirely as Russell no longer uses his machine and nobody else seems to have one any more. The conditional code for using arch_gettimeoffset() is removed as a result. For CONFIG_GENERIC_CLOCKEVENTS, there are still a couple of platforms not using clockevent drivers: parisc, ia64, most of m68k, and one Arm platform. These all do timer ticks slighly differently, and this gets cleaned up to the point they at least all call the same helper function. Instead of most platforms using 'select GENERIC_CLOCKEVENTS' in Kconfig, the polarity is now reversed, with the few remaining ones selecting LEGACY_TIMER_TICK instead. Signed-off-by: Arnd Bergmann <arnd@arndb.de> -----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEEo6/YBQwIrVS28WGKmmx57+YAGNkFAl/Y1v8ACgkQmmx57+YA GNmCvQ/9EDlgCt92r8SB+LGafDtgB8TUQZeIrs9S2mByzdxwnw0lxObIXFCnhQgh RpG3dR+ONRDnC5eI149B377JOEFMZWe2+BtYHUHkFARtUEWatslQcz7yAGvVRK/l TS/qReb6piKltlzuanF1bMZbjy2OhlaDRcm+OlC3y5mALR33M4emb+rJ6cSdfk3K v1iZhrxtfQT77ztesh/oPkPiyQ6kNcz7SfpyYOb6f5VLlml2BZ7YwBSVyGY7urHk RL3XqOUP4KKlMEAI8w0E2nvft6Fk+luziBhrMYWK0GvbmI1OESENuX/c6tgT2OQ1 DRaVHvcPG/EAY8adOKxxVyHhEJDSoz5GJV/EtjlOegsJk6RomczR1uuiT3Kvm7Ah PktMKv4xQht1E15KPSKbOvNIEP18w2s5z6gw+jVDv8pw42pVEQManm1D+BICqrhl fcpw6T1drf9UxAjwX4+zXtmNs+a+mqiFG8puU4VVgT4GpQ8umHvunXz2WUjZO0jc 3m8ErJHBvtJwW5TOHGyXnjl9SkwPzHOfF6IcXTYWEDU4/gQIK9TwUvCjLc0lE27t FMCV2ds7/K1CXwRgpa5IrefSkb8yOXSbRZ56NqqF7Ekxw4J5bYRSaY7jb+qD/e+3 5O1y+iPxFrpH+16hSahvzrtcdFNbLQvBBuRtEQOYuHLt2UJrNoU= =QpNs -----END PGP SIGNATURE----- Merge tag 'asm-generic-timers-5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/asm-generic Pull asm-generic cross-architecture timer cleanup from Arnd Bergmann: "This cleans up two ancient timer features that were never completed in the past, CONFIG_GENERIC_CLOCKEVENTS and CONFIG_ARCH_USES_GETTIMEOFFSET. There was only one user left for the ARCH_USES_GETTIMEOFFSET variant of clocksource implementations, the ARM EBSA110 platform. Rather than changing to use modern timekeeping, we remove the platform entirely as Russell no longer uses his machine and nobody else seems to have one any more. The conditional code for using arch_gettimeoffset() is removed as a result. For CONFIG_GENERIC_CLOCKEVENTS, there are still a couple of platforms not using clockevent drivers: parisc, ia64, most of m68k, and one Arm platform. These all do timer ticks slighly differently, and this gets cleaned up to the point they at least all call the same helper function. Instead of most platforms using 'select GENERIC_CLOCKEVENTS' in Kconfig, the polarity is now reversed, with the few remaining ones selecting LEGACY_TIMER_TICK instead" * tag 'asm-generic-timers-5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/asm-generic: timekeeping: default GENERIC_CLOCKEVENTS to enabled timekeeping: remove xtime_update m68k: remove timer_interrupt() function m68k: change remaining timers to legacy_timer_tick m68k: m68328: use legacy_timer_tick() m68k: sun3/sun3c: use legacy_timer_tick m68k: split heartbeat out of timer function m68k: coldfire: use legacy_timer_tick() parisc: use legacy_timer_tick ARM: rpc: use legacy_timer_tick ia64: convert to legacy_timer_tick timekeeping: add CONFIG_LEGACY_TIMER_TICK timekeeping: remove arch_gettimeoffset net: remove am79c961a driver ARM: remove ebsa110 platform
944 lines
24 KiB
C
944 lines
24 KiB
C
/*
|
|
* linux/arch/m68k/atari/config.c
|
|
*
|
|
* Copyright (C) 1994 Bjoern Brauel
|
|
*
|
|
* 5/2/94 Roman Hodek:
|
|
* Added setting of time_adj to get a better clock.
|
|
*
|
|
* 5/14/94 Roman Hodek:
|
|
* gettod() for TT
|
|
*
|
|
* 5/15/94 Roman Hodek:
|
|
* hard_reset_now() for Atari (and others?)
|
|
*
|
|
* 94/12/30 Andreas Schwab:
|
|
* atari_sched_init fixed to get precise clock.
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of this archive
|
|
* for more details.
|
|
*/
|
|
|
|
/*
|
|
* Miscellaneous atari stuff
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/console.h>
|
|
#include <linux/init.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/usb/isp116x.h>
|
|
#include <linux/vt_kern.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <asm/bootinfo.h>
|
|
#include <asm/bootinfo-atari.h>
|
|
#include <asm/byteorder.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/atarihw.h>
|
|
#include <asm/atariints.h>
|
|
#include <asm/atari_stram.h>
|
|
#include <asm/machdep.h>
|
|
#include <asm/hwtest.h>
|
|
#include <asm/io.h>
|
|
|
|
u_long atari_mch_cookie;
|
|
EXPORT_SYMBOL(atari_mch_cookie);
|
|
|
|
u_long atari_mch_type;
|
|
EXPORT_SYMBOL(atari_mch_type);
|
|
|
|
struct atari_hw_present atari_hw_present;
|
|
EXPORT_SYMBOL(atari_hw_present);
|
|
|
|
u_long atari_switches;
|
|
EXPORT_SYMBOL(atari_switches);
|
|
|
|
int atari_dont_touch_floppy_select;
|
|
EXPORT_SYMBOL(atari_dont_touch_floppy_select);
|
|
|
|
int atari_rtc_year_offset;
|
|
|
|
/* local function prototypes */
|
|
static void atari_reset(void);
|
|
static void atari_get_model(char *model);
|
|
static void atari_get_hardware_list(struct seq_file *m);
|
|
|
|
/* atari specific irq functions */
|
|
extern void atari_init_IRQ (void);
|
|
extern void atari_mksound(unsigned int count, unsigned int ticks);
|
|
#ifdef CONFIG_HEARTBEAT
|
|
static void atari_heartbeat(int on);
|
|
#endif
|
|
|
|
/* atari specific timer functions (in time.c) */
|
|
extern void atari_sched_init(void);
|
|
extern int atari_mste_hwclk (int, struct rtc_time *);
|
|
extern int atari_tt_hwclk (int, struct rtc_time *);
|
|
|
|
/* ++roman: This is a more elaborate test for an SCC chip, since the plain
|
|
* Medusa board generates DTACK at the SCC's standard addresses, but a SCC
|
|
* board in the Medusa is possible. Also, the addresses where the ST_ESCC
|
|
* resides generate DTACK without the chip, too.
|
|
* The method is to write values into the interrupt vector register, that
|
|
* should be readable without trouble (from channel A!).
|
|
*/
|
|
|
|
static int __init scc_test(volatile char *ctla)
|
|
{
|
|
if (!hwreg_present(ctla))
|
|
return 0;
|
|
MFPDELAY();
|
|
|
|
*ctla = 2;
|
|
MFPDELAY();
|
|
*ctla = 0x40;
|
|
MFPDELAY();
|
|
|
|
*ctla = 2;
|
|
MFPDELAY();
|
|
if (*ctla != 0x40)
|
|
return 0;
|
|
MFPDELAY();
|
|
|
|
*ctla = 2;
|
|
MFPDELAY();
|
|
*ctla = 0x60;
|
|
MFPDELAY();
|
|
|
|
*ctla = 2;
|
|
MFPDELAY();
|
|
if (*ctla != 0x60)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Parse an Atari-specific record in the bootinfo
|
|
*/
|
|
|
|
int __init atari_parse_bootinfo(const struct bi_record *record)
|
|
{
|
|
int unknown = 0;
|
|
const void *data = record->data;
|
|
|
|
switch (be16_to_cpu(record->tag)) {
|
|
case BI_ATARI_MCH_COOKIE:
|
|
atari_mch_cookie = be32_to_cpup(data);
|
|
break;
|
|
case BI_ATARI_MCH_TYPE:
|
|
atari_mch_type = be32_to_cpup(data);
|
|
break;
|
|
default:
|
|
unknown = 1;
|
|
break;
|
|
}
|
|
return unknown;
|
|
}
|
|
|
|
|
|
/* Parse the Atari-specific switches= option. */
|
|
static int __init atari_switches_setup(char *str)
|
|
{
|
|
char switches[COMMAND_LINE_SIZE];
|
|
char *p;
|
|
int ovsc_shift;
|
|
char *args = switches;
|
|
|
|
if (!MACH_IS_ATARI)
|
|
return 0;
|
|
|
|
/* copy string to local array, strsep works destructively... */
|
|
strcpy(switches, str);
|
|
atari_switches = 0;
|
|
|
|
/* parse the options */
|
|
while ((p = strsep(&args, ",")) != NULL) {
|
|
if (!*p)
|
|
continue;
|
|
ovsc_shift = 0;
|
|
if (strncmp(p, "ov_", 3) == 0) {
|
|
p += 3;
|
|
ovsc_shift = ATARI_SWITCH_OVSC_SHIFT;
|
|
}
|
|
|
|
if (strcmp(p, "ikbd") == 0) {
|
|
/* RTS line of IKBD ACIA */
|
|
atari_switches |= ATARI_SWITCH_IKBD << ovsc_shift;
|
|
} else if (strcmp(p, "midi") == 0) {
|
|
/* RTS line of MIDI ACIA */
|
|
atari_switches |= ATARI_SWITCH_MIDI << ovsc_shift;
|
|
} else if (strcmp(p, "snd6") == 0) {
|
|
atari_switches |= ATARI_SWITCH_SND6 << ovsc_shift;
|
|
} else if (strcmp(p, "snd7") == 0) {
|
|
atari_switches |= ATARI_SWITCH_SND7 << ovsc_shift;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
early_param("switches", atari_switches_setup);
|
|
|
|
|
|
/*
|
|
* Setup the Atari configuration info
|
|
*/
|
|
|
|
void __init config_atari(void)
|
|
{
|
|
unsigned short tos_version;
|
|
|
|
memset(&atari_hw_present, 0, sizeof(atari_hw_present));
|
|
|
|
/* Change size of I/O space from 64KB to 4GB. */
|
|
ioport_resource.end = 0xFFFFFFFF;
|
|
|
|
mach_sched_init = atari_sched_init;
|
|
mach_init_IRQ = atari_init_IRQ;
|
|
mach_get_model = atari_get_model;
|
|
mach_get_hardware_list = atari_get_hardware_list;
|
|
mach_reset = atari_reset;
|
|
#if IS_ENABLED(CONFIG_INPUT_M68K_BEEP)
|
|
mach_beep = atari_mksound;
|
|
#endif
|
|
#ifdef CONFIG_HEARTBEAT
|
|
mach_heartbeat = atari_heartbeat;
|
|
#endif
|
|
|
|
/* Set switches as requested by the user */
|
|
if (atari_switches & ATARI_SWITCH_IKBD)
|
|
acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID;
|
|
if (atari_switches & ATARI_SWITCH_MIDI)
|
|
acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
|
|
if (atari_switches & (ATARI_SWITCH_SND6|ATARI_SWITCH_SND7)) {
|
|
sound_ym.rd_data_reg_sel = 14;
|
|
sound_ym.wd_data = sound_ym.rd_data_reg_sel |
|
|
((atari_switches&ATARI_SWITCH_SND6) ? 0x40 : 0) |
|
|
((atari_switches&ATARI_SWITCH_SND7) ? 0x80 : 0);
|
|
}
|
|
|
|
/* ++bjoern:
|
|
* Determine hardware present
|
|
*/
|
|
|
|
pr_info("Atari hardware found:");
|
|
if (MACH_IS_MEDUSA) {
|
|
/* There's no Atari video hardware on the Medusa, but all the
|
|
* addresses below generate a DTACK so no bus error occurs! */
|
|
} else if (hwreg_present(f030_xreg)) {
|
|
ATARIHW_SET(VIDEL_SHIFTER);
|
|
pr_cont(" VIDEL");
|
|
/* This is a temporary hack: If there is Falcon video
|
|
* hardware, we assume that the ST-DMA serves SCSI instead of
|
|
* ACSI. In the future, there should be a better method for
|
|
* this...
|
|
*/
|
|
ATARIHW_SET(ST_SCSI);
|
|
pr_cont(" STDMA-SCSI");
|
|
} else if (hwreg_present(tt_palette)) {
|
|
ATARIHW_SET(TT_SHIFTER);
|
|
pr_cont(" TT_SHIFTER");
|
|
} else if (hwreg_present(&shifter_st.bas_hi)) {
|
|
if (hwreg_present(&shifter_st.bas_lo) &&
|
|
(shifter_st.bas_lo = 0x0aau, shifter_st.bas_lo == 0x0aau)) {
|
|
ATARIHW_SET(EXTD_SHIFTER);
|
|
pr_cont(" EXTD_SHIFTER");
|
|
} else {
|
|
ATARIHW_SET(STND_SHIFTER);
|
|
pr_cont(" STND_SHIFTER");
|
|
}
|
|
}
|
|
if (hwreg_present(&st_mfp.par_dt_reg)) {
|
|
ATARIHW_SET(ST_MFP);
|
|
pr_cont(" ST_MFP");
|
|
}
|
|
if (hwreg_present(&tt_mfp.par_dt_reg)) {
|
|
ATARIHW_SET(TT_MFP);
|
|
pr_cont(" TT_MFP");
|
|
}
|
|
if (hwreg_present(&tt_scsi_dma.dma_addr_hi)) {
|
|
ATARIHW_SET(SCSI_DMA);
|
|
pr_cont(" TT_SCSI_DMA");
|
|
}
|
|
/*
|
|
* The ST-DMA address registers aren't readable
|
|
* on all Medusas, so the test below may fail
|
|
*/
|
|
if (MACH_IS_MEDUSA ||
|
|
(hwreg_present(&st_dma.dma_vhi) &&
|
|
(st_dma.dma_vhi = 0x55) && (st_dma.dma_hi = 0xaa) &&
|
|
st_dma.dma_vhi == 0x55 && st_dma.dma_hi == 0xaa &&
|
|
(st_dma.dma_vhi = 0xaa) && (st_dma.dma_hi = 0x55) &&
|
|
st_dma.dma_vhi == 0xaa && st_dma.dma_hi == 0x55)) {
|
|
ATARIHW_SET(EXTD_DMA);
|
|
pr_cont(" EXTD_DMA");
|
|
}
|
|
if (hwreg_present(&tt_scsi.scsi_data)) {
|
|
ATARIHW_SET(TT_SCSI);
|
|
pr_cont(" TT_SCSI");
|
|
}
|
|
if (hwreg_present(&sound_ym.rd_data_reg_sel)) {
|
|
ATARIHW_SET(YM_2149);
|
|
pr_cont(" YM2149");
|
|
}
|
|
if (!MACH_IS_MEDUSA && hwreg_present(&tt_dmasnd.ctrl)) {
|
|
ATARIHW_SET(PCM_8BIT);
|
|
pr_cont(" PCM");
|
|
}
|
|
if (hwreg_present(&falcon_codec.unused5)) {
|
|
ATARIHW_SET(CODEC);
|
|
pr_cont(" CODEC");
|
|
}
|
|
if (hwreg_present(&dsp56k_host_interface.icr)) {
|
|
ATARIHW_SET(DSP56K);
|
|
pr_cont(" DSP56K");
|
|
}
|
|
if (hwreg_present(&tt_scc_dma.dma_ctrl) &&
|
|
#if 0
|
|
/* This test sucks! Who knows some better? */
|
|
(tt_scc_dma.dma_ctrl = 0x01, (tt_scc_dma.dma_ctrl & 1) == 1) &&
|
|
(tt_scc_dma.dma_ctrl = 0x00, (tt_scc_dma.dma_ctrl & 1) == 0)
|
|
#else
|
|
!MACH_IS_MEDUSA
|
|
#endif
|
|
) {
|
|
ATARIHW_SET(SCC_DMA);
|
|
pr_cont(" SCC_DMA");
|
|
}
|
|
if (scc_test(&atari_scc.cha_a_ctrl)) {
|
|
ATARIHW_SET(SCC);
|
|
pr_cont(" SCC");
|
|
}
|
|
if (scc_test(&st_escc.cha_b_ctrl)) {
|
|
ATARIHW_SET(ST_ESCC);
|
|
pr_cont(" ST_ESCC");
|
|
}
|
|
if (hwreg_present(&tt_scu.sys_mask)) {
|
|
ATARIHW_SET(SCU);
|
|
/* Assume a VME bus if there's a SCU */
|
|
ATARIHW_SET(VME);
|
|
pr_cont(" VME SCU");
|
|
}
|
|
if (hwreg_present((void *)(0xffff9210))) {
|
|
ATARIHW_SET(ANALOG_JOY);
|
|
pr_cont(" ANALOG_JOY");
|
|
}
|
|
if (hwreg_present(blitter.halftone)) {
|
|
ATARIHW_SET(BLITTER);
|
|
pr_cont(" BLITTER");
|
|
}
|
|
if (hwreg_present((void *)0xfff00039)) {
|
|
ATARIHW_SET(IDE);
|
|
pr_cont(" IDE");
|
|
}
|
|
#if 1 /* This maybe wrong */
|
|
if (!MACH_IS_MEDUSA && hwreg_present(&tt_microwire.data) &&
|
|
hwreg_present(&tt_microwire.mask) &&
|
|
(tt_microwire.mask = 0x7ff,
|
|
udelay(1),
|
|
tt_microwire.data = MW_LM1992_PSG_HIGH | MW_LM1992_ADDR,
|
|
udelay(1),
|
|
tt_microwire.data != 0)) {
|
|
ATARIHW_SET(MICROWIRE);
|
|
while (tt_microwire.mask != 0x7ff)
|
|
;
|
|
pr_cont(" MICROWIRE");
|
|
}
|
|
#endif
|
|
if (hwreg_present(&tt_rtc.regsel)) {
|
|
ATARIHW_SET(TT_CLK);
|
|
pr_cont(" TT_CLK");
|
|
mach_hwclk = atari_tt_hwclk;
|
|
}
|
|
if (hwreg_present(&mste_rtc.sec_ones)) {
|
|
ATARIHW_SET(MSTE_CLK);
|
|
pr_cont(" MSTE_CLK");
|
|
mach_hwclk = atari_mste_hwclk;
|
|
}
|
|
if (!MACH_IS_MEDUSA && hwreg_present(&dma_wd.fdc_speed) &&
|
|
hwreg_write(&dma_wd.fdc_speed, 0)) {
|
|
ATARIHW_SET(FDCSPEED);
|
|
pr_cont(" FDC_SPEED");
|
|
}
|
|
if (!ATARIHW_PRESENT(ST_SCSI)) {
|
|
ATARIHW_SET(ACSI);
|
|
pr_cont(" ACSI");
|
|
}
|
|
pr_cont("\n");
|
|
|
|
if (CPU_IS_040_OR_060)
|
|
/* Now it seems to be safe to turn of the tt0 transparent
|
|
* translation (the one that must not be turned off in
|
|
* head.S...)
|
|
*/
|
|
asm volatile ("\n"
|
|
" moveq #0,%%d0\n"
|
|
" .chip 68040\n"
|
|
" movec %%d0,%%itt0\n"
|
|
" movec %%d0,%%dtt0\n"
|
|
" .chip 68k"
|
|
: /* no outputs */
|
|
: /* no inputs */
|
|
: "d0");
|
|
|
|
/* allocator for memory that must reside in st-ram */
|
|
atari_stram_init();
|
|
|
|
/* Set up a mapping for the VMEbus address region:
|
|
*
|
|
* VME is either at phys. 0xfexxxxxx (TT) or 0xa00000..0xdfffff
|
|
* (MegaSTE) In both cases, the whole 16 MB chunk is mapped at
|
|
* 0xfe000000 virt., because this can be done with a single
|
|
* transparent translation. On the 68040, lots of often unused
|
|
* page tables would be needed otherwise. On a MegaSTE or similar,
|
|
* the highest byte is stripped off by hardware due to the 24 bit
|
|
* design of the bus.
|
|
*/
|
|
|
|
if (CPU_IS_020_OR_030) {
|
|
unsigned long tt1_val;
|
|
tt1_val = 0xfe008543; /* Translate 0xfexxxxxx, enable, cache
|
|
* inhibit, read and write, FDC mask = 3,
|
|
* FDC val = 4 -> Supervisor only */
|
|
asm volatile ("\n"
|
|
" .chip 68030\n"
|
|
" pmove %0,%/tt1\n"
|
|
" .chip 68k"
|
|
: : "m" (tt1_val));
|
|
} else {
|
|
asm volatile ("\n"
|
|
" .chip 68040\n"
|
|
" movec %0,%%itt1\n"
|
|
" movec %0,%%dtt1\n"
|
|
" .chip 68k"
|
|
:
|
|
: "d" (0xfe00a040)); /* Translate 0xfexxxxxx, enable,
|
|
* supervisor only, non-cacheable/
|
|
* serialized, writable */
|
|
|
|
}
|
|
|
|
/* Fetch tos version at Physical 2 */
|
|
/*
|
|
* We my not be able to access this address if the kernel is
|
|
* loaded to st ram, since the first page is unmapped. On the
|
|
* Medusa this is always the case and there is nothing we can do
|
|
* about this, so we just assume the smaller offset. For the TT
|
|
* we use the fact that in head.S we have set up a mapping
|
|
* 0xFFxxxxxx -> 0x00xxxxxx, so that the first 16MB is accessible
|
|
* in the last 16MB of the address space.
|
|
*/
|
|
tos_version = (MACH_IS_MEDUSA) ?
|
|
0xfff : *(unsigned short *)0xff000002;
|
|
atari_rtc_year_offset = (tos_version < 0x306) ? 70 : 68;
|
|
}
|
|
|
|
#ifdef CONFIG_HEARTBEAT
|
|
static void atari_heartbeat(int on)
|
|
{
|
|
unsigned char tmp;
|
|
unsigned long flags;
|
|
|
|
if (atari_dont_touch_floppy_select)
|
|
return;
|
|
|
|
local_irq_save(flags);
|
|
sound_ym.rd_data_reg_sel = 14; /* Select PSG Port A */
|
|
tmp = sound_ym.rd_data_reg_sel;
|
|
sound_ym.wd_data = on ? (tmp & ~0x02) : (tmp | 0x02);
|
|
local_irq_restore(flags);
|
|
}
|
|
#endif
|
|
|
|
/* ++roman:
|
|
*
|
|
* This function does a reset on machines that lack the ability to
|
|
* assert the processor's _RESET signal somehow via hardware. It is
|
|
* based on the fact that you can find the initial SP and PC values
|
|
* after a reset at physical addresses 0 and 4. This works pretty well
|
|
* for Atari machines, since the lowest 8 bytes of physical memory are
|
|
* really ROM (mapped by hardware). For other 680x0 machines: don't
|
|
* know if it works...
|
|
*
|
|
* To get the values at addresses 0 and 4, the MMU better is turned
|
|
* off first. After that, we have to jump into physical address space
|
|
* (the PC before the pmove statement points to the virtual address of
|
|
* the code). Getting that physical address is not hard, but the code
|
|
* becomes a bit complex since I've tried to ensure that the jump
|
|
* statement after the pmove is in the cache already (otherwise the
|
|
* processor can't fetch it!). For that, the code first jumps to the
|
|
* jump statement with the (virtual) address of the pmove section in
|
|
* an address register . The jump statement is surely in the cache
|
|
* now. After that, that physical address of the reset code is loaded
|
|
* into the same address register, pmove is done and the same jump
|
|
* statements goes to the reset code. Since there are not many
|
|
* statements between the two jumps, I hope it stays in the cache.
|
|
*
|
|
* The C code makes heavy use of the GCC features that you can get the
|
|
* address of a C label. No hope to compile this with another compiler
|
|
* than GCC!
|
|
*/
|
|
|
|
/* ++andreas: no need for complicated code, just depend on prefetch */
|
|
|
|
static void atari_reset(void)
|
|
{
|
|
long tc_val = 0;
|
|
long reset_addr;
|
|
|
|
/*
|
|
* On the Medusa, phys. 0x4 may contain garbage because it's no
|
|
* ROM. See above for explanation why we cannot use PTOV(4).
|
|
*/
|
|
reset_addr = MACH_IS_MEDUSA || MACH_IS_AB40 ? 0xe00030 :
|
|
*(unsigned long *) 0xff000004;
|
|
|
|
/* reset ACIA for switch off OverScan, if it's active */
|
|
if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
|
|
acia.key_ctrl = ACIA_RESET;
|
|
if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
|
|
acia.mid_ctrl = ACIA_RESET;
|
|
|
|
/* processor independent: turn off interrupts and reset the VBR;
|
|
* the caches must be left enabled, else prefetching the final jump
|
|
* instruction doesn't work.
|
|
*/
|
|
local_irq_disable();
|
|
asm volatile ("movec %0,%%vbr"
|
|
: : "d" (0));
|
|
|
|
if (CPU_IS_040_OR_060) {
|
|
unsigned long jmp_addr040 = virt_to_phys(&&jmp_addr_label040);
|
|
if (CPU_IS_060) {
|
|
/* 68060: clear PCR to turn off superscalar operation */
|
|
asm volatile ("\n"
|
|
" .chip 68060\n"
|
|
" movec %0,%%pcr\n"
|
|
" .chip 68k"
|
|
: : "d" (0));
|
|
}
|
|
|
|
asm volatile ("\n"
|
|
" move.l %0,%%d0\n"
|
|
" and.l #0xff000000,%%d0\n"
|
|
" or.w #0xe020,%%d0\n" /* map 16 MB, enable, cacheable */
|
|
" .chip 68040\n"
|
|
" movec %%d0,%%itt0\n"
|
|
" movec %%d0,%%dtt0\n"
|
|
" .chip 68k\n"
|
|
" jmp %0@"
|
|
: : "a" (jmp_addr040)
|
|
: "d0");
|
|
jmp_addr_label040:
|
|
asm volatile ("\n"
|
|
" moveq #0,%%d0\n"
|
|
" nop\n"
|
|
" .chip 68040\n"
|
|
" cinva %%bc\n"
|
|
" nop\n"
|
|
" pflusha\n"
|
|
" nop\n"
|
|
" movec %%d0,%%tc\n"
|
|
" nop\n"
|
|
/* the following setup of transparent translations is needed on the
|
|
* Afterburner040 to successfully reboot. Other machines shouldn't
|
|
* care about a different tt regs setup, they also didn't care in
|
|
* the past that the regs weren't turned off. */
|
|
" move.l #0xffc000,%%d0\n" /* whole insn space cacheable */
|
|
" movec %%d0,%%itt0\n"
|
|
" movec %%d0,%%itt1\n"
|
|
" or.w #0x40,%/d0\n" /* whole data space non-cacheable/ser. */
|
|
" movec %%d0,%%dtt0\n"
|
|
" movec %%d0,%%dtt1\n"
|
|
" .chip 68k\n"
|
|
" jmp %0@"
|
|
: /* no outputs */
|
|
: "a" (reset_addr)
|
|
: "d0");
|
|
} else
|
|
asm volatile ("\n"
|
|
" pmove %0,%%tc\n"
|
|
" jmp %1@"
|
|
: /* no outputs */
|
|
: "m" (tc_val), "a" (reset_addr));
|
|
}
|
|
|
|
|
|
static void atari_get_model(char *model)
|
|
{
|
|
strcpy(model, "Atari ");
|
|
switch (atari_mch_cookie >> 16) {
|
|
case ATARI_MCH_ST:
|
|
if (ATARIHW_PRESENT(MSTE_CLK))
|
|
strcat(model, "Mega ST");
|
|
else
|
|
strcat(model, "ST");
|
|
break;
|
|
case ATARI_MCH_STE:
|
|
if (MACH_IS_MSTE)
|
|
strcat(model, "Mega STE");
|
|
else
|
|
strcat(model, "STE");
|
|
break;
|
|
case ATARI_MCH_TT:
|
|
if (MACH_IS_MEDUSA)
|
|
/* Medusa has TT _MCH cookie */
|
|
strcat(model, "Medusa");
|
|
else
|
|
strcat(model, "TT");
|
|
break;
|
|
case ATARI_MCH_FALCON:
|
|
strcat(model, "Falcon");
|
|
if (MACH_IS_AB40)
|
|
strcat(model, " (with Afterburner040)");
|
|
break;
|
|
default:
|
|
sprintf(model + strlen(model), "(unknown mach cookie 0x%lx)",
|
|
atari_mch_cookie);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void atari_get_hardware_list(struct seq_file *m)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < m68k_num_memory; i++)
|
|
seq_printf(m, "\t%3ld MB at 0x%08lx (%s)\n",
|
|
m68k_memory[i].size >> 20, m68k_memory[i].addr,
|
|
(m68k_memory[i].addr & 0xff000000 ?
|
|
"alternate RAM" : "ST-RAM"));
|
|
|
|
#define ATARIHW_ANNOUNCE(name, str) \
|
|
if (ATARIHW_PRESENT(name)) \
|
|
seq_printf(m, "\t%s\n", str)
|
|
|
|
seq_puts(m, "Detected hardware:\n");
|
|
ATARIHW_ANNOUNCE(STND_SHIFTER, "ST Shifter");
|
|
ATARIHW_ANNOUNCE(EXTD_SHIFTER, "STe Shifter");
|
|
ATARIHW_ANNOUNCE(TT_SHIFTER, "TT Shifter");
|
|
ATARIHW_ANNOUNCE(VIDEL_SHIFTER, "Falcon Shifter");
|
|
ATARIHW_ANNOUNCE(YM_2149, "Programmable Sound Generator");
|
|
ATARIHW_ANNOUNCE(PCM_8BIT, "PCM 8 Bit Sound");
|
|
ATARIHW_ANNOUNCE(CODEC, "CODEC Sound");
|
|
ATARIHW_ANNOUNCE(TT_SCSI, "SCSI Controller NCR5380 (TT style)");
|
|
ATARIHW_ANNOUNCE(ST_SCSI, "SCSI Controller NCR5380 (Falcon style)");
|
|
ATARIHW_ANNOUNCE(ACSI, "ACSI Interface");
|
|
ATARIHW_ANNOUNCE(IDE, "IDE Interface");
|
|
ATARIHW_ANNOUNCE(FDCSPEED, "8/16 Mhz Switch for FDC");
|
|
ATARIHW_ANNOUNCE(ST_MFP, "Multi Function Peripheral MFP 68901");
|
|
ATARIHW_ANNOUNCE(TT_MFP, "Second Multi Function Peripheral MFP 68901");
|
|
ATARIHW_ANNOUNCE(SCC, "Serial Communications Controller SCC 8530");
|
|
ATARIHW_ANNOUNCE(ST_ESCC, "Extended Serial Communications Controller SCC 85230");
|
|
ATARIHW_ANNOUNCE(ANALOG_JOY, "Paddle Interface");
|
|
ATARIHW_ANNOUNCE(MICROWIRE, "MICROWIRE(tm) Interface");
|
|
ATARIHW_ANNOUNCE(STND_DMA, "DMA Controller (24 bit)");
|
|
ATARIHW_ANNOUNCE(EXTD_DMA, "DMA Controller (32 bit)");
|
|
ATARIHW_ANNOUNCE(SCSI_DMA, "DMA Controller for NCR5380");
|
|
ATARIHW_ANNOUNCE(SCC_DMA, "DMA Controller for SCC");
|
|
ATARIHW_ANNOUNCE(TT_CLK, "Clock Chip MC146818A");
|
|
ATARIHW_ANNOUNCE(MSTE_CLK, "Clock Chip RP5C15");
|
|
ATARIHW_ANNOUNCE(SCU, "System Control Unit");
|
|
ATARIHW_ANNOUNCE(BLITTER, "Blitter");
|
|
ATARIHW_ANNOUNCE(VME, "VME Bus");
|
|
ATARIHW_ANNOUNCE(DSP56K, "DSP56001 processor");
|
|
}
|
|
|
|
/*
|
|
* MSch: initial platform device support for Atari,
|
|
* required for EtherNAT/EtherNEC/NetUSBee drivers
|
|
*/
|
|
|
|
#if defined(CONFIG_ATARI_ETHERNAT) || defined(CONFIG_ATARI_ETHERNEC)
|
|
static void isp1160_delay(struct device *dev, int delay)
|
|
{
|
|
ndelay(delay);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_ATARI_ETHERNAT
|
|
/*
|
|
* EtherNAT: SMC91C111 Ethernet chipset, handled by smc91x driver
|
|
*/
|
|
|
|
#define ATARI_ETHERNAT_IRQ 140
|
|
|
|
static struct resource smc91x_resources[] = {
|
|
[0] = {
|
|
.name = "smc91x-regs",
|
|
.start = ATARI_ETHERNAT_PHYS_ADDR,
|
|
.end = ATARI_ETHERNAT_PHYS_ADDR + 0xfffff,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[1] = {
|
|
.name = "smc91x-irq",
|
|
.start = ATARI_ETHERNAT_IRQ,
|
|
.end = ATARI_ETHERNAT_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct platform_device smc91x_device = {
|
|
.name = "smc91x",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(smc91x_resources),
|
|
.resource = smc91x_resources,
|
|
};
|
|
|
|
/*
|
|
* ISP 1160 - using the isp116x-hcd module
|
|
*/
|
|
|
|
#define ATARI_USB_PHYS_ADDR 0x80000012
|
|
#define ATARI_USB_IRQ 139
|
|
|
|
static struct resource isp1160_resources[] = {
|
|
[0] = {
|
|
.name = "isp1160-data",
|
|
.start = ATARI_USB_PHYS_ADDR,
|
|
.end = ATARI_USB_PHYS_ADDR + 0x1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[1] = {
|
|
.name = "isp1160-regs",
|
|
.start = ATARI_USB_PHYS_ADDR + 0x4,
|
|
.end = ATARI_USB_PHYS_ADDR + 0x5,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[2] = {
|
|
.name = "isp1160-irq",
|
|
.start = ATARI_USB_IRQ,
|
|
.end = ATARI_USB_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
/* (DataBusWidth16|AnalogOCEnable|DREQOutputPolarity|DownstreamPort15KRSel ) */
|
|
static struct isp116x_platform_data isp1160_platform_data = {
|
|
/* Enable internal resistors on downstream ports */
|
|
.sel15Kres = 1,
|
|
/* On-chip overcurrent protection */
|
|
.oc_enable = 1,
|
|
/* INT output polarity */
|
|
.int_act_high = 1,
|
|
/* INT edge or level triggered */
|
|
.int_edge_triggered = 0,
|
|
|
|
/* WAKEUP pin connected - NOT SUPPORTED */
|
|
/* .remote_wakeup_connected = 0, */
|
|
/* Wakeup by devices on usb bus enabled */
|
|
.remote_wakeup_enable = 0,
|
|
.delay = isp1160_delay,
|
|
};
|
|
|
|
static struct platform_device isp1160_device = {
|
|
.name = "isp116x-hcd",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(isp1160_resources),
|
|
.resource = isp1160_resources,
|
|
.dev = {
|
|
.platform_data = &isp1160_platform_data,
|
|
},
|
|
};
|
|
|
|
static struct platform_device *atari_ethernat_devices[] __initdata = {
|
|
&smc91x_device,
|
|
&isp1160_device
|
|
};
|
|
#endif /* CONFIG_ATARI_ETHERNAT */
|
|
|
|
#ifdef CONFIG_ATARI_ETHERNEC
|
|
/*
|
|
* EtherNEC: RTL8019 (NE2000 compatible) Ethernet chipset,
|
|
* handled by ne.c driver
|
|
*/
|
|
|
|
#define ATARI_ETHERNEC_PHYS_ADDR 0xfffa0000
|
|
#define ATARI_ETHERNEC_BASE 0x300
|
|
#define ATARI_ETHERNEC_IRQ IRQ_MFP_TIMER1
|
|
|
|
static struct resource rtl8019_resources[] = {
|
|
[0] = {
|
|
.name = "rtl8019-regs",
|
|
.start = ATARI_ETHERNEC_BASE,
|
|
.end = ATARI_ETHERNEC_BASE + 0x20 - 1,
|
|
.flags = IORESOURCE_IO,
|
|
},
|
|
[1] = {
|
|
.name = "rtl8019-irq",
|
|
.start = ATARI_ETHERNEC_IRQ,
|
|
.end = ATARI_ETHERNEC_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct platform_device rtl8019_device = {
|
|
.name = "ne",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(rtl8019_resources),
|
|
.resource = rtl8019_resources,
|
|
};
|
|
|
|
/*
|
|
* NetUSBee: ISP1160 USB host adapter via ROM-port adapter
|
|
*/
|
|
|
|
#define ATARI_NETUSBEE_PHYS_ADDR 0xfffa8000
|
|
#define ATARI_NETUSBEE_BASE 0x340
|
|
#define ATARI_NETUSBEE_IRQ IRQ_MFP_TIMER2
|
|
|
|
static struct resource netusbee_resources[] = {
|
|
[0] = {
|
|
.name = "isp1160-data",
|
|
.start = ATARI_NETUSBEE_BASE,
|
|
.end = ATARI_NETUSBEE_BASE + 0x1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[1] = {
|
|
.name = "isp1160-regs",
|
|
.start = ATARI_NETUSBEE_BASE + 0x20,
|
|
.end = ATARI_NETUSBEE_BASE + 0x21,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[2] = {
|
|
.name = "isp1160-irq",
|
|
.start = ATARI_NETUSBEE_IRQ,
|
|
.end = ATARI_NETUSBEE_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
/* (DataBusWidth16|AnalogOCEnable|DREQOutputPolarity|DownstreamPort15KRSel ) */
|
|
static struct isp116x_platform_data netusbee_platform_data = {
|
|
/* Enable internal resistors on downstream ports */
|
|
.sel15Kres = 1,
|
|
/* On-chip overcurrent protection */
|
|
.oc_enable = 1,
|
|
/* INT output polarity */
|
|
.int_act_high = 1,
|
|
/* INT edge or level triggered */
|
|
.int_edge_triggered = 0,
|
|
|
|
/* WAKEUP pin connected - NOT SUPPORTED */
|
|
/* .remote_wakeup_connected = 0, */
|
|
/* Wakeup by devices on usb bus enabled */
|
|
.remote_wakeup_enable = 0,
|
|
.delay = isp1160_delay,
|
|
};
|
|
|
|
static struct platform_device netusbee_device = {
|
|
.name = "isp116x-hcd",
|
|
.id = 1,
|
|
.num_resources = ARRAY_SIZE(netusbee_resources),
|
|
.resource = netusbee_resources,
|
|
.dev = {
|
|
.platform_data = &netusbee_platform_data,
|
|
},
|
|
};
|
|
|
|
static struct platform_device *atari_netusbee_devices[] __initdata = {
|
|
&rtl8019_device,
|
|
&netusbee_device
|
|
};
|
|
#endif /* CONFIG_ATARI_ETHERNEC */
|
|
|
|
#if IS_ENABLED(CONFIG_ATARI_SCSI)
|
|
static const struct resource atari_scsi_st_rsrc[] __initconst = {
|
|
{
|
|
.flags = IORESOURCE_IRQ,
|
|
.start = IRQ_MFP_FSCSI,
|
|
.end = IRQ_MFP_FSCSI,
|
|
},
|
|
};
|
|
|
|
static const struct resource atari_scsi_tt_rsrc[] __initconst = {
|
|
{
|
|
.flags = IORESOURCE_IRQ,
|
|
.start = IRQ_TT_MFP_SCSI,
|
|
.end = IRQ_TT_MFP_SCSI,
|
|
},
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* Falcon IDE interface
|
|
*/
|
|
|
|
#define FALCON_IDE_BASE 0xfff00000
|
|
|
|
static const struct resource atari_falconide_rsrc[] __initconst = {
|
|
{
|
|
.flags = IORESOURCE_MEM,
|
|
.start = FALCON_IDE_BASE,
|
|
.end = FALCON_IDE_BASE + 0x39,
|
|
},
|
|
{
|
|
.flags = IORESOURCE_IRQ,
|
|
.start = IRQ_MFP_FSCSI,
|
|
.end = IRQ_MFP_FSCSI,
|
|
},
|
|
};
|
|
|
|
int __init atari_platform_init(void)
|
|
{
|
|
struct platform_device *pdev;
|
|
int rv = 0;
|
|
|
|
if (!MACH_IS_ATARI)
|
|
return -ENODEV;
|
|
|
|
#ifdef CONFIG_ATARI_ETHERNAT
|
|
{
|
|
unsigned char *enatc_virt;
|
|
enatc_virt = (unsigned char *)ioremap((ATARI_ETHERNAT_PHYS_ADDR+0x23), 0xf);
|
|
if (hwreg_present(enatc_virt)) {
|
|
rv = platform_add_devices(atari_ethernat_devices,
|
|
ARRAY_SIZE(atari_ethernat_devices));
|
|
}
|
|
iounmap(enatc_virt);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_ATARI_ETHERNEC
|
|
{
|
|
int error;
|
|
unsigned char *enec_virt;
|
|
enec_virt = (unsigned char *)ioremap((ATARI_ETHERNEC_PHYS_ADDR), 0xf);
|
|
if (hwreg_present(enec_virt)) {
|
|
error = platform_add_devices(atari_netusbee_devices,
|
|
ARRAY_SIZE(atari_netusbee_devices));
|
|
if (error && !rv)
|
|
rv = error;
|
|
}
|
|
iounmap(enec_virt);
|
|
}
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_ATARI_SCSI)
|
|
if (ATARIHW_PRESENT(ST_SCSI))
|
|
platform_device_register_simple("atari_scsi", -1,
|
|
atari_scsi_st_rsrc, ARRAY_SIZE(atari_scsi_st_rsrc));
|
|
else if (ATARIHW_PRESENT(TT_SCSI))
|
|
platform_device_register_simple("atari_scsi", -1,
|
|
atari_scsi_tt_rsrc, ARRAY_SIZE(atari_scsi_tt_rsrc));
|
|
#endif
|
|
|
|
if (ATARIHW_PRESENT(IDE)) {
|
|
pdev = platform_device_register_simple("atari-falcon-ide", -1,
|
|
atari_falconide_rsrc, ARRAY_SIZE(atari_falconide_rsrc));
|
|
if (IS_ERR(pdev))
|
|
rv = PTR_ERR(pdev);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
arch_initcall(atari_platform_init);
|