isr.c

使用MSP430的IAR开发环境

#include <stdio.h>
#include <string.h>

#include "Epphal.h"
#include <msp430x13x.h>
#include "d12ci.h"
#include "mainloop.h"
#include "USB100.h"

void bus_reset(void);

void ep0_txdone(void);
void ep0_rxdone(void);
void dma_eot(void);
void ep1_txdone(void);
void ep1_rxdone(void);
void main_txdone(void);
void main_rxdone(void);

EPPFLAGS bEPPflags;

/* Control endpoint TX/RX buffers */
extern CONTROL_XFER ControlData;

/* ISR static vars */
unsigned char GenEpBuf[EP1_PACKET_SIZE];
unsigned char EpBuf[EP2_PACKET_SIZE];
IO_REQUEST ioRequest;
unsigned char ioSize, ioCount;

unsigned long ClockTicks = 0;
unsigned char MainEpBuf[256];
unsigned int qq=0;

extern BOOL bNoRAM;

//#pragma vector=PORT1_VECTOR
//__interrupt void fn_usb_isr(void)
interrupt[PORT1_VECTOR] void usb_isr(void)
{
     
	_DINT();
	if(P1IFG&BIT2)
	{
	fn_usb_isr();
	P1IFG = 0;
	}
	_EINT();
}

void fn_usb_isr(void)
{
  unsigned int int_src;
  unsigned int pp;
  //_DINT();
  qq++;
  pp = qq;
  bEPPflags.bits.in_isr = 1;
  int_src = D12_ReadInterruptRegister();
  
  if(int_src)
  {
    if(int_src & D12_INT_BUSRESET) 
      {
        bus_reset();
        bEPPflags.bits.bus_reset = 1;
        //goto exit;
        }
    if(int_src & D12_INT_EOT)
    {
      dma_eot();  
      }
    if(int_src & D12_INT_SUSPENDCHANGE)
    {
      bEPPflags.bits.suspend = 1;
      }
    if(int_src & D12_INT_ENDP0IN)
    {
      ep0_txdone();
      }
    if(int_src & D12_INT_ENDP0OUT)
    {
      ep0_rxdone();
      }
    if(int_src & D12_INT_ENDP1IN)
    {
      ep1_txdone();
      }
    if(int_src & D12_INT_ENDP1OUT)
    {
      ep1_rxdone();
      }
    if(int_src & D12_INT_ENDP2IN)
    {
      main_txdone();
      }
    if(int_src & D12_INT_ENDP2OUT)
    {
      main_rxdone();
      }
    }
    //exit:
    bEPPflags.bits.in_isr = 0;    
   // P1IFG = 0;
    //_EINT();  
  }
 
void bus_reset(void)
{
 }
   
void ep0_txdone(void)
{
  int i = ControlData.wLength - ControlData.wCount;
  
  D12_ReadLastTransactionStatus(1);                     //Clear Endpoint Interrupt Flags
                                                        //LastState_1[CNT_1++] = 
  
  if(bEPPflags.bits.control_state != USB_TRANSMIT)      //Non Transmit_state,return
    return;                                             
  if(i >= EP0_PACKET_SIZE)                              //Transmit 16B
  {
    D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
    ControlData.wCount += EP0_PACKET_SIZE;
    bEPPflags.bits.control_state = USB_TRANSMIT;
  }   
  else if(i != 0)                                       //Transmit remains
  {
    D12_WriteEndpoint(1, i, ControlData.pData + ControlData.wCount);
    ControlData.wCount += i;
    bEPPflags.bits.control_state = USB_IDLE;
  }
  else if(i == 0)                                       //Transmission completed
  {
    D12_WriteEndpoint(1, 0, 0);
    bEPPflags.bits.control_state = USB_IDLE;
  }
}

/*------------Endpoint 0 OUT Interrupt-----------*/
void ep0_rxdone(void)
{
  unsigned char ep_last, i;
  unsigned int m1;
  unsigned int m2;
  unsigned int m3;
  unsigned char m4;
  unsigned char m5;
  ep_last = D12_ReadLastTransactionStatus(0);           //Clear Endpoint Interrupt Flags
  //LastState_0[CNT] = ep_last;
  if(ep_last & D12_SETUPPACKET)                         //Received Setup Packet
  { 
    ControlData.wLength = 0;
    ControlData.wCount = 0;
    if(D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST))
    {    
      D12_SetEndpointStatus(0,1);
      D12_SetEndpointStatus(1,1);
      bEPPflags.bits.control_state = USB_IDLE;
      return; 
    }
    
    m1=ControlData.DeviceRequest.wValue;// = ControlData.DeviceRequest.wValue;
    m2=ControlData.DeviceRequest.wIndex; //= ControlData.DeviceRequest.wIndex;
    m3=ControlData.DeviceRequest.wLength; //= ControlData.DeviceRequest.wLength;
    m4=ControlData.DeviceRequest.bmRequestType;
    m5=ControlData.DeviceRequest.bRequest;   
    //Acknowlege EndPoint0
    D12_AcknowledgeEndpoint(0);
    D12_AcknowledgeEndpoint(1);
    ControlData.wLength = ControlData.DeviceRequest.wLength;
    ControlData.wCount = 0;    
    if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
    {
      //Device --> Host
      bEPPflags.bits.setup_packet = 1;
      bEPPflags.bits.control_state = USB_TRANSMIT;
    }
    else
    { 
      //Host --> Device
      if(ControlData.DeviceRequest.wLength == 0)
      {
        bEPPflags.bits.setup_packet = 1;
        bEPPflags.bits.control_state = USB_IDLE;
      }
      else
      {
        if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE)
        {
          bEPPflags.bits.control_state = USB_IDLE;
          D12_SetEndpointStatus(0,1);
          D12_SetEndpointStatus(1,1);
        } 
        else  bEPPflags.bits.control_state = USB_RECEIVE;
      }//SET COMMAND WITH DATA
    }//ELSE SET COMMAND   
  }//IF SETUP PACKET
  else if(bEPPflags.bits.control_state == USB_RECEIVE)  
  {
    i = D12_ReadEndpoint(0, EP0_PACKET_SIZE, ControlData.dataBuffer + ControlData.wCount);
    ControlData.wCount += i;
    if(i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength)               //Data Receiving completed
    {
      bEPPflags.bits.setup_packet = 1;
      bEPPflags.bits.control_state = USB_IDLE;
    }
  }
  else  bEPPflags.bits.control_state = USB_IDLE;
  
  /*
  //trace the request
  DeviceRequest[CNT].bmRequestType = ControlData.DeviceRequest.bmRequestType;
  DeviceRequest[CNT].bRequest = ControlData.DeviceRequest.bRequest;
  DeviceRequest[CNT].wValue = ControlData.DeviceRequest.wValue;
  DeviceRequest[CNT].wIndex = ControlData.DeviceRequest.wIndex;
  DeviceRequest[CNT].wLength = ControlData.DeviceRequest.wLength;
  CNT++;
  
  */
}

void dma_eot(void)
{ 
}

void ep1_txdone(void)
{
  D12_ReadLastTransactionStatus(3);
}

void ep1_rxdone(void)
{
  unsigned char len;
  D12_ReadLastTransactionStatus(2);
  len = D12_ReadEndpoint(2, EP1_PACKET_SIZE, GenEpBuf);
  if(len != 0)
    bEPPflags.bits.ep1_rxdone = 1;
}

void main_txdone(void)
{
  unsigned char len;

	D12_ReadLastTransactionStatus(5); /* Clear interrupt flag */

	len = ioSize - ioCount;
	if(len == 0) 
	{
		if(bEPPflags.bits.dma_state == DMA_PENDING)
		{
			bEPPflags.bits.setup_dma ++;
		}
		else
		{
			bEPPflags.bits.dma_state = DMA_IDLE;
		}
	}
	else
	{
		if(len > 64)
		{
			len = 64;
		}
		if(bNoRAM)
		{
			len = D12_WriteEndpoint(5, len, EpBuf + ioCount);
		}
		else
		{
			len = D12_WriteEndpoint(5, len, MainEpBuf + ioCount);
		}
		ioCount += len;
	}
}


void main_rxdone(void)
{
  	unsigned char len;

	D12_ReadLastTransactionStatus(4); /* Clear interrupt flag */

	if(bNoRAM)
	{
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
	}
	else
	{
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	}
	ioCount += len;
	/*if(bNoRAM)
	{
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
	}
	else
	{	
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	}
	ioCount += len;*/
	if(ioCount >= ioSize) 
	{
		if(bEPPflags.bits.dma_state == DMA_PENDING)
		{
			bEPPflags.bits.setup_dma ++;
		}
		else
		{
			bEPPflags.bits.dma_state = DMA_IDLE;
		}
	}               //Read From Double Buffer
}