Subversion Repositories usb_fpga_2_14

/*%
   ZTEX Core API for C with examples
   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/.
%*/
 
/** @file
memfifo example for C.
This example demonstrates the usage of the C API and the high speed interface of the default firmware.
 
It performs certain tests (device and data integrity, read-write tests, performance) using the memory FIFO as described on
<a href="http://wiki.ztex.de/doku.php?id=en:ztex_boards:ztex_fpga_boards:memfifo:memfifo">memfifo example</a>.
 
The correct bitstream is detected and found automatically if the binary is executed from 
the directory tree of the SDK. Otherwise it can be specified with parameter '-s'.
 
Full list of options can be obtained with '-h'
@include memfifo.c
@cond memfifo
*/
 
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <libusb-1.0/libusb.h>
 
#include "ztex.h"
 
#define BULK_BUF_SIZE 4*1024*1024
#define RW_SIZE 65000			// must be smaller then FIFO size, 64K on USB-FPGA Module 2.01
 
static char* prog_name = NULL;		// name of the program
 
static int paramerr(const char* format,...)
{
    fprintf(stderr, "Usage: %s options\n",prog_name);
    fprintf(stderr, "  -h                           Display this usage information\n"
		    "  -fu <vendor ID>:<product ID> Select device by USB IDs, default: 0x221A:0x100, <0:ignore ID\n"
		    "  -fd <bus>:<device>           Select device by bus number and device address\n"
		    "  -fs <string>                 Select device by serial number string\n"
		    "  -fp <string>                 Select device by product string\n"
		    "  -s <path>                    Additional search path for bitstream, default '.."DIRSEP".."DIRSEP"examples"DIRSEP"memfifo'\n"
		    "  -r                           Reset device (default: reset configuration only)\n"
		    "  -i                           Print device info\n"
		    "  -p                           Print matching USB devices\n"
		    "  -pa                          Print all USB devices\n"
	    );
    if ( format ) {
	va_list args;
	va_start(args,format);
    	vfprintf(stderr, format, args);
    	va_end(args);
	return 1;
    }
    return 0;
}
 
int main(int argc, char **argv)
{
    int id_vendor = 0x221A;  	// ZTEX vendor ID
    int id_product = 0x100; 	// default product ID for ZTEX firmware
    int status = 0;
    libusb_device **devs = NULL;
    int print_all=0, print=0, print_info=0, reset_dev=0;
    int busnum = -1, devnum = -1;
    char *sn_string = NULL, *product_string = NULL;
    libusb_device_handle *handle = NULL;
    ztex_device_info info;
    char *bitstream_fn = NULL, *bitstream_path = NULL;
    char sbuf[8192];
    unsigned char *mbuf = NULL;
    int transferred, size;
    struct timeval tv1,tv2;
 
    // process parameters
    prog_name = argv[0];
    for (int i=1; i<argc; i++) {
	if ( !strcmp(argv[i],"-h") ) return paramerr(NULL);
	else if ( !strcmp(argv[i],"-p") ) print=1;
	else if ( !strcmp(argv[i],"-pa") ) print_all=1;
	else if ( !strcmp(argv[i],"-i") ) print_info=1;
	else if ( !strcmp(argv[i],"-r") ) reset_dev=1;
	else if ( !strcmp(argv[i],"-fu") ) {
	    i++;
	    if (i>=argc || sscanf(argv[i],"%i:%i", &id_vendor, &id_product)!=2 ) return paramerr("Error: <vendor ID>:<product ID> expected after -fu\n");
	}
	else if ( !strcmp(argv[i],"-fd") ) {
	    i++;
	    if (i>=argc || sscanf(argv[i],"%i:%i", &busnum, &devnum)!=2 ) return paramerr("Error: <bus>:<device> expected after -fd\n");
	}
	else if ( !strcmp(argv[i],"-fs") ) {
	    i++;
	    if (i>=argc ) return paramerr("Error: <string> expected after -fs\n");
	    sn_string = argv[i];
	}
	else if ( !strcmp(argv[i],"-fp") ) {
	    i++;
	    if (i>=argc ) return paramerr("Error: <string> expected after -fp\n");
	    product_string = argv[i];
	}
	else if ( !strcmp(argv[i],"-s") ) {
	    i++;
	    if (i>=argc ) return paramerr("Error: <path> expected after -s\n");
	    bitstream_path = argv[i];
	}
	else return paramerr("Error: Invalid parameter %s\n", argv[i]);
    }
 
 
    // INIT libusb
    status = libusb_init(NULL);
    if (status < 0) {
    	fprintf(stderr,"Error: Unable to init libusb: %s\n", libusb_error_name(status));
	return 1;
    }
 
    // find all USB devices
    status = libusb_get_device_list(NULL, &devs);
    if (status < 0) {
	fprintf(stderr,"Error: Unable to get device list: %s\n", libusb_error_name(status));
	goto err;
    }
 
    // print bus info or find device
    int dev_idx = ztex_scan_bus(sbuf, sizeof(sbuf), devs, print_all ? -1 : print ? 1 : 0, id_vendor, id_product, busnum, devnum, sn_string, product_string);
    printf(sbuf);
    fflush(stdout);
    if ( print || print_all ) {
	status = 0;
	goto noerr;
    } else if ( dev_idx<0 ) {
	if (dev_idx==-1) fprintf(stderr,"Error: No device found\n");
	goto err;
    }
 
    // open device
    status = libusb_open(devs[dev_idx], &handle);
    if (status < 0) {
	fprintf(stderr,"Error: Unable to open device: %s\n", libusb_error_name(status));
	goto err;
    }
    libusb_free_device_list(devs, 1);
    devs=NULL;
 
    // reset configuration or device
   if ( ! reset_dev ) {
	status = libusb_set_configuration(handle,-1);
	if (status < 0) {
	    fprintf(stderr,"Warning: Unable to unconfigure device: %s, trying to reset it\n", libusb_error_name(status));
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
	    fprintf(stderr,"Due to limitations of Windows neither this nor device reset works. This may cause further errors ...\n");
#endif    
	    reset_dev = 1;
	}
    }
    if ( reset_dev ) {
	status = libusb_reset_device(handle);
	if (status < 0) {
	    fprintf(stderr,"Error: Unable to reset device: %s\n", libusb_error_name(status));
	    goto err;
	}
    }
    status = libusb_set_configuration(handle,1);
    if (status < 0) fprintf(stderr,"Warning: Unable to set configuration 1: %s\n", libusb_error_name(status));
    fflush(stderr);
 
    // get and print device info
    status = ztex_get_device_info(handle, &info);
    if ( status < 0 ) {
	fprintf(stderr,"Error: Unable to get device info: %s\n", libusb_error_name(status));
	goto err;
    }
    if ( print_info ) {
	ztex_print_device_info( sbuf, sizeof(sbuf), &info );
	printf(sbuf);
	status = ztex_get_fpga_config(handle);
	if ( status < 0 ) {
	    fprintf(stderr,"Error: Unable to get FPGA configuration state: %s\n", libusb_error_name(status));
	    goto err;
	}
	printf("FPGA: %s\n", status==0 ? "unconfigured" : "configured");
	status = 0;
	goto noerr;
    }
 
    // find bitstream
    bitstream_fn = ztex_find_bitstream( &info, bitstream_path ? bitstream_path : ".."DIRSEP".."DIRSEP"examples"DIRSEP"memfifo" , "memfifo");
    if ( bitstream_fn )  {
	printf("Using bitstream '%s'\n", bitstream_fn);
	fflush(stdout);
    }
    else {
        fprintf(stderr,"Warning: Bitstream not found\n");
        goto nobitstream;
    }
 
    // read and upload bitstream
    FILE *fd = fopen(bitstream_fn, "rb");
    if ( fd == NULL ) {
        fprintf(stderr,"Warning: Error opening file '%s'\n", bitstream_fn);
        goto nobitstream;
    }
    status = ztex_upload_bitstream(sbuf,sizeof(sbuf),handle,&info,fd,-1);
    fclose(fd);
    fprintf(stderr,sbuf);
 
nobitstream:
    fflush(stderr);
    // check config
    status = ztex_get_fpga_config(handle);
    if ( status < 0 ) {
        fprintf(stderr,"Error: Unable to get FPGA configuration state: %s\n", libusb_error_name(status));
        goto err;
    } else if ( status == 0 ) {
        fprintf(stderr,"Error: FPGA not configured\n");
        goto err;
    }
 
    // claim interface
    status = libusb_claim_interface(handle, 0); 
    if ( status < 0 ) {
        fprintf(stderr,"Error claiming interface 0: %s\n", libusb_error_name(status));
        goto err;
    }
 
    mbuf = malloc(BULK_BUF_SIZE);
    if ( !mbuf ) {
        fprintf(stderr,"Error allocating %d bytes\n", BULK_BUF_SIZE);
        goto err;
    }
 
// verify mode and prepare device if necessary
    if ( ztex_default_gpio_ctl(handle,0,0) ) {
	fprintf(stderr,"Warning: wrong initial mode, switching to mode 0\n");
	ztex_default_gpio_ctl(handle,7,0);
        ztex_default_reset(handle,0);
        libusb_bulk_transfer(handle, info.default_in_ep, mbuf, BULK_BUF_SIZE, &transferred, 250);
    } else {
	status = libusb_bulk_transfer(handle, info.default_in_ep, mbuf, BULK_BUF_SIZE, &transferred, 250);
	if ( (status>=0) && (transferred>0) ) fprintf(stderr,"Warning: found %d bytes in EZ-USB FIFO\n", transferred);
    }
    fflush(stderr);
 
// test 1: read-write test (mode 0)
    for (int i=0; i<RW_SIZE; i+=2) {
	mbuf[i] = (i>>1) & 127;
	mbuf[i+1] = 128 | ((i >> 8 ) & 127);
    }
    TWO_TRIES(status, libusb_bulk_transfer(handle, info.default_out_ep, mbuf, RW_SIZE, &transferred, 2000));
    if ( status < 0 ) {
        fprintf(stderr,"Bulk write error: %s\n", libusb_error_name(status));
        goto err;
    }
    printf("Read-write test, short packet test: wrote %d Bytes\n", transferred);
    fflush(stdout);
 
    TWO_TRIES(status, libusb_bulk_transfer(handle, info.default_in_ep, mbuf, BULK_BUF_SIZE, &transferred, 4000));
    if ( status < 0 ) {
        fprintf(stderr,"Bulk read error: %s\n", libusb_error_name(status));
        goto err;
    }
    {
	int i=mbuf[0]>>7;
	int j=mbuf[i] | ((mbuf[i+1] & 127)<<7);
	printf("Read-write test: read (%d=%d*512+%d) Bytes.  %d leading Bytes lost", transferred, transferred/512, transferred&511, j*2  );
	if ( j ) printf("(This may be platform specific)" );
	size = 0;
	for (i=i+2; i+1<transferred; i+=2) {
	    int k = mbuf[i] | ((mbuf[i+1] & 127)<<7);
	    if ( k != ((j+1) & 0x3fff) ) size +=1;
	    j=k;
        }
	printf(". %d data errors.  %d Bytes remaining in FIFO due to memory transfer granularity\n", size, RW_SIZE-transferred);
	fflush(stdout);
    }
 
// test 2: read rate test using test data generator (mode 1)
    // reset application and set mode 1
    ztex_default_reset(handle,0);
    status = ztex_default_gpio_ctl(handle,7,1);
    if ( status < 0 ) {
        fprintf(stderr,"Error setting GPIO's: %s\n", libusb_error_name(status));
        goto err;
    }
 
    // read data and measure time, first packets are ignored because EZ-USB buffer may be filled
    printf("Measuring read rate using libusb_bulk_transfer ... \n");
    fflush(stdout);
    size=0;
    for (int i=0; i<55; i++) {
	if ( i==5 ) gettimeofday(&tv1, NULL);
	TWO_TRIES( status, libusb_bulk_transfer(handle, info.default_in_ep, mbuf, BULK_BUF_SIZE, &transferred, 2000));
	if ( status < 0 ) {
    	    fprintf(stderr,"Bulk read error: %s\n", libusb_error_name(status));
    	    goto err;
	}
	if ( (i==0) && ( (mbuf[0]!=0) && (mbuf[1]!=239) ) ) {
	    fprintf(stderr,"Warning: Invalid start of data: %d %d, leading data may went lost\n",mbuf[0], mbuf[1]);
	}
	if ( i>=5 ) size+=transferred;
    }
    gettimeofday(&tv2, NULL);
    printf("Read %.1f MB at %.1f MB/s\n", size/(1024.0*1024.0), size/( (tv2.tv_sec-tv1.tv_sec)*1e6 + (tv2.tv_usec-tv1.tv_usec) )); 
    fflush(stdout);
 
    // release resources
    status = 0;
    goto noerr;
err:
    status = 1;
noerr:
    if ( mbuf ) free(mbuf);
    if ( bitstream_fn ) free(bitstream_fn);
    if ( handle ) {
	libusb_release_interface(handle,0);
	libusb_close(handle);
    }
    if ( devs ) libusb_free_device_list(devs, 1);
    libusb_exit(NULL);
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
    printf("Press <return> to quit\n");
    fflush(NULL);
    fgetc(stdin);
#endif    
    return status;
}
///@endcond