[people/ms/u-boot.git] / drivers / usb / common / fsl-dt-fixup.c

/*
 * (C) Copyright 2009, 2011 Freescale Semiconductor, Inc.
 *
 * (C) Copyright 2008, Excito Elektronik i Sk=E5ne AB
 *
 * Author: Tor Krill tor@excito.com
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <usb.h>
#include <asm/io.h>
#include <hwconfig.h>
#include <fsl_errata.h>
#include <fsl_usb.h>
#include <fdt_support.h>

#ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
#define CONFIG_USB_MAX_CONTROLLER_COUNT 1
#endif

/* USB Controllers */
#define FSL_USB2_MPH	"fsl-usb2-mph"
#define FSL_USB2_DR	"fsl-usb2-dr"
#define CHIPIDEA_USB2	"chipidea,usb2"
#define SNPS_DWC3	"snps,dwc3"

static const char * const compat_usb_fsl[] = {
	FSL_USB2_MPH,
	FSL_USB2_DR,
	SNPS_DWC3,
	NULL
};

static int fdt_usb_get_node_type(void *blob, int start_offset,
				 int *node_offset, const char **node_type)
{
	int i;
	int ret = -ENOENT;

	for (i = 0; compat_usb_fsl[i]; i++) {
		*node_offset = fdt_node_offset_by_compatible
					(blob, start_offset,
					 compat_usb_fsl[i]);
		if (*node_offset >= 0) {
			*node_type = compat_usb_fsl[i];
			ret = 0;
			break;
		}
	}

	return ret;
}

static int fdt_fixup_usb_mode_phy_type(void *blob, const char *mode,
				       const char *phy_type, int start_offset)
{
	const char *prop_mode = "dr_mode";
	const char *prop_type = "phy_type";
	const char *node_type = NULL;
	int node_offset;
	int err;

	err = fdt_usb_get_node_type(blob, start_offset,
				    &node_offset, &node_type);
	if (err < 0)
		return err;

	if (mode) {
		err = fdt_setprop(blob, node_offset, prop_mode, mode,
				  strlen(mode) + 1);
		if (err < 0)
			printf("WARNING: could not set %s for %s: %s.\n",
			       prop_mode, node_type, fdt_strerror(err));
	}

	if (phy_type) {
		err = fdt_setprop(blob, node_offset, prop_type, phy_type,
				  strlen(phy_type) + 1);
		if (err < 0)
			printf("WARNING: could not set %s for %s: %s.\n",
			       prop_type, node_type, fdt_strerror(err));
	}

	return node_offset;
}

static int fdt_fixup_usb_erratum(void *blob, const char *prop_erratum,
				 const char *controller_type, int start_offset)
{
	int node_offset, err;
	const char *node_type = NULL;
	const char *node_name = NULL;

	err = fdt_usb_get_node_type(blob, start_offset,
				    &node_offset, &node_type);
	if (err < 0)
		return err;

	if (!strcmp(node_type, FSL_USB2_MPH) || !strcmp(node_type, FSL_USB2_DR))
		node_name = CHIPIDEA_USB2;
	else
		node_name = node_type;
	if (strcmp(node_name, controller_type))
		return err;

	err = fdt_setprop(blob, node_offset, prop_erratum, NULL, 0);
	if (err < 0) {
		printf("ERROR: could not set %s for %s: %s.\n",
		       prop_erratum, node_type, fdt_strerror(err));
	}

	return node_offset;
}

static int fdt_fixup_erratum(int *usb_erratum_off, void *blob,
			     const char *controller_type, char *str,
			     bool (*has_erratum)(void))
{
	char buf[32] = {0};

	snprintf(buf, sizeof(buf), "fsl,usb-erratum-%s", str);
	if (!has_erratum())
		return -EINVAL;
	*usb_erratum_off = fdt_fixup_usb_erratum(blob, buf, controller_type,
						 *usb_erratum_off);
	if (*usb_erratum_off < 0)
		return -ENOSPC;
	debug("Adding USB erratum %s\n", str);
	return 0;
}

void fdt_fixup_dr_usb(void *blob, bd_t *bd)
{
	static const char * const modes[] = { "host", "peripheral", "otg" };
	static const char * const phys[] = { "ulpi", "utmi", "utmi_dual" };
	int usb_erratum_a006261_off = -1;
	int usb_erratum_a007075_off = -1;
	int usb_erratum_a007792_off = -1;
	int usb_erratum_a005697_off = -1;
	int usb_erratum_a008751_off = -1;
	int usb_mode_off = -1;
	int usb_phy_off = -1;
	char str[5];
	int i, j;
	int ret;

	for (i = 1; i <= CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
		const char *dr_mode_type = NULL;
		const char *dr_phy_type = NULL;
		int mode_idx = -1, phy_idx = -1;

		snprintf(str, 5, "%s%d", "usb", i);
		if (hwconfig(str)) {
			for (j = 0; j < ARRAY_SIZE(modes); j++) {
				if (hwconfig_subarg_cmp(str, "dr_mode",
							modes[j])) {
					mode_idx = j;
					break;
				}
			}

			for (j = 0; j < ARRAY_SIZE(phys); j++) {
				if (hwconfig_subarg_cmp(str, "phy_type",
							phys[j])) {
					phy_idx = j;
					break;
				}
			}

			if (mode_idx < 0 && phy_idx < 0) {
				printf("WARNING: invalid phy or mode\n");
				return;
			}

			if (mode_idx > -1)
				dr_mode_type = modes[mode_idx];

			if (phy_idx > -1)
				dr_phy_type = phys[phy_idx];
		}

		if (has_dual_phy())
			dr_phy_type = phys[2];

		usb_mode_off = fdt_fixup_usb_mode_phy_type(blob,
							   dr_mode_type, NULL,
							   usb_mode_off);

		if (usb_mode_off < 0)
			return;

		usb_phy_off = fdt_fixup_usb_mode_phy_type(blob,
							  NULL, dr_phy_type,
							  usb_phy_off);

		if (usb_phy_off < 0)
			return;

		ret = fdt_fixup_erratum(&usb_erratum_a006261_off, blob,
					CHIPIDEA_USB2, "a006261",
					has_erratum_a006261);
		if (ret == -ENOSPC)
			return;
		ret = fdt_fixup_erratum(&usb_erratum_a007075_off, blob,
					CHIPIDEA_USB2, "a007075",
					has_erratum_a007075);
		if (ret == -ENOSPC)
			return;
		ret = fdt_fixup_erratum(&usb_erratum_a007792_off, blob,
					CHIPIDEA_USB2, "a007792",
					has_erratum_a007792);
		if (ret == -ENOSPC)
			return;
		ret = fdt_fixup_erratum(&usb_erratum_a005697_off, blob,
					CHIPIDEA_USB2, "a005697",
					has_erratum_a005697);
		if (ret == -ENOSPC)
			return;
		ret = fdt_fixup_erratum(&usb_erratum_a008751_off, blob,
					SNPS_DWC3, "a008751",
					has_erratum_a008751);
		if (ret == -ENOSPC)
			return;

	}
}
Commit	Line	Data
93eb8f39 SD	1	/*
	2	* (C) Copyright 2009, 2011 Freescale Semiconductor, Inc.
	3	*
	4	* (C) Copyright 2008, Excito Elektronik i Sk=E5ne AB
	5	*
	6	* Author: Tor Krill tor@excito.com
	7	*
	8	* SPDX-License-Identifier: GPL-2.0+
	9	*/
	10
	11	#include <common.h>
	12	#include <usb.h>
	13	#include <asm/io.h>
	14	#include <hwconfig.h>
92623672	15	#include <fsl_errata.h>
93eb8f39 SD	16	#include <fsl_usb.h>
	17	#include <fdt_support.h>
	18
	19	#ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
	20	#define CONFIG_USB_MAX_CONTROLLER_COUNT 1
	21	#endif
	22
bf655775 SD	23	/* USB Controllers */
	24	#define FSL_USB2_MPH "fsl-usb2-mph"
	25	#define FSL_USB2_DR "fsl-usb2-dr"
	26	#define CHIPIDEA_USB2 "chipidea,usb2"
	27	#define SNPS_DWC3 "snps,dwc3"
	28
b9f6786a	29	static const char * const compat_usb_fsl[] = {
bf655775 SD	30	FSL_USB2_MPH,
	31	FSL_USB2_DR,
	32	SNPS_DWC3,
b9f6786a SD	33	NULL
	34	};
	35
47435e5b SD	36	static int fdt_usb_get_node_type(void *blob, int start_offset,
47435e5b SD	37	int node_offset, const char *node_type)
93eb8f39	38	{
b9f6786a	39	int i;
47435e5b	40	int ret = -ENOENT;
93eb8f39	41
b9f6786a SD	42	for (i = 0; compat_usb_fsl[i]; i++) {
	43	*node_offset = fdt_node_offset_by_compatible
	44	(blob, start_offset,
	45	compat_usb_fsl[i]);
	46	if (*node_offset >= 0) {
47435e5b SD	47	*node_type = compat_usb_fsl[i];
47435e5b SD	48	ret = 0;
b9f6786a	49	break;
93eb8f39	50	}
93eb8f39 SD	51	}
93eb8f39 SD	52
47435e5b	53	return ret;
469e72bc SD	54	}
	55
	56	static int fdt_fixup_usb_mode_phy_type(void blob, const char mode,
	57	const char *phy_type, int start_offset)
	58	{
	59	const char *prop_mode = "dr_mode";
	60	const char *prop_type = "phy_type";
	61	const char *node_type = NULL;
	62	int node_offset;
	63	int err;
	64
47435e5b SD	65	err = fdt_usb_get_node_type(blob, start_offset,
	66	&node_offset, &node_type);
	67	if (err < 0)
	68	return err;
469e72bc	69
93eb8f39 SD	70	if (mode) {
	71	err = fdt_setprop(blob, node_offset, prop_mode, mode,
	72	strlen(mode) + 1);
	73	if (err < 0)
	74	printf("WARNING: could not set %s for %s: %s.\n",
	75	prop_mode, node_type, fdt_strerror(err));
	76	}
	77
	78	if (phy_type) {
	79	err = fdt_setprop(blob, node_offset, prop_type, phy_type,
	80	strlen(phy_type) + 1);
	81	if (err < 0)
	82	printf("WARNING: could not set %s for %s: %s.\n",
	83	prop_type, node_type, fdt_strerror(err));
	84	}
	85
	86	return node_offset;
	87	}
	88
93eb8f39	89	static int fdt_fixup_usb_erratum(void blob, const char prop_erratum,
bf655775	90	const char *controller_type, int start_offset)
93eb8f39 SD	91	{
	92	int node_offset, err;
	93	const char *node_type = NULL;
bf655775	94	const char *node_name = NULL;
93eb8f39	95
47435e5b SD	96	err = fdt_usb_get_node_type(blob, start_offset,
	97	&node_offset, &node_type);
	98	if (err < 0)
	99	return err;
93eb8f39	100
bf655775 SD	101	if (!strcmp(node_type, FSL_USB2_MPH) \|\| !strcmp(node_type, FSL_USB2_DR))
	102	node_name = CHIPIDEA_USB2;
	103	else
	104	node_name = node_type;
	105	if (strcmp(node_name, controller_type))
	106	return err;
	107
93eb8f39 SD	108	err = fdt_setprop(blob, node_offset, prop_erratum, NULL, 0);
	109	if (err < 0) {
	110	printf("ERROR: could not set %s for %s: %s.\n",
	111	prop_erratum, node_type, fdt_strerror(err));
	112	}
	113
	114	return node_offset;
	115	}
	116
bf655775 SD	117	static int fdt_fixup_erratum(int usb_erratum_off, void blob,
	118	const char controller_type, char str,
	119	bool (*has_erratum)(void))
	120	{
	121	char buf[32] = {0};
	122
	123	snprintf(buf, sizeof(buf), "fsl,usb-erratum-%s", str);
	124	if (!has_erratum())
	125	return -EINVAL;
	126	*usb_erratum_off = fdt_fixup_usb_erratum(blob, buf, controller_type,
	127	*usb_erratum_off);
	128	if (*usb_erratum_off < 0)
	129	return -ENOSPC;
	130	debug("Adding USB erratum %s\n", str);
	131	return 0;
	132	}
	133
93eb8f39 SD	134	void fdt_fixup_dr_usb(void blob, bd_t bd)
	135	{
	136	static const char * const modes[] = { "host", "peripheral", "otg" };
	137	static const char * const phys[] = { "ulpi", "utmi", "utmi_dual" };
	138	int usb_erratum_a006261_off = -1;
	139	int usb_erratum_a007075_off = -1;
	140	int usb_erratum_a007792_off = -1;
	141	int usb_erratum_a005697_off = -1;
ef53b8c4	142	int usb_erratum_a008751_off = -1;
93eb8f39 SD	143	int usb_mode_off = -1;
	144	int usb_phy_off = -1;
	145	char str[5];
	146	int i, j;
bf655775	147	int ret;
93eb8f39 SD	148
	149	for (i = 1; i <= CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
	150	const char *dr_mode_type = NULL;
	151	const char *dr_phy_type = NULL;
	152	int mode_idx = -1, phy_idx = -1;
	153
	154	snprintf(str, 5, "%s%d", "usb", i);
	155	if (hwconfig(str)) {
	156	for (j = 0; j < ARRAY_SIZE(modes); j++) {
	157	if (hwconfig_subarg_cmp(str, "dr_mode",
	158	modes[j])) {
	159	mode_idx = j;
	160	break;
	161	}
	162	}
	163
	164	for (j = 0; j < ARRAY_SIZE(phys); j++) {
	165	if (hwconfig_subarg_cmp(str, "phy_type",
	166	phys[j])) {
	167	phy_idx = j;
	168	break;
	169	}
	170	}
	171
	172	if (mode_idx < 0 && phy_idx < 0) {
	173	printf("WARNING: invalid phy or mode\n");
	174	return;
	175	}
	176
	177	if (mode_idx > -1)
	178	dr_mode_type = modes[mode_idx];
	179
	180	if (phy_idx > -1)
	181	dr_phy_type = phys[phy_idx];
	182	}
	183
	184	if (has_dual_phy())
	185	dr_phy_type = phys[2];
	186
	187	usb_mode_off = fdt_fixup_usb_mode_phy_type(blob,
	188	dr_mode_type, NULL,
	189	usb_mode_off);
	190
	191	if (usb_mode_off < 0)
	192	return;
	193
	194	usb_phy_off = fdt_fixup_usb_mode_phy_type(blob,
	195	NULL, dr_phy_type,
	196	usb_phy_off);
	197
	198	if (usb_phy_off < 0)
	199	return;
	200
bf655775 SD	201	ret = fdt_fixup_erratum(&usb_erratum_a006261_off, blob,
	202	CHIPIDEA_USB2, "a006261",
	203	has_erratum_a006261);
	204	if (ret == -ENOSPC)
	205	return;
	206	ret = fdt_fixup_erratum(&usb_erratum_a007075_off, blob,
	207	CHIPIDEA_USB2, "a007075",
	208	has_erratum_a007075);
	209	if (ret == -ENOSPC)
	210	return;
	211	ret = fdt_fixup_erratum(&usb_erratum_a007792_off, blob,
	212	CHIPIDEA_USB2, "a007792",
	213	has_erratum_a007792);
	214	if (ret == -ENOSPC)
	215	return;
	216	ret = fdt_fixup_erratum(&usb_erratum_a005697_off, blob,
	217	CHIPIDEA_USB2, "a005697",
	218	has_erratum_a005697);
	219	if (ret == -ENOSPC)
	220	return;
ef53b8c4 SD	221	ret = fdt_fixup_erratum(&usb_erratum_a008751_off, blob,
	222	SNPS_DWC3, "a008751",
	223	has_erratum_a008751);
	224	if (ret == -ENOSPC)
	225	return;
	226
93eb8f39 SD	227	}
93eb8f39 SD	228	}