11 #include "stlink-common.h"
12 #include "stlink-usb.h"
14 enum SCSI_Generic_Direction {SG_DXFER_TO_DEV=0, SG_DXFER_FROM_DEV=0x80};
16 void _stlink_usb_close(stlink_t* sl) {
20 struct stlink_libusb * const handle = sl->backend_data;
21 // maybe we couldn't even get the usb device?
23 if (handle->usb_handle != NULL) {
24 libusb_close(handle->usb_handle);
27 libusb_exit(handle->libusb_ctx);
32 ssize_t send_recv(struct stlink_libusb* handle, int terminate,
33 unsigned char* txbuf, size_t txsize,
34 unsigned char* rxbuf, size_t rxsize) {
35 /* note: txbuf and rxbuf can point to the same area */
38 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_req,
46 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
54 if ((handle->protocoll == 1) && terminate) {
55 /* Read the SG reply */
56 unsigned char sg_buf[13];
57 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
63 /* The STLink doesn't seem to evaluate the sequence number */
64 handle->sg_transfer_idx++;
70 static inline int send_only
71 (struct stlink_libusb* handle, int terminate,
72 unsigned char* txbuf, size_t txsize) {
73 return send_recv(handle, terminate, txbuf, txsize, NULL, 0);
77 static int fill_command
78 (stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
79 struct stlink_libusb * const slu = sl->backend_data;
80 unsigned char* const cmd = sl->c_buf;
82 memset(cmd, 0, sizeof (sl->c_buf));
83 if(slu->protocoll == 1) {
88 write_uint32(&cmd[i], slu->sg_transfer_idx);
89 write_uint32(&cmd[i + 4], len);
91 cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;
92 cmd[i++] = 0; /* Logical unit */
93 cmd[i++] = 0xa; /* Command length */
98 int _stlink_usb_version(stlink_t *sl) {
99 struct stlink_libusb * const slu = sl->backend_data;
100 unsigned char* const data = sl->q_buf;
101 unsigned char* const cmd = sl->c_buf;
103 uint32_t rep_len = 6;
104 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
106 cmd[i++] = STLINK_GET_VERSION;
108 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
110 printf("[!] send_recv\n");
117 int32_t _stlink_usb_target_voltage(stlink_t *sl) {
118 struct stlink_libusb * const slu = sl->backend_data;
119 unsigned char* const rdata = sl->q_buf;
120 unsigned char* const cmd = sl->c_buf;
122 uint32_t rep_len = 8;
123 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
124 uint32_t factor, reading;
127 cmd[i++] = STLINK_GET_TARGET_VOLTAGE;
129 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
131 printf("[!] send_recv\n");
133 } else if (size != 8) {
134 printf("[!] wrong length\n");
138 factor = (rdata[3] << 24) | (rdata[2] << 16) | (rdata[1] << 8) | (rdata[0] << 0);
139 reading = (rdata[7] << 24) | (rdata[6] << 16) | (rdata[5] << 8) | (rdata[4] << 0);
140 voltage = 2400 * reading / factor;
145 int _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
146 struct stlink_libusb * const slu = sl->backend_data;
147 unsigned char* const rdata = sl->q_buf;
148 unsigned char* const cmd = sl->c_buf;
150 const int rep_len = 8;
152 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
153 cmd[i++] = STLINK_DEBUG_COMMAND;
154 cmd[i++] = STLINK_JTAG_READDEBUG_32BIT;
155 write_uint32(&cmd[i], addr);
156 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
158 printf("[!] send_recv\n");
161 *data = read_uint32(rdata, 4);
165 int _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
166 struct stlink_libusb * const slu = sl->backend_data;
167 unsigned char* const rdata = sl->q_buf;
168 unsigned char* const cmd = sl->c_buf;
170 const int rep_len = 2;
172 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
173 cmd[i++] = STLINK_DEBUG_COMMAND;
174 cmd[i++] = STLINK_JTAG_WRITEDEBUG_32BIT;
175 write_uint32(&cmd[i], addr);
176 write_uint32(&cmd[i + 4], data);
177 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
179 printf("[!] send_recv\n");
186 int _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
187 struct stlink_libusb * const slu = sl->backend_data;
188 unsigned char* const data = sl->q_buf;
189 unsigned char* const cmd = sl->c_buf;
192 i = fill_command(sl, SG_DXFER_TO_DEV, len);
193 cmd[i++] = STLINK_DEBUG_COMMAND;
194 cmd[i++] = STLINK_DEBUG_WRITEMEM_32BIT;
195 write_uint32(&cmd[i], addr);
196 write_uint16(&cmd[i + 4], len);
197 ret = send_only(slu, 0, cmd, slu->cmd_len);
201 ret = send_only(slu, 1, data, len);
208 int _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
209 struct stlink_libusb * const slu = sl->backend_data;
210 unsigned char* const data = sl->q_buf;
211 unsigned char* const cmd = sl->c_buf;
214 i = fill_command(sl, SG_DXFER_TO_DEV, 0);
215 cmd[i++] = STLINK_DEBUG_COMMAND;
216 cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;
217 write_uint32(&cmd[i], addr);
218 write_uint16(&cmd[i + 4], len);
219 ret = send_only(slu, 0, cmd, slu->cmd_len);
223 ret = send_only(slu, 1, data, len);
231 int _stlink_usb_current_mode(stlink_t * sl) {
232 struct stlink_libusb * const slu = sl->backend_data;
233 unsigned char* const cmd = sl->c_buf;
234 unsigned char* const data = sl->q_buf;
237 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
239 cmd[i++] = STLINK_GET_CURRENT_MODE;
240 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
242 printf("[!] send_recv\n");
248 int _stlink_usb_core_id(stlink_t * sl) {
249 struct stlink_libusb * const slu = sl->backend_data;
250 unsigned char* const cmd = sl->c_buf;
251 unsigned char* const data = sl->q_buf;
254 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
256 cmd[i++] = STLINK_DEBUG_COMMAND;
257 cmd[i++] = STLINK_DEBUG_READCOREID;
259 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
261 printf("[!] send_recv\n");
265 sl->core_id = read_uint32(data, 0);
269 int _stlink_usb_status(stlink_t * sl) {
270 struct stlink_libusb * const slu = sl->backend_data;
271 unsigned char* const data = sl->q_buf;
272 unsigned char* const cmd = sl->c_buf;
275 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
277 cmd[i++] = STLINK_DEBUG_COMMAND;
278 cmd[i++] = STLINK_DEBUG_GETSTATUS;
280 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
282 printf("[!] send_recv\n");
285 sl->q_len = (size_t) size;
290 int _stlink_usb_force_debug(stlink_t *sl) {
291 struct stlink_libusb *slu = sl->backend_data;
292 unsigned char* const data = sl->q_buf;
293 unsigned char* const cmd = sl->c_buf;
296 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
298 cmd[i++] = STLINK_DEBUG_COMMAND;
299 cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
300 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
302 printf("[!] send_recv\n");
309 int _stlink_usb_enter_swd_mode(stlink_t * sl) {
310 struct stlink_libusb * const slu = sl->backend_data;
311 unsigned char* const cmd = sl->c_buf;
313 const int rep_len = 0;
314 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
316 cmd[i++] = STLINK_DEBUG_COMMAND;
317 cmd[i++] = STLINK_DEBUG_ENTER;
318 cmd[i++] = STLINK_DEBUG_ENTER_SWD;
320 size = send_only(slu, 1, cmd, slu->cmd_len);
322 printf("[!] send_recv\n");
329 int _stlink_usb_exit_dfu_mode(stlink_t* sl) {
330 struct stlink_libusb * const slu = sl->backend_data;
331 unsigned char* const cmd = sl->c_buf;
333 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
335 cmd[i++] = STLINK_DFU_COMMAND;
336 cmd[i++] = STLINK_DFU_EXIT;
338 size = send_only(slu, 1, cmd, slu->cmd_len);
340 printf("[!] send_recv\n");
348 * TODO - not convinced this does anything...
351 int _stlink_usb_reset(stlink_t * sl) {
352 struct stlink_libusb * const slu = sl->backend_data;
353 unsigned char* const data = sl->q_buf;
354 unsigned char* const cmd = sl->c_buf;
357 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
359 cmd[i++] = STLINK_DEBUG_COMMAND;
360 cmd[i++] = STLINK_DEBUG_RESETSYS;
362 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
364 printf("[!] send_recv\n");
372 int _stlink_usb_jtag_reset(stlink_t * sl, int value) {
373 struct stlink_libusb * const slu = sl->backend_data;
374 unsigned char* const data = sl->q_buf;
375 unsigned char* const cmd = sl->c_buf;
378 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
380 cmd[i++] = STLINK_DEBUG_COMMAND;
381 cmd[i++] = STLINK_JTAG_DRIVE_NRST;
384 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
386 printf("[!] send_recv\n");
394 int _stlink_usb_step(stlink_t* sl) {
395 struct stlink_libusb * const slu = sl->backend_data;
396 unsigned char* const data = sl->q_buf;
397 unsigned char* const cmd = sl->c_buf;
400 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
402 cmd[i++] = STLINK_DEBUG_COMMAND;
403 cmd[i++] = STLINK_DEBUG_STEPCORE;
405 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
407 printf("[!] send_recv\n");
415 * This seems to do a good job of restarting things from the beginning?
418 int _stlink_usb_run(stlink_t* sl) {
419 struct stlink_libusb * const slu = sl->backend_data;
420 unsigned char* const data = sl->q_buf;
421 unsigned char* const cmd = sl->c_buf;
424 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
426 cmd[i++] = STLINK_DEBUG_COMMAND;
427 cmd[i++] = STLINK_DEBUG_RUNCORE;
429 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
431 printf("[!] send_recv\n");
438 int _stlink_usb_exit_debug_mode(stlink_t *sl) {
439 struct stlink_libusb * const slu = sl->backend_data;
440 unsigned char* const cmd = sl->c_buf;
442 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
444 cmd[i++] = STLINK_DEBUG_COMMAND;
445 cmd[i++] = STLINK_DEBUG_EXIT;
447 size = send_only(slu, 1, cmd, slu->cmd_len);
449 printf("[!] send_only\n");
456 int _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
457 struct stlink_libusb * const slu = sl->backend_data;
458 unsigned char* const data = sl->q_buf;
459 unsigned char* const cmd = sl->c_buf;
461 int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
463 cmd[i++] = STLINK_DEBUG_COMMAND;
464 cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
465 write_uint32(&cmd[i], addr);
466 write_uint16(&cmd[i + 4], len);
468 size = send_recv(slu, 1, cmd, slu->cmd_len, data, len);
470 printf("[!] send_recv\n");
474 sl->q_len = (size_t) size;
476 stlink_print_data(sl);
480 int _stlink_usb_read_all_regs(stlink_t *sl, reg *regp) {
481 struct stlink_libusb * const slu = sl->backend_data;
482 unsigned char* const cmd = sl->c_buf;
483 unsigned char* const data = sl->q_buf;
485 uint32_t rep_len = 84;
486 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
488 cmd[i++] = STLINK_DEBUG_COMMAND;
489 cmd[i++] = STLINK_DEBUG_READALLREGS;
490 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
492 printf("[!] send_recv\n");
495 sl->q_len = (size_t) size;
496 stlink_print_data(sl);
498 regp->r[i]= read_uint32(sl->q_buf, i*4);
499 regp->xpsr = read_uint32(sl->q_buf, 64);
500 regp->main_sp = read_uint32(sl->q_buf, 68);
501 regp->process_sp = read_uint32(sl->q_buf, 72);
502 regp->rw = read_uint32(sl->q_buf, 76);
503 regp->rw2 = read_uint32(sl->q_buf, 80);
507 DLOG("xpsr = 0x%08x\n", read_uint32(sl->q_buf, 64));
508 DLOG("main_sp = 0x%08x\n", read_uint32(sl->q_buf, 68));
509 DLOG("process_sp = 0x%08x\n", read_uint32(sl->q_buf, 72));
510 DLOG("rw = 0x%08x\n", read_uint32(sl->q_buf, 76));
511 DLOG("rw2 = 0x%08x\n", read_uint32(sl->q_buf, 80));
516 int _stlink_usb_read_reg(stlink_t *sl, int r_idx, reg *regp) {
517 struct stlink_libusb * const slu = sl->backend_data;
518 unsigned char* const data = sl->q_buf;
519 unsigned char* const cmd = sl->c_buf;
522 uint32_t rep_len = 4;
523 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
525 cmd[i++] = STLINK_DEBUG_COMMAND;
526 cmd[i++] = STLINK_DEBUG_READREG;
527 cmd[i++] = (uint8_t) r_idx;
528 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
530 printf("[!] send_recv\n");
533 sl->q_len = (size_t) size;
534 stlink_print_data(sl);
535 r = read_uint32(sl->q_buf, 0);
536 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
546 regp->process_sp = r;
549 regp->rw = r; /* XXX ?(primask, basemask etc.) */
552 regp->rw2 = r; /* XXX ?(primask, basemask etc.) */
561 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
562 int _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, reg *regp) {
566 sl->q_buf[0] = (unsigned char) r_idx;
567 for (int i = 1; i < 4; i++) {
571 ret = _stlink_usb_write_mem32(sl, DCRSR, 4);
575 _stlink_usb_read_mem32(sl, DCRDR, 4);
579 r = read_uint32(sl->q_buf, 0);
580 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
584 regp->primask = (uint8_t) (r & 0xFF);
585 regp->basepri = (uint8_t) ((r>>8) & 0xFF);
586 regp->faultmask = (uint8_t) ((r>>16) & 0xFF);
587 regp->control = (uint8_t) ((r>>24) & 0xFF);
593 regp->s[r_idx - 0x40] = r;
600 int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, reg *regp) {
603 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
607 ret = _stlink_usb_read_unsupported_reg(sl, 0x21, regp);
611 for (int i = 0; i < 32; i++) {
612 ret = _stlink_usb_read_unsupported_reg(sl, 0x40+i, regp);
620 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
621 int _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, reg *regp) {
624 if (r_idx >= 0x1C && r_idx <= 0x1F) { /* primask, basepri, faultmask, or control */
625 /* These are held in the same register */
626 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
630 val = (uint8_t) (val>>24);
633 case 0x1C: /* control */
634 val = (((uint32_t) val) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
636 case 0x1D: /* faultmask */
637 val = (((uint32_t) regp->control) << 24) | (((uint32_t) val) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
639 case 0x1E: /* basepri */
640 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) val) << 8) | ((uint32_t) regp->primask);
642 case 0x1F: /* primask */
643 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) val);
650 write_uint32(sl->q_buf, val);
652 ret = _stlink_usb_write_mem32(sl, DCRDR, 4);
656 sl->q_buf[0] = (unsigned char) r_idx;
661 return _stlink_usb_write_mem32(sl, DCRSR, 4);
664 int _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
665 struct stlink_libusb * const slu = sl->backend_data;
666 unsigned char* const data = sl->q_buf;
667 unsigned char* const cmd = sl->c_buf;
669 uint32_t rep_len = 2;
670 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
672 cmd[i++] = STLINK_DEBUG_COMMAND;
673 cmd[i++] = STLINK_DEBUG_WRITEREG;
675 write_uint32(&cmd[i], reg);
676 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
678 printf("[!] send_recv\n");
681 sl->q_len = (size_t) size;
682 stlink_print_data(sl);
687 stlink_backend_t _stlink_usb_backend = {
689 _stlink_usb_exit_debug_mode,
690 _stlink_usb_enter_swd_mode,
691 NULL, // no enter_jtag_mode here...
692 _stlink_usb_exit_dfu_mode,
695 _stlink_usb_jtag_reset,
699 _stlink_usb_read_debug32,
700 _stlink_usb_read_mem32,
701 _stlink_usb_write_debug32,
702 _stlink_usb_write_mem32,
703 _stlink_usb_write_mem8,
704 _stlink_usb_read_all_regs,
705 _stlink_usb_read_reg,
706 _stlink_usb_read_all_unsupported_regs,
707 _stlink_usb_read_unsupported_reg,
708 _stlink_usb_write_unsupported_reg,
709 _stlink_usb_write_reg,
711 _stlink_usb_current_mode,
712 _stlink_usb_force_debug,
713 _stlink_usb_target_voltage
716 stlink_t *stlink_open_usb(enum ugly_loglevel verbose, bool reset, char serial[16])
719 struct stlink_libusb* slu = NULL;
723 sl = calloc(1, sizeof (stlink_t));
724 slu = calloc(1, sizeof (struct stlink_libusb));
726 goto on_malloc_error;
728 goto on_malloc_error;
731 sl->backend = &_stlink_usb_backend;
732 sl->backend_data = slu;
734 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
735 if (libusb_init(&(slu->libusb_ctx))) {
736 WLOG("failed to init libusb context, wrong version of libraries?\n");
740 libusb_device **list;
741 int cnt = libusb_get_device_list(slu->libusb_ctx, &list);
742 struct libusb_device_descriptor desc;
746 char *device = getenv("STLINK_DEVICE");
748 char *c = strchr(device,':');
750 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
756 ILOG("bus %03d dev %03d\n",devBus, devAddr);
760 libusb_get_device_descriptor( list[cnt], &desc );
761 if (desc.idVendor != USB_ST_VID)
764 if (devBus && devAddr) {
765 if ((libusb_get_bus_number(list[cnt]) != devBus)
766 || (libusb_get_device_address(list[cnt]) != devAddr)) {
771 if ((desc.idProduct == USB_STLINK_32L_PID) || (desc.idProduct == USB_STLINK_NUCLEO_PID)) {
772 struct libusb_device_handle *handle;
774 libusb_open(list[cnt], &handle);
775 sl->serial_size = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
776 (unsigned char *)sl->serial, sizeof(sl->serial));
777 libusb_close(handle);
779 if ((serial == NULL) || (*serial == 0))
782 if (sl->serial_size < 0)
785 if (memcmp(serial, &sl->serial, sl->serial_size) == 0)
791 if (desc.idProduct == USB_STLINK_PID) {
798 WLOG ("Couldn't find %s ST-Link/V2 devices\n",(devBus && devAddr)?"matched":"any");
801 ret = libusb_open(list[cnt], &slu->usb_handle);
803 WLOG("Error %d (%s) opening ST-Link/V2 device %03d:%03d\n",
804 ret, strerror (errno), libusb_get_bus_number(list[cnt]), libusb_get_device_address(list[cnt]));
809 libusb_free_device_list(list, 1);
811 if (libusb_kernel_driver_active(slu->usb_handle, 0) == 1) {
812 ret = libusb_detach_kernel_driver(slu->usb_handle, 0);
814 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-ret));
815 goto on_libusb_error;
819 if (libusb_get_configuration(slu->usb_handle, &config)) {
820 /* this may fail for a previous configured device */
821 WLOG("libusb_get_configuration()\n");
822 goto on_libusb_error;
826 printf("setting new configuration (%d -> 1)\n", config);
827 if (libusb_set_configuration(slu->usb_handle, 1)) {
828 /* this may fail for a previous configured device */
829 WLOG("libusb_set_configuration() failed\n");
830 goto on_libusb_error;
834 if (libusb_claim_interface(slu->usb_handle, 0)) {
835 WLOG("libusb_claim_interface() failed\n");
836 goto on_libusb_error;
839 // TODO - could use the scanning techniq from stm8 code here...
840 slu->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
841 if (desc.idProduct == USB_STLINK_NUCLEO_PID) {
842 slu->ep_req = 1 /* ep req */ | LIBUSB_ENDPOINT_OUT;
844 slu->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
847 slu->sg_transfer_idx = 0;
848 // TODO - never used at the moment, always CMD_SIZE
849 slu->cmd_len = (slu->protocoll == 1)? STLINK_SG_SIZE: STLINK_CMD_SIZE;
851 if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
852 ILOG("-- exit_dfu_mode\n");
853 stlink_exit_dfu_mode(sl);
856 if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
857 stlink_enter_swd_mode(sl);
866 ret = stlink_load_device_params(sl);
878 libusb_exit(slu->libusb_ctx);
889 static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[]) {
898 while ((dev = devs[i++]) != NULL) {
899 struct libusb_device_descriptor desc;
900 int r = libusb_get_device_descriptor(dev, &desc);
902 WLOG("failed to get libusb device descriptor\n");
906 if (desc.idProduct != USB_STLINK_32L_PID &&
907 desc.idProduct != USB_STLINK_NUCLEO_PID)
913 /* Allocate list of pointers */
914 _sldevs = calloc(slcnt, sizeof(stlink_t *));
920 /* Open stlinks and attach to list */
922 while ((dev = devs[i++]) != NULL) {
923 struct libusb_device_descriptor desc;
924 ret = libusb_get_device_descriptor(dev, &desc);
926 WLOG("failed to get libusb device descriptor\n");
930 if (desc.idProduct != USB_STLINK_32L_PID &&
931 desc.idProduct != USB_STLINK_NUCLEO_PID)
934 struct libusb_device_handle* handle;
936 memset(serial, 0, sizeof(serial));
938 ret = libusb_open(dev, &handle);
940 WLOG("failed to get libusb device descriptor\n");
944 ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)&serial, sizeof(serial));
948 libusb_close(handle);
951 sl = stlink_open_usb(0, 1, serial);
959 /* Something went wrong */
970 size_t stlink_probe_usb(stlink_t **stdevs[]) {
971 libusb_device **devs;
978 r = libusb_init(NULL);
982 cnt = libusb_get_device_list(NULL, &devs);
986 slcnt = stlink_probe_usb_devs(devs, &sldevs);
987 libusb_free_device_list(devs, 1);
995 void stlink_probe_usb_free(stlink_t ***stdevs, size_t size) {
996 if (stdevs == NULL || *stdevs == NULL || size == 0)
999 for (size_t n = 0; n < size; n++)
1000 stlink_close((*stdevs)[n]);