arch/arm/mach-msm/dfe-fsm9xxx.c - fp2-dev/kernel/msm - Gitiles

 /* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/miscdevice.h>
 #include <linux/spinlock.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <mach/msm_iomap.h>

 #include <linux/fsm_dfe_hh.h>

 /*
  * DFE of FSM9XXX
  */

 #define HH_ADDR_MASK			0x000ffffc
 #define HH_OFFSET_VALID(offset)		(((offset) & ~HH_ADDR_MASK) == 0)
 #define HH_REG_IOADDR(offset)		((uint8_t *) MSM_HH_BASE + (offset))
 #define HH_MAKE_OFFSET(blk, adr)	(((blk)&0x1F)<<15|((adr)&0x1FFF)<<2)

 #define HH_REG_SCPN_IREQ_MASK		HH_REG_IOADDR(HH_MAKE_OFFSET(5, 0x12))
 #define HH_REG_SCPN_IREQ_FLAG		HH_REG_IOADDR(HH_MAKE_OFFSET(5, 0x13))

 /*
  * Device private information per device node
  */

 #define HH_IRQ_FIFO_SIZE		64
 #define HH_IRQ_FIFO_EMPTY(pdev)		((pdev)->irq_fifo_head == \
 					(pdev)->irq_fifo_tail)
 #define HH_IRQ_FIFO_FULL(pdev)		((((pdev)->irq_fifo_tail + 1) % \
 					HH_IRQ_FIFO_SIZE) == \
 					(pdev)->irq_fifo_head)

 static struct hh_dev_node_info {
 	spinlock_t hh_lock;
 	char irq_fifo[HH_IRQ_FIFO_SIZE];
 	unsigned int irq_fifo_head, irq_fifo_tail;
 	wait_queue_head_t wq;
 } hh_dev_info;

 /*
  * Device private information per file
  */

 struct hh_dev_file_info {
 	/* Buffer */
 	unsigned int *parray;
 	unsigned int array_num;

 	struct dfe_command_entry *pcmd;
 	unsigned int cmd_num;
 };

 /*
  * File interface
  */

 static int hh_open(struct inode *inode, struct file *file)
 {
 	struct hh_dev_file_info *pdfi;

 	/* private data allocation */
 	pdfi = kmalloc(sizeof(*pdfi), GFP_KERNEL);
 	if (pdfi == NULL)
 		return -ENOMEM;
 	file->private_data = pdfi;

 	/* buffer initialization */
 	pdfi->parray = NULL;
 	pdfi->array_num = 0;
 	pdfi->pcmd = NULL;
 	pdfi->cmd_num = 0;

 	return 0;
 }

 static int hh_release(struct inode *inode, struct file *file)
 {
 	struct hh_dev_file_info *pdfi;

 	pdfi = (struct hh_dev_file_info *) file->private_data;

 	kfree(pdfi->parray);
 	pdfi->parray = NULL;
 	pdfi->array_num = 0;

 	kfree(pdfi->pcmd);
 	pdfi->pcmd = NULL;
 	pdfi->cmd_num = 0;

 	kfree(file->private_data);
 	file->private_data = NULL;

 	return 0;
 }

 static ssize_t hh_read(struct file *filp, char __user *buf, size_t count,
 	loff_t *f_pos)
 {
 	signed char irq = -1;
 	unsigned long irq_flags;

 	do {
 		spin_lock_irqsave(&hh_dev_info.hh_lock, irq_flags);
 		if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info)) {
 			irq = hh_dev_info.irq_fifo[hh_dev_info.irq_fifo_head];
 			if (++hh_dev_info.irq_fifo_head == HH_IRQ_FIFO_SIZE)
 				hh_dev_info.irq_fifo_head = 0;
 		}
 		spin_unlock_irqrestore(&hh_dev_info.hh_lock, irq_flags);

 		if (irq < 0)
 			if (wait_event_interruptible(hh_dev_info.wq,
 				!HH_IRQ_FIFO_EMPTY(&hh_dev_info)) < 0)
 				break;
 	} while (irq < 0);

 	if (irq < 0) {
 		/* No pending interrupt */
 		return 0;
 	} else {
 		put_user(irq, buf);
 		return 1;
 	}

 	return 0;
 }

 static ssize_t hh_write(struct file *file, const char __user *buffer,
 	size_t count, loff_t *ppos)
 {
 	return 0;
 }

 static long hh_ioctl(struct file *file,
 	unsigned int cmd, unsigned long arg)
 {
 	unsigned int __user *argp = (unsigned int __user *) arg;
 	struct hh_dev_file_info *pdfi =
 		(struct hh_dev_file_info *) file->private_data;

 	switch (cmd) {
 	case DFE_IOCTL_READ_REGISTER:
 		{
 			unsigned int offset, value;

 			if (get_user(offset, argp))
 				return -EFAULT;
 			if (!HH_OFFSET_VALID(offset))
 				return -EINVAL;
 			value = __raw_readl(HH_REG_IOADDR(offset));
 			if (put_user(value, argp))
 				return -EFAULT;
 		}
 		break;

 	case DFE_IOCTL_WRITE_REGISTER:
 		{
 			struct dfe_write_register_param param;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			if (!HH_OFFSET_VALID(param.offset))
 				return -EINVAL;
 			__raw_writel(param.value,
 				HH_REG_IOADDR(param.offset));
 		}
 		break;

 	case DFE_IOCTL_WRITE_REGISTER_WITH_MASK:
 		{
 			struct dfe_write_register_mask_param param;
 			unsigned int value;
 			unsigned long irq_flags;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			if (!HH_OFFSET_VALID(param.offset))
 				return -EINVAL;
 			spin_lock_irqsave(&hh_dev_info.hh_lock,
 				irq_flags);
 			value = __raw_readl(HH_REG_IOADDR(param.offset));
 			value &= ~param.mask;
 			value |= param.value & param.mask;
 			__raw_writel(value, HH_REG_IOADDR(param.offset));
 			spin_unlock_irqrestore(&hh_dev_info.hh_lock,
 				irq_flags);
 		}
 		break;

 	case DFE_IOCTL_READ_REGISTER_ARRAY:
 	case DFE_IOCTL_WRITE_REGISTER_ARRAY:
 		{
 			struct dfe_read_write_array_param param;
 			unsigned int req_sz;
 			unsigned long irq_flags;
 			unsigned int i;
 			void *addr;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			if (!HH_OFFSET_VALID(param.offset))
 				return -EINVAL;
 			if (param.num == 0)
 				break;
 			req_sz = sizeof(unsigned int) * param.num;

 			if (pdfi->array_num < param.num) {
 				void *pmem;

 				pmem = kmalloc(req_sz, GFP_KERNEL);
 				if (pmem == NULL)
 					return -ENOMEM;
 				pdfi->parray = (unsigned int *) pmem;
 				pdfi->array_num = param.num;
 			}

 			if (cmd == DFE_IOCTL_WRITE_REGISTER_ARRAY)
 				if (copy_from_user(pdfi->parray,
 					param.pArray, req_sz))
 					return -EFAULT;

 			addr = HH_REG_IOADDR(param.offset);

 			spin_lock_irqsave(&hh_dev_info.hh_lock,
 				irq_flags);
 			for (i = 0; i < param.num; ++i, addr += 4) {
 				if (cmd == DFE_IOCTL_READ_REGISTER_ARRAY)
 					pdfi->parray[i] = __raw_readl(addr);
 				else
 					__raw_writel(pdfi->parray[i], addr);
 			}
 			spin_unlock_irqrestore(&hh_dev_info.hh_lock,
 				irq_flags);

 			if (cmd == DFE_IOCTL_READ_REGISTER_ARRAY)
 				if (copy_to_user(pdfi->parray,
 					param.pArray, req_sz))
 					return -EFAULT;
 		}
 		break;

 	case DFE_IOCTL_COMMAND:
 		{
 			struct dfe_command_param param;
 			unsigned int req_sz;
 			unsigned long irq_flags;
 			unsigned int i, value;
 			struct dfe_command_entry *pcmd;
 			void *addr;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			if (param.num == 0)
 				break;
 			req_sz = sizeof(struct dfe_command_entry) * param.num;

 			if (pdfi->cmd_num < param.num) {
 				void *pmem;

 				pmem = kmalloc(req_sz, GFP_KERNEL);
 				if (pmem == NULL)
 					return -ENOMEM;
 				pdfi->pcmd = (struct dfe_command_entry *) pmem;
 				pdfi->cmd_num = param.num;
 			}

 			if (copy_from_user(pdfi->pcmd, param.pEntry, req_sz))
 				return -EFAULT;

 			pcmd = pdfi->pcmd;

 			spin_lock_irqsave(&hh_dev_info.hh_lock,
 				irq_flags);
 			for (i = 0; i < param.num; ++i, ++pcmd) {
 				if (!HH_OFFSET_VALID(pcmd->offset))
 					return -EINVAL;
 				addr = HH_REG_IOADDR(pcmd->offset);

 				switch (pcmd->code) {
 				case DFE_IOCTL_COMMAND_CODE_WRITE:
 					__raw_writel(pcmd->value, addr);
 					break;
 				case DFE_IOCTL_COMMAND_CODE_WRITE_WITH_MASK:
 					value = __raw_readl(addr);
 					value &= ~pcmd->mask;
 					value |= pcmd->value & pcmd->mask;
 					__raw_writel(value, addr);
 					break;
 				}
 			}
 			spin_unlock_irqrestore(&hh_dev_info.hh_lock,
 				irq_flags);
 		}
 		break;

 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static unsigned int hh_poll(struct file *filp,
 	struct poll_table_struct *wait)
 {
 	unsigned mask = 0;

 	if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info))
 		mask |= POLLIN;

 	if (mask == 0) {
 		poll_wait(filp, &hh_dev_info.wq, wait);
 		if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info))
 			mask |= POLLIN;
 	}

 	return mask;
 }

 static const struct file_operations hh_fops = {
 	.owner = THIS_MODULE,
 	.open = hh_open,
 	.release = hh_release,
 	.read = hh_read,
 	.write = hh_write,
 	.unlocked_ioctl = hh_ioctl,
 	.poll = hh_poll,
 };

 /*
  * Interrupt handling
  */

 static irqreturn_t hh_irq_handler(int irq, void *data)
 {
 	unsigned int irq_enable, irq_flag, irq_mask;
 	int i;

 	irq_enable = __raw_readl(HH_REG_SCPN_IREQ_MASK);
 	irq_flag = __raw_readl(HH_REG_SCPN_IREQ_FLAG);
 	irq_flag &= irq_enable;

 	/* Disables interrupts */
 	irq_enable &= ~irq_flag;
 	__raw_writel(irq_enable, HH_REG_SCPN_IREQ_MASK);

 	/* Adds the pending interrupts to irq_fifo */
 	spin_lock(&hh_dev_info.hh_lock);
 	for (i = 0, irq_mask = 1; i < 32; ++i, irq_mask <<= 1) {
 		if (HH_IRQ_FIFO_FULL(&hh_dev_info))
 			break;
 		if (irq_flag & irq_mask) {
 			hh_dev_info.irq_fifo[hh_dev_info.irq_fifo_tail] = \
 				(char) i;
 			if (++hh_dev_info.irq_fifo_tail == HH_IRQ_FIFO_SIZE)
 				hh_dev_info.irq_fifo_tail = 0;
 		}
 	}
 	spin_unlock(&hh_dev_info.hh_lock);

 	/* Wakes up pending processes */
 	wake_up_interruptible(&hh_dev_info.wq);

 	return IRQ_HANDLED;
 }

 /*
  * Driver initialization & cleanup
  */

 static struct miscdevice hh_misc_dev = {
 	.minor = MISC_DYNAMIC_MINOR,
 	.name = DFE_HH_DEVICE_NAME,
 	.fops = &hh_fops,
 };

 static int __init hh_init(void)
 {
 	int ret;

 	/* lock initialization */
 	spin_lock_init(&hh_dev_info.hh_lock);

 	/* interrupt handler */
 	hh_dev_info.irq_fifo_head = 0;
 	hh_dev_info.irq_fifo_tail = 0;
 	ret = request_irq(INT_HH_SUPSS_IRQ, hh_irq_handler,
 		IRQF_TRIGGER_RISING, "hh_dev", 0);
 	if (ret < 0) {
 		pr_err("Cannot register HH interrupt handler.\n");
 		return ret;
 	}

 	/* wait queue */
 	init_waitqueue_head(&hh_dev_info.wq);

 	return misc_register(&hh_misc_dev);
 }

 static void __exit hh_exit(void)
 {
 	misc_deregister(&hh_misc_dev);
 	free_irq(INT_HH_SUPSS_IRQ, 0);
 }

 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Rohit Vaswani <rvaswani@codeaurora.org>");
 MODULE_DESCRIPTION("Qualcomm Hammerhead Digital Front End driver");
 MODULE_VERSION("1.0");

 module_init(hh_init);
 module_exit(hh_exit);
	/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/fs.h>
	#include <linux/slab.h>
	#include <linux/miscdevice.h>
	#include <linux/spinlock.h>
	#include <linux/uaccess.h>
	#include <linux/io.h>
	#include <linux/irq.h>
	#include <linux/interrupt.h>
	#include <linux/sched.h>
	#include <linux/wait.h>
	#include <linux/poll.h>
	#include <mach/msm_iomap.h>

	#include <linux/fsm_dfe_hh.h>

	/*
	* DFE of FSM9XXX
	*/

	#define HH_ADDR_MASK 0x000ffffc
	#define HH_OFFSET_VALID(offset) (((offset) & ~HH_ADDR_MASK) == 0)
	#define HH_REG_IOADDR(offset) ((uint8_t *) MSM_HH_BASE + (offset))
	#define HH_MAKE_OFFSET(blk, adr) (((blk)&0x1F)<<15\|((adr)&0x1FFF)<<2)

	#define HH_REG_SCPN_IREQ_MASK HH_REG_IOADDR(HH_MAKE_OFFSET(5, 0x12))
	#define HH_REG_SCPN_IREQ_FLAG HH_REG_IOADDR(HH_MAKE_OFFSET(5, 0x13))

	/*
	* Device private information per device node
	*/

	#define HH_IRQ_FIFO_SIZE 64
	#define HH_IRQ_FIFO_EMPTY(pdev) ((pdev)->irq_fifo_head == \
	(pdev)->irq_fifo_tail)
	#define HH_IRQ_FIFO_FULL(pdev) ((((pdev)->irq_fifo_tail + 1) % \
	HH_IRQ_FIFO_SIZE) == \
	(pdev)->irq_fifo_head)

	static struct hh_dev_node_info {
	spinlock_t hh_lock;
	char irq_fifo[HH_IRQ_FIFO_SIZE];
	unsigned int irq_fifo_head, irq_fifo_tail;
	wait_queue_head_t wq;
	} hh_dev_info;

	/*
	* Device private information per file
	*/

	struct hh_dev_file_info {
	/* Buffer */
	unsigned int *parray;
	unsigned int array_num;

	struct dfe_command_entry *pcmd;
	unsigned int cmd_num;
	};

	/*
	* File interface
	*/

	static int hh_open(struct inode inode, struct file file)
	{
	struct hh_dev_file_info *pdfi;

	/* private data allocation */
	pdfi = kmalloc(sizeof(*pdfi), GFP_KERNEL);
	if (pdfi == NULL)
	return -ENOMEM;
	file->private_data = pdfi;

	/* buffer initialization */
	pdfi->parray = NULL;
	pdfi->array_num = 0;
	pdfi->pcmd = NULL;
	pdfi->cmd_num = 0;

	return 0;
	}

	static int hh_release(struct inode inode, struct file file)
	{
	struct hh_dev_file_info *pdfi;

	pdfi = (struct hh_dev_file_info *) file->private_data;

	kfree(pdfi->parray);
	pdfi->parray = NULL;
	pdfi->array_num = 0;

	kfree(pdfi->pcmd);
	pdfi->pcmd = NULL;
	pdfi->cmd_num = 0;

	kfree(file->private_data);
	file->private_data = NULL;

	return 0;
	}

	static ssize_t hh_read(struct file filp, char __user buf, size_t count,
	loff_t *f_pos)
	{
	signed char irq = -1;
	unsigned long irq_flags;

	do {
	spin_lock_irqsave(&hh_dev_info.hh_lock, irq_flags);
	if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info)) {
	irq = hh_dev_info.irq_fifo[hh_dev_info.irq_fifo_head];
	if (++hh_dev_info.irq_fifo_head == HH_IRQ_FIFO_SIZE)
	hh_dev_info.irq_fifo_head = 0;
	}
	spin_unlock_irqrestore(&hh_dev_info.hh_lock, irq_flags);

	if (irq < 0)
	if (wait_event_interruptible(hh_dev_info.wq,
	!HH_IRQ_FIFO_EMPTY(&hh_dev_info)) < 0)
	break;
	} while (irq < 0);

	if (irq < 0) {
	/* No pending interrupt */
	return 0;
	} else {
	put_user(irq, buf);
	return 1;
	}

	return 0;
	}

	static ssize_t hh_write(struct file file, const char __user buffer,
	size_t count, loff_t *ppos)
	{
	return 0;
	}

	static long hh_ioctl(struct file *file,
	unsigned int cmd, unsigned long arg)
	{
	unsigned int __user argp = (unsigned int __user ) arg;
	struct hh_dev_file_info *pdfi =
	(struct hh_dev_file_info *) file->private_data;

	switch (cmd) {
	case DFE_IOCTL_READ_REGISTER:
	{
	unsigned int offset, value;

	if (get_user(offset, argp))
	return -EFAULT;
	if (!HH_OFFSET_VALID(offset))
	return -EINVAL;
	value = __raw_readl(HH_REG_IOADDR(offset));
	if (put_user(value, argp))
	return -EFAULT;
	}
	break;

	case DFE_IOCTL_WRITE_REGISTER:
	{
	struct dfe_write_register_param param;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	if (!HH_OFFSET_VALID(param.offset))
	return -EINVAL;
	__raw_writel(param.value,
	HH_REG_IOADDR(param.offset));
	}
	break;

	case DFE_IOCTL_WRITE_REGISTER_WITH_MASK:
	{
	struct dfe_write_register_mask_param param;
	unsigned int value;
	unsigned long irq_flags;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	if (!HH_OFFSET_VALID(param.offset))
	return -EINVAL;
	spin_lock_irqsave(&hh_dev_info.hh_lock,
	irq_flags);
	value = __raw_readl(HH_REG_IOADDR(param.offset));
	value &= ~param.mask;
	value \|= param.value & param.mask;
	__raw_writel(value, HH_REG_IOADDR(param.offset));
	spin_unlock_irqrestore(&hh_dev_info.hh_lock,
	irq_flags);
	}
	break;

	case DFE_IOCTL_READ_REGISTER_ARRAY:
	case DFE_IOCTL_WRITE_REGISTER_ARRAY:
	{
	struct dfe_read_write_array_param param;
	unsigned int req_sz;
	unsigned long irq_flags;
	unsigned int i;
	void *addr;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	if (!HH_OFFSET_VALID(param.offset))
	return -EINVAL;
	if (param.num == 0)
	break;
	req_sz = sizeof(unsigned int) * param.num;

	if (pdfi->array_num < param.num) {
	void *pmem;

	pmem = kmalloc(req_sz, GFP_KERNEL);
	if (pmem == NULL)
	return -ENOMEM;
	pdfi->parray = (unsigned int *) pmem;
	pdfi->array_num = param.num;
	}

	if (cmd == DFE_IOCTL_WRITE_REGISTER_ARRAY)
	if (copy_from_user(pdfi->parray,
	param.pArray, req_sz))
	return -EFAULT;

	addr = HH_REG_IOADDR(param.offset);

	spin_lock_irqsave(&hh_dev_info.hh_lock,
	irq_flags);
	for (i = 0; i < param.num; ++i, addr += 4) {
	if (cmd == DFE_IOCTL_READ_REGISTER_ARRAY)
	pdfi->parray[i] = __raw_readl(addr);
	else
	__raw_writel(pdfi->parray[i], addr);
	}
	spin_unlock_irqrestore(&hh_dev_info.hh_lock,
	irq_flags);

	if (cmd == DFE_IOCTL_READ_REGISTER_ARRAY)
	if (copy_to_user(pdfi->parray,
	param.pArray, req_sz))
	return -EFAULT;
	}
	break;

	case DFE_IOCTL_COMMAND:
	{
	struct dfe_command_param param;
	unsigned int req_sz;
	unsigned long irq_flags;
	unsigned int i, value;
	struct dfe_command_entry *pcmd;
	void *addr;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	if (param.num == 0)
	break;
	req_sz = sizeof(struct dfe_command_entry) * param.num;

	if (pdfi->cmd_num < param.num) {
	void *pmem;

	pmem = kmalloc(req_sz, GFP_KERNEL);
	if (pmem == NULL)
	return -ENOMEM;
	pdfi->pcmd = (struct dfe_command_entry *) pmem;
	pdfi->cmd_num = param.num;
	}

	if (copy_from_user(pdfi->pcmd, param.pEntry, req_sz))
	return -EFAULT;

	pcmd = pdfi->pcmd;

	spin_lock_irqsave(&hh_dev_info.hh_lock,
	irq_flags);
	for (i = 0; i < param.num; ++i, ++pcmd) {
	if (!HH_OFFSET_VALID(pcmd->offset))
	return -EINVAL;
	addr = HH_REG_IOADDR(pcmd->offset);

	switch (pcmd->code) {
	case DFE_IOCTL_COMMAND_CODE_WRITE:
	__raw_writel(pcmd->value, addr);
	break;
	case DFE_IOCTL_COMMAND_CODE_WRITE_WITH_MASK:
	value = __raw_readl(addr);
	value &= ~pcmd->mask;
	value \|= pcmd->value & pcmd->mask;
	__raw_writel(value, addr);
	break;
	}
	}
	spin_unlock_irqrestore(&hh_dev_info.hh_lock,
	irq_flags);
	}
	break;

	default:
	return -EINVAL;
	}

	return 0;
	}

	static unsigned int hh_poll(struct file *filp,
	struct poll_table_struct *wait)
	{
	unsigned mask = 0;

	if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info))
	mask \|= POLLIN;

	if (mask == 0) {
	poll_wait(filp, &hh_dev_info.wq, wait);
	if (!HH_IRQ_FIFO_EMPTY(&hh_dev_info))
	mask \|= POLLIN;
	}

	return mask;
	}

	static const struct file_operations hh_fops = {
	.owner = THIS_MODULE,
	.open = hh_open,
	.release = hh_release,
	.read = hh_read,
	.write = hh_write,
	.unlocked_ioctl = hh_ioctl,
	.poll = hh_poll,
	};

	/*
	* Interrupt handling
	*/

	static irqreturn_t hh_irq_handler(int irq, void *data)
	{
	unsigned int irq_enable, irq_flag, irq_mask;
	int i;

	irq_enable = __raw_readl(HH_REG_SCPN_IREQ_MASK);
	irq_flag = __raw_readl(HH_REG_SCPN_IREQ_FLAG);
	irq_flag &= irq_enable;

	/* Disables interrupts */
	irq_enable &= ~irq_flag;
	__raw_writel(irq_enable, HH_REG_SCPN_IREQ_MASK);

	/* Adds the pending interrupts to irq_fifo */
	spin_lock(&hh_dev_info.hh_lock);
	for (i = 0, irq_mask = 1; i < 32; ++i, irq_mask <<= 1) {
	if (HH_IRQ_FIFO_FULL(&hh_dev_info))
	break;
	if (irq_flag & irq_mask) {
	hh_dev_info.irq_fifo[hh_dev_info.irq_fifo_tail] = \
	(char) i;
	if (++hh_dev_info.irq_fifo_tail == HH_IRQ_FIFO_SIZE)
	hh_dev_info.irq_fifo_tail = 0;
	}
	}
	spin_unlock(&hh_dev_info.hh_lock);

	/* Wakes up pending processes */
	wake_up_interruptible(&hh_dev_info.wq);

	return IRQ_HANDLED;
	}

	/*
	* Driver initialization & cleanup
	*/

	static struct miscdevice hh_misc_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = DFE_HH_DEVICE_NAME,
	.fops = &hh_fops,
	};

	static int __init hh_init(void)
	{
	int ret;

	/* lock initialization */
	spin_lock_init(&hh_dev_info.hh_lock);

	/* interrupt handler */
	hh_dev_info.irq_fifo_head = 0;
	hh_dev_info.irq_fifo_tail = 0;
	ret = request_irq(INT_HH_SUPSS_IRQ, hh_irq_handler,
	IRQF_TRIGGER_RISING, "hh_dev", 0);
	if (ret < 0) {
	pr_err("Cannot register HH interrupt handler.\n");
	return ret;
	}

	/* wait queue */
	init_waitqueue_head(&hh_dev_info.wq);

	return misc_register(&hh_misc_dev);
	}

	static void __exit hh_exit(void)
	{
	misc_deregister(&hh_misc_dev);
	free_irq(INT_HH_SUPSS_IRQ, 0);
	}

	MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Rohit Vaswani <rvaswani@codeaurora.org>");
	MODULE_DESCRIPTION("Qualcomm Hammerhead Digital Front End driver");
	MODULE_VERSION("1.0");

	module_init(hh_init);
	module_exit(hh_exit);