Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/extcon/extcon-palmas.c

  1 /*
  2  * Palmas USB transceiver driver
  3  *
  4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU General Public License as published by
  7  * the Free Software Foundation; either version 2 of the License, or
  8  * (at your option) any later version.
  9  *
 10  * Author: Graeme Gregory <gg@slimlogic.co.uk>
 11  * Author: Kishon Vijay Abraham I <kishon@ti.com>
 12  *
 13  * Based on twl6030_usb.c
 14  *
 15  * Author: Hema HK <hemahk@ti.com>
 16  *
 17  * This program is distributed in the hope that it will be useful,
 18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 20  * GNU General Public License for more details.
 21  */
 22 
 23 #include <linux/module.h>
 24 #include <linux/interrupt.h>
 25 #include <linux/platform_device.h>
 26 #include <linux/slab.h>
 27 #include <linux/err.h>
 28 #include <linux/mfd/palmas.h>
 29 #include <linux/of.h>
 30 #include <linux/of_platform.h>
 31 
 32 static const char *palmas_extcon_cable[] = {
 33         [0] = "USB",
 34         [1] = "USB-HOST",
 35         NULL,
 36 };
 37 
 38 static const int mutually_exclusive[] = {0x3, 0x0};
 39 
 40 static void palmas_usb_wakeup(struct palmas *palmas, int enable)
 41 {
 42         if (enable)
 43                 palmas_write(palmas, PALMAS_USB_OTG_BASE, PALMAS_USB_WAKEUP,
 44                         PALMAS_USB_WAKEUP_ID_WK_UP_COMP);
 45         else
 46                 palmas_write(palmas, PALMAS_USB_OTG_BASE, PALMAS_USB_WAKEUP, 0);
 47 }
 48 
 49 static irqreturn_t palmas_vbus_irq_handler(int irq, void *_palmas_usb)
 50 {
 51         struct palmas_usb *palmas_usb = _palmas_usb;
 52         unsigned int vbus_line_state;
 53 
 54         palmas_read(palmas_usb->palmas, PALMAS_INTERRUPT_BASE,
 55                 PALMAS_INT3_LINE_STATE, &vbus_line_state);
 56 
 57         if (vbus_line_state & PALMAS_INT3_LINE_STATE_VBUS) {
 58                 if (palmas_usb->linkstat != PALMAS_USB_STATE_VBUS) {
 59                         palmas_usb->linkstat = PALMAS_USB_STATE_VBUS;
 60                         extcon_set_cable_state(palmas_usb->edev, "USB", true);
 61                         dev_info(palmas_usb->dev, "USB cable is attached\n");
 62                 } else {
 63                         dev_dbg(palmas_usb->dev,
 64                                 "Spurious connect event detected\n");
 65                 }
 66         } else if (!(vbus_line_state & PALMAS_INT3_LINE_STATE_VBUS)) {
 67                 if (palmas_usb->linkstat == PALMAS_USB_STATE_VBUS) {
 68                         palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
 69                         extcon_set_cable_state(palmas_usb->edev, "USB", false);
 70                         dev_info(palmas_usb->dev, "USB cable is detached\n");
 71                 } else {
 72                         dev_dbg(palmas_usb->dev,
 73                                 "Spurious disconnect event detected\n");
 74                 }
 75         }
 76 
 77         return IRQ_HANDLED;
 78 }
 79 
 80 static irqreturn_t palmas_id_irq_handler(int irq, void *_palmas_usb)
 81 {
 82         unsigned int set, id_src;
 83         struct palmas_usb *palmas_usb = _palmas_usb;
 84 
 85         palmas_read(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
 86                 PALMAS_USB_ID_INT_LATCH_SET, &set);
 87         palmas_read(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
 88                 PALMAS_USB_ID_INT_SRC, &id_src);
 89 
 90         if ((set & PALMAS_USB_ID_INT_SRC_ID_GND) &&
 91                                 (id_src & PALMAS_USB_ID_INT_SRC_ID_GND)) {
 92                 palmas_write(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
 93                         PALMAS_USB_ID_INT_LATCH_CLR,
 94                         PALMAS_USB_ID_INT_EN_HI_CLR_ID_GND);
 95                 palmas_usb->linkstat = PALMAS_USB_STATE_ID;
 96                 extcon_set_cable_state(palmas_usb->edev, "USB-HOST", true);
 97                 dev_info(palmas_usb->dev, "USB-HOST cable is attached\n");
 98         } else if ((set & PALMAS_USB_ID_INT_SRC_ID_FLOAT) &&
 99                                 (id_src & PALMAS_USB_ID_INT_SRC_ID_FLOAT)) {
100                 palmas_write(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
101                         PALMAS_USB_ID_INT_LATCH_CLR,
102                         PALMAS_USB_ID_INT_EN_HI_CLR_ID_FLOAT);
103                 palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
104                 extcon_set_cable_state(palmas_usb->edev, "USB-HOST", false);
105                 dev_info(palmas_usb->dev, "USB-HOST cable is detached\n");
106         } else if ((palmas_usb->linkstat == PALMAS_USB_STATE_ID) &&
107                                 (!(set & PALMAS_USB_ID_INT_SRC_ID_GND))) {
108                 palmas_usb->linkstat = PALMAS_USB_STATE_DISCONNECT;
109                 extcon_set_cable_state(palmas_usb->edev, "USB-HOST", false);
110                 dev_info(palmas_usb->dev, "USB-HOST cable is detached\n");
111         } else if ((palmas_usb->linkstat == PALMAS_USB_STATE_DISCONNECT) &&
112                                 (id_src & PALMAS_USB_ID_INT_SRC_ID_GND)) {
113                 palmas_usb->linkstat = PALMAS_USB_STATE_ID;
114                 extcon_set_cable_state(palmas_usb->edev, "USB-HOST", true);
115                 dev_info(palmas_usb->dev, " USB-HOST cable is attached\n");
116         }
117 
118         return IRQ_HANDLED;
119 }
120 
121 static void palmas_enable_irq(struct palmas_usb *palmas_usb)
122 {
123         palmas_write(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
124                 PALMAS_USB_VBUS_CTRL_SET,
125                 PALMAS_USB_VBUS_CTRL_SET_VBUS_ACT_COMP);
126 
127         palmas_write(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
128                 PALMAS_USB_ID_CTRL_SET, PALMAS_USB_ID_CTRL_SET_ID_ACT_COMP);
129 
130         palmas_write(palmas_usb->palmas, PALMAS_USB_OTG_BASE,
131                 PALMAS_USB_ID_INT_EN_HI_SET,
132                 PALMAS_USB_ID_INT_EN_HI_SET_ID_GND |
133                 PALMAS_USB_ID_INT_EN_HI_SET_ID_FLOAT);
134 
135         if (palmas_usb->enable_vbus_detection)
136                 palmas_vbus_irq_handler(palmas_usb->vbus_irq, palmas_usb);
137 
138         /* cold plug for host mode needs this delay */
139         if (palmas_usb->enable_id_detection) {
140                 msleep(30);
141                 palmas_id_irq_handler(palmas_usb->id_irq, palmas_usb);
142         }
143 }
144 
145 static int palmas_usb_probe(struct platform_device *pdev)
146 {
147         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
148         struct palmas_usb_platform_data *pdata = dev_get_platdata(&pdev->dev);
149         struct device_node *node = pdev->dev.of_node;
150         struct palmas_usb *palmas_usb;
151         int status;
152 
153         palmas_usb = devm_kzalloc(&pdev->dev, sizeof(*palmas_usb), GFP_KERNEL);
154         if (!palmas_usb)
155                 return -ENOMEM;
156 
157         if (node && !pdata) {
158                 palmas_usb->wakeup = of_property_read_bool(node, "ti,wakeup");
159                 palmas_usb->enable_id_detection = of_property_read_bool(node,
160                                                 "ti,enable-id-detection");
161                 palmas_usb->enable_vbus_detection = of_property_read_bool(node,
162                                                 "ti,enable-vbus-detection");
163         } else {
164                 palmas_usb->wakeup = true;
165                 palmas_usb->enable_id_detection = true;
166                 palmas_usb->enable_vbus_detection = true;
167 
168                 if (pdata)
169                         palmas_usb->wakeup = pdata->wakeup;
170         }
171 
172         palmas->usb = palmas_usb;
173         palmas_usb->palmas = palmas;
174 
175         palmas_usb->dev  = &pdev->dev;
176 
177         palmas_usb->id_otg_irq = regmap_irq_get_virq(palmas->irq_data,
178                                                 PALMAS_ID_OTG_IRQ);
179         palmas_usb->id_irq = regmap_irq_get_virq(palmas->irq_data,
180                                                 PALMAS_ID_IRQ);
181         palmas_usb->vbus_otg_irq = regmap_irq_get_virq(palmas->irq_data,
182                                                 PALMAS_VBUS_OTG_IRQ);
183         palmas_usb->vbus_irq = regmap_irq_get_virq(palmas->irq_data,
184                                                 PALMAS_VBUS_IRQ);
185 
186         palmas_usb_wakeup(palmas, palmas_usb->wakeup);
187 
188         platform_set_drvdata(pdev, palmas_usb);
189 
190         palmas_usb->edev = devm_extcon_dev_allocate(&pdev->dev,
191                                                     palmas_extcon_cable);
192         if (IS_ERR(palmas_usb->edev)) {
193                 dev_err(&pdev->dev, "failed to allocate extcon device\n");
194                 return -ENOMEM;
195         }
196         palmas_usb->edev->name = kstrdup(node->name, GFP_KERNEL);
197         palmas_usb->edev->dev.parent = palmas_usb->dev;
198         palmas_usb->edev->mutually_exclusive = mutually_exclusive;
199 
200         status = devm_extcon_dev_register(&pdev->dev, palmas_usb->edev);
201         if (status) {
202                 dev_err(&pdev->dev, "failed to register extcon device\n");
203                 kfree(palmas_usb->edev->name);
204                 return status;
205         }
206 
207         if (palmas_usb->enable_id_detection) {
208                 status = devm_request_threaded_irq(palmas_usb->dev,
209                                 palmas_usb->id_irq,
210                                 NULL, palmas_id_irq_handler,
211                                 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING |
212                                 IRQF_ONESHOT | IRQF_EARLY_RESUME,
213                                 "palmas_usb_id", palmas_usb);
214                 if (status < 0) {
215                         dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
216                                         palmas_usb->id_irq, status);
217                         kfree(palmas_usb->edev->name);
218                         return status;
219                 }
220         }
221 
222         if (palmas_usb->enable_vbus_detection) {
223                 status = devm_request_threaded_irq(palmas_usb->dev,
224                                 palmas_usb->vbus_irq, NULL,
225                                 palmas_vbus_irq_handler,
226                                 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING |
227                                 IRQF_ONESHOT | IRQF_EARLY_RESUME,
228                                 "palmas_usb_vbus", palmas_usb);
229                 if (status < 0) {
230                         dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
231                                         palmas_usb->vbus_irq, status);
232                         kfree(palmas_usb->edev->name);
233                         return status;
234                 }
235         }
236 
237         palmas_enable_irq(palmas_usb);
238         device_set_wakeup_capable(&pdev->dev, true);
239         return 0;
240 }
241 
242 static int palmas_usb_remove(struct platform_device *pdev)
243 {
244         struct palmas_usb *palmas_usb = platform_get_drvdata(pdev);
245 
246         kfree(palmas_usb->edev->name);
247 
248         return 0;
249 }
250 
251 #ifdef CONFIG_PM_SLEEP
252 static int palmas_usb_suspend(struct device *dev)
253 {
254         struct palmas_usb *palmas_usb = dev_get_drvdata(dev);
255 
256         if (device_may_wakeup(dev)) {
257                 if (palmas_usb->enable_vbus_detection)
258                         enable_irq_wake(palmas_usb->vbus_irq);
259                 if (palmas_usb->enable_id_detection)
260                         enable_irq_wake(palmas_usb->id_irq);
261         }
262         return 0;
263 }
264 
265 static int palmas_usb_resume(struct device *dev)
266 {
267         struct palmas_usb *palmas_usb = dev_get_drvdata(dev);
268 
269         if (device_may_wakeup(dev)) {
270                 if (palmas_usb->enable_vbus_detection)
271                         disable_irq_wake(palmas_usb->vbus_irq);
272                 if (palmas_usb->enable_id_detection)
273                         disable_irq_wake(palmas_usb->id_irq);
274         }
275         return 0;
276 };
277 #endif
278 
279 static SIMPLE_DEV_PM_OPS(palmas_pm_ops, palmas_usb_suspend, palmas_usb_resume);
280 
281 static struct of_device_id of_palmas_match_tbl[] = {
282         { .compatible = "ti,palmas-usb", },
283         { .compatible = "ti,palmas-usb-vid", },
284         { .compatible = "ti,twl6035-usb", },
285         { .compatible = "ti,twl6035-usb-vid", },
286         { /* end */ }
287 };
288 
289 static struct platform_driver palmas_usb_driver = {
290         .probe = palmas_usb_probe,
291         .remove = palmas_usb_remove,
292         .driver = {
293                 .name = "palmas-usb",
294                 .of_match_table = of_palmas_match_tbl,
295                 .owner = THIS_MODULE,
296                 .pm = &palmas_pm_ops,
297         },
298 };
299 
300 module_platform_driver(palmas_usb_driver);
301 
302 MODULE_ALIAS("platform:palmas-usb");
303 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
304 MODULE_DESCRIPTION("Palmas USB transceiver driver");
305 MODULE_LICENSE("GPL");
306 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);
307 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us