Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 50177dcd in mainline


Ignore:
Timestamp:
2011-11-24T22:44:25Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
9aed144
Parents:
25c51c8
Message:

Add sparc64 support for frame_low/high_arch_init().

Location:
kernel/arch/sparc64/src/mm
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/sparc64/src/mm/sun4u/frame.c

    r25c51c8 r50177dcd  
    4141#include <macros.h>
    4242
     43// TODO: remove me
    4344uintptr_t last_frame = (uintptr_t) NULL;
    4445
     
    4748 * Walk the memory map and create frame zones according to it.
    4849 */
    49 void frame_low_arch_init(void)
     50static void frame_common_arch_init(bool low)
    5051{
    51         if (config.cpu_active == 1) {
    52                 unsigned int i;
     52        unsigned int i;
     53       
     54        for (i = 0; i < memmap.cnt; i++) {
     55                uintptr_t base;
     56                size_t size;
     57
     58                /*
     59                 * The memmap is created by HelenOS boot loader.
     60                 * It already contains no holes.
     61                 */
     62
     63                /* To be safe, make the available zone possibly smaller */
     64                base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
     65                size = ALIGN_DOWN(memmap.zones[i].size -
     66                    (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    5367               
    54                 for (i = 0; i < memmap.cnt; i++) {
    55                         /* To be safe, make the available zone possibly smaller */
    56                         uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    57                             FRAME_SIZE);
    58                         size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
    59                             (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    60                        
    61                         /*
    62                          * The memmap is created by HelenOS boot loader.
    63                          * It already contains no holes.
    64                          */
    65                        
    66                         pfn_t confdata = ADDR2PFN(new_start);
    67                        
     68                // TODO: remove me
     69                last_frame = max(last_frame, base + size);
     70
     71                if (!frame_adjust_zone_bounds(low, &base, &size))
     72                        continue;
     73 
     74                pfn_t confdata;
     75                pfn_t pfn = ADDR2PFN(base);
     76                size_t count = SIZE2FRAMES(size);
     77
     78                if (low) {
     79                        confdata = pfn;
    6880                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6981                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    7082                       
    71                         zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    72                             confdata, 0);
    73                        
    74                         last_frame = max(last_frame, new_start + new_size);
     83                        zone_create(pfn, count, confdata,
     84                            ZONE_AVAILABLE | ZONE_LOWMEM);
     85                } else {
     86                        confdata = zone_external_conf_alloc(count);
     87                        zone_create(pfn, count, confdata,
     88                            ZONE_AVAILABLE | ZONE_HIGHMEM);
    7589                }
     90        }
    7691               
    77                 /*
    78                  * On sparc64, physical memory can start on a non-zero address.
    79                  * The generic frame_init() only marks PFN 0 as not free, so we
    80                  * must mark the physically first frame not free explicitly
    81                  * here, no matter what is its address.
    82                  */
    83                 frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    84         }
     92}
     93
     94void frame_low_arch_init(void)
     95{
     96        if (config.cpu_active > 1)
     97                return;
     98       
     99        frame_common_arch_init(true);
     100       
     101        /*
     102         * On sparc64, physical memory can start on a non-zero address.
     103         * The generic frame_init() only marks PFN 0 as not free, so we
     104         * must mark the physically first frame not free explicitly
     105         * here, no matter what is its address.
     106         */
     107        frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    85108       
    86109        end_of_identity = PA2KA(last_frame);
     
    89112void frame_high_arch_init(void)
    90113{
     114        if (config.cpu_active > 1)
     115                return;
     116
     117        frame_common_arch_init(false);
    91118}
    92119
  • kernel/arch/sparc64/src/mm/sun4v/frame.c

    r25c51c8 r50177dcd  
    4545 * Walk the memory map and create frame zones according to it.
    4646 */
    47 void frame_low_arch_init(void)
     47static void frame_common_arch_init(bool low)
    4848{
    49         if (config.cpu_active == 1) {
    50                 unsigned int i;
     49        unsigned int i;
    5150               
    52                 for (i = 0; i < memmap.cnt; i++) {
    53                         /* To be safe, make the available zone possibly smaller */
    54                         uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    55                             FRAME_SIZE);
    56                         size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
    57                             (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    58                        
    59                         /*
    60                          * The memmap is created by HelenOS boot loader.
    61                          * It already contains no holes.
    62                          */
    63                        
    64                         pfn_t confdata = ADDR2PFN(new_start);
    65                        
     51        for (i = 0; i < memmap.cnt; i++) {
     52                uintptr_t base;
     53                size_t size;
     54
     55                /*
     56                 * The memmap is created by HelenOS boot loader.
     57                 * It already contains no holes.
     58                 */
     59
     60                /* To be safe, make the available zone possibly smaller */
     61                base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
     62                size = ALIGN_DOWN(memmap.zones[i].size -
     63                    (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     64               
     65                if (!frame_adjust_zone_bounds(low, &base, &size))
     66                        continue;
     67
     68                pfn_t confdata;
     69                pfn_t pfn = ADDR2PFN(base);
     70                size_t count = SIZE2FRAMES(size);
     71
     72                if (low) {
     73                        confdata = pfn;
    6674                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6775                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    6876                       
    69                         zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    70                             confdata, 0);
     77                        zone_create(pfn, count, confdata,
     78                            ZONE_AVAILABLE | ZONE_LOWMEM);
     79                } else {
     80                        confdata = zone_external_conf_alloc(count);
     81                        zone_create(pfn, count, confdata,
     82                            ZONE_AVAILABLE | ZONE_HIGHMEM);
    7183                }
     84        }
    7285               
    73                 /*
    74                  * On sparc64, physical memory can start on a non-zero address.
    75                  * The generic frame_init() only marks PFN 0 as not free, so we
    76                  * must mark the physically first frame not free explicitly
    77                  * here, no matter what is its address.
    78                  */
    79                 frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    80         }
     86}
     87
     88
     89void frame_low_arch_init(void)
     90{
     91        if (config.cpu_active > 1)
     92                return;
     93
     94        frame_common_arch_init(true);
     95
     96        /*
     97         * On sparc64, physical memory can start on a non-zero address.
     98         * The generic frame_init() only marks PFN 0 as not free, so we
     99         * must mark the physically first frame not free explicitly
     100         * here, no matter what is its address.
     101         */
     102        frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    81103}
    82104
    83105void frame_high_arch_init(void)
    84106{
     107        if (config.cpu_active > 1)
     108                return;
     109
     110        frame_common_arch_init(false);
    85111}
    86112
Note: See TracChangeset for help on using the changeset viewer.