📄 mainloop.c
字号:
/*
//*************************************************************************
//
// P H I L I P S P R O P R I E T A R Y
//
// COPYRIGHT (c) 1999 BY PHILIPS SINGAPORE.
// -- ALL RIGHTS RESERVED --
//
// File Name: MainLoop.C
// Created: Oct 24, 2000
// Modified:
// Revision: 1.01
//
//*************************************************************************
// Implementation Notes:
// 3. Default Control Pipe Finate State Machine
// SETUP Stage -> SETUP Proc -> DATA OUT Stage -> CONTROL OUT Handshake -> STATUS Stage -> IDLE
// SETUP Stage -> SETUP Proc -> CONTROL OUT Handshake -> STATUS Stage -> IDLE
// SETUP Stage -> SETUP Proc -> DATA IN Stage-> CONTROL IN Handshake ->STATUS Stage -> IDLE
// STALL -> SETUP Stage -> ...
//
// 2. Stack Overflow Avoidance.
// Setup TK overwritten allowance.
// 1. System Modeling
// A. D13
// B. 8051
// 0. 8051 Modeling
// A. Target 8051 , 128 RAM, 4K ROM
// B. Choose 2 IRQL levels, Interrupt Priority 0 as IRQL_1, Mainloop as IRQL_0
// C. Bit Address Space, Byte Ram Addess Space, Code Address Space
//
//*************************************************************************
// Development Environment
// 1. Use VC++ IDE instead of DOS enviroment
// 0. Keil C
//*************************************************************************
//ww, july13, to test ES7 suspend function
*/
#include <stdio.h>
#include <string.h>
#include <reg51.h> /* special function register declarations */
#include <intrins.h>
#include "BasicTyp.H"
#include "SysCnfg.h"
#include "Hal4Sys.h"
#include "Hal4D13.h"
#include "mainloop.h"
#include "usb100.h"
#include "chap_9.h"
#include "common.h"
//bulk by dma
#include "d13bus.h"
/*
//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************
*/
code void (*StandardDeviceRequest[])(void) =
{
Chap9_GetStatus,
Chap9_ClearFeature,
Chap9_StallEP0,
Chap9_SetFeature,
Chap9_StallEP0,
Chap9_SetAddress,
Chap9_GetDescriptor,
Chap9_StallEP0,
Chap9_GetConfiguration,
Chap9_SetConfiguration,
Chap9_GetInterface,
Chap9_SetInterface,
Chap9_StallEP0
};
/*
//*************************************************************************
// Class device requests
//*************************************************************************
*/
code void (*ClassDeviceRequest[])(void) =
{
ML_Reserved
};
/*
//*************************************************************************
// Vendor Device Request
//*************************************************************************
*/
code void (*VendorDeviceRequest[])(void) =
{
//dec5, vendor request for DMA, iso D13Bus_Watchdog,
// reserved,
//march1
EnableDMA4ISO,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
reserved,
read_write_register,
reserved,
reserved,
reserved
};
/*
//*************************************************************************
// Public static data
//*************************************************************************
*/
extern D13FLAGS bD13flags;
extern IO_REQUEST idata ioRequest;
extern UCHAR idata GenEpBuf[];
extern UCHAR ioSize, ioCount;
//extern UCHAR xdata ExtRAMBuf[];
extern UCHAR idata IntRAMBuf[];
BOOL bNoExtRAM;
extern USHORT Hal4Sys_ClockTicks;
CONTROL_XFER ControlData;
/*
//*************************************************************************
// Public data
//*************************************************************************
*/
void main(void)
{
UCHAR i;
RaiseIRQL();
Hal4Sys_InitMCU();
Hal4Sys_InitD13();
D13CS_N = 1; //Enable Chip select
reconnect_USB();
/* Main program loop */
while(TRUE)
{
LowerIRQL();
if( MCU_PB2 == 0 )
{
Isr_SuspendChange();
}
if (bD13flags.bits.bus_reset)
{
RaiseIRQL();
bus_reset();
bD13flags.bits.bus_reset = 0;
LowerIRQL();
} // if bus reset
if (bD13flags.bits.suspend)
{
RaiseIRQL();
suspend_change();
bD13flags.bits.suspend= 0;
LowerIRQL();
} // if suspend change
if (bD13flags.bits.remote_wakeup)
{
RaiseIRQL();
wakeup_change();
bD13flags.bits.remote_wakeup = 0;
LowerIRQL();
}
if (bD13flags.bits.DCP_state == USBFSM4DCP_SETUPPROC)
{
RaiseIRQL();
SetupToken_Handler();
LowerIRQL();
}
if (bD13flags.bits.DCP_state == USBFSM4DCP_REQUESTPROC)
{
RaiseIRQL();
DeviceRequest_Handler();
LowerIRQL();
} /* if setup_packet for DeviceRequest*/
if (bD13flags.bits.setup_dma)
{
RaiseIRQL();
bD13flags.bits.setup_dma = 0;
setup_dma();
while(DMAINTRANSFER==1);
DMASTART = 0;
LowerIRQL();
} // if setup_dma
} // Main Loop
}
/*
//*************************************************************************
// Subroutines
//*************************************************************************
*/
void SetupToken_Handler(void)
{
/*
// Normal path
// Setup Transaction starts after a completed Control Transfer.
*/
ControlData.wLength = 0;
ControlData.wCount = 0;
if( Hal4D13_ReadEndpointWOClearBuffer(EPINDEX4EP0_CONTROL_OUT, (UCHAR *)(&(ControlData.DeviceRequest)), sizeof(ControlData.DeviceRequest)) == sizeof(DEVICE_REQUEST) )
{
ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
ControlData.DeviceRequest.wLength = SWAP(ControlData.DeviceRequest.wLength);
ControlData.wLength = ControlData.DeviceRequest.wLength;
ControlData.wCount = 0;
if (ControlData.DeviceRequest.bmRequestType & (UCHAR)USB_ENDPOINT_DIRECTION_MASK)
{
/* get command */
ML_AcknowledgeSETUP();
if((ControlData.DeviceRequest.bRequest == 0) & (ControlData.DeviceRequest.bmRequestType == 0xc0))
{
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
}
else
{
bD13flags.bits.DCP_state = USBFSM4DCP_REQUESTPROC;
}
}
else
{
/* set command */
if (ControlData.DeviceRequest.wLength == 0)
{
/* Set command without Data stage*/
ML_AcknowledgeSETUP();
bD13flags.bits.DCP_state = USBFSM4DCP_REQUESTPROC;
}
else
{
/*
// Set command with Data stage
// get Data Buffer
*/
if(ControlData.DeviceRequest.wLength <= MAX_CONTROLDATA_SIZE)
{
/* set command with OUT token */
bD13flags.bits.DCP_state = USBFSM4DCP_DATAOUT;
ML_AcknowledgeSETUP();
}
else
{
ML_AcknowledgeSETUP();
Hal4D13_StallEP0InControlWrite();
bD13flags.bits.DCP_state = USBFSM4DCP_STALL;
}
}
}
}
else
{
Chap9_StallEP0();
}
}
void DeviceRequest_Handler(void)
{
UCHAR type, req;
type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;
// printf("type = x%hx, req = x%hx\n", type, req);
// help_devreq(type, req); /* print out device request */
if ((type == USB_STANDARD_REQUEST) && (req < MAX_STANDARD_REQUEST))
(*StandardDeviceRequest[req])();
else if ((type == USB_CLASS_REQUEST) && (req <MAX_CLASS_REQUEST))
(*ClassDeviceRequest[req])();
else if ((type == USB_VENDOR_REQUEST) && (req < MAX_VENDOR_REQUEST))
(*VendorDeviceRequest[req])();
else
Chap9_StallEP0();
}
void disconnect_USB(void)
{
}
void connect_USB(void)
{
/*
// reset event flags
*/
bD13flags.value = 0;
bD13flags.bits.DCP_state = USBFSM4DCP_IDLE;
//config EP 1st, then enable D13_int
config_endpoint();
Hal4D13_SetMode(D13REG_MODE_INT_EN|D13REG_MODE_SOFTCONNECT);
}
void reconnect_USB(void)
{
USHORT clk_cnt;
/*
// reconnect USB and On LED 1 second.
*/
MCU_LED0 = 0;
MCU_LED1 = 0;
disconnect_USB();
Hal4Sys_WaitInMS(50);
connect_USB();
//Off LED
MCU_LED0 = 1;
MCU_LED1 = 1;
}
void config_endpoint(void)
{
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_8,EPINDEX4EP01);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_NONISOSZ_16,EPINDEX4EP02);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP03);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP04);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_ISOSZ_512|D13REG_EPCNFG_ISO_EN,EPINDEX4EP05);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_FIFO_EN|D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_ISOSZ_512|D13REG_EPCNFG_ISO_EN,EPINDEX4EP06);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP07);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP08);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP09);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP0A);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP0B);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP0C);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP0D);
Hal4D13_SetEndpointConfig(D13REG_EPCNFG_DBLBUF_EN|D13REG_EPCNFG_IN_EN|D13REG_EPCNFG_NONISOSZ_64,EPINDEX4EP0E);
Hal4D13_SetIntEnable(D13REG_INTSRC_EP0OUT|D13REG_INTSRC_EP0IN\
|D13REG_INTSRC_EP03|D13REG_INTSRC_EP04\
|D13REG_INTSRC_EP05|D13REG_INTSRC_EP06\
|D13REG_INTSRC_SUSPEND\
|D13REG_INTSRC_BUSRESET);
Hal4D13_SetDevConfig(D13REG_DEVCNFG_PWROFF\
|D13REG_DEVCNFG_NOLAZYCLOCK\
|D13REG_DEVCNFG_CLOCKDIV_240M\
|D13REG_DEVCNFG_WAKEUPBY_CS\
/* |D13REG_DEVCNFG_CLOCKRUNNING\*/
|D13REG_DEVCNFG_EOTPOL\
|D13REG_DEVCNFG_DMARQPOL);
}
void bus_reset(void)
{
}
void suspend_change(void)
{
unsigned int i,j;
/*
FROM HERE
D13_WAKEUP = 0;
D13CS_N = 1; // CS deactive!!!
Hal4Sys_WaitInMS(10);
//D13CS_N = 0;
//Hal4Sys_WaitInMS(1);
D13CS_N = 0;
//outportb(D13_COMMAND_PORT,D13CMD_DEV_RD_ADDR);
D13CS_N = 1;
//inportb(D13_DATA_PORT);
//D13CS_N = 1;
//NOV28, P0~ tri-state to power down 8051
//feb19
//ww, july13, wakeup pin, dma_reset pin keep low
Hal4Sys_PDMCU();
Hal4Sys_PDMCU();
Hal4Sys_PDMCU();
//I have 2ms to let MCU power down, don't let emulator power down
//nov28, if using emulator, don't use power down
//dec4, to meet suspend current requirement, must de-select D13!!!, all input pins of D13 is inactive
//Jan16, for inter-operability test
PCON |= 0x02; //Powerdown bit set
while (1);// dead loop, nothing to do. Waiting for WakeUp by system
TOHERE*/
//remote wakeup, wait for 10sec, then auto wakeup D13
}
//suspend
void wakeup_change(void)
{
//Unlock device\n");
// Hal4D13_LockDevice(0xAA37);
}
//*/
void ML_AcknowledgeSETUP(void)
{
LowerIRQL();
RaiseIRQL();
#if 0
if( Hal4D13_IsSetupPktInvalid() || ControlData.Abort)
{
return;
}
#endif
Hal4D13_AcknowledgeSETUP();
Hal4D13_ClearBuffer(EPINDEX4EP0_CONTROL_OUT);
}
void ML_Reserved(void)
{
Hal4D13_ClearBuffer(EPINDEX4EP0_CONTROL_OUT);
}
void setup_dma(void)
{
if(ioRequest.bCommand & 0x80)
{
D13_config_DMA();
return;
}
else
{
bD13flags.bits.dma_disable = 0;
setup_io();
}
}
void D13_config_DMA(void)
{
UCHAR ENDPINDEXNO;
bD13flags.bits.dma_disable = 1;
bD13flags.bits.dma_state = DMA_RUNNING;
dma_start(&ioRequest);
Hal4D13_SetDMACounter(ioRequest.uSize);
if(ioRequest.bCommand & 0x1)
{//IN
ENDPINDEXNO = 0x50;
}
else
{// out
ENDPINDEXNO = 0x40;
}
Hal4D13_SetDMAConfig(D13REG_DMACNFG_COUNTER_EN|\
D13REG_DMACNFG_BURSTLEN8|\
D13REG_DMACNFG_ENABLE|\
ENDPINDEXNO);
Hal4D13_SetIntEnable(D13REG_INTSRC_EP0OUT\
|D13REG_INTSRC_EP0IN\
|D13REG_INTSRC_BUSRESET\
|D13REG_INTSRC_EOT);
DMASTART = 1;
}
void setup_io(void)
{
ioSize = ioRequest.uSize;
ioCount = 0;
//Jan16, for OHCI, validate buffer
outportb(0x1, 0x65);
outportb(0x1, 0x65);
bD13flags.bits.dma_state = DMA_RUNNING;
if(ioRequest.bCommand & 0x1)
{
if(ioSize >= 64)
ioCount += Hal4D13_WriteEndpoint(EPINDEX4EP04, IntRAMBuf, 64);
else
ioCount += Hal4D13_WriteEndpoint(EPINDEX4EP04, IntRAMBuf, ioSize);
}
// Chap9_SingleTransmitEP0(0,0);
}
//march1
void EnableDMA4ISO()
{
ULONG l;
UCHAR IsoMode = 0;
Chap9_SingleTransmitEP0(0, 0);
if( ControlData.DeviceRequest.wLength == 0)
{
IsoMode &= ~ControlData.DeviceRequest.wIndex;
IsoMode |= ControlData.DeviceRequest.wValue;
ioRequest.bCommand = IsoMode; // in or out only, not support ISOloop
/*
if(IsoMode&ISO_LOOP) //isoloop by PIO only, NO ISPLOOP cmd
{
RaiseIRQL();
ISOLOOP(EPINDEX4EP05, EPINDEX4EP06, 64);
LowerIRQL();
}
else //iso in/out by DMA
*/
{
ioRequest.uSize = 0x03E8; //1000byte, 16x8=128B, ; 0x3e8 for1000 for iso buffer
ioRequest.uAddressL = 0x0;
ioRequest.bAddressH = 0x0;
Hal4D13_SetDMACounter(0x03E8);
RaiseIRQL();
if(IsoMode&ISO_OUT)
{
Hal4D13_SetDMAConfig(D13REG_DMACNFG_COUNTER_EN\
|D13REG_DMACNFG_BURSTLEN8\
|D13REG_DMACNFG_ENABLE\
|0x60);
}
if(IsoMode&ISO_IN)
{
Hal4D13_SetDMAConfig(D13REG_DMACNFG_COUNTER_EN\
|D13REG_DMACNFG_BURSTLEN8\
|D13REG_DMACNFG_ENABLE\
|0x70);
}
dma_start4iso(&ioRequest);
Hal4D13_SetIntEnable(D13REG_INTSRC_EP0OUT\
|D13REG_INTSRC_EP0IN\
|D13REG_INTSRC_BUSRESET\
|D13REG_INTSRC_EOT);
DMASTART = 1; //Start CPLD-DMA
while(DMAINTRANSFER==1);
DMASTART = 0;
LowerIRQL();
}
}
else
Chap9_StallEP0();
}
void ISOLOOP(UCHAR bOUTEPIndex, UCHAR bINEPIndex, USHORT len)
{
Hal4D13_GetEndpointStatusWInteruptClear(bOUTEPIndex);
Hal4D13_ReadEndpoint(bOUTEPIndex, IntRAMBuf, 64);
Hal4D13_WriteEndpoint(bINEPIndex, IntRAMBuf, 64);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -