static void init_button_pio()
{
/* initialize the push button interrupt vector */
alt_irq_register( BUTTON_PIO_IRQ, (void*) 0, BUTTON_ISR);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0x0);
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
/* Initialize Variables */
edge_capture = 0;
}
/* Initialize the button_pio. */
static void init_button_pio()
{
/* Recast the edge_capture pointer to match the
alt_irq_register() function prototype. */
void* edge_capture_ptr = (void*) &edge_capture;
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_BASE, 0xf);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_BASE, 0x0);
/* Register the ISR. */
alt_ic_isr_register(BUTTON_IRQ_INTERRUPT_CONTROLLER_ID,
BUTTON_IRQ,
handle_button_interrupt,
edge_capture_ptr, 0x0);
}
/* The main function creates the LCD task, registers the edge counter polling interrupt,
* and starts the OS. */
int main(void)
{
int status;
// Initialize components.
lcd_init();
queue_init();
// Create the LCD task.
// OSTaskCreateExt(lcd_task,
// NULL,
// (void *)&lcd_task_stk[TASK_STACKSIZE - 1],
// LCD_TASK_PRIORITY,
// LCD_TASK_PRIORITY,
// lcd_task_stk,
// TASK_STACKSIZE,
// NULL,
// 0);
// Create the IR task.
OSTaskCreateExt(ir_task,
NULL,
(void *)&ir_task_stk[TASK_STACKSIZE - 1],
IR_TASK_PRIORITY,
IR_TASK_PRIORITY,
ir_task_stk,
TASK_STACKSIZE,
NULL,
0);
// Register the IR pushbutton interrupt.
status = alt_ic_isr_register(IR_PUSHBUTTON_IRQ_INTERRUPT_CONTROLLER_ID,
IR_PUSHBUTTON_IRQ,
isr_on_ir_pushbutton,
NULL,
NULL);
// Enable key interrupts.
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(IR_PUSHBUTTON_BASE, IR_PUSHBUTTON_CAPTURE);
// Start.
if (status == OK) {
OSStart();
}
return 0;
}
void EnableKeyInterrupt(void){
int error;
// enable interrupt, 2-keybutton
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY_BASE,0x03);
// clear capture flag
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY_BASE,0);
//
bKeyPressed = FALSE;
// register interrupt isr
error = alt_irq_register (KEY_IRQ, 0, KEY_ISR);
if (error)
printf("Failed to register interrut\r\n");
}
static void init_button_pio()
{
/* Recast the edge_capture pointer to match the alt_irq_register() function
* prototype. */
void* edge_capture_ptr = (void*) &edge_capture;
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0x0);
#ifdef ALT_ENHANCED_INTERRUPT_API_PRESENT
alt_ic_isr_register(BUTTON_PIO_IRQ_INTERRUPT_CONTROLLER_ID, BUTTON_PIO_IRQ,
handle_button_interrupts, edge_capture_ptr, 0x0);
#else
alt_irq_register( BUTTON_PIO_IRQ, edge_capture_ptr,
handle_button_interrupts);
#endif
}
/*
* === FUNCTION ======================================================================
* Name: initialize_usb
* Description:
* =====================================================================================
*/
int initialize_usb(void)
{
PIO_USB_RD=1;
PIO_USB_WR=1;
PIO_USB_A0=1;
usb.receive_ok_flag=0;
// enable the io interrupt
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(USB_NINT_BASE,1);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(USB_NINT_BASE,0);
alt_irq_register(USB_NINT_IRQ,NULL,irq_usb);
set_usb_mode(USB_DEVICE);
return 0;
}
/* The main function creates two task and starts multi-tasking */
int main(void) {
OSInit();
// Create the message queue to hold incoming MIDI msg
qsemMsg = OSQCreate((void*)&qMessages, QMESSAGE_SIZE);
songSem = OSSemCreate(0);
lcd = fopen("/dev/char_lcd", "w");
//Task for decoding MIDI messages.
OSTaskCreateExt(midiDecode,
NULL,
(void *)&midi_stk[TASK_STACKSIZE-1],
MIDI_PRIORITY,
MIDI_PRIORITY,
midi_stk,
TASK_STACKSIZE,
NULL,
0);
serial_init(31250);
/* Enable all 8 switch interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCHES_BASE, 0xff);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCHES_BASE, 0x0);
/* Register the interrupt handler. */
alt_irq_register(SWITCHES_IRQ, 0, switches_isr);
alt_irq_enable(SWITCHES_IRQ);
OSTaskCreateExt(playSong,
NULL,
(void *)&song_stk[TASK_STACKSIZE-1],
SONG_PRIORITY,
SONG_PRIORITY,
song_stk,
TASK_STACKSIZE,
NULL,
0);
OSStart();
return 0;
}
/*System initialization function. Should be called before your while(1)*/
void system_initialization(){
/*Hard-code to 1 right here, you can use ISR
*to change the value by yourself
*/
uartStartRecvFlag = 1;
/*Open Uart port and ready to transmit and receive*/
uart = open(UART_NAME, O_ACCMODE);
if(!uart){
printf("failed to open uart\n");
//return 0;
} else {
printf("Uart ready!\n");
}
//Interrupts Registrations
alt_irq_register(switch0_id, (void *)&switch0, handle_switch0_interrupt);
alt_irq_register(switch1_id, (void *)&switch1, handle_switch1_interrupt);
alt_irq_register(switch2_id, (void *)&switch2, handle_switch2_interrupt);
alt_irq_register(switch3_id, (void *)&switch3, handle_switch3_interrupt);
alt_irq_register(switch4_id, (void *)&switch4, handle_switch4_interrupt);
alt_irq_register(switch5_id, (void *)&switch5, handle_switch5_interrupt);
alt_irq_register(key0_id, (void *)&key0, handle_key0_interrupt);
alt_irq_register(key1_id, (void *)&key1, handle_key1_interrupt);
alt_irq_register(key2_id, (void *)&key2, handle_key2_interrupt);
alt_irq_register(key3_id, (void *)&key3, handle_key3_interrupt);
alt_irq_register(leftready_id, (void *)&leftready, handle_leftready_interrupt_test);
alt_irq_register(rightready_id, (void *)&rightready, handle_rightready_interrupt_test);
/*Interrupt enable -> mask to enable it*/
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH0_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH1_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH2_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH3_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH4_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH5_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY0_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY1_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY2_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY3_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(LEFTREADY_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(RIGHTREADY_BASE, 1);
/*Reset edge capture bit*/
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH0_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH1_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH2_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH3_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH4_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH5_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY0_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY1_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY2_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY3_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(LEFTREADY_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(RIGHTREADY_BASE, 0);
/*turn off all LEDs*/
IOWR_ALTERA_AVALON_PIO_DATA(LED_BASE, 0x00);
/*initialize SPI transmission*/
IOWR_ALTERA_AVALON_PIO_DATA(CS_BASE, 1); // ~CS low
IOWR_ALTERA_AVALON_PIO_DATA(SCLK_BASE, 0); // Initialize SCLK to high
}
int main()
{
bool bRxVideoOn = FALSE, bTxSinkOn = FALSE, bRxModeChanged = FALSE;
alt_u8 led_mask;
alt_u32 BlinkTime;
bool bHwNg = FALSE;
// disable color depth if button1 is pressed when system boot.
gEnableColorDepth = ((~IORD(PIO_BUTTON_BASE,0)) & 0x02)?0:1;
OS_PRINTF("\n======== HDMI Demo REMIX by gh00st==============\n");
//-------------------------------
// HDMI TX init
//-------------------------------
#ifndef TX_DISABLED
if (!HDMITX_Init()) {
printf("Failed to find CAT6613 HDMI-TX Chip.\n");
bHwNg = TRUE;
//return 0;
}
// init tx i2s irq
THDMI_TX_I2S_Start();
IOWR(I2S_TX_BASE, I2S_REG_IRQ_CLEAR, 0x00); //clear interrupt flag
// hdmi i2s irq
if ((alt_irq_register(I2S_TX_IRQ, (void *)0, i2s_isr) != 0))
OS_PRINTF("[I2S]register callback fail\n");
else
OS_PRINTF("[I2S]register callback success\n");
//
// button irq for generate audio
// enable interrupt, button0/1
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(PIO_BUTTON_BASE, 0x03);
// Reset the edge capture register
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(PIO_BUTTON_BASE,0);
if ((alt_irq_register(PIO_BUTTON_IRQ, (void *)0, button_isr) != 0))
OS_PRINTF("[I2S]register button callback fail\n");
else
OS_PRINTF("[I2S]register button callback success\n");
//
#endif //TX_DISABLED
//-------------------------------
// HDMI RX init
//-------------------------------
#ifndef RX_DISABLED
IOWR(HDMI_RX_HPD_N_BASE, 0, 0x03); // pull-low hdmi connector hpd
OS_DelayMS(1); // 1 ms
if (!HDMIRX_Init(RX_PORT_AUTO))
bHwNg = TRUE;
IOWR(HDMI_RX_HPD_N_BASE, 0, 0x00); // pull-high hdmi connector hpd
#endif //RX_ENABLED
// gh00st
SelectHDMIPort(CAT_HDMI_PORTA);
InitIT6605();
//HDMIRX_DevLoopProc();
SelectHDMIPort(CAT_HDMI_PORTB);
InitIT6605();
//HDMIRX_DevLoopProc();
//
IOWR(HDMI_RX_SYNC_BASE, 0,0x00);
led_mask = ~0x01;
IOWR(PIO_LED_BASE, 0, led_mask);
BlinkTime = alt_nticks() + alt_ticks_per_second()/4;
if (bHwNg) {
led_mask = 0x00;
while(1) {
if (alt_nticks() > BlinkTime) {
IOWR(PIO_LED_BASE, 0, led_mask);
led_mask ^= 0xFF;
BlinkTime = alt_nticks() + alt_ticks_per_second()/4;
}
}
}
//-------------------------------
// MAIN LOOP
//-------------------------------
while(1) {
#ifndef TX_DISABLED
//========== TX
if (HDMITX_DevLoopProc() || bRxModeChanged) {
bTxSinkOn = HDMITX_HPD();
if (bTxSinkOn) {
// update state
gDemoMode = bRxVideoOn?DEMO_LOOPBACK: DEMO_TX_ONLY;
//
HDMITX_DisableVideoOutput();
if (gDemoMode == DEMO_TX_ONLY) {
// tx-only
VPG_Config(gVpgMode, gVpgColor);
SetupTxVIC(gVpgMode);
}
SetupColorSpace();
HDMITX_EnableVideoOutput();
} else {
HDMITX_DisableVideoOutput();
}
}
#endif //
#ifndef RX_DISABLED
//========== RX
bRxModeChanged = HDMIRX_DevLoopProc();
if (HDMIRX_IsVideoOn() ^ bRxVideoOn) {
bRxVideoOn = HDMIRX_IsVideoOn();
IOWR(HDMI_RX_SYNC_BASE, 0, bRxVideoOn?0x01:0x00);
OS_PRINTF("[RX]Video On:%s\n", bRxVideoOn?"Yes":"No");
// update state
gDemoMode = !bTxSinkOn?DEMO_READY:(bRxVideoOn?DEMO_LOOPBACK:DEMO_TX_ONLY);
}
if (bRxModeChanged && bRxVideoOn) {
OS_PRINTF("XXXXXX \n");
#ifndef TX_DISABLED
// bypass AviInfoFrame from source to sink
alt_u8 VIC, ColorMode;
bool b16x9, bITU709;
if (HDMIRX_GetAVIInfoFrame(&VIC, &ColorMode, &b16x9, &bITU709)) {
OS_PRINTF("YYYYYYY \n");
HDMITX_ChangeVideoTimingAndColor(VIC, ColorMode);
}
//SetupColorSpace();
#endif
}
#endif //RX_ENABLED
//===== LED indication
if (alt_nticks() > BlinkTime) {
led_mask ^= 0x03;
led_mask |= ~0x03;
if (HDMITX_HPD())
led_mask &= ~0x04; // rx-source available (led is low-active)
if (bRxVideoOn)
led_mask &= ~0x08; // rx-source available (led is low-active)
IOWR(PIO_LED_BASE, 0, led_mask);
//led_mask ^= 0xFF;
BlinkTime = alt_nticks() + alt_ticks_per_second()/4;
}
#if 0 // (DEBUG Purpose) dump register if button is pressed
alt_u8 mask;
mask = (~IORD(PIO_BUTTON_BASE,0)) & 0x03; // active low (PCI)
if ((mask & 0x01) == 0x01) { // BUTTON[0]
HDMITX_DumpAllReg();
HDMIRX_DumpAllReg();
}
#endif
}
}
