diff --git a/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb b/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb index 15a9d8985625cada4d7dfb655cf4cd17ba07fc2b..7109345de811fa0a708cb4b9550c695166eccf14 100755 --- a/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb +++ b/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -115,16 +115,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'2023/2/20 17:44:40 +479858'" + "'2023/3/14 10:6:56 +300702'" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -139,6 +139,50 @@ "metadata": {}, "source": [] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/xilinx/pynq/overlays/soclabs/design_1.bit\n", + "2023/3/14 10:6:56 +300702\n" + ] + } + ], + "source": [ + "print(PL.bitfile_name)\n", + "print(PL.timestamp)\n", + "\n", + "#PL.ip_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x80020000\n", + "0x80060000\n" + ] + } + ], + "source": [ + "ADP_address = PL.ip_dict['cmsdk_socket/axi_stream_io_0']['phys_addr']\n", + "print(hex(ADP_address))\n", + "UART2_address = PL.ip_dict['cmsdk_socket/axi_uartlite_0']['phys_addr']\n", + "print(hex(UART2_address))" + ] + }, { "cell_type": "code", "execution_count": 6, @@ -153,8 +197,8 @@ "#ADP_address = 0x80020000 # nanosoc FT1248 com channel\n", "#ADP_address = 0x80030000 # streamio TX/RX loopback (unbuffered)\n", "#ADP_address = 0x80040000 # streamio TX/RX loopback (FIFO buffered)\n", - "ADP_address = 0x80050000 # local test ADP controller COM channel\n", - "UART2_address = 0x80060000 # nanosoc UART2 com serial (9600 baud?)\n", + "#ADP_address = 0x80050000 # local test ADP controller COM channel\n", + "#UART2_address = 0x80060000 # nanosoc UART2 com serial (9600 baud?)\n", "#ADP_address = 0x80070000 # uart TX/RX loopback\n", "\n", "# HARDWARE CONSTANTS\n", @@ -225,7 +269,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Inspect the ADP banner after reset (0x50CLAB02 expected)" + "Inspect the ADP banner after reset (0x50CLAB03 expected)" ] }, { @@ -234,21 +278,26 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "' 0x50c1ab02\\n\\r\\n\\r]'" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " 0x50c1ab03\n", + "\r\n", + "\n", + "\n", + "SOCLABS: ARM Cortex-M0 nanosoc\n", + "** Remap->RAM2\n", + "\n", + "\r", + "]\n" + ] } ], "source": [ "adp = ADPIO(ADP_address)\n", "# Setup AXI UART register\n", "adp.setupCtrlReg()\n", - "adp.read(20)" + "print(adp.read(100))" ] }, { @@ -294,26 +343,25 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'A 0x00000000\\n\\r]'" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x00000000\n", + "\r", + "]\n" + ] } ], "source": [ "adp.write('A\\n')\n", - "adp.read(20)" + "print(adp.read(100))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "And do a couple of 32-bit reads" + "Do a couple of auto-incrementing 32-bit reads from ROM1 space" ] }, { @@ -322,19 +370,22 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'R 0x00000000\\n\\r]'" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x10000000\n", + "\r", + "]R 0x30000368\n", + "\r", + "]R 0x10000335\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('R\\n')\n", - "adp.read(15)" + "adp.write('A 0x10000000\\nR\\nR\\n')\n", + "print(adp.read(100))" ] }, { @@ -343,26 +394,29 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'R 0x00000000\\n\\r]'" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x30000000\n", + "\r", + "]R 0x05f5e100\n", + "\r", + "]R 0x00000000\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('R\\n')\n", - "adp.read(15)" + "adp.write('A 0x30000000\\nR\\nR\\n')\n", + "print(adp.read(100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Verify the address pointer has auto-incremented two words" + "Write patterns to RAM3 base" ] }, { @@ -371,47 +425,62 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'A 0x00000008\\n\\r]'" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x30000000\n", + "\r", + "]W 0x11111111\n", + "\r", + "]W 0x22222222\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('A\\n')\n", - "adp.read(15)" + "adp.write('A 0x30000000\\nW 0x11111111\\nW22222222\\n')\n", + "print(adp.read(100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now set adp address to high memory and write a couple of patterns" + "Read back the patterns from RAM3" ] }, { "cell_type": "code", "execution_count": 13, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { - "data": { - "text/plain": [ - "'A 0xc0000000\\n\\r]'" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x30000000\n", + "\r", + "]R 0x11111111\n", + "\r", + "]R 0x22222222\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('A c0000000\\n')\n", - "adp.read(20)" + "adp.write('A 0x30000000\\nR\\nR\\n')\n", + "print(adp.read(100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next try writes to map with bus errors - get a \"!\" warning on faulting accesses" ] }, { @@ -420,19 +489,22 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'W 0x11111111\\n\\r]'" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x50000000\n", + "\r", + "]W!0x11111111\n", + "\r", + "]W!0x22222222\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('W 111111111\\n')\n", - "adp.read(15)" + "adp.write('A 0x50000000\\nW 0x11111111\\nW22222222\\n')\n", + "print(adp.read(100))" ] }, { @@ -441,26 +513,29 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'W 0x22222222\\n\\r]'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x50000000\n", + "\r", + "]R!0x00000000\n", + "\r", + "]R!0x00000000\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('W 22222222\\n')\n", - "adp.read(15)" + "adp.write('A 0x50000000\\nR\\nR\\n')\n", + "print(adp.read(100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Reset the address pointer and verify same patterns read back" + "Run a poll cammand (no match), followed by a poll with match" ] }, { @@ -469,19 +544,34 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'A 0xc0000000\\n\\r]'" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x10000000\n", + "]M 0xf0000000\n", + "]V 0x00000000\n", + "]P!0x00004000\n", + "]\n", + "A 0x10000000\n", + "]M 0xf0000000\n", + "]V 0x30000000\n", + "]P 0x00000001\n", + "]\n" + ] } ], "source": [ - "adp.write('A c0000000\\n')\n", - "adp.read(20)" + "adp.write('A 10000000\\nM 0xF0000000\\nV 0\\nP 4000\\n')\n", + "print(adp.read(100))\n", + "adp.write('A 10000000\\nM\\nV 30000000\\nP 2000\\n')\n", + "print(adp.read(100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fill command - set a pattern value, base address and Fill number of words" ] }, { @@ -490,19 +580,26 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'R 0x11111111\\n\\r]'" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x90000000\n", + "\r", + "]V 0x87654321\n", + "\r", + "]F 0x00000400\n", + "\r", + "]A 0x90001000\n", + "\r", + "]W 0xffffffff\n", + "\r", + "]\n" + ] } ], "source": [ - "adp.write('R\\n')\n", - "adp.read(15)" + "adp.write('A 90000000\\nV 0x87654321\\nF 400\\nA\\nW FFFFFFFF\\n')\n", + "print(adp.read(100))" ] }, { @@ -511,19 +608,27 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "'R 0x22222222\\n\\r]'" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "A 0x90000000\n", + "]R 0x87654321\n", + "]R 0x87654321\n", + "]R 0x87654321\n", + "]\n", + "A 0x90000ffc\n", + "]R 0x87654321\n", + "]R 0xffffffff\n", + "]A 0x90001004\n", + "]\n" + ] } ], "source": [ - "adp.write('R\\n')\n", - "adp.read(15)" + "adp.write('A 0x90000000\\nR\\nR\\nR\\n')\n", + "print(adp.read(100))\n", + "adp.write('A 0x90000FFC\\nR\\nR\\nA\\n')\n", + "print(adp.read(100))" ] }, { diff --git a/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd b/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd index d0b75b39580ddb49af40fd737ded8ca4e2a32c1e..c7a8ea7f9a973f6058895275058fb4fc12ecf4c5 100644 --- a/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd +++ b/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd @@ -19,9 +19,28 @@ r r r r -a 30000200 -z 400 A + +v 0xe5e5e5e5 +a 80000000 +f 4000 +A +A b0000000 +w 1 +r +A +A 0x10000000 +R +m 0xf0000000 +V 0x30000000 +P 1fff +A +A 0x10000000 +M +V +P 200 +A +! C 201 A diff --git a/IPLIB/ADPcontrol_v1_0/ADPmanager.v b/IPLIB/ADPcontrol_v1_0/ADPmanager.v index f4747ae3006625177bd065d731cdf0604d7334e9..96761df3a81a88f2de84365b8c685bde8eb0ff29 100755 --- a/IPLIB/ADPcontrol_v1_0/ADPmanager.v +++ b/IPLIB/ADPcontrol_v1_0/ADPmanager.v @@ -63,17 +63,17 @@ wire STD_RXE_i = !STDRX_TVALID_i; `ifdef ADPBASIC localparam BANNERHEX = 32'h50c1ab01; `else - localparam BANNERHEX = 32'h50c1ab02; + localparam BANNERHEX = 32'h50c1ab03; `endif localparam CMD_bad = 4'b0000; localparam CMD_A = 4'b0001; // set address `ifndef ADPBASIC -localparam CMD_B = 4'b1000; // Binary upload (wordocunt) from addr++ +localparam CMD_U = 4'b1000; // Binary Upload (wordocunt) from addr++ localparam CMD_M = 4'b1010; // set read mask localparam CMD_P = 4'b1011; // Poll hardware (count) localparam CMD_V = 4'b1100; // match value -localparam CMD_Z = 4'b1101; // Zero-fill (wordocunt) from addr++ +localparam CMD_F = 4'b1101; // (Zero)fill (wordocunt) from addr++ `endif localparam CMD_C = 4'b1001; // Control localparam CMD_R = 4'b0010; // read word, addr++ @@ -103,16 +103,16 @@ case (char8[7:0]) "X": FNvalid_cmd = CMD_X; "x": FNvalid_cmd = CMD_X; `ifndef ADPBASIC -"B": FNvalid_cmd = CMD_B; -"b": FNvalid_cmd = CMD_B; +"U": FNvalid_cmd = CMD_U; +"u": FNvalid_cmd = CMD_U; "M": FNvalid_cmd = CMD_M; "m": FNvalid_cmd = CMD_M; "P": FNvalid_cmd = CMD_P; "p": FNvalid_cmd = CMD_P; "V": FNvalid_cmd = CMD_V; "v": FNvalid_cmd = CMD_V; -"Z": FNvalid_cmd = CMD_Z; -"z": FNvalid_cmd = CMD_Z; +"F": FNvalid_cmd = CMD_F; +"f": FNvalid_cmd = CMD_F; `endif default: FNvalid_cmd = 0; @@ -282,17 +282,17 @@ localparam STD_RXD1 = 6'b011010 ; localparam STD_RXD2 = 6'b011011 ; localparam STD_TXD1 = 6'b011101 ; localparam STD_TXD2 = 6'b011110 ; -localparam ADP_BCTRL = 6'b011111 ; -localparam ADP_BREADB0 = 6'b100000 ; -localparam ADP_BREADB1 = 6'b100001 ; -localparam ADP_BREADB2 = 6'b100010 ; -localparam ADP_BREADB3 = 6'b100011 ; -localparam ADP_BWRITE = 6'b100100 ; +localparam ADP_UCTRL = 6'b011111 ; +localparam ADP_UREADB0 = 6'b100000 ; +localparam ADP_UREADB1 = 6'b100001 ; +localparam ADP_UREADB2 = 6'b100010 ; +localparam ADP_UREADB3 = 6'b100011 ; +localparam ADP_UWRITE = 6'b100100 ; localparam ADP_POLL = 6'b100101 ; localparam ADP_POLL1 = 6'b100110 ; localparam ADP_POLL2 = 6'b100111 ; -localparam ADP_ZCTRL = 6'b101110 ; -localparam ADP_ZWRITE = 6'b101111 ; +localparam ADP_FCTRL = 6'b101110 ; +localparam ADP_FWRITE = 6'b101111 ; localparam ADP_ECHOCMD = 6'b110000 ; localparam ADP_ECHOCMDSP = 6'b110001 ; localparam ADP_UNKNOWN = 6'b101000 ; @@ -333,17 +333,17 @@ localparam STD_RXD1 = 48'b000000000000000000000100000000000000000000000000 localparam STD_RXD2 = 48'b000000000000000000001000000000000000000000000000 ; // = 6'b011011 localparam STD_TXD1 = 48'b000000000000000000010000000000000000000000000000 ; // = 6'b011101 localparam STD_TXD2 = 48'b000000000000000000100000000000000000000000000000 ; // = 6'b011110 -localparam ADP_BCTRL = 48'b000000000000000001000000000000000000000000000000 ; // = 6'b011111 -localparam ADP_BREADB0 = 48'b000000000000000010000000000000000000000000000000 ; // = 6'b100000 -localparam ADP_BREADB1 = 48'b000000000000000100000000000000000000000000000000 ; // = 6'b100001 -localparam ADP_BREADB2 = 48'b000000000000001000000000000000000000000000000000 ; // = 6'b100010 -localparam ADP_BREADB3 = 48'b000000000000010000000000000000000000000000000000 ; // = 6'b100011 -localparam ADP_BWRITE = 48'b000000000000100000000000000000000000000000000000 ; // = 6'b100100 +localparam ADP_UCTRL = 48'b000000000000000001000000000000000000000000000000 ; // = 6'b011111 +localparam ADP_UREADB0 = 48'b000000000000000010000000000000000000000000000000 ; // = 6'b100000 +localparam ADP_UREADB1 = 48'b000000000000000100000000000000000000000000000000 ; // = 6'b100001 +localparam ADP_UREADB2 = 48'b000000000000001000000000000000000000000000000000 ; // = 6'b100010 +localparam ADP_UREADB3 = 48'b000000000000010000000000000000000000000000000000 ; // = 6'b100011 +localparam ADP_UWRITE = 48'b000000000000100000000000000000000000000000000000 ; // = 6'b100100 localparam ADP_POLL = 48'b000000000001000000000000000000000000000000000000 ; // = 6'b100101 localparam ADP_POLL1 = 48'b000000000010000000000000000000000000000000000000 ; // = 6'b100110 localparam ADP_POLL2 = 48'b000000000100000000000000000000000000000000000000 ; // = 6'b100111 -localparam ADP_ZCTRL = 48'b000000001000000000000000000000000000000000000000 ; // = 6'b101110 -localparam ADP_ZWRITE = 48'b000000010000000000000000000000000000000000000000 ; // = 6'b101111 +localparam ADP_FCTRL = 48'b000000001000000000000000000000000000000000000000 ; // = 6'b101110 +localparam ADP_FWRITE = 48'b000000010000000000000000000000000000000000000000 ; // = 6'b101111 localparam ADP_ECHOCMD = 48'b000000100000000000000000000000000000000000000000 ; // = 6'b110000 localparam ADP_ECHOCMDSP = 48'b000001000000000000000000000000000000000000000000 ; // = 6'b110001 localparam ADP_UNKNOWN = 48'b000010000000000000000000000000000000000000000000 ; // = 6'b101000 @@ -364,8 +364,9 @@ reg [ 7:0] std_tx_byte; reg std_rx_ack ; reg adp_bus_req ; reg adp_bus_write ; +reg adp_bus_err ; reg [7:0] adp_cmd ; -reg [31:0] adp_param ; +reg [32:0] adp_param ; reg [31:0] adp_addr ; reg adp_addr_inc; reg [31:0] adp_sys ; @@ -411,16 +412,12 @@ assign HWRITE_o = adp_bus_write; `ifndef ADPBASIC -//reg [63:0] adp_bctrl64; -reg [31:0] adp_bctrl; reg [31:0] adp_val; reg [31:0] adp_mask; reg [31:0] adp_poll; reg [31:0] adp_count; reg adp_count_dec ; wire adp_delay_done; -wire adp_bctrl_done; -wire adp_bctrl_zero; wire poll2_loop_next; `endif @@ -476,6 +473,7 @@ always @(posedge HCLK or negedge HRESETn) std_tx_req <= 0; // default no TX req std_rx_ack <= 0; // default no RX ack adp_bus_req <= 0; // default no bus transaction + adp_bus_err <= 0; // default no bus error adp_cmd <= 0; adp_param <= 0; adp_addr <= 0; @@ -506,7 +504,7 @@ always @(posedge HCLK or negedge HRESETn) STD_IOCHK: // check for commsrx or STDOUT and not busy service, else loop back if (com_rx_req) begin com_rx_ack <= 1; adp_state <= STD_RXD1; end // input char pending for STDIN // else if (com_tx_ack & std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending and not busy - else if (std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending and not busy + else if (std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending STD_TXD1: // get STD out char if (std_rx_done) begin com_tx_byte <= std_rx_byte; com_tx_req <= 1; adp_state <= STD_TXD2; end @@ -532,9 +530,12 @@ always @(posedge HCLK or negedge HRESETn) else com_tx_req <= 1; // extend ADP_IOCHK: // check for commsrx or STDOUT and not busy service, else loop back - if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end - else if (com_tx_ack & std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end -// else if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end + if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end + else if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end + +// if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end +// else if (com_tx_ack & std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end +//// else if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end // >>>>>>>>>>>>>>>> ADP <STDOUT> >>>>>>>>>>>>>>>>>>>>>> ADP_STDOUT: // output "<" @@ -547,7 +548,7 @@ always @(posedge HCLK or negedge HRESETn) if (com_tx_done) begin com_tx_byte <= ">"; com_tx_req <= 1; adp_state <= ADP_STDOUT3; end else com_tx_req <= 1; // else extend ADP_STDOUT3: // output ">" - if (com_tx_done) begin adp_state <= ADP_IOCHK; end + if (com_tx_done) begin if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end else adp_state <= ADP_IOCHK; end else com_tx_req <= 1; // else extend // >>>>>>>>>>>>>>>> ADP COMMAND PARSING >>>>>>>>>>>>>>>>>>>>>> @@ -556,7 +557,7 @@ always @(posedge HCLK or negedge HRESETn) if (FNexit(com_rx_byte)) adp_state <= STD_IOCHK; // immediate exit else if (FNvalid_space(com_rx_byte)) com_rx_ack <= 1; // retry for a command else if (FNvalid_EOL(com_rx_byte)) begin adp_cmd <= "?"; adp_state <= ADP_ACTION; end // no command, skip param - else begin adp_cmd <= com_rx_byte; adp_param <= 32'hffffffff; com_rx_ack <= 1; adp_state <= ADP_RXPARAM; end // get optional parameter + else begin adp_cmd <= com_rx_byte; adp_param <= 33'h1_00000000; com_rx_ack <= 1; adp_state <= ADP_RXPARAM; end // get optional parameter end else com_rx_ack <= 1; // extend stream request if not ready ADP_RXPARAM: // read and build hex parameter @@ -564,12 +565,12 @@ always @(posedge HCLK or negedge HRESETn) if (FNexit(com_rx_byte)) adp_state <= STD_IOCHK; // exit else if (FNvalid_EOL(com_rx_byte)) `ifndef ADPBASIC - begin adp_count <= adp_param; adp_state <= ADP_ACTION; end // parameter complete on EOL + begin adp_count <= adp_param[31:0]; adp_state <= ADP_ACTION; end // parameter complete on EOL `else begin adp_state <= ADP_ACTION; end // parameter complete on EOL `endif else - begin adp_param <= FNBuild_param32_hexdigit(adp_param, com_rx_byte); com_rx_ack <= 1; end // build parameter + begin adp_param <= {1'b0,FNBuild_param32_hexdigit(adp_param[31:0], com_rx_byte)}; com_rx_ack <= 1; end // build parameter end else com_rx_ack <= 1; @@ -577,7 +578,7 @@ always @(posedge HCLK or negedge HRESETn) if (FNexit(com_rx_byte)) adp_state <= STD_IOCHK; else if (FNvalid_cmd(adp_cmd) == CMD_A) - begin if (adp_param == 32'hffffffff) adp_param <= adp_addr; else adp_addr <= adp_param; + begin if (adp_param[32] == 1'b1) adp_param <= {1'b0, adp_addr}; else adp_addr <= adp_param[31:0]; adp_state <= ADP_ECHOCMD; end else if (FNvalid_cmd(adp_cmd) == CMD_C) begin if (adp_param[31:8] == 0) // report GPO @@ -596,22 +597,22 @@ always @(posedge HCLK or negedge HRESETn) else if (FNvalid_cmd(adp_cmd) == CMD_S) begin adp_state <= ADP_SYSCHK; end else if (FNvalid_cmd(adp_cmd) == CMD_W) - begin adp_bus_data <= adp_param; ADP_BUSWRITEINC_next(); adp_state <= ADP_WRITE; end + begin adp_bus_data <= adp_param[31:0]; ADP_BUSWRITEINC_next(); adp_state <= ADP_WRITE; end else if (FNvalid_cmd(adp_cmd) == CMD_X) begin com_tx_byte <= 8'h0a; com_tx_req <= 1; adp_state <= ADP_EXIT; end `ifndef ADPBASIC - else if (FNvalid_cmd(adp_cmd) == CMD_B) - if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_BCTRL; // non-zero count + else if (FNvalid_cmd(adp_cmd) == CMD_U) + if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_UCTRL; // non-zero count else if (FNvalid_cmd(adp_cmd) == CMD_M) - begin if (adp_param == 32'hffffffff) adp_param <= adp_mask; else adp_mask <= adp_param; + begin if (adp_param[32] == 1'b1) adp_param <= {1'b0,adp_mask}; else adp_mask <= adp_param[31:0]; adp_state <= ADP_ECHOCMD; end else if (FNvalid_cmd(adp_cmd) == CMD_P) - if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_POLL; // non-zero count + if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_POLL; // non-zero count else if (FNvalid_cmd(adp_cmd) == CMD_V) - begin if (adp_param == 32'hffffffff) adp_param <= adp_val; else adp_val <= adp_param; + begin if (adp_param[32] == 1'b1) adp_param <= {1'b0,adp_val}; else adp_val <= adp_param[31:0]; adp_state <= ADP_ECHOCMD; end - else if (FNvalid_cmd(adp_cmd) == CMD_Z) - if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_ZCTRL; // non-zero count + else if (FNvalid_cmd(adp_cmd) == CMD_F) + if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_FCTRL; // non-zero count `endif else begin ADP_txchar_next("?"); adp_state <= ADP_UNKNOWN; end // unrecognised/invald @@ -619,53 +620,53 @@ always @(posedge HCLK or negedge HRESETn) // >>>>>>>>>>>>>>>> ADP BUS WRITE and READ >>>>>>>>>>>>>>>>>>>>>> ADP_WRITE: // perform bus write at current address pointer (and auto increment) - if (adp_bus_done) begin adp_state <= ADP_ECHOCMD; end + if (adp_bus_done) begin adp_state <= ADP_ECHOCMD; adp_bus_err <= HRESP_i; end else begin ADP_BUSWRITEINC_next(); end // extend request ADP_READ: // perform bus read at current adp address (and auto increment) - and report in hex - if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; ADP_txchar_next("R"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP; end + if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_bus_err <= HRESP_i; ADP_txchar_next("R"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP; end else begin ADP_BUSREADINC_next(); end // extend request `ifndef ADPBASIC // >>>>>>>>>>>>>>>> ADP BINARY UPLOAD >>>>>>>>>>>>>>>>>>>>>> - ADP_BCTRL: // set control value - begin com_rx_ack <= 1; adp_state <= ADP_BREADB0; end // read next 4 bytes - ADP_BREADB0: // read raw binary byte - if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[31:24] <= com_rx_byte; adp_state <= ADP_BREADB1; end + ADP_UCTRL: // set control value + begin com_rx_ack <= 1; adp_state <= ADP_UREADB0; end // read next 4 bytes + ADP_UREADB0: // read raw binary byte + if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[31:24] <= com_rx_byte; adp_state <= ADP_UREADB1; end else com_rx_ack <= 1; // extend stream request if not ready - ADP_BREADB1: // read raw binary byte - if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[23:16] <= com_rx_byte; adp_state <= ADP_BREADB2; end + ADP_UREADB1: // read raw binary byte + if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[23:16] <= com_rx_byte; adp_state <= ADP_UREADB2; end else com_rx_ack <= 1; // extend stream request if not ready - ADP_BREADB2: // read raw binary byte 0 - if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[15: 8] <= com_rx_byte; adp_state <= ADP_BREADB3; end + ADP_UREADB2: // read raw binary byte 0 + if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[15: 8] <= com_rx_byte; adp_state <= ADP_UREADB3; end else com_rx_ack <= 1; // extend stream request if not ready - ADP_BREADB3: // read raw binary byte 0 + ADP_UREADB3: // read raw binary byte 0 if (com_rx_done) - begin adp_bus_data[ 7: 0] <= com_rx_byte; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_BWRITE; end + begin adp_bus_data[ 7: 0] <= com_rx_byte; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_UWRITE; end else com_rx_ack <= 1; // extend stream request if not ready - ADP_BWRITE: // Write word to Addr++ + ADP_UWRITE: // Write word to Addr++ if (adp_bus_done) begin // auto address++, count-- - if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_BREADB0; end + if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_UREADB0; adp_bus_err <= adp_bus_err | HRESP_i; end end else begin ADP_BUSWRITEINC_next(); adp_count_dec <= 1; end // extend request // >>>>>>>>>>>>>>>> ADP BUS READ LOOP >>>>>>>>>>>>>>>>>>>>>> ADP_POLL: // set poll value begin adp_bus_req <= 1; adp_bus_write <= 0; adp_state <= ADP_POLL1; end ADP_POLL1: // wait for read data, no addr++ - if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_count_dec <=1; adp_state <= ADP_POLL2; end + if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_count_dec <=1; adp_state <= ADP_POLL2; adp_bus_err <= adp_bus_err | HRESP_i; end else begin adp_bus_req <= 1; adp_count_dec <=1; end ADP_POLL2: - if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; // timeout - else if (((adp_bus_data & adp_mask) ^ adp_val) == 0) adp_state <= ADP_WRITEHEX; // exact match + if (FNcount_down_zero_next(adp_count)) begin adp_state <= ADP_ECHOCMD; adp_bus_err <= 1'b1; end // timeout + else if (((adp_bus_data & adp_mask) ^ adp_val) == 0) begin adp_state <= ADP_ECHOCMD; adp_param <= {1'b0, (adp_param[31:0] - adp_count)}; end // exact match else adp_state <= ADP_POLL; -// >>>>>>>>>>>>>>>> ADP ZERO MEMORY >>>>>>>>>>>>>>>>>>>>>> - ADP_ZCTRL: // set control value - begin adp_bus_data <= adp_val; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_ZWRITE; end - ADP_ZWRITE: // Write word to Addr++ +// >>>>>>>>>>>>>>>> ADP (ZERO) FILL MEMORY >>>>>>>>>>>>>>>>>>>>>> + ADP_FCTRL: // set control value + begin adp_bus_data <= adp_val; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_FWRITE; end + ADP_FWRITE: // Write word to Addr++ if (adp_bus_done) begin // auto address++, count-- - if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_ZCTRL; end + if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_FCTRL; adp_bus_err <= adp_bus_err | HRESP_i; end end else begin ADP_BUSWRITEINC_next(); adp_count_dec <= 1; end // extend request `endif @@ -692,13 +693,13 @@ always @(posedge HCLK or negedge HRESETn) begin adp_bus_data <= {GPI8_i[7:0],adp_sys[7:0],adp_param[15:0]}; ADP_txchar_next("C"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP; end ADP_ECHOCMD: // output command and (param) data - begin adp_state <= ADP_ECHOCMDSP; ADP_txchar_next(adp_cmd & 8'h5f); adp_bus_data <= adp_param; end // output command char + begin adp_state <= ADP_ECHOCMDSP; ADP_txchar_next(adp_cmd & 8'h5f); adp_bus_data <= adp_param[31:0]; end // output command char ADP_ECHOCMDSP: // output command space and (bus) data - if (com_tx_done) begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(" "); end // output space char + if (com_tx_done) begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(adp_bus_err ? "!" : " "); end // output space char, or "!" on bus error else com_tx_req <= 1; // extend ADP_WRITEHEX: // output hex word with prefix - begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(" "); end // output "0" hex prefix + begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(adp_bus_err ? "!" : " "); end // output space char, or "!" on bus error ADP_WRITEHEXS: if (com_tx_done) begin adp_state <= ADP_WRITEHEX9; ADP_txchar_next("0"); end // output "0" hex prefix @@ -732,6 +733,7 @@ always @(posedge HCLK or negedge HRESETn) else com_tx_req <= 1; // extend ADP_WRITEHEX0: // output hex nibble 0 (if not startup banner then scan to end of line before lineack if (com_tx_done) begin + adp_bus_err <= 1'b0; // clear sticky bus error flag if (banner) begin ADP_LINEACK_next(); end else begin ADP_txchar_next(8'h0A); com_tx_req <= 1; adp_state <= ADP_LINEACK; end // newline and prompt end else com_tx_req <= 1; // extend @@ -746,7 +748,7 @@ always @(posedge HCLK or negedge HRESETn) else begin ADP_txchar_next(PROMPT_CHAR); adp_state <= ADP_PROMPT; end end else com_tx_req <= 1; // extend default: - begin ADP_txchar_next("!"); adp_state <= ADP_UNKNOWN; end // default error + begin ADP_txchar_next("#"); adp_state <= ADP_UNKNOWN; end // default error endcase end @@ -756,8 +758,8 @@ endmodule //ADPmaster // #(.PROMPT_CHAR ("]")) // ADPmaster( -// .HCLK (ahb_hclk ), -// .HRESETn (ahb_hrestn ), +// .HCLK (ahb_hclk ), +// .HRESETn (ahb_hrestn ), // .HADDR32_o (ahb_haddr ), // .HBURST3_o (ahb_hburst ), // .HMASTLOCK_o (ahb_hmastlock ),