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 | |
| 80 | static const struct ehci_driver_overrides ehci_ci_overrides = { |
| 81 | .extra_priv_size = sizeof(struct ehci_ci_priv), |
| 82 | .port_power = ehci_ci_portpower, |
| 83 | }; |
| 84 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 85 | static irqreturn_t host_irq(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 86 | { |
| 87 | return usb_hcd_irq(ci->irq, ci->hcd); |
| 88 | } |
| 89 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 90 | static int host_start(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 91 | { |
| 92 | struct usb_hcd *hcd; |
| 93 | struct ehci_hcd *ehci; |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 94 | struct ehci_ci_priv *priv; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 95 | int ret; |
| 96 | |
| 97 | if (usb_disabled()) |
| 98 | return -ENODEV; |
| 99 | |
| 100 | hcd = usb_create_hcd(&ci_ehci_hc_driver, ci->dev, dev_name(ci->dev)); |
| 101 | if (!hcd) |
| 102 | return -ENOMEM; |
| 103 | |
Peter Chen | 24c498d | 2014-12-24 11:33:17 +0800 | [diff] [blame] | 104 | dev_set_drvdata(ci->dev, ci); |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 105 | hcd->rsrc_start = ci->hw_bank.phys; |
| 106 | hcd->rsrc_len = ci->hw_bank.size; |
| 107 | hcd->regs = ci->hw_bank.abs; |
| 108 | hcd->has_tt = 1; |
| 109 | |
Richard Zhao | 77c4400 | 2012-06-29 17:48:53 +0800 | [diff] [blame] | 110 | hcd->power_budget = ci->platdata->power_budget; |
Peter Chen | f6a9ff0 | 2014-08-19 09:51:56 +0800 | [diff] [blame] | 111 | hcd->tpl_support = ci->platdata->tpl_support; |
Antoine Tenart | 1e5e2d3 | 2014-10-30 18:41:19 +0100 | [diff] [blame] | 112 | if (ci->phy) |
| 113 | hcd->phy = ci->phy; |
| 114 | else |
| 115 | hcd->usb_phy = ci->usb_phy; |
Alexander Shishkin | bd84198 | 2012-05-11 17:25:55 +0300 | [diff] [blame] | 116 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 117 | ehci = hcd_to_ehci(hcd); |
| 118 | ehci->caps = ci->hw_bank.cap; |
| 119 | ehci->has_hostpc = ci->hw_bank.lpm; |
Tuomas Tynkkynen | 2cdcec4 | 2013-08-12 16:06:49 +0300 | [diff] [blame] | 120 | ehci->has_tdi_phy_lpm = ci->hw_bank.lpm; |
Peter Chen | ed8f831 | 2014-01-10 13:51:27 +0800 | [diff] [blame] | 121 | ehci->imx28_write_fix = ci->imx28_write_fix; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 122 | |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 123 | priv = (struct ehci_ci_priv *)ehci->priv; |
| 124 | priv->reg_vbus = NULL; |
| 125 | |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 126 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) { |
| 127 | if (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON) { |
| 128 | ret = regulator_enable(ci->platdata->reg_vbus); |
| 129 | if (ret) { |
| 130 | dev_err(ci->dev, |
| 131 | "Failed to enable vbus regulator, ret=%d\n", |
| 132 | ret); |
| 133 | goto put_hcd; |
| 134 | } |
| 135 | } else { |
| 136 | priv->reg_vbus = ci->platdata->reg_vbus; |
| 137 | } |
| 138 | } |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 139 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 140 | ret = usb_add_hcd(hcd, 0, 0); |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 141 | if (ret) { |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 142 | goto disable_reg; |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 143 | } else { |
Antoine Tenart | ef44cb4 | 2014-10-30 18:41:16 +0100 | [diff] [blame] | 144 | struct usb_otg *otg = &ci->otg; |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 145 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 146 | ci->hcd = hcd; |
Antoine Tenart | ef44cb4 | 2014-10-30 18:41:16 +0100 | [diff] [blame] | 147 | |
| 148 | if (ci_otg_is_fsm_mode(ci)) { |
Li Jun | 0698b9b | 2014-04-23 15:56:46 +0800 | [diff] [blame] | 149 | otg->host = &hcd->self; |
| 150 | hcd->self.otg_port = 1; |
| 151 | } |
| 152 | } |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 153 | |
Peter Chen | bf9c85e | 2015-03-17 10:40:50 +0800 | [diff] [blame] | 154 | ci_platform_configure(ci); |
Peter Chen | 2836267 | 2015-06-18 11:51:53 +0800 | [diff] [blame] | 155 | |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 156 | return ret; |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 157 | |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 158 | disable_reg: |
| 159 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) && |
| 160 | (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON)) |
| 161 | regulator_disable(ci->platdata->reg_vbus); |
Peter Chen | 40ed51a | 2013-08-14 12:44:04 +0300 | [diff] [blame] | 162 | put_hcd: |
| 163 | usb_put_hcd(hcd); |
| 164 | |
| 165 | return ret; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 166 | } |
| 167 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 168 | static void host_stop(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 169 | { |
| 170 | struct usb_hcd *hcd = ci->hcd; |
| 171 | |
Russell King - ARM Linux | 41314fe | 2013-10-16 13:45:15 +0100 | [diff] [blame] | 172 | if (hcd) { |
| 173 | usb_remove_hcd(hcd); |
| 174 | usb_put_hcd(hcd); |
Li Jun | 6594591 | 2015-02-11 12:45:02 +0800 | [diff] [blame] | 175 | if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) && |
| 176 | (ci->platdata->flags & CI_HDRC_TURN_VBUS_EARLY_ON)) |
| 177 | regulator_disable(ci->platdata->reg_vbus); |
Russell King - ARM Linux | 41314fe | 2013-10-16 13:45:15 +0100 | [diff] [blame] | 178 | } |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 179 | } |
| 180 | |
Peter Chen | 3f124d2 | 2013-08-14 12:44:07 +0300 | [diff] [blame] | 181 | |
| 182 | void ci_hdrc_host_destroy(struct ci_hdrc *ci) |
| 183 | { |
Peter Chen | df101c5 | 2013-10-22 11:13:41 +0800 | [diff] [blame] | 184 | if (ci->role == CI_ROLE_HOST && ci->hcd) |
Peter Chen | 3f124d2 | 2013-08-14 12:44:07 +0300 | [diff] [blame] | 185 | host_stop(ci); |
| 186 | } |
| 187 | |
Peter Chen | 78f0357 | 2015-02-11 12:44:59 +0800 | [diff] [blame] | 188 | static int ci_ehci_bus_suspend(struct usb_hcd *hcd) |
| 189 | { |
| 190 | struct ehci_hcd *ehci = hcd_to_ehci(hcd); |
| 191 | int port; |
| 192 | u32 tmp; |
| 193 | |
| 194 | int ret = orig_bus_suspend(hcd); |
| 195 | |
| 196 | if (ret) |
| 197 | return ret; |
| 198 | |
| 199 | port = HCS_N_PORTS(ehci->hcs_params); |
| 200 | while (port--) { |
| 201 | u32 __iomem *reg = &ehci->regs->port_status[port]; |
| 202 | u32 portsc = ehci_readl(ehci, reg); |
| 203 | |
| 204 | if (portsc & PORT_CONNECT) { |
| 205 | /* |
| 206 | * For chipidea, the resume signal will be ended |
| 207 | * automatically, so for remote wakeup case, the |
| 208 | * usbcmd.rs may not be set before the resume has |
| 209 | * ended if other resume paths consumes too much |
| 210 | * time (~24ms), in that case, the SOF will not |
| 211 | * send out within 3ms after resume ends, then the |
| 212 | * high speed device will enter full speed mode. |
| 213 | */ |
| 214 | |
| 215 | tmp = ehci_readl(ehci, &ehci->regs->command); |
| 216 | tmp |= CMD_RUN; |
| 217 | ehci_writel(ehci, tmp, &ehci->regs->command); |
| 218 | /* |
| 219 | * It needs a short delay between set RS bit and PHCD. |
| 220 | */ |
| 221 | usleep_range(150, 200); |
| 222 | break; |
| 223 | } |
| 224 | } |
| 225 | |
| 226 | return 0; |
| 227 | } |
| 228 | |
Alexander Shishkin | 8e22978 | 2013-06-24 14:46:36 +0300 | [diff] [blame] | 229 | int ci_hdrc_host_init(struct ci_hdrc *ci) |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 230 | { |
| 231 | struct ci_role_driver *rdrv; |
| 232 | |
| 233 | if (!hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_HC)) |
| 234 | return -ENXIO; |
| 235 | |
| 236 | rdrv = devm_kzalloc(ci->dev, sizeof(struct ci_role_driver), GFP_KERNEL); |
| 237 | if (!rdrv) |
| 238 | return -ENOMEM; |
| 239 | |
| 240 | rdrv->start = host_start; |
| 241 | rdrv->stop = host_stop; |
| 242 | rdrv->irq = host_irq; |
| 243 | rdrv->name = "host"; |
| 244 | ci->roles[CI_ROLE_HOST] = rdrv; |
| 245 | |
Peter Chen | 2f01a33 | 2015-07-21 09:51:29 +0800 | [diff] [blame] | 246 | return 0; |
| 247 | } |
| 248 | |
| 249 | void ci_hdrc_host_driver_init(void) |
| 250 | { |
Michael Grzeschik | c8679a2 | 2014-10-13 09:53:04 +0800 | [diff] [blame] | 251 | ehci_init_driver(&ci_ehci_hc_driver, &ehci_ci_overrides); |
Peter Chen | 78f0357 | 2015-02-11 12:44:59 +0800 | [diff] [blame] | 252 | orig_bus_suspend = ci_ehci_hc_driver.bus_suspend; |
| 253 | ci_ehci_hc_driver.bus_suspend = ci_ehci_bus_suspend; |
Alexander Shishkin | eb70e5a | 2012-05-11 17:25:54 +0300 | [diff] [blame] | 254 | } |