[FX3/libbladeRF] Major refactoring of FX3 application

- Split RF, FPGA load, and firmware methods into seperate .c files
 - Split several vendor requests to eliminate magic glEp0Idx and to allow
   for better error handling
   - Updated libbladeRF to use new vendor requests and properly check return
     code.
 - Changed glSpiPageSize from global to #define
 - Move OTP handling into firmware.c
 - Version bump

Conflicts:

	fx3_firmware/bladeRF.c
This commit is contained in:
Keith Rothman 2013-09-22 08:02:30 +00:00
commit 57116c919a
14 changed files with 1463 additions and 1260 deletions

View file

@ -43,12 +43,9 @@
#define BLADE_USB_CMD_WRITE_OTP 104
#define BLADE_USB_CMD_RESET 105
#define BLADE_USB_CMD_JUMP_TO_BOOTLOADER 106
#define BLADE_USB_CMD_QUERY_VERSION 0
#define BLADE_USB_CMD_QUERY_FPGA_STATUS 1
#define BLADE_USB_CMD_BEGIN_PROG 2
#define BLADE_USB_CMD_END_PROG 3
#define BLADE_USB_CMD_RF_RX 4
#define BLADE_USB_CMD_READ_PAGE_BUFFER 107
#define BLADE_USB_CMD_WRITE_PAGE_BUFFER 108
#define BLADE_USB_CMD_LOCK_OTP 109
struct bladeRF_version {
unsigned short major;

File diff suppressed because it is too large Load diff

View file

@ -1,9 +1,11 @@
#ifndef _INCLUDED_BLADE_H_
#define _INCLUDED_BLADE_H_
#include <stdint.h>
#include "cyu3externcstart.h"
#include "cyu3types.h"
#include "cyu3usbconst.h"
#include "cyu3dma.h"
#include "../firmware_common/bladeRF.h"
#define BLADE_GPIF_16_32BIT_CONF_SELECT (0)
@ -46,20 +48,20 @@ extern const uint8_t CyFxUSBProductDscr[];
#include "cyu3externcend.h"
int FpgaBeginProgram(void);
void NuandFirmwareStart(void);
void NuandFirmwareStop(void);
CyU3PReturnStatus_t CyFxSpiEraseSector(CyBool_t /* isErase */, uint8_t /* sector */);
void NuandEnso();
void NuandExso();
void NuandLockOtp();
void NuandGPIOReconfigure(CyBool_t /* fullGpif */, CyBool_t /* warm */);
int NuandExtractField(char * /* ptr */, int /* len */, char * /* field */, char * /* val */, size_t /* maxlen */);
int FpgaBeginProgram(void);
void ClearDMAChannel(uint8_t ep, CyU3PDmaChannel * handle, uint32_t count, CyBool_t stall_only);
void CyFxAppErrorHandler(CyU3PReturnStatus_t apiRetStatus);
extern uint32_t glAppMode;
struct NuandApplication {
void (*start)(void);
void (*stop)(void);
CyBool_t (*halt_endpoint)(CyBool_t set, uint16_t endpoint);
CyBool_t (*halted)(uint16_t endpoint, uint8_t *data);
};
#define GPIO_nSTATUS 52
#define GPIO_nCONFIG 51
#define GPIO_CONFDONE 50

172
fx3_firmware/firmware.c Normal file
View file

@ -0,0 +1,172 @@
#include "firmware.h"
#include <string.h>
#include "cyu3spi.h"
#include "cyu3error.h"
#include "bladeRF.h"
#include "spi_flash_lib.h"
static CyU3PReturnStatus_t FlashReadStatus(uint8_t *val)
{
int status;
uint8_t read_status = 0x05; /* RDSTATUS */
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (&read_status, 1);
status = CyU3PSpiReceiveWords(val, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
return status;
}
CyU3PReturnStatus_t NuandLockOtp() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[1];
uint8_t read_status;
status = FlashReadStatus(&read_status);
location[0] = 0x06; /* Write enable. */
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
status = FlashReadStatus(&read_status);
location[0] = 0x2f;// WRSCUR
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
location[0] = 0x02;// Page program
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
location[0] = 0x2b; /* RDSCUR */
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiReceiveWords(location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
return status;
}
CyU3PReturnStatus_t NuandEnso() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[1];
location[0] = 0xb1; // ENSO
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
return status;
}
CyU3PReturnStatus_t NuandExso() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[1];
location[0] = 0xc1; // EXSO
status = CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiSetSsnLine (CyTrue);
return status;
}
CyU3PReturnStatus_t NuandReadOtp(size_t offset, size_t size, void *buf) {
CyU3PReturnStatus_t status;
status = NuandEnso();
status = CyFxSpiTransfer(offset, size, buf, CyTrue);
status = NuandExso();
return status;
}
CyU3PReturnStatus_t NuandWriteOtp(size_t offset, size_t size, void *buf) {
CyU3PReturnStatus_t status;
status = NuandEnso();
status = CyFxSpiTransfer(offset, size, buf, CyFalse);
status = NuandExso();
return status;
}
void NuandFirmwareStart() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
NuandGPIOReconfigure(CyFalse, CyFalse);
status = CyFxSpiInit();
glAppMode = MODE_FW_CONFIG;
}
void NuandFirmwareStop() {
CyFxSpiDeInit();
}
static inline size_t min_sz(size_t x, size_t y)
{
return x < y ? x : y;
}
/******
* CRC16 implementation from http://softwaremonkey.org/Code/CRC16
*/
typedef unsigned char byte; /* 8 bit unsigned */
typedef unsigned short int word; /* 16 bit unsigned */
static word crc16mp(word crcval, void *data_p, word count) {
/* CRC-16 Routine for processing multiple part data blocks.
* Pass 0 into 'crcval' for first call for any given block; for
* subsequent calls pass the CRC returned by the previous call. */
word xx;
byte *ptr=data_p;
while (count-- > 0) {
crcval=(word)(crcval^(word)(((word)*ptr++)<<8));
for (xx=0;xx<8;xx++) {
if(crcval&0x8000) { crcval=(word)((word)(crcval<<1)^0x1021); }
else { crcval=(word)(crcval<<1); }
}
}
return(crcval);
}
int NuandExtractField(char *ptr, int len, char *field,
char *val, size_t maxlen) {
int c, wlen;
unsigned char *ub, *end;
unsigned short a1, a2;
int flen;
flen = strlen(field);
ub = (unsigned char *)ptr;
end = ub + len;
while (ub < end) {
c = *ub;
if (c == 0xff) // flash and OTP are 0xff if they've never been written to
break;
a1 = *(unsigned short *)(&ub[c+1]); // read checksum
a2 = crc16mp(0, ub, c+1); // calculated checksum
if (a1 == a2 || 1) {
if (!strncmp((char *)ub + 1, field, flen)) {
wlen = min_sz(c - flen, maxlen);
strncpy(val, (char *)ub + 1 + flen, wlen);
val[wlen] = 0;
return 0;
}
} else {
return 1;
}
ub += c + 3; //skip past `c' bytes, 2 byte CRC field, and 1 byte len field
}
return 1;
}

17
fx3_firmware/firmware.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef _FIRMWARE_H_
#define _FIRMWARE_H_
#include <stddef.h>
#include "cyu3error.h"
CyU3PReturnStatus_t NuandReadOtp(size_t offset, size_t size, void *buf);
CyU3PReturnStatus_t NuandWriteOtp(size_t offset, size_t size, void *buf);
CyU3PReturnStatus_t NuandLockOtp();
void NuandFirmwareStart();
void NuandFirmwareStop();
int NuandExtractField(char *ptr, int len, char *field,
char *val, size_t maxlen);
#endif /* _FIRMWARE_H_ */

227
fx3_firmware/fpga.c Normal file
View file

@ -0,0 +1,227 @@
#include "bladeRF.h"
#include "cyu3error.h"
#include "cyu3gpio.h"
#include "cyu3usb.h"
#include "cyu3gpif.h"
#include "cyfxgpif_C4loader.h"
/* DMA Channel for RF U2P (USB to P-port) transfers */
static CyU3PDmaChannel glChHandlebladeRFUtoP;
static uint32_t glDMARxCount = 0; /* Counter to track the number of buffers received
* from USB during FPGA programming */
static uint16_t glFlipLut[256];
void NuandFpgaConfigSwInit(void) {
uint32_t i, tmpr, tmpw;
for (i = 0; i < 256; i++) {
tmpr = i;
tmpw = 0;
#define US_GPIF_2_FPP(GPIFbit, FPPbit) tmpw |= (tmpr & (1 << FPPbit)) ? (1 << GPIFbit) : 0;
US_GPIF_2_FPP(7, 0);
US_GPIF_2_FPP(15, 1);
US_GPIF_2_FPP(6, 2);
US_GPIF_2_FPP(2, 3);
US_GPIF_2_FPP(1, 4);
US_GPIF_2_FPP(3, 5);
US_GPIF_2_FPP(9, 6);
US_GPIF_2_FPP(11, 7);
glFlipLut[i] = tmpw;
}
}
/* DMA callback function to handle the produce events for U to P transfers. */
static void bladeRFConfigUtoPDmaCallback(CyU3PDmaChannel *chHandle, CyU3PDmaCbType_t type, CyU3PDmaCBInput_t *input)
{
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
if (type == CY_U3P_DMA_CB_PROD_EVENT) {
int i;
uint8_t *end_in_b = &( ((uint8_t *)input->buffer_p.buffer)[input->buffer_p.count - 1]);
uint32_t *end_in_w = &( ((uint32_t *)input->buffer_p.buffer)[input->buffer_p.count - 1]);
/* Flip the bits in such a way that the FPGA can be programmed
* This mapping can be determined by looking at the schematic */
for (i = input->buffer_p.count - 1; i >= 0; i--) {
*end_in_w-- = glFlipLut[*end_in_b--];
}
status = CyU3PDmaChannelCommitBuffer (chHandle, input->buffer_p.count * 4, 0);
if (status != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PDmaChannelCommitBuffer failed, Error code = %d\n", status);
}
/* Increment the counter. */
glDMARxCount++;
}
}
static void NuandFpgaConfigStart(void)
{
uint16_t size = 0;
CyU3PEpConfig_t epCfg;
CyU3PDmaChannelConfig_t dmaCfg;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
CyU3PUSBSpeed_t usbSpeed = CyU3PUsbGetSpeed();
static int first_call = 1;
NuandGPIOReconfigure(CyTrue, !first_call);
first_call = 0;
/* Load the GPIF configuration for loading the FPGA */
apiRetStatus = CyU3PGpifLoad(&C4loader_CyFxGpifConfig);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PGpifLoad failed, Error Code = %d\n",apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Start the state machine. */
apiRetStatus = CyU3PGpifSMStart(C4LOADER_START, C4LOADER_ALPHA_START);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PGpifSMStart failed, Error Code = %d\n",apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Determine max packet size based on USB speed */
switch (usbSpeed)
{
case CY_U3P_FULL_SPEED:
size = 64;
break;
case CY_U3P_HIGH_SPEED:
size = 512;
break;
case CY_U3P_SUPER_SPEED:
size = 1024;
break;
default:
CyU3PDebugPrint(4, "Error! Invalid USB speed.\n");
CyFxAppErrorHandler(CY_U3P_ERROR_FAILURE);
break;
}
CyU3PMemSet((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyTrue;
epCfg.epType = CY_U3P_USB_EP_BULK;
epCfg.burstLen = 1;
epCfg.streams = 0;
epCfg.pcktSize = size;
apiRetStatus = CyU3PSetEpConfig(BLADE_FPGA_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
dmaCfg.size = size * 4;
dmaCfg.count = BLADE_DMA_BUF_COUNT;
dmaCfg.prodSckId = BLADE_FPGA_CONFIG_SOCKET;
dmaCfg.consSckId = CY_U3P_PIB_SOCKET_3;
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
/* Enable the callback for produce event, this is where the bits will get flipped */
dmaCfg.notification = CY_U3P_DMA_CB_PROD_EVENT;
dmaCfg.cb = bladeRFConfigUtoPDmaCallback;
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = size * 3;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
apiRetStatus = CyU3PDmaChannelCreate(&glChHandlebladeRFUtoP,
CY_U3P_DMA_TYPE_MANUAL, &dmaCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaChannelCreate failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Flush the endpoint memory */
CyU3PUsbFlushEp(BLADE_FPGA_EP_PRODUCER);
/* Set DMA channel transfer size. */
apiRetStatus = CyU3PDmaChannelSetXfer(&glChHandlebladeRFUtoP, BLADE_DMA_TX_SIZE);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaChannelSetXfer Failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
glAppMode = MODE_FPGA_CONFIG;
}
void NuandFpgaConfigStop(void)
{
CyU3PEpConfig_t epCfg;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Flush the endpoint memory */
CyU3PUsbFlushEp(BLADE_FPGA_EP_PRODUCER);
/* Destroy the channel */
CyU3PDmaChannelDestroy(&glChHandlebladeRFUtoP);
/* Disable endpoints. */
CyU3PMemSet((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyFalse;
/* Producer endpoint configuration. */
apiRetStatus = CyU3PSetEpConfig(BLADE_FPGA_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
CyU3PGpifDisable(CyTrue);
glAppMode = MODE_NO_CONFIG;
}
uint8_t FPGA_status_bits[] = {
[BLADE_FPGA_EP_PRODUCER] = 0,
};
CyBool_t NuandFpgaConfigHaltEndpoint(CyBool_t set, uint16_t endpoint)
{
CyBool_t isHandled = CyFalse;
switch(endpoint) {
case BLADE_FPGA_EP_PRODUCER:
FPGA_status_bits[endpoint] = set;
ClearDMAChannel(endpoint, &glChHandlebladeRFUtoP,
BLADE_DMA_TX_SIZE, set);
isHandled = CyTrue;
break;
}
return isHandled;
}
CyBool_t NuandFpgaConfigHalted(uint16_t endpoint, uint8_t * data)
{
CyBool_t isHandled = CyFalse;
switch(endpoint) {
case BLADE_FPGA_EP_PRODUCER:
*data = FPGA_status_bits[endpoint];
isHandled = CyTrue;
break;
}
return isHandled;
}
const struct NuandApplication NuandFpgaConfig = {
.start = NuandFpgaConfigStart,
.stop = NuandFpgaConfigStop,
.halt_endpoint = NuandFpgaConfigHaltEndpoint,
.halted = NuandFpgaConfigHalted,
};

9
fx3_firmware/fpga.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef _FPGA_H_
#define _FPGA_H_
#include "bladeRF.h"
void NuandFpgaConfigSwInit(void);
extern const struct NuandApplication NuandFpgaConfig;
#endif /* _FPGA_H_ */

438
fx3_firmware/rf.c Normal file
View file

@ -0,0 +1,438 @@
#include "rf.h"
#include "cyu3error.h"
#include "cyu3gpio.h"
#include "cyu3usb.h"
#include "cyu3gpif.h"
#include "cyfxgpif_RFlink.h"
#include "cyu3uart.h"
static CyU3PDmaChannel glChHandlebladeRFUtoUART; /* DMA Channel for U2P transfers */
static CyU3PDmaChannel glChHandlebladeRFUARTtoU; /* DMA Channel for U2P transfers */
static CyU3PDmaChannel glChHandleUtoP;
static CyU3PDmaChannel glChHandlePtoU;
static void UartBridgeStart(void)
{
uint16_t size = 0;
CyU3PEpConfig_t epCfg;
CyU3PUSBSpeed_t usbSpeed = CyU3PUsbGetSpeed();
CyU3PDmaChannelConfig_t dmaCfg;
CyU3PUartConfig_t uartConfig;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Initialize the UART for printing debug messages */
apiRetStatus = CyU3PUartInit();
if (apiRetStatus != CY_U3P_SUCCESS) {
CyFxAppErrorHandler(apiRetStatus);
}
/* Set UART configuration */
CyU3PMemSet ((uint8_t *)&uartConfig, 0, sizeof (uartConfig));
uartConfig.baudRate = CY_U3P_UART_BAUDRATE_115200;
uartConfig.stopBit = CY_U3P_UART_ONE_STOP_BIT;
uartConfig.parity = CY_U3P_UART_NO_PARITY;
uartConfig.txEnable = CyTrue;
uartConfig.rxEnable = CyTrue;
uartConfig.flowCtrl = CyFalse;
uartConfig.isDma = CyTrue;
apiRetStatus = CyU3PUartSetConfig (&uartConfig, NULL);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyFxAppErrorHandler(apiRetStatus);
}
/* Set UART Tx and Rx transfer Size to infinite */
apiRetStatus = CyU3PUartTxSetBlockXfer(0xFFFFFFFF);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyFxAppErrorHandler(apiRetStatus);
}
apiRetStatus = CyU3PUartRxSetBlockXfer(0xFFFFFFFF);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyFxAppErrorHandler(apiRetStatus);
}
/* Determine max packet size based on USB speed */
switch (usbSpeed)
{
case CY_U3P_FULL_SPEED:
size = 64;
break;
case CY_U3P_HIGH_SPEED:
size = 512;
break;
case CY_U3P_SUPER_SPEED:
size = 1024;
break;
default:
CyU3PDebugPrint (4, "Error! Invalid USB speed.\n");
CyFxAppErrorHandler (CY_U3P_ERROR_FAILURE);
break;
}
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyTrue;
epCfg.epType = CY_U3P_USB_EP_BULK;
epCfg.burstLen = 1;
epCfg.streams = 0;
epCfg.pcktSize = size;
/* Producer endpoint configuration */
apiRetStatus = CyU3PSetEpConfig(BLADE_UART_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
/* Consumer endpoint configuration */
apiRetStatus = CyU3PSetEpConfig(BLADE_UART_EP_CONSUMER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
CyU3PMemSet((uint8_t *)&dmaCfg, 0, sizeof(dmaCfg));
dmaCfg.size = 16;
dmaCfg.count = 10;
dmaCfg.prodSckId = CY_U3P_UIB_SOCKET_PROD_2;
dmaCfg.consSckId = CY_U3P_LPP_SOCKET_UART_CONS;
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.notification = 0;
dmaCfg.cb = 0;
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = 0;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
apiRetStatus = CyU3PDmaChannelCreate(&glChHandlebladeRFUtoUART,
CY_U3P_DMA_TYPE_AUTO, &dmaCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PDmaChannelCreate failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
dmaCfg.prodSckId = CY_U3P_LPP_SOCKET_UART_PROD;
dmaCfg.consSckId = CY_U3P_UIB_SOCKET_CONS_2;
apiRetStatus = CyU3PDmaChannelCreate(&glChHandlebladeRFUARTtoU,
CY_U3P_DMA_TYPE_AUTO, &dmaCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PDmaChannelCreate failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Flush the endpoint memory */
CyU3PUsbFlushEp(BLADE_UART_EP_PRODUCER);
CyU3PUsbFlushEp(BLADE_UART_EP_CONSUMER);
/* Set DMA channel transfer size */
apiRetStatus = CyU3PDmaChannelSetXfer(&glChHandlebladeRFUtoUART, BLADE_DMA_TX_SIZE);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PDmaChannelSetXfer Failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
apiRetStatus = CyU3PDmaChannelSetXfer(&glChHandlebladeRFUARTtoU, BLADE_DMA_TX_SIZE);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PDmaChannelSetXfer Failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Set UART Tx and Rx transfer Size to infinite */
apiRetStatus = CyU3PUartTxSetBlockXfer(0xFFFFFFFF);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyFxAppErrorHandler(apiRetStatus);
}
apiRetStatus = CyU3PUartRxSetBlockXfer(0xFFFFFFFF);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyFxAppErrorHandler(apiRetStatus);
}
}
static void UartBridgeStop(void)
{
CyU3PEpConfig_t epCfg;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Flush the endpoint memory */
CyU3PUsbFlushEp(BLADE_UART_EP_PRODUCER);
CyU3PUsbFlushEp(BLADE_UART_EP_CONSUMER);
/* Destroy the channel */
CyU3PDmaChannelDestroy(&glChHandlebladeRFUARTtoU);
CyU3PDmaChannelDestroy(&glChHandlebladeRFUtoUART);
/* Disable endpoints. */
CyU3PMemSet((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyFalse;
/* Producer endpoint configuration. */
apiRetStatus = CyU3PSetEpConfig(BLADE_UART_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
apiRetStatus = CyU3PSetEpConfig(BLADE_UART_EP_CONSUMER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint (4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
CyU3PUartDeInit();
}
/* This function starts the RF data transport mechanism. This is the second
* interface of the first and only descriptor. */
static void NuandRFLinkStart(void)
{
uint16_t size = 0;
CyU3PEpConfig_t epCfg;
CyU3PDmaChannelConfig_t dmaCfg;
CyU3PDmaMultiChannelConfig_t dmaMultiConfig;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
CyU3PUSBSpeed_t usbSpeed = CyU3PUsbGetSpeed();
NuandGPIOReconfigure(CyTrue, CyTrue);
/* Load the GPIF configuration for loading the RF transceiver */
apiRetStatus = CyU3PGpifLoad(&Rflink_CyFxGpifConfig);
if (apiRetStatus != CY_U3P_SUCCESS)
{
CyU3PDebugPrint (4, "CyU3PGpifLoad failed, Error Code = %d\n",apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
// strobe the RESET pin to the FPGA
CyU3PGpioSetValue(GPIO_SYS_RST, CyTrue);
CyU3PGpioSetValue(GPIO_SYS_RST, CyFalse);
/* Start the state machine. */
apiRetStatus = CyU3PGpifSMStart(RFLINK_START, RFLINK_ALPHA_START);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PGpifSMStart failed, Error Code = %d\n",apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Determine max packet size based on USB speed */
switch (usbSpeed)
{
case CY_U3P_FULL_SPEED:
size = 64;
break;
case CY_U3P_HIGH_SPEED:
size = 512;
break;
case CY_U3P_SUPER_SPEED:
size = 1024;
break;
default:
CyU3PDebugPrint (4, "Error! Invalid USB speed.\n");
CyFxAppErrorHandler (CY_U3P_ERROR_FAILURE);
break;
}
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyTrue;
epCfg.epType = CY_U3P_USB_EP_BULK;
epCfg.burstLen = (usbSpeed == CY_U3P_SUPER_SPEED ? 15 : 1);
epCfg.streams = 0;
epCfg.pcktSize = size;
/* Producer endpoint configuration */
apiRetStatus = CyU3PSetEpConfig(BLADE_RF_SAMPLE_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
/* Consumer endpoint configuration */
apiRetStatus = CyU3PSetEpConfig(BLADE_RF_SAMPLE_EP_CONSUMER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler (apiRetStatus);
}
// multi variant
dmaMultiConfig.size = size * 2;
dmaMultiConfig.count = 22;
dmaMultiConfig.validSckCount = 2;
dmaMultiConfig.prodSckId[0] = BLADE_RF_SAMPLE_EP_PRODUCER_USB_SOCKET;
dmaMultiConfig.consSckId[0] = CY_U3P_PIB_SOCKET_2;
dmaMultiConfig.consSckId[1] = CY_U3P_PIB_SOCKET_3;
dmaMultiConfig.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaMultiConfig.notification = 0;
dmaMultiConfig.cb = 0;
dmaMultiConfig.prodHeader = 0;
dmaMultiConfig.prodFooter = 0;
dmaMultiConfig.consHeader = 0;
dmaMultiConfig.prodAvailCount = 0;
// non multi variant
CyU3PMemSet((uint8_t *)&dmaCfg, 0, sizeof(dmaCfg));
dmaCfg.size = size * 2;
dmaCfg.count = 22;
dmaCfg.prodSckId = BLADE_RF_SAMPLE_EP_PRODUCER_USB_SOCKET;
dmaCfg.consSckId = CY_U3P_PIB_SOCKET_3;
dmaCfg.dmaMode = CY_U3P_DMA_MODE_BYTE;
dmaCfg.notification = 0;
dmaCfg.cb = 0;
dmaCfg.prodHeader = 0;
dmaCfg.prodFooter = 0;
dmaCfg.consHeader = 0;
dmaCfg.prodAvailCount = 0;
apiRetStatus = CyU3PDmaChannelCreate(&glChHandleUtoP, CY_U3P_DMA_TYPE_AUTO, &dmaCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaMultiChannelCreate failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
dmaCfg.prodSckId = CY_U3P_PIB_SOCKET_0;
dmaCfg.consSckId = BLADE_RF_SAMPLE_EP_CONSUMER_USB_SOCKET;
apiRetStatus = CyU3PDmaChannelCreate(&glChHandlePtoU, CY_U3P_DMA_TYPE_AUTO, &dmaCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaMultiChannelCreate failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Flush the Endpoint memory */
CyU3PUsbFlushEp(BLADE_RF_SAMPLE_EP_PRODUCER);
CyU3PUsbFlushEp(BLADE_RF_SAMPLE_EP_CONSUMER);
/* Set DMA channel transfer size. */
apiRetStatus = CyU3PDmaChannelSetXfer (&glChHandleUtoP, BLADE_DMA_TX_SIZE);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaChannelSetXfer Failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
apiRetStatus = CyU3PDmaChannelSetXfer (&glChHandlePtoU, BLADE_DMA_TX_SIZE);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PDmaChannelSetXfer Failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
UartBridgeStart();
glAppMode = MODE_RF_CONFIG;
}
/* This function stops the slave FIFO loop application. This shall be called
* whenever a RESET or DISCONNECT event is received from the USB host. The
* endpoints are disabled and the DMA pipe is destroyed by this function. */
static void NuandRFLinkStop (void)
{
CyU3PEpConfig_t epCfg;
CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
/* Flush endpoint memory buffers */
CyU3PUsbFlushEp(BLADE_RF_SAMPLE_EP_PRODUCER);
CyU3PUsbFlushEp(BLADE_RF_SAMPLE_EP_CONSUMER);
/* Destroy the channels */
CyU3PDmaChannelDestroy(&glChHandleUtoP);
CyU3PDmaChannelDestroy(&glChHandlePtoU);
/* Disable endpoints. */
CyU3PMemSet ((uint8_t *)&epCfg, 0, sizeof (epCfg));
epCfg.enable = CyFalse;
/* Disable producer endpoint */
apiRetStatus = CyU3PSetEpConfig(BLADE_RF_SAMPLE_EP_PRODUCER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Disable consumer endpoint */
apiRetStatus = CyU3PSetEpConfig(BLADE_RF_SAMPLE_EP_CONSUMER, &epCfg);
if (apiRetStatus != CY_U3P_SUCCESS) {
CyU3PDebugPrint(4, "CyU3PSetEpConfig failed, Error code = %d\n", apiRetStatus);
CyFxAppErrorHandler(apiRetStatus);
}
/* Reset the GPIF */
CyU3PGpifDisable(CyTrue);
UartBridgeStop();
glAppMode = MODE_NO_CONFIG;
}
static uint8_t RF_status_bits[] = {
[BLADE_RF_SAMPLE_EP_PRODUCER] = 0,
[BLADE_RF_SAMPLE_EP_CONSUMER] = 0,
[BLADE_UART_EP_PRODUCER] = 0,
[BLADE_UART_EP_CONSUMER] = 0,
};
CyBool_t NuandRFLinkHaltEndpoint(CyBool_t set, uint16_t endpoint)
{
CyBool_t isHandled = CyFalse;
switch(endpoint) {
case BLADE_RF_SAMPLE_EP_PRODUCER:
case BLADE_RF_SAMPLE_EP_CONSUMER:
case BLADE_UART_EP_PRODUCER:
case BLADE_UART_EP_CONSUMER:
isHandled = CyTrue;
RF_status_bits[endpoint] = set;
break;
}
switch(endpoint) {
case BLADE_RF_SAMPLE_EP_PRODUCER:
ClearDMAChannel(endpoint, &glChHandleUtoP, BLADE_DMA_TX_SIZE, set);
break;
case BLADE_RF_SAMPLE_EP_CONSUMER:
ClearDMAChannel(endpoint, &glChHandlePtoU, BLADE_DMA_TX_SIZE, set);
break;
case BLADE_UART_EP_PRODUCER:
ClearDMAChannel(endpoint, &glChHandlebladeRFUtoUART, BLADE_DMA_TX_SIZE, set);
break;
case BLADE_UART_EP_CONSUMER:
ClearDMAChannel(endpoint, &glChHandlebladeRFUARTtoU, BLADE_DMA_TX_SIZE, set);
break;
}
return isHandled;
}
CyBool_t NuandRFLinkHalted(uint16_t endpoint, uint8_t * data)
{
CyBool_t isHandled = CyFalse;
switch(endpoint) {
case BLADE_RF_SAMPLE_EP_PRODUCER:
case BLADE_RF_SAMPLE_EP_CONSUMER:
case BLADE_UART_EP_PRODUCER:
case BLADE_UART_EP_CONSUMER:
*data = RF_status_bits[endpoint];
isHandled = CyTrue;
break;
}
return isHandled;
}
const struct NuandApplication NuandRFLink = {
.start = NuandRFLinkStart,
.stop = NuandRFLinkStop,
.halt_endpoint = NuandRFLinkHaltEndpoint,
.halted = NuandRFLinkHalted,
};

8
fx3_firmware/rf.h Normal file
View file

@ -0,0 +1,8 @@
#ifndef _RF_H_
#define _RF_H_
#include "bladeRF.h"
extern const struct NuandApplication NuandRFLink;
#endif /* _RF_H_ */

View file

@ -20,10 +20,9 @@
#include "cyu3spi.h"
#include "spi_flash_lib.h"
uint16_t glSpiPageSize = 0x100; /* SPI Page size to be used for transfers. */
/* SPI initialization for application. */
CyU3PReturnStatus_t CyFxSpiInit(uint16_t pageLen)
CyU3PReturnStatus_t CyFxSpiInit(void)
{
CyU3PSpiConfig_t spiConfig;
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
@ -102,18 +101,18 @@ CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, ui
{
uint8_t location[4];
uint32_t byteAddress = 0;
uint16_t pageCount = (byteCount / glSpiPageSize);
uint16_t pageCount = (byteCount / FLASH_PAGE_SIZE);
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
if (byteCount == 0) {
return CY_U3P_SUCCESS;
}
if ((byteCount % glSpiPageSize) != 0) {
pageCount ++;
if ((byteCount % FLASH_PAGE_SIZE) != 0) {
return CY_U3P_ERROR_NOT_SUPPORTED;
}
byteAddress = pageAddress * glSpiPageSize;
byteAddress = pageAddress * FLASH_PAGE_SIZE;
while (pageCount != 0) {
location[1] = (byteAddress >> 16) & 0xFF; /* MS byte */
@ -136,7 +135,7 @@ CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, ui
return status;
}
status = CyU3PSpiReceiveWords(buffer, glSpiPageSize);
status = CyU3PSpiReceiveWords(buffer, FLASH_PAGE_SIZE);
if (status != CY_U3P_SUCCESS) {
CyU3PSpiSetSsnLine(CyTrue);
return status;
@ -158,7 +157,7 @@ CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, ui
return status;
}
status = CyU3PSpiTransmitWords(buffer, glSpiPageSize);
status = CyU3PSpiTransmitWords(buffer, FLASH_PAGE_SIZE);
if (status != CY_U3P_SUCCESS) {
CyU3PSpiSetSsnLine(CyTrue);
return status;
@ -167,8 +166,8 @@ CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, ui
CyU3PSpiSetSsnLine(CyTrue);
}
byteAddress += glSpiPageSize;
buffer += glSpiPageSize;
byteAddress += FLASH_PAGE_SIZE;
buffer += FLASH_PAGE_SIZE;
pageCount--;
CyU3PThreadSleep(15);
@ -177,65 +176,6 @@ CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, ui
return CY_U3P_SUCCESS;
}
void NuandLockOtp() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[4];
location[0] = 0x05; /* RDSTATUS */
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiReceiveWords(location, 1);
CyU3PSpiSetSsnLine (CyTrue);
location[0] = 0x06; /* Write enable. */
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
CyU3PSpiSetSsnLine (CyTrue);
location[0] = 0x05; /* RDSTATUS */
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiReceiveWords(location, 1);
CyU3PSpiSetSsnLine (CyTrue);
CyU3PSpiSetSsnLine (CyFalse);
location[0] = 0x2f;// WRSCUR
status = CyU3PSpiTransmitWords (location, 1);
CyU3PSpiSetSsnLine (CyTrue);
CyU3PSpiSetSsnLine (CyFalse);
location[0] = 0x2;// WRSCUR
status = CyU3PSpiTransmitWords (location, 1);
CyU3PSpiSetSsnLine (CyTrue);
location[0] = 0x2b; /* RDSCUR */
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
status = CyU3PSpiReceiveWords(location, 1);
CyU3PSpiSetSsnLine (CyTrue);
}
void NuandEnso() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[4];
location[0] = 0xb1; // ENSO
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
CyU3PSpiSetSsnLine (CyTrue);
}
void NuandExso() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
uint8_t location[4];
location[0] = 0xc1; // EXSO
CyU3PSpiSetSsnLine (CyFalse);
status = CyU3PSpiTransmitWords (location, 1);
CyU3PSpiSetSsnLine (CyTrue);
}
/* Function to erase SPI flash sectors. */
CyU3PReturnStatus_t CyFxSpiEraseSector(CyBool_t isErase, uint8_t sector)
{
@ -274,82 +214,3 @@ CyU3PReturnStatus_t CyFxSpiEraseSector(CyBool_t isErase, uint8_t sector)
return status;
}
void NuandFirmwareStart() {
CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
NuandGPIOReconfigure(CyFalse, CyFalse);
FpgaBeginProgram();
status = CyFxSpiInit(0x100);
glAppMode = MODE_FW_CONFIG;
}
void NuandFirmwareStop() {
CyFxSpiDeInit();
}
/******
* CRC16 implementation from http://softwaremonkey.org/Code/CRC16
*/
typedef unsigned char byte; /* 8 bit unsigned */
typedef unsigned short int word; /* 16 bit unsigned */
static word crc16mp(word crcval, void *data_p, word count) {
/* CRC-16 Routine for processing multiple part data blocks.
* Pass 0 into 'crcval' for first call for any given block; for
* subsequent calls pass the CRC returned by the previous call. */
word xx;
byte *ptr=data_p;
while (count-- > 0) {
crcval=(word)(crcval^(word)(((word)*ptr++)<<8));
for (xx=0;xx<8;xx++) {
if(crcval&0x8000) { crcval=(word)((word)(crcval<<1)^0x1021); }
else { crcval=(word)(crcval<<1); }
}
}
return(crcval);
}
static inline size_t min_sz(size_t x, size_t y)
{
return x < y ? x : y;
}
int NuandExtractField(char *ptr, int len, char *field,
char *val, size_t maxlen) {
int c, wlen;
unsigned char *ub, *end;
unsigned short a1, a2;
int flen;
flen = strlen(field);
ub = (unsigned char *)ptr;
end = ub + len;
while (ub < end) {
c = *ub;
if (c == 0xff) // flash and OTP are 0xff if they've never been written to
break;
a1 = *(unsigned short *)(&ub[c+1]); // read checksum
a2 = crc16mp(0, ub, c+1); // calculated checksum
if (a1 == a2 || 1) {
if (!strncmp((char *)ub + 1, field, flen)) {
wlen = min_sz(c - flen, maxlen);
strncpy(val, (char *)ub + 1 + flen, wlen);
val[wlen] = 0;
return 0;
}
} else {
return 1;
}
ub += c + 3; //skip past `c' bytes, 2 byte CRC field, and 1 byte len field
}
return 1;
}

View file

@ -1,7 +1,10 @@
#ifndef _SPI_FLASH_LIB_H_
#define _SPI_FLASH_LIB_H_
CyU3PReturnStatus_t CyFxSpiInit(uint16_t pageLen);
#define FLASH_PAGE_SIZE 0x100 /* SPI Page size to be used for transfers. */
CyU3PReturnStatus_t CyFxSpiInit();
CyU3PReturnStatus_t CyFxSpiDeInit();
CyU3PReturnStatus_t CyFxSpiTransfer(uint16_t pageAddress, uint16_t byteCount, uint8_t *buffer, CyBool_t isRead);
#endif

View file

@ -21,6 +21,8 @@
* LE16_TO_HOST 16-bit little endian to host endianness conversion
* HOST_TO_BE16 16-bit host endianness to big endian conversion
* BE16_TO_HOST 16-bit big endian to host endianness conversion
* HOST_TO_LE32 32-bit host endianness to little endian conversion
* LE32_TO_HOST 32-bit little endian to host endianness conversion
******************************************************************************/
/*-----------------------
@ -33,6 +35,8 @@
#define LE16_TO_HOST(val) le16toh(val)
#define HOST_TO_BE16(val) htobe16(val)
#define BE16_TO_HOST(val) be16toh(val)
#define HOST_TO_LE32(val) htole32(val)
#define LE32_TO_HOST(val) le32toh(val)
/*-----------------------
* Apple OSX
@ -44,6 +48,8 @@
#define LE16_TO_HOST(val) OSSwapLittleToHostInt16(val)
#define HOST_TO_BE16(val) OSSwapHostToBigInt16(val)
#define BE16_TO_HOST(val) OSSwapBigToHostInt16(val)
#define HOST_TO_LE32(val) OSSwapHostToLittleInt32(val)
#define LE32_TO_HOST(val) OSSwapLittleToHostInt32(val)
/*-----------------------
* Windows
@ -58,6 +64,8 @@
#define LE16_TO_HOST(val) (val)
#define HOST_TO_BE16(val) _byteswap_ushort(val)
#define BE16_TO_HOST(val) _byteswap_ushort(val)
#define HOST_TO_LE32(val) (val)
#define LE32_TO_HOST(val) (val)
/*-----------------------
* Unsupported or bug

View file

@ -14,7 +14,7 @@ project(libbladeRF C)
################################################################################
set(VERSION_INFO_MAJOR 0)
set(VERSION_INFO_MINOR 4)
set(VERSION_INFO_MINOR 5)
set(VERSION_INFO_PATCH 0)
set(VERSION_INFO_EXTRA "git")
include(Version)

View file

@ -123,7 +123,7 @@ static int vendor_command_int(struct bladerf *dev,
status = BLADERF_ERR_IO;
} else {
if( ep_dir == EP_DIR_IN ) {
*val = buf;
*val = LE32_TO_HOST(buf);
}
status = 0;
}
@ -131,6 +131,72 @@ static int vendor_command_int(struct bladerf *dev,
return status;
}
/* Quick wrapper for vendor commands that get/send a 32-bit integer value + wValue */
static int vendor_command_int_value(struct bladerf *dev,
uint16_t cmd, uint16_t wValue, int32_t *val)
{
int32_t buf;
int status;
struct bladerf_lusb *lusb = dev->backend;
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE | LIBUSB_REQUEST_TYPE_VENDOR | EP_DIR_IN,
cmd,
wValue,
0,
(unsigned char *)&buf,
sizeof(buf),
BLADERF_LIBUSB_TIMEOUT_MS
);
if (status < 0) {
log_error( "status < 0: %s\n", libusb_error_name(status) );
status = error_libusb2bladerf(status);
} else if (status != sizeof(buf)) {
log_error( "status != sizeof(buf): %s\n", libusb_error_name(status) );
status = BLADERF_ERR_IO;
} else {
*val = LE32_TO_HOST(buf);
status = 0;
}
return status;
}
/* Quick wrapper for vendor commands that get/send a 32-bit integer value + wIndex */
static int vendor_command_int_index(struct bladerf *dev,
uint16_t cmd, uint16_t wIndex, int32_t *val)
{
int32_t buf;
int status;
struct bladerf_lusb *lusb = dev->backend;
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE | LIBUSB_REQUEST_TYPE_VENDOR | EP_DIR_IN,
cmd,
0,
wIndex,
(unsigned char *)&buf,
sizeof(buf),
BLADERF_LIBUSB_TIMEOUT_MS
);
if (status < 0) {
log_error( "status < 0: %s\n", libusb_error_name(status) );
status = error_libusb2bladerf(status);
} else if (status != sizeof(buf)) {
log_error( "status != sizeof(buf): %s\n", libusb_error_name(status) );
status = BLADERF_ERR_IO;
} else {
*val = LE32_TO_HOST(buf);
status = 0;
}
return status;
}
static int begin_fpga_programming(struct bladerf *dev)
{
int result;
@ -277,9 +343,40 @@ static int change_setting(struct bladerf *dev, uint8_t setting)
}
}
static void enable_rf(struct bladerf *dev) {
int32_t fx3_ret = -1;
int status;
uint16_t val;
status = change_setting(dev, USB_IF_RF_LINK);
log_info( "Changed into RF link mode: %s\n", libusb_error_name(status) ) ;
val = 1;
status = vendor_command_int_value(
dev, BLADE_USB_CMD_RF_RX,
val, &fx3_ret);
if(status) {
log_warning("Could not enable RF RX (%d): %s\n",
status, libusb_error_name(status) );
} else if(fx3_ret) {
log_warning("Error enabling RF RX (%d)\n",
fx3_ret );
}
status = vendor_command_int_value(
dev, BLADE_USB_CMD_RF_TX,
val, &fx3_ret);
if(status) {
log_warning("Could not enable RF TX (%d): %s\n",
status, libusb_error_name(status) );
} else if(fx3_ret) {
log_warning("Error enabling RF RX (%d)\n",
fx3_ret );
}
}
static int lusb_open(struct bladerf **device, struct bladerf_devinfo *info)
{
int status, i, n, inf, val;
int status, i, n, inf;
int fx3_status;
ssize_t count;
struct bladerf *dev = NULL;
@ -395,18 +492,7 @@ static int lusb_open(struct bladerf **device, struct bladerf_devinfo *info)
if (dev) {
if (lusb_is_fpga_configured(dev)) {
status = change_setting(dev, USB_IF_RF_LINK);
log_info( "Changed into RF link mode: %s\n", libusb_error_name(status) ) ;
val = 1;
status = vendor_command_int(dev, BLADE_USB_CMD_RF_RX, EP_DIR_OUT, &val);
if(status) {
log_warning("Could not enable RF RX (%d): %s\n", status, libusb_error_name(status) );
}
status = vendor_command_int(dev, BLADE_USB_CMD_RF_TX, EP_DIR_OUT, &val);
if(status) {
log_warning("Could not enable RF TX (%d): %s\n", status, libusb_error_name(status) );
}
enable_rf(dev);
}
}
@ -470,7 +556,7 @@ static int lusb_close(struct bladerf *dev)
static int lusb_load_fpga(struct bladerf *dev, uint8_t *image, size_t image_size)
{
unsigned int wait_count;
int status = 0, val;
int status = 0;
int transferred = 0;
struct bladerf_lusb *lusb = dev->backend;
@ -538,16 +624,7 @@ static int lusb_load_fpga(struct bladerf *dev, uint8_t *image, size_t image_size
log_info("libusb_set_interface_alt_setting: %s\n", libusb_error_name(status));
}
val = 1;
status = vendor_command_int(dev, BLADE_USB_CMD_RF_RX, EP_DIR_OUT, &val);
if(status) {
log_warning("Could not enable RF RX (%d): %s\n", status, libusb_error_name(status) );
}
status = vendor_command_int(dev, BLADE_USB_CMD_RF_TX, EP_DIR_OUT, &val);
if(status) {
log_warning("Could not enable RF TX (%d): %s\n", status, libusb_error_name(status) );
}
enable_rf(dev);
return status;
}
@ -587,12 +664,13 @@ static int lusb_erase_flash(struct bladerf *dev, int sector_offset, int n_bytes)
sizeof(erase_ret),
BLADERF_LIBUSB_TIMEOUT_MS);
if (status != sizeof(erase_ret) || !erase_ret) {
if (status != sizeof(erase_ret) || erase_ret != 0) {
log_error("Failed to erase sector %d\n", sector_to_erase);
if (status < 0) {
log_error("libusb status: %s\n", libusb_error_name(status));
} else if (!erase_ret) {
log_error("Received erase failure status from FX3.\n");
} else if (erase_ret != 0) {
log_error("Received erase failure status from FX3. error = %d\n",
erase_ret);
} else {
log_error("Unexpected read size: %d\n", status);
}
@ -610,18 +688,80 @@ static int lusb_erase_flash(struct bladerf *dev, int sector_offset, int n_bytes)
}
}
static int read_page_buffer(struct bladerf *dev, int read_size, uint8_t *ptr)
{
struct bladerf_lusb *lusb = dev->backend;
size_t buf_off;
int status;
for(buf_off = 0; buf_off < FLASH_PAGE_SIZE; buf_off += read_size)
{
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_IN,
BLADE_USB_CMD_READ_PAGE_BUFFER,
0,
buf_off,
&ptr[buf_off],
read_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if(status < 0) {
log_error("Failed to read page buffer at offset 0x%02x: %s\n",
buf_off, libusb_error_name(status));
return error_libusb2bladerf(status);
} else if(status != read_size) {
log_error("Got unexpected read size when writing page buffer at offset 0x%02x: "
"expected %d, got %d\n",
read_size, status);
return BLADERF_ERR_IO;
}
}
return 0;
}
static int read_one_page(struct bladerf *dev, int read_size, int page_offset, uint8_t *ptr)
{
int32_t read_status;
int status;
status = vendor_command_int_index(
dev, BLADE_USB_CMD_FLASH_READ,
page_offset, &read_status);
if(status != LIBUSB_SUCCESS) {
return status;
}
if(read_status != 0) {
log_error("Failed to read page %d: %d\n",
page_offset, read_status);
status = BLADERF_ERR_UNEXPECTED;
}
return read_page_buffer(dev, read_size, ptr);
}
static int lusb_read_flash(struct bladerf *dev, int page_offset,
uint8_t *ptr, size_t n_bytes)
{
int status = 0;
int page_i, n_read, total_read;
int read_size = dev->speed ? FLASH_PAGE_SIZE: 64;
int page_i, total_read;
int read_size = dev->speed ? FLASH_PAGE_SIZE : 64;
int pages_to_read = FLASH_BYTES_TO_PAGES(n_bytes);
struct bladerf_lusb *lusb = dev->backend;
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
log_error("Failed to set interface: %s\n", libusb_error_name(status));
status = BLADERF_ERR_IO;
}
assert(page_offset < FLASH_NUM_PAGES);
assert((page_offset + n_bytes) < FLASH_NUM_PAGES);
/* FIXME: support data_size that are not multiple of pages */
assert(n_bytes % FLASH_PAGE_SIZE == 0);
total_read = 0;
@ -631,37 +771,9 @@ static int lusb_read_flash(struct bladerf *dev, int page_offset,
page_i++) {
/* Read back a page */
n_read = 0;
do {
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_IN,
BLADE_USB_CMD_FLASH_READ,
0,
page_i,
ptr,
read_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if (status != read_size) {
if (status < 0) {
log_error("Failed to read back page %d: %s\n", page_i,
libusb_error_name(status));
} else {
log_error("Unexpected read size: %d\n", status);
}
status = BLADERF_ERR_IO;
} else {
n_read += read_size;
total_read += read_size;
ptr += read_size;
status = 0;
}
} while (n_read < FLASH_PAGE_SIZE && !status);
status = read_one_page(dev, read_size, page_i, ptr);
ptr += FLASH_PAGE_SIZE;
total_read += FLASH_PAGE_SIZE;
}
if (status == 0) {
@ -675,10 +787,9 @@ static int verify_flash(struct bladerf *dev, int page_offset,
uint8_t *image, size_t n_bytes)
{
int status = 0;
int page_i, check_i, n_read;
int page_i, check_i;
int read_size = dev->speed ? FLASH_PAGE_SIZE: 64;
int pages_to_read = FLASH_BYTES_TO_PAGES(n_bytes);
struct bladerf_lusb *lusb = dev->backend;
uint8_t page_buf[FLASH_PAGE_SIZE];
uint8_t *image_page;
@ -693,35 +804,7 @@ static int verify_flash(struct bladerf *dev, int page_offset,
page_i++) {
/* Read back a page */
n_read = 0;
do {
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_IN,
BLADE_USB_CMD_FLASH_READ,
0,
page_i,
page_buf + n_read,
read_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if (status != read_size) {
if (status < 0) {
log_error("Failed to read back page %d: %s\n", page_i,
libusb_error_name(status));
} else {
log_error("Unexpected read size: %d\n", status);
}
status = BLADERF_ERR_IO;
} else {
n_read += read_size;
status = 0;
}
} while (n_read < FLASH_PAGE_SIZE && !status);
status = read_one_page(dev, read_size, page_i, page_buf);
/* Verify the page */
for (check_i = 0; check_i < FLASH_PAGE_SIZE && !status; check_i++) {
@ -742,18 +825,64 @@ static int verify_flash(struct bladerf *dev, int page_offset,
return status;
}
static int write_one_page(struct bladerf *dev, int write_size, int page_offset, uint8_t *data)
{
struct bladerf_lusb *lusb = dev->backend;
size_t buf_off;
int32_t write_status;
int status;
for(buf_off = 0; buf_off < FLASH_PAGE_SIZE; buf_off += write_size)
{
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_OUT,
BLADE_USB_CMD_WRITE_PAGE_BUFFER,
0,
buf_off,
&data[buf_off],
write_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if(status < 0) {
log_error("Failed to write page buffer at offset 0x%02x for page %d: %s\n",
buf_off, page_offset, libusb_error_name(status));
return error_libusb2bladerf(status);
} else if(status != write_size) {
log_error("Got unexpected write size when writing page buffer at offset 0x%02x: "
"expected %d, got %d\n",
write_size, status);
return BLADERF_ERR_IO;
}
}
status = vendor_command_int_index(
dev, BLADE_USB_CMD_FLASH_WRITE,
page_offset, &write_status);
if(status != LIBUSB_SUCCESS) {
return status;
}
if(write_status != 0) {
log_error("Failed to write page %d: %d\n",
page_offset, write_status);
status = BLADERF_ERR_UNEXPECTED;
}
return 0;
}
static int lusb_write_flash(struct bladerf *dev, int page_offset,
uint8_t *data, size_t data_size)
{
int status = 0;
int i;
int n_write, total_written;
int write_size = dev->speed ? FLASH_PAGE_SIZE : 64;
int total_written;
int pages_to_write = FLASH_BYTES_TO_PAGES(data_size);
struct bladerf_lusb *lusb = dev->backend;
uint8_t *data_page;
int write_size = dev->speed ? FLASH_PAGE_SIZE : 64;
log_info("Flashing with write size = %d\n", write_size);
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
@ -765,41 +894,14 @@ static int lusb_write_flash(struct bladerf *dev, int page_offset,
assert(page_offset < FLASH_NUM_PAGES);
assert((page_offset + pages_to_write) < FLASH_NUM_PAGES);
/* FIXME: support data_size that are not multiple of pages */
assert(data_size % FLASH_PAGE_SIZE == 0);
total_written = 0;
for (i = page_offset; i < (page_offset + pages_to_write) && !status; i++) {
n_write = 0;
do {
data_page = data + (i - page_offset) * FLASH_PAGE_SIZE + n_write;
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_OUT,
BLADE_USB_CMD_FLASH_WRITE,
0,
i,
(unsigned char *)data_page,
write_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if (status != write_size) {
if (status < 0) {
log_error("Failed to write page %d: %s\n", i,
libusb_error_name(status));
} else {
log_error("Got unexpected write size: %d\n", status);
}
status = BLADERF_ERR_IO;
} else {
n_write += write_size;
total_written += write_size;
status = 0;
}
} while (n_write < FLASH_PAGE_SIZE && !status);
status = write_one_page(dev, write_size, i, data);
total_written += FLASH_PAGE_SIZE;
data += FLASH_PAGE_SIZE;
}
if (status == 0) {
@ -894,16 +996,7 @@ static int lusb_flash_firmware(struct bladerf *dev,
{
int status;
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
log_error("Failed to set interface: %s\n", libusb_error_name(status));
status = BLADERF_ERR_IO;
}
if (status == 0) {
status = lusb_erase_flash(dev, 0, image_size);
}
status = lusb_erase_flash(dev, 0, image_size);
if (status >= 0) {
status = lusb_write_flash(dev, 0, image, image_size);
@ -971,29 +1064,31 @@ static int lusb_jump_to_bootloader(struct bladerf *dev)
static int lusb_get_otp(struct bladerf *dev, char *otp)
{
struct bladerf_lusb *lusb = dev->backend;
int status;
int read_size = dev->speed ? 256 : 64;
int nbytes;
int otp_page = 0;
int32_t read_status;
for (nbytes = 0; nbytes < 256; nbytes += status) {
status = libusb_control_transfer(
lusb->handle,
LIBUSB_RECIPIENT_INTERFACE |
LIBUSB_REQUEST_TYPE_VENDOR |
EP_DIR_IN,
BLADE_USB_CMD_READ_OTP,
0,
0,
(unsigned char *)&otp[nbytes],
read_size,
BLADERF_LIBUSB_TIMEOUT_MS);
if (status < 0) {
log_error("Failed to read OTP (%d): %s\n", status, libusb_error_name(status));
return error_libusb2bladerf(status);
}
status = change_setting(dev, USB_IF_SPI_FLASH);
if (status) {
log_error("Failed to set interface: %s\n", libusb_error_name(status));
return BLADERF_ERR_IO;
}
return 0;
status = vendor_command_int_index(
dev, BLADE_USB_CMD_READ_OTP,
otp_page, &read_status);
if(status != LIBUSB_SUCCESS) {
return status;
}
if(read_status != 0) {
log_error("Failed to read OTP page %d: %d\n",
otp_page, read_status);
status = BLADERF_ERR_UNEXPECTED;
}
return read_page_buffer(dev, read_size, (uint8_t*)otp);
}
#define CAL_SIZE 256