msm: fsm_rfic: Add MRay support to rfic driver (aca9ddd9) · Commits · e / devices / android_kernel_sony_msm8994

Documentation/devicetree/bindings/arm/msm/msm_rfic.txt

+4 −2

Original line number	Diff line number	Diff line
		@@ -40,7 +40,8 @@ vdd-switch-supply: regulator used to control RF switches.
		vdd-wtr-supply: regulator used to control WTR.
		vdd-ftr1-supply: regulator used to control FTR1.
		vdd-ftr2-supply: regulator used to control FTR2.
		vdd-mtr-supply: regulator used to control MTR.
		vdd-1v8-supply: regulator used to control 1.8V to all RFICs.
		vdd-1v3-supply: regulator used to control 1.3V to all RFICs

		Example:
		qcom,rfic@fd4a4090 {
		@@ -50,7 +51,8 @@ Example:
		vdd-wtr-supply = <&pma8084_l19>;
		vdd-ftr1-supply = <&pma8084_l23>;
		vdd-ftr2-supply = <&pma8084_l25>;
		vdd-mtr-supply = <&pma8084_l26>;
		vdd-1v8-supply = <&pma8084_l26>;
		vdd-1v3-supply = <&pma8084_l11>;
		};

		qcom,pdm@f9b10000 {

arch/arm/mach-msm/board-fsm9900-gpiomux.c

+166 −0

Original line number	Diff line number	Diff line
		@@ -783,6 +783,165 @@ static struct msm_gpiomux_config fsm_rf_configs[] __initdata = {
		},
		};

		struct msm_gpiomux_config fsm_mtr_configs[] = {
		{
		.gpio = 88, /* TX1_HB_PA_EN / TX1_PA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 89, /* TX1_LB_PA_EN / TX2_PA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 90, /* TX2_HB_PA_EN / FTR1_DPD_SEL1 */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 91, /* TX2_LB_PA_EN / FTR1_DPD_SEL0 */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 92, /* TX3_HB_PA_EN / TX3_PA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 93, /* TX3_LB_PA_EN / TX4_PA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 94, /* TX4_HB_PA_EN / FTR2_DPD_SEL1 */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 95, /* TX4_LB_PA_EN / FTR2_DPD_SEL0 */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 96, /* TX3_TX4_HB_PA_EN / FTR2_NL_SW1_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 97, /* TX3_TX4_LB_PA_EN / FTR2_NL_SW2_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 98, /* TX1_TX2_HB_PA_EN / FTR1_NL_SW1_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 99, /* TX1_TX2_LB_PA_EN / FTR1_NL_SW2_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 100, /* ANT1_HBLB_FTR_SEL / SPARE */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 101, /* FTR2_TXRX_SW_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 102, /* FTR1_TXRX_SW_SEL */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 103, /* HB_TDD / FTR1_RX_ON */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 104, /* SPARE */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 105, /* FTR2_SEL0 / FTR2_RX_ON */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 106, /* SPARE */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 109, /* WTR1605_RX_ON / FTR1_INTERRUPT */
		.settings = {
		[GPIOMUX_SUSPENDED] = &rf_detect_config,
		},
		},
		{
		.gpio = 110, /* WTR1605_RF_ON / FTR2_INTERRUPT */
		.settings = {
		[GPIOMUX_SUSPENDED] = &rf_detect_config,
		},
		},
		{
		.gpio = 111, /* WTR2605_RX_ON / SPARE */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 112, /* TX1_VPA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 113 , /* TX2_VPA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 114, /* TX3_VPA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		{
		.gpio = 115, /* TX4_VPA_EN */
		.settings = {
		[GPIOMUX_SUSPENDED] = &mdm_grfc_config,
		},
		},
		};

		void __init fsm9900_init_gpiomux(void)
		{
		int rc;
		@@ -811,6 +970,13 @@ void fsm9900_gluon_init(void)
		msm_gpiomux_install(fsm_gluon_grfc_configs,
		ARRAY_SIZE(fsm_gluon_grfc_configs));
		}

		void fsm9900_mtr_init(void)
		{
		msm_gpiomux_install(fsm_mtr_configs,
		ARRAY_SIZE(fsm_mtr_configs));
		}

		void fsm9900_rfic_init(void)
		{
		msm_gpiomux_install(fsm_mdm_grfc_configs,

arch/arm/mach-msm/include/mach/board.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#define RF_TYPE_16 0x10
		#define RF_TYPE_17 0x11
		#define RF_TYPE_18 0x12
		#define RF_TYPE_19 0x13
		#define RF_TYPE_32 0x20
		#define RF_TYPE_33 0x21
		#define RF_TYPE_48 0x30

arch/arm/mach-msm/rfic-fsm9900.c

+308 −155

Original line number	Diff line number	Diff line
		@@ -49,8 +49,7 @@
		* FTR8700, WTR1605 RFIC
		*/

		#define RFIC_MTR_DEVICE_NUM 5
		#define RFIC_DEVICE_NUM 9
		#define RFIC_DEVICE_NUM 8
		#define RFIC_GRFC_REG_NUM 6

		#define ANY_BUS 0x0
		@@ -83,6 +82,7 @@
		uint8_t rfbid;
		void __iomem *grfc_base;
		void __iomem *pdm_base;
		void __iomem *wf_base;
		/*
		* Device private information per device node
		*/
		@@ -112,6 +112,45 @@ int nDev;

		static int ftr_find_id(int minor);

		static int rf_regulator_init(struct platform_device pdev, char reg_name,
		int opt_mode)
		{
		int ret;
		struct regulator *vreg_ldo;

		vreg_ldo = regulator_get(&pdev->dev, reg_name);
		if (IS_ERR(vreg_ldo)) {
		pr_err("%s: vreg get %s failed (%ld)\n",
		__func__, reg_name, PTR_ERR(vreg_ldo));
		return PTR_ERR(vreg_ldo);
		}

		if (opt_mode) {
		ret = regulator_set_optimum_mode(vreg_ldo, 250000);
		if (ret < 0) {
		pr_err("%s: unable to set optimum mode for %s\n",
		__func__, reg_name);
		return PTR_ERR(vreg_ldo);
		}
		}
		ret = regulator_enable(vreg_ldo);
		if (ret) {
		pr_err("%s: unable to enable %s voltage\n", __func__, reg_name);
		return PTR_ERR(vreg_ldo);
		}

		return 0;
		}

		static ssize_t rfb_id_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		return snprintf(buf, sizeof(int), "%d\n", (int)rfbid);
		}

		static DEVICE_ATTR(rfboard_id, S_IRUGO, rfb_id_show, NULL);


		static int ftr_open(struct inode inode, struct file file)
		{
		struct ftr_dev_file_info *pdfi;
		@@ -165,7 +204,7 @@ static long ftr_ioctl(struct file *file,

		mutex_lock(&pdev->lock);

		if (((pdfi->ftrid == 2) \|\| (pdfi->ftrid == 3))
		if (((pdfi->ftrid == 1) \|\| (pdfi->ftrid == 2))
		&& (rfbid < RF_TYPE_48)) {
		__raw_writel(
		pdev->busselect[RFIC_FTR_GET_BUS(rficaddr)],
		@@ -201,7 +240,7 @@ static long ftr_ioctl(struct file *file,

		mutex_lock(&pdev->lock);

		if (((pdfi->ftrid == 2) \|\| (pdfi->ftrid == 3))
		if (((pdfi->ftrid == 1) \|\| (pdfi->ftrid == 2))
		&& (rfbid < RF_TYPE_48)) {
		__raw_writel(
		pdev->busselect[RFIC_FTR_GET_BUS(rficaddr)],
		@@ -233,7 +272,7 @@ static long ftr_ioctl(struct file *file,

		mutex_lock(&pdev->lock);

		if (((pdfi->ftrid == 2) \|\| (pdfi->ftrid == 3))
		if (((pdfi->ftrid == 1) \|\| (pdfi->ftrid == 2))
		&& (rfbid < RF_TYPE_48)) {
		__raw_writel(
		pdev->busselect[RFIC_FTR_GET_BUS(rficaddr)],
		@@ -352,6 +391,88 @@ static long ftr_ioctl(struct file *file,
		}
		break;

		case RFIC_IOCTL_SET_WFM:
		{
		struct rfic_wfm_param param;

		if (pdfi->ftrid != 0)
		return -EINVAL;

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

		if (param.offset + param.num > 0xA00000)
		return -EINVAL;

		if (copy_from_user(wf_base + param.offset,
		param.pArray, param.num))
		return -EFAULT;
		}
		break;

		case RFIC_IOCTL_SET_LDO:
		{
		unsigned int ldo;

		if (pdfi->ftrid != 0) {
		pr_err("%s: Invalid id %d\n", __func__,
		pdfi->ftrid);
		return -EINVAL;
		}

		if (get_user(ldo, argp)) {
		pr_err("%s: Invalid ldo %d\n", __func__, ldo);
		return -EFAULT;
		}

		switch (ldo) {
		case LDO11:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-1v3", 0) != 0)
		pr_err("%s: LDO11 fail\n", __func__);
		break;
		case LDO18:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-switch", 0) != 0)
		pr_err("%s: LDO18 fail\n", __func__);
		break;
		case LDO19:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-wtr", 0) != 0)
		pr_err("%s: LDO19 fail\n", __func__);
		break;
		case LDO23:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-ftr1", 1) != 0)
		pr_err("%s: LDO23 fail\n", __func__);
		break;
		case LDO25:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-ftr2", 1) != 0)
		pr_err("%s: LDO25 fail\n", __func__);
		break;
		case LDO26:
		if (rf_regulator_init(to_platform_device
		(pdev->dev), "vdd-1v8", 0) != 0)
		pr_err("%s: LDO26 fail\n", __func__);
		break;
		default:
		pr_err("%s: Unknown LDO\n", __func__);
		break;
		}
		}
		break;

		case RFIC_IOCTL_SET_BOARDID:
		{
		if (pdfi->ftrid != 0)
		return -EINVAL;

		if (get_user(rfbid, argp))
		return -EFAULT;
		}
		break;

		case RFIC_IOCTL_GET_BOARDID:
		{
		if (pdfi->ftrid != 0)
		@@ -362,49 +483,74 @@ static long ftr_ioctl(struct file *file,
		}
		break;

		case RFIC_IOCTL_PDM_READ:
		case RFIC_IOCTL_GET_PDM:
		{
		unsigned int pdmaddr;
		u32 value = 0;
		struct pdm_param param;
		void __iomem *pdmaddr;
		int num;

		if (get_user(pdmaddr, argp))
		if (copy_from_user(&param, argp, sizeof(param))) {
		pr_err("%s: CFU\n", __func__);
		return -EFAULT;
		}

		if ((pdfi->ftrid != 0) \|\| (param.num > 5)) {
		pr_err("%s: ftrid %d num =%d\n", __func__,
		pdfi->ftrid, param.num);
		return -EINVAL;
		}

		mutex_lock(&pdev->lock);

		if (pdfi->ftrid == 1)
		value = __raw_readl(pdm_base + pdmaddr);
		if (param.num > 2)
		num = param.num + 1;
		else
		num = param.num;

		pdmaddr = pdm_base + PDM_1_1_CTL * num;
		param.enable = __raw_readl(pdmaddr);
		param.value = __raw_readl(pdmaddr + 4);

		mutex_unlock(&pdev->lock);

		if (put_user(value, argp))
		if (copy_to_user(argp, &param, sizeof(param))) {
		pr_err("%s: CTU\n", __func__);
		return -EFAULT;

		}
		return 0;
		}
		break;

		case RFIC_IOCTL_PDM_WRITE:
		case RFIC_IOCTL_SET_PDM:
		{
		struct pdm_write_param param;
		struct pdm_param param;
		void __iomem *pdmaddr;
		u8 value;
		u16 value;
		int num;

		if (copy_from_user(&param, argp, sizeof(param)))
		if (copy_from_user(&param, argp, sizeof(param))) {
		pr_err("%s: CFU\n", __func__);
		return -EFAULT;
		}

		pdmaddr = pdm_base + param.offset;
		value = (u8) param.value;
		if ((pdfi->ftrid != 0) \|\| (param.num > 5)) {
		pr_err("%s: Invalid id or num\n", __func__);
		return -EINVAL;
		}

		mutex_lock(&pdev->lock);

		if (pdfi->ftrid == 1) {
		__raw_writel(value, pdmaddr);
		mb();
		}
		if (param.num > 2)
		num = param.num + 1;
		else
		num = param.num;

		value = (u16) param.value;
		pdmaddr = pdm_base + PDM_1_1_CTL * num;
		__raw_writel(param.enable, pdmaddr);
		if (param.enable)
		__raw_writel(value, pdmaddr + 4);
		mutex_unlock(&pdev->lock);

		return 0;
		}
		break;
		@@ -455,11 +601,6 @@ struct miscdevice ftr_misc_dev[RFIC_DEVICE_NUM] = {
		.name = GRFC_DEVICE_NAME,
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = PDM_DEVICE_NAME,
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_FTR_DEVICE_NAME "0",
		@@ -497,7 +638,7 @@ struct miscdevice ftr_misc_dev[RFIC_DEVICE_NUM] = {
		},
		};

		struct miscdevice mtr_misc_dev[RFIC_MTR_DEVICE_NUM] = {
		struct miscdevice mtr_misc_dev[RFIC_DEVICE_NUM] = {
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = GRFC_DEVICE_NAME,
		@@ -505,17 +646,32 @@ struct miscdevice mtr_misc_dev[RFIC_MTR_DEVICE_NUM] = {
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = PDM_DEVICE_NAME,
		.name = RFIC_MTR_DEVICE_NAME "0",
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_MTR_DEVICE_NAME "0",
		.name = RFIC_MTR_DEVICE_NAME "1",
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_MTR_DEVICE_NAME "1",
		.name = RFIC_MTR_DEVICE_NAME "2",
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_MTR_DEVICE_NAME "3",
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_WTR_DEVICE_NAME "1-rx",
		.fops = &ftr_fops,
		},
		{
		.minor = MISC_DYNAMIC_MINOR,
		.name = RFIC_WTR_DEVICE_NAME "1-tx",
		.fops = &ftr_fops,
		},
		{
		@@ -529,103 +685,91 @@ int ftr_find_id(int minor)
		{
		int i;

		if (rfbid < RF_TYPE_48) {
		for (i = 0; i < RFIC_DEVICE_NUM; ++i)
		if (ftr_misc_dev[i].minor == minor)
		break;

		return i;
		} else {
		for (i = 0; i < RFIC_DEVICE_NUM; ++i)
		if (mtr_misc_dev[i].minor == minor)
		break;
		}

		static ssize_t rfb_id_show(struct device dev, struct device_attribute attr,
		char *buf)
		{
		return snprintf(buf, sizeof(int), "%d\n", (int)rfbid);
		return i;
		}

		static DEVICE_ATTR(rfboard_id, S_IRUGO, rfb_id_show, NULL);

		static int ftr_regulator_init(struct platform_device *pdev)
		{
		int ret;
		struct regulator vreg_ldo18, vreg_ldo23, *vreg_ldo25;

		vreg_ldo23 = regulator_get(&pdev->dev, "vdd-ftr1");
		if (IS_ERR(vreg_ldo23)) {
		pr_err("%s: vreg get l23-reg failed (%ld)\n",
		__func__, PTR_ERR(vreg_ldo23));
		return PTR_ERR(vreg_ldo23);
		}

		ret = regulator_set_optimum_mode(vreg_ldo23, 250000);
		if (ret < 0) {
		pr_err("%s: unable to set optimum mode for ldo23\n", __func__);
		return PTR_ERR(vreg_ldo23);
		}

		ret = regulator_enable(vreg_ldo23);
		if (ret) {
		pr_err("%s: unable to enable ldo23 voltage\n", __func__);
		return PTR_ERR(vreg_ldo23);
		}

		vreg_ldo25 = regulator_get(&pdev->dev, "vdd-ftr2");
		if (IS_ERR(vreg_ldo25)) {
		pr_err("%s: vreg get l25-reg failed (%ld)\n",
		__func__, PTR_ERR(vreg_ldo25));
		return PTR_ERR(vreg_ldo25);
		}

		ret = regulator_set_optimum_mode(vreg_ldo25, 250000);
		if (ret < 0) {
		pr_err("%s: unable to set optimum mode for ldo25\n", __func__);
		return PTR_ERR(vreg_ldo25);
		}
		ret = (rf_regulator_init(pdev, "vdd-1v8", 0));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-1v3", 0));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-ftr1", 1));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-ftr2", 1));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-switch", 0));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-wtr", 0));
		if (ret)
		return ret;

		ret = regulator_enable(vreg_ldo25);
		if (ret) {
		pr_err("%s: unable to enable ldo25 voltage\n", __func__);
		return PTR_ERR(vreg_ldo25);
		return 0;
		}

		vreg_ldo18 = regulator_get(&pdev->dev, "vdd-switch");
		if (IS_ERR(vreg_ldo18)) {
		pr_err("%s: vreg get l18-reg failed (%ld)\n",
		__func__, PTR_ERR(vreg_ldo18));
		return PTR_ERR(vreg_ldo18);
		}
		static int glu_regulator_init(struct platform_device *pdev)
		{
		int ret;

		ret = regulator_enable(vreg_ldo18);
		if (ret) {
		pr_err("%s: unable to enable ldo18 voltage\n", __func__);
		return PTR_ERR(vreg_ldo18);
		}
		ret = (rf_regulator_init(pdev, "vdd-1v3", 0));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-ftr1", 1));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-ftr2", 1));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-switch", 0));
		if (ret)
		return ret;

		return 0;
		}

		static int wtr_regulator_init(struct platform_device *pdev)
		static int mtr_regulator_init(struct platform_device *pdev)
		{
		int ret;
		struct regulator *vreg_ldo19;

		vreg_ldo19 = regulator_get(&pdev->dev, "vdd-wtr");
		if (IS_ERR(vreg_ldo19)) {
		pr_err("%s: vreg get l19-reg failed (%ld)\n",
		__func__, PTR_ERR(vreg_ldo19));
		return PTR_ERR(vreg_ldo19);
		}
		ret = (rf_regulator_init(pdev, "vdd-ftr1", 1));
		if (ret)
		return ret;

		ret = regulator_enable(vreg_ldo19);
		if (ret) {
		pr_err("%s: unable to enable ldo19 voltage\n", __func__);
		return PTR_ERR(vreg_ldo19);
		}
		ret = (rf_regulator_init(pdev, "vdd-ftr2", 1));
		if (ret)
		return ret;

		return 0;
		}
		udelay(150);

		static int mantaray_regulator_init(struct platform_device *pdev)
		{
		ret = (rf_regulator_init(pdev, "vdd-1v3", 0));
		if (ret)
		return ret;

		udelay(100);

		ret = (rf_regulator_init(pdev, "vdd-1v8", 0));
		if (ret)
		return ret;
		ret = (rf_regulator_init(pdev, "vdd-switch", 0));
		if (ret)
		return ret;

		return 0;
		}
		@@ -641,14 +785,10 @@ static void pdm_enable(void)

		void pdm_mtr_enable(void)
		{
		__raw_writel(PDM_OE, pdm_base + PDM_1_2_CTL);
		__raw_writel(0xb200, pdm_base + PDM_1_2_CTL + 4);
		__raw_writel(PDM_OE, pdm_base + PDM_2_0_CTL);
		__raw_writel(0xb200, pdm_base + PDM_2_0_CTL + 4);
		__raw_writel(PDM_OE, pdm_base + PDM_2_1_CTL);
		__raw_writel(0xb2, pdm_base + PDM_2_1_CTL + 4);
		__raw_writel(PDM_OE, pdm_base + PDM_2_2_CTL);
		__raw_writel(0xb200, pdm_base + PDM_2_2_CTL + 4);
		}


		@@ -674,22 +814,23 @@ static int ftr_probe(struct platform_device *pdev)

		if (!nDev) {
		rfbid = rf_interface_id();
		if ((rfbid != 0xff) && (rfbid != 0))
		rfbid = rfbid & RF_TYPE_48;

		pr_info("%s: RF Board Type 0x%x\n", __func__, rfbid);

		switch (rfbid) {
		case RF_TYPE_16:
		ftr_regulator_init(pdev);
		wtr_regulator_init(pdev);
		break;
		case RF_TYPE_32:
		ftr_regulator_init(pdev);
		glu_regulator_init(pdev);
		break;
		case RF_TYPE_48:
		mantaray_regulator_init(pdev);
		mtr_regulator_init(pdev);
		break;
		default:
		pr_warn("%s:Regulators may not be turned ON %d\n",
		pr_warn("%s:Regulators not turned ON %d\n",
		__func__, rfbid);
		}

		@@ -702,8 +843,12 @@ static int ftr_probe(struct platform_device *pdev)
		break;
		case RF_TYPE_17:
		case RF_TYPE_18:
		case RF_TYPE_19:
		fsm9900_rfic_init();
		break;
		case RF_TYPE_49:
		fsm9900_mtr_init();
		break;
		default:
		pr_warn("%s:GPIOs not configured %d\n",
		__func__, rfbid);
		@@ -715,16 +860,24 @@ static int ftr_probe(struct platform_device *pdev)
		mutex_unlock(&rficlock);
		return PTR_ERR(grfc_base);
		}
		ret = device_create_file(&pdev->dev, &dev_attr_rfboard_id);
		WARN_ON(ret);

		} else if ((nDev == 1) && (rfbid > RF_TYPE_48)) {
		mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
		wf_base = devm_ioremap_resource(&pdev->dev, mem_res);
		if (IS_ERR(wf_base)) {
		mutex_unlock(&rficlock);
		return PTR_ERR(wf_base);
		}

		mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
		pdm_base = devm_ioremap_resource(&pdev->dev, mem_res);
		if (IS_ERR(pdm_base)) {
		mutex_unlock(&rficlock);
		return PTR_ERR(pdm_base);
		}

		ret = device_create_file(&pdev->dev, &dev_attr_rfboard_id);
		WARN_ON(ret);

		pdm_clk = clk_get(&pdev->dev, "ahb_clk");
		if (IS_ERR(pdm_clk)) {
		pdm_clk = NULL;
		@@ -747,43 +900,43 @@ static int ftr_probe(struct platform_device *pdev)
		clk_enable(pdm_clk);
		}

		if ((rfbid > RF_TYPE_48) && (rfbid != 0xff)) {
		pdm_mtr_enable();
		pr_info("%s: MTR PDM Enabled\n", __func__);
		} else if ((nDev == 1) && (rfbid > RF_TYPE_16) &&
		(rfbid < RF_TYPE_32)) {
		mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		pdm_base = devm_ioremap_resource(&pdev->dev, mem_res);
		if (IS_ERR(pdm_base)) {
		mutex_unlock(&rficlock);
		return PTR_ERR(pdm_base);
		}

		pdm_clk = clk_get(&pdev->dev, "ahb_clk");
		if (IS_ERR(pdm_clk)) {
		pdm_clk = NULL;
		pr_err("%s: AHB CLK is NULL\n", __func__);
		} else {
		clk_prepare(pdm_clk);
		clk_enable(pdm_clk);
		}

		pdm_clk = clk_get(&pdev->dev, "pdm2_clk");
		if (IS_ERR(pdm_clk)) {
		pdm_clk = NULL;
		pr_err("%s: PDM2 CLK is NULL\n", __func__);
		} else if ((rfbid > RF_TYPE_16) && (rfbid < RF_TYPE_32)) {
		pdm_enable();
		pr_info("%s: PDM Enabled\n", __func__);
		} else {
		clk_prepare(pdm_clk);
		clk_enable(pdm_clk);
		pr_warn("%s:PDMs not configured %d\n",
		__func__, rfbid);
		}

		pdm_enable();
		pr_info("%s: PDM Enabled\n", __func__);
		}

		ptr = ftr_dev_info + nDev;
		ptr->dev = &pdev->dev;

		if (((rfbid & RF_TYPE_16) \|\| ((rfbid & RF_TYPE_32))) && (nDev == 2)) {
		if ((nDev >= 1) && (nDev <= 7)) {
		struct ssbi *ssbi =
		platform_get_drvdata(to_platform_device(pdev->dev.parent));
		if ((rfbid > RF_TYPE_48) && (nDev <= 4)) {
		ssbi->controller_type =
		FSM_SBI_CTRL_GENI_SSBI2_ARBITER;
		set_ssbi_mode_2(ssbi->base);
		pr_debug("%s: SSBI2 = 0x%x\n", __func__,
		ssbi->controller_type);
		} else {
		ssbi->controller_type =
		FSM_SBI_CTRL_GENI_SSBI_ARBITER;
		set_ssbi_mode_1(ssbi->base);
		pr_debug("%s: SSBI1 = 0x%x\n", __func__,
		ssbi->controller_type);
		}
		platform_set_drvdata(to_platform_device(pdev->dev.parent),
		ssbi);
		}

		if ((rfbid > RF_TYPE_16) && (rfbid < RF_TYPE_48) && (nDev == 1)) {
		ssbi_write(pdev->dev.parent, 0xff, &version, 1);
		ssbi_read(pdev->dev.parent, 0x2, &version, 1);
		pr_info("%s: FTR1 Version = %02x\n", __func__, version);
		@@ -796,8 +949,8 @@ static int ftr_probe(struct platform_device *pdev)
		ptr->busselect[TX2_BUS] = 0x00001000;
		ptr->busselect[MISC_BUS] = 0x00000800;
		ptr->busselect[RX_BUS] = 0x00001800;
		} else if (((rfbid & RF_TYPE_16) \|\| ((rfbid & RF_TYPE_32))) &&
		(nDev == 3)) {
		} else if ((rfbid > RF_TYPE_16) && (rfbid < RF_TYPE_48) &&
		(nDev == 2)) {
		ssbi_write(pdev->dev.parent, 0xff, &version, 1);
		ssbi_read(pdev->dev.parent, 0x2, &version, 1);
		pr_info("%s: FTR2 Version = %02x\n", __func__, version);
		@@ -833,7 +986,7 @@ static int ftr_probe(struct platform_device *pdev)
		}

		nDev++;
		pr_info("%s: num_of_ssbi_devices = %d\n", __func__, nDev);
		pr_debug("%s: num_of_ssbi_devices = %d\n", __func__, nDev);
		mutex_unlock(&rficlock);

		return of_platform_populate(np, NULL, NULL, &pdev->dev);
		@@ -848,7 +1001,7 @@ static int ftr_remove(struct platform_device *pdev)
		for (i = 0; i < RFIC_DEVICE_NUM; ++i)
		misc_deregister(ftr_misc_dev + i);
		} else {
		for (i = 0; i < RFIC_MTR_DEVICE_NUM; ++i)
		for (i = 0; i < RFIC_DEVICE_NUM; ++i)
		misc_deregister(mtr_misc_dev + i);
		}
		return 0;

include/linux/fsm_rfic.h

+27 −4

Original line number	Diff line number	Diff line
		@@ -33,6 +33,13 @@ void fsm9900_mtr_init(void);
		#define PDM_DEVICE_NAME "pdm"
		#define BBIF_DEVICE_NAME "bbif"

		#define LDO11 1
		#define LDO18 2
		#define LDO19 3
		#define LDO23 4
		#define LDO25 5
		#define LDO26 6

		/*
		* IOCTL interface
		*/
		@@ -64,9 +71,10 @@ struct rfic_grfc_param {
		unsigned int ctrlvalue;
		};

		struct pdm_write_param {
		unsigned int offset;
		struct pdm_param {
		unsigned int num;
		unsigned int value;
		unsigned int enable;
		};

		struct bbif_param {
		@@ -95,6 +103,12 @@ struct rfic_gpio_param {
		struct gpio_alt_config *pArray;
		};

		struct rfic_wfm_param {
		unsigned int num;
		unsigned int offset;
		void *pArray;
		};

		#define RFIC_IOCTL_MAGIC 'f'
		#define RFIC_IOCTL_READ_REGISTER \
		_IOC(_IOC_READ, RFIC_IOCTL_MAGIC, 0x01, \
		@@ -117,10 +131,13 @@ struct rfic_gpio_param {
		#define RFIC_IOCTL_GET_BOARDID \
		_IOC(_IOC_READ, RFIC_IOCTL_MAGIC, 0x20, \
		sizeof(unsigned int *))
		#define RFIC_IOCTL_PDM_READ \
		#define RFIC_IOCTL_SET_BOARDID \
		_IOC(_IOC_READ, RFIC_IOCTL_MAGIC, 0x21, \
		sizeof(unsigned int *))
		#define RFIC_IOCTL_GET_PDM \
		_IOC(_IOC_READ, RFIC_IOCTL_MAGIC, 0x31, \
		sizeof(unsigned int *))
		#define RFIC_IOCTL_PDM_WRITE \
		#define RFIC_IOCTL_SET_PDM \
		_IOC(_IOC_WRITE, RFIC_IOCTL_MAGIC, 0x32, \
		sizeof(struct pdm_write_param *))
		#define BBIF_IOCTL_GET \
		@@ -132,4 +149,10 @@ struct rfic_gpio_param {
		#define BBIF_IOCTL_SET_ADC_BW \
		_IOC(_IOC_WRITE, RFIC_IOCTL_MAGIC, 0x43, \
		sizeof(struct bbif_bw_param *))
		#define RFIC_IOCTL_SET_LDO \
		_IOC(_IOC_WRITE, RFIC_IOCTL_MAGIC, 0x50, \
		sizeof(unsigned int *))
		#define RFIC_IOCTL_SET_WFM \
		_IOC(_IOC_WRITE, RFIC_IOCTL_MAGIC, 0x51, \
		sizeof(unsigned int *))
		#endif /* _FSM_RFIC_H_ */