[deliverable/linux.git] / arch / arm / mach-omap1 / usb.c

/*
 * Platform level USB initialization for FS USB OTG controller on omap1 and 24xx
 *
 * Copyright (C) 2004 Texas Instruments, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/io.h>

#include <asm/irq.h>

#include <mach/mux.h>

#include <mach/usb.h>

#include "common.h"

/* These routines should handle the standard chip-specific modes
 * for usb0/1/2 ports, covering basic mux and transceiver setup.
 *
 * Some board-*.c files will need to set up additional mux options,
 * like for suspend handling, vbus sensing, GPIOs, and the D+ pullup.
 */

/* TESTED ON:
 *  - 1611B H2 (with usb1 mini-AB) using standard Mini-B or OTG cables
 *  - 5912 OSK OHCI (with usb0 standard-A), standard A-to-B cables
 *  - 5912 OSK UDC, with *nonstandard* A-to-A cable
 *  - 1510 Innovator UDC with bundled usb0 cable
 *  - 1510 Innovator OHCI with bundled usb1/usb2 cable
 *  - 1510 Innovator OHCI with custom usb0 cable, feeding 5V VBUS
 *  - 1710 custom development board using alternate pin group
 *  - 1710 H3 (with usb1 mini-AB) using standard Mini-B or OTG cables
 */

#define INT_USB_IRQ_GEN		IH2_BASE + 20
#define INT_USB_IRQ_NISO	IH2_BASE + 30
#define INT_USB_IRQ_ISO		IH2_BASE + 29
#define INT_USB_IRQ_HGEN	INT_USB_HHC_1
#define INT_USB_IRQ_OTG		IH2_BASE + 8

#ifdef	CONFIG_ARCH_OMAP_OTG

void __init
omap_otg_init(struct omap_usb_config *config)
{
	u32		syscon;
	int		alt_pingroup = 0;

	/* NOTE:  no bus or clock setup (yet?) */

	syscon = omap_readl(OTG_SYSCON_1) & 0xffff;
	if (!(syscon & OTG_RESET_DONE))
		pr_debug("USB resets not complete?\n");

	//omap_writew(0, OTG_IRQ_EN);

	/* pin muxing and transceiver pinouts */
	if (config->pins[0] > 2)	/* alt pingroup 2 */
		alt_pingroup = 1;
	syscon |= config->usb0_init(config->pins[0], is_usb0_device(config));
	syscon |= config->usb1_init(config->pins[1]);
	syscon |= config->usb2_init(config->pins[2], alt_pingroup);
	pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
	omap_writel(syscon, OTG_SYSCON_1);

	syscon = config->hmc_mode;
	syscon |= USBX_SYNCHRO | (4 << 16) /* B_ASE0_BRST */;
#ifdef	CONFIG_USB_OTG
	if (config->otg)
		syscon |= OTG_EN;
#endif
	if (cpu_class_is_omap1())
		pr_debug("USB_TRANSCEIVER_CTRL = %03x\n",
			 omap_readl(USB_TRANSCEIVER_CTRL));
	pr_debug("OTG_SYSCON_2 = %08x\n", omap_readl(OTG_SYSCON_2));
	omap_writel(syscon, OTG_SYSCON_2);

	printk("USB: hmc %d", config->hmc_mode);
	if (!alt_pingroup)
		printk(", usb2 alt %d wires", config->pins[2]);
	else if (config->pins[0])
		printk(", usb0 %d wires%s", config->pins[0],
			is_usb0_device(config) ? " (dev)" : "");
	if (config->pins[1])
		printk(", usb1 %d wires", config->pins[1]);
	if (!alt_pingroup && config->pins[2])
		printk(", usb2 %d wires", config->pins[2]);
	if (config->otg)
		printk(", Mini-AB on usb%d", config->otg - 1);
	printk("\n");

	if (cpu_class_is_omap1()) {
		u16 w;

		/* leave USB clocks/controllers off until needed */
		w = omap_readw(ULPD_SOFT_REQ);
		w &= ~SOFT_USB_CLK_REQ;
		omap_writew(w, ULPD_SOFT_REQ);

		w = omap_readw(ULPD_CLOCK_CTRL);
		w &= ~USB_MCLK_EN;
		w |= DIS_USB_PVCI_CLK;
		omap_writew(w, ULPD_CLOCK_CTRL);
	}
	syscon = omap_readl(OTG_SYSCON_1);
	syscon |= HST_IDLE_EN|DEV_IDLE_EN|OTG_IDLE_EN;

#if IS_ENABLED(CONFIG_USB_OMAP)
	if (config->otg || config->register_dev) {
		struct platform_device *udc_device = config->udc_device;
		int status;

		syscon &= ~DEV_IDLE_EN;
		udc_device->dev.platform_data = config;
		status = platform_device_register(udc_device);
		if (status)
			pr_debug("can't register UDC device, %d\n", status);
	}
#endif

#if	IS_ENABLED(CONFIG_USB_OHCI_HCD)
	if (config->otg || config->register_host) {
		struct platform_device *ohci_device = config->ohci_device;
		int status;

		syscon &= ~HST_IDLE_EN;
		ohci_device->dev.platform_data = config;
		status = platform_device_register(ohci_device);
		if (status)
			pr_debug("can't register OHCI device, %d\n", status);
	}
#endif

#ifdef	CONFIG_USB_OTG
	if (config->otg) {
		struct platform_device *otg_device = config->otg_device;
		int status;

		syscon &= ~OTG_IDLE_EN;
		otg_device->dev.platform_data = config;
		status = platform_device_register(otg_device);
		if (status)
			pr_debug("can't register OTG device, %d\n", status);
	}
#endif
	pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
	omap_writel(syscon, OTG_SYSCON_1);
}

#else
void omap_otg_init(struct omap_usb_config *config) {}
#endif

#if IS_ENABLED(CONFIG_USB_OMAP)

static struct resource udc_resources[] = {
	/* order is significant! */
	{		/* registers */
		.start		= UDC_BASE,
		.end		= UDC_BASE + 0xff,
		.flags		= IORESOURCE_MEM,
	}, {		/* general IRQ */
		.start		= INT_USB_IRQ_GEN,
		.flags		= IORESOURCE_IRQ,
	}, {		/* PIO IRQ */
		.start		= INT_USB_IRQ_NISO,
		.flags		= IORESOURCE_IRQ,
	}, {		/* SOF IRQ */
		.start		= INT_USB_IRQ_ISO,
		.flags		= IORESOURCE_IRQ,
	},
};

static u64 udc_dmamask = ~(u32)0;

static struct platform_device udc_device = {
	.name		= "omap_udc",
	.id		= -1,
	.dev = {
		.dma_mask		= &udc_dmamask,
		.coherent_dma_mask	= 0xffffffff,
	},
	.num_resources	= ARRAY_SIZE(udc_resources),
	.resource	= udc_resources,
};

static inline void udc_device_init(struct omap_usb_config *pdata)
{
	/* IRQ numbers for omap7xx */
	if(cpu_is_omap7xx()) {
		udc_resources[1].start = INT_7XX_USB_GENI;
		udc_resources[2].start = INT_7XX_USB_NON_ISO;
		udc_resources[3].start = INT_7XX_USB_ISO;
	}
	pdata->udc_device = &udc_device;
}

#else

static inline void udc_device_init(struct omap_usb_config *pdata)
{
}

#endif

#if	IS_ENABLED(CONFIG_USB_OHCI_HCD)

/* The dmamask must be set for OHCI to work */
static u64 ohci_dmamask = ~(u32)0;

static struct resource ohci_resources[] = {
	{
		.start	= OMAP_OHCI_BASE,
		.end	= OMAP_OHCI_BASE + 0xff,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= INT_USB_IRQ_HGEN,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device ohci_device = {
	.name			= "ohci",
	.id			= -1,
	.dev = {
		.dma_mask		= &ohci_dmamask,
		.coherent_dma_mask	= 0xffffffff,
	},
	.num_resources	= ARRAY_SIZE(ohci_resources),
	.resource		= ohci_resources,
};

static inline void ohci_device_init(struct omap_usb_config *pdata)
{
	if (cpu_is_omap7xx())
		ohci_resources[1].start = INT_7XX_USB_HHC_1;
	pdata->ohci_device = &ohci_device;
	pdata->ocpi_enable = &ocpi_enable;
}

#else

static inline void ohci_device_init(struct omap_usb_config *pdata)
{
}

#endif

#if	defined(CONFIG_USB_OTG) && defined(CONFIG_ARCH_OMAP_OTG)

static struct resource otg_resources[] = {
	/* order is significant! */
	{
		.start		= OTG_BASE,
		.end		= OTG_BASE + 0xff,
		.flags		= IORESOURCE_MEM,
	}, {
		.start		= INT_USB_IRQ_OTG,
		.flags		= IORESOURCE_IRQ,
	},
};

static struct platform_device otg_device = {
	.name		= "omap_otg",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(otg_resources),
	.resource	= otg_resources,
};

static inline void otg_device_init(struct omap_usb_config *pdata)
{
	if (cpu_is_omap7xx())
		otg_resources[1].start = INT_7XX_USB_OTG;
	pdata->otg_device = &otg_device;
}

#else

static inline void otg_device_init(struct omap_usb_config *pdata)
{
}

#endif

static u32 __init omap1_usb0_init(unsigned nwires, unsigned is_device)
{
	u32	syscon1 = 0;

	if (nwires == 0) {
		if (!cpu_is_omap15xx()) {
			u32 l;

			/* pulldown D+/D- */
			l = omap_readl(USB_TRANSCEIVER_CTRL);
			l &= ~(3 << 1);
			omap_writel(l, USB_TRANSCEIVER_CTRL);
		}
		return 0;
	}

	if (is_device) {
		if (cpu_is_omap7xx()) {
			omap_cfg_reg(AA17_7XX_USB_DM);
			omap_cfg_reg(W16_7XX_USB_PU_EN);
			omap_cfg_reg(W17_7XX_USB_VBUSI);
			omap_cfg_reg(W18_7XX_USB_DMCK_OUT);
			omap_cfg_reg(W19_7XX_USB_DCRST);
		} else
			omap_cfg_reg(W4_USB_PUEN);
	}

	if (nwires == 2) {
		u32 l;

		// omap_cfg_reg(P9_USB_DP);
		// omap_cfg_reg(R8_USB_DM);

		if (cpu_is_omap15xx()) {
			/* This works on 1510-Innovator */
			return 0;
		}

		/* NOTES:
		 *  - peripheral should configure VBUS detection!
		 *  - only peripherals may use the internal D+/D- pulldowns
		 *  - OTG support on this port not yet written
		 */

		/* Don't do this for omap7xx -- it causes USB to not work correctly */
		if (!cpu_is_omap7xx()) {
			l = omap_readl(USB_TRANSCEIVER_CTRL);
			l &= ~(7 << 4);
			if (!is_device)
				l |= (3 << 1);
			omap_writel(l, USB_TRANSCEIVER_CTRL);
		}

		return 3 << 16;
	}

	/* alternate pin config, external transceiver */
	if (cpu_is_omap15xx()) {
		printk(KERN_ERR "no usb0 alt pin config on 15xx\n");
		return 0;
	}

	omap_cfg_reg(V6_USB0_TXD);
	omap_cfg_reg(W9_USB0_TXEN);
	omap_cfg_reg(W5_USB0_SE0);
	if (nwires != 3)
		omap_cfg_reg(Y5_USB0_RCV);

	/* NOTE:  SPEED and SUSP aren't configured here.  OTG hosts
	 * may be able to use I2C requests to set those bits along
	 * with VBUS switching and overcurrent detection.
	 */

	if (nwires != 6) {
		u32 l;

		l = omap_readl(USB_TRANSCEIVER_CTRL);
		l &= ~CONF_USB2_UNI_R;
		omap_writel(l, USB_TRANSCEIVER_CTRL);
	}

	switch (nwires) {
	case 3:
		syscon1 = 2;
		break;
	case 4:
		syscon1 = 1;
		break;
	case 6:
		syscon1 = 3;
		{
			u32 l;

			omap_cfg_reg(AA9_USB0_VP);
			omap_cfg_reg(R9_USB0_VM);
			l = omap_readl(USB_TRANSCEIVER_CTRL);
			l |= CONF_USB2_UNI_R;
			omap_writel(l, USB_TRANSCEIVER_CTRL);
		}
		break;
	default:
		printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
			0, nwires);
	}

	return syscon1 << 16;
}

static u32 __init omap1_usb1_init(unsigned nwires)
{
	u32	syscon1 = 0;

	if (!cpu_is_omap15xx() && nwires != 6) {
		u32 l;

		l = omap_readl(USB_TRANSCEIVER_CTRL);
		l &= ~CONF_USB1_UNI_R;
		omap_writel(l, USB_TRANSCEIVER_CTRL);
	}
	if (nwires == 0)
		return 0;

	/* external transceiver */
	omap_cfg_reg(USB1_TXD);
	omap_cfg_reg(USB1_TXEN);
	if (nwires != 3)
		omap_cfg_reg(USB1_RCV);

	if (cpu_is_omap15xx()) {
		omap_cfg_reg(USB1_SEO);
		omap_cfg_reg(USB1_SPEED);
		// SUSP
	} else if (cpu_is_omap1610() || cpu_is_omap5912()) {
		omap_cfg_reg(W13_1610_USB1_SE0);
		omap_cfg_reg(R13_1610_USB1_SPEED);
		// SUSP
	} else if (cpu_is_omap1710()) {
		omap_cfg_reg(R13_1710_USB1_SE0);
		// SUSP
	} else {
		pr_debug("usb%d cpu unrecognized\n", 1);
		return 0;
	}

	switch (nwires) {
	case 2:
		goto bad;
	case 3:
		syscon1 = 2;
		break;
	case 4:
		syscon1 = 1;
		break;
	case 6:
		syscon1 = 3;
		omap_cfg_reg(USB1_VP);
		omap_cfg_reg(USB1_VM);
		if (!cpu_is_omap15xx()) {
			u32 l;

			l = omap_readl(USB_TRANSCEIVER_CTRL);
			l |= CONF_USB1_UNI_R;
			omap_writel(l, USB_TRANSCEIVER_CTRL);
		}
		break;
	default:
bad:
		printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
			1, nwires);
	}

	return syscon1 << 20;
}

static u32 __init omap1_usb2_init(unsigned nwires, unsigned alt_pingroup)
{
	u32	syscon1 = 0;

	/* NOTE omap1 erratum: must leave USB2_UNI_R set if usb0 in use */
	if (alt_pingroup || nwires == 0)
		return 0;

	if (!cpu_is_omap15xx() && nwires != 6) {
		u32 l;

		l = omap_readl(USB_TRANSCEIVER_CTRL);
		l &= ~CONF_USB2_UNI_R;
		omap_writel(l, USB_TRANSCEIVER_CTRL);
	}

	/* external transceiver */
	if (cpu_is_omap15xx()) {
		omap_cfg_reg(USB2_TXD);
		omap_cfg_reg(USB2_TXEN);
		omap_cfg_reg(USB2_SEO);
		if (nwires != 3)
			omap_cfg_reg(USB2_RCV);
		/* there is no USB2_SPEED */
	} else if (cpu_is_omap16xx()) {
		omap_cfg_reg(V6_USB2_TXD);
		omap_cfg_reg(W9_USB2_TXEN);
		omap_cfg_reg(W5_USB2_SE0);
		if (nwires != 3)
			omap_cfg_reg(Y5_USB2_RCV);
		// FIXME omap_cfg_reg(USB2_SPEED);
	} else {
		pr_debug("usb%d cpu unrecognized\n", 1);
		return 0;
	}

	// omap_cfg_reg(USB2_SUSP);

	switch (nwires) {
	case 2:
		goto bad;
	case 3:
		syscon1 = 2;
		break;
	case 4:
		syscon1 = 1;
		break;
	case 5:
		goto bad;
	case 6:
		syscon1 = 3;
		if (cpu_is_omap15xx()) {
			omap_cfg_reg(USB2_VP);
			omap_cfg_reg(USB2_VM);
		} else {
			u32 l;

			omap_cfg_reg(AA9_USB2_VP);
			omap_cfg_reg(R9_USB2_VM);
			l = omap_readl(USB_TRANSCEIVER_CTRL);
			l |= CONF_USB2_UNI_R;
			omap_writel(l, USB_TRANSCEIVER_CTRL);
		}
		break;
	default:
bad:
		printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
			2, nwires);
	}

	return syscon1 << 24;
}

#ifdef	CONFIG_ARCH_OMAP15XX

/* ULPD_DPLL_CTRL */
#define DPLL_IOB		(1 << 13)
#define DPLL_PLL_ENABLE		(1 << 4)
#define DPLL_LOCK		(1 << 0)

/* ULPD_APLL_CTRL */
#define APLL_NDPLL_SWITCH	(1 << 0)

static void __init omap_1510_usb_init(struct omap_usb_config *config)
{
	unsigned int val;
	u16 w;

	config->usb0_init(config->pins[0], is_usb0_device(config));
	config->usb1_init(config->pins[1]);
	config->usb2_init(config->pins[2], 0);

	val = omap_readl(MOD_CONF_CTRL_0) & ~(0x3f << 1);
	val |= (config->hmc_mode << 1);
	omap_writel(val, MOD_CONF_CTRL_0);

	printk("USB: hmc %d", config->hmc_mode);
	if (config->pins[0])
		printk(", usb0 %d wires%s", config->pins[0],
			is_usb0_device(config) ? " (dev)" : "");
	if (config->pins[1])
		printk(", usb1 %d wires", config->pins[1]);
	if (config->pins[2])
		printk(", usb2 %d wires", config->pins[2]);
	printk("\n");

	/* use DPLL for 48 MHz function clock */
	pr_debug("APLL %04x DPLL %04x REQ %04x\n", omap_readw(ULPD_APLL_CTRL),
			omap_readw(ULPD_DPLL_CTRL), omap_readw(ULPD_SOFT_REQ));

	w = omap_readw(ULPD_APLL_CTRL);
	w &= ~APLL_NDPLL_SWITCH;
	omap_writew(w, ULPD_APLL_CTRL);

	w = omap_readw(ULPD_DPLL_CTRL);
	w |= DPLL_IOB | DPLL_PLL_ENABLE;
	omap_writew(w, ULPD_DPLL_CTRL);

	w = omap_readw(ULPD_SOFT_REQ);
	w |= SOFT_UDC_REQ | SOFT_DPLL_REQ;
	omap_writew(w, ULPD_SOFT_REQ);

	while (!(omap_readw(ULPD_DPLL_CTRL) & DPLL_LOCK))
		cpu_relax();

#if IS_ENABLED(CONFIG_USB_OMAP)
	if (config->register_dev) {
		int status;

		udc_device.dev.platform_data = config;
		status = platform_device_register(&udc_device);
		if (status)
			pr_debug("can't register UDC device, %d\n", status);
		/* udc driver gates 48MHz by D+ pullup */
	}
#endif

#if	IS_ENABLED(CONFIG_USB_OHCI_HCD)
	if (config->register_host) {
		int status;

		ohci_device.dev.platform_data = config;
		status = platform_device_register(&ohci_device);
		if (status)
			pr_debug("can't register OHCI device, %d\n", status);
		/* hcd explicitly gates 48MHz */
	}
#endif
}

#else
static inline void omap_1510_usb_init(struct omap_usb_config *config) {}
#endif

void __init omap1_usb_init(struct omap_usb_config *_pdata)
{
	struct omap_usb_config *pdata;

	pdata = kmemdup(_pdata, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return;

	pdata->usb0_init = omap1_usb0_init;
	pdata->usb1_init = omap1_usb1_init;
	pdata->usb2_init = omap1_usb2_init;
	udc_device_init(pdata);
	ohci_device_init(pdata);
	otg_device_init(pdata);

	if (cpu_is_omap7xx() || cpu_is_omap16xx())
		omap_otg_init(pdata);
	else if (cpu_is_omap15xx())
		omap_1510_usb_init(pdata);
	else
		printk(KERN_ERR "USB: No init for your chip yet\n");
}
Commit	Line	Data
dd0cdd88 TL	1	/*
	2	* Platform level USB initialization for FS USB OTG controller on omap1 and 24xx
	3	*
	4	* Copyright (C) 2004 Texas Instruments, Inc.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*/
	20
	21	#include <linux/module.h>
	22	#include <linux/kernel.h>
	23	#include <linux/init.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/io.h>
	26
	27	#include <asm/irq.h>
	28
70c494c3	29	#include <mach/mux.h>
b924b204 TL	30
b924b204 TL	31	#include <mach/usb.h>
dd0cdd88	32
d3645d39 PW	33	#include "common.h"
d3645d39 PW	34
dd0cdd88 TL	35	/* These routines should handle the standard chip-specific modes
	36	* for usb0/1/2 ports, covering basic mux and transceiver setup.
	37	*
	38	* Some board-*.c files will need to set up additional mux options,
	39	* like for suspend handling, vbus sensing, GPIOs, and the D+ pullup.
	40	*/
	41
	42	/* TESTED ON:
	43	* - 1611B H2 (with usb1 mini-AB) using standard Mini-B or OTG cables
	44	* - 5912 OSK OHCI (with usb0 standard-A), standard A-to-B cables
	45	* - 5912 OSK UDC, with nonstandard A-to-A cable
	46	* - 1510 Innovator UDC with bundled usb0 cable
	47	* - 1510 Innovator OHCI with bundled usb1/usb2 cable
	48	* - 1510 Innovator OHCI with custom usb0 cable, feeding 5V VBUS
	49	* - 1710 custom development board using alternate pin group
	50	* - 1710 H3 (with usb1 mini-AB) using standard Mini-B or OTG cables
	51	*/
	52
	53	#define INT_USB_IRQ_GEN IH2_BASE + 20
	54	#define INT_USB_IRQ_NISO IH2_BASE + 30
	55	#define INT_USB_IRQ_ISO IH2_BASE + 29
	56	#define INT_USB_IRQ_HGEN INT_USB_HHC_1
	57	#define INT_USB_IRQ_OTG IH2_BASE + 8
	58
b924b204 TL	59	#ifdef CONFIG_ARCH_OMAP_OTG
	60
	61	void __init
	62	omap_otg_init(struct omap_usb_config *config)
	63	{
	64	u32 syscon;
	65	int alt_pingroup = 0;
	66
	67	/* NOTE: no bus or clock setup (yet?) */
	68
	69	syscon = omap_readl(OTG_SYSCON_1) & 0xffff;
	70	if (!(syscon & OTG_RESET_DONE))
	71	pr_debug("USB resets not complete?\n");
	72
	73	//omap_writew(0, OTG_IRQ_EN);
	74
	75	/* pin muxing and transceiver pinouts */
	76	if (config->pins[0] > 2) /* alt pingroup 2 */
	77	alt_pingroup = 1;
	78	syscon \|= config->usb0_init(config->pins[0], is_usb0_device(config));
	79	syscon \|= config->usb1_init(config->pins[1]);
	80	syscon \|= config->usb2_init(config->pins[2], alt_pingroup);
	81	pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
	82	omap_writel(syscon, OTG_SYSCON_1);
	83
	84	syscon = config->hmc_mode;
	85	syscon \|= USBX_SYNCHRO \| (4 << 16) /* B_ASE0_BRST */;
	86	#ifdef CONFIG_USB_OTG
	87	if (config->otg)
	88	syscon \|= OTG_EN;
	89	#endif
	90	if (cpu_class_is_omap1())
	91	pr_debug("USB_TRANSCEIVER_CTRL = %03x\n",
	92	omap_readl(USB_TRANSCEIVER_CTRL));
	93	pr_debug("OTG_SYSCON_2 = %08x\n", omap_readl(OTG_SYSCON_2));
	94	omap_writel(syscon, OTG_SYSCON_2);
	95
	96	printk("USB: hmc %d", config->hmc_mode);
	97	if (!alt_pingroup)
	98	printk(", usb2 alt %d wires", config->pins[2]);
	99	else if (config->pins[0])
	100	printk(", usb0 %d wires%s", config->pins[0],
	101	is_usb0_device(config) ? " (dev)" : "");
	102	if (config->pins[1])
	103	printk(", usb1 %d wires", config->pins[1]);
	104	if (!alt_pingroup && config->pins[2])
	105	printk(", usb2 %d wires", config->pins[2]);
	106	if (config->otg)
	107	printk(", Mini-AB on usb%d", config->otg - 1);
	108	printk("\n");
	109
	110	if (cpu_class_is_omap1()) {
	111	u16 w;
	112
	113	/* leave USB clocks/controllers off until needed */
	114	w = omap_readw(ULPD_SOFT_REQ);
	115	w &= ~SOFT_USB_CLK_REQ;
	116	omap_writew(w, ULPD_SOFT_REQ);
	117
	118	w = omap_readw(ULPD_CLOCK_CTRL);
	119	w &= ~USB_MCLK_EN;
	120	w \|= DIS_USB_PVCI_CLK;
	121	omap_writew(w, ULPD_CLOCK_CTRL);
	122	}
123	syscon = omap_readl(OTG_SYSCON_1);
124	syscon \|= HST_IDLE_EN\|DEV_IDLE_EN\|OTG_IDLE_EN;
125
0345a1e3	126	#if IS_ENABLED(CONFIG_USB_OMAP)
b924b204 TL	127	if (config->otg \|\| config->register_dev) {
	128	struct platform_device *udc_device = config->udc_device;
	129	int status;
	130
	131	syscon &= ~DEV_IDLE_EN;
	132	udc_device->dev.platform_data = config;
	133	status = platform_device_register(udc_device);
	134	if (status)
	135	pr_debug("can't register UDC device, %d\n", status);
	136	}
	137	#endif
	138
fcebddb9	139	#if IS_ENABLED(CONFIG_USB_OHCI_HCD)
b924b204 TL	140	if (config->otg \|\| config->register_host) {
	141	struct platform_device *ohci_device = config->ohci_device;
	142	int status;
	143
	144	syscon &= ~HST_IDLE_EN;
	145	ohci_device->dev.platform_data = config;
	146	status = platform_device_register(ohci_device);
	147	if (status)
	148	pr_debug("can't register OHCI device, %d\n", status);
	149	}
	150	#endif
	151
	152	#ifdef CONFIG_USB_OTG
	153	if (config->otg) {
	154	struct platform_device *otg_device = config->otg_device;
	155	int status;
	156
	157	syscon &= ~OTG_IDLE_EN;
	158	otg_device->dev.platform_data = config;
	159	status = platform_device_register(otg_device);
	160	if (status)
	161	pr_debug("can't register OTG device, %d\n", status);
	162	}
	163	#endif
	164	pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
	165	omap_writel(syscon, OTG_SYSCON_1);
	166	}
	167
	168	#else
	169	void omap_otg_init(struct omap_usb_config *config) {}
	170	#endif
	171
0345a1e3	172	#if IS_ENABLED(CONFIG_USB_OMAP)
dd0cdd88 TL	173
	174	static struct resource udc_resources[] = {
	175	/* order is significant! */
	176	{ /* registers */
	177	.start = UDC_BASE,
	178	.end = UDC_BASE + 0xff,
	179	.flags = IORESOURCE_MEM,
	180	}, { /* general IRQ */
	181	.start = INT_USB_IRQ_GEN,
	182	.flags = IORESOURCE_IRQ,
	183	}, { /* PIO IRQ */
	184	.start = INT_USB_IRQ_NISO,
	185	.flags = IORESOURCE_IRQ,
	186	}, { /* SOF IRQ */
	187	.start = INT_USB_IRQ_ISO,
	188	.flags = IORESOURCE_IRQ,
	189	},
	190	};
	191
	192	static u64 udc_dmamask = ~(u32)0;
	193
	194	static struct platform_device udc_device = {
	195	.name = "omap_udc",
	196	.id = -1,
	197	.dev = {
	198	.dma_mask = &udc_dmamask,
	199	.coherent_dma_mask = 0xffffffff,
	200	},
	201	.num_resources = ARRAY_SIZE(udc_resources),
	202	.resource = udc_resources,
	203	};
	204
	205	static inline void udc_device_init(struct omap_usb_config *pdata)
	206	{
	207	/* IRQ numbers for omap7xx */
	208	if(cpu_is_omap7xx()) {
	209	udc_resources[1].start = INT_7XX_USB_GENI;
	210	udc_resources[2].start = INT_7XX_USB_NON_ISO;
	211	udc_resources[3].start = INT_7XX_USB_ISO;
	212	}
	213	pdata->udc_device = &udc_device;
	214	}
	215
	216	#else
	217
	218	static inline void udc_device_init(struct omap_usb_config *pdata)
	219	{
	220	}
	221
	222	#endif
	223
fcebddb9	224	#if IS_ENABLED(CONFIG_USB_OHCI_HCD)
dd0cdd88 TL	225
	226	/* The dmamask must be set for OHCI to work */
	227	static u64 ohci_dmamask = ~(u32)0;
	228
	229	static struct resource ohci_resources[] = {
	230	{
	231	.start = OMAP_OHCI_BASE,
	232	.end = OMAP_OHCI_BASE + 0xff,
	233	.flags = IORESOURCE_MEM,
	234	},
	235	{
	236	.start = INT_USB_IRQ_HGEN,
	237	.flags = IORESOURCE_IRQ,
	238	},
	239	};
	240
	241	static struct platform_device ohci_device = {
	242	.name = "ohci",
	243	.id = -1,
	244	.dev = {
	245	.dma_mask = &ohci_dmamask,
	246	.coherent_dma_mask = 0xffffffff,
	247	},
	248	.num_resources = ARRAY_SIZE(ohci_resources),
	249	.resource = ohci_resources,
	250	};
	251
	252	static inline void ohci_device_init(struct omap_usb_config *pdata)
	253	{
	254	if (cpu_is_omap7xx())
	255	ohci_resources[1].start = INT_7XX_USB_HHC_1;
	256	pdata->ohci_device = &ohci_device;
d3645d39	257	pdata->ocpi_enable = &ocpi_enable;
dd0cdd88 TL	258	}
	259
	260	#else
	261
	262	static inline void ohci_device_init(struct omap_usb_config *pdata)
	263	{
	264	}
	265
	266	#endif
	267
	268	#if defined(CONFIG_USB_OTG) && defined(CONFIG_ARCH_OMAP_OTG)
	269
	270	static struct resource otg_resources[] = {
	271	/* order is significant! */
	272	{
	273	.start = OTG_BASE,
	274	.end = OTG_BASE + 0xff,
	275	.flags = IORESOURCE_MEM,
	276	}, {
	277	.start = INT_USB_IRQ_OTG,
	278	.flags = IORESOURCE_IRQ,
	279	},
	280	};
	281
	282	static struct platform_device otg_device = {
	283	.name = "omap_otg",
	284	.id = -1,
	285	.num_resources = ARRAY_SIZE(otg_resources),
	286	.resource = otg_resources,
	287	};
	288
	289	static inline void otg_device_init(struct omap_usb_config *pdata)
	290	{
	291	if (cpu_is_omap7xx())
	292	otg_resources[1].start = INT_7XX_USB_OTG;
	293	pdata->otg_device = &otg_device;
	294	}
	295
	296	#else
	297
	298	static inline void otg_device_init(struct omap_usb_config *pdata)
	299	{
	300	}
	301
	302	#endif
	303
eba36d77	304	static u32 __init omap1_usb0_init(unsigned nwires, unsigned is_device)
dd0cdd88 TL	305	{
	306	u32 syscon1 = 0;
	307
	308	if (nwires == 0) {
	309	if (!cpu_is_omap15xx()) {
	310	u32 l;
	311
	312	/* pulldown D+/D- */
	313	l = omap_readl(USB_TRANSCEIVER_CTRL);
	314	l &= ~(3 << 1);
	315	omap_writel(l, USB_TRANSCEIVER_CTRL);
	316	}
	317	return 0;
	318	}
	319
	320	if (is_device) {
	321	if (cpu_is_omap7xx()) {
	322	omap_cfg_reg(AA17_7XX_USB_DM);
	323	omap_cfg_reg(W16_7XX_USB_PU_EN);
	324	omap_cfg_reg(W17_7XX_USB_VBUSI);
	325	omap_cfg_reg(W18_7XX_USB_DMCK_OUT);
	326	omap_cfg_reg(W19_7XX_USB_DCRST);
	327	} else
	328	omap_cfg_reg(W4_USB_PUEN);
	329	}
	330
	331	if (nwires == 2) {
	332	u32 l;
	333
	334	// omap_cfg_reg(P9_USB_DP);
	335	// omap_cfg_reg(R8_USB_DM);
	336
	337	if (cpu_is_omap15xx()) {
	338	/* This works on 1510-Innovator */
	339	return 0;
	340	}
	341
	342	/* NOTES:
	343	* - peripheral should configure VBUS detection!
	344	* - only peripherals may use the internal D+/D- pulldowns
	345	* - OTG support on this port not yet written
	346	*/
	347
	348	/* Don't do this for omap7xx -- it causes USB to not work correctly */
	349	if (!cpu_is_omap7xx()) {
	350	l = omap_readl(USB_TRANSCEIVER_CTRL);
	351	l &= ~(7 << 4);
	352	if (!is_device)
	353	l \|= (3 << 1);
	354	omap_writel(l, USB_TRANSCEIVER_CTRL);
	355	}
	356
	357	return 3 << 16;
	358	}
	359
	360	/* alternate pin config, external transceiver */
	361	if (cpu_is_omap15xx()) {
	362	printk(KERN_ERR "no usb0 alt pin config on 15xx\n");
	363	return 0;
	364	}
	365
	366	omap_cfg_reg(V6_USB0_TXD);
	367	omap_cfg_reg(W9_USB0_TXEN);
	368	omap_cfg_reg(W5_USB0_SE0);
369	if (nwires != 3)
370	omap_cfg_reg(Y5_USB0_RCV);
371
372	/* NOTE: SPEED and SUSP aren't configured here. OTG hosts
373	* may be able to use I2C requests to set those bits along
374	* with VBUS switching and overcurrent detection.
375	*/
376
377	if (nwires != 6) {
378	u32 l;
379
380	l = omap_readl(USB_TRANSCEIVER_CTRL);
381	l &= ~CONF_USB2_UNI_R;
382	omap_writel(l, USB_TRANSCEIVER_CTRL);
383	}
384
385	switch (nwires) {
386	case 3:
387	syscon1 = 2;
388	break;
389	case 4:
390	syscon1 = 1;
391	break;
392	case 6:
393	syscon1 = 3;
394	{
395	u32 l;
396
397	omap_cfg_reg(AA9_USB0_VP);
398	omap_cfg_reg(R9_USB0_VM);
399	l = omap_readl(USB_TRANSCEIVER_CTRL);
400	l \|= CONF_USB2_UNI_R;
401	omap_writel(l, USB_TRANSCEIVER_CTRL);
402	}
403	break;
404	default:
405	printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
406	0, nwires);
407	}
408
409	return syscon1 << 16;
410	}
411
eba36d77	412	static u32 __init omap1_usb1_init(unsigned nwires)
dd0cdd88 TL	413	{
	414	u32 syscon1 = 0;
	415
	416	if (!cpu_is_omap15xx() && nwires != 6) {
	417	u32 l;
	418
	419	l = omap_readl(USB_TRANSCEIVER_CTRL);
	420	l &= ~CONF_USB1_UNI_R;
	421	omap_writel(l, USB_TRANSCEIVER_CTRL);
	422	}
	423	if (nwires == 0)
	424	return 0;
	425
	426	/* external transceiver */
	427	omap_cfg_reg(USB1_TXD);
	428	omap_cfg_reg(USB1_TXEN);
	429	if (nwires != 3)
	430	omap_cfg_reg(USB1_RCV);
	431
	432	if (cpu_is_omap15xx()) {
	433	omap_cfg_reg(USB1_SEO);
	434	omap_cfg_reg(USB1_SPEED);
	435	// SUSP
	436	} else if (cpu_is_omap1610() \|\| cpu_is_omap5912()) {
	437	omap_cfg_reg(W13_1610_USB1_SE0);
	438	omap_cfg_reg(R13_1610_USB1_SPEED);
	439	// SUSP
	440	} else if (cpu_is_omap1710()) {
	441	omap_cfg_reg(R13_1710_USB1_SE0);
	442	// SUSP
	443	} else {
	444	pr_debug("usb%d cpu unrecognized\n", 1);
	445	return 0;
	446	}
	447
	448	switch (nwires) {
	449	case 2:
	450	goto bad;
	451	case 3:
	452	syscon1 = 2;
	453	break;
	454	case 4:
	455	syscon1 = 1;
	456	break;
	457	case 6:
	458	syscon1 = 3;
	459	omap_cfg_reg(USB1_VP);
	460	omap_cfg_reg(USB1_VM);
	461	if (!cpu_is_omap15xx()) {
	462	u32 l;
	463
	464	l = omap_readl(USB_TRANSCEIVER_CTRL);
	465	l \|= CONF_USB1_UNI_R;
	466	omap_writel(l, USB_TRANSCEIVER_CTRL);
	467	}
	468	break;
	469	default:
	470	bad:
	471	printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
	472	1, nwires);
	473	}
	474
	475	return syscon1 << 20;
	476	}
477
eba36d77	478	static u32 __init omap1_usb2_init(unsigned nwires, unsigned alt_pingroup)
dd0cdd88 TL	479	{
	480	u32 syscon1 = 0;
	481
	482	/* NOTE omap1 erratum: must leave USB2_UNI_R set if usb0 in use */
	483	if (alt_pingroup \|\| nwires == 0)
	484	return 0;
	485
	486	if (!cpu_is_omap15xx() && nwires != 6) {
	487	u32 l;
	488
	489	l = omap_readl(USB_TRANSCEIVER_CTRL);
	490	l &= ~CONF_USB2_UNI_R;
	491	omap_writel(l, USB_TRANSCEIVER_CTRL);
	492	}
	493
	494	/* external transceiver */
	495	if (cpu_is_omap15xx()) {
	496	omap_cfg_reg(USB2_TXD);
	497	omap_cfg_reg(USB2_TXEN);
	498	omap_cfg_reg(USB2_SEO);
	499	if (nwires != 3)
	500	omap_cfg_reg(USB2_RCV);
	501	/* there is no USB2_SPEED */
	502	} else if (cpu_is_omap16xx()) {
	503	omap_cfg_reg(V6_USB2_TXD);
	504	omap_cfg_reg(W9_USB2_TXEN);
	505	omap_cfg_reg(W5_USB2_SE0);
	506	if (nwires != 3)
	507	omap_cfg_reg(Y5_USB2_RCV);
	508	// FIXME omap_cfg_reg(USB2_SPEED);
	509	} else {
	510	pr_debug("usb%d cpu unrecognized\n", 1);
	511	return 0;
	512	}
	513
	514	// omap_cfg_reg(USB2_SUSP);
	515
	516	switch (nwires) {
	517	case 2:
	518	goto bad;
	519	case 3:
	520	syscon1 = 2;
	521	break;
	522	case 4:
	523	syscon1 = 1;
	524	break;
	525	case 5:
	526	goto bad;
	527	case 6:
	528	syscon1 = 3;
	529	if (cpu_is_omap15xx()) {
	530	omap_cfg_reg(USB2_VP);
	531	omap_cfg_reg(USB2_VM);
	532	} else {
	533	u32 l;
	534
	535	omap_cfg_reg(AA9_USB2_VP);
	536	omap_cfg_reg(R9_USB2_VM);
	537	l = omap_readl(USB_TRANSCEIVER_CTRL);
	538	l \|= CONF_USB2_UNI_R;
	539	omap_writel(l, USB_TRANSCEIVER_CTRL);
	540	}
	541	break;
	542	default:
543	bad:
544	printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
545	2, nwires);
546	}
547
548	return syscon1 << 24;
549	}
550
551	#ifdef CONFIG_ARCH_OMAP15XX
552
553	/* ULPD_DPLL_CTRL */
554	#define DPLL_IOB (1 << 13)
555	#define DPLL_PLL_ENABLE (1 << 4)
556	#define DPLL_LOCK (1 << 0)
557
558	/* ULPD_APLL_CTRL */
559	#define APLL_NDPLL_SWITCH (1 << 0)
560
561	static void __init omap_1510_usb_init(struct omap_usb_config *config)
562	{
563	unsigned int val;
564	u16 w;
565
566	config->usb0_init(config->pins[0], is_usb0_device(config));
567	config->usb1_init(config->pins[1]);
568	config->usb2_init(config->pins[2], 0);
569
570	val = omap_readl(MOD_CONF_CTRL_0) & ~(0x3f << 1);
571	val \|= (config->hmc_mode << 1);
572	omap_writel(val, MOD_CONF_CTRL_0);
573
574	printk("USB: hmc %d", config->hmc_mode);
575	if (config->pins[0])
576	printk(", usb0 %d wires%s", config->pins[0],
577	is_usb0_device(config) ? " (dev)" : "");
578	if (config->pins[1])
579	printk(", usb1 %d wires", config->pins[1]);
580	if (config->pins[2])
581	printk(", usb2 %d wires", config->pins[2]);
582	printk("\n");
583
584	/* use DPLL for 48 MHz function clock */
585	pr_debug("APLL %04x DPLL %04x REQ %04x\n", omap_readw(ULPD_APLL_CTRL),
586	omap_readw(ULPD_DPLL_CTRL), omap_readw(ULPD_SOFT_REQ));
587
588	w = omap_readw(ULPD_APLL_CTRL);
589	w &= ~APLL_NDPLL_SWITCH;
590	omap_writew(w, ULPD_APLL_CTRL);
591
592	w = omap_readw(ULPD_DPLL_CTRL);
593	w \|= DPLL_IOB \| DPLL_PLL_ENABLE;
594	omap_writew(w, ULPD_DPLL_CTRL);
595
596	w = omap_readw(ULPD_SOFT_REQ);
597	w \|= SOFT_UDC_REQ \| SOFT_DPLL_REQ;
598	omap_writew(w, ULPD_SOFT_REQ);
599
600	while (!(omap_readw(ULPD_DPLL_CTRL) & DPLL_LOCK))
601	cpu_relax();
602
0345a1e3	603	#if IS_ENABLED(CONFIG_USB_OMAP)
dd0cdd88 TL	604	if (config->register_dev) {
	605	int status;
	606
	607	udc_device.dev.platform_data = config;
	608	status = platform_device_register(&udc_device);
	609	if (status)
	610	pr_debug("can't register UDC device, %d\n", status);
	611	/* udc driver gates 48MHz by D+ pullup */
	612	}
	613	#endif
	614
fcebddb9	615	#if IS_ENABLED(CONFIG_USB_OHCI_HCD)
dd0cdd88 TL	616	if (config->register_host) {
	617	int status;
	618
	619	ohci_device.dev.platform_data = config;
	620	status = platform_device_register(&ohci_device);
	621	if (status)
	622	pr_debug("can't register OHCI device, %d\n", status);
	623	/* hcd explicitly gates 48MHz */
	624	}
	625	#endif
	626	}
	627
	628	#else
	629	static inline void omap_1510_usb_init(struct omap_usb_config *config) {}
	630	#endif
	631
07fd296d	632	void __init omap1_usb_init(struct omap_usb_config *_pdata)
dd0cdd88	633	{
07fd296d AK	634	struct omap_usb_config *pdata;
	635
	636	pdata = kmemdup(_pdata, sizeof(*pdata), GFP_KERNEL);
	637	if (!pdata)
	638	return;
	639
dd0cdd88 TL	640	pdata->usb0_init = omap1_usb0_init;
	641	pdata->usb1_init = omap1_usb1_init;
	642	pdata->usb2_init = omap1_usb2_init;
	643	udc_device_init(pdata);
	644	ohci_device_init(pdata);
	645	otg_device_init(pdata);
	646
	647	if (cpu_is_omap7xx() \|\| cpu_is_omap16xx())
	648	omap_otg_init(pdata);
	649	else if (cpu_is_omap15xx())
	650	omap_1510_usb_init(pdata);
	651	else
	652	printk(KERN_ERR "USB: No init for your chip yet\n");
	653	}