arch/ppc/platforms/prpmc750_setup.c

   1 /*
   2  * arch/ppc/platforms/prpmc750_setup.c
   3  *
   4  * Board setup routines for Motorola PrPMC750
   5  *
   6  * Author: Matt Porter <mporter@mvista.com>
   7  *
   8  * 2001 (c) MontaVista, Software, Inc.  This file is licensed under
   9  * the terms of the GNU General Public License version 2.1.  This program
  10  * is licensed "as is" without any warranty of any kind, whether express
  11  * or implied.
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/stddef.h>
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/errno.h>
  19 #include <linux/reboot.h>
  20 #include <linux/pci.h>
  21 #include <linux/kdev_t.h>
  22 #include <linux/types.h>
  23 #include <linux/major.h>
  24 #include <linux/blk.h>
  25 #include <linux/console.h>
  26 #include <linux/delay.h>
  27 #include <linux/irq.h>
  28 #include <linux/seq_file.h>
  29 #include <linux/ide.h>
  30 #include <linux/root_dev.h>
  31
  32 #include <asm/system.h>
  33 #include <asm/pgtable.h>
  34 #include <asm/page.h>
  35 #include <asm/dma.h>
  36 #include <asm/io.h>
  37 #include <asm/machdep.h>
  38 #include <asm/time.h>
  39 #include <platforms/prpmc750.h>
  40 #include <asm/open_pic.h>
  41 #include <asm/bootinfo.h>
  42 #include <asm/pplus.h>
  43
  44 extern void prpmc750_find_bridges(void);
  45 extern int mpic_init(void);
  46 extern unsigned long loops_per_jiffy;
  47
  48 static u_char prpmc750_openpic_initsenses[] __initdata =
  49 {
  50     1,  /* PRPMC750_INT_HOSTINT0 */
  51     1,  /* PRPMC750_INT_UART */
  52     1,  /* PRPMC750_INT_DEBUGINT */
  53     1,  /* PRPMC750_INT_HAWK_WDT */
  54     1,  /* PRPMC750_INT_UNUSED */
  55     1,  /* PRPMC750_INT_ABORT */
  56     1,  /* PRPMC750_INT_HOSTINT1 */
  57     1,  /* PRPMC750_INT_HOSTINT2 */
  58     1,  /* PRPMC750_INT_HOSTINT3 */
  59     1,  /* PRPMC750_INT_PMC_INTA */
  60     1,  /* PRPMC750_INT_PMC_INTB */
  61     1,  /* PRPMC750_INT_PMC_INTC */
  62     1,  /* PRPMC750_INT_PMC_INTD */
  63     1,  /* PRPMC750_INT_UNUSED */
  64     1,  /* PRPMC750_INT_UNUSED */
  65     1,  /* PRPMC750_INT_UNUSED */
  66 };
  67
  68 static int
  69 prpmc750_show_cpuinfo(struct seq_file *m)
  70 {
  71         seq_printf(m, "machine\t\t: PrPMC750\n");
  72
  73         return 0;
  74 }
  75
  76 static void __init
  77 prpmc750_setup_arch(void)
  78 {
  79         /* init to some ~sane value until calibrate_delay() runs */
  80         loops_per_jiffy = 50000000/HZ;
  81
  82         /* Lookup PCI host bridges */
  83         prpmc750_find_bridges();
  84
  85 #ifdef CONFIG_BLK_DEV_INITRD
  86         if (initrd_start)
  87                 ROOT_DEV = Root_RAM0;
  88         else
  89 #endif
  90 #ifdef CONFIG_ROOT_NFS
  91                 ROOT_DEV = Root_NFS;
  92 #else
  93                 ROOT_DEV = Root_SDA2;
  94 #endif
  95
  96 #ifdef CONFIG_DUMMY_CONSOLE
  97         conswitchp = &dummy_con;
  98 #endif
  99
 100         /* Find and map our OpenPIC */
 101         pplus_mpic_init(PRPMC750_PCI_MEM_OFFSET);
 102         OpenPIC_InitSenses = prpmc750_openpic_initsenses;
 103         OpenPIC_NumInitSenses = sizeof(prpmc750_openpic_initsenses);
 104
 105         printk("PrPMC750 port (C) 2001 MontaVista Software, Inc. (source@mvista.com)\n");
 106 }
 107
 108 /*
 109  * Compute the PrPMC750's bus speed using the baud clock as a
 110  * reference.
 111  */
 112 static unsigned long __init
 113 prpmc750_get_bus_speed(void)
 114 {
 115         unsigned long tbl_start, tbl_end;
 116         unsigned long current_state, old_state, bus_speed;
 117         unsigned char lcr, dll, dlm;
 118         int baud_divisor, count;
 119
 120         /* Read the UART's baud clock divisor */
 121         lcr = readb(PRPMC750_SERIAL_0_LCR);
 122         writeb(lcr | UART_LCR_DLAB, PRPMC750_SERIAL_0_LCR);
 123         dll = readb(PRPMC750_SERIAL_0_DLL);
 124         dlm = readb(PRPMC750_SERIAL_0_DLM);
 125         writeb(lcr & ~UART_LCR_DLAB, PRPMC750_SERIAL_0_LCR);
 126         baud_divisor = (dlm << 8) | dll;
 127
 128         /*
 129          * Use the baud clock divisor and base baud clock
 130          * to determine the baud rate and use that as
 131          * the number of baud clock edges we use for
 132          * the time base sample.  Make it half the baud
 133          * rate.
 134          */
 135         count = PRPMC750_BASE_BAUD / (baud_divisor * 16);
 136
 137         /* Find the first edge of the baud clock */
 138         old_state = readb(PRPMC750_STATUS_REG) & PRPMC750_BAUDOUT_MASK;
 139         do {
 140                 current_state = readb(PRPMC750_STATUS_REG) &
 141                         PRPMC750_BAUDOUT_MASK;
 142         } while(old_state == current_state);
 143
 144         old_state = current_state;
 145
 146         /* Get the starting time base value */
 147         tbl_start = get_tbl();
 148
 149         /*
 150          * Loop until we have found a number of edges equal
 151          * to half the count (half the baud rate)
 152          */
 153         do {
 154                 do {
 155                         current_state = readb(PRPMC750_STATUS_REG) &
 156                                 PRPMC750_BAUDOUT_MASK;
 157                 } while(old_state == current_state);
 158                 old_state = current_state;
 159         } while (--count);
 160
 161         /* Get the ending time base value */
 162         tbl_end = get_tbl();
 163
 164         /* Compute bus speed */
 165         bus_speed = (tbl_end-tbl_start)*128;
 166
 167         return bus_speed;
 168 }
 169
 170 static void __init
 171 prpmc750_calibrate_decr(void)
 172 {
 173         unsigned long freq;
 174         int divisor = 4;
 175
 176         freq = prpmc750_get_bus_speed();
 177
 178         tb_ticks_per_jiffy = freq / (HZ * divisor);
 179         tb_to_us = mulhwu_scale_factor(freq/divisor, 1000000);
 180 }
 181
 182 static void
 183 prpmc750_restart(char *cmd)
 184 {
 185         local_irq_disable();
 186         writeb(PRPMC750_MODRST_MASK, PRPMC750_MODRST_REG);
 187         while(1);
 188 }
 189
 190 static void
 191 prpmc750_halt(void)
 192 {
 193         local_irq_disable();
 194         while (1);
 195 }
 196
 197 static void
 198 prpmc750_power_off(void)
 199 {
 200         prpmc750_halt();
 201 }
 202
 203 static void __init
 204 prpmc750_init_IRQ(void)
 205 {
 206         openpic_init(1, 0, 0, -1);
 207 }
 208
 209 /*
 210  * Set BAT 3 to map 0xf0000000 to end of physical memory space.
 211  */
 212 static __inline__ void
 213 prpmc750_set_bat(void)
 214 {
 215         unsigned long   bat3u, bat3l;
 216         static int      mapping_set = 0;
 217
 218         if (!mapping_set)
 219         {
 220                 __asm__ __volatile__(
 221                                 " lis %0,0xf000\n \
 222                                 ori %1,%0,0x002a\n \
 223                                 ori %0,%0,0x1ffe\n \
 224                                 mtspr 0x21e,%0\n \
 225                                 mtspr 0x21f,%1\n \
 226                                 isync\n \
 227                                 sync "
 228                                 : "=r" (bat3u), "=r" (bat3l));
 229
 230                 mapping_set = 1;
 231         }
 232         return;
 233 }
 234
 235 /*
 236  * We need to read the Falcon/Hawk memory controller
 237  * to properly determine this value
 238  */
 239 static unsigned long __init
 240 prpmc750_find_end_of_memory(void)
 241 {
 242         /* Cover the Hawk registers with a BAT */
 243         prpmc750_set_bat();
 244
 245         /* Read the memory size from the Hawk SMC */
 246         return pplus_get_mem_size(PRPMC750_HAWK_SMC_BASE);
 247 }
 248
 249 static void __init
 250 prpmc750_map_io(void)
 251 {
 252         io_block_mapping(0x80000000, 0x80000000, 0x10000000, _PAGE_IO);
 253         io_block_mapping(0xf0000000, 0xc0000000, 0x08000000, _PAGE_IO);
 254         io_block_mapping(0xf8000000, 0xf8000000, 0x08000000, _PAGE_IO);
 255 }
 256
 257 void __init
 258 platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
 259               unsigned long r6, unsigned long r7)
 260 {
 261         parse_bootinfo(find_bootinfo());
 262
 263         isa_io_base = PRPMC750_ISA_IO_BASE;
 264         isa_mem_base = PRPMC750_ISA_MEM_BASE;
 265         pci_dram_offset = PRPMC750_SYS_MEM_BASE;
 266
 267         ppc_md.setup_arch       = prpmc750_setup_arch;
 268         ppc_md.show_cpuinfo     = prpmc750_show_cpuinfo;
 269         ppc_md.init_IRQ         = prpmc750_init_IRQ;
 270         ppc_md.get_irq          = openpic_get_irq;
 271
 272         ppc_md.find_end_of_memory = prpmc750_find_end_of_memory;
 273         ppc_md.setup_io_mappings = prpmc750_map_io;
 274
 275         ppc_md.restart          = prpmc750_restart;
 276         ppc_md.power_off        = prpmc750_power_off;
 277         ppc_md.halt             = prpmc750_halt;
 278
 279         /* PrPMC750 has no timekeeper part */
 280         ppc_md.time_init        = NULL;
 281         ppc_md.get_rtc_time     = NULL;
 282         ppc_md.set_rtc_time     = NULL;
 283         ppc_md.calibrate_decr   = prpmc750_calibrate_decr;
 284 }