util/mkelfImage/linux-ia64/convert_params.c

   1 #include "stdint.h"
   2 #include "limits.h"
   3 #include <stdarg.h>
   4 #include "elf.h"
   5 #include "elf_boot.h"
   6 #include "convert.h"
   7
   8
   9 /* NOTE be very careful with static variables.  No relocations are
  10  * being performed so static variables with initialized pointers will
  11  * point to the wrong locations, unless this file is loaded at just
  12  * the right location.
  13  */
  14 /* Data and functions in head.S */
  15 extern void uart_tx_byte(int c);
  16
  17 static void putchar(int c)
  18 {
  19         if (c == '\n') {
  20                 putchar('\r');
  21         }
  22 #if 0
  23         uart_tx_byte(c);
  24 #endif
  25 }
  26
  27 #define LONG_SHIFT  ((int)((sizeof(unsigned long)*CHAR_BIT) - 4))
  28 #define INT_SHIFT   ((int)((sizeof(unsigned int)*CHAR_BIT) - 4))
  29 #define SHRT_SHIFT  ((int)((sizeof(unsigned short)*CHAR_BIT) - 4))
  30 #define CHAR_SHIFT  ((int)((sizeof(unsigned char)*CHAR_BIT) - 4))
  31
  32 /**************************************************************************
  33 PRINTF and friends
  34
  35         Formats:
  36                 %x      - 4 bytes int (8 hex digits, lower case)
  37                 %X      - 4 bytes int (8 hex digits, upper case)
  38                 %lx     - 8 bytes long (16 hex digits, lower case)
  39                 %lX     - 8 bytes long (16 hex digits, upper case)
  40                 %hx     - 2 bytes int (4 hex digits, lower case)
  41                 %hX     - 2 bytes int (4 hex digits, upper case)
  42                 %hhx    - 1 byte int (2 hex digits, lower case)
  43                 %hhX    - 1 byte int (2 hex digits, upper case)
  44                         - optional # prefixes 0x or 0X
  45                 %d      - decimal int
  46                 %c      - char
  47                 %s      - string
  48         Note: width specification not supported
  49 **************************************************************************/
  50 static void printf(const char *fmt, ...)
  51 {
  52         va_list args;
  53         char *p;
  54         va_start(args, fmt);
  55         for ( ; *fmt != '\0'; ++fmt) {
  56                 if (*fmt != '%') {
  57                         putchar(*fmt);
  58                         continue;
  59                 }
  60                 if (*++fmt == 's') {
  61                         for(p = va_arg(args, char *); *p != '\0'; p++)
  62                                 putchar(*p);
  63                 }
  64                 else {  /* Length of item is bounded */
  65                         char tmp[40], *q = tmp;
  66                         int shift = INT_SHIFT;
  67                         if (*fmt == 'l') {
  68                                 shift = LONG_SHIFT;
  69                                 fmt++;
  70                         }
  71                         else if (*fmt == 'h') {
  72                                 shift = SHRT_SHIFT;
  73                                 fmt++;
  74                                 if (*fmt == 'h') {
  75                                         shift = CHAR_SHIFT;
  76                                         fmt++;
  77                                 }
  78                         }
  79
  80                         /*
  81                          * Before each format q points to tmp buffer
  82                          * After each format q points past end of item
  83                          */
  84                         if ((*fmt | 0x20) == 'x') {
  85                                 /* With x86 gcc, sizeof(long) == sizeof(int) */
  86                                 unsigned long h;
  87                                 int ncase;
  88                                 if (shift > INT_SHIFT) {
  89                                         h = va_arg(args, unsigned long);
  90                                 } else {
  91                                         h = va_arg(args, unsigned int);
  92                                 }
  93                                 ncase = (*fmt & 0x20);
  94                                 for ( ; shift >= 0; shift -= 4)
  95                                         *q++ = "0123456789ABCDEF"[(h >> shift) & 0xF] | ncase;
  96                         }
  97                         else if (*fmt == 'd') {
  98                                 char *r;
  99                                 long i;
 100                                 if (shift > INT_SHIFT) {
 101                                         i = va_arg(args, long);
 102                                 } else {
 103                                         i = va_arg(args, int);
 104                                 }
 105                                 if (i < 0) {
 106                                         *q++ = '-';
 107                                         i = -i;
 108                                 }
 109                                 p = q;          /* save beginning of digits */
 110                                 do {
 111                                         *q++ = '0' + (i % 10);
 112                                         i /= 10;
 113                                 } while (i);
 114                                 /* reverse digits, stop in middle */
 115                                 r = q;          /* don't alter q */
 116                                 while (--r > p) {
 117                                         i = *r;
 118                                         *r = *p;
 119                                         *p++ = i;
 120                                 }
 121                         }
 122                         else if (*fmt == 'c')
 123                                 *q++ = va_arg(args, int);
 124                         else
 125                                 *q++ = *fmt;
 126                         /* now output the saved string */
 127                         for (p = tmp; p < q; ++p)
 128                                 putchar(*p);
 129                 }
 130         }
 131         va_end(args);
 132 }
 133
 134 void *memcpy(void *vdest, void *vsrc, size_t size)
 135 {
 136         unsigned char *dest = vdest, *src = vsrc;
 137         size_t i;
 138         for(i = 0; i < size; i++) {
 139                 *dest++ = *src++;
 140         }
 141         return dest;
 142 }
 143
 144 int memcmp(void *vs1, void *vs2, size_t size)
 145 {
 146         unsigned char *s1 =vs1, *s2=vs2;
 147         size_t i;
 148         for(i = 0; i < size; i++, s1++, s2++) {
 149                 if (*s1 != *s2)
 150                         return *s1 - *s2;
 151         }
 152         return 0;
 153
 154 }
 155
 156 void strappend(char *dest, const char *src, size_t max)
 157 {
 158         size_t len, i;
 159         /* Walk to the end of the destination string */
 160         for(len = 0; len < max; len++) {
 161                 if (dest[len] == '\0')
 162                         break;
 163         }
 164         /* Walk through the source string and append it */
 165         for(i = 0; (i + len) < max; i++) {
 166                 if (src[i] == '\0')
 167                         break;
 168                 dest[len + i] = src[i];
 169         }
 170         len = len + i;
 171         /* Now null terminate the string */
 172         if (len >= max) {
 173                 len = max -1;
 174         }
 175         dest[len] = '\0';
 176 }
 177
 178 static struct ia64_boot_param {
 179         uint64_t command_line;          /* physical address of command line arguments */
 180         uint64_t efi_systab;            /* physical address of EFI system table */
 181         uint64_t efi_memmap;            /* physical address of EFI memory map */
 182         uint64_t efi_memmap_size;               /* size of EFI memory map */
 183         uint64_t efi_memdesc_size;              /* size of an EFI memory map descriptor */
 184         uint32_t efi_memdesc_version;   /* memory descriptor version */
 185         struct {
 186                 uint16_t num_cols;      /* number of columns on console output device */
 187                 uint16_t num_rows;      /* number of rows on console output device */
 188                 uint16_t orig_x;        /* cursor's x position */
 189                 uint16_t orig_y;        /* cursor's y position */
 190         } console_info;
 191         uint64_t fpswa;         /* physical address of the fpswa interface */
 192         uint64_t initrd_start;
 193         uint64_t initrd_size;
 194 } bp = { 0, 0, 0, 0, 0, 0, { 80, 24, 0, 0 }, 0, 0, 0 };
 195
 196 static void append_command_line(char *arg)
 197 {
 198         strappend((char *)bp.command_line, " ", CMDLINE_MAX);
 199         strappend((char *)bp.command_line, arg, CMDLINE_MAX);
 200 }
 201
 202 static void convert_ia64_boot_params(struct ia64_boot_param *orig_bp)
 203 {
 204         /* Copy the parameters I have no clue about */
 205         bp.efi_systab            = orig_bp->efi_systab;
 206         bp.efi_memmap            = orig_bp->efi_memmap;
 207         bp.efi_memmap_size       = orig_bp->efi_memmap_size;
 208         bp.efi_memdesc_size      = orig_bp->efi_memdesc_size;
 209         bp.efi_memdesc_version   = orig_bp->efi_memdesc_version;
 210         bp.console_info.num_cols = orig_bp->console_info.num_cols;
 211         bp.console_info.num_rows = orig_bp->console_info.num_rows;
 212         bp.console_info.orig_x   = orig_bp->console_info.orig_x;
 213         bp.console_info.orig_y   = orig_bp->console_info.orig_y;
 214         bp.fpswa                 = orig_bp->fpswa;
 215         /* If a ramdisk was supplied and I didn't original have one,
 216          * use it.
 217          */
 218         if (orig_bp->initrd_size && (!bp.initrd_size)) {
 219                 bp.initrd_start = orig_bp->initrd_start;
 220                 bp.initrd_size = orig_bp->initrd_size;
 221         }
 222         /* If a command line was supplied append it */
 223         if (orig_bp->command_line) {
 224                 append_command_line((char *)(orig_bp->command_line));
 225         }
 226 }
 227
 228 static void convert_bhdr_params(Elf_Bhdr *bhdr)
 229 {
 230         unsigned char *note, *end;
 231         char *ldr_name, *ldr_version, *firmware;
 232
 233         ldr_name = ldr_version = firmware = 0;
 234
 235         note = ((char *)bhdr) + sizeof(*bhdr);
 236         end  = ((char *)bhdr) + bhdr->b_size;
 237         while(note < end) {
 238                 Elf_Nhdr *hdr;
 239                 unsigned char *n_name, *n_desc, *next;
 240                 hdr = (Elf_Nhdr *)note;
 241                 n_name = note + sizeof(*hdr);
 242                 n_desc = n_name + ((hdr->n_namesz + 3) & ~3);
 243                 next = n_desc + ((hdr->n_descsz + 3) & ~3);
 244                 if (next > end)
 245                         break;
 246 #if 0
 247                 printf("n_type: %x n_name(%d): n_desc(%d): \n",
 248                         hdr->n_type, hdr->n_namesz, hdr->n_descsz);
 249 #endif
 250
 251                 if (hdr->n_namesz == 0) {
 252                         switch(hdr->n_type) {
 253                         case EBN_FIRMWARE_TYPE:
 254                                 firmware = n_desc;
 255                                 break;
 256                         case EBN_BOOTLOADER_NAME:
 257                                 ldr_name = n_desc;
 258                                 break;
 259                         case EBN_BOOTLOADER_VERSION:
 260                                 ldr_version = n_desc;
 261                                 break;
 262                         case EBN_COMMAND_LINE:
 263                                 append_command_line(n_desc);
 264                                 break;
 265                         }
 266                 }
 267                 else if ((hdr->n_namesz == 10) &&
 268                         (memcmp(n_name, "Etherboot", 10) == 0)) {
 269                         switch(hdr->n_type) {
 270                         case EB_IA64_SYSTAB:
 271                         {
 272                                 uint64_t *systabp = (void *)n_desc;
 273                                 bp.efi_systab = *systabp;
 274                                 break;
 275                         }
 276                         case EB_IA64_FPSWA:
 277                         {
 278                                 uint64_t *fpswap = (void *)n_desc;
 279                                 bp.fpswa = *fpswap;
 280                                 break;
 281                         }
 282                         case EB_IA64_CONINFO:
 283                                 memcpy(&bp.console_info, n_desc, sizeof(bp.console_info));
 284                                 break;
 285                         case EB_IA64_MEMMAP:
 286                         {
 287                                 struct efi_mem_map {
 288                                         uint64_t        map_size;
 289                                         uint64_t        map_key;
 290                                         uint64_t        descriptor_size;
 291                                         uint64_t        descriptor_version;
 292                                         uint8_t         map[40];
 293                                 } *map = (void *)n_desc;
 294                                 bp.efi_memmap = (uint64_t)&map->map;
 295                                 bp.efi_memmap_size     = map->map_size;
 296                                 bp.efi_memdesc_size    = map->descriptor_size;
 297                                 bp.efi_memdesc_version = map->descriptor_version;
 298                                 break;
 299                         }
 300                         }
 301                 }
 302                 note = next;
 303         }
 304         if (ldr_name && ldr_version) {
 305                 printf("Loader: %s version: %s\n",
 306                         ldr_name, ldr_version);
 307         }
 308         if (firmware) {
 309                 printf("Firmware: %s\n",
 310                         firmware);
 311         }
 312 }
 313
 314 void *convert_params(unsigned long arg1, unsigned long r28,
 315         struct image_parameters *params)
 316 {
 317         struct ia64_boot_param *orig_bp;
 318         Elf_Bhdr *bhdr = (Elf_Bhdr*)arg1;
 319
 320         /* handle the options I can easily deal with */
 321         bp.command_line = (unsigned long)&params->cmdline;
 322         bp.initrd_start = params->initrd_start;
 323         bp.initrd_size  = params->initrd_size;
 324
 325         orig_bp = (struct ia64_boot_param *)r28;
 326         if (bhdr->b_signature == 0x0E1FB007) {
 327                 convert_bhdr_params(bhdr);
 328         }
 329         else {
 330                 convert_ia64_boot_params(orig_bp);
 331         }
 332
 333         return &bp;
 334 }