fcdhid.h File Reference

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include "fcdhidcmd.h"
#include "hidapi.h"
#include <inttypes.h>

Include dependency graph for fcdhid.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FCD_CAPS_STRUCT
	FCD capabilities that depend on both hardware and firmware. More...

Macros
#define	FALSE   0
#define	TRUE   1

Typedefs
typedef int	BOOL

Enumerations
enum	FCD_MODE_ENUM { FCD_MODE_NONE, FCD_MODE_DEAD, FCD_MODE_BL, FCD_MODE_APP }
	FCD mode enumeration. More...

Functions
hid_device *	fcdOpen (uint16_t usVID, uint16_t usPID, int whichdongle)
	Open FCD device. More...
void	fcdClose (hid_device *phd)
	Close FCD HID device. More...
FCD_MODE_ENUM	fcdGetMode (hid_device *phd)
	Get FCD mode. More...
FCD_MODE_ENUM	fcdGetFwVerStr (hid_device *phd, char *str)
	Get FCD firmware version as string. More...
FCD_MODE_ENUM	fcdGetCaps (hid_device *phd, FCD_CAPS_STRUCT *fcd_caps)
	Get hardware and firmware dependent FCD capabilities. More...
FCD_MODE_ENUM	fcdGetCapsStr (hid_device *phd, char *caps_str)
	Get hardware and firmware dependent FCD capabilities as string. More...
FCD_MODE_ENUM	fcdAppReset (hid_device *phd)
	Reset FCD to bootloader mode. More...
FCD_MODE_ENUM	fcdAppSetFreqkHz (hid_device *phd, int nFreq)
	Set FCD frequency with kHz resolution. More...
FCD_MODE_ENUM	fcdAppSetFreq (hid_device *phd, int nFreq)
	Set FCD frequency with Hz resolution. More...
FCD_MODE_ENUM	fcdBlReset (hid_device *phd)
	Reset FCD to application mode. More...
FCD_MODE_ENUM	fcdBlErase (hid_device *phd)
	Erase firmware from FCD. More...
FCD_MODE_ENUM	fcdBlWriteFirmware (hid_device *phd, char *pc, int64_t n64Size)
	Write new firmware into the FCD. More...
FCD_MODE_ENUM	fcdBlVerifyFirmware (hid_device *phd, char *pc, int64_t n64Size)
	Verify firmware in FCd flash. More...
FCD_MODE_ENUM	fcdAppSetParam (hid_device *phd, uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len)
	Write FCD parameter (e.g. gain or filter) More...
FCD_MODE_ENUM	fcdAppGetParam (hid_device *phd, uint8_t u8Cmd, uint8_t *pu8Data, uint8_t u8len)
	Read FCD parameter (e.g. gain or filter) More...

Macro Definition Documentation

FALSE

#define FALSE   0

Definition at line 35 of file fcdhid.h.

TRUE

#define TRUE   1

Definition at line 36 of file fcdhid.h.

Typedef Documentation

BOOL

typedef int BOOL

Definition at line 37 of file fcdhid.h.

Enumeration Type Documentation

FCD_MODE_ENUM

enum FCD_MODE_ENUM

FCD mode enumeration.

Enumerator
FCD_MODE_NONE	No FCD detected.
FCD_MODE_DEAD
FCD_MODE_BL	FCD present in bootloader mode.
FCD_MODE_APP	FCD present in aplpication mode.

Definition at line 40 of file fcdhid.h.

             {
    FCD_MODE_NONE,  
    FCD_MODE_DEAD,
    FCD_MODE_BL,    
    FCD_MODE_APP    
} FCD_MODE_ENUM; // The current mode of the FCD: none inserted, in bootloader mode or in normal application mode

Function Documentation

fcdAppGetParam()

FCD_MODE_ENUM fcdAppGetParam	(	hid_device *	phd,
		uint8_t	u8Cmd,
		uint8_t *	pu8Data,
		uint8_t	u8len
	)

Read FCD parameter (e.g. gain or filter)

Parameters

u8Cmd	The command byte / parameter ID, see FCD_CMD_APP_GET_*
pu8Data	TPointer to buffer where the parameter value(s) will be written
u8len	Length of pu8Data in bytes

Returns

One of FCD_MODE_NONE, FCD_MODE_APP or FCD_MODE_BL (see description)

This function can be used to read the value of a parameter in the FCD for which there is no high level API call. It gives access to the low level API of the FCD and the caller is expected to be aware of the various FCD commands, since they are required to be supplied as parameter to this function.

The return value can be used to determine the success or failure of the command execution:

• FCD_MODE_APP : Reply from FCD was as expected (nominal case).
• FCD_MODE_BL : Reply from FCD was not as expected.
• FCD_MODE_NONE : No FCD was found

Definition at line 884 of file fcdhid.c.

References FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufOut[65];
    unsigned char aucBufIn[65];

    /*
    phd = fcdOpen();
    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    aucBufOut[0]=0; // Report ID, ignored
    aucBufOut[1]=u8Cmd;
    hid_write(phd,aucBufOut,65);

    memset(aucBufIn,0xCC,65); // Clear out the response buffer
    hid_read(phd,aucBufIn,65);
    /* Copy return data to output buffer (even if cmd exec failed) */
    memcpy(pu8Data,aucBufIn+2,u8len);

    /* Check status bytes in returned data */
    if (aucBufIn[0]==u8Cmd && aucBufIn[1]==1) {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    /* Response did not contain the expected bytes */
    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;
}

Here is the call graph for this function:

fcdAppReset()

FCD_MODE_ENUM fcdAppReset

(

hid_device *

phd

)

Reset FCD to bootloader mode.

Returns

FCD_MODE_NONE

This function is used to switch the FCD into bootloader mode in which various firmware operations can be performed.

FIXME: hid_read() will occasionally hang due to a pthread_cond_wait() never returning. It seems that the read_callback() in hid-libusb.c will never receive any data during the reconfiguration. Since the same logic works in the native windows application, it could be a libusb thing. Anyhow, since the value returned by this function is not used, we may as well just skip the hid_read() and return FME_NONE. Correct switch from APP to BL mode can be observed in /var/log/messages (linux) (when in bootloader mode the device version includes 'BL')

Definition at line 339 of file fcdhid.c.

References FCD_CMD_APP_RESET, FCD_MODE_NONE, and hid_write().

{
    //hid_device *phd=NULL;
    //unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Send an App reset command
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_APP_RESET;
    hid_write(phd, aucBufOut, 65);

    /*
       memset(aucBufIn,0xCC,65); // Clear out the response buffer
       hid_read(phd,aucBufIn,65);

       if (aucBufIn[0]==FCDCMDAPPRESET && aucBufIn[1]==1)
       {
       FCDClose(phd);
       phd=NULL;
       return FME_APP;
       }
       FCDClose(phd);
       phd=NULL;
       return FME_BL;
       */

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_NONE;

}

Here is the call graph for this function:

fcdAppSetFreq()

FCD_MODE_ENUM fcdAppSetFreq	(	hid_device *	phd,
		int	nFreq
	)

Set FCD frequency with Hz resolution.

Parameters

nFreq

The new frequency in Hz.

Returns

The FCD mode.

This function sets the frequency of the FCD with 1 Hz resolution. The parameter nFreq must already contain any necessary frequency correction.

See also

fcdAppSetFreq

Definition at line 450 of file fcdhid.c.

References FCD_CMD_APP_SET_FREQ_HZ, FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

Referenced by FCDProInput::set_center_freq(), and FCDProPlusInput::set_center_freq().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Send an App reset command
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_APP_SET_FREQ_HZ;
    aucBufOut[2] = (unsigned char)nFreq;
    aucBufOut[3] = (unsigned char)(nFreq>>8);
    aucBufOut[4] = (unsigned char)(nFreq>>16);
    aucBufOut[5] = (unsigned char)(nFreq>>24);
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_HZ && aucBufIn[1]==1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fcdAppSetFreqkHz()

FCD_MODE_ENUM fcdAppSetFreqkHz	(	hid_device *	phd,
		int	nFreq
	)

Set FCD frequency with kHz resolution.

Parameters

nFreq

The new frequency in kHz.

Returns

The FCD mode.

This function sets the frequency of the FCD with 1 kHz resolution. The parameter nFreq must already contain any necessary frequency correction.

See also

fcdAppSetFreq

Definition at line 400 of file fcdhid.c.

References FCD_CMD_APP_SET_FREQ_KHZ, FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Send an App reset command
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_APP_SET_FREQ_KHZ;
    aucBufOut[2] = (unsigned char)nFreq;
    aucBufOut[3] = (unsigned char)(nFreq>>8);
    aucBufOut[4] = (unsigned char)(nFreq>>16);
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]==FCD_CMD_APP_SET_FREQ_KHZ && aucBufIn[1]==1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;
}

Here is the call graph for this function:

fcdAppSetParam()

FCD_MODE_ENUM fcdAppSetParam	(	hid_device *	phd,
		uint8_t	u8Cmd,
		uint8_t *	pu8Data,
		uint8_t	u8len
	)

Write FCD parameter (e.g. gain or filter)

Parameters

u8Cmd	The command byte / parameter ID, see FCD_CMD_APP_SET_*
pu8Data	The parameter value to be written
u8len	Length of pu8Data in bytes

Returns

One of FCD_MODE_NONE, FCD_MODE_APP or FCD_MODE_BL (see description)

This function can be used to set the value of a parameter in the FCD for which there is no high level API call. It gives access to the low level API of the FCD and the caller is expected to be aware of the various FCD commands, since they are required to be supplied as parameter to this function.

The return value can be used to determine the success or failure of the command execution:

• FCD_MODE_APP : Reply from FCD was as expected (nominal case).
• FCD_MODE_BL : Reply from FCD was not as expected.
• FCD_MODE_NONE : No FCD was found

Definition at line 826 of file fcdhid.c.

References FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

Referenced by FCDProInput::set_band(), FCDProPlusInput::set_bias_t(), FCDProInput::set_biasCurrent(), FCDProInput::set_gain1(), FCDProInput::set_gain2(), FCDProInput::set_gain3(), FCDProInput::set_gain4(), FCDProInput::set_gain5(), FCDProInput::set_gain6(), FCDProPlusInput::set_if_filter(), FCDProPlusInput::set_if_gain(), FCDProInput::set_ifFilter(), FCDProPlusInput::set_lna_gain(), FCDProInput::set_lnaEnhance(), FCDProInput::set_lnaGain(), FCDProPlusInput::set_mixer_gain(), FCDProInput::set_mixerFilter(), FCDProInput::set_mixerGain(), FCDProInput::set_mode(), FCDProInput::set_rcFilter(), FCDProPlusInput::set_rf_filter(), and FCDProInput::set_rfFilter().

{
    //hid_device *phd=NULL;
    unsigned char aucBufOut[65];
    unsigned char aucBufIn[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    aucBufOut[0]=0; // Report ID, ignored
    aucBufOut[1]=u8Cmd;
    memcpy(aucBufOut+2, pu8Data,u8len);
    hid_write(phd,aucBufOut,65);

    /* we must read after each write in order to empty FCD/HID buffer */
    memset(aucBufIn,0xCC,65); // Clear out the response buffer
    hid_read(phd,aucBufIn,65);

    /* Check the response, if OK return FCD_MODE_APP */
    if (aucBufIn[0]==u8Cmd && aucBufIn[1]==1) {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    /* Response did not contain the expected bytes */
    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;

}

Here is the call graph for this function:

Here is the caller graph for this function:

fcdBlErase()

FCD_MODE_ENUM fcdBlErase

(

hid_device *

phd

)

Erase firmware from FCD.

Returns

The FCD mode

This function deletes the firmware from the FCD. This is required before writing new firmware into the FCD.

See also

fcdBlWriteFirmware

Definition at line 559 of file fcdhid.c.

References FCD_CMD_BL_ERASE, FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Send an App reset command
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_ERASE;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]==FCD_CMD_BL_ERASE && aucBufIn[1]==1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_BL;
    }

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_APP;
}

Here is the call graph for this function:

fcdBlReset()

FCD_MODE_ENUM fcdBlReset

(

hid_device *

phd

)

Reset FCD to application mode.

Returns

FCD_MODE_NONE

This function is used to switch the FCD from bootloader mode into application mode.

FIXME: hid_read() will hang due to a pthread_cond_wait() never returning. It seems that the read_callback() in hid-libusb.c will never receive any data during the reconfiguration. Since the same logic works in the native windows application, it could be a libusb thing. Anyhow, since the value returned by this function is not used, we may as well jsut skip the hid_read() and return FME_NONE. Correct switch from BL to APP mode can be observed in /var/log/messages (linux) (when in bootloader mode the device version includes 'BL')

Definition at line 499 of file fcdhid.c.

References FCD_CMD_BL_RESET, FCD_MODE_NONE, and hid_write().

{
    //hid_device *phd=NULL;
    //    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Send an BL reset command
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_RESET;
    hid_write(phd, aucBufOut, 65);

    /*
       memset(aucBufIn,0xCC,65); // Clear out the response buffer
       hid_read(phd,aucBufIn,65);

       if (aucBufIn[0]==FCDCMDBLRESET && aucBufIn[1]==1)
       {
       FCDClose(phd);
       phd=NULL;
       return FME_BL;
       }
       FCDClose(phd);
       phd=NULL;
       return FME_APP;
       */

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_NONE;

}

Here is the call graph for this function:

fcdBlVerifyFirmware()

FCD_MODE_ENUM fcdBlVerifyFirmware	(	hid_device *	phd,
		char *	pc,
		int64_t	n64Size
	)

Verify firmware in FCd flash.

Parameters

pc	Pointer to firmware data to verify against.
n64Size	Size of the data in pc.

Returns

The FCD_MODE_BL if verification was succesful.

This function verifies the firmware currently in the FCd flash against the firmware image pointed to by pc. The function return FCD_MODE_BL if the verification is OK and FCD_MODE_APP otherwise.

Definition at line 708 of file fcdhid.c.

References FCD_CMD_BL_GET_BYTE_ADDR_RANGE, FCD_CMD_BL_READ_FLASH_BLOCK, FCD_CMD_BL_SET_BYTE_ADDR, FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    uint32_t u32AddrStart;
    uint32_t u32AddrEnd;
    uint32_t u32Addr;

    /*
    phd = fcdOpen();

    if (phd==NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Get the valid flash address range
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_GET_BYTE_ADDR_RANGE;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]!=FCD_CMD_BL_GET_BYTE_ADDR_RANGE || aucBufIn[1]!=1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    u32AddrStart=
        aucBufIn[2]+
        (((uint32_t)aucBufIn[3])<<8)+
        (((uint32_t)aucBufIn[4])<<16)+
        (((uint32_t)aucBufIn[5])<<24);

    u32AddrEnd=
        aucBufIn[6]+
        (((uint32_t)aucBufIn[7])<<8)+
        (((uint32_t)aucBufIn[8])<<16)+
        (((uint32_t)aucBufIn[9])<<24);

    // Set start address for flash
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_SET_BYTE_ADDR;
    aucBufOut[2] = ((unsigned char)u32AddrStart);
    aucBufOut[3] = ((unsigned char)(u32AddrStart>>8));
    aucBufOut[4] = ((unsigned char)(u32AddrStart>>16));
    aucBufOut[5] = ((unsigned char)(u32AddrStart>>24));
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]!=FCD_CMD_BL_SET_BYTE_ADDR || aucBufIn[1]!=1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    // Read blocks
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_READ_FLASH_BLOCK;
    for (u32Addr=u32AddrStart; u32Addr+47<u32AddrEnd && u32Addr+47<n64Size; u32Addr+=48)
    {
        hid_write(phd, aucBufOut, 65);
        memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
        hid_read(phd, aucBufIn, 65);

        if (aucBufIn[0]!=FCD_CMD_BL_READ_FLASH_BLOCK || aucBufIn[1]!=1)
        {
            /*
            fcdClose(phd);
            phd = NULL;*/

            return FCD_MODE_APP;
        }

        if (memcmp(&aucBufIn[2],&pc[u32Addr],48)!=0)
        {
            /*
            fcdClose(phd);
            phd = NULL;*/

            return FCD_MODE_APP;
        }
    }

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;
}

Here is the call graph for this function:

fcdBlWriteFirmware()

FCD_MODE_ENUM fcdBlWriteFirmware	(	hid_device *	phd,
		char *	pc,
		int64_t	n64Size
	)

Write new firmware into the FCD.

Parameters

pc	Pointer to the new firmware data
n64size	The number of bytes in the data

Returns

The FCD mode

This function is used to upload new firmware into the FCD flash.

See also

fcdBlErase

Definition at line 606 of file fcdhid.c.

References FCD_CMD_BL_GET_BYTE_ADDR_RANGE, FCD_CMD_BL_SET_BYTE_ADDR, FCD_CMD_BL_WRITE_FLASH_BLOCK, FCD_MODE_APP, FCD_MODE_BL, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    uint32_t u32AddrStart;
    uint32_t u32AddrEnd;
    uint32_t u32Addr;

    /*
    phd = fcdOpen();

    if (phd==NULL)
    {
        return FCD_MODE_NONE;
    }*/

    // Get the valid flash address range
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_GET_BYTE_ADDR_RANGE;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]!=FCD_CMD_BL_GET_BYTE_ADDR_RANGE || aucBufIn[1]!=1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    u32AddrStart=
        aucBufIn[2]+
        (((uint32_t)aucBufIn[3])<<8)+
        (((uint32_t)aucBufIn[4])<<16)+
        (((uint32_t)aucBufIn[5])<<24);
    u32AddrEnd=
        aucBufIn[6]+
        (((uint32_t)aucBufIn[7])<<8)+
        (((uint32_t)aucBufIn[8])<<16)+
        (((uint32_t)aucBufIn[9])<<24);

    // Set start address for flash
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_SET_BYTE_ADDR;
    aucBufOut[2] = ((unsigned char)u32AddrStart);
    aucBufOut[3] = ((unsigned char)(u32AddrStart>>8));
    aucBufOut[4] = ((unsigned char)(u32AddrStart>>16));
    aucBufOut[5] = ((unsigned char)(u32AddrStart>>24));
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    if (aucBufIn[0]!=FCD_CMD_BL_SET_BYTE_ADDR || aucBufIn[1]!=1)
    {
        /*
        fcdClose(phd);
        phd = NULL;*/

        return FCD_MODE_APP;
    }

    // Write blocks
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_WRITE_FLASH_BLOCK;
    for (u32Addr=u32AddrStart; u32Addr+47<u32AddrEnd && u32Addr+47<n64Size; u32Addr+=48)
    {
        memcpy(&aucBufOut[3], &pc[u32Addr], 48);

        hid_write(phd, aucBufOut, 65);
        memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
        hid_read(phd, aucBufIn, 65);

        if (aucBufIn[0]!=FCD_CMD_BL_WRITE_FLASH_BLOCK || aucBufIn[1]!=1)
        {
            /*
            fcdClose(phd);
            phd = NULL;*/

            return FCD_MODE_APP;
        }
    }

    /*
    fcdClose(phd);
    phd = NULL;*/

    return FCD_MODE_BL;
}

Here is the call graph for this function:

fcdClose()

void fcdClose

(

hid_device *

phd

)

Close FCD HID device.

Definition at line 78 of file fcdhid.c.

References hid_close().

Referenced by FCDProPlusInput::closeDevice(), and FCDProInput::closeDevice().

{
    hid_close(phd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fcdGetCaps()

FCD_MODE_ENUM fcdGetCaps	(	hid_device *	phd,
		FCD_CAPS_STRUCT *	fcd_caps
	)

Get hardware and firmware dependent FCD capabilities.

Parameters

fcd_caps

Pointer to an FCD_CAPS_STRUCT

Returns

The current FCD mode.

This function queries the FCD and extracts the hardware and firmware dependent capabilities. Currently these capabilities are:

• Bias T (available since S/N TBD)
• Cellular block (the certified version of the FCD) When the FCD is in application mode, the string returned by the query command is (starting at index 2): FCDAPP 18.08 Brd 1.0 No blk 1.0 means no bias tee, 1.1 means there is a bias tee 'No blk' means it is not cellular blocked.

Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303

Definition at line 205 of file fcdhid.c.

References FCD_CMD_BL_QUERY, FCD_MODE_APP, FCD_MODE_BL, FCD_MODE_NONE, FCD_CAPS_STRUCT::hasBiasT, FCD_CAPS_STRUCT::hasCellBlock, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;

    /* clear output buffer */
    fcd_caps->hasBiasT = 0;
    fcd_caps->hasCellBlock = 0;

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    /* Send a BL Query Command */
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_QUERY;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    /*
    fcdClose(phd);
    phd = NULL;*/

    /* first check status bytes then check which mode */
    if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {

        /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
        if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
            fcd_mode = FCD_MODE_BL;
        }
        /* In application mode we have "FCDAPP 18.08 Brd 1.0 No blk" (see API doc) */
        else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {

            /* Bias T */
            fcd_caps->hasBiasT = (aucBufIn[21] == '1') ? 1 : 0;

            /* cellular block */
            if (strncmp((char *)(aucBufIn+23), "No blk", 6) == 0) {
                fcd_caps->hasCellBlock = 0;
            } else {
                fcd_caps->hasCellBlock = 1;
            }

            fcd_mode = FCD_MODE_APP;
        }
        /* either no FCD or firmware less than 18f */
        else {
            fcd_mode = FCD_MODE_NONE;
        }
    }

    return fcd_mode;
}

Here is the call graph for this function:

fcdGetCapsStr()

FCD_MODE_ENUM fcdGetCapsStr	(	hid_device *	phd,
		char *	caps_str
	)

Get hardware and firmware dependent FCD capabilities as string.

Parameters

caps_str

Pointer to a pre-allocated string buffer where the info will be copied.

Returns

The current FCD mode.

This function queries the FCD and copies the returned string into the caps_str parameter. THe return buffer must be at least 28 characters. When the FCD is in application mode, the string returned by the query command is (starting at index 2): FCDAPP 18.08 Brd 1.0 No blk 1.0 means no bias tee, 1.1 means there is a bias tee 'No blk' means it is not cellular blocked.

Ref: http://uk.groups.yahoo.com/group/FCDevelopment/message/303

Definition at line 281 of file fcdhid.c.

References FCD_CMD_BL_QUERY, FCD_MODE_APP, FCD_MODE_BL, FCD_MODE_NONE, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    /* Send a BL Query Command */
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_QUERY;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    /*
    fcdClose(phd);
    phd = NULL;*/

    /* first check status bytes then check which mode */
    if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {

        /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
        if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
            fcd_mode = FCD_MODE_BL;
        }
        /* In application mode we have "FCDAPP 18.08 Brd 1.0 No blk" (see API doc) */
        else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {

            strncpy(caps_str, (char *)(aucBufIn+2), 27);
            caps_str[27] = 0;

            fcd_mode = FCD_MODE_APP;
        }
        /* either no FCD or firmware less than 18f */
        else {
            fcd_mode = FCD_MODE_NONE;
        }
    }

    return fcd_mode;
}

Here is the call graph for this function:

fcdGetFwVerStr()

FCD_MODE_ENUM fcdGetFwVerStr	(	hid_device *	phd,
		char *	str
	)

Get FCD firmware version as string.

Parameters

str	The returned vesion number as a 0 terminated string (must be pre-allocated)

Returns

The current FCD mode.

See also

FCD_MODE_ENUM

Definition at line 140 of file fcdhid.c.

References FCD_CMD_BL_QUERY, FCD_MODE_APP, FCD_MODE_BL, FCD_MODE_NONE, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_NONE;
    }*/

    /* Send a BL Query Command */
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_QUERY;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    /*
    fcdClose(phd);
    phd = NULL;*/

    /* first check status bytes then check which mode */
    if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {

        /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
        if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
            fcd_mode = FCD_MODE_BL;
        }
        /* In application mode we have "FCDAPP_18.06" where the number is the FW version */
        else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
            strncpy(str, (char *)(aucBufIn+9), 5);
            str[5] = 0;
            fcd_mode = FCD_MODE_APP;
        }
        /* either no FCD or firmware less than 18f */
        else {
            fcd_mode = FCD_MODE_NONE;
        }
    }

    return fcd_mode;
}

Here is the call graph for this function:

fcdGetMode()

FCD_MODE_ENUM fcdGetMode

(

hid_device *

phd

)

Get FCD mode.

Returns

The current FCD mode.

See also

FCD_MODE_ENUM

Definition at line 88 of file fcdhid.c.

References FCD_CMD_BL_QUERY, FCD_MODE_APP, FCD_MODE_BL, FCD_MODE_NONE, hid_read(), and hid_write().

{
    //hid_device *phd=NULL;
    unsigned char aucBufIn[65];
    unsigned char aucBufOut[65];
    FCD_MODE_ENUM fcd_mode = FCD_MODE_NONE;

    /*
    phd = fcdOpen();

    if (phd == NULL)
    {
        return FCD_MODE_DEAD;
    }*/

    /* Send a BL Query Command */
    aucBufOut[0] = 0; // Report ID, ignored
    aucBufOut[1] = FCD_CMD_BL_QUERY;
    hid_write(phd, aucBufOut, 65);
    memset(aucBufIn, 0xCC, 65); // Clear out the response buffer
    hid_read(phd, aucBufIn, 65);

    /*
    fcdClose(phd);
    phd = NULL;*/

    /* first check status bytes then check which mode */
    if (aucBufIn[0]==FCD_CMD_BL_QUERY && aucBufIn[1]==1) {

        /* In bootloader mode we have the string "FCDBL" starting at acBufIn[2] **/
        if (strncmp((char *)(aucBufIn+2), "FCDBL", 5) == 0) {
            fcd_mode = FCD_MODE_BL;
        }
        /* In application mode we have "FCDAPP_18.06" where the number is the FW version */
        else if (strncmp((char *)(aucBufIn+2), "FCDAPP", 6) == 0) {
            fcd_mode = FCD_MODE_APP;
        }
        /* either no FCD or firmware less than 18f */
        else {
            fcd_mode = FCD_MODE_NONE;
        }
    }

    return fcd_mode;
}

Here is the call graph for this function:

fcdOpen()

hid_device* fcdOpen	(	uint16_t	usVID,
		uint16_t	usPID,
		int	whichdongle
	)

Open FCD device.

Returns

Pointer to the FCD HID device or NULL if none found

This function looks for FCD devices connected to the computer and opens the first one found.

Definition at line 31 of file fcdhid.c.

References hid_enumerate(), hid_free_enumeration(), hid_open_path(), hid_device_info::next, and hid_device_info::path.

Referenced by FCDProPlusInput::openDevice(), and FCDProInput::openDevice().

{
    struct hid_device_info *phdi=NULL;
    hid_device *phd=NULL;
    char *pszPath=NULL;

    phdi = hid_enumerate(usVID, usPID);

    int which = whichdongle;

    while (phdi && which)
    {
        phdi=phdi->next;
        which--;
    }

    if (phdi==NULL)
    {
        return NULL; // No FCD device found
    }

    pszPath=strdup(phdi->path);

    if (pszPath==NULL)
    {
        return NULL;
    }

    hid_free_enumeration(phdi);
    phdi=NULL;

    if ((phd=hid_open_path(pszPath)) == NULL)
    {
        free(pszPath);
        pszPath=NULL;

        return NULL;
    }

    free(pszPath);
    pszPath=NULL;

    return phd;
}

Here is the call graph for this function:

Here is the caller graph for this function: