[mirror_ubuntu-hirsute-kernel.git] / arch / arm / mach-imx / mx31moboard-marxbot.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2009 Valentin Longchamp, EPFL Mobots group
 */

#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/types.h>

#include <linux/usb/otg.h>

#include "board-mx31moboard.h"
#include "common.h"
#include "devices-imx31.h"
#include "ehci.h"
#include "hardware.h"
#include "iomux-mx3.h"
#include "ulpi.h"

static unsigned int marxbot_pins[] = {
	/* SDHC2 */
	MX31_PIN_PC_PWRON__SD2_DATA3, MX31_PIN_PC_VS1__SD2_DATA2,
	MX31_PIN_PC_READY__SD2_DATA1, MX31_PIN_PC_WAIT_B__SD2_DATA0,
	MX31_PIN_PC_CD2_B__SD2_CLK, MX31_PIN_PC_CD1_B__SD2_CMD,
	MX31_PIN_ATA_DIOR__GPIO3_28, MX31_PIN_ATA_DIOW__GPIO3_29,
	/* dsPIC resets */
	MX31_PIN_STXD5__GPIO1_21, MX31_PIN_SRXD5__GPIO1_22,
	/*battery detection */
	MX31_PIN_LCS0__GPIO3_23,
	/* USB H1 */
	MX31_PIN_CSPI1_MISO__USBH1_RXDP, MX31_PIN_CSPI1_MOSI__USBH1_RXDM,
	MX31_PIN_CSPI1_SS0__USBH1_TXDM, MX31_PIN_CSPI1_SS1__USBH1_TXDP,
	MX31_PIN_CSPI1_SS2__USBH1_RCV, MX31_PIN_CSPI1_SCLK__USBH1_OEB,
	MX31_PIN_CSPI1_SPI_RDY__USBH1_FS, MX31_PIN_SFS6__USBH1_SUSPEND,
	MX31_PIN_NFRE_B__GPIO1_11, MX31_PIN_NFALE__GPIO1_12,
	/* SEL */
	MX31_PIN_DTR_DCE1__GPIO2_8, MX31_PIN_DSR_DCE1__GPIO2_9,
	MX31_PIN_RI_DCE1__GPIO2_10, MX31_PIN_DCD_DCE1__GPIO2_11,
};

#define SDHC2_CD IOMUX_TO_GPIO(MX31_PIN_ATA_DIOR)
#define SDHC2_WP IOMUX_TO_GPIO(MX31_PIN_ATA_DIOW)

static int marxbot_sdhc2_get_ro(struct device *dev)
{
	return !gpio_get_value(SDHC2_WP);
}

static int marxbot_sdhc2_init(struct device *dev, irq_handler_t detect_irq,
		void *data)
{
	int ret;

	ret = gpio_request(SDHC2_CD, "sdhc-detect");
	if (ret)
		return ret;

	gpio_direction_input(SDHC2_CD);

	ret = gpio_request(SDHC2_WP, "sdhc-wp");
	if (ret)
		goto err_gpio_free;
	gpio_direction_input(SDHC2_WP);

	ret = request_irq(gpio_to_irq(SDHC2_CD), detect_irq,
		IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
		"sdhc2-card-detect", data);
	if (ret)
		goto err_gpio_free_2;

	return 0;

err_gpio_free_2:
	gpio_free(SDHC2_WP);
err_gpio_free:
	gpio_free(SDHC2_CD);

	return ret;
}

static void marxbot_sdhc2_exit(struct device *dev, void *data)
{
	free_irq(gpio_to_irq(SDHC2_CD), data);
	gpio_free(SDHC2_WP);
	gpio_free(SDHC2_CD);
}

static const struct imxmmc_platform_data sdhc2_pdata __initconst = {
	.get_ro	= marxbot_sdhc2_get_ro,
	.init	= marxbot_sdhc2_init,
	.exit	= marxbot_sdhc2_exit,
};

#define TRSLAT_RST_B	IOMUX_TO_GPIO(MX31_PIN_STXD5)
#define DSPICS_RST_B	IOMUX_TO_GPIO(MX31_PIN_SRXD5)

static void dspics_resets_init(void)
{
	if (!gpio_request(TRSLAT_RST_B, "translator-rst")) {
		gpio_direction_output(TRSLAT_RST_B, 0);
		gpio_export(TRSLAT_RST_B, false);
	}

	if (!gpio_request(DSPICS_RST_B, "dspics-rst")) {
		gpio_direction_output(DSPICS_RST_B, 0);
		gpio_export(DSPICS_RST_B, false);
	}
}

static struct spi_board_info marxbot_spi_board_info[] __initdata = {
	{
		.modalias = "spidev",
		.max_speed_hz = 300000,
		.bus_num = 1,
		.chip_select = 1, /* according spi1_cs[] ! */
	},
};

#define SEL0 IOMUX_TO_GPIO(MX31_PIN_DTR_DCE1)
#define SEL1 IOMUX_TO_GPIO(MX31_PIN_DSR_DCE1)
#define SEL2 IOMUX_TO_GPIO(MX31_PIN_RI_DCE1)
#define SEL3 IOMUX_TO_GPIO(MX31_PIN_DCD_DCE1)

static void marxbot_init_sel_gpios(void)
{
	if (!gpio_request(SEL0, "sel0")) {
		gpio_direction_input(SEL0);
		gpio_export(SEL0, true);
	}

	if (!gpio_request(SEL1, "sel1")) {
		gpio_direction_input(SEL1);
		gpio_export(SEL1, true);
	}

	if (!gpio_request(SEL2, "sel2")) {
		gpio_direction_input(SEL2);
		gpio_export(SEL2, true);
	}

	if (!gpio_request(SEL3, "sel3")) {
		gpio_direction_input(SEL3);
		gpio_export(SEL3, true);
	}
}

#define USB_PAD_CFG (PAD_CTL_DRV_MAX | PAD_CTL_SRE_FAST | PAD_CTL_HYS_CMOS | \
			PAD_CTL_ODE_CMOS | PAD_CTL_100K_PU)

static int marxbot_usbh1_hw_init(struct platform_device *pdev)
{
	mxc_iomux_set_gpr(MUX_PGP_USB_SUSPEND, true);

	mxc_iomux_set_pad(MX31_PIN_CSPI1_MISO, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_MOSI, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS0, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS1, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS2, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_SCLK, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_CSPI1_SPI_RDY, USB_PAD_CFG);
	mxc_iomux_set_pad(MX31_PIN_SFS6, USB_PAD_CFG);

	mdelay(10);

	return mx31_initialize_usb_hw(pdev->id, MXC_EHCI_POWER_PINS_ENABLED |
			MXC_EHCI_INTERFACE_SINGLE_UNI);
}

#define USBH1_VBUSEN_B	IOMUX_TO_GPIO(MX31_PIN_NFRE_B)
#define USBH1_MODE	IOMUX_TO_GPIO(MX31_PIN_NFALE)

static int marxbot_isp1105_init(struct usb_phy *otg)
{
	int ret = gpio_request(USBH1_MODE, "usbh1-mode");
	if (ret)
		return ret;
	/* single ended */
	gpio_direction_output(USBH1_MODE, 0);

	ret = gpio_request(USBH1_VBUSEN_B, "usbh1-vbusen");
	if (ret) {
		gpio_free(USBH1_MODE);
		return ret;
	}
	gpio_direction_output(USBH1_VBUSEN_B, 1);

	return 0;
}


static int marxbot_isp1105_set_vbus(struct usb_otg *otg, bool on)
{
	if (on)
		gpio_set_value(USBH1_VBUSEN_B, 0);
	else
		gpio_set_value(USBH1_VBUSEN_B, 1);

	return 0;
}

static struct mxc_usbh_platform_data usbh1_pdata __initdata = {
	.init	= marxbot_usbh1_hw_init,
	.portsc	= MXC_EHCI_MODE_UTMI | MXC_EHCI_SERIAL,
};

static int __init marxbot_usbh1_init(void)
{
	struct usb_phy *phy;
	struct platform_device *pdev;

	phy = kzalloc(sizeof(*phy), GFP_KERNEL);
	if (!phy)
		return -ENOMEM;

	phy->otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
	if (!phy->otg) {
		kfree(phy);
		return -ENOMEM;
	}

	phy->label	= "ISP1105";
	phy->init	= marxbot_isp1105_init;
	phy->otg->set_vbus	= marxbot_isp1105_set_vbus;

	usbh1_pdata.otg = phy;

	pdev = imx31_add_mxc_ehci_hs(1, &usbh1_pdata);

	return PTR_ERR_OR_ZERO(pdev);
}

static const struct fsl_usb2_platform_data usb_pdata __initconst = {
	.operating_mode	= FSL_USB2_DR_DEVICE,
	.phy_mode	= FSL_USB2_PHY_ULPI,
};

/*
 * system init for baseboard usage. Will be called by mx31moboard init.
 */
void __init mx31moboard_marxbot_init(void)
{
	printk(KERN_INFO "Initializing mx31marxbot peripherals\n");

	mxc_iomux_setup_multiple_pins(marxbot_pins, ARRAY_SIZE(marxbot_pins),
		"marxbot");

	marxbot_init_sel_gpios();

	dspics_resets_init();

	imx31_add_mxc_mmc(1, &sdhc2_pdata);

	spi_register_board_info(marxbot_spi_board_info,
		ARRAY_SIZE(marxbot_spi_board_info));

	/* battery present pin */
	gpio_request(IOMUX_TO_GPIO(MX31_PIN_LCS0), "bat-present");
	gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_LCS0));
	gpio_export(IOMUX_TO_GPIO(MX31_PIN_LCS0), false);

	imx31_add_fsl_usb2_udc(&usb_pdata);

	marxbot_usbh1_init();
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2009 Valentin Longchamp, EPFL Mobots group
	4	*/
	5
	6	#include <linux/delay.h>
	7	#include <linux/gpio.h>
	8	#include <linux/init.h>
	9	#include <linux/interrupt.h>
	10	#include <linux/i2c.h>
	11	#include <linux/spi/spi.h>
	12	#include <linux/slab.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/types.h>
	15
	16	#include <linux/usb/otg.h>
	17
	18	#include "board-mx31moboard.h"
	19	#include "common.h"
	20	#include "devices-imx31.h"
	21	#include "ehci.h"
	22	#include "hardware.h"
	23	#include "iomux-mx3.h"
	24	#include "ulpi.h"
	25
	26	static unsigned int marxbot_pins[] = {
	27	/* SDHC2 */
	28	MX31_PIN_PC_PWRON__SD2_DATA3, MX31_PIN_PC_VS1__SD2_DATA2,
	29	MX31_PIN_PC_READY__SD2_DATA1, MX31_PIN_PC_WAIT_B__SD2_DATA0,
	30	MX31_PIN_PC_CD2_B__SD2_CLK, MX31_PIN_PC_CD1_B__SD2_CMD,
	31	MX31_PIN_ATA_DIOR__GPIO3_28, MX31_PIN_ATA_DIOW__GPIO3_29,
	32	/* dsPIC resets */
	33	MX31_PIN_STXD5__GPIO1_21, MX31_PIN_SRXD5__GPIO1_22,
	34	/battery detection /
	35	MX31_PIN_LCS0__GPIO3_23,
	36	/* USB H1 */
	37	MX31_PIN_CSPI1_MISO__USBH1_RXDP, MX31_PIN_CSPI1_MOSI__USBH1_RXDM,
	38	MX31_PIN_CSPI1_SS0__USBH1_TXDM, MX31_PIN_CSPI1_SS1__USBH1_TXDP,
	39	MX31_PIN_CSPI1_SS2__USBH1_RCV, MX31_PIN_CSPI1_SCLK__USBH1_OEB,
	40	MX31_PIN_CSPI1_SPI_RDY__USBH1_FS, MX31_PIN_SFS6__USBH1_SUSPEND,
	41	MX31_PIN_NFRE_B__GPIO1_11, MX31_PIN_NFALE__GPIO1_12,
	42	/* SEL */
	43	MX31_PIN_DTR_DCE1__GPIO2_8, MX31_PIN_DSR_DCE1__GPIO2_9,
	44	MX31_PIN_RI_DCE1__GPIO2_10, MX31_PIN_DCD_DCE1__GPIO2_11,
	45	};
	46
	47	#define SDHC2_CD IOMUX_TO_GPIO(MX31_PIN_ATA_DIOR)
	48	#define SDHC2_WP IOMUX_TO_GPIO(MX31_PIN_ATA_DIOW)
	49
	50	static int marxbot_sdhc2_get_ro(struct device *dev)
	51	{
	52	return !gpio_get_value(SDHC2_WP);
	53	}
	54
	55	static int marxbot_sdhc2_init(struct device *dev, irq_handler_t detect_irq,
	56	void *data)
	57	{
	58	int ret;
	59
	60	ret = gpio_request(SDHC2_CD, "sdhc-detect");
	61	if (ret)
	62	return ret;
	63
	64	gpio_direction_input(SDHC2_CD);
	65
	66	ret = gpio_request(SDHC2_WP, "sdhc-wp");
	67	if (ret)
	68	goto err_gpio_free;
	69	gpio_direction_input(SDHC2_WP);
	70
	71	ret = request_irq(gpio_to_irq(SDHC2_CD), detect_irq,
	72	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	73	"sdhc2-card-detect", data);
	74	if (ret)
	75	goto err_gpio_free_2;
	76
	77	return 0;
	78
	79	err_gpio_free_2:
	80	gpio_free(SDHC2_WP);
	81	err_gpio_free:
	82	gpio_free(SDHC2_CD);
	83
	84	return ret;
	85	}
	86
	87	static void marxbot_sdhc2_exit(struct device dev, void data)
	88	{
	89	free_irq(gpio_to_irq(SDHC2_CD), data);
	90	gpio_free(SDHC2_WP);
	91	gpio_free(SDHC2_CD);
	92	}
	93
	94	static const struct imxmmc_platform_data sdhc2_pdata __initconst = {
	95	.get_ro = marxbot_sdhc2_get_ro,
	96	.init = marxbot_sdhc2_init,
	97	.exit = marxbot_sdhc2_exit,
	98	};
	99
	100	#define TRSLAT_RST_B IOMUX_TO_GPIO(MX31_PIN_STXD5)
	101	#define DSPICS_RST_B IOMUX_TO_GPIO(MX31_PIN_SRXD5)
	102
	103	static void dspics_resets_init(void)
	104	{
	105	if (!gpio_request(TRSLAT_RST_B, "translator-rst")) {
	106	gpio_direction_output(TRSLAT_RST_B, 0);
	107	gpio_export(TRSLAT_RST_B, false);
	108	}
	109
	110	if (!gpio_request(DSPICS_RST_B, "dspics-rst")) {
	111	gpio_direction_output(DSPICS_RST_B, 0);
	112	gpio_export(DSPICS_RST_B, false);
	113	}
	114	}
	115
	116	static struct spi_board_info marxbot_spi_board_info[] __initdata = {
	117	{
	118	.modalias = "spidev",
	119	.max_speed_hz = 300000,
	120	.bus_num = 1,
	121	.chip_select = 1, /* according spi1_cs[] ! */
	122	},
	123	};
	124
	125	#define SEL0 IOMUX_TO_GPIO(MX31_PIN_DTR_DCE1)
	126	#define SEL1 IOMUX_TO_GPIO(MX31_PIN_DSR_DCE1)
	127	#define SEL2 IOMUX_TO_GPIO(MX31_PIN_RI_DCE1)
	128	#define SEL3 IOMUX_TO_GPIO(MX31_PIN_DCD_DCE1)
	129
	130	static void marxbot_init_sel_gpios(void)
	131	{
	132	if (!gpio_request(SEL0, "sel0")) {
	133	gpio_direction_input(SEL0);
	134	gpio_export(SEL0, true);
	135	}
	136
	137	if (!gpio_request(SEL1, "sel1")) {
	138	gpio_direction_input(SEL1);
	139	gpio_export(SEL1, true);
	140	}
	141
	142	if (!gpio_request(SEL2, "sel2")) {
	143	gpio_direction_input(SEL2);
	144	gpio_export(SEL2, true);
	145	}
	146
	147	if (!gpio_request(SEL3, "sel3")) {
	148	gpio_direction_input(SEL3);
	149	gpio_export(SEL3, true);
	150	}
	151	}
	152
	153	#define USB_PAD_CFG (PAD_CTL_DRV_MAX \| PAD_CTL_SRE_FAST \| PAD_CTL_HYS_CMOS \| \
	154	PAD_CTL_ODE_CMOS \| PAD_CTL_100K_PU)
	155
	156	static int marxbot_usbh1_hw_init(struct platform_device *pdev)
	157	{
	158	mxc_iomux_set_gpr(MUX_PGP_USB_SUSPEND, true);
	159
	160	mxc_iomux_set_pad(MX31_PIN_CSPI1_MISO, USB_PAD_CFG);
	161	mxc_iomux_set_pad(MX31_PIN_CSPI1_MOSI, USB_PAD_CFG);
	162	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS0, USB_PAD_CFG);
	163	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS1, USB_PAD_CFG);
	164	mxc_iomux_set_pad(MX31_PIN_CSPI1_SS2, USB_PAD_CFG);
	165	mxc_iomux_set_pad(MX31_PIN_CSPI1_SCLK, USB_PAD_CFG);
	166	mxc_iomux_set_pad(MX31_PIN_CSPI1_SPI_RDY, USB_PAD_CFG);
	167	mxc_iomux_set_pad(MX31_PIN_SFS6, USB_PAD_CFG);
	168
	169	mdelay(10);
	170
	171	return mx31_initialize_usb_hw(pdev->id, MXC_EHCI_POWER_PINS_ENABLED \|
	172	MXC_EHCI_INTERFACE_SINGLE_UNI);
	173	}
	174
	175	#define USBH1_VBUSEN_B IOMUX_TO_GPIO(MX31_PIN_NFRE_B)
	176	#define USBH1_MODE IOMUX_TO_GPIO(MX31_PIN_NFALE)
	177
	178	static int marxbot_isp1105_init(struct usb_phy *otg)
	179	{
	180	int ret = gpio_request(USBH1_MODE, "usbh1-mode");
	181	if (ret)
	182	return ret;
	183	/* single ended */
	184	gpio_direction_output(USBH1_MODE, 0);
	185
	186	ret = gpio_request(USBH1_VBUSEN_B, "usbh1-vbusen");
	187	if (ret) {
	188	gpio_free(USBH1_MODE);
	189	return ret;
	190	}
	191	gpio_direction_output(USBH1_VBUSEN_B, 1);
	192
	193	return 0;
	194	}
	195
	196
	197	static int marxbot_isp1105_set_vbus(struct usb_otg *otg, bool on)
	198	{
	199	if (on)
	200	gpio_set_value(USBH1_VBUSEN_B, 0);
	201	else
	202	gpio_set_value(USBH1_VBUSEN_B, 1);
	203
	204	return 0;
	205	}
	206
	207	static struct mxc_usbh_platform_data usbh1_pdata __initdata = {
	208	.init = marxbot_usbh1_hw_init,
	209	.portsc = MXC_EHCI_MODE_UTMI \| MXC_EHCI_SERIAL,
	210	};
	211
	212	static int __init marxbot_usbh1_init(void)
	213	{
	214	struct usb_phy *phy;
	215	struct platform_device *pdev;
	216
	217	phy = kzalloc(sizeof(*phy), GFP_KERNEL);
	218	if (!phy)
	219	return -ENOMEM;
	220
	221	phy->otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
	222	if (!phy->otg) {
	223	kfree(phy);
	224	return -ENOMEM;
	225	}
	226
	227	phy->label = "ISP1105";
	228	phy->init = marxbot_isp1105_init;
	229	phy->otg->set_vbus = marxbot_isp1105_set_vbus;
	230
	231	usbh1_pdata.otg = phy;
	232
	233	pdev = imx31_add_mxc_ehci_hs(1, &usbh1_pdata);
	234
	235	return PTR_ERR_OR_ZERO(pdev);
	236	}
	237
	238	static const struct fsl_usb2_platform_data usb_pdata __initconst = {
	239	.operating_mode = FSL_USB2_DR_DEVICE,
	240	.phy_mode = FSL_USB2_PHY_ULPI,
	241	};
	242
	243	/*
	244	* system init for baseboard usage. Will be called by mx31moboard init.
	245	*/
	246	void __init mx31moboard_marxbot_init(void)
	247	{
	248	printk(KERN_INFO "Initializing mx31marxbot peripherals\n");
	249
	250	mxc_iomux_setup_multiple_pins(marxbot_pins, ARRAY_SIZE(marxbot_pins),
	251	"marxbot");
	252
	253	marxbot_init_sel_gpios();
	254
	255	dspics_resets_init();
	256
	257	imx31_add_mxc_mmc(1, &sdhc2_pdata);
	258
	259	spi_register_board_info(marxbot_spi_board_info,
	260	ARRAY_SIZE(marxbot_spi_board_info));
	261
	262	/* battery present pin */
	263	gpio_request(IOMUX_TO_GPIO(MX31_PIN_LCS0), "bat-present");
	264	gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_LCS0));
	265	gpio_export(IOMUX_TO_GPIO(MX31_PIN_LCS0), false);
	266
	267	imx31_add_fsl_usb2_udc(&usb_pdata);
	268
	269	marxbot_usbh1_init();
	270	}