arch/arm/mach-msm/rfic-fsm9xxx.c - kernel/msm - Gitiles

 /* Copyright (c) 2010-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/mutex.h>
 #include <linux/i2c.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
 #include <mach/msm_iomap.h>

 #include <linux/fsm_rfic_ftr.h>

 /*
  * FTR8700 RFIC
  */

 #define RFIC_FTR_DEVICE_NUM		2
 #define RFIC_GRFC_REG_NUM		6

 #define ANY_BUS				0x0
 #define TX1_BUS				0x0
 #define TX2_BUS				0x1
 #define MISC_BUS			0x2
 #define RX_BUS				0x3
 #define BUS_BITS			0x3

 /*
  * Device private information per device node
  */

 static struct ftr_dev_node_info {
 	void *grfcCtrlAddr;
 	void *grfcMaskAddr;
 	unsigned int busSelect[4];
 	struct i2c_adapter *ssbi_adap;

 	/* lock */
 	struct mutex lock;
 } ftr_dev_info[RFIC_FTR_DEVICE_NUM];

 /*
  * Device private information per file
  */

 struct ftr_dev_file_info {
 	int ftrId;
 };

 /*
  * File interface
  */

 static int ftr_find_id(int minor);

 static int ftr_open(struct inode *inode, struct file *file)
 {
 	struct ftr_dev_file_info *pdfi;

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

 	/* FTR ID */
 	pdfi->ftrId = ftr_find_id(MINOR(inode->i_rdev));

 	return 0;
 }

 static int ftr_release(struct inode *inode, struct file *file)
 {
 	struct ftr_dev_file_info *pdfi;

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

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

 	return 0;
 }

 static ssize_t ftr_read(struct file *filp, char __user *buf, size_t count,
 	loff_t *f_pos)
 {
 	return 0;
 }

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

 static int ftr_ssbi_read(
 	struct ftr_dev_node_info *pdev,
 	unsigned int addr,
 	u8 *buf,
 	size_t len)
 {
 	int ret;
 	struct i2c_msg msg = {
 		.addr = addr,
 		.flags = I2C_M_RD,
 		.buf = buf,
 		.len = len,
 	};

 	ret = i2c_transfer(pdev->ssbi_adap, &msg, 1);

 	return (ret == 1) ? 0 : ret;
 }

 static int ftr_ssbi_write(
 	struct ftr_dev_node_info *pdev,
 	unsigned int addr,
 	u8 *buf,
 	size_t len)
 {
 	int ret;
 	struct i2c_msg msg = {
 		.addr = addr,
 		.flags = 0x0,
 		.buf = (u8 *) buf,
 		.len = len,
 	};

 	ret = i2c_transfer(pdev->ssbi_adap, &msg, 1);

 	return (ret == 1) ? 0 : ret;
 }

 static long ftr_ioctl(struct file *file,
 	unsigned int cmd, unsigned long arg)
 {
 	unsigned int __user *argp = (unsigned int __user *) arg;
 	struct ftr_dev_file_info *pdfi =
 		(struct ftr_dev_file_info *) file->private_data;
 	struct ftr_dev_node_info *pdev;

 	if (pdfi->ftrId < 0 || pdfi->ftrId >= RFIC_FTR_DEVICE_NUM)
 		return -EINVAL;

 	pdev = ftr_dev_info + pdfi->ftrId;

 	switch (cmd) {
 	case RFIC_IOCTL_READ_REGISTER:
 		{
 			int ret;
 			unsigned int rficAddr;
 			u8 value;

 			if (get_user(rficAddr, argp))
 				return -EFAULT;

 			mutex_lock(&pdev->lock);
 			mb();
 			/* Need to write twice due to bug in hardware */
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			mb();
 			ret = ftr_ssbi_read(pdev, RFIC_FTR_GET_ADDR(rficAddr),
 				&value, 1);
 			mutex_unlock(&pdev->lock);

 			if (ret)
 				return ret;

 			if (put_user(value, argp))
 				return -EFAULT;
 		}
 		break;

 	case RFIC_IOCTL_WRITE_REGISTER:
 		{
 			int ret;
 			struct rfic_write_register_param param;
 			unsigned int rficAddr;
 			u8 value;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			rficAddr = param.rficAddr;
 			value = (u8) param.value;

 			mutex_lock(&pdev->lock);
 			mb();
 			/* Need to write twice due to bug in hardware */
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			mb();
 			ret = ftr_ssbi_write(pdev, RFIC_FTR_GET_ADDR(rficAddr),
 				&value, 1);
 			mutex_unlock(&pdev->lock);

 			if (ret)
 				return ret;
 		}
 		break;

 	case RFIC_IOCTL_WRITE_REGISTER_WITH_MASK:
 		{
 			int ret;
 			struct rfic_write_register_mask_param param;
 			unsigned int rficAddr;
 			u8 value;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;
 			rficAddr = param.rficAddr;

 			mutex_lock(&pdev->lock);
 			mb();
 			/* Need to write twice due to bug in hardware */
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			__raw_writel(
 				pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
 				pdev->grfcCtrlAddr);
 			mb();
 			ret = ftr_ssbi_read(pdev, RFIC_FTR_GET_ADDR(rficAddr),
 				&value, 1);
 			value &= (u8) ~param.mask;
 			value |= (u8) (param.value & param.mask);
 			ret = ftr_ssbi_write(pdev, RFIC_FTR_GET_ADDR(rficAddr),
 				&value, 1);
 			mutex_unlock(&pdev->lock);

 			if (ret)
 				return ret;
 		}
 		break;

 	case RFIC_IOCTL_GET_GRFC:
 		{
 			struct rfic_grfc_param param;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;

 			if (param.grfcId >= RFIC_GRFC_REG_NUM)
 				return -EINVAL;

 			param.maskValue = __raw_readl(
 				MSM_GRFC_BASE + 0x18 + param.grfcId * 4);
 			param.ctrlValue = __raw_readl(
 				MSM_GRFC_BASE + 0x00 + param.grfcId * 4);

 			if (copy_to_user(argp, &param, sizeof param))
 				return -EFAULT;
 		}
 		break;

 	case RFIC_IOCTL_SET_GRFC:
 		{
 			struct rfic_grfc_param param;

 			if (copy_from_user(&param, argp, sizeof param))
 				return -EFAULT;

 			if (param.grfcId >= RFIC_GRFC_REG_NUM)
 				return -EINVAL;

 			__raw_writel(param.maskValue,
 				MSM_GRFC_BASE + 0x18 + param.grfcId * 4);
 			/* Need to write twice due to bug in hardware */
 			__raw_writel(param.ctrlValue,
 				MSM_GRFC_BASE + 0x00 + param.grfcId * 4);
 			__raw_writel(param.ctrlValue,
 				MSM_GRFC_BASE + 0x00 + param.grfcId * 4);
 			mb();
 		}
 		break;

 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static const struct file_operations ftr_fops = {
 	.owner = THIS_MODULE,
 	.open = ftr_open,
 	.release = ftr_release,
 	.read = ftr_read,
 	.write = ftr_write,
 	.unlocked_ioctl = ftr_ioctl,
 };

 /*
  * Driver initialization & cleanup
  */

 struct miscdevice ftr_misc_dev[RFIC_FTR_DEVICE_NUM] = {
 	{
 		.minor = MISC_DYNAMIC_MINOR,
 		.name = RFIC_FTR_DEVICE_NAME "0",
 		.fops = &ftr_fops,
 	},
 	{
 		.minor = MISC_DYNAMIC_MINOR,
 		.name = RFIC_FTR_DEVICE_NAME "1",
 		.fops = &ftr_fops,
 	},
 };

 int ftr_find_id(int minor)
 {
 	int i;

 	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i)
 		if (ftr_misc_dev[i].minor == minor)
 			break;

 	return i;
 }

 static int __init ftr_init(void)
 {
 	int i, ret;
 	struct ftr_dev_node_info *pdev;

 	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i) {
 		pdev = ftr_dev_info + i;

 		if (i == 0) {
 			pdev->grfcCtrlAddr = MSM_GRFC_BASE + 0x00;
 			pdev->grfcMaskAddr = MSM_GRFC_BASE + 0x18;
 			__raw_writel(0x300000, pdev->grfcMaskAddr);
 			pdev->busSelect[TX1_BUS] = 0x000000;
 			pdev->busSelect[TX2_BUS] = 0x100000;
 			pdev->busSelect[MISC_BUS] = 0x200000;
 			pdev->busSelect[RX_BUS] = 0x300000;
 			pdev->ssbi_adap = i2c_get_adapter(1);
 		} else {
 			pdev->grfcCtrlAddr = MSM_GRFC_BASE + 0x04;
 			pdev->grfcMaskAddr = MSM_GRFC_BASE + 0x1c;
 			__raw_writel(0x480000, pdev->grfcMaskAddr);
 			pdev->busSelect[TX1_BUS] = 0x000000;
 			pdev->busSelect[TX2_BUS] = 0x400000;
 			pdev->busSelect[MISC_BUS] = 0x080000;
 			pdev->busSelect[RX_BUS] = 0x480000;
 			pdev->ssbi_adap = i2c_get_adapter(2);
 		}

 		mutex_init(&pdev->lock);
 		ret = misc_register(ftr_misc_dev + i);

 		if (ret < 0) {
 			while (--i >= 0)
 				misc_deregister(ftr_misc_dev + i);
 			return ret;
 		}
 	}

 	return 0;
 }

 static void __exit ftr_exit(void)
 {
 	int i;

 	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i)
 		misc_deregister(ftr_misc_dev + i);
 }

 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Rohit Vaswani <rvaswani@codeaurora.org>");
 MODULE_DESCRIPTION("Qualcomm FSM RFIC driver");
 MODULE_VERSION("1.0");

 module_init(ftr_init);
 module_exit(ftr_exit);
	/* Copyright (c) 2010-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/mutex.h>
	#include <linux/i2c.h>
	#include <linux/uaccess.h>
	#include <linux/io.h>
	#include <linux/gpio.h>
	#include <mach/msm_iomap.h>

	#include <linux/fsm_rfic_ftr.h>

	/*
	* FTR8700 RFIC
	*/

	#define RFIC_FTR_DEVICE_NUM 2
	#define RFIC_GRFC_REG_NUM 6

	#define ANY_BUS 0x0
	#define TX1_BUS 0x0
	#define TX2_BUS 0x1
	#define MISC_BUS 0x2
	#define RX_BUS 0x3
	#define BUS_BITS 0x3

	/*
	* Device private information per device node
	*/

	static struct ftr_dev_node_info {
	void *grfcCtrlAddr;
	void *grfcMaskAddr;
	unsigned int busSelect[4];
	struct i2c_adapter *ssbi_adap;

	/* lock */
	struct mutex lock;
	} ftr_dev_info[RFIC_FTR_DEVICE_NUM];

	/*
	* Device private information per file
	*/

	struct ftr_dev_file_info {
	int ftrId;
	};

	/*
	* File interface
	*/

	static int ftr_find_id(int minor);

	static int ftr_open(struct inode inode, struct file file)
	{
	struct ftr_dev_file_info *pdfi;

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

	/* FTR ID */
	pdfi->ftrId = ftr_find_id(MINOR(inode->i_rdev));

	return 0;
	}

	static int ftr_release(struct inode inode, struct file file)
	{
	struct ftr_dev_file_info *pdfi;

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

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

	return 0;
	}

	static ssize_t ftr_read(struct file filp, char __user buf, size_t count,
	loff_t *f_pos)
	{
	return 0;
	}

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

	static int ftr_ssbi_read(
	struct ftr_dev_node_info *pdev,
	unsigned int addr,
	u8 *buf,
	size_t len)
	{
	int ret;
	struct i2c_msg msg = {
	.addr = addr,
	.flags = I2C_M_RD,
	.buf = buf,
	.len = len,
	};

	ret = i2c_transfer(pdev->ssbi_adap, &msg, 1);

	return (ret == 1) ? 0 : ret;
	}

	static int ftr_ssbi_write(
	struct ftr_dev_node_info *pdev,
	unsigned int addr,
	u8 *buf,
	size_t len)
	{
	int ret;
	struct i2c_msg msg = {
	.addr = addr,
	.flags = 0x0,
	.buf = (u8 *) buf,
	.len = len,
	};

	ret = i2c_transfer(pdev->ssbi_adap, &msg, 1);

	return (ret == 1) ? 0 : ret;
	}

	static long ftr_ioctl(struct file *file,
	unsigned int cmd, unsigned long arg)
	{
	unsigned int __user argp = (unsigned int __user ) arg;
	struct ftr_dev_file_info *pdfi =
	(struct ftr_dev_file_info *) file->private_data;
	struct ftr_dev_node_info *pdev;

	if (pdfi->ftrId < 0 \|\| pdfi->ftrId >= RFIC_FTR_DEVICE_NUM)
	return -EINVAL;

	pdev = ftr_dev_info + pdfi->ftrId;

	switch (cmd) {
	case RFIC_IOCTL_READ_REGISTER:
	{
	int ret;
	unsigned int rficAddr;
	u8 value;

	if (get_user(rficAddr, argp))
	return -EFAULT;

	mutex_lock(&pdev->lock);
	mb();
	/* Need to write twice due to bug in hardware */
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	mb();
	ret = ftr_ssbi_read(pdev, RFIC_FTR_GET_ADDR(rficAddr),
	&value, 1);
	mutex_unlock(&pdev->lock);

	if (ret)
	return ret;

	if (put_user(value, argp))
	return -EFAULT;
	}
	break;

	case RFIC_IOCTL_WRITE_REGISTER:
	{
	int ret;
	struct rfic_write_register_param param;
	unsigned int rficAddr;
	u8 value;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	rficAddr = param.rficAddr;
	value = (u8) param.value;

	mutex_lock(&pdev->lock);
	mb();
	/* Need to write twice due to bug in hardware */
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	mb();
	ret = ftr_ssbi_write(pdev, RFIC_FTR_GET_ADDR(rficAddr),
	&value, 1);
	mutex_unlock(&pdev->lock);

	if (ret)
	return ret;
	}
	break;

	case RFIC_IOCTL_WRITE_REGISTER_WITH_MASK:
	{
	int ret;
	struct rfic_write_register_mask_param param;
	unsigned int rficAddr;
	u8 value;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;
	rficAddr = param.rficAddr;

	mutex_lock(&pdev->lock);
	mb();
	/* Need to write twice due to bug in hardware */
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	__raw_writel(
	pdev->busSelect[RFIC_FTR_GET_BUS(rficAddr)],
	pdev->grfcCtrlAddr);
	mb();
	ret = ftr_ssbi_read(pdev, RFIC_FTR_GET_ADDR(rficAddr),
	&value, 1);
	value &= (u8) ~param.mask;
	value \|= (u8) (param.value & param.mask);
	ret = ftr_ssbi_write(pdev, RFIC_FTR_GET_ADDR(rficAddr),
	&value, 1);
	mutex_unlock(&pdev->lock);

	if (ret)
	return ret;
	}
	break;

	case RFIC_IOCTL_GET_GRFC:
	{
	struct rfic_grfc_param param;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;

	if (param.grfcId >= RFIC_GRFC_REG_NUM)
	return -EINVAL;

	param.maskValue = __raw_readl(
	MSM_GRFC_BASE + 0x18 + param.grfcId * 4);
	param.ctrlValue = __raw_readl(
	MSM_GRFC_BASE + 0x00 + param.grfcId * 4);

	if (copy_to_user(argp, &param, sizeof param))
	return -EFAULT;
	}
	break;

	case RFIC_IOCTL_SET_GRFC:
	{
	struct rfic_grfc_param param;

	if (copy_from_user(&param, argp, sizeof param))
	return -EFAULT;

	if (param.grfcId >= RFIC_GRFC_REG_NUM)
	return -EINVAL;

	__raw_writel(param.maskValue,
	MSM_GRFC_BASE + 0x18 + param.grfcId * 4);
	/* Need to write twice due to bug in hardware */
	__raw_writel(param.ctrlValue,
	MSM_GRFC_BASE + 0x00 + param.grfcId * 4);
	__raw_writel(param.ctrlValue,
	MSM_GRFC_BASE + 0x00 + param.grfcId * 4);
	mb();
	}
	break;

	default:
	return -EINVAL;
	}

	return 0;
	}

	static const struct file_operations ftr_fops = {
	.owner = THIS_MODULE,
	.open = ftr_open,
	.release = ftr_release,
	.read = ftr_read,
	.write = ftr_write,
	.unlocked_ioctl = ftr_ioctl,
	};

	/*
	* Driver initialization & cleanup
	*/

	struct miscdevice ftr_misc_dev[RFIC_FTR_DEVICE_NUM] = {
	{
	.minor = MISC_DYNAMIC_MINOR,
	.name = RFIC_FTR_DEVICE_NAME "0",
	.fops = &ftr_fops,
	},
	{
	.minor = MISC_DYNAMIC_MINOR,
	.name = RFIC_FTR_DEVICE_NAME "1",
	.fops = &ftr_fops,
	},
	};

	int ftr_find_id(int minor)
	{
	int i;

	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i)
	if (ftr_misc_dev[i].minor == minor)
	break;

	return i;
	}

	static int __init ftr_init(void)
	{
	int i, ret;
	struct ftr_dev_node_info *pdev;

	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i) {
	pdev = ftr_dev_info + i;

	if (i == 0) {
	pdev->grfcCtrlAddr = MSM_GRFC_BASE + 0x00;
	pdev->grfcMaskAddr = MSM_GRFC_BASE + 0x18;
	__raw_writel(0x300000, pdev->grfcMaskAddr);
	pdev->busSelect[TX1_BUS] = 0x000000;
	pdev->busSelect[TX2_BUS] = 0x100000;
	pdev->busSelect[MISC_BUS] = 0x200000;
	pdev->busSelect[RX_BUS] = 0x300000;
	pdev->ssbi_adap = i2c_get_adapter(1);
	} else {
	pdev->grfcCtrlAddr = MSM_GRFC_BASE + 0x04;
	pdev->grfcMaskAddr = MSM_GRFC_BASE + 0x1c;
	__raw_writel(0x480000, pdev->grfcMaskAddr);
	pdev->busSelect[TX1_BUS] = 0x000000;
	pdev->busSelect[TX2_BUS] = 0x400000;
	pdev->busSelect[MISC_BUS] = 0x080000;
	pdev->busSelect[RX_BUS] = 0x480000;
	pdev->ssbi_adap = i2c_get_adapter(2);
	}

	mutex_init(&pdev->lock);
	ret = misc_register(ftr_misc_dev + i);

	if (ret < 0) {
	while (--i >= 0)
	misc_deregister(ftr_misc_dev + i);
	return ret;
	}
	}

	return 0;
	}

	static void __exit ftr_exit(void)
	{
	int i;

	for (i = 0; i < RFIC_FTR_DEVICE_NUM; ++i)
	misc_deregister(ftr_misc_dev + i);
	}

	MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Rohit Vaswani <rvaswani@codeaurora.org>");
	MODULE_DESCRIPTION("Qualcomm FSM RFIC driver");
	MODULE_VERSION("1.0");

	module_init(ftr_init);
	module_exit(ftr_exit);