cp/nucleus/init.c

   1 /*
   2  * (C) Copyright 2007-2011  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * This file is released under the GPLv2.  See the COPYING file for more
   5  * details.
   6  */
   7
   8 #include <mm.h>
   9 #include <dat.h>
  10 #include <slab.h>
  11 #include <page.h>
  12 #include <buddy.h>
  13 #include <io.h>
  14 #include <sched.h>
  15 #include <device.h>
  16 #include <console.h>
  17 #include <interrupt.h>
  18 #include <magic.h>
  19 #include <shell.h>
  20 #include <sclp.h>
  21
  22 static struct psw new_io_psw = {
  23         .ea     = 1,
  24         .ba     = 1,
  25
  26         .ptr  = (u64) &IO_INT,
  27 };
  28
  29 static struct psw new_ext_psw = {
  30         .ea     = 1,
  31         .ba     = 1,
  32
  33         .ptr    = (u64) &EXT_INT,
  34 };
  35
  36 static struct psw new_svc_psw = {
  37         .ea     = 1,
  38         .ba     = 1,
  39
  40         .ptr    = (u64) &SVC_INT,
  41 };
  42
  43 static struct psw new_pgm_psw = {
  44         .ea     = 1,
  45         .ba     = 1,
  46
  47         .ptr    = (u64) &PGM_INT,
  48 };
  49
  50 u8 *int_stack_ptr;
  51
  52 struct fs *sysfs;
  53
  54 const u8 zeropage[PAGE_SIZE];
  55
  56 /* the time HVF got IPLd */
  57 struct datetime ipltime;
  58
  59 static void init_int_stack(void)
  60 {
  61         struct page *page;
  62
  63         page = alloc_pages(0, ZONE_NORMAL);
  64         BUG_ON(!page);
  65
  66         int_stack_ptr = PAGE_SIZE + (u8*)page_to_addr(page);
  67 }
  68
  69 static void idle_task_body(void)
  70 {
  71         /*
  72          * Warning: hack alert! The following overrides what __init_task
  73          * set, this allows us to skip the usual start_task wrapper.
  74          */
  75         current->regs.psw.w   = 1;
  76         current->regs.psw.ptr = MAGIC_PSW_IDLE_CODE;
  77
  78         /*
  79          * Load the new PSW that'll wait with special magic code set
  80          */
  81         lpswe(&current->regs.psw);
  82
  83         BUG();
  84 }
  85
  86 static int __finish_loading(void *data)
  87 {
  88         struct console *opcon; /* operator's console */
  89         u32 iplsch;
  90
  91         iplsch = (u32) (u64) data;
  92
  93         /*
  94          * Load the config file
  95          */
  96         sysfs = load_config(iplsch);
  97         if (IS_ERR(sysfs))
  98                 BUG();
  99
 100         /*
 101          * IPL is more or less done
 102          */
 103         get_parsed_tod(&ipltime);
 104
 105         sclp_msg("IPL AT %02d:%02d:%02d UTC %04d-%02d-%02d\n\n",
 106                    ipltime.th, ipltime.tm, ipltime.ts, ipltime.dy,
 107                    ipltime.dm, ipltime.dd);
 108
 109         opcon = start_oper_console();
 110
 111         con_printf(opcon, "NOW %02d:%02d:%02d UTC %04d-%02d-%02d\n\n",
 112                    ipltime.th, ipltime.tm, ipltime.ts, ipltime.dy,
 113                    ipltime.dm, ipltime.dd);
 114
 115         spawn_oper_shell(opcon);
 116
 117         return 0;
 118 }
 119
 120 /*
 121  * This is where everything starts
 122  */
 123 void start(u64 __memsize, u32 __iplsch)
 124 {
 125         u64 first_free_page;
 126         u64 struct_page_bytes;
 127         struct psw psw;
 128
 129         /*
 130          * ticks starts at 0
 131          */
 132         ticks = 0;
 133
 134         /*
 135          * save total system memory size
 136          */
 137         memsize = __memsize;
 138
 139         /*
 140          * Initialize struct page entries
 141          */
 142         init_pages();
 143
 144         /*
 145          * Calculate address of the first free page (we may have to round
 146          * up)
 147          */
 148         struct_page_bytes = (memsize >> PAGE_SHIFT) * sizeof(struct page);
 149
 150         first_free_page = (u64) PAGE_INFO_BASE + struct_page_bytes;
 151         if (struct_page_bytes & (PAGE_SIZE-1))
 152                 first_free_page += PAGE_SIZE - (struct_page_bytes & (PAGE_SIZE-1));
 153
 154         /*
 155          * Initialize the buddy allocator
 156          */
 157         init_buddy_alloc(first_free_page);
 158
 159         /*
 160          * Initialize slab allocator default caches
 161          */
 162         init_slab();
 163
 164         /*
 165          * Set up interrupt PSWs
 166          */
 167         memcpy(IO_INT_NEW_PSW, &new_io_psw, sizeof(struct psw));
 168         memcpy(EXT_INT_NEW_PSW, &new_ext_psw, sizeof(struct psw));
 169         memcpy(SVC_INT_NEW_PSW, &new_svc_psw, sizeof(struct psw));
 170         memcpy(PGM_INT_NEW_PSW, &new_pgm_psw, sizeof(struct psw));
 171
 172         /* Turn on Low-address Protection */
 173         lap_on();
 174
 175         /*
 176          * Set up page table entries for the nucleus
 177          */
 178         setup_dat();
 179
 180         /*
 181          * Allocate & initialize the interrupt stack
 182          */
 183         init_int_stack();
 184
 185         /*
 186          * Initialize the io subsystem
 187          */
 188         init_io();
 189
 190         /*
 191          * Register all the device drivers
 192          */
 193         register_drivers();
 194
 195         /*
 196          * Time to enable interrupts => load new psw
 197          */
 198         memset(&psw, 0, sizeof(struct psw));
 199         psw.io  = 1;
 200         psw.ea  = 1;
 201         psw.ba  = 1;
 202
 203         asm volatile(
 204                 "       larl    %%r1,0f\n"
 205                 "       stg     %%r1,%0\n"
 206                 "       lpswe   %1\n"
 207                 "0:\n"
 208         : /* output */
 209           "=m" (psw.ptr)
 210         : /* input */
 211           "m" (psw)
 212         : /* clobbered */
 213           "r1"
 214         );
 215
 216         /*
 217          * Let's discover all the devices attached
 218          */
 219         scan_devices();
 220
 221         /*
 222          * Initialize the process scheduler
 223          */
 224         init_sched();
 225
 226         /*
 227          * Start tracking locking dependencies
 228          */
 229         ldep_on();
 230
 231         /*
 232          * Create a thread that'll finish setting everything up for us
 233          */
 234         create_task("*finish-loading", __finish_loading, (void*) (u64) __iplsch);
 235
 236         /*
 237          * THIS IS WHERE THE IDLE TASK BEGINS
 238          */
 239
 240         idle_task_body();
 241 }
 242