sim/ppc/device.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 _DEVICE_C_
  23 #define _DEVICE_C_
  24
  25 #include <stdio.h>
  26
  27 #include "device_table.h"
  28 #include "cap.h"
  29
  30 #include "events.h"
  31 #include "psim.h"
  32
  33 #ifdef HAVE_STDLIB_H
  34 #include <stdlib.h>
  35 #endif
  36
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #else
  40 #ifdef HAVE_STRINGS_H
  41 #include <strings.h>
  42 #endif
  43 #endif
  44
  45 #include <ctype.h>
  46
  47 STATIC_INLINE_DEVICE (void) clean_device_properties(device *);
  48
  49 /* property entries */
  50
  51 typedef struct _device_property_entry device_property_entry;
  52 struct _device_property_entry {
  53   device_property_entry *next;
  54   device_property *value;
  55   const void *init_array;
  56   unsigned sizeof_init_array;
  57 };
  58
  59
  60 /* Interrupt edges */
  61
  62 typedef struct _device_interrupt_edge device_interrupt_edge;
  63 struct _device_interrupt_edge {
  64   int my_port;
  65   device *dest;
  66   int dest_port;
  67   device_interrupt_edge *next;
  68   object_disposition disposition;
  69 };
  70
  71 STATIC_INLINE_DEVICE\
  72 (void)
  73 attach_device_interrupt_edge(device_interrupt_edge **list,
  74                              int my_port,
  75                              device *dest,
  76                              int dest_port,
  77                              object_disposition disposition)
  78 {
  79   device_interrupt_edge *new_edge = ZALLOC(device_interrupt_edge);
  80   new_edge->my_port = my_port;
  81   new_edge->dest = dest;
  82   new_edge->dest_port = dest_port;
  83   new_edge->next = *list;
  84   new_edge->disposition = disposition;
  85   *list = new_edge;
  86 }
  87
  88 STATIC_INLINE_DEVICE\
  89 (void)
  90 detach_device_interrupt_edge(device *me,
  91                              device_interrupt_edge **list,
  92                              int my_port,
  93                              device *dest,
  94                              int dest_port)
  95 {
  96   while (*list != NULL) {
  97     device_interrupt_edge *old_edge = *list;
  98     if (old_edge->dest == dest
  99         && old_edge->dest_port == dest_port
 100         && old_edge->my_port == my_port) {
 101       if (old_edge->disposition == permenant_object)
 102         device_error(me, "attempt to delete permenant interrupt");
 103       *list = old_edge->next;
 104       zfree(old_edge);
 105       return;
 106     }
 107   }
 108   device_error(me, "attempt to delete unattached interrupt");
 109 }
 110
 111 STATIC_INLINE_DEVICE\
 112 (void)
 113 clean_device_interrupt_edges(device_interrupt_edge **list)
 114 {
 115   while (*list != NULL) {
 116     device_interrupt_edge *old_edge = *list;
 117     switch (old_edge->disposition) {
 118     case permenant_object:
 119       list = &old_edge->next;
 120       break;
 121     case tempoary_object:
 122       *list = old_edge->next;
 123       zfree(old_edge);
 124       break;
 125     }
 126   }
 127 }
 128
 129
 130 /* A device */
 131
 132 struct _device {
 133
 134   /* my name is ... */
 135   const char *name;
 136   device_unit unit_address;
 137   const char *path;
 138   int nr_address_cells;
 139   int nr_size_cells;
 140
 141   /* device tree */
 142   device *parent;
 143   device *children;
 144   device *sibling;
 145
 146   /* its template methods */
 147   void *data; /* device specific data */
 148   const device_callbacks *callback;
 149
 150   /* device properties */
 151   device_property_entry *properties;
 152
 153   /* interrupts */
 154   device_interrupt_edge *interrupt_destinations;
 155
 156   /* any open instances of this device */
 157   device_instance *instances;
 158
 159   /* the internal/external mappings and other global requirements */
 160   cap *ihandles;
 161   cap *phandles;
 162   psim *system;
 163
 164   /* debugging */
 165   int trace;
 166 };
 167
 168
 169 /* an instance of a device */
 170 struct _device_instance {
 171   void *data;
 172   char *args;
 173   char *path;
 174   const device_instance_callbacks *callback;
 175   /* the root instance */
 176   device *owner;
 177   device_instance *next;
 178   /* interposed instance */
 179   device_instance *parent;
 180   device_instance *child;
 181 };
 182
 183
 184 \f
 185 /* creation */
 186
 187 STATIC_INLINE_DEVICE\
 188 (const char *)
 189 device_full_name(device *leaf,
 190                  char *buf,
 191                  unsigned sizeof_buf)
 192 {
 193   /* get a buffer */
 194   char full_name[1024];
 195   if (buf == (char*)0) {
 196     buf = full_name;
 197     sizeof_buf = sizeof(full_name);
 198   }
 199
 200   /* construct a name */
 201   if (leaf->parent == NULL) {
 202     if (sizeof_buf < 1)
 203       error("device_full_name: buffer overflow");
 204     *buf = '\0';
 205   }
 206   else {
 207     char unit[1024];
 208     device_full_name(leaf->parent, buf, sizeof_buf);
 209     if (leaf->parent != NULL
 210         && device_encode_unit(leaf->parent,
 211                               &leaf->unit_address,
 212                               unit+1,
 213                               sizeof(unit)-1) > 0)
 214       unit[0] = '@';
 215     else
 216       unit[0] = '\0';
 217     if (strlen(buf) + strlen("/") + strlen(leaf->name) + strlen(unit)
 218         >= sizeof_buf)
 219       error("device_full_name: buffer overflow");
 220     strcat(buf, "/");
 221     strcat(buf, leaf->name);
 222     strcat (buf, unit);
 223   }
 224
 225   /* return it usefully */
 226   if (buf == full_name)
 227     buf = (char *) strdup(full_name);
 228   return buf;
 229 }
 230
 231 STATIC_INLINE_DEVICE\
 232 (device *)
 233 device_create_from(const char *name,
 234                    const device_unit *unit_address,
 235                    void *data,
 236                    const device_callbacks *callbacks,
 237                    device *parent)
 238 {
 239   device *new_device = ZALLOC(device);
 240
 241   /* insert it into the device tree */
 242   new_device->parent = parent;
 243   new_device->children = NULL;
 244   if (parent != NULL) {
 245     device **sibling = &parent->children;
 246     while ((*sibling) != NULL)
 247       sibling = &(*sibling)->sibling;
 248     *sibling = new_device;
 249   }
 250
 251   /* give it a name */
 252   new_device->name = (char *) strdup(name);
 253   new_device->unit_address = *unit_address;
 254   new_device->path = device_full_name(new_device, NULL, 0);
 255
 256   /* its template */
 257   new_device->data = data;
 258   new_device->callback = callbacks;
 259
 260   /* its properties - already null */
 261   /* interrupts - already null */
 262
 263   /* mappings - if needed */
 264   if (parent == NULL) {
 265     new_device->ihandles = cap_create(name);
 266     new_device->phandles = cap_create(name);
 267   }
 268   else {
 269     new_device->ihandles = device_root(parent)->ihandles;
 270     new_device->phandles = device_root(parent)->phandles;
 271   }
 272
 273   cap_add(new_device->phandles, new_device);
 274   return new_device;
 275 }
 276
 277
 278
 279 INLINE_DEVICE\
 280 (device *)
 281 device_create(device *parent,
 282               const char *base,
 283               const char *name,
 284               const char *unit_address,
 285               const char *args)
 286 {
 287   const device_descriptor *const *table;
 288   for (table = device_table; *table != NULL; table++) {
 289     const device_descriptor *descr;
 290     for (descr = *table; descr->name != NULL; descr++) {
 291       if (strcmp(base, descr->name) == 0) {
 292         device_unit address = { 0 };
 293         void *data = NULL;
 294         if (parent != NULL)
 295           if (device_decode_unit(parent, unit_address, &address) < 0)
 296             device_error(parent, "invalid address %s for device %s",
 297                          unit_address, name);
 298         if (descr->creator != NULL)
 299           data = descr->creator(name, &address, args);
 300         return device_create_from(name, &address, data,
 301                                   descr->callbacks, parent);
 302       }
 303     }
 304   }
 305   device_error(parent, "attempt to attach unknown device %s", name);
 306   return NULL;
 307 }
 308
 309
 310
 311 INLINE_DEVICE\
 312 (void)
 313 device_usage(int verbose)
 314 {
 315   const device_descriptor *const *table;
 316   if (verbose == 1) {
 317     int pos = 0;
 318     for (table = device_table; *table != NULL; table++) {
 319       const device_descriptor *descr;
 320       for (descr = *table; descr->name != NULL; descr++) {
 321         pos += strlen(descr->name) + 2;
 322         if (pos > 75) {
 323           pos = strlen(descr->name) + 2;
 324           printf_filtered("\n");
 325         }
 326         printf_filtered("  %s", descr->name);
 327       }
 328       printf_filtered("\n");
 329     }
 330   }
 331   if (verbose > 1) {
 332     for (table = device_table; *table != NULL; table++) {
 333       const device_descriptor *descr;
 334       for (descr = *table; descr->name != NULL; descr++) {
 335         printf_filtered("  %s:\n", descr->name);
 336         /* interrupt ports */
 337         if (descr->callbacks->interrupt.ports != NULL) {
 338           const device_interrupt_port_descriptor *ports =
 339             descr->callbacks->interrupt.ports;
 340           printf_filtered("    interrupt ports:");
 341           while (ports->name != NULL) {
 342             printf_filtered(" %s", ports->name);
 343             ports++;
 344           }
 345           printf_filtered("\n");
 346         }
 347         /* general info */
 348         if (descr->callbacks->usage != NULL)
 349           descr->callbacks->usage(verbose);
 350       }
 351     }
 352   }
 353 }
 354
 355
 356
 357
 358 \f
 359 /* Device node: */
 360
 361 INLINE_DEVICE\
 362 (device *)
 363 device_parent(device *me)
 364 {
 365   return me->parent;
 366 }
 367
 368 INLINE_DEVICE\
 369 (device *)
 370 device_root(device *me)
 371 {
 372   ASSERT(me != NULL);
 373   while (me->parent != NULL)
 374     me = me->parent;
 375   return me;
 376 }
 377
 378 INLINE_DEVICE\
 379 (device *)
 380 device_sibling(device *me)
 381 {
 382   return me->sibling;
 383 }
 384
 385 INLINE_DEVICE\
 386 (device *)
 387 device_child(device *me)
 388 {
 389   return me->children;
 390 }
 391
 392 INLINE_DEVICE\
 393 (const char *)
 394 device_name(device *me)
 395 {
 396   return me->name;
 397 }
 398
 399 INLINE_DEVICE\
 400 (const char *)
 401 device_path(device *me)
 402 {
 403   return me->path;
 404 }
 405
 406 INLINE_DEVICE\
 407 (void *)
 408 device_data(device *me)
 409 {
 410   return me->data;
 411 }
 412
 413 INLINE_DEVICE\
 414 (psim *)
 415 device_system(device *me)
 416 {
 417   return me->system;
 418 }
 419
 420 INLINE_DEVICE\
 421 (const device_unit *)
 422 device_unit_address(device *me)
 423 {
 424   return &me->unit_address;
 425 }
 426
 427
 428 INLINE_DEVICE\
 429 (int)
 430 device_address_to_attach_address(device *me,
 431                                  const device_unit *address,
 432                                  int *attach_space,
 433                                  unsigned_word *attach_address,
 434                                  device *client)
 435 {
 436   if (me->callback->convert.address_to_attach_address == NULL)
 437     device_error(me, "no convert.address_to_attach_address method");
 438   return me->callback->convert.address_to_attach_address(me, address, attach_space, attach_address, client);
 439 }
 440
 441
 442 INLINE_DEVICE\
 443 (int)
 444 device_size_to_attach_size(device *me,
 445                            const device_unit *size,
 446                            unsigned *nr_bytes,
 447                            device *client)
 448 {
 449   if (me->callback->convert.size_to_attach_size == NULL)
 450     device_error(me, "no convert.size_to_attach_size method");
 451   return me->callback->convert.size_to_attach_size(me, size, nr_bytes, client);
 452 }
 453
 454
 455 INLINE_DEVICE\
 456 (int)
 457 device_decode_unit(device *bus,
 458                    const char *unit,
 459                    device_unit *address)
 460 {
 461   if (bus->callback->convert.decode_unit == NULL)
 462     device_error(bus, "no convert.decode_unit method");
 463   return bus->callback->convert.decode_unit(bus, unit, address);
 464 }
 465
 466
 467 INLINE_DEVICE\
 468 (int)
 469 device_encode_unit(device *bus,
 470                    const device_unit *unit_address,
 471                    char *buf,
 472                    int sizeof_buf)
 473 {
 474   if (bus->callback->convert.encode_unit == NULL)
 475     device_error(bus, "no convert.encode_unit method");
 476   return bus->callback->convert.encode_unit(bus, unit_address, buf, sizeof_buf);
 477 }
 478
 479 INLINE_DEVICE\
 480 (unsigned)
 481 device_nr_address_cells(device *me)
 482 {
 483   if (me->nr_address_cells == 0) {
 484     if (device_find_property(me, "#address-cells") != NULL)
 485       me->nr_address_cells = device_find_integer_property(me, "#address-cells");
 486     else
 487       me->nr_address_cells = 2;
 488   }
 489   return me->nr_address_cells;
 490 }
 491
 492 INLINE_DEVICE\
 493 (unsigned)
 494 device_nr_size_cells(device *me)
 495 {
 496   if (me->nr_size_cells == 0) {
 497     if (device_find_property(me, "#size-cells") != NULL)
 498       me->nr_size_cells = device_find_integer_property(me, "#size-cells");
 499     else
 500       me->nr_size_cells = 1;
 501   }
 502   return me->nr_size_cells;
 503 }
 504
 505
 506 \f
 507 /* device-instance: */
 508
 509 INLINE_DEVICE\
 510 (device_instance *)
 511 device_create_instance_from(device *me,
 512                             device_instance *parent,
 513                             void *data,
 514                             const char *path,
 515                             const char *args,
 516                             const device_instance_callbacks *callbacks)
 517 {
 518   device_instance *instance = ZALLOC(device_instance);
 519   if ((me == NULL) == (parent == NULL))
 520     device_error(me, "can't have both parent instance and parent device");
 521   /*instance->unit*/
 522   /* link this instance into the devices list */
 523   if (me != NULL) {
 524     ASSERT(parent == NULL);
 525     instance->owner = me;
 526     instance->parent = NULL;
 527     /* link this instance into the front of the devices instance list */
 528     instance->next = me->instances;
 529     me->instances = instance;
 530   }
 531   if (parent != NULL) {
 532     device_instance **previous;
 533     ASSERT(parent->child == NULL);
 534     parent->child = instance;
 535     ASSERT(me == NULL);
 536     instance->owner = parent->owner;
 537     instance->parent = parent;
 538     /* in the devices instance list replace the parent instance with
 539        this one */
 540     instance->next = parent->next;
 541     /* replace parent with this new node */
 542     previous = &instance->owner->instances;
 543     while (*previous != parent) {
 544       ASSERT(*previous != NULL);
 545       previous = &(*previous)->next;
 546     }
 547     *previous = instance;
 548   }
 549   instance->data = data;
 550   instance->args = (args == NULL ? NULL : (char *) strdup(args));
 551   instance->path = (path == NULL ? NULL : (char *) strdup(path));
 552   instance->callback = callbacks;
 553   cap_add(instance->owner->ihandles, instance);
 554   return instance;
 555 }
 556
 557
 558 INLINE_DEVICE\
 559 (device_instance *)
 560 device_create_instance(device *me,
 561                        const char *path,
 562                        const char *args)
 563 {
 564   /* create the instance */
 565   if (me->callback->instance_create == NULL)
 566     device_error(me, "no instance_create method");
 567   return me->callback->instance_create(me, path, args);
 568 }
 569
 570
 571 STATIC_INLINE_DEVICE\
 572 (void)
 573 clean_device_instances(device *me)
 574 {
 575   device_instance **instance = &me->instances;
 576   while (*instance != NULL) {
 577     device_instance *old_instance = *instance;
 578     device_instance_delete(old_instance);
 579     instance = &me->instances;
 580   }
 581 }
 582
 583
 584 INLINE_DEVICE\
 585 (void)
 586 device_instance_delete(device_instance *instance)
 587 {
 588   device *me = instance->owner;
 589   if (instance->callback->delete == NULL)
 590     device_error(me, "no delete method");
 591   instance->callback->delete(instance);
 592   if (instance->args != NULL)
 593     zfree(instance->args);
 594   if (instance->path != NULL)
 595     zfree(instance->path);
 596   if (instance->child == NULL) {
 597     /* only remove leaf nodes */
 598     device_instance **curr = &me->instances;
 599     while (*curr != instance) {
 600       ASSERT(*curr != NULL);
 601       curr = &(*curr)->next;
 602     }
 603     *curr = instance->next;
 604   }
 605   else {
 606     /* check it isn't in the instance list */
 607     device_instance *curr = me->instances;
 608     while (curr != NULL) {
 609       ASSERT(curr != instance);
 610       curr = curr->next;
 611     }
 612     /* unlink the child */
 613     ASSERT(instance->child->parent == instance);
 614     instance->child->parent = NULL;
 615   }
 616   cap_remove(me->ihandles, instance);
 617   zfree(instance);
 618 }
 619
 620 INLINE_DEVICE\
 621 (int)
 622 device_instance_read(device_instance *instance,
 623                      void *addr,
 624                      unsigned_word len)
 625 {
 626   device *me = instance->owner;
 627   if (instance->callback->read == NULL)
 628     device_error(me, "no read method");
 629   return instance->callback->read(instance, addr, len);
 630 }
 631
 632 INLINE_DEVICE\
 633 (int)
 634 device_instance_write(device_instance *instance,
 635                       const void *addr,
 636                       unsigned_word len)
 637 {
 638   device *me = instance->owner;
 639   if (instance->callback->write == NULL)
 640     device_error(me, "no write method");
 641   return instance->callback->write(instance, addr, len);
 642 }
 643
 644 INLINE_DEVICE\
 645 (int)
 646 device_instance_seek(device_instance *instance,
 647                      unsigned_word pos_hi,
 648                      unsigned_word pos_lo)
 649 {
 650   device *me = instance->owner;
 651   if (instance->callback->seek == NULL)
 652     device_error(me, "no seek method");
 653   return instance->callback->seek(instance, pos_hi, pos_lo);
 654 }
 655
 656 INLINE_DEVICE\
 657 (int)
 658 device_instance_call_method(device_instance *instance,
 659                             const char *method_name,
 660                             int n_stack_args,
 661                             unsigned_cell stack_args[/*n_stack_args*/],
 662                             int n_stack_returns,
 663                             unsigned_cell stack_returns[/*n_stack_args*/])
 664 {
 665   device *me = instance->owner;
 666   const device_instance_methods *method = instance->callback->methods;
 667   if (method == NULL) {
 668     device_error(me, "no methods (want %s)", method_name);
 669   }
 670   while (method->name != NULL) {
 671     if (strcmp(method->name, method_name) == 0) {
 672       return method->method(instance,
 673                             n_stack_args, stack_args,
 674                             n_stack_returns, stack_returns);
 675     }
 676     method++;
 677   }
 678   device_error(me, "no %s method", method_name);
 679   return 0;
 680 }
 681
 682
 683 INLINE_DEVICE\
 684 (device *)
 685 device_instance_device(device_instance *instance)
 686 {
 687   return instance->owner;
 688 }
 689
 690 INLINE_DEVICE\
 691 (const char *)
 692 device_instance_path(device_instance *instance)
 693 {
 694   return instance->path;
 695 }
 696
 697 INLINE_DEVICE\
 698 (void *)
 699 device_instance_data(device_instance *instance)
 700 {
 701   return instance->data;
 702 }
 703
 704
 705 \f
 706 /* Device Properties: */
 707
 708 STATIC_INLINE_DEVICE\
 709 (device_property_entry *)
 710 find_property_entry(device *me,
 711                      const char *property)
 712 {
 713   device_property_entry *entry;
 714   ASSERT(property != NULL);
 715   entry = me->properties;
 716   while (entry != NULL) {
 717     if (strcmp(entry->value->name, property) == 0)
 718       return entry;
 719     entry = entry->next;
 720   }
 721   return NULL;
 722 }
 723
 724 STATIC_INLINE_DEVICE\
 725 (void)
 726 device_add_property(device *me,
 727                     const char *property,
 728                     device_property_type type,
 729                     const void *init_array,
 730                     unsigned sizeof_init_array,
 731                     const void *array,
 732                     unsigned sizeof_array,
 733                     const device_property *original,
 734                     object_disposition disposition)
 735 {
 736   device_property_entry *new_entry = NULL;
 737   device_property *new_value = NULL;
 738
 739   /* find the list end */
 740   device_property_entry **insertion_point = &me->properties;
 741   while (*insertion_point != NULL) {
 742     if (strcmp((*insertion_point)->value->name, property) == 0)
 743       return;
 744     insertion_point = &(*insertion_point)->next;
 745   }
 746
 747   /* create a new value */
 748   new_value = ZALLOC(device_property);
 749   new_value->name = (char *) strdup(property);
 750   new_value->type = type;
 751   if (sizeof_array > 0) {
 752     void *new_array = zalloc(sizeof_array);
 753     memcpy(new_array, array, sizeof_array);
 754     new_value->array = new_array;
 755     new_value->sizeof_array = sizeof_array;
 756   }
 757   new_value->owner = me;
 758   new_value->original = original;
 759   new_value->disposition = disposition;
 760
 761   /* insert the value into the list */
 762   new_entry = ZALLOC(device_property_entry);
 763   *insertion_point = new_entry;
 764   if (sizeof_init_array > 0) {
 765     void *new_init_array = zalloc(sizeof_init_array);
 766     memcpy(new_init_array, init_array, sizeof_init_array);
 767     new_entry->init_array = new_init_array;
 768     new_entry->sizeof_init_array = sizeof_init_array;
 769   }
 770   new_entry->value = new_value;
 771 }
 772
 773
 774 /* local - not available externally */
 775 STATIC_INLINE_DEVICE\
 776 (void)
 777 device_set_property(device *me,
 778                     const char *property,
 779                     device_property_type type,
 780                     const void *array,
 781                     int sizeof_array)
 782 {
 783   /* find the property */
 784   device_property_entry *entry = find_property_entry(me, property);
 785   if (entry != NULL) {
 786     /* existing property - update it */
 787     void *new_array = 0;
 788     device_property *value = entry->value;
 789     /* check the type matches */
 790     if (value->type != type)
 791       device_error(me, "conflict between type of new and old value for property %s", property);
 792     /* replace its value */
 793     if (value->array != NULL)
 794       zfree((void*)value->array);
 795     new_array = (sizeof_array > 0
 796                  ? zalloc(sizeof_array)
 797                  : (void*)0);
 798     value->array = new_array;
 799     value->sizeof_array = sizeof_array;
 800     if (sizeof_array > 0)
 801       memcpy(new_array, array, sizeof_array);
 802     return;
 803   }
 804   else {
 805     /* new property - create it */
 806     device_add_property(me, property, type,
 807                         NULL, 0, array, sizeof_array,
 808                         NULL, tempoary_object);
 809   }
 810 }
 811
 812
 813 STATIC_INLINE_DEVICE\
 814 (void)
 815 clean_device_properties(device *me)
 816 {
 817   device_property_entry **delete_point = &me->properties;
 818   while (*delete_point != NULL) {
 819     device_property_entry *current = *delete_point;
 820     switch (current->value->disposition) {
 821     case permenant_object:
 822       /* zap the current value, will be initialized later */
 823       ASSERT(current->init_array != NULL);
 824       if (current->value->array != NULL) {
 825         zfree((void*)current->value->array);
 826         current->value->array = NULL;
 827       }
 828       delete_point = &(*delete_point)->next;
 829       break;
 830     case tempoary_object:
 831       /* zap the actual property, was created during simulation run */
 832       ASSERT(current->init_array == NULL);
 833       *delete_point = current->next;
 834       if (current->value->array != NULL)
 835         zfree((void*)current->value->array);
 836       zfree(current->value);
 837       zfree(current);
 838       break;
 839     }
 840   }
 841 }
 842
 843
 844 INLINE_DEVICE\
 845 (void)
 846 device_init_static_properties(device *me,
 847                               void *data)
 848 {
 849   device_property_entry *property;
 850   for (property = me->properties;
 851        property != NULL;
 852        property = property->next) {
 853     ASSERT(property->init_array != NULL);
 854     ASSERT(property->value->array == NULL);
 855     ASSERT(property->value->disposition == permenant_object);
 856     switch (property->value->type) {
 857     case array_property:
 858     case boolean_property:
 859     case range_array_property:
 860     case reg_array_property:
 861     case string_property:
 862     case string_array_property:
 863     case integer_property:
 864       /* delete the property, and replace it with the original */
 865       device_set_property(me, property->value->name,
 866                           property->value->type,
 867                           property->init_array,
 868                           property->sizeof_init_array);
 869       break;
 870     case ihandle_property:
 871       break;
 872     }
 873   }
 874 }
 875
 876
 877 INLINE_DEVICE\
 878 (void)
 879 device_init_runtime_properties(device *me,
 880                                void *data)
 881 {
 882   device_property_entry *property;
 883   for (property = me->properties;
 884        property != NULL;
 885        property = property->next) {
 886     switch (property->value->disposition) {
 887     case permenant_object:
 888       switch (property->value->type) {
 889       case ihandle_property:
 890         {
 891           device_instance *ihandle;
 892           ihandle_runtime_property_spec spec;
 893           ASSERT(property->init_array != NULL);
 894           ASSERT(property->value->array == NULL);
 895           device_find_ihandle_runtime_property(me, property->value->name, &spec);
 896           ihandle = tree_instance(me, spec.full_path);
 897           device_set_ihandle_property(me, property->value->name, ihandle);
 898           break;
 899         }
 900       case array_property:
 901       case boolean_property:
 902       case range_array_property:
 903       case integer_property:
 904       case reg_array_property:
 905       case string_property:
 906       case string_array_property:
 907         ASSERT(property->init_array != NULL);
 908         ASSERT(property->value->array != NULL);
 909         break;
 910       }
 911       break;
 912     case tempoary_object:
 913       ASSERT(property->init_array == NULL);
 914       ASSERT(property->value->array != NULL);
 915       break;
 916     }
 917   }
 918 }
 919
 920
 921 INLINE_DEVICE\
 922 (const device_property *)
 923 device_next_property(const device_property *property)
 924 {
 925   /* find the property in the list */
 926   device *owner = property->owner;
 927   device_property_entry *entry = owner->properties;
 928   while (entry != NULL && entry->value != property)
 929     entry = entry->next;
 930   /* now return the following property */
 931   ASSERT(entry != NULL); /* must be a member! */
 932   if (entry->next != NULL)
 933     return entry->next->value;
 934   else
 935     return NULL;
 936 }
 937
 938
 939 INLINE_DEVICE\
 940 (const device_property *)
 941 device_find_property(device *me,
 942                      const char *property)
 943 {
 944   if (me == NULL) {
 945     return NULL;
 946   }
 947   else if (property == NULL || strcmp(property, "") == 0) {
 948     if (me->properties == NULL)
 949       return NULL;
 950     else
 951       return me->properties->value;
 952   }
 953   else {
 954     device_property_entry *entry = find_property_entry(me, property);
 955     if (entry != NULL)
 956       return entry->value;
 957   }
 958   return NULL;
 959 }
 960
 961
 962 INLINE_DEVICE\
 963 (void)
 964 device_add_array_property(device *me,
 965                           const char *property,
 966                           const void *array,
 967                           int sizeof_array)
 968 {
 969   device_add_property(me, property, array_property,
 970                       array, sizeof_array, array, sizeof_array,
 971                       NULL, permenant_object);
 972 }
 973
 974 INLINE_DEVICE\
 975 (void)
 976 device_set_array_property(device *me,
 977                           const char *property,
 978                           const void *array,
 979                           int sizeof_array)
 980 {
 981   device_set_property(me, property, array_property, array, sizeof_array);
 982 }
 983
 984 INLINE_DEVICE\
 985 (const device_property *)
 986 device_find_array_property(device *me,
 987                            const char *property)
 988 {
 989   const device_property *node;
 990   node = device_find_property(me, property);
 991   if (node == (device_property*)0
 992       || node->type != array_property)
 993     device_error(me, "property %s not found or of wrong type", property);
 994   return node;
 995 }
 996
 997
 998 INLINE_DEVICE\
 999 (void)
1000 device_add_boolean_property(device *me,
1001                             const char *property,
1002                             int boolean)
1003 {
1004   signed32 new_boolean = (boolean ? -1 : 0);
1005   device_add_property(me, property, boolean_property,
1006                       &new_boolean, sizeof(new_boolean),
1007                       &new_boolean, sizeof(new_boolean),
1008                       NULL, permenant_object);
1009 }
1010
1011 INLINE_DEVICE\
1012 (int)
1013 device_find_boolean_property(device *me,
1014                              const char *property)
1015 {
1016   const device_property *node;
1017   unsigned_cell boolean;
1018   node = device_find_property(me, property);
1019   if (node == (device_property*)0
1020       || node->type != boolean_property)
1021     device_error(me, "property %s not found or of wrong type", property);
1022   ASSERT(sizeof(boolean) == node->sizeof_array);
1023   memcpy(&boolean, node->array, sizeof(boolean));
1024   return boolean;
1025 }
1026
1027
1028 INLINE_DEVICE\
1029 (void)
1030 device_add_ihandle_runtime_property(device *me,
1031                                     const char *property,
1032                                     const ihandle_runtime_property_spec *ihandle)
1033 {
1034   /* enter the full path as the init array */
1035   device_add_property(me, property, ihandle_property,
1036                       ihandle->full_path, strlen(ihandle->full_path) + 1,
1037                       NULL, 0,
1038                       NULL, permenant_object);
1039 }
1040
1041 INLINE_DEVICE\
1042 (void)
1043 device_find_ihandle_runtime_property(device *me,
1044                                      const char *property,
1045                                      ihandle_runtime_property_spec *ihandle)
1046 {
1047   device_property_entry *entry = find_property_entry(me, property);
1048   TRACE(trace_devices,
1049         ("device_find_ihandle_runtime_property(me=0x%lx, property=%s)\n",
1050          (long)me, property));
1051   if (entry == NULL
1052       || entry->value->type != ihandle_property
1053       || entry->value->disposition != permenant_object)
1054     device_error(me, "property %s not found or of wrong type", property);
1055   ASSERT(entry->init_array != NULL);
1056   /* the full path */
1057   ihandle->full_path = entry->init_array;
1058 }
1059
1060
1061
1062 INLINE_DEVICE\
1063 (void)
1064 device_set_ihandle_property(device *me,
1065                             const char *property,
1066                             device_instance *ihandle)
1067 {
1068   unsigned_cell cells;
1069   cells = H2BE_cell(device_instance_to_external(ihandle));
1070   device_set_property(me, property, ihandle_property,
1071                       &cells, sizeof(cells));
1072
1073 }
1074
1075 INLINE_DEVICE\
1076 (device_instance *)
1077 device_find_ihandle_property(device *me,
1078                              const char *property)
1079 {
1080   const device_property *node;
1081   unsigned_cell ihandle;
1082   device_instance *instance;
1083
1084   node = device_find_property(me, property);
1085   if (node == NULL || node->type != ihandle_property)
1086     device_error(me, "property %s not found or of wrong type", property);
1087   if (node->array == NULL)
1088     device_error(me, "runtime property %s not yet initialized", property);
1089
1090   ASSERT(sizeof(ihandle) == node->sizeof_array);
1091   memcpy(&ihandle, node->array, sizeof(ihandle));
1092   instance = external_to_device_instance(me, BE2H_cell(ihandle));
1093   ASSERT(instance != NULL);
1094   return instance;
1095 }
1096
1097
1098 INLINE_DEVICE\
1099 (void)
1100 device_add_integer_property(device *me,
1101                             const char *property,
1102                             signed_cell integer)
1103 {
1104   H2BE(integer);
1105   device_add_property(me, property, integer_property,
1106                       &integer, sizeof(integer),
1107                       &integer, sizeof(integer),
1108                       NULL, permenant_object);
1109 }
1110
1111 INLINE_DEVICE\
1112 (signed_cell)
1113 device_find_integer_property(device *me,
1114                              const char *property)
1115 {
1116   const device_property *node;
1117   signed_cell integer;
1118   TRACE(trace_devices,
1119         ("device_find_integer(me=0x%lx, property=%s)\n",
1120          (long)me, property));
1121   node = device_find_property(me, property);
1122   if (node == (device_property*)0
1123       || node->type != integer_property)
1124     device_error(me, "property %s not found or of wrong type", property);
1125   ASSERT(sizeof(integer) == node->sizeof_array);
1126   memcpy(&integer, node->array, sizeof(integer));
1127   return BE2H_cell(integer);
1128 }
1129
1130 INLINE_DEVICE\
1131 (int)
1132 device_find_integer_array_property(device *me,
1133                                    const char *property,
1134                                    unsigned index,
1135                                    signed_cell *integer)
1136 {
1137   const device_property *node;
1138   int sizeof_integer = sizeof(*integer);
1139   signed_cell *cell;
1140   TRACE(trace_devices,
1141         ("device_find_integer(me=0x%lx, property=%s)\n",
1142          (long)me, property));
1143
1144   /* check things sane */
1145   node = device_find_property(me, property);
1146   if (node == (device_property*)0
1147       || (node->type != integer_property
1148           && node->type != array_property))
1149     device_error(me, "property %s not found or of wrong type", property);
1150   if ((node->sizeof_array % sizeof_integer) != 0)
1151     device_error(me, "property %s contains an incomplete number of cells", property);
1152   if (node->sizeof_array <= sizeof_integer * index)
1153     return 0;
1154
1155   /* Find and convert the value */
1156   cell = ((signed_cell*)node->array) + index;
1157   *integer = BE2H_cell(*cell);
1158
1159   return node->sizeof_array / sizeof_integer;
1160 }
1161
1162
1163 STATIC_INLINE_DEVICE\
1164 (unsigned_cell *)
1165 unit_address_to_cells(const device_unit *unit,
1166                       unsigned_cell *cell,
1167                       int nr_cells)
1168 {
1169   int i;
1170   ASSERT(nr_cells == unit->nr_cells);
1171   for (i = 0; i < unit->nr_cells; i++) {
1172     *cell = H2BE_cell(unit->cells[i]);
1173     cell += 1;
1174   }
1175   return cell;
1176 }
1177
1178
1179 STATIC_INLINE_DEVICE\
1180 (const unsigned_cell *)
1181 cells_to_unit_address(const unsigned_cell *cell,
1182                       device_unit *unit,
1183                       int nr_cells)
1184 {
1185   int i;
1186   memset(unit, 0, sizeof(*unit));
1187   unit->nr_cells = nr_cells;
1188   for (i = 0; i < unit->nr_cells; i++) {
1189     unit->cells[i] = BE2H_cell(*cell);
1190     cell += 1;
1191   }
1192   return cell;
1193 }
1194
1195
1196 STATIC_INLINE_DEVICE\
1197 (unsigned)
1198 nr_range_property_cells(device *me,
1199                         int nr_ranges)
1200 {
1201   return ((device_nr_address_cells(me)
1202            + device_nr_address_cells(device_parent(me))
1203            + device_nr_size_cells(me))
1204           ) * nr_ranges;
1205 }
1206
1207 INLINE_DEVICE\
1208 (void)
1209 device_add_range_array_property(device *me,
1210                                 const char *property,
1211                                 const range_property_spec *ranges,
1212                                 unsigned nr_ranges)
1213 {
1214   unsigned sizeof_cells = (nr_range_property_cells(me, nr_ranges)
1215                            * sizeof(unsigned_cell));
1216   unsigned_cell *cells = zalloc(sizeof_cells);
1217   unsigned_cell *cell;
1218   int i;
1219
1220   /* copy the property elements over */
1221   cell = cells;
1222   for (i = 0; i < nr_ranges; i++) {
1223     const range_property_spec *range = &ranges[i];
1224     /* copy the child address */
1225     cell = unit_address_to_cells(&range->child_address, cell,
1226                                  device_nr_address_cells(me));
1227     /* copy the parent address */
1228     cell = unit_address_to_cells(&range->parent_address, cell,
1229                                  device_nr_address_cells(device_parent(me)));
1230     /* copy the size */
1231     cell = unit_address_to_cells(&range->size, cell,
1232                                  device_nr_size_cells(me));
1233   }
1234   ASSERT(cell == &cells[nr_range_property_cells(me, nr_ranges)]);
1235
1236   /* add it */
1237   device_add_property(me, property, range_array_property,
1238                       cells, sizeof_cells,
1239                       cells, sizeof_cells,
1240                       NULL, permenant_object);
1241
1242   zfree(cells);
1243 }
1244
1245 INLINE_DEVICE\
1246 (int)
1247 device_find_range_array_property(device *me,
1248                                  const char *property,
1249                                  unsigned index,
1250                                  range_property_spec *range)
1251 {
1252   const device_property *node;
1253   unsigned sizeof_entry = (nr_range_property_cells(me, 1)
1254                            * sizeof(unsigned_cell));
1255   const unsigned_cell *cells;
1256
1257   /* locate the property */
1258   node = device_find_property(me, property);
1259   if (node == (device_property*)0
1260       || node->type != range_array_property)
1261     device_error(me, "property %s not found or of wrong type", property);
1262
1263   /* aligned ? */
1264   if ((node->sizeof_array % sizeof_entry) != 0)
1265     device_error(me, "property %s contains an incomplete number of entries",
1266                  property);
1267
1268   /* within bounds? */
1269   if (node->sizeof_array < sizeof_entry * (index + 1))
1270     return 0;
1271
1272   /* find the range of interest */
1273   cells = (unsigned_cell*)((char*)node->array + sizeof_entry * index);
1274
1275   /* copy the child address out - converting as we go */
1276   cells = cells_to_unit_address(cells, &range->child_address,
1277                                 device_nr_address_cells(me));
1278
1279   /* copy the parent address out - converting as we go */
1280   cells = cells_to_unit_address(cells, &range->parent_address,
1281                                 device_nr_address_cells(device_parent(me)));
1282
1283   /* copy the size - converting as we go */
1284   cells = cells_to_unit_address(cells, &range->size,
1285                                 device_nr_size_cells(me));
1286
1287   return node->sizeof_array / sizeof_entry;
1288 }
1289
1290
1291 STATIC_INLINE_DEVICE\
1292 (unsigned)
1293 nr_reg_property_cells(device *me,
1294                       int nr_regs)
1295 {
1296   return (device_nr_address_cells(device_parent(me))
1297           + device_nr_size_cells(device_parent(me))
1298           ) * nr_regs;
1299 }
1300
1301 INLINE_DEVICE\
1302 (void)
1303 device_add_reg_array_property(device *me,
1304                               const char *property,
1305                               const reg_property_spec *regs,
1306                               unsigned nr_regs)
1307 {
1308   unsigned sizeof_cells = (nr_reg_property_cells(me, nr_regs)
1309                            * sizeof(unsigned_cell));
1310   unsigned_cell *cells = zalloc(sizeof_cells);
1311   unsigned_cell *cell;
1312   int i;
1313
1314   /* copy the property elements over */
1315   cell = cells;
1316   for (i = 0; i < nr_regs; i++) {
1317     const reg_property_spec *reg = &regs[i];
1318     /* copy the address */
1319     cell = unit_address_to_cells(&reg->address, cell,
1320                                  device_nr_address_cells(device_parent(me)));
1321     /* copy the size */
1322     cell = unit_address_to_cells(&reg->size, cell,
1323                                  device_nr_size_cells(device_parent(me)));
1324   }
1325   ASSERT(cell == &cells[nr_reg_property_cells(me, nr_regs)]);
1326
1327   /* add it */
1328   device_add_property(me, property, reg_array_property,
1329                       cells, sizeof_cells,
1330                       cells, sizeof_cells,
1331                       NULL, permenant_object);
1332
1333   zfree(cells);
1334 }
1335
1336 INLINE_DEVICE\
1337 (int)
1338 device_find_reg_array_property(device *me,
1339                                const char *property,
1340                                unsigned index,
1341                                reg_property_spec *reg)
1342 {
1343   const device_property *node;
1344   unsigned sizeof_entry = (nr_reg_property_cells(me, 1)
1345                            * sizeof(unsigned_cell));
1346   const unsigned_cell *cells;
1347
1348   /* locate the property */
1349   node = device_find_property(me, property);
1350   if (node == (device_property*)0
1351       || node->type != reg_array_property)
1352     device_error(me, "property %s not found or of wrong type", property);
1353
1354   /* aligned ? */
1355   if ((node->sizeof_array % sizeof_entry) != 0)
1356     device_error(me, "property %s contains an incomplete number of entries",
1357                  property);
1358
1359   /* within bounds? */
1360   if (node->sizeof_array < sizeof_entry * (index + 1))
1361     return 0;
1362
1363   /* find the range of interest */
1364   cells = (unsigned_cell*)((char*)node->array + sizeof_entry * index);
1365
1366   /* copy the address out - converting as we go */
1367   cells = cells_to_unit_address(cells, &reg->address,
1368                                 device_nr_address_cells(device_parent(me)));
1369
1370   /* copy the size out - converting as we go */
1371   cells = cells_to_unit_address(cells, &reg->size,
1372                                 device_nr_size_cells(device_parent(me)));
1373
1374   return node->sizeof_array / sizeof_entry;
1375 }
1376
1377
1378 INLINE_DEVICE\
1379 (void)
1380 device_add_string_property(device *me,
1381                            const char *property,
1382                            const char *string)
1383 {
1384   device_add_property(me, property, string_property,
1385                       string, strlen(string) + 1,
1386                       string, strlen(string) + 1,
1387                       NULL, permenant_object);
1388 }
1389
1390 INLINE_DEVICE\
1391 (const char *)
1392 device_find_string_property(device *me,
1393                             const char *property)
1394 {
1395   const device_property *node;
1396   const char *string;
1397   node = device_find_property(me, property);
1398   if (node == (device_property*)0
1399       || node->type != string_property)
1400     device_error(me, "property %s not found or of wrong type", property);
1401   string = node->array;
1402   ASSERT(strlen(string) + 1 == node->sizeof_array);
1403   return string;
1404 }
1405
1406 INLINE_DEVICE\
1407 (void)
1408 device_add_string_array_property(device *me,
1409                                  const char *property,
1410                                  const string_property_spec *strings,
1411                                  unsigned nr_strings)
1412 {
1413   int sizeof_array;
1414   int string_nr;
1415   char *array;
1416   char *chp;
1417   if (nr_strings == 0)
1418     device_error(me, "property %s must be non-null", property);
1419   /* total up the size of the needed array */
1420   for (sizeof_array = 0, string_nr = 0;
1421        string_nr < nr_strings;
1422        string_nr ++) {
1423     sizeof_array += strlen(strings[string_nr]) + 1;
1424   }
1425   /* create the array */
1426   array = (char*)zalloc(sizeof_array);
1427   chp = array;
1428   for (string_nr = 0;
1429        string_nr < nr_strings;
1430        string_nr++) {
1431     strcpy(chp, strings[string_nr]);
1432     chp += strlen(chp) + 1;
1433   }
1434   ASSERT(chp == array + sizeof_array);
1435   /* now enter it */
1436   device_add_property(me, property, string_array_property,
1437                       array, sizeof_array,
1438                       array, sizeof_array,
1439                       NULL, permenant_object);
1440 }
1441
1442 INLINE_DEVICE\
1443 (int)
1444 device_find_string_array_property(device *me,
1445                                   const char *property,
1446                                   unsigned index,
1447                                   string_property_spec *string)
1448 {
1449   const device_property *node;
1450   node = device_find_property(me, property);
1451   if (node == (device_property*)0)
1452     device_error(me, "property %s not found", property);
1453   switch (node->type) {
1454   default:
1455     device_error(me, "property %s of wrong type", property);
1456     break;
1457   case string_property:
1458     if (index == 0) {
1459       *string = node->array;
1460       ASSERT(strlen(*string) + 1 == node->sizeof_array);
1461       return 1;
1462     }
1463     break;
1464   case array_property:
1465     if (node->sizeof_array == 0
1466         || ((char*)node->array)[node->sizeof_array - 1] != '\0')
1467       device_error(me, "property %s invalid for string array", property);
1468     /* FALL THROUGH */
1469   case string_array_property:
1470     ASSERT(node->sizeof_array > 0);
1471     ASSERT(((char*)node->array)[node->sizeof_array - 1] == '\0');
1472     {
1473       const char *chp = node->array;
1474       int nr_entries = 0;
1475       /* count the number of strings, keeping an eye out for the one
1476          we're looking for */
1477       *string = chp;
1478       do {
1479         if (*chp == '\0') {
1480           /* next string */
1481           nr_entries++;
1482           chp++;
1483           if (nr_entries == index)
1484             *string = chp;
1485         }
1486         else {
1487           chp++;
1488         }
1489       } while (chp < (char*)node->array + node->sizeof_array);
1490       if (index < nr_entries)
1491         return nr_entries;
1492       else {
1493         *string = NULL;
1494         return 0;
1495       }
1496     }
1497     break;
1498   }
1499   return 0;
1500 }
1501
1502 INLINE_DEVICE\
1503 (void)
1504 device_add_duplicate_property(device *me,
1505                               const char *property,
1506                               const device_property *original)
1507 {
1508   device_property_entry *master;
1509   TRACE(trace_devices,
1510         ("device_add_duplicate_property(me=0x%lx, property=%s, ...)\n",
1511          (long)me, property));
1512   if (original->disposition != permenant_object)
1513     device_error(me, "Can only duplicate permenant objects");
1514   /* find the original's master */
1515   master = original->owner->properties;
1516   while (master->value != original) {
1517     master = master->next;
1518     ASSERT(master != NULL);
1519   }
1520   /* now duplicate it */
1521   device_add_property(me, property,
1522                       original->type,
1523                       master->init_array, master->sizeof_init_array,
1524                       original->array, original->sizeof_array,
1525                       original, permenant_object);
1526 }
1527
1528
1529 \f
1530 /* Device Hardware: */
1531
1532 INLINE_DEVICE\
1533 (unsigned)
1534 device_io_read_buffer(device *me,
1535                       void *dest,
1536                       int space,
1537                       unsigned_word addr,
1538                       unsigned nr_bytes,
1539                       cpu *processor,
1540                       unsigned_word cia)
1541 {
1542   if (me->callback->io.read_buffer == NULL)
1543     device_error(me, "no io.read_buffer method");
1544   return me->callback->io.read_buffer(me, dest, space,
1545                                       addr, nr_bytes,
1546                                       processor, cia);
1547 }
1548
1549 INLINE_DEVICE\
1550 (unsigned)
1551 device_io_write_buffer(device *me,
1552                        const void *source,
1553                        int space,
1554                        unsigned_word addr,
1555                        unsigned nr_bytes,
1556                        cpu *processor,
1557                        unsigned_word cia)
1558 {
1559   if (me->callback->io.write_buffer == NULL)
1560     device_error(me, "no io.write_buffer method");
1561   return me->callback->io.write_buffer(me, source, space,
1562                                        addr, nr_bytes,
1563                                        processor, cia);
1564 }
1565
1566 INLINE_DEVICE\
1567 (unsigned)
1568 device_dma_read_buffer(device *me,
1569                        void *dest,
1570                        int space,
1571                        unsigned_word addr,
1572                        unsigned nr_bytes)
1573 {
1574   if (me->callback->dma.read_buffer == NULL)
1575     device_error(me, "no dma.read_buffer method");
1576   return me->callback->dma.read_buffer(me, dest, space,
1577                                        addr, nr_bytes);
1578 }
1579
1580 INLINE_DEVICE\
1581 (unsigned)
1582 device_dma_write_buffer(device *me,
1583                         const void *source,
1584                         int space,
1585                         unsigned_word addr,
1586                         unsigned nr_bytes,
1587                         int violate_read_only_section)
1588 {
1589   if (me->callback->dma.write_buffer == NULL)
1590     device_error(me, "no dma.write_buffer method");
1591   return me->callback->dma.write_buffer(me, source, space,
1592                                         addr, nr_bytes,
1593                                         violate_read_only_section);
1594 }
1595
1596 INLINE_DEVICE\
1597 (void)
1598 device_attach_address(device *me,
1599                       attach_type attach,
1600                       int space,
1601                       unsigned_word addr,
1602                       unsigned nr_bytes,
1603                       access_type access,
1604                       device *client) /*callback/default*/
1605 {
1606   if (me->callback->address.attach == NULL)
1607     device_error(me, "no address.attach method");
1608   me->callback->address.attach(me, attach, space,
1609                                addr, nr_bytes, access, client);
1610 }
1611
1612 INLINE_DEVICE\
1613 (void)
1614 device_detach_address(device *me,
1615                       attach_type attach,
1616                       int space,
1617                       unsigned_word addr,
1618                       unsigned nr_bytes,
1619                       access_type access,
1620                       device *client) /*callback/default*/
1621 {
1622   if (me->callback->address.detach == NULL)
1623     device_error(me, "no address.detach method");
1624   me->callback->address.detach(me, attach, space,
1625                                addr, nr_bytes, access, client);
1626 }
1627
1628
1629 \f
1630 /* Interrupts: */
1631
1632 INLINE_DEVICE(void)
1633 device_interrupt_event(device *me,
1634                        int my_port,
1635                        int level,
1636                        cpu *processor,
1637                        unsigned_word cia)
1638 {
1639   int found_an_edge = 0;
1640   device_interrupt_edge *edge;
1641   /* device's interrupt lines directly connected */
1642   for (edge = me->interrupt_destinations;
1643        edge != NULL;
1644        edge = edge->next) {
1645     if (edge->my_port == my_port) {
1646       if (edge->dest->callback->interrupt.event == NULL)
1647         device_error(me, "no interrupt method");
1648       edge->dest->callback->interrupt.event(edge->dest,
1649                                             edge->dest_port,
1650                                             me,
1651                                             my_port,
1652                                             level,
1653                                             processor, cia);
1654       found_an_edge = 1;
1655     }
1656   }
1657   if (!found_an_edge) {
1658     device_error(me, "No interrupt edge for port %d", my_port);
1659   }
1660 }
1661
1662 INLINE_DEVICE\
1663 (void)
1664 device_interrupt_attach(device *me,
1665                         int my_port,
1666                         device *dest,
1667                         int dest_port,
1668                         object_disposition disposition)
1669 {
1670   attach_device_interrupt_edge(&me->interrupt_destinations,
1671                                my_port,
1672                                dest,
1673                                dest_port,
1674                                disposition);
1675 }
1676
1677 INLINE_DEVICE\
1678 (void)
1679 device_interrupt_detach(device *me,
1680                         int my_port,
1681                         device *dest,
1682                         int dest_port)
1683 {
1684   detach_device_interrupt_edge(me,
1685                                &me->interrupt_destinations,
1686                                my_port,
1687                                dest,
1688                                dest_port);
1689 }
1690
1691 INLINE_DEVICE\
1692 (void)
1693 device_interrupt_traverse(device *me,
1694                           device_interrupt_traverse_function *handler,
1695                           void *data)
1696 {
1697   device_interrupt_edge *interrupt_edge;
1698   for (interrupt_edge = me->interrupt_destinations;
1699        interrupt_edge != NULL;
1700        interrupt_edge = interrupt_edge->next) {
1701     handler(me, interrupt_edge->my_port,
1702             interrupt_edge->dest, interrupt_edge->dest_port,
1703             data);
1704   }
1705 }
1706
1707 INLINE_DEVICE\
1708 (int)
1709 device_interrupt_decode(device *me,
1710                         const char *port_name,
1711                         port_direction direction)
1712 {
1713   if (port_name == NULL || port_name[0] == '\0')
1714     return 0;
1715   if (isdigit(port_name[0])) {
1716     return strtoul(port_name, NULL, 0);
1717   }
1718   else {
1719     const device_interrupt_port_descriptor *ports =
1720       me->callback->interrupt.ports;
1721     if (ports != NULL) {
1722       while (ports->name != NULL) {
1723         if (ports->direction == bidirect_port
1724             || ports->direction == direction) {
1725           if (ports->nr_ports > 0) {
1726             int len = strlen(ports->name);
1727             if (strncmp(port_name, ports->name, len) == 0) {
1728               if (port_name[len] == '\0')
1729                 return ports->number;
1730               else if(isdigit(port_name[len])) {
1731                 int port = ports->number + strtoul(&port_name[len], NULL, 0);
1732                 if (port >= ports->number + ports->nr_ports)
1733                   device_error(me, "Interrupt port %s out of range",
1734                                port_name);
1735                 return port;
1736               }
1737             }
1738           }
1739           else if (strcmp(port_name, ports->name) == 0)
1740             return ports->number;
1741         }
1742         ports++;
1743       }
1744     }
1745   }
1746   device_error(me, "Unreconized interrupt port %s", port_name);
1747   return 0;
1748 }
1749
1750 INLINE_DEVICE\
1751 (int)
1752 device_interrupt_encode(device *me,
1753                         int port_number,
1754                         char *buf,
1755                         int sizeof_buf,
1756                         port_direction direction)
1757 {
1758   const device_interrupt_port_descriptor *ports = NULL;
1759   ports = me->callback->interrupt.ports;
1760   if (ports != NULL) {
1761     while (ports->name != NULL) {
1762       if (ports->direction == bidirect_port
1763           || ports->direction == direction) {
1764         if (ports->nr_ports > 0) {
1765           if (port_number >= ports->number
1766               && port_number < ports->number + ports->nr_ports) {
1767             strcpy(buf, ports->name);
1768             sprintf(buf + strlen(buf), "%d", port_number - ports->number);
1769             if (strlen(buf) >= sizeof_buf)
1770               error("device_interrupt_encode: buffer overflow");
1771             return strlen(buf);
1772           }
1773         }
1774         else {
1775           if (ports->number == port_number) {
1776             if (strlen(ports->name) >= sizeof_buf)
1777               error("device_interrupt_encode: buffer overflow");
1778             strcpy(buf, ports->name);
1779             return strlen(buf);
1780           }
1781         }
1782       }
1783       ports++;
1784     }
1785   }
1786   sprintf(buf, "%d", port_number);
1787   if (strlen(buf) >= sizeof_buf)
1788     error("device_interrupt_encode: buffer overflow");
1789   return strlen(buf);
1790 }
1791
1792
1793 \f
1794 /* IOCTL: */
1795
1796 EXTERN_DEVICE\
1797 (int)
1798 device_ioctl(device *me,
1799              cpu *processor,
1800              unsigned_word cia,
1801              device_ioctl_request request,
1802              ...)
1803 {
1804   int status;
1805   va_list ap;
1806   va_start(ap, request);
1807   if (me->callback->ioctl == NULL)
1808     device_error(me, "no ioctl method");
1809   status = me->callback->ioctl(me, processor, cia, request, ap);
1810   va_end(ap);
1811   return status;
1812 }
1813
1814
1815 \f
1816 /* I/O */
1817
1818 EXTERN_DEVICE\
1819 (void volatile)
1820 device_error(device *me,
1821              const char *fmt,
1822              ...)
1823 {
1824   char message[1024];
1825   va_list ap;
1826   /* format the message */
1827   va_start(ap, fmt);
1828   vsprintf(message, fmt, ap);
1829   va_end(ap);
1830   /* sanity check */
1831   if (strlen(message) >= sizeof(message))
1832     error("device_error: buffer overflow");
1833   if (me == NULL)
1834     error("device: %s", message);
1835   else if (me->path != NULL && me->path[0] != '\0')
1836     error("%s: %s", me->path, message);
1837   else if (me->name != NULL && me->name[0] != '\0')
1838     error("%s: %s", me->name, message);
1839   else
1840     error("device: %s", message);
1841   while(1);
1842 }
1843
1844 INLINE_DEVICE\
1845 (int)
1846 device_trace(device *me)
1847 {
1848   return me->trace;
1849 }
1850
1851 \f
1852 /* External representation */
1853
1854 INLINE_DEVICE\
1855 (device *)
1856 external_to_device(device *tree_member,
1857                    unsigned_cell phandle)
1858 {
1859   device *me = cap_internal(tree_member->phandles, phandle);
1860   return me;
1861 }
1862
1863 INLINE_DEVICE\
1864 (unsigned_cell)
1865 device_to_external(device *me)
1866 {
1867   unsigned_cell phandle = cap_external(me->phandles, me);
1868   return phandle;
1869 }
1870
1871 INLINE_DEVICE\
1872 (device_instance *)
1873 external_to_device_instance(device *tree_member,
1874                             unsigned_cell ihandle)
1875 {
1876   device_instance *instance = cap_internal(tree_member->ihandles, ihandle);
1877   return instance;
1878 }
1879
1880 INLINE_DEVICE\
1881 (unsigned_cell)
1882 device_instance_to_external(device_instance *instance)
1883 {
1884   unsigned_cell ihandle = cap_external(instance->owner->ihandles, instance);
1885   return ihandle;
1886 }
1887
1888
1889 /* Map onto the event functions */
1890
1891 INLINE_DEVICE\
1892 (event_entry_tag)
1893 device_event_queue_schedule(device *me,
1894                             signed64 delta_time,
1895                             device_event_handler *handler,
1896                             void *data)
1897 {
1898   return event_queue_schedule(psim_event_queue(me->system),
1899                               delta_time,
1900                               handler,
1901                               data);
1902 }
1903
1904 INLINE_DEVICE\
1905 (void)
1906 device_event_queue_deschedule(device *me,
1907                               event_entry_tag event_to_remove)
1908 {
1909   event_queue_deschedule(psim_event_queue(me->system),
1910                          event_to_remove);
1911 }
1912
1913 INLINE_DEVICE\
1914 (signed64)
1915 device_event_queue_time(device *me)
1916 {
1917   return event_queue_time(psim_event_queue(me->system));
1918 }
1919
1920
1921 /* Initialization: */
1922
1923
1924 INLINE_DEVICE\
1925 (void)
1926 device_clean(device *me,
1927              void *data)
1928 {
1929   psim *system;
1930   system = (psim*)data;
1931   TRACE(trace_device_init, ("device_clean - initializing %s", me->path));
1932   clean_device_interrupt_edges(&me->interrupt_destinations);
1933   clean_device_instances(me);
1934   clean_device_properties(me);
1935 }
1936
1937 /* Device initialization: */
1938
1939 INLINE_DEVICE\
1940 (void)
1941 device_init_address(device *me,
1942                     void *data)
1943 {
1944   psim *system = (psim*)data;
1945   int nr_address_cells;
1946   int nr_size_cells;
1947   TRACE(trace_device_init, ("device_init_address - initializing %s", me->path));
1948
1949   /* ensure the cap database is valid */
1950   if (me->parent == NULL) {
1951     cap_init(me->ihandles);
1952     cap_init(me->phandles);
1953   }
1954
1955   /* some basics */
1956   me->system = system; /* misc things not known until now */
1957   me->trace = (device_find_property(me, "trace")
1958                ? device_find_integer_property(me, "trace")
1959                : 0);
1960
1961   /* Ensure that the first address found in the reg property matches
1962      anything that was specified as part of the devices name */
1963   if (device_find_property(me, "reg") != NULL) {
1964     reg_property_spec unit;
1965     device_find_reg_array_property(me, "reg", 0, &unit);
1966     if (memcmp(device_unit_address(me), &unit.address, sizeof(unit.address))
1967         != 0)
1968       device_error(me, "Unit address as specified by the reg property in conflict with the value previously specified in the devices path");
1969   }
1970
1971   /* ensure that the devices #address/size-cells is consistent */
1972   nr_address_cells = device_nr_address_cells(me);
1973   if (device_find_property(me, "#address-cells") != NULL
1974       && (nr_address_cells
1975           != device_find_integer_property(me, "#address-cells")))
1976     device_error(me, "#address-cells property used before defined");
1977   nr_size_cells = device_nr_size_cells(me);
1978   if (device_find_property(me, "#size-cells") != NULL
1979       && (nr_size_cells
1980           != device_find_integer_property(me, "#size-cells")))
1981     device_error(me, "#size-cells property used before defined");
1982
1983   /* now init it */
1984   if (me->callback->init.address != NULL)
1985     me->callback->init.address(me);
1986 }
1987
1988 INLINE_DEVICE\
1989 (void)
1990 device_init_data(device *me,
1991                     void *data)
1992 {
1993   TRACE(trace_device_init, ("device_init_data - initializing %s", me->path));
1994   if (me->callback->init.data != NULL)
1995     me->callback->init.data(me);
1996 }
1997
1998 #endif /* _DEVICE_C_ */