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

%*/

/*

    Debugging and logging functions.

*/

#include "cyu3system.h"

#include "cyu3os.h"

#include "cyu3usb.h"

#define ZTEX_DEBUG_MSG_SIZE_MAX         32

#define ZTEX_DEBUG_MSG_LIMIT            ZTEX_DEBUG_MSG_SIZE_MAX  // maximum amount of messages between two get debug messages requests

#define ZTEX_LOG( args... ) {                           \

    uint8_t* buf = CyU3PMemAlloc(512);                  \

    CyU3PDebugStringPrint(buf, 512, args );             \

    ztex_debug_add(1, strlen((char*)buf), buf, 2);      \

    CyU3PMemFree(buf);                                  \

}

#define ZTEX_ASSERT( a ) {                              \

    if (!(a)) ztex_runtime_error( 65530, __FILE__, __LINE__ );  \

}

#define ZTEX_ASSERT_RET( a ) {                          \

    if (!(a)) {                                         \

        ztex_runtime_error( 65530, __FILE__, __LINE__ );        \

        return 255;                                     \

    }                                                   \

}

#define ZTEX_REC(a) {                                   \

    uint16_t ec=(a);                                    \

    if ( ec != 0 ) {                                     \

        ztex_runtime_error( ec, __FILE__, __LINE__ );   \

    }                                                   \

}

#define ZTEX_REC_RET(a) {                               \

    uint16_t ec=(a);                                    \

    if ( ec != 0 ) {                                     \

        ztex_runtime_error( ec, __FILE__, __LINE__ );   \

        return 255;                                     \

    }                                                   \

}

#define ZTEX_REC_CONT(a) {                              \

    uint16_t ec=(a);                                    \

    if ( ec != 0 ) {                                     \

        ztex_runtime_error( ec, __FILE__, __LINE__ );   \

        continue;                                       \

    }                                                   \

}

uint8_t ztex_ec = 0;                             // 1 if firmware halted due to fatal error

uint32_t debug_msg_last = 0;                     // index of last debug message + 1

uint16_t debug_msg_cnt = 0;                      // number of stored messages

uint16_t debug_msg_limit = ZTEX_DEBUG_MSG_LIMIT;        // current message limit

uint8_t* debug_msg[ZTEX_DEBUG_MSG_SIZE_MAX];            // debug messages

uint16_t debug_msg_size[ZTEX_DEBUG_MSG_SIZE_MAX];       // length of the message

uint8_t debug_msg_type[ZTEX_DEBUG_MSG_SIZE_MAX];        // 1: string; 2: line info, other values: data

uint8_t debug_msg_action[ZTEX_DEBUG_MSG_SIZE_MAX];      // 0: do nothing, 1 free memory if overwritten, >1 copy + free           

void ztex_debug_add(uint8_t type, uint16_t size, uint8_t* buf, uint8_t action) {

    if (debug_msg_last >= debug_msg_limit ) {

        if ( action >= 1 ) CyU3PMemFree(buf);

        return;

    }

    uint16_t j = debug_msg_last % ZTEX_DEBUG_MSG_SIZE_MAX;

    if ( debug_msg_last >= ZTEX_DEBUG_MSG_SIZE_MAX ) {

        if ( debug_msg_action[j] >= 1 ) CyU3PMemFree(debug_msg[j]);

    }

    else {

        debug_msg_cnt++;

    }

    debug_msg_last++;

    if ( action>1 ) {

        debug_msg[j] = CyU3PMemAlloc(size);

        CyU3PMemCopy(debug_msg[j], buf, size);

    }

    else {

        debug_msg[j]=buf;

    }

    debug_msg_size[j] = size;

    debug_msg_type[j] = type;

    debug_msg_action[j] = action;

}

uint8_t ztex_log ( const char* str ) {

    ztex_debug_add(1, strlen(str), (uint8_t*) str, 0);

    return(255);

}

void ztex_runtime_error ( uint16_t ec, const char* fn, uint16_t line ) {

    uint8_t size=strlen(fn)+4;

    uint8_t* buf=CyU3PMemAlloc(size);

    buf[0]=ec;

    buf[1]=ec>>8;

    buf[2]=line;

    buf[3]=line>>8;

    CyU3PMemCopy(&buf[4], (uint8_t*)fn, size-4);

    ztex_debug_add(2, size, buf, 1);

}

// VR 0x28

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

    uint32_t idx = index | (value << 16);

    if ( length < 10 ) length = 10;

    if ( length > 4096 ) length = 4096;

    ztex_ep0buf[0]=ztex_ec;

    ztex_ep0buf[1]=debug_msg_last;

    ztex_ep0buf[2]=debug_msg_last>>8;

    ztex_ep0buf[3]=debug_msg_last>>16;

    ztex_ep0buf[4]=debug_msg_last>>24;

    ztex_ep0buf[5]=debug_msg_cnt;

    ztex_ep0buf[6]=debug_msg_cnt>>8;

    if ( (idx<debug_msg_last-debug_msg_cnt) || idx>=debug_msg_last) {

        ztex_ep0buf[7]=0;

        ztex_ep0buf[8]=0;

        ztex_ep0buf[9]=255;

        length=10;

    }

    else {

        uint16_t j = idx % ZTEX_DEBUG_MSG_SIZE_MAX;

        ztex_ep0buf[7]=debug_msg_size[j];

        ztex_ep0buf[8]=debug_msg_size[j]>>8;

        ztex_ep0buf[9]=debug_msg_type[j];

        for ( uint16_t i = 0; i < debug_msg_size[j]; i++ )

            if ( length>i+10) ztex_ep0buf[i+10]=debug_msg[j][i];

        length=10+debug_msg_size[j];

    }

    idx+=ZTEX_DEBUG_MSG_LIMIT;

    if (idx>=debug_msg_limit) debug_msg_limit=idx;

    ZTEX_REC_RET( CyU3PUsbSendEP0Data( length, ztex_ep0buf ) );

    return 0;

}

// VR 0x29

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

    uint16_t w;

    ztex_ep0buf[0] = w = ZTEX_USB3_SND_ERROR_COUNT;

    ztex_ep0buf[1] = w >> 8;

    ztex_ep0buf[2] = w = ZTEX_USB3_RCV_ERROR_COUNT;

    ztex_ep0buf[3] = w >> 8;

    ztex_ep0buf[3] = 0;                  // reserved for future use

    ztex_ep0buf[4] = 0;                  // reserved for future use

    ztex_ep0buf[5] = 0;                  // reserved for future use

    ztex_ep0buf[6] = 0;                  // reserved for future use

    ztex_ep0buf[7] = 0;                  // reserved for future use

    if (length>8) length = 8;

    ZTEX_REC_RET( CyU3PUsbSendEP0Data( length, ztex_ep0buf ) );

    return 0;

}

uint8_t ztex_register_vendor_req(uint8_t idx, ztex_vendor_func f);

void ztex_debug_init () {

    ztex_register_vendor_req(0x28, ztex_vr_debug_send);

    ztex_register_vendor_req(0x29, ztex_vr_usb3_errors);

}