Return to init.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / kernel

Annotation of qemu/roms/SLOF/clients/net-snk/kernel/init.c, revision 1.1.1.1

1.1       root        1: /******************************************************************************
                      2:  * Copyright (c) 2004, 2008 IBM Corporation
                      3:  * All rights reserved.
                      4:  * This program and the accompanying materials
                      5:  * are made available under the terms of the BSD License
                      6:  * which accompanies this distribution, and is available at
                      7:  * http://www.opensource.org/licenses/bsd-license.php
                      8:  *
                      9:  * Contributors:
                     10:  *     IBM Corporation - initial implementation
                     11:  *****************************************************************************/
                     12: 
                     13: #include <of.h>
                     14: #include <pci.h>
                     15: #include <kernel.h>
                     16: #include <stdint.h>
                     17: #include <string.h>
                     18: #include <cpu.h>
                     19: #include <fileio.h>
                     20: #include <stdlib.h> /* malloc */
                     21: #include <ioctl.h> /* ioctl */
                     22: 
                     23: /* Application entry point .*/
                     24: extern int _start(unsigned char *arg_string, long len);
                     25: extern int main(int, char**);
                     26: void * malloc_aligned(size_t size, int align);
                     27: extern snk_module_t *insmod_by_type(int);
                     28: extern void rmmod_by_type(int);
                     29: 
                     30: unsigned long exception_stack_frame;
                     31: 
                     32: snk_fileio_t fd_array[FILEIO_MAX];
                     33: 
                     34: extern uint64_t tb_freq;
                     35: 
                     36: void modules_init(void);
                     37: void modules_term(void);
                     38: int glue_init(snk_kernel_t *, unsigned int *, size_t, size_t);
                     39: void glue_release(void);
                     40: 
                     41: static char save_vector[0x4000];
                     42: extern char _lowmem_start;
                     43: extern char _lowmem_end;
                     44: extern char __client_start;
                     45: extern char __client_end;
                     46: 
                     47: snk_kernel_t snk_kernel_interface = {
                     48:        .version          = 1,
                     49:        .print            = printk,
                     50:        .us_delay         = udelay,
                     51:        .ms_delay         = mdelay,
                     52:        .k_malloc         = malloc,
                     53:        .k_malloc_aligned = malloc_aligned,
                     54:        .k_free           = free,
                     55:        .strcmp           = strcmp,
                     56:        .snk_call         = main,
                     57:        .k_open           = open,
                     58:        .k_close          = close,
                     59:        .k_read           = read,
                     60:        .k_write          = write,
                     61:        .k_ioctl          = ioctl,
                     62:        .modules_remove   = rmmod_by_type,
                     63:        .modules_load     = insmod_by_type,
                     64: };
                     65: 
                     66: void *
                     67: malloc_aligned(size_t size, int align)
                     68: {
                     69:        unsigned long p = (unsigned long) malloc(size + align - 1);
                     70:        p = p + align - 1;
                     71:        p = p & ~(align - 1);
                     72: 
                     73:        return (void *) p;
                     74: }
                     75: 
                     76: static void
                     77: copy_exception_vectors()
                     78: {
                     79:        char *dest;
                     80:        char *src;
                     81:        int len;
                     82: 
                     83:        dest = save_vector;
                     84:        src = (char *) 0x200;
                     85:        len = &_lowmem_end - &_lowmem_start;
                     86:        memcpy(dest, src, len);
                     87: 
                     88:        dest = (char *) 0x200;
                     89:        src = &_lowmem_start;
                     90:        memcpy(dest, src, len);
                     91:        flush_cache(dest, len);
                     92: }
                     93: 
                     94: static void
                     95: restore_exception_vectors()
                     96: {
                     97:        char *dest;
                     98:        char *src;
                     99:        int len;
                    100: 
                    101:        dest = (char *) 0x200;
                    102:        src = save_vector;
                    103:        len = &_lowmem_end - &_lowmem_start;
                    104:        memcpy(dest, src, len);
                    105:        flush_cache(dest, len);
                    106: }
                    107: 
                    108: int
                    109: _start_kernel(unsigned long p0, unsigned long p1)
                    110: {
                    111:        int rc;
                    112:        unsigned int timebase;
                    113: 
                    114:        /* initialize all file descriptor by marking them as empty */
                    115:        for(rc=0; rc<FILEIO_MAX; ++rc) {
                    116:                fd_array[rc].type = FILEIO_TYPE_EMPTY;
                    117:                fd_array[rc].idx  = rc;
                    118:        }
                    119: 
                    120:        /* this is step is e.g. resposible to initialize file descriptor 0 and 1 for STDIO */
                    121:        rc = glue_init(&snk_kernel_interface, &timebase, (size_t)(unsigned long)&__client_start,
                    122:                       (size_t)(unsigned long)&__client_end - (size_t)(unsigned long)&__client_start);
                    123:        if(rc < 0)
                    124:                return -1;
                    125: 
                    126:        tb_freq = (uint64_t) timebase;
                    127:        copy_exception_vectors();
                    128:        modules_init();
                    129:        rc = _start((unsigned char *) p0, p1);
                    130:        modules_term();
                    131:        restore_exception_vectors();
                    132: 
                    133:        glue_release();
                    134:        return rc;
                    135: }
                    136: 
                    137: 
                    138: void
                    139: exception_forward(void)
                    140: {
                    141:        restore_exception_vectors();
                    142:        undo_exception();
                    143: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.