X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fpresto.c;h=bd1cc5d441c80c3c61740436a7f53b29ac7d7c4f;hp=c8417c22f772feeb0a07a4e29703717540ef68da;hb=53d605e12c3765aeedabf2bfe0c5cc338dc95d5a;hpb=6e2acffa9ca85299b702699c311a1f3c91b310f7 diff --git a/src/jtag/presto.c b/src/jtag/presto.c index c8417c22f7..bd1cc5d441 100644 --- a/src/jtag/presto.c +++ b/src/jtag/presto.c @@ -23,26 +23,12 @@ #if IS_CYGWIN == 1 #include "windows.h" -#undef ERROR #endif -#include "replacements.h" - -/* project specific includes */ -#include "log.h" -#include "types.h" -#include "jtag.h" -#include "configuration.h" +#include "interface.h" #include "time_support.h" #include "bitq.h" -/* system includes */ -#include -#include -#include - -#include -#include /* PRESTO access library includes */ #if BUILD_PRESTO_FTD2XX == 1 @@ -53,31 +39,33 @@ #error "BUG: either FTD2XX and LIBFTDI has to be used" #endif - -int presto_jtag_speed(int speed); -int presto_jtag_register_commands(struct command_context_s *cmd_ctx); -int presto_jtag_init(void); -int presto_jtag_quit(void); +static int presto_jtag_speed(int speed); +static int presto_jtag_khz(int khz, int *jtag_speed); +static int presto_jtag_speed_div(int speed, int *khz); +static int presto_jtag_register_commands(struct command_context_s *cmd_ctx); +static int presto_jtag_init(void); +static int presto_jtag_quit(void); jtag_interface_t presto_interface = { .name = "presto", .execute_queue = bitq_execute_queue, .speed = presto_jtag_speed, + .khz = presto_jtag_khz, + .speed_div = presto_jtag_speed_div, .register_commands = presto_jtag_register_commands, .init = presto_jtag_init, .quit = presto_jtag_quit, }; +static int presto_bitq_out(int tms, int tdi, int tdo_req); +static int presto_bitq_flush(void); +static int presto_bitq_sleep(unsigned long us); +static int presto_bitq_reset(int trst, int srst); +static int presto_bitq_in_rdy(void); +static int presto_bitq_in(void); -int presto_bitq_out(int tms, int tdi, int tdo_req); -int presto_bitq_flush(void); -int presto_bitq_sleep(unsigned long us); -int presto_bitq_reset(int trst, int srst); -int presto_bitq_in_rdy(void); -int presto_bitq_in(void); - -bitq_interface_t presto_bitq = +static bitq_interface_t presto_bitq = { .out = presto_bitq_out, .flush = presto_bitq_flush, @@ -87,10 +75,8 @@ bitq_interface_t presto_bitq = .in = presto_bitq_in, }; - /* -------------------------------------------------------------------------- */ - #define FT_DEVICE_NAME_LEN 64 #define FT_DEVICE_SERNUM_LEN 64 @@ -109,13 +95,13 @@ typedef struct presto_s struct ftdi_context ftdic; int retval; #endif - + char serial[FT_DEVICE_SERNUM_LEN]; - u8 buff_out[BUFFER_SIZE]; + uint8_t buff_out[BUFFER_SIZE]; int buff_out_pos; - u8 buff_in[BUFFER_SIZE]; + uint8_t buff_in[BUFFER_SIZE]; int buff_in_exp; /* expected in buffer length */ int buff_in_len; /* length of data received */ int buff_in_pos; @@ -125,133 +111,136 @@ typedef struct presto_s int jtag_tms; /* last tms state */ int jtag_tck; /* last tck state */ + int jtag_rst; /* last trst state */ int jtag_tdi_data; int jtag_tdi_count; + int jtag_speed; + } presto_t; -presto_t presto_state; -presto_t *presto = &presto_state; +static presto_t presto_state; +static presto_t *presto = &presto_state; -u8 presto_init_seq[] = +static uint8_t presto_init_seq[] = { 0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0 }; -int presto_write(u8 *buf, int size, u32* bytes_written) +static int presto_write(uint8_t *buf, uint32_t size) { #if BUILD_PRESTO_FTD2XX == 1 - DWORD dw_bytes_written; - if ((presto->status = FT_Write(presto->handle, buf, size, &dw_bytes_written)) != FT_OK) + DWORD ftbytes; + if ((presto->status = FT_Write(presto->handle, buf, size, &ftbytes)) != FT_OK) { - *bytes_written = dw_bytes_written; - ERROR("FT_Write returned: %lu", presto->status); + LOG_ERROR("FT_Write returned: %lu", presto->status); return ERROR_JTAG_DEVICE_ERROR; } - else - { - *bytes_written = dw_bytes_written; - return ERROR_OK; - } + #elif BUILD_PRESTO_LIBFTDI == 1 + uint32_t ftbytes; if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0) { - *bytes_written = 0; - ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic)); + LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic)); return ERROR_JTAG_DEVICE_ERROR; } - else + ftbytes = presto->retval; +#endif + + if (ftbytes != size) { - *bytes_written = presto->retval; /* FIXME: Correct? */ - return ERROR_OK; + LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)", + (unsigned)ftbytes, (unsigned)size); + return ERROR_JTAG_DEVICE_ERROR; } -#endif + + return ERROR_OK; } -int presto_read(u8* buf, int size, u32* bytes_read) +static int presto_read(uint8_t* buf, uint32_t size) { #if BUILD_PRESTO_FTD2XX == 1 - DWORD dw_bytes_read; - int timeout = 5; - *bytes_read = 0; - - while ((*bytes_read < size) && timeout--) + DWORD ftbytes; + if ((presto->status = FT_Read(presto->handle, buf, size, &ftbytes)) != FT_OK) { - if ((presto->status = FT_Read(presto->handle, buf + *bytes_read, size - - *bytes_read, &dw_bytes_read)) != FT_OK) - { - *bytes_read = 0; - ERROR("FT_Read returned: %lu", presto->status); - return ERROR_JTAG_DEVICE_ERROR; - } - *bytes_read += dw_bytes_read; + LOG_ERROR("FT_Read returned: %lu", presto->status); + return ERROR_JTAG_DEVICE_ERROR; } + #elif BUILD_PRESTO_LIBFTDI == 1 - int timeout = 100; - *bytes_read = 0; - - while ((*bytes_read < size) && timeout--) + uint32_t ftbytes = 0; + + struct timeval timeout, now; + gettimeofday(&timeout, NULL); + timeval_add_time(&timeout, 1, 0); /* one second timeout */ + + while (ftbytes < size) { - if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + *bytes_read, size - *bytes_read)) < 0) + if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + ftbytes, size - ftbytes)) < 0) { - *bytes_read = 0; - ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic)); + LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic)); return ERROR_JTAG_DEVICE_ERROR; } - *bytes_read += presto->retval; /* FIXME: Correct? */ + ftbytes += presto->retval; + + gettimeofday(&now, NULL); + if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec))) + break; } #endif - if (*bytes_read < size) + if (ftbytes != size) { - ERROR("couldn't read the requested number of bytes from PRESTO (%i < %i)", *bytes_read, size); + /* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */ + LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)", + (unsigned)ftbytes, (unsigned)size); return ERROR_JTAG_DEVICE_ERROR; } - + return ERROR_OK; } #if BUILD_PRESTO_FTD2XX == 1 -int presto_open_ftd2xx(char *req_serial) +static int presto_open_ftd2xx(char *req_serial) { - int i; + uint32_t i; DWORD numdevs; DWORD vidpid; char devname[FT_DEVICE_NAME_LEN]; FT_DEVICE device; BYTE presto_data; - unsigned long ftbytes; + DWORD ftbytes; presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE; - + #if IS_WIN32 == 0 /* Add non-standard Vid/Pid to the linux driver */ if ((presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID)) != FT_OK) { - ERROR("couldn't add PRESTO VID/PID"); + LOG_ERROR("couldn't add PRESTO VID/PID"); exit(-1); } #endif if ((presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY)) != FT_OK) { - ERROR("FT_ListDevices failed: %i", (int)presto->status); + LOG_ERROR("FT_ListDevices failed: %i", (int)presto->status); return ERROR_JTAG_DEVICE_ERROR; } - - DEBUG("FTDI devices available: %i", numdevs); + + LOG_DEBUG("FTDI devices available: %lu", numdevs); for (i = 0; i < numdevs; i++) { if ((presto->status = FT_Open(i, &(presto->handle))) != FT_OK) { /* this is not fatal, the device may be legitimately open by other process, hence debug message only */ - DEBUG("FT_Open failed: %i", (int)presto->status); + LOG_DEBUG("FT_Open failed: %i", (int)presto->status); continue; } - DEBUG("FTDI device %i open", i); - + LOG_DEBUG("FTDI device %i open", i); + if ((presto->status = FT_GetDeviceInfo(presto->handle, &device, &vidpid, presto->serial, devname, NULL)) == FT_OK) { @@ -260,9 +249,9 @@ int presto_open_ftd2xx(char *req_serial) break; } else - DEBUG("FT_GetDeviceInfo failed: %i", presto->status); - - DEBUG("FTDI device %i does not match, closing", i); + LOG_DEBUG("FT_GetDeviceInfo failed: %lu", presto->status); + + LOG_DEBUG("FTDI device %i does not match, closing", i); FT_Close(presto->handle); presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE; } @@ -272,28 +261,28 @@ int presto_open_ftd2xx(char *req_serial) if ((presto->status = FT_SetLatencyTimer(presto->handle, 1)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - - + + if ((presto->status = FT_SetTimeouts(presto->handle, 100, 0)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + presto_data = 0xD0; if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason, probably a bug in library threading */ usleep(100000); if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - - if (ftbytes!=1) + + if (ftbytes != 1) { - DEBUG("PRESTO reset"); - + LOG_DEBUG("PRESTO reset"); + if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; if ((presto->status = FT_SetBitMode(presto->handle, 0x80, 1)) != FT_OK) @@ -310,31 +299,31 @@ int presto_open_ftd2xx(char *req_serial) if ((presto->status = FT_SetBitMode(presto->handle, 0x00, 0)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + presto_data = 0xD0; if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - + /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason, probably a bug in library threading */ usleep(100000); if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - - if (ftbytes!=1) + + if (ftbytes != 1) { - DEBUG("PRESTO not responding"); + LOG_DEBUG("PRESTO not responding"); return ERROR_JTAG_DEVICE_ERROR; - } + } } - + if ((presto->status = FT_SetTimeouts(presto->handle, 0, 0)) != FT_OK) return ERROR_JTAG_DEVICE_ERROR; - - + + presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes); if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq)) return ERROR_JTAG_DEVICE_ERROR; @@ -343,49 +332,80 @@ int presto_open_ftd2xx(char *req_serial) } #elif BUILD_PRESTO_LIBFTDI == 1 -int presto_open_libftdi(char *req_serial) +static int presto_open_libftdi(char *req_serial) { - u8 presto_data; - u32 ftbytes; - - DEBUG("searching for presto JTAG interface using libftdi"); + uint8_t presto_data; + + LOG_DEBUG("searching for PRESTO using libftdi"); + + /* initialize FTDI context structure */ + if (ftdi_init(&presto->ftdic) < 0) + { + LOG_ERROR("unable to init libftdi: %s", presto->ftdic.error_str); + return ERROR_JTAG_DEVICE_ERROR; + } /* context, vendor id, product id */ if (ftdi_usb_open_desc(&presto->ftdic, PRESTO_VID, PRESTO_PID, NULL, req_serial) < 0) { - ERROR("unable to open presto: %s", presto->ftdic.error_str); + LOG_ERROR("unable to open PRESTO: %s", presto->ftdic.error_str); return ERROR_JTAG_DEVICE_ERROR; } - + if (ftdi_usb_reset(&presto->ftdic) < 0) { - ERROR("unable to reset presto device"); + LOG_ERROR("unable to reset PRESTO device"); return ERROR_JTAG_DEVICE_ERROR; } if (ftdi_set_latency_timer(&presto->ftdic, 1) < 0) { - ERROR("unable to set latency timer"); + LOG_ERROR("unable to set latency timer"); return ERROR_JTAG_DEVICE_ERROR; } if (ftdi_usb_purge_buffers(&presto->ftdic) < 0) { - ERROR("unable to purge presto buffer"); + LOG_ERROR("unable to purge PRESTO buffers"); return ERROR_JTAG_DEVICE_ERROR; } - + presto_data = 0xD0; - if ((presto->retval = presto_write(&presto_data, 1, &ftbytes)) != ERROR_OK) + if (presto_write(&presto_data, 1) != ERROR_OK) + { + LOG_ERROR("error writing to PRESTO"); return ERROR_JTAG_DEVICE_ERROR; - if ((presto->retval = presto_read(&presto_data, 1, &ftbytes)) != ERROR_OK) + } + + if (presto_read(&presto_data, 1) != ERROR_OK) + { + LOG_DEBUG("no response from PRESTO, retrying"); + + if (ftdi_usb_purge_buffers(&presto->ftdic) < 0) + return ERROR_JTAG_DEVICE_ERROR; + + presto_data = 0xD0; + if (presto_write(&presto_data, 1) != ERROR_OK) + return ERROR_JTAG_DEVICE_ERROR; + + if (presto_read(&presto_data, 1) != ERROR_OK) + { + LOG_ERROR("no response from PRESTO, giving up"); + return ERROR_JTAG_DEVICE_ERROR; + } + } + + if (presto_write(presto_init_seq, sizeof(presto_init_seq)) != ERROR_OK) + { + LOG_ERROR("error writing PRESTO init sequence"); return ERROR_JTAG_DEVICE_ERROR; - + } + return ERROR_OK; } #endif /* BUILD_PRESTO_LIBFTDI == 1 */ -int presto_open(char *req_serial) +static int presto_open(char *req_serial) { presto->buff_out_pos=0; presto->buff_in_pos=0; @@ -397,9 +417,12 @@ int presto_open(char *req_serial) presto->jtag_tms=0; presto->jtag_tck=0; + presto->jtag_rst=0; presto->jtag_tdi_data=0; presto->jtag_tdi_count=0; + presto->jtag_speed=0; + #if BUILD_PRESTO_FTD2XX == 1 return presto_open_ftd2xx(req_serial); #elif BUILD_PRESTO_LIBFTDI == 1 @@ -407,7 +430,7 @@ int presto_open(char *req_serial) #endif } -int presto_close(void) +static int presto_close(void) { int result = ERROR_OK; @@ -433,56 +456,46 @@ int presto_close(void) result = ERROR_JTAG_DEVICE_ERROR; else presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE; - + #elif BUILD_PRESTO_LIBFTDI == 1 - - if ((presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq))) < 0) - { + + if ((presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq))) != sizeof(presto_init_seq)) result = ERROR_JTAG_DEVICE_ERROR; - } - + if ((presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16)) < 0) - { result = ERROR_JTAG_DEVICE_ERROR; - } - - ftdi_deinit(&presto->ftdic); + if ((presto->retval = ftdi_usb_close(&presto->ftdic)) < 0) + result = ERROR_JTAG_DEVICE_ERROR; + else + ftdi_deinit(&presto->ftdic); #endif return result; } - -int presto_flush(void) +static int presto_flush(void) { - u32 ftbytes; - if (presto->buff_out_pos == 0) return ERROR_OK; #if BUILD_PRESTO_FTD2XX == 1 if (presto->status != FT_OK) #elif BUILD_PRESTO_LIBFTDI == 1 - if (presto->retval != ERROR_OK) + if (presto->retval < 0) #endif - return ERROR_JTAG_DEVICE_ERROR; - - - if (presto_write(presto->buff_out, presto->buff_out_pos, &ftbytes) != ERROR_OK) { - presto->buff_out_pos = 0; + LOG_DEBUG("error in previous communication, canceling I/O operation"); return ERROR_JTAG_DEVICE_ERROR; } - presto->total_out += ftbytes; - - if (presto->buff_out_pos != ftbytes) + if (presto_write(presto->buff_out, presto->buff_out_pos) != ERROR_OK) { presto->buff_out_pos = 0; return ERROR_JTAG_DEVICE_ERROR; } + presto->total_out += presto->buff_out_pos; presto->buff_out_pos = 0; if (presto->buff_in_exp == 0) @@ -491,55 +504,52 @@ int presto_flush(void) presto->buff_in_pos = 0; presto->buff_in_len = 0; - if (presto_read(presto->buff_in, presto->buff_in_exp, &ftbytes) != ERROR_OK) - { - presto->buff_in_exp = 0; - return ERROR_JTAG_DEVICE_ERROR; - } - - presto->total_in += ftbytes; - - if (ftbytes != presto->buff_in_exp) + if (presto_read(presto->buff_in, presto->buff_in_exp) != ERROR_OK) { presto->buff_in_exp = 0; return ERROR_JTAG_DEVICE_ERROR; } + presto->total_in += presto->buff_in_exp; presto->buff_in_len = presto->buff_in_exp; presto->buff_in_exp = 0; return ERROR_OK; } - -int presto_sendbyte(int data) +static int presto_sendbyte(int data) { if (data == EOF) return presto_flush(); if (presto->buff_out_pos < BUFFER_SIZE) { - presto->buff_out[presto->buff_out_pos++] = (u8)data; + presto->buff_out[presto->buff_out_pos++] = (uint8_t)data; if (((data & 0xC0) == 0x40) || ((data & 0xD0)== 0xD0)) presto->buff_in_exp++; } else return ERROR_JTAG_DEVICE_ERROR; +#if BUILD_PRESTO_FTD2XX == 1 if (presto->buff_out_pos >= BUFFER_SIZE) +#elif BUILD_PRESTO_LIBFTDI == 1 + /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 bytes only!) */ + if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp==128) +#endif return presto_flush(); - + return ERROR_OK; } - -int presto_getbyte(void) +#if 0 +static int presto_getbyte(void) { if (presto->buff_in_pos < presto->buff_in_len) return presto->buff_in[presto->buff_in_pos++]; if (presto->buff_in_exp == 0) return -1; - + if (presto_flush() != ERROR_OK) return -1; @@ -548,96 +558,106 @@ int presto_getbyte(void) return -1; } - +#endif /* -------------------------------------------------------------------------- */ - -int presto_bitq_out(int tms, int tdi, int tdo_req) +static int presto_tdi_flush(void) { - unsigned char cmdparam; + if (presto->jtag_tdi_count == 0) + return 0; if (presto->jtag_tck == 0) { - presto_sendbyte(0xA4); - presto->jtag_tck = 1; + LOG_ERROR("BUG: unexpected TAP condition, TCK low"); + return -1; } - else if (!tdo_req && tms == presto->jtag_tms) + presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4; + presto_sendbyte(presto->jtag_tdi_data); + presto->jtag_tdi_count = 0; + presto->jtag_tdi_data = 0; + + return 0; +} + +static int presto_tck_idle(void) +{ + if (presto->jtag_tck == 1) { - if (presto->jtag_tdi_count == 0) - presto->jtag_tdi_data = (tdi != 0); - else - presto->jtag_tdi_data |= (tdi != 0) << presto->jtag_tdi_count; - - if (++presto->jtag_tdi_count == 4) - { - presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4; - presto_sendbyte(presto->jtag_tdi_data); - presto->jtag_tdi_count = 0; - } - return 0; + presto_sendbyte(0xCA); + presto->jtag_tck = 0; } - if (presto->jtag_tdi_count) + return 0; +} + +/* -------------------------------------------------------------------------- */ + +static int presto_bitq_out(int tms, int tdi, int tdo_req) +{ + int i; + unsigned char cmd; + + if (presto->jtag_tck == 0) { - presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4; - presto_sendbyte(presto->jtag_tdi_data); - presto->jtag_tdi_count = 0; + presto_sendbyte(0xA4); /* LED idicator - JTAG active */ } + else if (presto->jtag_speed == 0 && !tdo_req && tms == presto->jtag_tms) + { + presto->jtag_tdi_data |= (tdi != 0) << presto->jtag_tdi_count; - if (tdi) - cmdparam = 0x0B; - else - cmdparam = 0x0A; + if (++presto->jtag_tdi_count == 4) + presto_tdi_flush(); - presto_sendbyte( 0xC0 | cmdparam); + return 0; + } + + presto_tdi_flush(); + + cmd = tdi ? 0xCB : 0xCA; + presto_sendbyte(cmd); if (tms != presto->jtag_tms) { - if (tms) - presto_sendbyte(0xEC); - else - presto_sendbyte(0xE8); + presto_sendbyte((tms ? 0xEC : 0xE8) | (presto->jtag_rst ? 0x02 : 0)); presto->jtag_tms = tms; } - if (tdo_req) - presto_sendbyte(0xD4 | cmdparam); - else - presto_sendbyte(0xC4|cmdparam); + /* delay with TCK low */ + for (i=presto->jtag_speed; i>1; i--) + presto_sendbyte(cmd); + + cmd |= 0x04; + presto_sendbyte(cmd | (tdo_req ? 0x10 : 0)); + + /* delay with TCK high */ + for (i=presto->jtag_speed; i>1; i--) + presto_sendbyte(cmd); + + presto->jtag_tck = 1; return 0; } - -int presto_bitq_flush(void) +static int presto_bitq_flush(void) { - if (presto->jtag_tdi_count) - { - presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4; - presto_sendbyte(presto->jtag_tdi_data); - presto->jtag_tdi_count = 0; - } + presto_tdi_flush(); + presto_tck_idle(); - presto_sendbyte(0xCA); - presto->jtag_tck = 0; - - presto_sendbyte(0xA0); + presto_sendbyte(0xA0); /* LED idicator - JTAG idle */ return presto_flush(); } - -int presto_bitq_in_rdy(void) +static int presto_bitq_in_rdy(void) { if (presto->buff_in_pos>=presto->buff_in_len) return 0; return presto->buff_in_len-presto->buff_in_pos; } - -int presto_bitq_in(void) +static int presto_bitq_in(void) { if (presto->buff_in_pos>=presto->buff_in_len) return -1; @@ -645,11 +665,13 @@ int presto_bitq_in(void) return 0; } - -int presto_bitq_sleep(unsigned long us) +static int presto_bitq_sleep(unsigned long us) { long waits; + presto_tdi_flush(); + presto_tck_idle(); + if (us > 100000) { presto_bitq_flush(); @@ -664,51 +686,73 @@ int presto_bitq_sleep(unsigned long us) return 0; } - -int presto_bitq_reset(int trst, int srst) +static int presto_bitq_reset(int trst, int srst) { - unsigned char cmd; + presto_tdi_flush(); + presto_tck_idle(); - cmd = 0xE8; - if (presto->jtag_tms) - cmd |= 0x04; + /* add a delay after possible TCK transition */ + presto_sendbyte(0x80); + presto_sendbyte(0x80); - if (trst || srst) - cmd |= 0x02; + presto->jtag_rst = trst || srst; + presto_sendbyte((presto->jtag_rst ? 0xEA : 0xE8) | (presto->jtag_tms ? 0x04 : 0)); - presto_sendbyte(cmd); return 0; } - /* -------------------------------------------------------------------------- */ -char *presto_speed_text[4] = +static int presto_jtag_khz(int khz, int *jtag_speed) { - "3 MHz", - "1.5 MHz", - "750 kHz", - "93.75 kHz" -}; + if (khz < 0) + { + *jtag_speed=0; + return ERROR_INVALID_ARGUMENTS; + } -int presto_jtag_speed(int speed) -{ + if (khz >= 3000) *jtag_speed = 0; + else *jtag_speed = (1000+khz-1)/khz; - if ((speed < 0) || (speed > 3)) + return 0; +} + +static int presto_jtag_speed_div(int speed, int *khz) +{ + if ((speed < 0) || (speed > 1000)) { - INFO("valid speed values: 0 (3 MHz), 1 (1.5 MHz), 2 (750 kHz) and 3 (93.75 kHz)"); + *khz=0; return ERROR_INVALID_ARGUMENTS; } - jtag_speed = speed; - INFO("setting speed to %d, max. TCK freq. is %s", speed, presto_speed_text[speed]); - return presto_sendbyte(0xA8 | speed); + if (speed == 0) *khz = 3000; + else *khz = 1000/speed; + + return 0; } +static int presto_jtag_speed(int speed) +{ + int khz; + + if (presto_jtag_speed_div(speed, &khz)) + { + return ERROR_INVALID_ARGUMENTS; + } + + presto->jtag_speed = speed; + + if (khz%1000 == 0) + LOG_INFO("setting speed to %d, max. TCK freq. is %d MHz", speed, khz/1000); + else + LOG_INFO("setting speed to %d, max. TCK freq. is %d kHz", speed, khz); + + return 0; +} -char *presto_serial; +static char *presto_serial; -int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc == 1) { @@ -718,47 +762,44 @@ int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, c } else { - ERROR("expected exactly one argument to presto_serial "); + LOG_ERROR("expected exactly one argument to presto_serial "); } return ERROR_OK; } - -int presto_jtag_register_commands(struct command_context_s *cmd_ctx) +static int presto_jtag_register_commands(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "presto_serial", presto_handle_serial_command, COMMAND_CONFIG, NULL); return ERROR_OK; } - -int presto_jtag_init(void) +static int presto_jtag_init(void) { if (presto_open(presto_serial) != ERROR_OK) { presto_close(); if (presto_serial != NULL) - ERROR("Cannot open PRESTO, serial number '%s'", presto_serial); + LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial); else - ERROR("Cannot open PRESTO"); + LOG_ERROR("Cannot open PRESTO"); return ERROR_JTAG_INIT_FAILED; } - INFO("PRESTO open, serial number '%s'", presto->serial); - + LOG_INFO("PRESTO open, serial number '%s'", presto->serial); + /* use JTAG speed setting from configuration file */ - presto_jtag_speed(jtag_speed); - + presto_jtag_speed(jtag_get_speed()); + bitq_interface = &presto_bitq; return ERROR_OK; } - -int presto_jtag_quit(void) +static int presto_jtag_quit(void) { bitq_cleanup(); presto_close(); - INFO("PRESTO closed"); + LOG_INFO("PRESTO closed"); if (presto_serial) {