コード例 #1
0
  /**
   * Instantiate and attach a dynamic PLPSimBusModule-based module to this I/O registry and to the
   * bus of the given simulation core. PLPDynamicModuleFramework is called to create a new instance
   * of the module.
   *
   * @param index Index of the dynamic module CLASS
   * @param addr Starting address of the module's memory map
   * @param size Number of registers
   * @param isWordAligned Denote whether the module's address space is word aligned
   * @param frame Frame object associated with this module
   * @return PLP_OK on completion, or PLP_DBUSMOD_INSTANTIATION_ERROR if the module object failed to
   *     initialize
   */
  public int attachDynamicModule(
      int index, long startAddr, long endAddr, boolean isWordAligned, Object frame) {
    moduleFrames.add(frame);
    PLPSimBusModule module = DynamicModuleFramework.newBusModuleInstance(index);

    if (module == null) return Constants.PLP_DMOD_INSTANTIATION_ERROR;

    module.setNewParameters(startAddr, endAddr, isWordAligned);
    modules.add(module);
    type.add(-1); // -1 for dynamic module
    regSize.add(isWordAligned ? (endAddr - startAddr) / 4 + 1 : endAddr - startAddr + 1);
    module.enable();
    positionInBus.add(plp.sim.bus.add(module));

    return Constants.PLP_OK;
  }
コード例 #2
0
  /**
   * Instantiate and attach a PLPSimBusModule-based module to this I/O registry and to the bus of
   * the given simulation core. This method also associates a module with its internal frame, if GUI
   * representation is implemented. Module developers will have to write their module's
   * initialization here.
   *
   * @param index Module type as registered in the constructor.
   * @param addr The starting address of the module's address space.
   * @param size The size of the module's address space.
   * @return PLP_OK on completion, or PLP_SIM_INVALID_MODULE if invalid index is specified.
   */
  public int attachModuleToBus(int index, long addr, long size) {
    // we're not loading dynamic modules from here (index -1)
    if (index < 0) return Constants.PLP_OK;

    PLPSimBusModule module = null;
    Object moduleFrame = null;

    Msg.D("Loading " + mods[index][0], 3, this);

    switch (index) {

        // This is where the modules are initialized when the simulator
        // requests an I/O module instance to be created.

        /** *************************************************************** */
        // PLPSimMemModule is summoned
      case 0:
        module = new MemModule(addr, size, true);

        break;

        /** *************************************************************** */
        // LEDArray is summoned
      case 1:
        module = new LEDArray(addr);
        if (plp.g()) {
          moduleFrame = new LEDArrayFrame();
          attachModuleFrameListeners((JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMLEDS);
        }

        break;

        /** *************************************************************** */
        // Switches is summoned
      case 2:
        module = new Switches(addr);
        if (plp.g()) {
          moduleFrame = new SwitchesFrame((Switches) module);
          attachModuleFrameListeners(
              (JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMSWITCHES);
        }

        break;

        /** *************************************************************** */
        // FTrace is requested, he doesn't respond to summons
      case 3:
        module = new FTracer(addr, size);
        break;

        /** *************************************************************** */
        // PLPID is summoned
      case 4:
        module = new PLPID(addr);
        if (plp.g()) {
          moduleFrame = new PLPIDFrame((PLPID) module);
          attachModuleFrameListeners((JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMPLPID);
        }
        break;

        /** *************************************************************** */
        // DummyMemory is summoned
      case 5:
        module = new DummyMemory(addr, size, true);
        break;

        /** *************************************************************** */
        // VGA is summoned
      case 6:
        if (plp.g()) {
          moduleFrame = new VGAFrame();
          attachModuleFrameListeners((JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMVGA);
        }
        module = new VGA(addr, plp.sim.bus, (VGAFrame) moduleFrame);
        module.threaded = plptool.Config.threadedModEnabled;
        module.stop = false;
        if (module.threaded) module.start();
        break;

        /** *************************************************************** */
        // Timer is summoned
      case 7:
        module = new Timer(addr, plp.sim);
        break;

        /** *************************************************************** */
        // UART is summoned
      case 8:
        if (plp.g()) {
          moduleFrame = new UARTFrame();
          attachModuleFrameListeners((JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMUART);
        }
        module = new UART(addr, (UARTFrame) moduleFrame, plp.sim);
        break;

        /** *************************************************************** */
        // Seven Segments is summoned
      case 9:
        module = new SevenSegments(addr);
        if (plp.g()) {
          moduleFrame = new SevenSegmentsFrame();
          attachModuleFrameListeners(
              (JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMSEVENSEGMENTS);
        }

        break;

        /** *************************************************************** */
        // Interrupt Controller is summoned
      case 10:
        module = new InterruptController(addr, plp.sim);

        break;

        /** *************************************************************** */
        // Bus monitor is summoned
      case 11:
        module = new BusMonitor(plp.sim);
        if (plp.g()) {
          moduleFrame = new BusMonitorFrame((BusMonitor) module, null);
        }

        break;

        /** *************************************************************** */
        // GPIO is summoned
      case 12:
        module = new GPIO(addr);
        if (plp.g()) {
          moduleFrame = new GPIOFrame((GPIO) module);
          attachModuleFrameListeners((JFrame) moduleFrame, plp, Constants.PLP_TOOLFRAME_SIMGPIO);
        }

        break;

        // ADD YOUR MODULE INITIALIZATION HERE

        // ...3rd party code...//

        /** DO NOT EDIT ANYTHING BELOW THIS * */
      default:
        return Msg.E(
            "attachModuleToBus(): invalid module ID.", Constants.PLP_SIM_INVALID_MODULE, this);
    }

    moduleFrames.add(moduleFrame);
    modules.add(module);
    type.add(index);
    regSize.add(size);
    module.enable();
    positionInBus.add(plp.sim.bus.add(module));

    // if(moduleFrame != null && moduleFrame instanceof JFrame) {
    // attachModuleFrameListeners((JFrame) moduleFrame, plp);
    // simDesktop.add((JFrame) moduleFrame);
    // ((JFrame) moduleFrame).setVisible(true);
    // }

    return Constants.PLP_OK;
  }