sim/ppc/hw_memory.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #ifndef _HW_MEMORY_C_
  23 #define _HW_MEMORY_C_
  24
  25 #ifndef STATIC_INLINE_HW_MEMORY
  26 #define STATIC_INLINE_HW_MEMORY STATIC_INLINE
  27 #endif
  28
  29 #include "device_table.h"
  30
  31 /* DEVICE
  32
  33
  34    memory - description of system memory
  35
  36
  37    DESCRIPTION
  38
  39
  40    This device describes the size and location of the banks of
  41    physical memory within the simulation.
  42
  43    In addition, this device supports the "claim" and "release" methods
  44    that can be used by OpenBoot client programs to manage the
  45    allocation of physical memory.
  46
  47
  48    PROPERTIES
  49
  50
  51    reg = { <address> <size> } (required)
  52
  53    Each pair specify one bank of memory.
  54
  55    available = { <address> <size> } (automatic)
  56
  57    Each pair specifies a block of memory that is currently unallocated.
  58
  59
  60    BUGS
  61
  62
  63    OpenFirmware doesn't make it clear if, when releasing memory the
  64    same address + size pair as was used during the claim should be
  65    specified.
  66
  67    It is assumed that #size-cells and #address-cells for the parent
  68    node of this device are both one i.e. an address or size can be
  69    specified using a single memory cell (word).
  70
  71    Significant work will be required before the <<memory>> device can
  72    support 64bit addresses (#address-cells equal two).
  73
  74    */
  75
  76 typedef struct _memory_reg_spec {
  77   unsigned_cell base;
  78   unsigned_cell size;
  79 } memory_reg_spec;
  80
  81 typedef struct _hw_memory_chunk hw_memory_chunk;
  82 struct _hw_memory_chunk {
  83   unsigned_word address;
  84   unsigned_word size;
  85   int available;
  86   hw_memory_chunk *next;
  87 };
  88
  89 typedef struct _hw_memory_device {
  90   hw_memory_chunk *heap;
  91 } hw_memory_device;
  92
  93
  94 static void *
  95 hw_memory_create(const char *name,
  96                  const device_unit *unit_address,
  97                  const char *args)
  98 {
  99   hw_memory_device *hw_memory = ZALLOC(hw_memory_device);
 100   return hw_memory;
 101 }
 102
 103
 104 static void
 105 hw_memory_set_available(device *me,
 106                         hw_memory_device *hw_memory)
 107 {
 108   hw_memory_chunk *chunk = NULL;
 109   memory_reg_spec *available = NULL;
 110   int nr_available = 0;
 111   int curr = 0;
 112   int sizeof_available = 0;
 113   /* determine the nr of available chunks */
 114   chunk = hw_memory->heap;
 115   nr_available = 0;
 116   while (chunk != NULL) {
 117     if (chunk->available)
 118       nr_available += 1;
 119     ASSERT(chunk->next == NULL
 120            || chunk->address < chunk->next->address);
 121     ASSERT(chunk->next == NULL
 122            || chunk->address + chunk->size == chunk->next->address);
 123     chunk = chunk->next;
 124   }
 125   /* now create the available struct */
 126   ASSERT(nr_available > 0);
 127   sizeof_available = sizeof(memory_reg_spec) * nr_available;
 128   available = zalloc(sizeof_available);
 129   chunk = hw_memory->heap;
 130   curr = 0;
 131   while (chunk != NULL) {
 132     if (chunk->available) {
 133       available[curr].base = H2BE_cell(chunk->address);
 134       available[curr].size = H2BE_cell(chunk->size);
 135       curr += 1;
 136     }
 137     chunk = chunk->next;
 138   }
 139   /* update */
 140   device_set_array_property(me, "available", available, sizeof_available);
 141   zfree(available);
 142 }
 143
 144
 145 static void
 146 hw_memory_init_address(device *me)
 147 {
 148   hw_memory_device *hw_memory = (hw_memory_device*)device_data(me);
 149
 150   /* free up any previous structures */
 151   {
 152     hw_memory_chunk *curr_chunk = hw_memory->heap;
 153     hw_memory->heap = NULL;
 154     while (curr_chunk != NULL) {
 155       hw_memory_chunk *dead_chunk = curr_chunk;
 156       curr_chunk = dead_chunk->next;
 157       dead_chunk->next = NULL;
 158       zfree(dead_chunk);
 159     }
 160   }
 161
 162   /* attach memory regions according to the "reg" property */
 163   {
 164     int reg_nr;
 165     reg_property_spec reg;
 166     for (reg_nr = 0;
 167          device_find_reg_array_property(me, "reg", reg_nr, &reg);
 168          reg_nr++) {
 169       int i;
 170       /* check that the entry meets restrictions */
 171       for (i = 0; i < reg.address.nr_cells - 1; i++)
 172         if (reg.address.cells[i] != 0)
 173           device_error(me, "Only single celled addresses supported");
 174       for (i = 0; i < reg.size.nr_cells - 1; i++)
 175         if (reg.size.cells[i] != 0)
 176           device_error(me, "Only single celled sizes supported");
 177       /* attach the range */
 178       device_attach_address(device_parent(me),
 179                             attach_raw_memory,
 180                             0 /*address space*/,
 181                             reg.address.cells[reg.address.nr_cells - 1],
 182                             reg.size.cells[reg.size.nr_cells - 1],
 183                             access_read_write_exec,
 184                             me);
 185     }
 186   }
 187
 188   /* create the initial `available memory' data structure */
 189   if (device_find_property(me, "available") != NULL) {
 190     hw_memory_chunk **curr_chunk = &hw_memory->heap;
 191     int cell_nr;
 192     unsigned_cell dummy;
 193     int nr_cells = device_find_integer_array_property(me, "available", 0, &dummy);
 194     if ((nr_cells % 2) != 0)
 195       device_error(me, "property \"available\" invalid - contains an odd number of cells");
 196     for (cell_nr = 0;
 197          cell_nr < nr_cells;
 198          cell_nr += 2) {
 199       hw_memory_chunk *new_chunk = ZALLOC(hw_memory_chunk);
 200       device_find_integer_array_property(me, "available", cell_nr,
 201                                          &new_chunk->address);
 202       device_find_integer_array_property(me, "available", cell_nr + 1,
 203                                          &new_chunk->size);
 204       new_chunk->available = 1;
 205       *curr_chunk = new_chunk;
 206       curr_chunk = &new_chunk->next;
 207     }
 208   }
 209   else {
 210     hw_memory_chunk **curr_chunk = &hw_memory->heap;
 211     int reg_nr;
 212     reg_property_spec reg;
 213     for (reg_nr = 0;
 214          device_find_reg_array_property(me, "reg", reg_nr, &reg);
 215          reg_nr++) {
 216       hw_memory_chunk *new_chunk;
 217       new_chunk = ZALLOC(hw_memory_chunk);
 218       new_chunk->address = reg.address.cells[reg.address.nr_cells - 1];
 219       new_chunk->size = reg.size.cells[reg.size.nr_cells - 1];
 220       new_chunk->available = 1;
 221       *curr_chunk = new_chunk;
 222       curr_chunk = &new_chunk->next;
 223     }
 224   }
 225
 226   /* initialize the alloc property for this device */
 227   hw_memory_set_available(me, hw_memory);
 228 }
 229
 230 static void
 231 hw_memory_instance_delete(device_instance *instance)
 232 {
 233   return;
 234 }
 235
 236 static int
 237 hw_memory_instance_claim(device_instance *instance,
 238                          int n_stack_args,
 239                          unsigned_cell stack_args[/*n_stack_args*/],
 240                          int n_stack_returns,
 241                          unsigned_cell stack_returns[/*n_stack_returns*/])
 242 {
 243   hw_memory_device *hw_memory = device_instance_data(instance);
 244   device *me = device_instance_device(instance);
 245   int stackp = 0;
 246   unsigned_word alignment;
 247   unsigned_cell size;
 248   unsigned_cell address;
 249   hw_memory_chunk *chunk = NULL;
 250
 251   /* get the alignment from the stack */
 252   if (n_stack_args < stackp + 1)
 253     device_error(me, "claim - incorrect number of arguments (alignment missing)");
 254   alignment = stack_args[stackp];
 255   stackp++;
 256
 257   /* get the size from the stack */
 258   {
 259     int i;
 260     int nr_cells = device_nr_size_cells(device_parent(me));
 261     if (n_stack_args < stackp + nr_cells)
 262       device_error(me, "claim - incorrect number of arguments (size missing)");
 263     for (i = 0; i < nr_cells - 1; i++) {
 264       if (stack_args[stackp] != 0)
 265         device_error(me, "claim - multi-cell sizes not supported");
 266       stackp++;
 267     }
 268     size = stack_args[stackp];
 269     stackp++;
 270   }
 271
 272   /* get the address from the stack */
 273   {
 274     int nr_cells = device_nr_address_cells(device_parent(me));
 275     if (alignment != 0) {
 276       if (n_stack_args != stackp) {
 277         if (n_stack_args == stackp + nr_cells)
 278           DTRACE(memory, ("claim - extra address argument ignored\n"));
 279         else
 280           device_error(me, "claim - incorrect number of arguments (optional addr)");
 281       }
 282       address = 0;
 283     }
 284     else {
 285       int i;
 286       if (n_stack_args != stackp + nr_cells)
 287         device_error(me, "claim - incorrect number of arguments (addr missing)");
 288       for (i = 0; i < nr_cells - 1; i++) {
 289         if (stack_args[stackp] != 0)
 290           device_error(me, "claim - multi-cell addresses not supported");
 291         stackp++;
 292       }
 293       address = stack_args[stackp];
 294     }
 295   }
 296
 297   /* check that there is space for the result */
 298   if (n_stack_returns != 0
 299       && n_stack_returns != device_nr_address_cells(device_parent(me)))
 300     device_error(me, "claim - invalid number of return arguments");
 301
 302   /* find a chunk candidate, either according to address or alignment */
 303   if (alignment == 0) {
 304     chunk = hw_memory->heap;
 305     while (chunk != NULL) {
 306       if ((address + size) <= (chunk->address + chunk->size))
 307         break;
 308       chunk = chunk->next;
 309     }
 310     if (chunk == NULL || address < chunk->address || !chunk->available)
 311       device_error(me, "failed to allocate %ld bytes at 0x%lx",
 312                    (unsigned long)size, (unsigned long)address);
 313     DTRACE(memory, ("claim - address=0x%lx size=0x%lx\n",
 314                     (unsigned long)address,
 315                     (unsigned long)size));
 316   }
 317   else {
 318     /* adjust the alignment so that it is a power of two */
 319     unsigned_word align_mask = 1;
 320     while (align_mask < alignment && align_mask != 0)
 321       align_mask <<= 1;
 322     if (align_mask == 0)
 323       device_error(me, "alignment 0x%lx is to large", (unsigned long)alignment);
 324     align_mask -= 1;
 325     /* now find an aligned chunk that fits */
 326     chunk = hw_memory->heap;
 327     while (chunk != NULL) {
 328       address = ((chunk->address + align_mask) & ~align_mask);
 329       if ((chunk->available)
 330           && (chunk->address + chunk->size >= address + size))
 331         break;
 332       chunk = chunk->next;
 333     }
 334     if (chunk == NULL)
 335       device_error(me, "failed to allocate %ld bytes with alignment %ld",
 336                    (unsigned long)size, (unsigned long)alignment);
 337     DTRACE(memory, ("claim - size=0x%lx alignment=%ld (0x%lx), address=0x%lx\n",
 338                     (unsigned long)size,
 339                     (unsigned long)alignment,
 340                     (unsigned long)alignment,
 341                     (unsigned long)address));
 342   }
 343
 344   /* break off a bit before this chunk if needed */
 345   ASSERT(address >= chunk->address);
 346   if (address > chunk->address) {
 347     hw_memory_chunk *next_chunk = ZALLOC(hw_memory_chunk);
 348     /* insert a new chunk */
 349     next_chunk->next = chunk->next;
 350     chunk->next = next_chunk;
 351     /* adjust the address/size */
 352     next_chunk->address = address;
 353     next_chunk->size = chunk->address + chunk->size - next_chunk->address;
 354     next_chunk->available = 1;
 355     chunk->size = next_chunk->address - chunk->address;
 356     /* make this new chunk the one to allocate */
 357     chunk = next_chunk;
 358   }
 359   ASSERT(address == chunk->address);
 360
 361   /* break off a bit after this chunk if needed */
 362   ASSERT(address + size <= chunk->address + chunk->size);
 363   if (address + size < chunk->address + chunk->size) {
 364     hw_memory_chunk *next_chunk = ZALLOC(hw_memory_chunk);
 365     /* insert it in to the list */
 366     next_chunk->next = chunk->next;
 367     chunk->next = next_chunk;
 368     /* adjust the address/size */
 369     next_chunk->address = address + size;
 370     next_chunk->size = chunk->address + chunk->size - next_chunk->address;
 371     next_chunk->available = 1;
 372     chunk->size = next_chunk->address - chunk->address;
 373   }
 374   ASSERT(address + size == chunk->address + chunk->size);
 375
 376   /* now allocate/return it */
 377   chunk->available = 0;
 378   hw_memory_set_available(device_instance_device(instance), hw_memory);
 379   if (n_stack_returns > 0) {
 380     int i;
 381     for (i = 0; i < n_stack_returns - 1; i++)
 382       stack_returns[i] = 0;
 383     stack_returns[n_stack_returns - 1] = address;
 384   }
 385
 386   return 0;
 387 }
 388
 389
 390 static int
 391 hw_memory_instance_release(device_instance *instance,
 392                            int n_stack_args,
 393                            unsigned_cell stack_args[/*n_stack_args*/],
 394                            int n_stack_returns,
 395                            unsigned_cell stack_returns[/*n_stack_returns*/])
 396 {
 397   hw_memory_device *hw_memory = device_instance_data(instance);
 398   device *me = device_instance_device(instance);
 399   unsigned_word length;
 400   unsigned_word address;
 401   int stackp = 0;
 402   hw_memory_chunk *chunk;
 403
 404   /* get the length from the stack */
 405   {
 406     int i;
 407     int nr_cells = device_nr_size_cells(device_parent(me));
 408     if (n_stack_args < stackp + nr_cells)
 409       device_error(me, "release - incorrect number of arguments (length missing)");
 410     for (i = 0; i < nr_cells - 1; i++) {
 411       if (stack_args[stackp] != 0)
 412         device_error(me, "release - multi-cell length not supported");
 413       stackp++;
 414     }
 415     length = stack_args[stackp];
 416     stackp++;
 417   }
 418
 419   /* get the address from the stack */
 420   {
 421     int i;
 422     int nr_cells = device_nr_address_cells(device_parent(me));
 423     if (n_stack_args != stackp + nr_cells)
 424       device_error(me, "release - incorrect number of arguments (addr missing)");
 425     for (i = 0; i < nr_cells - 1; i++) {
 426       if (stack_args[stackp] != 0)
 427         device_error(me, "release - multi-cell addresses not supported");
 428       stackp++;
 429     }
 430     address = stack_args[stackp];
 431   }
 432
 433   /* returns ok */
 434   if (n_stack_returns != 0)
 435     device_error(me, "release - nonzero number of results");
 436
 437   /* try to free the corresponding memory chunk */
 438   chunk = hw_memory->heap;
 439   while (chunk != NULL) {
 440     if (chunk->address == address
 441         && chunk->size == length) {
 442       /* an exact match */
 443       if (chunk->available)
 444         device_error(me, "memory chunk 0x%lx (size 0x%lx) already available",
 445                      (unsigned long)address,
 446                      (unsigned long)length);
 447       else {
 448         /* free this chunk */
 449         DTRACE(memory, ("release - address=0x%lx, length=0x%lx\n",
 450                         (unsigned long) address,
 451                         (unsigned long) length));
 452         chunk->available = 1;
 453         break;
 454       }
 455     }
 456     else if (chunk->address >= address
 457              && chunk->address + chunk->size <= address + length) {
 458       /* a sub region */
 459       if (!chunk->available) {
 460         DTRACE(memory, ("release - address=0x%lx, size=0x%lx within region 0x%lx length 0x%lx\n",
 461                         (unsigned long) chunk->address,
 462                         (unsigned long) chunk->size,
 463                         (unsigned long) address,
 464                         (unsigned long) length));
 465         chunk->available = 1;
 466       }
 467     }
 468     chunk = chunk->next;
 469   }
 470   if (chunk == NULL) {
 471     printf_filtered("warning: released chunks within region 0x%lx..0x%lx\n",
 472                     (unsigned long)address,
 473                     (unsigned long)(address + length - 1));
 474   }
 475
 476   /* check for the chance to merge two adjacent available memory chunks */
 477   chunk = hw_memory->heap;
 478   while (chunk != NULL) {
 479     if (chunk->available
 480         && chunk->next != NULL && chunk->next->available) {
 481       /* adjacent */
 482       hw_memory_chunk *delete = chunk->next;
 483       ASSERT(chunk->address + chunk->size == delete->address);
 484       chunk->size += delete->size;
 485       chunk->next = delete->next;
 486       zfree(delete);
 487     }
 488     else {
 489       chunk = chunk->next;
 490     }
 491   }
 492
 493   /* update the corresponding property */
 494   hw_memory_set_available(device_instance_device(instance), hw_memory);
 495
 496   return 0;
 497 }
 498
 499
 500 static device_instance_methods hw_memory_instance_methods[] = {
 501   { "claim", hw_memory_instance_claim },
 502   { "release", hw_memory_instance_release },
 503   { NULL, },
 504 };
 505
 506 static device_instance_callbacks const hw_memory_instance_callbacks = {
 507   hw_memory_instance_delete,
 508   NULL /*read*/, NULL /*write*/, NULL /*seek*/,
 509   hw_memory_instance_methods
 510 };
 511
 512 static device_instance *
 513 hw_memory_create_instance(device *me,
 514                           const char *path,
 515                           const char *args)
 516 {
 517   return device_create_instance_from(me, NULL,
 518                                      device_data(me), /* nothing better */
 519                                      path, args,
 520                                      &hw_memory_instance_callbacks);
 521 }
 522
 523 static device_callbacks const hw_memory_callbacks = {
 524   { hw_memory_init_address, },
 525   { NULL, }, /* address */
 526   { NULL, }, /* IO */
 527   { NULL, }, /* DMA */
 528   { NULL, }, /* interrupt */
 529   { NULL, }, /* unit */
 530   hw_memory_create_instance,
 531 };
 532
 533 const device_descriptor hw_memory_device_descriptor[] = {
 534   { "memory", hw_memory_create, &hw_memory_callbacks },
 535   { NULL },
 536 };
 537
 538 #endif /* _HW_MEMORY_C_ */