blob: 31102170c7a0bf07f4d8da0a6b26ea02e18b521b [file] [log] [blame]
Andrew Victor39a269c2006-01-22 10:32:13 -08001/*
2 * OHCI HCD (Host Controller Driver) for USB.
3 *
4 * Copyright (C) 2004 SAN People (Pty) Ltd.
5 * Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
6 *
David Brownell0365ee02006-06-19 14:27:20 -07007 * AT91 Bus Glue
Andrew Victor39a269c2006-01-22 10:32:13 -08008 *
9 * Based on fragments of 2.4 driver by Rick Bronson.
10 * Based on ohci-omap.c
11 *
12 * This file is licenced under the GPL.
13 */
14
15#include <linux/clk.h>
Manjunath Goudare3825b42013-09-21 16:38:42 +053016#include <linux/dma-mapping.h>
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +080017#include <linux/of_platform.h>
18#include <linux/of_gpio.h>
Manjunath Goudare3825b42013-09-21 16:38:42 +053019#include <linux/platform_device.h>
Jean-Christophe PLAGNIOL-VILLARDbcd23602012-10-30 05:12:23 +080020#include <linux/platform_data/atmel.h>
Manjunath Goudare3825b42013-09-21 16:38:42 +053021#include <linux/io.h>
22#include <linux/kernel.h>
23#include <linux/module.h>
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +080024#include <linux/mfd/syscon.h>
25#include <linux/regmap.h>
Manjunath Goudare3825b42013-09-21 16:38:42 +053026#include <linux/usb.h>
27#include <linux/usb/hcd.h>
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +080028#include <soc/at91/atmel-sfr.h>
Andrew Victor39a269c2006-01-22 10:32:13 -080029
Manjunath Goudare3825b42013-09-21 16:38:42 +053030#include "ohci.h"
Andrew Victor39a269c2006-01-22 10:32:13 -080031
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +010032#define valid_port(index) ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
33#define at91_for_each_port(index) \
34 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
35
Boris BREZILLON6b0a1cf2013-08-01 19:09:13 +020036/* interface, function and usb clocks; sometimes also an AHB clock */
Sylvain Rochet1b207452015-01-20 14:39:02 +010037#define hcd_to_ohci_at91_priv(h) \
38 ((struct ohci_at91_priv *)hcd_to_ohci(h)->priv)
39
Alexandre Bellonib4f19472015-08-10 16:23:09 +020040#define AT91_MAX_USBH_PORTS 3
41struct at91_usbh_data {
42 int vbus_pin[AT91_MAX_USBH_PORTS]; /* port power-control pin */
43 int overcurrent_pin[AT91_MAX_USBH_PORTS];
44 u8 ports; /* number of ports on root hub */
45 u8 overcurrent_supported;
46 u8 vbus_pin_active_low[AT91_MAX_USBH_PORTS];
47 u8 overcurrent_status[AT91_MAX_USBH_PORTS];
48 u8 overcurrent_changed[AT91_MAX_USBH_PORTS];
49};
50
Sylvain Rochet1b207452015-01-20 14:39:02 +010051struct ohci_at91_priv {
52 struct clk *iclk;
53 struct clk *fclk;
Sylvain Rochet1b207452015-01-20 14:39:02 +010054 struct clk *hclk;
55 bool clocked;
Sylvain Rochet1cee6b82015-01-20 14:39:04 +010056 bool wakeup; /* Saved wake-up state for resume */
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +080057 struct regmap *sfr_regmap;
Sylvain Rochet1b207452015-01-20 14:39:02 +010058};
Manjunath Goudare3825b42013-09-21 16:38:42 +053059/* interface and function clocks; sometimes also an AHB clock */
60
61#define DRIVER_DESC "OHCI Atmel driver"
62
63static const char hcd_name[] = "ohci-atmel";
64
65static struct hc_driver __read_mostly ohci_at91_hc_driver;
Sylvain Rochet1b207452015-01-20 14:39:02 +010066
67static const struct ohci_driver_overrides ohci_at91_drv_overrides __initconst = {
68 .extra_priv_size = sizeof(struct ohci_at91_priv),
69};
Andrew Victor39a269c2006-01-22 10:32:13 -080070
71extern int usb_disabled(void);
72
73/*-------------------------------------------------------------------------*/
74
Sylvain Rochet1b207452015-01-20 14:39:02 +010075static void at91_start_clock(struct ohci_at91_priv *ohci_at91)
Andrew Victored077bb2007-02-16 10:18:58 -080076{
Sylvain Rochet1cee6b82015-01-20 14:39:04 +010077 if (ohci_at91->clocked)
78 return;
Boris Brezillon963719c2015-03-17 17:15:47 +010079
80 clk_set_rate(ohci_at91->fclk, 48000000);
Sylvain Rochet1b207452015-01-20 14:39:02 +010081 clk_prepare_enable(ohci_at91->hclk);
82 clk_prepare_enable(ohci_at91->iclk);
83 clk_prepare_enable(ohci_at91->fclk);
84 ohci_at91->clocked = true;
Andrew Victored077bb2007-02-16 10:18:58 -080085}
86
Sylvain Rochet1b207452015-01-20 14:39:02 +010087static void at91_stop_clock(struct ohci_at91_priv *ohci_at91)
Andrew Victored077bb2007-02-16 10:18:58 -080088{
Sylvain Rochet1cee6b82015-01-20 14:39:04 +010089 if (!ohci_at91->clocked)
90 return;
Boris Brezillon963719c2015-03-17 17:15:47 +010091
Sylvain Rochet1b207452015-01-20 14:39:02 +010092 clk_disable_unprepare(ohci_at91->fclk);
93 clk_disable_unprepare(ohci_at91->iclk);
94 clk_disable_unprepare(ohci_at91->hclk);
Sylvain Rochet1b207452015-01-20 14:39:02 +010095 ohci_at91->clocked = false;
Andrew Victored077bb2007-02-16 10:18:58 -080096}
97
Andrew Victor39a269c2006-01-22 10:32:13 -080098static void at91_start_hc(struct platform_device *pdev)
99{
100 struct usb_hcd *hcd = platform_get_drvdata(pdev);
101 struct ohci_regs __iomem *regs = hcd->regs;
Sylvain Rochet1b207452015-01-20 14:39:02 +0100102 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Andrew Victor39a269c2006-01-22 10:32:13 -0800103
David Brownell0365ee02006-06-19 14:27:20 -0700104 dev_dbg(&pdev->dev, "start\n");
Andrew Victor39a269c2006-01-22 10:32:13 -0800105
106 /*
107 * Start the USB clocks.
108 */
Sylvain Rochet1b207452015-01-20 14:39:02 +0100109 at91_start_clock(ohci_at91);
Andrew Victor39a269c2006-01-22 10:32:13 -0800110
111 /*
112 * The USB host controller must remain in reset.
113 */
114 writel(0, &regs->control);
115}
116
117static void at91_stop_hc(struct platform_device *pdev)
118{
119 struct usb_hcd *hcd = platform_get_drvdata(pdev);
120 struct ohci_regs __iomem *regs = hcd->regs;
Sylvain Rochet1b207452015-01-20 14:39:02 +0100121 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Andrew Victor39a269c2006-01-22 10:32:13 -0800122
David Brownell0365ee02006-06-19 14:27:20 -0700123 dev_dbg(&pdev->dev, "stop\n");
Andrew Victor39a269c2006-01-22 10:32:13 -0800124
125 /*
126 * Put the USB host controller into reset.
127 */
128 writel(0, &regs->control);
129
130 /*
131 * Stop the USB clocks.
132 */
Sylvain Rochet1b207452015-01-20 14:39:02 +0100133 at91_stop_clock(ohci_at91);
Andrew Victor39a269c2006-01-22 10:32:13 -0800134}
135
136
137/*-------------------------------------------------------------------------*/
138
Bill Pembertonfb4e98a2012-11-19 13:26:20 -0500139static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
Andrew Victor39a269c2006-01-22 10:32:13 -0800140
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800141struct regmap *at91_dt_syscon_sfr(void)
142{
143 struct regmap *regmap;
144
145 regmap = syscon_regmap_lookup_by_compatible("atmel,sama5d2-sfr");
146 if (IS_ERR(regmap))
147 regmap = NULL;
148
149 return regmap;
150}
151
Andrew Victor39a269c2006-01-22 10:32:13 -0800152/* configure so an HC device and id are always provided */
153/* always called with process context; sleeping is OK */
154
155
156/**
David Brownell0365ee02006-06-19 14:27:20 -0700157 * usb_hcd_at91_probe - initialize AT91-based HCDs
Andrew Victor39a269c2006-01-22 10:32:13 -0800158 * Context: !in_interrupt()
159 *
160 * Allocates basic resources for this USB host controller, and
161 * then invokes the start() method for the HCD associated with it
162 * through the hotplug entry's driver_data.
Andrew Victor39a269c2006-01-22 10:32:13 -0800163 */
Bill Pemberton41ac7b32012-11-19 13:21:48 -0500164static int usb_hcd_at91_probe(const struct hc_driver *driver,
David Brownell0365ee02006-06-19 14:27:20 -0700165 struct platform_device *pdev)
Andrew Victor39a269c2006-01-22 10:32:13 -0800166{
Manjunath Goudare3825b42013-09-21 16:38:42 +0530167 struct at91_usbh_data *board;
168 struct ohci_hcd *ohci;
Andrew Victor39a269c2006-01-22 10:32:13 -0800169 int retval;
Sylvain Rochet3b3394a2015-01-20 14:39:03 +0100170 struct usb_hcd *hcd;
Sylvain Rochet1b207452015-01-20 14:39:02 +0100171 struct ohci_at91_priv *ohci_at91;
Boris BREZILLONfb5f1832013-12-08 15:59:59 +0100172 struct device *dev = &pdev->dev;
173 struct resource *res;
174 int irq;
Andrew Victor39a269c2006-01-22 10:32:13 -0800175
Boris BREZILLONfb5f1832013-12-08 15:59:59 +0100176 irq = platform_get_irq(pdev, 0);
177 if (irq < 0) {
178 dev_dbg(dev, "hcd probe: missing irq resource\n");
179 return irq;
Andrew Victor39a269c2006-01-22 10:32:13 -0800180 }
181
Boris BREZILLON5b218a02013-12-09 09:51:54 +0100182 hcd = usb_create_hcd(driver, dev, "at91");
Andrew Victor39a269c2006-01-22 10:32:13 -0800183 if (!hcd)
184 return -ENOMEM;
Sylvain Rochet1b207452015-01-20 14:39:02 +0100185 ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Andrew Victor39a269c2006-01-22 10:32:13 -0800186
Varka Bhadram04dc3152014-11-04 07:51:12 +0530187 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Boris BREZILLONcca2bbb2013-12-09 09:51:53 +0100188 hcd->regs = devm_ioremap_resource(dev, res);
189 if (IS_ERR(hcd->regs)) {
190 retval = PTR_ERR(hcd->regs);
191 goto err;
Andrew Victor39a269c2006-01-22 10:32:13 -0800192 }
Varka Bhadram04dc3152014-11-04 07:51:12 +0530193 hcd->rsrc_start = res->start;
194 hcd->rsrc_len = resource_size(res);
Andrew Victor39a269c2006-01-22 10:32:13 -0800195
Sylvain Rochet1b207452015-01-20 14:39:02 +0100196 ohci_at91->iclk = devm_clk_get(dev, "ohci_clk");
197 if (IS_ERR(ohci_at91->iclk)) {
Boris BREZILLON5b218a02013-12-09 09:51:54 +0100198 dev_err(dev, "failed to get ohci_clk\n");
Sylvain Rochet1b207452015-01-20 14:39:02 +0100199 retval = PTR_ERR(ohci_at91->iclk);
Boris BREZILLONcca2bbb2013-12-09 09:51:53 +0100200 goto err;
Jean-Christophe PLAGNIOL-VILLARD68134632011-12-08 16:32:00 +0100201 }
Sylvain Rochet1b207452015-01-20 14:39:02 +0100202 ohci_at91->fclk = devm_clk_get(dev, "uhpck");
203 if (IS_ERR(ohci_at91->fclk)) {
Boris BREZILLON5b218a02013-12-09 09:51:54 +0100204 dev_err(dev, "failed to get uhpck\n");
Sylvain Rochet1b207452015-01-20 14:39:02 +0100205 retval = PTR_ERR(ohci_at91->fclk);
Boris BREZILLONfc7a3252013-12-09 09:51:55 +0100206 goto err;
Jean-Christophe PLAGNIOL-VILLARD68134632011-12-08 16:32:00 +0100207 }
Sylvain Rochet1b207452015-01-20 14:39:02 +0100208 ohci_at91->hclk = devm_clk_get(dev, "hclk");
209 if (IS_ERR(ohci_at91->hclk)) {
Boris BREZILLON5b218a02013-12-09 09:51:54 +0100210 dev_err(dev, "failed to get hclk\n");
Sylvain Rochet1b207452015-01-20 14:39:02 +0100211 retval = PTR_ERR(ohci_at91->hclk);
Boris BREZILLONfc7a3252013-12-09 09:51:55 +0100212 goto err;
Jean-Christophe PLAGNIOL-VILLARD68134632011-12-08 16:32:00 +0100213 }
Andrew Victor39a269c2006-01-22 10:32:13 -0800214
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800215 ohci_at91->sfr_regmap = at91_dt_syscon_sfr();
216 if (!ohci_at91->sfr_regmap)
217 dev_warn(dev, "failed to find sfr node\n");
218
Manjunath Goudare3825b42013-09-21 16:38:42 +0530219 board = hcd->self.controller->platform_data;
220 ohci = hcd_to_ohci(hcd);
221 ohci->num_ports = board->ports;
Andrew Victor39a269c2006-01-22 10:32:13 -0800222 at91_start_hc(pdev);
Andrew Victor39a269c2006-01-22 10:32:13 -0800223
Boris BREZILLONfb5f1832013-12-08 15:59:59 +0100224 retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
Arnd Bergmann1f53b482014-01-07 12:54:58 +0100225 if (retval == 0) {
Peter Chen3c9740a2013-11-05 10:46:02 +0800226 device_wakeup_enable(hcd->self.controller);
Andrew Victor39a269c2006-01-22 10:32:13 -0800227 return retval;
Peter Chen3c9740a2013-11-05 10:46:02 +0800228 }
Andrew Victor39a269c2006-01-22 10:32:13 -0800229
230 /* Error handling */
231 at91_stop_hc(pdev);
232
Boris BREZILLONcca2bbb2013-12-09 09:51:53 +0100233 err:
Andrew Victor39a269c2006-01-22 10:32:13 -0800234 usb_put_hcd(hcd);
235 return retval;
236}
237
238
Andrew Victor39a269c2006-01-22 10:32:13 -0800239/* may be called with controller, bus, and devices active */
240
241/**
David Brownell0365ee02006-06-19 14:27:20 -0700242 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
Andrew Victor39a269c2006-01-22 10:32:13 -0800243 * @dev: USB Host Controller being removed
244 * Context: !in_interrupt()
245 *
246 * Reverses the effect of usb_hcd_at91_probe(), first invoking
247 * the HCD's stop() method. It is always called from a thread
David Brownell0365ee02006-06-19 14:27:20 -0700248 * context, "rmmod" or something similar.
Andrew Victor39a269c2006-01-22 10:32:13 -0800249 *
250 */
Bill Pembertonfb4e98a2012-11-19 13:26:20 -0500251static void usb_hcd_at91_remove(struct usb_hcd *hcd,
David Brownell0365ee02006-06-19 14:27:20 -0700252 struct platform_device *pdev)
Andrew Victor39a269c2006-01-22 10:32:13 -0800253{
254 usb_remove_hcd(hcd);
255 at91_stop_hc(pdev);
Pete Zaitcev421b4bf2008-06-01 14:38:43 -0700256 usb_put_hcd(hcd);
Andrew Victor39a269c2006-01-22 10:32:13 -0800257}
258
259/*-------------------------------------------------------------------------*/
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200260static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
261{
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100262 if (!valid_port(port))
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200263 return;
264
Jean-Christophe PLAGNIOL-VILLARD8a7a49d2011-09-19 15:32:23 +0800265 if (!gpio_is_valid(pdata->vbus_pin[port]))
Jean-Christophe PLAGNIOL-VILLARD770f0ba2011-11-12 16:46:13 +0100266 return;
267
Jean-Christophe PLAGNIOL-VILLARD8134ff52011-12-08 16:32:01 +0100268 gpio_set_value(pdata->vbus_pin[port],
Nicolas Ferre1e7caf82012-03-21 14:38:55 +0100269 pdata->vbus_pin_active_low[port] ^ enable);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200270}
271
272static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
273{
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100274 if (!valid_port(port))
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200275 return -EINVAL;
276
Jean-Christophe PLAGNIOL-VILLARD8a7a49d2011-09-19 15:32:23 +0800277 if (!gpio_is_valid(pdata->vbus_pin[port]))
Jean-Christophe PLAGNIOL-VILLARD770f0ba2011-11-12 16:46:13 +0100278 return -EINVAL;
279
Jean-Christophe PLAGNIOL-VILLARD8134ff52011-12-08 16:32:01 +0100280 return gpio_get_value(pdata->vbus_pin[port]) ^
Nicolas Ferre1e7caf82012-03-21 14:38:55 +0100281 pdata->vbus_pin_active_low[port];
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200282}
283
284/*
285 * Update the status data from the hub with the over-current indicator change.
286 */
287static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
288{
Manjunath Goudare3825b42013-09-21 16:38:42 +0530289 struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
Laurent Pinchart42b59eb2014-04-16 18:00:09 +0200290 int length = ohci_hub_status_data(hcd, buf);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200291 int port;
292
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100293 at91_for_each_port(port) {
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200294 if (pdata->overcurrent_changed[port]) {
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100295 if (!length)
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200296 length = 1;
297 buf[0] |= 1 << (port + 1);
298 }
299 }
300
301 return length;
302}
303
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800304static int ohci_at91_port_suspend(struct regmap *regmap, u8 set)
305{
306 u32 regval;
307 int ret;
308
309 if (!regmap)
310 return 0;
311
312 ret = regmap_read(regmap, AT91_SFR_OHCIICR, &regval);
313 if (ret)
314 return ret;
315
316 if (set)
317 regval |= AT91_OHCIICR_USB_SUSPEND;
318 else
319 regval &= ~AT91_OHCIICR_USB_SUSPEND;
320
321 regmap_write(regmap, AT91_SFR_OHCIICR, regval);
322
323 return 0;
324}
325
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200326/*
327 * Look at the control requests to the root hub and see if we need to override.
328 */
329static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
330 u16 wIndex, char *buf, u16 wLength)
331{
Jingoo Hand4f09e22013-07-30 19:59:40 +0900332 struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller);
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800333 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200334 struct usb_hub_descriptor *desc;
335 int ret = -EINVAL;
336 u32 *data = (u32 *)buf;
337
338 dev_dbg(hcd->self.controller,
339 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
340 hcd, typeReq, wValue, wIndex, buf, wLength);
341
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100342 wIndex--;
343
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200344 switch (typeReq) {
345 case SetPortFeature:
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800346 switch (wValue) {
347 case USB_PORT_FEAT_POWER:
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200348 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100349 if (valid_port(wIndex)) {
350 ohci_at91_usb_set_power(pdata, wIndex, 1);
351 ret = 0;
352 }
353
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200354 goto out;
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800355
356 case USB_PORT_FEAT_SUSPEND:
357 dev_dbg(hcd->self.controller, "SetPortFeat: SUSPEND\n");
358 if (valid_port(wIndex)) {
359 ohci_at91_port_suspend(ohci_at91->sfr_regmap,
360 1);
361 return 0;
362 }
363 break;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200364 }
365 break;
366
367 case ClearPortFeature:
368 switch (wValue) {
369 case USB_PORT_FEAT_C_OVER_CURRENT:
370 dev_dbg(hcd->self.controller,
371 "ClearPortFeature: C_OVER_CURRENT\n");
372
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100373 if (valid_port(wIndex)) {
374 pdata->overcurrent_changed[wIndex] = 0;
375 pdata->overcurrent_status[wIndex] = 0;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200376 }
377
378 goto out;
379
380 case USB_PORT_FEAT_OVER_CURRENT:
381 dev_dbg(hcd->self.controller,
382 "ClearPortFeature: OVER_CURRENT\n");
383
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100384 if (valid_port(wIndex))
385 pdata->overcurrent_status[wIndex] = 0;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200386
387 goto out;
388
389 case USB_PORT_FEAT_POWER:
390 dev_dbg(hcd->self.controller,
391 "ClearPortFeature: POWER\n");
392
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100393 if (valid_port(wIndex)) {
394 ohci_at91_usb_set_power(pdata, wIndex, 0);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200395 return 0;
396 }
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800397 break;
398
399 case USB_PORT_FEAT_SUSPEND:
400 dev_dbg(hcd->self.controller, "ClearPortFeature: SUSPEND\n");
401 if (valid_port(wIndex)) {
402 ohci_at91_port_suspend(ohci_at91->sfr_regmap,
403 0);
404 return 0;
405 }
406 break;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200407 }
408 break;
409 }
410
Laurent Pinchart42b59eb2014-04-16 18:00:09 +0200411 ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200412 if (ret)
413 goto out;
414
415 switch (typeReq) {
416 case GetHubDescriptor:
417
418 /* update the hub's descriptor */
419
420 desc = (struct usb_hub_descriptor *)buf;
421
422 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
423 desc->wHubCharacteristics);
424
425 /* remove the old configurations for power-switching, and
426 * over-current protection, and insert our new configuration
427 */
428
429 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
Sergei Shtylyova9c49bc2015-01-19 01:39:44 +0300430 desc->wHubCharacteristics |=
431 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200432
433 if (pdata->overcurrent_supported) {
434 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
Sergei Shtylyova9c49bc2015-01-19 01:39:44 +0300435 desc->wHubCharacteristics |=
436 cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200437 }
438
439 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
440 desc->wHubCharacteristics);
441
442 return ret;
443
444 case GetPortStatus:
445 /* check port status */
446
447 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
448
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100449 if (valid_port(wIndex)) {
450 if (!ohci_at91_usb_get_power(pdata, wIndex))
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200451 *data &= ~cpu_to_le32(RH_PS_PPS);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200452
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100453 if (pdata->overcurrent_changed[wIndex])
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200454 *data |= cpu_to_le32(RH_PS_OCIC);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200455
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100456 if (pdata->overcurrent_status[wIndex])
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200457 *data |= cpu_to_le32(RH_PS_POCI);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200458 }
459 }
460
461 out:
462 return ret;
463}
464
Andrew Victor39a269c2006-01-22 10:32:13 -0800465/*-------------------------------------------------------------------------*/
466
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200467static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
468{
469 struct platform_device *pdev = data;
Jingoo Hand4f09e22013-07-30 19:59:40 +0900470 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev);
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200471 int val, gpio, port;
472
473 /* From the GPIO notifying the over-current situation, find
474 * out the corresponding port */
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100475 at91_for_each_port(port) {
Joachim Eastwood01bb6502012-09-23 22:56:00 +0200476 if (gpio_is_valid(pdata->overcurrent_pin[port]) &&
477 gpio_to_irq(pdata->overcurrent_pin[port]) == irq) {
Nicolas Ferree4499072012-02-11 14:23:06 +0100478 gpio = pdata->overcurrent_pin[port];
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200479 break;
Nicolas Ferree4499072012-02-11 14:23:06 +0100480 }
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200481 }
482
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100483 if (port == AT91_MAX_USBH_PORTS) {
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200484 dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
485 return IRQ_HANDLED;
486 }
487
488 val = gpio_get_value(gpio);
489
490 /* When notified of an over-current situation, disable power
491 on the corresponding port, and mark this port in
492 over-current. */
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100493 if (!val) {
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200494 ohci_at91_usb_set_power(pdata, port, 0);
495 pdata->overcurrent_status[port] = 1;
496 pdata->overcurrent_changed[port] = 1;
497 }
498
499 dev_dbg(& pdev->dev, "overcurrent situation %s\n",
500 val ? "exited" : "notified");
501
502 return IRQ_HANDLED;
503}
504
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800505static const struct of_device_id at91_ohci_dt_ids[] = {
506 { .compatible = "atmel,at91rm9200-ohci" },
507 { /* sentinel */ }
508};
509
510MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
511
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200512/*-------------------------------------------------------------------------*/
513
514static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800515{
516 struct device_node *np = pdev->dev.of_node;
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800517 struct at91_usbh_data *pdata;
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200518 int i;
519 int gpio;
520 int ret;
521 enum of_gpio_flags flags;
522 u32 ports;
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800523
524 /* Right now device-tree probed devices don't get dma_mask set.
525 * Since shared usb code relies on it, set it here for now.
526 * Once we have dma capability bindings this can go away.
527 */
Russell Kinge1fd7342013-06-27 12:36:37 +0100528 ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
Russell King22d9d8e2013-06-10 16:28:49 +0100529 if (ret)
530 return ret;
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800531
532 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
533 if (!pdata)
534 return -ENOMEM;
535
Alexandre Belloni4a0c4c32015-12-02 20:36:55 +0100536 pdev->dev.platform_data = pdata;
537
Jean-Christophe PLAGNIOL-VILLARD24197302011-11-21 06:55:18 +0800538 if (!of_property_read_u32(np, "num-ports", &ports))
539 pdata->ports = ports;
540
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100541 at91_for_each_port(i) {
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200542 /*
543 * do not configure PIO if not in relation with
544 * real USB port on board
545 */
546 if (i >= pdata->ports) {
547 pdata->vbus_pin[i] = -EINVAL;
Alexandre Belloni4a0c4c32015-12-02 20:36:55 +0100548 pdata->overcurrent_pin[i] = -EINVAL;
Alexandre Bellonie4df9222015-08-10 16:23:12 +0200549 continue;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200550 }
551
Alexandre Bellonie4df9222015-08-10 16:23:12 +0200552 gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i,
553 &flags);
554 pdata->vbus_pin[i] = gpio;
555 if (!gpio_is_valid(gpio))
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200556 continue;
Alexandre Bellonie4df9222015-08-10 16:23:12 +0200557 pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200558
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200559 ret = gpio_request(gpio, "ohci_vbus");
560 if (ret) {
561 dev_err(&pdev->dev,
562 "can't request vbus gpio %d\n", gpio);
563 continue;
564 }
565 ret = gpio_direction_output(gpio,
566 !pdata->vbus_pin_active_low[i]);
567 if (ret) {
568 dev_err(&pdev->dev,
569 "can't put vbus gpio %d as output %d\n",
570 gpio, !pdata->vbus_pin_active_low[i]);
571 gpio_free(gpio);
572 continue;
573 }
Nicolas Ferreaaf9f5f2012-03-21 16:58:11 +0100574
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200575 ohci_at91_usb_set_power(pdata, i, 1);
576 }
Nicolas Ferreaaf9f5f2012-03-21 16:58:11 +0100577
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200578 at91_for_each_port(i) {
Alexandre Belloni4a0c4c32015-12-02 20:36:55 +0100579 if (i >= pdata->ports)
580 break;
Alexandre Bellonie4df9222015-08-10 16:23:12 +0200581
582 pdata->overcurrent_pin[i] =
583 of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags);
584
Alexandre Bellonibd73bfc2015-08-10 16:23:11 +0200585 if (!gpio_is_valid(pdata->overcurrent_pin[i]))
586 continue;
587 gpio = pdata->overcurrent_pin[i];
588
589 ret = gpio_request(gpio, "ohci_overcurrent");
590 if (ret) {
591 dev_err(&pdev->dev,
592 "can't request overcurrent gpio %d\n",
593 gpio);
594 continue;
595 }
596
597 ret = gpio_direction_input(gpio);
598 if (ret) {
599 dev_err(&pdev->dev,
600 "can't configure overcurrent gpio %d as input\n",
601 gpio);
602 gpio_free(gpio);
603 continue;
604 }
605
606 ret = request_irq(gpio_to_irq(gpio),
607 ohci_hcd_at91_overcurrent_irq,
608 IRQF_SHARED, "ohci_overcurrent", pdev);
609 if (ret) {
610 gpio_free(gpio);
611 dev_err(&pdev->dev,
612 "can't get gpio IRQ for overcurrent\n");
David Brownell4bde4a42007-12-27 11:19:49 -0800613 }
614 }
615
David Brownell0365ee02006-06-19 14:27:20 -0700616 device_init_wakeup(&pdev->dev, 1);
617 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
Andrew Victor39a269c2006-01-22 10:32:13 -0800618}
619
Bill Pembertonfb4e98a2012-11-19 13:26:20 -0500620static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
Andrew Victor39a269c2006-01-22 10:32:13 -0800621{
Jingoo Hand4f09e22013-07-30 19:59:40 +0900622 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev);
David Brownell4bde4a42007-12-27 11:19:49 -0800623 int i;
624
625 if (pdata) {
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100626 at91_for_each_port(i) {
Jean-Christophe PLAGNIOL-VILLARD8a7a49d2011-09-19 15:32:23 +0800627 if (!gpio_is_valid(pdata->vbus_pin[i]))
David Brownell4bde4a42007-12-27 11:19:49 -0800628 continue;
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200629 ohci_at91_usb_set_power(pdata, i, 0);
David Brownell4bde4a42007-12-27 11:19:49 -0800630 gpio_free(pdata->vbus_pin[i]);
631 }
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200632
Nicolas Ferre0ee6d1e2012-03-21 16:53:09 +0100633 at91_for_each_port(i) {
Jean-Christophe PLAGNIOL-VILLARD8a7a49d2011-09-19 15:32:23 +0800634 if (!gpio_is_valid(pdata->overcurrent_pin[i]))
Thomas Petazzoniaa6e52a2011-07-13 11:29:17 +0200635 continue;
636 free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
637 gpio_free(pdata->overcurrent_pin[i]);
638 }
David Brownell4bde4a42007-12-27 11:19:49 -0800639 }
640
David Brownell0365ee02006-06-19 14:27:20 -0700641 device_init_wakeup(&pdev->dev, 0);
Pete Zaitcev421b4bf2008-06-01 14:38:43 -0700642 usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
643 return 0;
Andrew Victor39a269c2006-01-22 10:32:13 -0800644}
645
Arnd Bergmannd2905192016-03-02 16:24:05 +0100646static int __maybe_unused
Sylvain Rochet94ac0e52015-01-20 14:39:00 +0100647ohci_hcd_at91_drv_suspend(struct device *dev)
David Brownell68ba61b2006-04-02 20:26:21 -0800648{
Sylvain Rochet94ac0e52015-01-20 14:39:00 +0100649 struct usb_hcd *hcd = dev_get_drvdata(dev);
David Brownell0365ee02006-06-19 14:27:20 -0700650 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
Sylvain Rochet1b207452015-01-20 14:39:02 +0100651 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Majunath Goudara9d38402013-11-13 17:40:17 +0530652 int ret;
David Brownell0365ee02006-06-19 14:27:20 -0700653
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100654 /*
655 * Disable wakeup if we are going to sleep with slow clock mode
656 * enabled.
657 */
658 ohci_at91->wakeup = device_may_wakeup(dev)
659 && !at91_suspend_entering_slow_clock();
660
661 if (ohci_at91->wakeup)
David Brownell0365ee02006-06-19 14:27:20 -0700662 enable_irq_wake(hcd->irq);
David Brownell0365ee02006-06-19 14:27:20 -0700663
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800664 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 1);
665
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100666 ret = ohci_suspend(hcd, ohci_at91->wakeup);
Majunath Goudara9d38402013-11-13 17:40:17 +0530667 if (ret) {
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100668 if (ohci_at91->wakeup)
669 disable_irq_wake(hcd->irq);
Majunath Goudara9d38402013-11-13 17:40:17 +0530670 return ret;
671 }
David Brownell0365ee02006-06-19 14:27:20 -0700672 /*
673 * The integrated transceivers seem unable to notice disconnect,
674 * reconnect, or wakeup without the 48 MHz clock active. so for
675 * correctness, always discard connection state (using reset).
676 *
677 * REVISIT: some boards will be able to turn VBUS off...
678 */
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100679 if (!ohci_at91->wakeup) {
Manjunath Goudare3825b42013-09-21 16:38:42 +0530680 ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
681 ohci->hc_control &= OHCI_CTRL_RWC;
682 ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
683 ohci->rh_state = OHCI_RH_HALTED;
684
Patrice Vilchez869aa982010-04-28 13:45:40 +0200685 /* flush the writes */
686 (void) ohci_readl (ohci, &ohci->regs->control);
Sylvain Rochet1b207452015-01-20 14:39:02 +0100687 at91_stop_clock(ohci_at91);
David Brownell0365ee02006-06-19 14:27:20 -0700688 }
Andrew Victor39a269c2006-01-22 10:32:13 -0800689
Majunath Goudara9d38402013-11-13 17:40:17 +0530690 return ret;
Andrew Victor39a269c2006-01-22 10:32:13 -0800691}
692
Arnd Bergmannd2905192016-03-02 16:24:05 +0100693static int __maybe_unused
694ohci_hcd_at91_drv_resume(struct device *dev)
Andrew Victor39a269c2006-01-22 10:32:13 -0800695{
Sylvain Rochet94ac0e52015-01-20 14:39:00 +0100696 struct usb_hcd *hcd = dev_get_drvdata(dev);
Sylvain Rochet1b207452015-01-20 14:39:02 +0100697 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
Marc Pignat6dde8962007-01-09 14:00:11 -0800698
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100699 if (ohci_at91->wakeup)
Marc Pignat6dde8962007-01-09 14:00:11 -0800700 disable_irq_wake(hcd->irq);
701
Sylvain Rochet1cee6b82015-01-20 14:39:04 +0100702 at91_start_clock(ohci_at91);
Andrew Victor39a269c2006-01-22 10:32:13 -0800703
Florian Fainellicfa49b42012-10-08 15:11:29 +0200704 ohci_resume(hcd, false);
Wenyou Yang2e2aa1b2016-08-23 09:05:29 +0800705
706 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 0);
707
Andrew Victor39a269c2006-01-22 10:32:13 -0800708 return 0;
709}
Andrew Victor39a269c2006-01-22 10:32:13 -0800710
Sylvain Rochet94ac0e52015-01-20 14:39:00 +0100711static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops, ohci_hcd_at91_drv_suspend,
712 ohci_hcd_at91_drv_resume);
713
Andrew Victor39a269c2006-01-22 10:32:13 -0800714static struct platform_driver ohci_hcd_at91_driver = {
715 .probe = ohci_hcd_at91_drv_probe,
Bill Pemberton76904172012-11-19 13:21:08 -0500716 .remove = ohci_hcd_at91_drv_remove,
Aleksey Gorelov64a21d02006-08-08 17:24:08 -0700717 .shutdown = usb_hcd_platform_shutdown,
Andrew Victor39a269c2006-01-22 10:32:13 -0800718 .driver = {
David Brownell0365ee02006-06-19 14:27:20 -0700719 .name = "at91_ohci",
Sylvain Rochet94ac0e52015-01-20 14:39:00 +0100720 .pm = &ohci_hcd_at91_pm_ops,
Alexandre Bellonibe12be52015-08-10 16:23:10 +0200721 .of_match_table = at91_ohci_dt_ids,
Andrew Victor39a269c2006-01-22 10:32:13 -0800722 },
723};
Manjunath Goudare3825b42013-09-21 16:38:42 +0530724
725static int __init ohci_at91_init(void)
726{
727 if (usb_disabled())
728 return -ENODEV;
729
730 pr_info("%s: " DRIVER_DESC "\n", hcd_name);
Sylvain Rochet1b207452015-01-20 14:39:02 +0100731 ohci_init_driver(&ohci_at91_hc_driver, &ohci_at91_drv_overrides);
Manjunath Goudare3825b42013-09-21 16:38:42 +0530732
733 /*
734 * The Atmel HW has some unusual quirks, which require Atmel-specific
735 * workarounds. We override certain hc_driver functions here to
736 * achieve that. We explicitly do not enhance ohci_driver_overrides to
737 * allow this more easily, since this is an unusual case, and we don't
738 * want to encourage others to override these functions by making it
739 * too easy.
740 */
741
Manjunath Goudare3825b42013-09-21 16:38:42 +0530742 ohci_at91_hc_driver.hub_status_data = ohci_at91_hub_status_data;
743 ohci_at91_hc_driver.hub_control = ohci_at91_hub_control;
744
745 return platform_driver_register(&ohci_hcd_at91_driver);
746}
747module_init(ohci_at91_init);
748
749static void __exit ohci_at91_cleanup(void)
750{
751 platform_driver_unregister(&ohci_hcd_at91_driver);
752}
753module_exit(ohci_at91_cleanup);
754
755MODULE_DESCRIPTION(DRIVER_DESC);
756MODULE_LICENSE("GPL");
757MODULE_ALIAS("platform:at91_ohci");