static bool deassert_cs(void) { int ret; if (reset_cs) { ret = jaylink_set_reset(jaylink_devh); if (ret != JAYLINK_OK) { msg_perr("jaylink_set_reset() failed: %s.\n", jaylink_strerror(ret)); return false; } } else { ret = jaylink_jtag_set_trst(jaylink_devh); if (ret != JAYLINK_OK) { msg_perr("jaylink_jtag_set_trst() failed: %s.\n", jaylink_strerror(ret)); return false; } } return true; }
static int jlink_spi_send_command(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt, const unsigned char *writearr, unsigned char *readarr) { uint32_t length; uint8_t *buffer; length = writecnt + readcnt; if (length > JTAG_MAX_TRANSFER_SIZE) return SPI_INVALID_LENGTH; buffer = malloc(length); if (!buffer) { msg_perr("Memory allocation failed.\n"); return SPI_GENERIC_ERROR; } /* Reverse all bytes because the device transfers data LSB first. */ reverse_bytes(buffer, writearr, writecnt); memset(buffer + writecnt, 0x00, readcnt); if (!assert_cs()) { free(buffer); return SPI_PROGRAMMER_ERROR; } int ret; ret = jaylink_jtag_io(jaylink_devh, buffer, buffer, buffer, length * 8, JAYLINK_JTAG_VERSION_2); if (ret != JAYLINK_OK) { msg_perr("jaylink_jag_io() failed: %s.\n", jaylink_strerror(ret)); free(buffer); return SPI_PROGRAMMER_ERROR; } if (!deassert_cs()) { free(buffer); return SPI_PROGRAMMER_ERROR; } /* Reverse all bytes because the device transfers data LSB first. */ reverse_bytes(readarr, buffer + writecnt, readcnt); free(buffer); return 0; }
int jlink_spi_init(void) { char *arg; unsigned long speed = 0; register_shutdown(jlink_spi_shutdown, NULL); arg = extract_programmer_param("spispeed"); if (arg) { char *endptr; errno = 0; speed = strtoul(arg, &endptr, 10); if (*endptr != '\0' || errno != 0) { msg_perr("Invalid SPI speed specified: %s.\n", arg); free(arg); return 1; } if (speed < 1) { msg_perr("SPI speed must be at least 1 kHz.\n"); free(arg); return 1; } } free(arg); int ret; bool use_serial_number; uint32_t serial_number; arg = extract_programmer_param("serial"); if (arg) { if (!strlen(arg)) { msg_perr("Emptpy serial number specified.\n"); free(arg); return 1; } ret = jaylink_parse_serial_number(arg, &serial_number); if (ret == JAYLINK_ERR) { msg_perr("Invalid serial number specified: %s.\n", arg); free(arg); return 1; } if (ret != JAYLINK_OK) { msg_perr("jaylink_parse_serial_number() failed: %s.\n", jaylink_strerror(ret)); free(arg); return 1; } use_serial_number = true; } else { use_serial_number = false; } free(arg); reset_cs = true; arg = extract_programmer_param("cs"); if (arg) { if (!strcasecmp(arg, "reset")) { reset_cs = true; } else if (!strcasecmp(arg, "trst")) { reset_cs = false; } else { msg_perr("Invalid chip select pin specified: '%s'.\n", arg); free(arg); return 1; } } free(arg); if (reset_cs) msg_pdbg("Using RESET as chip select signal.\n"); else msg_pdbg("Using TRST as chip select signal.\n"); ret = jaylink_init(&jaylink_ctx); if (ret != JAYLINK_OK) { msg_perr("jaylink_init() failed: %s.\n", jaylink_strerror(ret)); return 1; } ret = jaylink_discovery_scan(jaylink_ctx, 0); if (ret != JAYLINK_OK) { msg_perr("jaylink_discover_scan() failed: %s.\n", jaylink_strerror(ret)); return 1; } struct jaylink_device **devs; ret = jaylink_get_devices(jaylink_ctx, &devs, NULL); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_devices() failed: %s.\n", jaylink_strerror(ret)); return 1; } if (!use_serial_number) msg_pdbg("No device selected, using first device.\n"); size_t i; struct jaylink_device *dev; bool device_found = false; for (i = 0; devs[i]; i++) { if (use_serial_number) { uint32_t tmp; ret = jaylink_device_get_serial_number(devs[i], &tmp); if (ret == JAYLINK_ERR_NOT_AVAILABLE) { continue; } else if (ret != JAYLINK_OK) { msg_pwarn("jaylink_device_get_serial_number() failed: %s.\n", jaylink_strerror(ret)); continue; } if (serial_number != tmp) continue; } ret = jaylink_open(devs[i], &jaylink_devh); if (ret == JAYLINK_OK) { dev = devs[i]; device_found = true; break; } jaylink_devh = NULL; } jaylink_free_devices(devs, true); if (!device_found) { msg_perr("No J-Link device found.\n"); return 1; } size_t length; char *firmware_version; ret = jaylink_get_firmware_version(jaylink_devh, &firmware_version, &length); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_firmware_version() failed: %s.\n", jaylink_strerror(ret)); return 1; } else if (length > 0) { msg_pdbg("Firmware: %s\n", firmware_version); free(firmware_version); } ret = jaylink_device_get_serial_number(dev, &serial_number); if (ret == JAYLINK_OK) { msg_pdbg("S/N: %" PRIu32 "\n", serial_number); } else if (ret == JAYLINK_ERR_NOT_AVAILABLE) { msg_pdbg("S/N: N/A\n"); } else { msg_perr("jaylink_device_get_serial_number() failed: %s.\n", jaylink_strerror(ret)); return 1; } uint8_t caps[JAYLINK_DEV_EXT_CAPS_SIZE]; memset(caps, 0, sizeof(caps)); ret = jaylink_get_caps(jaylink_devh, caps); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_caps() failed: %s.\n", jaylink_strerror(ret)); return 1; } if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_EXT_CAPS)) { ret = jaylink_get_extended_caps(jaylink_devh, caps); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_available_interfaces() failed: %s.\n", jaylink_strerror(ret)); return 1; } } uint32_t ifaces; ret = jaylink_get_available_interfaces(jaylink_devh, &ifaces); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_available_interfaces() failed: %s.\n", jaylink_strerror(ret)); return 1; } if (!(ifaces & (1 << JAYLINK_TIF_JTAG))) { msg_perr("Device does not support JTAG interface.\n"); return 1; } ret = jaylink_select_interface(jaylink_devh, JAYLINK_TIF_JTAG, NULL); if (ret != JAYLINK_OK) { msg_perr("jaylink_select_interface() failed: %s.\n", jaylink_strerror(ret)); return 1; } struct jaylink_hardware_status hwstat; ret = jaylink_get_hardware_status(jaylink_devh, &hwstat); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_hardware_status() failed: %s.\n", jaylink_strerror(ret)); return 1; } msg_pdbg("VTarget: %u.%03u V\n", hwstat.target_voltage / 1000, hwstat.target_voltage % 1000); if (hwstat.target_voltage < MIN_TARGET_VOLTAGE) { msg_perr("Target voltage is below %u.%03u V. You need to attach VTref to the I/O voltage of " "the chip.\n", MIN_TARGET_VOLTAGE / 1000, MIN_TARGET_VOLTAGE % 1000); return 1; } struct jaylink_speed device_speeds; device_speeds.freq = DEFAULT_FREQ; device_speeds.div = DEFAULT_FREQ_DIV; if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_SPEEDS)) { ret = jaylink_get_speeds(jaylink_devh, &device_speeds); if (ret != JAYLINK_OK) { msg_perr("jaylink_get_speeds() failed: %s.\n", jaylink_strerror(ret)); return 1; } } device_speeds.freq /= 1000; msg_pdbg("Maximum SPI speed: %" PRIu32 " kHz\n", device_speeds.freq / device_speeds.div); if (!speed) { speed = device_speeds.freq / device_speeds.div; msg_pdbg("SPI speed not specified, using %lu kHz.\n", speed); } if (speed > (device_speeds.freq / device_speeds.div)) { msg_perr("Specified SPI speed of %lu kHz is too high. Maximum is %" PRIu32 " kHz.\n", speed, device_speeds.freq / device_speeds.div); return 1; } ret = jaylink_set_speed(jaylink_devh, speed); if (ret != JAYLINK_OK) { msg_perr("jaylink_set_speed() failed: %s.\n", jaylink_strerror(ret)); return 1; } msg_pdbg("SPI speed: %lu kHz\n", speed); /* Ensure that the CS signal is not active initially. */ if (!deassert_cs()) return 1; register_spi_master(&spi_master_jlink_spi); return 0; }
/** * Perform a SWD I/O operation. * * @note This function must only be used if the #JAYLINK_TIF_SWD interface is * available and selected. * * @param[in,out] devh Device handle. * @param[in] direction Buffer to read the transfer direction from. * @param[in] out Buffer to read host-to-target data from. * @param[out] in Buffer to store target-to-host data on success. Its content * is undefined on failure. The buffer must be large enough to * contain at least the specified number of bits to transfer. * @param[in] length Total number of bits to transfer from host to target and * vice versa. * * @retval JAYLINK_OK Success. * @retval JAYLINK_ERR_ARG Invalid arguments. * @retval JAYLINK_ERR_TIMEOUT A timeout occurred. * @retval JAYLINK_ERR_DEV Unspecified device error. * @retval JAYLINK_ERR_DEV_NO_MEMORY Not enough memory on the device to perform * the operation. * @retval JAYLINK_ERR Other error conditions. * * @see jaylink_select_interface() * @see jaylink_set_speed() * * @since 0.1.0 */ JAYLINK_API int jaylink_swd_io(struct jaylink_device_handle *devh, const uint8_t *direction, const uint8_t *out, uint8_t *in, uint16_t length) { int ret; struct jaylink_context *ctx; uint16_t num_bytes; uint8_t buf[4]; uint8_t status; if (!devh || !direction || !out || !in || !length) return JAYLINK_ERR_ARG; ctx = devh->dev->ctx; num_bytes = (length + 7) / 8; ret = transport_start_write_read(devh, 4 + 2 * num_bytes, num_bytes + 1, true); if (ret != JAYLINK_OK) { log_err(ctx, "transport_start_write_read() failed: %s.", jaylink_strerror(ret)); return ret; } buf[0] = CMD_SWD_IO; buf[1] = 0x00; buffer_set_u16(buf, length, 2); ret = transport_write(devh, buf, 4); if (ret != JAYLINK_OK) { log_err(ctx, "transport_write() failed: %s.", jaylink_strerror(ret)); return ret; } ret = transport_write(devh, direction, num_bytes); if (ret != JAYLINK_OK) { log_err(ctx, "transport_write() failed: %s.", jaylink_strerror(ret)); return ret; } ret = transport_write(devh, out, num_bytes); if (ret != JAYLINK_OK) { log_err(ctx, "transport_write() failed: %s.", jaylink_strerror(ret)); return ret; } ret = transport_read(devh, in, num_bytes); if (ret != JAYLINK_OK) { log_err(ctx, "transport_read() failed: %s.", jaylink_strerror(ret)); return ret; } ret = transport_read(devh, &status, 1); if (ret != JAYLINK_OK) { log_err(ctx, "transport_read() failed: %s.", jaylink_strerror(ret)); return ret; } if (status == SWD_IO_ERR_NO_MEMORY) { return JAYLINK_ERR_DEV_NO_MEMORY; } else if (status > 0) { log_err(ctx, "SWD I/O operation failed: %02x.", status); return JAYLINK_ERR_DEV; } return JAYLINK_OK; }