📄 isr.c
字号:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "BasicTyp.h"
#include "common.h"
#include "USB.h"
#include "HAL4D13.h"
#include "isr.h"
#include "iso.h"
#include "mainloop.h"
#include "usb_irq.h"
#include "chap_9.h"
// ************************************************************************
// Public static data
// ************************************************************************
extern D13FLAGS bD13flags;
extern USBCHECK_DEVICE_STATES bUSBCheck_Device_State;
extern CONTROL_XFER ControlData;
//extern unsigned short ioSize, ioCount;
// ************************************************************************
// ISR Subroutine
// ************************************************************************
//void usb_isr(void)
void fn_usb_isr(void)
{
//disable();
IOWR(PIO_0_BASE, 2, 0);//DIS INT1
IOWR(PIO_0_BASE, 3, 0);//CLAER
Hal4D13_LockDevice(0);
// fn_usb_isr();
// IOWR(PIO_0_BASE, 3, 0);//CLAER
IOWR(PIO_0_BASE, 2, 2);//EN INT1
// enable();
}
void usb_isr(void)
//void fn_usb_isr(void)
{
ULONG i_st;
unsigned char bbuf[1];
//IOWR(PIO_0_BASE, 3, 0);//CLAER
IOWR(PIO_0_BASE, 2, 0);//DIS INT1
IOWR(PIO_0_BASE, 3, 0);//CLAER
// Hal4D13_LockDevice(0);
bD13flags.bits.At_IRQL1 = 1;
i_st = Hal4D13_ReadInterruptRegister();
//printf("I%08x\n",i_st);
if(i_st != 0)
{
if(i_st & D13REG_INTSRC_BUSRESET)
Isr_BusReset();
else if(i_st & D13REG_INTSRC_SUSPEND)
Isr_SuspendChange();
else if(i_st & D13REG_INTSRC_EOT)
Isr_DmaEot();
else if(i_st & (D13REG_INTSRC_SOF|D13REG_INTSRC_PSEUDO_SOF))
Isr_SOF();
else if(i_st & D13REG_INTSRC_SHORT_PACKET)
Isr_SHORT_PACKET();
else if(i_st & D13REG_INTSRC_RESUME)
{
printf("RESUME\n");
Hal4D13_LockDevice(0);
}
else
{
if(i_st & D13REG_INTSRC_EP0OUT)
Isr_Ep00RxDone();
if(i_st & D13REG_INTSRC_EP0IN)
Isr_Ep00TxDone();
if(i_st & D13REG_INTSRC_EP01)
Isr_Ep01Done();
if(i_st & D13REG_INTSRC_EP02)
Isr_Ep02Done();
if(i_st & D13REG_INTSRC_EP03)
Isr_Ep03Done();
if(i_st & D13REG_INTSRC_EP04)
Isr_Ep04Done();
if(i_st & D13REG_INTSRC_EP05)
Isr_Ep05Done();
if(i_st & D13REG_INTSRC_EP06)
Isr_Ep06Done();
}
}
//printf("int_end\n");
IOWR(PIO_0_BASE, 2, 2);//EN INT1
bD13flags.bits.At_IRQL1 = 0;
//bbuf[0]=0xaa;
//Hal4D13_WriteEndpoint(EPINDEX4EP01,&bbuf, 1);
}
void Isr_BusReset(void)
{
printf("BUS RESET\n");
reconnect_USB();
bD13flags.bits.DCP_state = 0x00;
bD13flags.bits.dma_disable=0x00;
bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 1;
bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 0;
config_endpoint();
}
void Isr_SuspendChange(void)
{
bD13flags.bits.suspend=1;
}
void Isr_SHORT_PACKET(void)
{
printf("SHORT PACKET INTERRUPT\n");
}
void Isr_DmaEot(void)
{
bD13flags.bits.dma_disable =0;
if(bD13flags.bits.dma_state == DMA_PENDING)
bD13flags.bits.setup_dma = 1;
else
bD13flags.bits.dma_state = DMA_IDLE;
printf("EOT reached!!!\n");
if(bD13flags.bits.verbose==1)
printf("dma_counter = %x\n", Hal4D13_GetDMACounter());
printf("\n");
}
void Isr_SOF(void)
{
}
void Isr_Ep00RxDone(void)
{
UCHAR ep_last, i;
printf("RX %d\n",bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS++);
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0_CONTROL_OUT); /* Clear interrupt flag */
if (ep_last & D13REG_EPSTS_SETUP)
{
if(bD13flags.bits.DCP_state == USBFSM4DCP_REQUESTPROC)
{
ControlData.Abort = 1;
bD13flags.bits.DCP_state = USBFSM4DCP_SETUPPROC;
}
else
bD13flags.bits.DCP_state = USBFSM4DCP_SETUPPROC;
}
else /* not a setup packet, just a Data Out Packet */
{
switch (bD13flags.bits.DCP_state)
{
case USBFSM4DCP_DATAOUT:
i = Hal4D13_ReadEndpoint(EPINDEX4EP0_CONTROL_OUT, ControlData.dataBuffer + ControlData.wCount,
EP0_PACKET_SIZE);
ControlData.wCount += i;
if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength)
{
bD13flags.bits.DCP_state = USBFSM4DCP_REQUESTPROC;
}
break;
case USBFSM4DCP_HANDSHAKE:
bD13flags.bits.DCP_state = USBFSM4DCP_IDLE;
break;
case USBFSM4DCP_STALL: break;
case USBFSM4DCP_SETUPPROC: break;
case USBFSM4DCP_REQUESTPROC:break;
case USBFSM4DCP_DATAIN: break;
default:
printf("Fatal Error: Isr_Ep0RxDone ReadLastTranactionStatus=%x\n",ep_last);
bD13flags.bits.DCP_state = USBFSM4DCP_STALL;
Hal4D13_StallEP0InControlWrite();
break;
}
}
return ;
}
void Isr_Ep00TxDone(void)
{
short i = ControlData.wLength - ControlData.wCount;
UCHAR ep_last;
//printf("TX %d\n",bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS++);
Hal4D13_ReadInterruptRegister();
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0_CONTROL_IN); /* Clear interrupt flag */
switch (bD13flags.bits.DCP_state)
{
case USBFSM4DCP_HANDSHAKE:
break;
case USBFSM4DCP_DATAIN:
if( i >= EP0_PACKET_SIZE)
{
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN,ControlData.Addr.pData + ControlData.wCount, EP0_PACKET_SIZE);
ControlData.wCount += EP0_PACKET_SIZE;
// State remains at USBFSM4DCP_DATAIN
}
else if( i != 0)
{
Hal4D13_WriteEndpoint(1, ControlData.Addr.pData + ControlData.wCount, i);
ControlData.wCount += i;
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
//LowerIRQL();
}
else if (i == 0)
{
// Hal4D13_SingleTransmitEP0(0, 0);
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
Hal4D13_SingleTransmitEP0(0, 0);
}
break;
case USBFSM4DCP_REQUESTPROC: break;
case USBFSM4DCP_IDLE: break;
case USBFSM4DCP_SETUPPROC: break;
case USBFSM4DCP_STALL: break;
case USBFSM4DCP_DATAOUT: break;
default:
printf("Fatal Error: Isr_Ep0TxDone Unexpected FSMState=%x\n",bD13flags.bits.DCP_state);
bD13flags.bits.DCP_state = USBFSM4DCP_STALL;
//printf("bD13flags.bits.DCP_state = x%hx\n", bD13flags.bits.DCP_state);
Hal4D13_StallEP0InControlRead();
break;
}
//Chap9_SetConfiguration();Chap9_GetConfiguration();
}
void Isr_Ep01Done(void)
{
unsigned char bbuf[8];
UCHAR c;
c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP01);
Hal4D13_ReadEndpoint(EPINDEX4EP01, &bbuf, 8);
// Hal4D13_WriteEndpoint(EPINDEX4EP01,&bbuf, 1);
Hal4D13_ReadBulkEndpoint(EPINDEX4EP01,&bbuf, 1);
// IOWR(LED_GREEN_BASE,0,bbuf[0]);
// IOWR(LED_RED_BASE, 0 , ( (bbuf[1]<<8) + bbuf[2] ) );
printf("ep1 %x %x %x %x %x %x %x %x \n",
bbuf[0],bbuf[1],bbuf[2],bbuf[3],
bbuf[4],bbuf[5],bbuf[6],bbuf[7]
);
if (bbuf[0]==0xaa) bbuf[0]=bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS++;
else if (bbuf[0]==0x55) bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS = 0;
else if (bbuf[0]==0x99) bUSBCheck_Device_State.State_bits.RESET_BITS = 1;
else bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS=0xcc;
bbuf[0]=bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS;
IOWR(LED_GREEN_BASE,0,bbuf[0]);
IOWR(SEG7_DISPLAY_BASE,0,bbuf[0]);
Hal4D13_WriteEndpoint(EPINDEX4EP02,&bbuf, 8);
Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP01); /* Clear interrupt flag*/
///Hal4D13_WriteEndpoint(EPINDEX4EP02,bbuf, 1);
}
void Isr_Ep02Done(void)
{
unsigned char bbuf[8];
printf("ep2\n");
bbuf[0]=0x99;
Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP02);
}
void Isr_Ep03Done(void)
{
UCHAR ep_last;
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP03); /* Clear interrupt flag*/
/*
UCHAR ep_last, DoubleBuff=1;
UCHAR len;
USHORT far *fp;
USHORT seg, off;
ep_last = (UCHAR)Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP03); // Clear interrupt flag
// Check for Double Buffer Condition
if((ep_last & 0x60) == 0x60)
DoubleBuff = 2;
else
DoubleBuff = 1;
if (!(ep_last & (D13REG_EPSTS_DBF0|D13REG_EPSTS_DBF1)) || (ep_last & 0x80))
{
printf("ep_last = %x, \n", ep_last);
return ;
}
else //Data Out Packet
{
while(DoubleBuff)
{
if (ioCount <= ioSize)
{
// Initialise the pointer
seg = (ioBuffer + ioCount)>>4;
off = (ioBuffer + ioCount)&0xf;
fp = MK_FP(seg, off);
// Determine the Transfer length
if((ioSize-ioCount) >64)
len = 64;
else
{
len = ioSize - ioCount;
if(bD13flags.bits.dma_state == DMA_PENDING)
bD13flags.bits.setup_dma = 1;
else
bD13flags.bits.dma_state = DMA_IDLE;
}
// Read in Data from Endpoint, and update the ioCount
ioCount += Hal4D13_ReadBulkEndpoint(EPINDEX4EP03, fp, len);
}
else
{
Hal4D13_ClearBuffer(EPINDEX4EP03);
if(bD13flags.bits.dma_state == DMA_PENDING)
bD13flags.bits.setup_dma = 1;
else
bD13flags.bits.dma_state = DMA_IDLE;
}
DoubleBuff --;
if(DoubleBuff == 1)
ep_last = (UCHAR)Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP03); // Clear interrupt flag
}
}
*/
}
void Isr_Ep04Done(void)
{
UCHAR ep_last;
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP04); /* Clear interrupt flag*/
/*
USHORT len;
USHORT far *fp;
USHORT seg, off;
UCHAR DoubleBuff=0;
UCHAR ep_last;
ep_last = (UCHAR)Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP04); // Clear interrupt flag
if((ep_last & (D13REG_EPSTS_DBF0|D13REG_EPSTS_DBF1)) == 0x00)
DoubleBuff = 2;
else
DoubleBuff = 1;
if((ep_last & (D13REG_EPSTS_DBF0|D13REG_EPSTS_DBF1)) == 0x60)
{
// BUFFER IS NOT EMPTY
printf("ep_last = %x, \n", ep_last);
return ;
}
else // Data IN Packet
{
while(DoubleBuff)
{
// Initialise the pointer
seg = (ioBuffer + ioCount)>>4;
off = (ioBuffer + ioCount)&0xf;
fp = MK_FP(seg, off);
// Determine the Transfer length
if(ioSize >= ioCount)
len = ioSize - ioCount;
if(len > 64)
{
ioCount += Hal4D13_WriteBulkEndpoint(EPINDEX4EP04, fp, 64);
bD13flags.bits.dma_state = DMA_IDLE;
}
else if(len >= 1)
{
ioCount += Hal4D13_WriteBulkEndpoint(EPINDEX4EP04, fp, len);
bD13flags.bits.dma_state = DMA_IN_DONE;
}
DoubleBuff--;
if(DoubleBuff == 1)
ep_last = (UCHAR)Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP04); // Clear interrupt flag
}
}
*/
}
void Isr_Ep05Done(void)
{
UCHAR ep_last, DoubleBuff=1;
USHORT ISO_Buffer[512], len;
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP05); // Clear interrupt flag
if((ep_last & (D13REG_EPSTS_DBF0|D13REG_EPSTS_DBF1)) == 0x00)
DoubleBuff = 2;
else
DoubleBuff = 1;
if (ep_last | D13REG_EPSTS_DBF0|D13REG_EPSTS_DBF1)
{
return ;
}
else //Data Out Packet
{
if((ep_last & 0x60) != 0x00)
{
if(DoubleBuff == 2)
{
while(DoubleBuff)
{
len = Hal4D13_ReadISOEndpoint(EPINDEX4EP05, ISO_Buffer, 512);
Hal4D13_WriteISOEndpoint(EPINDEX4EP06, ISO_Buffer, len);
DoubleBuff--;
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP05); // Clear interrupt flag
}
}
else
{
len = Hal4D13_ReadISOEndpoint(EPINDEX4EP05, ISO_Buffer, 512);
Hal4D13_WriteISOEndpoint(EPINDEX4EP06, ISO_Buffer, len);
}
}
}
}
void Isr_Ep06Done(void)
{
UCHAR ep_last;
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP06); /* Clear interrupt flag*/
}
void Isr_Ep07Done(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP07); /* Clear interrupt flag */
}
void Isr_Ep08Done(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP08); /* Clear interrupt flag */
}
void Isr_Ep09Done(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP09); /* Clear interrupt flag */
}
void Isr_Ep0ADone(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0A); /* Clear interrupt flag */
}
void Isr_Ep0BDone(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0B); /* Clear interrupt flag */
}
void Isr_Ep0CDone(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0C); /* Clear interrupt flag */
}
void Isr_Ep0DDone(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0D); /* Clear interrupt flag */
}
void Isr_Ep0EDone(void)
{
// UCHAR c;
// c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0E); /* Clear interrupt flag */
}
//*********************************************************************
// supporting Functions
//*********************************************************************
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -