second/prom.c

   1 /*
   2  *  prom.c - Routines for talking to the Open Firmware PROM
   3  *
   4  *  Copyright (C) 2001, 2002 Ethan Benson
   5  *
   6  *  Copyright (C) 1999 Benjamin Herrenschmidt
   7  *
   8  *  Copyright (C) 1999 Marius Vollmer
   9  *
  10  *  Copyright (C) 1996 Paul Mackerras.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #include "prom.h"
  28 #include "stdarg.h"
  29 #include "stddef.h"
  30 #include "stdlib.h"
  31 #include "types.h"
  32 #include "ctype.h"
  33 #include "asm/processor.h"
  34 #include "errors.h"
  35 #include "debug.h"
  36 #include "string.h"
  37
  38 #define READ_BLOCKS_USE_READ    1
  39
  40 static int yaboot_debug;
  41
  42 prom_entry prom;
  43
  44 ihandle prom_stdin, prom_stdout;
  45
  46 static ihandle prom_mem, prom_mmu;
  47 static ihandle prom_chosen, prom_options;
  48
  49 struct prom_args {
  50      const char *service;
  51      int nargs;
  52      int nret;
  53      void *args[10];
  54 };
  55
  56 void *
  57 call_prom (const char *service, int nargs, int nret, ...)
  58 {
  59      va_list list;
  60      int i;
  61      struct prom_args prom_args;
  62
  63      prom_args.service = service;
  64      prom_args.nargs = nargs;
  65      prom_args.nret = nret;
  66      va_start (list, nret);
  67      for (i = 0; i < nargs; ++i)
  68           prom_args.args[i] = va_arg(list, void *);
  69      va_end(list);
  70      for (i = 0; i < nret; ++i)
  71           prom_args.args[i + nargs] = 0;
  72      prom (&prom_args);
  73      if (nret > 0)
  74           return prom_args.args[nargs];
  75      else
  76           return 0;
  77 }
  78
  79 void *
  80 call_prom_return (const char *service, int nargs, int nret, ...)
  81 {
  82      va_list list;
  83      int i;
  84      void* result;
  85      struct prom_args prom_args;
  86
  87      prom_args.service = service;
  88      prom_args.nargs = nargs;
  89      prom_args.nret = nret;
  90      va_start (list, nret);
  91      for (i = 0; i < nargs; ++i)
  92           prom_args.args[i] = va_arg(list, void *);
  93      for (i = 0; i < nret; ++i)
  94           prom_args.args[i + nargs] = 0;
  95      if (prom (&prom_args) != 0)
  96           return PROM_INVALID_HANDLE;
  97      if (nret > 0) {
  98           result = prom_args.args[nargs];
  99           for (i=1; i<nret; i++) {
 100                void** rp = va_arg(list, void**);
 101                *rp = prom_args.args[i+nargs];
 102           }
 103      } else
 104           result = 0;
 105      va_end(list);
 106      return result;
 107 }
 108
 109 static void *
 110 call_method_1 (char *method, prom_handle h, int nargs, ...)
 111 {
 112      va_list list;
 113      int i;
 114      struct prom_args prom_args;
 115
 116      prom_args.service = "call-method";
 117      prom_args.nargs = nargs+2;
 118      prom_args.nret = 2;
 119      prom_args.args[0] = method;
 120      prom_args.args[1] = h;
 121      va_start (list, nargs);
 122      for (i = 0; i < nargs; ++i)
 123           prom_args.args[2+i] = va_arg(list, void *);
 124      va_end(list);
 125      prom_args.args[2+nargs] = 0;
 126      prom_args.args[2+nargs+1] = 0;
 127
 128      prom (&prom_args);
 129
 130      if (prom_args.args[2+nargs] != 0)
 131      {
 132           prom_printf ("method '%s' failed %p\n", method, prom_args.args[2+nargs]);
 133           return 0;
 134      }
 135      return prom_args.args[2+nargs+1];
 136 }
 137
 138
 139 prom_handle
 140 prom_finddevice (char *name)
 141 {
 142      return call_prom ("finddevice", 1, 1, name);
 143 }
 144
 145 prom_handle
 146 prom_findpackage(char *path)
 147 {
 148      return call_prom ("find-package", 1, 1, path);
 149 }
 150
 151 int
 152 prom_getprop (prom_handle pack, char *name, void *mem, int len)
 153 {
 154      return (int)call_prom ("getprop", 4, 1, pack, name, mem, len);
 155 }
 156
 157 int
 158 prom_getproplen(prom_handle pack, const char *name)
 159 {
 160      return (int)call_prom("getproplen", 2, 1, pack, name);
 161 }
 162
 163 int
 164 prom_setprop (prom_handle pack, char *name, void *mem, int len)
 165 {
 166      return (int)call_prom ("setprop", 4, 1, pack, name, mem, len);
 167 }
 168
 169 int
 170 prom_get_chosen (char *name, void *mem, int len)
 171 {
 172      return prom_getprop (prom_chosen, name, mem, len);
 173 }
 174
 175 int
 176 prom_get_options (char *name, void *mem, int len)
 177 {
 178      if (prom_options == (void *)-1)
 179           return -1;
 180      return prom_getprop (prom_options, name, mem, len);
 181 }
 182
 183 int
 184 prom_set_options (char *name, void *mem, int len)
 185 {
 186      if (prom_options == (void *)-1)
 187           return -1;
 188      return prom_setprop (prom_options, name, mem, len);
 189 }
 190
 191 int
 192 prom_get_devtype (char *device)
 193 {
 194      phandle    dev;
 195      int        result;
 196      char       tmp[64];
 197
 198      if (strstr(device, TOK_ISCSI))
 199           device = strcpy(tmp, "/vdevice/gscsi/disk");
 200
 201      /* Find OF device phandle */
 202      dev = prom_finddevice(device);
 203      if (dev == PROM_INVALID_HANDLE) {
 204           return FILE_ERR_BADDEV;
 205      }
 206
 207      /* Check the kind of device */
 208      result = prom_getprop(dev, "device_type", tmp, 63);
 209      if (result == -1) {
 210           prom_printf("can't get <device_type> for device: %s\n", device);
 211           return FILE_ERR_BADDEV;
 212      }
 213      tmp[result] = 0;
 214      if (!strcmp(tmp, "block"))
 215           return FILE_DEVICE_BLOCK;
 216      else if (!strcmp(tmp, "network"))
 217           return FILE_DEVICE_NET;
 218      else {
 219           prom_printf("Unkown device type <%s>\n", tmp);
 220           return FILE_ERR_BADDEV;
 221      }
 222 }
 223
 224 void
 225 prom_init (prom_entry pp)
 226 {
 227      prom = pp;
 228
 229      prom_chosen = prom_finddevice ("/chosen");
 230      if (prom_chosen == (void *)-1)
 231           prom_exit ();
 232      prom_options = prom_finddevice ("/options");
 233      if (prom_get_chosen ("stdout", &prom_stdout, sizeof(prom_stdout)) <= 0)
 234           prom_exit();
 235      if (prom_get_chosen ("stdin", &prom_stdin, sizeof(prom_stdin)) <= 0)
 236           prom_abort ("\nCan't open stdin");
 237      if (prom_get_chosen ("memory", &prom_mem, sizeof(prom_mem)) <= 0)
 238           prom_abort ("\nCan't get mem handle");
 239      if (prom_get_chosen ("mmu", &prom_mmu, sizeof(prom_mmu)) <= 0)
 240           prom_abort ("\nCan't get mmu handle");
 241
 242      yaboot_debug = 0;
 243      prom_get_options("linux,yaboot-debug", &yaboot_debug, sizeof(yaboot_debug));
 244
 245   // move cursor to fresh line
 246      prom_printf ("\n");
 247
 248      /* Add a few OF methods (thanks Darwin) */
 249 #if DEBUG
 250      prom_printf ("Adding OF methods...\n");
 251 #endif
 252
 253      prom_interpret (
 254           /* All values in this forth code are in hex */
 255           "hex "
 256           /* Those are a few utilities ripped from Apple */
 257           ": D2NIP decode-int nip nip ;\r"      // A useful function to save space
 258           ": GPP$ get-package-property 0= ;\r"  // Another useful function to save space
 259           ": ^on0 0= if -1 throw then ;\r"      // Bail if result zero
 260           ": $CM $call-method ;\r"
 261           );
 262
 263      /* Some forth words used by the release method */
 264      prom_interpret (
 265           " \" /chosen\" find-package if "
 266                  "dup \" memory\" rot GPP$ if "
 267                          "D2NIP swap "                           // ( MEMORY-ihandle "/chosen"-phandle )
 268                          "\" mmu\" rot GPP$ if "
 269                                  "D2NIP "                                // ( MEMORY-ihandle MMU-ihandle )
 270                          "else "
 271                                  "0 "                                    // ( MEMORY-ihandle 0 )
 272                          "then "
 273                  "else "
 274                          "0 0 "                                          // ( 0 0 )
 275                  "then "
 276           "else "
 277                  "0 0 "                                                  // ( 0 0 )
 278           "then\r"
 279           "value mmu# "
 280           "value mem# "
 281           );
 282
 283      prom_interpret (
 284           ": ^mem mem# $CM ; "
 285           ": ^mmu mmu# $CM ; "
 286           );
 287
 288      DEBUG_F("OF interface initialized.\n");
 289 }
 290
 291 prom_handle
 292 prom_open (char *spec)
 293 {
 294      return call_prom ("open", 1, 1, spec, strlen(spec));
 295 }
 296
 297 void
 298 prom_close (prom_handle file)
 299 {
 300      call_prom ("close", 1, 0, file);
 301 }
 302
 303 int
 304 prom_read (prom_handle file, void *buf, int n)
 305 {
 306      int result = 0;
 307      int retries = 10;
 308
 309      if (n == 0)
 310           return 0;
 311      while(--retries) {
 312           result = (int)call_prom ("read", 3, 1, file, buf, n);
 313           if (result != 0)
 314                break;
 315           call_prom("interpret", 1, 1, " 10 ms");
 316      }
 317
 318      return result;
 319 }
 320
 321 int
 322 prom_write (prom_handle file, void *buf, int n)
 323 {
 324      return (int)call_prom ("write", 3, 1, file, buf, n);
 325 }
 326
 327 int
 328 prom_seek (prom_handle file, int pos)
 329 {
 330      int status = (int)call_prom ("seek", 3, 1, file, 0, pos);
 331      return status == 0 || status == 1;
 332 }
 333
 334 int
 335 prom_lseek (prom_handle file, unsigned long long pos)
 336 {
 337      int status = (int)call_prom ("seek", 3, 1, file,
 338                                   (unsigned int)(pos >> 32), (unsigned int)(pos & 0xffffffffUL));
 339      return status == 0 || status == 1;
 340 }
 341
 342 int
 343 prom_loadmethod (prom_handle device, void* addr)
 344 {
 345      return (int)call_method_1 ("load", device, 1, addr);
 346 }
 347
 348 int
 349 prom_getblksize (prom_handle file)
 350 {
 351      return (int)call_method_1 ("block-size", file, 0);
 352 }
 353
 354 int
 355 prom_readblocks (prom_handle dev, int blockNum, int blockCount, void *buffer)
 356 {
 357 #if READ_BLOCKS_USE_READ
 358      int status;
 359      unsigned int blksize;
 360
 361      blksize = prom_getblksize(dev);
 362      if (blksize <= 1)
 363           blksize = 512;
 364      status = prom_seek(dev, blockNum * blksize);
 365      if (status != 1) {
 366           return 0;
 367           prom_printf("Can't seek to 0x%x\n", blockNum * blksize);
 368      }
 369
 370      status = prom_read(dev, buffer, blockCount * blksize);
 371 //  prom_printf("prom_readblocks, bl: %d, cnt: %d, status: %d\n",
 372 //      blockNum, blockCount, status);
 373
 374      return status == (blockCount * blksize);
 375 #else
 376      int result;
 377      int retries = 10;
 378
 379      if (blockCount == 0)
 380           return blockCount;
 381      while(--retries) {
 382           result = call_method_1 ("read-blocks", dev, 3, buffer, blockNum, blockCount);
 383           if (result != 0)
 384                break;
 385           call_prom("interpret", 1, 1, " 10 ms");
 386      }
 387
 388      return result;
 389 #endif
 390 }
 391
 392 int
 393 prom_getchar ()
 394 {
 395      char c;
 396      int a;
 397
 398      while ((a = (int)call_prom ("read", 3, 1, prom_stdin, &c, 1)) == 0)
 399           ;
 400      if (a == -1)
 401           prom_abort ("EOF on console\n");
 402      return c;
 403 }
 404
 405 int
 406 prom_nbgetchar()
 407 {
 408      char ch;
 409
 410      return (int) call_prom("read", 3, 1, prom_stdin, &ch, 1) > 0? ch: -1;
 411 }
 412
 413 void
 414 prom_putchar (char c)
 415 {
 416      if (c == '\n')
 417           call_prom ("write", 3, 1, prom_stdout, "\r\n", 2);
 418      else
 419           call_prom ("write", 3, 1, prom_stdout, &c, 1);
 420 }
 421
 422 void
 423 prom_puts (prom_handle file, char *s)
 424 {
 425      const char *p, *q;
 426
 427      for (p = s; *p != 0; p = q)
 428      {
 429           for (q = p; *q != 0 && *q != '\n'; ++q)
 430                ;
 431           if (q > p)
 432                call_prom ("write", 3, 1, file, p, q - p);
 433           if (*q != 0)
 434           {
 435                ++q;
 436                call_prom ("write", 3, 1, file, "\r\n", 2);
 437           }
 438      }
 439 }
 440
 441 void
 442 prom_vfprintf (prom_handle file, char *fmt, va_list ap)
 443 {
 444      static char printf_buf[2048];
 445      vsprintf (printf_buf, fmt, ap);
 446      prom_puts (file, printf_buf);
 447 }
 448
 449 void
 450 prom_vprintf (char *fmt, va_list ap)
 451 {
 452      static char printf_buf[2048];
 453      vsprintf (printf_buf, fmt, ap);
 454      prom_puts (prom_stdout, printf_buf);
 455 }
 456
 457 void
 458 prom_fprintf (prom_handle file, char *fmt, ...)
 459 {
 460      va_list ap;
 461      va_start (ap, fmt);
 462      prom_vfprintf (file, fmt, ap);
 463      va_end (ap);
 464 }
 465
 466 void
 467 prom_printf (char *fmt, ...)
 468 {
 469      va_list ap;
 470      va_start (ap, fmt);
 471      prom_vfprintf (prom_stdout, fmt, ap);
 472      va_end (ap);
 473 }
 474
 475 void
 476 prom_debug (char *fmt, ...)
 477 {
 478      va_list ap;
 479
 480      if (!yaboot_debug)
 481           return;
 482
 483      va_start (ap, fmt);
 484      prom_vfprintf (prom_stdout, fmt, ap);
 485      va_end (ap);
 486 }
 487
 488 void
 489 prom_perror (int error, char *filename)
 490 {
 491      if (error == FILE_ERR_EOF)
 492           prom_printf("%s: Unexpected End Of File\n", filename);
 493      else if (error == FILE_ERR_NOTFOUND)
 494           prom_printf("%s: No such file or directory\n", filename);
 495      else if (error == FILE_CANT_SEEK)
 496           prom_printf("%s: Seek error\n", filename);
 497      else if (error == FILE_IOERR)
 498           prom_printf("%s: Input/output error\n", filename);
 499      else if (error == FILE_BAD_PATH)
 500           prom_printf("%s: Path too long\n", filename);
 501      else if (error == FILE_ERR_BAD_TYPE)
 502           prom_printf("%s: Not a regular file\n", filename);
 503      else if (error == FILE_ERR_NOTDIR)
 504           prom_printf("%s: Not a directory\n", filename);
 505      else if (error == FILE_ERR_BAD_FSYS)
 506           prom_printf("%s: Unknown or corrupt filesystem\n", filename);
 507      else if (error == FILE_ERR_SYMLINK_LOOP)
 508           prom_printf("%s: Too many levels of symbolic links\n", filename);
 509      else if (error == FILE_ERR_LENGTH)
 510           prom_printf("%s: File too large\n", filename);
 511      else if (error == FILE_ERR_FSBUSY)
 512           prom_printf("%s: Filesystem busy\n", filename);
 513      else if (error == FILE_ERR_BADDEV)
 514           prom_printf("%s: Unable to open file, Invalid device\n", filename);
 515      else
 516           prom_printf("%s: Unknown error\n", filename);
 517 }
 518
 519 void
 520 prom_readline (char *prompt, char *buf, int len)
 521 {
 522      int i = 0;
 523      int c;
 524
 525      if (prompt)
 526           prom_puts (prom_stdout, prompt);
 527
 528      while (i < len-1 && (c = prom_getchar ()) != '\r')
 529      {
 530           if (c == 8)
 531           {
 532                if (i > 0)
 533                {
 534                     prom_puts (prom_stdout, "\b \b");
 535                     i--;
 536                }
 537                else
 538                     prom_putchar ('\a');
 539           }
 540           else if (isprint (c))
 541           {
 542                prom_putchar (c);
 543                buf[i++] = c;
 544           }
 545           else
 546                prom_putchar ('\a');
 547      }
 548      prom_putchar ('\n');
 549      buf[i] = 0;
 550 }
 551
 552 #ifdef CONFIG_SET_COLORMAP
 553 int prom_set_color(prom_handle device, int color, int r, int g, int b)
 554 {
 555      return (int)call_prom( "call-method", 6, 1, "color!", device, color, b, g, r );
 556 }
 557 #endif /* CONFIG_SET_COLORMAP */
 558
 559 void
 560 prom_exit ()
 561 {
 562      call_prom ("exit", 0, 0);
 563 }
 564
 565 void
 566 prom_abort (char *fmt, ...)
 567 {
 568      va_list ap;
 569      va_start (ap, fmt);
 570      prom_vfprintf (prom_stdout, fmt, ap);
 571      va_end (ap);
 572      prom_exit ();
 573 }
 574
 575 void
 576 prom_sleep (int seconds)
 577 {
 578      int end;
 579      end = (prom_getms() + (seconds * 1000));
 580      while (prom_getms() <= end);
 581 }
 582
 583 /* if address given is claimed look for other addresses to get the needed
 584  * space before giving up
 585  */
 586 void *
 587 prom_claim_chunk(void *virt, unsigned int size, unsigned int align)
 588 {
 589      void *found, *addr;
 590      for(addr=virt; addr <= (void*)PROM_CLAIM_MAX_ADDR;
 591          addr+=(0x100000/sizeof(addr))) {
 592           found = call_prom("claim", 3, 1, addr, size, 0);
 593           if (found != (void *)-1) {
 594                prom_debug("claim of 0x%x at 0x%x returned 0x%x\n", size, (int)addr, (int)found);
 595                return(found);
 596           }
 597      }
 598      prom_printf("ERROR: claim of 0x%x in range 0x%x-0x%x failed\n", size, (int)virt, PROM_CLAIM_MAX_ADDR);
 599      return((void*)-1);
 600 }
 601
 602 /* Start from top of memory and work down to get the needed space */
 603 void *
 604 prom_claim_chunk_top(unsigned int size, unsigned int align)
 605 {
 606      void *found, *addr;
 607      for(addr=(void*)PROM_CLAIM_MAX_ADDR; addr >= (void *)size;
 608          addr-=(0x100000/sizeof(addr))) {
 609           found = call_prom("claim", 3, 1, addr, size, 0);
 610           if (found != (void *)-1) {
 611                prom_debug("claim of 0x%x at 0x%x returned 0x%x\n", size, (int)addr, (int)found);
 612                return(found);
 613           }
 614      }
 615      prom_printf("ERROR: claim of 0x%x in range 0x0-0x%x failed\n", size, PROM_CLAIM_MAX_ADDR);
 616      return((void*)-1);
 617 }
 618
 619 void *
 620 prom_claim (void *virt, unsigned int size, unsigned int align)
 621 {
 622      void *ret;
 623
 624      ret = call_prom ("claim", 3, 1, virt, size, align);
 625      if (ret == (void *)-1)
 626           prom_printf("ERROR: claim of 0x%x at 0x%x failed\n", size, (int)virt);
 627      else
 628           prom_debug("claim of 0x%x at 0x%x returned 0x%x\n", size, (int)virt, (int)ret);
 629
 630      return ret;
 631 }
 632
 633 void
 634 prom_release(void *virt, unsigned int size)
 635 {
 636      void *ret;
 637
 638      ret = call_prom ("release", 2, 0, virt, size);
 639      prom_debug("release of 0x%x at 0x%x returned 0x%x\n", size, (int)virt, (int)ret);
 640 }
 641
 642 void
 643 prom_map (void *phys, void *virt, int size)
 644 {
 645      unsigned long msr = mfmsr();
 646
 647      /* Only create a mapping if we're running with relocation enabled. */
 648      if ( (msr & MSR_IR) && (msr & MSR_DR) )
 649           call_method_1 ("map", prom_mmu, 4, -1, size, virt, phys);
 650 }
 651
 652 void
 653 prom_unmap (void *phys, void *virt, int size)
 654 {
 655      unsigned long msr = mfmsr();
 656
 657      /* Only unmap if we're running with relocation enabled. */
 658      if ( (msr & MSR_IR) && (msr & MSR_DR) )
 659           call_method_1 ("map", prom_mmu, 4, -1, size, virt, phys);
 660 }
 661
 662 char *
 663 prom_getargs ()
 664 {
 665      static char args[256];
 666      int l;
 667
 668      l = prom_get_chosen ("bootargs", args, 255);
 669      args[l] = '\0';
 670      return args;
 671 }
 672
 673 void
 674 prom_setargs (char *args)
 675 {
 676      int l = strlen (args)+1;
 677      if ((int)call_prom ("setprop", 4, 1, prom_chosen, "bootargs", args, l) != l)
 678           prom_printf ("can't set args\n");
 679 }
 680
 681 int prom_interpret (char *forth)
 682 {
 683      return (int)call_prom("interpret", 1, 1, forth);
 684 }
 685
 686 int
 687 prom_getms(void)
 688 {
 689      return (int) call_prom("milliseconds", 0, 1);
 690 }
 691
 692 void
 693 prom_pause(void)
 694 {
 695      prom_print_available();
 696      call_prom("enter", 0, 0);
 697 }
 698
 699 /*
 700  * prom_get_netinfo()
 701  * returns the packet with all needed info for netboot
 702  */
 703 struct bootp_packet * prom_get_netinfo (void)
 704 {
 705      void *bootp_response = NULL;
 706      char *propname;
 707      struct bootp_packet *packet;
 708      /* struct bootp_packet contains a VLA, so sizeof won't work.
 709         the VLA /must/ be the last field in the structure so use it's
 710         offset as a good estimate of the packet size */
 711      size_t packet_size = offsetof(struct bootp_packet, options);
 712      int i = 0, size, offset = 0;
 713      prom_handle chosen;
 714 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 715
 716      chosen = prom_finddevice("/chosen");
 717      if (chosen < 0) {
 718           DEBUG_F("chosen=%d\n", chosen);
 719       return 0;
 720      }
 721
 722      for (i = 0; i < ARRAY_SIZE(bootp_response_properties); i++) {
 723          propname = bootp_response_properties[i].name;
 724          size = prom_getproplen(chosen, propname);
 725          if (size <= 0)
 726              continue;
 727
 728          DEBUG_F("using /chosen/%s\n", propname);
 729          offset = bootp_response_properties[i].offset;
 730          break;
 731      }
 732
 733      if (size <= 0)
 734          return NULL;
 735
 736      if (packet_size > size - offset) {
 737          prom_printf("Malformed %s property?\n", propname);
 738          return NULL;
 739      }
 740
 741      bootp_response = malloc(size);
 742      if (!bootp_response)
 743          return NULL;
 744
 745      if (prom_getprop(chosen, propname, bootp_response, size) < 0)
 746          return NULL;
 747
 748      packet = bootp_response + offset;
 749      return packet;
 750 }
 751
 752 /*
 753  * prom_get_mac()
 754  * returns the mac addr of an net card
 755  */
 756 char * prom_get_mac (struct bootp_packet * packet)
 757 {
 758      char * conf_path;
 759      int i;
 760
 761      if (!packet)
 762         return NULL;
 763
 764      /* 3 chars per byte in chaddr + \0 */
 765      conf_path = malloc(packet->hlen * 3 + 1);
 766      if (!conf_path)
 767          return NULL;
 768      sprintf(conf_path, "%02x", packet->chaddr[0]);
 769
 770      for (i = 1; i < packet->hlen; i++) {
 771       char tmp[4];
 772       sprintf(tmp, "-%02x", packet->chaddr[i]);
 773       strcat(conf_path, tmp);
 774      }
 775
 776      return conf_path;
 777 }
 778
 779 /*
 780  * prom_get_ip()
 781  * returns the ip addr of an net card
 782  */
 783 char * prom_get_ip (struct bootp_packet * packet)
 784 {
 785      char * conf_path;
 786
 787      if (!packet)
 788         return NULL;
 789
 790      /* 8 chars in yiaddr + \0 */
 791      conf_path = malloc(9);
 792      if (!conf_path)
 793          return NULL;
 794      sprintf(conf_path, "%08x", packet->yiaddr);
 795
 796      return conf_path;
 797 }
 798
 799 /* We call this too early to use malloc, 128 cells should be large enough */
 800 #define NR_AVAILABLE 128
 801
 802 void prom_print_available(void)
 803 {
 804      prom_handle root;
 805      unsigned int addr_cells, size_cells;
 806      ihandle mem;
 807      unsigned int available[NR_AVAILABLE];
 808      unsigned int len;
 809      unsigned int *p;
 810
 811      if (!yaboot_debug)
 812           return;
 813
 814      root = prom_finddevice("/");
 815      if (!root)
 816           return;
 817
 818      addr_cells = 2;
 819      prom_getprop(root, "#address-cells", &addr_cells, sizeof(addr_cells));
 820
 821      size_cells = 1;
 822      prom_getprop(root, "#size-cells", &size_cells, sizeof(size_cells));
 823
 824      mem = prom_finddevice("/memory@0");
 825      if (mem == PROM_INVALID_HANDLE)
 826           return;
 827
 828      len = prom_getprop(mem, "available", available, sizeof(available));
 829      if (len == -1)
 830           return;
 831      len /= 4;
 832
 833      prom_printf("\nAvailable memory ranges:\n");
 834
 835      p = available;
 836      while (len > 0) {
 837           unsigned int addr, size;
 838
 839           /*
 840            * Since we are in 32bit mode it should be safe to only print the
 841            * bottom 32bits of each range.
 842            */
 843           p += (addr_cells - 1);
 844           addr = *p;
 845           p++;
 846
 847           p += (size_cells - 1);
 848           size = *p;
 849           p++;
 850
 851           if (size)
 852                prom_printf("0x%08x-0x%08x (%3d MB)\n", addr, addr + size,
 853                            size/1024/1024);
 854
 855           len -= (addr_cells + size_cells);
 856      }
 857
 858      prom_printf("\n");
 859 }
 860
 861 /*
 862  * Local variables:
 863  * c-file-style: "k&r"
 864  * c-basic-offset: 5
 865  * End:
 866  */