Subversion Repositories HelenOS-historic

Rev

Rev 1058 | Rev 1146 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2005 Martin Decky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include "ofw.h"
  30. #include "asm.h"
  31. #include "printf.h"
  32.  
  33. #define MAX_OFW_ARGS    10
  34.  
  35. typedef unsigned int ofw_arg_t;
  36. typedef unsigned int ihandle;
  37. typedef unsigned int phandle;
  38.  
  39. /** OpenFirmware command structure
  40.  *
  41.  */
  42. typedef struct {
  43.     const char *service;          /**< Command name */
  44.     unsigned int nargs;           /**< Number of in arguments */
  45.     unsigned int nret;            /**< Number of out arguments */
  46.     ofw_arg_t args[MAX_OFW_ARGS]; /**< List of arguments */
  47. } ofw_args_t;
  48.  
  49. typedef void (*ofw_entry)(ofw_args_t *);
  50.  
  51.  
  52. ofw_entry ofw;
  53.  
  54. phandle ofw_chosen;
  55. ihandle ofw_mmu;
  56. ihandle ofw_stdout;
  57.  
  58.  
  59. static int ofw_call(const char *service, const int nargs, const int nret, ...)
  60. {
  61.     va_list list;
  62.     ofw_args_t args;
  63.     int i;
  64.    
  65.     args.service = service;
  66.     args.nargs = nargs;
  67.     args.nret = nret;
  68.    
  69.     va_start(list, nret);
  70.     for (i = 0; i < nargs; i++)
  71.         args.args[i] = va_arg(list, ofw_arg_t);
  72.     va_end(list);
  73.    
  74.     for (i = 0; i < nret; i++)
  75.         args.args[i + nargs] = 0;
  76.    
  77.     ofw(&args);
  78.    
  79.     return args.args[nargs];
  80. }
  81.  
  82.  
  83. static phandle ofw_find_device(const char *name)
  84. {
  85.     return ofw_call("finddevice", 1, 1, name);
  86. }
  87.  
  88.  
  89. static int ofw_get_property(const phandle device, const char *name, const void *buf, const int buflen)
  90. {
  91.     return ofw_call("getprop", 4, 1, device, name, buf, buflen);
  92. }
  93.  
  94. static ihandle ofw_open(const char *name)
  95. {
  96.     return ofw_call("open", 1, 1, name);
  97. }
  98.  
  99.  
  100. void init(void)
  101. {
  102.     ofw_chosen = ofw_find_device("/chosen");
  103.     if (ofw_chosen == -1)
  104.         halt();
  105.    
  106.     if (ofw_get_property(ofw_chosen, "stdout",  &ofw_stdout, sizeof(ofw_stdout)) <= 0) 
  107.         ofw_stdout = 0;
  108.    
  109.     ofw_mmu = ofw_open("/mmu");
  110.     if (ofw_mmu == -1) {
  111.         puts("Unable to open /mmu node\n");
  112.         halt();
  113.     }
  114. }
  115.  
  116.  
  117. void ofw_write(const char *str, const int len)
  118. {
  119.     if (ofw_stdout == 0)
  120.         return;
  121.    
  122.     ofw_call("write", 3, 1, ofw_stdout, str, len);
  123. }
  124.  
  125.  
  126. void *ofw_translate(const void *virt)
  127. {
  128.     return (void *) ofw_call("call-method", 7, 1, "translate", ofw_mmu, virt, 0, 0, 0, 0);
  129. }
  130.  
  131.  
  132. int ofw_map(const void *phys, const void *virt, const int size, const int mode)
  133. {
  134.     return ofw_call("call-method", 6, 1, "map", ofw_mmu, mode, size, virt, phys);
  135. }
  136.  
  137.  
  138. int ofw_memmap(memmap_t *map)
  139. {
  140.     int i;
  141.     int ret;
  142.  
  143.     phandle handle = ofw_find_device("/memory");
  144.     if (handle == -1)
  145.         return false;
  146.    
  147.     ret = ofw_get_property(handle, "reg", &map->zones, sizeof(map->zones));
  148.     if (ret == -1)
  149.         return false;
  150.    
  151.     map->total = 0;
  152.     map->count = 0;
  153.     for (i = 0; i < MEMMAP_MAX_RECORDS; i++) {
  154.         if (map->zones[i].size == 0)
  155.             break;
  156.         map->count++;
  157.         map->total += map->zones[i].size;
  158.     }
  159. }
  160.