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) {
21 struct stlink_libusb * const handle = sl->backend_data;
22 // maybe we couldn't even get the usb device?
24 if (handle->usb_handle != NULL) {
25 libusb_close(handle->usb_handle);
28 libusb_exit(handle->libusb_ctx);
33 ssize_t send_recv(struct stlink_libusb* handle, int terminate,
34 unsigned char* txbuf, size_t txsize,
35 unsigned char* rxbuf, size_t rxsize) {
36 /* note: txbuf and rxbuf can point to the same area */
39 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_req,
47 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
55 if ((handle->protocoll == 1) && terminate) {
56 /* Read the SG reply */
57 unsigned char sg_buf[13];
58 if (libusb_bulk_transfer(handle->usb_handle, handle->ep_rep,
64 /* The STLink doesn't seem to evaluate the sequence number */
65 handle->sg_transfer_idx++;
71 static inline int send_only
72 (struct stlink_libusb* handle, int terminate,
73 unsigned char* txbuf, size_t txsize) {
74 return send_recv(handle, terminate, txbuf, txsize, NULL, 0);
78 static int fill_command
79 (stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
80 struct stlink_libusb * const slu = sl->backend_data;
81 unsigned char* const cmd = sl->c_buf;
83 memset(cmd, 0, sizeof (sl->c_buf));
84 if(slu->protocoll == 1) {
89 write_uint32(&cmd[i], slu->sg_transfer_idx);
90 write_uint32(&cmd[i + 4], len);
92 cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;
93 cmd[i++] = 0; /* Logical unit */
94 cmd[i++] = 0xa; /* Command length */
99 int _stlink_usb_version(stlink_t *sl) {
100 struct stlink_libusb * const slu = sl->backend_data;
101 unsigned char* const data = sl->q_buf;
102 unsigned char* const cmd = sl->c_buf;
104 uint32_t rep_len = 6;
105 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
107 cmd[i++] = STLINK_GET_VERSION;
109 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
111 printf("[!] send_recv\n");
118 int32_t _stlink_usb_target_voltage(stlink_t *sl) {
119 struct stlink_libusb * const slu = sl->backend_data;
120 unsigned char* const rdata = sl->q_buf;
121 unsigned char* const cmd = sl->c_buf;
123 uint32_t rep_len = 8;
124 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
125 uint32_t factor, reading;
128 cmd[i++] = STLINK_GET_TARGET_VOLTAGE;
130 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
132 printf("[!] send_recv\n");
134 } else if (size != 8) {
135 printf("[!] wrong length\n");
139 factor = (rdata[3] << 24) | (rdata[2] << 16) | (rdata[1] << 8) | (rdata[0] << 0);
140 reading = (rdata[7] << 24) | (rdata[6] << 16) | (rdata[5] << 8) | (rdata[4] << 0);
141 voltage = 2400 * reading / factor;
146 int _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
147 struct stlink_libusb * const slu = sl->backend_data;
148 unsigned char* const rdata = sl->q_buf;
149 unsigned char* const cmd = sl->c_buf;
151 const int rep_len = 8;
153 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
154 cmd[i++] = STLINK_DEBUG_COMMAND;
155 cmd[i++] = STLINK_JTAG_READDEBUG_32BIT;
156 write_uint32(&cmd[i], addr);
157 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
159 printf("[!] send_recv\n");
162 *data = read_uint32(rdata, 4);
166 int _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
167 struct stlink_libusb * const slu = sl->backend_data;
168 unsigned char* const rdata = sl->q_buf;
169 unsigned char* const cmd = sl->c_buf;
171 const int rep_len = 2;
173 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
174 cmd[i++] = STLINK_DEBUG_COMMAND;
175 cmd[i++] = STLINK_JTAG_WRITEDEBUG_32BIT;
176 write_uint32(&cmd[i], addr);
177 write_uint32(&cmd[i + 4], data);
178 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
180 printf("[!] send_recv\n");
187 int _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
188 struct stlink_libusb * const slu = sl->backend_data;
189 unsigned char* const data = sl->q_buf;
190 unsigned char* const cmd = sl->c_buf;
193 i = fill_command(sl, SG_DXFER_TO_DEV, len);
194 cmd[i++] = STLINK_DEBUG_COMMAND;
195 cmd[i++] = STLINK_DEBUG_WRITEMEM_32BIT;
196 write_uint32(&cmd[i], addr);
197 write_uint16(&cmd[i + 4], len);
198 ret = send_only(slu, 0, cmd, slu->cmd_len);
202 ret = send_only(slu, 1, data, len);
209 int _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
210 struct stlink_libusb * const slu = sl->backend_data;
211 unsigned char* const data = sl->q_buf;
212 unsigned char* const cmd = sl->c_buf;
215 i = fill_command(sl, SG_DXFER_TO_DEV, 0);
216 cmd[i++] = STLINK_DEBUG_COMMAND;
217 cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;
218 write_uint32(&cmd[i], addr);
219 write_uint16(&cmd[i + 4], len);
220 ret = send_only(slu, 0, cmd, slu->cmd_len);
224 ret = send_only(slu, 1, data, len);
232 int _stlink_usb_current_mode(stlink_t * sl) {
233 struct stlink_libusb * const slu = sl->backend_data;
234 unsigned char* const cmd = sl->c_buf;
235 unsigned char* const data = sl->q_buf;
238 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
240 cmd[i++] = STLINK_GET_CURRENT_MODE;
241 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
243 printf("[!] send_recv\n");
249 int _stlink_usb_core_id(stlink_t * sl) {
250 struct stlink_libusb * const slu = sl->backend_data;
251 unsigned char* const cmd = sl->c_buf;
252 unsigned char* const data = sl->q_buf;
255 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
257 cmd[i++] = STLINK_DEBUG_COMMAND;
258 cmd[i++] = STLINK_DEBUG_READCOREID;
260 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
262 printf("[!] send_recv\n");
266 sl->core_id = read_uint32(data, 0);
270 int _stlink_usb_status(stlink_t * sl) {
271 struct stlink_libusb * const slu = sl->backend_data;
272 unsigned char* const data = sl->q_buf;
273 unsigned char* const cmd = sl->c_buf;
276 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
278 cmd[i++] = STLINK_DEBUG_COMMAND;
279 cmd[i++] = STLINK_DEBUG_GETSTATUS;
281 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
283 printf("[!] send_recv\n");
286 sl->q_len = (size_t) size;
291 int _stlink_usb_force_debug(stlink_t *sl) {
292 struct stlink_libusb *slu = sl->backend_data;
293 unsigned char* const data = sl->q_buf;
294 unsigned char* const cmd = sl->c_buf;
297 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
299 cmd[i++] = STLINK_DEBUG_COMMAND;
300 cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
301 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
303 printf("[!] send_recv\n");
310 int _stlink_usb_enter_swd_mode(stlink_t * sl) {
311 struct stlink_libusb * const slu = sl->backend_data;
312 unsigned char* const cmd = sl->c_buf;
314 const int rep_len = 0;
315 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
317 cmd[i++] = STLINK_DEBUG_COMMAND;
318 cmd[i++] = STLINK_DEBUG_ENTER;
319 cmd[i++] = STLINK_DEBUG_ENTER_SWD;
321 size = send_only(slu, 1, cmd, slu->cmd_len);
323 printf("[!] send_recv\n");
330 int _stlink_usb_exit_dfu_mode(stlink_t* sl) {
331 struct stlink_libusb * const slu = sl->backend_data;
332 unsigned char* const cmd = sl->c_buf;
334 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
336 cmd[i++] = STLINK_DFU_COMMAND;
337 cmd[i++] = STLINK_DFU_EXIT;
339 size = send_only(slu, 1, cmd, slu->cmd_len);
341 printf("[!] send_recv\n");
349 * TODO - not convinced this does anything...
352 int _stlink_usb_reset(stlink_t * sl) {
353 struct stlink_libusb * const slu = sl->backend_data;
354 unsigned char* const data = sl->q_buf;
355 unsigned char* const cmd = sl->c_buf;
358 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
360 cmd[i++] = STLINK_DEBUG_COMMAND;
361 cmd[i++] = STLINK_DEBUG_RESETSYS;
363 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
365 printf("[!] send_recv\n");
373 int _stlink_usb_jtag_reset(stlink_t * sl, int value) {
374 struct stlink_libusb * const slu = sl->backend_data;
375 unsigned char* const data = sl->q_buf;
376 unsigned char* const cmd = sl->c_buf;
379 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
381 cmd[i++] = STLINK_DEBUG_COMMAND;
382 cmd[i++] = STLINK_JTAG_DRIVE_NRST;
385 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
387 printf("[!] send_recv\n");
395 int _stlink_usb_step(stlink_t* sl) {
396 struct stlink_libusb * const slu = sl->backend_data;
397 unsigned char* const data = sl->q_buf;
398 unsigned char* const cmd = sl->c_buf;
401 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
403 cmd[i++] = STLINK_DEBUG_COMMAND;
404 cmd[i++] = STLINK_DEBUG_STEPCORE;
406 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
408 printf("[!] send_recv\n");
416 * This seems to do a good job of restarting things from the beginning?
419 int _stlink_usb_run(stlink_t* sl) {
420 struct stlink_libusb * const slu = sl->backend_data;
421 unsigned char* const data = sl->q_buf;
422 unsigned char* const cmd = sl->c_buf;
425 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
427 cmd[i++] = STLINK_DEBUG_COMMAND;
428 cmd[i++] = STLINK_DEBUG_RUNCORE;
430 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
432 printf("[!] send_recv\n");
439 int _stlink_usb_exit_debug_mode(stlink_t *sl) {
440 struct stlink_libusb * const slu = sl->backend_data;
441 unsigned char* const cmd = sl->c_buf;
443 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
445 cmd[i++] = STLINK_DEBUG_COMMAND;
446 cmd[i++] = STLINK_DEBUG_EXIT;
448 size = send_only(slu, 1, cmd, slu->cmd_len);
450 printf("[!] send_only\n");
457 int _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
458 struct stlink_libusb * const slu = sl->backend_data;
459 unsigned char* const data = sl->q_buf;
460 unsigned char* const cmd = sl->c_buf;
462 int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
464 cmd[i++] = STLINK_DEBUG_COMMAND;
465 cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
466 write_uint32(&cmd[i], addr);
467 write_uint16(&cmd[i + 4], len);
469 size = send_recv(slu, 1, cmd, slu->cmd_len, data, len);
471 printf("[!] send_recv\n");
475 sl->q_len = (size_t) size;
477 stlink_print_data(sl);
481 int _stlink_usb_read_all_regs(stlink_t *sl, reg *regp) {
482 struct stlink_libusb * const slu = sl->backend_data;
483 unsigned char* const cmd = sl->c_buf;
484 unsigned char* const data = sl->q_buf;
486 uint32_t rep_len = 84;
487 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
489 cmd[i++] = STLINK_DEBUG_COMMAND;
490 cmd[i++] = STLINK_DEBUG_READALLREGS;
491 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
493 printf("[!] send_recv\n");
496 sl->q_len = (size_t) size;
497 stlink_print_data(sl);
499 regp->r[i]= read_uint32(sl->q_buf, i*4);
500 regp->xpsr = read_uint32(sl->q_buf, 64);
501 regp->main_sp = read_uint32(sl->q_buf, 68);
502 regp->process_sp = read_uint32(sl->q_buf, 72);
503 regp->rw = read_uint32(sl->q_buf, 76);
504 regp->rw2 = read_uint32(sl->q_buf, 80);
508 DLOG("xpsr = 0x%08x\n", read_uint32(sl->q_buf, 64));
509 DLOG("main_sp = 0x%08x\n", read_uint32(sl->q_buf, 68));
510 DLOG("process_sp = 0x%08x\n", read_uint32(sl->q_buf, 72));
511 DLOG("rw = 0x%08x\n", read_uint32(sl->q_buf, 76));
512 DLOG("rw2 = 0x%08x\n", read_uint32(sl->q_buf, 80));
517 int _stlink_usb_read_reg(stlink_t *sl, int r_idx, reg *regp) {
518 struct stlink_libusb * const slu = sl->backend_data;
519 unsigned char* const data = sl->q_buf;
520 unsigned char* const cmd = sl->c_buf;
523 uint32_t rep_len = 4;
524 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
526 cmd[i++] = STLINK_DEBUG_COMMAND;
527 cmd[i++] = STLINK_DEBUG_READREG;
528 cmd[i++] = (uint8_t) r_idx;
529 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
531 printf("[!] send_recv\n");
534 sl->q_len = (size_t) size;
535 stlink_print_data(sl);
536 r = read_uint32(sl->q_buf, 0);
537 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
547 regp->process_sp = r;
550 regp->rw = r; /* XXX ?(primask, basemask etc.) */
553 regp->rw2 = r; /* XXX ?(primask, basemask etc.) */
562 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
563 int _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, reg *regp) {
567 sl->q_buf[0] = (unsigned char) r_idx;
568 for (int i = 1; i < 4; i++) {
572 ret = _stlink_usb_write_mem32(sl, DCRSR, 4);
576 _stlink_usb_read_mem32(sl, DCRDR, 4);
580 r = read_uint32(sl->q_buf, 0);
581 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
585 regp->primask = (uint8_t) (r & 0xFF);
586 regp->basepri = (uint8_t) ((r>>8) & 0xFF);
587 regp->faultmask = (uint8_t) ((r>>16) & 0xFF);
588 regp->control = (uint8_t) ((r>>24) & 0xFF);
594 regp->s[r_idx - 0x40] = r;
601 int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, reg *regp) {
604 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
608 ret = _stlink_usb_read_unsupported_reg(sl, 0x21, regp);
612 for (int i = 0; i < 32; i++) {
613 ret = _stlink_usb_read_unsupported_reg(sl, 0x40+i, regp);
621 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
622 int _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, reg *regp) {
625 if (r_idx >= 0x1C && r_idx <= 0x1F) { /* primask, basepri, faultmask, or control */
626 /* These are held in the same register */
627 ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
631 val = (uint8_t) (val>>24);
634 case 0x1C: /* control */
635 val = (((uint32_t) val) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
637 case 0x1D: /* faultmask */
638 val = (((uint32_t) regp->control) << 24) | (((uint32_t) val) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
640 case 0x1E: /* basepri */
641 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) val) << 8) | ((uint32_t) regp->primask);
643 case 0x1F: /* primask */
644 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) val);
651 write_uint32(sl->q_buf, val);
653 ret = _stlink_usb_write_mem32(sl, DCRDR, 4);
657 sl->q_buf[0] = (unsigned char) r_idx;
662 return _stlink_usb_write_mem32(sl, DCRSR, 4);
665 int _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
666 struct stlink_libusb * const slu = sl->backend_data;
667 unsigned char* const data = sl->q_buf;
668 unsigned char* const cmd = sl->c_buf;
670 uint32_t rep_len = 2;
671 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
673 cmd[i++] = STLINK_DEBUG_COMMAND;
674 cmd[i++] = STLINK_DEBUG_WRITEREG;
676 write_uint32(&cmd[i], reg);
677 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
679 printf("[!] send_recv\n");
682 sl->q_len = (size_t) size;
683 stlink_print_data(sl);
688 stlink_backend_t _stlink_usb_backend = {
690 _stlink_usb_exit_debug_mode,
691 _stlink_usb_enter_swd_mode,
692 NULL, // no enter_jtag_mode here...
693 _stlink_usb_exit_dfu_mode,
696 _stlink_usb_jtag_reset,
700 _stlink_usb_read_debug32,
701 _stlink_usb_read_mem32,
702 _stlink_usb_write_debug32,
703 _stlink_usb_write_mem32,
704 _stlink_usb_write_mem8,
705 _stlink_usb_read_all_regs,
706 _stlink_usb_read_reg,
707 _stlink_usb_read_all_unsupported_regs,
708 _stlink_usb_read_unsupported_reg,
709 _stlink_usb_write_unsupported_reg,
710 _stlink_usb_write_reg,
712 _stlink_usb_current_mode,
713 _stlink_usb_force_debug,
714 _stlink_usb_target_voltage
718 stlink_t* stlink_open_usb(const int verbose, int reset, char *p_usb_iserial) {
720 struct stlink_libusb* slu = NULL;
724 sl = calloc(1, sizeof (stlink_t));
725 slu = calloc(1, sizeof (struct stlink_libusb));
726 if (sl == NULL) goto on_malloc_error;
727 if (slu == NULL) goto on_malloc_error;
730 sl->backend = &_stlink_usb_backend;
731 sl->backend_data = slu;
733 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
734 if (libusb_init(&(slu->libusb_ctx))) {
735 WLOG("failed to init libusb context, wrong version of libraries?\n");
739 libusb_device **list;
740 int cnt = libusb_get_device_list(slu->libusb_ctx, &list);
741 struct libusb_device_descriptor desc;
745 char *device = getenv("STLINK_DEVICE");
747 char *c = strchr(device,':');
749 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
755 ILOG("bus %03d dev %03d\n",devBus, devAddr);
758 libusb_get_device_descriptor( list[cnt], &desc );
759 if (desc.idVendor!=USB_ST_VID) continue;
760 if (devBus && devAddr)
761 if ((libusb_get_bus_number(list[cnt])!=devBus) || (libusb_get_device_address(list[cnt])!=devAddr)) continue;
762 if ( (desc.idProduct == USB_STLINK_32L_PID) || (desc.idProduct == USB_STLINK_NUCLEO_PID) ){
763 if ((p_usb_iserial != NULL)){
764 struct libusb_device_handle* handle;
765 libusb_open(list[cnt], &handle);
766 libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)sl->serial, sizeof(sl->serial));
767 libusb_close(handle);
768 if (memcmp(p_usb_iserial,&sl->serial, sizeof(sl->serial) - 1) == 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);
871 if (sl != NULL) free(sl);
872 if (slu != NULL) free(slu);
876 static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[]) {
885 while ((dev = devs[i++]) != NULL) {
886 struct libusb_device_descriptor desc;
887 int r = libusb_get_device_descriptor(dev, &desc);
889 WLOG("failed to get libusb device descriptor\n");
893 if (desc.idProduct != USB_STLINK_32L_PID &&
894 desc.idProduct != USB_STLINK_NUCLEO_PID)
900 /* Allocate list of pointers */
901 _sldevs = calloc(slcnt, sizeof(stlink_t *));
907 /* Open stlinks and attach to list */
909 while ((dev = devs[i++]) != NULL) {
910 struct libusb_device_descriptor desc;
911 ret = libusb_get_device_descriptor(dev, &desc);
913 WLOG("failed to get libusb device descriptor\n");
917 if (desc.idProduct != USB_STLINK_32L_PID &&
918 desc.idProduct != USB_STLINK_NUCLEO_PID)
921 struct libusb_device_handle* handle;
923 memset(serial, 0, sizeof(serial));
925 ret = libusb_open(dev, &handle);
927 WLOG("failed to get libusb device descriptor\n");
930 libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)&serial, sizeof(serial));
931 libusb_close(handle);
934 sl = stlink_open_usb(0, 1, serial);
942 /* Something went wrong */
953 size_t stlink_probe_usb(stlink_t **stdevs[]) {
954 libusb_device **devs;
961 r = libusb_init(NULL);
965 cnt = libusb_get_device_list(NULL, &devs);
969 slcnt = stlink_probe_usb_devs(devs, &sldevs);
970 libusb_free_device_list(devs, 1);
978 void stlink_probe_usb_free(stlink_t ***stdevs, size_t size) {
979 if (stdevs == NULL || *stdevs == NULL || size == 0)
982 for (size_t n = 0; n < size; n++)
983 stlink_close((*stdevs)[n]);