9 #include "stlink-common.h"
10 #include "stlink-usb.h"
11 #include "uglylogging.h"
13 #define LOG_TAG __FILE__
14 #define DLOG(format, args...) ugly_log(UDEBUG, LOG_TAG, format, ## args)
15 #define ILOG(format, args...) ugly_log(UINFO, LOG_TAG, format, ## args)
16 #define WLOG(format, args...) ugly_log(UWARN, LOG_TAG, format, ## args)
17 #define fatal(format, args...) ugly_log(UFATAL, LOG_TAG, format, ## args)
19 /* code from bsd timersub.h
20 http://www.gnu-darwin.org/www001/src/ports/net/libevnet/work/libevnet-0.3.8/libnostd/bsd/sys/time/timersub.h.html
23 #define timersub(a, b, r) do { \
24 (r)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
25 (r)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
26 if ((r)->tv_usec < 0) { \
28 (r)->tv_usec += 1000000; \
33 enum SCSI_Generic_Direction {SG_DXFER_TO_DEV=0, SG_DXFER_FROM_DEV=0x80};
35 void _stlink_usb_close(stlink_t* sl) {
36 struct stlink_libusb * const handle = sl->backend_data;
37 // maybe we couldn't even get the usb device?
39 if (handle->req_trans != NULL)
40 libusb_free_transfer(handle->req_trans);
42 if (handle->rep_trans != NULL)
43 libusb_free_transfer(handle->rep_trans);
45 if (handle->usb_handle != NULL) {
46 libusb_close(handle->usb_handle);
49 libusb_exit(handle->libusb_ctx);
56 #define TRANS_FLAGS_IS_DONE (1 << 0)
57 #define TRANS_FLAGS_HAS_ERROR (1 << 1)
58 volatile unsigned long flags;
65 static void LIBUSB_CALL on_trans_done(struct libusb_transfer * trans) {
66 struct trans_ctx * const ctx = trans->user_data;
68 if (trans->status != LIBUSB_TRANSFER_COMPLETED)
69 ctx->flags |= TRANS_FLAGS_HAS_ERROR;
71 ctx->flags |= TRANS_FLAGS_IS_DONE;
74 int submit_wait(struct stlink_libusb *slu, struct libusb_transfer * trans) {
78 struct trans_ctx trans_ctx;
79 enum libusb_error error;
83 /* brief intrusion inside the libusb interface */
84 trans->callback = on_trans_done;
85 trans->user_data = &trans_ctx;
87 if ((error = libusb_submit_transfer(trans))) {
88 printf("libusb_submit_transfer(%d)\n", error);
92 gettimeofday(&start, NULL);
94 while (trans_ctx.flags == 0) {
95 struct timeval timeout;
98 if (libusb_handle_events_timeout(slu->libusb_ctx, &timeout)) {
99 printf("libusb_handle_events()\n");
103 gettimeofday(&now, NULL);
104 timersub(&now, &start, &diff);
105 if (diff.tv_sec >= 3) {
106 printf("libusb_handle_events() timeout\n");
111 if (trans_ctx.flags & TRANS_FLAGS_HAS_ERROR) {
112 printf("libusb_handle_events() | has_error\n");
119 ssize_t send_recv(struct stlink_libusb* handle, int terminate,
120 unsigned char* txbuf, size_t txsize,
121 unsigned char* rxbuf, size_t rxsize) {
122 /* note: txbuf and rxbuf can point to the same area */
125 libusb_fill_bulk_transfer(handle->req_trans, handle->usb_handle,
132 if (submit_wait(handle, handle->req_trans)) return -1;
137 /* read the response */
139 libusb_fill_bulk_transfer(handle->rep_trans, handle->usb_handle,
140 handle->ep_rep, rxbuf, rxsize, NULL, NULL, 0);
142 if (submit_wait(handle, handle->rep_trans)) return -1;
143 res = handle->rep_trans->actual_length;
146 if ((handle->protocoll == 1) && terminate) {
147 /* Read the SG reply */
148 unsigned char sg_buf[13];
149 libusb_fill_bulk_transfer
150 (handle->rep_trans, handle->usb_handle,
151 handle->ep_rep, sg_buf, 13, NULL, NULL, 0);
152 res = submit_wait(handle, handle->rep_trans);
153 /* The STLink doesn't seem to evaluate the sequence number */
154 handle->sg_transfer_idx++;
158 return handle->rep_trans->actual_length;
161 static inline int send_only
162 (struct stlink_libusb* handle, int terminate,
163 unsigned char* txbuf, size_t txsize) {
164 return send_recv(handle, terminate, txbuf, txsize, NULL, 0);
168 static int fill_command
169 (stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
170 struct stlink_libusb * const slu = sl->backend_data;
171 unsigned char* const cmd = sl->c_buf;
173 memset(cmd, 0, sizeof (sl->c_buf));
174 if(slu->protocoll == 1) {
179 write_uint32(&cmd[i], slu->sg_transfer_idx);
180 write_uint32(&cmd[i + 4], len);
182 cmd[i++] = (dir == SG_DXFER_FROM_DEV)?0x80:0;
183 cmd[i++] = 0; /* Logical unit */
184 cmd[i++] = 0xa; /* Command length */
189 void _stlink_usb_version(stlink_t *sl) {
190 struct stlink_libusb * const slu = sl->backend_data;
191 unsigned char* const data = sl->q_buf;
192 unsigned char* const cmd = sl->c_buf;
194 uint32_t rep_len = 6;
195 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
197 cmd[i++] = STLINK_GET_VERSION;
199 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
201 printf("[!] send_recv\n");
206 int32_t _stlink_usb_target_voltage(stlink_t *sl) {
207 struct stlink_libusb * const slu = sl->backend_data;
208 unsigned char* const rdata = sl->q_buf;
209 unsigned char* const cmd = sl->c_buf;
211 uint32_t rep_len = 8;
212 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
213 uint32_t factor, reading;
216 cmd[i++] = STLINK_GET_TARGET_VOLTAGE;
218 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
220 printf("[!] send_recv\n");
222 } else if (size != 8) {
223 printf("[!] wrong length\n");
227 factor = (rdata[3] << 24) | (rdata[2] << 16) | (rdata[1] << 8) | (rdata[0] << 0);
228 reading = (rdata[7] << 24) | (rdata[6] << 16) | (rdata[5] << 8) | (rdata[4] << 0);
229 voltage = 2400 * reading / factor;
234 uint32_t _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr) {
235 struct stlink_libusb * const slu = sl->backend_data;
236 unsigned char* const rdata = sl->q_buf;
237 unsigned char* const cmd = sl->c_buf;
239 const int rep_len = 8;
241 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
242 cmd[i++] = STLINK_DEBUG_COMMAND;
243 cmd[i++] = STLINK_JTAG_READDEBUG_32BIT;
244 write_uint32(&cmd[i], addr);
245 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
247 printf("[!] send_recv\n");
250 return read_uint32(rdata, 4);
253 void _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
254 struct stlink_libusb * const slu = sl->backend_data;
255 unsigned char* const rdata = sl->q_buf;
256 unsigned char* const cmd = sl->c_buf;
258 const int rep_len = 2;
260 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
261 cmd[i++] = STLINK_DEBUG_COMMAND;
262 cmd[i++] = STLINK_JTAG_WRITEDEBUG_32BIT;
263 write_uint32(&cmd[i], addr);
264 write_uint32(&cmd[i + 4], data);
265 size = send_recv(slu, 1, cmd, slu->cmd_len, rdata, rep_len);
267 printf("[!] send_recv\n");
272 void _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
273 struct stlink_libusb * const slu = sl->backend_data;
274 unsigned char* const data = sl->q_buf;
275 unsigned char* const cmd = sl->c_buf;
277 int i = fill_command(sl, SG_DXFER_TO_DEV, len);
278 cmd[i++] = STLINK_DEBUG_COMMAND;
279 cmd[i++] = STLINK_DEBUG_WRITEMEM_32BIT;
280 write_uint32(&cmd[i], addr);
281 write_uint16(&cmd[i + 4], len);
282 send_only(slu, 0, cmd, slu->cmd_len);
284 send_only(slu, 1, data, len);
287 void _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
288 struct stlink_libusb * const slu = sl->backend_data;
289 unsigned char* const data = sl->q_buf;
290 unsigned char* const cmd = sl->c_buf;
292 int i = fill_command(sl, SG_DXFER_TO_DEV, 0);
293 cmd[i++] = STLINK_DEBUG_COMMAND;
294 cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;
295 write_uint32(&cmd[i], addr);
296 write_uint16(&cmd[i + 4], len);
297 send_only(slu, 0, cmd, slu->cmd_len);
298 send_only(slu, 1, data, len);
302 int _stlink_usb_current_mode(stlink_t * sl) {
303 struct stlink_libusb * const slu = sl->backend_data;
304 unsigned char* const cmd = sl->c_buf;
305 unsigned char* const data = sl->q_buf;
308 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
310 cmd[i++] = STLINK_GET_CURRENT_MODE;
311 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
313 printf("[!] send_recv\n");
319 void _stlink_usb_core_id(stlink_t * sl) {
320 struct stlink_libusb * const slu = sl->backend_data;
321 unsigned char* const cmd = sl->c_buf;
322 unsigned char* const data = sl->q_buf;
325 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
327 cmd[i++] = STLINK_DEBUG_COMMAND;
328 cmd[i++] = STLINK_DEBUG_READCOREID;
330 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
332 printf("[!] send_recv\n");
336 sl->core_id = read_uint32(data, 0);
339 void _stlink_usb_status(stlink_t * sl) {
340 struct stlink_libusb * const slu = sl->backend_data;
341 unsigned char* const data = sl->q_buf;
342 unsigned char* const cmd = sl->c_buf;
345 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
347 cmd[i++] = STLINK_DEBUG_COMMAND;
348 cmd[i++] = STLINK_DEBUG_GETSTATUS;
350 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
352 printf("[!] send_recv\n");
357 void _stlink_usb_force_debug(stlink_t *sl) {
358 struct stlink_libusb *slu = sl->backend_data;
359 unsigned char* const data = sl->q_buf;
360 unsigned char* const cmd = sl->c_buf;
363 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
365 cmd[i++] = STLINK_DEBUG_COMMAND;
366 cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
367 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
369 printf("[!] send_recv\n");
374 void _stlink_usb_enter_swd_mode(stlink_t * sl) {
375 struct stlink_libusb * const slu = sl->backend_data;
376 unsigned char* const cmd = sl->c_buf;
378 const int rep_len = 0;
379 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
381 cmd[i++] = STLINK_DEBUG_COMMAND;
382 cmd[i++] = STLINK_DEBUG_ENTER;
383 cmd[i++] = STLINK_DEBUG_ENTER_SWD;
385 size = send_only(slu, 1, cmd, slu->cmd_len);
387 printf("[!] send_recv\n");
392 void _stlink_usb_exit_dfu_mode(stlink_t* sl) {
393 struct stlink_libusb * const slu = sl->backend_data;
394 unsigned char* const cmd = sl->c_buf;
396 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
398 cmd[i++] = STLINK_DFU_COMMAND;
399 cmd[i++] = STLINK_DFU_EXIT;
401 size = send_only(slu, 1, cmd, slu->cmd_len);
403 printf("[!] send_recv\n");
409 * TODO - not convinced this does anything...
412 void _stlink_usb_reset(stlink_t * sl) {
413 struct stlink_libusb * const slu = sl->backend_data;
414 unsigned char* const data = sl->q_buf;
415 unsigned char* const cmd = sl->c_buf;
418 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
420 cmd[i++] = STLINK_DEBUG_COMMAND;
421 cmd[i++] = STLINK_DEBUG_RESETSYS;
423 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
425 printf("[!] send_recv\n");
431 void _stlink_usb_jtag_reset(stlink_t * sl, int value) {
432 struct stlink_libusb * const slu = sl->backend_data;
433 unsigned char* const data = sl->q_buf;
434 unsigned char* const cmd = sl->c_buf;
437 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
439 cmd[i++] = STLINK_DEBUG_COMMAND;
440 cmd[i++] = STLINK_JTAG_DRIVE_NRST;
441 cmd[i++] = (value)?0:1;
443 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
445 printf("[!] send_recv\n");
451 void _stlink_usb_step(stlink_t* sl) {
452 struct stlink_libusb * const slu = sl->backend_data;
453 unsigned char* const data = sl->q_buf;
454 unsigned char* const cmd = sl->c_buf;
457 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
459 cmd[i++] = STLINK_DEBUG_COMMAND;
460 cmd[i++] = STLINK_DEBUG_STEPCORE;
462 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
464 printf("[!] send_recv\n");
470 * This seems to do a good job of restarting things from the beginning?
473 void _stlink_usb_run(stlink_t* sl) {
474 struct stlink_libusb * const slu = sl->backend_data;
475 unsigned char* const data = sl->q_buf;
476 unsigned char* const cmd = sl->c_buf;
479 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
481 cmd[i++] = STLINK_DEBUG_COMMAND;
482 cmd[i++] = STLINK_DEBUG_RUNCORE;
484 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
486 printf("[!] send_recv\n");
491 void _stlink_usb_exit_debug_mode(stlink_t *sl) {
492 struct stlink_libusb * const slu = sl->backend_data;
493 unsigned char* const cmd = sl->c_buf;
495 int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
497 cmd[i++] = STLINK_DEBUG_COMMAND;
498 cmd[i++] = STLINK_DEBUG_EXIT;
500 size = send_only(slu, 1, cmd, slu->cmd_len);
502 printf("[!] send_only\n");
507 void _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
508 struct stlink_libusb * const slu = sl->backend_data;
509 unsigned char* const data = sl->q_buf;
510 unsigned char* const cmd = sl->c_buf;
512 int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
514 cmd[i++] = STLINK_DEBUG_COMMAND;
515 cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
516 write_uint32(&cmd[i], addr);
517 write_uint16(&cmd[i + 4], len);
519 size = send_recv(slu, 1, cmd, slu->cmd_len, data, len);
521 printf("[!] send_recv\n");
525 sl->q_len = (size_t) size;
527 stlink_print_data(sl);
530 void _stlink_usb_read_all_regs(stlink_t *sl, reg *regp) {
531 struct stlink_libusb * const slu = sl->backend_data;
532 unsigned char* const cmd = sl->c_buf;
533 unsigned char* const data = sl->q_buf;
535 uint32_t rep_len = 84;
536 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
538 cmd[i++] = STLINK_DEBUG_COMMAND;
539 cmd[i++] = STLINK_DEBUG_READALLREGS;
540 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
542 printf("[!] send_recv\n");
545 sl->q_len = (size_t) size;
546 stlink_print_data(sl);
548 regp->r[i]= read_uint32(sl->q_buf, i*4);
549 regp->xpsr = read_uint32(sl->q_buf, 64);
550 regp->main_sp = read_uint32(sl->q_buf, 68);
551 regp->process_sp = read_uint32(sl->q_buf, 72);
552 regp->rw = read_uint32(sl->q_buf, 76);
553 regp->rw2 = read_uint32(sl->q_buf, 80);
557 DLOG("xpsr = 0x%08x\n", read_uint32(sl->q_buf, 64));
558 DLOG("main_sp = 0x%08x\n", read_uint32(sl->q_buf, 68));
559 DLOG("process_sp = 0x%08x\n", read_uint32(sl->q_buf, 72));
560 DLOG("rw = 0x%08x\n", read_uint32(sl->q_buf, 76));
561 DLOG("rw2 = 0x%08x\n", read_uint32(sl->q_buf, 80));
564 void _stlink_usb_read_reg(stlink_t *sl, int r_idx, reg *regp) {
565 struct stlink_libusb * const slu = sl->backend_data;
566 unsigned char* const data = sl->q_buf;
567 unsigned char* const cmd = sl->c_buf;
570 uint32_t rep_len = 4;
571 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
573 cmd[i++] = STLINK_DEBUG_COMMAND;
574 cmd[i++] = STLINK_DEBUG_READREG;
575 cmd[i++] = (uint8_t) r_idx;
576 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
578 printf("[!] send_recv\n");
581 sl->q_len = (size_t) size;
582 stlink_print_data(sl);
583 r = read_uint32(sl->q_buf, 0);
584 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
594 regp->process_sp = r;
597 regp->rw = r; /* XXX ?(primask, basemask etc.) */
600 regp->rw2 = r; /* XXX ?(primask, basemask etc.) */
607 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
608 void _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, reg *regp) {
611 sl->q_buf[0] = (unsigned char) r_idx;
612 for (int i = 1; i < 4; i++) {
616 _stlink_usb_write_mem32(sl, DCRSR, 4);
617 _stlink_usb_read_mem32(sl, DCRDR, 4);
619 r = read_uint32(sl->q_buf, 0);
620 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
624 regp->primask = (uint8_t) (r & 0xFF);
625 regp->basepri = (uint8_t) ((r>>8) & 0xFF);
626 regp->faultmask = (uint8_t) ((r>>16) & 0xFF);
627 regp->control = (uint8_t) ((r>>24) & 0xFF);
633 regp->s[r_idx - 0x40] = r;
638 void _stlink_usb_read_all_unsupported_regs(stlink_t *sl, reg *regp) {
639 _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
640 _stlink_usb_read_unsupported_reg(sl, 0x21, regp);
642 for (int i = 0; i < 32; i++) {
643 _stlink_usb_read_unsupported_reg(sl, 0x40+i, regp);
647 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
648 void _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, reg *regp) {
649 if (r_idx >= 0x1C && r_idx <= 0x1F) { /* primask, basepri, faultmask, or control */
650 /* These are held in the same register */
651 _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
653 val = (uint8_t) (val>>24);
656 case 0x1C: /* control */
657 val = (((uint32_t) val) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
659 case 0x1D: /* faultmask */
660 val = (((uint32_t) regp->control) << 24) | (((uint32_t) val) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) regp->primask);
662 case 0x1E: /* basepri */
663 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) val) << 8) | ((uint32_t) regp->primask);
665 case 0x1F: /* primask */
666 val = (((uint32_t) regp->control) << 24) | (((uint32_t) regp->faultmask) << 16) | (((uint32_t) regp->basepri) << 8) | ((uint32_t) val);
673 write_uint32(sl->q_buf, val);
675 _stlink_usb_write_mem32(sl, DCRDR, 4);
677 sl->q_buf[0] = (unsigned char) r_idx;
682 _stlink_usb_write_mem32(sl, DCRSR, 4);
685 void _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
686 struct stlink_libusb * const slu = sl->backend_data;
687 unsigned char* const data = sl->q_buf;
688 unsigned char* const cmd = sl->c_buf;
690 uint32_t rep_len = 2;
691 int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
693 cmd[i++] = STLINK_DEBUG_COMMAND;
694 cmd[i++] = STLINK_DEBUG_WRITEREG;
696 write_uint32(&cmd[i], reg);
697 size = send_recv(slu, 1, cmd, slu->cmd_len, data, rep_len);
699 printf("[!] send_recv\n");
702 sl->q_len = (size_t) size;
703 stlink_print_data(sl);
706 stlink_backend_t _stlink_usb_backend = {
708 _stlink_usb_exit_debug_mode,
709 _stlink_usb_enter_swd_mode,
710 NULL, // no enter_jtag_mode here...
711 _stlink_usb_exit_dfu_mode,
714 _stlink_usb_jtag_reset,
718 _stlink_usb_read_debug32,
719 _stlink_usb_read_mem32,
720 _stlink_usb_write_debug32,
721 _stlink_usb_write_mem32,
722 _stlink_usb_write_mem8,
723 _stlink_usb_read_all_regs,
724 _stlink_usb_read_reg,
725 _stlink_usb_read_all_unsupported_regs,
726 _stlink_usb_read_unsupported_reg,
727 _stlink_usb_write_unsupported_reg,
728 _stlink_usb_write_reg,
730 _stlink_usb_current_mode,
731 _stlink_usb_force_debug,
732 _stlink_usb_target_voltage
736 stlink_t* stlink_open_usb(const int verbose, int reset) {
738 struct stlink_libusb* slu = NULL;
740 libusb_device** devs = NULL;
743 sl = malloc(sizeof (stlink_t));
744 slu = malloc(sizeof (struct stlink_libusb));
745 if (sl == NULL) goto on_error;
746 if (slu == NULL) goto on_error;
747 memset(sl, 0, sizeof (stlink_t));
748 memset(slu, 0, sizeof (struct stlink_libusb));
751 sl->backend = &_stlink_usb_backend;
752 sl->backend_data = slu;
754 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
756 if (libusb_init(&(slu->libusb_ctx))) {
757 WLOG("failed to init libusb context, wrong version of libraries?\n");
761 libusb_device **list;
762 int cnt = libusb_get_device_list(slu->libusb_ctx, &list);
763 struct libusb_device_descriptor desc;
767 char *device = getenv("STLINK_DEVICE");
769 char *c = strchr(device,':');
771 WLOG("STLINK_DEVICE must be <USB_BUS>:<USB_ADDR> format\n");
777 ILOG("bus %03d dev %03d\n",devBus, devAddr);
781 libusb_get_device_descriptor( list[cnt], &desc );
782 if (desc.idVendor!=USB_ST_VID) continue;
783 if (devBus && devAddr)
784 if ((libusb_get_bus_number(list[cnt])!=devBus) || (libusb_get_device_address(list[cnt])!=devAddr)) continue;
785 if (desc.idProduct == USB_STLINK_32L_PID) break;
786 if (desc.idProduct == USB_STLINK_PID) {
793 WLOG ("Couldn't find %s ST-Link/V2 devices\n",(devBus && devAddr)?"matched":"any");
796 if( libusb_open(list[cnt], &slu->usb_handle) !=0){
797 WLOG("Couldn't open ST-Link/V2 device %03d:%03d\n",libusb_get_bus_number(list[cnt]), libusb_get_device_address(list[cnt]));
802 libusb_free_device_list(list, 1);
805 if (libusb_kernel_driver_active(slu->usb_handle, 0) == 1) {
808 r = libusb_detach_kernel_driver(slu->usb_handle, 0);
810 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-r));
811 goto on_libusb_error;
815 if (libusb_get_configuration(slu->usb_handle, &config)) {
816 /* this may fail for a previous configured device */
817 WLOG("libusb_get_configuration()\n");
818 goto on_libusb_error;
822 printf("setting new configuration (%d -> 1)\n", config);
823 if (libusb_set_configuration(slu->usb_handle, 1)) {
824 /* this may fail for a previous configured device */
825 WLOG("libusb_set_configuration() failed\n");
826 goto on_libusb_error;
830 if (libusb_claim_interface(slu->usb_handle, 0)) {
831 WLOG("libusb_claim_interface() failed\n");
832 goto on_libusb_error;
835 slu->req_trans = libusb_alloc_transfer(0);
836 if (slu->req_trans == NULL) {
837 WLOG("libusb_alloc_transfer failed\n");
838 goto on_libusb_error;
841 slu->rep_trans = libusb_alloc_transfer(0);
842 if (slu->rep_trans == NULL) {
843 WLOG("libusb_alloc_transfer failed\n");
844 goto on_libusb_error;
846 // TODO - could use the scanning techniq from stm8 code here...
847 slu->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
848 slu->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
850 slu->sg_transfer_idx = 0;
851 // TODO - never used at the moment, always CMD_SIZE
852 slu->cmd_len = (slu->protocoll == 1)? STLINK_SG_SIZE: STLINK_CMD_SIZE;
856 if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
857 ILOG("-- exit_dfu_mode\n");
858 stlink_exit_dfu_mode(sl);
861 if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE) {
862 stlink_enter_swd_mode(sl);
868 stlink_load_device_params(sl);
875 libusb_free_device_list(devs, 1);
888 libusb_exit(slu->libusb_ctx);
889 if (sl != NULL) free(sl);
890 if (slu != NULL) free(slu);