URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or_debug_proxy/] [src/] [or_debug_proxy.c] - Blame information for rev 608

Go to most recent revision | Details | Compare with Previous | View Log


/*$$HEADER*/
/******************************************************************************/
/*                                                                            */
/*                    H E A D E R   I N F O R M A T I O N                     */
/*                                                                            */
/******************************************************************************/
 
// Project Name                   : OpenRISC Debug Proxy
// File Name                      : or_debug_proxy.c
// Prepared By                    : jb
// Project Start                  : 2008-10-01
 
/*$$COPYRIGHT NOTICE*/
/******************************************************************************/
/*                                                                            */
/*                      C O P Y R I G H T   N O T I C E                       */
/*                                                                            */
/******************************************************************************/
/*
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation;
  version 2.1 of the License, a copy of which is available from
  http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
/*$$DESCRIPTION*/
/******************************************************************************/
/*                                                                            */
/*                           D E S C R I P T I O N                            */
/*                                                                            */
/******************************************************************************/
//
// The entry point for the OpenRISC debug proxy console application. Is 
// compilable under both Linux/Unix systems and Cygwin Windows.
//
 
#include <assert.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <sys/types.h>
 
// Windows includes
#ifdef CYGWIN_COMPILE
#include <windows.h>
#include "win_FTCJTAG.h"
#include "win_FTCJTAG_ptrs.h"
#else
#include <signal.h>
void catch_sigint(int sig_num); // First param must be "int"
#endif
 
#include "gdb.h"
 
#ifdef USB_ENDPOINT_ENABLED
#include "usb_functions.h"
#endif
 
#include "or_debug_proxy.h"
 
// Defines of endpoint numbers
#define ENDPOINT_TARGET_NONE 0
#define ENDPOINT_TARGET_USB 1
#define ENDPOINT_TARGET_OTHER 2
 
static int endpoint_target;     // Value to hold targeted endpoint
 
#define GDB_PROTOCOL_JTAG  1
#define GDB_PROTOCOL_RSP   2
#define GDB_PROTOCOL_NONE  3
 
int err;                        // Global error value
 
/* Currently selected scan chain - just to prevent unnecessary transfers. */
int current_chain = -1;
 
/* The chain that should be currently selected. */
int dbg_chain = -1;
 
/* By default, provide access to CPU */
int no_cpu = 0;
 
int main(int argc, char *argv[])
{
 
        char *s;
        int gdb_protocol = GDB_PROTOCOL_NONE;
        endpoint_target = ENDPOINT_TARGET_NONE;
        int inp_arg = 1;
 
 
        // Check we were compiled with at least one endpoint enabled
#ifndef USB_ENDPOINT_ENABLED
        printf
            ("No endpoints enabled.\nRecompile the proxy with at least one endpoint enabled\n");
        exit(0);
#endif
 
        // init our global error number
        err = DBG_ERR_OK;
 
        // Parse input options
        if (argc < 3) {
                print_usage();
                exit(1);
        }
 
        err = DBG_ERR_OK;
        srand(getpid());
 
        // Parse through the input, check what we've been given
 
        while (argv[inp_arg] != NULL) {
                if (strcmp(argv[inp_arg], "-r") == 0) {
                        gdb_protocol = GDB_PROTOCOL_RSP;
                        endpoint_target = ENDPOINT_TARGET_USB;
                } else if (strcmp(argv[inp_arg], "-o") == 0) {
                        gdb_protocol = GDB_PROTOCOL_RSP;
                        endpoint_target = ENDPOINT_TARGET_OTHER;
                } else if (strcmp(argv[inp_arg], "-k") == 0) {
                        kernel_debug = 1;
                } else if (strcmp(argv[inp_arg], "-b") == 0) {
                        no_cpu = 1;
                } else {
                        serverPort = strtol(argv[2], &s, 10);
                }
 
                inp_arg++;
        }
 
        if (endpoint_target == ENDPOINT_TARGET_NONE ||
            gdb_protocol == GDB_PROTOCOL_NONE ||
            serverPort > 65535 || *s != '\0') {
                print_usage();
                exit(1);
        }
#ifdef CYGWIN_COMPILE
        // Load the FTCJTAG DLL function pointers
        if (getFTDIJTAGFunctions() < 0) {
                exit(-1);
        }
#endif
 
#ifndef CYGWIN_COMPILE
        // Install a signal handler to exit gracefully
        // when we receive a sigint
        signal(SIGINT, catch_sigint);
#endif
 
        /* Initialise connection to our OR1k system */
        current_chain = -1;
#ifdef USB_ENDPOINT_ENABLED
        /* USB Endpoint */
        if (endpoint_target == ENDPOINT_TARGET_USB) {
                printf("\nConnecting to OR1k via USB debug cable\n\n");
                if ((err = usb_dbg_reset()))
                        goto JtagIfError;
                if (!no_cpu)
                        dbg_test();     // Perform some tests
        }
#endif
 
        /* We have a connection to the target system.  Now establish server
           connection. */
        if (gdb_protocol == GDB_PROTOCOL_RSP) { // Connect to RSP server
                /* RSP always starts stalled as though we have just reset the
                   processor. */
                // rsp_exception (EXCEPT_TRAP);
                handle_rsp();
        } else {
                fprintf(stderr, "Cannot start RSP Proxy server on port %d\n",
                        serverPort);
                exit(-1);
        }
 
JtagIfError:
        fprintf(stderr,
                "Connection via USB debug cable failed (err = %d).\nPlease ensure the device is attached and correctly installed\n\n",
                err);
        exit(-1);
        return 0;
}
 
int dbg_reset()
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_reset();
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
void dbg_test()
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                usb_dbg_test();
#endif
}
 
/* Set TAP instruction register */
int dbg_set_tap_ir(uint32_t ir)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                usb_set_tap_ir(ir);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* Sets scan chain.  */
int dbg_set_chain(uint32_t chain)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_set_chain(chain);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* sends out a command with 32bit address and 16bit length, if len >= 0 */
int dbg_command(uint32_t type, uint32_t adr, uint32_t len)
{
        // This is never called by any of the VPI functions, so only USB 
        // endpoint
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_command(type, adr, len);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* writes a ctrl reg */
int dbg_ctrl(uint32_t reset, uint32_t stall)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_ctrl(reset, stall);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* reads control register */
int dbg_ctrl_read(uint32_t * reset, uint32_t * stall)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_ctrl_read(reset, stall);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* issues a burst read/write */
int dbg_go(unsigned char *data, uint16_t len, uint32_t read)
{
        // Only USB endpouint32_t option here
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_go(data, len, read);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* read a byte from wishbone */
int dbg_wb_read8(uint32_t adr, uint8_t * data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_read8(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* read a word from wishbone */
int dbg_wb_read32(uint32_t adr, uint32_t * data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_read32(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* write a word to wishbone */
int dbg_wb_write8(uint32_t adr, uint8_t data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_write8(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* write a word to wishbone */
int dbg_wb_write32(uint32_t adr, uint32_t data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_write32(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* read a block from wishbone */
int dbg_wb_read_block32(uint32_t adr, uint32_t * data, uint32_t len)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_read_block32(adr, data, len);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* write a block to wishbone */
int dbg_wb_write_block32(uint32_t adr, uint32_t * data, uint32_t len)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_wb_write_block32(adr, data, len);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* read a register from cpu */
int dbg_cpu0_read(uint32_t adr, uint32_t * data, uint32_t length)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_cpu0_read(adr, data, length);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* write a cpu register */
int dbg_cpu0_write(uint32_t adr, uint32_t * data, uint32_t length)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_cpu0_write(adr, data, length);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* write a cpu module register */
int dbg_cpu0_write_ctrl(uint32_t adr, unsigned char data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_cpu0_write_ctrl(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
/* read a register from cpu module */
int dbg_cpu0_read_ctrl(uint32_t adr, unsigned char *data)
{
#ifdef USB_ENDPOINT_ENABLED
        if (endpoint_target == ENDPOINT_TARGET_USB)
                return usb_dbg_cpu0_read_ctrl(adr, data);
#endif
        return DBG_ERR_INVALID_ENDPOINT;
}
 
void test_sdram(void)
{
        return;
}
 
// Close down gracefully when we receive any kill signals
void catch_sigint(int sig_num)
{
        // Close down any potentially open sockets and USB handles
        if (server_fd)
                close(server_fd);
        gdb_close();
#ifdef USB_ENDPOINT_ENABLED
        usb_close_device_handle();
#endif
        printf
            ("\nInterrupt signal received. Closing down connections and exiting\n\n");
        exit(0);
}
 
void print_usage()
{
        printf("\n");
        printf("Usage: or_debug_proxy <SERVERTYPE> <PORT> <OPTIONS>\n");
        printf("OpenRISC GDB Proxy Server\n");
        printf("\n");
        printf("\tServer Type:\n");
#ifdef USB_ENDPOINT_ENABLED
        printf
            ("\t-r\tStart a server using RSP, connection to hadware target via\n\t\tUSB\n");
        printf
            ("\t-j\tStart a server using legacy OR remote JTAG protocol, to\n\t\thardware target via USB (DEPRECATED)\n");
        printf("\n");
#endif
        printf("\tPort:\n");
        printf("\t\tAny free port within the usable range of 0 - 65535\n");
        printf("\n");
        printf("\tOptions:\n");
        printf
            ("\t-k\tAccesses to 0xC0000000 map to 0x0. Useful for kernel debugging.\n");
        printf
            ("\t-b\tBus access only - do not attempt to talk to the CPU\n");
        printf("\n");
        printf("\tExample:\n");
#ifdef USB_ENDPOINT_ENABLED
        printf
            ("\t\tStart a GDB server on port 50001, using RSP, connecting to\n\t\thardware target via USB:\n\n");
        printf("\t\t./or_debug_proxy -r 50001\n");
        printf("\n");
#endif
        fflush(stdout);
}

Line No.	Rev	Author	Line
1	39	julius	`/$$HEADER/`
2			`/******************************************************************************/`
3			`/* */`
4			`/* H E A D E R I N F O R M A T I O N */`
5			`/* */`
6			`/******************************************************************************/`
7
8			`// Project Name : OpenRISC Debug Proxy`
9			`// File Name : or_debug_proxy.c`
10			`// Prepared By : jb`
11			`// Project Start : 2008-10-01`
12
13			`/$$COPYRIGHT NOTICE/`
14			`/******************************************************************************/`
15			`/* */`
16			`/* C O P Y R I G H T N O T I C E */`
17			`/* */`
18			`/******************************************************************************/`
19			`/*`
20			`This library is free software; you can redistribute it and/or`
21			`modify it under the terms of the GNU Lesser General Public`
22			`License as published by the Free Software Foundation;`
23			`version 2.1 of the License, a copy of which is available from`
24			`http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt.`
25
26			`This library is distributed in the hope that it will be useful,`
27			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
28			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
29			`Lesser General Public License for more details.`
30
31			`You should have received a copy of the GNU Lesser General Public`
32			`License along with this library; if not, write to the Free Software`
33			`Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA`
34			`*/`
35
36			`/$$DESCRIPTION/`
37			`/******************************************************************************/`
38			`/* */`
39			`/* D E S C R I P T I O N */`
40			`/* */`
41			`/******************************************************************************/`
42			`//`
43			`// The entry point for the OpenRISC debug proxy console application. Is`
44			`// compilable under both Linux/Unix systems and Cygwin Windows.`
45			`//`
46
47			`#include <assert.h>`
48			`#include <stdio.h>`
49			`#include <ctype.h>`
50			`#include <string.h>`
51			`#include <stdlib.h>`
52			`#include <unistd.h>`
53			`#include <stdarg.h>`
54			`#include <sys/stat.h>`
55			`#include <sys/types.h>`
56
57			`// Windows includes`
58			`#ifdef CYGWIN_COMPILE`
59			`#include <windows.h>`
60			`#include "win_FTCJTAG.h"`
61			`#include "win_FTCJTAG_ptrs.h"`
62			`#else`
63			`#include <signal.h>`
64	497	julius	`void catch_sigint(int sig_num); // First param must be "int"`
65	39	julius	`#endif`
66
67			`#include "gdb.h"`
68
69			`#ifdef USB_ENDPOINT_ENABLED`
70			`#include "usb_functions.h"`
71			`#endif`
72
73			`#include "or_debug_proxy.h"`
74
75			`// Defines of endpoint numbers`
76			`#define ENDPOINT_TARGET_NONE 0`
77			`#define ENDPOINT_TARGET_USB 1`
78	376	julius	`#define ENDPOINT_TARGET_OTHER 2`
79	39	julius
80	497	julius	`static int endpoint_target; // Value to hold targeted endpoint`
81	39	julius
82			`#define GDB_PROTOCOL_JTAG 1`
83			`#define GDB_PROTOCOL_RSP 2`
84			`#define GDB_PROTOCOL_NONE 3`
85
86	497	julius	`int err; // Global error value`
87	39	julius
88			`/* Currently selected scan chain - just to prevent unnecessary transfers. */`
89			`int current_chain = -1;`
90
91			`/* The chain that should be currently selected. */`
92			`int dbg_chain = -1;`
93
94	529	julius	`/* By default, provide access to CPU */`
95			`int no_cpu = 0;`
96
97	497	julius	`int main(int argc, char *argv[])`
98			`{`
99	39	julius
100	497	julius	`char *s;`
101			`int gdb_protocol = GDB_PROTOCOL_NONE;`
102			`endpoint_target = ENDPOINT_TARGET_NONE;`
103			`int inp_arg = 1;`
104	529	julius
105	39	julius
106	497	julius	`// Check we were compiled with at least one endpoint enabled`
107	39	julius	`#ifndef USB_ENDPOINT_ENABLED`
108	497	julius	`printf`
109			`("No endpoints enabled.\nRecompile the proxy with at least one endpoint enabled\n");`
110			`exit(0);`
111	39	julius	`#endif`
112
113	497	julius	`// init our global error number`
114			`err = DBG_ERR_OK;`
115	39	julius
116	497	julius	`// Parse input options`
117			`if (argc < 3) {`
118			`print_usage();`
119			`exit(1);`
120			`}`
121	39	julius
122	497	julius	`err = DBG_ERR_OK;`
123			`srand(getpid());`
124	39	julius
125	497	julius	`// Parse through the input, check what we've been given`
126	39	julius
127	497	julius	`while (argv[inp_arg] != NULL) {`
128			`if (strcmp(argv[inp_arg], "-r") == 0) {`
129			`gdb_protocol = GDB_PROTOCOL_RSP;`
130			`endpoint_target = ENDPOINT_TARGET_USB;`
131			`} else if (strcmp(argv[inp_arg], "-o") == 0) {`
132			`gdb_protocol = GDB_PROTOCOL_RSP;`
133			`endpoint_target = ENDPOINT_TARGET_OTHER;`
134			`} else if (strcmp(argv[inp_arg], "-k") == 0) {`
135			`kernel_debug = 1;`
136	529	julius	`} else if (strcmp(argv[inp_arg], "-b") == 0) {`
137			`no_cpu = 1;`
138	497	julius	`} else {`
139			`serverPort = strtol(argv[2], &s, 10);`
140			`}`
141
142			`inp_arg++;`
143	39	julius	`}`
144	497	julius
145			`if (endpoint_target == ENDPOINT_TARGET_NONE \|\|`
146			`gdb_protocol == GDB_PROTOCOL_NONE \|\|`
147			`serverPort > 65535 \|\| *s != '\0') {`
148			`print_usage();`
149			`exit(1);`
150	39	julius	`}`
151	497	julius	`#ifdef CYGWIN_COMPILE`
152			`// Load the FTCJTAG DLL function pointers`
153			`if (getFTDIJTAGFunctions() < 0) {`
154			`exit(-1);`
155	39	julius	`}`
156			`#endif`
157
158			`#ifndef CYGWIN_COMPILE`
159	497	julius	`// Install a signal handler to exit gracefully`
160			`// when we receive a sigint`
161			`signal(SIGINT, catch_sigint);`
162	39	julius	`#endif`
163	497	julius
164			`/* Initialise connection to our OR1k system */`
165			`current_chain = -1;`
166	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
167	497	julius	`/* USB Endpoint */`
168			`if (endpoint_target == ENDPOINT_TARGET_USB) {`
169			`printf("\nConnecting to OR1k via USB debug cable\n\n");`
170			`if ((err = usb_dbg_reset()))`
171			`goto JtagIfError;`
172	529	julius	`if (!no_cpu)`
173			`dbg_test(); // Perform some tests`
174	497	julius	`}`
175	39	julius	`#endif`
176
177	497	julius	`/* We have a connection to the target system. Now establish server`
178			`connection. */`
179			`if (gdb_protocol == GDB_PROTOCOL_RSP) { // Connect to RSP server`
180			`/* RSP always starts stalled as though we have just reset the`
181			`processor. */`
182			`// rsp_exception (EXCEPT_TRAP);`
183			`handle_rsp();`
184			`} else {`
185			`fprintf(stderr, "Cannot start RSP Proxy server on port %d\n",`
186			`serverPort);`
187			`exit(-1);`
188			`}`
189	39	julius
190			`JtagIfError:`
191	497	julius	`fprintf(stderr,`
192			`"Connection via USB debug cable failed (err = %d).\nPlease ensure the device is attached and correctly installed\n\n",`
193			`err);`
194			`exit(-1);`
195			`return 0;`
196	39	julius	`}`
197
198			`int dbg_reset()`
199			`{`
200			`#ifdef USB_ENDPOINT_ENABLED`
201	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
202			`return usb_dbg_reset();`
203	39	julius	`#endif`
204	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
205	39	julius	`}`
206
207	497	julius	`void dbg_test()`
208			`{`
209	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
210	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
211			`usb_dbg_test();`
212	39	julius	`#endif`
213			`}`
214
215			`/* Set TAP instruction register */`
216	497	julius	`int dbg_set_tap_ir(uint32_t ir)`
217			`{`
218	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
219	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
220			`usb_set_tap_ir(ir);`
221	39	julius	`#endif`
222	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
223	39	julius	`}`
224
225			`/* Sets scan chain. */`
226	497	julius	`int dbg_set_chain(uint32_t chain)`
227			`{`
228	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
229	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
230			`return usb_dbg_set_chain(chain);`
231	39	julius	`#endif`
232	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
233			`}`
234	39	julius
235			`/* sends out a command with 32bit address and 16bit length, if len >= 0 */`
236	497	julius	`int dbg_command(uint32_t type, uint32_t adr, uint32_t len)`
237			`{`
238			`// This is never called by any of the VPI functions, so only USB`
239			`// endpoint`
240	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
241	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
242			`return usb_dbg_command(type, adr, len);`
243	39	julius	`#endif`
244	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
245	39	julius	`}`
246
247			`/* writes a ctrl reg */`
248	497	julius	`int dbg_ctrl(uint32_t reset, uint32_t stall)`
249			`{`
250	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
251	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
252			`return usb_dbg_ctrl(reset, stall);`
253	39	julius	`#endif`
254	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
255	39	julius	`}`
256
257			`/* reads control register */`
258	497	julius	`int dbg_ctrl_read(uint32_t * reset, uint32_t * stall)`
259			`{`
260	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
261	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
262			`return usb_dbg_ctrl_read(reset, stall);`
263	39	julius	`#endif`
264	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
265	39	julius	`}`
266
267			`/* issues a burst read/write */`
268	497	julius	`int dbg_go(unsigned char *data, uint16_t len, uint32_t read)`
269			`{`
270			`// Only USB endpouint32_t option here`
271	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
272	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
273			`return usb_dbg_go(data, len, read);`
274	39	julius	`#endif`
275	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
276	39	julius	`}`
277
278	94	julius	`/* read a byte from wishbone */`
279	497	julius	`int dbg_wb_read8(uint32_t adr, uint8_t * data)`
280			`{`
281	94	julius	`#ifdef USB_ENDPOINT_ENABLED`
282	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
283			`return usb_dbg_wb_read8(adr, data);`
284	94	julius	`#endif`
285	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
286	94	julius	`}`
287
288	39	julius	`/* read a word from wishbone */`
289	497	julius	`int dbg_wb_read32(uint32_t adr, uint32_t * data)`
290			`{`
291	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
292	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
293			`return usb_dbg_wb_read32(adr, data);`
294	39	julius	`#endif`
295	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
296	39	julius	`}`
297
298	46	julius	`/* write a word to wishbone */`
299	497	julius	`int dbg_wb_write8(uint32_t adr, uint8_t data)`
300			`{`
301	46	julius	`#ifdef USB_ENDPOINT_ENABLED`
302	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
303			`return usb_dbg_wb_write8(adr, data);`
304	46	julius	`#endif`
305	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
306	46	julius	`}`
307	39	julius
308			`/* write a word to wishbone */`
309	497	julius	`int dbg_wb_write32(uint32_t adr, uint32_t data)`
310			`{`
311	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
312	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
313			`return usb_dbg_wb_write32(adr, data);`
314	39	julius	`#endif`
315	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
316	39	julius	`}`
317
318			`/* read a block from wishbone */`
319	497	julius	`int dbg_wb_read_block32(uint32_t adr, uint32_t * data, uint32_t len)`
320			`{`
321	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
322	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
323			`return usb_dbg_wb_read_block32(adr, data, len);`
324	39	julius	`#endif`
325	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
326	39	julius	`}`
327
328			`/* write a block to wishbone */`
329	497	julius	`int dbg_wb_write_block32(uint32_t adr, uint32_t * data, uint32_t len)`
330			`{`
331	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
332	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
333			`return usb_dbg_wb_write_block32(adr, data, len);`
334	39	julius	`#endif`
335	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
336	39	julius	`}`
337
338			`/* read a register from cpu */`
339	497	julius	`int dbg_cpu0_read(uint32_t adr, uint32_t * data, uint32_t length)`
340			`{`
341	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
342	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
343			`return usb_dbg_cpu0_read(adr, data, length);`
344	39	julius	`#endif`
345	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
346	39	julius	`}`
347
348			`/* write a cpu register */`
349	497	julius	`int dbg_cpu0_write(uint32_t adr, uint32_t * data, uint32_t length)`
350			`{`
351	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
352	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
353			`return usb_dbg_cpu0_write(adr, data, length);`
354	39	julius	`#endif`
355	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
356	39	julius	`}`
357
358			`/* write a cpu module register */`
359	497	julius	`int dbg_cpu0_write_ctrl(uint32_t adr, unsigned char data)`
360			`{`
361	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
362	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
363			`return usb_dbg_cpu0_write_ctrl(adr, data);`
364	39	julius	`#endif`
365	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
366	39	julius	`}`
367
368			`/* read a register from cpu module */`
369	497	julius	`int dbg_cpu0_read_ctrl(uint32_t adr, unsigned char *data)`
370			`{`
371	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
372	497	julius	`if (endpoint_target == ENDPOINT_TARGET_USB)`
373			`return usb_dbg_cpu0_read_ctrl(adr, data);`
374	39	julius	`#endif`
375	497	julius	`return DBG_ERR_INVALID_ENDPOINT;`
376	39	julius	`}`
377
378	497	julius	`void test_sdram(void)`
379			`{`
380	39	julius	`return;`
381			`}`
382
383			`// Close down gracefully when we receive any kill signals`
384			`void catch_sigint(int sig_num)`
385			`{`
386	497	julius	`// Close down any potentially open sockets and USB handles`
387			`if (server_fd)`
388			`close(server_fd);`
389			`gdb_close();`
390	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
391	497	julius	`usb_close_device_handle();`
392	39	julius	`#endif`
393	497	julius	`printf`
394			`("\nInterrupt signal received. Closing down connections and exiting\n\n");`
395			`exit(0);`
396	39	julius	`}`
397
398			`void print_usage()`
399			`{`
400	497	julius	`printf("\n");`
401			`printf("Usage: or_debug_proxy <SERVERTYPE> <PORT> <OPTIONS>\n");`
402			`printf("OpenRISC GDB Proxy Server\n");`
403			`printf("\n");`
404			`printf("\tServer Type:\n");`
405	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
406	497	julius	`printf`
407			`("\t-r\tStart a server using RSP, connection to hadware target via\n\t\tUSB\n");`
408			`printf`
409			`("\t-j\tStart a server using legacy OR remote JTAG protocol, to\n\t\thardware target via USB (DEPRECATED)\n");`
410			`printf("\n");`
411	39	julius	`#endif`
412	497	julius	`printf("\tPort:\n");`
413			`printf("\t\tAny free port within the usable range of 0 - 65535\n");`
414			`printf("\n");`
415			`printf("\tOptions:\n");`
416			`printf`
417			`("\t-k\tAccesses to 0xC0000000 map to 0x0. Useful for kernel debugging.\n");`
418	529	julius	`printf`
419			`("\t-b\tBus access only - do not attempt to talk to the CPU\n");`
420	497	julius	`printf("\n");`
421			`printf("\tExample:\n");`
422	39	julius	`#ifdef USB_ENDPOINT_ENABLED`
423	497	julius	`printf`
424			`("\t\tStart a GDB server on port 50001, using RSP, connecting to\n\t\thardware target via USB:\n\n");`
425			`printf("\t\t./or_debug_proxy -r 50001\n");`
426			`printf("\n");`
427	39	julius	`#endif`
428	497	julius	`fflush(stdout);`
429	39	julius	`}`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or_debug_proxy/] [src/] [or_debug_proxy.c] - Blame information for rev 608