MicroBlaze Interrupt Handler Not Called - c++

Question

I want to capture mouse movement packets in an embedded system receiving packets of data from an input mouse (initialized in ps/2 mode). How do I get my exception handler to get called? The interrupt handler is never triggered. I set up my processor to run with external interrupts and connected only one signal to the processor's interrupt input port, and I do not use an interrupt controller. To capture input movements, I use a software based circular buffer.
Please help.
#include "xparameters.h"
#include "xil_exception.h"
#include "ps2_core.h"
Ps2Core::Ps2Core(uint32_t core_base_addr) {
base_addr = core_base_addr;
registerCallback();
}
Ps2Core::~Ps2Core() {
}
void Ps2Core::enqueue(unsigned char value) {
if ((tail + 1) % QUEUE_SIZE == head) {
// queue is full, do nothing
return;
}
queue[tail] = value;
queueCount++;
tail = (tail + 1) % QUEUE_SIZE;
}
unsigned char Ps2Core::dequeue(void) {
if (head == tail) {
// queue is empty, do nothing
return 0;
}
unsigned char value = queue[head];
queueCount--;
head = (head + 1) % QUEUE_SIZE;
return value;
}
void Ps2Core::handleInterrupt(Ps2Core *ps2) {
uint8_t byte;
byte = ps2->rx_byte();
ps2->enqueue(byte);
}
void Ps2Core::registerCallback(){
Xil_ExceptionInit();
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
(Xil_ExceptionHandler)handleInterrupt,
this);
Xil_ExceptionEnable();
}
int Ps2Core::get_mouse_activity(int *lbtn, int *rbtn, int *xmov,
int *ymov, int *zmov) {
uint8_t b1, b2, b3, b4;
uint32_t tmp;
/* retrieve bytes only if 4 or a multiple of 4 exist in queue */
if (queueCount >= 4) {
b1 = dequeue();
b2 = dequeue();
b3 = dequeue();
b4 = dequeue();
}
else
return (0);
/* extract button info */
*lbtn = (int) (b1 & 0x01); // extract bit 0
*rbtn = (int) (b1 & 0x02) >> 1; // extract bit 1
/* extract x movement; manually convert 9-bit 2's comp to int */
tmp = (uint32_t) b2;
if (b1 & 0x10) // check MSB (sign bit) of x movement
tmp = tmp | 0xffffff00; // manual sign-extension if negative
*xmov = (int) tmp; // data conversion
/* extract y movement; manually convert 9-bit 2's comp to int */
tmp = (uint32_t) b3;
if (b1 & 0x20) // check MSB (sign bit) of y movement
tmp = tmp | 0xffffff00; // manual sign-extension if negative
*ymov = (int) tmp; // data conversion
tmp = (uint32_t) b4;
if (b4 & 0x08) // check MSB (sign bit) of z movement
tmp = tmp | 0xfffffff0; // manual sign-extension if negative
*zmov = (int) tmp; // data conversion
/* success */
return (1);
}
Module Instances
//instantiate uBlaze MCS
cpu cpu_unit (
.Clk(clk_100M),
.Reset(reset),
.IO_addr_strobe(io_addr_strobe),
.IO_address(io_address),
.IO_byte_enable(io_byte_enable),
.IO_read_data(io_read_data),
.IO_read_strobe(io_read_strobe),
.IO_ready(io_ready),
.IO_write_data(io_write_data),
.IO_write_strobe(io_write_strobe),
.INTC_Interrupt(interrupt)
);
// instantiated i/o subsystem
mmio_sys_sampler_arty_a7 mmio_unit (
.clk(clk_100M),
.reset(reset),
.mmio_cs(fp_mmio_cs),
.mmio_wr(fp_wr),
.mmio_rd(fp_rd),
.mmio_addr(fp_addr),
.mmio_wr_data(fp_wr_data),
.mmio_rd_data(fp_rd_data),
.rx_done_tick(interrupt),
.ps2d_in(ps2d_in),
.ps2c_in(ps2c_in),
.tri_c(tri_c),
.tri_d(tri_d),
.ps2c_out(ps2c_out),
.ps2d_out(ps2d_out),
.rx(rx),
.tx(tx)
);
EDIT - Latest Code (Interrupt not triggered, but interrupt signal generated on each byte received, verified by visual output on oscilloscope)
#define INTERRUPT_ID 16U //if != 16U then MICROBLAZE_EXCEPTIONS_ENABLED must be defined
// Define the address of the interrupt control register for the MicroBlaze processor
#define INTERRUPT_CONTROL_REG XPAR_IOMODULE_0_IO_BASEADDR + XIN_ISR_OFFSET
void Ps2Core::handleInterrupt(Ps2Core *ps2) {
uint8_t byte;
byte = ps2->rx_byte();
ps2->enqueue(byte);
}
void Ps2Core::clearInterrupt(unsigned int interruptID) {
// Clear the interrupt flag by writing a 1 to the appropriate bit in the ISR
*(volatile unsigned int*)(INTERRUPT_CONTROL_REG) = (1 << interruptID);
}
void Ps2Core::checkInterruptStatus(Ps2Core *ps2) {
/* Read the status of the interrupt */
u32 IntrStatus = XIOModule_DiscreteRead(&ps2->intr, INTERRUPT_CONTROL_REG);
if (IntrStatus) {
Ps2Core::handleInterrupt(ps2);
Ps2Core::clearInterrupt(INTERRUPT_ID);
}
}
void Ps2Core::setUpInterrupt(){
Xil_ExceptionInit();
// Register the interrupt handler function with the microblaze processor
//microblaze_register_handler((XInterruptHandler)checkInterruptStatus, this);
// Register interrupt handler function
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)checkInterruptStatus, this);
}

Answer 1

Judging by the port names, it looks like you have an interrupt controller in your 'cpu' module. But I don't see any code configuring that--instead it's connecting directly to the MicroBlaze CPU's exception handler. Xilinx's driver for the interrupt controller should be attaching itself to the exception handler and your code should be connecting to it via register_int_handler / enable_interrupt.