diff options
Diffstat (limited to 'debian/patches/bugfix/m68k/m68k-reformat.diff')
| -rw-r--r-- | debian/patches/bugfix/m68k/m68k-reformat.diff | 4818 |
1 files changed, 4818 insertions, 0 deletions
diff --git a/debian/patches/bugfix/m68k/m68k-reformat.diff b/debian/patches/bugfix/m68k/m68k-reformat.diff new file mode 100644 index 000000000000..d218533dd0c5 --- /dev/null +++ b/debian/patches/bugfix/m68k/m68k-reformat.diff @@ -0,0 +1,4818 @@ +Subject: [PATCH] m68k: reformat various m68k files + +From: Roman Zippel <zippel@linux-m68k.org> + +Reformat various m68k files, so they actually look like Linux sources. + +Signed-off-by: Roman Zippel <zippel@linux-m68k.org> +Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org> +--- + arch/m68k/amiga/config.c | 1062 +++++++++++++++++++++++------------------------ + arch/m68k/atari/config.c | 983 ++++++++++++++++++++----------------------- + arch/m68k/atari/debug.c | 470 ++++++++++---------- + arch/m68k/kernel/entry.S | 2 + arch/m68k/kernel/head.S | 2 + arch/m68k/kernel/setup.c | 381 ++++++++-------- + arch/m68k/mac/config.c | 161 +++---- + arch/m68k/mac/debug.c | 331 +++++++------- + arch/m68k/q40/config.c | 259 +++++------ + arch/m68k/sun3x/prom.c | 121 ++--- + 10 files changed, 1856 insertions(+), 1916 deletions(-) + +--- linux-m68k-2.6.21.orig/arch/m68k/amiga/config.c ++++ linux-m68k-2.6.21/arch/m68k/amiga/config.c +@@ -22,9 +22,7 @@ + #include <linux/vt_kern.h> + #include <linux/delay.h> + #include <linux/interrupt.h> +-#ifdef CONFIG_ZORRO + #include <linux/zorro.h> +-#endif + + #include <asm/bootinfo.h> + #include <asm/setup.h> +@@ -62,21 +60,21 @@ static char s_cdtv[] __initdata = "CDTV" + static char s_cd32[] __initdata = "CD32"; + static char s_draco[] __initdata = "Draco"; + static char *amiga_models[] __initdata = { +- [AMI_500-AMI_500] = s_a500, +- [AMI_500PLUS-AMI_500] = s_a500p, +- [AMI_600-AMI_500] = s_a600, +- [AMI_1000-AMI_500] = s_a1000, +- [AMI_1200-AMI_500] = s_a1200, +- [AMI_2000-AMI_500] = s_a2000, +- [AMI_2500-AMI_500] = s_a2500, +- [AMI_3000-AMI_500] = s_a3000, +- [AMI_3000T-AMI_500] = s_a3000t, +- [AMI_3000PLUS-AMI_500] = s_a3000p, +- [AMI_4000-AMI_500] = s_a4000, +- [AMI_4000T-AMI_500] = s_a4000t, +- [AMI_CDTV-AMI_500] = s_cdtv, +- [AMI_CD32-AMI_500] = s_cd32, +- [AMI_DRACO-AMI_500] = s_draco, ++ [AMI_500-AMI_500] = s_a500, ++ [AMI_500PLUS-AMI_500] = s_a500p, ++ [AMI_600-AMI_500] = s_a600, ++ [AMI_1000-AMI_500] = s_a1000, ++ [AMI_1200-AMI_500] = s_a1200, ++ [AMI_2000-AMI_500] = s_a2000, ++ [AMI_2500-AMI_500] = s_a2500, ++ [AMI_3000-AMI_500] = s_a3000, ++ [AMI_3000T-AMI_500] = s_a3000t, ++ [AMI_3000PLUS-AMI_500] = s_a3000p, ++ [AMI_4000-AMI_500] = s_a4000, ++ [AMI_4000T-AMI_500] = s_a4000t, ++ [AMI_CDTV-AMI_500] = s_cdtv, ++ [AMI_CD32-AMI_500] = s_cd32, ++ [AMI_DRACO-AMI_500] = s_draco, + }; + + static char amiga_model_name[13] = "Amiga "; +@@ -85,17 +83,17 @@ extern char m68k_debug_device[]; + + static void amiga_sched_init(irq_handler_t handler); + /* amiga specific irq functions */ +-extern void amiga_init_IRQ (void); ++extern void amiga_init_IRQ(void); + static void amiga_get_model(char *model); + static int amiga_get_hardware_list(char *buffer); + /* amiga specific timer functions */ +-static unsigned long amiga_gettimeoffset (void); +-static int a3000_hwclk (int, struct rtc_time *); +-static int a2000_hwclk (int, struct rtc_time *); +-static int amiga_set_clock_mmss (unsigned long); +-static unsigned int amiga_get_ss (void); +-extern void amiga_mksound( unsigned int count, unsigned int ticks ); +-static void amiga_reset (void); ++static unsigned long amiga_gettimeoffset(void); ++static int a3000_hwclk(int, struct rtc_time *); ++static int a2000_hwclk(int, struct rtc_time *); ++static int amiga_set_clock_mmss(unsigned long); ++static unsigned int amiga_get_ss(void); ++extern void amiga_mksound(unsigned int count, unsigned int ticks); ++static void amiga_reset(void); + extern void amiga_init_sound(void); + static void amiga_savekmsg_init(void); + static void amiga_mem_console_write(struct console *co, const char *b, +@@ -108,9 +106,9 @@ static void amiga_heartbeat(int on); + #endif + + static struct console amiga_console_driver = { +- .name = "debug", +- .flags = CON_PRINTBUFFER, +- .index = -1, ++ .name = "debug", ++ .flags = CON_PRINTBUFFER, ++ .index = -1, + }; + + +@@ -119,24 +117,24 @@ static struct console amiga_console_driv + */ + + static struct { +- struct resource _ciab, _ciaa, _custom, _kickstart; ++ struct resource _ciab, _ciaa, _custom, _kickstart; + } mb_resources = { +- ._ciab = { +- .name = "CIA B", .start = 0x00bfd000, .end = 0x00bfdfff +- }, +- ._ciaa = { +- .name = "CIA A", .start = 0x00bfe000, .end = 0x00bfefff +- }, +- ._custom = { +- .name = "Custom I/O", .start = 0x00dff000, .end = 0x00dfffff +- }, +- ._kickstart = { +- .name = "Kickstart ROM", .start = 0x00f80000, .end = 0x00ffffff +- } ++ ._ciab = { ++ .name = "CIA B", .start = 0x00bfd000, .end = 0x00bfdfff ++ }, ++ ._ciaa = { ++ .name = "CIA A", .start = 0x00bfe000, .end = 0x00bfefff ++ }, ++ ._custom = { ++ .name = "Custom I/O", .start = 0x00dff000, .end = 0x00dfffff ++ }, ++ ._kickstart = { ++ .name = "Kickstart ROM", .start = 0x00f80000, .end = 0x00ffffff ++ } + }; + + static struct resource rtc_resource = { +- .start = 0x00dc0000, .end = 0x00dcffff ++ .start = 0x00dc0000, .end = 0x00dcffff + }; + + static struct resource ram_resource[NUM_MEMINFO]; +@@ -148,57 +146,57 @@ static struct resource ram_resource[NUM_ + + int amiga_parse_bootinfo(const struct bi_record *record) + { +- int unknown = 0; +- const unsigned long *data = record->data; ++ int unknown = 0; ++ const unsigned long *data = record->data; + +- switch (record->tag) { ++ switch (record->tag) { + case BI_AMIGA_MODEL: +- amiga_model = *data; +- break; ++ amiga_model = *data; ++ break; + + case BI_AMIGA_ECLOCK: +- amiga_eclock = *data; +- break; ++ amiga_eclock = *data; ++ break; + + case BI_AMIGA_CHIPSET: +- amiga_chipset = *data; +- break; ++ amiga_chipset = *data; ++ break; + + case BI_AMIGA_CHIP_SIZE: +- amiga_chip_size = *(const int *)data; +- break; ++ amiga_chip_size = *(const int *)data; ++ break; + + case BI_AMIGA_VBLANK: +- amiga_vblank = *(const unsigned char *)data; +- break; ++ amiga_vblank = *(const unsigned char *)data; ++ break; + + case BI_AMIGA_PSFREQ: +- amiga_psfreq = *(const unsigned char *)data; +- break; ++ amiga_psfreq = *(const unsigned char *)data; ++ break; + + case BI_AMIGA_AUTOCON: + #ifdef CONFIG_ZORRO +- if (zorro_num_autocon < ZORRO_NUM_AUTO) { +- const struct ConfigDev *cd = (struct ConfigDev *)data; +- struct zorro_dev *dev = &zorro_autocon[zorro_num_autocon++]; +- dev->rom = cd->cd_Rom; +- dev->slotaddr = cd->cd_SlotAddr; +- dev->slotsize = cd->cd_SlotSize; +- dev->resource.start = (unsigned long)cd->cd_BoardAddr; +- dev->resource.end = dev->resource.start+cd->cd_BoardSize-1; +- } else +- printk("amiga_parse_bootinfo: too many AutoConfig devices\n"); ++ if (zorro_num_autocon < ZORRO_NUM_AUTO) { ++ const struct ConfigDev *cd = (struct ConfigDev *)data; ++ struct zorro_dev *dev = &zorro_autocon[zorro_num_autocon++]; ++ dev->rom = cd->cd_Rom; ++ dev->slotaddr = cd->cd_SlotAddr; ++ dev->slotsize = cd->cd_SlotSize; ++ dev->resource.start = (unsigned long)cd->cd_BoardAddr; ++ dev->resource.end = dev->resource.start + cd->cd_BoardSize - 1; ++ } else ++ printk("amiga_parse_bootinfo: too many AutoConfig devices\n"); + #endif /* CONFIG_ZORRO */ +- break; ++ break; + + case BI_AMIGA_SERPER: +- /* serial port period: ignored here */ +- break; ++ /* serial port period: ignored here */ ++ break; + + default: +- unknown = 1; +- } +- return(unknown); ++ unknown = 1; ++ } ++ return unknown; + } + + /* +@@ -207,159 +205,159 @@ int amiga_parse_bootinfo(const struct bi + + static void __init amiga_identify(void) + { +- /* Fill in some default values, if necessary */ +- if (amiga_eclock == 0) +- amiga_eclock = 709379; +- +- memset(&amiga_hw_present, 0, sizeof(amiga_hw_present)); +- +- printk("Amiga hardware found: "); +- if (amiga_model >= AMI_500 && amiga_model <= AMI_DRACO) { +- printk("[%s] ", amiga_models[amiga_model-AMI_500]); +- strcat(amiga_model_name, amiga_models[amiga_model-AMI_500]); +- } +- +- switch(amiga_model) { +- case AMI_UNKNOWN: +- goto Generic; +- +- case AMI_600: +- case AMI_1200: +- AMIGAHW_SET(A1200_IDE); +- AMIGAHW_SET(PCMCIA); +- case AMI_500: +- case AMI_500PLUS: +- case AMI_1000: +- case AMI_2000: +- case AMI_2500: +- AMIGAHW_SET(A2000_CLK); /* Is this correct for all models? */ +- goto Generic; +- +- case AMI_3000: +- case AMI_3000T: +- AMIGAHW_SET(AMBER_FF); +- AMIGAHW_SET(MAGIC_REKICK); +- /* fall through */ +- case AMI_3000PLUS: +- AMIGAHW_SET(A3000_SCSI); +- AMIGAHW_SET(A3000_CLK); +- AMIGAHW_SET(ZORRO3); +- goto Generic; +- +- case AMI_4000T: +- AMIGAHW_SET(A4000_SCSI); +- /* fall through */ +- case AMI_4000: +- AMIGAHW_SET(A4000_IDE); +- AMIGAHW_SET(A3000_CLK); +- AMIGAHW_SET(ZORRO3); +- goto Generic; +- +- case AMI_CDTV: +- case AMI_CD32: +- AMIGAHW_SET(CD_ROM); +- AMIGAHW_SET(A2000_CLK); /* Is this correct? */ +- goto Generic; +- +- Generic: +- AMIGAHW_SET(AMI_VIDEO); +- AMIGAHW_SET(AMI_BLITTER); +- AMIGAHW_SET(AMI_AUDIO); +- AMIGAHW_SET(AMI_FLOPPY); +- AMIGAHW_SET(AMI_KEYBOARD); +- AMIGAHW_SET(AMI_MOUSE); +- AMIGAHW_SET(AMI_SERIAL); +- AMIGAHW_SET(AMI_PARALLEL); +- AMIGAHW_SET(CHIP_RAM); +- AMIGAHW_SET(PAULA); +- +- switch(amiga_chipset) { +- case CS_OCS: +- case CS_ECS: +- case CS_AGA: +- switch (amiga_custom.deniseid & 0xf) { +- case 0x0c: +- AMIGAHW_SET(DENISE_HR); +- break; +- case 0x08: +- AMIGAHW_SET(LISA); +- break; +- } +- break; +- default: +- AMIGAHW_SET(DENISE); +- break; +- } +- switch ((amiga_custom.vposr>>8) & 0x7f) { +- case 0x00: +- AMIGAHW_SET(AGNUS_PAL); +- break; +- case 0x10: +- AMIGAHW_SET(AGNUS_NTSC); +- break; +- case 0x20: +- case 0x21: +- AMIGAHW_SET(AGNUS_HR_PAL); +- break; +- case 0x30: +- case 0x31: +- AMIGAHW_SET(AGNUS_HR_NTSC); +- break; +- case 0x22: +- case 0x23: +- AMIGAHW_SET(ALICE_PAL); +- break; +- case 0x32: +- case 0x33: +- AMIGAHW_SET(ALICE_NTSC); +- break; +- } +- AMIGAHW_SET(ZORRO); +- break; +- +- case AMI_DRACO: +- panic("No support for Draco yet"); +- +- default: +- panic("Unknown Amiga Model"); +- } ++ /* Fill in some default values, if necessary */ ++ if (amiga_eclock == 0) ++ amiga_eclock = 709379; ++ ++ memset(&amiga_hw_present, 0, sizeof(amiga_hw_present)); ++ ++ printk("Amiga hardware found: "); ++ if (amiga_model >= AMI_500 && amiga_model <= AMI_DRACO) { ++ printk("[%s] ", amiga_models[amiga_model-AMI_500]); ++ strcat(amiga_model_name, amiga_models[amiga_model-AMI_500]); ++ } ++ ++ switch (amiga_model) { ++ case AMI_UNKNOWN: ++ goto Generic; ++ ++ case AMI_600: ++ case AMI_1200: ++ AMIGAHW_SET(A1200_IDE); ++ AMIGAHW_SET(PCMCIA); ++ case AMI_500: ++ case AMI_500PLUS: ++ case AMI_1000: ++ case AMI_2000: ++ case AMI_2500: ++ AMIGAHW_SET(A2000_CLK); /* Is this correct for all models? */ ++ goto Generic; ++ ++ case AMI_3000: ++ case AMI_3000T: ++ AMIGAHW_SET(AMBER_FF); ++ AMIGAHW_SET(MAGIC_REKICK); ++ /* fall through */ ++ case AMI_3000PLUS: ++ AMIGAHW_SET(A3000_SCSI); ++ AMIGAHW_SET(A3000_CLK); ++ AMIGAHW_SET(ZORRO3); ++ goto Generic; ++ ++ case AMI_4000T: ++ AMIGAHW_SET(A4000_SCSI); ++ /* fall through */ ++ case AMI_4000: ++ AMIGAHW_SET(A4000_IDE); ++ AMIGAHW_SET(A3000_CLK); ++ AMIGAHW_SET(ZORRO3); ++ goto Generic; ++ ++ case AMI_CDTV: ++ case AMI_CD32: ++ AMIGAHW_SET(CD_ROM); ++ AMIGAHW_SET(A2000_CLK); /* Is this correct? */ ++ goto Generic; ++ ++ Generic: ++ AMIGAHW_SET(AMI_VIDEO); ++ AMIGAHW_SET(AMI_BLITTER); ++ AMIGAHW_SET(AMI_AUDIO); ++ AMIGAHW_SET(AMI_FLOPPY); ++ AMIGAHW_SET(AMI_KEYBOARD); ++ AMIGAHW_SET(AMI_MOUSE); ++ AMIGAHW_SET(AMI_SERIAL); ++ AMIGAHW_SET(AMI_PARALLEL); ++ AMIGAHW_SET(CHIP_RAM); ++ AMIGAHW_SET(PAULA); ++ ++ switch (amiga_chipset) { ++ case CS_OCS: ++ case CS_ECS: ++ case CS_AGA: ++ switch (amiga_custom.deniseid & 0xf) { ++ case 0x0c: ++ AMIGAHW_SET(DENISE_HR); ++ break; ++ case 0x08: ++ AMIGAHW_SET(LISA); ++ break; ++ } ++ break; ++ default: ++ AMIGAHW_SET(DENISE); ++ break; ++ } ++ switch ((amiga_custom.vposr>>8) & 0x7f) { ++ case 0x00: ++ AMIGAHW_SET(AGNUS_PAL); ++ break; ++ case 0x10: ++ AMIGAHW_SET(AGNUS_NTSC); ++ break; ++ case 0x20: ++ case 0x21: ++ AMIGAHW_SET(AGNUS_HR_PAL); ++ break; ++ case 0x30: ++ case 0x31: ++ AMIGAHW_SET(AGNUS_HR_NTSC); ++ break; ++ case 0x22: ++ case 0x23: ++ AMIGAHW_SET(ALICE_PAL); ++ break; ++ case 0x32: ++ case 0x33: ++ AMIGAHW_SET(ALICE_NTSC); ++ break; ++ } ++ AMIGAHW_SET(ZORRO); ++ break; + +-#define AMIGAHW_ANNOUNCE(name, str) \ +- if (AMIGAHW_PRESENT(name)) \ +- printk(str) ++ case AMI_DRACO: ++ panic("No support for Draco yet"); ++ ++ default: ++ panic("Unknown Amiga Model"); ++ } + +- AMIGAHW_ANNOUNCE(AMI_VIDEO, "VIDEO "); +- AMIGAHW_ANNOUNCE(AMI_BLITTER, "BLITTER "); +- AMIGAHW_ANNOUNCE(AMBER_FF, "AMBER_FF "); +- AMIGAHW_ANNOUNCE(AMI_AUDIO, "AUDIO "); +- AMIGAHW_ANNOUNCE(AMI_FLOPPY, "FLOPPY "); +- AMIGAHW_ANNOUNCE(A3000_SCSI, "A3000_SCSI "); +- AMIGAHW_ANNOUNCE(A4000_SCSI, "A4000_SCSI "); +- AMIGAHW_ANNOUNCE(A1200_IDE, "A1200_IDE "); +- AMIGAHW_ANNOUNCE(A4000_IDE, "A4000_IDE "); +- AMIGAHW_ANNOUNCE(CD_ROM, "CD_ROM "); +- AMIGAHW_ANNOUNCE(AMI_KEYBOARD, "KEYBOARD "); +- AMIGAHW_ANNOUNCE(AMI_MOUSE, "MOUSE "); +- AMIGAHW_ANNOUNCE(AMI_SERIAL, "SERIAL "); +- AMIGAHW_ANNOUNCE(AMI_PARALLEL, "PARALLEL "); +- AMIGAHW_ANNOUNCE(A2000_CLK, "A2000_CLK "); +- AMIGAHW_ANNOUNCE(A3000_CLK, "A3000_CLK "); +- AMIGAHW_ANNOUNCE(CHIP_RAM, "CHIP_RAM "); +- AMIGAHW_ANNOUNCE(PAULA, "PAULA "); +- AMIGAHW_ANNOUNCE(DENISE, "DENISE "); +- AMIGAHW_ANNOUNCE(DENISE_HR, "DENISE_HR "); +- AMIGAHW_ANNOUNCE(LISA, "LISA "); +- AMIGAHW_ANNOUNCE(AGNUS_PAL, "AGNUS_PAL "); +- AMIGAHW_ANNOUNCE(AGNUS_NTSC, "AGNUS_NTSC "); +- AMIGAHW_ANNOUNCE(AGNUS_HR_PAL, "AGNUS_HR_PAL "); +- AMIGAHW_ANNOUNCE(AGNUS_HR_NTSC, "AGNUS_HR_NTSC "); +- AMIGAHW_ANNOUNCE(ALICE_PAL, "ALICE_PAL "); +- AMIGAHW_ANNOUNCE(ALICE_NTSC, "ALICE_NTSC "); +- AMIGAHW_ANNOUNCE(MAGIC_REKICK, "MAGIC_REKICK "); +- AMIGAHW_ANNOUNCE(PCMCIA, "PCMCIA "); +- if (AMIGAHW_PRESENT(ZORRO)) +- printk("ZORRO%s ", AMIGAHW_PRESENT(ZORRO3) ? "3" : ""); +- printk("\n"); ++#define AMIGAHW_ANNOUNCE(name, str) \ ++ if (AMIGAHW_PRESENT(name)) \ ++ printk(str) ++ ++ AMIGAHW_ANNOUNCE(AMI_VIDEO, "VIDEO "); ++ AMIGAHW_ANNOUNCE(AMI_BLITTER, "BLITTER "); ++ AMIGAHW_ANNOUNCE(AMBER_FF, "AMBER_FF "); ++ AMIGAHW_ANNOUNCE(AMI_AUDIO, "AUDIO "); ++ AMIGAHW_ANNOUNCE(AMI_FLOPPY, "FLOPPY "); ++ AMIGAHW_ANNOUNCE(A3000_SCSI, "A3000_SCSI "); ++ AMIGAHW_ANNOUNCE(A4000_SCSI, "A4000_SCSI "); ++ AMIGAHW_ANNOUNCE(A1200_IDE, "A1200_IDE "); ++ AMIGAHW_ANNOUNCE(A4000_IDE, "A4000_IDE "); ++ AMIGAHW_ANNOUNCE(CD_ROM, "CD_ROM "); ++ AMIGAHW_ANNOUNCE(AMI_KEYBOARD, "KEYBOARD "); ++ AMIGAHW_ANNOUNCE(AMI_MOUSE, "MOUSE "); ++ AMIGAHW_ANNOUNCE(AMI_SERIAL, "SERIAL "); ++ AMIGAHW_ANNOUNCE(AMI_PARALLEL, "PARALLEL "); ++ AMIGAHW_ANNOUNCE(A2000_CLK, "A2000_CLK "); ++ AMIGAHW_ANNOUNCE(A3000_CLK, "A3000_CLK "); ++ AMIGAHW_ANNOUNCE(CHIP_RAM, "CHIP_RAM "); ++ AMIGAHW_ANNOUNCE(PAULA, "PAULA "); ++ AMIGAHW_ANNOUNCE(DENISE, "DENISE "); ++ AMIGAHW_ANNOUNCE(DENISE_HR, "DENISE_HR "); ++ AMIGAHW_ANNOUNCE(LISA, "LISA "); ++ AMIGAHW_ANNOUNCE(AGNUS_PAL, "AGNUS_PAL "); ++ AMIGAHW_ANNOUNCE(AGNUS_NTSC, "AGNUS_NTSC "); ++ AMIGAHW_ANNOUNCE(AGNUS_HR_PAL, "AGNUS_HR_PAL "); ++ AMIGAHW_ANNOUNCE(AGNUS_HR_NTSC, "AGNUS_HR_NTSC "); ++ AMIGAHW_ANNOUNCE(ALICE_PAL, "ALICE_PAL "); ++ AMIGAHW_ANNOUNCE(ALICE_NTSC, "ALICE_NTSC "); ++ AMIGAHW_ANNOUNCE(MAGIC_REKICK, "MAGIC_REKICK "); ++ AMIGAHW_ANNOUNCE(PCMCIA, "PCMCIA "); ++ if (AMIGAHW_PRESENT(ZORRO)) ++ printk("ZORRO%s ", AMIGAHW_PRESENT(ZORRO3) ? "3" : ""); ++ printk("\n"); + + #undef AMIGAHW_ANNOUNCE + } +@@ -370,119 +368,117 @@ static void __init amiga_identify(void) + + void __init config_amiga(void) + { +- int i; ++ int i; ++ ++ amiga_debug_init(); ++ amiga_identify(); + +- amiga_debug_init(); +- amiga_identify(); ++ /* Yuk, we don't have PCI memory */ ++ iomem_resource.name = "Memory"; ++ for (i = 0; i < 4; i++) ++ request_resource(&iomem_resource, &((struct resource *)&mb_resources)[i]); ++ ++ mach_sched_init = amiga_sched_init; ++ mach_init_IRQ = amiga_init_IRQ; ++ mach_get_model = amiga_get_model; ++ mach_get_hardware_list = amiga_get_hardware_list; ++ mach_gettimeoffset = amiga_gettimeoffset; ++ if (AMIGAHW_PRESENT(A3000_CLK)) { ++ mach_hwclk = a3000_hwclk; ++ rtc_resource.name = "A3000 RTC"; ++ request_resource(&iomem_resource, &rtc_resource); ++ } else /* if (AMIGAHW_PRESENT(A2000_CLK)) */ { ++ mach_hwclk = a2000_hwclk; ++ rtc_resource.name = "A2000 RTC"; ++ request_resource(&iomem_resource, &rtc_resource); ++ } + +- /* Yuk, we don't have PCI memory */ +- iomem_resource.name = "Memory"; +- for (i = 0; i < 4; i++) +- request_resource(&iomem_resource, &((struct resource *)&mb_resources)[i]); +- +- mach_sched_init = amiga_sched_init; +- mach_init_IRQ = amiga_init_IRQ; +- mach_get_model = amiga_get_model; +- mach_get_hardware_list = amiga_get_hardware_list; +- mach_gettimeoffset = amiga_gettimeoffset; +- if (AMIGAHW_PRESENT(A3000_CLK)){ +- mach_hwclk = a3000_hwclk; +- rtc_resource.name = "A3000 RTC"; +- request_resource(&iomem_resource, &rtc_resource); +- } +- else{ /* if (AMIGAHW_PRESENT(A2000_CLK)) */ +- mach_hwclk = a2000_hwclk; +- rtc_resource.name = "A2000 RTC"; +- request_resource(&iomem_resource, &rtc_resource); +- } +- +- mach_max_dma_address = 0xffffffff; /* +- * default MAX_DMA=0xffffffff +- * on all machines. If we don't +- * do so, the SCSI code will not +- * be able to allocate any mem +- * for transfers, unless we are +- * dealing with a Z2 mem only +- * system. /Jes +- */ +- +- mach_set_clock_mmss = amiga_set_clock_mmss; +- mach_get_ss = amiga_get_ss; +- mach_reset = amiga_reset; ++ /* ++ * default MAX_DMA=0xffffffff on all machines. If we don't do so, the SCSI ++ * code will not be able to allocate any mem for transfers, unless we are ++ * dealing with a Z2 mem only system. /Jes ++ */ ++ mach_max_dma_address = 0xffffffff; ++ ++ mach_set_clock_mmss = amiga_set_clock_mmss; ++ mach_get_ss = amiga_get_ss; ++ mach_reset = amiga_reset; + #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE) +- mach_beep = amiga_mksound; ++ mach_beep = amiga_mksound; + #endif + + #ifdef CONFIG_HEARTBEAT +- mach_heartbeat = amiga_heartbeat; ++ mach_heartbeat = amiga_heartbeat; + #endif + +- /* Fill in the clock values (based on the 700 kHz E-Clock) */ +- amiga_masterclock = 40*amiga_eclock; /* 28 MHz */ +- amiga_colorclock = 5*amiga_eclock; /* 3.5 MHz */ +- +- /* clear all DMA bits */ +- amiga_custom.dmacon = DMAF_ALL; +- /* ensure that the DMA master bit is set */ +- amiga_custom.dmacon = DMAF_SETCLR | DMAF_MASTER; +- +- /* don't use Z2 RAM as system memory on Z3 capable machines */ +- if (AMIGAHW_PRESENT(ZORRO3)) { +- int i, j; +- u32 disabled_z2mem = 0; +- for (i = 0; i < m68k_num_memory; i++) +- if (m68k_memory[i].addr < 16*1024*1024) { +- if (i == 0) { +- /* don't cut off the branch we're sitting on */ +- printk("Warning: kernel runs in Zorro II memory\n"); +- continue; +- } +- disabled_z2mem += m68k_memory[i].size; +- m68k_num_memory--; +- for (j = i; j < m68k_num_memory; j++) +- m68k_memory[j] = m68k_memory[j+1]; +- i--; +- } +- if (disabled_z2mem) +- printk("%dK of Zorro II memory will not be used as system memory\n", +- disabled_z2mem>>10); +- } +- +- /* request all RAM */ +- for (i = 0; i < m68k_num_memory; i++) { +- ram_resource[i].name = +- (m68k_memory[i].addr >= 0x01000000) ? "32-bit Fast RAM" : +- (m68k_memory[i].addr < 0x00c00000) ? "16-bit Fast RAM" : +- "16-bit Slow RAM"; +- ram_resource[i].start = m68k_memory[i].addr; +- ram_resource[i].end = m68k_memory[i].addr+m68k_memory[i].size-1; +- request_resource(&iomem_resource, &ram_resource[i]); +- } +- +- /* initialize chipram allocator */ +- amiga_chip_init (); +- +- /* debugging using chipram */ +- if (!strcmp( m68k_debug_device, "mem" )){ +- if (!AMIGAHW_PRESENT(CHIP_RAM)) +- printk("Warning: no chipram present for debugging\n"); +- else { +- amiga_savekmsg_init(); +- amiga_console_driver.write = amiga_mem_console_write; +- register_console(&amiga_console_driver); +- } +- } +- +- /* our beloved beeper */ +- if (AMIGAHW_PRESENT(AMI_AUDIO)) +- amiga_init_sound(); +- +- /* +- * if it is an A3000, set the magic bit that forces +- * a hard rekick +- */ +- if (AMIGAHW_PRESENT(MAGIC_REKICK)) +- *(unsigned char *)ZTWO_VADDR(0xde0002) |= 0x80; ++ /* Fill in the clock values (based on the 700 kHz E-Clock) */ ++ amiga_masterclock = 40*amiga_eclock; /* 28 MHz */ ++ amiga_colorclock = 5*amiga_eclock; /* 3.5 MHz */ ++ ++ /* clear all DMA bits */ ++ amiga_custom.dmacon = DMAF_ALL; ++ /* ensure that the DMA master bit is set */ ++ amiga_custom.dmacon = DMAF_SETCLR | DMAF_MASTER; ++ ++ /* don't use Z2 RAM as system memory on Z3 capable machines */ ++ if (AMIGAHW_PRESENT(ZORRO3)) { ++ int i, j; ++ u32 disabled_z2mem = 0; ++ ++ for (i = 0; i < m68k_num_memory; i++) { ++ if (m68k_memory[i].addr < 16*1024*1024) { ++ if (i == 0) { ++ /* don't cut off the branch we're sitting on */ ++ printk("Warning: kernel runs in Zorro II memory\n"); ++ continue; ++ } ++ disabled_z2mem += m68k_memory[i].size; ++ m68k_num_memory--; ++ for (j = i; j < m68k_num_memory; j++) ++ m68k_memory[j] = m68k_memory[j+1]; ++ i--; ++ } ++ } ++ if (disabled_z2mem) ++ printk("%dK of Zorro II memory will not be used as system memory\n", ++ disabled_z2mem>>10); ++ } ++ ++ /* request all RAM */ ++ for (i = 0; i < m68k_num_memory; i++) { ++ ram_resource[i].name = ++ (m68k_memory[i].addr >= 0x01000000) ? "32-bit Fast RAM" : ++ (m68k_memory[i].addr < 0x00c00000) ? "16-bit Fast RAM" : ++ "16-bit Slow RAM"; ++ ram_resource[i].start = m68k_memory[i].addr; ++ ram_resource[i].end = m68k_memory[i].addr+m68k_memory[i].size-1; ++ request_resource(&iomem_resource, &ram_resource[i]); ++ } ++ ++ /* initialize chipram allocator */ ++ amiga_chip_init(); ++ ++ /* debugging using chipram */ ++ if (!strcmp(m68k_debug_device, "mem")) { ++ if (!AMIGAHW_PRESENT(CHIP_RAM)) ++ printk("Warning: no chipram present for debugging\n"); ++ else { ++ amiga_savekmsg_init(); ++ amiga_console_driver.write = amiga_mem_console_write; ++ register_console(&amiga_console_driver); ++ } ++ } ++ ++ /* our beloved beeper */ ++ if (AMIGAHW_PRESENT(AMI_AUDIO)) ++ amiga_init_sound(); ++ ++ /* ++ * if it is an A3000, set the magic bit that forces ++ * a hard rekick ++ */ ++ if (AMIGAHW_PRESENT(MAGIC_REKICK)) ++ *(unsigned char *)ZTWO_VADDR(0xde0002) |= 0x80; + } + + static unsigned short jiffy_ticks; +@@ -490,12 +486,12 @@ static unsigned short jiffy_ticks; + static void __init amiga_sched_init(irq_handler_t timer_routine) + { + static struct resource sched_res = { +- .name = "timer", .start = 0x00bfd400, .end = 0x00bfd5ff, ++ .name = "timer", .start = 0x00bfd400, .end = 0x00bfd5ff, + }; + jiffy_ticks = (amiga_eclock+HZ/2)/HZ; + + if (request_resource(&mb_resources._ciab, &sched_res)) +- printk("Cannot allocate ciab.ta{lo,hi}\n"); ++ printk("Cannot allocate ciab.ta{lo,hi}\n"); + ciab.cra &= 0xC0; /* turn off timer A, continuous mode, from Eclk */ + ciab.talo = jiffy_ticks % 256; + ciab.tahi = jiffy_ticks / 256; +@@ -513,7 +509,7 @@ static void __init amiga_sched_init(irq_ + #define TICK_SIZE 10000 + + /* This is always executed with interrupts disabled. */ +-static unsigned long amiga_gettimeoffset (void) ++static unsigned long amiga_gettimeoffset(void) + { + unsigned short hi, lo, hi2; + unsigned long ticks, offset = 0; +@@ -585,15 +581,15 @@ static int a2000_hwclk(int op, struct rt + + tod_2000.cntrl1 = TOD2000_CNTRL1_HOLD; + +- while ((tod_2000.cntrl1 & TOD2000_CNTRL1_BUSY) && cnt--) +- { +- tod_2000.cntrl1 &= ~TOD2000_CNTRL1_HOLD; +- udelay(70); +- tod_2000.cntrl1 |= TOD2000_CNTRL1_HOLD; ++ while ((tod_2000.cntrl1 & TOD2000_CNTRL1_BUSY) && cnt--) { ++ tod_2000.cntrl1 &= ~TOD2000_CNTRL1_HOLD; ++ udelay(70); ++ tod_2000.cntrl1 |= TOD2000_CNTRL1_HOLD; + } + + if (!cnt) +- printk(KERN_INFO "hwclk: timed out waiting for RTC (0x%x)\n", tod_2000.cntrl1); ++ printk(KERN_INFO "hwclk: timed out waiting for RTC (0x%x)\n", ++ tod_2000.cntrl1); + + if (!op) { /* read */ + t->tm_sec = tod_2000.second1 * 10 + tod_2000.second2; +@@ -606,7 +602,7 @@ static int a2000_hwclk(int op, struct rt + if (t->tm_year <= 69) + t->tm_year += 100; + +- if (!(tod_2000.cntrl3 & TOD2000_CNTRL3_24HMODE)){ ++ if (!(tod_2000.cntrl3 & TOD2000_CNTRL3_24HMODE)) { + if (!(tod_2000.hour1 & TOD2000_HOUR1_PM) && t->tm_hour == 12) + t->tm_hour = 0; + else if ((tod_2000.hour1 & TOD2000_HOUR1_PM) && t->tm_hour != 12) +@@ -642,7 +638,7 @@ static int a2000_hwclk(int op, struct rt + return 0; + } + +-static int amiga_set_clock_mmss (unsigned long nowtime) ++static int amiga_set_clock_mmss(unsigned long nowtime) + { + short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60; + +@@ -660,8 +656,7 @@ static int amiga_set_clock_mmss (unsigne + + tod_2000.cntrl1 |= TOD2000_CNTRL1_HOLD; + +- while ((tod_2000.cntrl1 & TOD2000_CNTRL1_BUSY) && cnt--) +- { ++ while ((tod_2000.cntrl1 & TOD2000_CNTRL1_BUSY) && cnt--) { + tod_2000.cntrl1 &= ~TOD2000_CNTRL1_HOLD; + udelay(70); + tod_2000.cntrl1 |= TOD2000_CNTRL1_HOLD; +@@ -681,7 +676,7 @@ static int amiga_set_clock_mmss (unsigne + return 0; + } + +-static unsigned int amiga_get_ss( void ) ++static unsigned int amiga_get_ss(void) + { + unsigned int s; + +@@ -695,71 +690,72 @@ static unsigned int amiga_get_ss( void ) + return s; + } + +-static NORET_TYPE void amiga_reset( void ) ++static NORET_TYPE void amiga_reset(void) + ATTRIB_NORET; + +-static void amiga_reset (void) ++static void amiga_reset(void) + { +- unsigned long jmp_addr040 = virt_to_phys(&&jmp_addr_label040); +- unsigned long jmp_addr = virt_to_phys(&&jmp_addr_label); +- +- local_irq_disable(); +- if (CPU_IS_040_OR_060) +- /* Setup transparent translation registers for mapping +- * of 16 MB kernel segment before disabling translation +- */ +- __asm__ __volatile__ +- ("movel %0,%/d0\n\t" +- "andl #0xff000000,%/d0\n\t" +- "orw #0xe020,%/d0\n\t" /* map 16 MB, enable, cacheable */ +- ".chip 68040\n\t" +- "movec %%d0,%%itt0\n\t" +- "movec %%d0,%%dtt0\n\t" +- ".chip 68k\n\t" +- "jmp %0@\n\t" +- : /* no outputs */ +- : "a" (jmp_addr040)); +- else +- /* for 680[23]0, just disable translation and jump to the physical +- * address of the label +- */ +- __asm__ __volatile__ +- ("pmove %/tc,%@\n\t" +- "bclr #7,%@\n\t" +- "pmove %@,%/tc\n\t" +- "jmp %0@\n\t" +- : /* no outputs */ +- : "a" (jmp_addr)); +- jmp_addr_label040: +- /* disable translation on '040 now */ +- __asm__ __volatile__ +- ("moveq #0,%/d0\n\t" +- ".chip 68040\n\t" +- "movec %%d0,%%tc\n\t" /* disable MMU */ +- ".chip 68k\n\t" +- : /* no outputs */ +- : /* no inputs */ +- : "d0"); +- +- jmp_addr_label: +- /* pickup reset address from AmigaOS ROM, reset devices and jump +- * to reset address +- */ +- __asm__ __volatile__ +- ("movew #0x2700,%/sr\n\t" +- "leal 0x01000000,%/a0\n\t" +- "subl %/a0@(-0x14),%/a0\n\t" +- "movel %/a0@(4),%/a0\n\t" +- "subql #2,%/a0\n\t" +- "bra 1f\n\t" +- /* align on a longword boundary */ +- __ALIGN_STR "\n" +- "1:\n\t" +- "reset\n\t" +- "jmp %/a0@" : /* Just that gcc scans it for % escapes */ ); ++ unsigned long jmp_addr040 = virt_to_phys(&&jmp_addr_label040); ++ unsigned long jmp_addr = virt_to_phys(&&jmp_addr_label); + +- for (;;); ++ local_irq_disable(); ++ if (CPU_IS_040_OR_060) ++ /* Setup transparent translation registers for mapping ++ * of 16 MB kernel segment before disabling translation ++ */ ++ 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@\n" ++ : /* no outputs */ ++ : "a" (jmp_addr040) ++ : "d0"); ++ else ++ /* for 680[23]0, just disable translation and jump to the physical ++ * address of the label ++ */ ++ asm volatile ("\n" ++ " pmove %%tc,%@\n" ++ " bclr #7,%@\n" ++ " pmove %@,%%tc\n" ++ " jmp %0@\n" ++ : /* no outputs */ ++ : "a" (jmp_addr)); ++jmp_addr_label040: ++ /* disable translation on '040 now */ ++ asm volatile ("\n" ++ " moveq #0,%%d0\n" ++ " .chip 68040\n" ++ " movec %%d0,%%tc\n" /* disable MMU */ ++ " .chip 68k\n" ++ : /* no outputs */ ++ : /* no inputs */ ++ : "d0"); ++ ++ jmp_addr_label: ++ /* pickup reset address from AmigaOS ROM, reset devices and jump ++ * to reset address ++ */ ++ asm volatile ("\n" ++ " move.w #0x2700,%sr\n" ++ " lea 0x01000000,%a0\n" ++ " sub.l %a0@(-0x14),%a0\n" ++ " move.l %a0@(4),%a0\n" ++ " subq.l #2,%a0\n" ++ " jra 1f\n" ++ /* align on a longword boundary */ ++ " " __ALIGN_STR "\n" ++ "1:\n" ++ " reset\n" ++ " jmp %a0@"); + ++ for (;;) ++ ; + } + + +@@ -773,11 +769,11 @@ static void amiga_reset (void) + #define SAVEKMSG_MAGIC2 0x4B4D5347 /* 'KMSG' */ + + struct savekmsg { +- unsigned long magic1; /* SAVEKMSG_MAGIC1 */ +- unsigned long magic2; /* SAVEKMSG_MAGIC2 */ +- unsigned long magicptr; /* address of magic1 */ +- unsigned long size; +- char data[0]; ++ unsigned long magic1; /* SAVEKMSG_MAGIC1 */ ++ unsigned long magic2; /* SAVEKMSG_MAGIC2 */ ++ unsigned long magicptr; /* address of magic1 */ ++ unsigned long size; ++ char data[0]; + }; + + static struct savekmsg *savekmsg; +@@ -785,100 +781,100 @@ static struct savekmsg *savekmsg; + static void amiga_mem_console_write(struct console *co, const char *s, + unsigned int count) + { +- if (savekmsg->size+count <= SAVEKMSG_MAXMEM-sizeof(struct savekmsg)) { +- memcpy(savekmsg->data+savekmsg->size, s, count); +- savekmsg->size += count; +- } ++ if (savekmsg->size + count <= SAVEKMSG_MAXMEM-sizeof(struct savekmsg)) { ++ memcpy(savekmsg->data + savekmsg->size, s, count); ++ savekmsg->size += count; ++ } + } + + static void amiga_savekmsg_init(void) + { +- static struct resource debug_res = { .name = "Debug" }; ++ static struct resource debug_res = { .name = "Debug" }; + +- savekmsg = amiga_chip_alloc_res(SAVEKMSG_MAXMEM, &debug_res); +- savekmsg->magic1 = SAVEKMSG_MAGIC1; +- savekmsg->magic2 = SAVEKMSG_MAGIC2; +- savekmsg->magicptr = ZTWO_PADDR(savekmsg); +- savekmsg->size = 0; ++ savekmsg = amiga_chip_alloc_res(SAVEKMSG_MAXMEM, &debug_res); ++ savekmsg->magic1 = SAVEKMSG_MAGIC1; ++ savekmsg->magic2 = SAVEKMSG_MAGIC2; ++ savekmsg->magicptr = ZTWO_PADDR(savekmsg); ++ savekmsg->size = 0; + } + + static void amiga_serial_putc(char c) + { +- amiga_custom.serdat = (unsigned char)c | 0x100; +- while (!(amiga_custom.serdatr & 0x2000)) +- ; ++ amiga_custom.serdat = (unsigned char)c | 0x100; ++ while (!(amiga_custom.serdatr & 0x2000)) ++ ; + } + + void amiga_serial_console_write(struct console *co, const char *s, +- unsigned int count) ++ unsigned int count) + { +- while (count--) { +- if (*s == '\n') +- amiga_serial_putc('\r'); +- amiga_serial_putc(*s++); +- } ++ while (count--) { ++ if (*s == '\n') ++ amiga_serial_putc('\r'); ++ amiga_serial_putc(*s++); ++ } + } + + #ifdef CONFIG_SERIAL_CONSOLE + void amiga_serial_puts(const char *s) + { +- amiga_serial_console_write(NULL, s, strlen(s)); ++ amiga_serial_console_write(NULL, s, strlen(s)); + } + + int amiga_serial_console_wait_key(struct console *co) + { +- int ch; ++ int ch; + +- while (!(amiga_custom.intreqr & IF_RBF)) +- barrier(); +- ch = amiga_custom.serdatr & 0xff; +- /* clear the interrupt, so that another character can be read */ +- amiga_custom.intreq = IF_RBF; +- return ch; ++ while (!(amiga_custom.intreqr & IF_RBF)) ++ barrier(); ++ ch = amiga_custom.serdatr & 0xff; ++ /* clear the interrupt, so that another character can be read */ ++ amiga_custom.intreq = IF_RBF; ++ return ch; + } + + void amiga_serial_gets(struct console *co, char *s, int len) + { +- int ch, cnt = 0; ++ int ch, cnt = 0; ++ ++ while (1) { ++ ch = amiga_serial_console_wait_key(co); + +- while (1) { +- ch = amiga_serial_console_wait_key(co); ++ /* Check for backspace. */ ++ if (ch == 8 || ch == 127) { ++ if (cnt == 0) { ++ amiga_serial_putc('\007'); ++ continue; ++ } ++ cnt--; ++ amiga_serial_puts("\010 \010"); ++ continue; ++ } ++ ++ /* Check for enter. */ ++ if (ch == 10 || ch == 13) ++ break; ++ ++ /* See if line is too long. */ ++ if (cnt >= len + 1) { ++ amiga_serial_putc(7); ++ cnt--; ++ continue; ++ } + +- /* Check for backspace. */ +- if (ch == 8 || ch == 127) { +- if (cnt == 0) { +- amiga_serial_putc('\007'); +- continue; +- } +- cnt--; +- amiga_serial_puts("\010 \010"); +- continue; +- } +- +- /* Check for enter. */ +- if (ch == 10 || ch == 13) +- break; +- +- /* See if line is too long. */ +- if (cnt >= len + 1) { +- amiga_serial_putc(7); +- cnt--; +- continue; +- } +- +- /* Store and echo character. */ +- s[cnt++] = ch; +- amiga_serial_putc(ch); +- } +- /* Print enter. */ +- amiga_serial_puts("\r\n"); +- s[cnt] = 0; ++ /* Store and echo character. */ ++ s[cnt++] = ch; ++ amiga_serial_putc(ch); ++ } ++ /* Print enter. */ ++ amiga_serial_puts("\r\n"); ++ s[cnt] = 0; + } + #endif + + static void __init amiga_debug_init(void) + { +- if (!strcmp( m68k_debug_device, "ser" )) { ++ if (!strcmp(m68k_debug_device, "ser" )) { + /* no initialization required (?) */ + amiga_console_driver.write = amiga_serial_console_write; + register_console(&amiga_console_driver); +@@ -888,10 +884,10 @@ static void __init amiga_debug_init(void + #ifdef CONFIG_HEARTBEAT + static void amiga_heartbeat(int on) + { +- if (on) +- ciaa.pra &= ~2; +- else +- ciaa.pra |= 2; ++ if (on) ++ ciaa.pra &= ~2; ++ else ++ ciaa.pra |= 2; + } + #endif + +@@ -901,81 +897,81 @@ static void amiga_heartbeat(int on) + + static void amiga_get_model(char *model) + { +- strcpy(model, amiga_model_name); ++ strcpy(model, amiga_model_name); + } + + + static int amiga_get_hardware_list(char *buffer) + { +- int len = 0; ++ int len = 0; + +- if (AMIGAHW_PRESENT(CHIP_RAM)) +- len += sprintf(buffer+len, "Chip RAM:\t%ldK\n", amiga_chip_size>>10); +- len += sprintf(buffer+len, "PS Freq:\t%dHz\nEClock Freq:\t%ldHz\n", +- amiga_psfreq, amiga_eclock); +- if (AMIGAHW_PRESENT(AMI_VIDEO)) { +- char *type; +- switch(amiga_chipset) { +- case CS_OCS: +- type = "OCS"; +- break; +- case CS_ECS: +- type = "ECS"; +- break; +- case CS_AGA: +- type = "AGA"; +- break; +- default: +- type = "Old or Unknown"; +- break; ++ if (AMIGAHW_PRESENT(CHIP_RAM)) ++ len += sprintf(buffer+len, "Chip RAM:\t%ldK\n", amiga_chip_size>>10); ++ len += sprintf(buffer+len, "PS Freq:\t%dHz\nEClock Freq:\t%ldHz\n", ++ amiga_psfreq, amiga_eclock); ++ if (AMIGAHW_PRESENT(AMI_VIDEO)) { ++ char *type; ++ switch (amiga_chipset) { ++ case CS_OCS: ++ type = "OCS"; ++ break; ++ case CS_ECS: ++ type = "ECS"; ++ break; ++ case CS_AGA: ++ type = "AGA"; ++ break; ++ default: ++ type = "Old or Unknown"; ++ break; ++ } ++ len += sprintf(buffer+len, "Graphics:\t%s\n", type); + } +- len += sprintf(buffer+len, "Graphics:\t%s\n", type); +- } + + #define AMIGAHW_ANNOUNCE(name, str) \ +- if (AMIGAHW_PRESENT(name)) \ +- len += sprintf (buffer+len, "\t%s\n", str) ++ if (AMIGAHW_PRESENT(name)) \ ++ len += sprintf (buffer+len, "\t%s\n", str) + +- len += sprintf (buffer + len, "Detected hardware:\n"); ++ len += sprintf (buffer + len, "Detected hardware:\n"); + +- AMIGAHW_ANNOUNCE(AMI_VIDEO, "Amiga Video"); +- AMIGAHW_ANNOUNCE(AMI_BLITTER, "Blitter"); +- AMIGAHW_ANNOUNCE(AMBER_FF, "Amber Flicker Fixer"); +- AMIGAHW_ANNOUNCE(AMI_AUDIO, "Amiga Audio"); +- AMIGAHW_ANNOUNCE(AMI_FLOPPY, "Floppy Controller"); +- AMIGAHW_ANNOUNCE(A3000_SCSI, "SCSI Controller WD33C93 (A3000 style)"); +- AMIGAHW_ANNOUNCE(A4000_SCSI, "SCSI Controller NCR53C710 (A4000T style)"); +- AMIGAHW_ANNOUNCE(A1200_IDE, "IDE Interface (A1200 style)"); +- AMIGAHW_ANNOUNCE(A4000_IDE, "IDE Interface (A4000 style)"); +- AMIGAHW_ANNOUNCE(CD_ROM, "Internal CD ROM drive"); +- AMIGAHW_ANNOUNCE(AMI_KEYBOARD, "Keyboard"); +- AMIGAHW_ANNOUNCE(AMI_MOUSE, "Mouse Port"); +- AMIGAHW_ANNOUNCE(AMI_SERIAL, "Serial Port"); +- AMIGAHW_ANNOUNCE(AMI_PARALLEL, "Parallel Port"); +- AMIGAHW_ANNOUNCE(A2000_CLK, "Hardware Clock (A2000 style)"); +- AMIGAHW_ANNOUNCE(A3000_CLK, "Hardware Clock (A3000 style)"); +- AMIGAHW_ANNOUNCE(CHIP_RAM, "Chip RAM"); +- AMIGAHW_ANNOUNCE(PAULA, "Paula 8364"); +- AMIGAHW_ANNOUNCE(DENISE, "Denise 8362"); +- AMIGAHW_ANNOUNCE(DENISE_HR, "Denise 8373"); +- AMIGAHW_ANNOUNCE(LISA, "Lisa 8375"); +- AMIGAHW_ANNOUNCE(AGNUS_PAL, "Normal/Fat PAL Agnus 8367/8371"); +- AMIGAHW_ANNOUNCE(AGNUS_NTSC, "Normal/Fat NTSC Agnus 8361/8370"); +- AMIGAHW_ANNOUNCE(AGNUS_HR_PAL, "Fat Hires PAL Agnus 8372"); +- AMIGAHW_ANNOUNCE(AGNUS_HR_NTSC, "Fat Hires NTSC Agnus 8372"); +- AMIGAHW_ANNOUNCE(ALICE_PAL, "PAL Alice 8374"); +- AMIGAHW_ANNOUNCE(ALICE_NTSC, "NTSC Alice 8374"); +- AMIGAHW_ANNOUNCE(MAGIC_REKICK, "Magic Hard Rekick"); +- AMIGAHW_ANNOUNCE(PCMCIA, "PCMCIA Slot"); ++ AMIGAHW_ANNOUNCE(AMI_VIDEO, "Amiga Video"); ++ AMIGAHW_ANNOUNCE(AMI_BLITTER, "Blitter"); ++ AMIGAHW_ANNOUNCE(AMBER_FF, "Amber Flicker Fixer"); ++ AMIGAHW_ANNOUNCE(AMI_AUDIO, "Amiga Audio"); ++ AMIGAHW_ANNOUNCE(AMI_FLOPPY, "Floppy Controller"); ++ AMIGAHW_ANNOUNCE(A3000_SCSI, "SCSI Controller WD33C93 (A3000 style)"); ++ AMIGAHW_ANNOUNCE(A4000_SCSI, "SCSI Controller NCR53C710 (A4000T style)"); ++ AMIGAHW_ANNOUNCE(A1200_IDE, "IDE Interface (A1200 style)"); ++ AMIGAHW_ANNOUNCE(A4000_IDE, "IDE Interface (A4000 style)"); ++ AMIGAHW_ANNOUNCE(CD_ROM, "Internal CD ROM drive"); ++ AMIGAHW_ANNOUNCE(AMI_KEYBOARD, "Keyboard"); ++ AMIGAHW_ANNOUNCE(AMI_MOUSE, "Mouse Port"); ++ AMIGAHW_ANNOUNCE(AMI_SERIAL, "Serial Port"); ++ AMIGAHW_ANNOUNCE(AMI_PARALLEL, "Parallel Port"); ++ AMIGAHW_ANNOUNCE(A2000_CLK, "Hardware Clock (A2000 style)"); ++ AMIGAHW_ANNOUNCE(A3000_CLK, "Hardware Clock (A3000 style)"); ++ AMIGAHW_ANNOUNCE(CHIP_RAM, "Chip RAM"); ++ AMIGAHW_ANNOUNCE(PAULA, "Paula 8364"); ++ AMIGAHW_ANNOUNCE(DENISE, "Denise 8362"); ++ AMIGAHW_ANNOUNCE(DENISE_HR, "Denise 8373"); ++ AMIGAHW_ANNOUNCE(LISA, "Lisa 8375"); ++ AMIGAHW_ANNOUNCE(AGNUS_PAL, "Normal/Fat PAL Agnus 8367/8371"); ++ AMIGAHW_ANNOUNCE(AGNUS_NTSC, "Normal/Fat NTSC Agnus 8361/8370"); ++ AMIGAHW_ANNOUNCE(AGNUS_HR_PAL, "Fat Hires PAL Agnus 8372"); ++ AMIGAHW_ANNOUNCE(AGNUS_HR_NTSC, "Fat Hires NTSC Agnus 8372"); ++ AMIGAHW_ANNOUNCE(ALICE_PAL, "PAL Alice 8374"); ++ AMIGAHW_ANNOUNCE(ALICE_NTSC, "NTSC Alice 8374"); ++ AMIGAHW_ANNOUNCE(MAGIC_REKICK, "Magic Hard Rekick"); ++ AMIGAHW_ANNOUNCE(PCMCIA, "PCMCIA Slot"); + #ifdef CONFIG_ZORRO +- if (AMIGAHW_PRESENT(ZORRO)) +- len += sprintf(buffer+len, "\tZorro II%s AutoConfig: %d Expansion " +- "Device%s\n", +- AMIGAHW_PRESENT(ZORRO3) ? "I" : "", +- zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s"); ++ if (AMIGAHW_PRESENT(ZORRO)) ++ len += sprintf(buffer+len, "\tZorro II%s AutoConfig: %d Expansion " ++ "Device%s\n", ++ AMIGAHW_PRESENT(ZORRO3) ? "I" : "", ++ zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s"); + #endif /* CONFIG_ZORRO */ + + #undef AMIGAHW_ANNOUNCE + +- return(len); ++ return len; + } +--- linux-m68k-2.6.21.orig/arch/m68k/atari/config.c ++++ linux-m68k-2.6.21/arch/m68k/atari/config.c +@@ -50,19 +50,19 @@ int atari_dont_touch_floppy_select; + int atari_rtc_year_offset; + + /* local function prototypes */ +-static void atari_reset( void ); ++static void atari_reset(void); + static void atari_get_model(char *model); + static int atari_get_hardware_list(char *buffer); + + /* atari specific irq functions */ + extern void atari_init_IRQ (void); +-extern void atari_mksound( unsigned int count, unsigned int ticks ); ++extern void atari_mksound(unsigned int count, unsigned int ticks); + #ifdef CONFIG_HEARTBEAT +-static void atari_heartbeat( int on ); ++static void atari_heartbeat(int on); + #endif + + /* atari specific timer functions (in time.c) */ +-extern void atari_sched_init(irq_handler_t ); ++extern void atari_sched_init(irq_handler_t); + extern unsigned long atari_gettimeoffset (void); + extern int atari_mste_hwclk (int, struct rtc_time *); + extern int atari_tt_hwclk (int, struct rtc_time *); +@@ -73,48 +73,6 @@ extern int atari_tt_set_clock_mmss (unsi + extern void atari_debug_init(void); + + +-/* I've moved hwreg_present() and hwreg_present_bywrite() out into +- * mm/hwtest.c, to avoid having multiple copies of the same routine +- * in the kernel [I wanted them in hp300 and they were already used +- * in the nubus code. NB: I don't have an Atari so this might (just +- * conceivably) break something. +- * I've preserved the #if 0 version of hwreg_present_bywrite() here +- * for posterity. +- * -- Peter Maydell <pmaydell@chiark.greenend.org.uk>, 05/1998 +- */ +- +-#if 0 +-static int __init +-hwreg_present_bywrite(volatile void *regp, unsigned char val) +-{ +- int ret; +- long save_sp, save_vbr; +- static long tmp_vectors[3] = { [2] = (long)&&after_test }; +- +- __asm__ __volatile__ +- ( "movec %/vbr,%2\n\t" /* save vbr value */ +- "movec %4,%/vbr\n\t" /* set up temporary vectors */ +- "movel %/sp,%1\n\t" /* save sp */ +- "moveq #0,%0\n\t" /* assume not present */ +- "moveb %5,%3@\n\t" /* write the hardware reg */ +- "cmpb %3@,%5\n\t" /* compare it */ +- "seq %0" /* comes here only if reg */ +- /* is present */ +- : "=d&" (ret), "=r&" (save_sp), "=r&" (save_vbr) +- : "a" (regp), "r" (tmp_vectors), "d" (val) +- ); +- after_test: +- __asm__ __volatile__ +- ( "movel %0,%/sp\n\t" /* restore sp */ +- "movec %1,%/vbr" /* restore vbr */ +- : : "r" (save_sp), "r" (save_vbr) : "sp" +- ); +- +- return( ret ); +-} +-#endif +- +- + /* ++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 +@@ -123,26 +81,34 @@ hwreg_present_bywrite(volatile void *reg + * should be readable without trouble (from channel A!). + */ + +-static int __init scc_test( volatile char *ctla ) ++static int __init scc_test(volatile char *ctla) + { +- if (!hwreg_present( ctla )) +- return( 0 ); ++ if (!hwreg_present(ctla)) ++ return 0; + MFPDELAY(); + +- *ctla = 2; MFPDELAY(); +- *ctla = 0x40; MFPDELAY(); ++ *ctla = 2; ++ MFPDELAY(); ++ *ctla = 0x40; ++ MFPDELAY(); + +- *ctla = 2; MFPDELAY(); +- if (*ctla != 0x40) return( 0 ); ++ *ctla = 2; ++ MFPDELAY(); ++ if (*ctla != 0x40) ++ return 0; + MFPDELAY(); + +- *ctla = 2; MFPDELAY(); +- *ctla = 0x60; MFPDELAY(); ++ *ctla = 2; ++ MFPDELAY(); ++ *ctla = 0x60; ++ MFPDELAY(); + +- *ctla = 2; MFPDELAY(); +- if (*ctla != 0x60) return( 0 ); ++ *ctla = 2; ++ MFPDELAY(); ++ if (*ctla != 0x60) ++ return 0; + +- return( 1 ); ++ return 1; + } + + +@@ -152,59 +118,58 @@ static int __init scc_test( volatile cha + + int __init atari_parse_bootinfo(const struct bi_record *record) + { +- int unknown = 0; +- const u_long *data = record->data; ++ int unknown = 0; ++ const u_long *data = record->data; + +- switch (record->tag) { ++ switch (record->tag) { + case BI_ATARI_MCH_COOKIE: +- atari_mch_cookie = *data; +- break; ++ atari_mch_cookie = *data; ++ break; + case BI_ATARI_MCH_TYPE: +- atari_mch_type = *data; +- break; ++ atari_mch_type = *data; ++ break; + default: +- unknown = 1; +- } +- return(unknown); ++ unknown = 1; ++ break; ++ } ++ return unknown; + } + + + /* Parse the Atari-specific switches= option. */ +-void __init atari_switches_setup( const char *str, unsigned len ) ++void __init atari_switches_setup(const char *str, unsigned len) + { +- char switches[len+1]; +- char *p; +- int ovsc_shift; +- char *args = switches; +- +- /* copy string to local array, strsep works destructively... */ +- strlcpy( switches, str, sizeof(switches) ); +- 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; ++ char switches[len+1]; ++ char *p; ++ int ovsc_shift; ++ char *args = switches; ++ ++ /* copy string to local array, strsep works destructively... */ ++ strlcpy(switches, str, sizeof(switches)); ++ 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; ++ } + } +- else if (strcmp( p, "snd7" ) == 0) { +- atari_switches |= ATARI_SWITCH_SND7 << ovsc_shift; +- } +- } + } + + +@@ -214,284 +179,283 @@ void __init atari_switches_setup( const + + void __init config_atari(void) + { +- unsigned short tos_version; ++ unsigned short tos_version; + +- memset(&atari_hw_present, 0, sizeof(atari_hw_present)); ++ memset(&atari_hw_present, 0, sizeof(atari_hw_present)); + +- atari_debug_init(); ++ atari_debug_init(); + +- ioport_resource.end = 0xFFFFFFFF; /* Change size of I/O space from 64KB +- to 4GB. */ ++ /* 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_gettimeoffset = atari_gettimeoffset; +- mach_reset = atari_reset; +- mach_max_dma_address = 0xffffff; ++ 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_gettimeoffset = atari_gettimeoffset; ++ mach_reset = atari_reset; ++ mach_max_dma_address = 0xffffff; + #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE) +- mach_beep = atari_mksound; ++ mach_beep = atari_mksound; + #endif + #ifdef CONFIG_HEARTBEAT +- mach_heartbeat = atari_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 +- */ ++ /* 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); ++ } + +- printk( "Atari hardware found: " ); +- if (MACH_IS_MEDUSA || MACH_IS_HADES) { +- /* 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); +- printk( "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); +- printk( "STDMA-SCSI " ); +- } +- else if (hwreg_present( tt_palette )) { +- ATARIHW_SET(TT_SHIFTER); +- printk( "TT_SHIFTER " ); +- } +- else if (hwreg_present( &shifter.bas_hi )) { +- if (hwreg_present( &shifter.bas_lo ) && +- (shifter.bas_lo = 0x0aau, shifter.bas_lo == 0x0aau)) { +- ATARIHW_SET(EXTD_SHIFTER); +- printk( "EXTD_SHIFTER " ); +- } +- else { +- ATARIHW_SET(STND_SHIFTER); +- printk( "STND_SHIFTER " ); +- } +- } +- if (hwreg_present( &mfp.par_dt_reg )) { +- ATARIHW_SET(ST_MFP); +- printk( "ST_MFP " ); +- } +- if (hwreg_present( &tt_mfp.par_dt_reg )) { +- ATARIHW_SET(TT_MFP); +- printk( "TT_MFP " ); +- } +- if (hwreg_present( &tt_scsi_dma.dma_addr_hi )) { +- ATARIHW_SET(SCSI_DMA); +- printk( "TT_SCSI_DMA " ); +- } +- if (!MACH_IS_HADES && hwreg_present( &st_dma.dma_hi )) { +- ATARIHW_SET(STND_DMA); +- printk( "STND_DMA " ); +- } +- if (MACH_IS_MEDUSA || /* The ST-DMA address registers aren't readable +- * on all Medusas, so the test below may fail */ +- (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); +- printk( "EXTD_DMA " ); +- } +- if (hwreg_present( &tt_scsi.scsi_data )) { +- ATARIHW_SET(TT_SCSI); +- printk( "TT_SCSI " ); +- } +- if (hwreg_present( &sound_ym.rd_data_reg_sel )) { +- ATARIHW_SET(YM_2149); +- printk( "YM2149 " ); +- } +- if (!MACH_IS_MEDUSA && !MACH_IS_HADES && +- hwreg_present( &tt_dmasnd.ctrl )) { +- ATARIHW_SET(PCM_8BIT); +- printk( "PCM " ); +- } +- if (!MACH_IS_HADES && hwreg_present( &falcon_codec.unused5 )) { +- ATARIHW_SET(CODEC); +- printk( "CODEC " ); +- } +- if (hwreg_present( &dsp56k_host_interface.icr )) { +- ATARIHW_SET(DSP56K); +- printk( "DSP56K " ); +- } +- if (hwreg_present( &tt_scc_dma.dma_ctrl ) && ++ /* ++bjoern: ++ * Determine hardware present ++ */ ++ ++ printk("Atari hardware found: "); ++ if (MACH_IS_MEDUSA || MACH_IS_HADES) { ++ /* 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); ++ printk("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); ++ printk("STDMA-SCSI "); ++ } else if (hwreg_present(tt_palette)) { ++ ATARIHW_SET(TT_SHIFTER); ++ printk("TT_SHIFTER "); ++ } else if (hwreg_present(&shifter.bas_hi)) { ++ if (hwreg_present(&shifter.bas_lo) && ++ (shifter.bas_lo = 0x0aau, shifter.bas_lo == 0x0aau)) { ++ ATARIHW_SET(EXTD_SHIFTER); ++ printk("EXTD_SHIFTER "); ++ } else { ++ ATARIHW_SET(STND_SHIFTER); ++ printk("STND_SHIFTER "); ++ } ++ } ++ if (hwreg_present(&mfp.par_dt_reg)) { ++ ATARIHW_SET(ST_MFP); ++ printk("ST_MFP "); ++ } ++ if (hwreg_present(&tt_mfp.par_dt_reg)) { ++ ATARIHW_SET(TT_MFP); ++ printk("TT_MFP "); ++ } ++ if (hwreg_present(&tt_scsi_dma.dma_addr_hi)) { ++ ATARIHW_SET(SCSI_DMA); ++ printk("TT_SCSI_DMA "); ++ } ++ if (!MACH_IS_HADES && hwreg_present(&st_dma.dma_hi)) { ++ ATARIHW_SET(STND_DMA); ++ printk("STND_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); ++ printk("EXTD_DMA "); ++ } ++ if (hwreg_present(&tt_scsi.scsi_data)) { ++ ATARIHW_SET(TT_SCSI); ++ printk("TT_SCSI "); ++ } ++ if (hwreg_present(&sound_ym.rd_data_reg_sel)) { ++ ATARIHW_SET(YM_2149); ++ printk("YM2149 "); ++ } ++ if (!MACH_IS_MEDUSA && !MACH_IS_HADES && ++ hwreg_present(&tt_dmasnd.ctrl)) { ++ ATARIHW_SET(PCM_8BIT); ++ printk("PCM "); ++ } ++ if (!MACH_IS_HADES && hwreg_present(&falcon_codec.unused5)) { ++ ATARIHW_SET(CODEC); ++ printk("CODEC "); ++ } ++ if (hwreg_present(&dsp56k_host_interface.icr)) { ++ ATARIHW_SET(DSP56K); ++ printk("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) ++ /* 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 && !MACH_IS_HADES ++ !MACH_IS_MEDUSA && !MACH_IS_HADES + #endif +- ) { +- ATARIHW_SET(SCC_DMA); +- printk( "SCC_DMA " ); +- } +- if (scc_test( &scc.cha_a_ctrl )) { +- ATARIHW_SET(SCC); +- printk( "SCC " ); +- } +- if (scc_test( &st_escc.cha_b_ctrl )) { +- ATARIHW_SET( ST_ESCC ); +- printk( "ST_ESCC " ); +- } +- if (MACH_IS_HADES) +- { +- ATARIHW_SET( VME ); +- printk( "VME " ); +- } +- else if (hwreg_present( &tt_scu.sys_mask )) { +- ATARIHW_SET(SCU); +- /* Assume a VME bus if there's a SCU */ +- ATARIHW_SET( VME ); +- printk( "VME SCU " ); +- } +- if (hwreg_present( (void *)(0xffff9210) )) { +- ATARIHW_SET(ANALOG_JOY); +- printk( "ANALOG_JOY " ); +- } +- if (!MACH_IS_HADES && hwreg_present( blitter.halftone )) { +- ATARIHW_SET(BLITTER); +- printk( "BLITTER " ); +- } +- if (hwreg_present((void *)0xfff00039)) { +- ATARIHW_SET(IDE); +- printk( "IDE " ); +- } ++ ) { ++ ATARIHW_SET(SCC_DMA); ++ printk("SCC_DMA "); ++ } ++ if (scc_test(&scc.cha_a_ctrl)) { ++ ATARIHW_SET(SCC); ++ printk("SCC "); ++ } ++ if (scc_test(&st_escc.cha_b_ctrl)) { ++ ATARIHW_SET(ST_ESCC); ++ printk("ST_ESCC "); ++ } ++ if (MACH_IS_HADES) { ++ ATARIHW_SET(VME); ++ printk("VME "); ++ } else if (hwreg_present(&tt_scu.sys_mask)) { ++ ATARIHW_SET(SCU); ++ /* Assume a VME bus if there's a SCU */ ++ ATARIHW_SET(VME); ++ printk("VME SCU "); ++ } ++ if (hwreg_present((void *)(0xffff9210))) { ++ ATARIHW_SET(ANALOG_JOY); ++ printk("ANALOG_JOY "); ++ } ++ if (!MACH_IS_HADES && hwreg_present(blitter.halftone)) { ++ ATARIHW_SET(BLITTER); ++ printk("BLITTER "); ++ } ++ if (hwreg_present((void *)0xfff00039)) { ++ ATARIHW_SET(IDE); ++ printk("IDE "); ++ } + #if 1 /* This maybe wrong */ +- if (!MACH_IS_MEDUSA && !MACH_IS_HADES && +- 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) ; +- printk( "MICROWIRE " ); +- } ++ if (!MACH_IS_MEDUSA && !MACH_IS_HADES && ++ 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) ++ ; ++ printk("MICROWIRE "); ++ } + #endif +- if (hwreg_present( &tt_rtc.regsel )) { +- ATARIHW_SET(TT_CLK); +- printk( "TT_CLK " ); +- mach_hwclk = atari_tt_hwclk; +- mach_set_clock_mmss = atari_tt_set_clock_mmss; +- } +- if (!MACH_IS_HADES && hwreg_present( &mste_rtc.sec_ones)) { +- ATARIHW_SET(MSTE_CLK); +- printk( "MSTE_CLK "); +- mach_hwclk = atari_mste_hwclk; +- mach_set_clock_mmss = atari_mste_set_clock_mmss; +- } +- if (!MACH_IS_MEDUSA && !MACH_IS_HADES && +- hwreg_present( &dma_wd.fdc_speed ) && +- hwreg_write( &dma_wd.fdc_speed, 0 )) { +- ATARIHW_SET(FDCSPEED); +- printk( "FDC_SPEED "); +- } +- if (!MACH_IS_HADES && !ATARIHW_PRESENT(ST_SCSI)) { +- ATARIHW_SET(ACSI); +- printk( "ACSI " ); +- } +- printk("\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 ("moveq #0,%/d0\n\t" +- ".chip 68040\n\t" +- "movec %%d0,%%itt0\n\t" +- "movec %%d0,%%dtt0\n\t" +- ".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 (hwreg_present(&tt_rtc.regsel)) { ++ ATARIHW_SET(TT_CLK); ++ printk("TT_CLK "); ++ mach_hwclk = atari_tt_hwclk; ++ mach_set_clock_mmss = atari_tt_set_clock_mmss; ++ } ++ if (!MACH_IS_HADES && hwreg_present(&mste_rtc.sec_ones)) { ++ ATARIHW_SET(MSTE_CLK); ++ printk("MSTE_CLK "); ++ mach_hwclk = atari_mste_hwclk; ++ mach_set_clock_mmss = atari_mste_set_clock_mmss; ++ } ++ if (!MACH_IS_MEDUSA && !MACH_IS_HADES && ++ hwreg_present(&dma_wd.fdc_speed) && ++ hwreg_write(&dma_wd.fdc_speed, 0)) { ++ ATARIHW_SET(FDCSPEED); ++ printk("FDC_SPEED "); ++ } ++ if (!MACH_IS_HADES && !ATARIHW_PRESENT(ST_SCSI)) { ++ ATARIHW_SET(ACSI); ++ printk("ACSI "); ++ } ++ printk("\n"); + +- 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__ ( ".chip 68030\n\t" +- "pmove %0@,%/tt1\n\t" +- ".chip 68k" +- : : "a" (&tt1_val) ); +- } +- else { +- __asm__ __volatile__ +- ( "movel %0,%/d0\n\t" +- ".chip 68040\n\t" +- "movec %%d0,%%itt1\n\t" +- "movec %%d0,%%dtt1\n\t" +- ".chip 68k" +- : +- : "g" (0xfe00a040) /* Translate 0xfexxxxxx, enable, +- * supervisor only, non-cacheable/ +- * serialized, writable */ +- : "d0" ); +- +- } +- +- /* 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 || MACH_IS_HADES) ? +- 0xfff : *(unsigned short *)0xff000002; +- atari_rtc_year_offset = (tos_version < 0x306) ? 70 : 68; ++ 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" ++ : : "a" (&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 || MACH_IS_HADES) ? ++ 0xfff : *(unsigned short *)0xff000002; ++ atari_rtc_year_offset = (tos_version < 0x306) ? 70 : 68; + } + + #ifdef CONFIG_HEARTBEAT +-static void atari_heartbeat( int on ) ++static void atari_heartbeat(int on) + { +- unsigned char tmp; +- unsigned long flags; ++ unsigned char tmp; ++ unsigned long flags; + +- if (atari_dont_touch_floppy_select) +- return; ++ 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); ++ 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 + +@@ -526,180 +490,171 @@ static void atari_heartbeat( int on ) + + /* ++andreas: no need for complicated code, just depend on prefetch */ + +-static void atari_reset (void) ++static void atari_reset(void) + { +- long tc_val = 0; +- long reset_addr; ++ 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_HADES ? 0x7fe00030 : +- 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__ +- ("moveq #0,%/d0\n\t" +- "movec %/d0,%/vbr" +- : : : "d0" ); +- +- 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__ +- ("moveq #0,%/d0\n\t" +- ".chip 68060\n\t" +- "movec %%d0,%%pcr\n\t" +- ".chip 68k" +- : : : "d0" ); +- } +- +- __asm__ __volatile__ +- ("movel %0,%/d0\n\t" +- "andl #0xff000000,%/d0\n\t" +- "orw #0xe020,%/d0\n\t" /* map 16 MB, enable, cacheable */ +- ".chip 68040\n\t" +- "movec %%d0,%%itt0\n\t" +- "movec %%d0,%%dtt0\n\t" +- ".chip 68k\n\t" +- "jmp %0@\n\t" +- : /* no outputs */ +- : "a" (jmp_addr040) +- : "d0" ); +- jmp_addr_label040: +- __asm__ __volatile__ +- ("moveq #0,%/d0\n\t" +- "nop\n\t" +- ".chip 68040\n\t" +- "cinva %%bc\n\t" +- "nop\n\t" +- "pflusha\n\t" +- "nop\n\t" +- "movec %%d0,%%tc\n\t" +- "nop\n\t" +- /* 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. */ +- "movel #0xffc000,%%d0\n\t" /* whole insn space cacheable */ +- "movec %%d0,%%itt0\n\t" +- "movec %%d0,%%itt1\n\t" +- "orw #0x40,%/d0\n\t" /* whole data space non-cacheable/ser. */ +- "movec %%d0,%%dtt0\n\t" +- "movec %%d0,%%dtt1\n\t" +- ".chip 68k\n\t" +- "jmp %0@" +- : /* no outputs */ +- : "a" (reset_addr) +- : "d0"); +- } +- else +- __asm__ __volatile__ +- ("pmove %0@,%/tc\n\t" +- "jmp %1@" +- : /* no outputs */ +- : "a" (&tc_val), "a" (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_HADES ? 0x7fe00030 : ++ 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 */ ++ : "a" (&tc_val), "a" (reset_addr)); + } + + + static void atari_get_model(char *model) + { +- strcpy(model, "Atari "); +- switch (atari_mch_cookie >> 16) { ++ 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; ++ 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; ++ 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 if (MACH_IS_HADES) +- strcat(model, "Hades"); +- else +- strcat (model, "TT"); +- break; ++ if (MACH_IS_MEDUSA) ++ /* Medusa has TT _MCH cookie */ ++ strcat(model, "Medusa"); ++ else if (MACH_IS_HADES) ++ strcat(model, "Hades"); ++ else ++ strcat(model, "TT"); ++ break; + case ATARI_MCH_FALCON: +- strcat (model, "Falcon"); +- if (MACH_IS_AB40) +- strcat (model, " (with Afterburner040)"); +- break; ++ 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; +- } ++ sprintf(model + strlen(model), "(unknown mach cookie 0x%lx)", ++ atari_mch_cookie); ++ break; ++ } + } + + + static int atari_get_hardware_list(char *buffer) + { +- int len = 0, i; ++ int len = 0, i; + +- for (i = 0; i < m68k_num_memory; i++) +- len += sprintf (buffer+len, "\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)) \ +- len += sprintf (buffer + len, "\t%s\n", str) +- +- len += sprintf (buffer + len, "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"); ++ for (i = 0; i < m68k_num_memory; i++) ++ len += sprintf(buffer+len, "\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)) \ ++ len += sprintf(buffer + len, "\t%s\n", str) ++ ++ len += sprintf(buffer + len, "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"); + +- return(len); ++ return len; + } +- +-/* +- * Local variables: +- * c-indent-level: 4 +- * tab-width: 8 +- * End: +- */ +--- linux-m68k-2.6.21.orig/arch/m68k/atari/debug.c ++++ linux-m68k-2.6.21/arch/m68k/atari/debug.c +@@ -30,317 +30,311 @@ int atari_SCC_init_done; + int atari_SCC_reset_done; + + static struct console atari_console_driver = { +- .name = "debug", +- .flags = CON_PRINTBUFFER, +- .index = -1, ++ .name = "debug", ++ .flags = CON_PRINTBUFFER, ++ .index = -1, + }; + + +-static inline void ata_mfp_out (char c) ++static inline void ata_mfp_out(char c) + { +- while (!(mfp.trn_stat & 0x80)) /* wait for tx buf empty */ +- barrier (); +- mfp.usart_dta = c; ++ while (!(mfp.trn_stat & 0x80)) /* wait for tx buf empty */ ++ barrier(); ++ mfp.usart_dta = c; + } + +-void atari_mfp_console_write (struct console *co, const char *str, +- unsigned int count) ++void atari_mfp_console_write(struct console *co, const char *str, ++ unsigned int count) + { +- while (count--) { +- if (*str == '\n') +- ata_mfp_out( '\r' ); +- ata_mfp_out( *str++ ); +- } ++ while (count--) { ++ if (*str == '\n') ++ ata_mfp_out('\r'); ++ ata_mfp_out(*str++); ++ } + } + +-static inline void ata_scc_out (char c) ++static inline void ata_scc_out(char c) + { +- do { ++ do { ++ MFPDELAY(); ++ } while (!(scc.cha_b_ctrl & 0x04)); /* wait for tx buf empty */ + MFPDELAY(); +- } while (!(scc.cha_b_ctrl & 0x04)); /* wait for tx buf empty */ +- MFPDELAY(); +- scc.cha_b_data = c; ++ scc.cha_b_data = c; + } + +-void atari_scc_console_write (struct console *co, const char *str, +- unsigned int count) ++void atari_scc_console_write(struct console *co, const char *str, ++ unsigned int count) + { +- while (count--) { +- if (*str == '\n') +- ata_scc_out( '\r' ); +- ata_scc_out( *str++ ); +- } ++ while (count--) { ++ if (*str == '\n') ++ ata_scc_out('\r'); ++ ata_scc_out(*str++); ++ } + } + +-static inline void ata_midi_out (char c) ++static inline void ata_midi_out(char c) + { +- while (!(acia.mid_ctrl & ACIA_TDRE)) /* wait for tx buf empty */ +- barrier (); +- acia.mid_data = c; ++ while (!(acia.mid_ctrl & ACIA_TDRE)) /* wait for tx buf empty */ ++ barrier(); ++ acia.mid_data = c; + } + +-void atari_midi_console_write (struct console *co, const char *str, +- unsigned int count) ++void atari_midi_console_write(struct console *co, const char *str, ++ unsigned int count) + { +- while (count--) { +- if (*str == '\n') +- ata_midi_out( '\r' ); +- ata_midi_out( *str++ ); +- } ++ while (count--) { ++ if (*str == '\n') ++ ata_midi_out('\r'); ++ ata_midi_out(*str++); ++ } + } + +-static int ata_par_out (char c) ++static int ata_par_out(char c) + { +- unsigned char tmp; +- /* This a some-seconds timeout in case no printer is connected */ +- unsigned long i = loops_per_jiffy > 1 ? loops_per_jiffy : 10000000/HZ; ++ unsigned char tmp; ++ /* This a some-seconds timeout in case no printer is connected */ ++ unsigned long i = loops_per_jiffy > 1 ? loops_per_jiffy : 10000000/HZ; + +- while( (mfp.par_dt_reg & 1) && --i ) /* wait for BUSY == L */ +- ; +- if (!i) return( 0 ); ++ while ((mfp.par_dt_reg & 1) && --i) /* wait for BUSY == L */ ++ ; ++ if (!i) ++ return 0; + +- sound_ym.rd_data_reg_sel = 15; /* select port B */ +- sound_ym.wd_data = c; /* put char onto port */ +- sound_ym.rd_data_reg_sel = 14; /* select port A */ +- tmp = sound_ym.rd_data_reg_sel; +- sound_ym.wd_data = tmp & ~0x20; /* set strobe L */ +- MFPDELAY(); /* wait a bit */ +- sound_ym.wd_data = tmp | 0x20; /* set strobe H */ +- return( 1 ); ++ sound_ym.rd_data_reg_sel = 15; /* select port B */ ++ sound_ym.wd_data = c; /* put char onto port */ ++ sound_ym.rd_data_reg_sel = 14; /* select port A */ ++ tmp = sound_ym.rd_data_reg_sel; ++ sound_ym.wd_data = tmp & ~0x20; /* set strobe L */ ++ MFPDELAY(); /* wait a bit */ ++ sound_ym.wd_data = tmp | 0x20; /* set strobe H */ ++ return 1; + } + +-static void atari_par_console_write (struct console *co, const char *str, +- unsigned int count) ++static void atari_par_console_write(struct console *co, const char *str, ++ unsigned int count) + { +- static int printer_present = 1; +- +- if (!printer_present) +- return; ++ static int printer_present = 1; + +- while (count--) { +- if (*str == '\n') +- if (!ata_par_out( '\r' )) { +- printer_present = 0; ++ if (!printer_present) + return; +- } +- if (!ata_par_out( *str++ )) { +- printer_present = 0; +- return; ++ ++ while (count--) { ++ if (*str == '\n') { ++ if (!ata_par_out('\r')) { ++ printer_present = 0; ++ return; ++ } ++ } ++ if (!ata_par_out(*str++)) { ++ printer_present = 0; ++ return; ++ } + } +- } + } + + #ifdef CONFIG_SERIAL_CONSOLE + int atari_mfp_console_wait_key(struct console *co) + { +- while( !(mfp.rcv_stat & 0x80) ) /* wait for rx buf filled */ +- barrier(); +- return( mfp.usart_dta ); ++ while (!(mfp.rcv_stat & 0x80)) /* wait for rx buf filled */ ++ barrier(); ++ return mfp.usart_dta; + } + + int atari_scc_console_wait_key(struct console *co) + { +- do { ++ do { ++ MFPDELAY(); ++ } while (!(scc.cha_b_ctrl & 0x01)); /* wait for rx buf filled */ + MFPDELAY(); +- } while( !(scc.cha_b_ctrl & 0x01) ); /* wait for rx buf filled */ +- MFPDELAY(); +- return( scc.cha_b_data ); ++ return scc.cha_b_data; + } + + int atari_midi_console_wait_key(struct console *co) + { +- while( !(acia.mid_ctrl & ACIA_RDRF) ) /* wait for rx buf filled */ +- barrier(); +- return( acia.mid_data ); ++ while (!(acia.mid_ctrl & ACIA_RDRF)) /* wait for rx buf filled */ ++ barrier(); ++ return acia.mid_data; + } + #endif + +-/* The following two functions do a quick'n'dirty initialization of the MFP or ++/* ++ * The following two functions do a quick'n'dirty initialization of the MFP or + * SCC serial ports. They're used by the debugging interface, kgdb, and the +- * serial console code. */ ++ * serial console code. ++ */ + #ifndef CONFIG_SERIAL_CONSOLE +-static void __init atari_init_mfp_port( int cflag ) ++static void __init atari_init_mfp_port(int cflag) + #else +-void atari_init_mfp_port( int cflag ) ++void atari_init_mfp_port(int cflag) + #endif + { +- /* timer values for 1200...115200 bps; > 38400 select 110, 134, or 150 +- * bps, resp., and work only correct if there's a RSVE or RSSPEED */ +- static int baud_table[9] = { 16, 11, 8, 4, 2, 1, 175, 143, 128 }; +- int baud = cflag & CBAUD; +- int parity = (cflag & PARENB) ? ((cflag & PARODD) ? 0x04 : 0x06) : 0; +- int csize = ((cflag & CSIZE) == CS7) ? 0x20 : 0x00; +- +- if (cflag & CBAUDEX) +- baud += B38400; +- if (baud < B1200 || baud > B38400+2) +- baud = B9600; /* use default 9600bps for non-implemented rates */ +- baud -= B1200; /* baud_table[] starts at 1200bps */ +- +- mfp.trn_stat &= ~0x01; /* disable TX */ +- mfp.usart_ctr = parity | csize | 0x88; /* 1:16 clk mode, 1 stop bit */ +- mfp.tim_ct_cd &= 0x70; /* stop timer D */ +- mfp.tim_dt_d = baud_table[baud]; +- mfp.tim_ct_cd |= 0x01; /* start timer D, 1:4 */ +- mfp.trn_stat |= 0x01; /* enable TX */ +- +- atari_MFP_init_done = 1; +-} +- +-#define SCC_WRITE(reg,val) \ +- do { \ +- scc.cha_b_ctrl = (reg); \ +- MFPDELAY(); \ +- scc.cha_b_ctrl = (val); \ +- MFPDELAY(); \ +- } while(0) ++ /* ++ * timer values for 1200...115200 bps; > 38400 select 110, 134, or 150 ++ * bps, resp., and work only correct if there's a RSVE or RSSPEED ++ */ ++ static int baud_table[9] = { 16, 11, 8, 4, 2, 1, 175, 143, 128 }; ++ int baud = cflag & CBAUD; ++ int parity = (cflag & PARENB) ? ((cflag & PARODD) ? 0x04 : 0x06) : 0; ++ int csize = ((cflag & CSIZE) == CS7) ? 0x20 : 0x00; ++ ++ if (cflag & CBAUDEX) ++ baud += B38400; ++ if (baud < B1200 || baud > B38400+2) ++ baud = B9600; /* use default 9600bps for non-implemented rates */ ++ baud -= B1200; /* baud_table[] starts at 1200bps */ ++ ++ mfp.trn_stat &= ~0x01; /* disable TX */ ++ mfp.usart_ctr = parity | csize | 0x88; /* 1:16 clk mode, 1 stop bit */ ++ mfp.tim_ct_cd &= 0x70; /* stop timer D */ ++ mfp.tim_dt_d = baud_table[baud]; ++ mfp.tim_ct_cd |= 0x01; /* start timer D, 1:4 */ ++ mfp.trn_stat |= 0x01; /* enable TX */ ++ ++ atari_MFP_init_done = 1; ++} ++ ++#define SCC_WRITE(reg, val) \ ++ do { \ ++ scc.cha_b_ctrl = (reg); \ ++ MFPDELAY(); \ ++ scc.cha_b_ctrl = (val); \ ++ MFPDELAY(); \ ++ } while (0) + + /* loops_per_jiffy isn't initialized yet, so we can't use udelay(). This does a + * delay of ~ 60us. */ +-#define LONG_DELAY() \ +- do { \ +- int i; \ +- for( i = 100; i > 0; --i ) \ +- MFPDELAY(); \ +- } while(0) ++#define LONG_DELAY() \ ++ do { \ ++ int i; \ ++ for (i = 100; i > 0; --i) \ ++ MFPDELAY(); \ ++ } while (0) + + #ifndef CONFIG_SERIAL_CONSOLE +-static void __init atari_init_scc_port( int cflag ) ++static void __init atari_init_scc_port(int cflag) + #else +-void atari_init_scc_port( int cflag ) ++void atari_init_scc_port(int cflag) + #endif + { +- extern int atari_SCC_reset_done; +- static int clksrc_table[9] = +- /* reg 11: 0x50 = BRG, 0x00 = RTxC, 0x28 = TRxC */ +- { 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x00, 0x00 }; +- static int brgsrc_table[9] = +- /* reg 14: 0 = RTxC, 2 = PCLK */ +- { 2, 2, 2, 2, 2, 2, 0, 2, 2 }; +- static int clkmode_table[9] = +- /* reg 4: 0x40 = x16, 0x80 = x32, 0xc0 = x64 */ +- { 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xc0, 0x80 }; +- static int div_table[9] = +- /* reg12 (BRG low) */ +- { 208, 138, 103, 50, 24, 11, 1, 0, 0 }; +- +- int baud = cflag & CBAUD; +- int clksrc, clkmode, div, reg3, reg5; +- +- if (cflag & CBAUDEX) +- baud += B38400; +- if (baud < B1200 || baud > B38400+2) +- baud = B9600; /* use default 9600bps for non-implemented rates */ +- baud -= B1200; /* tables starts at 1200bps */ +- +- clksrc = clksrc_table[baud]; +- clkmode = clkmode_table[baud]; +- div = div_table[baud]; +- if (ATARIHW_PRESENT(TT_MFP) && baud >= 6) { +- /* special treatment for TT, where rates >= 38400 are done via TRxC */ +- clksrc = 0x28; /* TRxC */ +- clkmode = baud == 6 ? 0xc0 : +- baud == 7 ? 0x80 : /* really 76800bps */ +- 0x40; /* really 153600bps */ +- div = 0; +- } +- +- reg3 = (cflag & CSIZE) == CS8 ? 0xc0 : 0x40; +- reg5 = (cflag & CSIZE) == CS8 ? 0x60 : 0x20 | 0x82 /* assert DTR/RTS */; +- +- (void)scc.cha_b_ctrl; /* reset reg pointer */ +- SCC_WRITE( 9, 0xc0 ); /* reset */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCC_WRITE( 4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 | +- 0x04 /* 1 stopbit */ | +- clkmode ); +- SCC_WRITE( 3, reg3 ); +- SCC_WRITE( 5, reg5 ); +- SCC_WRITE( 9, 0 ); /* no interrupts */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCC_WRITE( 10, 0 ); /* NRZ mode */ +- SCC_WRITE( 11, clksrc ); /* main clock source */ +- SCC_WRITE( 12, div ); /* BRG value */ +- SCC_WRITE( 13, 0 ); /* BRG high byte */ +- SCC_WRITE( 14, brgsrc_table[baud] ); +- SCC_WRITE( 14, brgsrc_table[baud] | (div ? 1 : 0) ); +- SCC_WRITE( 3, reg3 | 1 ); +- SCC_WRITE( 5, reg5 | 8 ); ++ extern int atari_SCC_reset_done; ++ static int clksrc_table[9] = ++ /* reg 11: 0x50 = BRG, 0x00 = RTxC, 0x28 = TRxC */ ++ { 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x00, 0x00 }; ++ static int brgsrc_table[9] = ++ /* reg 14: 0 = RTxC, 2 = PCLK */ ++ { 2, 2, 2, 2, 2, 2, 0, 2, 2 }; ++ static int clkmode_table[9] = ++ /* reg 4: 0x40 = x16, 0x80 = x32, 0xc0 = x64 */ ++ { 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xc0, 0x80 }; ++ static int div_table[9] = ++ /* reg12 (BRG low) */ ++ { 208, 138, 103, 50, 24, 11, 1, 0, 0 }; ++ ++ int baud = cflag & CBAUD; ++ int clksrc, clkmode, div, reg3, reg5; ++ ++ if (cflag & CBAUDEX) ++ baud += B38400; ++ if (baud < B1200 || baud > B38400+2) ++ baud = B9600; /* use default 9600bps for non-implemented rates */ ++ baud -= B1200; /* tables starts at 1200bps */ ++ ++ clksrc = clksrc_table[baud]; ++ clkmode = clkmode_table[baud]; ++ div = div_table[baud]; ++ if (ATARIHW_PRESENT(TT_MFP) && baud >= 6) { ++ /* special treatment for TT, where rates >= 38400 are done via TRxC */ ++ clksrc = 0x28; /* TRxC */ ++ clkmode = baud == 6 ? 0xc0 : ++ baud == 7 ? 0x80 : /* really 76800bps */ ++ 0x40; /* really 153600bps */ ++ div = 0; ++ } ++ ++ reg3 = (cflag & CSIZE) == CS8 ? 0xc0 : 0x40; ++ reg5 = (cflag & CSIZE) == CS8 ? 0x60 : 0x20 | 0x82 /* assert DTR/RTS */; ++ ++ (void)scc.cha_b_ctrl; /* reset reg pointer */ ++ SCC_WRITE(9, 0xc0); /* reset */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCC_WRITE(4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) ++ : 0 | 0x04 /* 1 stopbit */ | clkmode); ++ SCC_WRITE(3, reg3); ++ SCC_WRITE(5, reg5); ++ SCC_WRITE(9, 0); /* no interrupts */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCC_WRITE(10, 0); /* NRZ mode */ ++ SCC_WRITE(11, clksrc); /* main clock source */ ++ SCC_WRITE(12, div); /* BRG value */ ++ SCC_WRITE(13, 0); /* BRG high byte */ ++ SCC_WRITE(14, brgsrc_table[baud]); ++ SCC_WRITE(14, brgsrc_table[baud] | (div ? 1 : 0)); ++ SCC_WRITE(3, reg3 | 1); ++ SCC_WRITE(5, reg5 | 8); + +- atari_SCC_reset_done = 1; +- atari_SCC_init_done = 1; ++ atari_SCC_reset_done = 1; ++ atari_SCC_init_done = 1; + } + + #ifndef CONFIG_SERIAL_CONSOLE +-static void __init atari_init_midi_port( int cflag ) ++static void __init atari_init_midi_port(int cflag) + #else +-void atari_init_midi_port( int cflag ) ++void atari_init_midi_port(int cflag) + #endif + { +- int baud = cflag & CBAUD; +- int csize = ((cflag & CSIZE) == CS8) ? 0x10 : 0x00; +- /* warning 7N1 isn't possible! (instead 7O2 is used...) */ +- int parity = (cflag & PARENB) ? ((cflag & PARODD) ? 0x0c : 0x08) : 0x04; +- int div; +- +- /* 4800 selects 7812.5, 115200 selects 500000, all other (incl. 9600 as +- * default) the standard MIDI speed 31250. */ +- if (cflag & CBAUDEX) +- baud += B38400; +- if (baud == B4800) +- div = ACIA_DIV64; /* really 7812.5 bps */ +- else if (baud == B38400+2 /* 115200 */) +- div = ACIA_DIV1; /* really 500 kbps (does that work??) */ +- else +- div = ACIA_DIV16; /* 31250 bps, standard for MIDI */ ++ int baud = cflag & CBAUD; ++ int csize = ((cflag & CSIZE) == CS8) ? 0x10 : 0x00; ++ /* warning 7N1 isn't possible! (instead 7O2 is used...) */ ++ int parity = (cflag & PARENB) ? ((cflag & PARODD) ? 0x0c : 0x08) : 0x04; ++ int div; ++ ++ /* 4800 selects 7812.5, 115200 selects 500000, all other (incl. 9600 as ++ * default) the standard MIDI speed 31250. */ ++ if (cflag & CBAUDEX) ++ baud += B38400; ++ if (baud == B4800) ++ div = ACIA_DIV64; /* really 7812.5 bps */ ++ else if (baud == B38400+2 /* 115200 */) ++ div = ACIA_DIV1; /* really 500 kbps (does that work??) */ ++ else ++ div = ACIA_DIV16; /* 31250 bps, standard for MIDI */ + +- /* RTS low, ints disabled */ +- acia.mid_ctrl = div | csize | parity | ++ /* RTS low, ints disabled */ ++ acia.mid_ctrl = div | csize | parity | + ((atari_switches & ATARI_SWITCH_MIDI) ? + ACIA_RHTID : ACIA_RLTID); + } + + void __init atari_debug_init(void) + { +- if (!strcmp( m68k_debug_device, "ser" )) { +- /* defaults to ser2 for a Falcon and ser1 otherwise */ +- strcpy( m68k_debug_device, MACH_IS_FALCON ? "ser2" : "ser1" ); +- +- } +- +- if (!strcmp( m68k_debug_device, "ser1" )) { +- /* ST-MFP Modem1 serial port */ +- atari_init_mfp_port( B9600|CS8 ); +- atari_console_driver.write = atari_mfp_console_write; +- } +- else if (!strcmp( m68k_debug_device, "ser2" )) { +- /* SCC Modem2 serial port */ +- atari_init_scc_port( B9600|CS8 ); +- atari_console_driver.write = atari_scc_console_write; +- } +- else if (!strcmp( m68k_debug_device, "midi" )) { +- /* MIDI port */ +- atari_init_midi_port( B9600|CS8 ); +- atari_console_driver.write = atari_midi_console_write; +- } +- else if (!strcmp( m68k_debug_device, "par" )) { +- /* parallel printer */ +- atari_turnoff_irq( IRQ_MFP_BUSY ); /* avoid ints */ +- sound_ym.rd_data_reg_sel = 7; /* select mixer control */ +- sound_ym.wd_data = 0xff; /* sound off, ports are output */ +- sound_ym.rd_data_reg_sel = 15; /* select port B */ +- sound_ym.wd_data = 0; /* no char */ +- sound_ym.rd_data_reg_sel = 14; /* select port A */ +- sound_ym.wd_data = sound_ym.rd_data_reg_sel | 0x20; /* strobe H */ +- atari_console_driver.write = atari_par_console_write; +- } +- if (atari_console_driver.write) +- register_console(&atari_console_driver); +-} ++ if (!strcmp(m68k_debug_device, "ser")) { ++ /* defaults to ser2 for a Falcon and ser1 otherwise */ ++ strcpy(m68k_debug_device, MACH_IS_FALCON ? "ser2" : "ser1"); ++ } + +-/* +- * Local variables: +- * c-indent-level: 4 +- * tab-width: 8 +- * End: +- */ ++ if (!strcmp(m68k_debug_device, "ser1")) { ++ /* ST-MFP Modem1 serial port */ ++ atari_init_mfp_port(B9600|CS8); ++ atari_console_driver.write = atari_mfp_console_write; ++ } else if (!strcmp(m68k_debug_device, "ser2")) { ++ /* SCC Modem2 serial port */ ++ atari_init_scc_port(B9600|CS8); ++ atari_console_driver.write = atari_scc_console_write; ++ } else if (!strcmp(m68k_debug_device, "midi")) { ++ /* MIDI port */ ++ atari_init_midi_port(B9600|CS8); ++ atari_console_driver.write = atari_midi_console_write; ++ } else if (!strcmp(m68k_debug_device, "par")) { ++ /* parallel printer */ ++ atari_turnoff_irq(IRQ_MFP_BUSY); /* avoid ints */ ++ sound_ym.rd_data_reg_sel = 7; /* select mixer control */ ++ sound_ym.wd_data = 0xff; /* sound off, ports are output */ ++ sound_ym.rd_data_reg_sel = 15; /* select port B */ ++ sound_ym.wd_data = 0; /* no char */ ++ sound_ym.rd_data_reg_sel = 14; /* select port A */ ++ sound_ym.wd_data = sound_ym.rd_data_reg_sel | 0x20; /* strobe H */ ++ atari_console_driver.write = atari_par_console_write; ++ } ++ if (atari_console_driver.write) ++ register_console(&atari_console_driver); ++} +--- linux-m68k-2.6.21.orig/arch/m68k/kernel/entry.S ++++ linux-m68k-2.6.21/arch/m68k/kernel/entry.S +@@ -692,7 +692,7 @@ sys_call_table: + .long sys_tgkill /* 265 */ + .long sys_utimes + .long sys_fadvise64_64 +- .long sys_mbind ++ .long sys_mbind + .long sys_get_mempolicy + .long sys_set_mempolicy /* 270 */ + .long sys_mq_open +--- linux-m68k-2.6.21.orig/arch/m68k/kernel/head.S ++++ linux-m68k-2.6.21/arch/m68k/kernel/head.S +@@ -3195,7 +3195,7 @@ func_start serial_putc,%d0/%d1/%a0/%a1 + jbra L(serial_putc_done) + 3: + #endif +- ++ + L(serial_putc_done): + func_return serial_putc + +--- linux-m68k-2.6.21.orig/arch/m68k/kernel/setup.c ++++ linux-m68k-2.6.21/arch/m68k/kernel/setup.c +@@ -133,78 +133,78 @@ extern void config_hp300(void); + extern void config_q40(void); + extern void config_sun3x(void); + +-extern void mac_debugging_short (int, short); +-extern void mac_debugging_long (int, long); +- + #define MASK_256K 0xfffc0000 + + extern void paging_init(void); + + static void __init m68k_parse_bootinfo(const struct bi_record *record) + { +- while (record->tag != BI_LAST) { +- int unknown = 0; +- const unsigned long *data = record->data; +- switch (record->tag) { +- case BI_MACHTYPE: +- case BI_CPUTYPE: +- case BI_FPUTYPE: +- case BI_MMUTYPE: +- /* Already set up by head.S */ +- break; +- +- case BI_MEMCHUNK: +- if (m68k_num_memory < NUM_MEMINFO) { +- m68k_memory[m68k_num_memory].addr = data[0]; +- m68k_memory[m68k_num_memory].size = data[1]; +- m68k_num_memory++; +- } else +- printk("m68k_parse_bootinfo: too many memory chunks\n"); +- break; +- +- case BI_RAMDISK: +- m68k_ramdisk.addr = data[0]; +- m68k_ramdisk.size = data[1]; +- break; +- +- case BI_COMMAND_LINE: +- strlcpy(m68k_command_line, (const char *)data, sizeof(m68k_command_line)); +- break; +- +- default: +- if (MACH_IS_AMIGA) +- unknown = amiga_parse_bootinfo(record); +- else if (MACH_IS_ATARI) +- unknown = atari_parse_bootinfo(record); +- else if (MACH_IS_MAC) +- unknown = mac_parse_bootinfo(record); +- else if (MACH_IS_Q40) +- unknown = q40_parse_bootinfo(record); +- else if (MACH_IS_BVME6000) +- unknown = bvme6000_parse_bootinfo(record); +- else if (MACH_IS_MVME16x) +- unknown = mvme16x_parse_bootinfo(record); +- else if (MACH_IS_MVME147) +- unknown = mvme147_parse_bootinfo(record); +- else if (MACH_IS_HP300) +- unknown = hp300_parse_bootinfo(record); +- else +- unknown = 1; +- } +- if (unknown) +- printk("m68k_parse_bootinfo: unknown tag 0x%04x ignored\n", +- record->tag); +- record = (struct bi_record *)((unsigned long)record+record->size); +- } ++ while (record->tag != BI_LAST) { ++ int unknown = 0; ++ const unsigned long *data = record->data; ++ ++ switch (record->tag) { ++ case BI_MACHTYPE: ++ case BI_CPUTYPE: ++ case BI_FPUTYPE: ++ case BI_MMUTYPE: ++ /* Already set up by head.S */ ++ break; ++ ++ case BI_MEMCHUNK: ++ if (m68k_num_memory < NUM_MEMINFO) { ++ m68k_memory[m68k_num_memory].addr = data[0]; ++ m68k_memory[m68k_num_memory].size = data[1]; ++ m68k_num_memory++; ++ } else ++ printk("m68k_parse_bootinfo: too many memory chunks\n"); ++ break; ++ ++ case BI_RAMDISK: ++ m68k_ramdisk.addr = data[0]; ++ m68k_ramdisk.size = data[1]; ++ break; ++ ++ case BI_COMMAND_LINE: ++ strlcpy(m68k_command_line, (const char *)data, ++ sizeof(m68k_command_line)); ++ break; ++ ++ default: ++ if (MACH_IS_AMIGA) ++ unknown = amiga_parse_bootinfo(record); ++ else if (MACH_IS_ATARI) ++ unknown = atari_parse_bootinfo(record); ++ else if (MACH_IS_MAC) ++ unknown = mac_parse_bootinfo(record); ++ else if (MACH_IS_Q40) ++ unknown = q40_parse_bootinfo(record); ++ else if (MACH_IS_BVME6000) ++ unknown = bvme6000_parse_bootinfo(record); ++ else if (MACH_IS_MVME16x) ++ unknown = mvme16x_parse_bootinfo(record); ++ else if (MACH_IS_MVME147) ++ unknown = mvme147_parse_bootinfo(record); ++ else if (MACH_IS_HP300) ++ unknown = hp300_parse_bootinfo(record); ++ else ++ unknown = 1; ++ } ++ if (unknown) ++ printk("m68k_parse_bootinfo: unknown tag 0x%04x ignored\n", ++ record->tag); ++ record = (struct bi_record *)((unsigned long)record + ++ record->size); ++ } + +- m68k_realnum_memory = m68k_num_memory; ++ m68k_realnum_memory = m68k_num_memory; + #ifdef CONFIG_SINGLE_MEMORY_CHUNK +- if (m68k_num_memory > 1) { +- printk("Ignoring last %i chunks of physical memory\n", +- (m68k_num_memory - 1)); +- m68k_num_memory = 1; +- } +- m68k_memoffset = m68k_memory[0].addr-PAGE_OFFSET; ++ if (m68k_num_memory > 1) { ++ printk("Ignoring last %i chunks of physical memory\n", ++ (m68k_num_memory - 1)); ++ m68k_num_memory = 1; ++ } ++ m68k_memoffset = m68k_memory[0].addr-PAGE_OFFSET; + #endif + } + +@@ -234,7 +234,7 @@ void __init setup_arch(char **cmdline_p) + /* clear the fpu if we have one */ + if (m68k_fputype & (FPU_68881|FPU_68882|FPU_68040|FPU_68060)) { + volatile int zero = 0; +- asm __volatile__ ("frestore %0" : : "m" (zero)); ++ asm volatile ("frestore %0" : : "m" (zero)); + } + #endif + +@@ -262,32 +262,35 @@ void __init setup_arch(char **cmdline_p) + * For the m68k, this is currently only "debug=xxx" to enable printing + * certain kernel messages to some machine-specific device. + */ +- for( p = *cmdline_p; p && *p; ) { +- i = 0; +- if (!strncmp( p, "debug=", 6 )) { +- strlcpy( m68k_debug_device, p+6, sizeof(m68k_debug_device) ); +- if ((q = strchr( m68k_debug_device, ' ' ))) *q = 0; +- i = 1; +- } ++ for (p = *cmdline_p; p && *p;) { ++ i = 0; ++ if (!strncmp(p, "debug=", 6)) { ++ strlcpy(m68k_debug_device, p+6, sizeof(m68k_debug_device)); ++ q = strchr(m68k_debug_device, ' '); ++ if (q) ++ *q = 0; ++ i = 1; ++ } + #ifdef CONFIG_ATARI +- /* This option must be parsed very early */ +- if (!strncmp( p, "switches=", 9 )) { +- extern void atari_switches_setup( const char *, int ); +- atari_switches_setup( p+9, (q = strchr( p+9, ' ' )) ? +- (q - (p+9)) : strlen(p+9) ); +- i = 1; +- } +-#endif +- +- if (i) { +- /* option processed, delete it */ +- if ((q = strchr( p, ' ' ))) +- strcpy( p, q+1 ); +- else +- *p = 0; +- } else { +- if ((p = strchr( p, ' ' ))) ++p; +- } ++ /* This option must be parsed very early */ ++ if (!strncmp(p, "switches=", 9)) { ++ extern void atari_switches_setup(const char *, int); ++ q = strchr(p + 9, ' '); ++ atari_switches_setup(p + 9, q ? (q - (p + 9)) : strlen(p + 9)); ++ i = 1; ++ } ++#endif ++ ++ if (i) { ++ /* option processed, delete it */ ++ if ((q = strchr(p, ' '))) ++ strcpy(p, q + 1); ++ else ++ *p = 0; ++ } else { ++ if ((p = strchr(p, ' '))) ++ ++p; ++ } + } + + #ifdef CONFIG_DUMMY_CONSOLE +@@ -296,62 +299,62 @@ void __init setup_arch(char **cmdline_p) + + switch (m68k_machtype) { + #ifdef CONFIG_AMIGA +- case MACH_AMIGA: ++ case MACH_AMIGA: + config_amiga(); + break; + #endif + #ifdef CONFIG_ATARI +- case MACH_ATARI: ++ case MACH_ATARI: + config_atari(); + break; + #endif + #ifdef CONFIG_MAC +- case MACH_MAC: ++ case MACH_MAC: + config_mac(); + break; + #endif + #ifdef CONFIG_SUN3 +- case MACH_SUN3: ++ case MACH_SUN3: + config_sun3(); + break; + #endif + #ifdef CONFIG_APOLLO +- case MACH_APOLLO: ++ case MACH_APOLLO: + config_apollo(); + break; + #endif + #ifdef CONFIG_MVME147 +- case MACH_MVME147: ++ case MACH_MVME147: + config_mvme147(); + break; + #endif + #ifdef CONFIG_MVME16x +- case MACH_MVME16x: ++ case MACH_MVME16x: + config_mvme16x(); + break; + #endif + #ifdef CONFIG_BVME6000 +- case MACH_BVME6000: ++ case MACH_BVME6000: + config_bvme6000(); + break; + #endif + #ifdef CONFIG_HP300 +- case MACH_HP300: ++ case MACH_HP300: + config_hp300(); + break; + #endif + #ifdef CONFIG_Q40 +- case MACH_Q40: +- config_q40(); ++ case MACH_Q40: ++ config_q40(); + break; + #endif + #ifdef CONFIG_SUN3X +- case MACH_SUN3X: ++ case MACH_SUN3X: + config_sun3x(); + break; + #endif +- default: +- panic ("No configuration setup"); ++ default: ++ panic("No configuration setup"); + } + + #ifndef CONFIG_SUN3 +@@ -380,7 +383,7 @@ void __init setup_arch(char **cmdline_p) + reserve_bootmem(m68k_ramdisk.addr, m68k_ramdisk.size); + initrd_start = (unsigned long)phys_to_virt(m68k_ramdisk.addr); + initrd_end = initrd_start + m68k_ramdisk.size; +- printk ("initrd: %08lx - %08lx\n", initrd_start, initrd_end); ++ printk("initrd: %08lx - %08lx\n", initrd_start, initrd_end); + } + #endif + +@@ -402,18 +405,18 @@ void __init setup_arch(char **cmdline_p) + #if defined(CONFIG_ISA) && defined(MULTI_ISA) + #if defined(CONFIG_Q40) + if (MACH_IS_Q40) { +- isa_type = Q40_ISA; +- isa_sex = 0; ++ isa_type = Q40_ISA; ++ isa_sex = 0; + } + #elif defined(CONFIG_GG2) +- if (MACH_IS_AMIGA && AMIGAHW_PRESENT(GG2_ISA)){ +- isa_type = GG2_ISA; +- isa_sex = 0; ++ if (MACH_IS_AMIGA && AMIGAHW_PRESENT(GG2_ISA)) { ++ isa_type = GG2_ISA; ++ isa_sex = 0; + } + #elif defined(CONFIG_AMIGA_PCMCIA) +- if (MACH_IS_AMIGA && AMIGAHW_PRESENT(PCMCIA)){ +- isa_type = AG_ISA; +- isa_sex = 1; ++ if (MACH_IS_AMIGA && AMIGAHW_PRESENT(PCMCIA)) { ++ isa_type = AG_ISA; ++ isa_sex = 1; + } + #endif + #endif +@@ -421,66 +424,66 @@ void __init setup_arch(char **cmdline_p) + + static int show_cpuinfo(struct seq_file *m, void *v) + { +- const char *cpu, *mmu, *fpu; +- unsigned long clockfreq, clockfactor; ++ const char *cpu, *mmu, *fpu; ++ unsigned long clockfreq, clockfactor; + + #define LOOP_CYCLES_68020 (8) + #define LOOP_CYCLES_68030 (8) + #define LOOP_CYCLES_68040 (3) + #define LOOP_CYCLES_68060 (1) + +- if (CPU_IS_020) { +- cpu = "68020"; +- clockfactor = LOOP_CYCLES_68020; +- } else if (CPU_IS_030) { +- cpu = "68030"; +- clockfactor = LOOP_CYCLES_68030; +- } else if (CPU_IS_040) { +- cpu = "68040"; +- clockfactor = LOOP_CYCLES_68040; +- } else if (CPU_IS_060) { +- cpu = "68060"; +- clockfactor = LOOP_CYCLES_68060; +- } else { +- cpu = "680x0"; +- clockfactor = 0; +- } ++ if (CPU_IS_020) { ++ cpu = "68020"; ++ clockfactor = LOOP_CYCLES_68020; ++ } else if (CPU_IS_030) { ++ cpu = "68030"; ++ clockfactor = LOOP_CYCLES_68030; ++ } else if (CPU_IS_040) { ++ cpu = "68040"; ++ clockfactor = LOOP_CYCLES_68040; ++ } else if (CPU_IS_060) { ++ cpu = "68060"; ++ clockfactor = LOOP_CYCLES_68060; ++ } else { ++ cpu = "680x0"; ++ clockfactor = 0; ++ } + + #ifdef CONFIG_M68KFPU_EMU_ONLY +- fpu="none(soft float)"; ++ fpu = "none(soft float)"; + #else +- if (m68k_fputype & FPU_68881) +- fpu = "68881"; +- else if (m68k_fputype & FPU_68882) +- fpu = "68882"; +- else if (m68k_fputype & FPU_68040) +- fpu = "68040"; +- else if (m68k_fputype & FPU_68060) +- fpu = "68060"; +- else if (m68k_fputype & FPU_SUNFPA) +- fpu = "Sun FPA"; +- else +- fpu = "none"; +-#endif +- +- if (m68k_mmutype & MMU_68851) +- mmu = "68851"; +- else if (m68k_mmutype & MMU_68030) +- mmu = "68030"; +- else if (m68k_mmutype & MMU_68040) +- mmu = "68040"; +- else if (m68k_mmutype & MMU_68060) +- mmu = "68060"; +- else if (m68k_mmutype & MMU_SUN3) +- mmu = "Sun-3"; +- else if (m68k_mmutype & MMU_APOLLO) +- mmu = "Apollo"; +- else +- mmu = "unknown"; ++ if (m68k_fputype & FPU_68881) ++ fpu = "68881"; ++ else if (m68k_fputype & FPU_68882) ++ fpu = "68882"; ++ else if (m68k_fputype & FPU_68040) ++ fpu = "68040"; ++ else if (m68k_fputype & FPU_68060) ++ fpu = "68060"; ++ else if (m68k_fputype & FPU_SUNFPA) ++ fpu = "Sun FPA"; ++ else ++ fpu = "none"; ++#endif ++ ++ if (m68k_mmutype & MMU_68851) ++ mmu = "68851"; ++ else if (m68k_mmutype & MMU_68030) ++ mmu = "68030"; ++ else if (m68k_mmutype & MMU_68040) ++ mmu = "68040"; ++ else if (m68k_mmutype & MMU_68060) ++ mmu = "68060"; ++ else if (m68k_mmutype & MMU_SUN3) ++ mmu = "Sun-3"; ++ else if (m68k_mmutype & MMU_APOLLO) ++ mmu = "Apollo"; ++ else ++ mmu = "unknown"; + +- clockfreq = loops_per_jiffy*HZ*clockfactor; ++ clockfreq = loops_per_jiffy * HZ * clockfactor; + +- seq_printf(m, "CPU:\t\t%s\n" ++ seq_printf(m, "CPU:\t\t%s\n" + "MMU:\t\t%s\n" + "FPU:\t\t%s\n" + "Clocking:\t%lu.%1luMHz\n" +@@ -490,7 +493,7 @@ static int show_cpuinfo(struct seq_file + clockfreq/1000000,(clockfreq/100000)%10, + loops_per_jiffy/(500000/HZ),(loops_per_jiffy/(5000/HZ))%100, + loops_per_jiffy); +- return 0; ++ return 0; + } + + static void *c_start(struct seq_file *m, loff_t *pos) +@@ -506,44 +509,44 @@ static void c_stop(struct seq_file *m, v + { + } + struct seq_operations cpuinfo_op = { +- .start = c_start, +- .next = c_next, +- .stop = c_stop, +- .show = show_cpuinfo, ++ .start = c_start, ++ .next = c_next, ++ .stop = c_stop, ++ .show = show_cpuinfo, + }; + + int get_hardware_list(char *buffer) + { +- int len = 0; +- char model[80]; +- unsigned long mem; +- int i; +- +- if (mach_get_model) +- mach_get_model(model); +- else +- strcpy(model, "Unknown m68k"); +- +- len += sprintf(buffer+len, "Model:\t\t%s\n", model); +- for (mem = 0, i = 0; i < m68k_num_memory; i++) +- mem += m68k_memory[i].size; +- len += sprintf(buffer+len, "System Memory:\t%ldK\n", mem>>10); ++ int len = 0; ++ char model[80]; ++ unsigned long mem; ++ int i; ++ ++ if (mach_get_model) ++ mach_get_model(model); ++ else ++ strcpy(model, "Unknown m68k"); ++ ++ len += sprintf(buffer + len, "Model:\t\t%s\n", model); ++ for (mem = 0, i = 0; i < m68k_num_memory; i++) ++ mem += m68k_memory[i].size; ++ len += sprintf(buffer + len, "System Memory:\t%ldK\n", mem >> 10); + +- if (mach_get_hardware_list) +- len += mach_get_hardware_list(buffer+len); ++ if (mach_get_hardware_list) ++ len += mach_get_hardware_list(buffer + len); + +- return(len); ++ return len; + } + + void check_bugs(void) + { + #ifndef CONFIG_M68KFPU_EMU + if (m68k_fputype == 0) { +- printk( KERN_EMERG "*** YOU DO NOT HAVE A FLOATING POINT UNIT, " +- "WHICH IS REQUIRED BY LINUX/M68K ***\n" ); +- printk( KERN_EMERG "Upgrade your hardware or join the FPU " +- "emulation project\n" ); +- panic( "no FPU" ); ++ printk(KERN_EMERG "*** YOU DO NOT HAVE A FLOATING POINT UNIT, " ++ "WHICH IS REQUIRED BY LINUX/M68K ***\n"); ++ printk(KERN_EMERG "Upgrade your hardware or join the FPU " ++ "emulation project\n"); ++ panic("no FPU"); + } + #endif /* !CONFIG_M68KFPU_EMU */ + } +--- linux-m68k-2.6.21.orig/arch/m68k/mac/config.c ++++ linux-m68k-2.6.21/arch/m68k/mac/config.c +@@ -59,15 +59,15 @@ extern struct mem_info m68k_ramdisk; + + extern char m68k_command_line[CL_SIZE]; + +-void *mac_env; /* Loaded by the boot asm */ ++void *mac_env; /* Loaded by the boot asm */ + + /* The phys. video addr. - might be bogus on some machines */ + unsigned long mac_orig_videoaddr; + + /* Mac specific timer functions */ +-extern unsigned long mac_gettimeoffset (void); +-extern int mac_hwclk (int, struct rtc_time *); +-extern int mac_set_clock_mmss (unsigned long); ++extern unsigned long mac_gettimeoffset(void); ++extern int mac_hwclk(int, struct rtc_time *); ++extern int mac_set_clock_mmss(unsigned long); + extern int show_mac_interrupts(struct seq_file *, void *); + extern void iop_preinit(void); + extern void iop_init(void); +@@ -99,51 +99,52 @@ static void mac_sched_init(irq_handler_t + + int __init mac_parse_bootinfo(const struct bi_record *record) + { +- int unknown = 0; +- const u_long *data = record->data; ++ int unknown = 0; ++ const u_long *data = record->data; + +- switch (record->tag) { ++ switch (record->tag) { + case BI_MAC_MODEL: +- mac_bi_data.id = *data; +- break; ++ mac_bi_data.id = *data; ++ break; + case BI_MAC_VADDR: +- mac_bi_data.videoaddr = *data; +- break; ++ mac_bi_data.videoaddr = *data; ++ break; + case BI_MAC_VDEPTH: +- mac_bi_data.videodepth = *data; +- break; ++ mac_bi_data.videodepth = *data; ++ break; + case BI_MAC_VROW: +- mac_bi_data.videorow = *data; +- break; ++ mac_bi_data.videorow = *data; ++ break; + case BI_MAC_VDIM: +- mac_bi_data.dimensions = *data; +- break; ++ mac_bi_data.dimensions = *data; ++ break; + case BI_MAC_VLOGICAL: +- mac_bi_data.videological = VIDEOMEMBASE + (*data & ~VIDEOMEMMASK); +- mac_orig_videoaddr = *data; +- break; ++ mac_bi_data.videological = VIDEOMEMBASE + (*data & ~VIDEOMEMMASK); ++ mac_orig_videoaddr = *data; ++ break; + case BI_MAC_SCCBASE: +- mac_bi_data.sccbase = *data; +- break; ++ mac_bi_data.sccbase = *data; ++ break; + case BI_MAC_BTIME: +- mac_bi_data.boottime = *data; +- break; ++ mac_bi_data.boottime = *data; ++ break; + case BI_MAC_GMTBIAS: +- mac_bi_data.gmtbias = *data; +- break; ++ mac_bi_data.gmtbias = *data; ++ break; + case BI_MAC_MEMSIZE: +- mac_bi_data.memsize = *data; +- break; ++ mac_bi_data.memsize = *data; ++ break; + case BI_MAC_CPUID: +- mac_bi_data.cpuid = *data; +- break; +- case BI_MAC_ROMBASE: +- mac_bi_data.rombase = *data; +- break; ++ mac_bi_data.cpuid = *data; ++ break; ++ case BI_MAC_ROMBASE: ++ mac_bi_data.rombase = *data; ++ break; + default: +- unknown = 1; +- } +- return(unknown); ++ unknown = 1; ++ break; ++ } ++ return unknown; + } + + /* +@@ -155,6 +156,7 @@ int __init mac_parse_bootinfo(const stru + static void mac_cache_card_flush(int writeback) + { + unsigned long flags; ++ + local_irq_save(flags); + via_flush_cache(); + local_irq_restore(flags); +@@ -162,28 +164,27 @@ static void mac_cache_card_flush(int wri + + void __init config_mac(void) + { +- if (!MACH_IS_MAC) { +- printk(KERN_ERR "ERROR: no Mac, but config_mac() called!! \n"); +- } ++ if (!MACH_IS_MAC) ++ printk(KERN_ERR "ERROR: no Mac, but config_mac() called!! \n"); + +- mach_sched_init = mac_sched_init; +- mach_init_IRQ = mac_init_IRQ; +- mach_get_model = mac_get_model; +- mach_gettimeoffset = mac_gettimeoffset; ++ mach_sched_init = mac_sched_init; ++ mach_init_IRQ = mac_init_IRQ; ++ mach_get_model = mac_get_model; ++ mach_gettimeoffset = mac_gettimeoffset; + #warning move to adb/via init + #if 0 +- mach_hwclk = mac_hwclk; ++ mach_hwclk = mac_hwclk; + #endif +- mach_set_clock_mmss = mac_set_clock_mmss; +- mach_reset = mac_reset; +- mach_halt = mac_poweroff; +- mach_power_off = mac_poweroff; ++ mach_set_clock_mmss = mac_set_clock_mmss; ++ mach_reset = mac_reset; ++ mach_halt = mac_poweroff; ++ mach_power_off = mac_poweroff; + mach_max_dma_address = 0xffffffff; + #if 0 +- mach_debug_init = mac_debug_init; ++ mach_debug_init = mac_debug_init; + #endif + #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE) +- mach_beep = mac_mksound; ++ mach_beep = mac_mksound; + #endif + #ifdef CONFIG_HEARTBEAT + #if 0 +@@ -199,21 +200,22 @@ void __init config_mac(void) + mac_identify(); + mac_report_hardware(); + +- /* AFAIK only the IIci takes a cache card. The IIfx has onboard +- cache ... someone needs to figure out how to tell if it's on or +- not. */ ++ /* ++ * AFAIK only the IIci takes a cache card. The IIfx has onboard ++ * cache ... someone needs to figure out how to tell if it's on or ++ * not. ++ */ + + if (macintosh_config->ident == MAC_MODEL_IICI +- || macintosh_config->ident == MAC_MODEL_IIFX) { ++ || macintosh_config->ident == MAC_MODEL_IIFX) + mach_l2_flush = mac_cache_card_flush; +- } + + /* + * Check for machine specific fixups. + */ + + #ifdef OLD_NUBUS_CODE +- nubus_sweep_video(); ++ nubus_sweep_video(); + #endif + } + +@@ -233,8 +235,7 @@ void __init config_mac(void) + struct mac_model *macintosh_config; + EXPORT_SYMBOL(macintosh_config); + +-static struct mac_model mac_data_table[]= +-{ ++static struct mac_model mac_data_table[] = { + /* + * We'll pretend to be a Macintosh II, that's pretty safe. + */ +@@ -784,12 +785,12 @@ void mac_identify(void) + if (!model) { + /* no bootinfo model id -> NetBSD booter was used! */ + /* XXX FIXME: breaks for model > 31 */ +- model=(mac_bi_data.cpuid>>2)&63; +- printk (KERN_WARNING "No bootinfo model ID, using cpuid instead (hey, use Penguin!)\n"); ++ model = (mac_bi_data.cpuid >> 2) & 63; ++ printk(KERN_WARNING "No bootinfo model ID, using cpuid instead (hey, use Penguin!)\n"); + } + + macintosh_config = mac_data_table; +- for (m = macintosh_config ; m->ident != -1 ; m++) { ++ for (m = macintosh_config; m->ident != -1; m++) { + if (m->ident == model) { + macintosh_config = m; + break; +@@ -803,25 +804,25 @@ void mac_identify(void) + iop_preinit(); + mac_debug_init(); + +- printk (KERN_INFO "Detected Macintosh model: %d \n", model); ++ printk(KERN_INFO "Detected Macintosh model: %d \n", model); + + /* + * Report booter data: + */ +- printk (KERN_DEBUG " Penguin bootinfo data:\n"); +- printk (KERN_DEBUG " Video: addr 0x%lx row 0x%lx depth %lx dimensions %ld x %ld\n", ++ printk(KERN_DEBUG " Penguin bootinfo data:\n"); ++ printk(KERN_DEBUG " Video: addr 0x%lx row 0x%lx depth %lx dimensions %ld x %ld\n", + mac_bi_data.videoaddr, mac_bi_data.videorow, + mac_bi_data.videodepth, mac_bi_data.dimensions & 0xFFFF, + mac_bi_data.dimensions >> 16); +- printk (KERN_DEBUG " Videological 0x%lx phys. 0x%lx, SCC at 0x%lx \n", ++ printk(KERN_DEBUG " Videological 0x%lx phys. 0x%lx, SCC at 0x%lx \n", + mac_bi_data.videological, mac_orig_videoaddr, + mac_bi_data.sccbase); +- printk (KERN_DEBUG " Boottime: 0x%lx GMTBias: 0x%lx \n", ++ printk(KERN_DEBUG " Boottime: 0x%lx GMTBias: 0x%lx \n", + mac_bi_data.boottime, mac_bi_data.gmtbias); +- printk (KERN_DEBUG " Machine ID: %ld CPUid: 0x%lx memory size: 0x%lx \n", ++ printk(KERN_DEBUG " Machine ID: %ld CPUid: 0x%lx memory size: 0x%lx \n", + mac_bi_data.id, mac_bi_data.cpuid, mac_bi_data.memsize); + #if 0 +- printk ("Ramdisk: addr 0x%lx size 0x%lx\n", ++ printk("Ramdisk: addr 0x%lx size 0x%lx\n", + m68k_ramdisk.addr, m68k_ramdisk.size); + #endif + +@@ -830,22 +831,22 @@ void mac_identify(void) + */ + switch (macintosh_config->scsi_type) { + case MAC_SCSI_OLD: +- MACHW_SET(MAC_SCSI_80); +- break; ++ MACHW_SET(MAC_SCSI_80); ++ break; + case MAC_SCSI_QUADRA: + case MAC_SCSI_QUADRA2: + case MAC_SCSI_QUADRA3: +- MACHW_SET(MAC_SCSI_96); +- if ((macintosh_config->ident == MAC_MODEL_Q900) || +- (macintosh_config->ident == MAC_MODEL_Q950)) +- MACHW_SET(MAC_SCSI_96_2); +- break; ++ MACHW_SET(MAC_SCSI_96); ++ if ((macintosh_config->ident == MAC_MODEL_Q900) || ++ (macintosh_config->ident == MAC_MODEL_Q950)) ++ MACHW_SET(MAC_SCSI_96_2); ++ break; + default: +- printk(KERN_WARNING "config.c: wtf: unknown scsi, using 53c80\n"); +- MACHW_SET(MAC_SCSI_80); +- break; +- ++ printk(KERN_WARNING "config.c: wtf: unknown scsi, using 53c80\n"); ++ MACHW_SET(MAC_SCSI_80); ++ break; + } ++ + iop_init(); + via_init(); + oss_init(); +@@ -860,6 +861,6 @@ void mac_report_hardware(void) + + static void mac_get_model(char *str) + { +- strcpy(str,"Macintosh "); ++ strcpy(str, "Macintosh "); + strcat(str, macintosh_config->name); + } +--- linux-m68k-2.6.21.orig/arch/m68k/mac/debug.c ++++ linux-m68k-2.6.21/arch/m68k/mac/debug.c +@@ -52,7 +52,7 @@ extern void mac_serial_print(const char + */ + + #ifdef DEBUG_SCREEN +-static int peng=0, line=0; ++static int peng, line; + #endif + + void mac_debugging_short(int pos, short num) +@@ -74,15 +74,14 @@ void mac_debugging_short(int pos, short + } + + /* calculate current offset */ +- pengoffset=(unsigned char *)(mac_videobase+(150+line*2)*mac_rowbytes) +- +80*peng; ++ pengoffset = (unsigned char *)mac_videobase + ++ (150+line*2) * mac_rowbytes) + 80 * peng; + +- pptr=pengoffset; ++ pptr = pengoffset; + +- for(i=0;i<8*sizeof(short);i++) /* # of bits */ +- { ++ for (i = 0; i < 8 * sizeof(short); i++) { /* # of bits */ + /* value mask for bit i, reverse order */ +- *pptr++ = (num & ( 1 << (8*sizeof(short)-i-1) ) ? 0xFF : 0x00); ++ *pptr++ = (num & (1 << (8*sizeof(short)-i-1)) ? 0xFF : 0x00); + } + + peng++; +@@ -115,11 +114,10 @@ void mac_debugging_long(int pos, long ad + pengoffset=(unsigned char *)(mac_videobase+(150+line*2)*mac_rowbytes) + +80*peng; + +- pptr=pengoffset; ++ pptr = pengoffset; + +- for(i=0;i<8*sizeof(long);i++) /* # of bits */ +- { +- *pptr++ = (addr & ( 1 << (8*sizeof(long)-i-1) ) ? 0xFF : 0x00); ++ for (i = 0; i < 8 * sizeof(long); i++) { /* # of bits */ ++ *pptr++ = (addr & (1 << (8*sizeof(long)-i-1)) ? 0xFF : 0x00); + } + + peng++; +@@ -136,16 +134,15 @@ void mac_debugging_long(int pos, long ad + * TODO: serial debug code + */ + +-struct mac_SCC +- { +- u_char cha_b_ctrl; +- u_char char_dummy1; +- u_char cha_a_ctrl; +- u_char char_dummy2; +- u_char cha_b_data; +- u_char char_dummy3; +- u_char cha_a_data; +- }; ++struct mac_SCC { ++ u_char cha_b_ctrl; ++ u_char char_dummy1; ++ u_char cha_a_ctrl; ++ u_char char_dummy2; ++ u_char cha_b_data; ++ u_char char_dummy3; ++ u_char cha_a_data; ++}; + + # define scc (*((volatile struct mac_SCC*)mac_bi_data.sccbase)) + +@@ -158,9 +155,9 @@ int mac_SCC_reset_done; + static int scc_port = -1; + + static struct console mac_console_driver = { +- .name = "debug", +- .flags = CON_PRINTBUFFER, +- .index = -1, ++ .name = "debug", ++ .flags = CON_PRINTBUFFER, ++ .index = -1, + }; + + /* +@@ -178,8 +175,8 @@ static struct console mac_console_driver + * this driver if Mac. + */ + +-void mac_debug_console_write (struct console *co, const char *str, +- unsigned int count) ++void mac_debug_console_write(struct console *co, const char *str, ++ unsigned int count) + { + mac_serial_print(str); + } +@@ -190,48 +187,50 @@ void mac_debug_console_write (struct con + + #define uSEC 1 + +-static inline void mac_sccb_out (char c) ++static inline void mac_sccb_out(char c) + { +- int i; +- do { +- for( i = uSEC; i > 0; --i ) ++ int i; ++ ++ do { ++ for (i = uSEC; i > 0; --i) ++ barrier(); ++ } while (!(scc.cha_b_ctrl & 0x04)); /* wait for tx buf empty */ ++ for (i = uSEC; i > 0; --i) + barrier(); +- } while (!(scc.cha_b_ctrl & 0x04)); /* wait for tx buf empty */ +- for( i = uSEC; i > 0; --i ) +- barrier(); +- scc.cha_b_data = c; ++ scc.cha_b_data = c; + } + +-static inline void mac_scca_out (char c) ++static inline void mac_scca_out(char c) + { +- int i; +- do { +- for( i = uSEC; i > 0; --i ) ++ int i; ++ ++ do { ++ for (i = uSEC; i > 0; --i) ++ barrier(); ++ } while (!(scc.cha_a_ctrl & 0x04)); /* wait for tx buf empty */ ++ for (i = uSEC; i > 0; --i) + barrier(); +- } while (!(scc.cha_a_ctrl & 0x04)); /* wait for tx buf empty */ +- for( i = uSEC; i > 0; --i ) +- barrier(); +- scc.cha_a_data = c; +-} +- +-void mac_sccb_console_write (struct console *co, const char *str, +- unsigned int count) +-{ +- while (count--) { +- if (*str == '\n') +- mac_sccb_out( '\r' ); +- mac_sccb_out( *str++ ); +- } +-} +- +-void mac_scca_console_write (struct console *co, const char *str, +- unsigned int count) +-{ +- while (count--) { +- if (*str == '\n') +- mac_scca_out( '\r' ); +- mac_scca_out( *str++ ); +- } ++ scc.cha_a_data = c; ++} ++ ++void mac_sccb_console_write(struct console *co, const char *str, ++ unsigned int count) ++{ ++ while (count--) { ++ if (*str == '\n') ++ mac_sccb_out('\r'); ++ mac_sccb_out(*str++); ++ } ++} ++ ++void mac_scca_console_write(struct console *co, const char *str, ++ unsigned int count) ++{ ++ while (count--) { ++ if (*str == '\n') ++ mac_scca_out('\r'); ++ mac_scca_out(*str++); ++ } + } + + +@@ -239,41 +238,41 @@ void mac_scca_console_write (struct cons + * SCC serial ports. They're used by the debugging interface, kgdb, and the + * serial console code. */ + #define SCCB_WRITE(reg,val) \ +- do { \ +- int i; \ +- scc.cha_b_ctrl = (reg); \ +- for( i = uSEC; i > 0; --i ) \ +- barrier(); \ +- scc.cha_b_ctrl = (val); \ +- for( i = uSEC; i > 0; --i ) \ +- barrier(); \ +- } while(0) ++ do { \ ++ int i; \ ++ scc.cha_b_ctrl = (reg); \ ++ for (i = uSEC; i > 0; --i) \ ++ barrier(); \ ++ scc.cha_b_ctrl = (val); \ ++ for (i = uSEC; i > 0; --i) \ ++ barrier(); \ ++ } while(0) + + #define SCCA_WRITE(reg,val) \ +- do { \ +- int i; \ +- scc.cha_a_ctrl = (reg); \ +- for( i = uSEC; i > 0; --i ) \ +- barrier(); \ +- scc.cha_a_ctrl = (val); \ +- for( i = uSEC; i > 0; --i ) \ +- barrier(); \ +- } while(0) ++ do { \ ++ int i; \ ++ scc.cha_a_ctrl = (reg); \ ++ for (i = uSEC; i > 0; --i) \ ++ barrier(); \ ++ scc.cha_a_ctrl = (val); \ ++ for (i = uSEC; i > 0; --i) \ ++ barrier(); \ ++ } while(0) + + /* loops_per_jiffy isn't initialized yet, so we can't use udelay(). This does a + * delay of ~ 60us. */ + /* Mac: loops_per_jiffy min. 19000 ^= .5 us; MFPDELAY was 0.6 us*/ +-#define LONG_DELAY() \ +- do { \ +- int i; \ +- for( i = 60*uSEC; i > 0; --i ) \ +- barrier(); \ +- } while(0) ++#define LONG_DELAY() \ ++ do { \ ++ int i; \ ++ for (i = 60*uSEC; i > 0; --i) \ ++ barrier(); \ ++ } while(0) + + #ifndef CONFIG_SERIAL_CONSOLE +-static void __init mac_init_scc_port( int cflag, int port ) ++static void __init mac_init_scc_port(int cflag, int port) + #else +-void mac_init_scc_port( int cflag, int port ) ++void mac_init_scc_port(int cflag, int port) + #endif + { + extern int mac_SCC_reset_done; +@@ -292,71 +291,71 @@ void mac_init_scc_port( int cflag, int p + /* reg12 (BRG low) */ + { 94, 62, 46, 22, 10, 4, 1, 0, 0 }; + +- int baud = cflag & CBAUD; +- int clksrc, clkmode, div, reg3, reg5; ++ int baud = cflag & CBAUD; ++ int clksrc, clkmode, div, reg3, reg5; + +- if (cflag & CBAUDEX) +- baud += B38400; +- if (baud < B1200 || baud > B38400+2) +- baud = B9600; /* use default 9600bps for non-implemented rates */ +- baud -= B1200; /* tables starts at 1200bps */ +- +- clksrc = clksrc_table[baud]; +- clkmode = clkmode_table[baud]; +- div = div_table[baud]; +- +- reg3 = (((cflag & CSIZE) == CS8) ? 0xc0 : 0x40); +- reg5 = (((cflag & CSIZE) == CS8) ? 0x60 : 0x20) | 0x82 /* assert DTR/RTS */; +- +- if (port == 1) { +- (void)scc.cha_b_ctrl; /* reset reg pointer */ +- SCCB_WRITE( 9, 0xc0 ); /* reset */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCCB_WRITE( 4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 | +- 0x04 /* 1 stopbit */ | +- clkmode ); +- SCCB_WRITE( 3, reg3 ); +- SCCB_WRITE( 5, reg5 ); +- SCCB_WRITE( 9, 0 ); /* no interrupts */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCCB_WRITE( 10, 0 ); /* NRZ mode */ +- SCCB_WRITE( 11, clksrc ); /* main clock source */ +- SCCB_WRITE( 12, div ); /* BRG value */ +- SCCB_WRITE( 13, 0 ); /* BRG high byte */ +- SCCB_WRITE( 14, 1 ); +- SCCB_WRITE( 3, reg3 | 1 ); +- SCCB_WRITE( 5, reg5 | 8 ); +- } else if (port == 0) { +- (void)scc.cha_a_ctrl; /* reset reg pointer */ +- SCCA_WRITE( 9, 0xc0 ); /* reset */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCCA_WRITE( 4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 | ++ if (cflag & CBAUDEX) ++ baud += B38400; ++ if (baud < B1200 || baud > B38400+2) ++ baud = B9600; /* use default 9600bps for non-implemented rates */ ++ baud -= B1200; /* tables starts at 1200bps */ ++ ++ clksrc = clksrc_table[baud]; ++ clkmode = clkmode_table[baud]; ++ div = div_table[baud]; ++ ++ reg3 = (((cflag & CSIZE) == CS8) ? 0xc0 : 0x40); ++ reg5 = (((cflag & CSIZE) == CS8) ? 0x60 : 0x20) | 0x82 /* assert DTR/RTS */; ++ ++ if (port == 1) { ++ (void)scc.cha_b_ctrl; /* reset reg pointer */ ++ SCCB_WRITE(9, 0xc0); /* reset */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCCB_WRITE(4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 | ++ 0x04 /* 1 stopbit */ | ++ clkmode); ++ SCCB_WRITE(3, reg3); ++ SCCB_WRITE(5, reg5); ++ SCCB_WRITE(9, 0); /* no interrupts */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCCB_WRITE(10, 0); /* NRZ mode */ ++ SCCB_WRITE(11, clksrc); /* main clock source */ ++ SCCB_WRITE(12, div); /* BRG value */ ++ SCCB_WRITE(13, 0); /* BRG high byte */ ++ SCCB_WRITE(14, 1); ++ SCCB_WRITE(3, reg3 | 1); ++ SCCB_WRITE(5, reg5 | 8); ++ } else if (port == 0) { ++ (void)scc.cha_a_ctrl; /* reset reg pointer */ ++ SCCA_WRITE(9, 0xc0); /* reset */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCCA_WRITE(4, (cflag & PARENB) ? ((cflag & PARODD) ? 0x01 : 0x03) : 0 | + 0x04 /* 1 stopbit */ | +- clkmode ); +- SCCA_WRITE( 3, reg3 ); +- SCCA_WRITE( 5, reg5 ); +- SCCA_WRITE( 9, 0 ); /* no interrupts */ +- LONG_DELAY(); /* extra delay after WR9 access */ +- SCCA_WRITE( 10, 0 ); /* NRZ mode */ +- SCCA_WRITE( 11, clksrc ); /* main clock source */ +- SCCA_WRITE( 12, div ); /* BRG value */ +- SCCA_WRITE( 13, 0 ); /* BRG high byte */ +- SCCA_WRITE( 14, 1 ); +- SCCA_WRITE( 3, reg3 | 1 ); +- SCCA_WRITE( 5, reg5 | 8 ); +- } ++ clkmode); ++ SCCA_WRITE(3, reg3); ++ SCCA_WRITE(5, reg5); ++ SCCA_WRITE(9, 0); /* no interrupts */ ++ LONG_DELAY(); /* extra delay after WR9 access */ ++ SCCA_WRITE(10, 0); /* NRZ mode */ ++ SCCA_WRITE(11, clksrc); /* main clock source */ ++ SCCA_WRITE(12, div); /* BRG value */ ++ SCCA_WRITE(13, 0); /* BRG high byte */ ++ SCCA_WRITE(14, 1); ++ SCCA_WRITE(3, reg3 | 1); ++ SCCA_WRITE(5, reg5 | 8); ++ } + +- mac_SCC_reset_done = 1; +- mac_SCC_init_done = 1; ++ mac_SCC_reset_done = 1; ++ mac_SCC_init_done = 1; + } + #endif /* DEBUG_SERIAL */ + +-void mac_init_scca_port( int cflag ) ++void mac_init_scca_port(int cflag) + { + mac_init_scc_port(cflag, 0); + } + +-void mac_init_sccb_port( int cflag ) ++void mac_init_sccb_port(int cflag) + { + mac_init_scc_port(cflag, 1); + } +@@ -364,34 +363,26 @@ void mac_init_sccb_port( int cflag ) + void __init mac_debug_init(void) + { + #ifdef DEBUG_SERIAL +- if ( !strcmp( m68k_debug_device, "ser" ) +- || !strcmp( m68k_debug_device, "ser1" )) { +- /* Mac modem port */ +- mac_init_scc_port( B9600|CS8, 0 ); +- mac_console_driver.write = mac_scca_console_write; +- scc_port = 0; +- } +- else if (!strcmp( m68k_debug_device, "ser2" )) { +- /* Mac printer port */ +- mac_init_scc_port( B9600|CS8, 1 ); +- mac_console_driver.write = mac_sccb_console_write; +- scc_port = 1; +- } ++ if (!strcmp(m68k_debug_device, "ser") || ++ !strcmp(m68k_debug_device, "ser1")) { ++ /* Mac modem port */ ++ mac_init_scc_port(B9600|CS8, 0); ++ mac_console_driver.write = mac_scca_console_write; ++ scc_port = 0; ++ } else if (!strcmp(m68k_debug_device, "ser2")) { ++ /* Mac printer port */ ++ mac_init_scc_port(B9600|CS8, 1); ++ mac_console_driver.write = mac_sccb_console_write; ++ scc_port = 1; ++ } + #endif + #ifdef DEBUG_HEADS +- if ( !strcmp( m68k_debug_device, "scn" ) +- || !strcmp( m68k_debug_device, "con" )) { +- /* display, using head.S console routines */ +- mac_console_driver.write = mac_debug_console_write; +- } ++ if (!strcmp(m68k_debug_device, "scn") || ++ !strcmp(m68k_debug_device, "con")) { ++ /* display, using head.S console routines */ ++ mac_console_driver.write = mac_debug_console_write; ++ } + #endif +- if (mac_console_driver.write) +- register_console(&mac_console_driver); ++ if (mac_console_driver.write) ++ register_console(&mac_console_driver); + } +- +-/* +- * Local variables: +- * c-indent-level: 4 +- * tab-width: 8 +- * End: +- */ +--- linux-m68k-2.6.21.orig/arch/m68k/q40/config.c ++++ linux-m68k-2.6.21/arch/m68k/q40/config.c +@@ -35,35 +35,35 @@ + #include <asm/machdep.h> + #include <asm/q40_master.h> + +-extern irqreturn_t q40_process_int (int level, struct pt_regs *regs); +-extern void q40_init_IRQ (void); ++extern irqreturn_t q40_process_int(int level, struct pt_regs *regs); ++extern void q40_init_IRQ(void); + static void q40_get_model(char *model); + static int q40_get_hardware_list(char *buffer); + extern void q40_sched_init(irq_handler_t handler); + +-extern unsigned long q40_gettimeoffset (void); +-extern int q40_hwclk (int, struct rtc_time *); +-extern unsigned int q40_get_ss (void); +-extern int q40_set_clock_mmss (unsigned long); ++extern unsigned long q40_gettimeoffset(void); ++extern int q40_hwclk(int, struct rtc_time *); ++extern unsigned int q40_get_ss(void); ++extern int q40_set_clock_mmss(unsigned long); + static int q40_get_rtc_pll(struct rtc_pll_info *pll); + static int q40_set_rtc_pll(struct rtc_pll_info *pll); +-extern void q40_reset (void); ++extern void q40_reset(void); + void q40_halt(void); + extern void q40_waitbut(void); +-void q40_set_vectors (void); ++void q40_set_vectors(void); + +-extern void q40_mksound(unsigned int /*freq*/, unsigned int /*ticks*/ ); ++extern void q40_mksound(unsigned int /*freq*/, unsigned int /*ticks*/); + + extern char m68k_debug_device[]; + static void q40_mem_console_write(struct console *co, const char *b, +- unsigned int count); ++ unsigned int count); + + extern int ql_ticks; + + static struct console q40_console_driver = { +- .name = "debug", +- .flags = CON_PRINTBUFFER, +- .index = -1, ++ .name = "debug", ++ .flags = CON_PRINTBUFFER, ++ .index = -1, + }; + + +@@ -74,150 +74,157 @@ static int _cpleft; + static void q40_mem_console_write(struct console *co, const char *s, + unsigned int count) + { +- char *p=(char *)s; ++ const char *p = s; + +- if (count<_cpleft) +- while (count-- >0){ +- *q40_mem_cptr=*p++; +- q40_mem_cptr+=4; +- _cpleft--; +- } ++ if (count < _cpleft) { ++ while (count-- > 0) { ++ *q40_mem_cptr = *p++; ++ q40_mem_cptr += 4; ++ _cpleft--; ++ } ++ } + } ++ + #if 0 + void printq40(char *str) + { +- int l=strlen(str); +- char *p=q40_mem_cptr; ++ int l = strlen(str); ++ char *p = q40_mem_cptr; + +- while (l-- >0 && _cpleft-- >0) +- { +- *p=*str++; +- p+=4; +- } +- q40_mem_cptr=p; ++ while (l-- > 0 && _cpleft-- > 0) { ++ *p = *str++; ++ p += 4; ++ } ++ q40_mem_cptr = p; + } + #endif + +-static int halted=0; ++static int halted; + + #ifdef CONFIG_HEARTBEAT + static void q40_heartbeat(int on) + { +- if (halted) return; ++ if (halted) ++ return; + +- if (on) +- Q40_LED_ON(); +- else +- Q40_LED_OFF(); ++ if (on) ++ Q40_LED_ON(); ++ else ++ Q40_LED_OFF(); + } + #endif + + void q40_reset(void) + { +- halted=1; +- printk ("\n\n*******************************************\n" ++ halted = 1; ++ printk("\n\n*******************************************\n" + "Called q40_reset : press the RESET button!! \n" + "*******************************************\n"); + Q40_LED_ON(); +- while(1) ; ++ while (1) ++ ; + } + void q40_halt(void) + { +- halted=1; +- printk ("\n\n*******************\n" +- " Called q40_halt\n" +- "*******************\n"); ++ halted = 1; ++ printk("\n\n*******************\n" ++ " Called q40_halt\n" ++ "*******************\n"); + Q40_LED_ON(); +- while(1) ; ++ while (1) ++ ; + } + + static void q40_get_model(char *model) + { +- sprintf(model, "Q40"); ++ sprintf(model, "Q40"); + } + + /* No hardware options on Q40? */ + + static int q40_get_hardware_list(char *buffer) + { +- *buffer = '\0'; +- return 0; ++ *buffer = '\0'; ++ return 0; + } + +-static unsigned int serports[]={0x3f8,0x2f8,0x3e8,0x2e8,0}; ++static unsigned int serports[] = ++{ ++ 0x3f8,0x2f8,0x3e8,0x2e8,0 ++}; + void q40_disable_irqs(void) + { +- unsigned i,j; ++ unsigned i, j; + +- j=0; +- while((i=serports[j++])) outb(0,i+UART_IER); +- master_outb(0,EXT_ENABLE_REG); +- master_outb(0,KEY_IRQ_ENABLE_REG); ++ j = 0; ++ while ((i = serports[j++])) ++ outb(0, i + UART_IER); ++ master_outb(0, EXT_ENABLE_REG); ++ master_outb(0, KEY_IRQ_ENABLE_REG); + } + + void __init config_q40(void) + { +- mach_sched_init = q40_sched_init; ++ mach_sched_init = q40_sched_init; + +- mach_init_IRQ = q40_init_IRQ; +- mach_gettimeoffset = q40_gettimeoffset; +- mach_hwclk = q40_hwclk; +- mach_get_ss = q40_get_ss; +- mach_get_rtc_pll = q40_get_rtc_pll; +- mach_set_rtc_pll = q40_set_rtc_pll; +- mach_set_clock_mmss = q40_set_clock_mmss; +- +- mach_reset = q40_reset; +- mach_get_model = q40_get_model; +- mach_get_hardware_list = q40_get_hardware_list; ++ mach_init_IRQ = q40_init_IRQ; ++ mach_gettimeoffset = q40_gettimeoffset; ++ mach_hwclk = q40_hwclk; ++ mach_get_ss = q40_get_ss; ++ mach_get_rtc_pll = q40_get_rtc_pll; ++ mach_set_rtc_pll = q40_set_rtc_pll; ++ mach_set_clock_mmss = q40_set_clock_mmss; ++ ++ mach_reset = q40_reset; ++ mach_get_model = q40_get_model; ++ mach_get_hardware_list = q40_get_hardware_list; + + #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE) +- mach_beep = q40_mksound; ++ mach_beep = q40_mksound; + #endif + #ifdef CONFIG_HEARTBEAT +- mach_heartbeat = q40_heartbeat; ++ mach_heartbeat = q40_heartbeat; + #endif +- mach_halt = q40_halt; ++ mach_halt = q40_halt; + +- /* disable a few things that SMSQ might have left enabled */ +- q40_disable_irqs(); ++ /* disable a few things that SMSQ might have left enabled */ ++ q40_disable_irqs(); + +- /* no DMA at all, but ide-scsi requires it.. make sure +- * all physical RAM fits into the boundary - otherwise +- * allocator may play costly and useless tricks */ +- mach_max_dma_address = 1024*1024*1024; +- +- /* useful for early debugging stages - writes kernel messages into SRAM */ +- if (!strncmp( m68k_debug_device,"mem",3 )) +- { +- /*printk("using NVRAM debug, q40_mem_cptr=%p\n",q40_mem_cptr);*/ +- _cpleft=2000-((long)q40_mem_cptr-0xff020000)/4; +- q40_console_driver.write = q40_mem_console_write; +- register_console(&q40_console_driver); +- } ++ /* no DMA at all, but ide-scsi requires it.. make sure ++ * all physical RAM fits into the boundary - otherwise ++ * allocator may play costly and useless tricks */ ++ mach_max_dma_address = 1024*1024*1024; ++ ++ /* useful for early debugging stages - writes kernel messages into SRAM */ ++ if (!strncmp( m68k_debug_device,"mem", 3)) { ++ /*printk("using NVRAM debug, q40_mem_cptr=%p\n",q40_mem_cptr);*/ ++ _cpleft = 2000 - ((long)q40_mem_cptr-0xff020000) / 4; ++ q40_console_driver.write = q40_mem_console_write; ++ register_console(&q40_console_driver); ++ } + } + + + int q40_parse_bootinfo(const struct bi_record *rec) + { +- return 1; ++ return 1; + } + + +-static inline unsigned char bcd2bin (unsigned char b) ++static inline unsigned char bcd2bin(unsigned char b) + { +- return ((b>>4)*10 + (b&15)); ++ return (b >> 4) * 10 + (b & 15); + } + +-static inline unsigned char bin2bcd (unsigned char b) ++static inline unsigned char bin2bcd(unsigned char b) + { +- return (((b/10)*16) + (b%10)); ++ return (b / 10) * 16 + (b % 10); + } + + +-unsigned long q40_gettimeoffset (void) ++unsigned long q40_gettimeoffset(void) + { +- return 5000*(ql_ticks!=0); ++ return 5000 * (ql_ticks != 0); + } + + +@@ -238,9 +245,9 @@ unsigned long q40_gettimeoffset (void) + + int q40_hwclk(int op, struct rtc_time *t) + { +- if (op) +- { /* Write.... */ +- Q40_RTC_CTRL |= Q40_RTC_WRITE; ++ if (op) { ++ /* Write.... */ ++ Q40_RTC_CTRL |= Q40_RTC_WRITE; + + Q40_RTC_SECS = bin2bcd(t->tm_sec); + Q40_RTC_MINS = bin2bcd(t->tm_min); +@@ -251,25 +258,23 @@ int q40_hwclk(int op, struct rtc_time *t + if (t->tm_wday >= 0) + Q40_RTC_DOW = bin2bcd(t->tm_wday+1); + +- Q40_RTC_CTRL &= ~(Q40_RTC_WRITE); +- } +- else +- { /* Read.... */ +- Q40_RTC_CTRL |= Q40_RTC_READ; +- +- t->tm_year = bcd2bin (Q40_RTC_YEAR); +- t->tm_mon = bcd2bin (Q40_RTC_MNTH)-1; +- t->tm_mday = bcd2bin (Q40_RTC_DATE); +- t->tm_hour = bcd2bin (Q40_RTC_HOUR); +- t->tm_min = bcd2bin (Q40_RTC_MINS); +- t->tm_sec = bcd2bin (Q40_RTC_SECS); +- +- Q40_RTC_CTRL &= ~(Q40_RTC_READ); +- +- if (t->tm_year < 70) +- t->tm_year += 100; +- t->tm_wday = bcd2bin(Q40_RTC_DOW)-1; +- ++ Q40_RTC_CTRL &= ~(Q40_RTC_WRITE); ++ } else { ++ /* Read.... */ ++ Q40_RTC_CTRL |= Q40_RTC_READ; ++ ++ t->tm_year = bcd2bin (Q40_RTC_YEAR); ++ t->tm_mon = bcd2bin (Q40_RTC_MNTH)-1; ++ t->tm_mday = bcd2bin (Q40_RTC_DATE); ++ t->tm_hour = bcd2bin (Q40_RTC_HOUR); ++ t->tm_min = bcd2bin (Q40_RTC_MINS); ++ t->tm_sec = bcd2bin (Q40_RTC_SECS); ++ ++ Q40_RTC_CTRL &= ~(Q40_RTC_READ); ++ ++ if (t->tm_year < 70) ++ t->tm_year += 100; ++ t->tm_wday = bcd2bin(Q40_RTC_DOW)-1; + } + + return 0; +@@ -285,29 +290,25 @@ unsigned int q40_get_ss(void) + * clock is out by > 30 minutes. Logic lifted from atari code. + */ + +-int q40_set_clock_mmss (unsigned long nowtime) ++int q40_set_clock_mmss(unsigned long nowtime) + { + int retval = 0; + short real_seconds = nowtime % 60, real_minutes = (nowtime / 60) % 60; + + int rtc_minutes; + ++ rtc_minutes = bcd2bin(Q40_RTC_MINS); + +- rtc_minutes = bcd2bin (Q40_RTC_MINS); +- +- if ((rtc_minutes < real_minutes +- ? real_minutes - rtc_minutes +- : rtc_minutes - real_minutes) < 30) +- { +- Q40_RTC_CTRL |= Q40_RTC_WRITE; ++ if ((rtc_minutes < real_minutes ? ++ real_minutes - rtc_minutes : ++ rtc_minutes - real_minutes) < 30) { ++ Q40_RTC_CTRL |= Q40_RTC_WRITE; + Q40_RTC_MINS = bin2bcd(real_minutes); + Q40_RTC_SECS = bin2bcd(real_seconds); + Q40_RTC_CTRL &= ~(Q40_RTC_WRITE); +- } +- else ++ } else + retval = -1; + +- + return retval; + } + +@@ -318,21 +319,23 @@ int q40_set_clock_mmss (unsigned long no + + static int q40_get_rtc_pll(struct rtc_pll_info *pll) + { +- int tmp=Q40_RTC_CTRL; ++ int tmp = Q40_RTC_CTRL; ++ + pll->pll_value = tmp & Q40_RTC_PLL_MASK; + if (tmp & Q40_RTC_PLL_SIGN) + pll->pll_value = -pll->pll_value; +- pll->pll_max=31; +- pll->pll_min=-31; +- pll->pll_posmult=512; +- pll->pll_negmult=256; +- pll->pll_clock=125829120; ++ pll->pll_max = 31; ++ pll->pll_min = -31; ++ pll->pll_posmult = 512; ++ pll->pll_negmult = 256; ++ pll->pll_clock = 125829120; ++ + return 0; + } + + static int q40_set_rtc_pll(struct rtc_pll_info *pll) + { +- if (!pll->pll_ctrl){ ++ if (!pll->pll_ctrl) { + /* the docs are a bit unclear so I am doublesetting */ + /* RTC_WRITE here ... */ + int tmp = (pll->pll_value & 31) | (pll->pll_value<0 ? 32 : 0) | +--- linux-m68k-2.6.21.orig/arch/m68k/sun3x/prom.c ++++ linux-m68k-2.6.21/arch/m68k/sun3x/prom.c +@@ -34,43 +34,43 @@ e_vector *sun3x_prom_vbr; + /* Handle returning to the prom */ + void sun3x_halt(void) + { +- unsigned long flags; ++ unsigned long flags; + +- /* Disable interrupts while we mess with things */ +- local_irq_save(flags); ++ /* Disable interrupts while we mess with things */ ++ local_irq_save(flags); + +- /* Restore prom vbr */ +- __asm__ volatile ("movec %0,%%vbr" : : "r" ((void*)sun3x_prom_vbr)); ++ /* Restore prom vbr */ ++ asm volatile ("movec %0,%%vbr" : : "r" ((void*)sun3x_prom_vbr)); + +- /* Restore prom NMI clock */ +-// sun3x_disable_intreg(5); +- sun3_enable_irq(7); ++ /* Restore prom NMI clock */ ++// sun3x_disable_intreg(5); ++ sun3_enable_irq(7); + +- /* Let 'er rip */ +- __asm__ volatile ("trap #14" : : ); ++ /* Let 'er rip */ ++ asm volatile ("trap #14"); + +- /* Restore everything */ +- sun3_disable_irq(7); +- sun3_enable_irq(5); ++ /* Restore everything */ ++ sun3_disable_irq(7); ++ sun3_enable_irq(5); + +- __asm__ volatile ("movec %0,%%vbr" : : "r" ((void*)vectors)); +- local_irq_restore(flags); ++ asm volatile ("movec %0,%%vbr" : : "r" ((void*)vectors)); ++ local_irq_restore(flags); + } + + void sun3x_reboot(void) + { +- /* This never returns, don't bother saving things */ +- local_irq_disable(); ++ /* This never returns, don't bother saving things */ ++ local_irq_disable(); + +- /* Restore prom vbr */ +- __asm__ volatile ("movec %0,%%vbr" : : "r" ((void*)sun3x_prom_vbr)); ++ /* Restore prom vbr */ ++ asm volatile ("movec %0,%%vbr" : : "r" ((void*)sun3x_prom_vbr)); + +- /* Restore prom NMI clock */ +- sun3_disable_irq(5); +- sun3_enable_irq(7); ++ /* Restore prom NMI clock */ ++ sun3_disable_irq(5); ++ sun3_enable_irq(7); + +- /* Let 'er rip */ +- (*romvec->pv_reboot)("vmlinux"); ++ /* Let 'er rip */ ++ (*romvec->pv_reboot)("vmlinux"); + } + + extern char m68k_debug_device[]; +@@ -78,54 +78,52 @@ extern char m68k_debug_device[]; + static void sun3x_prom_write(struct console *co, const char *s, + unsigned int count) + { +- while (count--) { +- if (*s == '\n') +- sun3x_putchar('\r'); +- sun3x_putchar(*s++); +- } ++ while (count--) { ++ if (*s == '\n') ++ sun3x_putchar('\r'); ++ sun3x_putchar(*s++); ++ } + } + + /* debug console - write-only */ + + static struct console sun3x_debug = { +- .name = "debug", +- .write = sun3x_prom_write, +- .flags = CON_PRINTBUFFER, +- .index = -1, ++ .name = "debug", ++ .write = sun3x_prom_write, ++ .flags = CON_PRINTBUFFER, ++ .index = -1, + }; + + void sun3x_prom_init(void) + { +- /* Read the vector table */ ++ /* Read the vector table */ + +- sun3x_putchar = *(void (**)(int)) (SUN3X_P_PUTCHAR); +- sun3x_getchar = *(int (**)(void)) (SUN3X_P_GETCHAR); +- sun3x_mayget = *(int (**)(void)) (SUN3X_P_MAYGET); +- sun3x_mayput = *(int (**)(int)) (SUN3X_P_MAYPUT); +- sun3x_prom_reboot = *(void (**)(void)) (SUN3X_P_REBOOT); +- sun3x_prom_abort = *(e_vector *) (SUN3X_P_ABORT); +- romvec = (struct linux_romvec *)SUN3X_PROM_BASE; +- +- idprom_init(); +- +- if(!((idprom->id_machtype & SM_ARCH_MASK) == SM_SUN3X)) { +- printk("Warning: machine reports strange type %02x\n", +- idprom->id_machtype); +- printk("Pretending it's a 3/80, but very afraid...\n"); +- idprom->id_machtype = SM_SUN3X | SM_3_80; +- } +- +- /* point trap #14 at abort. +- * XXX this is futile since we restore the vbr first - oops +- */ +- vectors[VEC_TRAP14] = sun3x_prom_abort; +- +- /* If debug=prom was specified, start the debug console */ +- +- if (!strcmp(m68k_debug_device, "prom")) +- register_console(&sun3x_debug); ++ sun3x_putchar = *(void (**)(int)) (SUN3X_P_PUTCHAR); ++ sun3x_getchar = *(int (**)(void)) (SUN3X_P_GETCHAR); ++ sun3x_mayget = *(int (**)(void)) (SUN3X_P_MAYGET); ++ sun3x_mayput = *(int (**)(int)) (SUN3X_P_MAYPUT); ++ sun3x_prom_reboot = *(void (**)(void)) (SUN3X_P_REBOOT); ++ sun3x_prom_abort = *(e_vector *) (SUN3X_P_ABORT); ++ romvec = (struct linux_romvec *)SUN3X_PROM_BASE; ++ ++ idprom_init(); ++ ++ if (!((idprom->id_machtype & SM_ARCH_MASK) == SM_SUN3X)) { ++ printk("Warning: machine reports strange type %02x\n", ++ idprom->id_machtype); ++ printk("Pretending it's a 3/80, but very afraid...\n"); ++ idprom->id_machtype = SM_SUN3X | SM_3_80; ++ } ++ ++ /* point trap #14 at abort. ++ * XXX this is futile since we restore the vbr first - oops ++ */ ++ vectors[VEC_TRAP14] = sun3x_prom_abort; + ++ /* If debug=prom was specified, start the debug console */ + ++ if (!strcmp(m68k_debug_device, "prom")) ++ register_console(&sun3x_debug); + } + + /* some prom functions to export */ +@@ -141,7 +139,6 @@ int prom_getbool (int node, char *prop) + + void prom_printf(char *fmt, ...) + { +- + } + + void prom_halt (void) +@@ -159,7 +156,7 @@ prom_get_idprom(char *idbuf, int num_byt + int i; + + /* make a copy of the idprom structure */ +- for(i = 0; i < num_bytes; i++) ++ for (i = 0; i < num_bytes; i++) + idbuf[i] = ((char *)SUN3X_IDPROM)[i]; + + return idbuf[0]; |