2 Copyright (c) 2010 "Capt'ns Missing Link" Authors. All rights reserved.
3 Use of this source code is governed by a BSD-style
4 license that can be found in the LICENSE file.
6 A linux stlink access demo. The purpose of this file is to mitigate the usual
7 "reinventing the wheel" force by incompatible licenses and give you an idea,
8 how to access the stlink device. That doesn't mean you should be a free-loader
9 and not contribute your improvements to this code.
11 Author: Martin Capitanio <m@capitanio.org>
12 The stlink related constants kindly provided by Oliver Spencer (OpenOCD)
13 for use in a GPL compatible license.
15 Tested compatibility: linux, gcc >= 4.3.3
17 The communication is based on standard USB mass storage device
18 BOT (Bulk Only Transfer)
19 - Endpoint 1: BULK_IN, 64 bytes max
20 - Endpoint 2: BULK_OUT, 64 bytes max
22 All CBW transfers are ordered with the LSB (byte 0) first (little endian).
23 Any command must be answered before sending the next command.
24 Each USB transfer must complete in less than 1s.
26 SB Device Class Definition for Mass Storage Devices:
27 www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf
29 dt - Data Transfer (IN/OUT)
30 CBW - Command Block Wrapper
31 CSW - Command Status Wrapper
32 RFU - Reserved for Future Use
34 Originally, this driver used scsi pass through commands, which required the
35 usb-storage module to be loaded, providing the /dev/sgX links. The USB mass
36 storage implementation on the STLinkv1 is however terribly broken, and it can
37 take many minutes for the kernel to give up.
39 However, in Nov 2011, the scsi pass through was replaced by raw libusb, so
40 instead of having to let usb-storage struggle with the device, and also greatly
41 limiting the portability of the driver, you can now tell usb-storage to simply
42 ignore this device completely.
45 http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob_plain;f=Documentation/kernel-parameters.txt
46 Each entry has the form VID:PID:Flags where VID and PID are Vendor and Product
47 ID values (4-digit hex numbers) and Flags is a set of characters, each corresponding
48 to a common usb-storage quirk flag as follows:
50 a = SANE_SENSE (collect more than 18 bytes of sense data);
51 b = BAD_SENSE (don't collect more than 18 bytes of sense data);
52 c = FIX_CAPACITY (decrease the reported device capacity by one sector);
53 h = CAPACITY_HEURISTICS (decrease the reported device capacity by one sector if the number is odd);
54 i = IGNORE_DEVICE (don't bind to this device);
55 l = NOT_LOCKABLE (don't try to lock and unlock ejectable media);
56 m = MAX_SECTORS_64 (don't transfer more than 64 sectors = 32 KB at a time);
57 o = CAPACITY_OK (accept the capacity reported by the device);
58 r = IGNORE_RESIDUE (the device reports bogus residue values);
59 s = SINGLE_LUN (the device has only one Logical Unit);
60 w = NO_WP_DETECT (don't test whether the medium is write-protected).
62 Example: quirks=0419:aaf5:rl,0421:0433:rc
63 http://permalink.gmane.org/gmane.linux.usb.general/35053
65 For the stlinkv1, you just want the following
67 modprobe -r usb-storage && modprobe usb-storage quirks=483:3744:i
69 Equivalently, you can add a line saying
71 options usb-storage quirks=483:3744:i
73 to your /etc/modprobe.conf or /etc/modprobe.d/local.conf (or add the "quirks=..."
74 part to an existing options line for usb-storage).
86 #include <sys/types.h>
90 #include "stlink-common.h"
91 #include "stlink-sg.h"
92 #include "uglylogging.h"
94 #define LOG_TAG __FILE__
95 #define DLOG(format, args...) ugly_log(UDEBUG, LOG_TAG, format, ## args)
96 #define ILOG(format, args...) ugly_log(UINFO, LOG_TAG, format, ## args)
97 #define WLOG(format, args...) ugly_log(UWARN, LOG_TAG, format, ## args)
98 #define fatal(format, args...) ugly_log(UFATAL, LOG_TAG, format, ## args)
100 static void clear_cdb(struct stlink_libsg *sl) {
101 for (size_t i = 0; i < sizeof (sl->cdb_cmd_blk); i++)
102 sl->cdb_cmd_blk[i] = 0;
104 sl->cdb_cmd_blk[0] = STLINK_DEBUG_COMMAND;
105 sl->q_data_dir = Q_DATA_IN;
109 * Close and free any _backend_ related information...
111 */void _stlink_sg_close(stlink_t *sl) {
113 struct stlink_libsg *slsg = sl->backend_data;
114 libusb_close(slsg->usb_handle);
115 libusb_exit(slsg->libusb_ctx);
120 static int get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t endpoint, uint32_t *tag)
122 unsigned char csw[13];
123 memset(csw, 0, sizeof(csw));
128 ret = libusb_bulk_transfer(handle, endpoint, (unsigned char *)&csw, sizeof(csw),
129 &transferred, SG_TIMEOUT_MSEC);
130 if (ret == LIBUSB_ERROR_PIPE) {
131 libusb_clear_halt(handle, endpoint);
134 } while ((ret == LIBUSB_ERROR_PIPE) && (try < 3));
135 if (ret != LIBUSB_SUCCESS) {
136 WLOG("%s: receiving failed: %d\n", __func__, ret);
139 if (transferred != sizeof(csw)) {
140 WLOG("%s: received unexpected amount: %d\n", __func__, transferred);
144 uint32_t rsig = read_uint32(csw, 0);
145 uint32_t rtag = read_uint32(csw, 4);
146 /* uint32_t residue = read_uint32(csw, 8); */
147 #define USB_CSW_SIGNATURE 0x53425355 // 'U' 'S' 'B' 'S' (reversed)
148 if (rsig != USB_CSW_SIGNATURE) {
149 WLOG("status signature was invalid: %#x\n", rsig);
153 uint8_t rstatus = csw[12];
157 static int dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
159 char *dbugp = dbugblah;
160 dbugp += sprintf(dbugp, "Sending CDB [");
161 for (uint8_t i = 0; i < cdb_len; i++) {
162 dbugp += sprintf(dbugp, " %#02x", (unsigned int) cdb[i]);
164 sprintf(dbugp, "]\n");
170 * Wraps a CDB mass storage command in the appropriate gunk to get it down
177 * @param expected_rx_size
180 int send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint_out,
181 uint8_t *cdb, uint8_t cdb_length,
182 uint8_t lun, uint8_t flags, uint32_t expected_rx_size) {
183 DLOG("Sending usb m-s cmd: cdblen:%d, rxsize=%d\n", cdb_length, expected_rx_size);
184 dump_CDB_command(cdb, cdb_length);
193 int real_transferred;
196 uint8_t c_buf[STLINK_SG_SIZE];
197 // tag is allegedly ignored... TODO - verify
202 write_uint32(&c_buf[i], tag);
203 uint32_t this_tag = tag++;
204 write_uint32(&c_buf[i+4], expected_rx_size);
209 c_buf[i++] = cdb_length;
211 // Now the actual CDB request
212 assert(cdb_length <= CDB_SL);
213 memcpy(&(c_buf[i]), cdb, cdb_length);
215 int sending_length = STLINK_SG_SIZE;
219 ret = libusb_bulk_transfer(handle, endpoint_out, c_buf, sending_length,
220 &real_transferred, SG_TIMEOUT_MSEC);
221 if (ret == LIBUSB_ERROR_PIPE) {
222 libusb_clear_halt(handle, endpoint_out);
225 } while ((ret == LIBUSB_ERROR_PIPE) && (try < 3));
226 if (ret != LIBUSB_SUCCESS) {
227 WLOG("sending failed: %d\n", ret);
235 * Straight from stm8 stlink code...
238 * @param endpoint_out
241 get_sense(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t endpoint_out)
243 DLOG("Fetching sense...\n");
245 memset(cdb, 0, sizeof(cdb));
246 #define REQUEST_SENSE 0x03
247 #define REQUEST_SENSE_LENGTH 18
248 cdb[0] = REQUEST_SENSE;
249 cdb[4] = REQUEST_SENSE_LENGTH;
250 uint32_t tag = send_usb_mass_storage_command(handle, endpoint_out, cdb, sizeof(cdb), 0,
251 LIBUSB_ENDPOINT_IN, REQUEST_SENSE_LENGTH);
253 WLOG("refusing to send request sense with tag 0\n");
256 unsigned char sense[REQUEST_SENSE_LENGTH];
261 ret = libusb_bulk_transfer(handle, endpoint_in, sense, sizeof(sense),
262 &transferred, SG_TIMEOUT_MSEC);
263 if (ret == LIBUSB_ERROR_PIPE) {
264 libusb_clear_halt(handle, endpoint_in);
267 } while ((ret == LIBUSB_ERROR_PIPE) && (try < 3));
268 if (ret != LIBUSB_SUCCESS) {
269 WLOG("receiving sense failed: %d\n", ret);
272 if (transferred != sizeof(sense)) {
273 WLOG("received unexpected amount of sense: %d != %d\n", transferred, sizeof(sense));
275 uint32_t received_tag;
276 int status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
278 WLOG("receiving sense failed with status: %02x\n", status);
281 if (sense[0] != 0x70 && sense[0] != 0x71) {
282 WLOG("No sense data\n");
284 WLOG("Sense KCQ: %02X %02X %02X\n", sense[2] & 0x0f, sense[12], sense[13]);
289 * Just send a buffer on an endpoint, no questions asked.
290 * Handles repeats, and time outs. Also handles reading status reports and sense
291 * @param handle libusb device *
292 * @param endpoint_out sends
293 * @param endpoint_in used to read status reports back in
294 * @param cbuf what to send
295 * @param length how much to send
296 * @return number of bytes actually sent, or -1 for failures.
298 int send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_out,
299 unsigned char endpoint_in, unsigned char *cbuf, unsigned int length) {
301 int real_transferred;
304 ret = libusb_bulk_transfer(handle, endpoint_out, cbuf, length,
305 &real_transferred, SG_TIMEOUT_MSEC);
306 if (ret == LIBUSB_ERROR_PIPE) {
307 libusb_clear_halt(handle, endpoint_out);
310 } while ((ret == LIBUSB_ERROR_PIPE) && (try < 3));
311 if (ret != LIBUSB_SUCCESS) {
312 WLOG("sending failed: %d\n", ret);
316 // now, swallow up the status, so that things behave nicely...
317 uint32_t received_tag;
318 // -ve is for my errors, 0 is good, +ve is libusb sense status bytes
319 int status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
321 WLOG("receiving status failed: %d\n", status);
325 WLOG("receiving status not passed :(: %02x\n", status);
328 get_sense(handle, endpoint_in, endpoint_out);
332 return real_transferred;
336 int stlink_q(stlink_t *sl) {
337 struct stlink_libsg* sg = sl->backend_data;
338 //uint8_t cdb_len = 6; // FIXME varies!!!
339 uint8_t cdb_len = 10; // FIXME varies!!!
340 uint8_t lun = 0; // always zero...
341 uint32_t tag = send_usb_mass_storage_command(sg->usb_handle, sg->ep_req,
342 sg->cdb_cmd_blk, cdb_len, lun, LIBUSB_ENDPOINT_IN, sl->q_len);
345 // now wait for our response...
346 // length copied from stlink-usb...
347 int rx_length = sl->q_len;
349 int real_transferred;
353 ret = libusb_bulk_transfer(sg->usb_handle, sg->ep_rep, sl->q_buf, rx_length,
354 &real_transferred, SG_TIMEOUT_MSEC);
355 if (ret == LIBUSB_ERROR_PIPE) {
356 libusb_clear_halt(sg->usb_handle, sg->ep_req);
359 } while ((ret == LIBUSB_ERROR_PIPE) && (try < 3));
361 if (ret != LIBUSB_SUCCESS) {
362 WLOG("Receiving failed: %d\n", ret);
366 if (real_transferred != rx_length) {
367 WLOG("received unexpected amount: %d != %d\n", real_transferred, rx_length);
371 uint32_t received_tag;
372 // -ve is for my errors, 0 is good, +ve is libusb sense status bytes
373 int status = get_usb_mass_storage_status(sg->usb_handle, sg->ep_rep, &received_tag);
375 WLOG("receiving status failed: %d\n", status);
379 WLOG("receiving status not passed :(: %02x\n", status);
382 get_sense(sg->usb_handle, sg->ep_rep, sg->ep_req);
385 if (received_tag != tag) {
386 WLOG("received tag %d but expected %d\n", received_tag, tag);
389 if (rx_length > 0 && real_transferred != rx_length) {
395 // TODO thinking, cleanup
397 void stlink_stat(stlink_t *stl, char *txt) {
401 stlink_print_data(stl);
403 switch (stl->q_buf[0]) {
405 DLOG(" %s: ok\n", txt);
408 DLOG(" %s: false\n", txt);
411 DLOG(" %s: unknown\n", txt);
416 void _stlink_sg_version(stlink_t *stl) {
417 struct stlink_libsg *sl = stl->backend_data;
419 sl->cdb_cmd_blk[0] = STLINK_GET_VERSION;
426 // STLINK_DEV_DFU_MODE || STLINK_DEV_MASS_MODE || STLINK_DEV_DEBUG_MODE
427 // usb dfu || usb mass || jtag or swd
429 int _stlink_sg_current_mode(stlink_t *stl) {
430 struct stlink_libsg *sl = stl->backend_data;
432 sl->cdb_cmd_blk[0] = STLINK_GET_CURRENT_MODE;
436 return stl->q_buf[0];
439 // Exit the mass mode and enter the swd debug mode.
441 void _stlink_sg_enter_swd_mode(stlink_t *sl) {
442 struct stlink_libsg *sg = sl->backend_data;
444 sg->cdb_cmd_blk[1] = STLINK_DEBUG_ENTER;
445 sg->cdb_cmd_blk[2] = STLINK_DEBUG_ENTER_SWD;
446 sl->q_len = 0; // >0 -> aboard
450 // Exit the mass mode and enter the jtag debug mode.
451 // (jtag is disabled in the discovery's stlink firmware)
453 void _stlink_sg_enter_jtag_mode(stlink_t *sl) {
454 struct stlink_libsg *sg = sl->backend_data;
455 DLOG("\n*** stlink_enter_jtag_mode ***\n");
457 sg->cdb_cmd_blk[1] = STLINK_DEBUG_ENTER;
458 sg->cdb_cmd_blk[2] = STLINK_DEBUG_ENTER_JTAG;
463 // XXX kernel driver performs reset, the device temporally disappears
464 // Suspect this is no longer the case when we have ignore on? RECHECK
465 void _stlink_sg_exit_dfu_mode(stlink_t *sl) {
466 struct stlink_libsg *sg = sl->backend_data;
467 DLOG("\n*** stlink_exit_dfu_mode ***\n");
469 sg->cdb_cmd_blk[0] = STLINK_DFU_COMMAND;
470 sg->cdb_cmd_blk[1] = STLINK_DFU_EXIT;
474 [135121.844564] sd 19:0:0:0: [sdb] Unhandled error code
475 [135121.844569] sd 19:0:0:0: [sdb] Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK
476 [135121.844574] sd 19:0:0:0: [sdb] CDB: Read(10): 28 00 00 00 10 00 00 00 08 00
477 [135121.844584] end_request: I/O error, dev sdb, sector 4096
478 [135121.844590] Buffer I/O error on device sdb, logical block 512
479 [135130.122567] usb 6-1: reset full speed USB device using uhci_hcd and address 7
480 [135130.274551] usb 6-1: device firmware changed
481 [135130.274618] usb 6-1: USB disconnect, address 7
482 [135130.275186] VFS: busy inodes on changed media or resized disk sdb
483 [135130.275424] VFS: busy inodes on changed media or resized disk sdb
484 [135130.286758] VFS: busy inodes on changed media or resized disk sdb
485 [135130.292796] VFS: busy inodes on changed media or resized disk sdb
486 [135130.301481] VFS: busy inodes on changed media or resized disk sdb
487 [135130.304316] VFS: busy inodes on changed media or resized disk sdb
488 [135130.431113] usb 6-1: new full speed USB device using uhci_hcd and address 8
489 [135130.629444] usb-storage 6-1:1.0: Quirks match for vid 0483 pid 3744: 102a1
490 [135130.629492] scsi20 : usb-storage 6-1:1.0
491 [135131.625600] scsi 20:0:0:0: Direct-Access STM32 PQ: 0 ANSI: 0
492 [135131.627010] sd 20:0:0:0: Attached scsi generic sg2 type 0
493 [135131.633603] sd 20:0:0:0: [sdb] 64000 512-byte logical blocks: (32.7 MB/31.2 MiB)
494 [135131.633613] sd 20:0:0:0: [sdb] Assuming Write Enabled
495 [135131.633620] sd 20:0:0:0: [sdb] Assuming drive cache: write through
496 [135131.640584] sd 20:0:0:0: [sdb] Assuming Write Enabled
497 [135131.640592] sd 20:0:0:0: [sdb] Assuming drive cache: write through
499 [135131.652634] sd 20:0:0:0: [sdb] Assuming Write Enabled
500 [135131.652639] sd 20:0:0:0: [sdb] Assuming drive cache: write through
501 [135131.652645] sd 20:0:0:0: [sdb] Attached SCSI removable disk
502 [135131.671536] sd 20:0:0:0: [sdb] Result: hostbyte=DID_OK driverbyte=DRIVER_SENSE
503 [135131.671548] sd 20:0:0:0: [sdb] Sense Key : Illegal Request [current]
504 [135131.671553] sd 20:0:0:0: [sdb] Add. Sense: Logical block address out of range
505 [135131.671560] sd 20:0:0:0: [sdb] CDB: Read(10): 28 00 00 00 f9 80 00 00 08 00
506 [135131.671570] end_request: I/O error, dev sdb, sector 63872
507 [135131.671575] Buffer I/O error on device sdb, logical block 7984
508 [135131.678527] sd 20:0:0:0: [sdb] Result: hostbyte=DID_OK driverbyte=DRIVER_SENSE
509 [135131.678532] sd 20:0:0:0: [sdb] Sense Key : Illegal Request [current]
510 [135131.678537] sd 20:0:0:0: [sdb] Add. Sense: Logical block address out of range
511 [135131.678542] sd 20:0:0:0: [sdb] CDB: Read(10): 28 00 00 00 f9 80 00 00 08 00
512 [135131.678551] end_request: I/O error, dev sdb, sector 63872
514 [135131.853565] end_request: I/O error, dev sdb, sector 4096
518 void _stlink_sg_core_id(stlink_t *sl) {
519 struct stlink_libsg *sg = sl->backend_data;
521 sg->cdb_cmd_blk[1] = STLINK_DEBUG_READCOREID;
525 sl->core_id = read_uint32(sl->q_buf, 0);
528 // Arm-core reset -> halted state.
530 void _stlink_sg_reset(stlink_t *sl) {
531 struct stlink_libsg *sg = sl->backend_data;
533 sg->cdb_cmd_blk[1] = STLINK_DEBUG_RESETSYS;
537 stlink_stat(sl, "core reset");
540 // Arm-core reset -> halted state.
542 void _stlink_sg_jtag_reset(stlink_t *sl, int value) {
543 struct stlink_libsg *sg = sl->backend_data;
545 sg->cdb_cmd_blk[1] = STLINK_JTAG_DRIVE_NRST;
546 sg->cdb_cmd_blk[2] = (value)?0:1;
550 stlink_stat(sl, "core reset");
553 // Arm-core status: halted or running.
555 void _stlink_sg_status(stlink_t *sl) {
556 struct stlink_libsg *sg = sl->backend_data;
558 sg->cdb_cmd_blk[1] = STLINK_DEBUG_GETSTATUS;
564 // Force the core into the debug mode -> halted state.
566 void _stlink_sg_force_debug(stlink_t *sl) {
567 struct stlink_libsg *sg = sl->backend_data;
569 sg->cdb_cmd_blk[1] = STLINK_DEBUG_FORCEDEBUG;
573 stlink_stat(sl, "force debug");
576 // Read all arm-core registers.
578 void _stlink_sg_read_all_regs(stlink_t *sl, reg *regp) {
579 struct stlink_libsg *sg = sl->backend_data;
582 sg->cdb_cmd_blk[1] = STLINK_DEBUG_READALLREGS;
586 stlink_print_data(sl);
588 // TODO - most of this should be re-extracted up....
590 // 0-3 | 4-7 | ... | 60-63 | 64-67 | 68-71 | 72-75 | 76-79 | 80-83
591 // r0 | r1 | ... | r15 | xpsr | main_sp | process_sp | rw | rw2
592 for (int i = 0; i < 16; i++) {
593 regp->r[i] = read_uint32(sl->q_buf, 4 * i);
595 DLOG("r%2d = 0x%08x\n", i, regp->r[i]);
597 regp->xpsr = read_uint32(sl->q_buf, 64);
598 regp->main_sp = read_uint32(sl->q_buf, 68);
599 regp->process_sp = read_uint32(sl->q_buf, 72);
600 regp->rw = read_uint32(sl->q_buf, 76);
601 regp->rw2 = read_uint32(sl->q_buf, 80);
605 DLOG("xpsr = 0x%08x\n", regp->xpsr);
606 DLOG("main_sp = 0x%08x\n", regp->main_sp);
607 DLOG("process_sp = 0x%08x\n", regp->process_sp);
608 DLOG("rw = 0x%08x\n", regp->rw);
609 DLOG("rw2 = 0x%08x\n", regp->rw2);
612 // Read an arm-core register, the index must be in the range 0..20.
613 // 0 | 1 | ... | 15 | 16 | 17 | 18 | 19 | 20
614 // r0 | r1 | ... | r15 | xpsr | main_sp | process_sp | rw | rw2
616 void _stlink_sg_read_reg(stlink_t *sl, int r_idx, reg *regp) {
617 struct stlink_libsg *sg = sl->backend_data;
619 sg->cdb_cmd_blk[1] = STLINK_DEBUG_READREG;
620 sg->cdb_cmd_blk[2] = r_idx;
624 // 0 | 1 | ... | 15 | 16 | 17 | 18 | 19 | 20
625 // 0-3 | 4-7 | ... | 60-63 | 64-67 | 68-71 | 72-75 | 76-79 | 80-83
626 // r0 | r1 | ... | r15 | xpsr | main_sp | process_sp | rw | rw2
627 stlink_print_data(sl);
629 uint32_t r = read_uint32(sl->q_buf, 0);
630 DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
640 regp->process_sp = r;
643 regp->rw = r; //XXX ?(primask, basemask etc.)
646 regp->rw2 = r; //XXX ?(primask, basemask etc.)
653 // Write an arm-core register. Index:
654 // 0 | 1 | ... | 15 | 16 | 17 | 18 | 19 | 20
655 // r0 | r1 | ... | r15 | xpsr | main_sp | process_sp | rw | rw2
657 void _stlink_sg_write_reg(stlink_t *sl, uint32_t reg, int idx) {
658 struct stlink_libsg *sg = sl->backend_data;
660 sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEREG;
663 sg->cdb_cmd_blk[2] = idx;
664 write_uint32(sg->cdb_cmd_blk + 3, reg);
668 stlink_stat(sl, "write reg");
671 // Write a register of the debug module of the core.
672 // XXX ?(atomic writes)
675 void stlink_write_dreg(stlink_t *sl, uint32_t reg, uint32_t addr) {
676 struct stlink_libsg *sg = sl->backend_data;
677 DLOG("\n*** stlink_write_dreg ***\n");
679 sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEDEBUGREG;
680 // 2-5: address of reg of the debug module
682 write_uint32(sg->cdb_cmd_blk + 2, addr);
683 write_uint32(sg->cdb_cmd_blk + 6, reg);
687 stlink_stat(sl, "write debug reg");
690 // Force the core exit the debug mode.
692 void _stlink_sg_run(stlink_t *sl) {
693 struct stlink_libsg *sg = sl->backend_data;
695 sg->cdb_cmd_blk[1] = STLINK_DEBUG_RUNCORE;
699 stlink_stat(sl, "run core");
702 // Step the arm-core.
704 void _stlink_sg_step(stlink_t *sl) {
705 struct stlink_libsg *sg = sl->backend_data;
707 sg->cdb_cmd_blk[1] = STLINK_DEBUG_STEPCORE;
711 stlink_stat(sl, "step core");
715 // see Cortex-M3 Technical Reference Manual
716 // TODO make delegate!
717 void stlink_set_hw_bp(stlink_t *sl, int fp_nr, uint32_t addr, int fp) {
718 DLOG("\n*** stlink_set_hw_bp ***\n");
719 struct stlink_libsg *sg = sl->backend_data;
721 sg->cdb_cmd_blk[1] = STLINK_DEBUG_SETFP;
722 // 2:The number of the flash patch used to set the breakpoint
723 // 3-6: Address of the breakpoint (LSB)
724 // 7: FP_ALL (0x02) / FP_UPPER (0x01) / FP_LOWER (0x00)
725 sl->q_buf[2] = fp_nr;
726 write_uint32(sl->q_buf, addr);
731 stlink_stat(sl, "set flash breakpoint");
736 // TODO make delegate!
737 void stlink_clr_hw_bp(stlink_t *sl, int fp_nr) {
738 struct stlink_libsg *sg = sl->backend_data;
739 DLOG("\n*** stlink_clr_hw_bp ***\n");
741 sg->cdb_cmd_blk[1] = STLINK_DEBUG_CLEARFP;
742 sg->cdb_cmd_blk[2] = fp_nr;
746 stlink_stat(sl, "clear flash breakpoint");
749 // Read a "len" bytes to the sl->q_buf from the memory, max 6kB (6144 bytes)
751 void _stlink_sg_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
752 struct stlink_libsg *sg = sl->backend_data;
754 sg->cdb_cmd_blk[1] = STLINK_DEBUG_READMEM_32BIT;
757 write_uint32(sg->cdb_cmd_blk + 2, addr);
758 write_uint16(sg->cdb_cmd_blk + 6, len);
760 // data_in 0-0x40-len
761 // !!! len _and_ q_len must be max 6k,
762 // i.e. >1024 * 6 = 6144 -> aboard)
763 // !!! if len < q_len: 64*k, 1024*n, n=1..5 -> aboard
764 // (broken residue issue)
768 stlink_print_data(sl);
771 // Write a "len" bytes from the sl->q_buf to the memory, max 64 Bytes.
773 void _stlink_sg_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
774 struct stlink_libsg *sg = sl->backend_data;
776 sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEMEM_8BIT;
778 // 6-7: len (>0x40 (64) -> aboard)
779 write_uint32(sg->cdb_cmd_blk + 2, addr);
780 write_uint16(sg->cdb_cmd_blk + 6, len);
782 // this sends the command...
783 send_usb_mass_storage_command(sg->usb_handle, sg->ep_req, sg->cdb_cmd_blk, CDB_SL, 0, 0, 0);
784 // This sends the data...
785 send_usb_data_only(sg->usb_handle, sg->ep_req, sg->ep_rep, sl->q_buf, len);
786 stlink_print_data(sl);
789 // Write a "len" bytes from the sl->q_buf to the memory, max Q_BUF_LEN bytes.
791 void _stlink_sg_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
792 struct stlink_libsg *sg = sl->backend_data;
794 sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEMEM_32BIT;
796 // 6-7: len "unlimited"
797 write_uint32(sg->cdb_cmd_blk + 2, addr);
798 write_uint16(sg->cdb_cmd_blk + 6, len);
800 // this sends the command...
801 send_usb_mass_storage_command(sg->usb_handle, sg->ep_req, sg->cdb_cmd_blk, CDB_SL, 0, 0, 0);
802 // This sends the data...
803 send_usb_data_only(sg->usb_handle, sg->ep_req, sg->ep_rep, sl->q_buf, len);
805 stlink_print_data(sl);
808 // Write one DWORD data to memory
810 void _stlink_sg_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
811 struct stlink_libsg *sg = sl->backend_data;
813 sg->cdb_cmd_blk[1] = STLINK_JTAG_WRITEDEBUG_32BIT;
815 write_uint32(sg->cdb_cmd_blk + 2, addr);
816 write_uint32(sg->cdb_cmd_blk + 6, data);
822 // Read one DWORD data from memory
824 uint32_t _stlink_sg_read_debug32(stlink_t *sl, uint32_t addr) {
825 struct stlink_libsg *sg = sl->backend_data;
827 sg->cdb_cmd_blk[1] = STLINK_JTAG_READDEBUG_32BIT;
829 write_uint32(sg->cdb_cmd_blk + 2, addr);
833 return read_uint32(sl->q_buf, 4);
836 // Exit the jtag or swd mode and enter the mass mode.
838 void _stlink_sg_exit_debug_mode(stlink_t *stl) {
841 struct stlink_libsg* sl = stl->backend_data;
843 sl->cdb_cmd_blk[1] = STLINK_DEBUG_EXIT;
844 stl->q_len = 0; // >0 -> aboard
850 // 1) open a sg device, switch the stlink from dfu to mass mode
851 // 2) wait 5s until the kernel driver stops reseting the broken device
852 // 3) reopen the device
853 // 4) the device driver is now ready for a switch to jtag/swd mode
854 // TODO thinking, better error handling, wait until the kernel driver stops reseting the plugged-in device
856 stlink_backend_t _stlink_sg_backend = {
858 _stlink_sg_exit_debug_mode,
859 _stlink_sg_enter_swd_mode,
860 _stlink_sg_enter_jtag_mode,
861 _stlink_sg_exit_dfu_mode,
864 _stlink_sg_jtag_reset,
868 _stlink_sg_read_debug32,
869 _stlink_sg_read_mem32,
870 _stlink_sg_write_debug32,
871 _stlink_sg_write_mem32,
872 _stlink_sg_write_mem8,
873 _stlink_sg_read_all_regs,
875 NULL, /* read_all_unsupported_regs */
876 NULL, /* read_unsupported_regs */
877 NULL, /* write_unsupported_regs */
878 _stlink_sg_write_reg,
880 _stlink_sg_current_mode,
881 _stlink_sg_force_debug,
885 static stlink_t* stlink_open(const int verbose) {
887 stlink_t *sl = malloc(sizeof (stlink_t));
888 memset(sl, 0, sizeof(stlink_t));
889 struct stlink_libsg *slsg = malloc(sizeof (struct stlink_libsg));
890 if (sl == NULL || slsg == NULL) {
891 WLOG("Couldn't malloc stlink and stlink_sg structures out of memory!\n");
895 if (libusb_init(&(slsg->libusb_ctx))) {
896 WLOG("failed to init libusb context, wrong version of libraries?\n");
902 libusb_set_debug(slsg->libusb_ctx, 3);
904 slsg->usb_handle = libusb_open_device_with_vid_pid(slsg->libusb_ctx, USB_ST_VID, USB_STLINK_PID);
905 if (slsg->usb_handle == NULL) {
906 WLOG("Failed to find an stlink v1 by VID:PID\n");
907 libusb_close(slsg->usb_handle);
908 libusb_exit(slsg->libusb_ctx);
915 // Could read the interface config descriptor, and assert lots of the assumptions
917 // assumption: numInterfaces is always 1...
918 if (libusb_kernel_driver_active(slsg->usb_handle, 0) == 1) {
919 int r = libusb_detach_kernel_driver(slsg->usb_handle, 0);
921 WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-r));
922 libusb_close(slsg->usb_handle);
923 libusb_exit(slsg->libusb_ctx);
928 DLOG("Kernel driver was successfully detached\n");
932 if (libusb_get_configuration(slsg->usb_handle, &config)) {
933 /* this may fail for a previous configured device */
934 WLOG("libusb_get_configuration()\n");
935 libusb_close(slsg->usb_handle);
936 libusb_exit(slsg->libusb_ctx);
943 // assumption: bConfigurationValue is always 1
945 WLOG("Your stlink got into a real weird configuration, trying to fix it!\n");
946 DLOG("setting new configuration (%d -> 1)\n", config);
947 if (libusb_set_configuration(slsg->usb_handle, 1)) {
948 /* this may fail for a previous configured device */
949 WLOG("libusb_set_configuration() failed\n");
950 libusb_close(slsg->usb_handle);
951 libusb_exit(slsg->libusb_ctx);
958 if (libusb_claim_interface(slsg->usb_handle, 0)) {
959 WLOG("libusb_claim_interface() failed\n");
960 libusb_close(slsg->usb_handle);
961 libusb_exit(slsg->libusb_ctx);
967 // assumption: endpoint config is fixed mang. really.
968 slsg->ep_rep = 1 /* ep rep */ | LIBUSB_ENDPOINT_IN;
969 slsg->ep_req = 2 /* ep req */ | LIBUSB_ENDPOINT_OUT;
971 DLOG("Successfully opened stlinkv1 by libusb :)\n");
973 sl->verbose = verbose;
974 sl->backend_data = slsg;
975 sl->backend = &_stlink_sg_backend;
977 sl->core_stat = STLINK_CORE_STAT_UNKNOWN;
984 stlink_t* stlink_v1_open_inner(const int verbose) {
986 stlink_t *sl = stlink_open(verbose);
988 fputs("Error: could not open stlink device\n", stderr);
993 if ((sl->version.st_vid != USB_ST_VID) || (sl->version.stlink_pid != USB_STLINK_PID)) {
994 ugly_log(UERROR, LOG_TAG,
995 "WTF? successfully opened, but unable to read version details. BROKEN!\n");
999 DLOG("Reading current mode...\n");
1000 switch (stlink_current_mode(sl)) {
1001 case STLINK_DEV_MASS_MODE:
1003 case STLINK_DEV_DEBUG_MODE:
1007 ILOG("Current mode unusable, trying to get back to a useful state...\n");
1011 DLOG("Attempting to exit DFU mode\n");
1012 _stlink_sg_exit_dfu_mode(sl);
1014 // re-query device info (and retest)
1016 if ((sl->version.st_vid != USB_ST_VID) || (sl->version.stlink_pid != USB_STLINK_PID)) {
1017 ugly_log(UERROR, LOG_TAG,
1018 "WTF? successfully opened, but unable to read version details. BROKEN!\n");
1025 stlink_t* stlink_v1_open(const int verbose, int reset) {
1026 stlink_t *sl = stlink_v1_open_inner(verbose);
1028 fputs("Error: could not open stlink device\n", stderr);
1031 // by now, it _must_ be fully open and in a useful mode....
1032 stlink_enter_swd_mode(sl);
1033 /* Now we are ready to read the parameters */
1037 stlink_load_device_params(sl);
1038 ILOG("Successfully opened a stlink v1 debugger\n");