Subversion Repositories openrisc

/*$$HEADER*/

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

/*                                                                            */

/*                    H E A D E R   I N F O R M A T I O N                     */

/*                                                                            */

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

// Project Name                   : OpenRISC Debug Proxy

// File Name                      : win_usb_driver_calls.c

// Prepared By                    : jb

// Project Start                  : 2008-10-01

/*$$COPYRIGHT NOTICE*/

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

/*                                                                            */

/*                      C O P Y R I G H T   N O T I C E                       */

/*                                                                            */

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

/*

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public

  License as published by the Free Software Foundation;

  version 2.1 of the License, a copy of which is available from

  http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt.

  This library 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

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public

  License along with this library; if not, write to the Free Software

  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*/

/*$$DESCRIPTION*/

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

/*                                                                            */

/*                           D E S C R I P T I O N                            */

/*                                                                            */

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

//

// Some generically named functions for interfacing to the JTAG driver 

// functions, making the code calling these platform independant. The correct 

// driver calling file (either Cygwin or Linux driver) is included at compile 

// time.

// Also included in this file is the USB-JTAG chip initialisation function.

//

/*$$CHANGE HISTORY*/

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

/*                                                                            */

/*                         C H A N G E  H I S T O R Y                         */

/*                                                                            */

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

// Date         Version Description

//------------------------------------------------------------------------

// 081101               First revision                                  jb

#include <stdio.h>

#include <assert.h>

#include <ctype.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <windows.h>

#include "win_FTCJTAG.h"

#include "win_FTCJTAG_ptrs.h"   

#include "usb_driver_calls.h"

#include "or_debug_proxy.h"

// Load the pointers and loading functions of the FTCJTAG driver

int getFTDIJTAGFunctions (){

  HINSTANCE hLib;

  /* Load the library */

  hLib = LoadLibrary("lib/FTCJTAG.dll");

  if (hLib == NULL) {

    printf("Loading of library file \"FTCJTAG.dll\" failed!\n");

    return -1;

  }

  /* get the address of the functions */

  jtagGetNumDevices = (jtagGetNumDevicesPtr) GetProcAddress(hLib, "JTAG_GetNumDevices");

  if (jtagGetNumDevices == NULL) {

    printf("GetProcAddress for JTAG_GetNumDevices Failed.\n");

    return -1;

  }

  jtagInitDevice = (jtagInitDevicePtr) GetProcAddress(hLib, "JTAG_InitDevice");

  if (jtagInitDevice == NULL) {

    printf("GetProcAddress for JTAG_InitDevice  Failed.\n");

    return -1;

  }

  jtagOpen = (jtagOpenPtr) GetProcAddress(hLib, "JTAG_Open");

  if (jtagOpen == NULL) {

    printf("GetProcAddress for JTAG_Open  Failed.\n");

    return -1;

  }

  jtagOpenEx = (jtagOpenExPtr) GetProcAddress(hLib, "JTAG_OpenEx");

  if (jtagOpenEx == NULL) {

    printf("GetProcAddress for JTAG_OpenEx  Failed.\n");

    return -1;

  }

  jtagGetDeviceNameLocID = (jtagGetDeviceNameLocIDPtr) GetProcAddress(hLib, "JTAG_GetDeviceNameLocID");

  if (jtagGetDeviceNameLocID == NULL) {

    printf("GetProcAddress for  Failed JTAG_GetDeviceNameLocID.\n");

    return -1;

  }

  jtagClose = (jtagClosePtr) GetProcAddress(hLib, "JTAG_Close");

  if (jtagClose == NULL) {

    printf("GetProcAddress for JTAG_Close  Failed.\n");

    return -1;

  }

  jtagGetClock = (jtagGetClockPtr) GetProcAddress(hLib, "JTAG_GetClock");

  if (jtagGetClock == NULL) {

    printf("GetProcAddress for JTAG_GetClock  Failed.\n");

    return -1;

  }

  jtagSetClock = (jtagSetClockPtr) GetProcAddress(hLib, "JTAG_SetClock");

  if (jtagSetClock == NULL) {

    printf("GetProcAddress for JTAG_SetClock  Failed.\n");

    return -1;

  }

  jtagSetLoopback = (jtagSetLoopbackPtr) GetProcAddress(hLib, "JTAG_SetLoopback");

  if (jtagSetLoopback == NULL) {

    printf("GetProcAddress for JTAG_SetLoopback  Failed.\n");

    return -1;

  }

  jtagSetGPIOs = (jtagSetGPIOsPtr) GetProcAddress(hLib, "JTAG_SetGPIOs");

  if (jtagSetGPIOs == NULL) {

    printf("GetProcAddress for JTAG_SetGPIOs  Failed.\n");

    return -1;

  }

  jtagGetGPIOs = (jtagGetGPIOsPtr) GetProcAddress(hLib, "JTAG_GetGPIOs");

  if (jtagGetGPIOs == NULL) {

    printf("GetProcAddress for JTAG_GetGPIOs  Failed.\n");

    return -1;

  }

  jtagWrite = (jtagWritePtr) GetProcAddress(hLib, "JTAG_Write");

  if (jtagWrite == NULL) {

    printf("GetProcAddress for JTAG_Write  Failed.\n");

    return -1;

  }

  jtagRead = (jtagReadPtr) GetProcAddress(hLib, "JTAG_Read");

  if (jtagRead == NULL) {

    printf("GetProcAddress for JTAG_Read  Failed.\n");

    return -1;

  }

  jtagWriteRead = (jtagWriteReadPtr) GetProcAddress(hLib, "JTAG_WriteRead");

  if (jtagWriteRead == NULL) {

    printf("GetProcAddress for JTAG_WriteRead  Failed.\n");

    return -1;

  }

  jtagAddWriteCmd = (jtagAddWriteCmdPtr) GetProcAddress(hLib, "JTAG_AddWriteCmd");

  if (jtagAddWriteCmd == NULL) {

    printf("GetProcAddress for JTAG_AddWriteCmd  Failed.\n");

    return -1;

  }

  jtagAddReadCmd = (jtagAddReadCmdPtr) GetProcAddress(hLib, "JTAG_AddReadCmd");

  if (jtagAddReadCmd == NULL) {

    printf("GetProcAddress for JTAG_AddReadCmd  Failed.\n");

    return -1;

  }

  jtagAddWriteReadCmd = (jtagAddWriteReadCmdPtr) GetProcAddress(hLib, "JTAG_AddWriteReadCmd");

  if (jtagAddWriteReadCmd == NULL) {

    printf("GetProcAddress for JTAG_AddWriteReadCmd  Failed.\n");

    return -1;

  }

  jtagClearDeviceCmdSequence = (jtagClearDeviceCmdSequencePtr) GetProcAddress(hLib, "JTAG_ClearDeviceCmdSequence");

  if (jtagClearDeviceCmdSequence == NULL) {

    printf("GetProcAddress for  Failed.\n JTAG_ClearDeviceCmdSequence");

    return -1;

  }

  jtagAddDeviceReadCmd = (jtagAddDeviceReadCmdPtr) GetProcAddress(hLib, "JTAG_AddDeviceReadCmd");

  if (jtagAddDeviceReadCmd == NULL) {

    printf("GetProcAddress for  Failed JTAG_AddDeviceReadCmd.\n");

    return -1;

  }

  jtagAddDeviceWriteReadCmd = (jtagAddDeviceWriteReadCmdPtr) GetProcAddress(hLib, "JTAG_AddDeviceWriteReadCmd");

  if (jtagAddDeviceWriteReadCmd == NULL) {

    printf("GetProcAddress for  Failed.\n JTAG_AddDeviceWriteReadCmd");

    return -1;

  }

  jtagExecuteCmdSequence = (jtagExecuteCmdSequencePtr) GetProcAddress(hLib, "JTAG_ExecuteCmdSequence");

  if (jtagExecuteCmdSequence == NULL) {

    printf("GetProcAddress for  Failed JTAG_ExecuteCmdSequence.\n");

    return -1;

  }

  jtagGetDllVersion = (jtagGetDllVersionPtr) GetProcAddress(hLib, "JTAG_GetDllVersion");

  if (jtagGetDllVersion == NULL) {

    printf("GetProcAddress for JTAG_GetDllVersion  Failed.\n");

    return -1;

  }

  jtagGetErrorCodeString = (jtagGetErrorCodeStringPtr) GetProcAddress(hLib, "JTAG_GetErrorCodeString");

  if (jtagGetErrorCodeString == NULL) {

    printf("GetProcAddress for  Failed JTAG_GetErrorCodeString.\n");

    return -1;

  }

  //   = (Ptr) GetProcAddress(hLib, "");  

  //if ( == NULL) {

  //  printf("GetProcAddress for  Failed.\n");

  //  return -1;

  // }

  return 0;

}

// Global USB JTAG device handle

FTC_HANDLE ftHandle;

FTC_STATUS

FT2232_USB_JTAG_WriteDataToExternalDevice(

                                          //FTC_HANDLE ftHandle, 

                                          BOOL bInstructionTestData,

                                          DWORD dwNumBitsToWrite,

                                          PWriteDataByteBuffer pWriteDataBuffer,

                                          DWORD dwNumBytesToWrite,

                                          DWORD dwTapControllerState)

{

  // Return the appropritae call to the Windows driver

  return (jtagWrite)(

                     ftHandle,

                     bInstructionTestData,

                     dwNumBitsToWrite,

                     pWriteDataBuffer,

                     dwNumBytesToWrite,

                     dwTapControllerState);

}

// Read data from external device

FTC_STATUS

FT2232_USB_JTAG_ReadDataFromExternalDevice(

                                           //FTC_HANDLE ftHandle, 

                                            BOOL bInstructionTestData,

                                            DWORD dwNumBitsToRead,

                                            PReadDataByteBuffer pReadDataBuffer,

                                            LPDWORD lpdwNumBytesReturned,

                                            DWORD dwTapControllerState)

{

  return (jtagRead)(

                    ftHandle,

                    bInstructionTestData,

                    dwNumBitsToRead,

                    pReadDataBuffer,

                    lpdwNumBytesReturned,

                    dwTapControllerState);

}

// Write Read

FTC_STATUS

FT2232_USB_JTAG_WriteReadDataToFromExternalDevice(

                                                  //FTC_HANDLE ftHandle, 

                                                  BOOL bInstructionTestData,

                                                  DWORD dwNumBitsToWriteRead,

                                                  PWriteDataByteBuffer pWriteDataBuffer,

                                                  DWORD dwNumBytesToWrite,

                                                  PReadDataByteBuffer pReadDataBuffer,

                                                  LPDWORD lpdwNumBytesReturned,

                                                  DWORD dwTapControllerState)

{

 return (jtagWriteRead)(

                        ftHandle,

                        bInstructionTestData,

                        dwNumBitsToWriteRead,

                        pWriteDataBuffer,

                        dwNumBytesToWrite,

                        pReadDataBuffer,

                        lpdwNumBytesReturned,

                        dwTapControllerState);

}

// Close device

FTC_STATUS

FT2232_USB_JTAG_CloseDevice()

{

  return (jtagClose)(ftHandle);

}

void

reinit_usb_jtag(void)

{

  FTC_STATUS Status = FTC_SUCCESS;

  if (DEBUG_USB_DRVR_FUNCS) printf("win_usb_driver_calls: reset_usb_jtag() - ");

  Status = (jtagInitDevice)(ftHandle, 0);

  if (DEBUG_USB_DRVR_FUNCS) printf("return Status: %d\n", (int) Status);

}

// Set clock frequency

// Frequency = 12Mhz/((1+divisor)*2), 

// divisor=1000 => Freq=5995Hz~=6kHz, divisor=500=>Freq=12kHz

#define USB_JTAG_CLK_DIVIDER 0

int init_usb_jtag()

{

  FTC_STATUS Status = FTC_SUCCESS;

  DWORD dwNumDevices = 0;

  char szDeviceName[100];

  DWORD dwLocationID = 0;

  // Made global: FTC_HANDLE ftHandle;

  DWORD dwClockFrequencyHz = 0;

  FTC_INPUT_OUTPUT_PINS LowInputOutputPinsData;

  FTC_INPUT_OUTPUT_PINS HighInputOutputPinsData;

  FTC_LOW_HIGH_PINS LowPinsInputData;

  FTC_LOW_HIGH_PINS HighPinsInputData;

  BOOL bPerformCommandSequence = false;

  DWORD dwLoopCntr = 0;

  char szDllVersion[10];

  Status = (jtagGetNumDevices)(&dwNumDevices);

  if (DEBUG_USB_DRVR_FUNCS)

    printf("JTAG_GetNumDevices returned Status: 0x%x and %d devices\n",

                    Status, dwNumDevices);

  if (dwNumDevices == 0)

    {

      printf("Error: USB debug cable not detected\nPlease ensure the device is attached and correctly installed\n\n");

      exit(-1);

    }

  Status = (jtagGetDllVersion)(szDllVersion, 10);

  if (DEBUG_USB_DRVR_FUNCS)

    printf("JTAG_GetDLLVersion returned Status: 0x%x and version %s\n",

                     Status, szDllVersion);

  // To do: Iterate through dwNumDevices by index number ,looking for the ORSoC Device, "ORSoC OpenRISC debug cable A\0",

  if ((Status == FTC_SUCCESS) && (dwNumDevices > 0))

    {

      if (dwNumDevices == 1)

        {

          Status = (jtagGetDeviceNameLocID)(0,szDeviceName,50, &dwLocationID);

          if (DEBUG_USB_DRVR_FUNCS)

            printf("JTAG_GetDeviceNameLocID: %s at: 0x%x\n",

                   szDeviceName, dwLocationID);

          if (Status == FTC_SUCCESS)

            {

              Status = (jtagOpenEx)(szDeviceName, dwLocationID, &ftHandle);

            }

        }

      else

        {

          if (dwNumDevices == 2)

            {

              Status=(jtagGetDeviceNameLocID)(1,szDeviceName,50,&dwLocationID);

              if (Status == FTC_SUCCESS)

                {

                  Status = (jtagOpenEx)(szDeviceName, dwLocationID, &ftHandle);

                }

            }

        }

    }

  if ((Status == FTC_SUCCESS) && (dwNumDevices > 0))

    {

      Status = (jtagInitDevice)(ftHandle, 0);

      // Set clock frequency

      // Frequency = 12Mhz/((1+divisor)*2), 

      // divisor=1000 => Freq=5995Hz~=6kHz, divisor=500=>Freq=12kHz

      if (Status == FTC_SUCCESS)

        Status = (jtagSetClock)(ftHandle, USB_JTAG_CLK_DIVIDER,

                                &dwClockFrequencyHz);

      if (Status == FTC_SUCCESS){

        printf("USB JTAG interface initialised\n");

        Status = (jtagGetClock)(5, &dwClockFrequencyHz);

      }

      if (Status == FTC_SUCCESS)

        { // true=output, false=input

          LowInputOutputPinsData.bPin1InputOutputState = true; // ADBUS4 - 

          // set ADBUS4 to output 0 to enable JTAG buffers on Olimex devices

          LowInputOutputPinsData.bPin2InputOutputState = true; //ADBUS5

          LowInputOutputPinsData.bPin3InputOutputState = true;

          LowInputOutputPinsData.bPin4InputOutputState = true;

          //ADBUS4 = 0 (enable JTAG buffers on Olimex devices)

          LowInputOutputPinsData.bPin1LowHighState = false; // ADBUS4

          LowInputOutputPinsData.bPin2LowHighState = false; // ADBUS5

          LowInputOutputPinsData.bPin3LowHighState = true; // ADBUS6

          LowInputOutputPinsData.bPin4LowHighState = true; // ADBUS7

          HighInputOutputPinsData.bPin1InputOutputState = true; // ACBUS0

          HighInputOutputPinsData.bPin2InputOutputState = true; // ACBUS1

          HighInputOutputPinsData.bPin3InputOutputState = true; // ACBUS2

          HighInputOutputPinsData.bPin4InputOutputState = true; // ACBUS3

          HighInputOutputPinsData.bPin1LowHighState = true; // ACBUS0

          HighInputOutputPinsData.bPin2LowHighState = true; // ACBUS1

          HighInputOutputPinsData.bPin3LowHighState = true; // ACBUS2

            HighInputOutputPinsData.bPin4LowHighState =true; // ACBUS3

          Status = (jtagSetGPIOs)(ftHandle, true, &LowInputOutputPinsData,

                                        true, &HighInputOutputPinsData);

          if (Status == FTC_SUCCESS)

            Status = (jtagGetGPIOs)(ftHandle, true, &LowPinsInputData,

                                    true, &HighPinsInputData);

          if (DEBUG_USB_DRVR_FUNCS)

            printf("JTAG low gpio pins values: (ADBUS7-ADBUS4):%x%x%x%x\n",

                   (LowPinsInputData.bPin4LowHighState==true),

                   (LowPinsInputData.bPin3LowHighState==true),

                   (LowPinsInputData.bPin2LowHighState==true),

                   (LowPinsInputData.bPin1LowHighState==true));

          if (DEBUG_USB_DRVR_FUNCS)

            printf("JTAG high gpio pins values: (ACBUS3-ACBUS0): %x%x%x%x\n",

                   (HighPinsInputData.bPin4LowHighState==true),

                   (HighPinsInputData.bPin3LowHighState==true),

                   (HighPinsInputData.bPin2LowHighState==true),

                   (HighPinsInputData.bPin1LowHighState==true));

        }

    }

  if (Status == FTC_SUCCESS)

    return 0;

  else

    return 1;

}