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