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/.

%*/

/*

    Example implementation of SD card as secondary flash device.

*/

#include "cyu3system.h"

#include "cyu3os.h"

#include "cyu3usb.h"

#include "cyu3dma.h"

#include "cyu3error.h"

#include "cyu3sib.h"

#define ZTEX_SD_EC_TIMEOUT 2

#define ZTEX_SD_EC_BUSY 3

#define ZTEX_SD_EC_PENDING 4

#define ZTEX_SD_EC_NOTSUPPORTED 7

#define ZTEX_SD_EC_RUNTIME 8

#define ENABLE_SPORT0

#define ZTEX_SD_DONE_EVENT      (1 << 0)        /* SIB transfer done event. */

struct __attribute__((__packed__)) ztex_sd_t {

    uint8_t enabled;                    // 0    1: enabled, 0:disabled

    uint16_t sector_size;               // 1    in bytes

    uint32_t sectors;                   // 3    number of sectors

    uint8_t ec;                         // 7    error code

    uint16_t page_sectors;              // maximum amount of sectors per transfer

};

struct ztex_sd_t ztex_sd;

CyU3PDmaChannel ztex_sd_wr_handle, ztex_sd_rd_handle;

CyU3PEvent ztex_sd_event;

/* *********************************************************************

   ***** ztex_sd_callback **********************************************

   ********************************************************************* */

void ztex_sd_callback (uint8_t portId, CyU3PSibEventType evt, CyU3PReturnStatus_t status) {

    if ( evt == CY_U3P_SIB_EVENT_XFER_CPLT ) CyU3PEventSet (&ztex_sd_event, ZTEX_SD_DONE_EVENT, CYU3P_EVENT_OR);

}

/* *********************************************************************

   ***** ztex_sd_get_info **********************************************

   ********************************************************************* */

void ztex_sd_get_info () {

    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

    CyU3PSibDevInfo_t devInfo;

    ztex_sd.enabled = 0;

    ztex_sd.ec = ZTEX_SD_EC_NOTSUPPORTED;

    ztex_sd.sector_size = 512;

    ztex_sd.sectors = 0;

    ztex_sd.page_sectors = 8;

    // read SD card properties

    ZTEX_REC( status = CyU3PSibQueryDevice (0, &devInfo) );

    if (status != CY_U3P_SUCCESS) return;

    if ( (devInfo.numUnits == 0) || ( (devInfo.cardType != CY_U3P_SIB_DEV_SD) && (devInfo.cardType != CY_U3P_SIB_DEV_MMC)) ) return;  // not supported

    if ( devInfo.blkLen > 2048 ) {

        ZTEX_LOG("Unsupported sector size: %d", devInfo.blkLen);

        return;

    }

    ztex_sd.enabled = 1;

    ztex_sd.sector_size = devInfo.blkLen;

    ztex_sd.sectors = devInfo.numBlks;

    ztex_sd.page_sectors = 4096 / devInfo.blkLen;

    ztex_sd.ec = 0;

}

/* *********************************************************************

   ***** ztex_sd_read **************************************************

   ********************************************************************* */

uint8_t ztex_sd_read (uint8_t* buf, uint32_t sector, uint32_t nblk) {

    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

    CyU3PDmaBuffer_t buf_p;

    uint32_t b2, evStat;

    buf_p.buffer = buf;

    buf_p.status = 0;

    while ( nblk>0 ) {

        b2 = nblk;

        if ( b2 > ztex_sd.page_sectors ) b2 = ztex_sd.page_sectors;

        buf_p.size  = b2 * ztex_sd.sector_size;

        buf_p.count = 0;

        ZTEX_REC(status = CyU3PDmaChannelSetupRecvBuffer (&ztex_sd_rd_handle, &buf_p));

        if (status != CY_U3P_SUCCESS) goto errreturn1;

        ZTEX_REC(status = CyU3PSibReadWriteRequest (CyTrue, 0, 0, b2, sector, (uint8_t)CY_U3P_SIB_SOCKET_1) );

        if (status != CY_U3P_SUCCESS) goto errreturn1;

        CyU3PEventGet(&ztex_sd_event, ZTEX_SD_DONE_EVENT, CYU3P_EVENT_OR_CLEAR, &evStat, 1000);

        if (status != CY_U3P_SUCCESS) goto errreturn2;

//      ZTEX_REC(status = CyU3PDmaChannelWaitForCompletion (&ztex_sd_rd_handle, 1000));

        ZTEX_REC(status = CyU3PDmaChannelWaitForRecvBuffer (&ztex_sd_rd_handle, &buf_p, 1000) );

        if (status != CY_U3P_SUCCESS) goto errreturn2;

        nblk-=b2;

        buf_p.buffer+=b2 * ztex_sd.sector_size;

        sector+=b2;

    }

    return 0;

errreturn2:

    CyU3PSibAbortRequest (0);

errreturn1:

    CyU3PDmaChannelReset (&ztex_sd_rd_handle);

    ztex_sd.ec = ZTEX_SD_EC_RUNTIME;

    return ztex_sd.ec;

}

/* *********************************************************************

   ***** ztex_sd_write *************************************************

   ********************************************************************* */

uint8_t ztex_sd_write (uint8_t* buf, uint32_t sector, uint32_t nblk) {

    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

    CyU3PDmaBuffer_t buf_p;

    uint32_t b2, evStat;

    buf_p.buffer = buf;

    buf_p.status = 0;

    while ( nblk>0 ) {

        b2 = nblk;

        if ( b2 > ztex_sd.page_sectors ) b2 = ztex_sd.page_sectors;

        buf_p.size  = b2 * ztex_sd.sector_size;

        buf_p.count = b2 * ztex_sd.sector_size;

        ZTEX_REC(status = CyU3PSibReadWriteRequest (CyFalse, 0, 0, b2, sector, (uint8_t)CY_U3P_SIB_SOCKET_0) );

        if (status != CY_U3P_SUCCESS) goto errreturn1;

        ZTEX_REC(status = CyU3PDmaChannelSetupSendBuffer (&ztex_sd_wr_handle, &buf_p));

        if (status != CY_U3P_SUCCESS) goto errreturn2;

        ZTEX_REC( status = CyU3PEventGet(&ztex_sd_event, ZTEX_SD_DONE_EVENT, CYU3P_EVENT_OR_CLEAR, &evStat, 5000) );

        if (status != CY_U3P_SUCCESS) goto errreturn2;

        ZTEX_REC(status = CyU3PDmaChannelWaitForCompletion (&ztex_sd_wr_handle, 500));

        if (status != CY_U3P_SUCCESS) goto errreturn2;

        nblk-=b2;

        buf_p.buffer+=b2 * ztex_sd.sector_size;

        sector+=b2;

    }

    return 0;

errreturn2:

    CyU3PSibAbortRequest (0);

errreturn1:

    ztex_sd.ec = ZTEX_SD_EC_RUNTIME;

    CyU3PDmaChannelReset (&ztex_sd_wr_handle);

    return ztex_sd.ec;

}

/* *********************************************************************

   ***** vr_flash2_info ************************************************

   ********************************************************************* */

// VR 0x44

uint8_t vr_flash2_info(uint16_t value, uint16_t index, uint16_t length ) {

    ztex_sd_get_info();

    CyU3PMemCopy( ztex_ep0buf, (uint8_t*)&ztex_sd, 8);

    ZTEX_REC_RET( CyU3PUsbSendEP0Data( 8, ztex_ep0buf ) );

    return 0;

}

/* *********************************************************************

   ***** vr_flash2_read ************************************************

   ********************************************************************* */

// VR 0x45

uint8_t vr_flash2_read(uint16_t value, uint16_t index, uint16_t length ) {

//    ZTEX_LOG("F2R: %d, %d", index, value);

    if ( ztex_sd_read(ztex_ep0buf, (index << 16) | value, length/ztex_sd.sector_size ) ) return 255;

    ZTEX_REC_RET ( CyU3PUsbSendEP0Data( length, ztex_ep0buf ) );

    return 0;

}

/* *********************************************************************

   ***** vr_flash2_write ************************************************

   ********************************************************************* */

// VC 0x46

uint8_t vc_flash2_write(uint16_t value, uint16_t index, uint16_t length ) {

//    ZTEX_LOG("F2W: %d, %d", index, value);

    ZTEX_REC_RET ( CyU3PUsbGetEP0Data (length, ztex_ep0buf, NULL) );

    if ( ztex_sd_write(ztex_ep0buf, (index << 16) | value, length/ztex_sd.sector_size ) ) return 255;

    return 0;

}

/* *********************************************************************

   ***** ztex_sd_init **************************************************

   ********************************************************************* */

void ztex_sd_init () {

    CyU3PReturnStatus_t status = CY_U3P_SUCCESS;

    CyU3PSibIntfParams_t intfParams;

    ztex_sd.enabled = 0;

    ztex_sd.ec = ZTEX_SD_EC_NOTSUPPORTED;

    ztex_register_vendor_req(0x44, vr_flash2_info);

    ztex_register_vendor_req(0x45, vr_flash2_read);

    ztex_register_vendor_cmd(0x46, vc_flash2_write);

    ZTEX_REC( CyU3PDeviceGpioOverride (43, CyTrue) );

    ZTEX_REC( CyU3PDeviceGpioOverride (44, CyTrue) );

    // Configure SD card port

//    intfParams.cardDetType = CY_U3P_SIB_DETECT_DAT_3;   // Card detect based on SD_DAT[3]

    intfParams.cardDetType = CY_U3P_SIB_DETECT_GPIO;    // Card detect based on deticated GPIO pin

    intfParams.writeProtEnable = CyTrue;                // Write protecttion handling enabled

//    intfParams.useDdr = CyFalse;                        // DDR clocking enabled

//    intfParams.maxFreq = CY_U3P_SIB_FREQ_104MHZ;        // No S port clock limitation

    intfParams.useDdr = CyFalse;                        // DDR clocking disabled

    intfParams.maxFreq = CY_U3P_SIB_FREQ_52MHZ;         // S port clock limited to 52 MHz

    intfParams.cardInitDelay   = 5;                     // SD/MMC initialization delay of 5ms 

    intfParams.resetGpio = 0xFF;                        // No reset GPIO's

    intfParams.rstActHigh = CyTrue;

    intfParams.voltageSwGpio = 0xFF;                    // No low voltage switch GPIO's

    intfParams.lvGpioState = CyFalse;

    intfParams.lowVoltage = CyFalse;

    ZTEX_REC( status = CyU3PSibSetIntfParams (0, &intfParams) );

    if (status != CY_U3P_SUCCESS) goto errreturn;

    // start the module and initialize SD card

    ZTEX_REC( status = CyU3PSibStart() );

    if (status != CY_U3P_SUCCESS) goto errreturn;

    // init event handler

    ZTEX_REC(status = CyU3PEventCreate (&ztex_sd_event));

    if (status != CY_U3P_SUCCESS) goto errreturn;

    ZTEX_REC(status = CyU3PSibRegisterCbk (ztex_sd_callback));

    if (status != CY_U3P_SUCCESS) goto errreturn;

    // create DMA channels

    CyU3PDmaChannelConfig_t dmaConfig;

    CyU3PMemSet ((uint8_t *)&dmaConfig, 0, sizeof(dmaConfig));

    dmaConfig.size           = 4096;

    // 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 SD flash

    dmaConfig.prodSckId = CY_U3P_CPU_SOCKET_PROD;

    dmaConfig.consSckId = CY_U3P_SIB_SOCKET_0;

    ZTEX_REC(status =  CyU3PDmaChannelCreate (&ztex_sd_wr_handle, CY_U3P_DMA_TYPE_MANUAL_OUT, &dmaConfig) );

    if (status != CY_U3P_SUCCESS) goto errreturn;

    // Channel to read from SD flash

    dmaConfig.prodSckId = CY_U3P_SIB_SOCKET_1;

    dmaConfig.consSckId = CY_U3P_CPU_SOCKET_CONS;

    ZTEX_REC(status =  CyU3PDmaChannelCreate (&ztex_sd_rd_handle, CY_U3P_DMA_TYPE_MANUAL_IN, &dmaConfig) );

    if (status != CY_U3P_SUCCESS) goto errreturn;

    // read SD card properties

    ztex_sd_get_info();

    if ( ztex_sd.enabled == 0 ) goto noflashreturn;

    ZTEX_LOG("Found %d MByte SD Flash",(ztex_sd.sectors>>14)*(ztex_sd.sector_size>>6));

    return;

errreturn:

    ztex_sd.ec = ZTEX_SD_EC_RUNTIME;

noflashreturn:

    ztex_log("No SD Flash found");

}

/* *********************************************************************

   ***** ztex_usb_stop_sd **********************************************

   ********************************************************************* */

void ztex_usb_stop_sd() {

    CyU3PDmaChannelReset (&ztex_sd_wr_handle);

    CyU3PDmaChannelReset (&ztex_sd_rd_handle);

}