[BACK]Return to boot32.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / acorn32 / stand / boot32

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/acorn32/stand/boot32/boot32.c between version 1.20 and 1.20.4.1

version 1.20, 2005/12/11 12:16:08 version 1.20.4.1, 2006/09/09 02:36:41
Line 14 
Line 14 
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products   * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.   *    derived from this software without specific prior written permission.
  *   *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
Line 49  int debug = 1;
Line 49  int debug = 1;
   
   
 /* constants */  /* constants */
 #define PODRAM_START   (512*1024*1024)                          /* XXX Kinetic cards XXX        */  #define PODRAM_START   (512*1024*1024)          /* XXX Kinetic cards XXX */
   
 #define MAX_RELOCPAGES  4096  #define MAX_RELOCPAGES  4096
   
Line 62  int debug = 1;
Line 62  int debug = 1;
   
   
 /* booter variables */  /* booter variables */
 char     scrap[80], twirl_cnt;                                  /* misc                         */  char     scrap[80], twirl_cnt;          /* misc                         */
 char     booted_file[80];  char     booted_file[80];
   
 struct bootconfig *bconfig;                                     /* bootconfig passing           */  struct bootconfig *bconfig;             /* bootconfig passing           */
 u_long   bconfig_new_phys;                                      /* physical address its bound   */  u_long   bconfig_new_phys;              /* physical address its bound   */
   
 u_int    monitor_type, monitor_sync, ioeb_flags, lcd_flags;     /* computer knowledge           */  /* computer knowledge           */
   u_int    monitor_type, monitor_sync, ioeb_flags, lcd_flags;
 u_int    superio_flags, superio_flags_basic, superio_flags_extra;  u_int    superio_flags, superio_flags_basic, superio_flags_extra;
   
 int      nbpp, memory_table_size, memory_image_size;            /* sizes                        */  /* sizes                        */
 u_long   reloc_tablesize, *reloc_instruction_table;             /* relocate info                */  int      nbpp, memory_table_size, memory_image_size;
 u_long  *reloc_pos;                                             /* current empty entry          */  /* relocate info                */
 int      reloc_entries;                                         /* number of relocations        */  u_long   reloc_tablesize, *reloc_instruction_table;
 int      first_mapped_DRAM_page_index;                          /* offset in RISC OS blob       */  u_long  *reloc_pos;                     /* current empty entry          */
 int      first_mapped_PODRAM_page_index;                        /* offset in RISC OS blob       */  int      reloc_entries;                 /* number of relocations        */
   int      first_mapped_DRAM_page_index;  /* offset in RISC OS blob       */
 struct page_info *mem_pages_info;                               /* {nr, virt, phys}*            */  int      first_mapped_PODRAM_page_index;/* offset in RISC OS blob       */
 struct page_info *free_relocation_page;                         /* points to the page_info chain*/  
 struct page_info *relocate_table_pages;                         /* points to seq. relocate info */  struct page_info *mem_pages_info;       /* {nr, virt, phys}*            */
 struct page_info *relocate_code_page;                           /* points to the copied code    */  struct page_info *free_relocation_page; /* points to the page_info chain*/
 struct page_info *bconfig_page;                                 /* page for passing on settings */  struct page_info *relocate_table_pages; /* points to seq. relocate info */
   struct page_info *relocate_code_page;   /* points to the copied code    */
   struct page_info *bconfig_page;         /* page for passing on settings */
   
 unsigned char *memory_page_types;                               /* packed array of 4 bit typeId */  unsigned char *memory_page_types;       /* packed array of 4 bit typeId */
   
 u_long  *initial_page_tables;                                   /* pagetables to be booted from */  u_long  *initial_page_tables;           /* pagetables to be booted from */
   
   
 /* XXX rename *_BLOCKS to MEM_BLOCKS */  /* XXX rename *_BLOCKS to MEM_BLOCKS */
 /* DRAM/VRAM/ROM/IO info */  /* DRAM/VRAM/ROM/IO info */
 u_long   videomem_start, videomem_pages, display_size;          /* where the display is         */  /* where the display is         */
   u_long   videomem_start, videomem_pages, display_size;
 u_long   pv_offset, top_physdram;                               /* kernel_base - phys. diff     */  
 u_long   top_1Mb_dram;                                          /* the lower mapped top 1Mb     */  
 u_long   new_L1_pages_phys;                                     /* physical address of L1 pages */  
   
 u_long   total_podram_pages, total_dram_pages, total_vram_pages;/* for bootconfig passing       */  u_long   pv_offset, top_physdram;       /* kernel_base - phys. diff     */
 int      dram_blocks, podram_blocks;                            /* number of mem. objects/type  */  u_long   top_1Mb_dram;                  /* the lower mapped top 1Mb     */
   u_long   new_L1_pages_phys;             /* physical address of L1 pages */
   
   /* for bootconfig passing       */
   u_long   total_podram_pages, total_dram_pages, total_vram_pages;
   int      dram_blocks, podram_blocks;    /* number of mem. objects/type  */
 int      vram_blocks, rom_blocks, io_blocks;  int      vram_blocks, rom_blocks, io_blocks;
   
 u_long   DRAM_addr[DRAM_BLOCKS],     DRAM_pages[DRAM_BLOCKS];  u_long   DRAM_addr[DRAM_BLOCKS],     DRAM_pages[DRAM_BLOCKS];
 u_long   PODRAM_addr[PODRAM_BLOCKS], PODRAM_pages[PODRAM_BLOCKS];       /* processor only RAM   */  /* processor only RAM   */
   u_long   PODRAM_addr[PODRAM_BLOCKS], PODRAM_pages[PODRAM_BLOCKS];
 u_long   VRAM_addr[VRAM_BLOCKS],     VRAM_pages[VRAM_BLOCKS];  u_long   VRAM_addr[VRAM_BLOCKS],     VRAM_pages[VRAM_BLOCKS];
 u_long   ROM_addr[ROM_BLOCKS],       ROM_pages[ROM_BLOCKS];  u_long   ROM_addr[ROM_BLOCKS],       ROM_pages[ROM_BLOCKS];
 u_long   IO_addr[IO_BLOCKS],         IO_pages[IO_BLOCKS];  u_long   IO_addr[IO_BLOCKS],         IO_pages[IO_BLOCKS];
   
   
 /* RISC OS memory pages we claimed */  /* RISC OS memory pages we claimed */
 u_long   firstpage, lastpage, totalpages;                       /* RISC OS pagecounters         */  u_long   firstpage, lastpage, totalpages; /* RISC OS pagecounters       */
 char    *memory_image, *bottom_memory, *top_memory;             /* RISC OS memory               */  /* RISC OS memory               */
   char    *memory_image, *bottom_memory, *top_memory;
   
 u_long   videomem_start_ro;                                     /* for debugging mainly         */  u_long   videomem_start_ro;             /* for debugging mainly         */
   
 /* kernel info */  /* kernel info */
 u_long   marks[MARK_MAX];                                       /* loader mark pointers         */  u_long   marks[MARK_MAX];               /* loader mark pointers         */
 u_long   kernel_physical_start;                                 /* where does it get relocated  */  u_long   kernel_physical_start;         /* where does it get relocated  */
 u_long   kernel_free_vm_start;                                  /* where does the free VM start */  u_long   kernel_free_vm_start;          /* where does the free VM start */
 u_long   scratch_virtualbase, scratch_physicalbase;             /* some free space to mess with */  /* some free space to mess with */
   u_long   scratch_virtualbase, scratch_physicalbase;
   
   
 /* bootprogram identifiers */  /* bootprogram identifiers */
Line 140  void  create_configuration(int argc, cha
Line 148  void  create_configuration(int argc, cha
 void     prepare_and_check_relocation_system(void);  void     prepare_and_check_relocation_system(void);
 void     twirl(void);  void     twirl(void);
 int      vdu_var(int);  int      vdu_var(int);
 void     process_args(int argc, char **argv, int *howto, char *file, int *start_args);  void     process_args(int argc, char **argv, int *howto, char *file,
       int *start_args);
   
 char             *sprint0(int width, char prefix, char base, int value);  char             *sprint0(int width, char prefix, char base, int value);
 struct page_info *get_relocated_page(u_long destination, int size);  struct page_info *get_relocated_page(u_long destination, int size);
Line 156  extern void start_kernel(
Line 165  extern void start_kernel(
   
   
 /* the loader itself */  /* the loader itself */
 void init_datastructures(void) {  void
   init_datastructures(void)
   {
   
         /* Get number of pages and the memorytablesize */          /* Get number of pages and the memorytablesize */
         osmemory_read_arrangement_table_size(&memory_table_size, &nbpp);          osmemory_read_arrangement_table_size(&memory_table_size, &nbpp);
   
Line 174  void init_datastructures(void) {
Line 186  void init_datastructures(void) {
         bottom_memory = memory_image;          bottom_memory = memory_image;
         top_memory    = memory_image + memory_image_size;          top_memory    = memory_image + memory_image_size;
   
         firstpage  = ((int) bottom_memory / nbpp) + 1;  /* safety */          firstpage  = ((int)bottom_memory / nbpp) + 1;   /* safety */
         lastpage   = ((int) top_memory    / nbpp) - 1;          lastpage   = ((int)top_memory    / nbpp) - 1;
         totalpages = lastpage - firstpage;          totalpages = lastpage - firstpage;
   
         printf("Allocated %ld memory pages, each of %d kilobytes.\n\n",          printf("Allocated %ld memory pages, each of %d kilobytes.\n\n",
Line 221  void init_datastructures(void) {
Line 233  void init_datastructures(void) {
 }  }
   
   
 void prepare_and_check_relocation_system(void) {  void
   prepare_and_check_relocation_system(void)
   {
         int     relocate_size, relocate_pages;          int     relocate_size, relocate_pages;
         int     bank, pages, found;          int     bank, pages, found;
         u_long  dst, src, base, destination, extend;          u_long  dst, src, base, destination, extend;
Line 242  void prepare_and_check_relocation_system
Line 256  void prepare_and_check_relocation_system
         relocate_table_pages = free_relocation_page;          relocate_table_pages = free_relocation_page;
         pages = 0;          pages = 0;
         while (pages < relocate_pages) {          while (pages < relocate_pages) {
                 src = (u_long) reloc_instruction_table + pages*nbpp;                  src = (u_long)reloc_instruction_table + pages*nbpp;
                 dst = (relocate_table_pages + pages)->logical;                  dst = relocate_table_pages[pages].logical;
                 memcpy((void *) dst, (void *) src, nbpp);                  memcpy((void *)dst, (void *)src, nbpp);
   
                 if (pages < relocate_pages-1) {                  if (pages < relocate_pages - 1) {
                         /* check if next page is sequential physically */                          /* check if next page is sequential physically */
                         if ((relocate_table_pages+pages+1)->physical - (relocate_table_pages+pages)->physical != nbpp) {                          if (relocate_table_pages[pages+1].physical -
                                 /* Non contigunous relocate area -> try again */                              relocate_table_pages[pages].physical != nbpp) {
                                   /*
                                    * Non contigunous relocate area ->
                                    * try again
                                    */
                                 printf("*");                                  printf("*");
                                 relocate_table_pages += pages;                                  relocate_table_pages += pages;
                                   pages = 0;
                                 continue;       /* while */                                  continue;       /* while */
                         };                          }
                 };                  }
                 pages++;                  pages++;
         };          }
         free_relocation_page = relocate_table_pages + pages;          free_relocation_page = relocate_table_pages + pages;
   
         /* copy the relocation code into this page in start_kernel */          /* copy the relocation code into this page in start_kernel */
Line 279  void prepare_and_check_relocation_system
Line 298  void prepare_and_check_relocation_system
                 length      = reloc_entry[2];                  length      = reloc_entry[2];
   
                 /* paranoia check */                  /* paranoia check */
                 if ((long) (src - last_src) <= 0) printf("relocation sequence challenged -- booting might fail ");                  if ((long) (src - last_src) <= 0)
                           printf("relocation sequence challenged -- "
                               "booting might fail ");
                 last_src = src;                  last_src = src;
   
                 /* check if its gonna be relocated into (PO)DRAM ! */                  /* check if its gonna be relocated into (PO)DRAM ! */
Line 287  void prepare_and_check_relocation_system
Line 308  void prepare_and_check_relocation_system
                 found = 0;                  found = 0;
                 for (bank = 0; (bank < dram_blocks) && !found; bank++) {                  for (bank = 0; (bank < dram_blocks) && !found; bank++) {
                         base   = DRAM_addr[bank];                          base   = DRAM_addr[bank];
                         found = (destination >= base) && (extend <= base + DRAM_pages[bank]*nbpp);                          found = (destination >= base) &&
                 };                              (extend <= base + DRAM_pages[bank]*nbpp);
                   }
                 for (bank = 0; (bank < podram_blocks) && !found; bank++) {                  for (bank = 0; (bank < podram_blocks) && !found; bank++) {
                         base = PODRAM_addr[bank];                          base = PODRAM_addr[bank];
                         found = (destination >= base) && (extend <= base + PODRAM_pages[bank]*nbpp);                          found = (destination >= base) &&
                 };                              (extend <= base + PODRAM_pages[bank]*nbpp);
                   }
                 if (!found || (extend > top_physdram)) {                  if (!found || (extend > top_physdram)) {
                         panic( "Internal error: relocating range [%lx +%lx => %lx] outside (PO)DRAM banks!",                          panic("Internal error: relocating range "
                                 src, length, destination                              "[%lx +%lx => %lx] outside (PO)DRAM banks!",
                         );                              src, length, destination);
                 };                  }
   
                 reloc_entry+=3;                  reloc_entry += 3;
         };          }
         if (reloc_entry != reloc_pos) panic("Relocation instruction table is corrupted");          if (reloc_entry != reloc_pos)
                   panic("Relocation instruction table is corrupted");
   
         printf("OK!\n");          printf("OK!\n");
 }  }
   
   
 void get_memory_configuration(void) {  void
   get_memory_configuration(void)
   {
         int loop, current_page_type, page_count, phys_page;          int loop, current_page_type, page_count, phys_page;
         int page, count, bank, top_bank, video_bank;          int page, count, bank, top_bank, video_bank;
         int mapped_screen_memory;          int mapped_screen_memory;
Line 319  void get_memory_configuration(void) {
Line 345  void get_memory_configuration(void) {
         osmemory_read_arrangement_table(memory_page_types);          osmemory_read_arrangement_table(memory_page_types);
   
         /* init counters */          /* init counters */
         bank = vram_blocks = dram_blocks = rom_blocks = io_blocks = podram_blocks = 0;          bank = vram_blocks = dram_blocks = rom_blocks = io_blocks =
               podram_blocks = 0;
   
         current_page_type = -1;          current_page_type = -1;
         phys_page = 0;                  /* physical address in pages    */          phys_page = 0;                  /* physical address in pages    */
Line 328  void get_memory_configuration(void) {
Line 355  void get_memory_configuration(void) {
   
         /* iterating over a packed array of 2 page types/byte i.e. 8 kb/byte */          /* iterating over a packed array of 2 page types/byte i.e. 8 kb/byte */
         while (loop < 2*memory_table_size) {          while (loop < 2*memory_table_size) {
                 page = (memory_page_types[loop / 2]);   /* read twice              */                  page = memory_page_types[loop / 2];     /* read twice */
                 if (loop & 1) page >>= 4;               /* take other nibble       */                  if (loop & 1) page >>= 4;               /* take other nibble */
   
                 /* bits 0-2 give type, bit3 means the bit page is allocatable      */                  /*
                 page &= 0x7;                            /* only take bottom 3 bits */                   * bits 0-2 give type, bit3 means the bit page is
                    * allocatable
                    */
                   page &= 0x7;                    /* only take bottom 3 bits */
                 if (page != current_page_type) {                  if (page != current_page_type) {
                         /* passed a boundary ... note this block                   */                          /* passed a boundary ... note this block           */
                         /* splitting in different vars is for compatability reasons*/                          /*
                            * splitting in different vars is for
                            * compatability reasons
                            */
                         switch (current_page_type) {                          switch (current_page_type) {
                                 case -1 :                          case -1:
                                 case  0 :                          case  0:
                                         break;                                  break;
                                 case osmemory_TYPE_DRAM :                          case osmemory_TYPE_DRAM:
                                         if (phys_page < PODRAM_START) {                                  if (phys_page < PODRAM_START) {
                                                 DRAM_addr[dram_blocks]  = phys_page * nbpp;                                          DRAM_addr[dram_blocks]  =
                                                 DRAM_pages[dram_blocks] = page_count;                                              phys_page * nbpp;
                                                 dram_blocks++;                                          DRAM_pages[dram_blocks] =
                                         } else {                                              page_count;
                                                 PODRAM_addr[podram_blocks]  = phys_page * nbpp;                                          dram_blocks++;
                                                 PODRAM_pages[podram_blocks] = page_count;                                  } else {
                                                 podram_blocks++;                                          PODRAM_addr[podram_blocks]  =
                                         };                                              phys_page * nbpp;
                                         break;                                          PODRAM_pages[podram_blocks] =
                                 case osmemory_TYPE_VRAM :                                              page_count;
                                         VRAM_addr[vram_blocks]  = phys_page * nbpp;                                          podram_blocks++;
                                         VRAM_pages[vram_blocks] = page_count;                                  }
                                         vram_blocks++;                                  break;
                                         break;                          case osmemory_TYPE_VRAM:
                                 case osmemory_TYPE_ROM :                                  VRAM_addr[vram_blocks]  = phys_page * nbpp;
                                         ROM_addr[rom_blocks]  = phys_page * nbpp;                                  VRAM_pages[vram_blocks] = page_count;
                                         ROM_pages[rom_blocks] = page_count;                                  vram_blocks++;
                                         rom_blocks++;                                  break;
                                         break;                          case osmemory_TYPE_ROM:
                                 case osmemory_TYPE_IO :                                  ROM_addr[rom_blocks]  = phys_page * nbpp;
                                         IO_addr[io_blocks]  = phys_page * nbpp;                                  ROM_pages[rom_blocks] = page_count;
                                         IO_pages[io_blocks] = page_count;                                  rom_blocks++;
                                         io_blocks++;                                  break;
                                         break;                          case osmemory_TYPE_IO:
                                 default :                                  IO_addr[io_blocks]  = phys_page * nbpp;
                                         printf("WARNING : found unknown memory object %d ", current_page_type);                                  IO_pages[io_blocks] = page_count;
                                         printf(" at 0x%s", sprint0(8,'0','x', phys_page * nbpp));                                  io_blocks++;
                                         printf(" for %s k\n", sprint0(5,' ','d', (page_count*nbpp)>>10));                                  break;
                                         break;                          default:
                         };                                  printf("WARNING : found unknown "
                                       "memory object %d ", current_page_type);
                                   printf(" at 0x%s",
                                       sprint0(8,'0','x', phys_page * nbpp));
                                   printf(" for %s k\n",
                                       sprint0(5,' ','d', (page_count*nbpp)>>10));
                                   break;
                           }
                         current_page_type = page;                          current_page_type = page;
                         phys_page = loop;                          phys_page = loop;
                         page_count = 0;                          page_count = 0;
                 };                  }
                 /* smallest unit we recognise is one page ... silly could be upto 64 pages i.e. 256 kb */                  /*
                    * smallest unit we recognise is one page ... silly
                    * could be upto 64 pages i.e. 256 kb
                    */
                 page_count += 1;                  page_count += 1;
                 loop       += 1;                  loop       += 1;
                 if ((loop & 31) == 0) twirl();                  if ((loop & 31) == 0) twirl();
         };          }
   
         printf(" \n\n");          printf(" \n\n");
   
         if (VRAM_pages[0] == 0) {          if (VRAM_pages[0] == 0) {
                 /* map DRAM as video memory */                  /* map DRAM as video memory */
                 display_size     = (vdu_var(os_VDUVAR_TOTAL_SCREEN_SIZE) & ~(nbpp-1));                  display_size     =
                       vdu_var(os_VDUVAR_TOTAL_SCREEN_SIZE) & ~(nbpp-1);
 #if 0  #if 0
                 mapped_screen_memory = 1024 * 1024;             /* max allowed on RiscPC        */                  mapped_screen_memory = 1024 * 1024; /* max allowed on RiscPC */
                 videomem_pages   = (mapped_screen_memory / nbpp);                  videomem_pages   = (mapped_screen_memory / nbpp);
                 videomem_start   = DRAM_addr[0];                  videomem_start   = DRAM_addr[0];
                 DRAM_addr[0]    += videomem_pages * nbpp;                  DRAM_addr[0]    += videomem_pages * nbpp;
                 DRAM_pages[0]   -= videomem_pages;                  DRAM_pages[0]   -= videomem_pages;
 #else  #else
                 mapped_screen_memory = display_size;                  mapped_screen_memory = display_size;
                 videomem_pages   = (mapped_screen_memory / nbpp);                  videomem_pages   = mapped_screen_memory / nbpp;
                 one_mb_pages     = (1024*1024)/nbpp;                  one_mb_pages     = (1024*1024)/nbpp;
   
                 /*                  /*
Line 410  void get_memory_configuration(void) {
Line 454  void get_memory_configuration(void) {
                 if (DRAM_pages[top_bank] == one_mb_pages) video_bank--;                  if (DRAM_pages[top_bank] == one_mb_pages) video_bank--;
   
                 if (DRAM_pages[video_bank] < videomem_pages)                  if (DRAM_pages[video_bank] < videomem_pages)
                         panic("Weird memory configuration found; please contact acorn32 portmaster.");                          panic("Weird memory configuration found; please "
                               "contact acorn32 portmaster.");
   
                 /* split off the top 1Mb */                  /* split off the top 1Mb */
                 DRAM_addr [top_bank+1]  = DRAM_addr[top_bank] + (DRAM_pages[top_bank] - one_mb_pages)*nbpp;                  DRAM_addr [top_bank+1]  = DRAM_addr[top_bank] +
                       (DRAM_pages[top_bank] - one_mb_pages)*nbpp;
                 DRAM_pages[top_bank+1]  = one_mb_pages;                  DRAM_pages[top_bank+1]  = one_mb_pages;
                 DRAM_pages[top_bank  ] -= one_mb_pages;                  DRAM_pages[top_bank  ] -= one_mb_pages;
                 dram_blocks++;                  dram_blocks++;
   
                 /* Map video memory at the end of the choosen DIMM */                  /* Map video memory at the end of the choosen DIMM */
                 videomem_start          = DRAM_addr[video_bank] + (DRAM_pages[video_bank] - videomem_pages)*nbpp;                  videomem_start          = DRAM_addr[video_bank] +
                       (DRAM_pages[video_bank] - videomem_pages)*nbpp;
                 DRAM_pages[video_bank] -= videomem_pages;                  DRAM_pages[video_bank] -= videomem_pages;
   
                 /* sanity */                  /* sanity */
Line 427  void get_memory_configuration(void) {
Line 474  void get_memory_configuration(void) {
                         DRAM_addr [top_bank] = DRAM_addr [top_bank+1];                          DRAM_addr [top_bank] = DRAM_addr [top_bank+1];
                         DRAM_pages[top_bank] = DRAM_pages[top_bank+1];                          DRAM_pages[top_bank] = DRAM_pages[top_bank+1];
                         dram_blocks--;                          dram_blocks--;
                 };                  }
 #endif  #endif
         } else {          } else {
                 /* use VRAM */                  /* use VRAM */
Line 435  void get_memory_configuration(void) {
Line 482  void get_memory_configuration(void) {
                 videomem_start   = VRAM_addr[0];                  videomem_start   = VRAM_addr[0];
                 videomem_pages   = VRAM_pages[0];                  videomem_pages   = VRAM_pages[0];
                 display_size     = videomem_pages * nbpp;                  display_size     = videomem_pages * nbpp;
         };          }
   
         if (mapped_screen_memory) {          if (mapped_screen_memory) {
                 printf("Used %d kb DRAM ", (mapped_screen_memory)/1024);                  printf("Used %d kb DRAM ", mapped_screen_memory / 1024);
                 printf("at 0x%s for video memory\n", sprint0(8,'0','x', videomem_start));                  printf("at 0x%s for video memory\n",
         };                      sprint0(8,'0','x', videomem_start));
           }
   
         /* find top of (PO)DRAM pages */          /* find top of (PO)DRAM pages */
         top_physdram = 0;          top_physdram = 0;
         for (loop = 0; loop < podram_blocks; loop++) {          for (loop = 0; loop < podram_blocks; loop++) {
                 top = PODRAM_addr[loop] + PODRAM_pages[loop]*nbpp;                  top = PODRAM_addr[loop] + PODRAM_pages[loop]*nbpp;
                 if (top > top_physdram) top_physdram = top;                  if (top > top_physdram) top_physdram = top;
         };          }
         for (loop = 0; loop < dram_blocks; loop++) {          for (loop = 0; loop < dram_blocks; loop++) {
                 top = DRAM_addr[loop] + DRAM_pages[loop]*nbpp;                  top = DRAM_addr[loop] + DRAM_pages[loop]*nbpp;
                 if (top > top_physdram) top_physdram = top;                  if (top > top_physdram) top_physdram = top;
         };          }
         if (top_physdram == 0) panic("reality check: No DRAM in this machine?");          if (top_physdram == 0)
                   panic("reality check: No DRAM in this machine?");
         if (((top_physdram >> 20) << 20) != top_physdram)          if (((top_physdram >> 20) << 20) != top_physdram)
                 panic("Top is not not aligned on a Mb; remove very small DIMMS?");                  panic("Top is not not aligned on a Mb; "
                       "remove very small DIMMS?");
   
         videomem_start_ro = vdu_var(os_VDUVAR_DISPLAY_START);          videomem_start_ro = vdu_var(os_VDUVAR_DISPLAY_START);
   
Line 462  void get_memory_configuration(void) {
Line 512  void get_memory_configuration(void) {
         for (count = 0; count < rom_blocks; count++) {          for (count = 0; count < rom_blocks; count++) {
                 printf("Found ROM  (%d)", count);                  printf("Found ROM  (%d)", count);
                 printf(" at 0x%s", sprint0(8,'0','x', ROM_addr[count]));                  printf(" at 0x%s", sprint0(8,'0','x', ROM_addr[count]));
                 printf(" for %s k\n", sprint0(5,' ','d', (ROM_pages[count]*nbpp)>>10));                  printf(" for %s k\n",
         };                      sprint0(5,' ','d', (ROM_pages[count]*nbpp)>>10));
           }
   
         for (count = 0; count < io_blocks; count++) {          for (count = 0; count < io_blocks; count++) {
                 printf("Found I/O  (%d)", count);                  printf("Found I/O  (%d)", count);
                 printf(" at 0x%s", sprint0(8,'0','x', IO_addr[count]));                  printf(" at 0x%s", sprint0(8,'0','x', IO_addr[count]));
                 printf(" for %s k\n", sprint0(5,' ','d', (IO_pages[count]*nbpp)>>10));                  printf(" for %s k\n",
         };                      sprint0(5,' ','d', (IO_pages[count]*nbpp)>>10));
           }
   
         /* for DRAM/VRAM also count the number of pages */          /* for DRAM/VRAM also count the number of pages */
         total_dram_pages = 0;          total_dram_pages = 0;
Line 477  void get_memory_configuration(void) {
Line 529  void get_memory_configuration(void) {
                 total_dram_pages += DRAM_pages[count];                  total_dram_pages += DRAM_pages[count];
                 printf("Found DRAM (%d)", count);                  printf("Found DRAM (%d)", count);
                 printf(" at 0x%s", sprint0(8,'0','x', DRAM_addr[count]));                  printf(" at 0x%s", sprint0(8,'0','x', DRAM_addr[count]));
                 printf(" for %s k\n", sprint0(5,' ','d', (DRAM_pages[count]*nbpp)>>10));                  printf(" for %s k\n",
         };                      sprint0(5,' ','d', (DRAM_pages[count]*nbpp)>>10));
           }
   
         total_vram_pages = 0;          total_vram_pages = 0;
         for (count = 0; count < vram_blocks; count++) {          for (count = 0; count < vram_blocks; count++) {
                 total_vram_pages += VRAM_pages[count];                  total_vram_pages += VRAM_pages[count];
                 printf("Found VRAM (%d)", count);                  printf("Found VRAM (%d)", count);
                 printf(" at 0x%s", sprint0(8,'0','x', VRAM_addr[count]));                  printf(" at 0x%s", sprint0(8,'0','x', VRAM_addr[count]));
                 printf(" for %s k\n", sprint0(5,' ','d', (VRAM_pages[count]*nbpp)>>10));                  printf(" for %s k\n",
         };                      sprint0(5,' ','d', (VRAM_pages[count]*nbpp)>>10));
           }
   
         total_podram_pages = 0;          total_podram_pages = 0;
         for (count = 0; count < podram_blocks; count++) {          for (count = 0; count < podram_blocks; count++) {
                 total_podram_pages += PODRAM_pages[count];                  total_podram_pages += PODRAM_pages[count];
                 printf("Found Processor only (S)DRAM (%d)", count);                  printf("Found Processor only (S)DRAM (%d)", count);
                 printf(" at 0x%s", sprint0(8,'0','x', PODRAM_addr[count]));                  printf(" at 0x%s", sprint0(8,'0','x', PODRAM_addr[count]));
                 printf(" for %s k\n", sprint0(5,' ','d', (PODRAM_pages[count]*nbpp)>>10));                  printf(" for %s k\n",
         };                      sprint0(5,' ','d', (PODRAM_pages[count]*nbpp)>>10));
           }
 }  }
   
   
 void get_memory_map(void) {  void
   get_memory_map(void)
   {
         struct page_info *page_info;          struct page_info *page_info;
         int     page, inout;          int     page, inout;
         int     phys_addr;          int     phys_addr;
   
         printf("\nGetting actual memorymapping");          printf("\nGetting actual memorymapping");
         for (page = 0, page_info = mem_pages_info; page < totalpages; page++, page_info++) {          for (page = 0, page_info = mem_pages_info;
                page < totalpages;
                page++, page_info++) {
                 page_info->pagenumber = 0;      /* not used */                  page_info->pagenumber = 0;      /* not used */
                 page_info->logical    = (firstpage + page) * nbpp;                  page_info->logical    = (firstpage + page) * nbpp;
                 page_info->physical   = 0;      /* result comes here */                  page_info->physical   = 0;      /* result comes here */
                 /* to avoid triggering a `bug' in RISC OS 4, page it in */                  /* to avoid triggering a `bug' in RISC OS 4, page it in */
                 *((int *) page_info->logical) = 0;                  *((int *)page_info->logical) = 0;
         };          }
         /* close list */          /* close list */
         page_info->pagenumber = -1;          page_info->pagenumber = -1;
   
         inout = osmemory_GIVEN_LOG_ADDR | osmemory_RETURN_PAGE_NO | osmemory_RETURN_PHYS_ADDR;          inout = osmemory_GIVEN_LOG_ADDR | osmemory_RETURN_PAGE_NO |
               osmemory_RETURN_PHYS_ADDR;
         osmemory_page_op(inout, mem_pages_info, totalpages);          osmemory_page_op(inout, mem_pages_info, totalpages);
   
         printf(" ; sorting ");          printf(" ; sorting ");
Line 522  void get_memory_map(void) {
Line 582  void get_memory_map(void) {
             &page_info_cmp);              &page_info_cmp);
         printf(".\n");          printf(".\n");
   
         /* get the first DRAM index and show the physical memory fragments we got */          /*
            * get the first DRAM index and show the physical memory
            * fragments we got
            */
         printf("\nFound physical memory blocks :\n");          printf("\nFound physical memory blocks :\n");
         first_mapped_DRAM_page_index = -1;          first_mapped_DRAM_page_index = -1;
         first_mapped_PODRAM_page_index = -1;          first_mapped_PODRAM_page_index = -1;
Line 530  void get_memory_map(void) {
Line 593  void get_memory_map(void) {
                 phys_addr = mem_pages_info[page].physical;                  phys_addr = mem_pages_info[page].physical;
                 printf("[0x%x", phys_addr);                  printf("[0x%x", phys_addr);
                 while (mem_pages_info[page+1].physical - phys_addr == nbpp) {                  while (mem_pages_info[page+1].physical - phys_addr == nbpp) {
                         if ((first_mapped_DRAM_page_index<0) && (phys_addr >= DRAM_addr[0])) {                          if (first_mapped_DRAM_page_index < 0 &&
                               phys_addr >= DRAM_addr[0])
                                 first_mapped_DRAM_page_index = page;                                  first_mapped_DRAM_page_index = page;
                         };                          if (first_mapped_PODRAM_page_index < 0 &&
                         if ((first_mapped_PODRAM_page_index<0) && (phys_addr >= PODRAM_addr[0])) {                              phys_addr >= PODRAM_addr[0])
                                 first_mapped_PODRAM_page_index = page;                                  first_mapped_PODRAM_page_index = page;
                         };  
                         page++;                          page++;
                         phys_addr = mem_pages_info[page].physical;                          phys_addr = mem_pages_info[page].physical;
                 };                  }
                 printf("-0x%x]  ", (phys_addr + nbpp -1));                  printf("-0x%x]  ", phys_addr + nbpp -1);
         };          }
         printf("\n\n");          printf("\n\n");
         if (first_mapped_PODRAM_page_index < 0) {          if (first_mapped_PODRAM_page_index < 0 && PODRAM_addr[0])
                 if (PODRAM_addr[0]) panic("Found no (S)DRAM mapped in the bootloader");                  panic("Found no (S)DRAM mapped in the bootloader");
         };          if (first_mapped_DRAM_page_index < 0)
         if (first_mapped_DRAM_page_index < 0) panic("No DRAM mapped in the bootloader");                  panic("No DRAM mapped in the bootloader");
 }  }
   
   
 void create_initial_page_tables(void) {  void
   create_initial_page_tables(void)
   {
         u_long page, section, addr, kpage;          u_long page, section, addr, kpage;
   
         /* mark a section by the following bits and domain 0, AP=01, CB=0 */          /* mark a section by the following bits and domain 0, AP=01, CB=0 */
         /*         A         P         C        B        section                 domain         */          /*         A         P         C        B        section
         section = (0<<11) | (1<<10) | (0<<3) | (0<<2) | (1<<4) | (1<<1) | (0) | (0 << 5);                     domain               */
           section = (0<<11) | (1<<10) | (0<<3) | (0<<2) | (1<<4) | (1<<1) |
               (0) | (0 << 5);
   
         /* first of all a full 1:1 mapping */          /* first of all a full 1:1 mapping */
         for (page = 0; page < 4*1024; page++) {          for (page = 0; page < 4*1024; page++)
                 initial_page_tables[page] = (page<<20) | section;                  initial_page_tables[page] = (page<<20) | section;
         };  
   
         /* video memory is mapped 1:1 in the DRAM section or in VRAM section    */  
   
         /* map 1Mb from top of DRAM memory to bottom 1Mb of virtual memmap      */          /*
            * video memory is mapped 1:1 in the DRAM section or in VRAM
            * section
            *
            * map 1Mb from top of DRAM memory to bottom 1Mb of virtual memmap
            */
         top_1Mb_dram = (((top_physdram - 1024*1024) >> 20) << 20);          top_1Mb_dram = (((top_physdram - 1024*1024) >> 20) << 20);
   
         initial_page_tables[0] = top_1Mb_dram | section;          initial_page_tables[0] = top_1Mb_dram | section;
   
         /* map 16 Mb of kernel space to KERNEL_BASE i.e. marks[KERNEL_START]    */          /*
            * map 16 Mb of kernel space to KERNEL_BASE
            * i.e. marks[KERNEL_START]
            */
         for (page = 0; page < 16; page++) {          for (page = 0; page < 16; page++) {
                 addr  = (kernel_physical_start >> 20) + page;                  addr  = (kernel_physical_start >> 20) + page;
                 kpage = (marks[MARK_START]     >> 20) + page;                  kpage = (marks[MARK_START]     >> 20) + page;
                 initial_page_tables[kpage] = (addr << 20) | section;                  initial_page_tables[kpage] = (addr << 20) | section;
         };          }
 }  }
   
   
 void add_pagetables_at_top(void) {  void
   add_pagetables_at_top(void)
   {
         int page;          int page;
         u_long src, dst, fragaddr;          u_long src, dst, fragaddr;
   
         /* Special : destination must be on a 16 Kb boundary                    */          /* Special : destination must be on a 16 Kb boundary */
         /* get 4 pages on the top of the physical memory and copy PT's in it    */          /* get 4 pages on the top of the physical memory and copy PT's in it */
         new_L1_pages_phys = top_physdram - 4*nbpp;          new_L1_pages_phys = top_physdram - 4 * nbpp;
   
         /* If the L1 page tables are not 16 kb aligned, adjust base until it is */          /*
         while (new_L1_pages_phys & (16*1024-1)) {           * If the L1 page tables are not 16 kb aligned, adjust base
            * until it is
            */
           while (new_L1_pages_phys & (16*1024-1))
                 new_L1_pages_phys -= nbpp;                  new_L1_pages_phys -= nbpp;
         };          if (new_L1_pages_phys & (16*1024-1))
         if (new_L1_pages_phys & (16*1024-1)) panic("Paranoia : L1 pages not on 16Kb boundary");                  panic("Paranoia : L1 pages not on 16Kb boundary");
   
         dst = new_L1_pages_phys;          dst = new_L1_pages_phys;
         src = (u_long) initial_page_tables;          src = (u_long)initial_page_tables;
   
         for (page = 0; page < 4; page++) {          for (page = 0; page < 4; page++) {
                 /* get a page for a fragment */                  /* get a page for a fragment */
                 fragaddr = get_relocated_page(dst, nbpp)->logical;                  fragaddr = get_relocated_page(dst, nbpp)->logical;
                 memcpy((void *) fragaddr, (void *) src, nbpp);                  memcpy((void *)fragaddr, (void *)src, nbpp);
   
                 src += nbpp;                  src += nbpp;
                 dst += nbpp;                  dst += nbpp;
         };          }
 }  }
   
   
 void add_initvectors(void) {  void
   add_initvectors(void)
   {
         u_long *pos;          u_long *pos;
         u_long  vectoraddr, count;          u_long  vectoraddr, count;
   
Line 613  void add_initvectors(void) {
Line 692  void add_initvectors(void) {
         vectoraddr = get_relocated_page(top_1Mb_dram, nbpp)->logical;          vectoraddr = get_relocated_page(top_1Mb_dram, nbpp)->logical;
   
         /* fill the vectors with `movs pc, lr' opcodes */          /* fill the vectors with `movs pc, lr' opcodes */
         pos = (u_long *) vectoraddr; memset(pos, 0, nbpp);          pos = (u_long *)vectoraddr; memset(pos, 0, nbpp);
         for (count = 0; count < 128; count++) *pos++ = 0xE1B0F00E;          for (count = 0; count < 128; count++) *pos++ = 0xE1B0F00E;
 }  }
   
   /*
    * Work out the display's vertical sync rate.  One might hope that there
    * would be a simpler way than by counting vsync interrupts for a second,
    * but if there is, I can't find it.
    */
   static int
   vsync_rate(void)
   {
           uint8_t count0;
           unsigned int time0;
   
           count0 = osbyte_read(osbyte_VAR_VSYNC_TIMER);
           time0 = os_read_monotonic_time();
           while (os_read_monotonic_time() - time0 < 100)
                   continue;
           return (u_int8_t)(count0 - osbyte_read(osbyte_VAR_VSYNC_TIMER));
   }
   
 void create_configuration(int argc, char **argv, int start_args) {  void
   create_configuration(int argc, char **argv, int start_args)
   {
         int   i, root_specified, id_low, id_high;          int   i, root_specified, id_low, id_high;
         char *pos;          char *pos;
   
         bconfig_new_phys = kernel_free_vm_start - pv_offset;          bconfig_new_phys = kernel_free_vm_start - pv_offset;
         bconfig_page = get_relocated_page(bconfig_new_phys, nbpp);          bconfig_page = get_relocated_page(bconfig_new_phys, nbpp);
         bconfig = (struct bootconfig *) (bconfig_page->logical);          bconfig = (struct bootconfig *)(bconfig_page->logical);
         kernel_free_vm_start += nbpp;          kernel_free_vm_start += nbpp;
   
         /* get some miscelanious info for the bootblock */          /* get some miscelanious info for the bootblock */
         os_readsysinfo_monitor_info(NULL, &monitor_type, &monitor_sync);          os_readsysinfo_monitor_info(NULL, (int *)&monitor_type, (int *)&monitor_sync);
         os_readsysinfo_chip_presence(&ioeb_flags, &superio_flags, &lcd_flags);          os_readsysinfo_chip_presence((int *)&ioeb_flags, (int *)&superio_flags, (int *)&lcd_flags);
         os_readsysinfo_superio_features(&superio_flags_basic, &superio_flags_extra);          os_readsysinfo_superio_features((int *)&superio_flags_basic,
               (int *)&superio_flags_extra);
         os_readsysinfo_unique_id(&id_low, &id_high);          os_readsysinfo_unique_id(&id_low, &id_high);
   
         /* fill in the bootconfig *bconfig structure : generic version II */          /* fill in the bootconfig *bconfig structure : generic version II */
Line 639  void create_configuration(int argc, char
Line 738  void create_configuration(int argc, char
         bconfig->version        = BOOTCONFIG_VERSION;          bconfig->version        = BOOTCONFIG_VERSION;
         strcpy(bconfig->kernelname, booted_file);          strcpy(bconfig->kernelname, booted_file);
   
         /* get the kernel base name and update the RiscOS name to a Unix name */          /*
            * get the kernel base name and update the RiscOS name to a
            * Unix name
            */
         i = strlen(booted_file);          i = strlen(booted_file);
         while ((i >= 0) && (booted_file[i] != '.')) i--;          while (i >= 0 && booted_file[i] != '.') i--;
         if (i) {          if (i) {
                 strcpy(bconfig->kernelname, "/");                  strcpy(bconfig->kernelname, "/");
                 strcat(bconfig->kernelname, booted_file+i+1);                  strcat(bconfig->kernelname, booted_file+i+1);
         };          }
   
         pos = bconfig->kernelname+1;          pos = bconfig->kernelname+1;
         while (*pos) {          while (*pos) {
                 if (*pos == '/') *pos = '.';                  if (*pos == '/') *pos = '.';
                 pos++;                  pos++;
         };          }
   
         /* set the machine_id */          /* set the machine_id */
         memcpy(&(bconfig->machine_id), &id_low, 4);          memcpy(&(bconfig->machine_id), &id_low, 4);
Line 662  void create_configuration(int argc, char
Line 764  void create_configuration(int argc, char
         for (i = start_args; i < argc; i++) {          for (i = start_args; i < argc; i++) {
                 if (strncmp(argv[i], "root=",5) ==0) root_specified = 1;                  if (strncmp(argv[i], "root=",5) ==0) root_specified = 1;
                 strcat(bconfig->args, argv[i]);                  strcat(bconfig->args, argv[i]);
         };          }
         if (!root_specified) {          if (!root_specified) {
                 strcat(bconfig->args, "root=");                  strcat(bconfig->args, "root=");
                 strcat(bconfig->args, DEFAULT_ROOT);                  strcat(bconfig->args, DEFAULT_ROOT);
         };          }
   
         /* mark kernel pointers */          /* mark kernel pointers */
         bconfig->kernvirtualbase        = marks[MARK_START];          bconfig->kernvirtualbase        = marks[MARK_START];
         bconfig->kernphysicalbase       = kernel_physical_start;          bconfig->kernphysicalbase       = kernel_physical_start;
         bconfig->kernsize               = kernel_free_vm_start - marks[MARK_START];          bconfig->kernsize               = kernel_free_vm_start -
                                               marks[MARK_START];
         bconfig->ksym_start             = marks[MARK_SYM];          bconfig->ksym_start             = marks[MARK_SYM];
         bconfig->ksym_end               = marks[MARK_SYM] + marks[MARK_NSYM];          bconfig->ksym_end               = marks[MARK_SYM] + marks[MARK_NSYM];
   
Line 682  void create_configuration(int argc, char
Line 785  void create_configuration(int argc, char
         bconfig->width                  = vdu_var(os_MODEVAR_XWIND_LIMIT);          bconfig->width                  = vdu_var(os_MODEVAR_XWIND_LIMIT);
         bconfig->height                 = vdu_var(os_MODEVAR_YWIND_LIMIT);          bconfig->height                 = vdu_var(os_MODEVAR_YWIND_LIMIT);
         bconfig->log2_bpp               = vdu_var(os_MODEVAR_LOG2_BPP);          bconfig->log2_bpp               = vdu_var(os_MODEVAR_LOG2_BPP);
         bconfig->framerate              = 56;           /* XXX why? better guessing possible? XXX */          bconfig->framerate              = vsync_rate();
   
         /* fill in memory info */          /* fill in memory info */
         bconfig->pagesize               = nbpp;          bconfig->pagesize               = nbpp;
         bconfig->drampages              = total_dram_pages + total_podram_pages;        /* XXX */          bconfig->drampages              = total_dram_pages +
                                               total_podram_pages; /* XXX */
         bconfig->vrampages              = total_vram_pages;          bconfig->vrampages              = total_vram_pages;
         bconfig->dramblocks             = dram_blocks + podram_blocks;                  /* XXX */          bconfig->dramblocks             = dram_blocks + podram_blocks; /*XXX*/
         bconfig->vramblocks             = vram_blocks;          bconfig->vramblocks             = vram_blocks;
   
         for (i = 0; i < dram_blocks; i++) {          for (i = 0; i < dram_blocks; i++) {
                 bconfig->dram[i].address = DRAM_addr[i];                  bconfig->dram[i].address = DRAM_addr[i];
                 bconfig->dram[i].pages   = DRAM_pages[i];                  bconfig->dram[i].pages   = DRAM_pages[i];
                 bconfig->dram[i].flags   = PHYSMEM_TYPE_GENERIC;                  bconfig->dram[i].flags   = PHYSMEM_TYPE_GENERIC;
         };          }
         for (; i < dram_blocks + podram_blocks; i++) {          for (; i < dram_blocks + podram_blocks; i++) {
                 bconfig->dram[i].address = PODRAM_addr[i];                  bconfig->dram[i].address = PODRAM_addr[i];
                 bconfig->dram[i].pages   = PODRAM_pages[i];                  bconfig->dram[i].pages   = PODRAM_pages[i];
                 bconfig->dram[i].flags   = PHYSMEM_TYPE_PROCESSOR_ONLY;                  bconfig->dram[i].flags   = PHYSMEM_TYPE_PROCESSOR_ONLY;
         };          }
         for (i = 0; i < vram_blocks; i++) {          for (i = 0; i < vram_blocks; i++) {
                 bconfig->vram[i].address = VRAM_addr[i];                  bconfig->vram[i].address = VRAM_addr[i];
                 bconfig->vram[i].pages   = VRAM_pages[i];                  bconfig->vram[i].pages   = VRAM_pages[i];
                 bconfig->vram[i].flags   = PHYSMEM_TYPE_GENERIC;                  bconfig->vram[i].flags   = PHYSMEM_TYPE_GENERIC;
         };          }
 }  }
   
   
 int main(int argc, char **argv) {  int
   main(int argc, char **argv)
   {
         int howto, start_args, ret;          int howto, start_args, ret;
   
         printf("\n\n");          printf("\n\n");
Line 726  int main(int argc, char **argv) {
Line 832  int main(int argc, char **argv) {
         get_memory_configuration();          get_memory_configuration();
         get_memory_map();          get_memory_map();
   
         /* point to the first free DRAM page guaranteed to be in strict order up */          /*
         if (first_mapped_PODRAM_page_index) {           * point to the first free DRAM page guaranteed to be in
                 free_relocation_page = mem_pages_info + first_mapped_PODRAM_page_index;           * strict order up
            */
           if (podram_blocks != 0) {
                   free_relocation_page =
                       mem_pages_info + first_mapped_PODRAM_page_index;
                 kernel_physical_start = PODRAM_addr[0];                  kernel_physical_start = PODRAM_addr[0];
         } else {          } else {
                 free_relocation_page = mem_pages_info + first_mapped_DRAM_page_index;                  free_relocation_page =
                       mem_pages_info + first_mapped_DRAM_page_index;
                 kernel_physical_start = DRAM_addr[0];                  kernel_physical_start = DRAM_addr[0];
         };          }
   
         printf("\nLoading %s ", booted_file);          printf("\nLoading %s ", booted_file);
   
         /* first count the kernel to get the markers */          /* first count the kernel to get the markers */
         ret = loadfile(booted_file, marks, COUNT_KERNEL);          ret = loadfile(booted_file, marks, COUNT_KERNEL);
         if (ret == -1) panic("Kernel load failed");                             /* lie to the user ...  */          if (ret == -1) panic("Kernel load failed"); /* lie to the user ... */
         close(ret);          close(ret);
   
         /* calculate how much the difference is between physical and virtual space for the kernel       */          /*
         pv_offset = ((u_long) marks[MARK_START] - kernel_physical_start);           * calculate how much the difference is between physical and
         kernel_free_vm_start = (marks[MARK_END] + nbpp-1) & ~(nbpp-1);          /* round on a page      */           * virtual space for the kernel
            */
           pv_offset = ((u_long)marks[MARK_START] - kernel_physical_start);
           /* round on a page      */
           kernel_free_vm_start = (marks[MARK_END] + nbpp-1) & ~(nbpp-1);
   
         /* we seem to be forced to clear the marks[] ? */          /* we seem to be forced to clear the marks[] ? */
         bzero(marks, sizeof(marks[MARK_MAX]));          bzero(marks, sizeof(marks[MARK_MAX]));
Line 760  int main(int argc, char **argv) {
Line 875  int main(int argc, char **argv) {
         add_pagetables_at_top();          add_pagetables_at_top();
         create_configuration(argc, argv, start_args);          create_configuration(argc, argv, start_args);
   
         /* done relocating and creating information, now update and check the relocation mechanism */          /*
            * done relocating and creating information, now update and
            * check the relocation mechanism
            */
         prepare_and_check_relocation_system();          prepare_and_check_relocation_system();
   
         printf("\nStarting at 0x%lx\n", marks[MARK_ENTRY]);          printf("\nStarting at 0x%lx\n", marks[MARK_ENTRY]);
         printf("Will boot in a few secs due to relocation....\nbye bye from RISC OS!");          printf("Will boot in a few secs due to relocation....\n"
               "bye bye from RISC OS!");
   
         /* dismount all filesystems */          /* dismount all filesystems */
         xosfscontrol_shutdown();          xosfscontrol_shutdown();
Line 774  int main(int argc, char **argv) {
Line 893  int main(int argc, char **argv) {
   
         start_kernel(          start_kernel(
                 /* r0 relocation code page (V)  */ relocate_code_page->logical,                  /* r0 relocation code page (V)  */ relocate_code_page->logical,
                 /* r1 relocation pv offset      */ relocate_code_page->physical-relocate_code_page->logical,                  /* r1 relocation pv offset      */
                 /* r2 configuration structure   */ bconfig_new_phys,                  relocate_code_page->physical-relocate_code_page->logical,
                 /* r3 relocation table (P)      */ relocate_table_pages->physical,      /* one piece! */                  /* r2 configuration structure   */ bconfig_new_phys,
                   /* r3 relocation table (P)      */
                   relocate_table_pages->physical, /* one piece! */
                 /* r4 L1 page descriptor (P)    */ new_L1_pages_phys,                  /* r4 L1 page descriptor (P)    */ new_L1_pages_phys,
                 /* r5 kernel entry point        */ marks[MARK_ENTRY]                  /* r5 kernel entry point        */ marks[MARK_ENTRY]
         );          );
Line 784  int main(int argc, char **argv) {
Line 905  int main(int argc, char **argv) {
 }  }
   
   
 ssize_t boot32_read(int f, void *addr, size_t size) {  ssize_t
   boot32_read(int f, void *addr, size_t size)
   {
         caddr_t fragaddr;          caddr_t fragaddr;
         size_t fragsize;          size_t fragsize;
         ssize_t bytes_read, total;          ssize_t bytes_read, total;
Line 792  ssize_t boot32_read(int f, void *addr, s
Line 915  ssize_t boot32_read(int f, void *addr, s
         /* printf("read at %p for %ld bytes\n", addr, size); */          /* printf("read at %p for %ld bytes\n", addr, size); */
         total = 0;          total = 0;
         while (size > 0) {          while (size > 0) {
                 fragsize = nbpp;                                /* select one page      */                  fragsize = nbpp;                /* select one page      */
                 if (size < nbpp) fragsize = size;               /* clip to size left    */                  if (size < nbpp) fragsize = size;/* clip to size left   */
   
                 /* get a page for a fragment */                  /* get a page for a fragment */
                 fragaddr = (caddr_t) get_relocated_page((u_long) addr - pv_offset, fragsize)->logical;                  fragaddr = (caddr_t)get_relocated_page((u_long) addr -
                       pv_offset, fragsize)->logical;
   
                 bytes_read = read(f, fragaddr, fragsize);                  bytes_read = read(f, fragaddr, fragsize);
                 if (bytes_read < 0) return bytes_read;          /* error!               */                  if (bytes_read < 0) return bytes_read;  /* error!       */
                 total += bytes_read;                            /* account read bytes   */                  total += bytes_read;            /* account read bytes   */
   
                 if (bytes_read < fragsize) return total;        /* does this happen?    */                  if (bytes_read < fragsize)
                           return total;           /* does this happen?    */
   
                 size -= fragsize;                               /* advance              */                  size -= fragsize;               /* advance              */
                 addr += fragsize;                  addr += fragsize;
         };          }
         return total;          return total;
 }  }
   
   
 void *boot32_memcpy(void *dst, const void *src, size_t size) {  void *
   boot32_memcpy(void *dst, const void *src, size_t size)
   {
         caddr_t fragaddr;          caddr_t fragaddr;
         size_t fragsize;          size_t fragsize;
   
         /* printf("memcpy to %p from %p for %ld bytes\n", dst, src, size); */          /* printf("memcpy to %p from %p for %ld bytes\n", dst, src, size); */
         while (size > 0) {          while (size > 0) {
                 fragsize = nbpp;                                /* select one page      */                  fragsize = nbpp;                /* select one page      */
                 if (size < nbpp) fragsize = size;               /* clip to size left    */                  if (size < nbpp) fragsize = size;/* clip to size left   */
   
                 /* get a page for a fragment */                  /* get a page for a fragment */
                 fragaddr = (caddr_t) get_relocated_page((u_long) dst - pv_offset, fragsize)->logical;                  fragaddr = (caddr_t)get_relocated_page((u_long) dst -
                       pv_offset, fragsize)->logical;
                 memcpy(fragaddr, src, size);                  memcpy(fragaddr, src, size);
   
                 src += fragsize;                                /* account copy         */                  src += fragsize;                /* account copy         */
                 dst += fragsize;                  dst += fragsize;
                 size-= fragsize;                  size-= fragsize;
         };          }
         return dst;          return dst;
 };  }
   
   
 void *boot32_memset(void *dst, int c, size_t size) {  void *
   boot32_memset(void *dst, int c, size_t size)
   {
         caddr_t fragaddr;          caddr_t fragaddr;
         size_t fragsize;          size_t fragsize;
   
         /* printf("memset %p for %ld bytes with %d\n", dst, size, c); */          /* printf("memset %p for %ld bytes with %d\n", dst, size, c); */
         while (size > 0) {          while (size > 0) {
                 fragsize = nbpp;                                /* select one page      */                  fragsize = nbpp;                /* select one page      */
                 if (size < nbpp) fragsize = size;               /* clip to size left    */                  if (size < nbpp) fragsize = size;/* clip to size left   */
   
                 /* get a page for a fragment */                  /* get a page for a fragment */
                 fragaddr = (caddr_t) get_relocated_page((u_long) dst - pv_offset, fragsize)->logical;                  fragaddr = (caddr_t)get_relocated_page((u_long)dst - pv_offset,
                       fragsize)->logical;
                 memset(fragaddr, c, fragsize);                  memset(fragaddr, c, fragsize);
   
                 dst += fragsize;                                /* account memsetting   */                  dst += fragsize;                /* account memsetting   */
                 size-= fragsize;                  size-= fragsize;
   
         };          }
         return dst;          return dst;
 }  }
   
   
 /* We can rely on the fact that two entries never have identical ->physical */  /* We can rely on the fact that two entries never have identical ->physical */
 int page_info_cmp(const void *a, const void *b) {  int
   page_info_cmp(const void *a, const void *b)
   {
   
         return (((struct page_info *)a)->physical <          return (((struct page_info *)a)->physical <
             ((struct page_info *)b)->physical) ? -1 : 1;              ((struct page_info *)b)->physical) ? -1 : 1;
 }  }
   
 struct page_info *get_relocated_page(u_long destination, int size) {  struct page_info *
   get_relocated_page(u_long destination, int size)
   {
         struct page_info *page;          struct page_info *page;
   
         /* get a page for a fragment */          /* get a page for a fragment */
         page = free_relocation_page;          page = free_relocation_page;
         if (free_relocation_page->pagenumber < 0) panic("\n\nOut of pages");          if (free_relocation_page->pagenumber < 0) panic("\n\nOut of pages");
         reloc_entries++;          reloc_entries++;
         if (reloc_entries >= MAX_RELOCPAGES) panic("\n\nToo many relocations! What are you loading ??");          if (reloc_entries >= MAX_RELOCPAGES)
                   panic("\n\nToo many relocations! What are you loading ??");
   
         /* record the relocation */          /* record the relocation */
         *reloc_pos++ = free_relocation_page->physical;          *reloc_pos++ = free_relocation_page->physical;
         *reloc_pos++ = destination;          *reloc_pos++ = destination;
         *reloc_pos++ = size;          *reloc_pos++ = size;
         free_relocation_page++;                         /* advance              */          free_relocation_page++;                 /* advance              */
   
         return page;          return page;
 }  }
   
   
 int vdu_var(int var) {  int
   vdu_var(int var)
   {
         int varlist[2], vallist[2];          int varlist[2], vallist[2];
   
         varlist[0] = var;          varlist[0] = var;
Line 888  int vdu_var(int var) {
Line 1027  int vdu_var(int var) {
 }  }
   
   
 void twirl(void) {  void
   twirl(void)
   {
   
         printf("%c%c", "|/-\\"[(int) twirl_cnt], 8);          printf("%c%c", "|/-\\"[(int) twirl_cnt], 8);
         twirl_cnt++;          twirl_cnt++;
         twirl_cnt &= 3;          twirl_cnt &= 3;
 }  }
   
   
 void process_args(int argc, char **argv, int *howto, char *file, int *start_args) {  void
   process_args(int argc, char **argv, int *howto, char *file, int *start_args)
   {
         int i, j;          int i, j;
         static char filename[80];          static char filename[80];
   
Line 911  void process_args(int argc, char **argv,
Line 1055  void process_args(int argc, char **argv,
                         else {                          else {
                                 strcpy(file, argv[i]);                                  strcpy(file, argv[i]);
                                 *start_args = i+1;                                  *start_args = i+1;
                         };                          }
                         break;                          break;
                 };                  }
         };          }
         if (*file == NULL) {          if (*file == NULL) {
                 if (*howto & RB_ASKNAME) {                  if (*howto & RB_ASKNAME) {
                         printf("boot: ");                          printf("boot: ");
Line 922  void process_args(int argc, char **argv,
Line 1066  void process_args(int argc, char **argv,
                         strcpy(file, filename);                          strcpy(file, filename);
                 } else                  } else
                         strcpy(file, "netbsd");                          strcpy(file, "netbsd");
         };          }
 }  }
   
   
 char *sprint0(int width, char prefix, char base, int value) {  char *
   sprint0(int width, char prefix, char base, int value)
   {
         static char format[50], scrap[50];          static char format[50], scrap[50];
         char *pos;          char *pos;
         int length;          int length;
Legend:
Removed from v.1.20  
changed lines
  Added in v.1.20.4.1
CVSweb <webmaster@jp.NetBSD.org>