drivers/platform/msm/gpio-usbdetect.c - kernel/msm-4.9 - Gitiles

 /* Copyright (c) 2013-2015, 2017-2018, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/of_platform.h>
 #include <linux/interrupt.h>
 #include <linux/of_gpio.h>
 #include <linux/gpio.h>
 #include <linux/extcon.h>
 #include <linux/regulator/consumer.h>

 struct gpio_usbdetect {
 	struct platform_device	*pdev;
 	struct regulator	*vin;
 	int			vbus_det_irq;
 	int			id_det_irq;
 	int			gpio;
 	struct extcon_dev	*extcon_dev;
 	int			vbus_state;
 	bool			id_state;
 };

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

 static irqreturn_t gpio_usbdetect_vbus_irq(int irq, void *data)
 {
 	struct gpio_usbdetect *usb = data;
 	union extcon_property_value val;

 	usb->vbus_state = gpio_get_value(usb->gpio);
 	if (usb->vbus_state) {
 		dev_dbg(&usb->pdev->dev, "setting vbus notification\n");
 		val.intval = true;
 		extcon_set_property(usb->extcon_dev, EXTCON_USB,
 					EXTCON_PROP_USB_SS, val);
 		extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB, 1);
 	} else {
 		dev_dbg(&usb->pdev->dev, "setting vbus removed notification\n");
 		extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB, 0);
 	}

 	return IRQ_HANDLED;
 }

 static irqreturn_t gpio_usbdetect_id_irq(int irq, void *data)
 {
 	struct gpio_usbdetect *usb = data;
 	int ret;

 	ret = irq_get_irqchip_state(irq, IRQCHIP_STATE_LINE_LEVEL,
 			&usb->id_state);
 	if (ret < 0) {
 		dev_err(&usb->pdev->dev, "unable to read ID IRQ LINE\n");
 		return IRQ_HANDLED;
 	}

 	return IRQ_WAKE_THREAD;
 }

 static irqreturn_t gpio_usbdetect_id_irq_thread(int irq, void *data)
 {
 	struct gpio_usbdetect *usb = data;
 	bool curr_id_state;
 	static int prev_id_state = -EINVAL;
 	union extcon_property_value val;

 	curr_id_state = usb->id_state;
 	if (curr_id_state == prev_id_state) {
 		dev_dbg(&usb->pdev->dev, "no change in ID state\n");
 		return IRQ_HANDLED;
 	}

 	if (curr_id_state) {
 		dev_dbg(&usb->pdev->dev, "stopping usb host\n");
 		extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB_HOST, 0);
 		enable_irq(usb->vbus_det_irq);
 	} else {
 		dev_dbg(&usb->pdev->dev, "starting usb HOST\n");
 		disable_irq(usb->vbus_det_irq);
 		val.intval = true;
 		extcon_set_property(usb->extcon_dev, EXTCON_USB_HOST,
 					EXTCON_PROP_USB_SS, val);
 		extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB_HOST, 1);
 	}

 	prev_id_state = curr_id_state;
 	return IRQ_HANDLED;
 }

 static const u32 gpio_usb_extcon_exclusive[] = {0x3, 0};

 static int gpio_usbdetect_probe(struct platform_device *pdev)
 {
 	struct gpio_usbdetect *usb;
 	int rc;

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

 	usb->pdev = pdev;

 	usb->extcon_dev = devm_extcon_dev_allocate(&pdev->dev,
 			gpio_usb_extcon_table);
 	if (IS_ERR(usb->extcon_dev)) {
 		dev_err(&pdev->dev, "failed to allocate a extcon device\n");
 		return PTR_ERR(usb->extcon_dev);
 	}

 	usb->extcon_dev->mutually_exclusive = gpio_usb_extcon_exclusive;
 	rc = devm_extcon_dev_register(&pdev->dev, usb->extcon_dev);
 	if (rc) {
 		dev_err(&pdev->dev, "failed to register extcon device\n");
 		return rc;
 	}

 	rc = extcon_set_property_capability(usb->extcon_dev,
 			EXTCON_USB, EXTCON_PROP_USB_SS);
 	rc |= extcon_set_property_capability(usb->extcon_dev,
 			EXTCON_USB_HOST, EXTCON_PROP_USB_SS);
 	if (rc) {
 		dev_err(&pdev->dev, "failed to register extcon props rc=%d\n",
 						rc);
 		return rc;
 	}

 	if (of_get_property(pdev->dev.of_node, "vin-supply", NULL)) {
 		usb->vin = devm_regulator_get(&pdev->dev, "vin");
 		if (IS_ERR(usb->vin)) {
 			dev_err(&pdev->dev, "Failed to get VIN regulator: %ld\n",
 				PTR_ERR(usb->vin));
 			return PTR_ERR(usb->vin);
 		}
 	}

 	if (usb->vin) {
 		rc = regulator_enable(usb->vin);
 		if (rc) {
 			dev_err(&pdev->dev, "Failed to enable VIN regulator: %d\n",
 				rc);
 			return rc;
 		}
 	}

 	usb->gpio = of_get_named_gpio(pdev->dev.of_node,
 				"qcom,vbus-det-gpio", 0);
 	if (usb->gpio < 0) {
 		dev_err(&pdev->dev, "Failed to get gpio: %d\n", usb->gpio);
 		rc = usb->gpio;
 		goto error;
 	}

 	rc = gpio_request(usb->gpio, "vbus-det-gpio");
 	if (rc < 0) {
 		dev_err(&pdev->dev, "Failed to request gpio: %d\n", rc);
 		goto error;
 	}

 	usb->vbus_det_irq = gpio_to_irq(usb->gpio);
 	if (usb->vbus_det_irq < 0) {
 		dev_err(&pdev->dev, "get vbus_det_irq failed\n");
 		rc = usb->vbus_det_irq;
 		goto error;
 	}

 	rc = devm_request_threaded_irq(&pdev->dev, usb->vbus_det_irq,
 				NULL, gpio_usbdetect_vbus_irq,
 			      IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
 			      IRQF_ONESHOT, "vbus_det_irq", usb);
 	if (rc) {
 		dev_err(&pdev->dev, "request for vbus_det_irq failed: %d\n",
 			rc);
 		goto error;
 	}

 	usb->id_det_irq = platform_get_irq_byname(pdev, "pmic_id_irq");
 	if (usb->id_det_irq < 0) {
 		dev_err(&pdev->dev, "get id_det_irq failed\n");
 		rc = usb->id_det_irq;
 		goto error;
 	}

 	rc = devm_request_threaded_irq(&pdev->dev, usb->id_det_irq,
 				gpio_usbdetect_id_irq,
 				gpio_usbdetect_id_irq_thread,
 				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
 				IRQF_ONESHOT, "id_det_irq", usb);
 	if (rc) {
 		dev_err(&pdev->dev, "request for id_det_irq failed: %d\n", rc);
 		goto error;
 	}

 	enable_irq_wake(usb->vbus_det_irq);
 	enable_irq_wake(usb->id_det_irq);
 	dev_set_drvdata(&pdev->dev, usb);

 	if (usb->id_det_irq) {
 		gpio_usbdetect_id_irq(usb->id_det_irq, usb);
 		if (!usb->id_state) {
 			gpio_usbdetect_id_irq_thread(usb->id_det_irq, usb);
 			return 0;
 		}
 	}

 	/* Read and report initial VBUS state */
 	gpio_usbdetect_vbus_irq(usb->vbus_det_irq, usb);

 	return 0;

 error:
 	if (usb->vin)
 		regulator_disable(usb->vin);
 	return rc;
 }

 static int gpio_usbdetect_remove(struct platform_device *pdev)
 {
 	struct gpio_usbdetect *usb = dev_get_drvdata(&pdev->dev);

 	disable_irq_wake(usb->vbus_det_irq);
 	disable_irq(usb->vbus_det_irq);
 	disable_irq_wake(usb->id_det_irq);
 	disable_irq(usb->id_det_irq);
 	if (usb->vin)
 		regulator_disable(usb->vin);

 	return 0;
 }

 static const struct of_device_id of_match_table[] = {
 	{ .compatible = "qcom,gpio-usbdetect", },
 	{}
 };

 static struct platform_driver gpio_usbdetect_driver = {
 	.driver		= {
 		.name	= "qcom,gpio-usbdetect",
 		.of_match_table = of_match_table,
 	},
 	.probe		= gpio_usbdetect_probe,
 	.remove		= gpio_usbdetect_remove,
 };

 module_driver(gpio_usbdetect_driver, platform_driver_register,
 		platform_driver_unregister);

 MODULE_DESCRIPTION("GPIO USB VBUS Detection driver");
 MODULE_LICENSE("GPL v2");
	/* Copyright (c) 2013-2015, 2017-2018, The Linux Foundation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/err.h>
	#include <linux/errno.h>
	#include <linux/slab.h>
	#include <linux/of_platform.h>
	#include <linux/interrupt.h>
	#include <linux/of_gpio.h>
	#include <linux/gpio.h>
	#include <linux/extcon.h>
	#include <linux/regulator/consumer.h>

	struct gpio_usbdetect {
	struct platform_device *pdev;
	struct regulator *vin;
	int vbus_det_irq;
	int id_det_irq;
	int gpio;
	struct extcon_dev *extcon_dev;
	int vbus_state;
	bool id_state;
	};

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

	static irqreturn_t gpio_usbdetect_vbus_irq(int irq, void *data)
	{
	struct gpio_usbdetect *usb = data;
	union extcon_property_value val;

	usb->vbus_state = gpio_get_value(usb->gpio);
	if (usb->vbus_state) {
	dev_dbg(&usb->pdev->dev, "setting vbus notification\n");
	val.intval = true;
	extcon_set_property(usb->extcon_dev, EXTCON_USB,
	EXTCON_PROP_USB_SS, val);
	extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB, 1);
	} else {
	dev_dbg(&usb->pdev->dev, "setting vbus removed notification\n");
	extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB, 0);
	}

	return IRQ_HANDLED;
	}

	static irqreturn_t gpio_usbdetect_id_irq(int irq, void *data)
	{
	struct gpio_usbdetect *usb = data;
	int ret;

	ret = irq_get_irqchip_state(irq, IRQCHIP_STATE_LINE_LEVEL,
	&usb->id_state);
	if (ret < 0) {
	dev_err(&usb->pdev->dev, "unable to read ID IRQ LINE\n");
	return IRQ_HANDLED;
	}

	return IRQ_WAKE_THREAD;
	}

	static irqreturn_t gpio_usbdetect_id_irq_thread(int irq, void *data)
	{
	struct gpio_usbdetect *usb = data;
	bool curr_id_state;
	static int prev_id_state = -EINVAL;
	union extcon_property_value val;

	curr_id_state = usb->id_state;
	if (curr_id_state == prev_id_state) {
	dev_dbg(&usb->pdev->dev, "no change in ID state\n");
	return IRQ_HANDLED;
	}

	if (curr_id_state) {
	dev_dbg(&usb->pdev->dev, "stopping usb host\n");
	extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB_HOST, 0);
	enable_irq(usb->vbus_det_irq);
	} else {
	dev_dbg(&usb->pdev->dev, "starting usb HOST\n");
	disable_irq(usb->vbus_det_irq);
	val.intval = true;
	extcon_set_property(usb->extcon_dev, EXTCON_USB_HOST,
	EXTCON_PROP_USB_SS, val);
	extcon_set_cable_state_(usb->extcon_dev, EXTCON_USB_HOST, 1);
	}

	prev_id_state = curr_id_state;
	return IRQ_HANDLED;
	}

	static const u32 gpio_usb_extcon_exclusive[] = {0x3, 0};

	static int gpio_usbdetect_probe(struct platform_device *pdev)
	{
	struct gpio_usbdetect *usb;
	int rc;

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

	usb->pdev = pdev;

	usb->extcon_dev = devm_extcon_dev_allocate(&pdev->dev,
	gpio_usb_extcon_table);
	if (IS_ERR(usb->extcon_dev)) {
	dev_err(&pdev->dev, "failed to allocate a extcon device\n");
	return PTR_ERR(usb->extcon_dev);
	}

	usb->extcon_dev->mutually_exclusive = gpio_usb_extcon_exclusive;
	rc = devm_extcon_dev_register(&pdev->dev, usb->extcon_dev);
	if (rc) {
	dev_err(&pdev->dev, "failed to register extcon device\n");
	return rc;
	}

	rc = extcon_set_property_capability(usb->extcon_dev,
	EXTCON_USB, EXTCON_PROP_USB_SS);
	rc \|= extcon_set_property_capability(usb->extcon_dev,
	EXTCON_USB_HOST, EXTCON_PROP_USB_SS);
	if (rc) {
	dev_err(&pdev->dev, "failed to register extcon props rc=%d\n",
	rc);
	return rc;
	}

	if (of_get_property(pdev->dev.of_node, "vin-supply", NULL)) {
	usb->vin = devm_regulator_get(&pdev->dev, "vin");
	if (IS_ERR(usb->vin)) {
	dev_err(&pdev->dev, "Failed to get VIN regulator: %ld\n",
	PTR_ERR(usb->vin));
	return PTR_ERR(usb->vin);
	}
	}

	if (usb->vin) {
	rc = regulator_enable(usb->vin);
	if (rc) {
	dev_err(&pdev->dev, "Failed to enable VIN regulator: %d\n",
	rc);
	return rc;
	}
	}

	usb->gpio = of_get_named_gpio(pdev->dev.of_node,
	"qcom,vbus-det-gpio", 0);
	if (usb->gpio < 0) {
	dev_err(&pdev->dev, "Failed to get gpio: %d\n", usb->gpio);
	rc = usb->gpio;
	goto error;
	}

	rc = gpio_request(usb->gpio, "vbus-det-gpio");
	if (rc < 0) {
	dev_err(&pdev->dev, "Failed to request gpio: %d\n", rc);
	goto error;
	}

	usb->vbus_det_irq = gpio_to_irq(usb->gpio);
	if (usb->vbus_det_irq < 0) {
	dev_err(&pdev->dev, "get vbus_det_irq failed\n");
	rc = usb->vbus_det_irq;
	goto error;
	}

	rc = devm_request_threaded_irq(&pdev->dev, usb->vbus_det_irq,
	NULL, gpio_usbdetect_vbus_irq,
	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING \|
	IRQF_ONESHOT, "vbus_det_irq", usb);
	if (rc) {
	dev_err(&pdev->dev, "request for vbus_det_irq failed: %d\n",
	rc);
	goto error;
	}

	usb->id_det_irq = platform_get_irq_byname(pdev, "pmic_id_irq");
	if (usb->id_det_irq < 0) {
	dev_err(&pdev->dev, "get id_det_irq failed\n");
	rc = usb->id_det_irq;
	goto error;
	}

	rc = devm_request_threaded_irq(&pdev->dev, usb->id_det_irq,
	gpio_usbdetect_id_irq,
	gpio_usbdetect_id_irq_thread,
	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING \|
	IRQF_ONESHOT, "id_det_irq", usb);
	if (rc) {
	dev_err(&pdev->dev, "request for id_det_irq failed: %d\n", rc);
	goto error;
	}

	enable_irq_wake(usb->vbus_det_irq);
	enable_irq_wake(usb->id_det_irq);
	dev_set_drvdata(&pdev->dev, usb);

	if (usb->id_det_irq) {
	gpio_usbdetect_id_irq(usb->id_det_irq, usb);
	if (!usb->id_state) {
	gpio_usbdetect_id_irq_thread(usb->id_det_irq, usb);
	return 0;
	}
	}

	/* Read and report initial VBUS state */
	gpio_usbdetect_vbus_irq(usb->vbus_det_irq, usb);

	return 0;

	error:
	if (usb->vin)
	regulator_disable(usb->vin);
	return rc;
	}

	static int gpio_usbdetect_remove(struct platform_device *pdev)
	{
	struct gpio_usbdetect *usb = dev_get_drvdata(&pdev->dev);

	disable_irq_wake(usb->vbus_det_irq);
	disable_irq(usb->vbus_det_irq);
	disable_irq_wake(usb->id_det_irq);
	disable_irq(usb->id_det_irq);
	if (usb->vin)
	regulator_disable(usb->vin);

	return 0;
	}

	static const struct of_device_id of_match_table[] = {
	{ .compatible = "qcom,gpio-usbdetect", },
	{}
	};

	static struct platform_driver gpio_usbdetect_driver = {
	.driver = {
	.name = "qcom,gpio-usbdetect",
	.of_match_table = of_match_table,
	},
	.probe = gpio_usbdetect_probe,
	.remove = gpio_usbdetect_remove,
	};

	module_driver(gpio_usbdetect_driver, platform_driver_register,
	platform_driver_unregister);

	MODULE_DESCRIPTION("GPIO USB VBUS Detection driver");
	MODULE_LICENSE("GPL v2");