altosui: Eliminate unncessary import altosui lines
[fw/altos] / ao-tools / altosui / AltosDebug.java
1 /*
2  * Copyright © 2010 Keith Packard <keithp@keithp.com>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; version 2 of the License.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License along
14  * with this program; if not, write to the Free Software Foundation, Inc.,
15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
16  */
17
18 package altosui;
19
20 import java.lang.*;
21 import java.io.*;
22 import java.util.concurrent.LinkedBlockingQueue;
23 import java.util.LinkedList;
24 import java.util.Iterator;
25
26 public class AltosDebug extends AltosSerial {
27
28         public static final byte WR_CONFIG =            0x1d;
29         public static final byte RD_CONFIG =            0x24;
30         public static final byte CONFIG_TIMERS_OFF =            (1 << 3);
31         public static final byte CONFIG_DMA_PAUSE =             (1 << 2);
32         public static final byte CONFIG_TIMER_SUSPEND =         (1 << 1);
33         public static final byte SET_FLASH_INFO_PAGE =          (1 << 0);
34
35         public static final byte GET_PC =               0x28;
36         public static final byte READ_STATUS =          0x34;
37         public static final byte STATUS_CHIP_ERASE_DONE =       (byte) (1 << 7);
38         public static final byte STATUS_PCON_IDLE =             (1 << 6);
39         public static final byte STATUS_CPU_HALTED =            (1 << 5);
40         public static final byte STATUS_POWER_MODE_0 =          (1 << 4);
41         public static final byte STATUS_HALT_STATUS =           (1 << 3);
42         public static final byte STATUS_DEBUG_LOCKED =          (1 << 2);
43         public static final byte STATUS_OSCILLATOR_STABLE =     (1 << 1);
44         public static final byte STATUS_STACK_OVERFLOW =        (1 << 0);
45
46         public static final byte SET_HW_BRKPNT =        0x3b;
47         public static byte       HW_BRKPNT_N(byte n)    { return (byte) ((n) << 3); }
48         public static final byte HW_BRKPNT_N_MASK =             (0x3 << 3);
49         public static final byte HW_BRKPNT_ENABLE =             (1 << 2);
50
51         public static final byte HALT =                 0x44;
52         public static final byte RESUME =               0x4c;
53         public static       byte DEBUG_INSTR(byte n)    { return (byte) (0x54|(n)); }
54         public static final byte STEP_INSTR =           0x5c;
55         public static        byte STEP_REPLACE(byte n)  { return  (byte) (0x64|(n)); }
56         public static final byte GET_CHIP_ID =          0x68;
57
58
59         boolean debug_mode;
60
61         void ensure_debug_mode() {
62                 if (!debug_mode) {
63                         printf("D\n");
64                         flush_input();
65                         debug_mode = true;
66                 }
67         }
68
69         void dump_memory(String header, int address, byte[] bytes, int start, int len) {
70                 System.out.printf("%s\n", header);
71                 for (int j = 0; j < len; j++) {
72                         if ((j & 15) == 0) {
73                                 if (j != 0)
74                                         System.out.printf("\n");
75                                 System.out.printf ("%04x:", address + j);
76                         }
77                         System.out.printf(" %02x", bytes[start + j]);
78                 }
79                 System.out.printf("\n");
80         }
81
82         /*
83          * Write target memory
84          */
85         public void write_memory(int address, byte[] bytes, int start, int len) {
86                 ensure_debug_mode();
87 //              dump_memory("write_memory", address, bytes, start, len);
88                 printf("O %x %x\n", len, address);
89                 for (int i = 0; i < len; i++)
90                         printf("%02x", bytes[start + i]);
91         }
92
93         public void write_memory(int address, byte[] bytes) {
94                 write_memory(address, bytes, 0, bytes.length);
95         }
96
97         /*
98          * Read target memory
99          */
100         public byte[] read_memory(int address, int length)
101                 throws IOException, InterruptedException {
102                 byte[]  data = new byte[length];
103
104                 flush_input();
105                 ensure_debug_mode();
106                 printf("I %x %x\n", length, address);
107                 int i = 0;
108                 int start = 0;
109                 while (i < length) {
110                         String  line = get_reply().trim();
111                         if (!Altos.ishex(line) || line.length() % 2 != 0)
112                                 throw new IOException(
113                                         String.format
114                                         ("Invalid reply \"%s\"", line));
115                         int this_time = line.length() / 2;
116                         for (int j = 0; j < this_time; j++)
117                                 data[start + j] = (byte) ((Altos.fromhex(line.charAt(j*2)) << 4) +
118                                                   Altos.fromhex(line.charAt(j*2+1)));
119                         start += this_time;
120                         i += this_time;
121                 }
122 //              dump_memory("read_memory", address, data, 0, length);
123
124                 return data;
125         }
126
127         /*
128          * Write raw bytes to the debug link using the 'P' command
129          */
130         public void write_bytes(byte[] bytes) throws IOException {
131                 int i = 0;
132                 ensure_debug_mode();
133                 while (i < bytes.length) {
134                         int this_time = bytes.length - i;
135                         if (this_time > 8)
136                                 this_time = 0;
137                         printf("P");
138                         for (int j = 0; j < this_time; j++)
139                                 printf(" %02x", bytes[i+j]);
140                         printf("\n");
141                         i += this_time;
142                 }
143         }
144
145         public void write_byte(byte b) throws IOException {
146                 byte[] bytes = { b };
147                 write_bytes(bytes);
148         }
149
150         /*
151          * Read raw bytes from the debug link using the 'G' command
152          */
153         public byte[] read_bytes(int length)
154                 throws IOException, InterruptedException {
155
156                 flush_input();
157                 ensure_debug_mode();
158                 printf("G %x\n", length);
159                 int i = 0;
160                 byte[] data = new byte[length];
161                 while (i < length) {
162                         String line = get_reply().trim();
163                         String tokens[] = line.split("\\s+");
164                         for (int j = 0; j < tokens.length; j++) {
165                                 if (!Altos.ishex(tokens[j]) ||
166                                     tokens[j].length() != 2)
167                                         throw new IOException(
168                                                 String.format
169                                                 ("Invalid read_bytes reply \"%s\"", line));
170                                 try {
171                                         data[i + j] = (byte) Integer.parseInt(tokens[j], 16);
172                                 } catch (NumberFormatException ne) {
173                                         throw new IOException(
174                                                 String.format
175                                                 ("Invalid read_bytes reply \"%s\"", line));
176                                 }
177                         }
178                         i += tokens.length;
179                 }
180                 return data;
181         }
182
183         public byte read_byte() throws IOException, InterruptedException {
184                 return read_bytes(1)[0];
185         }
186
187         public byte debug_instr(byte[] instruction) throws IOException, InterruptedException {
188                 byte[] command = new byte[1 + instruction.length];
189                 command[0] = DEBUG_INSTR((byte) instruction.length);
190                 for (int i = 0; i < instruction.length; i++)
191                         command[i+1] = instruction[i];
192                 write_bytes(command);
193                 return read_byte();
194         }
195
196         public byte resume() throws IOException, InterruptedException {
197                 write_byte(RESUME);
198                 return read_byte();
199         }
200
201         public int read_uint16() throws IOException, InterruptedException {
202                 byte[] d = read_bytes(2);
203                 return ((int) (d[0] & 0xff) << 8) | (d[1] & 0xff);
204         }
205
206         public int read_uint8()  throws IOException, InterruptedException {
207                 byte[] d = read_bytes(1);
208                 return (int) (d[0] & 0xff);
209         }
210
211         public int get_chip_id() throws IOException, InterruptedException {
212                 write_byte(GET_CHIP_ID);
213                 return read_uint16();
214         }
215
216         public int get_pc() throws IOException, InterruptedException {
217                 write_byte(GET_PC);
218                 return read_uint16();
219         }
220
221         public byte read_status() throws IOException, InterruptedException {
222                 write_byte(READ_STATUS);
223                 return read_byte();
224         }
225
226         static final byte LJMP                  = 0x02;
227
228         public void set_pc(int pc) throws IOException, InterruptedException {
229                 byte high = (byte) (pc >> 8);
230                 byte low = (byte) pc;
231                 byte[] jump_mem = { LJMP, high, low };
232                 debug_instr(jump_mem);
233         }
234
235         public boolean check_connection() throws IOException, InterruptedException {
236                 byte reply = read_status();
237                 if ((reply & STATUS_CHIP_ERASE_DONE) == 0)
238                         return false;
239                 if ((reply & STATUS_PCON_IDLE) != 0)
240                         return false;
241                 if ((reply & STATUS_POWER_MODE_0) == 0)
242                         return false;
243                 return true;
244         }
245
246         public AltosRomconfig romconfig() {
247                 try {
248                         byte[] bytes = read_memory(0xa0, 10);
249                         return new AltosRomconfig(bytes, 0);
250                 } catch (IOException ie) {
251                 } catch (InterruptedException ie) {
252                 }
253                 return new AltosRomconfig();
254         }
255
256         /*
257          * Reset target
258          */
259         public void reset() {
260                 printf ("R\n");
261         }
262 }