Subversion Repositories gecko3

/* GECKO3COM
 *
 * Copyright (C) 2008 by
 *   ___    ____  _   _
 *  (  _`\ (  __)( ) ( )   
 *  | (_) )| (_  | |_| |   Bern University of Applied Sciences
 *  |  _ <'|  _) |  _  |   School of Engineering and
 *  | (_) )| |   | | | |   Information Technology
 *  (____/'(_)   (_) (_)
 *
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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     gecko3com_gpif.c
 *********************************************************************
 * \brief     project specific functions to handle the GPIF
 *
 *            
 *
 * \author    GNUradio team, Christoph Zimmermann bfh.ch
 * \date      2009-4-16
 *
 * \note Comments from the original GNU radio source: \n
 * The GPIF Designer tool is kind of screwed up, in that it doesn't 
 * configure some of the ports correctly.  We just use their tables and 
 * handle the initialization ourselves.  They also declare that their 
 * static initialized data is in xdata, which screws us too.
 *
*/
 
#include <stdint.h>
#include "gecko3com_gpif.h"
#include "gpif_data.h"
#include "isr.h"
#include "delay.h"
#include "fx2regs.h"
#include "gecko3com_regs.h"
#include "gecko3com_interfaces.h"
#include "syncdelay.h"
#include "debugprint.h"
 
 
/* These are the tables generated by the Cypress GPIF Designer */
 
/** \brief Waveform data generated by the Cypress GPIF Designer
 *
 *  this table is defined in the gpif_data.c file. provide the 
 *  desired file for your board
 */
extern const char WaveData[128];
 
/** \brief Flowstate data generated by the Cypress GPIF Designer
 *
 *  this table is defined in the gpif_data.c file. provide the 
 *  desired file for your board
 */
extern const char FlowStates[36];
 
/** \brief Init values generated by the Cypress GPIF Designer 
 *  and the edit-gpif script
 *
 *  this table is defined in the gpif_data.h file. provide the 
 *  desired file for your board
 */
extern const char InitData[7];
 
 
//** private flag to signal, that the GPIF receives data from the FPGA */
//volatile static uint8_t flGPIF;
 
 
 
/** 
 * \brief exectuted when the gpif waveform terminates 
 */
void
isr_gpif_done (void) interrupt
{
  ISR_DEBUG_PORT |= bmGPIF_DONE;
 
  /* check if this is a end of a IN transfer */
  if((flGPIF & bmGPIF_READ_IN_PROGRESS) == bmGPIF_READ_IN_PROGRESS){
    INPKTEND = USB_TMC_EP_IN;
  }
 
  //EA = 0;		/* disable all interrupts */
  while(!(GPIFTRIG & bmGPIF_IDLE));
  //EA = 1;		/* global interrupt enable */
 
  /* check if there is data available for an OUT transfer */  
  //if((flGPIF & bmGPIF_PENDING_DATA) == bmGPIF_PENDING_DATA) {
    //if(!(EP2468STAT & bmEP2EMPTY)) {
    //flGPIF &= ~bmGPIF_PENDING_DATA;
 
    //EA = 0;		/* disable all interrupts */
    //flGPIF &= ~bmGPIF_READ_IN_PROGRESS;
    //gpif_trigger_write();
    //EA = 1;		/* global interrupt enable */
  //}
  /*else*/ {
    EA = 0;		/* disable all interrupts */
    clear_fifo_gpif_irq();
    flGPIF |= bmGPIF_READ_IN_PROGRESS;
    gpif_trigger_read();
    EA = 1;		/* global interrupt enable */
  }
 
 
 
  ISR_DEBUG_PORT &= ~bmGPIF_DONE;
}
 
 
/** 
 * \brief exectuted when data is available in the OUT endpoint 
 */
void
isr_endpoint_out_data (void) interrupt
{
  ISR_DEBUG_PORT |= bmFIFO_PF;
 
  /* check if there is a active IN transfer */
  if((GPIFREADYSTAT & bmWRX) == bmWRX) {
    flGPIF |= bmGPIF_PENDING_DATA;
  }
  else {
    //EA = 0;		/* disable all interrupts */
    if((flGPIF & bmGPIF_READ_IN_PROGRESS) == bmGPIF_READ_IN_PROGRESS) {
      GPIFABORT = 0xFF;
      SYNCDELAY;
      flGPIF &= ~bmGPIF_READ_IN_PROGRESS;
    }
    //EA = 1;		/* global interrupt enable */
    //EA = 0;		/* disable all interrupts */
    while(!(GPIFTRIG & bmGPIF_IDLE));
    //EA = 1;		/* global interrupt enable */
    EA = 0;		/* disable all interrupts */
    flGPIF &= ~bmGPIF_READ_IN_PROGRESS;
    gpif_trigger_write();
    EA = 1;		/* global interrupt enable */
  }
 
  clear_fifo_gpif_irq();
 
  ISR_DEBUG_PORT &= ~bmFIFO_PF;
}
 
 
/** \brief initialize GPIF system */
void init_gpif (void)
{
  uint8_t i;
 
#ifdef GECKO3MAIN
  /* IFCLK is generated internally and runs at 30 MHz; GPIF "master mode" */
  //IFCONFIG = bmIFCLKSRC | bm3048MHZ | bmIFCLKOE | bmGSTATE | bmIFGPIF;
  IFCONFIG = bmIFCLKSRC | bmIFCLKOE | bmGSTATE | bmIFGPIF;
  SYNCDELAY;
 
  /* we have to commit the currently processed packet BEFORE we switch
   *to auto out mode */
  OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;
 
    /* reset FIFOs */
 
  FIFORESET = bmNAKALL;					SYNCDELAY;
  FIFORESET = 6;					SYNCDELAY;
  FIFORESET = 0;					SYNCDELAY;
 
  /* enable autoout and autoin feature of the endpoints */
  EP2FIFOCFG |= bmAUTOOUT;
  SYNCDELAY;
  EP6FIFOCFG |= bmAUTOIN;
  SYNCDELAY;
 
  /* set endpoint 2 fifo (out) programmable flag to "higher or equal 3" 
   * we use the programmable flag as interrupt source to detect if data for the
   * FPGA is available and as GPIF flag to stop the flowstate, for this the 
   * flag has to change one cycle before the FIFO is completly empty, else we 
   * transfer one word too much */
  EP2FIFOPFH = bmDECIS;
  EP2FIFOPFL = 4;
  SYNCDELAY;
 
  EP2GPIFFLGSEL = bmFLAG_PROGRAMMABLE;
  //EP2GPIFFLGSEL = bmFLAG_EMPTY;
  SYNCDELAY;
 
  //EP6FIFOPFH = bmDECIS | 0x19;
  //EP6FIFOPFL = 0xFB;
  //SYNCDELAY;
 
  //EP6GPIFFLGSEL = bmFLAG_PROGRAMMABLE;
  EP6GPIFFLGSEL = bmFLAG_FULL;
  SYNCDELAY;
 
  EP2GPIFPFSTOP = 0;
  EP6GPIFPFSTOP = 0;
 
#endif
 
  GPIFABORT = 0xFF;  /* abort any waveforms pending */
  SYNCDELAY;
 
  GPIFREADYCFG = InitData[ 0 ];
  GPIFCTLCFG = InitData[ 1 ];
  GPIFIDLECS = InitData[ 2 ];
  GPIFIDLECTL = InitData[ 3 ];
  /* Hmmm, what's InitData[ 4 ] ... */
  GPIFWFSELECT = InitData[ 5 ];
  /* I think this register is read only... */
  /* GPIFREADYSTAT = InitData[ 6 ]; */ 
 
  for (i = 0; i < 128; i++){
    GPIF_WAVE_DATA[i] = WaveData[i];
  }
 
  setup_flowstate_common(); 
 
  FLOWSTATE = 0;		/* ensure it's off */
 
  GPIFREADYCFG |= bmINTRDY; /* set the internal ready signal */
 
  /* unset gpif flags */
  flGPIF = 0;
 
 
  EA = 0;		/* disable all interrupts */
 
  /* hook gpif interupt services */
 
  /* due to big problems with the done interrupt, we use the WAVEFORM interrupt
     to signal the firmware that the GPIF is done */
  hook_fgv(FGV_GPIFWF,(unsigned short) isr_gpif_done);
  hook_fgv(FGV_EP2PF,(unsigned short) isr_endpoint_out_data);
 
  EP2FIFOIE = bmFIFO_PF;
  GPIFIE = bmGPIFWF;
 
  EA = 1;		/* global interrupt enable */
 
 
  /* start gpif read, default state of the gpif to wait for fpga data */
  flGPIF |= bmGPIF_READ_IN_PROGRESS;
  gpif_trigger_read();
 
}
 
 
/** \brief aborts any gpif running gpif transaction  */
void abort_gpif(void) {
 
  EA = 0;		/* disable all interrupts */
 
  flGPIF = 0;
 
  /* abort the current GPIF waveform */
  GPIFABORT = 0xFF;
  SYNCDELAY;
  while(!(GPIFTRIG & bmGPIF_IDLE));
 
  EA = 1;		/* global interrupt enable */
 
  //print_info("gpif aborted\n");
 
#ifdef GECKO3MAIN
  /* signal an abort condition to the FPGA (both WRU and RDYU high) */
  GPIFIDLECTL |= bmRDYU | bmWRU;
  udelay(10);
  GPIFIDLECTL = InitData[ 3 ]; /* restore original state */
#endif
 
  gpif_trigger_read();
  flGPIF |= bmGPIF_READ_IN_PROGRESS;
}
 
 
/** \brief disables gpif system */
void deactivate_gpif(void) {
 
  EA = 0;	  /* disable all interrupts */
 
  EP2FIFOIE = 0;  /* disable FIFO interrupt */
  SYNCDELAY;
  GPIFIE = 0;     /* disable all GPIF interrupts */
  SYNCDELAY;
 
  GPIFTCB0 = 0x00;
  EP2GPIFPFSTOP = 1;
  EP6GPIFPFSTOP = 1;
 
  GPIFABORT = 0xFF; /* abort pending GPIF transaction */
  SYNCDELAY;
 
  flGPIF = 0;  /* unset all internal GPIF flags */
 
  EA = 1;		/* global interrupt enable */
 
  while(!(GPIFTRIG & bmGPIF_IDLE));
 
#ifdef GECKO3MAIN
  /* signal an abort condition to the FPGA (both WRU and RDYU high) */
  GPIFIDLECTL |= bmRDYU | bmWRU;
  udelay(10);
  GPIFIDLECTL = InitData[ 3 ]; /* restore original state */
 
  EP2FIFOCFG &= ~bmAUTOOUT;  /* disable AutoOUT feature */
  SYNCDELAY;
  //EP6FIFOCFG &= ~bmINFM;
  EP6FIFOCFG &= ~bmAUTOIN;   /* disable AutoIN feature */
#endif
 
  //print_info("gpif deactivated\n");
}