git.sur5r.net Git - openocd/blob - src/jtag/presto.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Pavel Chromy                                    *
   3  *   chromy@asix.cz                                                        *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #if IS_CYGWIN == 1
  25 #include "windows.h"
  26 #endif
  27
  28 #include "interface.h"
  29 #include "time_support.h"
  30 #include "bitq.h"
  31
  32
  33 /* PRESTO access library includes */
  34 #if BUILD_PRESTO_FTD2XX == 1
  35 #include <ftd2xx.h>
  36 #elif BUILD_PRESTO_LIBFTDI == 1
  37 #include <ftdi.h>
  38 #else
  39 #error "BUG: either FTD2XX and LIBFTDI has to be used"
  40 #endif
  41
  42 static int presto_jtag_speed(int speed);
  43 static int presto_jtag_khz(int khz, int *jtag_speed);
  44 static int presto_jtag_speed_div(int speed, int *khz);
  45 static int presto_jtag_register_commands(struct command_context_s *cmd_ctx);
  46 static int presto_jtag_init(void);
  47 static int presto_jtag_quit(void);
  48
  49 jtag_interface_t presto_interface =
  50 {
  51         .name = "presto",
  52         .execute_queue = bitq_execute_queue,
  53         .speed = presto_jtag_speed,
  54         .khz = presto_jtag_khz,
  55         .speed_div = presto_jtag_speed_div,
  56         .register_commands = presto_jtag_register_commands,
  57         .init = presto_jtag_init,
  58         .quit = presto_jtag_quit,
  59 };
  60
  61 static int presto_bitq_out(int tms, int tdi, int tdo_req);
  62 static int presto_bitq_flush(void);
  63 static int presto_bitq_sleep(unsigned long us);
  64 static int presto_bitq_reset(int trst, int srst);
  65 static int presto_bitq_in_rdy(void);
  66 static int presto_bitq_in(void);
  67
  68 static bitq_interface_t presto_bitq =
  69 {
  70         .out = presto_bitq_out,
  71         .flush = presto_bitq_flush,
  72         .sleep = presto_bitq_sleep,
  73         .reset = presto_bitq_reset,
  74         .in_rdy = presto_bitq_in_rdy,
  75         .in = presto_bitq_in,
  76 };
  77
  78 /* -------------------------------------------------------------------------- */
  79
  80 #define FT_DEVICE_NAME_LEN 64
  81 #define FT_DEVICE_SERNUM_LEN 64
  82
  83 #define PRESTO_VID_PID 0x0403f1a0
  84 #define PRESTO_VID (0x0403)
  85 #define PRESTO_PID (0xf1a0)
  86
  87 #define BUFFER_SIZE (64*62)
  88
  89 typedef struct presto_s
  90 {
  91 #if BUILD_PRESTO_FTD2XX == 1
  92         FT_HANDLE handle;
  93         FT_STATUS status;
  94 #elif BUILD_PRESTO_LIBFTDI == 1
  95         struct ftdi_context ftdic;
  96         int retval;
  97 #endif
  98
  99         char serial[FT_DEVICE_SERNUM_LEN];
 100
 101         uint8_t buff_out[BUFFER_SIZE];
 102         int buff_out_pos;
 103
 104         uint8_t buff_in[BUFFER_SIZE];
 105         int buff_in_exp; /* expected in buffer length */
 106         int buff_in_len; /* length of data received */
 107         int buff_in_pos;
 108
 109         unsigned long total_out;
 110         unsigned long total_in;
 111
 112         int jtag_tms; /* last tms state */
 113         int jtag_tck; /* last tck state */
 114         int jtag_rst; /* last trst state */
 115
 116         int jtag_tdi_data;
 117         int jtag_tdi_count;
 118
 119         int jtag_speed;
 120
 121 } presto_t;
 122
 123 static presto_t presto_state;
 124 static presto_t *presto = &presto_state;
 125
 126 static uint8_t presto_init_seq[] =
 127 {
 128         0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
 129 };
 130
 131 static int presto_write(uint8_t *buf, uint32_t size)
 132 {
 133 #if BUILD_PRESTO_FTD2XX == 1
 134         DWORD ftbytes;
 135         if ((presto->status = FT_Write(presto->handle, buf, size, &ftbytes)) != FT_OK)
 136         {
 137                 LOG_ERROR("FT_Write returned: %lu", presto->status);
 138                 return ERROR_JTAG_DEVICE_ERROR;
 139         }
 140
 141 #elif BUILD_PRESTO_LIBFTDI == 1
 142         uint32_t ftbytes;
 143         if ((presto->retval = ftdi_write_data(&presto->ftdic, buf, size)) < 0)
 144         {
 145                 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto->ftdic));
 146                 return ERROR_JTAG_DEVICE_ERROR;
 147         }
 148         ftbytes = presto->retval;
 149 #endif
 150
 151         if (ftbytes != size)
 152         {
 153                 LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)",
 154                           (unsigned)ftbytes, (unsigned)size);
 155                 return ERROR_JTAG_DEVICE_ERROR;
 156         }
 157
 158         return ERROR_OK;
 159 }
 160
 161 static int presto_read(uint8_t* buf, uint32_t size)
 162 {
 163 #if BUILD_PRESTO_FTD2XX == 1
 164         DWORD ftbytes;
 165         if ((presto->status = FT_Read(presto->handle, buf, size, &ftbytes)) != FT_OK)
 166         {
 167                 LOG_ERROR("FT_Read returned: %lu", presto->status);
 168                 return ERROR_JTAG_DEVICE_ERROR;
 169         }
 170
 171 #elif BUILD_PRESTO_LIBFTDI == 1
 172         uint32_t ftbytes = 0;
 173
 174         struct timeval timeout, now;
 175         gettimeofday(&timeout, NULL);
 176         timeval_add_time(&timeout, 1, 0); /* one second timeout */
 177
 178         while (ftbytes < size)
 179         {
 180                 if ((presto->retval = ftdi_read_data(&presto->ftdic, buf + ftbytes, size - ftbytes)) < 0)
 181                 {
 182                         LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto->ftdic));
 183                         return ERROR_JTAG_DEVICE_ERROR;
 184                 }
 185                 ftbytes += presto->retval;
 186
 187                 gettimeofday(&now, NULL);
 188                 if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec)))
 189                         break;
 190         }
 191 #endif
 192
 193         if (ftbytes != size)
 194         {
 195                 /* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
 196                 LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)",
 197                             (unsigned)ftbytes, (unsigned)size);
 198                 return ERROR_JTAG_DEVICE_ERROR;
 199         }
 200
 201         return ERROR_OK;
 202 }
 203
 204 #if BUILD_PRESTO_FTD2XX == 1
 205 static int presto_open_ftd2xx(char *req_serial)
 206 {
 207         uint32_t i;
 208         DWORD numdevs;
 209         DWORD vidpid;
 210         char devname[FT_DEVICE_NAME_LEN];
 211         FT_DEVICE device;
 212
 213         BYTE presto_data;
 214         DWORD ftbytes;
 215
 216         presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
 217
 218 #if IS_WIN32 == 0
 219         /* Add non-standard Vid/Pid to the linux driver */
 220         if ((presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID)) != FT_OK)
 221         {
 222                 LOG_ERROR("couldn't add PRESTO VID/PID");
 223                 exit(-1);
 224         }
 225 #endif
 226
 227         if ((presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY)) != FT_OK)
 228         {
 229                 LOG_ERROR("FT_ListDevices failed: %i", (int)presto->status);
 230                 return ERROR_JTAG_DEVICE_ERROR;
 231         }
 232
 233         LOG_DEBUG("FTDI devices available: %lu", numdevs);
 234         for (i = 0; i < numdevs; i++)
 235         {
 236                 if ((presto->status = FT_Open(i, &(presto->handle))) != FT_OK)
 237                 {
 238                         /* this is not fatal, the device may be legitimately open by other process, hence debug message only */
 239                         LOG_DEBUG("FT_Open failed: %i", (int)presto->status);
 240                         continue;
 241                 }
 242                 LOG_DEBUG("FTDI device %i open", i);
 243
 244                 if ((presto->status = FT_GetDeviceInfo(presto->handle, &device, &vidpid,
 245                                 presto->serial, devname, NULL)) == FT_OK)
 246                 {
 247                         if (vidpid == PRESTO_VID_PID
 248                                         && (req_serial == NULL || !strcmp(presto->serial, req_serial)))
 249                                 break;
 250                 }
 251                 else
 252                         LOG_DEBUG("FT_GetDeviceInfo failed: %lu", presto->status);
 253
 254                 LOG_DEBUG("FTDI device %i does not match, closing", i);
 255                 FT_Close(presto->handle);
 256                 presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
 257         }
 258
 259         if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
 260                 return ERROR_JTAG_DEVICE_ERROR; /* presto not open, return */
 261
 262         if ((presto->status = FT_SetLatencyTimer(presto->handle, 1)) != FT_OK)
 263                 return ERROR_JTAG_DEVICE_ERROR;
 264
 265
 266         if ((presto->status = FT_SetTimeouts(presto->handle, 100, 0)) != FT_OK)
 267                 return ERROR_JTAG_DEVICE_ERROR;
 268
 269         if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
 270                 return ERROR_JTAG_DEVICE_ERROR;
 271
 272         presto_data = 0xD0;
 273         if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
 274                 return ERROR_JTAG_DEVICE_ERROR;
 275
 276         /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
 277            probably a bug in library threading */
 278         usleep(100000);
 279         if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
 280                 return ERROR_JTAG_DEVICE_ERROR;
 281
 282         if (ftbytes != 1)
 283         {
 284                 LOG_DEBUG("PRESTO reset");
 285
 286                 if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
 287                         return ERROR_JTAG_DEVICE_ERROR;
 288                 if ((presto->status = FT_SetBitMode(presto->handle, 0x80, 1)) != FT_OK)
 289                         return ERROR_JTAG_DEVICE_ERROR;
 290                 if ((presto->status = FT_SetBaudRate(presto->handle, 9600)) != FT_OK)
 291                         return ERROR_JTAG_DEVICE_ERROR;
 292
 293                 presto_data = 0;
 294                 for (i = 0; i < 4 * 62; i++)
 295                         if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
 296                                 return ERROR_JTAG_DEVICE_ERROR;
 297
 298                 usleep(100000);
 299
 300                 if ((presto->status = FT_SetBitMode(presto->handle, 0x00, 0)) != FT_OK)
 301                         return ERROR_JTAG_DEVICE_ERROR;
 302
 303                 if ((presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX)) != FT_OK)
 304                         return ERROR_JTAG_DEVICE_ERROR;
 305
 306                 presto_data = 0xD0;
 307                 if ((presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
 308                         return ERROR_JTAG_DEVICE_ERROR;
 309
 310                 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
 311                    probably a bug in library threading */
 312                 usleep(100000);
 313                 if ((presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes)) != FT_OK)
 314                         return ERROR_JTAG_DEVICE_ERROR;
 315
 316                 if (ftbytes != 1)
 317                 {
 318                         LOG_DEBUG("PRESTO not responding");
 319                         return ERROR_JTAG_DEVICE_ERROR;
 320                 }
 321         }
 322
 323         if ((presto->status = FT_SetTimeouts(presto->handle, 0, 0)) != FT_OK)
 324                 return ERROR_JTAG_DEVICE_ERROR;
 325
 326
 327         presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
 328         if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
 329                 return ERROR_JTAG_DEVICE_ERROR;
 330
 331         return ERROR_OK;
 332 }
 333
 334 #elif BUILD_PRESTO_LIBFTDI == 1
 335 static int presto_open_libftdi(char *req_serial)
 336 {
 337         uint8_t presto_data;
 338
 339         LOG_DEBUG("searching for PRESTO using libftdi");
 340
 341         /* initialize FTDI context structure */
 342         if (ftdi_init(&presto->ftdic) < 0)
 343         {
 344                 LOG_ERROR("unable to init libftdi: %s", presto->ftdic.error_str);
 345                 return ERROR_JTAG_DEVICE_ERROR;
 346         }
 347
 348         /* context, vendor id, product id */
 349         if (ftdi_usb_open_desc(&presto->ftdic, PRESTO_VID, PRESTO_PID, NULL, req_serial) < 0)
 350         {
 351                 LOG_ERROR("unable to open PRESTO: %s", presto->ftdic.error_str);
 352                 return ERROR_JTAG_DEVICE_ERROR;
 353         }
 354
 355         if (ftdi_usb_reset(&presto->ftdic) < 0)
 356         {
 357                 LOG_ERROR("unable to reset PRESTO device");
 358                 return ERROR_JTAG_DEVICE_ERROR;
 359         }
 360
 361         if (ftdi_set_latency_timer(&presto->ftdic, 1) < 0)
 362         {
 363                 LOG_ERROR("unable to set latency timer");
 364                 return ERROR_JTAG_DEVICE_ERROR;
 365         }
 366
 367         if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
 368         {
 369                 LOG_ERROR("unable to purge PRESTO buffers");
 370                 return ERROR_JTAG_DEVICE_ERROR;
 371         }
 372
 373         presto_data = 0xD0;
 374         if (presto_write(&presto_data, 1) != ERROR_OK)
 375         {
 376                 LOG_ERROR("error writing to PRESTO");
 377                 return ERROR_JTAG_DEVICE_ERROR;
 378         }
 379
 380         if (presto_read(&presto_data, 1) != ERROR_OK)
 381         {
 382                 LOG_DEBUG("no response from PRESTO, retrying");
 383
 384                 if (ftdi_usb_purge_buffers(&presto->ftdic) < 0)
 385                         return ERROR_JTAG_DEVICE_ERROR;
 386
 387                 presto_data = 0xD0;
 388                 if (presto_write(&presto_data, 1) != ERROR_OK)
 389                         return ERROR_JTAG_DEVICE_ERROR;
 390
 391                 if (presto_read(&presto_data, 1) != ERROR_OK)
 392                 {
 393                         LOG_ERROR("no response from PRESTO, giving up");
 394                         return ERROR_JTAG_DEVICE_ERROR;
 395                 }
 396         }
 397
 398         if (presto_write(presto_init_seq, sizeof(presto_init_seq)) != ERROR_OK)
 399         {
 400                 LOG_ERROR("error writing PRESTO init sequence");
 401                 return ERROR_JTAG_DEVICE_ERROR;
 402         }
 403
 404         return ERROR_OK;
 405 }
 406 #endif /* BUILD_PRESTO_LIBFTDI == 1 */
 407
 408 static int presto_open(char *req_serial)
 409 {
 410         presto->buff_out_pos = 0;
 411         presto->buff_in_pos = 0;
 412         presto->buff_in_len = 0;
 413         presto->buff_in_exp = 0;
 414
 415         presto->total_out = 0;
 416         presto->total_in = 0;
 417
 418         presto->jtag_tms = 0;
 419         presto->jtag_tck = 0;
 420         presto->jtag_rst = 0;
 421         presto->jtag_tdi_data = 0;
 422         presto->jtag_tdi_count = 0;
 423
 424         presto->jtag_speed = 0;
 425
 426 #if BUILD_PRESTO_FTD2XX == 1
 427         return presto_open_ftd2xx(req_serial);
 428 #elif BUILD_PRESTO_LIBFTDI == 1
 429         return presto_open_libftdi(req_serial);
 430 #endif
 431 }
 432
 433 static int presto_close(void)
 434 {
 435
 436         int result = ERROR_OK;
 437
 438 #if BUILD_PRESTO_FTD2XX == 1
 439         unsigned long ftbytes;
 440
 441         if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
 442                 return result;
 443
 444         presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
 445         if (presto->status != FT_OK)
 446                 result = ERROR_JTAG_DEVICE_ERROR;
 447
 448         presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes);
 449         if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
 450                 result = ERROR_JTAG_DEVICE_ERROR;
 451
 452         if ((presto->status = FT_SetLatencyTimer(presto->handle, 16)) != FT_OK)
 453                 result = ERROR_JTAG_DEVICE_ERROR;
 454
 455         if ((presto->status = FT_Close(presto->handle)) != FT_OK)
 456                 result = ERROR_JTAG_DEVICE_ERROR;
 457         else
 458                 presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
 459
 460 #elif BUILD_PRESTO_LIBFTDI == 1
 461
 462         if ((presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq))) != sizeof(presto_init_seq))
 463                 result = ERROR_JTAG_DEVICE_ERROR;
 464
 465         if ((presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16)) < 0)
 466                 result = ERROR_JTAG_DEVICE_ERROR;
 467
 468         if ((presto->retval = ftdi_usb_close(&presto->ftdic)) < 0)
 469                 result = ERROR_JTAG_DEVICE_ERROR;
 470         else
 471                 ftdi_deinit(&presto->ftdic);
 472 #endif
 473
 474         return result;
 475 }
 476
 477 static int presto_flush(void)
 478 {
 479         if (presto->buff_out_pos == 0)
 480                 return ERROR_OK;
 481
 482 #if BUILD_PRESTO_FTD2XX == 1
 483         if (presto->status != FT_OK)
 484 #elif BUILD_PRESTO_LIBFTDI == 1
 485         if (presto->retval < 0)
 486 #endif
 487         {
 488                 LOG_DEBUG("error in previous communication, canceling I/O operation");
 489                 return ERROR_JTAG_DEVICE_ERROR;
 490         }
 491
 492         if (presto_write(presto->buff_out, presto->buff_out_pos) != ERROR_OK)
 493         {
 494                 presto->buff_out_pos = 0;
 495                 return ERROR_JTAG_DEVICE_ERROR;
 496         }
 497
 498         presto->total_out += presto->buff_out_pos;
 499         presto->buff_out_pos = 0;
 500
 501         if (presto->buff_in_exp == 0)
 502                 return ERROR_OK;
 503
 504         presto->buff_in_pos = 0;
 505         presto->buff_in_len = 0;
 506
 507         if (presto_read(presto->buff_in, presto->buff_in_exp) != ERROR_OK)
 508         {
 509                 presto->buff_in_exp = 0;
 510                 return ERROR_JTAG_DEVICE_ERROR;
 511         }
 512
 513         presto->total_in += presto->buff_in_exp;
 514         presto->buff_in_len = presto->buff_in_exp;
 515         presto->buff_in_exp = 0;
 516
 517         return ERROR_OK;
 518 }
 519
 520 static int presto_sendbyte(int data)
 521 {
 522         if (data == EOF) return presto_flush();
 523
 524         if (presto->buff_out_pos < BUFFER_SIZE)
 525         {
 526                 presto->buff_out[presto->buff_out_pos++] = (uint8_t)data;
 527                 if (((data & 0xC0) == 0x40) || ((data & 0xD0)== 0xD0))
 528                         presto->buff_in_exp++;
 529         }
 530         else
 531                 return ERROR_JTAG_DEVICE_ERROR;
 532
 533 #if BUILD_PRESTO_FTD2XX == 1
 534         if (presto->buff_out_pos >= BUFFER_SIZE)
 535 #elif BUILD_PRESTO_LIBFTDI == 1
 536         /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 bytes only!) */
 537         if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp == 128)
 538 #endif
 539                 return presto_flush();
 540
 541         return ERROR_OK;
 542 }
 543
 544 #if 0
 545 static int presto_getbyte(void)
 546 {
 547         if (presto->buff_in_pos < presto->buff_in_len)
 548                 return presto->buff_in[presto->buff_in_pos++];
 549
 550         if (presto->buff_in_exp == 0)
 551                 return -1;
 552
 553         if (presto_flush() != ERROR_OK)
 554                 return -1;
 555
 556         if (presto->buff_in_pos < presto->buff_in_len)
 557                 return presto->buff_in[presto->buff_in_pos++];
 558
 559         return -1;
 560 }
 561 #endif
 562
 563 /* -------------------------------------------------------------------------- */
 564
 565 static int presto_tdi_flush(void)
 566 {
 567         if (presto->jtag_tdi_count == 0)
 568                 return 0;
 569
 570         if (presto->jtag_tck == 0)
 571         {
 572                 LOG_ERROR("BUG: unexpected TAP condition, TCK low");
 573                 return -1;
 574         }
 575
 576         presto->jtag_tdi_data |= (presto->jtag_tdi_count - 1) << 4;
 577         presto_sendbyte(presto->jtag_tdi_data);
 578         presto->jtag_tdi_count = 0;
 579         presto->jtag_tdi_data = 0;
 580
 581         return 0;
 582 }
 583
 584 static int presto_tck_idle(void)
 585 {
 586         if (presto->jtag_tck == 1)
 587         {
 588                 presto_sendbyte(0xCA);
 589                 presto->jtag_tck = 0;
 590         }
 591
 592         return 0;
 593 }
 594
 595 /* -------------------------------------------------------------------------- */
 596
 597 static int presto_bitq_out(int tms, int tdi, int tdo_req)
 598 {
 599         int i;
 600         unsigned char cmd;
 601
 602         if (presto->jtag_tck == 0)
 603         {
 604                 presto_sendbyte(0xA4); /* LED idicator - JTAG active */
 605         }
 606         else if (presto->jtag_speed == 0 && !tdo_req && tms == presto->jtag_tms)
 607         {
 608                 presto->jtag_tdi_data |= (tdi != 0) << presto->jtag_tdi_count;
 609
 610                 if (++presto->jtag_tdi_count == 4)
 611                         presto_tdi_flush();
 612
 613                 return 0;
 614         }
 615
 616         presto_tdi_flush();
 617
 618         cmd = tdi ? 0xCB : 0xCA;
 619         presto_sendbyte(cmd);
 620
 621         if (tms != presto->jtag_tms)
 622         {
 623                 presto_sendbyte((tms ? 0xEC : 0xE8) | (presto->jtag_rst ? 0x02 : 0));
 624                 presto->jtag_tms = tms;
 625         }
 626
 627         /* delay with TCK low */
 628         for (i = presto->jtag_speed; i > 1; i--)
 629                 presto_sendbyte(cmd);
 630
 631         cmd |= 0x04;
 632         presto_sendbyte(cmd | (tdo_req ? 0x10 : 0));
 633
 634         /* delay with TCK high */
 635         for (i = presto->jtag_speed; i > 1; i--)
 636                 presto_sendbyte(cmd);
 637
 638         presto->jtag_tck = 1;
 639
 640         return 0;
 641 }
 642
 643 static int presto_bitq_flush(void)
 644 {
 645         presto_tdi_flush();
 646         presto_tck_idle();
 647
 648         presto_sendbyte(0xA0); /* LED idicator - JTAG idle */
 649
 650         return presto_flush();
 651 }
 652
 653 static int presto_bitq_in_rdy(void)
 654 {
 655         if (presto->buff_in_pos >= presto->buff_in_len)
 656                 return 0;
 657         return presto->buff_in_len-presto->buff_in_pos;
 658 }
 659
 660 static int presto_bitq_in(void)
 661 {
 662         if (presto->buff_in_pos >= presto->buff_in_len)
 663                 return -1;
 664         if (presto->buff_in[presto->buff_in_pos++]&0x08) return 1;
 665         return 0;
 666 }
 667
 668 static int presto_bitq_sleep(unsigned long us)
 669 {
 670         long waits;
 671
 672         presto_tdi_flush();
 673         presto_tck_idle();
 674
 675         if (us > 100000)
 676         {
 677                 presto_bitq_flush();
 678                 jtag_sleep(us);
 679                 return 0;
 680         }
 681
 682         waits = us / 170 + 2;
 683         while (waits--)
 684                 presto_sendbyte(0x80);
 685
 686         return 0;
 687 }
 688
 689 static int presto_bitq_reset(int trst, int srst)
 690 {
 691         presto_tdi_flush();
 692         presto_tck_idle();
 693
 694         /* add a delay after possible TCK transition */
 695         presto_sendbyte(0x80);
 696         presto_sendbyte(0x80);
 697
 698         presto->jtag_rst = trst || srst;
 699         presto_sendbyte((presto->jtag_rst ? 0xEA : 0xE8) | (presto->jtag_tms ? 0x04 : 0));
 700
 701         return 0;
 702 }
 703
 704 /* -------------------------------------------------------------------------- */
 705
 706 static int presto_jtag_khz(int khz, int *jtag_speed)
 707 {
 708         if (khz < 0)
 709         {
 710                 *jtag_speed = 0;
 711                 return ERROR_INVALID_ARGUMENTS;
 712         }
 713
 714         if (khz >= 3000) *jtag_speed = 0;
 715         else *jtag_speed = (1000 + khz-1)/khz;
 716
 717         return 0;
 718 }
 719
 720 static int presto_jtag_speed_div(int speed, int *khz)
 721 {
 722         if ((speed < 0) || (speed > 1000))
 723         {
 724                 *khz = 0;
 725                 return ERROR_INVALID_ARGUMENTS;
 726         }
 727
 728         if (speed == 0) *khz = 3000;
 729         else *khz = 1000/speed;
 730
 731         return 0;
 732 }
 733
 734 static int presto_jtag_speed(int speed)
 735 {
 736         int khz;
 737
 738         if (presto_jtag_speed_div(speed, &khz))
 739         {
 740                 return ERROR_INVALID_ARGUMENTS;
 741         }
 742
 743         presto->jtag_speed = speed;
 744
 745         if (khz%1000 == 0)
 746                 LOG_INFO("setting speed to %d, max. TCK freq. is %d MHz", speed, khz/1000);
 747         else
 748                 LOG_INFO("setting speed to %d, max. TCK freq. is %d kHz", speed, khz);
 749
 750         return 0;
 751 }
 752
 753 static char *presto_serial;
 754
 755 static int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 756 {
 757         if (argc == 1)
 758         {
 759                 if (presto_serial)
 760                         free(presto_serial);
 761                 presto_serial = strdup(args[0]);
 762         }
 763         else
 764         {
 765                 LOG_ERROR("expected exactly one argument to presto_serial <serial-number>");
 766         }
 767
 768         return ERROR_OK;
 769 }
 770
 771 static int presto_jtag_register_commands(struct command_context_s *cmd_ctx)
 772 {
 773         register_command(cmd_ctx, NULL, "presto_serial", presto_handle_serial_command,
 774                 COMMAND_CONFIG, NULL);
 775         return ERROR_OK;
 776 }
 777
 778 static int presto_jtag_init(void)
 779 {
 780         if (presto_open(presto_serial) != ERROR_OK)
 781         {
 782                 presto_close();
 783                 if (presto_serial != NULL)
 784                         LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial);
 785                 else
 786                         LOG_ERROR("Cannot open PRESTO");
 787                 return ERROR_JTAG_INIT_FAILED;
 788         }
 789         LOG_INFO("PRESTO open, serial number '%s'", presto->serial);
 790
 791         /* use JTAG speed setting from configuration file */
 792         presto_jtag_speed(jtag_get_speed());
 793
 794         bitq_interface = &presto_bitq;
 795         return ERROR_OK;
 796 }
 797
 798 static int presto_jtag_quit(void)
 799 {
 800         bitq_cleanup();
 801         presto_close();
 802         LOG_INFO("PRESTO closed");
 803
 804         if (presto_serial)
 805         {
 806                 free(presto_serial);
 807                 presto_serial = NULL;
 808         }
 809
 810         return ERROR_OK;
 811 }