GPIO Interrupt Handler not getting called - DM365

/******************************************************************************
 * This file creates a char device and registers the interrupt for the soft shutdown 
 * interrupt. Iterrupt handler sends asynchronous notification to
 * the user space application.
 * 
 * Device :-> /dev/pwrdn_int
 * Major Number :-> Dynamically allocated by the kernel
 * Minor Number :-> 0
 * Version : 1.0
 ******************************************************************************/

/* Include linux kernel header files */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <asm/arch/hardware.h>
#include <asm/gpio.h>
#include <linux/interrupt.h>
#include <asm/irq.h>

/* Include local header file */
#include "pwrdn_int.h"

MODULE_LICENSE("GPL"); 

/* declare location variables */
static dev_t dev;  
static struct cdev *pwrdn_int_cdev;
/* local functions */
static int pwrdn_int_open (struct inode *inode, struct file *filp);
static int pwrdn_int_release (struct inode *inode, struct file *filp);
static int pwrdn_int_fasync(int fd, struct file *filp, int on);
int pwrdn_int_init_module(void);
void pwrdn_int_cleanup_module(void);
struct class *hhtp_class; /* Tie with the device model */
static struct fasync_struct *pwrdn_int_async_queue;

/* declare file operation structure */
static struct file_operations pwrdn_int_fops = {
    .owner = THIS_MODULE,
    .open  = pwrdn_int_open,
    .release = pwrdn_int_release,
	.fasync	= pwrdn_int_fasync,
};

/*Interrupt Handler */
static irqreturn_t hhtint_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	printk("\n pwrdn_interrupt raised\n");
	kill_fasync(&pwrdn_int_async_queue, SIGIO, POLL_IN);
	return IRQ_HANDLED;
}

/***************************************************************************
 * Function             - gpio_request_irq
 * Functionality        - Registers Handlers to the IRQ's of GPIO's by request_irq
 * Input Params - 
 * Return Value - None
 * Note                 - None
 ****************************************************************************/
void gpio_request_irq(int irq_num)
{
	int status = 0;

	status = request_irq(irq_num, hhtint_interrupt,SA_INTERRUPT,"pwrdn_int", NULL);

	printk(KERN_WARNING "gpio_request_irq %d status %d\n",
			   irq_num, status);

	if (status == -EINVAL) {
		printk("<1> EINVAL \n");
		} 
	else if (status == -ENOMEM) {
		printk("<1> ENOMEM ");
		} 		
		
	if (status < 0) {
		printk("<1> gpio_request_irq : Failed to Register IRQ %d  \n",
		       irq_num);
		printk("<1> gpio_request_irq : return status is %d  \n",
		       status);
	}

}

/***************************************************************************
 * Function             - gpio_unrequest_irq
 * Functionality        - Free Handlers o the IRQ's of GPIO's
 * Input Params - 
 * Return Value - None
 * Note                 - None
 ****************************************************************************/
void gpio_unrequest_irq(int irq_num)
{
	free_irq(irq_num, NULL);
	printk("<1> gpio_unrequest_irq :  Freeing IRQ %d  \n", irq_num);

}
/****************************************************************************/


static int pwrdn_int_fasync(int fd, struct file *filp, int on)
{
	int temp;
//	return fasync_helper(fd, filp, on, &pwrdn_int_async_queue);
	temp = fasync_helper(fd, filp, on, &pwrdn_int_async_queue);
	if (fd != -1)
		kill_fasync(&pwrdn_int_async_queue, SIGIO, POLL_IN);
	return(temp);
}

/******************************************************************************
 * pwrdn_int_open - do nothing 
 *****************************************************************************/
void hhtp_gpio_init(void)
{
	unsigned int control;

	/*control=WRI_REG(PINMUX3);
	control &=0xf07fffe0; // 23-27=0 > GIO8 to 11 
	WRI_REG(PINMUX3)= control;

	gpio_direction_input(KPD_R4);*/
	gpio_direction_input(PUSH_INT);
	/* Rows: inputs */
	//gpio_direction_output(KPD_C0,0);
	//gpio_direction_output(KPD_C1,0);
	//gpio_direction_output(KPD_C2,0);
	//gpio_direction_output(KPD_C3,0);

	control=WRI_REG(SET_FAL_TRIG01);
	control |= 0x00000001;	// 
	WRI_REG(SET_FAL_TRIG01)=control;

	control=WRI_REG(CLR_FAL_TRIG01);
	control |= 0x00000001;	// 
	WRI_REG(SET_FAL_TRIG01)=control;

	control=WRI_REG(DIR01);
	//control &= 0xfffff0ff; // set columns as GIO[11:8] OUTPUT = 0
	control |= 0x00000001; // set rows as GIO[30:26] INPUT = 1
	WRI_REG(DIR01)=control;

	control=WRI_REG(GPIO_BINTEN);
	control |= 0x00000001;	// Bank 1 interrupt enabled
	WRI_REG(GPIO_BINTEN)=control;

	//control = WRI_REG(OUT_DATA01);	//initialize rows
	//control &= 0xfffff0ff;		// GIO 26 - 30 => 0
	//WRI_REG(OUT_DATA01) = control;	// Output all rows and wait for interrupt

	gpio_request_irq(gpio_to_irq(PUSH_INT));
}

/******************************************************************************
 * pwrdn_int_open - do nothing 
 *****************************************************************************/
static int pwrdn_int_open (struct inode *inode, struct file *filp)
{
    return 0;
}    

/******************************************************************************
 * pwrdn_int_release - do nothing 
 *****************************************************************************/
static int pwrdn_int_release (struct inode *inode, struct file *filp)
{
	if (filp->f_flags & FASYNC) {
		pwrdn_int_fasync (-1, filp, 0);
	}
	return 0;
} 

/*****************************************************************************
 * pwrdn_int_init_module - initialise user gpio module
 ****************************************************************************/
int pwrdn_int_init_module ()
{
//alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)
    if (alloc_chrdev_region(&dev, 0, 1, "pwrdn_int") < 0) {
        printk(KERN_WARNING "Failed to register the device\n");
        return 1;
    }

	hhtp_class = class_create(THIS_MODULE, "pwrdn_int");

    pwrdn_int_cdev = cdev_alloc();
    if (pwrdn_int_cdev == NULL) {
        printk(KERN_WARNING "Failed to allocate cdev\n");
        return 1;
    }

    cdev_init(pwrdn_int_cdev, &pwrdn_int_fops);
    if (cdev_add(pwrdn_int_cdev, dev, 1) < 0) {
        printk(KERN_WARNING "Failed to add cdev\n");
        return 1;
    }

	class_device_create(hhtp_class, NULL, dev, NULL, "pwrdn_int", 0);

    hhtp_gpio_init();
    return 0;
}

/*****************************************************************************
 * pwrdn_int_init_cleanup - cleanup user gpio module
 ****************************************************************************/
void pwrdn_int_cleanup_module ()
{
    cdev_del(pwrdn_int_cdev);
    unregister_chrdev_region(dev, 1);
	class_device_destroy(hhtp_class, MKDEV(MAJOR(dev), 0));
	class_destroy(hhtp_class);
	gpio_unrequest_irq(gpio_to_irq(PUSH_INT));
}

module_init(pwrdn_int_init_module);
module_exit(pwrdn_int_cleanup_module);