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 /* @TODO: Reading a environment variable in a usb open function is not very nice, this
747 should be refactored and moved into the CLI tools, and instead of giving USB_BUS:USB_ADDR a real stlink
748 serial string should be passed to this function. Probably people are using this but this is very odd because
749 as programmer can change to multiple busses and it is better to detect them based on serial. */
750 char *device = getenv("STLINK_DEVICE");
752 char *c = strchr(device,':');
754 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
760 ILOG("bus %03d dev %03d\n",devBus, devAddr);
764 libusb_get_device_descriptor( list[cnt], &desc );
765 if (desc.idVendor != USB_ST_VID)
768 if (devBus && devAddr) {
769 if ((libusb_get_bus_number(list[cnt]) != devBus)
770 || (libusb_get_device_address(list[cnt]) != devAddr)) {
775 if ((desc.idProduct == USB_STLINK_32L_PID) || (desc.idProduct == USB_STLINK_NUCLEO_PID)) {
776 struct libusb_device_handle *handle;
778 libusb_open(list[cnt], &handle);
779 sl->serial_size = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber,
780 (unsigned char *)sl->serial, sizeof(sl->serial));
781 libusb_close(handle);
783 if ((serial == NULL) || (*serial == 0))
786 if (sl->serial_size < 0)
789 if (memcmp(serial, &sl->serial, sl->serial_size) == 0)
795 if (desc.idProduct == USB_STLINK_PID) {
802 WLOG ("Couldn't find %s ST-Link/V2 devices\n",(devBus && devAddr)?"matched":"any");
805 ret = libusb_open(list[cnt], &slu->usb_handle);
807 WLOG("Error %d (%s) opening ST-Link/V2 device %03d:%03d\n",
808 ret, strerror (errno), libusb_get_bus_number(list[cnt]), libusb_get_device_address(list[cnt]));
813 libusb_free_device_list(list, 1);
815 if (libusb_kernel_driver_active(slu->usb_handle, 0) == 1) {
816 ret = libusb_detach_kernel_driver(slu->usb_handle, 0);
818 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-ret));
819 goto on_libusb_error;
823 if (libusb_get_configuration(slu->usb_handle, &config)) {
824 /* this may fail for a previous configured device */
825 WLOG("libusb_get_configuration()\n");
826 goto on_libusb_error;
830 printf("setting new configuration (%d -> 1)\n", config);
831 if (libusb_set_configuration(slu->usb_handle, 1)) {
832 /* this may fail for a previous configured device */
833 WLOG("libusb_set_configuration() failed\n");
834 goto on_libusb_error;
838 if (libusb_claim_interface(slu->usb_handle, 0)) {
839 WLOG("libusb_claim_interface() failed\n");
840 goto on_libusb_error;
843 // TODO - could use the scanning techniq from stm8 code here...
844 slu->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
845 if (desc.idProduct == USB_STLINK_NUCLEO_PID) {
846 slu->ep_req = 1 /* ep req */ | LIBUSB_ENDPOINT_OUT;
848 slu->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
851 slu->sg_transfer_idx = 0;
852 // TODO - never used at the moment, always CMD_SIZE
853 slu->cmd_len = (slu->protocoll == 1)? STLINK_SG_SIZE: STLINK_CMD_SIZE;
855 if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
856 ILOG("-- exit_dfu_mode\n");
857 stlink_exit_dfu_mode(sl);
860 if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
861 stlink_enter_swd_mode(sl);
870 ret = stlink_load_device_params(sl);
882 libusb_exit(slu->libusb_ctx);
893 static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[]) {
902 while ((dev = devs[i++]) != NULL) {
903 struct libusb_device_descriptor desc;
904 int r = libusb_get_device_descriptor(dev, &desc);
906 WLOG("failed to get libusb device descriptor\n");
910 if (desc.idProduct != USB_STLINK_32L_PID &&
911 desc.idProduct != USB_STLINK_NUCLEO_PID)
917 /* Allocate list of pointers */
918 _sldevs = calloc(slcnt, sizeof(stlink_t *));
924 /* Open stlinks and attach to list */
926 while ((dev = devs[i++]) != NULL) {
927 struct libusb_device_descriptor desc;
928 ret = libusb_get_device_descriptor(dev, &desc);
930 WLOG("failed to get libusb device descriptor\n");
934 if (desc.idProduct != USB_STLINK_32L_PID &&
935 desc.idProduct != USB_STLINK_NUCLEO_PID)
938 struct libusb_device_handle* handle;
940 memset(serial, 0, sizeof(serial));
942 ret = libusb_open(dev, &handle);
944 WLOG("failed to get libusb device descriptor\n");
948 ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)&serial, sizeof(serial));
952 libusb_close(handle);
955 sl = stlink_open_usb(0, 1, serial);
963 /* Something went wrong */
974 size_t stlink_probe_usb(stlink_t **stdevs[]) {
975 libusb_device **devs;
982 r = libusb_init(NULL);
986 cnt = libusb_get_device_list(NULL, &devs);
990 slcnt = stlink_probe_usb_devs(devs, &sldevs);
991 libusb_free_device_list(devs, 1);
999 void stlink_probe_usb_free(stlink_t ***stdevs, size_t size) {
1000 if (stdevs == NULL || *stdevs == NULL || size == 0)
1003 for (size_t n = 0; n < size; n++)
1004 stlink_close((*stdevs)[n]);