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 ),