1 /* 2 * linux/arch/m68k/atari/config.c 3 * 4 * Copyright (C) 1994 Bjoern Brauel 5 * 6 * 5/2/94 Roman Hodek: 7 * Added setting of time_adj to get a better clock. 8 * 9 * 5/14/94 Roman Hodek: 10 * gettod() for TT 11 * 12 * 5/15/94 Roman Hodek: 13 * hard_reset_now() for Atari (and others?) 14 * 15 * 94/12/30 Andreas Schwab: 16 * atari_sched_init fixed to get precise clock. 17 * 18 * This file is subject to the terms and conditions of the GNU General Public 19 * License. See the file COPYING in the main directory of this archive 20 * for more details. 21 */ 22 23 /* 24 * Miscellaneous atari stuff 25 */ 26 27 #include <linux/config.h> 28 #include <linux/types.h> 29 #include <linux/mm.h> 30 #include <linux/console.h> 31 #include <linux/init.h> 32 #include <linux/delay.h> 33 #include <linux/ioport.h> 34 #include <linux/vt_kern.h> 35 36 #include <asm/bootinfo.h> 37 #include <asm/setup.h> 38 #include <asm/atarihw.h> 39 #include <asm/atariints.h> 40 #include <asm/atari_stram.h> 41 #include <asm/system.h> 42 #include <asm/machdep.h> 43 #include <asm/hwtest.h> 44 #include <asm/io.h> 45 46 u_long atari_mch_cookie; 47 u_long atari_mch_type; 48 struct atari_hw_present atari_hw_present; 49 u_long atari_switches; 50 int atari_dont_touch_floppy_select; 51 int atari_rtc_year_offset; 52 53 /* local function prototypes */ 54 static void atari_reset( void ); 55 static void atari_get_model(char *model); 56 static int atari_get_hardware_list(char *buffer); 57 58 /* atari specific irq functions */ 59 extern void atari_init_IRQ (void); 60 extern int atari_request_irq (unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), 61 unsigned long flags, const char *devname, void *dev_id); 62 extern void atari_free_irq (unsigned int irq, void *dev_id); 63 extern void atari_enable_irq (unsigned int); 64 extern void atari_disable_irq (unsigned int); 65 extern int show_atari_interrupts (struct seq_file *, void *); 66 extern void atari_mksound( unsigned int count, unsigned int ticks ); 67 #ifdef CONFIG_HEARTBEAT 68 static void atari_heartbeat( int on ); 69 #endif 70 71 /* atari specific timer functions (in time.c) */ 72 extern void atari_sched_init(irqreturn_t (*)(int, void *, struct pt_regs *)); 73 extern unsigned long atari_gettimeoffset (void); 74 extern int atari_mste_hwclk (int, struct rtc_time *); 75 extern int atari_tt_hwclk (int, struct rtc_time *); 76 extern int atari_mste_set_clock_mmss (unsigned long); 77 extern int atari_tt_set_clock_mmss (unsigned long); 78 79 /* atari specific debug functions (in debug.c) */ 80 extern void atari_debug_init(void); 81 82 83 /* I've moved hwreg_present() and hwreg_present_bywrite() out into 84 * mm/hwtest.c, to avoid having multiple copies of the same routine 85 * in the kernel [I wanted them in hp300 and they were already used 86 * in the nubus code. NB: I don't have an Atari so this might (just 87 * conceivably) break something. 88 * I've preserved the #if 0 version of hwreg_present_bywrite() here 89 * for posterity. 90 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk>, 05/1998 91 */ 92 93 #if 0 94 static int __init 95 hwreg_present_bywrite(volatile void *regp, unsigned char val) 96 { 97 int ret; 98 long save_sp, save_vbr; 99 static long tmp_vectors[3] = { [2] = (long)&&after_test }; 100 101 __asm__ __volatile__ 102 ( "movec %/vbr,%2\n\t" /* save vbr value */ 103 "movec %4,%/vbr\n\t" /* set up temporary vectors */ 104 "movel %/sp,%1\n\t" /* save sp */ 105 "moveq #0,%0\n\t" /* assume not present */ 106 "moveb %5,%3@\n\t" /* write the hardware reg */ 107 "cmpb %3@,%5\n\t" /* compare it */ 108 "seq %0" /* comes here only if reg */ 109 /* is present */ 110 : "=d&" (ret), "=r&" (save_sp), "=r&" (save_vbr) 111 : "a" (regp), "r" (tmp_vectors), "d" (val) 112 ); 113 after_test: 114 __asm__ __volatile__ 115 ( "movel %0,%/sp\n\t" /* restore sp */ 116 "movec %1,%/vbr" /* restore vbr */ 117 : : "r" (save_sp), "r" (save_vbr) : "sp" 118 ); 119 120 return( ret ); 121 } 122 #endif 123 124 125 /* ++roman: This is a more elaborate test for an SCC chip, since the plain 126 * Medusa board generates DTACK at the SCC's standard addresses, but a SCC 127 * board in the Medusa is possible. Also, the addresses where the ST_ESCC 128 * resides generate DTACK without the chip, too. 129 * The method is to write values into the interrupt vector register, that 130 * should be readable without trouble (from channel A!). 131 */ 132 133 static int __init scc_test( volatile char *ctla ) 134 { 135 if (!hwreg_present( ctla )) 136 return( 0 ); 137 MFPDELAY(); 138 139 *ctla = 2; MFPDELAY(); 140 *ctla = 0x40; MFPDELAY(); 141 142 *ctla = 2; MFPDELAY(); 143 if (*ctla != 0x40) return( 0 ); 144 MFPDELAY(); 145 146 *ctla = 2; MFPDELAY(); 147 *ctla = 0x60; MFPDELAY(); 148 149 *ctla = 2; MFPDELAY(); 150 if (*ctla != 0x60) return( 0 ); 151 152 return( 1 ); 153 } 154 155 156 /* 157 * Parse an Atari-specific record in the bootinfo 158 */ 159 160 int __init atari_parse_bootinfo(const struct bi_record *record) 161 { 162 int unknown = 0; 163 const u_long *data = record->data; 164 165 switch (record->tag) { 166 case BI_ATARI_MCH_COOKIE: 167 atari_mch_cookie = *data; 168 break; 169 case BI_ATARI_MCH_TYPE: 170 atari_mch_type = *data; 171 break; 172 default: 173 unknown = 1; 174 } 175 return(unknown); 176 } 177 178 179 /* Parse the Atari-specific switches= option. */ 180 void __init atari_switches_setup( const char *str, unsigned len ) 181 { 182 char switches[len+1]; 183 char *p; 184 int ovsc_shift; 185 char *args = switches; 186 187 /* copy string to local array, strsep works destructively... */ 188 strlcpy( switches, str, sizeof(switches) ); 189 atari_switches = 0; 190 191 /* parse the options */ 192 while ((p = strsep(&args, ",")) != NULL) { 193 if (!*p) continue; 194 ovsc_shift = 0; 195 if (strncmp( p, "ov_", 3 ) == 0) { 196 p += 3; 197 ovsc_shift = ATARI_SWITCH_OVSC_SHIFT; 198 } 199 200 if (strcmp( p, "ikbd" ) == 0) { 201 /* RTS line of IKBD ACIA */ 202 atari_switches |= ATARI_SWITCH_IKBD << ovsc_shift; 203 } 204 else if (strcmp( p, "midi" ) == 0) { 205 /* RTS line of MIDI ACIA */ 206 atari_switches |= ATARI_SWITCH_MIDI << ovsc_shift; 207 } 208 else if (strcmp( p, "snd6" ) == 0) { 209 atari_switches |= ATARI_SWITCH_SND6 << ovsc_shift; 210 } 211 else if (strcmp( p, "snd7" ) == 0) { 212 atari_switches |= ATARI_SWITCH_SND7 << ovsc_shift; 213 } 214 } 215 } 216 217 218 /* 219 * Setup the Atari configuration info 220 */ 221 222 void __init config_atari(void) 223 { 224 unsigned short tos_version; 225 226 memset(&atari_hw_present, 0, sizeof(atari_hw_present)); 227 228 atari_debug_init(); 229 230 ioport_resource.end = 0xFFFFFFFF; /* Change size of I/O space from 64KB 231 to 4GB. */ 232 233 mach_sched_init = atari_sched_init; 234 mach_init_IRQ = atari_init_IRQ; 235 mach_request_irq = atari_request_irq; 236 mach_free_irq = atari_free_irq; 237 enable_irq = atari_enable_irq; 238 disable_irq = atari_disable_irq; 239 mach_get_model = atari_get_model; 240 mach_get_hardware_list = atari_get_hardware_list; 241 mach_get_irq_list = show_atari_interrupts; 242 mach_gettimeoffset = atari_gettimeoffset; 243 mach_reset = atari_reset; 244 mach_max_dma_address = 0xffffff; 245 #if defined(CONFIG_INPUT_M68K_BEEP) || defined(CONFIG_INPUT_M68K_BEEP_MODULE) 246 mach_beep = atari_mksound; 247 #endif 248 #ifdef CONFIG_HEARTBEAT 249 mach_heartbeat = atari_heartbeat; 250 #endif 251 252 /* Set switches as requested by the user */ 253 if (atari_switches & ATARI_SWITCH_IKBD) 254 acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID; 255 if (atari_switches & ATARI_SWITCH_MIDI) 256 acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID; 257 if (atari_switches & (ATARI_SWITCH_SND6|ATARI_SWITCH_SND7)) { 258 sound_ym.rd_data_reg_sel = 14; 259 sound_ym.wd_data = sound_ym.rd_data_reg_sel | 260 ((atari_switches&ATARI_SWITCH_SND6) ? 0x40 : 0) | 261 ((atari_switches&ATARI_SWITCH_SND7) ? 0x80 : 0); 262 } 263 264 /* ++bjoern: 265 * Determine hardware present 266 */ 267 268 printk( "Atari hardware found: " ); 269 if (MACH_IS_MEDUSA || MACH_IS_HADES) { 270 /* There's no Atari video hardware on the Medusa, but all the 271 * addresses below generate a DTACK so no bus error occurs! */ 272 } 273 else if (hwreg_present( f030_xreg )) { 274 ATARIHW_SET(VIDEL_SHIFTER); 275 printk( "VIDEL " ); 276 /* This is a temporary hack: If there is Falcon video 277 * hardware, we assume that the ST-DMA serves SCSI instead of 278 * ACSI. In the future, there should be a better method for 279 * this... 280 */ 281 ATARIHW_SET(ST_SCSI); 282 printk( "STDMA-SCSI " ); 283 } 284 else if (hwreg_present( tt_palette )) { 285 ATARIHW_SET(TT_SHIFTER); 286 printk( "TT_SHIFTER " ); 287 } 288 else if (hwreg_present( &shifter.bas_hi )) { 289 if (hwreg_present( &shifter.bas_lo ) && 290 (shifter.bas_lo = 0x0aau, shifter.bas_lo == 0x0aau)) { 291 ATARIHW_SET(EXTD_SHIFTER); 292 printk( "EXTD_SHIFTER " ); 293 } 294 else { 295 ATARIHW_SET(STND_SHIFTER); 296 printk( "STND_SHIFTER " ); 297 } 298 } 299 if (hwreg_present( &mfp.par_dt_reg )) { 300 ATARIHW_SET(ST_MFP); 301 printk( "ST_MFP " ); 302 } 303 if (hwreg_present( &tt_mfp.par_dt_reg )) { 304 ATARIHW_SET(TT_MFP); 305 printk( "TT_MFP " ); 306 } 307 if (hwreg_present( &tt_scsi_dma.dma_addr_hi )) { 308 ATARIHW_SET(SCSI_DMA); 309 printk( "TT_SCSI_DMA " ); 310 } 311 if (!MACH_IS_HADES && hwreg_present( &st_dma.dma_hi )) { 312 ATARIHW_SET(STND_DMA); 313 printk( "STND_DMA " ); 314 } 315 if (MACH_IS_MEDUSA || /* The ST-DMA address registers aren't readable 316 * on all Medusas, so the test below may fail */ 317 (hwreg_present( &st_dma.dma_vhi ) && 318 (st_dma.dma_vhi = 0x55) && (st_dma.dma_hi = 0xaa) && 319 st_dma.dma_vhi == 0x55 && st_dma.dma_hi == 0xaa && 320 (st_dma.dma_vhi = 0xaa) && (st_dma.dma_hi = 0x55) && 321 st_dma.dma_vhi == 0xaa && st_dma.dma_hi == 0x55)) { 322 ATARIHW_SET(EXTD_DMA); 323 printk( "EXTD_DMA " ); 324 } 325 if (hwreg_present( &tt_scsi.scsi_data )) { 326 ATARIHW_SET(TT_SCSI); 327 printk( "TT_SCSI " ); 328 } 329 if (hwreg_present( &sound_ym.rd_data_reg_sel )) { 330 ATARIHW_SET(YM_2149); 331 printk( "YM2149 " ); 332 } 333 if (!MACH_IS_MEDUSA && !MACH_IS_HADES && 334 hwreg_present( &tt_dmasnd.ctrl )) { 335 ATARIHW_SET(PCM_8BIT); 336 printk( "PCM " ); 337 } 338 if (!MACH_IS_HADES && hwreg_present( &falcon_codec.unused5 )) { 339 ATARIHW_SET(CODEC); 340 printk( "CODEC " ); 341 } 342 if (hwreg_present( &dsp56k_host_interface.icr )) { 343 ATARIHW_SET(DSP56K); 344 printk( "DSP56K " ); 345 } 346 if (hwreg_present( &tt_scc_dma.dma_ctrl ) && 347 #if 0 348 /* This test sucks! Who knows some better? */ 349 (tt_scc_dma.dma_ctrl = 0x01, (tt_scc_dma.dma_ctrl & 1) == 1) && 350 (tt_scc_dma.dma_ctrl = 0x00, (tt_scc_dma.dma_ctrl & 1) == 0) 351 #else 352 !MACH_IS_MEDUSA && !MACH_IS_HADES 353 #endif 354 ) { 355 ATARIHW_SET(SCC_DMA); 356 printk( "SCC_DMA " ); 357 } 358 if (scc_test( &scc.cha_a_ctrl )) { 359 ATARIHW_SET(SCC); 360 printk( "SCC " ); 361 } 362 if (scc_test( &st_escc.cha_b_ctrl )) { 363 ATARIHW_SET( ST_ESCC ); 364 printk( "ST_ESCC " ); 365 } 366 if (MACH_IS_HADES) 367 { 368 ATARIHW_SET( VME ); 369 printk( "VME " ); 370 } 371 else if (hwreg_present( &tt_scu.sys_mask )) { 372 ATARIHW_SET(SCU); 373 /* Assume a VME bus if there's a SCU */ 374 ATARIHW_SET( VME ); 375 printk( "VME SCU " ); 376 } 377 if (hwreg_present( (void *)(0xffff9210) )) { 378 ATARIHW_SET(ANALOG_JOY); 379 printk( "ANALOG_JOY " ); 380 } 381 if (!MACH_IS_HADES && hwreg_present( blitter.halftone )) { 382 ATARIHW_SET(BLITTER); 383 printk( "BLITTER " ); 384 } 385 if (hwreg_present((void *)0xfff00039)) { 386 ATARIHW_SET(IDE); 387 printk( "IDE " ); 388 } 389 #if 1 /* This maybe wrong */ 390 if (!MACH_IS_MEDUSA && !MACH_IS_HADES && 391 hwreg_present( &tt_microwire.data ) && 392 hwreg_present( &tt_microwire.mask ) && 393 (tt_microwire.mask = 0x7ff, 394 udelay(1), 395 tt_microwire.data = MW_LM1992_PSG_HIGH | MW_LM1992_ADDR, 396 udelay(1), 397 tt_microwire.data != 0)) { 398 ATARIHW_SET(MICROWIRE); 399 while (tt_microwire.mask != 0x7ff) ; 400 printk( "MICROWIRE " ); 401 } 402 #endif 403 if (hwreg_present( &tt_rtc.regsel )) { 404 ATARIHW_SET(TT_CLK); 405 printk( "TT_CLK " ); 406 mach_hwclk = atari_tt_hwclk; 407 mach_set_clock_mmss = atari_tt_set_clock_mmss; 408 } 409 if (!MACH_IS_HADES && hwreg_present( &mste_rtc.sec_ones)) { 410 ATARIHW_SET(MSTE_CLK); 411 printk( "MSTE_CLK "); 412 mach_hwclk = atari_mste_hwclk; 413 mach_set_clock_mmss = atari_mste_set_clock_mmss; 414 } 415 if (!MACH_IS_MEDUSA && !MACH_IS_HADES && 416 hwreg_present( &dma_wd.fdc_speed ) && 417 hwreg_write( &dma_wd.fdc_speed, 0 )) { 418 ATARIHW_SET(FDCSPEED); 419 printk( "FDC_SPEED "); 420 } 421 if (!MACH_IS_HADES && !ATARIHW_PRESENT(ST_SCSI)) { 422 ATARIHW_SET(ACSI); 423 printk( "ACSI " ); 424 } 425 printk("\n"); 426 427 if (CPU_IS_040_OR_060) 428 /* Now it seems to be safe to turn of the tt0 transparent 429 * translation (the one that must not be turned off in 430 * head.S...) 431 */ 432 __asm__ volatile ("moveq #0,%/d0\n\t" 433 ".chip 68040\n\t" 434 "movec %%d0,%%itt0\n\t" 435 "movec %%d0,%%dtt0\n\t" 436 ".chip 68k" 437 : /* no outputs */ 438 : /* no inputs */ 439 : "d0"); 440 441 /* allocator for memory that must reside in st-ram */ 442 atari_stram_init (); 443 444 /* Set up a mapping for the VMEbus address region: 445 * 446 * VME is either at phys. 0xfexxxxxx (TT) or 0xa00000..0xdfffff 447 * (MegaSTE) In both cases, the whole 16 MB chunk is mapped at 448 * 0xfe000000 virt., because this can be done with a single 449 * transparent translation. On the 68040, lots of often unused 450 * page tables would be needed otherwise. On a MegaSTE or similar, 451 * the highest byte is stripped off by hardware due to the 24 bit 452 * design of the bus. 453 */ 454 455 if (CPU_IS_020_OR_030) { 456 unsigned long tt1_val; 457 tt1_val = 0xfe008543; /* Translate 0xfexxxxxx, enable, cache 458 * inhibit, read and write, FDC mask = 3, 459 * FDC val = 4 -> Supervisor only */ 460 __asm__ __volatile__ ( ".chip 68030\n\t" 461 "pmove %0@,%/tt1\n\t" 462 ".chip 68k" 463 : : "a" (&tt1_val) ); 464 } 465 else { 466 __asm__ __volatile__ 467 ( "movel %0,%/d0\n\t" 468 ".chip 68040\n\t" 469 "movec %%d0,%%itt1\n\t" 470 "movec %%d0,%%dtt1\n\t" 471 ".chip 68k" 472 : 473 : "g" (0xfe00a040) /* Translate 0xfexxxxxx, enable, 474 * supervisor only, non-cacheable/ 475 * serialized, writable */ 476 : "d0" ); 477 478 } 479 480 /* Fetch tos version at Physical 2 */ 481 /* We my not be able to access this address if the kernel is 482 loaded to st ram, since the first page is unmapped. On the 483 Medusa this is always the case and there is nothing we can do 484 about this, so we just assume the smaller offset. For the TT 485 we use the fact that in head.S we have set up a mapping 486 0xFFxxxxxx -> 0x00xxxxxx, so that the first 16MB is accessible 487 in the last 16MB of the address space. */ 488 tos_version = (MACH_IS_MEDUSA || MACH_IS_HADES) ? 489 0xfff : *(unsigned short *)0xff000002; 490 atari_rtc_year_offset = (tos_version < 0x306) ? 70 : 68; 491 } 492 493 #ifdef CONFIG_HEARTBEAT 494 static void atari_heartbeat( int on ) 495 { 496 unsigned char tmp; 497 unsigned long flags; 498 499 if (atari_dont_touch_floppy_select) 500 return; 501 502 local_irq_save(flags); 503 sound_ym.rd_data_reg_sel = 14; /* Select PSG Port A */ 504 tmp = sound_ym.rd_data_reg_sel; 505 sound_ym.wd_data = on ? (tmp & ~0x02) : (tmp | 0x02); 506 local_irq_restore(flags); 507 } 508 #endif 509 510 /* ++roman: 511 * 512 * This function does a reset on machines that lack the ability to 513 * assert the processor's _RESET signal somehow via hardware. It is 514 * based on the fact that you can find the initial SP and PC values 515 * after a reset at physical addresses 0 and 4. This works pretty well 516 * for Atari machines, since the lowest 8 bytes of physical memory are 517 * really ROM (mapped by hardware). For other 680x0 machines: don't 518 * know if it works... 519 * 520 * To get the values at addresses 0 and 4, the MMU better is turned 521 * off first. After that, we have to jump into physical address space 522 * (the PC before the pmove statement points to the virtual address of 523 * the code). Getting that physical address is not hard, but the code 524 * becomes a bit complex since I've tried to ensure that the jump 525 * statement after the pmove is in the cache already (otherwise the 526 * processor can't fetch it!). For that, the code first jumps to the 527 * jump statement with the (virtual) address of the pmove section in 528 * an address register . The jump statement is surely in the cache 529 * now. After that, that physical address of the reset code is loaded 530 * into the same address register, pmove is done and the same jump 531 * statements goes to the reset code. Since there are not many 532 * statements between the two jumps, I hope it stays in the cache. 533 * 534 * The C code makes heavy use of the GCC features that you can get the 535 * address of a C label. No hope to compile this with another compiler 536 * than GCC! 537 */ 538 539 /* ++andreas: no need for complicated code, just depend on prefetch */ 540 541 static void atari_reset (void) 542 { 543 long tc_val = 0; 544 long reset_addr; 545 546 /* On the Medusa, phys. 0x4 may contain garbage because it's no 547 ROM. See above for explanation why we cannot use PTOV(4). */ 548 reset_addr = MACH_IS_HADES ? 0x7fe00030 : 549 MACH_IS_MEDUSA || MACH_IS_AB40 ? 0xe00030 : 550 *(unsigned long *) 0xff000004; 551 552 /* reset ACIA for switch off OverScan, if it's active */ 553 if (atari_switches & ATARI_SWITCH_OVSC_IKBD) 554 acia.key_ctrl = ACIA_RESET; 555 if (atari_switches & ATARI_SWITCH_OVSC_MIDI) 556 acia.mid_ctrl = ACIA_RESET; 557 558 /* processor independent: turn off interrupts and reset the VBR; 559 * the caches must be left enabled, else prefetching the final jump 560 * instruction doesn't work. */ 561 local_irq_disable(); 562 __asm__ __volatile__ 563 ("moveq #0,%/d0\n\t" 564 "movec %/d0,%/vbr" 565 : : : "d0" ); 566 567 if (CPU_IS_040_OR_060) { 568 unsigned long jmp_addr040 = virt_to_phys(&&jmp_addr_label040); 569 if (CPU_IS_060) { 570 /* 68060: clear PCR to turn off superscalar operation */ 571 __asm__ __volatile__ 572 ("moveq #0,%/d0\n\t" 573 ".chip 68060\n\t" 574 "movec %%d0,%%pcr\n\t" 575 ".chip 68k" 576 : : : "d0" ); 577 } 578 579 __asm__ __volatile__ 580 ("movel %0,%/d0\n\t" 581 "andl #0xff000000,%/d0\n\t" 582 "orw #0xe020,%/d0\n\t" /* map 16 MB, enable, cacheable */ 583 ".chip 68040\n\t" 584 "movec %%d0,%%itt0\n\t" 585 "movec %%d0,%%dtt0\n\t" 586 ".chip 68k\n\t" 587 "jmp %0@\n\t" 588 : /* no outputs */ 589 : "a" (jmp_addr040) 590 : "d0" ); 591 jmp_addr_label040: 592 __asm__ __volatile__ 593 ("moveq #0,%/d0\n\t" 594 "nop\n\t" 595 ".chip 68040\n\t" 596 "cinva %%bc\n\t" 597 "nop\n\t" 598 "pflusha\n\t" 599 "nop\n\t" 600 "movec %%d0,%%tc\n\t" 601 "nop\n\t" 602 /* the following setup of transparent translations is needed on the 603 * Afterburner040 to successfully reboot. Other machines shouldn't 604 * care about a different tt regs setup, they also didn't care in 605 * the past that the regs weren't turned off. */ 606 "movel #0xffc000,%%d0\n\t" /* whole insn space cacheable */ 607 "movec %%d0,%%itt0\n\t" 608 "movec %%d0,%%itt1\n\t" 609 "orw #0x40,%/d0\n\t" /* whole data space non-cacheable/ser. */ 610 "movec %%d0,%%dtt0\n\t" 611 "movec %%d0,%%dtt1\n\t" 612 ".chip 68k\n\t" 613 "jmp %0@" 614 : /* no outputs */ 615 : "a" (reset_addr) 616 : "d0"); 617 } 618 else 619 __asm__ __volatile__ 620 ("pmove %0@,%/tc\n\t" 621 "jmp %1@" 622 : /* no outputs */ 623 : "a" (&tc_val), "a" (reset_addr)); 624 } 625 626 627 static void atari_get_model(char *model) 628 { 629 strcpy(model, "Atari "); 630 switch (atari_mch_cookie >> 16) { 631 case ATARI_MCH_ST: 632 if (ATARIHW_PRESENT(MSTE_CLK)) 633 strcat (model, "Mega ST"); 634 else 635 strcat (model, "ST"); 636 break; 637 case ATARI_MCH_STE: 638 if (MACH_IS_MSTE) 639 strcat (model, "Mega STE"); 640 else 641 strcat (model, "STE"); 642 break; 643 case ATARI_MCH_TT: 644 if (MACH_IS_MEDUSA) 645 /* Medusa has TT _MCH cookie */ 646 strcat (model, "Medusa"); 647 else if (MACH_IS_HADES) 648 strcat(model, "Hades"); 649 else 650 strcat (model, "TT"); 651 break; 652 case ATARI_MCH_FALCON: 653 strcat (model, "Falcon"); 654 if (MACH_IS_AB40) 655 strcat (model, " (with Afterburner040)"); 656 break; 657 default: 658 sprintf (model + strlen (model), "(unknown mach cookie 0x%lx)", 659 atari_mch_cookie); 660 break; 661 } 662 } 663 664 665 static int atari_get_hardware_list(char *buffer) 666 { 667 int len = 0, i; 668 669 for (i = 0; i < m68k_num_memory; i++) 670 len += sprintf (buffer+len, "\t%3ld MB at 0x%08lx (%s)\n", 671 m68k_memory[i].size >> 20, m68k_memory[i].addr, 672 (m68k_memory[i].addr & 0xff000000 ? 673 "alternate RAM" : "ST-RAM")); 674 675 #define ATARIHW_ANNOUNCE(name,str) \ 676 if (ATARIHW_PRESENT(name)) \ 677 len += sprintf (buffer + len, "\t%s\n", str) 678 679 len += sprintf (buffer + len, "Detected hardware:\n"); 680 ATARIHW_ANNOUNCE(STND_SHIFTER, "ST Shifter"); 681 ATARIHW_ANNOUNCE(EXTD_SHIFTER, "STe Shifter"); 682 ATARIHW_ANNOUNCE(TT_SHIFTER, "TT Shifter"); 683 ATARIHW_ANNOUNCE(VIDEL_SHIFTER, "Falcon Shifter"); 684 ATARIHW_ANNOUNCE(YM_2149, "Programmable Sound Generator"); 685 ATARIHW_ANNOUNCE(PCM_8BIT, "PCM 8 Bit Sound"); 686 ATARIHW_ANNOUNCE(CODEC, "CODEC Sound"); 687 ATARIHW_ANNOUNCE(TT_SCSI, "SCSI Controller NCR5380 (TT style)"); 688 ATARIHW_ANNOUNCE(ST_SCSI, "SCSI Controller NCR5380 (Falcon style)"); 689 ATARIHW_ANNOUNCE(ACSI, "ACSI Interface"); 690 ATARIHW_ANNOUNCE(IDE, "IDE Interface"); 691 ATARIHW_ANNOUNCE(FDCSPEED, "8/16 Mhz Switch for FDC"); 692 ATARIHW_ANNOUNCE(ST_MFP, "Multi Function Peripheral MFP 68901"); 693 ATARIHW_ANNOUNCE(TT_MFP, "Second Multi Function Peripheral MFP 68901"); 694 ATARIHW_ANNOUNCE(SCC, "Serial Communications Controller SCC 8530"); 695 ATARIHW_ANNOUNCE(ST_ESCC, "Extended Serial Communications Controller SCC 85230"); 696 ATARIHW_ANNOUNCE(ANALOG_JOY, "Paddle Interface"); 697 ATARIHW_ANNOUNCE(MICROWIRE, "MICROWIRE(tm) Interface"); 698 ATARIHW_ANNOUNCE(STND_DMA, "DMA Controller (24 bit)"); 699 ATARIHW_ANNOUNCE(EXTD_DMA, "DMA Controller (32 bit)"); 700 ATARIHW_ANNOUNCE(SCSI_DMA, "DMA Controller for NCR5380"); 701 ATARIHW_ANNOUNCE(SCC_DMA, "DMA Controller for SCC"); 702 ATARIHW_ANNOUNCE(TT_CLK, "Clock Chip MC146818A"); 703 ATARIHW_ANNOUNCE(MSTE_CLK, "Clock Chip RP5C15"); 704 ATARIHW_ANNOUNCE(SCU, "System Control Unit"); 705 ATARIHW_ANNOUNCE(BLITTER, "Blitter"); 706 ATARIHW_ANNOUNCE(VME, "VME Bus"); 707 ATARIHW_ANNOUNCE(DSP56K, "DSP56001 processor"); 708 709 return(len); 710 } 711 712 /* 713 * Local variables: 714 * c-indent-level: 4 715 * tab-width: 8 716 * End: 717 */ 718