Subversion Repositories HelenOS

Rev

Rev 2131 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2131 Rev 2307
Line 36... Line 36...
36
 
36
 
37
phandle ofw_chosen;
37
phandle ofw_chosen;
38
ihandle ofw_stdout;
38
ihandle ofw_stdout;
39
phandle ofw_root;
39
phandle ofw_root;
40
ihandle ofw_mmu;
40
ihandle ofw_mmu;
-
 
41
ihandle ofw_memory_prop;
41
phandle ofw_memory;
42
phandle ofw_memory;
42
phandle ofw_aliases;
43
phandle ofw_aliases;
43
 
44
 
44
void ofw_init(void)
45
void ofw_init(void)
45
{
46
{
46
    ofw_chosen = ofw_find_device("/chosen");
47
    ofw_chosen = ofw_find_device("/chosen");
47
    if (ofw_chosen == -1)
48
    if (ofw_chosen == -1)
48
        halt();
49
        halt();
49
   
50
   
50
    if (ofw_get_property(ofw_chosen, "stdout",  &ofw_stdout, sizeof(ofw_stdout)) <= 0)
51
    if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout, sizeof(ofw_stdout)) <= 0)
51
        ofw_stdout = 0;
52
        ofw_stdout = 0;
52
   
53
   
53
    ofw_root = ofw_find_device("/");
54
    ofw_root = ofw_find_device("/");
54
    if (ofw_root == -1) {
55
    if (ofw_root == -1) {
55
        puts("\r\nError: Unable to find / device, halted.\r\n");
56
        puts("\r\nError: Unable to find / device, halted.\r\n");
56
        halt();
57
        halt();
57
    }
58
    }
58
   
59
   
59
    if (ofw_get_property(ofw_chosen, "mmu",  &ofw_mmu, sizeof(ofw_mmu)) <= 0) {
60
    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
        puts("\r\nError: Unable to get mmu property, halted.\r\n");
61
        halt();
62
        halt();
62
    }
63
    }
-
 
64
    if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop, sizeof(ofw_memory_prop)) <= 0) {
-
 
65
        puts("\r\nError: Unable to get memory property, halted.\r\n");
-
 
66
        halt();
-
 
67
    }
63
 
68
 
64
    ofw_memory = ofw_find_device("/memory");
69
    ofw_memory = ofw_find_device("/memory");
65
    if (ofw_memory == -1) {
70
    if (ofw_memory == -1) {
66
        puts("\r\nError: Unable to find /memory device, halted.\r\n");
71
        puts("\r\nError: Unable to find /memory device, halted.\r\n");
67
        halt();
72
        halt();
Line 198... Line 203...
198
    if (sizeof(unative_t) == 8)
203
    if (sizeof(unative_t) == 8)
199
        shift = 32;
204
        shift = 32;
200
    else
205
    else
201
        shift = 0;
206
        shift = 0;
202
 
207
 
203
    return (void *) ((result[2]<<shift)|result[3]);
208
    return (void *) ((result[2] << shift) | result[3]);
204
}
209
}
205
 
210
 
206
void *ofw_claim(const void *virt, const int len)
211
void *ofw_claim_virt(const void *virt, const int len)
207
{
212
{
208
    ofw_arg_t retaddr;
213
    ofw_arg_t retaddr;
209
    int shift;
-
 
210
 
214
 
211
    if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len, virt) != 0) {
215
    if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len, virt) != 0) {
212
        puts("Error: MMU method claim() failed, halting.\n");
216
        puts("Error: MMU method claim() failed, halting.\n");
213
        halt();
217
        halt();
214
    }
218
    }
215
 
219
 
216
    return (void *) retaddr;
220
    return (void *) retaddr;
217
}
221
}
218
 
222
 
-
 
223
void *ofw_claim_phys(const void *phys, const int len)
-
 
224
{
-
 
225
    ofw_arg_t retaddr[2];
-
 
226
    int shift;
-
 
227
 
-
 
228
    if (sizeof(unative_t) == 8) {
-
 
229
        shift = 32;
-
 
230
        if (ofw_call("call-method", 6, 3, retaddr, "claim",
-
 
231
            ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift,
-
 
232
            ((uintptr_t) phys) & ((uint32_t) -1)) != 0) {
-
 
233
            /*
-
 
234
             * Note that this will help us to discover
-
 
235
             * conflicts between OpenFirmware allocations
-
 
236
             * and our use of physical memory.
-
 
237
             * It is better to detect collisions here
-
 
238
             * than to cope with weird errors later.
-
 
239
             *
-
 
240
             * So this is really not to make the loader
-
 
241
             * more generic; it is here for debugging
-
 
242
             * purposes.
-
 
243
             */
-
 
244
            puts("Error: memory method claim() failed, halting.\n");
-
 
245
            halt();
-
 
246
        }
-
 
247
    } else {
-
 
248
        shift = 0;
-
 
249
        /*
-
 
250
         * FIXME: the number of arguments is probably different...
-
 
251
         */
-
 
252
        puts("Error: 32-bit ofw_claim_phys not implemented.\n");
-
 
253
        halt();
-
 
254
    }
-
 
255
 
-
 
256
    return (void *) ((retaddr[0] << shift) | retaddr[1]);
-
 
257
}
-
 
258
 
219
int ofw_map(const void *phys, const void *virt, const int size, const int mode)
259
int ofw_map(const void *phys, const void *virt, const int size, const int mode)
220
{
260
{
221
    uintptr_t phys_hi, phys_lo;
261
    uintptr_t phys_hi, phys_lo;
222
 
262
 
223
    if (sizeof(unative_t) == 8) {
263
    if (sizeof(unative_t) == 8) {
Line 228... Line 268...
228
        phys_hi = 0;
268
        phys_hi = 0;
229
        phys_lo = (uintptr_t) phys;
269
        phys_lo = (uintptr_t) phys;
230
    }
270
    }
231
 
271
 
232
    return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size, virt,
272
    return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size, virt,
233
        phys_hi, phys_lo);
273
        phys_hi, phys_lo);
234
}
274
}
235
 
275
 
236
/** Save OpenFirmware physical memory map.
276
/** Save OpenFirmware physical memory map.
237
 *
277
 *
238
 * @param map Memory map structure where the map will be saved.
278
 * @param map Memory map structure where the map will be saved.
Line 250... Line 290...
250
        return false;
290
        return false;
251
 
291
 
252
    int pos;
292
    int pos;
253
    map->total = 0;
293
    map->total = 0;
254
    map->count = 0;
294
    map->count = 0;
255
    for (pos = 0; (pos < ret / sizeof(uint32_t)) && (map->count <
295
    for (pos = 0; (pos < ret / sizeof(uint32_t)) &&
256
        MEMMAP_MAX_RECORDS); pos += ac + sc) {
296
        (map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) {
257
        void * start = (void *) ((uintptr_t) buf[pos + ac - 1]);
297
        void * start = (void *) ((uintptr_t) buf[pos + ac - 1]);
258
        unsigned int size = buf[pos + ac + sc - 1];
298
        unsigned int size = buf[pos + ac + sc - 1];
259
       
299
       
260
        if (size > 0) {
300
        if (size > 0) {
261
            map->zones[map->count].start = start;
301
            map->zones[map->count].start = start;