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 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  */