11 #include "stlink-common.h"
12 #include "stlink-usb.h"
13 #include "uglylogging.h"
15 enum SCSI_Generic_Direction {SG_DXFER_TO_DEV=0, SG_DXFER_FROM_DEV=0x80};
17 void _stlink_usb_close(stlink_t* sl) {
18 struct stlink_libusb * const handle = sl->backend_data;
19 // maybe we couldn't even get the usb device?
21 if (handle->usb_handle != NULL) {
22 libusb_close(handle->usb_handle);
25 libusb_exit(handle->libusb_ctx);
30 ssize_t send_recv(struct stlink_libusb* handle, int terminate,
31 unsigned char* txbuf, size_t txsize,
32 unsigned char* rxbuf, size_t rxsize) {
33 /* note: txbuf and rxbuf can point to the same area */
36 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_req,
44 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
52 if ((handle->protocoll == 1) && terminate) {
53 /* Read the SG reply */
54 unsigned char sg_buf[13];
55 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
61 /* The STLink doesn't seem to evaluate the sequence number */
62 handle->sg_transfer_idx++;
68 static inline int send_only
69 (struct stlink_libusb* handle, int terminate,
70 unsigned char* txbuf, size_t txsize) {
71 return send_recv(handle, terminate, txbuf, txsize, NULL, 0);
75 static int fill_command
76 (stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
77 struct stlink_libusb * const slu = sl->backend_data;
78 unsigned char* const cmd = sl->c_buf;
80 memset(cmd, 0, sizeof (sl->c_buf));
81 if(slu->protocoll == 1) {
86 write_uint32(&cmd[i], slu->sg_transfer_idx);
87 write_uint32(&cmd[i + 4], len);
89 cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;
90 cmd[i++] = 0; /* Logical unit */
91 cmd[i++] = 0xa; /* Command length */
96 int _stlink_usb_version(stlink_t *sl) {
97 struct stlink_libusb * const slu = sl->backend_data;
98 unsigned char* const data = sl->q_buf;
99 unsigned char* const cmd = sl->c_buf;
101 uint32_t rep_len = 6;
102 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
104 cmd[i++] = STLINK_GET_VERSION;
106 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
108 printf("[!] send_recv\n");
115 int32_t _stlink_usb_target_voltage(stlink_t *sl) {
116 struct stlink_libusb * const slu = sl->backend_data;
117 unsigned char* const rdata = sl->q_buf;
118 unsigned char* const cmd = sl->c_buf;
120 uint32_t rep_len = 8;
121 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
122 uint32_t factor, reading;
125 cmd[i++] = STLINK_GET_TARGET_VOLTAGE;
127 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
129 printf("[!] send_recv\n");
131 } else if (size != 8) {
132 printf("[!] wrong length\n");
136 factor = (rdata[3] << 24) | (rdata[2] << 16) | (rdata[1] << 8) | (rdata[0] << 0);
137 reading = (rdata[7] << 24) | (rdata[6] << 16) | (rdata[5] << 8) | (rdata[4] << 0);
138 voltage = 2400 * reading / factor;
143 int _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
144 struct stlink_libusb * const slu = sl->backend_data;
145 unsigned char* const rdata = sl->q_buf;
146 unsigned char* const cmd = sl->c_buf;
148 const int rep_len = 8;
150 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
151 cmd[i++] = STLINK_DEBUG_COMMAND;
152 cmd[i++] = STLINK_JTAG_READDEBUG_32BIT;
153 write_uint32(&cmd[i], addr);
154 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
156 printf("[!] send_recv\n");
159 *data = read_uint32(rdata, 4);
163 int _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
164 struct stlink_libusb * const slu = sl->backend_data;
165 unsigned char* const rdata = sl->q_buf;
166 unsigned char* const cmd = sl->c_buf;
168 const int rep_len = 2;
170 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
171 cmd[i++] = STLINK_DEBUG_COMMAND;
172 cmd[i++] = STLINK_JTAG_WRITEDEBUG_32BIT;
173 write_uint32(&cmd[i], addr);
174 write_uint32(&cmd[i + 4], data);
175 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
177 printf("[!] send_recv\n");
184 int _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
185 struct stlink_libusb * const slu = sl->backend_data;
186 unsigned char* const data = sl->q_buf;
187 unsigned char* const cmd = sl->c_buf;
190 i = fill_command(sl, SG_DXFER_TO_DEV, len);
191 cmd[i++] = STLINK_DEBUG_COMMAND;
192 cmd[i++] = STLINK_DEBUG_WRITEMEM_32BIT;
193 write_uint32(&cmd[i], addr);
194 write_uint16(&cmd[i + 4], len);
195 ret = send_only(slu, 0, cmd, slu->cmd_len);
199 ret = send_only(slu, 1, data, len);
206 int _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
207 struct stlink_libusb * const slu = sl->backend_data;
208 unsigned char* const data = sl->q_buf;
209 unsigned char* const cmd = sl->c_buf;
212 i = fill_command(sl, SG_DXFER_TO_DEV, 0);
213 cmd[i++] = STLINK_DEBUG_COMMAND;
214 cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;
215 write_uint32(&cmd[i], addr);
216 write_uint16(&cmd[i + 4], len);
217 ret = send_only(slu, 0, cmd, slu->cmd_len);
221 ret = send_only(slu, 1, data, len);
229 int _stlink_usb_current_mode(stlink_t * sl) {
230 struct stlink_libusb * const slu = sl->backend_data;
231 unsigned char* const cmd = sl->c_buf;
232 unsigned char* const data = sl->q_buf;
235 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
237 cmd[i++] = STLINK_GET_CURRENT_MODE;
238 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
240 printf("[!] send_recv\n");
246 int _stlink_usb_core_id(stlink_t * sl) {
247 struct stlink_libusb * const slu = sl->backend_data;
248 unsigned char* const cmd = sl->c_buf;
249 unsigned char* const data = sl->q_buf;
252 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
254 cmd[i++] = STLINK_DEBUG_COMMAND;
255 cmd[i++] = STLINK_DEBUG_READCOREID;
257 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
259 printf("[!] send_recv\n");
263 sl->core_id = read_uint32(data, 0);
267 int _stlink_usb_status(stlink_t * sl) {
268 struct stlink_libusb * const slu = sl->backend_data;
269 unsigned char* const data = sl->q_buf;
270 unsigned char* const cmd = sl->c_buf;
273 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
275 cmd[i++] = STLINK_DEBUG_COMMAND;
276 cmd[i++] = STLINK_DEBUG_GETSTATUS;
278 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
280 printf("[!] send_recv\n");
283 sl->q_len = (size_t) size;
288 int _stlink_usb_force_debug(stlink_t *sl) {
289 struct stlink_libusb *slu = sl->backend_data;
290 unsigned char* const data = sl->q_buf;
291 unsigned char* const cmd = sl->c_buf;
294 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
296 cmd[i++] = STLINK_DEBUG_COMMAND;
297 cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
298 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
300 printf("[!] send_recv\n");
307 int _stlink_usb_enter_swd_mode(stlink_t * sl) {
308 struct stlink_libusb * const slu = sl->backend_data;
309 unsigned char* const cmd = sl->c_buf;
311 const int rep_len = 0;
312 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
314 cmd[i++] = STLINK_DEBUG_COMMAND;
315 cmd[i++] = STLINK_DEBUG_ENTER;
316 cmd[i++] = STLINK_DEBUG_ENTER_SWD;
318 size = send_only(slu, 1, cmd, slu->cmd_len);
320 printf("[!] send_recv\n");
327 int _stlink_usb_exit_dfu_mode(stlink_t* sl) {
328 struct stlink_libusb * const slu = sl->backend_data;
329 unsigned char* const cmd = sl->c_buf;
331 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
333 cmd[i++] = STLINK_DFU_COMMAND;
334 cmd[i++] = STLINK_DFU_EXIT;
336 size = send_only(slu, 1, cmd, slu->cmd_len);
338 printf("[!] send_recv\n");
346 * TODO - not convinced this does anything...
349 int _stlink_usb_reset(stlink_t * sl) {
350 struct stlink_libusb * const slu = sl->backend_data;
351 unsigned char* const data = sl->q_buf;
352 unsigned char* const cmd = sl->c_buf;
355 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
357 cmd[i++] = STLINK_DEBUG_COMMAND;
358 cmd[i++] = STLINK_DEBUG_RESETSYS;
360 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
362 printf("[!] send_recv\n");
370 int _stlink_usb_jtag_reset(stlink_t * sl, int value) {
371 struct stlink_libusb * const slu = sl->backend_data;
372 unsigned char* const data = sl->q_buf;
373 unsigned char* const cmd = sl->c_buf;
376 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
378 cmd[i++] = STLINK_DEBUG_COMMAND;
379 cmd[i++] = STLINK_JTAG_DRIVE_NRST;
382 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
384 printf("[!] send_recv\n");
392 int _stlink_usb_step(stlink_t* sl) {
393 struct stlink_libusb * const slu = sl->backend_data;
394 unsigned char* const data = sl->q_buf;
395 unsigned char* const cmd = sl->c_buf;
398 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
400 cmd[i++] = STLINK_DEBUG_COMMAND;
401 cmd[i++] = STLINK_DEBUG_STEPCORE;
403 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
405 printf("[!] send_recv\n");
413 * This seems to do a good job of restarting things from the beginning?
416 int _stlink_usb_run(stlink_t* sl) {
417 struct stlink_libusb * const slu = sl->backend_data;
418 unsigned char* const data = sl->q_buf;
419 unsigned char* const cmd = sl->c_buf;
422 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
424 cmd[i++] = STLINK_DEBUG_COMMAND;
425 cmd[i++] = STLINK_DEBUG_RUNCORE;
427 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
429 printf("[!] send_recv\n");
436 int _stlink_usb_exit_debug_mode(stlink_t *sl) {
437 struct stlink_libusb * const slu = sl->backend_data;
438 unsigned char* const cmd = sl->c_buf;
440 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
442 cmd[i++] = STLINK_DEBUG_COMMAND;
443 cmd[i++] = STLINK_DEBUG_EXIT;
445 size = send_only(slu, 1, cmd, slu->cmd_len);
447 printf("[!] send_only\n");
454 int _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
455 struct stlink_libusb * const slu = sl->backend_data;
456 unsigned char* const data = sl->q_buf;
457 unsigned char* const cmd = sl->c_buf;
459 int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
461 cmd[i++] = STLINK_DEBUG_COMMAND;
462 cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
463 write_uint32(&cmd[i], addr);
464 write_uint16(&cmd[i + 4], len);
466 size = send_recv(slu, 1, cmd, slu->cmd_len, data, len);
468 printf("[!] send_recv\n");
472 sl->q_len = (size_t) size;
474 stlink_print_data(sl);
478 int _stlink_usb_read_all_regs(stlink_t *sl, reg *regp) {
479 struct stlink_libusb * const slu = sl->backend_data;
480 unsigned char* const cmd = sl->c_buf;
481 unsigned char* const data = sl->q_buf;
483 uint32_t rep_len = 84;
484 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
486 cmd[i++] = STLINK_DEBUG_COMMAND;
487 cmd[i++] = STLINK_DEBUG_READALLREGS;
488 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
490 printf("[!] send_recv\n");
493 sl->q_len = (size_t) size;
494 stlink_print_data(sl);
496 regp->r[i]= read_uint32(sl->q_buf, i*4);
497 regp->xpsr = read_uint32(sl->q_buf, 64);
498 regp->main_sp = read_uint32(sl->q_buf, 68);
499 regp->process_sp = read_uint32(sl->q_buf, 72);
500 regp->rw = read_uint32(sl->q_buf, 76);
501 regp->rw2 = read_uint32(sl->q_buf, 80);
505 DLOG("xpsr = 0x%08x\n", read_uint32(sl->q_buf, 64));
506 DLOG("main_sp = 0x%08x\n", read_uint32(sl->q_buf, 68));
507 DLOG("process_sp = 0x%08x\n", read_uint32(sl->q_buf, 72));
508 DLOG("rw = 0x%08x\n", read_uint32(sl->q_buf, 76));
509 DLOG("rw2 = 0x%08x\n", read_uint32(sl->q_buf, 80));
514 int _stlink_usb_read_reg(stlink_t *sl, int r_idx, reg *regp) {
515 struct stlink_libusb * const slu = sl->backend_data;
516 unsigned char* const data = sl->q_buf;
517 unsigned char* const cmd = sl->c_buf;
520 uint32_t rep_len = 4;
521 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
523 cmd[i++] = STLINK_DEBUG_COMMAND;
524 cmd[i++] = STLINK_DEBUG_READREG;
525 cmd[i++] = (uint8_t) r_idx;
526 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
528 printf("[!] send_recv\n");
531 sl->q_len = (size_t) size;
532 stlink_print_data(sl);
533 r = read_uint32(sl->q_buf, 0);
534 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
544 regp->process_sp = r;
547 regp->rw = r; /* XXX ?(primask, basemask etc.) */
550 regp->rw2 = r; /* XXX ?(primask, basemask etc.) */
559 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
560 int _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, reg *regp) {
564 sl->q_buf[0] = (unsigned char) r_idx;
565 for (int i = 1; i < 4; i++) {
569 ret = _stlink_usb_write_mem32(sl, DCRSR, 4);
573 _stlink_usb_read_mem32(sl, DCRDR, 4);
577 r = read_uint32(sl->q_buf, 0);
578 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
582 regp->primask = (uint8_t) (r & 0xFF);
583 regp->basepri = (uint8_t) ((r>>8) & 0xFF);
584 regp->faultmask = (uint8_t) ((r>>16) & 0xFF);
585 regp->control = (uint8_t) ((r>>24) & 0xFF);
591 regp->s[r_idx - 0x40] = r;
598 int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, reg *regp) {
601 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
605 ret = _stlink_usb_read_unsupported_reg(sl, 0x21, regp);
609 for (int i = 0; i < 32; i++) {
610 ret = _stlink_usb_read_unsupported_reg(sl, 0x40+i, regp);
618 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
619 int _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, reg *regp) {
622 if (r_idx >= 0x1C && r_idx <= 0x1F) { /* primask, basepri, faultmask, or control */
623 /* These are held in the same register */
624 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
628 val = (uint8_t) (val>>24);
631 case 0x1C: /* control */
632 val = (((uint32_t) val) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
634 case 0x1D: /* faultmask */
635 val = (((uint32_t) regp->control) << 24) | (((uint32_t) val) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
637 case 0x1E: /* basepri */
638 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) val) << 8) | ((uint32_t) regp->primask);
640 case 0x1F: /* primask */
641 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) val);
648 write_uint32(sl->q_buf, val);
650 ret = _stlink_usb_write_mem32(sl, DCRDR, 4);
654 sl->q_buf[0] = (unsigned char) r_idx;
659 return _stlink_usb_write_mem32(sl, DCRSR, 4);
662 int _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
663 struct stlink_libusb * const slu = sl->backend_data;
664 unsigned char* const data = sl->q_buf;
665 unsigned char* const cmd = sl->c_buf;
667 uint32_t rep_len = 2;
668 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
670 cmd[i++] = STLINK_DEBUG_COMMAND;
671 cmd[i++] = STLINK_DEBUG_WRITEREG;
673 write_uint32(&cmd[i], reg);
674 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
676 printf("[!] send_recv\n");
679 sl->q_len = (size_t) size;
680 stlink_print_data(sl);
685 stlink_backend_t _stlink_usb_backend = {
687 _stlink_usb_exit_debug_mode,
688 _stlink_usb_enter_swd_mode,
689 NULL, // no enter_jtag_mode here...
690 _stlink_usb_exit_dfu_mode,
693 _stlink_usb_jtag_reset,
697 _stlink_usb_read_debug32,
698 _stlink_usb_read_mem32,
699 _stlink_usb_write_debug32,
700 _stlink_usb_write_mem32,
701 _stlink_usb_write_mem8,
702 _stlink_usb_read_all_regs,
703 _stlink_usb_read_reg,
704 _stlink_usb_read_all_unsupported_regs,
705 _stlink_usb_read_unsupported_reg,
706 _stlink_usb_write_unsupported_reg,
707 _stlink_usb_write_reg,
709 _stlink_usb_current_mode,
710 _stlink_usb_force_debug,
711 _stlink_usb_target_voltage
715 stlink_t* stlink_open_usb(const int verbose, int reset, char *p_usb_iserial) {
717 struct stlink_libusb* slu = NULL;
721 sl = malloc(sizeof (stlink_t));
722 slu = malloc(sizeof (struct stlink_libusb));
723 if (sl == NULL) goto on_error;
724 if (slu == NULL) goto on_error;
725 memset(sl, 0, sizeof (stlink_t));
726 memset(slu, 0, sizeof (struct stlink_libusb));
729 sl->backend = &_stlink_usb_backend;
730 sl->backend_data = slu;
732 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
733 if (libusb_init(&(slu->libusb_ctx))) {
734 WLOG("failed to init libusb context, wrong version of libraries?\n");
738 libusb_device **list;
739 int cnt = libusb_get_device_list(slu->libusb_ctx, &list);
740 struct libusb_device_descriptor desc;
744 char *device = getenv("STLINK_DEVICE");
746 char *c = strchr(device,':');
748 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
754 ILOG("bus %03d dev %03d\n",devBus, devAddr);
757 libusb_get_device_descriptor( list[cnt], &desc );
758 if (desc.idVendor!=USB_ST_VID) continue;
759 if (devBus && devAddr)
760 if ((libusb_get_bus_number(list[cnt])!=devBus) || (libusb_get_device_address(list[cnt])!=devAddr)) continue;
761 if ( (desc.idProduct == USB_STLINK_32L_PID) || (desc.idProduct == USB_STLINK_NUCLEO_PID) ){
762 if ((p_usb_iserial != NULL)){
763 unsigned char buffer[13];
764 struct libusb_device_handle* handle;
765 libusb_open(list[cnt], &handle);
766 libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, buffer, 13);
767 libusb_close(handle);
768 if (memcmp(p_usb_iserial,&buffer,12) == 0){
777 if (desc.idProduct == USB_STLINK_PID) {
784 WLOG ("Couldn't find %s ST-Link/V2 devices\n",(devBus && devAddr)?"matched":"any");
787 int error = libusb_open(list[cnt], &slu->usb_handle);
789 WLOG("Error %d (%s) opening ST-Link/V2 device %03d:%03d\n",
790 error, strerror (errno), libusb_get_bus_number(list[cnt]), libusb_get_device_address(list[cnt]));
795 libusb_free_device_list(list, 1);
798 if (libusb_kernel_driver_active(slu->usb_handle, 0) == 1) {
801 r = libusb_detach_kernel_driver(slu->usb_handle, 0);
803 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-r));
804 goto on_libusb_error;
808 if (libusb_get_configuration(slu->usb_handle, &config)) {
809 /* this may fail for a previous configured device */
810 WLOG("libusb_get_configuration()\n");
811 goto on_libusb_error;
815 printf("setting new configuration (%d -> 1)\n", config);
816 if (libusb_set_configuration(slu->usb_handle, 1)) {
817 /* this may fail for a previous configured device */
818 WLOG("libusb_set_configuration() failed\n");
819 goto on_libusb_error;
823 if (libusb_claim_interface(slu->usb_handle, 0)) {
824 WLOG("libusb_claim_interface() failed\n");
825 goto on_libusb_error;
828 // TODO - could use the scanning techniq from stm8 code here...
829 slu->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
830 if (desc.idProduct == USB_STLINK_NUCLEO_PID) {
831 slu->ep_req = 1 /* ep req */ | LIBUSB_ENDPOINT_OUT;
833 slu->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
836 slu->sg_transfer_idx = 0;
837 // TODO - never used at the moment, always CMD_SIZE
838 slu->cmd_len = (slu->protocoll == 1)? STLINK_SG_SIZE: STLINK_CMD_SIZE;
842 if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
843 ILOG("-- exit_dfu_mode\n");
844 stlink_exit_dfu_mode(sl);
847 if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
848 stlink_enter_swd_mode(sl);
856 error = stlink_load_device_params(sl);
869 libusb_exit(slu->libusb_ctx);
870 if (sl != NULL) free(sl);
871 if (slu != NULL) free(slu);