manes/start.cpp

   1 /* Quarn OS
   2  *
   3  * Startup code
   4  *
   5  * Copyright (C) 2008 Pawel Dziepak
   6  *
   7  * This file consist of functions that are called in order to run Manes. It
   8  * includes initialization of hardware and internal kernel data structures.
   9  * After this operation kernel can change to the standard way of working witch
  10  * preemption, resources, actors and so on.
  11  */
  12
  13 #if __GNUC__ < 4
  14 #error Quarn OS is needed to be compiled on GCC 4 or later.
  15 #endif
  16
  17 #include "runtime.h"
  18 //#include "kernel_state.h"
  19 #include "manager.h"
  20
  21 #include "arch/x86/launch.h"
  22 //#include "arch/x86/speaker.h"
  23
  24 /*
  25 #include "services/timer.h"
  26 #include "services/logger.h"
  27 #include "services/early_logger.h"
  28 #include "services/tty_logger.h"
  29 #include "services/service.h"
  30 #include "services/service_manager.h"
  31 #include "services/service_shadow.h"
  32 #include "resources/resource_id.h"
  33 #include "resources/resource_order.h"
  34 #include "resources/isa.h"
  35 #include "resources/keybscr.h"
  36 #include "resources/fdc.h"
  37 #include "resources/fat.h"
  38 #include "resources/rs232.h"
  39 #include "resources/pio.h"
  40 #include "resources/fs.h"
  41 #include "resources/speaker.h"
  42 #include "resources/resource.h"
  43 #include "resources/resource_manager.h"
  44 #include "resources/slob.h"
  45 #include "resources/device.h"
  46 #include "modules/main_mmanager.h"
  47 #include "actors/actor_manager.h" */
  48
  49 #include "libs/delegate.h"
  50 #include "libs/string.h"
  51
  52 using namespace manes;
  53
  54 /*
  55 void aoh() {
  56         services::service_manager *sman = GET_SERVICES();
  57         sman->call<delegate<void, const char*> >("early_logger", "print")("\nHELLO!");
  58 }
  59
  60
  61 char *htoa(int cn)
  62 {
  63     char numbers[] =
  64         { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
  65         'E', 'F'
  66     };
  67     int i, j = 8;
  68     char temp[8];
  69     static char ret[10];
  70     char tp;
  71
  72     memset(ret, 0, 9);
  73     for (i = 0; i <= 8; i++) {
  74         temp[i] = numbers[(cn & 0x0F)];
  75         cn = cn >> 4;
  76     }
  77     for (i = 7; i != -1; i--) {
  78         if (temp[i] == '0' && j == 8 && i != 0)
  79             continue;
  80         j--;
  81         tp = temp[i];
  82         ret[7 - j] = tp;
  83     }
  84     ret[9] = 0;
  85     return ret;
  86 }
  87
  88 char *itoa(int cn) {
  89     int i, j = 8;
  90     char temp[8];
  91     static char ret[10];
  92     char tp;
  93
  94     memset(ret, 0, 9);
  95     for (i = 0; i <= 8; i++) {
  96         temp[i] = (cn % 10)+'0';
  97         cn = cn / 10;
  98     }
  99     for (i = 7; i != -1; i--) {
 100         if (temp[i] == '0' && j == 8 && i != 0)
 101             continue;
 102         j--;
 103         tp = temp[i];
 104         ret[7 - j] = tp;
 105     }
 106     ret[9] = 0;
 107     return ret;
 108 }
 109
 110 */
 111
 112 #if USE_MULTIBOOT == CONF_YES
 113 extern "C" void start() {
 114 #else
 115 extern "C" void _start() {
 116 #endif
 117         /* Prepare to execute C++ code */
 118         runtime_start();
 119
 120         /* Launch Managed Execution System */
 121         manec::launch_manes();
 122
 123         manager *main = manec::get();
 124         main->initialize();
 125
 126         /* Run low-level procedures */
 127         arch::launch();
 128
 129         /* Register creators */
 130         manec::register_creators();
 131
 132         /* Register built in types */
 133         //manec::register_builtin_types();
 134
 135         /* Run creators */
 136         //manec::animate_creators();
 137
 138         /* Manes is ready to use */
 139
 140 #if 0
 141         //services::service_manager *sman = services::service_manager::get_instance();
 142
 143         /* Register early logger service */
 144         services::logger::register_service();
 145
 146         services::early_logger::register_service();
 147
 148         services::timer::register_service();
 149
 150         delegate<void> ablah;
 151         ablah.function(aoh);
 152         services::service_shadow log("early_logger");
 153
 154         log.call<delegate<void, const char*> >("print")("OK.\nStarting Quarn OS...");
 155
 156         resources::resource_manager *rman = GET_RESOURCES();
 157
 158         delegate<manes::object *> res;
 159
 160         /* FS - base */
 161         resources::fs::register_resource();
 162
 163         /* ISA bus */
 164         resources::isa::register_resource();
 165
 166         /* TTY0 console */
 167         resources::keybscr::register_resource();
 168
 169         /* TTYS0 console */
 170         //resources::rs232::register_resource();
 171
 172         /* Speaker */
 173         resources::speaker::register_resource();
 174
 175         /* FDC */
 176         resources::fdc::register_resource();
 177
 178         /* FAT */
 179         resources::fat::register_resource();
 180
 181         /* PIO */
 182         //resources::pio::register_resource();
 183
 184         /* slob */
 185         resources::slob::register_resource();
 186
 187         resources::slob *_alloc = (resources::slob*)rman->new_object("slob");
 188         GET_KSTATE()->set_memory_allocator(_alloc);
 189
 190         /* res_buffer */
 191         //resources::res_buffer::register_resource();
 192
 193         resources::res_bus *isabus = (resources::res_bus *)rman->new_object("isa");
 194
 195         log.call<delegate<void, const char*> >("print")("\nMemory size: ~");
 196         log.call<delegate<void, const char*> >("print")(itoa(GET_KSTATE()->get_memory_size()/1024/1024 + 1));
 197         log.call<delegate<void, const char*> >("print")(" MB.\n");
 198
 199         log.call<delegate<void, const char*> >("print")("Scanning ISA bus...");
 200         int isadevs = ((resources::isa*)isabus)->scan_bus();
 201
 202         log.call<delegate<void, const char*> >("print")("done. Found ");
 203         log.call<delegate<void, const char*> >("print")(htoa(isadevs));
 204         log.call<delegate<void, const char*> >("print")(" devices.\n\n\n\n");
 205
 206         resources::res_stream *rstr = rman->get_resource<resources::res_stream>("keybscr",0);
 207
 208         resources::res_stream *speak = rman->get_resource<resources::res_stream>("speaker",0);
 209 while(1);
 210         rstr->write_bytes("\nResources: running      \n",26);
 211
 212 //      resources::pio *str = (resources::pio *)rman->new_object(rstr, "pio");
 213
 214 //      str->send_packet((void*)"Hello World!!!",14);
 215
 216         /* Sending orders (experimental) */
 217         resources::resource_order ord("speaker");
 218         ord.set_command("speed");
 219         ord.set_data<int>(3);
 220 //      str->send_order(&ord);
 221
 222         resources::resource_order ord1("speaker");
 223         ord1.set_command("start");
 224         ord1.set_data<bool>(true);
 225         ord1.set_data<delegate<void> >(ablah);
 226         //str->send_order(&ord1);
 227
 228         resources::res_block *flop = rman->get_resource<resources::res_block>("fdc",0);
 229         flop->read_block(19, 1, (void*)0x60000);
 230
 231         rman->new_object((resources::resource*)flop, "fat");
 232
 233         //resources::fat *faa = (resources::fat*)rman->get_resource<resources::res_fs>("fat", "fdc", 0);
 234         resources::resource_id rid("/fdc,0/fat");
 235         resources::fat *faa = (resources::fat*)rid.get_resource();
 236         faa->mount();
 237         faa->load_file("authors", (void*)0x60000);
 238         log.call<delegate<void, const char*> >("print")((const char*)0x60000);
 239
 240         ((modules::simple_mmanager*)modules::simple_mmanager::get_instance())->require("modules_start.ko");
 241
 242 u16 *com1_base_port = (u16*)0x400;
 243                 resources::isa_address com1_addr;
 244                 com1_addr.irq =  4;
 245                 com1_addr.ioport_base = (int)*com1_base_port;
 246                 resources::rs232 *com1 = (resources::rs232*)rman->new_object("rs232");
 247                 com1->init_device(com1_addr);
 248
 249         resources::res_stream *Srstr = rman->get_resource<resources::res_stream>("rs232",0);
 250
 251         Srstr->write_bytes("Starting Quarn OS...",20);
 252
 253         services::tty_logger::register_service();
 254
 255         services::service_shadow tlog("tty_logger");
 256
 257         ((modules::simple_mmanager*)modules::simple_mmanager::get_instance())->require("test.ko");
 258
 259         //GET_ACTORS()->new_actor(ablah);
 260         //GET_ACTORS()->launch();
 261
 262         tlog.call<delegate<void, const char*, services::logger::log_level> >("print")("\ntty logger is running (master)", services::logger::log_warning);
 263         tlog.call<delegate<void, const char*, services::logger::log_level> >("print")("\ntty logger is running (slave)", services::logger::log_info);
 264
 265         /* Testing allocation of memory */
 266         /* This code is a bit pointless but tests all possible circumstances
 267         in which slob will have to allocate_space memory. */
 268
 269         int temp = 1000;
 270         speak->write_dwords(&temp,1);
 271 #endif
 272
 273         while (1) __asm__("hlt");
 274 }
 275
 276
 277