src/jtag/drivers/stlink_usb.c

   1 /***************************************************************************
   2  *   Copyright (C) 2011-2012 by Mathias Kuester                            *
   3  *   Mathias Kuester <kesmtp@freenet.de>                                   *
   4  *                                                                         *
   5  *   This code is based on https://github.com/texane/stlink                *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  21  ***************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 /* project specific includes */
  28 #include <helper/binarybuffer.h>
  29 #include <jtag/interface.h>
  30 #include <jtag/stlink/stlink_layout.h>
  31 #include <jtag/stlink/stlink_transport.h>
  32 #include <jtag/stlink/stlink_interface.h>
  33 #include <target/target.h>
  34
  35 #include "libusb_common.h"
  36
  37 #define ENDPOINT_IN     0x80
  38 #define ENDPOINT_OUT    0x00
  39
  40 #define STLINK_RX_EP    (1|ENDPOINT_IN)
  41 #define STLINK_TX_EP    (2|ENDPOINT_OUT)
  42 #define STLINK_CMD_SIZE (16)
  43 #define STLINK_TX_SIZE  (4*128)
  44 #define STLINK_RX_SIZE  (4*128)
  45
  46 enum stlink_jtag_api_version {
  47         STLINK_JTAG_API_V1 = 0,
  48         STLINK_JTAG_API_V2,
  49 };
  50
  51 /** */
  52 struct stlink_usb_version {
  53         /** */
  54         int stlink;
  55         /** */
  56         int jtag;
  57         /** */
  58         int swim;
  59         /** highest supported jtag api version */
  60         enum stlink_jtag_api_version jtag_api_max;
  61 };
  62
  63 /** */
  64 struct stlink_usb_handle_s {
  65         /** */
  66         struct jtag_libusb_device_handle *fd;
  67         /** */
  68         struct libusb_transfer *trans;
  69         /** */
  70         uint8_t txbuf[STLINK_TX_SIZE];
  71         /** */
  72         uint8_t rxbuf[STLINK_RX_SIZE];
  73         /** */
  74         enum stlink_transports transport;
  75         /** */
  76         struct stlink_usb_version version;
  77         /** */
  78         uint16_t vid;
  79         /** */
  80         uint16_t pid;
  81         /** */
  82         uint32_t sg_tag;
  83         /** this is the currently used jtag api */
  84         enum stlink_jtag_api_version jtag_api;
  85 };
  86
  87 #define STLINK_DEBUG_ERR_OK                     0x80
  88 #define STLINK_DEBUG_ERR_FAULT                  0x81
  89 #define STLINK_CORE_RUNNING                     0x80
  90 #define STLINK_CORE_HALTED                      0x81
  91 #define STLINK_CORE_STAT_UNKNOWN                -1
  92
  93 #define STLINK_GET_VERSION                      0xF1
  94 #define STLINK_DEBUG_COMMAND                    0xF2
  95 #define STLINK_DFU_COMMAND                      0xF3
  96 #define STLINK_SWIM_COMMAND                     0xF4
  97 #define STLINK_GET_CURRENT_MODE                 0xF5
  98
  99 #define STLINK_DEV_DFU_MODE                     0x00
 100 #define STLINK_DEV_MASS_MODE                    0x01
 101 #define STLINK_DEV_DEBUG_MODE                   0x02
 102 #define STLINK_DEV_SWIM_MODE                    0x03
 103 #define STLINK_DEV_BOOTLOADER_MODE              0x04
 104 #define STLINK_DEV_UNKNOWN_MODE                 -1
 105
 106 #define STLINK_DFU_EXIT                         0x07
 107
 108 #define STLINK_SWIM_ENTER                       0x00
 109 #define STLINK_SWIM_EXIT                        0x01
 110
 111 #define STLINK_DEBUG_ENTER_JTAG                 0x00
 112 #define STLINK_DEBUG_GETSTATUS                  0x01
 113 #define STLINK_DEBUG_FORCEDEBUG                 0x02
 114 #define STLINK_DEBUG_APIV1_RESETSYS             0x03
 115 #define STLINK_DEBUG_APIV1_READALLREGS          0x04
 116 #define STLINK_DEBUG_APIV1_READREG              0x05
 117 #define STLINK_DEBUG_APIV1_WRITEREG             0x06
 118 #define STLINK_DEBUG_READMEM_32BIT              0x07
 119 #define STLINK_DEBUG_WRITEMEM_32BIT             0x08
 120 #define STLINK_DEBUG_RUNCORE                    0x09
 121 #define STLINK_DEBUG_STEPCORE                   0x0a
 122 #define STLINK_DEBUG_APIV1_SETFP                0x0b
 123 #define STLINK_DEBUG_READMEM_8BIT               0x0c
 124 #define STLINK_DEBUG_WRITEMEM_8BIT              0x0d
 125 #define STLINK_DEBUG_APIV1_CLEARFP              0x0e
 126 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG        0x0f
 127 #define STLINK_DEBUG_APIV1_SETWATCHPOINT        0x10
 128
 129 #define STLINK_DEBUG_ENTER_JTAG                 0x00
 130 #define STLINK_DEBUG_ENTER_SWD                  0xa3
 131
 132 #define STLINK_DEBUG_APIV1_ENTER                0x20
 133 #define STLINK_DEBUG_EXIT                       0x21
 134 #define STLINK_DEBUG_READCOREID                 0x22
 135
 136 #define STLINK_DEBUG_APIV2_ENTER                0x30
 137 #define STLINK_DEBUG_APIV2_READ_IDCODES         0x31
 138 #define STLINK_DEBUG_APIV2_RESETSYS             0x32
 139 #define STLINK_DEBUG_APIV2_READREG              0x33
 140 #define STLINK_DEBUG_APIV2_WRITEREG             0x34
 141
 142 #define STLINK_DEBUG_APIV2_READALLREGS          0x3A
 143
 144 #define STLINK_DEBUG_APIV2_DRIVE_NRST           0x3C
 145
 146 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW       0x00
 147 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH      0x01
 148 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE     0x02
 149
 150 /** */
 151 enum stlink_mode {
 152         STLINK_MODE_UNKNOWN = 0,
 153         STLINK_MODE_DFU,
 154         STLINK_MODE_MASS,
 155         STLINK_MODE_DEBUG_JTAG,
 156         STLINK_MODE_DEBUG_SWD,
 157         STLINK_MODE_DEBUG_SWIM
 158 };
 159
 160 /** */
 161 static void stlink_usb_recv_v1_create_cmd(char *b, int s, uint32_t tag, uint32_t rxsize,
 162                         uint8_t flag, uint8_t lun, uint8_t length)
 163 {
 164         int i = 0;
 165
 166         memset(b, 0x00, s);
 167
 168         /* fill the send buffer */
 169         strcpy(b, "USBC");
 170         i += 4;
 171
 172         buf_set_u32(b+i, 0, 32, tag);
 173         i += 4;
 174         buf_set_u32(b+i, 0, 32, rxsize);
 175         i += 4;
 176         b[i++] = flag;
 177         b[i++] = lun;
 178         b[i++] = length;
 179 }
 180
 181 /** */
 182 static int stlink_usb_recv_v1_mass_storage_cmd(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
 183                     int rxsize)
 184 {
 185         char sg_buffer[31];
 186         struct stlink_usb_handle_s *h;
 187
 188         assert(handle != NULL);
 189
 190         h = (struct stlink_usb_handle_s *)handle;
 191         h->sg_tag = (h->sg_tag + 1) & 1;
 192
 193         stlink_usb_recv_v1_create_cmd(sg_buffer, 31, h->sg_tag, rxsize, STLINK_TX_EP, 0x00, txsize);
 194
 195         memcpy(sg_buffer+15, txbuf, 10);
 196
 197         if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)sg_buffer, 31,
 198                                    1000) != 31) {
 199                 printf("send failed\n");
 200                 return ERROR_FAIL;
 201         }
 202
 203         return ERROR_OK;
 204 }
 205
 206 #define REQUEST_SENSE           0x03
 207 #define REQUEST_SENSE_LENGTH    18
 208
 209 /** */
 210 static int stlink_usb_recv_v1_get_status(void *handle, char *sg_buffer, int len)
 211 {
 212         struct stlink_usb_handle_s *h;
 213
 214         assert(handle != NULL);
 215
 216         h = (struct stlink_usb_handle_s *)handle;
 217
 218         /* read status */
 219         memset(sg_buffer, 0x00, len);
 220
 221         if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)sg_buffer,
 222                                 len, 1000) != len)
 223                 return ERROR_FAIL;
 224
 225         uint32_t t1, t2;
 226
 227         t1 = buf_get_u32(sg_buffer+0, 0, 32);
 228         t2 = buf_get_u32(sg_buffer+4, 0, 32);
 229
 230         /* check for USBS */
 231         if (t1 != 0x53425355)
 232                 return ERROR_FAIL;
 233
 234         return ERROR_OK;
 235 }
 236
 237 /** */
 238 static int stlink_usb_recv_v1_get_sense(void *handle)
 239 {
 240         struct stlink_usb_handle_s *h;
 241         char cdb[16];
 242         char sg_buffer[31];
 243
 244         assert(handle != NULL);
 245
 246         h = (struct stlink_usb_handle_s *)handle;
 247         h->sg_tag = (h->sg_tag + 1) & 1;
 248
 249         cdb[0] = REQUEST_SENSE;
 250         cdb[4] = REQUEST_SENSE_LENGTH;
 251
 252         stlink_usb_recv_v1_create_cmd(sg_buffer, 31, h->sg_tag, REQUEST_SENSE_LENGTH, STLINK_TX_EP,
 253                         0x00, 16);
 254
 255         memcpy(sg_buffer+15, cdb, 16);
 256
 257         if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)sg_buffer, 16,
 258                                    1000) != 16)
 259                 return ERROR_FAIL;
 260
 261         if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)cdb,
 262                                   16, 1000) != 16)
 263                 return ERROR_FAIL;
 264
 265         if (stlink_usb_recv_v1_get_status(handle, sg_buffer, 13) != ERROR_OK)
 266                 return ERROR_FAIL;
 267         /* check for sense */
 268         if (sg_buffer[12] != 0)
 269                 return ERROR_FAIL;
 270
 271         /* if (sense[0] != 0x70 && sense[0] != 0x71) */
 272
 273         return ERROR_OK;
 274 }
 275
 276 /** */
 277 static int stlink_usb_recv_v1(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
 278                     int rxsize)
 279 {
 280         int err;
 281         char sg_buffer[31];
 282         struct stlink_usb_handle_s *h;
 283
 284         assert(handle != NULL);
 285
 286         h = (struct stlink_usb_handle_s *)handle;
 287
 288         err = stlink_usb_recv_v1_mass_storage_cmd(handle, txbuf, txsize, rxbuf, rxsize);
 289
 290         if (err != ERROR_OK)
 291                 return err;
 292
 293         if (rxsize && rxbuf) {
 294                 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)rxbuf,
 295                                           rxsize, 1000) != rxsize) {
 296                         LOG_DEBUG("jtag_libusb_bulk_read");
 297                         return ERROR_FAIL;
 298                 }
 299         }
 300
 301         if (stlink_usb_recv_v1_get_status(handle, sg_buffer, 13) != ERROR_OK)
 302                 return ERROR_FAIL;
 303         /* check for sense */
 304         if (sg_buffer[12] == 1) {
 305                 LOG_DEBUG("get sense");
 306                 err = stlink_usb_recv_v1_get_sense(handle);
 307         }
 308         return err;
 309 }
 310
 311 /** */
 312 static int stlink_usb_recv_v2(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
 313                     int rxsize)
 314 {
 315         struct stlink_usb_handle_s *h;
 316
 317         assert(handle != NULL);
 318
 319         h = (struct stlink_usb_handle_s *)handle;
 320
 321         if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)txbuf, txsize,
 322                                    1000) != txsize) {
 323                 return ERROR_FAIL;
 324         }
 325         if (rxsize && rxbuf) {
 326                 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)rxbuf,
 327                                           rxsize, 1000) != rxsize) {
 328                         return ERROR_FAIL;
 329                 }
 330         }
 331         return ERROR_OK;
 332 }
 333
 334 /** */
 335 static int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
 336                     int rxsize)
 337 {
 338         struct stlink_usb_handle_s *h;
 339
 340         assert(handle != NULL);
 341
 342         h = (struct stlink_usb_handle_s *)handle;
 343
 344         if (h->version.stlink == 1) {
 345                 return stlink_usb_recv_v1(handle, txbuf, txsize, rxbuf, rxsize);
 346         } else {
 347                 if (txsize < STLINK_CMD_SIZE)
 348                         txsize = STLINK_CMD_SIZE;
 349                 return stlink_usb_recv_v2(handle, txbuf, txsize, rxbuf, rxsize);
 350         }
 351 }
 352
 353 /** */
 354 static void stlink_usb_init_buffer(void *handle)
 355 {
 356         struct stlink_usb_handle_s *h;
 357
 358         assert(handle != NULL);
 359
 360         h = (struct stlink_usb_handle_s *)handle;
 361
 362         memset(h->txbuf, 0, STLINK_TX_SIZE);
 363         memset(h->rxbuf, 0, STLINK_RX_SIZE);
 364 }
 365
 366 static const char * const stlink_usb_error_msg[] = {
 367         "unknown"
 368 };
 369
 370 /** */
 371 static int stlink_usb_error_check(void *handle)
 372 {
 373         int res;
 374         const char *err_msg = 0;
 375         struct stlink_usb_handle_s *h;
 376
 377         assert(handle != NULL);
 378
 379         h = (struct stlink_usb_handle_s *)handle;
 380
 381         /* TODO: no error checking yet on api V1 */
 382         if (h->jtag_api == STLINK_JTAG_API_V1)
 383                 h->rxbuf[0] = STLINK_DEBUG_ERR_OK;
 384
 385         switch (h->rxbuf[0]) {
 386                 case STLINK_DEBUG_ERR_OK:
 387                         res = ERROR_OK;
 388                         break;
 389                 case STLINK_DEBUG_ERR_FAULT:
 390                 default:
 391                         err_msg = stlink_usb_error_msg[0];
 392                         res = ERROR_FAIL;
 393                         break;
 394         }
 395
 396         if (res != ERROR_OK)
 397                 LOG_DEBUG("status error: %d ('%s')", h->rxbuf[0], err_msg);
 398
 399         return res;
 400 }
 401
 402 /** */
 403 static int stlink_usb_version(void *handle)
 404 {
 405         int res;
 406         uint16_t v;
 407         struct stlink_usb_handle_s *h;
 408
 409         assert(handle != NULL);
 410
 411         h = (struct stlink_usb_handle_s *)handle;
 412
 413         stlink_usb_init_buffer(handle);
 414
 415         h->txbuf[0] = STLINK_GET_VERSION;
 416
 417         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 6);
 418
 419         if (res != ERROR_OK)
 420                 return res;
 421
 422         v = (h->rxbuf[0] << 8) | h->rxbuf[1];
 423
 424         h->version.stlink = (v >> 12) & 0x0f;
 425         h->version.jtag = (v >> 6) & 0x3f;
 426         h->version.swim = v & 0x3f;
 427         h->vid = buf_get_u32(h->rxbuf, 16, 16);
 428         h->pid = buf_get_u32(h->rxbuf, 32, 16);
 429
 430         /* set the supported jtag api version
 431          * V1 doesn't support API V2 at all
 432          * V2 support API V2 since JTAG V13
 433          */
 434         if ((h->version.stlink == 2) && (h->version.jtag > 12))
 435                 h->version.jtag_api_max = STLINK_JTAG_API_V2;
 436         else
 437                 h->version.jtag_api_max = STLINK_JTAG_API_V1;
 438
 439         LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID %04X PID %04X",
 440                 h->version.stlink,
 441                 h->version.jtag,
 442                 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
 443                 h->version.swim,
 444                 h->vid,
 445                 h->pid);
 446
 447         return ERROR_OK;
 448 }
 449
 450 /** */
 451 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
 452 {
 453         int res;
 454         struct stlink_usb_handle_s *h;
 455
 456         assert(handle != NULL);
 457
 458         h = (struct stlink_usb_handle_s *)handle;
 459
 460         stlink_usb_init_buffer(handle);
 461
 462         h->txbuf[0] = STLINK_GET_CURRENT_MODE;
 463
 464         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 465
 466         if (res != ERROR_OK)
 467                 return res;
 468
 469         *mode = h->rxbuf[0];
 470
 471         return ERROR_OK;
 472 }
 473
 474 /** */
 475 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
 476 {
 477         int res;
 478         int rx_size = 0;
 479         struct stlink_usb_handle_s *h;
 480
 481         assert(handle != NULL);
 482
 483         h = (struct stlink_usb_handle_s *)handle;
 484
 485         stlink_usb_init_buffer(handle);
 486
 487         switch (type) {
 488                 case STLINK_MODE_DEBUG_JTAG:
 489                         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 490                         if (h->jtag_api == STLINK_JTAG_API_V1)
 491                                 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
 492                         else
 493                                 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
 494                         h->txbuf[2] = STLINK_DEBUG_ENTER_JTAG;
 495                         break;
 496                 case STLINK_MODE_DEBUG_SWD:
 497                         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 498                         if (h->jtag_api == STLINK_JTAG_API_V1)
 499                                 h->txbuf[1] = STLINK_DEBUG_APIV1_ENTER;
 500                         else
 501                                 h->txbuf[1] = STLINK_DEBUG_APIV2_ENTER;
 502                         h->txbuf[2] = STLINK_DEBUG_ENTER_SWD;
 503                         break;
 504                 case STLINK_MODE_DEBUG_SWIM:
 505                         h->txbuf[0] = STLINK_SWIM_COMMAND;
 506                         h->txbuf[1] = STLINK_SWIM_ENTER;
 507                         break;
 508                 case STLINK_MODE_DFU:
 509                 case STLINK_MODE_MASS:
 510                 default:
 511                         return ERROR_FAIL;
 512         }
 513
 514         /* on api V2 we are able the read the latest command
 515          * status
 516          * TODO: we need the test on api V1 too
 517          */
 518         if (h->jtag_api == STLINK_JTAG_API_V2)
 519                 rx_size = 2;
 520
 521         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, rx_size);
 522
 523         if (res != ERROR_OK)
 524                 return res;
 525
 526         res = stlink_usb_error_check(h);
 527
 528         return res;
 529 }
 530
 531 /** */
 532 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
 533 {
 534         int res;
 535         struct stlink_usb_handle_s *h;
 536
 537         assert(handle != NULL);
 538
 539         h = (struct stlink_usb_handle_s *)handle;
 540
 541         stlink_usb_init_buffer(handle);
 542
 543         switch (type) {
 544                 case STLINK_MODE_DEBUG_JTAG:
 545                 case STLINK_MODE_DEBUG_SWD:
 546                         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 547                         h->txbuf[1] = STLINK_DEBUG_EXIT;
 548                         break;
 549                 case STLINK_MODE_DEBUG_SWIM:
 550                         h->txbuf[0] = STLINK_SWIM_COMMAND;
 551                         h->txbuf[1] = STLINK_SWIM_EXIT;
 552                         break;
 553                 case STLINK_MODE_DFU:
 554                         h->txbuf[0] = STLINK_DFU_COMMAND;
 555                         h->txbuf[1] = STLINK_DFU_EXIT;
 556                         break;
 557                 case STLINK_MODE_MASS:
 558                 default:
 559                         return ERROR_FAIL;
 560         }
 561
 562         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
 563
 564         if (res != ERROR_OK)
 565                 return res;
 566
 567         return ERROR_OK;
 568 }
 569
 570 /** */
 571 static int stlink_usb_init_mode(void *handle)
 572 {
 573         int res;
 574         uint8_t mode;
 575         enum stlink_mode emode;
 576         struct stlink_usb_handle_s *h;
 577
 578         assert(handle != NULL);
 579
 580         h = (struct stlink_usb_handle_s *)handle;
 581
 582         res = stlink_usb_current_mode(handle, &mode);
 583
 584         if (res != ERROR_OK)
 585                 return res;
 586
 587         LOG_DEBUG("MODE: %02X", mode);
 588
 589         /* try to exit current mode */
 590         switch (mode) {
 591                 case STLINK_DEV_DFU_MODE:
 592                         emode = STLINK_MODE_DFU;
 593                         break;
 594                 case STLINK_DEV_DEBUG_MODE:
 595                         emode = STLINK_MODE_DEBUG_SWD;
 596                         break;
 597                 case STLINK_DEV_SWIM_MODE:
 598                         emode = STLINK_MODE_DEBUG_SWIM;
 599                         break;
 600                 case STLINK_DEV_BOOTLOADER_MODE:
 601                 case STLINK_DEV_MASS_MODE:
 602                 default:
 603                         emode = STLINK_MODE_UNKNOWN;
 604                         break;
 605         }
 606
 607         if (emode != STLINK_MODE_UNKNOWN) {
 608                 res = stlink_usb_mode_leave(handle, emode);
 609
 610                 if (res != ERROR_OK)
 611                         return res;
 612         }
 613
 614         res = stlink_usb_current_mode(handle, &mode);
 615
 616         if (res != ERROR_OK)
 617                 return res;
 618
 619         LOG_DEBUG("MODE: %02X", mode);
 620
 621         /* set selected mode */
 622         switch (h->transport) {
 623                 case STLINK_TRANSPORT_SWD:
 624                         emode = STLINK_MODE_DEBUG_SWD;
 625                         break;
 626                 case STLINK_TRANSPORT_JTAG:
 627                         emode = STLINK_MODE_DEBUG_JTAG;
 628                         break;
 629                 case STLINK_TRANSPORT_SWIM:
 630                         emode = STLINK_MODE_DEBUG_SWIM;
 631                         break;
 632                 default:
 633                         emode = STLINK_MODE_UNKNOWN;
 634                         break;
 635         }
 636
 637         if (emode == STLINK_MODE_UNKNOWN) {
 638                 LOG_ERROR("selected mode (transport) not supported");
 639                 return ERROR_FAIL;
 640         }
 641
 642         res = stlink_usb_mode_enter(handle, emode);
 643
 644         if (res != ERROR_OK)
 645                 return res;
 646
 647         res = stlink_usb_current_mode(handle, &mode);
 648
 649         if (res != ERROR_OK)
 650                 return res;
 651
 652         LOG_DEBUG("MODE: %02X", mode);
 653
 654         return ERROR_OK;
 655 }
 656
 657 /** */
 658 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
 659 {
 660         int res;
 661         struct stlink_usb_handle_s *h;
 662
 663         assert(handle != NULL);
 664
 665         h = (struct stlink_usb_handle_s *)handle;
 666
 667         stlink_usb_init_buffer(handle);
 668
 669         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 670         h->txbuf[1] = STLINK_DEBUG_READCOREID;
 671
 672         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
 673
 674         if (res != ERROR_OK)
 675                 return res;
 676
 677         *idcode = le_to_h_u32(h->rxbuf);
 678
 679         LOG_DEBUG("IDCODE: %08X", *idcode);
 680
 681         return ERROR_OK;
 682 }
 683
 684 /** */
 685 static enum target_state stlink_usb_state(void *handle)
 686 {
 687         int res;
 688         struct stlink_usb_handle_s *h;
 689
 690         assert(handle != NULL);
 691
 692         h = (struct stlink_usb_handle_s *)handle;
 693
 694         if (h->jtag_api == STLINK_JTAG_API_V2)
 695                 return TARGET_UNKNOWN;
 696
 697         stlink_usb_init_buffer(handle);
 698
 699         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 700         h->txbuf[1] = STLINK_DEBUG_GETSTATUS;
 701
 702         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 703
 704         if (res != ERROR_OK)
 705                 return TARGET_UNKNOWN;
 706
 707         if (h->rxbuf[0] == STLINK_CORE_RUNNING)
 708                 return TARGET_RUNNING;
 709         if (h->rxbuf[0] == STLINK_CORE_HALTED)
 710                 return TARGET_HALTED;
 711
 712         return TARGET_UNKNOWN;
 713 }
 714
 715 /** */
 716 static int stlink_usb_reset(void *handle)
 717 {
 718         int res;
 719         struct stlink_usb_handle_s *h;
 720
 721         assert(handle != NULL);
 722
 723         h = (struct stlink_usb_handle_s *)handle;
 724
 725         stlink_usb_init_buffer(handle);
 726
 727         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 728
 729         if (h->jtag_api == STLINK_JTAG_API_V1)
 730                 h->txbuf[1] = STLINK_DEBUG_APIV1_RESETSYS;
 731         else
 732                 h->txbuf[1] = STLINK_DEBUG_APIV2_RESETSYS;
 733
 734         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 735
 736         if (res != ERROR_OK)
 737                 return res;
 738
 739         LOG_DEBUG("RESET: %08X", h->rxbuf[0]);
 740
 741         return ERROR_OK;
 742 }
 743
 744 /** */
 745 static int stlink_usb_run(void *handle)
 746 {
 747         int res;
 748         struct stlink_usb_handle_s *h;
 749
 750         assert(handle != NULL);
 751
 752         h = (struct stlink_usb_handle_s *)handle;
 753
 754         if (h->jtag_api == STLINK_JTAG_API_V2)
 755                 return ERROR_FAIL;
 756
 757         stlink_usb_init_buffer(handle);
 758
 759         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 760         h->txbuf[1] = STLINK_DEBUG_RUNCORE;
 761
 762         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 763
 764         if (res != ERROR_OK)
 765                 return res;
 766
 767         return ERROR_OK;
 768 }
 769
 770 /** */
 771 static int stlink_usb_halt(void *handle)
 772 {
 773         int res;
 774         struct stlink_usb_handle_s *h;
 775
 776         assert(handle != NULL);
 777
 778         h = (struct stlink_usb_handle_s *)handle;
 779
 780         if (h->jtag_api == STLINK_JTAG_API_V2)
 781                 return ERROR_FAIL;
 782
 783         stlink_usb_init_buffer(handle);
 784
 785         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 786         h->txbuf[1] = STLINK_DEBUG_FORCEDEBUG;
 787
 788         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 789
 790         if (res != ERROR_OK)
 791                 return res;
 792
 793         return ERROR_OK;
 794 }
 795
 796 /** */
 797 static int stlink_usb_step(void *handle)
 798 {
 799         int res;
 800         struct stlink_usb_handle_s *h;
 801
 802         assert(handle != NULL);
 803
 804         h = (struct stlink_usb_handle_s *)handle;
 805
 806         if (h->jtag_api == STLINK_JTAG_API_V2)
 807                 return ERROR_FAIL;
 808
 809         stlink_usb_init_buffer(handle);
 810
 811         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 812         h->txbuf[1] = STLINK_DEBUG_STEPCORE;
 813
 814         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 815
 816         if (res != ERROR_OK)
 817                 return res;
 818
 819         return ERROR_OK;
 820 }
 821
 822 /** */
 823 static int stlink_usb_read_regs(void *handle)
 824 {
 825         int res;
 826         struct stlink_usb_handle_s *h;
 827
 828         assert(handle != NULL);
 829
 830         h = (struct stlink_usb_handle_s *)handle;
 831
 832         stlink_usb_init_buffer(handle);
 833
 834         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 835         if (h->jtag_api == STLINK_JTAG_API_V1)
 836                 h->txbuf[1] = STLINK_DEBUG_APIV1_READALLREGS;
 837         else
 838                 h->txbuf[1] = STLINK_DEBUG_APIV2_READALLREGS;
 839
 840         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 84);
 841
 842         if (res != ERROR_OK)
 843                 return res;
 844
 845         return ERROR_OK;
 846 }
 847
 848 /** */
 849 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
 850 {
 851         int res;
 852         struct stlink_usb_handle_s *h;
 853
 854         assert(handle != NULL);
 855
 856         h = (struct stlink_usb_handle_s *)handle;
 857
 858         stlink_usb_init_buffer(handle);
 859
 860         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 861         if (h->jtag_api == STLINK_JTAG_API_V1)
 862                 h->txbuf[1] = STLINK_DEBUG_APIV1_READREG;
 863         else
 864                 h->txbuf[1] = STLINK_DEBUG_APIV2_READREG;
 865         h->txbuf[2] = num;
 866
 867         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 4);
 868
 869         if (res != ERROR_OK)
 870                 return res;
 871
 872         *val = le_to_h_u32(h->rxbuf);
 873
 874         return ERROR_OK;
 875 }
 876
 877 /** */
 878 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
 879 {
 880         int res;
 881         struct stlink_usb_handle_s *h;
 882
 883         assert(handle != NULL);
 884
 885         h = (struct stlink_usb_handle_s *)handle;
 886
 887         stlink_usb_init_buffer(handle);
 888
 889         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 890         if (h->jtag_api == STLINK_JTAG_API_V1)
 891                 h->txbuf[1] = STLINK_DEBUG_APIV1_WRITEREG;
 892         else
 893                 h->txbuf[1] = STLINK_DEBUG_APIV2_WRITEREG;
 894         h->txbuf[2] = num;
 895         h_u32_to_le(h->txbuf + 3, val);
 896
 897         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, 2);
 898
 899         if (res != ERROR_OK)
 900                 return res;
 901
 902         return ERROR_OK;
 903 }
 904
 905 /** */
 906 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
 907                           uint8_t *buffer)
 908 {
 909         int res;
 910         uint16_t read_len = len;
 911         struct stlink_usb_handle_s *h;
 912
 913         assert(handle != NULL);
 914
 915         h = (struct stlink_usb_handle_s *)handle;
 916
 917         stlink_usb_init_buffer(handle);
 918
 919         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 920         h->txbuf[1] = STLINK_DEBUG_READMEM_8BIT;
 921         h_u32_to_le(h->txbuf + 2, addr);
 922         h_u16_to_le(h->txbuf + 2 + 4, len);
 923
 924         /* we need to fix read length for single bytes */
 925         if (read_len == 1)
 926                 read_len++;
 927
 928         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, read_len);
 929
 930         if (res != ERROR_OK)
 931                 return res;
 932
 933         memcpy(buffer, h->rxbuf, len);
 934
 935         return ERROR_OK;
 936 }
 937
 938 /** */
 939 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
 940                            const uint8_t *buffer)
 941 {
 942         int res;
 943         struct stlink_usb_handle_s *h;
 944
 945         assert(handle != NULL);
 946
 947         h = (struct stlink_usb_handle_s *)handle;
 948
 949         stlink_usb_init_buffer(handle);
 950
 951         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 952         h->txbuf[1] = STLINK_DEBUG_WRITEMEM_8BIT;
 953         h_u32_to_le(h->txbuf + 2, addr);
 954         h_u16_to_le(h->txbuf + 2 + 4, len);
 955
 956         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
 957
 958         if (res != ERROR_OK)
 959                 return res;
 960
 961         res = stlink_usb_recv(handle, (uint8_t *) buffer, len, 0, 0);
 962
 963         if (res != ERROR_OK)
 964                 return res;
 965
 966         return ERROR_OK;
 967 }
 968
 969 /** */
 970 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
 971                           uint32_t *buffer)
 972 {
 973         int res;
 974         struct stlink_usb_handle_s *h;
 975
 976         assert(handle != NULL);
 977
 978         h = (struct stlink_usb_handle_s *)handle;
 979
 980         stlink_usb_init_buffer(handle);
 981
 982         len *= 4;
 983
 984         h->txbuf[0] = STLINK_DEBUG_COMMAND;
 985         h->txbuf[1] = STLINK_DEBUG_READMEM_32BIT;
 986         h_u32_to_le(h->txbuf + 2, addr);
 987         h_u16_to_le(h->txbuf + 2 + 4, len);
 988
 989         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, h->rxbuf, len);
 990
 991         if (res != ERROR_OK)
 992                 return res;
 993
 994         memcpy(buffer, h->rxbuf, len);
 995
 996         return ERROR_OK;
 997 }
 998
 999 /** */
1000 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1001                            const uint32_t *buffer)
1002 {
1003         int res;
1004         struct stlink_usb_handle_s *h;
1005
1006         assert(handle != NULL);
1007
1008         h = (struct stlink_usb_handle_s *)handle;
1009
1010         stlink_usb_init_buffer(handle);
1011
1012         len *= 4;
1013
1014         h->txbuf[0] = STLINK_DEBUG_COMMAND;
1015         h->txbuf[1] = STLINK_DEBUG_WRITEMEM_32BIT;
1016         h_u32_to_le(h->txbuf + 2, addr);
1017         h_u16_to_le(h->txbuf + 2 + 4, len);
1018
1019         res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
1020
1021         if (res != ERROR_OK)
1022                 return res;
1023
1024         res = stlink_usb_recv(handle, (uint8_t *) buffer, len, 0, 0);
1025
1026         if (res != ERROR_OK)
1027                 return res;
1028
1029         return ERROR_OK;
1030 }
1031
1032 /** */
1033 static int stlink_usb_open(struct stlink_interface_param_s *param, void **fd)
1034 {
1035         int err;
1036         struct stlink_usb_handle_s *h;
1037
1038         LOG_DEBUG("stlink_usb_open");
1039
1040         h = malloc(sizeof(struct stlink_usb_handle_s));
1041
1042         if (h == 0) {
1043                 LOG_DEBUG("malloc failed");
1044                 return ERROR_FAIL;
1045         }
1046
1047         h->transport = param->transport;
1048
1049         const uint16_t vids[] = { param->vid, 0 };
1050         const uint16_t pids[] = { param->pid, 0 };
1051
1052         LOG_DEBUG("transport: %d vid: %04x pid: %04x", param->transport,
1053                 param->vid, param->pid);
1054
1055         if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1056                 LOG_ERROR("open failed");
1057                 return ERROR_FAIL;
1058         }
1059
1060         jtag_libusb_set_configuration(h->fd, 0);
1061
1062         if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1063                 LOG_DEBUG("claim interface failed");
1064                 return ERROR_FAIL;
1065         }
1066
1067         /* wrap version for first read */
1068         switch (param->pid) {
1069                 case 0x3744:
1070                         h->version.stlink = 1;
1071                         break;
1072                 default:
1073                         h->version.stlink = 2;
1074                         break;
1075         }
1076
1077         /* get the device version */
1078         err = stlink_usb_version(h);
1079
1080         if (err != ERROR_OK) {
1081                 LOG_ERROR("read version failed");
1082                 jtag_libusb_close(h->fd);
1083                 free(h);
1084                 return err;
1085         }
1086
1087         /* compare usb vid/pid */
1088         if ((param->vid != h->vid) || (param->pid != h->pid))
1089                 LOG_INFO("vid/pid are not identical: %04X/%04X %04X/%04X",
1090                         param->vid, param->pid,
1091                         h->vid, h->pid);
1092
1093         /* check if mode is supported */
1094         err = ERROR_OK;
1095
1096         switch (h->transport) {
1097                 case STLINK_TRANSPORT_SWD:
1098                 case STLINK_TRANSPORT_JTAG:
1099                         if (h->version.jtag == 0)
1100                                 err = ERROR_FAIL;
1101                         break;
1102                 case STLINK_TRANSPORT_SWIM:
1103                         if (h->version.swim == 0)
1104                                 err = ERROR_FAIL;
1105                         break;
1106                 default:
1107                         err = ERROR_FAIL;
1108                         break;
1109         }
1110
1111         if (err != ERROR_OK) {
1112                 LOG_ERROR("mode (transport) not supported by device");
1113                 jtag_libusb_close(h->fd);
1114                 free(h);
1115                 return err;
1116         }
1117
1118         /* set the used jtag api */
1119         h->jtag_api = STLINK_JTAG_API_V1;
1120
1121         /* initialize the debug hardware */
1122         err = stlink_usb_init_mode(h);
1123
1124         if (err != ERROR_OK) {
1125                 LOG_ERROR("init mode failed");
1126                 jtag_libusb_close(h->fd);
1127                 free(h);
1128                 return err;
1129         }
1130
1131         *fd = h;
1132
1133         return ERROR_OK;
1134 }
1135
1136 /** */
1137 static int stlink_usb_close(void *fd)
1138 {
1139         return ERROR_OK;
1140 }
1141
1142 /** */
1143 struct stlink_layout_api_s stlink_usb_layout_api = {
1144         /** */
1145         .open = stlink_usb_open,
1146         /** */
1147         .close = stlink_usb_close,
1148         /** */
1149         .idcode = stlink_usb_idcode,
1150         /** */
1151         .state = stlink_usb_state,
1152         /** */
1153         .reset = stlink_usb_reset,
1154         /** */
1155         .run = stlink_usb_run,
1156         /** */
1157         .halt = stlink_usb_halt,
1158         /** */
1159         .step = stlink_usb_step,
1160         /** */
1161         .read_regs = stlink_usb_read_regs,
1162         /** */
1163         .read_reg = stlink_usb_read_reg,
1164         /** */
1165         .write_reg = stlink_usb_write_reg,
1166         /** */
1167         .read_mem8 = stlink_usb_read_mem8,
1168         /** */
1169         .write_mem8 = stlink_usb_write_mem8,
1170         /** */
1171         .read_mem32 = stlink_usb_read_mem32,
1172         /** */
1173         .write_mem32 = stlink_usb_write_mem32,
1174 };