qemu/roms/ipxe/src/core/memmap_settings.c

   1 /*
   2  * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <byteswap.h>
  29 #include <ipxe/init.h>
  30 #include <ipxe/settings.h>
  31 #include <ipxe/io.h>
  32
  33 /** @file
  34  *
  35  * Memory map settings
  36  *
  37  * Memory map settings are numerically encoded as:
  38  *
  39  *  Bits 31-24  Number of regions, minus one
  40  *  Bits 23-16  Starting region
  41  *  Bits 15-11  Unused
  42  *  Bit  10     Ignore non-existent regions (rather than generating an error)
  43  *  Bit  9      Include length
  44  *  Bit  8      Include start address
  45  *  Bits 7-6    Unused
  46  *  Bits 5-0    Scale factor (i.e. right shift count)
  47  */
  48
  49 /**
  50  * Construct memory map setting tag
  51  *
  52  * @v start             Starting region
  53  * @v count             Number of regions
  54  * @v include_start     Include start address
  55  * @v include_length    Include length
  56  * @v ignore            Ignore non-existent regions
  57  * @v scale             Scale factor
  58  * @ret tag             Setting tag
  59  */
  60 #define MEMMAP_TAG( start, count, include_start, include_length,        \
  61                     ignore, scale )                                     \
  62         ( ( (start) << 16 ) | ( ( (count) - 1 ) << 24 ) |               \
  63           ( (ignore) << 10 ) | ( (include_length) << 9 ) |              \
  64           ( (include_start) << 8 ) | (scale) )
  65
  66 /**
  67  * Extract number of regions from setting tag
  68  *
  69  * @v tag               Setting tag
  70  * @ret count           Number of regions
  71  */
  72 #define MEMMAP_COUNT( tag ) ( ( ( (tag) >> 24 ) & 0xff ) + 1 )
  73
  74 /**
  75  * Extract starting region from setting tag
  76  *
  77  * @v tag               Setting tag
  78  * @ret start           Starting region
  79  */
  80 #define MEMMAP_START( tag ) ( ( (tag) >> 16 ) & 0xff )
  81
  82 /**
  83  * Extract ignore flag from setting tag
  84  *
  85  * @v tag               Setting tag
  86  * @ret ignore          Ignore non-existent regions
  87  */
  88 #define MEMMAP_IGNORE_NONEXISTENT( tag ) ( (tag) & 0x00000400UL )
  89
  90 /**
  91  * Extract length inclusion flag from setting tag
  92  *
  93  * @v tag               Setting tag
  94  * @ret include_length  Include length
  95  */
  96 #define MEMMAP_INCLUDE_LENGTH( tag ) ( (tag) & 0x00000200UL )
  97
  98 /**
  99  * Extract start address inclusion flag from setting tag
 100  *
 101  * @v tag               Setting tag
 102  * @ret include_start   Include start address
 103  */
 104 #define MEMMAP_INCLUDE_START( tag ) ( (tag) & 0x00000100UL )
 105
 106 /**
 107  * Extract scale factor from setting tag
 108  *
 109  * @v tag               Setting tag
 110  * @v scale             Scale factor
 111  */
 112 #define MEMMAP_SCALE( tag ) ( (tag) & 0x3f )
 113
 114 /** Memory map settings scope */
 115 static const struct settings_scope memmap_settings_scope;
 116
 117 /**
 118  * Check applicability of memory map setting
 119  *
 120  * @v settings          Settings block
 121  * @v setting           Setting
 122  * @ret applies         Setting applies within this settings block
 123  */
 124 static int memmap_settings_applies ( struct settings *settings __unused,
 125                                      const struct setting *setting ) {
 126
 127         return ( setting->scope == &memmap_settings_scope );
 128 }
 129
 130 /**
 131  * Fetch value of memory map setting
 132  *
 133  * @v settings          Settings block
 134  * @v setting           Setting to fetch
 135  * @v data              Buffer to fill with setting data
 136  * @v len               Length of buffer
 137  * @ret len             Length of setting data, or negative error
 138  */
 139 static int memmap_settings_fetch ( struct settings *settings,
 140                                    struct setting *setting,
 141                                    void *data, size_t len ) {
 142         struct memory_map memmap;
 143         struct memory_region *region;
 144         uint64_t result = 0;
 145         unsigned int i;
 146         unsigned int count;
 147
 148         DBGC ( settings, "MEMMAP start %d count %d %s%s%s%s scale %d\n",
 149                MEMMAP_START ( setting->tag ), MEMMAP_COUNT ( setting->tag ),
 150                ( MEMMAP_INCLUDE_START ( setting->tag ) ? "start" : "" ),
 151                ( ( MEMMAP_INCLUDE_START ( setting->tag ) &&
 152                    MEMMAP_INCLUDE_LENGTH ( setting->tag ) ) ? "+" : "" ),
 153                ( MEMMAP_INCLUDE_LENGTH ( setting->tag ) ? "length" : "" ),
 154                ( MEMMAP_IGNORE_NONEXISTENT ( setting->tag ) ? " ignore" : "" ),
 155                MEMMAP_SCALE ( setting->tag ) );
 156
 157         /* Fetch memory map */
 158         get_memmap ( &memmap );
 159
 160         /* Extract results from memory map */
 161         count = MEMMAP_COUNT ( setting->tag );
 162         for ( i = MEMMAP_START ( setting->tag ) ; count-- ; i++ ) {
 163
 164                 /* Check that region exists */
 165                 if ( i >= memmap.count ) {
 166                         if ( MEMMAP_IGNORE_NONEXISTENT ( setting->tag ) ) {
 167                                 continue;
 168                         } else {
 169                                 DBGC ( settings, "MEMMAP region %d does not "
 170                                        "exist\n", i );
 171                                 return -ENOENT;
 172                         }
 173                 }
 174
 175                 /* Extract results from this region */
 176                 region = &memmap.regions[i];
 177                 if ( MEMMAP_INCLUDE_START ( setting->tag ) ) {
 178                         result += region->start;
 179                         DBGC ( settings, "MEMMAP %d start %08llx\n",
 180                                i, region->start );
 181                 }
 182                 if ( MEMMAP_INCLUDE_LENGTH ( setting->tag ) ) {
 183                         result += ( region->end - region->start );
 184                         DBGC ( settings, "MEMMAP %d length %08llx\n",
 185                                i, ( region->end - region->start ) );
 186                 }
 187         }
 188
 189         /* Scale result */
 190         result >>= MEMMAP_SCALE ( setting->tag );
 191
 192         /* Return result */
 193         result = cpu_to_be64 ( result );
 194         if ( len > sizeof ( result ) )
 195                 len = sizeof ( result );
 196         memcpy ( data, &result, len );
 197
 198         /* Set type if not already specified */
 199         if ( ! setting->type )
 200                 setting->type = &setting_type_hexraw;
 201
 202         return sizeof ( result );
 203 }
 204
 205 /** Memory map settings operations */
 206 static struct settings_operations memmap_settings_operations = {
 207         .applies = memmap_settings_applies,
 208         .fetch = memmap_settings_fetch,
 209 };
 210
 211 /** Memory map settings */
 212 static struct settings memmap_settings = {
 213         .refcnt = NULL,
 214         .siblings = LIST_HEAD_INIT ( memmap_settings.siblings ),
 215         .children = LIST_HEAD_INIT ( memmap_settings.children ),
 216         .op = &memmap_settings_operations,
 217         .default_scope = &memmap_settings_scope,
 218 };
 219
 220 /** Initialise memory map settings */
 221 static void memmap_settings_init ( void ) {
 222         int rc;
 223
 224         if ( ( rc = register_settings ( &memmap_settings, NULL,
 225                                         "memmap" ) ) != 0 ) {
 226                 DBG ( "MEMMAP could not register settings: %s\n",
 227                       strerror ( rc ) );
 228                 return;
 229         }
 230 }
 231
 232 /** Memory map settings initialiser */
 233 struct init_fn memmap_settings_init_fn __init_fn ( INIT_NORMAL ) = {
 234         .initialise = memmap_settings_init,
 235 };
 236
 237 /** Memory map predefined settings */
 238 const struct setting memsize_setting __setting ( SETTING_MISC, memsize ) = {
 239         .name = "memsize",
 240         .description = "Memory size (in MB)",
 241         .tag = MEMMAP_TAG ( 0, 0x100, 0, 1, 1, 20 ),
 242         .type = &setting_type_int32,
 243         .scope = &memmap_settings_scope,
 244 };