git.oblomov.eu Git - linux-2.6/blob - arch/m68k/atari/config.c

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