usb430.c

使用MSP430的IAR开发环境

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

#include <msp430x13x.h>                /* special function register declarations   */

#include "epphal.h"
#include "d12ci.h"
#include "mainloop.h"
#include "usb100.h"
#include "chap_9.h"
#include "protodma.h"
/*;
;*************************************************************************
; USB protocol function pointer arrays
;*************************************************************************
*/
void (*StandardDeviceRequest[])(void) =              
{  
	get_status,
	clear_feature,
	reserved,
	set_feature,
	reserved,
	set_address,
	get_descriptor,
	reserved,
	get_configuration,
	set_configuration,
	get_interface,
	set_interface,
	reserved,
	reserved,
	reserved,
	reserved
};              //标准请求处理函数入口列表

void (*VendorDeviceRequest[])(void) =
{
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	read_write_register,
	reserved,
	reserved,
	reserved
};


/*;
;*************************************************************************
;  Public static data
;*************************************************************************
*/
//DEVICE_REQUEST DeviceRequest[30];
//unsigned char LastState_0[30];
//unsigned char LastState_1[30];
//unsigned int CNT = 0;
//unsigned int CNT_1 = 0;

extern EPPFLAGS bEPPflags;
extern unsigned char ioSize, ioCount;
extern unsigned char GenEpBuf[EP1_PACKET_SIZE];
extern unsigned char MainEpBuf[256];
extern unsigned char EpBuf[EP2_PACKET_SIZE];
extern unsigned long ClockTicks;
//unsigned int clk_cnt;
extern IO_REQUEST ioRequest;

extern void fn_usb_isr(void);
extern unsigned int D12_ReadChipID(void);

CONTROL_XFER ControlData;
unsigned char bNoRAM;

/*
void init_TimerB(void)
{
  TBCTL = TBSSEL_2 + TBCLR;               //Timer B clock source select: 2 - SMCLK 
  TBCCR0 = 7;                           // PWM Period:500K Hz
  TBCCTL1 = OUTMOD_7;                     // CCR1 toggle/set
  TBCCR1 = 4;                           // CCR1 PWM duty cycle
  TBCTL |= MC0;                             // Start Timer_B in up mode
}
*/

void init_TimerA(void)
{
  /*TACTL = TASSEL1 + MC0 + TACLR;              // MCLK, clear TAR,增计数模式
  CCTL0 = CCIE;                         // CCR0 interrupt enabled
  CCR0 = 65534;                         //6M时钟定时3ms
  */
  TACTL = TASSEL1 + TACLR;              // SMCLK, clear TAR
  CCTL0 = CCIE;                         // CCR0 interrupt enabled
  CCR0 = 8000;          //延时2.5ms
                        // P1.0 output
  TACTL |= MC0;                         // Start Timer_a in upmode
  
  
}

// Timer A0 interrupt service routine
//#pragma vector=TIMERA0_VECTOR
//__interrupt void Timer_A (void)
interrupt[TIMERA0_VECTOR] void Timer_A(void)
{
  //_DINT();
  ClockTicks++;
  //P3OUT ^= 0x80; 
  bEPPflags.bits.timer = 1;
  //_EINT();  
}	

void init_special_interrupts(void)
{
	P1DIR &=~0x04;
	P1IFG = 0x0;
	P1IES |=0x04;
	//P1IE |= 0X04;
}

void init_port(void)
{       
        P4SEL = 0x00;
	P4DIR = 0xFF;
	//P1SEL = 0X00;
	P1DIR = 0xFB;
	P1OUT = 0xFF;
	
	//P3SEL = 0XC0;
	P3DIR = 0xF0;
	P3OUT|= BIT6;
	P3OUT|= BIT7;
	
	//P3OUT =~BIT6;
        //P3OUT =~BIT7;
	
	//P4SEL |= 0X02;                        //TB PWM Output:500K Hz //TB1的PWM输出
	//P3SEL = 0X30;
	//P3DIR |= 0X10;                      //UTXD1,串口1输出 ,此解释错误，如为串口则应选外围模块模式
	                                      //且不用选方向和初始化输出值了
	//P3OUT |= 0X10;	                    //UTXD1输出1
	
	MCU_D12CS_0;	//D12 Select
	D12_SUSPD_0;		//D12 not in Suspend
}


void Send50words(void)
{
       unsigned char a[4]={0,1,2,3,};

       D12_WriteEndpoint(5, 4, a);

}

void init(void)
{ 
  unsigned char i;
  WDTCTL = WDTPW + WDTHOLD;             // Stop WDT
  BCSCTL1 &= ~XT2OFF;                   //Enable high frequency oscillator
  BCSCTL2 = 0X88;                       //MCLK = SMCLK = 8M Hz
  do 
  {
    IFG1 &= ~OFIFG;                       // Clear OSCFault flag
    for (i = 0xFF; i > 0; i--);           // Time for flag to set
  }
  while ((IFG1 & OFIFG) == OFIFG);      // OSCFault flag still set?                
 
 
 //WDTCTL = WDTPW + WDTHOLD;             // Stop WDT
 //BCSCTL1 = 0x00;                        //此两行为新添
// BCSCTL2 = 0x00;
  //BCSCTL1 &= ~XT2OFF;
  
 // init_AD(); 
  init_port();  
  //init_special_interrupts();
  init_TimerA();
  //init_TimerB();

  //D12_SetAddressEnable(0x0,1);
  //init_config();
}

void main(void)
{  
 
  unsigned int r;
  
  unsigned int w; 
  
 // unsigned int qq=0;       
  
  //_DINT();             
  init();
   
  //_EINT();
  
  //P3OUT =~BIT6;
  //P3OUT =~BIT7;
  //P3OUT |=BIT6;
  //P3OUT |=BIT7;
                           
                     
 //?? bEPPflags.value = 0;
  
  init_special_interrupts();
  r=D12_ReadChipID();
  w=sizeof(USB_DEVICE_DESCRIPTOR);
  _EINT();
  P1IE = 0x04;
  
  MCU_D12CS_1;
  bNoRAM = TRUE;
  MCU_D12CS_0;
  
  MCU_D12RST_0; 
  _NOP(); 
  _NOP(); 
  _NOP(); 
  MCU_D12RST_1;    //reset usb 芯片
  
 // for(i=0;i<2400;i++);
  bEPPflags.value = 0;
  
 
  reconnect_USB();
 
  
  
  while(TRUE)
  {    
 
    	if (bEPPflags.bits.timer)
		{
			_DINT(); 
		       
			bEPPflags.bits.timer = 0;
			_EINT();

			if(bEPPflags.bits.configuration)
				//check_key_LED();
                                Send50words();
		}
              
    if (bEPPflags.bits.bus_reset) 
    {                        //总线重起中断响应
      _DINT();
      bEPPflags.bits.bus_reset = 0;
      _EINT();
      
      D12_SUSPD_0;						
    } // if bus reset

    if (bEPPflags.bits.suspend) 
    {                          //挂起中断响应
      _DINT();
      bEPPflags.bits.suspend= 0;
      _EINT();
      if((P1OUT & D12_SUSPD) == D12_SUSPD) 
      {
        D12_SUSPD_0;
        //P4SEL = 0X00;
	P4DIR = 0XFF;
	P4OUT = 0xFF;
	P4DIR = 0X0;
	//P1SEL = 0X00;
	P1DIR = 0XFB;
	P1OUT = 0xFF;
	
	D12_SetDMA(0xC3);
	D12_SUSPD_1;
	while (1);
      }
    } // if suspend change
    
    

    if (bEPPflags.bits.setup_packet)
    {                    //接收到设置包中断处理
      _DINT();
      bEPPflags.bits.setup_packet = 0;
      _EINT();
      control_handler();
      
     D12_SUSPD_0;
    } // if setup_packet
    
    	if(bEPPflags.bits.setup_dma != 0) 
		{
			_DINT();
			bEPPflags.bits.setup_dma --;
			_EINT();
			setup_dma();
		} // if setup_dma
   }// Main Loop
}

void stall_ep0(void)                                    
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

void connect_USB(void)
{
	// reset event flags
	_DINT();
	bEPPflags.value = 0;
	_EINT();
	
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);
	//D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);//DMA用
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_4M);
}


void reconnect_USB(void)
{	  
  // Pull-down D12's SUSPEND pin  
  // Release D12's SUSPEND pin after receiving bus reset from host  
  //unsigned long clk_cnt;
   unsigned long clk_cnt = 0;
  
  P3OUT &=~BIT6;
  P3OUT &=~BIT7;
  
  D12_SUSPD_0;
  disconnect_USB();
  

 for(clk_cnt = 0;clk_cnt < 400;clk_cnt++);
 //_NOP();
 //clk_cnt = ClockTicks;
 //while(ClockTicks < clk_cnt + 10);
	//P3OUT &= ~0X40; 	

  connect_USB(); 
  
  P3OUT |=BIT6;
  P3OUT |=BIT7;
}

void init_unconfig(void)
{
  D12_SetEndpointEnable(0);	/* Disable all endpoints but EPP0. */
}

void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

void code_transmit(unsigned char * pRomData, unsigned short len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCount += EP0_PACKET_SIZE;
		_DINT();            
	        bEPPflags.bits.control_state = USB_TRANSMIT;               //总线处于传输状态
	        _EINT();
	}
	else {  
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);
		ControlData.wCount += ControlData.wLength;
		_DINT();
		bEPPflags.bits.control_state = USB_IDLE;                   //总线空闲
		_EINT();
	}
}

void setup_dma(void)
{
	ioSize = ioRequest.uSize;
	ioCount = 0;

	_DINT();
	bEPPflags.bits.dma_state = DMA_RUNNING;
	_EINT();

	single_transmit(0, 0);

	if(ioRequest.bCommand & 0x1)
	{
		if(ioSize > 64 || ioSize == 0)
		{
			//if(bNoRAM)
				D12_WriteEndpoint(5, 64, EpBuf);
			//else
			//	D12_WriteEndpoint(5, 64, MainEpBuf);
			ioCount += 64;
		}
		else
		{
			//if(bNoRAM)
				D12_WriteEndpoint(5, ioSize, EpBuf);
			//else
			//	D12_WriteEndpoint(5, ioSize, MainEpBuf);
			ioCount += ioSize;
		}
	}
}



void control_handler(void)                                                                   //usb请求处理程序
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;              //请求类型：标准or厂商
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;                         //具体请求代号	

	if (type == USB_STANDARD_REQUEST)
	{                                                    //标准请求处理
		(*StandardDeviceRequest[req])();	
	}
	else if (type == USB_VENDOR_REQUEST)
	{
		(*VendorDeviceRequest[req])();
	}	
	else
	{
		stall_ep0();
	}
		
}