[J-u-boot.git] / drivers / usb / musb-new / omap2430.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2005-2007 by Texas Instruments
 * Some code has been taken from tusb6010.c
 * Copyrights for that are attributable to:
 * Copyright (C) 2006 Nokia Corporation
 * Tony Lindgren <[email protected]>
 *
 * This file is part of the Inventra Controller Driver for Linux.
 */
#include <common.h>
#include <dm.h>
#include <serial.h>
#include <dm/device-internal.h>
#include <dm/device_compat.h>
#include <dm/lists.h>
#include <linux/err.h>
#include <linux/usb/otg.h>
#include <asm/omap_common.h>
#include <asm/omap_musb.h>
#include <twl4030.h>
#include <twl6030.h>
#include "linux-compat.h"
#include "musb_core.h"
#include "omap2430.h"
#include "musb_uboot.h"

static inline void omap2430_low_level_exit(struct musb *musb)
{
	u32 l;

	/* in any role */
	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	l |= ENABLEFORCE;	/* enable MSTANDBY */
	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
}

static inline void omap2430_low_level_init(struct musb *musb)
{
	u32 l;

	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	l &= ~ENABLEFORCE;	/* disable MSTANDBY */
	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
}


static int omap2430_musb_init(struct musb *musb)
{
	u32 l;
	int status = 0;
	unsigned long int start;

	struct omap_musb_board_data *data =
		(struct omap_musb_board_data *)musb->controller;

	/* Reset the controller */
	musb_writel(musb->mregs, OTG_SYSCONFIG, SOFTRST);

	start = get_timer(0);

	while (1) {
		l = musb_readl(musb->mregs, OTG_SYSCONFIG);
		if ((l & SOFTRST) == 0)
			break;

		if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
			dev_err(musb->controller, "MUSB reset is taking too long\n");
			return -ENODEV;
		}
	}

	l = musb_readl(musb->mregs, OTG_INTERFSEL);

	if (data->interface_type == MUSB_INTERFACE_UTMI) {
		/* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
		l &= ~ULPI_12PIN;       /* Disable ULPI */
		l |= UTMI_8BIT;         /* Enable UTMI  */
	} else {
		l |= ULPI_12PIN;
	}

	musb_writel(musb->mregs, OTG_INTERFSEL, l);

	pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
			"sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
			musb_readl(musb->mregs, OTG_REVISION),
			musb_readl(musb->mregs, OTG_SYSCONFIG),
			musb_readl(musb->mregs, OTG_SYSSTATUS),
			musb_readl(musb->mregs, OTG_INTERFSEL),
			musb_readl(musb->mregs, OTG_SIMENABLE));
	return 0;

err1:
	return status;
}

static int omap2430_musb_enable(struct musb *musb)
{
#ifdef CONFIG_TWL4030_USB
	if (twl4030_usb_ulpi_init()) {
		serial_printf("ERROR: %s Could not initialize PHY\n",
				__PRETTY_FUNCTION__);
	}
#endif

#ifdef CONFIG_TWL6030_POWER
	twl6030_usb_device_settings();
#endif

#ifdef CONFIG_OMAP44XX
	u32 *usbotghs_control = (u32 *)((*ctrl)->control_usbotghs_ctrl);
	*usbotghs_control = USBOTGHS_CONTROL_AVALID |
		USBOTGHS_CONTROL_VBUSVALID | USBOTGHS_CONTROL_IDDIG;
#endif

	return 0;
}

static void omap2430_musb_disable(struct musb *musb)
{

}

static int omap2430_musb_exit(struct musb *musb)
{
	del_timer_sync(&musb_idle_timer);

	omap2430_low_level_exit(musb);

	return 0;
}

const struct musb_platform_ops omap2430_ops = {
	.init		= omap2430_musb_init,
	.exit		= omap2430_musb_exit,
	.enable		= omap2430_musb_enable,
	.disable	= omap2430_musb_disable,
};

#if CONFIG_IS_ENABLED(DM_USB)

struct omap2430_musb_platdata {
	void *base;
	void *ctrl_mod_base;
	struct musb_hdrc_platform_data plat;
	struct musb_hdrc_config musb_config;
	struct omap_musb_board_data otg_board_data;
};

static int omap2430_musb_ofdata_to_platdata(struct udevice *dev)
{
	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
	const void *fdt = gd->fdt_blob;
	int node = dev_of_offset(dev);

	platdata->base = (void *)dev_read_addr_ptr(dev);

	platdata->musb_config.multipoint = fdtdec_get_int(fdt, node,
							  "multipoint",
							  -1);
	if (platdata->musb_config.multipoint < 0) {
		pr_err("MUSB multipoint DT entry missing\n");
		return -ENOENT;
	}

	platdata->musb_config.dyn_fifo = 1;
	platdata->musb_config.num_eps = fdtdec_get_int(fdt, node,
						       "num-eps", -1);
	if (platdata->musb_config.num_eps < 0) {
		pr_err("MUSB num-eps DT entry missing\n");
		return -ENOENT;
	}

	platdata->musb_config.ram_bits = fdtdec_get_int(fdt, node,
							"ram-bits", -1);
	if (platdata->musb_config.ram_bits < 0) {
		pr_err("MUSB ram-bits DT entry missing\n");
		return -ENOENT;
	}

	platdata->plat.power = fdtdec_get_int(fdt, node,
								"power", -1);
	if (platdata->plat.power < 0) {
		pr_err("MUSB power DT entry missing\n");
		return -ENOENT;
	}

	platdata->otg_board_data.interface_type = fdtdec_get_int(fdt, node,
									"interface-type", -1);
	if (platdata->otg_board_data.interface_type < 0) {
		pr_err("MUSB interface-type DT entry missing\n");
		return -ENOENT;
	}

#if 0 /* In a perfect world, mode would be set to OTG, mode 3 from DT */
	platdata->plat.mode = fdtdec_get_int(fdt, node,
										"mode", -1);
	if (platdata->plat.mode < 0) {
		pr_err("MUSB mode DT entry missing\n");
		return -ENOENT;
	}
#else /* MUSB_OTG, it doesn't work */
#ifdef CONFIG_USB_MUSB_HOST /* Host seems to be the only option that works */
	platdata->plat.mode = MUSB_HOST;
#else /* For that matter, MUSB_PERIPHERAL doesn't either */
	platdata->plat.mode = MUSB_PERIPHERAL;
#endif
#endif
	platdata->otg_board_data.dev = dev;
	platdata->plat.config = &platdata->musb_config;
	platdata->plat.platform_ops = &omap2430_ops;
	platdata->plat.board_data = &platdata->otg_board_data;
	return 0;
}

static int omap2430_musb_probe(struct udevice *dev)
{
#ifdef CONFIG_USB_MUSB_HOST
	struct musb_host_data *host = dev_get_priv(dev);
#else
	struct musb *musbp;
#endif
	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
	struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
	struct omap_musb_board_data *otg_board_data;
	int ret = 0;
	void *base = dev_read_addr_ptr(dev);

	priv->desc_before_addr = true;

	otg_board_data = &platdata->otg_board_data;

#ifdef CONFIG_USB_MUSB_HOST
	host->host = musb_init_controller(&platdata->plat,
					  (struct device *)otg_board_data,
					  platdata->base);
	if (!host->host) {
		return -EIO;
	}

	ret = musb_lowlevel_init(host);
#else
	musbp = musb_register(&platdata->plat,
			  (struct device *)otg_board_data,
			  platdata->base);
	if (IS_ERR_OR_NULL(musbp))
		return -EINVAL;
#endif
	return ret;
}

static int omap2430_musb_remove(struct udevice *dev)
{
	struct musb_host_data *host = dev_get_priv(dev);

	musb_stop(host->host);

	return 0;
}

static const struct udevice_id omap2430_musb_ids[] = {
	{ .compatible = "ti,omap3-musb" },
	{ .compatible = "ti,omap4-musb" },
	{ }
};

U_BOOT_DRIVER(omap2430_musb) = {
	.name	= "omap2430-musb",
#ifdef CONFIG_USB_MUSB_HOST
	.id		= UCLASS_USB,
#else
	.id		= UCLASS_USB_GADGET_GENERIC,
#endif
	.of_match = omap2430_musb_ids,
	.ofdata_to_platdata = omap2430_musb_ofdata_to_platdata,
	.probe = omap2430_musb_probe,
	.remove = omap2430_musb_remove,
#ifdef CONFIG_USB_MUSB_HOST
	.ops = &musb_usb_ops,
#endif
	.platdata_auto_alloc_size = sizeof(struct omap2430_musb_platdata),
	.priv_auto_alloc_size = sizeof(struct musb_host_data),
};

#endif /* CONFIG_IS_ENABLED(DM_USB) */
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0
673a524b IY	2	/*
	3	* Copyright (C) 2005-2007 by Texas Instruments
	4	* Some code has been taken from tusb6010.c
	5	* Copyrights for that are attributable to:
	6	* Copyright (C) 2006 Nokia Corporation
	7	* Tony Lindgren <[email protected]>
	8	*
	9	* This file is part of the Inventra Controller Driver for Linux.
673a524b	10	*/
673a524b	11	#include <common.h>
1a35526e	12	#include <dm.h>
f516fd99	13	#include <serial.h>
1a35526e	14	#include <dm/device-internal.h>
336d4615	15	#include <dm/device_compat.h>
1a35526e	16	#include <dm/lists.h>
61b29b82	17	#include <linux/err.h>
1a35526e	18	#include <linux/usb/otg.h>
27754d18	19	#include <asm/omap_common.h>
673a524b IY	20	#include <asm/omap_musb.h>
673a524b IY	21	#include <twl4030.h>
27754d18	22	#include <twl6030.h>
673a524b	23	#include "linux-compat.h"
673a524b IY	24	#include "musb_core.h"
673a524b IY	25	#include "omap2430.h"
1a35526e	26	#include "musb_uboot.h"
673a524b	27
673a524b IY	28	static inline void omap2430_low_level_exit(struct musb *musb)
	29	{
	30	u32 l;
	31
	32	/* in any role */
	33	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	34	l \|= ENABLEFORCE; /* enable MSTANDBY */
	35	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
	36	}
	37
	38	static inline void omap2430_low_level_init(struct musb *musb)
	39	{
	40	u32 l;
	41
	42	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	43	l &= ~ENABLEFORCE; /* disable MSTANDBY */
	44	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
	45	}
	46
673a524b IY	47
	48	static int omap2430_musb_init(struct musb *musb)
	49	{
	50	u32 l;
	51	int status = 0;
193d7d15	52	unsigned long int start;
1a35526e	53
673a524b IY	54	struct omap_musb_board_data *data =
673a524b IY	55	(struct omap_musb_board_data *)musb->controller;
673a524b	56
193d7d15 PK	57	/* Reset the controller */
	58	musb_writel(musb->mregs, OTG_SYSCONFIG, SOFTRST);
	59
	60	start = get_timer(0);
	61
	62	while (1) {
	63	l = musb_readl(musb->mregs, OTG_SYSCONFIG);
	64	if ((l & SOFTRST) == 0)
	65	break;
	66
	67	if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
	68	dev_err(musb->controller, "MUSB reset is taking too long\n");
	69	return -ENODEV;
	70	}
	71	}
673a524b	72
673a524b IY	73	l = musb_readl(musb->mregs, OTG_INTERFSEL);
	74
	75	if (data->interface_type == MUSB_INTERFACE_UTMI) {
	76	/* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
	77	l &= ~ULPI_12PIN; /* Disable ULPI */
	78	l \|= UTMI_8BIT; /* Enable UTMI */
	79	} else {
	80	l \|= ULPI_12PIN;
	81	}
	82
	83	musb_writel(musb->mregs, OTG_INTERFSEL, l);
	84
	85	pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
	86	"sysstatus 0x%x, intrfsel 0x%x, simenable 0x%x\n",
	87	musb_readl(musb->mregs, OTG_REVISION),
	88	musb_readl(musb->mregs, OTG_SYSCONFIG),
	89	musb_readl(musb->mregs, OTG_SYSSTATUS),
	90	musb_readl(musb->mregs, OTG_INTERFSEL),
	91	musb_readl(musb->mregs, OTG_SIMENABLE));
673a524b IY	92	return 0;
	93
	94	err1:
	95	return status;
	96	}
	97
15837236	98	static int omap2430_musb_enable(struct musb *musb)
673a524b	99	{
673a524b IY	100	#ifdef CONFIG_TWL4030_USB
	101	if (twl4030_usb_ulpi_init()) {
	102	serial_printf("ERROR: %s Could not initialize PHY\n",
	103	__PRETTY_FUNCTION__);
	104	}
	105	#endif
27754d18 PK	106
	107	#ifdef CONFIG_TWL6030_POWER
	108	twl6030_usb_device_settings();
	109	#endif
	110
77777f76	111	#ifdef CONFIG_OMAP44XX
27754d18 PK	112	u32 usbotghs_control = (u32 )((*ctrl)->control_usbotghs_ctrl);
	113	*usbotghs_control = USBOTGHS_CONTROL_AVALID \|
	114	USBOTGHS_CONTROL_VBUSVALID \| USBOTGHS_CONTROL_IDDIG;
	115	#endif
	116
15837236	117	return 0;
673a524b IY	118	}
	119
	120	static void omap2430_musb_disable(struct musb *musb)
	121	{
673a524b	122
673a524b IY	123	}
	124
	125	static int omap2430_musb_exit(struct musb *musb)
	126	{
	127	del_timer_sync(&musb_idle_timer);
	128
	129	omap2430_low_level_exit(musb);
	130
	131	return 0;
	132	}
	133
673a524b	134	const struct musb_platform_ops omap2430_ops = {
673a524b IY	135	.init = omap2430_musb_init,
673a524b IY	136	.exit = omap2430_musb_exit,
673a524b IY	137	.enable = omap2430_musb_enable,
	138	.disable = omap2430_musb_disable,
	139	};
1a35526e	140
fd09c205	141	#if CONFIG_IS_ENABLED(DM_USB)
1a35526e AF	142
	143	struct omap2430_musb_platdata {
	144	void *base;
	145	void *ctrl_mod_base;
	146	struct musb_hdrc_platform_data plat;
	147	struct musb_hdrc_config musb_config;
	148	struct omap_musb_board_data otg_board_data;
	149	};
	150
	151	static int omap2430_musb_ofdata_to_platdata(struct udevice *dev)
	152	{
	153	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
	154	const void *fdt = gd->fdt_blob;
	155	int node = dev_of_offset(dev);
	156
	157	platdata->base = (void *)dev_read_addr_ptr(dev);
	158
	159	platdata->musb_config.multipoint = fdtdec_get_int(fdt, node,
	160	"multipoint",
	161	-1);
	162	if (platdata->musb_config.multipoint < 0) {
	163	pr_err("MUSB multipoint DT entry missing\n");
	164	return -ENOENT;
	165	}
	166
	167	platdata->musb_config.dyn_fifo = 1;
	168	platdata->musb_config.num_eps = fdtdec_get_int(fdt, node,
	169	"num-eps", -1);
	170	if (platdata->musb_config.num_eps < 0) {
	171	pr_err("MUSB num-eps DT entry missing\n");
	172	return -ENOENT;
	173	}
	174
	175	platdata->musb_config.ram_bits = fdtdec_get_int(fdt, node,
	176	"ram-bits", -1);
	177	if (platdata->musb_config.ram_bits < 0) {
	178	pr_err("MUSB ram-bits DT entry missing\n");
	179	return -ENOENT;
	180	}
	181
	182	platdata->plat.power = fdtdec_get_int(fdt, node,
	183	"power", -1);
	184	if (platdata->plat.power < 0) {
	185	pr_err("MUSB power DT entry missing\n");
	186	return -ENOENT;
	187	}
	188
	189	platdata->otg_board_data.interface_type = fdtdec_get_int(fdt, node,
	190	"interface-type", -1);
	191	if (platdata->otg_board_data.interface_type < 0) {
	192	pr_err("MUSB interface-type DT entry missing\n");
	193	return -ENOENT;
	194	}
	195
	196	#if 0 /* In a perfect world, mode would be set to OTG, mode 3 from DT */
	197	platdata->plat.mode = fdtdec_get_int(fdt, node,
	198	"mode", -1);
	199	if (platdata->plat.mode < 0) {
	200	pr_err("MUSB mode DT entry missing\n");
	201	return -ENOENT;
	202	}
	203	#else /* MUSB_OTG, it doesn't work */
	204	#ifdef CONFIG_USB_MUSB_HOST /* Host seems to be the only option that works */
	205	platdata->plat.mode = MUSB_HOST;
206	#else /* For that matter, MUSB_PERIPHERAL doesn't either */
207	platdata->plat.mode = MUSB_PERIPHERAL;
208	#endif
209	#endif
210	platdata->otg_board_data.dev = dev;
211	platdata->plat.config = &platdata->musb_config;
212	platdata->plat.platform_ops = &omap2430_ops;
213	platdata->plat.board_data = &platdata->otg_board_data;
214	return 0;
215	}
216
217	static int omap2430_musb_probe(struct udevice *dev)
218	{
219	#ifdef CONFIG_USB_MUSB_HOST
220	struct musb_host_data *host = dev_get_priv(dev);
9adaa039 DW	221	#else
9adaa039 DW	222	struct musb *musbp;
1a35526e AF	223	#endif
	224	struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
	225	struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
	226	struct omap_musb_board_data *otg_board_data;
9adaa039	227	int ret = 0;
1a35526e AF	228	void *base = dev_read_addr_ptr(dev);
	229
	230	priv->desc_before_addr = true;
	231
	232	otg_board_data = &platdata->otg_board_data;
	233
	234	#ifdef CONFIG_USB_MUSB_HOST
	235	host->host = musb_init_controller(&platdata->plat,
	236	(struct device *)otg_board_data,
	237	platdata->base);
	238	if (!host->host) {
	239	return -EIO;
	240	}
	241
	242	ret = musb_lowlevel_init(host);
	243	#else
9adaa039	244	musbp = musb_register(&platdata->plat,
1a35526e AF	245	(struct device *)otg_board_data,
1a35526e AF	246	platdata->base);
9adaa039 DW	247	if (IS_ERR_OR_NULL(musbp))
9adaa039 DW	248	return -EINVAL;
1a35526e AF	249	#endif
	250	return ret;
	251	}
	252
	253	static int omap2430_musb_remove(struct udevice *dev)
	254	{
	255	struct musb_host_data *host = dev_get_priv(dev);
	256
	257	musb_stop(host->host);
	258
	259	return 0;
	260	}
	261
	262	static const struct udevice_id omap2430_musb_ids[] = {
	263	{ .compatible = "ti,omap3-musb" },
	264	{ .compatible = "ti,omap4-musb" },
	265	{ }
	266	};
	267
	268	U_BOOT_DRIVER(omap2430_musb) = {
	269	.name = "omap2430-musb",
	270	#ifdef CONFIG_USB_MUSB_HOST
	271	.id = UCLASS_USB,
	272	#else
01311624	273	.id = UCLASS_USB_GADGET_GENERIC,
1a35526e AF	274	#endif
	275	.of_match = omap2430_musb_ids,
	276	.ofdata_to_platdata = omap2430_musb_ofdata_to_platdata,
	277	.probe = omap2430_musb_probe,
	278	.remove = omap2430_musb_remove,
	279	#ifdef CONFIG_USB_MUSB_HOST
	280	.ops = &musb_usb_ops,
	281	#endif
	282	.platdata_auto_alloc_size = sizeof(struct omap2430_musb_platdata),
	283	.priv_auto_alloc_size = sizeof(struct musb_host_data),
	284	};
	285
fd09c205	286	#endif /* CONFIG_IS_ENABLED(DM_USB) */