[mirror_ubuntu-jammy-kernel.git] / drivers / extcon / extcon-usb-gpio.c

// SPDX-License-Identifier: GPL-2.0-only
/**
 * drivers/extcon/extcon-usb-gpio.c - USB GPIO extcon driver
 *
 * Copyright (C) 2015 Texas Instruments Incorporated - https://www.ti.com
 * Author: Roger Quadros <rogerq@ti.com>
 */

#include <linux/extcon-provider.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/pinctrl/consumer.h>

#define USB_GPIO_DEBOUNCE_MS	20	/* ms */

struct usb_extcon_info {
	struct device *dev;
	struct extcon_dev *edev;

	struct gpio_desc *id_gpiod;
	struct gpio_desc *vbus_gpiod;
	int id_irq;
	int vbus_irq;

	unsigned long debounce_jiffies;
	struct delayed_work wq_detcable;
};

static const unsigned int usb_extcon_cable[] = {
	EXTCON_USB,
	EXTCON_USB_HOST,
	EXTCON_NONE,
};

/*
 * "USB" = VBUS and "USB-HOST" = !ID, so we have:
 * Both "USB" and "USB-HOST" can't be set as active at the
 * same time so if "USB-HOST" is active (i.e. ID is 0)  we keep "USB" inactive
 * even if VBUS is on.
 *
 *  State              |    ID   |   VBUS
 * ----------------------------------------
 *  [1] USB            |    H    |    H
 *  [2] none           |    H    |    L
 *  [3] USB-HOST       |    L    |    H
 *  [4] USB-HOST       |    L    |    L
 *
 * In case we have only one of these signals:
 * - VBUS only - we want to distinguish between [1] and [2], so ID is always 1.
 * - ID only - we want to distinguish between [1] and [4], so VBUS = ID.
*/
static void usb_extcon_detect_cable(struct work_struct *work)
{
	int id, vbus;
	struct usb_extcon_info *info = container_of(to_delayed_work(work),
						    struct usb_extcon_info,
						    wq_detcable);

	/* check ID and VBUS and update cable state */
	id = info->id_gpiod ?
		gpiod_get_value_cansleep(info->id_gpiod) : 1;
	vbus = info->vbus_gpiod ?
		gpiod_get_value_cansleep(info->vbus_gpiod) : id;

	/* at first we clean states which are no longer active */
	if (id)
		extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
	if (!vbus)
		extcon_set_state_sync(info->edev, EXTCON_USB, false);

	if (!id) {
		extcon_set_state_sync(info->edev, EXTCON_USB_HOST, true);
	} else {
		if (vbus)
			extcon_set_state_sync(info->edev, EXTCON_USB, true);
	}
}

static irqreturn_t usb_irq_handler(int irq, void *dev_id)
{
	struct usb_extcon_info *info = dev_id;

	queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
			   info->debounce_jiffies);

	return IRQ_HANDLED;
}

static int usb_extcon_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
	struct usb_extcon_info *info;
	int ret;

	if (!np)
		return -EINVAL;

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

	info->dev = dev;
	info->id_gpiod = devm_gpiod_get_optional(&pdev->dev, "id", GPIOD_IN);
	info->vbus_gpiod = devm_gpiod_get_optional(&pdev->dev, "vbus",
						   GPIOD_IN);

	if (!info->id_gpiod && !info->vbus_gpiod) {
		dev_err(dev, "failed to get gpios\n");
		return -ENODEV;
	}

	if (IS_ERR(info->id_gpiod))
		return PTR_ERR(info->id_gpiod);

	if (IS_ERR(info->vbus_gpiod))
		return PTR_ERR(info->vbus_gpiod);

	info->edev = devm_extcon_dev_allocate(dev, usb_extcon_cable);
	if (IS_ERR(info->edev)) {
		dev_err(dev, "failed to allocate extcon device\n");
		return -ENOMEM;
	}

	ret = devm_extcon_dev_register(dev, info->edev);
	if (ret < 0) {
		dev_err(dev, "failed to register extcon device\n");
		return ret;
	}

	if (info->id_gpiod)
		ret = gpiod_set_debounce(info->id_gpiod,
					 USB_GPIO_DEBOUNCE_MS * 1000);
	if (!ret && info->vbus_gpiod)
		ret = gpiod_set_debounce(info->vbus_gpiod,
					 USB_GPIO_DEBOUNCE_MS * 1000);

	if (ret < 0)
		info->debounce_jiffies = msecs_to_jiffies(USB_GPIO_DEBOUNCE_MS);

	INIT_DELAYED_WORK(&info->wq_detcable, usb_extcon_detect_cable);

	if (info->id_gpiod) {
		info->id_irq = gpiod_to_irq(info->id_gpiod);
		if (info->id_irq < 0) {
			dev_err(dev, "failed to get ID IRQ\n");
			return info->id_irq;
		}

		ret = devm_request_threaded_irq(dev, info->id_irq, NULL,
						usb_irq_handler,
						IRQF_TRIGGER_RISING |
						IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
						pdev->name, info);
		if (ret < 0) {
			dev_err(dev, "failed to request handler for ID IRQ\n");
			return ret;
		}
	}

	if (info->vbus_gpiod) {
		info->vbus_irq = gpiod_to_irq(info->vbus_gpiod);
		if (info->vbus_irq < 0) {
			dev_err(dev, "failed to get VBUS IRQ\n");
			return info->vbus_irq;
		}

		ret = devm_request_threaded_irq(dev, info->vbus_irq, NULL,
						usb_irq_handler,
						IRQF_TRIGGER_RISING |
						IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
						pdev->name, info);
		if (ret < 0) {
			dev_err(dev, "failed to request handler for VBUS IRQ\n");
			return ret;
		}
	}

	platform_set_drvdata(pdev, info);
	device_set_wakeup_capable(&pdev->dev, true);

	/* Perform initial detection */
	usb_extcon_detect_cable(&info->wq_detcable.work);

	return 0;
}

static int usb_extcon_remove(struct platform_device *pdev)
{
	struct usb_extcon_info *info = platform_get_drvdata(pdev);

	cancel_delayed_work_sync(&info->wq_detcable);
	device_init_wakeup(&pdev->dev, false);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int usb_extcon_suspend(struct device *dev)
{
	struct usb_extcon_info *info = dev_get_drvdata(dev);
	int ret = 0;

	if (device_may_wakeup(dev)) {
		if (info->id_gpiod) {
			ret = enable_irq_wake(info->id_irq);
			if (ret)
				return ret;
		}
		if (info->vbus_gpiod) {
			ret = enable_irq_wake(info->vbus_irq);
			if (ret) {
				if (info->id_gpiod)
					disable_irq_wake(info->id_irq);

				return ret;
			}
		}
	}

	/*
	 * We don't want to process any IRQs after this point
	 * as GPIOs used behind I2C subsystem might not be
	 * accessible until resume completes. So disable IRQ.
	 */
	if (info->id_gpiod)
		disable_irq(info->id_irq);
	if (info->vbus_gpiod)
		disable_irq(info->vbus_irq);

	if (!device_may_wakeup(dev))
		pinctrl_pm_select_sleep_state(dev);

	return ret;
}

static int usb_extcon_resume(struct device *dev)
{
	struct usb_extcon_info *info = dev_get_drvdata(dev);
	int ret = 0;

	if (!device_may_wakeup(dev))
		pinctrl_pm_select_default_state(dev);

	if (device_may_wakeup(dev)) {
		if (info->id_gpiod) {
			ret = disable_irq_wake(info->id_irq);
			if (ret)
				return ret;
		}
		if (info->vbus_gpiod) {
			ret = disable_irq_wake(info->vbus_irq);
			if (ret) {
				if (info->id_gpiod)
					enable_irq_wake(info->id_irq);

				return ret;
			}
		}
	}

	if (info->id_gpiod)
		enable_irq(info->id_irq);
	if (info->vbus_gpiod)
		enable_irq(info->vbus_irq);

	queue_delayed_work(system_power_efficient_wq,
			   &info->wq_detcable, 0);

	return ret;
}
#endif

static SIMPLE_DEV_PM_OPS(usb_extcon_pm_ops,
			 usb_extcon_suspend, usb_extcon_resume);

static const struct of_device_id usb_extcon_dt_match[] = {
	{ .compatible = "linux,extcon-usb-gpio", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, usb_extcon_dt_match);

static const struct platform_device_id usb_extcon_platform_ids[] = {
	{ .name = "extcon-usb-gpio", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(platform, usb_extcon_platform_ids);

static struct platform_driver usb_extcon_driver = {
	.probe		= usb_extcon_probe,
	.remove		= usb_extcon_remove,
	.driver		= {
		.name	= "extcon-usb-gpio",
		.pm	= &usb_extcon_pm_ops,
		.of_match_table = usb_extcon_dt_match,
	},
	.id_table = usb_extcon_platform_ids,
};

module_platform_driver(usb_extcon_driver);

MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
MODULE_DESCRIPTION("USB GPIO extcon driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1802d0be	1	// SPDX-License-Identifier: GPL-2.0-only
e52817fa RQ	2	/**
	3	* drivers/extcon/extcon-usb-gpio.c - USB GPIO extcon driver
	4	*
f6dfb3c9	5	* Copyright (C) 2015 Texas Instruments Incorporated - https://www.ti.com
e52817fa	6	* Author: Roger Quadros <rogerq@ti.com>
e52817fa RQ	7	*/
e52817fa RQ	8
176aa360	9	#include <linux/extcon-provider.h>
92b7cb5d	10	#include <linux/gpio.h>
638f958b	11	#include <linux/gpio/consumer.h>
e52817fa RQ	12	#include <linux/init.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/irq.h>
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/of_gpio.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/slab.h>
	20	#include <linux/workqueue.h>
bcb7440e	21	#include <linux/pinctrl/consumer.h>
e52817fa RQ	22
	23	#define USB_GPIO_DEBOUNCE_MS 20 /* ms */
	24
	25	struct usb_extcon_info {
	26	struct device *dev;
	27	struct extcon_dev *edev;
	28
	29	struct gpio_desc *id_gpiod;
541332a1	30	struct gpio_desc *vbus_gpiod;
e52817fa	31	int id_irq;
541332a1	32	int vbus_irq;
e52817fa RQ	33
	34	unsigned long debounce_jiffies;
	35	struct delayed_work wq_detcable;
	36	};
	37
73b6ecdb	38	static const unsigned int usb_extcon_cable[] = {
2a9de9c0 CC	39	EXTCON_USB,
	40	EXTCON_USB_HOST,
	41	EXTCON_NONE,
e52817fa RQ	42	};
e52817fa RQ	43
541332a1 RQ	44	/*
	45	* "USB" = VBUS and "USB-HOST" = !ID, so we have:
	46	* Both "USB" and "USB-HOST" can't be set as active at the
	47	* same time so if "USB-HOST" is active (i.e. ID is 0) we keep "USB" inactive
	48	* even if VBUS is on.
	49	*
	50	* State \| ID \| VBUS
	51	* ----------------------------------------
	52	* [1] USB \| H \| H
	53	* [2] none \| H \| L
	54	* [3] USB-HOST \| L \| H
	55	* [4] USB-HOST \| L \| L
	56	*
	57	* In case we have only one of these signals:
	58	* - VBUS only - we want to distinguish between [1] and [2], so ID is always 1.
	59	* - ID only - we want to distinguish between [1] and [4], so VBUS = ID.
	60	*/
e52817fa RQ	61	static void usb_extcon_detect_cable(struct work_struct *work)
e52817fa RQ	62	{
541332a1	63	int id, vbus;
e52817fa RQ	64	struct usb_extcon_info *info = container_of(to_delayed_work(work),
	65	struct usb_extcon_info,
	66	wq_detcable);
	67
541332a1 RQ	68	/* check ID and VBUS and update cable state */
	69	id = info->id_gpiod ?
	70	gpiod_get_value_cansleep(info->id_gpiod) : 1;
	71	vbus = info->vbus_gpiod ?
	72	gpiod_get_value_cansleep(info->vbus_gpiod) : id;
	73
	74	/* at first we clean states which are no longer active */
	75	if (id)
8670b459	76	extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
541332a1	77	if (!vbus)
8670b459	78	extcon_set_state_sync(info->edev, EXTCON_USB, false);
541332a1 RQ	79
541332a1 RQ	80	if (!id) {
8670b459	81	extcon_set_state_sync(info->edev, EXTCON_USB_HOST, true);
541332a1 RQ	82	} else {
	83	if (vbus)
	84	extcon_set_state_sync(info->edev, EXTCON_USB, true);
e52817fa RQ	85	}
	86	}
	87
	88	static irqreturn_t usb_irq_handler(int irq, void *dev_id)
	89	{
	90	struct usb_extcon_info *info = dev_id;
	91
	92	queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
	93	info->debounce_jiffies);
	94
	95	return IRQ_HANDLED;
	96	}
	97
	98	static int usb_extcon_probe(struct platform_device *pdev)
	99	{
	100	struct device *dev = &pdev->dev;
	101	struct device_node *np = dev->of_node;
	102	struct usb_extcon_info *info;
	103	int ret;
	104
366380cd	105	if (!np)
e52817fa RQ	106	return -EINVAL;
	107
	108	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	109	if (!info)
	110	return -ENOMEM;
	111
	112	info->dev = dev;
541332a1 RQ	113	info->id_gpiod = devm_gpiod_get_optional(&pdev->dev, "id", GPIOD_IN);
	114	info->vbus_gpiod = devm_gpiod_get_optional(&pdev->dev, "vbus",
	115	GPIOD_IN);
	116
	117	if (!info->id_gpiod && !info->vbus_gpiod) {
	118	dev_err(dev, "failed to get gpios\n");
	119	return -ENODEV;
e52817fa RQ	120	}
e52817fa RQ	121
541332a1 RQ	122	if (IS_ERR(info->id_gpiod))
	123	return PTR_ERR(info->id_gpiod);
	124
	125	if (IS_ERR(info->vbus_gpiod))
	126	return PTR_ERR(info->vbus_gpiod);
	127
bc1aabad RB	128	info->edev = devm_extcon_dev_allocate(dev, usb_extcon_cable);
	129	if (IS_ERR(info->edev)) {
	130	dev_err(dev, "failed to allocate extcon device\n");
	131	return -ENOMEM;
	132	}
	133
	134	ret = devm_extcon_dev_register(dev, info->edev);
	135	if (ret < 0) {
	136	dev_err(dev, "failed to register extcon device\n");
	137	return ret;
	138	}
	139
541332a1 RQ	140	if (info->id_gpiod)
	141	ret = gpiod_set_debounce(info->id_gpiod,
	142	USB_GPIO_DEBOUNCE_MS * 1000);
	143	if (!ret && info->vbus_gpiod)
	144	ret = gpiod_set_debounce(info->vbus_gpiod,
	145	USB_GPIO_DEBOUNCE_MS * 1000);
	146
e52817fa RQ	147	if (ret < 0)
	148	info->debounce_jiffies = msecs_to_jiffies(USB_GPIO_DEBOUNCE_MS);
	149
	150	INIT_DELAYED_WORK(&info->wq_detcable, usb_extcon_detect_cable);
	151
541332a1 RQ	152	if (info->id_gpiod) {
	153	info->id_irq = gpiod_to_irq(info->id_gpiod);
	154	if (info->id_irq < 0) {
	155	dev_err(dev, "failed to get ID IRQ\n");
	156	return info->id_irq;
	157	}
	158
	159	ret = devm_request_threaded_irq(dev, info->id_irq, NULL,
	160	usb_irq_handler,
	161	IRQF_TRIGGER_RISING \|
	162	IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
	163	pdev->name, info);
	164	if (ret < 0) {
	165	dev_err(dev, "failed to request handler for ID IRQ\n");
	166	return ret;
	167	}
e52817fa RQ	168	}
e52817fa RQ	169
541332a1 RQ	170	if (info->vbus_gpiod) {
	171	info->vbus_irq = gpiod_to_irq(info->vbus_gpiod);
	172	if (info->vbus_irq < 0) {
	173	dev_err(dev, "failed to get VBUS IRQ\n");
	174	return info->vbus_irq;
	175	}
	176
	177	ret = devm_request_threaded_irq(dev, info->vbus_irq, NULL,
	178	usb_irq_handler,
	179	IRQF_TRIGGER_RISING \|
	180	IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
	181	pdev->name, info);
	182	if (ret < 0) {
	183	dev_err(dev, "failed to request handler for VBUS IRQ\n");
	184	return ret;
	185	}
e52817fa RQ	186	}
e52817fa RQ	187
e52817fa	188	platform_set_drvdata(pdev, info);
98fd0792	189	device_set_wakeup_capable(&pdev->dev, true);
e52817fa RQ	190
	191	/* Perform initial detection */
	192	usb_extcon_detect_cable(&info->wq_detcable.work);
	193
	194	return 0;
	195	}
	196
	197	static int usb_extcon_remove(struct platform_device *pdev)
	198	{
	199	struct usb_extcon_info *info = platform_get_drvdata(pdev);
	200
	201	cancel_delayed_work_sync(&info->wq_detcable);
12bd0f32 GS	202	device_init_wakeup(&pdev->dev, false);
12bd0f32 GS	203
e52817fa RQ	204	return 0;
	205	}
	206
	207	#ifdef CONFIG_PM_SLEEP
	208	static int usb_extcon_suspend(struct device *dev)
	209	{
	210	struct usb_extcon_info *info = dev_get_drvdata(dev);
	211	int ret = 0;
	212
541332a1 RQ	213	if (device_may_wakeup(dev)) {
	214	if (info->id_gpiod) {
	215	ret = enable_irq_wake(info->id_irq);
	216	if (ret)
	217	return ret;
	218	}
	219	if (info->vbus_gpiod) {
	220	ret = enable_irq_wake(info->vbus_irq);
	221	if (ret) {
	222	if (info->id_gpiod)
	223	disable_irq_wake(info->id_irq);
	224
	225	return ret;
	226	}
	227	}
	228	}
	229
e52817fa RQ	230	/*
	231	* We don't want to process any IRQs after this point
	232	* as GPIOs used behind I2C subsystem might not be
	233	* accessible until resume completes. So disable IRQ.
	234	*/
541332a1 RQ	235	if (info->id_gpiod)
	236	disable_irq(info->id_irq);
	237	if (info->vbus_gpiod)
	238	disable_irq(info->vbus_irq);
e52817fa	239
bcb7440e PC	240	if (!device_may_wakeup(dev))
	241	pinctrl_pm_select_sleep_state(dev);
	242
e52817fa RQ	243	return ret;
	244	}
	245
	246	static int usb_extcon_resume(struct device *dev)
	247	{
	248	struct usb_extcon_info *info = dev_get_drvdata(dev);
	249	int ret = 0;
	250
bcb7440e PC	251	if (!device_may_wakeup(dev))
	252	pinctrl_pm_select_default_state(dev);
	253
541332a1 RQ	254	if (device_may_wakeup(dev)) {
	255	if (info->id_gpiod) {
	256	ret = disable_irq_wake(info->id_irq);
	257	if (ret)
	258	return ret;
	259	}
	260	if (info->vbus_gpiod) {
	261	ret = disable_irq_wake(info->vbus_irq);
	262	if (ret) {
	263	if (info->id_gpiod)
	264	enable_irq_wake(info->id_irq);
	265
	266	return ret;
	267	}
	268	}
	269	}
	270
	271	if (info->id_gpiod)
	272	enable_irq(info->id_irq);
	273	if (info->vbus_gpiod)
	274	enable_irq(info->vbus_irq);
	275
8680b4d1 RQ	276	queue_delayed_work(system_power_efficient_wq,
8680b4d1 RQ	277	&info->wq_detcable, 0);
e52817fa RQ	278
	279	return ret;
	280	}
	281	#endif
	282
	283	static SIMPLE_DEV_PM_OPS(usb_extcon_pm_ops,
	284	usb_extcon_suspend, usb_extcon_resume);
	285
34825e51	286	static const struct of_device_id usb_extcon_dt_match[] = {
e52817fa RQ	287	{ .compatible = "linux,extcon-usb-gpio", },
	288	{ /* sentinel */ }
	289	};
	290	MODULE_DEVICE_TABLE(of, usb_extcon_dt_match);
	291
058b6659 LB	292	static const struct platform_device_id usb_extcon_platform_ids[] = {
	293	{ .name = "extcon-usb-gpio", },
	294	{ /* sentinel */ }
	295	};
	296	MODULE_DEVICE_TABLE(platform, usb_extcon_platform_ids);
	297
e52817fa RQ	298	static struct platform_driver usb_extcon_driver = {
	299	.probe = usb_extcon_probe,
	300	.remove = usb_extcon_remove,
	301	.driver = {
	302	.name = "extcon-usb-gpio",
	303	.pm = &usb_extcon_pm_ops,
	304	.of_match_table = usb_extcon_dt_match,
	305	},
058b6659	306	.id_table = usb_extcon_platform_ids,
e52817fa RQ	307	};
	308
	309	module_platform_driver(usb_extcon_driver);
	310
	311	MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
	312	MODULE_DESCRIPTION("USB GPIO extcon driver");
	313	MODULE_LICENSE("GPL v2");