Modification of OPEN8 core to interface with the Memory

The open8 core is to be modified to interface with the memory. The modification is described here.
REFERENCE TO THE OPEN8 INSTRUCTION SET GUIDE
Description : There is an implementation change to the open8 core so as to interface it with the memory provided with us. The implementation change is for instructions RTI (return from interrupt) and RTS(return from subroutine).

BUG
1. The interrupt occurs
2. There are 3 bytes that are stored in the stack The PSR and the 16 bit memory return address. They are stored in memory locations 127, 126, 125. This is with accordance with the Instruction set guide.
3. After stack operations is done, it  jumps to the ISR. ISR is pointed to location pointed to in memory by 129,128 as specified in the Assembly language reference manual.
4. In the ISR, it continues to execute code and when I use the RTI instruction, the control does not resume execution from where it left off. Instead it starts executing form location 0.
5. When RTI is executed, the stack operands are all popped out from the stack and available at the inputs but the controller does not read the data


MODIFICATION





You can see the interrupt signal going high when the CPU is executing at address 150 (decimal). The execution is completed and the next address 151(16 bits) is written into the stack along with the Program status register. Appropriately the stack pointer is loaded into the PC and corresponding write signals are generated to write the return address into the memory. The PC branches to ISR (indicated by address 771 in address line). The controller then starts executing code from that position till it encounters the RTI instruction (indicated by opcode 186 in the rd_data line). As you can see the stack is popped off to read the values.






But after the values are popped, the PC is supposed to load the return address (151 in our case) into the program counter but instead it loads 0 into the PC and starts executing from there.

This because of a delay the interrupt pipeline in reading the return data after it is popped.







It is to be seen in the waveform that when rd_data line has the return address (151 in our case) the cache_ctrl is idle. The cache_ctrl becomes cache_oper1 only after the next data from the stack is read (which is a 0 in our case). This causes the PC to be set to 0 (16 bits). This can be avoided by making the following changes in the code
  when RTS_C1 =>
        CPU_Next_State   <= RTS_C2;
        AS_Ctrl.Src      <= ADDR_SP;
        SP_Ctrl.Oper     <= SP_POP;

   when RTS_C2 =>
        CPU_Next_State   <= RTS_C3;
        AS_Ctrl.Src      <= ADDR_SP;
        -- Abishek start
        Cache_Ctrl       <= CACHE_OPER1; --line added
        -- Abishek end
        -- if this is an RTI, then we need to POP theflags                                                                                                
        if( SubOp = SOP_RTI )then
          SP_Ctrl.Oper   <= SP_POP;
        end if;

    when RTS_C3 =>
        CPU_Next_State   <= RTS_C4;
        -- Abishek start
        Cache_Ctrl       <= CACHE_OPER2;   --line added
        -- Cache_Ctrl     <= CACHE_OPER1; --original line
        -- Abishek end
        -- It doesn't really matter what is on the address bus for RTS, while
        -- it does for RTI, so we make this the default
        AS_Ctrl.Src          <= ADDR_SP;

    when RTS_C4 =>
        CPU_Next_State       <= RTS_C5;
        --Abishek start
        PC_Ctrl.Oper         <= PC_LOAD;   --these lines are added
        PC_Ctrl.Addr         <= Operand2 & Operand1;
        Cache_Ctrl           <= CACHE_OPER2;
        --Abishek end

    when RTS_C5 =>
        CPU_Next_State       <= PIPE_FILL_0;
        --Abishek start
        --PC_Ctrl.Oper         <= PC_LOAD; --these lines are commented
        --PC_Ctrl.Addr         <= Operand2 & Operand1;
        --Abishek end
        if( SubOp = SOP_RTI )then
          CPU_Next_State     <= RTI_C6;
          Cache_Ctrl         <= CACHE_OPER1;
        end if;

    when RTI_C6 =>
        CPU_Next_State       <= PIPE_FILL_1;
        PC_Ctrl.Oper         <= PC_INCR;
        ALU_Ctrl.Oper        <= ALU_RFLG;
        ALU_Ctrl.Data        <= Operand1;
        PC_Ctrl.Oper         <= PC_INCR;
        Int_RTI_D            <= '1';





After the modification, you can see that the RTI opcode (186) is executed, the return address (151) is read from the stack and loaded into the PC and the PC starts executing from 151 onwards.

Comments

Post a Comment

Popular posts from this blog

Setting up atalanta ATPG to work on Linux

Atalanta is an ATPG tool that is used to generate test patterns for combinational circuits. atalanta is a windows executable file. I am using Atalanta ATPG tool to generate the test patterns required for generating the Transition fault Test patterns RUNNING ATALANTA (LINUX) You need to have WINE installed to run windows executable binary. Created a symbolic link in the usr/bin to the atalanta.exe, name of the link s atalanta. (not necessary if you do not have root privilages) chmod u+x /place/atalanta/atalanta.exe cd /usr/bin sudo ln -s /place/atalanta/atalanta.exe ./atalanta COMMAND TO RUN ATALANTA atalanta [option] filename //put this in a shell script
Read more

Generating 16k ROM using Xilinx IP COREGEN and simulating it in modelsim

The instruction ROM is an IP Core. so before interfacing with the open8, it has to be generated. The method of generating and simulating a ROM Xilinx IP Core is described here. FIND ALL THE FILES HERE 1. app.coe (the initialization file) 2. rom_16k_core.vhd 3. rom_16k_core.vho 4. rom_16k_core.xco 5. top_level.vhd 6. do_memgen.do Creation of the ROM Xilinx 10.1 1. open ISE 2. create a new project 3. tools -> core generator(12.1) (or right click on the device and add a new file 10.1) 4. In the IP catalog -> Memory and storage elements -> RAM and ROM 5. double click on block memory generator, A new window opens 6. In the new window select single port ROM click next, Write first mode 7. Select Read Width = 8 and Read Depth = 16384 for 16K ROM -> next 8. The output ports are unregistered, load initialization COE if required -> next 9. No need to use the Reset pin -> next 10. Generate. (takes a little time then shows successfully generated) This
Read more

Sparse matrix - 3 tuple representation

//program to 3-tuple representation #include<stdio.h> #include<unistd.h> #define SIZE 3000; void main() { int a[5][5],row,columns,i,j; printf("Enter the order of the matrix(5*5)"); scanf("%d %d",&row,&columns); printf("Enter the element of the matrix\n"); for(i=0;i<row;i++) for(j=0;j<columns;j++) { scanf("%d", &a[i][j]); } printf("3-tuple representation"); for(i=0;i<row;i++) for(j=0;j<columns;j++) { if(a[i][j]!=0) { printf("%d %d %d", (i+1),(j+1),a[i][j]); } } getchar(); }
Read more