开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
config.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：24k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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