Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a648256 authored by Robert Jarzmik's avatar Robert Jarzmik Committed by Eric Miao
Browse files

[ARM] pxa: factor pxamci gpio handling 



Several boards use always the same pattern with pxamci :
request gpio, request irq for that gpio to detect MMC card
insertion, request gpio for read-only mode detection, etc
...

Now that pxamci provides platform_data to describe simple
gpio management of the MMC external controls, use it.

Signed-off-by: default avatarRobert Jarzmik <robert.jarzmik@free.fr>
Acked-by: default avatarMike Rapoport <mike@compulab.co.il>
Acked-by: default avatarPhilipp Zabel <philipp.zabel@gmail.com>
Acked-by: default avatarDmitry Eremin-Solenikov <dbaryshkov@gmail.com>
Cc: rpurdie@rpsys.net
Cc: drwyrm@gmail.com
Cc: sakoman@gmail.com
Cc: marek.vasut@gmail.com
Cc: s.hauer@pengutronix.de
Signed-off-by: default avatarEric Miao <eric.y.miao@gmail.com>
parent b405db6c

arch/arm/mach-pxa/cm-x270.c

+5 −49
Original line number Diff line number Diff line
@@ -271,56 +271,12 @@ static inline void cmx270_init_ohci(void) {} 
#endif



#if defined(CONFIG_MMC) || defined(CONFIG_MMC_MODULE)

static int cmx270_mci_init(struct device *dev,

			   irq_handler_t cmx270_detect_int,

			   void *data)

{

	int err;



	err = gpio_request(GPIO105_MMC_POWER, "MMC/SD power");

	if (err) {

		dev_warn(dev, "power gpio unavailable\n");

		return err;

	}



	gpio_direction_output(GPIO105_MMC_POWER, 0);



	err = request_irq(CMX270_MMC_IRQ, cmx270_detect_int,

			  IRQF_DISABLED | IRQF_TRIGGER_FALLING,

			  "MMC card detect", data);

	if (err) {

		gpio_free(GPIO105_MMC_POWER);

		dev_err(dev, "cmx270_mci_init: MMC/SD: can't"

			" request MMC card detect IRQ\n");

	}



	return err;

}



static void cmx270_mci_setpower(struct device *dev, unsigned int vdd)

{

	struct pxamci_platform_data *p_d = dev->platform_data;



	if ((1 << vdd) & p_d->ocr_mask) {

		dev_dbg(dev, "power on\n");

		gpio_set_value(GPIO105_MMC_POWER, 0);

	} else {

		gpio_set_value(GPIO105_MMC_POWER, 1);

		dev_dbg(dev, "power off\n");

	}

}



static void cmx270_mci_exit(struct device *dev, void *data)

{

	free_irq(CMX270_MMC_IRQ, data);

	gpio_free(GPIO105_MMC_POWER);

}



static struct pxamci_platform_data cmx270_mci_platform_data = {

	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,

	.init 		= cmx270_mci_init,

	.setpower 	= cmx270_mci_setpower,

	.exit		= cmx270_mci_exit,

	.gpio_card_detect	= GPIO83_MMC_IRQ,

	.gpio_card_ro		= -1,

	.gpio_power		= GPIO105_MMC_POWER,

	.gpio_power_invert	= 1,

};



static void __init cmx270_init_mmc(void)

arch/arm/mach-pxa/cm-x300.c

+12 −59
Original line number Diff line number Diff line
@@ -310,64 +310,17 @@ static struct pxamci_platform_data cm_x300_mci_platform_data = { 
	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,

	.init 			= cm_x300_mci_init,

	.exit			= cm_x300_mci_exit,

	.gpio_card_detect	= -1,

	.gpio_card_ro		= -1,

	.gpio_power		= -1,

};



static int cm_x300_mci2_ro(struct device *dev)

{

	return gpio_get_value(GPIO85_MMC2_WP);

}



static int cm_x300_mci2_init(struct device *dev,

			     irq_handler_t cm_x300_detect_int,

			     void *data)

{

	int err;



	/*

	 * setup GPIO for CM-X300 MMC controller

	 */

	err = gpio_request(GPIO82_MMC2_IRQ, "mmc card detect");

	if (err)

		goto err_request_cd;

	gpio_direction_input(GPIO82_MMC2_IRQ);



	err = gpio_request(GPIO85_MMC2_WP, "mmc write protect");

	if (err)

		goto err_request_wp;

	gpio_direction_input(GPIO85_MMC2_WP);



	err = request_irq(CM_X300_MMC2_IRQ, cm_x300_detect_int,

			  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

			  "MMC card detect", data);

	if (err) {

		printk(KERN_ERR "%s: MMC/SD/SDIO: "

				"can't request card detect IRQ\n", __func__);

		goto err_request_irq;

	}



	return 0;



err_request_irq:

	gpio_free(GPIO85_MMC2_WP);

err_request_wp:

	gpio_free(GPIO82_MMC2_IRQ);

err_request_cd:

	return err;

}



static void cm_x300_mci2_exit(struct device *dev, void *data)

{

	free_irq(CM_X300_MMC2_IRQ, data);

	gpio_free(GPIO82_MMC2_IRQ);

	gpio_free(GPIO85_MMC2_WP);

}



static struct pxamci_platform_data cm_x300_mci2_platform_data = {

	.detect_delay		= 20,

	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,

	.init 		= cm_x300_mci2_init,

	.exit		= cm_x300_mci2_exit,

	.get_ro		= cm_x300_mci2_ro,

	.gpio_card_detect	= GPIO82_MMC2_IRQ,

	.gpio_card_ro		= GPIO85_MMC2_WP,

	.gpio_power		= -1,

};



static void __init cm_x300_init_mmc(void)

arch/arm/mach-pxa/colibri-pxa3xx.c

+7 −4
Original line number Diff line number Diff line
@@ -99,6 +99,9 @@ static struct pxamci_platform_data colibri_pxa3xx_mci_platform_data = { 
	.ocr_mask		= MMC_VDD_32_33 | MMC_VDD_33_34,

	.init			= colibri_pxa3xx_mci_init,

	.exit			= colibri_pxa3xx_mci_exit,

	.gpio_card_detect	= -1,

	.gpio_card_ro		= -1,

	.gpio_power		= -1,

};



void __init colibri_pxa3xx_init_mmc(mfp_cfg_t *pins, int len, int detect_pin)

arch/arm/mach-pxa/corgi.c

+5 −70
Original line number Diff line number Diff line
@@ -307,77 +307,11 @@ static struct platform_device corgiled_device = { 
 * The card detect interrupt isn't debounced so we delay it by 250ms

 * to give the card a chance to fully insert/eject.

 */

static struct pxamci_platform_data corgi_mci_platform_data;



static int corgi_mci_init(struct device *dev, irq_handler_t corgi_detect_int, void *data)

{

	int err;



	err = gpio_request(CORGI_GPIO_nSD_DETECT, "nSD_DETECT");

	if (err)

		goto err_out;



	err = gpio_request(CORGI_GPIO_nSD_WP, "nSD_WP");

	if (err)

		goto err_free_1;



	err = gpio_request(CORGI_GPIO_SD_PWR, "SD_PWR");

	if (err)

		goto err_free_2;



	gpio_direction_input(CORGI_GPIO_nSD_DETECT);

	gpio_direction_input(CORGI_GPIO_nSD_WP);

	gpio_direction_output(CORGI_GPIO_SD_PWR, 0);



	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);



	err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_detect_int,

				IRQF_DISABLED | IRQF_TRIGGER_RISING |

				IRQF_TRIGGER_FALLING,

				"MMC card detect", data);

	if (err) {

		pr_err("%s: MMC/SD: can't request MMC card detect IRQ\n",

				__func__);

		goto err_free_3;

	}

	return 0;



err_free_3:

	gpio_free(CORGI_GPIO_SD_PWR);

err_free_2:

	gpio_free(CORGI_GPIO_nSD_WP);

err_free_1:

	gpio_free(CORGI_GPIO_nSD_DETECT);

err_out:

	return err;

}



static void corgi_mci_setpower(struct device *dev, unsigned int vdd)

{

	struct pxamci_platform_data* p_d = dev->platform_data;



	gpio_set_value(CORGI_GPIO_SD_PWR, ((1 << vdd) & p_d->ocr_mask));

}



static int corgi_mci_get_ro(struct device *dev)

{

	return gpio_get_value(CORGI_GPIO_nSD_WP);

}



static void corgi_mci_exit(struct device *dev, void *data)

{

	free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);

	gpio_free(CORGI_GPIO_SD_PWR);

	gpio_free(CORGI_GPIO_nSD_WP);

	gpio_free(CORGI_GPIO_nSD_DETECT);

}



static struct pxamci_platform_data corgi_mci_platform_data = {

	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,

	.init 		= corgi_mci_init,

	.get_ro		= corgi_mci_get_ro,

	.setpower 	= corgi_mci_setpower,

	.exit		= corgi_mci_exit,

	.gpio_card_detect	= -1,

	.gpio_card_ro		= CORGI_GPIO_nSD_WP,

	.gpio_power		= CORGI_GPIO_SD_PWR,

};
@@ -636,6 +570,7 @@ static void __init corgi_init(void) 
	corgi_init_spi();



 	pxa_set_udc_info(&udc_info);

	corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);

	pxa_set_mci_info(&corgi_mci_platform_data);

	pxa_set_ficp_info(&corgi_ficp_platform_data);

	pxa_set_i2c_info(NULL);

arch/arm/mach-pxa/csb726.c

+5 −49
Original line number Diff line number Diff line
@@ -130,61 +130,17 @@ static struct pxamci_platform_data csb726_mci_data; 
static int csb726_mci_init(struct device *dev,

		irq_handler_t detect, void *data)

{

	int err;



	csb726_mci_data.detect_delay = msecs_to_jiffies(500);



	err = gpio_request(CSB726_GPIO_MMC_DETECT, "MMC detect");

	if (err)

		goto err_det_req;



	err = gpio_direction_input(CSB726_GPIO_MMC_DETECT);

	if (err)

		goto err_det_dir;



	err = gpio_request(CSB726_GPIO_MMC_RO, "MMC ro");

	if (err)

		goto err_ro_req;



	err = gpio_direction_input(CSB726_GPIO_MMC_RO);

	if (err)

		goto err_ro_dir;



	err = request_irq(gpio_to_irq(CSB726_GPIO_MMC_DETECT), detect,

			IRQF_DISABLED, "MMC card detect", data);

	if (err)

		goto err_irq;



	return 0;



err_irq:

err_ro_dir:

	gpio_free(CSB726_GPIO_MMC_RO);

err_ro_req:

err_det_dir:

	gpio_free(CSB726_GPIO_MMC_DETECT);

err_det_req:

	return err;

}



static int csb726_mci_get_ro(struct device *dev)

{

	return gpio_get_value(CSB726_GPIO_MMC_RO);

}



static void csb726_mci_exit(struct device *dev, void *data)

{

	free_irq(gpio_to_irq(CSB726_GPIO_MMC_DETECT), data);

	gpio_free(CSB726_GPIO_MMC_RO);

	gpio_free(CSB726_GPIO_MMC_DETECT);

}



static struct pxamci_platform_data csb726_mci = {

	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,

	.init			= csb726_mci_init,

	.get_ro		= csb726_mci_get_ro,

	/* FIXME setpower */

	.exit		= csb726_mci_exit,

	.gpio_card_detect	= CSB726_GPIO_MMC_DETECT,

	.gpio_card_ro		= CSB726_GPIO_MMC_RO,

	.gpio_power		= -1,

};



static struct pxaohci_platform_data csb726_ohci_platform_data = {