Subversion Repositories usb_fpga_2_14

/*%
   ZTEX Firmware Kit for EZ-USB FX3 Microcontrollers
   Copyright (C) 2009-2017 ZTEX GmbH.
   http://www.ztex.de
 
   This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this file,
   You can obtain one at http://mozilla.org/MPL/2.0/.
 
   Alternatively, the contents of this file may be used under the terms
   of the GNU General Public License Version 3, as described below:
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 3 as
   published by the Free Software Foundation.
 
   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, see http://www.gnu.org/licenses/.
%*/
/*
    SPI flash support.
*/
 
#include "cyu3system.h"
#include "cyu3os.h"
#include "cyu3usb.h"
#include "cyu3spi.h"
#include "cyu3dma.h"
#include "cyu3error.h"
 
#define ZTEX_SPI_DMA
#define ZTEX_SPI_PAGE_SIZE 256
 
#ifdef ZTEX_SPI_DMA
CyU3PDmaChannel ztex_spi_wr_handle, ztex_spi_rd_handle;
#endif
 
#define FLASH_EC_TIMEOUT 2
#define FLASH_EC_BUSY 3
#define FLASH_EC_PENDING 4
#define FLASH_EC_NOTSUPPORTED 7
#define FLASH_EC_RUNTIME 8
 
struct __attribute__((__packed__)) ztex_flash_t {
    uint8_t enabled;			// 0	1: enabled, 0:disabled
    uint16_t sector_size; 		// 1    sector size <sector size> = MSB==0 : flash_sector_size and 0x7fff ? 1<<(flash_sector_size and 0x7fff)
    uint32_t sectors;			// 3	number of sectors
    uint8_t ec; 	       		// 7	error code
 
    uint8_t vendor;			// 0
    uint8_t device;			// 1
    uint8_t memtype;			// 2
    uint8_t erase_cmd;			// 3
    uint8_t last_cmd;			// 4
    uint8_t buf[4];			// 5
    uint8_t cs;
 
    uint32_t ep0_read_addr;
    uint8_t need_pp;
    uint32_t write_addr;
};
 
struct ztex_flash_t ztex_flash;
 
void ztex_flash_select () {
    CyU3PSpiSetSsnLine(CyFalse);
    ztex_flash.cs = 1;
}
 
void ztex_flash_deselect () {
    CyU3PSpiSetSsnLine(CyTrue);
    ztex_flash.cs = 0;
}
 
uint8_t ztex_flash_wait() {
    uint16_t i;
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
 
    ztex_flash.ec = ztex_flash.cs ? FLASH_EC_PENDING : ztex_flash.enabled ? 0 : FLASH_EC_NOTSUPPORTED;
    if ( ztex_flash.ec ) return ztex_flash.ec;
 
    ztex_flash.buf[0]=ztex_flash.last_cmd=5;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 1));
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
    for ( i=0; i<11000; i++) {  // wait up to 11s
	ZTEX_REC(status = CyU3PSpiReceiveWords (ztex_flash.buf, 4));
	if (status != CY_U3P_SUCCESS) goto errreturn;
	if ( !(ztex_flash.buf[0] & 1) ) break;
	CyU3PThreadSleep(1);	// 1ms
    }
    ztex_flash_deselect();
    ztex_flash.ec = ztex_flash.buf[0] & 1 ? FLASH_EC_TIMEOUT : 0;
    return ztex_flash.ec;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    return ztex_flash.ec;
}
 
uint8_t ztex_flash_read (uint8_t* buf, uint32_t addr, uint32_t size) {
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
 
    if ( ztex_flash_wait() ) return ztex_flash.ec;
 
    ztex_flash.buf[0]=ztex_flash.last_cmd=0xb;
    ztex_flash.buf[1]=addr>>16;
    ztex_flash.buf[2]=addr>>8;
    ztex_flash.buf[3]=addr;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 5));
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
#ifdef ZTEX_SPI_DMA
    CyU3PDmaBuffer_t buf_p;
    uint32_t s2;
 
    buf_p.buffer = buf;
    buf_p.status = 0;
 
    while ( size>0 ) {
	s2 = size;
	if ( s2 > ZTEX_SPI_PAGE_SIZE ) s2 = ZTEX_SPI_PAGE_SIZE;
 
        buf_p.size  = s2;
	buf_p.count = s2;
 
	CyU3PSpiSetBlockXfer (0, s2);
	ZTEX_REC(status = CyU3PDmaChannelSetupRecvBuffer (&ztex_spi_rd_handle, &buf_p));
	if (status != CY_U3P_SUCCESS) goto errreturn;
 
	ZTEX_REC(status = CyU3PDmaChannelWaitForCompletion (&ztex_spi_rd_handle, 500));
	if (status != CY_U3P_SUCCESS) {
    	    CyU3PDmaChannelReset (&ztex_spi_rd_handle);
    	    CyU3PSpiDisableBlockXfer (CyFalse, CyTrue);
	    goto errreturn;
	}
        CyU3PSpiDisableBlockXfer (CyFalse, CyTrue);
 
        size-=s2;
        buf_p.buffer+=s2;
//        CyU3PThreadSleep(1);
    }
#else
    ZTEX_REC(status = CyU3PSpiReceiveWords(buf, size) );
    if (status != CY_U3P_SUCCESS) goto errreturn;
#endif
    ztex_flash_deselect();
    return 0;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    return ztex_flash.ec;
}
 
 
// sends pp command
uint8_t ztex_flash_pp () {
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
 
    ztex_flash_deselect();			// finish previous write cmd
    ztex_flash.need_pp = 0;
    if ( ztex_flash_wait() ) return ztex_flash.ec;
 
//    ZTEX_LOG("flash_pp: %d",ztex_flash.write_addr);
 
    ztex_flash.buf[0]=ztex_flash.last_cmd=0x06;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 1));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ztex_flash_deselect();
 
    ztex_flash.buf[0]=ztex_flash.last_cmd=0x02;
    ztex_flash.buf[1]=ztex_flash.write_addr >> 16;
    ztex_flash.buf[2]=ztex_flash.write_addr >> 8;
    ztex_flash.buf[3]=ztex_flash.write_addr;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 4));
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
    return 0;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    return ztex_flash.ec;
}
 
// has to be called at begin of a 64K write sequence
uint8_t ztex_flash_write_start (uint16_t sector) {
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
 
    if ( ztex_flash_wait() ) return ztex_flash.ec;
 
    // write enable command
    ztex_flash.buf[0]=ztex_flash.last_cmd=0x06;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 1));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ztex_flash_deselect();
 
    // erase  command
//    ztex_log("flash_erase");
    ztex_flash.buf[0]=ztex_flash.last_cmd=ztex_flash.erase_cmd;
    ztex_flash.buf[1]=sector;
    ztex_flash.buf[2]=0;
    ztex_flash.buf[3]=0;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 4));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ztex_flash_deselect();
 
    ztex_flash.need_pp = 1;
    ztex_flash.write_addr = sector << 16;
    return 0;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    return ztex_flash.ec;
}
 
// is called between ztex_write_start and ztex_write_finish
uint8_t ztex_flash_write (uint8_t* buf, uint32_t size) {
    uint32_t s2;
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
 
    if ( ztex_flash.need_pp && ztex_flash_pp() ) return ztex_flash.ec;
 
    while (size>0) {
	s2 = 256-(ztex_flash.write_addr & 255);
	if (s2>size) s2=size;
#ifdef ZTEX_SPI_DMA
	CyU3PDmaBuffer_t buf_p;
 
        buf_p.size  = s2;
	buf_p.count = s2;
	buf_p.buffer = buf;
	buf_p.status = 0;
 
	CyU3PSpiSetBlockXfer (s2, 0);
	ZTEX_REC( status = CyU3PDmaChannelSetupSendBuffer (&ztex_spi_wr_handle, &buf_p) );
 
	ZTEX_REC(status = CyU3PDmaChannelWaitForCompletion (&ztex_spi_wr_handle, 500));
	if (status != CY_U3P_SUCCESS) {
    	    CyU3PSpiDisableBlockXfer (CyTrue, CyFalse);
	    goto errreturn;
	}
        CyU3PSpiDisableBlockXfer (CyTrue, CyFalse);
#else	
	ZTEX_REC(status = CyU3PSpiTransmitWords (buf, s2));
	if (status != CY_U3P_SUCCESS) goto errreturn;
#endif	
	size-=s2;
	buf+=s2;
	ztex_flash.write_addr+=s2;
	if ( size==0 ) {
	    ztex_flash_deselect();	// finish pp
	    ztex_flash.need_pp = 1;	// do not wait
	}
	else {
	    if ( ztex_flash_pp() ) return ztex_flash.ec; // finish pp + wait
	}
    }
 
    return 0;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    return ztex_flash.ec;
}
 
// is called after ztex_flash_write
void ztex_flash_write_finish () {
    ztex_flash_deselect();
}
 
 
// VR 0x40
uint8_t vr_flash_info(uint16_t value, uint16_t index, uint16_t length ) {
    if ( ztex_flash.ec==0 && ztex_flash.cs ) ztex_flash.ec = FLASH_EC_PENDING;
    CyU3PMemCopy( ztex_ep0buf, (uint8_t*)&ztex_flash, 8);
    ZTEX_REC_RET( CyU3PUsbSendEP0Data( 8, ztex_ep0buf ) );
    return 0;
}
 
// VR 0x41
uint8_t vr_flash_read(uint16_t value, uint16_t index, uint16_t length ) {
    index = index >> 8;
    if ( index==0 ) {
//        ZTEX_LOG("FR: %d, %d", index, value);
	ztex_flash.ep0_read_addr = value << 16;
    }
    if ( ztex_flash_read(ztex_ep0buf,ztex_flash.ep0_read_addr,length) ) return 255;
    ztex_flash.ep0_read_addr += length;
    ZTEX_REC_RET ( CyU3PUsbSendEP0Data( length, ztex_ep0buf ) );
    return 0;
}
 
// VC 0x42
uint8_t vc_flash_write(uint16_t value, uint16_t index, uint16_t length ) {
    index = index >> 8;
//    ZTEX_LOG("FW: %d, %d", index, value);
    if ( index==0 && ztex_flash_write_start(value) ) return 255;
 
    ZTEX_REC_RET ( CyU3PUsbGetEP0Data (length, ztex_ep0buf, NULL) );
    if ( ztex_flash_write(ztex_ep0buf,length) ) return 255;
 
    if ( index==3 ) ztex_flash_write_finish();
    return 0;
}
 
// VR 0x43
uint8_t vr_flash_info2(uint16_t value, uint16_t index, uint16_t length ) {
    CyU3PMemCopy( ztex_ep0buf, (uint8_t*)&ztex_flash.ec, 10);
    return CyU3PUsbSendEP0Data( 10, ztex_ep0buf );
}
 
void ztex_flash_init () {
    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;
    CyU3PSpiConfig_t spiConfig;
 
    ztex_flash.enabled = 0;
    ztex_flash.ec = FLASH_EC_NOTSUPPORTED;
    ztex_flash.cs = 0;
 
    ztex_register_vendor_req(0x40, vr_flash_info);
    ztex_register_vendor_req(0x41, vr_flash_read);
    ztex_register_vendor_cmd(0x42, vc_flash_write);
    ztex_register_vendor_req(0x43, vr_flash_info2);
 
    // Start the SPI module and configure the master 
    ZTEX_REC(status = CyU3PSpiInit());
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
    /* Start the SPI master block. Run the SPI clock at 8MHz
       and configure the word length to 8 bits. Also configure
       the slave select using FW */
    CyU3PMemSet ((uint8_t *)&spiConfig, 0, sizeof(spiConfig));
    spiConfig.isLsbFirst = CyFalse;
    spiConfig.cpol       = CyTrue;
    spiConfig.ssnPol     = CyFalse;
    spiConfig.cpha       = CyTrue;
    spiConfig.leadTime   = CY_U3P_SPI_SSN_LAG_LEAD_HALF_CLK;
    spiConfig.lagTime    = CY_U3P_SPI_SSN_LAG_LEAD_HALF_CLK;
    spiConfig.ssnCtrl    = CY_U3P_SPI_SSN_CTRL_FW;
    spiConfig.clock      = 33000000;
//    spiConfig.clock      = 10000000;
    spiConfig.wordLen    = 8;
    ZTEX_REC(status =  CyU3PSpiSetConfig (&spiConfig, NULL) );
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
#ifdef ZTEX_SPI_DMA
    CyU3PDmaChannelConfig_t dmaConfig;
 
    // DMA channels for SPI write 
    CyU3PMemSet ((uint8_t *)&dmaConfig, 0, sizeof(dmaConfig));
    dmaConfig.size           = ZTEX_SPI_PAGE_SIZE;
    // No buffers need to be allocated as this channel will be used only in override mode. */
    dmaConfig.count          = 0;
    dmaConfig.prodAvailCount = 0;
    dmaConfig.dmaMode        = CY_U3P_DMA_MODE_BYTE;
    dmaConfig.prodHeader     = 0;
    dmaConfig.prodFooter     = 0;
    dmaConfig.consHeader     = 0;
    dmaConfig.notification   = 0;
    dmaConfig.cb             = NULL;
 
    /* Channel to write to SPI flash. */
    dmaConfig.prodSckId = CY_U3P_CPU_SOCKET_PROD;
    dmaConfig.consSckId = CY_U3P_LPP_SOCKET_SPI_CONS;
    ZTEX_REC(status =  CyU3PDmaChannelCreate (&ztex_spi_wr_handle, CY_U3P_DMA_TYPE_MANUAL_OUT, &dmaConfig) );
    if (status != CY_U3P_SUCCESS) goto errreturn;
 
    /* Channel to read from SPI flash. */
    dmaConfig.prodSckId = CY_U3P_LPP_SOCKET_SPI_PROD;
    dmaConfig.consSckId = CY_U3P_CPU_SOCKET_CONS;
    ZTEX_REC(status =  CyU3PDmaChannelCreate (&ztex_spi_rd_handle, CY_U3P_DMA_TYPE_MANUAL_IN, &dmaConfig) );
    if (status != CY_U3P_SUCCESS) goto errreturn;
#endif
 
    // CMD 0x90 may not be supported by all devices
    ztex_flash.buf[0]=0x90;
    ztex_flash.buf[1]=0;
    ztex_flash.buf[2]=0;
    ztex_flash.buf[3]=0;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 4));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ztex_flash.device = CyU3PSpiReceiveWords (ztex_flash.buf, 2) == CY_U3P_SUCCESS ? ztex_flash.buf[1] : 127;
    ztex_flash_deselect();
 
    // CMD 0x9F: JEDEC ID
    ztex_flash.buf[0]=ztex_flash.last_cmd=0x9F;
    ztex_flash_select();
    ZTEX_REC(status = CyU3PSpiTransmitWords (ztex_flash.buf, 1));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ZTEX_REC(status = CyU3PSpiReceiveWords (ztex_flash.buf, 3));
    if (status != CY_U3P_SUCCESS) goto errreturn;
    ztex_flash_deselect();
 
    if ( ztex_flash.buf[2]<16 || ztex_flash.buf[2]>24 ) {
	ztex_log("Error: Invalid Flash size");
	return;
    }
    ztex_flash.vendor = ztex_flash.buf[0];
    ztex_flash.memtype = ztex_flash.buf[1];
    ztex_flash.sector_size = 0x8010;  		// only 64 KByte sectors are supported because erasing 4 KByte is extremely slow
    ztex_flash.sectors = 1 << (ztex_flash.buf[2]-16);
    ztex_flash.erase_cmd = 0xd8;
    ztex_flash.ec = 0;
    ztex_flash.enabled = 1;
 
    ZTEX_LOG("Info: Found %d MBit SPI Flash",ztex_flash.sectors>>1);
    return;
 
errreturn:
    ztex_flash.ec = FLASH_EC_RUNTIME;
    ztex_flash_deselect();
    ztex_log("Error: No SPI Flash found");
}
 
void ztex_usb_stop_flash() {
#ifdef ZTEX_SPI_DMA
    CyU3PDmaChannelReset (&ztex_spi_wr_handle);
    CyU3PDmaChannelReset (&ztex_spi_rd_handle);
#endif    
}