![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ofmem_common.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / libopenbios|
Return to ofmem_common.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / libopenbios |
1.1 ! root 1: /* ! 2: * <ofmem_common.c> ! 3: * ! 4: * OF Memory manager ! 5: * ! 6: * Copyright (C) 1999-2004 Samuel Rydh ([email protected]) ! 7: * Copyright (C) 2004 Stefan Reinauer ! 8: * ! 9: * This program is free software; you can redistribute it and/or ! 10: * modify it under the terms of the GNU General Public License ! 11: * as published by the Free Software Foundation ! 12: * ! 13: */ ! 14: ! 15: #include "config.h" ! 16: #include "libopenbios/bindings.h" ! 17: #include "libopenbios/ofmem.h" ! 18: ! 19: /* Default size of memory allocated for each of the MMU properties (in bytes) */ ! 20: #define OFMEM_DEFAULT_PROP_SIZE 2048 ! 21: ! 22: /* ! 23: * define OFMEM_FILL_RANGE to claim any unclaimed virtual and ! 24: * physical memory in the range for ofmem_map ! 25: * ! 26: * TODO: remove this macro and wrapped code if not needed by implementations ! 27: */ ! 28: //#define OFMEM_FILL_RANGE ! 29: ! 30: ! 31: static inline size_t align_size(size_t x, size_t a) ! 32: { ! 33: return (x + a - 1) & ~(a - 1); ! 34: } ! 35: ! 36: static inline phys_addr_t align_ptr(uintptr_t x, size_t a) ! 37: { ! 38: return (x + a - 1) & ~(a - 1); ! 39: } ! 40: ! 41: static ucell get_ram_size( void ) ! 42: { ! 43: ofmem_t *ofmem = ofmem_arch_get_private(); ! 44: return ofmem->ramsize; ! 45: } ! 46: ! 47: /************************************************************************/ ! 48: /* debug */ ! 49: /************************************************************************/ ! 50: ! 51: #if 0 ! 52: static void ! 53: print_range( range_t *r, char *str ) ! 54: { ! 55: printk("--- Range %s ---\n", str ); ! 56: for( ; r; r=r->next ) ! 57: printk(FMT_plx " - " FMT_plx "\n", r->start, r->start + r->size - 1); ! 58: printk("\n"); ! 59: } ! 60: ! 61: static void ! 62: print_phys_range() ! 63: { ! 64: print_range( ofmem.phys_range, "phys" ); ! 65: } ! 66: ! 67: static void ! 68: print_virt_range() ! 69: { ! 70: print_range( ofmem.virt_range, "virt" ); ! 71: } ! 72: ! 73: static void ! 74: print_trans( void ) ! 75: { ! 76: translation_t *t = ofmem.trans; ! 77: ! 78: printk("--- Translations ---\n"); ! 79: for( ; t; t=t->next ) ! 80: printk("%08lx -> " FMT_plx " [size %lx]\n", t->virt, t->phys, t->size); ! 81: printk("\n"); ! 82: } ! 83: #endif ! 84: ! 85: /************************************************************************/ ! 86: /* OF private allocations */ ! 87: /************************************************************************/ ! 88: ! 89: int ofmem_posix_memalign( void **memptr, size_t alignment, size_t size ) ! 90: { ! 91: ofmem_t *ofmem = ofmem_arch_get_private(); ! 92: alloc_desc_t *d, **pp; ! 93: void *ret; ! 94: ucell top; ! 95: phys_addr_t pa; ! 96: ! 97: if( !size ) ! 98: return ENOMEM; ! 99: ! 100: if( !ofmem->next_malloc ) ! 101: ofmem->next_malloc = (char*)ofmem_arch_get_malloc_base(); ! 102: ! 103: size = align_size(size + sizeof(alloc_desc_t), alignment); ! 104: ! 105: /* look in the freelist */ ! 106: for( pp=&ofmem->mfree; *pp && (**pp).size < size; pp = &(**pp).next ) { ! 107: } ! 108: ! 109: /* waste at most 4K by taking an entry from the freelist */ ! 110: if( *pp && (**pp).size < size + 0x1000 ) { ! 111: /* Alignment should be on physical not virtual address */ ! 112: pa = va2pa((uintptr_t)*pp + sizeof(alloc_desc_t)); ! 113: pa = align_ptr(pa, alignment); ! 114: ret = (void *)pa2va(pa); ! 115: ! 116: memset( ret, 0, (**pp).size - sizeof(alloc_desc_t) ); ! 117: *pp = (**pp).next; ! 118: ! 119: *memptr = ret; ! 120: return 0; ! 121: } ! 122: ! 123: top = ofmem_arch_get_heap_top(); ! 124: ! 125: /* Alignment should be on physical not virtual address */ ! 126: pa = va2pa((uintptr_t)ofmem->next_malloc + sizeof(alloc_desc_t)); ! 127: pa = align_ptr(pa, alignment); ! 128: ret = (void *)pa2va(pa); ! 129: ! 130: if( pointer2cell(ret) + size > top ) { ! 131: printk("out of malloc memory (%x)!\n", size ); ! 132: return ENOMEM; ! 133: } ! 134: ! 135: d = (alloc_desc_t*)((uintptr_t)ret - sizeof(alloc_desc_t)); ! 136: ofmem->next_malloc += size; ! 137: ! 138: d->next = NULL; ! 139: d->size = size; ! 140: ! 141: memset( ret, 0, size - sizeof(alloc_desc_t) ); ! 142: ! 143: *memptr = ret; ! 144: return 0; ! 145: } ! 146: ! 147: void* ofmem_malloc( size_t size ) ! 148: { ! 149: void *memptr; ! 150: int res; ! 151: ! 152: res = ofmem_posix_memalign( &memptr, CONFIG_OFMEM_MALLOC_ALIGN, size ); ! 153: if (!res) { ! 154: /* Success */ ! 155: return memptr; ! 156: } else { ! 157: /* Failure */ ! 158: return NULL; ! 159: } ! 160: } ! 161: ! 162: void ofmem_free( void *ptr ) ! 163: { ! 164: ofmem_t *ofmem = ofmem_arch_get_private(); ! 165: alloc_desc_t **pp, *d; ! 166: ! 167: /* it is legal to free NULL pointers (size zero allocations) */ ! 168: if( !ptr ) ! 169: return; ! 170: ! 171: d = (alloc_desc_t*)((char *)ptr - sizeof(alloc_desc_t)); ! 172: d->next = ofmem->mfree; ! 173: ! 174: /* insert in the (sorted) freelist */ ! 175: for( pp=&ofmem->mfree; *pp && (**pp).size < d->size ; pp = &(**pp).next ) { ! 176: } ! 177: ! 178: d->next = *pp; ! 179: *pp = d; ! 180: } ! 181: ! 182: void* ofmem_realloc( void *ptr, size_t size ) ! 183: { ! 184: alloc_desc_t *d = (alloc_desc_t*)((char *)ptr - sizeof(alloc_desc_t)); ! 185: char *p; ! 186: ! 187: if( !ptr ) ! 188: return malloc( size ); ! 189: if( !size ) { ! 190: free( ptr ); ! 191: return NULL; ! 192: } ! 193: p = malloc( size ); ! 194: memcpy( p, ptr, MIN(d->size - sizeof(alloc_desc_t),size) ); ! 195: free( ptr ); ! 196: return p; ! 197: } ! 198: ! 199: ! 200: /************************************************************************/ ! 201: /* "translations" and "available" property tracking */ ! 202: /************************************************************************/ ! 203: ! 204: static int trans_prop_size = 0, phys_range_prop_size = 0, virt_range_prop_size = 0; ! 205: static int trans_prop_used = 0, phys_range_prop_used = 0, virt_range_prop_used = 0; ! 206: static ucell *trans_prop, *phys_range_prop, *virt_range_prop; ! 207: ! 208: static void ! 209: ofmem_set_property( phandle_t ph, const char *name, const char *buf, int len ) ! 210: { ! 211: /* This is very similar to set_property() in libopenbios/bindings.c but allows ! 212: us to set the property pointer directly, rather than having to copy it ! 213: into the Forth dictonary every time we update the memory properties */ ! 214: if( !ph ) { ! 215: printk("ofmem_set_property: NULL phandle\n"); ! 216: return; ! 217: } ! 218: PUSH(pointer2cell(buf)); ! 219: PUSH(len); ! 220: push_str(name); ! 221: PUSH_ph(ph); ! 222: fword("encode-property"); ! 223: } ! 224: ! 225: phandle_t s_phandle_memory = 0; ! 226: phandle_t s_phandle_mmu = 0; ! 227: ! 228: static void ofmem_update_mmu_translations( void ) ! 229: { ! 230: ofmem_t *ofmem = ofmem_arch_get_private(); ! 231: translation_t *t; ! 232: int ncells, prop_used, prop_size; ! 233: ! 234: if (s_phandle_mmu == 0) ! 235: return; ! 236: ! 237: for( t = ofmem->trans, ncells = 0; t ; t=t->next, ncells++ ) { ! 238: } ! 239: ! 240: /* Get the current number of bytes required for the MMU translation property */ ! 241: prop_used = ncells * sizeof(ucell) * ofmem_arch_get_translation_entry_size(); ! 242: ! 243: if (prop_used > trans_prop_size) { ! 244: ! 245: /* The property doesn't fit within the existing space, so keep doubling it ! 246: until it does */ ! 247: prop_size = trans_prop_size; ! 248: while (prop_size < prop_used) { ! 249: prop_size *= 2; ! 250: } ! 251: ! 252: /* Allocate the new memory and copy all of the existing information across */ ! 253: trans_prop = realloc(trans_prop, prop_size); ! 254: trans_prop_size = prop_size; ! 255: trans_prop_used = prop_used; ! 256: } ! 257: ! 258: if (trans_prop == NULL) { ! 259: /* out of memory! */ ! 260: printk("Unable to allocate memory for translations property!\n"); ! 261: return; ! 262: } ! 263: ! 264: /* Call architecture-specific routines to generate translation entries */ ! 265: for( t = ofmem->trans, ncells = 0 ; t ; t=t->next ) { ! 266: ofmem_arch_create_translation_entry(&trans_prop[ncells], t); ! 267: ncells += ofmem_arch_get_translation_entry_size(); ! 268: } ! 269: ! 270: ofmem_set_property(s_phandle_mmu, "translations", ! 271: (char*)trans_prop, ncells * sizeof(trans_prop[0])); ! 272: ! 273: } ! 274: ! 275: ! 276: static void ofmem_update_memory_available( phandle_t ph, range_t *range, ! 277: ucell **mem_prop, int *mem_prop_size, int *mem_prop_used, u64 top_address ) ! 278: { ! 279: range_t *r; ! 280: int ncells, prop_used, prop_size; ! 281: phys_addr_t start; ! 282: ucell size, *prop; ! 283: ! 284: if (s_phandle_memory == 0) ! 285: return; ! 286: ! 287: /* count phys_range list entries */ ! 288: for( r = range, ncells = 0; r ; r=r->next, ncells++ ) { ! 289: } ! 290: ! 291: /* inverse of phys_range list could take 2 or more additional cells for the tail ! 292: For /memory, physical addresses may be wider than one ucell. */ ! 293: prop_used = (ncells + 1) * sizeof(ucell) * ofmem_arch_get_available_entry_size(ph) + 1; ! 294: ! 295: if (prop_used > *mem_prop_size) { ! 296: ! 297: /* The property doesn't fit within the existing space, so keep doubling it ! 298: until it does */ ! 299: prop_size = *mem_prop_size; ! 300: while (prop_size < prop_used) { ! 301: prop_size *= 2; ! 302: } ! 303: ! 304: /* Allocate the new memory and copy all of the existing information across */ ! 305: *mem_prop = realloc(*mem_prop, prop_size); ! 306: *mem_prop_size = prop_size; ! 307: *mem_prop_used = prop_used; ! 308: } ! 309: ! 310: if (*mem_prop == NULL) { ! 311: /* out of memory! */ ! 312: printk("Unable to allocate memory for memory range property!\n"); ! 313: return; ! 314: } ! 315: ! 316: start = 0; ! 317: ncells = 0; ! 318: prop = *mem_prop; ! 319: ! 320: for (r = range; r; r=r->next) { ! 321: if (r->start >= top_address) { ! 322: break; ! 323: } ! 324: ! 325: size = r->start - start; ! 326: if (size) { ! 327: ofmem_arch_create_available_entry(ph, &prop[ncells], start, size); ! 328: ncells += ofmem_arch_get_available_entry_size(ph); ! 329: } ! 330: start = r->start + r->size; ! 331: } ! 332: ! 333: /* tail */ ! 334: if (start < top_address) { ! 335: ofmem_arch_create_available_entry(ph, &prop[ncells], start, top_address - start); ! 336: ncells += ofmem_arch_get_available_entry_size(ph); ! 337: } ! 338: ! 339: ofmem_set_property(ph, "available", ! 340: (char*)prop, ncells * sizeof(prop[0])); ! 341: } ! 342: ! 343: static void ofmem_update_translations( void ) ! 344: { ! 345: ofmem_t *ofmem = ofmem_arch_get_private(); ! 346: ! 347: ofmem_update_memory_available(s_phandle_memory, ofmem->phys_range, ! 348: &phys_range_prop, &phys_range_prop_size, &phys_range_prop_used, ofmem_arch_get_phys_top()); ! 349: ofmem_update_memory_available(s_phandle_mmu, ofmem->virt_range, ! 350: &virt_range_prop, &virt_range_prop_size, &virt_range_prop_used, (ucell)-1); ! 351: ofmem_update_mmu_translations(); ! 352: } ! 353: ! 354: ! 355: /************************************************************************/ ! 356: /* client interface */ ! 357: /************************************************************************/ ! 358: ! 359: static int is_free( phys_addr_t ea, ucell size, range_t *r ) ! 360: { ! 361: if( size == 0 ) ! 362: return 1; ! 363: for( ; r ; r=r->next ) { ! 364: if( r->start + r->size - 1 >= ea && r->start <= ea ) ! 365: return 0; ! 366: if( r->start >= ea && r->start <= ea + size - 1 ) ! 367: return 0; ! 368: } ! 369: return 1; ! 370: } ! 371: ! 372: static void add_entry_( phys_addr_t ea, ucell size, range_t **r ) ! 373: { ! 374: range_t *nr; ! 375: ! 376: for( ; *r && (**r).start < ea; r=&(**r).next ) { ! 377: } ! 378: ! 379: nr = (range_t*)malloc( sizeof(range_t) ); ! 380: nr->next = *r; ! 381: nr->start = ea; ! 382: nr->size = size; ! 383: *r = nr; ! 384: } ! 385: ! 386: static int add_entry( phys_addr_t ea, ucell size, range_t **r ) ! 387: { ! 388: if( !is_free( ea, size, *r ) ) { ! 389: OFMEM_TRACE("add_entry: range not free!\n"); ! 390: return -1; ! 391: } ! 392: add_entry_( ea, size, r ); ! 393: return 0; ! 394: } ! 395: ! 396: #if defined(OFMEM_FILL_RANGE) ! 397: static void join_ranges( range_t **rr ) ! 398: { ! 399: range_t *n, *r = *rr; ! 400: while( r ) { ! 401: if( !(n=r->next) ) ! 402: break; ! 403: ! 404: if( r->start + r->size - 1 >= n->start -1 ) { ! 405: int s = n->size + (n->start - r->start - r->size); ! 406: if( s > 0 ) ! 407: r->size += s; ! 408: r->next = n->next; ! 409: free( n ); ! 410: continue; ! 411: } ! 412: r=r->next; ! 413: } ! 414: } ! 415: ! 416: static void fill_range( phys_addr_t ea, ucell size, range_t **rr ) ! 417: { ! 418: add_entry_( ea, size, rr ); ! 419: join_ranges( rr ); ! 420: } ! 421: #endif ! 422: ! 423: static ucell find_area( ucell align, ucell size, range_t *r, ! 424: phys_addr_t min, phys_addr_t max, int reverse ) ! 425: { ! 426: phys_addr_t base = min; ! 427: range_t *r2; ! 428: ! 429: if( (align & (align-1)) ) { ! 430: OFMEM_TRACE("bad alignment " FMT_ucell "\n", align); ! 431: align = 0x1000; ! 432: } ! 433: if( !align ) ! 434: align = 0x1000; ! 435: ! 436: base = reverse ? max - size : min; ! 437: r2 = reverse ? NULL : r; ! 438: ! 439: for( ;; ) { ! 440: if( !reverse ) { ! 441: base = (base + align - 1) & ~(align-1); ! 442: if( base < min ) ! 443: base = min; ! 444: if( base + size - 1 >= max -1 ) ! 445: break; ! 446: } else { ! 447: if( base > max - size ) ! 448: base = max - size; ! 449: base -= base & (align-1); ! 450: } ! 451: if( is_free( base, size, r ) ) ! 452: return base; ! 453: ! 454: if( !reverse ) { ! 455: if( !r2 ) ! 456: break; ! 457: base = r2->start + r2->size; ! 458: r2 = r2->next; ! 459: } else { ! 460: range_t *rp; ! 461: ! 462: for( rp=r; rp && rp->next != r2 ; rp=rp->next ) { ! 463: } ! 464: ! 465: r2 = rp; ! 466: if( !r2 ) ! 467: break; ! 468: base = r2->start - size; ! 469: } ! 470: } ! 471: return -1; ! 472: } ! 473: ! 474: static phys_addr_t ofmem_claim_phys_( phys_addr_t phys, ucell size, ucell align, ! 475: phys_addr_t min, phys_addr_t max, int reverse ) ! 476: { ! 477: ofmem_t *ofmem = ofmem_arch_get_private(); ! 478: if( !align ) { ! 479: if( !is_free( phys, size, ofmem->phys_range ) ) { ! 480: OFMEM_TRACE("Non-free physical memory claimed!\n"); ! 481: return -1; ! 482: } ! 483: add_entry( phys, size, &ofmem->phys_range ); ! 484: ofmem_update_translations(); ! 485: return phys; ! 486: } ! 487: phys = find_area( align, size, ofmem->phys_range, min, max, reverse ); ! 488: if( phys == -1 ) { ! 489: printk("ofmem_claim_phys - out of space (failed request for " FMT_ucellx " bytes)\n", size); ! 490: return -1; ! 491: } ! 492: add_entry( phys, size, &ofmem->phys_range ); ! 493: ! 494: ofmem_update_translations(); ! 495: ! 496: return phys; ! 497: } ! 498: ! 499: /* if align != 0, phys is ignored. Returns -1 on error */ ! 500: phys_addr_t ofmem_claim_phys( phys_addr_t phys, ucell size, ucell align ) ! 501: { ! 502: OFMEM_TRACE("ofmem_claim phys=" FMT_plx " size=" FMT_ucellx ! 503: " align=" FMT_ucellx "\n", ! 504: phys, size, align); ! 505: ! 506: return ofmem_claim_phys_( phys, size, align, 0, ofmem_arch_get_phys_top(), 1 ); ! 507: } ! 508: ! 509: static ucell ofmem_claim_virt_( ucell virt, ucell size, ucell align, ! 510: ucell min, ucell max, int reverse ) ! 511: { ! 512: ofmem_t *ofmem = ofmem_arch_get_private(); ! 513: if( !align ) { ! 514: if( !is_free( virt, size, ofmem->virt_range ) ) { ! 515: OFMEM_TRACE("Non-free virtual memory claimed!\n"); ! 516: return -1; ! 517: } ! 518: add_entry( virt, size, &ofmem->virt_range ); ! 519: ofmem_update_translations(); ! 520: return virt; ! 521: } ! 522: ! 523: virt = find_area( align, size, ofmem->virt_range, min, max, reverse ); ! 524: if( virt == -1 ) { ! 525: printk("ofmem_claim_virt - out of space (failed request for " FMT_ucellx " bytes)\n", size); ! 526: return -1; ! 527: } ! 528: add_entry( virt, size, &ofmem->virt_range ); ! 529: ! 530: ofmem_update_translations(); ! 531: ! 532: return virt; ! 533: } ! 534: ! 535: ucell ofmem_claim_virt( ucell virt, ucell size, ucell align ) ! 536: { ! 537: OFMEM_TRACE("ofmem_claim_virt virt=" FMT_ucellx " size=" FMT_ucellx ! 538: " align=" FMT_ucellx "\n", ! 539: virt, size, align); ! 540: ! 541: /* printk("+ ofmem_claim virt %08lx %lx %ld\n", virt, size, align ); */ ! 542: return ofmem_claim_virt_( virt, size, align, ! 543: get_ram_size(), ofmem_arch_get_virt_top(), 1 ); ! 544: } ! 545: ! 546: static ucell ofmem_claim_io_( ucell virt, ucell size, ucell align, ! 547: ucell min, ucell max, int reverse ) ! 548: { ! 549: ofmem_t *ofmem = ofmem_arch_get_private(); ! 550: if( !align ) { ! 551: if( !is_free( virt, size, ofmem->io_range ) ) { ! 552: OFMEM_TRACE("Non-free I/O memory claimed!\n"); ! 553: return -1; ! 554: } ! 555: add_entry( virt, size, &ofmem->io_range ); ! 556: return virt; ! 557: } ! 558: ! 559: virt = find_area( align, size, ofmem->io_range, min, max, reverse ); ! 560: if( virt == -1 ) { ! 561: printk("ofmem_claim_io - out of space (failed request for " FMT_ucellx " bytes)\n", size); ! 562: return -1; ! 563: } ! 564: add_entry( virt, size, &ofmem->io_range ); ! 565: return virt; ! 566: } ! 567: ! 568: ucell ofmem_claim_io( ucell virt, ucell size, ucell align ) ! 569: { ! 570: /* Claim a section of memory from the I/O range */ ! 571: return ofmem_claim_io_( virt, size, align, ! 572: ofmem_arch_get_iomem_base(), ofmem_arch_get_iomem_top(), 0 ); ! 573: } ! 574: ! 575: /* if align != 0, phys is ignored. Returns -1 on error */ ! 576: phys_addr_t ofmem_retain( phys_addr_t phys, ucell size, ucell align ) ! 577: { ! 578: retain_t *retained = ofmem_arch_get_retained(); ! 579: phys_addr_t retain_phys; ! 580: ! 581: OFMEM_TRACE("ofmem_retain phys=" FMT_plx " size=" FMT_ucellx ! 582: " align=" FMT_ucellx "\n", ! 583: phys, size, align); ! 584: ! 585: retain_phys = ofmem_claim_phys_( phys, size, align, 0, get_ram_size(), 0 ); ! 586: ! 587: /* Add to the retain_phys_range list */ ! 588: retained->retain_phys_range[retained->numentries].next = NULL; ! 589: retained->retain_phys_range[retained->numentries].start = retain_phys; ! 590: retained->retain_phys_range[retained->numentries].size = size; ! 591: retained->numentries++; ! 592: ! 593: return retain_phys; ! 594: } ! 595: ! 596: /* allocate both physical and virtual space and add a translation */ ! 597: ucell ofmem_claim( ucell addr, ucell size, ucell align ) ! 598: { ! 599: ofmem_t *ofmem = ofmem_arch_get_private(); ! 600: ucell virt; ! 601: phys_addr_t phys; ! 602: ucell offs = addr & 0xfff; ! 603: ! 604: OFMEM_TRACE("ofmem_claim " FMT_ucellx " " FMT_ucellx " " FMT_ucellx "\n", addr, size, align ); ! 605: virt = phys = 0; ! 606: if( !align ) { ! 607: if( is_free(addr, size, ofmem->virt_range) && ! 608: is_free(addr, size, ofmem->phys_range) ) { ! 609: ofmem_claim_phys_( addr, size, 0, 0, 0, 0 ); ! 610: ofmem_claim_virt_( addr, size, 0, 0, 0, 0 ); ! 611: virt = phys = addr; ! 612: } else { ! 613: OFMEM_TRACE("**** ofmem_claim failure ***!\n"); ! 614: return -1; ! 615: } ! 616: } else { ! 617: if( align < 0x1000 ) ! 618: align = 0x1000; ! 619: phys = ofmem_claim_phys_( addr, size, align, 0, ofmem_arch_get_phys_top(), 1 /* reverse */ ); ! 620: virt = ofmem_claim_virt_( addr, size, align, 0, get_ram_size(), 1 /* reverse */ ); ! 621: if( phys == -1 || virt == -1 ) { ! 622: OFMEM_TRACE("ofmem_claim failed\n"); ! 623: return -1; ! 624: } ! 625: /* printk("...phys = %08lX, virt = %08lX, size = %08lX\n", phys, virt, size ); */ ! 626: } ! 627: ! 628: /* align */ ! 629: if( phys & 0xfff ) { ! 630: size += (phys & 0xfff); ! 631: virt -= (phys & 0xfff); ! 632: phys &= ~0xfff; ! 633: } ! 634: if( size & 0xfff ) ! 635: size = (size + 0xfff) & ~0xfff; ! 636: ! 637: /* printk("...free memory found... phys: %08lX, virt: %08lX, size %lX\n", phys, virt, size ); */ ! 638: ofmem_map( phys, virt, size, -1 ); ! 639: return virt + offs; ! 640: } ! 641: ! 642: ! 643: /************************************************************************/ ! 644: /* keep track of ea -> phys translations */ ! 645: /************************************************************************/ ! 646: ! 647: static void split_trans( ucell virt ) ! 648: { ! 649: ofmem_t *ofmem = ofmem_arch_get_private(); ! 650: translation_t *t, *t2; ! 651: ! 652: for( t=ofmem->trans; t; t=t->next ) { ! 653: if( virt > t->virt && virt < t->virt + t->size-1 ) { ! 654: t2 = (translation_t*)malloc( sizeof(translation_t) ); ! 655: t2->virt = virt; ! 656: t2->size = t->size - (virt - t->virt); ! 657: t->size = virt - t->virt; ! 658: t2->phys = t->phys + t->size; ! 659: t2->mode = t->mode; ! 660: t2->next = t->next; ! 661: t->next = t2; ! 662: } ! 663: } ! 664: } ! 665: ! 666: int ofmem_map_page_range( phys_addr_t phys, ucell virt, ucell size, ucell mode ) ! 667: { ! 668: ofmem_t *ofmem = ofmem_arch_get_private(); ! 669: translation_t *t, **tt; ! 670: ! 671: OFMEM_TRACE("ofmem_map_page_range " FMT_ucellx ! 672: " -> " FMT_plx " " FMT_ucellx " mode " FMT_ucellx "\n", ! 673: virt, phys, size, mode ); ! 674: ! 675: split_trans( virt ); ! 676: split_trans( virt + size ); ! 677: ! 678: /* detect remappings */ ! 679: for( t=ofmem->trans; t; ) { ! 680: if( virt == t->virt || (virt < t->virt && virt + size > t->virt )) { ! 681: if( t->phys + virt - t->virt != phys ) { ! 682: OFMEM_TRACE("mapping altered virt=" FMT_ucellx ")\n", t->virt ); ! 683: } else if( t->mode != mode ){ ! 684: OFMEM_TRACE("mapping mode altered virt=" FMT_ucellx ! 685: " old mode=" FMT_ucellx " new mode=" FMT_ucellx "\n", ! 686: t->virt, t->mode, mode); ! 687: } ! 688: ! 689: for( tt=&ofmem->trans; *tt != t ; tt=&(**tt).next ) { ! 690: } ! 691: ! 692: *tt = t->next; ! 693: ! 694: /* really unmap these pages */ ! 695: ofmem_arch_unmap_pages(t->virt, t->size); ! 696: ! 697: free((char*)t); ! 698: ! 699: t=ofmem->trans; ! 700: continue; ! 701: } ! 702: t=t->next; ! 703: } ! 704: ! 705: /* add mapping */ ! 706: for( tt=&ofmem->trans; *tt && (**tt).virt < virt ; tt=&(**tt).next ) { ! 707: } ! 708: ! 709: t = (translation_t*)malloc( sizeof(translation_t) ); ! 710: t->virt = virt; ! 711: t->phys = phys; ! 712: t->size = size; ! 713: t->mode = mode; ! 714: t->next = *tt; ! 715: *tt = t; ! 716: ! 717: ofmem_update_translations(); ! 718: ! 719: return 0; ! 720: } ! 721: ! 722: static int unmap_page_range( ucell virt, ucell size ) ! 723: { ! 724: ofmem_t *ofmem = ofmem_arch_get_private(); ! 725: translation_t **plink; ! 726: ! 727: /* make sure there is exactly one matching translation entry */ ! 728: ! 729: split_trans( virt ); ! 730: split_trans( virt + size ); ! 731: ! 732: /* find and unlink entries in range */ ! 733: plink = &ofmem->trans; ! 734: ! 735: while (*plink && (*plink)->virt < virt+size) { ! 736: translation_t **plinkentry = plink; ! 737: translation_t *t = *plink; ! 738: ! 739: /* move ahead */ ! 740: plink = &t->next; ! 741: ! 742: if (t->virt >= virt && t->virt + t->size <= virt+size) { ! 743: ! 744: /* unlink entry */ ! 745: *plinkentry = t->next; ! 746: ! 747: OFMEM_TRACE("unmap_page_range found " ! 748: FMT_ucellx " -> " FMT_plx " " FMT_ucellx ! 749: " mode " FMT_ucellx "\n", ! 750: t->virt, t->phys, t->size, t->mode ); ! 751: ! 752: // really map these pages ! 753: ofmem_arch_unmap_pages(t->virt, t->size); ! 754: ! 755: free((char*)t); ! 756: } ! 757: } ! 758: ! 759: ofmem_update_translations(); ! 760: ! 761: return 0; ! 762: } ! 763: ! 764: int ofmem_map( phys_addr_t phys, ucell virt, ucell size, ucell mode ) ! 765: { ! 766: /* printk("+ofmem_map: %08lX --> %08lX (size %08lX, mode 0x%02X)\n", ! 767: virt, phys, size, mode ); */ ! 768: ! 769: if( (phys & 0xfff) || (virt & 0xfff) || (size & 0xfff) ) { ! 770: ! 771: OFMEM_TRACE("ofmem_map: Bad parameters (" ! 772: FMT_plx " " FMT_ucellX " " FMT_ucellX ")\n", ! 773: phys, virt, size ); ! 774: ! 775: phys &= ~0xfff; ! 776: virt &= ~0xfff; ! 777: size = (size + 0xfff) & ~0xfff; ! 778: } ! 779: ! 780: #if defined(OFMEM_FILL_RANGE) ! 781: { ! 782: ofmem_t *ofmem = ofmem_arch_get_private(); ! 783: /* claim any unclaimed virtual memory in the range */ ! 784: fill_range( virt, size, &ofmem->virt_range ); ! 785: /* hmm... we better claim the physical range too */ ! 786: fill_range( phys, size, &ofmem->phys_range ); ! 787: } ! 788: #endif ! 789: ! 790: if (mode==-1) { ! 791: mode = ofmem_arch_default_translation_mode(phys); ! 792: } ! 793: ! 794: /* install translations */ ! 795: ofmem_map_page_range(phys, virt, size, mode); ! 796: ! 797: /* allow arch to install mappings early, e.g. for locked mappings */ ! 798: ofmem_arch_early_map_pages(phys, virt, size, mode); ! 799: ! 800: return 0; ! 801: } ! 802: ! 803: int ofmem_unmap( ucell virt, ucell size ) ! 804: { ! 805: OFMEM_TRACE("ofmem_unmap " FMT_ucellx " " FMT_ucellx "\n", ! 806: virt, size ); ! 807: ! 808: if( (virt & 0xfff) || (size & 0xfff) ) { ! 809: /* printk("ofmem_unmap: Bad parameters (%08lX %08lX)\n", ! 810: virt, size ); */ ! 811: virt &= ~0xfff; ! 812: size = (size + 0xfff) & ~0xfff; ! 813: } ! 814: ! 815: /* remove translations and unmap pages */ ! 816: unmap_page_range(virt, size); ! 817: ! 818: return 0; ! 819: } ! 820: ! 821: ucell ofmem_map_io( phys_addr_t phys, ucell size ) ! 822: { ! 823: /* Claim virtual memory from the I/O range and map the page-aligned ! 824: physical address phys to it, returning the newly allocated ! 825: virtual address */ ! 826: ucell virt, mode; ! 827: phys_addr_t off; ! 828: int npages; ! 829: ! 830: off = phys & (PAGE_SIZE - 1); ! 831: npages = (off + size - 1) / PAGE_SIZE + 1; ! 832: phys &= ~(PAGE_SIZE - 1); ! 833: ! 834: virt = ofmem_claim_io(-1, npages * PAGE_SIZE, PAGE_SIZE); ! 835: ! 836: mode = ofmem_arch_io_translation_mode(off); ! 837: ! 838: ofmem_map_page_range(phys, virt, npages * PAGE_SIZE, mode); ! 839: ofmem_arch_early_map_pages(phys, virt, npages * PAGE_SIZE, mode); ! 840: ! 841: return (virt + off); ! 842: } ! 843: ! 844: /* virtual -> physical. */ ! 845: phys_addr_t ofmem_translate( ucell virt, ucell *mode ) ! 846: { ! 847: ofmem_t *ofmem = ofmem_arch_get_private(); ! 848: translation_t *t; ! 849: ! 850: for( t=ofmem->trans; t && t->virt <= virt ; t=t->next ) { ! 851: ucell offs; ! 852: if( t->virt + t->size - 1 < virt ) ! 853: continue; ! 854: offs = virt - t->virt; ! 855: *mode = t->mode; ! 856: return t->phys + offs; ! 857: } ! 858: ! 859: /*printk("ofmem_translate: no translation defined (%08lx)\n", virt);*/ ! 860: /*print_trans();*/ ! 861: return -1; ! 862: } ! 863: ! 864: static void remove_range( ucell ea, ucell size, range_t **r ) ! 865: { ! 866: OFMEM_TRACE("%s: not implemented\n", __func__); ! 867: } ! 868: ! 869: /* release memory allocated by ofmem_claim_phys */ ! 870: void ofmem_release_phys( phys_addr_t phys, ucell size ) ! 871: { ! 872: OFMEM_TRACE("ofmem_release_phys addr=" FMT_plx " size=" FMT_ucellx "\n", ! 873: phys, size); ! 874: ! 875: ofmem_t *ofmem = ofmem_arch_get_private(); ! 876: remove_range(phys, size, &ofmem->phys_range); ! 877: } ! 878: ! 879: /* release memory allocated by ofmem_claim_virt */ ! 880: void ofmem_release_virt( ucell virt, ucell size ) ! 881: { ! 882: OFMEM_TRACE("ofmem_release_virt addr=" FMT_ucellx " size=" FMT_ucellx "\n", ! 883: virt, size); ! 884: ! 885: ofmem_t *ofmem = ofmem_arch_get_private(); ! 886: remove_range(virt, size, &ofmem->virt_range); ! 887: } ! 888: ! 889: /* release memory allocated by ofmem_claim - 6.3.2.4 */ ! 890: void ofmem_release( ucell virt, ucell size ) ! 891: { ! 892: OFMEM_TRACE("%s addr=" FMT_ucellx " size=" FMT_ucellx "\n", ! 893: __func__, virt, size); ! 894: ! 895: ucell mode; ! 896: phys_addr_t phys = ofmem_translate(virt, &mode); ! 897: if (phys == (phys_addr_t)-1) { ! 898: OFMEM_TRACE("%s: no mapping\n", __func__); ! 899: return; ! 900: } ! 901: ofmem_unmap(virt, size); ! 902: ofmem_release_virt(virt, size); ! 903: ofmem_release_phys(phys, size); ! 904: } ! 905: ! 906: /************************************************************************/ ! 907: /* init / cleanup */ ! 908: /************************************************************************/ ! 909: ! 910: void ofmem_register( phandle_t ph_memory, phandle_t ph_mmu ) ! 911: { ! 912: s_phandle_memory = ph_memory; ! 913: s_phandle_mmu = ph_mmu; ! 914: ! 915: /* Initialise some default property sizes */ ! 916: trans_prop_size = phys_range_prop_size = virt_range_prop_size = OFMEM_DEFAULT_PROP_SIZE; ! 917: trans_prop = malloc(trans_prop_size); ! 918: phys_range_prop = malloc(phys_range_prop_size); ! 919: virt_range_prop = malloc(virt_range_prop_size); ! 920: ! 921: ofmem_update_translations(); ! 922: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.