[linux-2.6-block.git] / drivers / phy / motorola / phy-cpcap-usb.c

/*
 * Motorola CPCAP PMIC USB PHY driver
 * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
 *
 * Some parts based on earlier Motorola Linux kernel tree code in
 * board-mapphone-usb.c and cpcap-usb-det.c:
 * Copyright (C) 2007 - 2011 Motorola, 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 version 2.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/atomic.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/iio/consumer.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#include <linux/gpio/consumer.h>
#include <linux/mfd/motorola-cpcap.h>
#include <linux/phy/omap_usb.h>
#include <linux/phy/phy.h>
#include <linux/regulator/consumer.h>
#include <linux/usb/musb.h>

/* CPCAP_REG_USBC1 register bits */
#define CPCAP_BIT_IDPULSE		BIT(15)
#define CPCAP_BIT_ID100KPU		BIT(14)
#define CPCAP_BIT_IDPUCNTRL		BIT(13)
#define CPCAP_BIT_IDPU			BIT(12)
#define CPCAP_BIT_IDPD			BIT(11)
#define CPCAP_BIT_VBUSCHRGTMR3		BIT(10)
#define CPCAP_BIT_VBUSCHRGTMR2		BIT(9)
#define CPCAP_BIT_VBUSCHRGTMR1		BIT(8)
#define CPCAP_BIT_VBUSCHRGTMR0		BIT(7)
#define CPCAP_BIT_VBUSPU		BIT(6)
#define CPCAP_BIT_VBUSPD		BIT(5)
#define CPCAP_BIT_DMPD			BIT(4)
#define CPCAP_BIT_DPPD			BIT(3)
#define CPCAP_BIT_DM1K5PU		BIT(2)
#define CPCAP_BIT_DP1K5PU		BIT(1)
#define CPCAP_BIT_DP150KPU		BIT(0)

/* CPCAP_REG_USBC2 register bits */
#define CPCAP_BIT_ZHSDRV1		BIT(15)
#define CPCAP_BIT_ZHSDRV0		BIT(14)
#define CPCAP_BIT_DPLLCLKREQ		BIT(13)
#define CPCAP_BIT_SE0CONN		BIT(12)
#define CPCAP_BIT_UARTTXTRI		BIT(11)
#define CPCAP_BIT_UARTSWAP		BIT(10)
#define CPCAP_BIT_UARTMUX1		BIT(9)
#define CPCAP_BIT_UARTMUX0		BIT(8)
#define CPCAP_BIT_ULPISTPLOW		BIT(7)
#define CPCAP_BIT_TXENPOL		BIT(6)
#define CPCAP_BIT_USBXCVREN		BIT(5)
#define CPCAP_BIT_USBCNTRL		BIT(4)
#define CPCAP_BIT_USBSUSPEND		BIT(3)
#define CPCAP_BIT_EMUMODE2		BIT(2)
#define CPCAP_BIT_EMUMODE1		BIT(1)
#define CPCAP_BIT_EMUMODE0		BIT(0)

/* CPCAP_REG_USBC3 register bits */
#define CPCAP_BIT_SPARE_898_15		BIT(15)
#define CPCAP_BIT_IHSTX03		BIT(14)
#define CPCAP_BIT_IHSTX02		BIT(13)
#define CPCAP_BIT_IHSTX01		BIT(12)
#define CPCAP_BIT_IHSTX0		BIT(11)
#define CPCAP_BIT_IDPU_SPI		BIT(10)
#define CPCAP_BIT_UNUSED_898_9		BIT(9)
#define CPCAP_BIT_VBUSSTBY_EN		BIT(8)
#define CPCAP_BIT_VBUSEN_SPI		BIT(7)
#define CPCAP_BIT_VBUSPU_SPI		BIT(6)
#define CPCAP_BIT_VBUSPD_SPI		BIT(5)
#define CPCAP_BIT_DMPD_SPI		BIT(4)
#define CPCAP_BIT_DPPD_SPI		BIT(3)
#define CPCAP_BIT_SUSPEND_SPI		BIT(2)
#define CPCAP_BIT_PU_SPI		BIT(1)
#define CPCAP_BIT_ULPI_SPI_SEL		BIT(0)

struct cpcap_usb_ints_state {
	bool id_ground;
	bool id_float;
	bool chrg_det;
	bool rvrs_chrg;
	bool vbusov;

	bool chrg_se1b;
	bool se0conn;
	bool rvrs_mode;
	bool chrgcurr1;
	bool vbusvld;
	bool sessvld;
	bool sessend;
	bool se1;

	bool battdetb;
	bool dm;
	bool dp;
};

enum cpcap_gpio_mode {
	CPCAP_DM_DP,
	CPCAP_MDM_RX_TX,
	CPCAP_UNKNOWN,
	CPCAP_OTG_DM_DP,
};

struct cpcap_phy_ddata {
	struct regmap *reg;
	struct device *dev;
	struct clk *refclk;
	struct usb_phy phy;
	struct delayed_work detect_work;
	struct pinctrl *pins;
	struct pinctrl_state *pins_ulpi;
	struct pinctrl_state *pins_utmi;
	struct pinctrl_state *pins_uart;
	struct gpio_desc *gpio[2];
	struct iio_channel *vbus;
	struct iio_channel *id;
	struct regulator *vusb;
	atomic_t active;
};

static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
{
	int error, value = 0;

	error = iio_read_channel_processed(ddata->vbus, &value);
	if (error >= 0)
		return value > 3900 ? true : false;

	dev_err(ddata->dev, "error reading VBUS: %i\n", error);

	return false;
}

static int cpcap_usb_phy_set_host(struct usb_otg *otg, struct usb_bus *host)
{
	otg->host = host;
	if (!host)
		otg->state = OTG_STATE_UNDEFINED;

	return 0;
}

static int cpcap_usb_phy_set_peripheral(struct usb_otg *otg,
					struct usb_gadget *gadget)
{
	otg->gadget = gadget;
	if (!gadget)
		otg->state = OTG_STATE_UNDEFINED;

	return 0;
}

static const struct phy_ops ops = {
	.owner		= THIS_MODULE,
};

static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata,
				    struct cpcap_usb_ints_state *s)
{
	int val, error;

	error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
	if (error)
		return error;

	s->id_ground = val & BIT(15);
	s->id_float = val & BIT(14);
	s->vbusov = val & BIT(11);

	error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
	if (error)
		return error;

	s->vbusvld = val & BIT(3);
	s->sessvld = val & BIT(2);
	s->sessend = val & BIT(1);
	s->se1 = val & BIT(0);

	error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
	if (error)
		return error;

	s->dm = val & BIT(1);
	s->dp = val & BIT(0);

	return 0;
}

static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);

static void cpcap_usb_detect(struct work_struct *work)
{
	struct cpcap_phy_ddata *ddata;
	struct cpcap_usb_ints_state s;
	bool vbus = false;
	int error;

	ddata = container_of(work, struct cpcap_phy_ddata, detect_work.work);

	error = cpcap_phy_get_ints_state(ddata, &s);
	if (error)
		return;

	if (s.id_ground) {
		dev_dbg(ddata->dev, "id ground, USB host mode\n");
		error = cpcap_usb_set_usb_mode(ddata);
		if (error)
			goto out_err;

		error = musb_mailbox(MUSB_ID_GROUND);
		if (error)
			goto out_err;

		error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
					   CPCAP_BIT_VBUSSTBY_EN,
					   CPCAP_BIT_VBUSSTBY_EN);
		if (error)
			goto out_err;

		return;
	}

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
				   CPCAP_BIT_VBUSSTBY_EN, 0);
	if (error)
		goto out_err;

	vbus = cpcap_usb_vbus_valid(ddata);

	if (vbus) {
		/* Are we connected to a docking station with vbus? */
		if (s.id_ground) {
			dev_dbg(ddata->dev, "connected to a dock\n");

			/* No VBUS needed with docks */
			error = cpcap_usb_set_usb_mode(ddata);
			if (error)
				goto out_err;
			error = musb_mailbox(MUSB_ID_GROUND);
			if (error)
				goto out_err;

			return;
		}

		/* Otherwise assume we're connected to a USB host */
		dev_dbg(ddata->dev, "connected to USB host\n");
		error = cpcap_usb_set_usb_mode(ddata);
		if (error)
			goto out_err;
		error = musb_mailbox(MUSB_VBUS_VALID);
		if (error)
			goto out_err;

		return;
	}

	/* Default to debug UART mode */
	error = cpcap_usb_set_uart_mode(ddata);
	if (error)
		goto out_err;

	error = musb_mailbox(MUSB_VBUS_OFF);
	if (error)
		goto out_err;

	dev_dbg(ddata->dev, "set UART mode\n");

	return;

out_err:
	dev_err(ddata->dev, "error setting cable state: %i\n", error);
}

static irqreturn_t cpcap_phy_irq_thread(int irq, void *data)
{
	struct cpcap_phy_ddata *ddata = data;

	if (!atomic_read(&ddata->active))
		return IRQ_NONE;

	schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));

	return IRQ_HANDLED;
}

static int cpcap_usb_init_irq(struct platform_device *pdev,
			      struct cpcap_phy_ddata *ddata,
			      const char *name)
{
	int irq, error;

	irq = platform_get_irq_byname(pdev, name);
	if (!irq)
		return -ENODEV;

	error = devm_request_threaded_irq(ddata->dev, irq, NULL,
					  cpcap_phy_irq_thread,
					  IRQF_SHARED,
					  name, ddata);
	if (error) {
		dev_err(ddata->dev, "could not get irq %s: %i\n",
			name, error);

		return error;
	}

	return 0;
}

static const char * const cpcap_phy_irqs[] = {
	/* REG_INT_0 */
	"id_ground", "id_float",

	/* REG_INT1 */
	"se0conn", "vbusvld", "sessvld", "sessend", "se1",

	/* REG_INT_3 */
	"dm", "dp",
};

static int cpcap_usb_init_interrupts(struct platform_device *pdev,
				     struct cpcap_phy_ddata *ddata)
{
	int i, error;

	for (i = 0; i < ARRAY_SIZE(cpcap_phy_irqs); i++) {
		error = cpcap_usb_init_irq(pdev, ddata, cpcap_phy_irqs[i]);
		if (error)
			return error;
	}

	return 0;
}

/*
 * Optional pins and modes. At least Motorola mapphone devices
 * are using two GPIOs and dynamic pinctrl to multiplex PHY pins
 * to UART, ULPI or UTMI mode.
 */

static int cpcap_usb_gpio_set_mode(struct cpcap_phy_ddata *ddata,
				   enum cpcap_gpio_mode mode)
{
	if (!ddata->gpio[0] || !ddata->gpio[1])
		return 0;

	gpiod_set_value(ddata->gpio[0], mode & 1);
	gpiod_set_value(ddata->gpio[1], mode >> 1);

	return 0;
}

static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata)
{
	int error;

	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
	if (error)
		goto out_err;

	if (ddata->pins_uart) {
		error = pinctrl_select_state(ddata->pins, ddata->pins_uart);
		if (error)
			goto out_err;
	}

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
				   CPCAP_BIT_VBUSPD,
				   CPCAP_BIT_VBUSPD);
	if (error)
		goto out_err;

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
				   0xffff, CPCAP_BIT_UARTMUX0 |
				   CPCAP_BIT_EMUMODE0);
	if (error)
		goto out_err;

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff,
				   CPCAP_BIT_IDPU_SPI);
	if (error)
		goto out_err;

	return 0;

out_err:
	dev_err(ddata->dev, "%s failed with %i\n", __func__, error);

	return error;
}

static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata)
{
	int error;

	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
	if (error)
		return error;

	if (ddata->pins_utmi) {
		error = pinctrl_select_state(ddata->pins, ddata->pins_utmi);
		if (error) {
			dev_err(ddata->dev, "could not set usb mode: %i\n",
				error);

			return error;
		}
	}

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
				   CPCAP_BIT_VBUSPD, 0);
	if (error)
		goto out_err;

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
				   CPCAP_BIT_USBXCVREN,
				   CPCAP_BIT_USBXCVREN);
	if (error)
		goto out_err;

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
				   CPCAP_BIT_PU_SPI |
				   CPCAP_BIT_DMPD_SPI |
				   CPCAP_BIT_DPPD_SPI |
				   CPCAP_BIT_SUSPEND_SPI |
				   CPCAP_BIT_ULPI_SPI_SEL, 0);
	if (error)
		goto out_err;

	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
				   CPCAP_BIT_USBXCVREN,
				   CPCAP_BIT_USBXCVREN);
	if (error)
		goto out_err;

	return 0;

out_err:
	dev_err(ddata->dev, "%s failed with %i\n", __func__, error);

	return error;
}

static int cpcap_usb_init_optional_pins(struct cpcap_phy_ddata *ddata)
{
	ddata->pins = devm_pinctrl_get(ddata->dev);
	if (IS_ERR(ddata->pins)) {
		dev_info(ddata->dev, "default pins not configured: %ld\n",
			 PTR_ERR(ddata->pins));
		ddata->pins = NULL;

		return 0;
	}

	ddata->pins_ulpi = pinctrl_lookup_state(ddata->pins, "ulpi");
	if (IS_ERR(ddata->pins_ulpi)) {
		dev_info(ddata->dev, "ulpi pins not configured\n");
		ddata->pins_ulpi = NULL;
	}

	ddata->pins_utmi = pinctrl_lookup_state(ddata->pins, "utmi");
	if (IS_ERR(ddata->pins_utmi)) {
		dev_info(ddata->dev, "utmi pins not configured\n");
		ddata->pins_utmi = NULL;
	}

	ddata->pins_uart = pinctrl_lookup_state(ddata->pins, "uart");
	if (IS_ERR(ddata->pins_uart)) {
		dev_info(ddata->dev, "uart pins not configured\n");
		ddata->pins_uart = NULL;
	}

	if (ddata->pins_uart)
		return pinctrl_select_state(ddata->pins, ddata->pins_uart);

	return 0;
}

static void cpcap_usb_init_optional_gpios(struct cpcap_phy_ddata *ddata)
{
	int i;

	for (i = 0; i < 2; i++) {
		ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
						      i, GPIOD_OUT_HIGH);
		if (IS_ERR(ddata->gpio[i])) {
			dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
				 i, PTR_ERR(ddata->gpio[i]));
				 ddata->gpio[i] = NULL;
		}
	}
}

static int cpcap_usb_init_iio(struct cpcap_phy_ddata *ddata)
{
	enum iio_chan_type type;
	int error;

	ddata->vbus = devm_iio_channel_get(ddata->dev, "vbus");
	if (IS_ERR(ddata->vbus)) {
		error = PTR_ERR(ddata->vbus);
		goto out_err;
	}

	if (!ddata->vbus->indio_dev) {
		error = -ENXIO;
		goto out_err;
	}

	error = iio_get_channel_type(ddata->vbus, &type);
	if (error < 0)
		goto out_err;

	if (type != IIO_VOLTAGE) {
		error = -EINVAL;
		goto out_err;
	}

	return 0;

out_err:
	dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
		error);

	return error;
}

#ifdef CONFIG_OF
static const struct of_device_id cpcap_usb_phy_id_table[] = {
	{
		.compatible = "motorola,cpcap-usb-phy",
	},
	{
		.compatible = "motorola,mapphone-cpcap-usb-phy",
	},
	{},
};
MODULE_DEVICE_TABLE(of, cpcap_usb_phy_id_table);
#endif

static int cpcap_usb_phy_probe(struct platform_device *pdev)
{
	struct cpcap_phy_ddata *ddata;
	struct phy *generic_phy;
	struct phy_provider *phy_provider;
	struct usb_otg *otg;
	const struct of_device_id *of_id;
	int error;

	of_id = of_match_device(of_match_ptr(cpcap_usb_phy_id_table),
				&pdev->dev);
	if (!of_id)
		return -EINVAL;

	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
	if (!ddata)
		return -ENOMEM;

	ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
	if (!ddata->reg)
		return -ENODEV;

	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
	if (!otg)
		return -ENOMEM;

	ddata->dev = &pdev->dev;
	ddata->phy.dev = ddata->dev;
	ddata->phy.label = "cpcap_usb_phy";
	ddata->phy.otg = otg;
	ddata->phy.type = USB_PHY_TYPE_USB2;
	otg->set_host = cpcap_usb_phy_set_host;
	otg->set_peripheral = cpcap_usb_phy_set_peripheral;
	otg->usb_phy = &ddata->phy;
	INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
	platform_set_drvdata(pdev, ddata);

	ddata->vusb = devm_regulator_get(&pdev->dev, "vusb");
	if (IS_ERR(ddata->vusb))
		return PTR_ERR(ddata->vusb);

	error = regulator_enable(ddata->vusb);
	if (error)
		return error;

	generic_phy = devm_phy_create(ddata->dev, NULL, &ops);
	if (IS_ERR(generic_phy)) {
		error = PTR_ERR(generic_phy);
		return PTR_ERR(generic_phy);
	}

	phy_set_drvdata(generic_phy, ddata);

	phy_provider = devm_of_phy_provider_register(ddata->dev,
						     of_phy_simple_xlate);
	if (IS_ERR(phy_provider))
		return PTR_ERR(phy_provider);

	error = cpcap_usb_init_optional_pins(ddata);
	if (error)
		return error;

	cpcap_usb_init_optional_gpios(ddata);

	error = cpcap_usb_init_iio(ddata);
	if (error)
		return error;

	error = cpcap_usb_init_interrupts(pdev, ddata);
	if (error)
		return error;

	usb_add_phy_dev(&ddata->phy);
	atomic_set(&ddata->active, 1);
	schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));

	return 0;
}

static int cpcap_usb_phy_remove(struct platform_device *pdev)
{
	struct cpcap_phy_ddata *ddata = platform_get_drvdata(pdev);
	int error;

	atomic_set(&ddata->active, 0);
	error = cpcap_usb_set_uart_mode(ddata);
	if (error)
		dev_err(ddata->dev, "could not set UART mode\n");

	error = musb_mailbox(MUSB_VBUS_OFF);
	if (error)
		dev_err(ddata->dev, "could not set mailbox\n");

	usb_remove_phy(&ddata->phy);
	cancel_delayed_work_sync(&ddata->detect_work);
	clk_unprepare(ddata->refclk);
	regulator_disable(ddata->vusb);

	return 0;
}

static struct platform_driver cpcap_usb_phy_driver = {
	.probe		= cpcap_usb_phy_probe,
	.remove		= cpcap_usb_phy_remove,
	.driver		= {
		.name	= "cpcap-usb-phy",
		.of_match_table = of_match_ptr(cpcap_usb_phy_id_table),
	},
};

module_platform_driver(cpcap_usb_phy_driver);

MODULE_ALIAS("platform:cpcap_usb");
MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
MODULE_DESCRIPTION("CPCAP usb phy driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
6d6ce40f TL	1	/*
	2	* Motorola CPCAP PMIC USB PHY driver
	3	* Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
	4	*
	5	* Some parts based on earlier Motorola Linux kernel tree code in
	6	* board-mapphone-usb.c and cpcap-usb-det.c:
	7	* Copyright (C) 2007 - 2011 Motorola, Inc.
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License as
	11	* published by the Free Software Foundation version 2.
	12	*
	13	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	14	* kind, whether express or implied; without even the implied warranty
	15	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#include <linux/atomic.h>
	20	#include <linux/clk.h>
	21	#include <linux/delay.h>
	22	#include <linux/err.h>
	23	#include <linux/io.h>
	24	#include <linux/module.h>
	25	#include <linux/of.h>
	26	#include <linux/of_platform.h>
	27	#include <linux/iio/consumer.h>
	28	#include <linux/pinctrl/consumer.h>
	29	#include <linux/platform_device.h>
	30	#include <linux/regmap.h>
	31	#include <linux/slab.h>
	32
	33	#include <linux/gpio/consumer.h>
	34	#include <linux/mfd/motorola-cpcap.h>
	35	#include <linux/phy/omap_usb.h>
	36	#include <linux/phy/phy.h>
	37	#include <linux/regulator/consumer.h>
	38	#include <linux/usb/musb.h>
	39
	40	/* CPCAP_REG_USBC1 register bits */
	41	#define CPCAP_BIT_IDPULSE BIT(15)
	42	#define CPCAP_BIT_ID100KPU BIT(14)
	43	#define CPCAP_BIT_IDPUCNTRL BIT(13)
	44	#define CPCAP_BIT_IDPU BIT(12)
	45	#define CPCAP_BIT_IDPD BIT(11)
	46	#define CPCAP_BIT_VBUSCHRGTMR3 BIT(10)
	47	#define CPCAP_BIT_VBUSCHRGTMR2 BIT(9)
	48	#define CPCAP_BIT_VBUSCHRGTMR1 BIT(8)
	49	#define CPCAP_BIT_VBUSCHRGTMR0 BIT(7)
	50	#define CPCAP_BIT_VBUSPU BIT(6)
	51	#define CPCAP_BIT_VBUSPD BIT(5)
	52	#define CPCAP_BIT_DMPD BIT(4)
	53	#define CPCAP_BIT_DPPD BIT(3)
	54	#define CPCAP_BIT_DM1K5PU BIT(2)
	55	#define CPCAP_BIT_DP1K5PU BIT(1)
	56	#define CPCAP_BIT_DP150KPU BIT(0)
	57
	58	/* CPCAP_REG_USBC2 register bits */
	59	#define CPCAP_BIT_ZHSDRV1 BIT(15)
	60	#define CPCAP_BIT_ZHSDRV0 BIT(14)
	61	#define CPCAP_BIT_DPLLCLKREQ BIT(13)
	62	#define CPCAP_BIT_SE0CONN BIT(12)
	63	#define CPCAP_BIT_UARTTXTRI BIT(11)
	64	#define CPCAP_BIT_UARTSWAP BIT(10)
65	#define CPCAP_BIT_UARTMUX1 BIT(9)
66	#define CPCAP_BIT_UARTMUX0 BIT(8)
67	#define CPCAP_BIT_ULPISTPLOW BIT(7)
68	#define CPCAP_BIT_TXENPOL BIT(6)
69	#define CPCAP_BIT_USBXCVREN BIT(5)
70	#define CPCAP_BIT_USBCNTRL BIT(4)
71	#define CPCAP_BIT_USBSUSPEND BIT(3)
72	#define CPCAP_BIT_EMUMODE2 BIT(2)
73	#define CPCAP_BIT_EMUMODE1 BIT(1)
74	#define CPCAP_BIT_EMUMODE0 BIT(0)
75
76	/* CPCAP_REG_USBC3 register bits */
77	#define CPCAP_BIT_SPARE_898_15 BIT(15)
78	#define CPCAP_BIT_IHSTX03 BIT(14)
79	#define CPCAP_BIT_IHSTX02 BIT(13)
80	#define CPCAP_BIT_IHSTX01 BIT(12)
81	#define CPCAP_BIT_IHSTX0 BIT(11)
82	#define CPCAP_BIT_IDPU_SPI BIT(10)
83	#define CPCAP_BIT_UNUSED_898_9 BIT(9)
84	#define CPCAP_BIT_VBUSSTBY_EN BIT(8)
85	#define CPCAP_BIT_VBUSEN_SPI BIT(7)
86	#define CPCAP_BIT_VBUSPU_SPI BIT(6)
87	#define CPCAP_BIT_VBUSPD_SPI BIT(5)
88	#define CPCAP_BIT_DMPD_SPI BIT(4)
89	#define CPCAP_BIT_DPPD_SPI BIT(3)
90	#define CPCAP_BIT_SUSPEND_SPI BIT(2)
91	#define CPCAP_BIT_PU_SPI BIT(1)
92	#define CPCAP_BIT_ULPI_SPI_SEL BIT(0)
93
94	struct cpcap_usb_ints_state {
95	bool id_ground;
96	bool id_float;
97	bool chrg_det;
98	bool rvrs_chrg;
99	bool vbusov;
100
101	bool chrg_se1b;
102	bool se0conn;
103	bool rvrs_mode;
104	bool chrgcurr1;
105	bool vbusvld;
106	bool sessvld;
107	bool sessend;
108	bool se1;
109
110	bool battdetb;
111	bool dm;
112	bool dp;
113	};
114
115	enum cpcap_gpio_mode {
116	CPCAP_DM_DP,
117	CPCAP_MDM_RX_TX,
118	CPCAP_UNKNOWN,
119	CPCAP_OTG_DM_DP,
120	};
121
122	struct cpcap_phy_ddata {
123	struct regmap *reg;
124	struct device *dev;
125	struct clk *refclk;
126	struct usb_phy phy;
127	struct delayed_work detect_work;
128	struct pinctrl *pins;
129	struct pinctrl_state *pins_ulpi;
130	struct pinctrl_state *pins_utmi;
131	struct pinctrl_state *pins_uart;
132	struct gpio_desc *gpio[2];
133	struct iio_channel *vbus;
134	struct iio_channel *id;
135	struct regulator *vusb;
136	atomic_t active;
137	};
138
139	static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
140	{
141	int error, value = 0;
142
143	error = iio_read_channel_processed(ddata->vbus, &value);
144	if (error >= 0)
145	return value > 3900 ? true : false;
146
147	dev_err(ddata->dev, "error reading VBUS: %i\n", error);
148
149	return false;
150	}
151
152	static int cpcap_usb_phy_set_host(struct usb_otg otg, struct usb_bus host)
153	{
154	otg->host = host;
155	if (!host)
156	otg->state = OTG_STATE_UNDEFINED;
157
158	return 0;
159	}
160
161	static int cpcap_usb_phy_set_peripheral(struct usb_otg *otg,
162	struct usb_gadget *gadget)
163	{
164	otg->gadget = gadget;
165	if (!gadget)
166	otg->state = OTG_STATE_UNDEFINED;
167
168	return 0;
169	}
170
171	static const struct phy_ops ops = {
172	.owner = THIS_MODULE,
173	};
174
175	static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata,
176	struct cpcap_usb_ints_state *s)
177	{
178	int val, error;
179
180	error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
181	if (error)
182	return error;
183
184	s->id_ground = val & BIT(15);
185	s->id_float = val & BIT(14);
186	s->vbusov = val & BIT(11);
187
188	error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
189	if (error)
190	return error;
191
192	s->vbusvld = val & BIT(3);
193	s->sessvld = val & BIT(2);
194	s->sessend = val & BIT(1);
195	s->se1 = val & BIT(0);
196
197	error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
198	if (error)
199	return error;
200
201	s->dm = val & BIT(1);
202	s->dp = val & BIT(0);
203
204	return 0;
205	}
206
207	static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
208	static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);
209
210	static void cpcap_usb_detect(struct work_struct *work)
211	{
212	struct cpcap_phy_ddata *ddata;
213	struct cpcap_usb_ints_state s;
214	bool vbus = false;
215	int error;
216
217	ddata = container_of(work, struct cpcap_phy_ddata, detect_work.work);
218
219	error = cpcap_phy_get_ints_state(ddata, &s);
220	if (error)
221	return;
222
223	if (s.id_ground) {
224	dev_dbg(ddata->dev, "id ground, USB host mode\n");
225	error = cpcap_usb_set_usb_mode(ddata);
226	if (error)
227	goto out_err;
228
229	error = musb_mailbox(MUSB_ID_GROUND);
230	if (error)
231	goto out_err;
232
233	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
234	CPCAP_BIT_VBUSSTBY_EN,
235	CPCAP_BIT_VBUSSTBY_EN);
236	if (error)
237	goto out_err;
238
239	return;
240	}
241
242	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
243	CPCAP_BIT_VBUSSTBY_EN, 0);
244	if (error)
245	goto out_err;
246
247	vbus = cpcap_usb_vbus_valid(ddata);
248
249	if (vbus) {
250	/* Are we connected to a docking station with vbus? */
251	if (s.id_ground) {
252	dev_dbg(ddata->dev, "connected to a dock\n");
253
254	/* No VBUS needed with docks */
255	error = cpcap_usb_set_usb_mode(ddata);
256	if (error)
257	goto out_err;
258	error = musb_mailbox(MUSB_ID_GROUND);
259	if (error)
260	goto out_err;
261
262	return;
263	}
264
265	/* Otherwise assume we're connected to a USB host */
266	dev_dbg(ddata->dev, "connected to USB host\n");
267	error = cpcap_usb_set_usb_mode(ddata);
268	if (error)
269	goto out_err;
270	error = musb_mailbox(MUSB_VBUS_VALID);
271	if (error)
272	goto out_err;
273
274	return;
275	}
276
277	/* Default to debug UART mode */
278	error = cpcap_usb_set_uart_mode(ddata);
279	if (error)
280	goto out_err;
281
282	error = musb_mailbox(MUSB_VBUS_OFF);
283	if (error)
284	goto out_err;
285
286	dev_dbg(ddata->dev, "set UART mode\n");
287
288	return;
289
290	out_err:
291	dev_err(ddata->dev, "error setting cable state: %i\n", error);
292	}
293
294	static irqreturn_t cpcap_phy_irq_thread(int irq, void *data)
295	{
296	struct cpcap_phy_ddata *ddata = data;
297
298	if (!atomic_read(&ddata->active))
299	return IRQ_NONE;
300
301	schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
302
303	return IRQ_HANDLED;
304	}
305
306	static int cpcap_usb_init_irq(struct platform_device *pdev,
307	struct cpcap_phy_ddata *ddata,
308	const char *name)
309	{
310	int irq, error;
311
312	irq = platform_get_irq_byname(pdev, name);
313	if (!irq)
314	return -ENODEV;
315
316	error = devm_request_threaded_irq(ddata->dev, irq, NULL,
317	cpcap_phy_irq_thread,
318	IRQF_SHARED,
319	name, ddata);
320	if (error) {
321	dev_err(ddata->dev, "could not get irq %s: %i\n",
322	name, error);
323
324	return error;
325	}
326
327	return 0;
328	}
329
330	static const char * const cpcap_phy_irqs[] = {
331	/* REG_INT_0 */
332	"id_ground", "id_float",
333
334	/* REG_INT1 */
335	"se0conn", "vbusvld", "sessvld", "sessend", "se1",
336
337	/* REG_INT_3 */
338	"dm", "dp",
339	};
340
341	static int cpcap_usb_init_interrupts(struct platform_device *pdev,
342	struct cpcap_phy_ddata *ddata)
343	{
344	int i, error;
345
346	for (i = 0; i < ARRAY_SIZE(cpcap_phy_irqs); i++) {
347	error = cpcap_usb_init_irq(pdev, ddata, cpcap_phy_irqs[i]);
348	if (error)
349	return error;
350	}
351
352	return 0;
353	}
354
355	/*
356	* Optional pins and modes. At least Motorola mapphone devices
357	* are using two GPIOs and dynamic pinctrl to multiplex PHY pins
358	* to UART, ULPI or UTMI mode.
359	*/
360
361	static int cpcap_usb_gpio_set_mode(struct cpcap_phy_ddata *ddata,
362	enum cpcap_gpio_mode mode)
363	{
364	if (!ddata->gpio[0] \|\| !ddata->gpio[1])
365	return 0;
366
367	gpiod_set_value(ddata->gpio[0], mode & 1);
368	gpiod_set_value(ddata->gpio[1], mode >> 1);
369
370	return 0;
371	}
372
373	static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata)
374	{
375	int error;
376
377	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
378	if (error)
379	goto out_err;
380
381	if (ddata->pins_uart) {
382	error = pinctrl_select_state(ddata->pins, ddata->pins_uart);
383	if (error)
384	goto out_err;
385	}
386
387	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
388	CPCAP_BIT_VBUSPD,
389	CPCAP_BIT_VBUSPD);
390	if (error)
391	goto out_err;
392
393	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
394	0xffff, CPCAP_BIT_UARTMUX0 \|
395	CPCAP_BIT_EMUMODE0);
396	if (error)
397	goto out_err;
398
399	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff,
400	CPCAP_BIT_IDPU_SPI);
401	if (error)
402	goto out_err;
403
404	return 0;
405
406	out_err:
407	dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
408
409	return error;
410	}
411
412	static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata)
413	{
414	int error;
415
416	error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
417	if (error)
418	return error;
419
420	if (ddata->pins_utmi) {
421	error = pinctrl_select_state(ddata->pins, ddata->pins_utmi);
422	if (error) {
423	dev_err(ddata->dev, "could not set usb mode: %i\n",
424	error);
425
426	return error;
427	}
428	}
429
430	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
431	CPCAP_BIT_VBUSPD, 0);
432	if (error)
433	goto out_err;
434
435	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
436	CPCAP_BIT_USBXCVREN,
437	CPCAP_BIT_USBXCVREN);
438	if (error)
439	goto out_err;
440
441	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
442	CPCAP_BIT_PU_SPI \|
443	CPCAP_BIT_DMPD_SPI \|
444	CPCAP_BIT_DPPD_SPI \|
445	CPCAP_BIT_SUSPEND_SPI \|
446	CPCAP_BIT_ULPI_SPI_SEL, 0);
447	if (error)
448	goto out_err;
449
450	error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
451	CPCAP_BIT_USBXCVREN,
452	CPCAP_BIT_USBXCVREN);
453	if (error)
454	goto out_err;
455
456	return 0;
457
458	out_err:
459	dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
460
461	return error;
462	}
463
464	static int cpcap_usb_init_optional_pins(struct cpcap_phy_ddata *ddata)
465	{
466	ddata->pins = devm_pinctrl_get(ddata->dev);
467	if (IS_ERR(ddata->pins)) {
468	dev_info(ddata->dev, "default pins not configured: %ld\n",
469	PTR_ERR(ddata->pins));
470	ddata->pins = NULL;
259a2400 TL	471
259a2400 TL	472	return 0;
6d6ce40f TL	473	}
	474
	475	ddata->pins_ulpi = pinctrl_lookup_state(ddata->pins, "ulpi");
	476	if (IS_ERR(ddata->pins_ulpi)) {
	477	dev_info(ddata->dev, "ulpi pins not configured\n");
	478	ddata->pins_ulpi = NULL;
	479	}
	480
	481	ddata->pins_utmi = pinctrl_lookup_state(ddata->pins, "utmi");
	482	if (IS_ERR(ddata->pins_utmi)) {
	483	dev_info(ddata->dev, "utmi pins not configured\n");
	484	ddata->pins_utmi = NULL;
	485	}
	486
	487	ddata->pins_uart = pinctrl_lookup_state(ddata->pins, "uart");
	488	if (IS_ERR(ddata->pins_uart)) {
	489	dev_info(ddata->dev, "uart pins not configured\n");
	490	ddata->pins_uart = NULL;
	491	}
	492
	493	if (ddata->pins_uart)
	494	return pinctrl_select_state(ddata->pins, ddata->pins_uart);
	495
	496	return 0;
	497	}
	498
	499	static void cpcap_usb_init_optional_gpios(struct cpcap_phy_ddata *ddata)
	500	{
	501	int i;
	502
	503	for (i = 0; i < 2; i++) {
	504	ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
	505	i, GPIOD_OUT_HIGH);
	506	if (IS_ERR(ddata->gpio[i])) {
	507	dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
	508	i, PTR_ERR(ddata->gpio[i]));
	509	ddata->gpio[i] = NULL;
	510	}
	511	}
	512	}
	513
	514	static int cpcap_usb_init_iio(struct cpcap_phy_ddata *ddata)
	515	{
	516	enum iio_chan_type type;
	517	int error;
	518
	519	ddata->vbus = devm_iio_channel_get(ddata->dev, "vbus");
	520	if (IS_ERR(ddata->vbus)) {
	521	error = PTR_ERR(ddata->vbus);
	522	goto out_err;
	523	}
	524
	525	if (!ddata->vbus->indio_dev) {
	526	error = -ENXIO;
	527	goto out_err;
	528	}
	529
	530	error = iio_get_channel_type(ddata->vbus, &type);
	531	if (error < 0)
	532	goto out_err;
	533
	534	if (type != IIO_VOLTAGE) {
	535	error = -EINVAL;
	536	goto out_err;
537	}
538
539	return 0;
540
541	out_err:
542	dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
543	error);
544
545	return error;
546	}
547
548	#ifdef CONFIG_OF
549	static const struct of_device_id cpcap_usb_phy_id_table[] = {
550	{
551	.compatible = "motorola,cpcap-usb-phy",
552	},
553	{
554	.compatible = "motorola,mapphone-cpcap-usb-phy",
555	},
556	{},
557	};
558	MODULE_DEVICE_TABLE(of, cpcap_usb_phy_id_table);
559	#endif
560
561	static int cpcap_usb_phy_probe(struct platform_device *pdev)
562	{
563	struct cpcap_phy_ddata *ddata;
564	struct phy *generic_phy;
565	struct phy_provider *phy_provider;
566	struct usb_otg *otg;
567	const struct of_device_id *of_id;
568	int error;
569
570	of_id = of_match_device(of_match_ptr(cpcap_usb_phy_id_table),
571	&pdev->dev);
572	if (!of_id)
573	return -EINVAL;
574
575	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
576	if (!ddata)
577	return -ENOMEM;
578
579	ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
580	if (!ddata->reg)
581	return -ENODEV;
582
583	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
584	if (!otg)
585	return -ENOMEM;
586
587	ddata->dev = &pdev->dev;
588	ddata->phy.dev = ddata->dev;
589	ddata->phy.label = "cpcap_usb_phy";
590	ddata->phy.otg = otg;
591	ddata->phy.type = USB_PHY_TYPE_USB2;
592	otg->set_host = cpcap_usb_phy_set_host;
593	otg->set_peripheral = cpcap_usb_phy_set_peripheral;
594	otg->usb_phy = &ddata->phy;
595	INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
596	platform_set_drvdata(pdev, ddata);
597
598	ddata->vusb = devm_regulator_get(&pdev->dev, "vusb");
599	if (IS_ERR(ddata->vusb))
600	return PTR_ERR(ddata->vusb);
601
602	error = regulator_enable(ddata->vusb);
603	if (error)
604	return error;
605
606	generic_phy = devm_phy_create(ddata->dev, NULL, &ops);
607	if (IS_ERR(generic_phy)) {
608	error = PTR_ERR(generic_phy);
609	return PTR_ERR(generic_phy);
610	}
611
612	phy_set_drvdata(generic_phy, ddata);
613
614	phy_provider = devm_of_phy_provider_register(ddata->dev,
615	of_phy_simple_xlate);
616	if (IS_ERR(phy_provider))
617	return PTR_ERR(phy_provider);
618
619	error = cpcap_usb_init_optional_pins(ddata);
620	if (error)
621	return error;
622
623	cpcap_usb_init_optional_gpios(ddata);
624
625	error = cpcap_usb_init_iio(ddata);
626	if (error)
627	return error;
628
629	error = cpcap_usb_init_interrupts(pdev, ddata);
630	if (error)
631	return error;
632
633	usb_add_phy_dev(&ddata->phy);
634	atomic_set(&ddata->active, 1);
635	schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
636
637	return 0;
638	}
639
640	static int cpcap_usb_phy_remove(struct platform_device *pdev)
641	{
642	struct cpcap_phy_ddata *ddata = platform_get_drvdata(pdev);
643	int error;
644
645	atomic_set(&ddata->active, 0);
646	error = cpcap_usb_set_uart_mode(ddata);
647	if (error)
648	dev_err(ddata->dev, "could not set UART mode\n");
649
650	error = musb_mailbox(MUSB_VBUS_OFF);
651	if (error)
652	dev_err(ddata->dev, "could not set mailbox\n");
653
654	usb_remove_phy(&ddata->phy);
655	cancel_delayed_work_sync(&ddata->detect_work);
656	clk_unprepare(ddata->refclk);
657	regulator_disable(ddata->vusb);
658
659	return 0;
660	}
661
662	static struct platform_driver cpcap_usb_phy_driver = {
663	.probe = cpcap_usb_phy_probe,
664	.remove = cpcap_usb_phy_remove,
665	.driver = {
666	.name = "cpcap-usb-phy",
667	.of_match_table = of_match_ptr(cpcap_usb_phy_id_table),
668	},
669	};
670
671	module_platform_driver(cpcap_usb_phy_driver);
672
673	MODULE_ALIAS("platform:cpcap_usb");
674	MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
675	MODULE_DESCRIPTION("CPCAP usb phy driver");
676	MODULE_LICENSE("GPL v2");