arch/ppc/kernel/walnut_setup.c

   1 /*
   2  *
   3  *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
   4  *
   5  *    Module name: walnut_setup.c
   6  *
   7  *    Description:
   8  *      Architecture- / platform-specific boot-time initialization code for
   9  *      the IBM PowerPC 403GP "Walnut" evaluation board. Adapted from original
  10  *      code by Gary Thomas, Cort Dougan <cort@fsmlabs.com>, and Dan Malek
  11  *      <dan@net4x.com>.
  12  *
  13  */
  14
  15 #include <linux/config.h>
  16 #include <linux/init.h>
  17 #include <linux/smp.h>
  18 #include <linux/threads.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/param.h>
  21 #include <linux/string.h>
  22 #include <linux/blk.h>
  23
  24 #include <asm/processor.h>
  25 #include <asm/board.h>
  26 #include <asm/machdep.h>
  27 #include <asm/page.h>
  28
  29 #include "local_irq.h"
  30 #include "ppc4xx_pic.h"
  31 #include <asm/time.h>
  32 #include "walnut_setup.h"
  33
  34
  35 /* Function Prototypes */
  36
  37 extern void abort(void);
  38
  39 /* Global Variables */
  40
  41 unsigned char __res[sizeof(bd_t)];
  42
  43
  44 /*
  45  * void __init walnut_init()
  46  *
  47  * Description:
  48  *   This routine...
  49  *
  50  * Input(s):
  51  *   r3 - Optional pointer to a board information structure.
  52  *   r4 - Optional pointer to the physical starting address of the init RAM
  53  *        disk.
  54  *   r5 - Optional pointer to the physical ending address of the init RAM
  55  *        disk.
  56  *   r6 - Optional pointer to the physical starting address of any kernel
  57  *        command-line parameters.
  58  *   r7 - Optional pointer to the physical ending address of any kernel
  59  *        command-line parameters.
  60  *
  61  * Output(s):
  62  *   N/A
  63  *
  64  * Returns:
  65  *   N/A
  66  *
  67  */
  68 void __init
  69 walnut_init(unsigned long r3, unsigned long r4, unsigned long r5,
  70             unsigned long r6, unsigned long r7)
  71 {
  72         /*
  73          * If we were passed in a board information, copy it into the
  74          * residual data area.
  75          */
  76         if (r3) {
  77                 memcpy((void *)__res, (void *)(r3 + KERNELBASE), sizeof(bd_t));
  78         }
  79
  80 #if defined(CONFIG_BLK_DEV_INITRD)
  81         /*
  82          * If the init RAM disk has been configured in, and there's a valid
  83          * starting address for it, set it up.
  84          */
  85         if (r4) {
  86                 initrd_start = r4 + KERNELBASE;
  87                 initrd_end = r5 + KERNELBASE;
  88         }
  89 #endif /* CONFIG_BLK_DEV_INITRD */
  90
  91         /* Copy the kernel command line arguments to a safe place. */
  92
  93         if (r6) {
  94                 *(char *)(r7 + KERNELBASE) = 0;
  95                 strcpy(cmd_line, (char *)(r6 + KERNELBASE));
  96         }
  97
  98         /* Initialize machine-dependency vectors */
  99
 100         ppc_md.setup_arch               = walnut_setup_arch;
 101         ppc_md.setup_residual           = walnut_setup_residual;
 102         ppc_md.get_cpuinfo              = NULL;
 103         ppc_md.irq_cannonicalize        = NULL;
 104         ppc_md.init_IRQ                 = walnut_init_IRQ;
 105         ppc_md.get_irq                  = walnut_get_irq;
 106         ppc_md.init                     = NULL;
 107
 108         ppc_md.restart                  = walnut_restart;
 109         ppc_md.power_off                = walnut_power_off;
 110         ppc_md.halt                     = walnut_halt;
 111
 112         ppc_md.time_init                = walnut_time_init;
 113         ppc_md.set_rtc_time             = walnut_set_rtc_time;
 114         ppc_md.get_rtc_time             = walnut_get_rtc_time;
 115         ppc_md.calibrate_decr           = walnut_calibrate_decr;
 116
 117         ppc_md.kbd_setkeycode           = NULL;
 118         ppc_md.kbd_getkeycode           = NULL;
 119         ppc_md.kbd_translate            = NULL;
 120         ppc_md.kbd_unexpected_up        = NULL;
 121         ppc_md.kbd_leds                 = NULL;
 122         ppc_md.kbd_init_hw              = NULL;
 123
 124 #if defined(CONFIG_MAGIC_SYSRQ)
 125         ppc_md.ppc_kbd_sysrq_xlate      = NULL;
 126 #endif
 127
 128         return;
 129 }
 130
 131 /*
 132  * Document me.
 133  */
 134 void __init
 135 walnut_setup_arch(void)
 136 {
 137         /* XXX - Implement me */
 138 }
 139
 140 /*
 141  * int walnut_setup_residual()
 142  *
 143  * Description:
 144  *   This routine pretty-prints the platform's internal CPU and bus clock
 145  *   frequencies into the buffer for usage in /proc/cpuinfo.
 146  *
 147  * Input(s):
 148  *  *buffer - Buffer into which CPU and bus clock frequencies are to be
 149  *            printed.
 150  *
 151  * Output(s):
 152  *  *buffer - Buffer with the CPU and bus clock frequencies.
 153  *
 154  * Returns:
 155  *   The number of bytes copied into 'buffer' if OK, otherwise zero or less
 156  *   on error.
 157  */
 158 int
 159 walnut_setup_residual(char *buffer)
 160 {
 161         int len = 0;
 162         bd_t *bp = (bd_t *)__res;
 163
 164         len += sprintf(len + buffer,
 165                        "clock\t\t: %dMHz\n"
 166                        "bus clock\t\t: %dMHz\n",
 167                        bp->bi_intfreq / 1000000,
 168                        bp->bi_busfreq / 1000000);
 169
 170         return (len);
 171 }
 172
 173 /*
 174  * Document me.
 175  */
 176 void __init
 177 walnut_init_IRQ(void)
 178 {
 179         int i;
 180
 181         ppc4xx_pic_init();
 182
 183         for (i = 0; i < NR_IRQS; i++) {
 184                 irq_desc[i].handler = ppc4xx_pic;
 185         }
 186
 187         return;
 188 }
 189
 190 /*
 191  * Document me.
 192  */
 193 int
 194 walnut_get_irq(struct pt_regs *regs)
 195 {
 196         return (ppc4xx_pic_get_irq(regs));
 197 }
 198
 199 /*
 200  * Document me.
 201  */
 202 void
 203 walnut_restart(char *cmd)
 204 {
 205         abort();
 206 }
 207
 208 /*
 209  * Document me.
 210  */
 211 void
 212 walnut_power_off(void)
 213 {
 214         walnut_restart(NULL);
 215 }
 216
 217 /*
 218  * Document me.
 219  */
 220 void
 221 walnut_halt(void)
 222 {
 223         walnut_restart(NULL);
 224 }
 225
 226 /*
 227  * Document me.
 228  */
 229 long __init
 230 walnut_time_init(void)
 231 {
 232         /* XXX - Implement me */
 233         return 0;
 234 }
 235
 236 /*
 237  * Document me.
 238  */
 239 int __init
 240 walnut_set_rtc_time(unsigned long time)
 241 {
 242         /* XXX - Implement me */
 243
 244         return (0);
 245 }
 246
 247 /*
 248  * Document me.
 249  */
 250 unsigned long __init
 251 walnut_get_rtc_time(void)
 252 {
 253         /* XXX - Implement me */
 254
 255         return (0);
 256 }
 257
 258 /*
 259  * void __init walnut_calibrate_decr()
 260  *
 261  * Description:
 262  *   This routine retrieves the internal processor frequency from the board
 263  *   information structure, sets up the kernel timer decrementer based on
 264  *   that value, enables the 403 programmable interval timer (PIT) and sets
 265  *   it up for auto-reload.
 266  *
 267  * Input(s):
 268  *   N/A
 269  *
 270  * Output(s):
 271  *   N/A
 272  *
 273  * Returns:
 274  *   N/A
 275  *
 276  */
 277 void __init
 278 walnut_calibrate_decr(void)
 279 {
 280         unsigned int freq;
 281         bd_t *bip = (bd_t *)__res;
 282
 283         freq = bip->bi_intfreq;
 284
 285         decrementer_count = freq / HZ;
 286         count_period_num = 1;
 287         count_period_den = freq;
 288
 289         /* Enable the PIT and set auto-reload of its value */
 290
 291         mtspr(SPRN_TCR, TCR_PIE | TCR_ARE);
 292
 293         /* Clear any pending timer interrupts */
 294
 295         mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_PIS | TSR_FIS);
 296 }