[thirdparty/u-boot.git] / drivers / phy / omap-usb2-phy.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * OMAP USB2 PHY LAYER
 *
 * Copyright (C) 2018 Texas Instruments Incorporated - https://www.ti.com
 * Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
 */

#include <asm/global_data.h>
#include <asm/io.h>
#include <dm.h>
#include <errno.h>
#include <generic-phy.h>
#include <regmap.h>
#include <soc.h>
#include <syscon.h>
#include <linux/bitops.h>
#include <linux/err.h>

#define OMAP_USB2_CALIBRATE_FALSE_DISCONNECT	BIT(0)
#define OMAP_USB2_DISABLE_CHG_DET		BIT(1)

#define OMAP_DEV_PHY_PD		BIT(0)
#define OMAP_USB2_PHY_PD	BIT(28)

#define AM437X_USB2_PHY_PD		BIT(0)
#define AM437X_USB2_OTG_PD		BIT(1)
#define AM437X_USB2_OTGVDET_EN		BIT(19)
#define AM437X_USB2_OTGSESSEND_EN	BIT(20)

#define USB2PHY_DISCON_BYP_LATCH	BIT(31)
#define USB2PHY_ANA_CONFIG1		(0x4c)

#define AM654_USB2_OTG_PD		BIT(8)
#define AM654_USB2_VBUS_DET_EN		BIT(5)
#define AM654_USB2_VBUSVALID_DET_EN	BIT(4)

#define USB2PHY_CHRG_DET		 0x14
#define USB2PHY_USE_CHG_DET_REG		BIT(29)
#define USB2PHY_DIS_CHG_DET		BIT(28)

DECLARE_GLOBAL_DATA_PTR;

struct omap_usb2_phy {
	struct regmap *pwr_regmap;
	ulong flags;
	void *phy_base;
	u32 pwr_reg_offset;
};

struct usb_phy_data {
	const char *label;
	u8 flags;
	u32 mask;
	u32 power_on;
	u32 power_off;
};

static const struct usb_phy_data omap5_usb2_data = {
	.label = "omap5_usb2",
	.flags = 0,
	.mask = OMAP_DEV_PHY_PD,
	.power_off = OMAP_DEV_PHY_PD,
};

static const struct usb_phy_data dra7x_usb2_data = {
	.label = "dra7x_usb2",
	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	.mask = OMAP_DEV_PHY_PD,
	.power_off = OMAP_DEV_PHY_PD,
};

static const struct usb_phy_data dra7x_usb2_phy2_data = {
	.label = "dra7x_usb2_phy2",
	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	.mask = OMAP_USB2_PHY_PD,
	.power_off = OMAP_USB2_PHY_PD,
};

static const struct usb_phy_data am437x_usb2_data = {
	.label = "am437x_usb2",
	.flags =  0,
	.mask = AM437X_USB2_PHY_PD | AM437X_USB2_OTG_PD |
		AM437X_USB2_OTGVDET_EN | AM437X_USB2_OTGSESSEND_EN,
	.power_on = AM437X_USB2_OTGVDET_EN | AM437X_USB2_OTGSESSEND_EN,
	.power_off = AM437X_USB2_PHY_PD | AM437X_USB2_OTG_PD,
};

static const struct usb_phy_data am654_usb2_data = {
	.label = "am654_usb2",
	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	.mask = AM654_USB2_OTG_PD | AM654_USB2_VBUS_DET_EN |
		AM654_USB2_VBUSVALID_DET_EN,
	.power_on = AM654_USB2_VBUS_DET_EN | AM654_USB2_VBUSVALID_DET_EN,
	.power_off = AM654_USB2_OTG_PD,
};

static const struct udevice_id omap_usb2_id_table[] = {
	{
		.compatible = "ti,omap5-usb2",
		.data = (ulong)&omap5_usb2_data,
	},
	{
		.compatible = "ti,dra7x-usb2",
		.data = (ulong)&dra7x_usb2_data,
	},
	{
		.compatible = "ti,dra7x-usb2-phy2",
		.data = (ulong)&dra7x_usb2_phy2_data,
	},
	{
		.compatible = "ti,am437x-usb2",
		.data = (ulong)&am437x_usb2_data,
	},
	{
		.compatible = "ti,am654-usb2",
		.data = (ulong)&am654_usb2_data,
	},
	{},
};

static int omap_usb_phy_power(struct phy *usb_phy, bool on)
{
	struct udevice *dev = usb_phy->dev;
	const struct usb_phy_data *data;
	const struct omap_usb2_phy *phy = dev_get_priv(dev);
	u32 val;
	int rc;

	data = (const struct usb_phy_data *)dev_get_driver_data(dev);
	if (!data)
		return -EINVAL;

	rc = regmap_read(phy->pwr_regmap, phy->pwr_reg_offset, &val);
	if (rc)
		return rc;
	val &= ~data->mask;
	if (on)
		val |= data->power_on;
	else
		val |= data->power_off;
	rc = regmap_write(phy->pwr_regmap, phy->pwr_reg_offset, val);
	if (rc)
		return rc;

	return 0;
}

static int omap_usb2_phy_init(struct phy *usb_phy)
{
	struct udevice *dev = usb_phy->dev;
	struct omap_usb2_phy *priv = dev_get_priv(dev);
	u32 val;

	if (priv->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
		/*
		 *
		 * Reduce the sensitivity of internal PHY by enabling the
		 * DISCON_BYP_LATCH of the USB2PHY_ANA_CONFIG1 register. This
		 * resolves issues with certain devices which can otherwise
		 * be prone to false disconnects.
		 *
		 */
		val = readl(priv->phy_base + USB2PHY_ANA_CONFIG1);
		val |= USB2PHY_DISCON_BYP_LATCH;
		writel(val, priv->phy_base + USB2PHY_ANA_CONFIG1);
	}

	if (priv->flags & OMAP_USB2_DISABLE_CHG_DET) {
		val = readl(priv->phy_base + USB2PHY_CHRG_DET);
		val |= USB2PHY_USE_CHG_DET_REG | USB2PHY_DIS_CHG_DET;
		writel(val, priv->phy_base + USB2PHY_CHRG_DET);
	}

	return 0;
}

static int omap_usb2_phy_power_on(struct phy *usb_phy)
{
	return omap_usb_phy_power(usb_phy, true);
}

static int omap_usb2_phy_power_off(struct phy *usb_phy)
{
	return omap_usb_phy_power(usb_phy, false);
}

static int omap_usb2_phy_exit(struct phy *usb_phy)
{
	return omap_usb_phy_power(usb_phy, false);
}

struct phy_ops omap_usb2_phy_ops = {
	.init = omap_usb2_phy_init,
	.power_on = omap_usb2_phy_power_on,
	.power_off = omap_usb2_phy_power_off,
	.exit = omap_usb2_phy_exit,
};

static const struct soc_attr am65x_sr10_soc_devices[] = {
	{ .family = "AM65X", .revision = "SR1.0" },
	{ /* sentinel */ }
};

int omap_usb2_phy_probe(struct udevice *dev)
{
	int rc;
	struct regmap *regmap;
	struct omap_usb2_phy *priv = dev_get_priv(dev);
	const struct usb_phy_data *data;
	u32 tmp[2];

	data = (const struct usb_phy_data *)dev_get_driver_data(dev);
	if (!data)
		return -EINVAL;

	priv->phy_base = dev_read_addr_ptr(dev);

	if (!priv->phy_base)
		return -EINVAL;

	if (data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT)
		priv->flags |= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT;

	/*
	 * AM654x PG1.0 has a silicon bug that D+ is pulled high after
	 * POR, which could cause enumeration failure with some USB hubs.
	 * Disabling the USB2_PHY Charger Detect function will put D+
	 * into the normal state.
	 *
	 * Enable this workaround for AM654x PG1.0.
	 */
	if (soc_device_match(am65x_sr10_soc_devices))
		priv->flags |= OMAP_USB2_DISABLE_CHG_DET;

	regmap = syscon_regmap_lookup_by_phandle(dev, "syscon-phy-power");
	if (!IS_ERR(regmap)) {
		priv->pwr_regmap = regmap;
		rc =  dev_read_u32_array(dev, "syscon-phy-power", tmp, 2);
		if (rc) {
			printf("couldn't get power reg. offset (err %d)\n", rc);
			return rc;
		}
		priv->pwr_reg_offset = tmp[1];
		return 0;
	}
	regmap = syscon_regmap_lookup_by_phandle(dev, "ctrl-module");
	if (!IS_ERR(regmap)) {
		priv->pwr_regmap = regmap;
		priv->pwr_reg_offset = 0;
		return 0;
	}

	printf("can't get regmap (err %ld)\n", PTR_ERR(regmap));
	return PTR_ERR(regmap);
}

U_BOOT_DRIVER(omap_usb2_phy) = {
	.name = "omap_usb2_phy",
	.id = UCLASS_PHY,
	.of_match = omap_usb2_id_table,
	.probe = omap_usb2_phy_probe,
	.ops = &omap_usb2_phy_ops,
	.priv_auto	= sizeof(struct omap_usb2_phy),
};
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* OMAP USB2 PHY LAYER
	4	*
	5	* Copyright (C) 2018 Texas Instruments Incorporated - https://www.ti.com
	6	* Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
	7	*/
	8
	9	#include <asm/global_data.h>
	10	#include <asm/io.h>
	11	#include <dm.h>
	12	#include <errno.h>
	13	#include <generic-phy.h>
	14	#include <regmap.h>
	15	#include <soc.h>
	16	#include <syscon.h>
	17	#include <linux/bitops.h>
	18	#include <linux/err.h>
	19
	20	#define OMAP_USB2_CALIBRATE_FALSE_DISCONNECT BIT(0)
	21	#define OMAP_USB2_DISABLE_CHG_DET BIT(1)
	22
	23	#define OMAP_DEV_PHY_PD BIT(0)
	24	#define OMAP_USB2_PHY_PD BIT(28)
	25
	26	#define AM437X_USB2_PHY_PD BIT(0)
	27	#define AM437X_USB2_OTG_PD BIT(1)
	28	#define AM437X_USB2_OTGVDET_EN BIT(19)
	29	#define AM437X_USB2_OTGSESSEND_EN BIT(20)
	30
	31	#define USB2PHY_DISCON_BYP_LATCH BIT(31)
	32	#define USB2PHY_ANA_CONFIG1 (0x4c)
	33
	34	#define AM654_USB2_OTG_PD BIT(8)
	35	#define AM654_USB2_VBUS_DET_EN BIT(5)
	36	#define AM654_USB2_VBUSVALID_DET_EN BIT(4)
	37
	38	#define USB2PHY_CHRG_DET 0x14
	39	#define USB2PHY_USE_CHG_DET_REG BIT(29)
	40	#define USB2PHY_DIS_CHG_DET BIT(28)
	41
	42	DECLARE_GLOBAL_DATA_PTR;
	43
	44	struct omap_usb2_phy {
	45	struct regmap *pwr_regmap;
	46	ulong flags;
	47	void *phy_base;
	48	u32 pwr_reg_offset;
	49	};
	50
	51	struct usb_phy_data {
	52	const char *label;
	53	u8 flags;
	54	u32 mask;
	55	u32 power_on;
	56	u32 power_off;
	57	};
	58
	59	static const struct usb_phy_data omap5_usb2_data = {
	60	.label = "omap5_usb2",
	61	.flags = 0,
	62	.mask = OMAP_DEV_PHY_PD,
	63	.power_off = OMAP_DEV_PHY_PD,
	64	};
	65
	66	static const struct usb_phy_data dra7x_usb2_data = {
	67	.label = "dra7x_usb2",
	68	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	69	.mask = OMAP_DEV_PHY_PD,
	70	.power_off = OMAP_DEV_PHY_PD,
	71	};
	72
	73	static const struct usb_phy_data dra7x_usb2_phy2_data = {
	74	.label = "dra7x_usb2_phy2",
	75	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	76	.mask = OMAP_USB2_PHY_PD,
	77	.power_off = OMAP_USB2_PHY_PD,
	78	};
	79
	80	static const struct usb_phy_data am437x_usb2_data = {
	81	.label = "am437x_usb2",
	82	.flags = 0,
	83	.mask = AM437X_USB2_PHY_PD \| AM437X_USB2_OTG_PD \|
	84	AM437X_USB2_OTGVDET_EN \| AM437X_USB2_OTGSESSEND_EN,
	85	.power_on = AM437X_USB2_OTGVDET_EN \| AM437X_USB2_OTGSESSEND_EN,
	86	.power_off = AM437X_USB2_PHY_PD \| AM437X_USB2_OTG_PD,
	87	};
	88
	89	static const struct usb_phy_data am654_usb2_data = {
	90	.label = "am654_usb2",
	91	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	92	.mask = AM654_USB2_OTG_PD \| AM654_USB2_VBUS_DET_EN \|
	93	AM654_USB2_VBUSVALID_DET_EN,
	94	.power_on = AM654_USB2_VBUS_DET_EN \| AM654_USB2_VBUSVALID_DET_EN,
	95	.power_off = AM654_USB2_OTG_PD,
	96	};
	97
	98	static const struct udevice_id omap_usb2_id_table[] = {
	99	{
	100	.compatible = "ti,omap5-usb2",
	101	.data = (ulong)&omap5_usb2_data,
	102	},
	103	{
	104	.compatible = "ti,dra7x-usb2",
	105	.data = (ulong)&dra7x_usb2_data,
	106	},
	107	{
	108	.compatible = "ti,dra7x-usb2-phy2",
	109	.data = (ulong)&dra7x_usb2_phy2_data,
	110	},
	111	{
	112	.compatible = "ti,am437x-usb2",
	113	.data = (ulong)&am437x_usb2_data,
	114	},
	115	{
	116	.compatible = "ti,am654-usb2",
	117	.data = (ulong)&am654_usb2_data,
	118	},
	119	{},
	120	};
	121
	122	static int omap_usb_phy_power(struct phy *usb_phy, bool on)
	123	{
	124	struct udevice *dev = usb_phy->dev;
	125	const struct usb_phy_data *data;
	126	const struct omap_usb2_phy *phy = dev_get_priv(dev);
	127	u32 val;
	128	int rc;
	129
	130	data = (const struct usb_phy_data *)dev_get_driver_data(dev);
	131	if (!data)
	132	return -EINVAL;
	133
	134	rc = regmap_read(phy->pwr_regmap, phy->pwr_reg_offset, &val);
	135	if (rc)
	136	return rc;
	137	val &= ~data->mask;
	138	if (on)
	139	val \|= data->power_on;
	140	else
	141	val \|= data->power_off;
	142	rc = regmap_write(phy->pwr_regmap, phy->pwr_reg_offset, val);
	143	if (rc)
	144	return rc;
	145
	146	return 0;
	147	}
	148
	149	static int omap_usb2_phy_init(struct phy *usb_phy)
	150	{
	151	struct udevice *dev = usb_phy->dev;
	152	struct omap_usb2_phy *priv = dev_get_priv(dev);
	153	u32 val;
	154
	155	if (priv->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
	156	/*
	157	*
	158	* Reduce the sensitivity of internal PHY by enabling the
	159	* DISCON_BYP_LATCH of the USB2PHY_ANA_CONFIG1 register. This
	160	* resolves issues with certain devices which can otherwise
	161	* be prone to false disconnects.
	162	*
	163	*/
	164	val = readl(priv->phy_base + USB2PHY_ANA_CONFIG1);
	165	val \|= USB2PHY_DISCON_BYP_LATCH;
	166	writel(val, priv->phy_base + USB2PHY_ANA_CONFIG1);
	167	}
	168
	169	if (priv->flags & OMAP_USB2_DISABLE_CHG_DET) {
	170	val = readl(priv->phy_base + USB2PHY_CHRG_DET);
	171	val \|= USB2PHY_USE_CHG_DET_REG \| USB2PHY_DIS_CHG_DET;
	172	writel(val, priv->phy_base + USB2PHY_CHRG_DET);
	173	}
	174
	175	return 0;
	176	}
	177
	178	static int omap_usb2_phy_power_on(struct phy *usb_phy)
	179	{
	180	return omap_usb_phy_power(usb_phy, true);
	181	}
	182
	183	static int omap_usb2_phy_power_off(struct phy *usb_phy)
	184	{
	185	return omap_usb_phy_power(usb_phy, false);
	186	}
	187
	188	static int omap_usb2_phy_exit(struct phy *usb_phy)
	189	{
	190	return omap_usb_phy_power(usb_phy, false);
	191	}
	192
	193	struct phy_ops omap_usb2_phy_ops = {
	194	.init = omap_usb2_phy_init,
	195	.power_on = omap_usb2_phy_power_on,
	196	.power_off = omap_usb2_phy_power_off,
	197	.exit = omap_usb2_phy_exit,
	198	};
	199
	200	static const struct soc_attr am65x_sr10_soc_devices[] = {
	201	{ .family = "AM65X", .revision = "SR1.0" },
	202	{ /* sentinel */ }
	203	};
	204
	205	int omap_usb2_phy_probe(struct udevice *dev)
	206	{
	207	int rc;
	208	struct regmap *regmap;
	209	struct omap_usb2_phy *priv = dev_get_priv(dev);
	210	const struct usb_phy_data *data;
	211	u32 tmp[2];
	212
	213	data = (const struct usb_phy_data *)dev_get_driver_data(dev);
	214	if (!data)
	215	return -EINVAL;
	216
	217	priv->phy_base = dev_read_addr_ptr(dev);
	218
	219	if (!priv->phy_base)
	220	return -EINVAL;
	221
	222	if (data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT)
	223	priv->flags \|= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT;
	224
	225	/*
	226	* AM654x PG1.0 has a silicon bug that D+ is pulled high after
	227	* POR, which could cause enumeration failure with some USB hubs.
	228	* Disabling the USB2_PHY Charger Detect function will put D+
	229	* into the normal state.
	230	*
	231	* Enable this workaround for AM654x PG1.0.
	232	*/
	233	if (soc_device_match(am65x_sr10_soc_devices))
	234	priv->flags \|= OMAP_USB2_DISABLE_CHG_DET;
	235
	236	regmap = syscon_regmap_lookup_by_phandle(dev, "syscon-phy-power");
	237	if (!IS_ERR(regmap)) {
	238	priv->pwr_regmap = regmap;
	239	rc = dev_read_u32_array(dev, "syscon-phy-power", tmp, 2);
	240	if (rc) {
	241	printf("couldn't get power reg. offset (err %d)\n", rc);
	242	return rc;
	243	}
	244	priv->pwr_reg_offset = tmp[1];
	245	return 0;
	246	}
	247	regmap = syscon_regmap_lookup_by_phandle(dev, "ctrl-module");
	248	if (!IS_ERR(regmap)) {
	249	priv->pwr_regmap = regmap;
	250	priv->pwr_reg_offset = 0;
	251	return 0;
	252	}
	253
	254	printf("can't get regmap (err %ld)\n", PTR_ERR(regmap));
	255	return PTR_ERR(regmap);
	256	}
	257
	258	U_BOOT_DRIVER(omap_usb2_phy) = {
	259	.name = "omap_usb2_phy",
	260	.id = UCLASS_PHY,
	261	.of_match = omap_usb2_id_table,
	262	.probe = omap_usb2_phy_probe,
	263	.ops = &omap_usb2_phy_ops,
	264	.priv_auto = sizeof(struct omap_usb2_phy),
	265	};