Subversion Repositories gecko3

/* GECKO3COM

 *

 * Copyright (C) 2008 by

 *   ___    ____  _   _

 *  (  _`\ (  __)( ) ( )

 *  | (_) )| (_  | |_| |   Berne 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     usb_tmc.c

 *********************************************************************

 * \brief     The USB Test and Measurement Class (TMC) functions.

 *

 * \author    Christoph Zimmermann bfh.ch

 * \date      2009-02-04

 *

*/

#include <stdint.h>

#include "fx2regs.h"

#include "isr.h"

#include "usb_requests.h"

#include "usb_descriptors.h"

#include "usb_tmc.h"

#include "debugprint.h"

/* GECKO3COM specific includes */

#include "gecko3com_common.h"

#include "gecko3com_interfaces.h"

#include "gecko3com_gpif.h"

#include "fpga_load.h"

volatile static TMC_Status usb_tmc_status;

volatile TMC_State usb_tmc_state;

volatile idata TMC_Transfer_Info usb_tmc_transfer;

volatile idata IEEE488_status_registers ieee488_status;

/** This constant contains the device capabilities according to the TMC specification, Ref.: Table 37 */

volatile const USB_TMC_Capabilities USB_TMC_CAPABILITIES = {

  TMC_STATUS_SUCCESS,

      0,

      0x00,   /* BCD version number of TMC specification, 1.00 */

      0x01,

      HAS_INDICATOR_PULSE,

      0,

        {0,0,0,0,0,0},

    /* place here USB488 subclass capabilities */

    0x00,  /* BCD version number of USB488 specification, 1.00 */

      0x01,

      0,

      0,

        {0,0,0,0,0,0,0,0}

};

void init_usb_tmc(){

  usb_tmc_transfer.bTag = 0;

  usb_tmc_transfer.transfer_size = 0;

  usb_tmc_transfer.new_transfer = 0;

  usb_tmc_transfer.nbytes_rxd = 0;

  usb_tmc_transfer.nbytes_txd = 0;

  usb_tmc_status = TMC_STATUS_SUCCESS;

  usb_tmc_state = TMC_STATE_IDLE;

  ieee488_status.EventStatusRegister = bmPOWER_ON;

  ieee488_status.EventStatusEnable = 0;

  ieee488_status.StatusByteRegister = 0;

  ieee488_status.ServiceRequestEnable = 0;

}

uint8_t IEEE488_status_query(idata IEEE488_status_registers *status){

  uint8_t local_status, local_enable;

  local_status = status->EventStatusRegister;

  local_enable =  status->EventStatusEnable;

  if(local_status & local_enable)

    local_status |= 0x20; /* set the ESB bit */

  else

    local_status &= !0xDF;

  status->EventStatusRegister = local_status;

  local_status = status->StatusByteRegister;

  local_enable = status->ServiceRequestEnable;

  if((local_status &= 0xBF) & (local_enable & 0xBF)) {

    local_status |= 0x40; /* set the MSS bit */

    status->StatusByteRegister = local_status;

  }

  return local_status;

}

uint8_t usb_handle_tmc_packet (void){

  if ((bRequestType & bmRT_DIR_MASK) == bmRT_DIR_IN){

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

     *    handle the TMC IN requests

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

    switch (bRequest){

    case INITIATE_ABORT_BULK_OUT:

      /* --------------------------------------------------------------------*/

      /* abort GECKO3COM specific stuff */

      if( flLOCAL == GECKO3COM_REMOTE) {

        usb_tmc_status = TMC_STATUS_SUCCESS;

        usb_tmc_state = TMC_STATE_IDLE;

        abort_gpif();

      }

      /* check if the active transfer has the requested bTag value */

      else if(usb_tmc_transfer.bTag == wValueL) {

        usb_tmc_status = TMC_STATUS_SUCCESS;

        usb_tmc_state = TMC_STATE_IDLE;

        /* reset OUT FIFOs */

        FIFORESET = bmNAKALL;                    SYNCDELAY;

        FIFORESET = bmNAKALL | USB_TMC_EP_OUT;   SYNCDELAY;

        /* because we use quad buffering we have to flush all for buffers */

        OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

        OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

        OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

        OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

        FIFORESET = 0;               SYNCDELAY;

      }

      else {

        usb_tmc_status = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;

      }

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = usb_tmc_transfer.bTag;

      EP0BCH = 0;

      EP0BCL = 2;

      break;

    case CHECK_ABORT_BULK_OUT_STATUS:

      /* send number of transmitted bytes */

      usb_tmc_status = TMC_STATUS_SUCCESS;

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = 0;

      EP0BUF[2] = 0;

      EP0BUF[3] = 0;

      EP0BUF[4] = (usb_tmc_transfer.nbytes_rxd & 0x0000FF);

      EP0BUF[5] = (usb_tmc_transfer.nbytes_rxd & 0x00FF00)>>8;

      EP0BUF[6] = (usb_tmc_transfer.nbytes_rxd & 0xFF0000)>>16;

      EP0BUF[7] = usb_tmc_transfer.nbytes_rxd >>24;

      EP0BCH = 0;

      EP0BCL = 8;

      break;

    case INITIATE_ABORT_BULK_IN:

      /* --------------------------------------------------------------------*/

      /* abort GECKO3COM specific stuff */

      if( flLOCAL == GECKO3COM_REMOTE) {

        usb_tmc_status = TMC_STATUS_SUCCESS;

        usb_tmc_state = TMC_STATE_IDLE;

        abort_gpif();

        /* reset IN FIFOs */

        FIFORESET = bmNAKALL;                   SYNCDELAY;

        FIFORESET = bmNAKALL | USB_TMC_EP_IN;   SYNCDELAY;

        INPKTEND = bmSKIP | USB_TMC_EP_IN;      SYNCDELAY;

        FIFORESET = 0;               SYNCDELAY;

      }

      /* check if the active transfer has the requested bTag value */

      else if(usb_tmc_transfer.bTag == wValueL) {

        usb_tmc_status = TMC_STATUS_SUCCESS;

        usb_tmc_state = TMC_STATE_IDLE;

        IEEE488_clear_mav();

      }

      else {

        usb_tmc_status = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;

      }

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = wValueL;

      EP0BCH = 0;

      EP0BCL = 2;

      break;

    case CHECK_ABORT_BULK_IN_STATUS:

      /* send number of transmitted bytes */

      usb_tmc_status = TMC_STATUS_SUCCESS;

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = 0;

      EP0BUF[2] = 0;

      EP0BUF[3] = 0;

      EP0BUF[4] = (usb_tmc_transfer.nbytes_txd & 0x0000FF);

      EP0BUF[5] = (usb_tmc_transfer.nbytes_txd & 0x00FF00)>>8;

      EP0BUF[6] = (usb_tmc_transfer.nbytes_txd & 0xFF0000)>>16;

      EP0BUF[7] = usb_tmc_transfer.nbytes_txd >>24;

      EP0BCH = 0;

      EP0BCL = 8;

      break;

    case INITIATE_CLEAR:

      usb_tmc_status = TMC_STATUS_SUCCESS;

      usb_tmc_state = TMC_STATE_IDLE;

      IEEE488_clear_mav();

      /* --------------------------------------------------------------------*/

      /* abort GECKO3COM specific stuff */

      if( flLOCAL == GECKO3COM_REMOTE) {

        deactivate_gpif();

        flLOCAL = GECKO3COM_LOCAL;

        /* configure the fpga interface for configuration */

        init_fpga_interface();

      }

      /* --------------------------------------------------------------------*/

      /* reset FIFOs */

      FIFORESET = bmNAKALL;                    SYNCDELAY;

      FIFORESET = bmNAKALL | USB_TMC_EP_OUT;   SYNCDELAY;

      FIFORESET = bmNAKALL | USB_TMC_EP_IN;    SYNCDELAY;

      /* because we use quad buffering we have to flush all for buffers */

      OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

      OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

      OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

      OUTPKTEND = bmSKIP | USB_TMC_EP_OUT;       SYNCDELAY;

      FIFORESET = 0;                 SYNCDELAY;

      EP0BUF[0] = usb_tmc_status;

      EP0BCH = 0;

      EP0BCL = 1;

      break;

    case CHECK_CLEAR_STATUS:

      usb_tmc_status = TMC_STATUS_SUCCESS;

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = 0; /* no queued data in bulk-in buffer */

      EP0BCH = 0;

      EP0BCL = 2;

      break;

    case GET_CAPABILITIES:

      usb_tmc_status = TMC_STATUS_SUCCESS;

      {

        uint8_t i = 0;

        //code char *local_capabilities = &((code char)USB_TMC_CAPABILITIES);

        for(i;i<0x18;i++){

          //EP0BUF[i] = (&(code char)USB_TMC_CAPABILITIES)[i];

          //EP0BUF[i] = local_capabilities[i];

          EP0BUF[i] = (&(code unsigned char)USB_TMC_CAPABILITIES)[i];

        }

        EP0BCH = 0;

        EP0BCL = 0x18;

      }

      break;

    case INDICATOR_PULSE:

      /* GECKO3COM spcific command to set external LED */

      set_led_ext(ORANGE);

      usb_tmc_status = TMC_STATUS_SUCCESS;

      EP0BUF[0] = usb_tmc_status;

      EP0BCH = 0;

      EP0BCL = 1;

      break;

    /* USB488 subclass commands */

    case READ_STATUS_BYTE:

      usb_tmc_status = TMC_STATUS_SUCCESS;

      EP0BUF[0] = usb_tmc_status;

      EP0BUF[1] = wValueL;

      EP0BUF[2] = IEEE488_status_query(&ieee488_status);

      EP0BCH = 0;

      EP0BCL = 3;

      break;

    case REN_CONTROL:

      /* optional command, not implemented */

      break;

    case GO_TO_LOCAL:

      /* optional command, not implemented */

      return 0;

      break;

    case LOCAL_LOCKOUT:

      /* optional command, not implemented */

      return 0;

      break;

    default:

      return 0;

    }

  }

  else if ((bRequestType & bmRT_DIR_MASK) == bmRT_DIR_OUT){

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

     *    handle the TMC OUT requests

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

    switch (bRequest){

    default:

      usb_tmc_status = TMC_STATUS_FAILED;

      return 0;

    }

  }

  else

    return 0;    /* invalid bRequestType */

  return 1;

}