AM335X ADC LINUX 驱动无法进中断问题

static irqreturn_t adc_interrupt(int irq, void *dev)
{
 unsigned int status, irqclr = 0;
 int i;
 int fifo0count = 0;
 unsigned int readx1 = 0;

 printk("adc_interrupt enter, ev_adc %d...\n", ev_adc);

 if (!ev_adc)
 {
 status = am335x_adc_readl(adc_dev, TSCADC_REG_IRQSTATUS);

 printk("adc_interrupt status %d...\n", status);

 if (status & TSCADC_IRQENB_FIFO0THRES)
 {
 fifo0count = am335x_adc_readl(adc_dev, TSCADC_REG_FIFO0CNT);
 printk("ADC_Interrupt FIFO0_Count %d...\n", fifo0count);

 for (i = 0; i < fifo0count; i++)
 {
 readx1 = am335x_adc_readl(adc_dev, TSCADC_REG_FIFO0);
 printk("FIFO0_count %d : %d\n", i, readx1);
 adc_data += readx1;

 }

 if (fifo0count) 
 {
 adc_data = adc_data / fifo0count;
 }
 printk("ADC_DATA: %d \n", adc_data);

 irqclr |= TSCADC_IRQENB_FIFO0THRES;
 }

 am335x_stop_adc(adc_dev);
 am335x_adc_writel(adc_dev, TSCADC_REG_IRQSTATUS, irqclr); //clear TSCADC_IRQENB_FIFO0THRES irq
 am335x_adc_writel(adc_dev, TSCADC_REG_IRQEOI, 0x0); // check pending interrupts
 am335x_adc_writel(adc_dev, TSCADC_REG_SE, ADC_STPENB_STEPENB);
 ev_adc = 1;
 wake_up_interruptible(&adc_waitq);
 }

 return IRQ_HANDLED;

}



static unsigned int am335x_adc_readl(struct adc_st *adc, unsigned int reg)
{
 return readl(adc->adc_base + reg);
}

static void am335x_adc_writel(struct adc_st *adc, unsigned int reg, unsigned int val)
{
 writel(val, adc->adc_base + reg);
}

static void am335x_start_adc(struct adc_st *dev)
{
 int ctrl = 0;

 printk("Start adc channel %d\n", channel);
 //TSC_ADC_SS module enable bit.
 //After programming all the steps and configuration registers, write a
 //1 to this bit to turn on TSC_ADC_SS.
 //Writing a 0 will disable the module (after the current conversion)
 ctrl |= TSCADC_CNTRLREG_STEPCONFIGWRT | TSCADC_CNTRLREG_TSCSSENB;

 am335x_adc_writel(dev, TSCADC_REG_CTRL, ctrl);
}

static void am335x_stop_adc(struct adc_st *dev)
{
 int ctrl = 0;

 printk("Stop adc channel %d\n", channel);
 //TSC_ADC_SS module enable bit.
 //After programming all the steps and configuration registers, write a
 //1 to this bit to turn on TSC_ADC_SS.
 //Writing a 0 will disable the module (after the current conversion)
 ctrl |= TSCADC_CNTRLREG_STEPCONFIGWRT;

 am335x_adc_writel(dev, TSCADC_REG_CTRL, ctrl);

}



static void am335x_adc_step_config(struct adc_st *adc_dev)
{
 unsigned int step_config = 0;
 unsigned int delay = 0;
 int i;

 /* Configure the Step registers */
 step_config = TSCADC_STEPCONFIG_REFP | TSCADC_STEPCONFIG_RFM | TSCADC_STEPCONFIG_SINGLE_ENDED_OPER_MODE | TSCADC_STEPCONFIG_MODE;

 switch (channel)
 {
 case 0:
 step_config |= TSCADC_STEPCONFIG_1_INP;
 break;
 case 1:
 step_config |= TSCADC_STEPCONFIG_2_INP;
 break;
 case 2:
 step_config |= TSCADC_STEPCONFIG_3_INP;
 break;
 case 3:
 step_config |= TSCADC_STEPCONFIG_4_INP;
 break;
 case 4:
 step_config |= TSCADC_STEPCONFIG_5_INP;
 break;
 case 5:
 step_config |= TSCADC_STEPCONFIG_6_INP;
 break;
 case 6:
 step_config |= TSCADC_STEPCONFIG_7_INP;
 break;
 case 7:
 step_config |= TSCADC_STEPCONFIG_8_INP;
 break;
 default:
 channel = 4;
 step_config |= TSCADC_STEPCONFIG_5_INP; //default for channel 4
 printk("Input wrong! Channel number should be [0..7]\n");
 break;

 }

 printk("Choose ADC channel %d\n", channel);

 for (i = 1; i < 9; i++)
 {
 am335x_adc_writel(adc_dev, TSCADC_REG_STEPCONFIG(i), step_config);
 }

 delay = TSCADC_STEPCONFIG_SAMPLEDLY | TSCADC_STEPCONFIG_OPENDLY;

 for (i = 1; i < 9; i++)
 {
 am335x_adc_writel(adc_dev, TSCADC_REG_STEPDELAY(i), delay);
 }

 am335x_adc_writel(adc_dev, TSCADC_REG_SE, ADC_STPENB_STEPENB);

 // steven:this affect which step configs can be used!!! Important!!!
}

static void am335x_adc_idle_config(struct adc_st *adc_config)
{
 /* Idle mode adc screen config */
 unsigned int idle_config = 0;

 am335x_adc_writel(adc_config, TSCADC_REG_IDLECONFIG, idle_config);
}

static int am335x_adc_open(struct inode *inode, struct file *file)
{
 int err;
 int clk_value;
 int clock_rate, ctrl;
// struct resource *res;
 struct clk *clk;
 dev_t devno;
// int ret;

 printk("Going to open ADC\n");

 /* Allocate memory for device */
 adc_dev = kzalloc(sizeof(struct adc_st), GFP_KERNEL);
 if (!adc_dev)
 {
 printk("failed to allocate memory.\n");
 return -ENOMEM;
 }



 adc_dev->adc_base = ioremap(AM335X_ADC_BASE_ADDR, 0x1000);

 if (!adc_dev->adc_base)
 {
 printk("failed to map register memery.\n");
 err = -ENOMEM;
 goto err_release_mem;
 }
 printk("map register memery\n");
 //AM33XX_IRQ_ADC_GEN
 err = request_irq(16, adc_interrupt, IRQF_DISABLED, ADC_MOUDLE_NAME, adc_dev);

 if (err)
 {
 printk("Request adc irq failed\n");
 return err;
 }
 printk("irq request success, err = %x\n", err);

 clk = clk_get(NULL, "adc_tsc_fck");

 if (IS_ERR(clk))
 {
 printk("failed to get TSC fck\n");
 err = PTR_ERR(clk);
 goto err_free_irq;
 }
 printk("get clk success\n");
 clock_rate = clk_get_rate(clk);
 printk("get clock_rate success, clock_rate = %d\n", clock_rate);
 clk_value = clock_rate / ADC_CLK;
 if (clk_value < 7)
 {
 printk("clock input less than min clock requirement\n");
 err = -EINVAL;
 goto err_fail;
 }
 printk("get clk_value success, clk_value = %d\n", clk_value);
 /* TSCADC_CLKDIV needs to be configured to the value minus 1 */
 clk_value = clk_value - 1;
 am335x_adc_writel(adc_dev, TSCADC_REG_CLKDIV, clk_value);


 /* Set the control register bits */
 ctrl = TSCADC_CNTRLREG_STEPCONFIGWRT | TSCADC_CNTRLREG_TSCENB;

 am335x_adc_writel(adc_dev, TSCADC_REG_CTRL, ctrl);

 /* Set register bits for Idel Config Mode */
 am335x_adc_idle_config(adc_dev);
 am335x_adc_step_config(adc_dev);

 /* IRQ Enable */
 am335x_adc_writel(adc_dev, TSCADC_REG_IRQENABLE, TSCADC_IRQENB_FIFO0THRES);
 am335x_adc_writel(adc_dev, TSCADC_REG_FIFO0THR, 7); //FIFO THRESHOLD SET 0-7

// device_init_wakeup(&pdev->dev, true);
 printk("adc initialized!\n");

err_release_mem:
iounmap(adc_dev->adc_base);
err_free_irq:
free_irq(16, adc_dev); 
err_fail:

 return 0;
}

//standard read function
static ssize_t am335x_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
 printk("ADC channel:%d working, reading adc data\n", channel);

 if (!ev_adc)
 {
 if (filp->f_flags & O_NONBLOCK)
 {
 return -EAGAIN;
 } else
 {
 am335x_start_adc(adc_dev);

 wait_event_interruptible(adc_waitq, ev_adc);
 }
 }

 ev_adc = 0;

 copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data));

 adc_data = 0;

 return sizeof(adc_data);
}


static int am335x_adc_close (struct inode *inode, struct file *file)
{
 printk("close adc \n\r");

 free_irq(16, adc_dev);
 iounmap(adc_dev->adc_base);

 kfifo_free(ptrFifoMsgTx);
 kfifo_free(ptrFifoMsgRx);

 MOD_DEC_USE_COUNT;

 return 0;
}


static int am335x_adc_release(struct inode *inode, struct file *filp)
{

 return 0;
}

long am335x_adc_ioctl(struct file *file, unsigned int ioctl_num, unsigned long ioctl_param)
{
 return 0;
}



static struct file_operations am335x_adc_fops =
{
 .owner = THIS_MODULE,
 .open = am335x_adc_open,
 .close = am335x_adc_close,
 .read = am335x_adc_read,
 .release = am335x_adc_release,
 .unlocked_ioctl = am335x_adc_ioctl,
};

static int am335x_adc_setup_cdev(struct adc_st *dev, int index)
{
 int err, devno = MKDEV(adc_major, index);
 cdev_init(&dev->adc, &am335x_adc_fops);
 dev->adc.owner = THIS_MODULE;
 err = cdev_add(&dev->adc, devno, 1);
 if (err)
 {
 printk("no memory resource defined.\n");
 return err;
 }
}


static int __init am335x_adc_init(void)
{
 int ret;

 /* Fill in date and time into the module info. */
 if ((ret = register_chrdev(ADC_MAJOR_NUMBER, ADC_MOUDLE_NAME, &am335x_adc_fops)) < 0)
 {
 printk("am335x adc dirver register failed!\r\n");
 return ret;
 }

 printk("am335x adc dirver registed!\r\n");

 return 0;
}

module_init(am335x_adc_init);

static void __exit am335x_adc_exit(void)
{
 unregister_chrdev(ADC_MAJOR_NUMBER, ADC_MOUDLE_NAME);
 printk("am335x adc dirver unregister\r\n");
}

module_exit(am335x_adc_exit);

MODULE_DESCRIPTION("TOK ADC controller driver");
MODULE_AUTHOR("TOK");
MODULE_LICENSE("GPL");