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 = calloc(1, sizeof (stlink_t));
722 slu = calloc(1, sizeof (struct stlink_libusb));
723 if (sl == NULL) goto on_malloc_error;
724 if (slu == NULL) goto on_malloc_error;
727 sl->backend = &_stlink_usb_backend;
728 sl->backend_data = slu;
730 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
731 if (libusb_init(&(slu->libusb_ctx))) {
732 WLOG("failed to init libusb context, wrong version of libraries?\n");
736 libusb_device **list;
737 int cnt = libusb_get_device_list(slu->libusb_ctx, &list);
738 struct libusb_device_descriptor desc;
742 char *device = getenv("STLINK_DEVICE");
744 char *c = strchr(device,':');
746 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
752 ILOG("bus %03d dev %03d\n",devBus, devAddr);
755 libusb_get_device_descriptor( list[cnt], &desc );
756 if (desc.idVendor!=USB_ST_VID) continue;
757 if (devBus && devAddr)
758 if ((libusb_get_bus_number(list[cnt])!=devBus) || (libusb_get_device_address(list[cnt])!=devAddr)) continue;
759 if ( (desc.idProduct == USB_STLINK_32L_PID) || (desc.idProduct == USB_STLINK_NUCLEO_PID) ){
760 if ((p_usb_iserial != NULL)){
761 struct libusb_device_handle* handle;
762 libusb_open(list[cnt], &handle);
763 libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)sl->serial, sizeof(sl->serial));
764 libusb_close(handle);
765 if (memcmp(p_usb_iserial,&sl->serial, sizeof(sl->serial) - 1) == 0){
774 if (desc.idProduct == USB_STLINK_PID) {
781 WLOG ("Couldn't find %s ST-Link/V2 devices\n",(devBus && devAddr)?"matched":"any");
784 int error = libusb_open(list[cnt], &slu->usb_handle);
786 WLOG("Error %d (%s) opening ST-Link/V2 device %03d:%03d\n",
787 error, strerror (errno), libusb_get_bus_number(list[cnt]), libusb_get_device_address(list[cnt]));
792 libusb_free_device_list(list, 1);
795 if (libusb_kernel_driver_active(slu->usb_handle, 0) == 1) {
798 r = libusb_detach_kernel_driver(slu->usb_handle, 0);
800 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-r));
801 goto on_libusb_error;
805 if (libusb_get_configuration(slu->usb_handle, &config)) {
806 /* this may fail for a previous configured device */
807 WLOG("libusb_get_configuration()\n");
808 goto on_libusb_error;
812 printf("setting new configuration (%d -> 1)\n", config);
813 if (libusb_set_configuration(slu->usb_handle, 1)) {
814 /* this may fail for a previous configured device */
815 WLOG("libusb_set_configuration() failed\n");
816 goto on_libusb_error;
820 if (libusb_claim_interface(slu->usb_handle, 0)) {
821 WLOG("libusb_claim_interface() failed\n");
822 goto on_libusb_error;
825 // TODO - could use the scanning techniq from stm8 code here...
826 slu->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
827 if (desc.idProduct == USB_STLINK_NUCLEO_PID) {
828 slu->ep_req = 1 /* ep req */ | LIBUSB_ENDPOINT_OUT;
830 slu->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
833 slu->sg_transfer_idx = 0;
834 // TODO - never used at the moment, always CMD_SIZE
835 slu->cmd_len = (slu->protocoll == 1)? STLINK_SG_SIZE: STLINK_CMD_SIZE;
839 if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
840 ILOG("-- exit_dfu_mode\n");
841 stlink_exit_dfu_mode(sl);
844 if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
845 stlink_enter_swd_mode(sl);
853 error = stlink_load_device_params(sl);
866 libusb_exit(slu->libusb_ctx);
868 if (sl != NULL) free(sl);
869 if (slu != NULL) free(slu);
873 static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[]) {
881 while ((dev = devs[i++]) != NULL) {
882 struct libusb_device_descriptor desc;
883 int r = libusb_get_device_descriptor(dev, &desc);
885 fprintf(stderr, "failed to get device descriptor");
889 if (desc.idProduct != USB_STLINK_32L_PID &&
890 desc.idProduct != USB_STLINK_NUCLEO_PID)
896 /* Allocate list of pointers */
897 _sldevs = calloc(slcnt, sizeof(stlink_t *));
903 /* Open stlinks and attach to list */
905 while ((dev = devs[i++]) != NULL) {
906 struct libusb_device_descriptor desc;
907 int r = libusb_get_device_descriptor(dev, &desc);
909 fprintf(stderr, "failed to get device descriptor");
913 if (desc.idProduct != USB_STLINK_32L_PID &&
914 desc.idProduct != USB_STLINK_NUCLEO_PID)
917 struct libusb_device_handle* handle;
919 memset(serial, 0, sizeof(serial));
921 libusb_open(dev, &handle);
922 libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char *)&serial, sizeof(serial));
923 libusb_close(handle);
926 sl = stlink_open_usb(0, 1, serial);
938 size_t stlink_probe_usb(stlink_t **stdevs[]) {
939 libusb_device **devs;
946 r = libusb_init(NULL);
950 cnt = libusb_get_device_list(NULL, &devs);
954 slcnt = stlink_probe_usb_devs(devs, &sldevs);
955 libusb_free_device_list(devs, 1);
963 void stlink_probe_usb_free(stlink_t ***stdevs, size_t size) {
964 if (stdevs == NULL || *stdevs == NULL || size == 0)
967 for (size_t n = 0; n < size; n++)
968 stlink_close((*stdevs)[n]);