c_meyer/pxt-calliope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
pxt-calliope/editor/prepend/dapjs.js

3038 lines
129 KiB
JavaScript
Raw Permalink Normal View History

2.1.28, initiation update to PXT v5.28.24 (#54)
2019-12-02 05:58:26 +01:00
var DapJS =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var _this = this;
Object.defineProperty(exports, "__esModule", { value: true });
exports.readUInt32LE = function (b, idx) {
return (b[idx] |
(b[idx + 1] << 8) |
(b[idx + 2] << 16) |
(b[idx + 3] << 24)) >>> 0;
};
exports.bufferConcat = function (bufs) {
var len = 0;
for (var _i = 0, bufs_1 = bufs; _i < bufs_1.length; _i++) {
var b = bufs_1[_i];
len += b.length;
}
var r = new Uint8Array(len);
len = 0;
for (var _a = 0, bufs_2 = bufs; _a < bufs_2.length; _a++) {
var b = bufs_2[_a];
r.set(b, len);
len += b.length;
}
return r;
};
exports.delay = function (t) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, new Promise(function (resolve) {
setTimeout(resolve, t);
})];
});
}); };
exports.addInt32 = function (arr, val) {
if (!arr) {
arr = [];
}
arr.push(val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff, (val >> 24) & 0xff);
return arr;
};
exports.hex = function (v) {
return "0x" + v.toString(16);
};
exports.rid = function (v) {
var m = [
"DP_0x0",
"DP_0x4",
"DP_0x8",
"DP_0xC",
"AP_0x0",
"AP_0x4",
"AP_0x8",
"AP_0xC",
];
return m[v] || "?";
};
exports.bank = function (addr) {
var APBANKSEL = 0x000000f0;
return (addr & APBANKSEL) | (addr & 0xff000000);
};
exports.apReg = function (r, mode) {
var v = r | mode | 1 /* AP_ACC */;
return (4 + ((v & 0x0c) >> 2));
};
exports.bufToUint32Array = function (buf) {
exports.assert((buf.length & 3) === 0);
var r = [];
if (!buf.length) {
return r;
}
r[buf.length / 4 - 1] = 0;
for (var i = 0; i < r.length; ++i) {
r[i] = exports.readUInt32LE(buf, i << 2);
}
return r;
};
exports.assert = function (cond) {
if (!cond) {
throw new Error("assertion failed");
}
};
exports.regRequest = function (regId, isWrite) {
if (isWrite === void 0) { isWrite = false; }
var request = !isWrite ? 2 /* READ */ : 0 /* WRITE */;
if (regId < 4) {
request |= 0 /* DP_ACC */;
}
else {
request |= 1 /* AP_ACC */;
}
request |= (regId & 3) << 2;
return request;
};
exports.hexBytes = function (bytes) {
var chk = 0;
var r = ":";
bytes.forEach(function (b) { return chk += b; });
bytes.push((-chk) & 0xff);
bytes.forEach(function (b) { return r += ("0" + b.toString(16)).slice(-2); });
return r.toUpperCase();
};
exports.hex2bin = function (hexstr) {
var array = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length / 2; i++) {
array[i] = parseInt(hexstr.substr(2 * i, 2), 16);
}
return array;
};
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
/**
* # Prepared Memory Command
*
* Allows multiple memory operations to be batched together to improve HID
* interface utilisation.
*
* ## Usage
*
* Similarly to `CortexMPreparedCommand` and `DapPreparedCommand`, a convenience
* function exists to quickly create a prepared memory command:
*
* ```typescript
* const prep = core.memory.prepareCommand();
* ```
*
* You can then construct the sequence of commands using the same API as `Memory`.
*
* ```typescript
* prep.write32(0x20000, 1234);
* prep.write32(0x12344, 5678);
* prep.write16(0x12346, 123);
* ```
*
* And then dispatch the prepared commands asynchronously:
*
* ```typescript
* await prep.go();
* ```
*/
var PreparedMemoryCommand = (function () {
function PreparedMemoryCommand(dap) {
this.cmd = dap.prepareCommand();
}
/**
* Schedule a 32-bit memory write operation.
*
* @param addr Word-aligned memory address to write to.
* @param data Number to be written.
*/
PreparedMemoryCommand.prototype.write32 = function (addr, data) {
this.cmd.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
this.cmd.writeAp(4 /* TAR */, addr);
this.cmd.writeAp(12 /* DRW */, data);
};
/**
* Schedule a 16-bit memory write operation.
*
* @param addr Half word-aligned memory address to write to.
* @param data Number to be written.
*/
PreparedMemoryCommand.prototype.write16 = function (addr, data) {
data = data << ((addr & 0x02) << 3);
this.cmd.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 1 /* CSW_SIZE16 */);
this.cmd.writeAp(4 /* TAR */, addr);
this.cmd.writeAp(12 /* DRW */, data);
};
/**
* Schedule a 32-bit memory read operation.
*
* @param addr Word-aligned memory address to read from.
*/
PreparedMemoryCommand.prototype.read32 = function (addr) {
this.cmd.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
this.cmd.writeAp(4 /* TAR */, addr);
this.cmd.readAp(12 /* DRW */);
};
/**
* Schedule a 16-bit memory read operation.
*
* FIXME: the values need to be shifted after being read.
*
* @param addr Half word-aligned memory address to read from.
*/
PreparedMemoryCommand.prototype.read16 = function (addr) {
this.cmd.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 1 /* CSW_SIZE16 */);
this.cmd.writeAp(4 /* TAR */, addr);
this.cmd.readAp(12 /* DRW */);
};
/**
* Execute all commands asynchronously.
*/
PreparedMemoryCommand.prototype.go = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.cmd.go()];
});
});
};
return PreparedMemoryCommand;
}());
exports.PreparedMemoryCommand = PreparedMemoryCommand;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var debug_1 = __webpack_require__(5);
var memory_1 = __webpack_require__(7);
var prepared_1 = __webpack_require__(1);
var util_1 = __webpack_require__(0);
var constants_1 = __webpack_require__(3);
var prepared_2 = __webpack_require__(8);
/**
* # Cortex M
*
* Manages access to a CPU core, and its associated memory and debug functionality.
*
* > **NOTE:** all of the methods that involve interaction with the CPU core
* > are asynchronous, so must be `await`ed, or explicitly handled as a Promise.
*
* ## Usage
*
* First, let's create an instance of `CortexM`, using an associated _Debug Access
* Port_ (DAP) instance that we created earlier.
*
* ```typescript
* const core = new CortexM(dap);
* ```
*
* Now, we can halt and resume the core just like this:
*
* > **NOTE:** If you're not using ES2017, you can replace the use of `async` and
* > `await` with direct use of Promises. These examples also need to be run within
* > an `async` function for `async` to be used.
*
* ```typescript
* await core.halt();
* await core.resume();
* ```
*
* Resetting the core is just as easy:
*
* ```typescript
* await core.reset();
* ```
*
* You can even halt immediately after reset:
*
* ```typescript
* await core.reset(true);
* ```
*
* We can also read and write 32-bit values to/from core registers:
*
* ```typescript
* const sp = await core.readCoreRegister(CortexReg.SP);
*
* await core.writeCoreRegister(CortexReg.R0, 0x1000);
* await core.writeCoreRegister(CortexReg.PC, 0x1234);
* ```
*
* ### See also
*
* For details on debugging and memory features, see the documentation for
* `Debug` and `Memory`.
*/
var CortexM = (function () {
function CortexM(device) {
this.dev = device;
this.memory = new memory_1.Memory(device);
this.debug = new debug_1.Debug(this);
}
/**
* Initialise the debug access port on the device, and read the device type.
*/
CortexM.prototype.init = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.dev.init()];
case 1:
_a.sent();
// FIXME: don't run this if security is enabled on the K64F
return [4 /*yield*/, this.debug.init()];
case 2:
// FIXME: don't run this if security is enabled on the K64F
_a.sent();
return [4 /*yield*/, this.readCoreType()];
case 3:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Read the current state of the CPU.
*
* @returns A member of the `CoreState` enum corresponding to the current status of the CPU.
*/
CortexM.prototype.getState = function () {
return __awaiter(this, void 0, void 0, function () {
var dhcsr, newDHCSR;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.memory.read32(3758157296 /* DHCSR */)];
case 1:
dhcsr = _a.sent();
if (!(dhcsr & 33554432 /* S_RESET_ST */)) return [3 /*break*/, 3];
return [4 /*yield*/, this.memory.read32(3758157296 /* DHCSR */)];
case 2:
newDHCSR = _a.sent();
if (newDHCSR & 33554432 /* S_RESET_ST */ && !(newDHCSR & 16777216 /* S_RETIRE_ST */)) {
return [2 /*return*/, 0 /* TARGET_RESET */];
}
_a.label = 3;
case 3:
if (dhcsr & 524288 /* S_LOCKUP */) {
return [2 /*return*/, 1 /* TARGET_LOCKUP */];
}
else if (dhcsr & 262144 /* S_SLEEP */) {
return [2 /*return*/, 2 /* TARGET_SLEEPING */];
}
else if (dhcsr & 131072 /* S_HALT */) {
return [2 /*return*/, 3 /* TARGET_HALTED */];
}
else {
return [2 /*return*/, 4 /* TARGET_RUNNING */];
}
return [2 /*return*/];
}
});
});
};
/**
* Read the CPUID register from the CPU, and interpret its meaning in terms of implementer,
* architecture and core type.
*/
CortexM.prototype.readCoreType = function () {
return __awaiter(this, void 0, void 0, function () {
var cpuid, implementer, arch, coreType;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.memory.read32(3758157056 /* CPUID */)];
case 1:
cpuid = _a.sent();
implementer = ((cpuid & constants_1.CPUID_IMPLEMENTER_MASK) >> constants_1.CPUID_IMPLEMENTER_POS);
arch = ((cpuid & constants_1.CPUID_ARCHITECTURE_MASK) >> constants_1.CPUID_ARCHITECTURE_POS);
coreType = ((cpuid & constants_1.CPUID_PARTNO_MASK) >> constants_1.CPUID_PARTNO_POS);
console.debug("Found an ARM " + constants_1.CoreNames.get(coreType));
return [2 /*return*/, [implementer, arch, coreType]];
}
});
});
};
CortexM.prototype.prepareCommand = function () {
return new prepared_2.PreparedCortexMCommand(this.dev);
};
/**
* Read a core register from the CPU (e.g. r0...r15, pc, sp, lr, s0...)
*
* @param no Member of the `CortexReg` enum - an ARM Cortex CPU general-purpose register.
*/
CortexM.prototype.readCoreRegister = function (no) {
return __awaiter(this, void 0, void 0, function () {
var v;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.memory.write32(3758157300 /* DCRSR */, no)];
case 1:
_a.sent();
return [4 /*yield*/, this.memory.read32(3758157296 /* DHCSR */)];
case 2:
v = _a.sent();
util_1.assert(v & 65536 /* S_REGRDY */);
return [4 /*yield*/, this.memory.read32(3758157304 /* DCRDR */)];
case 3: return [2 /*return*/, _a.sent()];
}
});
});
};
/**
* Write a 32-bit word to the specified CPU general-purpose register.
*
* @param no Member of the `CortexReg` enum - an ARM Cortex CPU general-purpose register.
* @param val Value to be written.
*/
CortexM.prototype.writeCoreRegister = function (no, val) {
return __awaiter(this, void 0, void 0, function () {
var prep, v;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = new prepared_1.PreparedMemoryCommand(this.dev);
prep.write32(3758157304 /* DCRDR */, val);
prep.write32(3758157300 /* DCRSR */, no | 65536 /* DCRSR_REGWnR */);
prep.read32(3758157296 /* DHCSR */);
return [4 /*yield*/, prep.go()];
case 1:
v = (_a.sent())[0];
util_1.assert(v & 65536 /* S_REGRDY */);
return [2 /*return*/];
}
});
});
};
/**
* Halt the CPU core.
*/
CortexM.prototype.halt = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.memory.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ | 1 /* C_DEBUGEN */ | 2 /* C_HALT */)];
});
});
};
/**
* Resume the CPU core.
*/
CortexM.prototype.resume = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.isHalted()];
case 1:
if (!_a.sent()) return [3 /*break*/, 4];
return [4 /*yield*/, this.memory.write32(3758157104 /* DFSR */, 4 /* DFSR_DWTTRAP */ | 2 /* DFSR_BKPT */ | 1 /* DFSR_HALTED */)];
case 2:
_a.sent();
return [4 /*yield*/, this.debug.enable()];
case 3:
_a.sent();
_a.label = 4;
case 4: return [2 /*return*/];
}
});
});
};
/**
* Find out whether the CPU is halted.
*/
CortexM.prototype.isHalted = function () {
return __awaiter(this, void 0, void 0, function () {
var s;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.status()];
case 1:
s = _a.sent();
return [2 /*return*/, s.isHalted];
}
});
});
};
/**
* Read the current status of the CPU.
*
* @returns Object containing the contents of the `DHCSR` register, the `DFSR` register, and a boolean value
* stating the current halted state of the CPU.
*/
CortexM.prototype.status = function () {
return __awaiter(this, void 0, void 0, function () {
var prep, results, dhcsr, dfsr;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = new prepared_1.PreparedMemoryCommand(this.dev);
prep.read32(3758157296 /* DHCSR */);
prep.read32(3758157104 /* DFSR */);
return [4 /*yield*/, prep.go()];
case 1:
results = _a.sent();
dhcsr = results[0];
dfsr = results[1];
return [2 /*return*/, {
dfsr: dfsr,
dhscr: dhcsr,
isHalted: !!(dhcsr & 131072 /* S_HALT */),
}];
}
});
});
};
/**
* Reset the CPU core. This currently does a software reset - it is also technically possible to perform a 'hard'
* reset using the reset pin from the debugger.
*/
CortexM.prototype.reset = function (halt) {
if (halt === void 0) { halt = false; }
return __awaiter(this, void 0, void 0, function () {
var demcr;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!halt) return [3 /*break*/, 7];
return [4 /*yield*/, this.halt()];
case 1:
_a.sent();
return [4 /*yield*/, this.memory.read32(3758157308 /* DEMCR */)];
case 2:
demcr = _a.sent();
return [4 /*yield*/, this.memory.write32(3758157308 /* DEMCR */, demcr | 1 /* DEMCR_VC_CORERESET */)];
case 3:
_a.sent();
return [4 /*yield*/, this.softwareReset()];
case 4:
_a.sent();
return [4 /*yield*/, this.waitForHalt()];
case 5:
_a.sent();
// Unset the VC_CORERESET bit
return [4 /*yield*/, this.memory.write32(3758157308 /* DEMCR */, demcr)];
case 6:
// Unset the VC_CORERESET bit
_a.sent();
return [3 /*break*/, 9];
case 7: return [4 /*yield*/, this.softwareReset()];
case 8:
_a.sent();
_a.label = 9;
case 9: return [2 /*return*/];
}
});
});
};
/**
* Run specified machine code natively on the device. Assumes usual C calling conventions
* - returns the value of r0 once the program has terminated. The program _must_ terminate
* in order for this function to return. This can be achieved by placing a `bkpt`
* instruction at the end of the function.
*
* @param code array containing the machine code (32-bit words).
* @param address memory address at which to place the code.
* @param pc initial value of the program counter.
* @param lr initial value of the link register.
* @param sp initial value of the stack pointer.
* @param upload should we upload the code before running it.
* @param args set registers r0...rn before running code
*
* @returns A promise for the value of r0 on completion of the function call.
*/
CortexM.prototype.runCode = function (code, address, pc, lr, sp, upload) {
var args = [];
for (var _i = 6; _i < arguments.length; _i++) {
args[_i - 6] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var cmd, i;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
cmd = this.prepareCommand();
cmd.halt();
// Point the program counter to the start of the program
cmd.writeCoreRegister(15 /* PC */, pc);
cmd.writeCoreRegister(14 /* LR */, lr);
cmd.writeCoreRegister(13 /* SP */, sp);
for (i = 0; i < args.length; i++) {
cmd.writeCoreRegister(i, args[i]);
}
return [4 /*yield*/, cmd.go()];
case 1:
_a.sent();
if (!upload) return [3 /*break*/, 3];
return [4 /*yield*/, this.memory.writeBlock(address, code)];
case 2:
_a.sent();
_a.label = 3;
case 3:
// Run the program and wait for halt
return [4 /*yield*/, this.resume()];
case 4:
// Run the program and wait for halt
_a.sent();
return [4 /*yield*/, this.waitForHalt(constants_1.DEFAULT_RUNCODE_TIMEOUT)];
case 5:
_a.sent(); // timeout after 10s
return [4 /*yield*/, this.readCoreRegister(0 /* R0 */)];
case 6: return [2 /*return*/, _a.sent()];
}
});
});
};
/**
* Spin until the chip has halted.
*/
CortexM.prototype.waitForHalt = function (timeout) {
if (timeout === void 0) { timeout = 0; }
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
var running, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
running = true;
if (timeout > 0) {
setTimeout(function () {
if (running) {
reject("waitForHalt timed out.");
running = false;
}
}, timeout);
}
_b.label = 1;
case 1:
_a = running;
if (!_a) return [3 /*break*/, 3];
return [4 /*yield*/, this.isHalted()];
case 2:
_a = !(_b.sent());
_b.label = 3;
case 3:
if (!_a) return [3 /*break*/, 4];
return [3 /*break*/, 1];
case 4:
if (running) {
running = false;
resolve();
}
return [2 /*return*/];
}
});
}); })];
});
});
};
CortexM.prototype.softwareReset = function () {
return __awaiter(this, void 0, void 0, function () {
var dhcsr;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.memory.write32(3758157068 /* NVIC_AIRCR */, 100270080 /* NVIC_AIRCR_VECTKEY */ | 4 /* NVIC_AIRCR_SYSRESETREQ */)];
case 1:
_a.sent();
return [4 /*yield*/, this.memory.read32(3758157296 /* DHCSR */)];
case 2:
dhcsr = _a.sent();
_a.label = 3;
case 3:
if (!((dhcsr & 33554432 /* S_RESET_ST */) !== 0)) return [3 /*break*/, 5];
return [4 /*yield*/, this.memory.read32(3758157296 /* DHCSR */)];
case 4:
dhcsr = _a.sent();
return [3 /*break*/, 3];
case 5: return [2 /*return*/];
}
});
});
};
return CortexM;
}());
exports.CortexM = CortexM;
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_RUNCODE_TIMEOUT = 10000 /* ms */;
exports.CPUID_IMPLEMENTER_MASK = 0xff000000;
exports.CPUID_IMPLEMENTER_POS = 24;
exports.CPUID_VARIANT_MASK = 0x00f00000;
exports.CPUID_VARIANT_POS = 20;
exports.CPUID_ARCHITECTURE_MASK = 0x000f0000;
exports.CPUID_ARCHITECTURE_POS = 16;
exports.CPUID_PARTNO_MASK = 0x0000fff0;
exports.CPUID_PARTNO_POS = 4;
exports.CPUID_REVISION_MASK = 0x0000000f;
exports.CPUID_REVISION_POS = 0;
exports.ISANames = new Map();
exports.ISANames.set(12 /* ARMv6M */, "ARMv6M");
exports.ISANames.set(15 /* ARMv7M */, "ARMv7M");
exports.CoreNames = new Map();
exports.CoreNames.set(3104 /* CortexM0 */, "Cortex-M0");
exports.CoreNames.set(3105 /* CortexM1 */, "Cortex-M1");
exports.CoreNames.set(3107 /* CortexM3 */, "Cortex-M3");
exports.CoreNames.set(3108 /* CortexM4 */, "Cortex-M4");
exports.CoreNames.set(3168 /* CortexM0p */, "Cortex-M0+");
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var cortex_1 = __webpack_require__(2);
exports.CortexM = cortex_1.CortexM;
var constants_1 = __webpack_require__(3);
exports.CoreNames = constants_1.CoreNames;
exports.ISANames = constants_1.ISANames;
var dap_1 = __webpack_require__(9);
exports.DAP = dap_1.default;
var FlashTarget_1 = __webpack_require__(12);
exports.FlashTargets = FlashTarget_1.FlashTargets;
exports.FlashTarget = FlashTarget_1.FlashTarget;
var FlashProgram_1 = __webpack_require__(15);
exports.FlashProgram = FlashProgram_1.FlashProgram;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var breakpoint_1 = __webpack_require__(6);
/**
* # Debug Interface
*
* Keeps track of breakpoints set on the target, as well as deciding whether to
* use a hardware breakpoint or a software breakpoint.
*
* ## Usage
*
* ```typescript
* const dbg = core.debug;
*
* await dbg.setBreakpoint(0x123456);
*
* // resume the core and wait for the breakpoint
* await core.resume();
* await core.waitForHalt();
*
* // step forward one instruction
* await dbg.step();
*
* // remove the breakpoint
* await dbg.deleteBreakpoint(0x123456);
* ```
*/
var Debug = (function () {
function Debug(core) {
this.core = core;
this.enabled = false;
this.availableHWBreakpoints = [];
this.breakpoints = new Map();
}
Debug.prototype.init = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.setupFpb()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Enable debugging on the target CPU
*/
Debug.prototype.enable = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.core.memory.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ | 1 /* C_DEBUGEN */)];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Set breakpoints at specified memory addresses.
*
* @param addrs An array of memory addresses at which to set breakpoints.
*/
Debug.prototype.setBreakpoint = function (addr) {
return __awaiter(this, void 0, void 0, function () {
var breakpoint, bkpt, regAddr;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.breakpoints.has(addr)) {
breakpoint = this.breakpoints.get(addr);
if (typeof breakpoint !== "number") {
// already enabled
console.warn("Breakpoint at " + addr.toString(16) + " already enabled.");
return [2 /*return*/];
}
}
if (!(addr < 0x20000000)) return [3 /*break*/, 5];
if (!(this.availableHWBreakpoints.length > 0)) return [3 /*break*/, 3];
if (!!this.enabled) return [3 /*break*/, 2];
console.log("enabling fpb");
return [4 /*yield*/, this.setFpbEnabled(true)];
case 1:
_a.sent();
_a.label = 2;
case 2:
regAddr = this.availableHWBreakpoints.pop();
console.log("using regAddr=" + regAddr.toString(16));
bkpt = new breakpoint_1.HWBreakpoint(regAddr, this.core, addr);
return [3 /*break*/, 4];
case 3:
bkpt = new breakpoint_1.SWBreakpoint(this.core, addr);
_a.label = 4;
case 4: return [3 /*break*/, 6];
case 5:
bkpt = new breakpoint_1.SWBreakpoint(this.core, addr);
_a.label = 6;
case 6: return [4 /*yield*/, bkpt.set()];
case 7:
_a.sent();
this.breakpoints.set(addr, bkpt);
return [2 /*return*/];
}
});
});
};
Debug.prototype.deleteBreakpoint = function (addr) {
return __awaiter(this, void 0, void 0, function () {
var bkpt;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.breakpoints.has(addr)) return [3 /*break*/, 3];
bkpt = this.breakpoints.get(addr);
if (!(typeof bkpt !== "number")) return [3 /*break*/, 2];
return [4 /*yield*/, bkpt.clear()];
case 1:
_a.sent();
if (bkpt instanceof breakpoint_1.HWBreakpoint) {
// return the register address to the pool
this.availableHWBreakpoints.push(bkpt.regAddr);
}
_a.label = 2;
case 2:
this.breakpoints.delete(addr);
return [3 /*break*/, 4];
case 3:
console.warn("Breakpoint at " + addr.toString(16) + " does not exist.");
_a.label = 4;
case 4: return [2 /*return*/];
}
});
});
};
/**
* Step the processor forward by one instruction.
*/
Debug.prototype.step = function () {
return __awaiter(this, void 0, void 0, function () {
var dhcsr, interruptsMasked;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.core.memory.read32(3758157296 /* DHCSR */)];
case 1:
dhcsr = _a.sent();
if (!(dhcsr & (4 /* C_STEP */ | 2 /* C_HALT */))) {
console.error("Target is not halted.");
return [2 /*return*/];
}
interruptsMasked = (8 /* C_MASKINTS */ & dhcsr) !== 0;
if (!!interruptsMasked) return [3 /*break*/, 3];
return [4 /*yield*/, this.core.memory.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ |
1 /* C_DEBUGEN */ |
2 /* C_HALT */ |
8 /* C_MASKINTS */)];
case 2:
_a.sent();
_a.label = 3;
case 3: return [4 /*yield*/, this.core.memory.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ |
1 /* C_DEBUGEN */ |
8 /* C_MASKINTS */ |
4 /* C_STEP */)];
case 4:
_a.sent();
return [4 /*yield*/, this.core.waitForHalt()];
case 5:
_a.sent();
return [4 /*yield*/, this.core.memory.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ |
1 /* C_DEBUGEN */ |
2 /* C_HALT */)];
case 6:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Set up (and disable) the Flash Patch & Breakpoint unit. It will be enabled when
* the first breakpoint is set.
*
* Also reads the number of available hardware breakpoints.
*/
Debug.prototype.setupFpb = function () {
return __awaiter(this, void 0, void 0, function () {
var fpcr, nbCode, nbLit, i;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.core.memory.read32(3758104576 /* FP_CTRL */)];
case 1:
fpcr = _a.sent();
nbCode = ((fpcr >> 8) & 0x70) | ((fpcr >> 4) & 0xf);
nbLit = (fpcr >> 7) & 0xf;
this.totalHWBreakpoints = nbCode;
console.debug(nbCode + " hardware breakpoints, " + nbLit + " literal comparators");
return [4 /*yield*/, this.setFpbEnabled(false)];
case 2:
_a.sent();
i = 0;
_a.label = 3;
case 3:
if (!(i < nbCode)) return [3 /*break*/, 6];
this.availableHWBreakpoints.push(3758104584 /* FP_COMP0 */ + (4 * i));
return [4 /*yield*/, this.core.memory.write32(3758104584 /* FP_COMP0 */ + (i * 4), 0)];
case 4:
_a.sent();
_a.label = 5;
case 5:
i++;
return [3 /*break*/, 3];
case 6: return [2 /*return*/];
}
});
});
};
/**
* Enable or disable the Flash Patch and Breakpoint unit (FPB).
*
* @param enabled
*/
Debug.prototype.setFpbEnabled = function (enabled) {
if (enabled === void 0) { enabled = true; }
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this.enabled = enabled;
return [4 /*yield*/, this.core.memory.write32(3758104576 /* FP_CTRL */, 2 /* FP_CTRL_KEY */ | (enabled ? 1 : 0))];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
return Debug;
}());
exports.Debug = Debug;
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var HWBreakpoint = (function () {
function HWBreakpoint(regAddr, parent, addr) {
this.regAddr = regAddr;
this.parent = parent;
this.addr = addr;
}
HWBreakpoint.prototype.set = function () {
return __awaiter(this, void 0, void 0, function () {
var bpMatch;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
bpMatch = ((this.addr & 0x2) ? 2 : 1) << 30;
return [4 /*yield*/, this.parent.memory.write32(this.regAddr, this.addr & 0x1ffffffc | bpMatch | 1)];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
HWBreakpoint.prototype.clear = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
/* clear hardware breakpoint */
return [4 /*yield*/, this.parent.memory.write32(this.regAddr, 0)];
case 1:
/* clear hardware breakpoint */
_a.sent();
return [2 /*return*/];
}
});
});
};
return HWBreakpoint;
}());
exports.HWBreakpoint = HWBreakpoint;
var SWBreakpoint = (function () {
function SWBreakpoint(parent, addr) {
this.parent = parent;
this.addr = addr;
}
SWBreakpoint.prototype.set = function () {
return __awaiter(this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
// read the instruction from the CPU...
_a = this;
return [4 /*yield*/, this.parent.memory.read16(this.addr)];
case 1:
// read the instruction from the CPU...
_a.instruction = _b.sent();
return [4 /*yield*/, this.parent.memory.write16(this.addr, SWBreakpoint.BKPT_INSTRUCTION)];
case 2:
_b.sent();
return [2 /*return*/];
}
});
});
};
SWBreakpoint.prototype.clear = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
/* clear hardware breakpoint */
return [4 /*yield*/, this.parent.memory.write16(this.addr, this.instruction)];
case 1:
/* clear hardware breakpoint */
_a.sent();
return [2 /*return*/];
}
});
});
};
SWBreakpoint.BKPT_INSTRUCTION = 0xbe00;
return SWBreakpoint;
}());
exports.SWBreakpoint = SWBreakpoint;
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = __webpack_require__(0);
var prepared_1 = __webpack_require__(1);
/**
* # Memory Interface
*
* Controls access to the target's memory.
*
* ## Usage
*
* Using an instance of `CortexM`, as described before, we can simply read and
* write numbers to memory as follows:
*
* ```typescript
* const mem = core.memory;
*
* // NOTE: the address parameter must be word (4-byte) aligned.
* await mem.write32(0x200000, 12345);
* const val = await mem.read32(0x200000);
*
* // val === 12345
*
* // NOTE: the address parameter must be half-word (2-byte) aligned
* await mem.write16(0x2000002, 65534);
* const val16 = await mem.read16(0x2000002);
*
* // val16 === 65534
* ```
*
* To write a larger block of memory, we can use `readBlock` and `writeBlock`. Again,
* these blocks must be written to word-aligned addresses in memory.
*
* ```typescript
* const data = new Uint32Array([0x1234, 0x5678, 0x9ABC, 0xDEF0]);
* await mem.writeBlock(0x200000, data);
*
* const readData = await mem.readBlock(0x200000, data.length, 0x100);
* ```
*
* ## See also
*
* `PreparedMemoryCommand` provides an equivalent API with better performance (in some
* cases) by enabling batched memory operations.
*/
var Memory = (function () {
function Memory(dev) {
this.dev = dev;
}
/**
* Write a 32-bit word to the specified (word-aligned) memory address.
*
* @param addr Memory address to write to
* @param data Data to write (values above 2**32 will be truncated)
*/
Memory.prototype.write32 = function (addr, data) {
return __awaiter(this, void 0, void 0, function () {
var prep;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
prep.writeAp(4 /* TAR */, addr);
prep.writeAp(12 /* DRW */, data);
return [4 /*yield*/, prep.go()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Write a 16-bit word to the specified (half word-aligned) memory address.
*
* @param addr Memory address to write to
* @param data Data to write (values above 2**16 will be truncated)
*/
Memory.prototype.write16 = function (addr, data) {
return __awaiter(this, void 0, void 0, function () {
var prep;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
data = data << ((addr & 0x02) << 3);
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 1 /* CSW_SIZE16 */);
prep.writeAp(4 /* TAR */, addr);
prep.writeAp(12 /* DRW */, data);
return [4 /*yield*/, prep.go()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
/**
* Read a 32-bit word from the specified (word-aligned) memory address.
*
* @param addr Memory address to read from.
*/
Memory.prototype.read32 = function (addr) {
return __awaiter(this, void 0, void 0, function () {
var prep, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
prep.writeAp(4 /* TAR */, addr);
prep.readAp(12 /* DRW */);
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 6]);
return [4 /*yield*/, prep.go()];
case 2: return [2 /*return*/, (_a.sent())[0]];
case 3:
e_1 = _a.sent();
// transfer wait, try again.
return [4 /*yield*/, util_1.delay(100)];
case 4:
// transfer wait, try again.
_a.sent();
return [4 /*yield*/, this.read32(addr)];
case 5: return [2 /*return*/, _a.sent()];
case 6: return [2 /*return*/];
}
});
});
};
/**
* Read a 16-bit word from the specified (half word-aligned) memory address.
*
* @param addr Memory address to read from.
*/
Memory.prototype.read16 = function (addr) {
return __awaiter(this, void 0, void 0, function () {
var prep, val, e_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 1 /* CSW_SIZE16 */);
prep.writeAp(4 /* TAR */, addr);
prep.readAp(12 /* DRW */);
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 6]);
return [4 /*yield*/, prep.go()];
case 2:
val = (_a.sent())[0];
return [3 /*break*/, 6];
case 3:
e_2 = _a.sent();
// transfer wait, try again.
return [4 /*yield*/, util_1.delay(100)];
case 4:
// transfer wait, try again.
_a.sent();
return [4 /*yield*/, this.read16(addr)];
case 5:
val = _a.sent();
return [3 /*break*/, 6];
case 6:
val = (val >> ((addr & 0x02) << 3) & 0xffff);
return [2 /*return*/, val];
}
});
});
};
/**
* Reads a block of memory from the specified memory address.
*
* @param addr Address to read from
* @param words Number of words to read
* @param pageSize Memory page size
*/
Memory.prototype.readBlock = function (addr, words, pageSize) {
return __awaiter(this, void 0, void 0, function () {
var bufs, end, ptr, nextptr, len, _a, _b, result;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
bufs = [];
end = addr + words * 4;
ptr = addr;
_c.label = 1;
case 1:
if (!(ptr < end)) return [3 /*break*/, 3];
nextptr = ptr + pageSize;
if (ptr === addr) {
nextptr &= ~(pageSize - 1);
}
len = Math.min(nextptr - ptr, end - ptr);
util_1.assert((len & 3) === 0);
_b = (_a = bufs).push;
return [4 /*yield*/, this.readBlockCore(ptr, len >> 2)];
case 2:
_b.apply(_a, [_c.sent()]);
ptr = nextptr;
return [3 /*break*/, 1];
case 3:
result = util_1.bufferConcat(bufs);
return [2 /*return*/, result.subarray(0, words * 4)];
}
});
});
};
/**
* Write a block of memory to the specified memory address.
*
* @param addr Memory address to write to.
* @param words Array of 32-bit words to write to memory.
*/
Memory.prototype.writeBlock = function (addr, words) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
if (words.length === 0) {
return [2 /*return*/];
}
return [2 /*return*/, this.writeBlockCore(addr, words)];
});
});
};
Memory.prototype.prepareCommand = function () {
return new prepared_1.PreparedMemoryCommand(this.dev);
};
Memory.prototype.readBlockCore = function (addr, words) {
return __awaiter(this, void 0, void 0, function () {
var prep, lastSize, blocks, i, b;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
prep.writeAp(4 /* TAR */, addr);
return [4 /*yield*/, prep.go()];
case 1:
_a.sent();
lastSize = words % 15;
if (lastSize === 0) {
lastSize = 15;
}
blocks = [];
i = 0;
_a.label = 2;
case 2:
if (!(i < Math.ceil(words / 15))) return [3 /*break*/, 5];
return [4 /*yield*/, this.dev.readRegRepeat(util_1.apReg(12 /* DRW */, 2 /* READ */), i === blocks.length - 1 ? lastSize : 15)];
case 3:
b = _a.sent();
blocks.push(b);
_a.label = 4;
case 4:
i++;
return [3 /*break*/, 2];
case 5: return [2 /*return*/, util_1.bufferConcat(blocks).subarray(0, words * 4)];
}
});
});
};
Memory.prototype.writeBlockCore = function (addr, words) {
return __awaiter(this, void 0, void 0, function () {
var prep, e_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 7]);
prep = this.dev.prepareCommand();
prep.writeAp(0 /* CSW */, 587202640 /* CSW_VALUE */ | 2 /* CSW_SIZE32 */);
prep.writeAp(4 /* TAR */, addr);
prep.writeRegRepeat(util_1.apReg(12 /* DRW */, 0 /* WRITE */), words);
return [4 /*yield*/, prep.go()];
case 1:
_a.sent();
return [3 /*break*/, 7];
case 2:
e_3 = _a.sent();
if (!e_3.dapWait) return [3 /*break*/, 5];
console.debug("transfer wait, write block");
return [4 /*yield*/, util_1.delay(100)];
case 3:
_a.sent();
return [4 /*yield*/, this.writeBlockCore(addr, words)];
case 4: return [2 /*return*/, _a.sent()];
case 5: throw e_3;
case 6: return [3 /*break*/, 7];
case 7: return [2 /*return*/];
}
});
});
};
return Memory;
}());
exports.Memory = Memory;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var prepared_1 = __webpack_require__(1);
/**
* # Cortex M: Prepared Command
*
* Allows batching of Cortex M-related commands, such as writing to a register,
* halting and resuming the core.
*
* ## Example
*
* When preparing the sequence of commands, we can use the same API to prepare
* a command as we would to execute them immediately.
*
* ```typescript
* // Note that only the .go method is asynchronous.
*
* const prep = core.prepareCommand();
* prep.writeCoreRegister(CortexReg.R0, 0x1000);
* prep.writeCoreRegister(CortexReg.R1, 0x0);
* prep.writeCoreRegister(CortexReg.PC, 0x2000000);
* prep.resume();
* ```
*
* We can then execute them as efficiently as possible by combining them together
* and executing them like so.
*
* ```typescript
* await prep.go();
* ```
*
* The code above is equivalent to the following _non-prepared_ command:
*
* ```typescript
* await core.writeCoreRegister(CortexReg.R0, 0x1000);
* await core.writeCoreRegister(CortexReg.R1, 0x0);
* await core.writeCoreRegister(CortexReg.PC, 0x2000000);
* await core.resume();
* ```
*
* Since the batched version of this code avoids making three round-trips to the
* target, we are able to significantly improve performance. This is especially
* noticable when uploading a binary to flash memory, where are large number of
* repetetive commands are being used.
*
* ## Explanation
*
* For a detailed explanation of why prepared commands are used in DAP.js, see the
* documentation for `PreparedDapCommand`.
*/
var PreparedCortexMCommand = (function () {
function PreparedCortexMCommand(dap) {
this.cmd = new prepared_1.PreparedMemoryCommand(dap);
}
/**
* Schedule a 32-bit integer to be written to a core register.
*
* @param no Core register to be written.
* @param val Value to write.
*/
PreparedCortexMCommand.prototype.writeCoreRegister = function (no, val) {
this.cmd.write32(3758157304 /* DCRDR */, val);
this.cmd.write32(3758157300 /* DCRSR */, no | 65536 /* DCRSR_REGWnR */);
};
/**
* Schedule a halt command to be written to the CPU.
*/
PreparedCortexMCommand.prototype.halt = function () {
this.cmd.write32(3758157296 /* DHCSR */, -1604386816 /* DBGKEY */ | 1 /* C_DEBUGEN */ | 2 /* C_HALT */);
};
/**
* Schedule a resume command to be written to the CPU.
*/
PreparedCortexMCommand.prototype.resume = function () {
this.cmd.write32(3758157104 /* DFSR */, 4 /* DFSR_DWTTRAP */ | 2 /* DFSR_BKPT */ | 1 /* DFSR_HALTED */);
};
/**
* Execute all scheduled commands.
*/
PreparedCortexMCommand.prototype.go = function () {
return __awaiter(this, void 0, void 0, function () {
var v;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.cmd.go()];
case 1:
v = _a.sent();
return [2 /*return*/];
}
});
});
};
return PreparedCortexMCommand;
}());
exports.PreparedCortexMCommand = PreparedCortexMCommand;
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var prepared_1 = __webpack_require__(10);
var cmsis_dap_1 = __webpack_require__(11);
var util_1 = __webpack_require__(0);
var DAP = (function () {
function DAP(device) {
this.device = device;
this.dap = new cmsis_dap_1.CMSISDAP(device);
}
DAP.prototype.reconnect = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.dap.disconnect()];
case 1:
_a.sent();
return [4 /*yield*/, util_1.delay(100)];
case 2:
_a.sent();
return [4 /*yield*/, this.init()];
case 3:
_a.sent();
return [2 /*return*/];
}
});
});
};
DAP.prototype.init = function () {
return __awaiter(this, void 0, void 0, function () {
var n, prep, m, v;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.dap.connect()];
case 1:
_a.sent();
return [4 /*yield*/, this.readDp(0 /* IDCODE */)];
case 2:
n = _a.sent();
this.idcode = n;
prep = this.prepareCommand();
prep.writeReg(0 /* DP_0x0 */, 1 << 2); // clear sticky error
prep.writeDp(2 /* SELECT */, 0);
prep.writeDp(1 /* CTRL_STAT */, 1073741824 /* CSYSPWRUPREQ */ | 268435456 /* CDBGPWRUPREQ */);
m = 536870912 /* CDBGPWRUPACK */ | 2147483648 /* CSYSPWRUPACK */;
prep.readDp(1 /* CTRL_STAT */);
return [4 /*yield*/, prep.go()];
case 3:
v = (_a.sent())[0];
_a.label = 4;
case 4:
if (!((v & m) !== m)) return [3 /*break*/, 6];
return [4 /*yield*/, this.readDp(1 /* CTRL_STAT */)];
case 5:
v = _a.sent();
return [3 /*break*/, 4];
case 6:
prep = this.prepareCommand();
prep.writeDp(1 /* CTRL_STAT */, (1073741824 /* CSYSPWRUPREQ */ |
268435456 /* CDBGPWRUPREQ */ |
0 /* TRNNORMAL */ |
3840 /* MASKLANE */));
prep.writeDp(2 /* SELECT */, 0);
prep.readAp(252 /* IDR */);
return [4 /*yield*/, prep.go()];
case 7:
_a.sent();
return [2 /*return*/];
}
});
});
};
DAP.prototype.writeReg = function (regId, val) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.regOp(regId, val)];
});
});
};
DAP.prototype.readReg = function (regId) {
return __awaiter(this, void 0, void 0, function () {
var buf, v;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.regOp(regId, null)];
case 1:
buf = _a.sent();
v = util_1.readUInt32LE(buf, 3);
return [2 /*return*/, v];
}
});
});
};
DAP.prototype.prepareCommand = function () {
return new prepared_1.PreparedDapCommand(this.dap);
};
DAP.prototype.readDp = function (addr) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.readReg(addr)];
});
});
};
DAP.prototype.readAp = function (addr) {
return __awaiter(this, void 0, void 0, function () {
var prep;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
prep = this.prepareCommand();
prep.writeDp(2 /* SELECT */, util_1.bank(addr));
prep.readReg(util_1.apReg(addr, 2 /* READ */));
return [4 /*yield*/, prep.go()];
case 1: return [2 /*return*/, (_a.sent())[0]];
}
});
});
};
DAP.prototype.writeDp = function (addr, data) {
if (addr === 2 /* SELECT */) {
if (data === this.dpSelect) {
return Promise.resolve();
}
this.dpSelect = data;
}
return this.writeReg(addr, data);
};
DAP.prototype.writeAp = function (addr, data) {
return __awaiter(this, void 0, void 0, function () {
var prep;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (addr === 0 /* CSW */) {
if (data === this.csw) {
return [2 /*return*/, Promise.resolve()];
}
this.csw = data;
}
prep = this.prepareCommand();
prep.writeDp(2 /* SELECT */, util_1.bank(addr));
prep.writeReg(util_1.apReg(addr, 0 /* WRITE */), data);
return [4 /*yield*/, prep.go()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
DAP.prototype.close = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.device.close()];
});
});
};
DAP.prototype.readRegRepeat = function (regId, cnt) {
return __awaiter(this, void 0, void 0, function () {
var request, sendargs, i, buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
util_1.assert(cnt <= 15);
request = util_1.regRequest(regId);
sendargs = [0, cnt];
for (i = 0; i < cnt; ++i) {
sendargs.push(request);
}
return [4 /*yield*/, this.dap.cmdNums(5 /* DAP_TRANSFER */, sendargs)];
case 1:
buf = _a.sent();
if (buf[1] !== cnt) {
throw new Error(("(many) Bad #trans " + buf[1]));
}
else if (buf[2] !== 1) {
throw new Error(("(many) Bad transfer status " + buf[2]));
}
return [2 /*return*/, buf.subarray(3, 3 + cnt * 4)];
}
});
});
};
DAP.prototype.writeRegRepeat = function (regId, data) {
return __awaiter(this, void 0, void 0, function () {
var remainingLength, request, sendargs, buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
remainingLength = 64 - 1 - 1 - 2 - 1;
util_1.assert(data.length <= remainingLength / 4);
request = util_1.regRequest(regId, true);
sendargs = [0, data.length, 0, request];
data.forEach(function (d) {
// separate d into bytes
util_1.addInt32(sendargs, d);
});
return [4 /*yield*/, this.dap.cmdNums(6 /* DAP_TRANSFER_BLOCK */, sendargs)];
case 1:
buf = _a.sent();
if (buf[3] !== 1) {
throw new Error(("(many-wr) Bad transfer status " + buf[2]));
}
return [2 /*return*/];
}
});
});
};
DAP.prototype.regOp = function (regId, val) {
return __awaiter(this, void 0, void 0, function () {
var request, sendargs, buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
request = util_1.regRequest(regId, val !== null);
sendargs = [0, 1, request];
if (val !== null) {
util_1.addInt32(sendargs, val);
}
return [4 /*yield*/, this.dap.cmdNums(5 /* DAP_TRANSFER */, sendargs)];
case 1:
buf = _a.sent();
if (buf[1] !== 1) {
console.error("Make sure you have initialised the DAP connection.");
throw new Error(("Bad #trans " + buf[1]));
}
else if (buf[2] !== 1) {
if (buf[2] === 2) {
throw new Error(("Transfer wait"));
}
throw new Error(("Bad transfer status " + buf[2]));
}
return [2 /*return*/, buf];
}
});
});
};
return DAP;
}());
exports.default = DAP;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = __webpack_require__(0);
/**
* # Prepared DAP Command
*
* Batches together multiple Debug Access Port (DAP) commands into one (or more)
* CMSIS-DAP Transfers that can be written together to improve link utilisation.
*
* > **NOTE:** this will not normally need to be used by applications or libraries
* > depending on DAP.js.
*
* ## Architecture
*
* - `PreparedDapCommand` keeps a list of CMSIS-DAP `Transfer` commands.
* - Every time an action is scheduled (writing to or reading from a DP or AP register),
* we check to see if there is any remaining room in the current batch, starting a new
* batch if none is available.
* - When `go` is called, the batches are executed sequentially (so DAP commands are
* executed in the order they were added).
*
* ### Reading Values
*
* Writing values to registers is relatively straight forward, however mixing register
* reads and writes together requires us to keep track of how many commands in
* each batch are read commands.
*
* Once data has successfully been read back from the target, the values read are assembled
* into an array, and returned in the order they requested. This allows `PreparedDapCommand`s
* to be used higher up the stack in places where multiple independent read operations take
* place sequentially.
*
* ### Constructing CMSIS-DAP Commands
*
* We keep track of the number of commands in each batch, so that we can fill in the command
* count field of the `DAP_Transfer`.
*/
var PreparedDapCommand = (function () {
function PreparedDapCommand(dap) {
this.dap = dap;
this.commands = [[0, 1]];
this.commandCounts = [0];
this.currentCommand = 0;
this.readCounts = [0];
}
/**
* Schedule a value to be written to an AP or DP register.
*
* @param regId register ID to be written to
* @param value value to be written
*/
PreparedDapCommand.prototype.writeReg = function (regId, value) {
var request = util_1.regRequest(regId, true);
if (this.commands[this.currentCommand].length + 5 > 64) {
// start a new command
this.commands.push([0, 1]);
this.commandCounts.push(0);
this.readCounts.push(0);
this.currentCommand++;
}
this.commands[this.currentCommand].push(request);
util_1.addInt32(this.commands[this.currentCommand], value);
this.commandCounts[this.currentCommand]++;
};
/**
* Schedule a value to be read from an AP or DP register.
* @param regId register to read from
*/
PreparedDapCommand.prototype.readReg = function (regId) {
var request = util_1.regRequest(regId, false);
if (this.commands[this.currentCommand].length + 1 > 64) {
// start a new command
this.commands.push([0, 1]);
this.commandCounts.push(0);
this.readCounts.push(0);
this.currentCommand++;
}
this.commands[this.currentCommand].push(request);
this.commandCounts[this.currentCommand]++;
this.readCounts[this.currentCommand]++;
};
/**
* Schedule multiple values to be written to the same register.
*
* **TODO:** figure out dynamically whether it's better to use DAP_TransferBlock vs
* DAP_Transfer. We should be able to fill up the remaining space in a Transfer
* and then start a TransferBlock _if_ we can fit in _13 or more_ values into the
* TransferBlock. However, the gains from this are marginal unless we're using much
* larger packet sizes than 64 bytes.
*
* @param regId register to write to repeatedly
* @param data array of 32-bit values to be written
*/
PreparedDapCommand.prototype.writeRegRepeat = function (regId, data) {
var _this = this;
// fill up the rest of the command we have left
data.forEach(function (cmd) {
_this.writeReg(regId, cmd);
});
};
/**
* Asynchronously execute the commands scheduled.
*/
PreparedDapCommand.prototype.go = function () {
return __awaiter(this, void 0, void 0, function () {
var v, i, command, results, i, result, j;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
v = [];
for (i = 0; i < this.commands.length; i++) {
command = this.commands[i];
command[1] = this.commandCounts[i];
}
return [4 /*yield*/, this.dap.sendTransfers(this.commands)];
case 1:
results = _a.sent();
for (i = 0; i < this.commands.length; i++) {
result = results[i];
for (j = 0; j < this.readCounts[i]; j++) {
v.push(util_1.readUInt32LE(result, 3 + 4 * j));
}
}
return [2 /*return*/, v];
}
});
});
};
/**
* Schedule a value to be written to a DP register
*
* @param addr Address to write to
* @param data Data to be written
*/
PreparedDapCommand.prototype.writeDp = function (addr, data) {
if (addr === 2 /* SELECT */) {
if (data === this.dpSelect) {
return Promise.resolve();
}
this.dpSelect = data;
}
return this.writeReg(addr, data);
};
/**
* Schedule a value to be written to an AP register
*
* @param addr Address to write to
* @param data Data to be written
*/
PreparedDapCommand.prototype.writeAp = function (addr, data) {
this.writeDp(2 /* SELECT */, util_1.bank(addr));
if (addr === 0 /* CSW */) {
if (data === this.csw) {
return Promise.resolve();
}
this.csw = data;
}
this.writeReg(util_1.apReg(addr, 0 /* WRITE */), data);
};
/**
* Schedule a DP register to read from
*
* @param addr Address to read from
*/
PreparedDapCommand.prototype.readDp = function (addr) {
return this.readReg(addr);
};
/**
* Schedule an AP register to read from
*
* @param addr Address to read from
*/
PreparedDapCommand.prototype.readAp = function (addr) {
this.writeDp(2 /* SELECT */, util_1.bank(addr));
return this.readReg(util_1.apReg(addr, 2 /* READ */));
};
return PreparedDapCommand;
}());
exports.PreparedDapCommand = PreparedDapCommand;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = __webpack_require__(0);
var CMSISDAP = (function () {
function CMSISDAP(hid) {
this.maxSent = 1;
this.hid = hid;
}
CMSISDAP.prototype.resetTarget = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.cmdNums(10 /* DAP_RESET_TARGET */, [])];
});
});
};
CMSISDAP.prototype.disconnect = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.cmdNums(3 /* DAP_DISCONNECT */, [])];
});
});
};
CMSISDAP.prototype.sendTransfers = function (commands) {
return __awaiter(this, void 0, void 0, function () {
var res, _i, commands_1, cmd, _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
if (this.hid.sendMany)
return [2 /*return*/, this.hid.sendMany(commands.map(function (cmd) {
cmd.unshift(5 /* DAP_TRANSFER */);
return Uint8Array.from(cmd);
})).then(function (bufs) {
for (var _i = 0, bufs_1 = bufs; _i < bufs_1.length; _i++) {
var buf = bufs_1[_i];
if (buf[0] != 5 /* DAP_TRANSFER */)
throw new Error("Bad response for Transfer (many) -> " + buf[0]);
}
return bufs;
})];
res = [];
_i = 0, commands_1 = commands;
_c.label = 1;
case 1:
if (!(_i < commands_1.length)) return [3 /*break*/, 4];
cmd = commands_1[_i];
_b = (_a = res).push;
return [4 /*yield*/, this.cmdNums(5 /* DAP_TRANSFER */, cmd)];
case 2:
_b.apply(_a, [_c.sent()]);
_c.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, res];
}
});
});
};
CMSISDAP.prototype.cmdNums = function (op, data) {
return __awaiter(this, void 0, void 0, function () {
var buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
data.unshift(op);
return [4 /*yield*/, this.send(data)];
case 1:
buf = _a.sent();
if (buf[0] !== op) {
throw new Error("Bad response for " + op + " -> " + buf[0]);
}
switch (op) {
case 2 /* DAP_CONNECT */:
case 0 /* DAP_INFO */:
case 5 /* DAP_TRANSFER */:
case 6 /* DAP_TRANSFER_BLOCK */:
break;
default:
if (op < 0x80 && buf[1] !== 0) {
throw new Error("Bad status for " + op + " -> " + buf[1]);
}
}
return [2 /*return*/, buf];
}
});
});
};
CMSISDAP.prototype.connect = function () {
return __awaiter(this, void 0, void 0, function () {
var v, buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
console.log("Connecting...");
return [4 /*yield*/, this.info(254 /* PACKET_COUNT */)];
case 1:
v = _a.sent();
if (v) {
this.maxSent = v;
}
else {
throw new Error("DAP_INFO returned invalid packet count.");
}
return [4 /*yield*/, this.cmdNums(17 /* DAP_SWJ_CLOCK */, util_1.addInt32(null, 10000000))];
case 2:
_a.sent();
return [4 /*yield*/, this.cmdNums(2 /* DAP_CONNECT */, [0])];
case 3:
buf = _a.sent();
if (buf[1] !== 1) {
throw new Error("SWD mode not enabled.");
}
return [4 /*yield*/, this.cmdNums(17 /* DAP_SWJ_CLOCK */, util_1.addInt32(null, 10000000))];
case 4:
_a.sent();
return [4 /*yield*/, this.cmdNums(4 /* DAP_TRANSFER_CONFIGURE */, [0, 0x50, 0, 0, 0])];
case 5:
_a.sent();
return [4 /*yield*/, this.cmdNums(19 /* DAP_SWD_CONFIGURE */, [0])];
case 6:
_a.sent();
return [4 /*yield*/, this.jtagToSwd()];
case 7:
_a.sent();
console.log("Connected");
return [2 /*return*/];
}
});
});
};
CMSISDAP.prototype.jtagToSwd = function () {
return __awaiter(this, void 0, void 0, function () {
var arrs, _i, arrs_1, arr;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
arrs = [
[56, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
[16, 0x9e, 0xe7],
[56, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
[8, 0x00],
];
_i = 0, arrs_1 = arrs;
_a.label = 1;
case 1:
if (!(_i < arrs_1.length)) return [3 /*break*/, 4];
arr = arrs_1[_i];
return [4 /*yield*/, this.swjSequence(arr)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/];
}
});
});
};
CMSISDAP.prototype.swjSequence = function (data) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, this.cmdNums(18 /* DAP_SWJ_SEQUENCE */, data)];
});
});
};
CMSISDAP.prototype.info = function (id) {
return __awaiter(this, void 0, void 0, function () {
var buf;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.cmdNums(0 /* DAP_INFO */, [id])];
case 1:
buf = _a.sent();
if (buf[1] === 0) {
return [2 /*return*/, null];
}
switch (id) {
case 240 /* CAPABILITIES */:
case 254 /* PACKET_COUNT */:
case 255 /* PACKET_SIZE */:
if (buf[1] === 1) {
return [2 /*return*/, buf[2]];
}
else if (buf[1] === 2) {
return [2 /*return*/, buf[3] << 8 | buf[2]];
}
}
return [2 /*return*/, buf.subarray(2, buf[1] + 2 - 1)]; // .toString("utf8")
}
});
});
};
CMSISDAP.prototype.send = function (command) {
return __awaiter(this, void 0, void 0, function () {
var array, response;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
array = Uint8Array.from(command);
return [4 /*yield*/, this.hid.write(array.buffer)];
case 1:
_a.sent();
return [4 /*yield*/, this.hid.read()];
case 2:
response = _a.sent();
return [2 /*return*/, new Uint8Array(response.buffer)];
}
});
});
};
return CMSISDAP;
}());
exports.CMSISDAP = CMSISDAP;
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [0, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var cortex_1 = __webpack_require__(2);
var K64F_1 = __webpack_require__(13);
var NRF51_1 = __webpack_require__(14);
var analyzer = new Uint32Array([
0x2180468c, 0x2600b5f0, 0x4f2c2501, 0x447f4c2c, 0x1c2b0049, 0x425b4033, 0x40230872, 0x085a4053,
0x425b402b, 0x40534023, 0x402b085a, 0x4023425b, 0x085a4053, 0x425b402b, 0x40534023, 0x402b085a,
0x4023425b, 0x085a4053, 0x425b402b, 0x40534023, 0x402b085a, 0x4023425b, 0x085a4053, 0x425b402b,
0x40534023, 0xc7083601, 0xd1d2428e, 0x2b004663, 0x4663d01f, 0x46b4009e, 0x24ff2701, 0x44844d11,
0x1c3a447d, 0x88418803, 0x4351409a, 0xd0122a00, 0x22011856, 0x780b4252, 0x40533101, 0x009b4023,
0x0a12595b, 0x42b1405a, 0x43d2d1f5, 0x4560c004, 0x2000d1e7, 0x2200bdf0, 0x46c0e7f8, 0x000000b6,
0xedb88320, 0x00000044,
]);
var FlashTarget = (function (_super) {
__extends(FlashTarget, _super);
function FlashTarget(device, platform) {
var _this = _super.call(this, device) || this;
_this.platform = platform;
_this.inited = false;
return _this;
}
/**
* Initialise the flash driver on the chip. Must be called before any of the other
* flash-related methods.
*/
FlashTarget.prototype.flashInit = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this.inited) {
return [2 /*return*/];
}
// reset and halt
return [4 /*yield*/, this.reset(true)];
case 1:
// reset and halt
_a.sent();
// make sure we're in Thumb mode.
return [4 /*yield*/, this.writeCoreRegister(16 /* XPSR */, 1 << 24)];
case 2:
// make sure we're in Thumb mode.
_a.sent();
return [4 /*yield*/, this.writeCoreRegister(9 /* R9 */, this.platform.flashAlgo.staticBase)];
case 3:
_a.sent();
if (!this.platform.flashAlgo.analyzerSupported) return [3 /*break*/, 5];
return [4 /*yield*/, this.memory.writeBlock(this.platform.flashAlgo.analyzerAddress, analyzer)];
case 4:
_a.sent();
_a.label = 5;
case 5: return [4 /*yield*/, this.runCode(this.platform.flashAlgo.instructions, this.platform.flashAlgo.loadAddress, this.platform.flashAlgo.pcInit, this.platform.flashAlgo.loadAddress + 1, this.platform.flashAlgo.stackPointer, true, 0, 0, 0, 0)];
case 6:
result = _a.sent();
this.inited = true;
return [2 /*return*/, result];
}
});
});
};
/**
* Erase _all_ data stored in flash on the chip.
*/
FlashTarget.prototype.eraseChip = function () {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!!this.inited) return [3 /*break*/, 2];
return [4 /*yield*/, this.flashInit()];
case 1:
_a.sent();
_a.label = 2;
case 2: return [4 /*yield*/, this.runCode(this.platform.flashAlgo.instructions, this.platform.flashAlgo.loadAddress, this.platform.flashAlgo.pcEraseAll, this.platform.flashAlgo.loadAddress + 1, this.platform.flashAlgo.stackPointer, false, 0, 0, 0)];
case 3:
result = _a.sent();
return [2 /*return*/, result];
}
});
});
};
/**
* Upload a program to flash memory on the chip.
* TODO: add a callback to provide progress data
*
* @param data Array of 32-bit integers to write to flash.
*/
FlashTarget.prototype.flash = function (data, address, progressCb) {
return __awaiter(this, void 0, void 0, function () {
var pageSizeWords, bufferAddress, flashStart, ptr, wordPtr, pageData, flashAddress;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!!this.inited) return [3 /*break*/, 2];
return [4 /*yield*/, this.flashInit()];
case 1:
_a.sent();
_a.label = 2;
case 2:
pageSizeWords = this.platform.flashAlgo.pageSize / 4;
bufferAddress = this.platform.flashAlgo.pageBuffers[0];
flashStart = address || this.platform.flashAlgo.flashStart;
ptr = 0;
_a.label = 3;
case 3:
if (!(ptr < data.byteLength)) return [3 /*break*/, 6];
wordPtr = ptr / 4;
pageData = data.subarray(wordPtr, wordPtr + pageSizeWords);
flashAddress = flashStart + ptr;
return [4 /*yield*/, this.memory.writeBlock(bufferAddress, pageData)];
case 4:
_a.sent();
return [4 /*yield*/, this.runCode(this.platform.flashAlgo.instructions, this.platform.flashAlgo.loadAddress, this.platform.flashAlgo.pcProgramPage, // pc
this.platform.flashAlgo.loadAddress + 1, // lr
this.platform.flashAlgo.stackPointer, // sp
/* upload? */
false,
/* args */
flashAddress, this.platform.flashAlgo.pageSize, bufferAddress)];
case 5:
_a.sent();
if (progressCb) {
progressCb(ptr / data.byteLength);
}
ptr += pageData.byteLength;
return [3 /*break*/, 3];
case 6:
if (progressCb) {
progressCb(1.0);
}
return [2 /*return*/];
}
});
});
};
FlashTarget.prototype.program = function (program, progressCb) {
return __awaiter(this, void 0, void 0, function () {
var totalBytes, cumulativeBytes, startTime, _loop_1, this_1, _i, _a, section, endTime, elapsedTime, transferRate;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, this.flashInit()];
case 1:
_b.sent();
return [4 /*yield*/, this.eraseChip()];
case 2:
_b.sent();
totalBytes = program.totalByteLength();
cumulativeBytes = 0;
startTime = Date.now();
_loop_1 = function (section) {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this_1.flash(section.data, section.address, function (progress) {
var sectionBytes = section.data.byteLength * progress;
progressCb((cumulativeBytes + sectionBytes) / totalBytes);
})];
case 1:
_a.sent();
cumulativeBytes += section.data.byteLength;
return [2 /*return*/];
}
});
};
this_1 = this;
_i = 0, _a = program.sections;
_b.label = 3;
case 3:
if (!(_i < _a.length)) return [3 /*break*/, 6];
section = _a[_i];
return [5 /*yield**/, _loop_1(section)];
case 4:
_b.sent();
_b.label = 5;
case 5:
_i++;
return [3 /*break*/, 3];
case 6:
endTime = Date.now();
elapsedTime = endTime - startTime;
transferRate = totalBytes / elapsedTime;
console.debug("Transfer took " + elapsedTime / 1000 + " s");
console.debug("Transfered " + totalBytes + " bytes at " + transferRate + " kB/s");
return [4 /*yield*/, this.flashUnInit()];
case 7:
_b.sent();
progressCb(1.0);
return [2 /*return*/];
}
});
});
};
FlashTarget.prototype.flashUnInit = function () {
this.inited = false;
};
return FlashTarget;
}(cortex_1.CortexM));
exports.FlashTarget = FlashTarget;
exports.FlashTargets = new Map();
exports.FlashTargets.set("0240", new K64F_1.K64F());
exports.FlashTargets.set("9900", new NRF51_1.NRF51());
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var K64F_FLASH_ALGO = {
analyzerAddress: 0x1ffff000,
analyzerSupported: true,
flashSize: 0x100000,
flashStart: 0x0,
// Flash algorithm as a hex string
instructions: new Uint32Array([
0xE00ABE00, 0x062D780D, 0x24084068, 0xD3000040, 0x1E644058, 0x1C49D1FA, 0x2A001E52, 0x4770D1F2,
0x4604b570, 0x4616460d, 0x5020f24c, 0x81c84932, 0x1028f64d, 0x460881c8, 0xf0208800, 0x80080001,
0x4448482e, 0xf8dcf000, 0x2001b108, 0x2000bd70, 0x4601e7fc, 0x47702000, 0x4929b510, 0x44484827,
0xf8b8f000, 0xb92c4604, 0x48242100, 0xf0004448, 0x4604f9a9, 0xf837f000, 0xbd104620, 0x4604b570,
0x4448481e, 0x46214b1e, 0xf00068c2, 0x4605f85d, 0x481ab93d, 0x23004448, 0x68c24621, 0xf946f000,
0xf0004605, 0x4628f820, 0xb5febd70, 0x460c4605, 0x46234616, 0x46294632, 0x44484810, 0xf8f8f000,
0xb9674607, 0x22012000, 0x2000e9cd, 0x46224633, 0x90024629, 0x44484809, 0xf984f000, 0xf0004607,
0x4638f802, 0x4807bdfe, 0xf4206840, 0xf5000070, 0x49040070, 0x47706048, 0x40052000, 0x00000004,
0x6b65666b, 0x4001f000, 0x4a0e2070, 0x20807010, 0xbf007010, 0x7800480b, 0x280009c0, 0x4809d0fa,
0xf0017801, 0xb1080020, 0x47702067, 0x0010f001, 0x2068b108, 0xf001e7f9, 0xb1080001, 0xe7f42069,
0xe7f22000, 0x40020000, 0x4df0e92d, 0x460d4604, 0x469a4690, 0xf0004650, 0x4606f891, 0x4630b116,
0x8df0e8bd, 0x46422310, 0x46204629, 0xf86cf000, 0xb10e4606, 0xe7f34630, 0x0008eb05, 0x68e01e47,
0xf1f0fbb7, 0x7011fb00, 0x68e0b140, 0xf0f0fbb7, 0x0b01f100, 0xfb0068e0, 0x1e47f00b, 0x480be011,
0x68004478, 0x20096005, 0x71c84909, 0xffacf7ff, 0x69a04606, 0x69a0b108, 0xb1064780, 0x68e0e003,
0x42bd4405, 0xbf00d9eb, 0xe7c94630, 0x000002ec, 0x40020000, 0x4604b570, 0x4628460d, 0xf84ef000,
0xb10e4606, 0xbd704630, 0x2004b90c, 0x2044e7fb, 0x71c84902, 0xff88f7ff, 0x0000e7f5, 0x40020000,
0xb9094601, 0x47702004, 0x6cc04826, 0x6003f3c0, 0x447b4b25, 0x0010f833, 0xb90a0302, 0xe7f22064,
0x60082000, 0x2002604a, 0x02c06088, 0x200060c8, 0x61486108, 0xbf006188, 0x4602e7e5, 0x2004b90a,
0x61914770, 0xe7fb2000, 0x4604b530, 0x2004b90c, 0x1e58bd30, 0xb9104008, 0x40101e58, 0x2065b108,
0x6820e7f6, 0xd8054288, 0x0500e9d4, 0x188d4428, 0xd20142a8, 0xe7eb2066, 0xe7e92000, 0x480b4601,
0xd0014281, 0x4770206b, 0xe7fc2000, 0xb90b4603, 0x47702004, 0xd801290f, 0xd0012a04, 0xe7f82004,
0xe7f62000, 0x40048000, 0x0000025a, 0x6b65666b, 0x41f0e92d, 0x46884607, 0x461d4614, 0x2004b914,
0x81f0e8bd, 0x462a2308, 0x46384641, 0xffbcf7ff, 0xb10e4606, 0xe7f34630, 0x4812e01f, 0x68004478,
0x8000f8c0, 0x490fcc01, 0x390c4479, 0x60486809, 0x490ccc01, 0x39184479, 0x60886809, 0x490a2007,
0xf7ff71c8, 0x4606ff01, 0xb10869b8, 0x478069b8, 0xe004b106, 0x0808f108, 0x2d003d08, 0xbf00d1dd,
0xe7cd4630, 0x000001b0, 0x40020000, 0x4dffe92d, 0x4682b082, 0x2310460c, 0x46504621, 0xf7ff9a04,
0x4683ff83, 0x0f00f1bb, 0x4658d003, 0xe8bdb006, 0xe9da8df0, 0xfbb00101, 0x4260f7f1, 0x40084279,
0x42a54245, 0x443dd100, 0xe0229e04, 0x0804eba5, 0xd90045b0, 0xea4f46b0, 0x90011018, 0x4478480f,
0x60046800, 0x490e2001, 0x980171c8, 0x72c80a00, 0x72889801, 0x72489805, 0xfeb6f7ff, 0xf1bb4683,
0xd0010f00, 0xe7d14658, 0x0608eba6, 0x443d4444, 0x2e00bf00, 0x2000d1da, 0x0000e7c8, 0x0000010e,
0x40020000, 0x4604b570, 0xb90c460d, 0xbd702004, 0x49032040, 0x460871c8, 0xf7ff7185, 0xe7f6fe95,
0x40020000, 0x4dffe92d, 0x4617460c, 0xe9dd461d, 0xf8ddb80c, 0xb91da038, 0xb0042004, 0x8df0e8bd,
0x463a2304, 0x98004621, 0xff1ef7ff, 0xb10e4606, 0xe7f24630, 0x4814e022, 0x68004478, 0x20026004,
0x71c84912, 0xf8804608, 0x490fb00b, 0x39144479, 0x68096828, 0xf7ff6088, 0x4606fe67, 0xf1b8b15e,
0xd0010f00, 0x4000f8c8, 0x0f00f1ba, 0x2000d002, 0x0000f8ca, 0x1f3fe004, 0x1d241d2d, 0xd1da2f00,
0x4630bf00, 0x0000e7c9, 0x00000074, 0x40020000, 0x00000000, 0x00080000, 0x00100000, 0x00200000,
0x00400000, 0x00800000, 0x01000000, 0x01000000, 0x40020004, 0x00000000,
]),
loadAddress: 0x20000000,
pageBuffers: [0x20003000, 0x20004000],
pageSize: 0x1000,
// Relative function addresses
pcEraseAll: 0x20000059,
pcEraseSector: 0x2000007D,
pcInit: 0x20000021,
// pcUnInit: 0x49,
pcProgramPage: 0x200000AB,
stackPointer: 0x20001000,
staticBase: 0x20000000 + 0x20 + 0x474,
};
var K64F = (function () {
function K64F() {
this.flashAlgo = K64F_FLASH_ALGO;
}
K64F.prototype.overrideSecurityBits = function (address, data) {
var u8data = new Uint8Array(data.buffer);
// Kinetis security values and addresses
var SECURITY_START = 0x400;
var SECURITY_SIZE = 16;
var FPROT_ADDR = 0x408;
var FPROT_ADDR_END = 0x40c;
var FPROT_SIZE = 4;
var FSEC_ADDR = 0x40c;
var FSEC_VAL = 0xFE;
var FOPT_ADDR = 0x40d;
var FOPT_VAL = 0xFF;
var FEPROT_ADDR = 0x40e;
var FEPROT_VAL = 0xFF;
var FDPROT_ADDR = 0x40f;
var FDPROT_VAL = 0xFF;
if (address <= SECURITY_START && address + u8data.byteLength > SECURITY_START + SECURITY_SIZE) {
for (var i = FPROT_ADDR; i < FPROT_ADDR_END; i++) {
if (u8data[i - address] !== 0xff) {
u8data[i - address] = 0xff;
console.debug("FCF[" + (i - FPROT_ADDR) + "] at addr " + i + " changed to " + u8data[i - address]);
}
}
if (u8data[FSEC_ADDR - address] !== FSEC_VAL) {
u8data[FSEC_ADDR - address] = FSEC_VAL;
console.debug("FSEC at addr " + FSEC_ADDR + " changed to " + FSEC_VAL);
}
if (u8data[FOPT_ADDR - address] === 0x00) {
console.debug("FOPT set to restricted value 0x00");
}
if (u8data[FEPROT_ADDR - address] !== FEPROT_VAL) {
u8data[FEPROT_ADDR - address] = FEPROT_VAL;
console.debug("FEPROT at addr " + FEPROT_ADDR + " changed to " + FEPROT_VAL);
}
if (u8data[FDPROT_ADDR - address] !== FDPROT_VAL) {
u8data[FDPROT_ADDR - address] = FDPROT_VAL;
console.debug("FDPROT at addr " + FDPROT_ADDR + " changed to " + FDPROT_VAL);
}
}
};
return K64F;
}());
exports.K64F = K64F;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var NRF51_FLASH_ALGO = {
analyzerAddress: 0x20003000,
analyzerSupported: true,
beginData: 0x20002000,
flashSize: 0x40000,
flashStart: 0x0,
instructions: new Uint32Array([
0xE00ABE00, 0x062D780D, 0x24084068, 0xD3000040, 0x1E644058, 0x1C49D1FA, 0x2A001E52, 0x4770D1F2,
0x47702000, 0x47702000, 0x4c26b570, 0x60602002, 0x60e02001, 0x68284d24, 0xd00207c0, 0x60602000,
0xf000bd70, 0xe7f6f82c, 0x4c1eb570, 0x60612102, 0x4288491e, 0x2001d302, 0xe0006160, 0x4d1a60a0,
0xf81df000, 0x07c06828, 0x2000d0fa, 0xbd706060, 0x4605b5f8, 0x4813088e, 0x46142101, 0x4f126041,
0xc501cc01, 0x07c06838, 0x1e76d006, 0x480dd1f8, 0x60412100, 0xbdf84608, 0xf801f000, 0x480ce7f2,
0x06006840, 0xd00b0e00, 0x6849490a, 0xd0072900, 0x4a0a4909, 0xd00007c3, 0x1d09600a, 0xd1f90840,
0x00004770, 0x4001e500, 0x4001e400, 0x10001000, 0x40010400, 0x40010500, 0x40010600, 0x6e524635,
0x00000000,
]),
loadAddress: 0x20000000,
minProgramLength: 4,
pageBuffers: [0x20002000, 0x20002400],
pageSize: 0x400,
pcEraseAll: 0x20000029,
pcEraseSector: 0x20000049,
pcInit: 0x20000021,
pcProgramPage: 0x20000071,
stackPointer: 0x20001000,
staticBase: 0x20000170,
};
var NRF51 = (function () {
function NRF51() {
this.flashAlgo = NRF51_FLASH_ALGO;
}
NRF51.prototype.overrideSecurityBits = function (address, data) {
/* empty */
};
return NRF51;
}());
exports.NRF51 = NRF51;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = __webpack_require__(0);
var FlashSection = (function () {
function FlashSection(address, data) {
this.address = address;
this.data = data;
/* empty */
}
FlashSection.prototype.toString = function () {
return this.data.byteLength + " bytes @ " + this.address.toString(16);
};
return FlashSection;
}());
exports.FlashSection = FlashSection;
var FlashProgram = (function () {
function FlashProgram(sections) {
this.sections = sections;
}
FlashProgram.fromIntelHex = function (hex) {
var lines = hex.split(/\n/);
var upperAddr = 0;
var startAddr = 0;
var current = null;
var chunks = [];
for (var i = 0; i < lines.length; i++) {
var line = lines[i];
if (line.substr(0, 1) !== ":") {
throw new Error("Invaild line in hex file: " + (i + 1));
}
else {
var length_1 = parseInt(line.substr(1, 2), 16);
var addr = upperAddr + parseInt(line.substr(3, 4), 16);
var fieldType = parseInt(line.substr(7, 2), 16);
var data = line.substr(9, length_1 * 2);
if (fieldType === 0x00) {
if (current && addr !== startAddr + (current.length / 2)) {
// non-contiguous
var sectionData = util_1.hex2bin(current);
chunks.push(new FlashSection(startAddr, new Uint32Array(sectionData.buffer)));
current = "";
startAddr = addr;
}
else if (!current) {
startAddr = addr;
current = "";
}
current += data;
}
else if (fieldType === 0x01) {
// EOF
break;
}
else if (fieldType === 0x02) {
// extended segment address record
upperAddr = parseInt(data, 16) << 4;
}
else if (fieldType === 0x04) {
// extended linear address record
upperAddr = parseInt(data, 16) << 16;
}
}
}
return new FlashProgram(chunks);
};
FlashProgram.fromBinary = function (addr, bin) {
return new FlashProgram([new FlashSection(addr, bin)]);
};
FlashProgram.prototype.totalByteLength = function () {
return this.sections.map(function (s) { return s.data.byteLength; }).reduce(function (x, y) { return x + y; });
};
FlashProgram.prototype.toString = function () {
return this.sections.toString();
};
return FlashProgram;
}());
exports.FlashProgram = FlashProgram;
/***/ })
/******/ ]);
//# sourceMappingURL=dapjs.js.map
Reference in New Issue Copy Permalink