Merge tag 'riscv-for-linus-5.10-mw0' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-microblaze.git] / drivers / extcon / extcon-gpio.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * extcon_gpio.c - Single-state GPIO extcon driver based on extcon class
4  *
5  * Copyright (C) 2008 Google, Inc.
6  * Author: Mike Lockwood <lockwood@android.com>
7  *
8  * Modified by MyungJoo Ham <myungjoo.ham@samsung.com> to support extcon
9  * (originally switch class is supported)
10  */
11
12 #include <linux/extcon-provider.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/slab.h>
20 #include <linux/workqueue.h>
21
22 /**
23  * struct gpio_extcon_data - A simple GPIO-controlled extcon device state container.
24  * @edev:               Extcon device.
25  * @work:               Work fired by the interrupt.
26  * @debounce_jiffies:   Number of jiffies to wait for the GPIO to stabilize, from the debounce
27  *                      value.
28  * @gpiod:              GPIO descriptor for this external connector.
29  * @extcon_id:          The unique id of specific external connector.
30  * @debounce:           Debounce time for GPIO IRQ in ms.
31  * @check_on_resume:    Boolean describing whether to check the state of gpio
32  *                      while resuming from sleep.
33  */
34 struct gpio_extcon_data {
35         struct extcon_dev *edev;
36         struct delayed_work work;
37         unsigned long debounce_jiffies;
38         struct gpio_desc *gpiod;
39         unsigned int extcon_id;
40         unsigned long debounce;
41         bool check_on_resume;
42 };
43
44 static void gpio_extcon_work(struct work_struct *work)
45 {
46         int state;
47         struct gpio_extcon_data *data =
48                 container_of(to_delayed_work(work), struct gpio_extcon_data,
49                              work);
50
51         state = gpiod_get_value_cansleep(data->gpiod);
52         extcon_set_state_sync(data->edev, data->extcon_id, state);
53 }
54
55 static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
56 {
57         struct gpio_extcon_data *data = dev_id;
58
59         queue_delayed_work(system_power_efficient_wq, &data->work,
60                               data->debounce_jiffies);
61         return IRQ_HANDLED;
62 }
63
64 static int gpio_extcon_probe(struct platform_device *pdev)
65 {
66         struct gpio_extcon_data *data;
67         struct device *dev = &pdev->dev;
68         unsigned long irq_flags;
69         int irq;
70         int ret;
71
72         data = devm_kzalloc(dev, sizeof(struct gpio_extcon_data), GFP_KERNEL);
73         if (!data)
74                 return -ENOMEM;
75
76         /*
77          * FIXME: extcon_id represents the unique identifier of external
78          * connectors such as EXTCON_USB, EXTCON_DISP_HDMI and so on. extcon_id
79          * is necessary to register the extcon device. But, it's not yet
80          * developed to get the extcon id from device-tree or others.
81          * On later, it have to be solved.
82          */
83         if (data->extcon_id > EXTCON_NONE)
84                 return -EINVAL;
85
86         data->gpiod = devm_gpiod_get(dev, "extcon", GPIOD_IN);
87         if (IS_ERR(data->gpiod))
88                 return PTR_ERR(data->gpiod);
89         irq = gpiod_to_irq(data->gpiod);
90         if (irq <= 0)
91                 return irq;
92
93         /*
94          * It is unlikely that this is an acknowledged interrupt that goes
95          * away after handling, what we are looking for are falling edges
96          * if the signal is active low, and rising edges if the signal is
97          * active high.
98          */
99         if (gpiod_is_active_low(data->gpiod))
100                 irq_flags = IRQF_TRIGGER_FALLING;
101         else
102                 irq_flags = IRQF_TRIGGER_RISING;
103
104         /* Allocate the memory of extcon devie and register extcon device */
105         data->edev = devm_extcon_dev_allocate(dev, &data->extcon_id);
106         if (IS_ERR(data->edev)) {
107                 dev_err(dev, "failed to allocate extcon device\n");
108                 return -ENOMEM;
109         }
110
111         ret = devm_extcon_dev_register(dev, data->edev);
112         if (ret < 0)
113                 return ret;
114
115         INIT_DELAYED_WORK(&data->work, gpio_extcon_work);
116
117         /*
118          * Request the interrupt of gpio to detect whether external connector
119          * is attached or detached.
120          */
121         ret = devm_request_any_context_irq(dev, irq,
122                                         gpio_irq_handler, irq_flags,
123                                         pdev->name, data);
124         if (ret < 0)
125                 return ret;
126
127         platform_set_drvdata(pdev, data);
128         /* Perform initial detection */
129         gpio_extcon_work(&data->work.work);
130
131         return 0;
132 }
133
134 static int gpio_extcon_remove(struct platform_device *pdev)
135 {
136         struct gpio_extcon_data *data = platform_get_drvdata(pdev);
137
138         cancel_delayed_work_sync(&data->work);
139
140         return 0;
141 }
142
143 #ifdef CONFIG_PM_SLEEP
144 static int gpio_extcon_resume(struct device *dev)
145 {
146         struct gpio_extcon_data *data;
147
148         data = dev_get_drvdata(dev);
149         if (data->check_on_resume)
150                 queue_delayed_work(system_power_efficient_wq,
151                         &data->work, data->debounce_jiffies);
152
153         return 0;
154 }
155 #endif
156
157 static SIMPLE_DEV_PM_OPS(gpio_extcon_pm_ops, NULL, gpio_extcon_resume);
158
159 static struct platform_driver gpio_extcon_driver = {
160         .probe          = gpio_extcon_probe,
161         .remove         = gpio_extcon_remove,
162         .driver         = {
163                 .name   = "extcon-gpio",
164                 .pm     = &gpio_extcon_pm_ops,
165         },
166 };
167
168 module_platform_driver(gpio_extcon_driver);
169
170 MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
171 MODULE_DESCRIPTION("GPIO extcon driver");
172 MODULE_LICENSE("GPL");