Rev 2071 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
885 | decky | 1 | /* |
2071 | jermar | 2 | * Copyright (c) 2005 Martin Decky |
885 | 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 | |||
1789 | jermar | 29 | #include <ofw.h> |
30 | #include <ofwarch.h> |
||
1764 | jermar | 31 | #include <printf.h> |
32 | #include <asm.h> |
||
1782 | jermar | 33 | #include <types.h> |
885 | decky | 34 | |
1783 | jermar | 35 | uintptr_t ofw_cif; |
964 | decky | 36 | |
885 | decky | 37 | phandle ofw_chosen; |
1146 | decky | 38 | ihandle ofw_stdout; |
39 | phandle ofw_root; |
||
40 | ihandle ofw_mmu; |
||
41 | phandle ofw_memory; |
||
1130 | decky | 42 | phandle ofw_aliases; |
885 | decky | 43 | |
1789 | jermar | 44 | void ofw_init(void) |
45 | { |
||
46 | ofw_chosen = ofw_find_device("/chosen"); |
||
47 | if (ofw_chosen == -1) |
||
48 | halt(); |
||
49 | |||
50 | if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout, sizeof(ofw_stdout)) <= 0) |
||
51 | ofw_stdout = 0; |
||
52 | |||
53 | ofw_root = ofw_find_device("/"); |
||
54 | if (ofw_root == -1) { |
||
55 | puts("\r\nError: Unable to find / device, halted.\r\n"); |
||
56 | halt(); |
||
57 | } |
||
58 | |||
59 | if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu, sizeof(ofw_mmu)) <= 0) { |
||
60 | puts("\r\nError: Unable to get mmu property, halted.\r\n"); |
||
61 | halt(); |
||
62 | } |
||
63 | |||
64 | ofw_memory = ofw_find_device("/memory"); |
||
65 | if (ofw_memory == -1) { |
||
66 | puts("\r\nError: Unable to find /memory device, halted.\r\n"); |
||
67 | halt(); |
||
68 | } |
||
69 | |||
70 | ofw_aliases = ofw_find_device("/aliases"); |
||
71 | if (ofw_aliases == -1) { |
||
72 | puts("\r\nError: Unable to find /aliases device, halted.\r\n"); |
||
73 | halt(); |
||
74 | } |
||
75 | } |
||
76 | |||
1790 | jermar | 77 | /** Perform a call to OpenFirmware client interface. |
78 | * |
||
79 | * @param service String identifying the service requested. |
||
80 | * @param nargs Number of input arguments. |
||
81 | * @param nret Number of output arguments. This includes the return value. |
||
82 | * @param rets Buffer for output arguments or NULL. The buffer must accommodate nret - 1 items. |
||
83 | * |
||
84 | * @return Return value returned by the client interface. |
||
85 | */ |
||
1899 | jermar | 86 | unsigned long ofw_call(const char *service, const int nargs, const int nret, ofw_arg_t *rets, ...) |
885 | decky | 87 | { |
88 | va_list list; |
||
89 | ofw_args_t args; |
||
90 | int i; |
||
91 | |||
1790 | jermar | 92 | args.service = (ofw_arg_t) service; |
885 | decky | 93 | args.nargs = nargs; |
94 | args.nret = nret; |
||
95 | |||
1146 | decky | 96 | va_start(list, rets); |
885 | decky | 97 | for (i = 0; i < nargs; i++) |
98 | args.args[i] = va_arg(list, ofw_arg_t); |
||
99 | va_end(list); |
||
100 | |||
101 | for (i = 0; i < nret; i++) |
||
102 | args.args[i + nargs] = 0; |
||
103 | |||
1783 | jermar | 104 | (void) ofw(&args); |
105 | |||
1146 | decky | 106 | for (i = 1; i < nret; i++) |
107 | rets[i - 1] = args.args[i + nargs]; |
||
1783 | jermar | 108 | |
956 | decky | 109 | return args.args[nargs]; |
885 | decky | 110 | } |
111 | |||
1771 | jermar | 112 | phandle ofw_find_device(const char *name) |
953 | decky | 113 | { |
1146 | decky | 114 | return ofw_call("finddevice", 1, 1, NULL, name); |
964 | decky | 115 | } |
116 | |||
1895 | jermar | 117 | int ofw_get_property(const phandle device, const char *name, void *buf, const int buflen) |
964 | decky | 118 | { |
1146 | decky | 119 | return ofw_call("getprop", 4, 1, NULL, device, name, buf, buflen); |
964 | decky | 120 | } |
121 | |||
1893 | jermar | 122 | int ofw_get_proplen(const phandle device, const char *name) |
123 | { |
||
124 | return ofw_call("getproplen", 2, 1, NULL, device, name); |
||
125 | } |
||
1146 | decky | 126 | |
1893 | jermar | 127 | int ofw_next_property(const phandle device, char *previous, char *buf) |
128 | { |
||
129 | return ofw_call("nextprop", 3, 1, NULL, device, previous, buf); |
||
130 | } |
||
131 | |||
1895 | jermar | 132 | int ofw_package_to_path(const phandle device, char *buf, const int buflen) |
133 | { |
||
134 | return ofw_call("package-to-path", 3, 1, NULL, device, buf, buflen); |
||
135 | } |
||
136 | |||
1789 | jermar | 137 | unsigned int ofw_get_address_cells(const phandle device) |
1146 | decky | 138 | { |
1789 | jermar | 139 | unsigned int ret = 1; |
1146 | decky | 140 | |
141 | if (ofw_get_property(device, "#address-cells", &ret, sizeof(ret)) <= 0) |
||
142 | if (ofw_get_property(ofw_root, "#address-cells", &ret, sizeof(ret)) <= 0) |
||
1789 | jermar | 143 | ret = OFW_ADDRESS_CELLS; |
1146 | decky | 144 | |
145 | return ret; |
||
146 | } |
||
147 | |||
148 | |||
1789 | jermar | 149 | unsigned int ofw_get_size_cells(const phandle device) |
1146 | decky | 150 | { |
151 | unsigned int ret; |
||
152 | |||
153 | if (ofw_get_property(device, "#size-cells", &ret, sizeof(ret)) <= 0) |
||
154 | if (ofw_get_property(ofw_root, "#size-cells", &ret, sizeof(ret)) <= 0) |
||
1789 | jermar | 155 | ret = OFW_SIZE_CELLS; |
1146 | decky | 156 | |
157 | return ret; |
||
158 | } |
||
159 | |||
1881 | jermar | 160 | phandle ofw_get_child_node(const phandle node) |
161 | { |
||
162 | return ofw_call("child", 1, 1, NULL, node); |
||
163 | } |
||
1146 | decky | 164 | |
1881 | jermar | 165 | phandle ofw_get_peer_node(const phandle node) |
166 | { |
||
167 | return ofw_call("peer", 1, 1, NULL, node); |
||
168 | } |
||
169 | |||
964 | decky | 170 | static ihandle ofw_open(const char *name) |
171 | { |
||
1146 | decky | 172 | return ofw_call("open", 1, 1, NULL, name); |
953 | decky | 173 | } |
174 | |||
175 | |||
964 | decky | 176 | void ofw_write(const char *str, const int len) |
885 | decky | 177 | { |
964 | decky | 178 | if (ofw_stdout == 0) |
179 | return; |
||
180 | |||
1146 | decky | 181 | ofw_call("write", 3, 1, NULL, ofw_stdout, str, len); |
885 | decky | 182 | } |
183 | |||
184 | |||
956 | decky | 185 | void *ofw_translate(const void *virt) |
885 | decky | 186 | { |
1782 | jermar | 187 | ofw_arg_t result[4]; |
188 | int shift; |
||
189 | |||
190 | if (ofw_call("call-method", 3, 5, result, "translate", ofw_mmu, virt) != 0) { |
||
1146 | decky | 191 | puts("Error: MMU method translate() failed, halting.\n"); |
192 | halt(); |
||
193 | } |
||
1782 | jermar | 194 | |
1783 | jermar | 195 | if (ofw_translate_failed(result[0])) |
196 | return NULL; |
||
197 | |||
1782 | jermar | 198 | if (sizeof(unative_t) == 8) |
199 | shift = 32; |
||
200 | else |
||
201 | shift = 0; |
||
1789 | jermar | 202 | |
1783 | jermar | 203 | return (void *) ((result[2]<<shift)|result[3]); |
885 | decky | 204 | } |
953 | decky | 205 | |
1783 | jermar | 206 | void *ofw_claim(const void *virt, const int len) |
207 | { |
||
208 | ofw_arg_t retaddr; |
||
209 | int shift; |
||
953 | decky | 210 | |
1783 | jermar | 211 | if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len, virt) != 0) { |
212 | puts("Error: MMU method claim() failed, halting.\n"); |
||
213 | halt(); |
||
214 | } |
||
215 | |||
216 | return (void *) retaddr; |
||
217 | } |
||
218 | |||
1075 | decky | 219 | int ofw_map(const void *phys, const void *virt, const int size, const int mode) |
220 | { |
||
1782 | jermar | 221 | uintptr_t phys_hi, phys_lo; |
222 | |||
223 | if (sizeof(unative_t) == 8) { |
||
224 | int shift = 32; |
||
225 | phys_hi = (uintptr_t) phys >> shift; |
||
226 | phys_lo = (uintptr_t) phys & 0xffffffff; |
||
227 | } else { |
||
228 | phys_hi = 0; |
||
229 | phys_lo = (uintptr_t) phys; |
||
230 | } |
||
231 | |||
232 | return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size, virt, |
||
233 | phys_hi, phys_lo); |
||
1075 | decky | 234 | } |
235 | |||
2048 | jermar | 236 | /** Save OpenFirmware physical memory map. |
237 | * |
||
238 | * @param map Memory map structure where the map will be saved. |
||
239 | * |
||
240 | * @return Zero on failure, non-zero on success. |
||
241 | */ |
||
964 | decky | 242 | int ofw_memmap(memmap_t *map) |
243 | { |
||
1789 | jermar | 244 | unsigned int ac = ofw_get_address_cells(ofw_memory); |
245 | unsigned int sc = ofw_get_size_cells(ofw_memory); |
||
246 | |||
2048 | jermar | 247 | uint32_t buf[((ac + sc) * MEMMAP_MAX_RECORDS)]; |
1771 | jermar | 248 | int ret = ofw_get_property(ofw_memory, "reg", buf, sizeof(buf)); |
1789 | jermar | 249 | if (ret <= 0) /* ret is the number of written bytes */ |
964 | decky | 250 | return false; |
1789 | jermar | 251 | |
1146 | decky | 252 | int pos; |
964 | decky | 253 | map->total = 0; |
254 | map->count = 0; |
||
2048 | jermar | 255 | for (pos = 0; (pos < ret / sizeof(uint32_t)) && (map->count < |
256 | MEMMAP_MAX_RECORDS); pos += ac + sc) { |
||
1789 | jermar | 257 | void * start = (void *) ((uintptr_t) buf[pos + ac - 1]); |
1146 | decky | 258 | unsigned int size = buf[pos + ac + sc - 1]; |
259 | |||
260 | if (size > 0) { |
||
261 | map->zones[map->count].start = start; |
||
262 | map->zones[map->count].size = size; |
||
263 | map->count++; |
||
264 | map->total += size; |
||
265 | } |
||
964 | decky | 266 | } |
1789 | jermar | 267 | |
268 | return true; |
||
964 | decky | 269 | } |
1130 | decky | 270 | |
271 | |||
272 | int ofw_screen(screen_t *screen) |
||
273 | { |
||
1146 | decky | 274 | char device_name[BUF_SIZE]; |
1789 | jermar | 275 | uint32_t virtaddr; |
1130 | decky | 276 | |
1771 | jermar | 277 | if (ofw_get_property(ofw_aliases, "screen", device_name, sizeof(device_name)) <= 0) |
1130 | decky | 278 | return false; |
279 | |||
280 | phandle device = ofw_find_device(device_name); |
||
281 | if (device == -1) |
||
282 | return false; |
||
283 | |||
1789 | jermar | 284 | if (ofw_get_property(device, "address", &virtaddr, sizeof(virtaddr)) <= 0) |
1130 | decky | 285 | return false; |
1789 | jermar | 286 | |
287 | screen->addr = (void *) ((uintptr_t) virtaddr); |
||
288 | |||
1130 | decky | 289 | if (ofw_get_property(device, "width", &screen->width, sizeof(screen->width)) <= 0) |
290 | return false; |
||
291 | |||
292 | if (ofw_get_property(device, "height", &screen->height, sizeof(screen->height)) <= 0) |
||
293 | return false; |
||
294 | |||
295 | if (ofw_get_property(device, "depth", &screen->bpp, sizeof(screen->bpp)) <= 0) |
||
296 | return false; |
||
297 | |||
298 | if (ofw_get_property(device, "linebytes", &screen->scanline, sizeof(screen->scanline)) <= 0) |
||
299 | return false; |
||
300 | |||
301 | return true; |
||
302 | } |
||
1947 | decky | 303 | |
304 | |||
305 | void ofw_quiesce(void) |
||
306 | { |
||
1977 | jermar | 307 | ofw_call("quiesce", 0, 0, NULL); |
1947 | decky | 308 | } |