Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 1 | /* |
| 2 | * host.c - ChipIdea USB host controller driver |
| 3 | * |
| 4 | * Copyright (c) 2012 Intel Corporation |
| 5 | * |
| 6 | * Author: Alexander Shishkin |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 20 | */ |
| 21 | |
| 22 | #include <linux/kernel.h> |
Alan Stern | cdb2fac | 2012-11-03 12:39:27 -0400 | [diff] [blame] | 23 | #include <linux/io.h> |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 24 | #include <linux/usb.h> |
| 25 | #include <linux/usb/hcd.h> |
| 26 | #include <linux/usb/chipidea.h> |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 27 | #include <linux/regulator/consumer.h> |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 28 | |
Alan Stern | 09f6ffd | 2012-11-02 12:34:41 -0400 | [diff] [blame] | 29 | #include "../host/ehci.h" |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 30 | |
| 31 | #include "ci.h" |
| 32 | #include "bits.h" |
| 33 | #include "host.h" |
| 34 | |
Alan Stern | 09f6ffd | 2012-11-02 12:34:41 -0400 | [diff] [blame] | 35 | static struct hc_driver __read_mostly ci_ehci_hc_driver; |
Peter Chen | 78f0357 | 2015-02-11 12:44:59 +0800 | [diff] [blame] | 36 | static int (*orig_bus_suspend)(struct usb_hcd *hcd); |
Alan Stern | 09f6ffd | 2012-11-02 12:34:41 -0400 | [diff] [blame] | 37 | |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 38 | struct ehci_ci_priv { |
| 39 | struct regulator *reg_vbus; |
| 40 | }; |
| 41 | |
| 42 | static int ehci_ci_portpower(struct usb_hcd *hcd, int portnum, bool enable) |
| 43 | { |
| 44 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
| 45 | struct ehci_ci_priv *priv = (struct ehci_ci_priv *)ehci->priv; |
| 46 | struct device *dev = hcd->self.controller; |
Peter Chen | 1311d6e | 2015-07-14 15:43:02 +0800 | [diff] [blame] | 47 | struct ci_hdrc *ci = dev_get_drvdata(dev); |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 48 | int ret = 0; |
| 49 | int port = HCS_N_PORTS(ehci->hcs_params); |
| 50 | |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 51 | if (priv->reg_vbus) { |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 52 | if (port > 1) { |
| 53 | dev_warn(dev, |
| 54 | "Not support multi-port regulator control\n"); |
| 55 | return 0; |
| 56 | } |
| 57 | if (enable) |
| 58 | ret = regulator_enable(priv->reg_vbus); |
| 59 | else |
| 60 | ret = regulator_disable(priv->reg_vbus); |
| 61 | if (ret) { |
| 62 | dev_err(dev, |
| 63 | "Failed to %s vbus regulator, ret=%d\n", |
| 64 | enable ? "enable" : "disable", ret); |
| 65 | return ret; |
| 66 | } |
| 67 | } |
Rob Herring | fc6b68b | 2015-05-29 11:38:46 -0500 | [diff] [blame] | 68 | |
| 69 | if (enable && (ci->platdata->phy_mode == USBPHY_INTERFACE_MODE_HSIC)) { |
| 70 | /* |
| 71 | * Marvell 28nm HSIC PHY requires forcing the port to HS mode. |
| 72 | * As HSIC is always HS, this should be safe for others. |
| 73 | */ |
| 74 | hw_port_test_set(ci, 5); |
| 75 | hw_port_test_set(ci, 0); |
| 76 | } |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 77 | return 0; |
| 78 | }; |
| 79 | |
Peter Chen | 11a2709 | 2015-08-05 10:16:19 +0800 | [diff] [blame] | 80 | static int ehci_ci_reset(struct usb_hcd *hcd) |
| 81 | { |
| 82 | struct device *dev = hcd->self.controller; |
| 83 | struct ci_hdrc *ci = dev_get_drvdata(dev); |
Lucas Stach | c744a0d | 2016-08-15 16:09:07 +0200 | [diff] [blame] | 84 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
Peter Chen | 11a2709 | 2015-08-05 10:16:19 +0800 | [diff] [blame] | 85 | int ret; |
| 86 | |
| 87 | ret = ehci_setup(hcd); |
| 88 | if (ret) |
| 89 | return ret; |
| 90 | |
Lucas Stach | c744a0d | 2016-08-15 16:09:07 +0200 | [diff] [blame] | 91 | ehci->need_io_watchdog = 0; |
| 92 | |
Peter Chen | 11a2709 | 2015-08-05 10:16:19 +0800 | [diff] [blame] | 93 | ci_platform_configure(ci); |
| 94 | |
| 95 | return ret; |
| 96 | } |
| 97 | |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 98 | static const struct ehci_driver_overrides ehci_ci_overrides = { |
| 99 | .extra_priv_size = sizeof(struct ehci_ci_priv), |
| 100 | .port_power = ehci_ci_portpower, |
Peter Chen | 11a2709 | 2015-08-05 10:16:19 +0800 | [diff] [blame] | 101 | .reset = ehci_ci_reset, |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 102 | }; |
| 103 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 104 | static irqreturn_t host_irq(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 105 | { |
| 106 | return usb_hcd_irq(ci->irq, ci->hcd); |
| 107 | } |
| 108 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 109 | static int host_start(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 110 | { |
| 111 | struct usb_hcd *hcd; |
| 112 | struct ehci_hcd *ehci; |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 113 | struct ehci_ci_priv *priv; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 114 | int ret; |
| 115 | |
| 116 | if (usb_disabled()) |
| 117 | return -ENODEV; |
| 118 | |
| 119 | hcd = usb_create_hcd(&ci_ehci_hc_driver, ci->dev, dev_name(ci->dev)); |
| 120 | if (!hcd) |
| 121 | return -ENOMEM; |
| 122 | |
Peter Chen | 24c498d | 2014-12-24 11:33:17 +0800 | [diff] [blame] | 123 | dev_set_drvdata(ci->dev, ci); |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 124 | hcd->rsrc_start = ci->hw_bank.phys; |
| 125 | hcd->rsrc_len = ci->hw_bank.size; |
| 126 | hcd->regs = ci->hw_bank.abs; |
| 127 | hcd->has_tt = 1; |
| 128 | |
Richard Zhao | 77c4400 | 2012-06-29 17:48:53 +0800 | [diff] [blame] | 129 | hcd->power_budget = ci->platdata->power_budget; |
Peter Chen | f6a9ff0 | 2014-08-19 09:51:56 +0800 | [diff] [blame] | 130 | hcd->tpl_support = ci->platdata->tpl_support; |
Antoine Tenart | 1e5e2d3 | 2014-10-30 18:41:19 +0100 | [diff] [blame] | 131 | if (ci->phy) |
| 132 | hcd->phy = ci->phy; |
| 133 | else |
| 134 | hcd->usb_phy = ci->usb_phy; |
Alexander Shishkin | bd84198 | 2012-05-11 17:25:55 +0300 | [diff] [blame] | 135 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 136 | ehci = hcd_to_ehci(hcd); |
| 137 | ehci->caps = ci->hw_bank.cap; |
| 138 | ehci->has_hostpc = ci->hw_bank.lpm; |
Tuomas Tynkkynen | 2cdcec4 | 2013-08-12 16:06:49 +0300 | [diff] [blame] | 139 | ehci->has_tdi_phy_lpm = ci->hw_bank.lpm; |
Peter Chen | ed8f831 | 2014-01-10 13:51:27 +0800 | [diff] [blame] | 140 | ehci->imx28_write_fix = ci->imx28_write_fix; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 141 | |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 142 | priv = (struct ehci_ci_priv *)ehci->priv; |
| 143 | priv->reg_vbus = NULL; |
| 144 | |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 145 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) { |
| 146 | if (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON) { |
| 147 | ret = regulator_enable(ci->platdata->reg_vbus); |
| 148 | if (ret) { |
| 149 | dev_err(ci->dev, |
| 150 | "Failed to enable vbus regulator, ret=%d\n", |
| 151 | ret); |
| 152 | goto put_hcd; |
| 153 | } |
| 154 | } else { |
| 155 | priv->reg_vbus = ci->platdata->reg_vbus; |
| 156 | } |
| 157 | } |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 158 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 159 | ret = usb_add_hcd(hcd, 0, 0); |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 160 | if (ret) { |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 161 | goto disable_reg; |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 162 | } else { |
Antoine Tenart | ef44cb4 | 2014-10-30 18:41:16 +0100 | [diff] [blame] | 163 | struct usb_otg *otg = &ci->otg; |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 164 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 165 | ci->hcd = hcd; |
Antoine Tenart | ef44cb4 | 2014-10-30 18:41:16 +0100 | [diff] [blame] | 166 | |
| 167 | if (ci_otg_is_fsm_mode(ci)) { |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 168 | otg->host = &hcd->self; |
| 169 | hcd->self.otg_port = 1; |
| 170 | } |
| 171 | } |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 172 | |
| 173 | return ret; |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 174 | |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 175 | disable_reg: |
| 176 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) && |
| 177 | (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON)) |
| 178 | regulator_disable(ci->platdata->reg_vbus); |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 179 | put_hcd: |
| 180 | usb_put_hcd(hcd); |
| 181 | |
| 182 | return ret; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 183 | } |
| 184 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 185 | static void host_stop(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 186 | { |
| 187 | struct usb_hcd *hcd = ci->hcd; |
| 188 | |
Russell King - ARM Linux | 41314fe | 2013-10-16 13:45:15 +0100 | [diff] [blame] | 189 | if (hcd) { |
| 190 | usb_remove_hcd(hcd); |
| 191 | usb_put_hcd(hcd); |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 192 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) && |
| 193 | (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON)) |
| 194 | regulator_disable(ci->platdata->reg_vbus); |
Russell King - ARM Linux | 41314fe | 2013-10-16 13:45:15 +0100 | [diff] [blame] | 195 | } |
Li Jun | 43a4045 | 2015-12-15 17:47:47 +0800 | [diff] [blame] | 196 | ci->hcd = NULL; |
| 197 | ci->otg.host = NULL; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 198 | } |
| 199 | |
Peter Chen | 3f124d2 | 2013-08-14 12:44:07 +0300 | [diff] [blame] | 200 | |
| 201 | void ci_hdrc_host_destroy(struct ci_hdrc *ci) |
| 202 | { |
Peter Chen | df101c5 | 2013-10-22 11:13:41 +0800 | [diff] [blame] | 203 | if (ci->role == CI_ROLE_HOST && ci->hcd) |
Peter Chen | 3f124d2 | 2013-08-14 12:44:07 +0300 | [diff] [blame] | 204 | host_stop(ci); |
| 205 | } |
| 206 | |
Peter Chen | 78f0357 | 2015-02-11 12:44:59 +0800 | [diff] [blame] | 207 | static int ci_ehci_bus_suspend(struct usb_hcd *hcd) |
| 208 | { |
| 209 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
| 210 | int port; |
| 211 | u32 tmp; |
| 212 | |
| 213 | int ret = orig_bus_suspend(hcd); |
| 214 | |
| 215 | if (ret) |
| 216 | return ret; |
| 217 | |
| 218 | port = HCS_N_PORTS(ehci->hcs_params); |
| 219 | while (port--) { |
| 220 | u32 __iomem *reg = &ehci->regs->port_status[port]; |
| 221 | u32 portsc = ehci_readl(ehci, reg); |
| 222 | |
| 223 | if (portsc & PORT_CONNECT) { |
| 224 | /* |
| 225 | * For chipidea, the resume signal will be ended |
| 226 | * automatically, so for remote wakeup case, the |
| 227 | * usbcmd.rs may not be set before the resume has |
| 228 | * ended if other resume paths consumes too much |
| 229 | * time (~24ms), in that case, the SOF will not |
| 230 | * send out within 3ms after resume ends, then the |
| 231 | * high speed device will enter full speed mode. |
| 232 | */ |
| 233 | |
| 234 | tmp = ehci_readl(ehci, &ehci->regs->command); |
| 235 | tmp |= CMD_RUN; |
| 236 | ehci_writel(ehci, tmp, &ehci->regs->command); |
| 237 | /* |
| 238 | * It needs a short delay between set RS bit and PHCD. |
| 239 | */ |
| 240 | usleep_range(150, 200); |
| 241 | break; |
| 242 | } |
| 243 | } |
| 244 | |
| 245 | return 0; |
| 246 | } |
| 247 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 248 | int ci_hdrc_host_init(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 249 | { |
| 250 | struct ci_role_driver *rdrv; |
| 251 | |
| 252 | if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_HC)) |
| 253 | return -ENXIO; |
| 254 | |
| 255 | rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL); |
| 256 | if (!rdrv) |
| 257 | return -ENOMEM; |
| 258 | |
| 259 | rdrv->start = host_start; |
| 260 | rdrv->stop = host_stop; |
| 261 | rdrv->irq = host_irq; |
| 262 | rdrv->name = "host"; |
| 263 | ci->roles[CI_ROLE_HOST] = rdrv; |
| 264 | |
Peter Chen | 2f01a33 | 2015-07-21 09:51:29 +0800 | [diff] [blame] | 265 | return 0; |
| 266 | } |
| 267 | |
| 268 | void ci_hdrc_host_driver_init(void) |
| 269 | { |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 270 | ehci_init_driver(&ci_ehci_hc_driver, &ehci_ci_overrides); |
Peter Chen | 78f0357 | 2015-02-11 12:44:59 +0800 | [diff] [blame] | 271 | orig_bus_suspend = ci_ehci_hc_driver.bus_suspend; |
| 272 | ci_ehci_hc_driver.bus_suspend = ci_ehci_bus_suspend; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 273 | } |