Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 1 | /* |
| 2 | * Texas Instruments DSPS platforms "glue layer" |
| 3 | * |
| 4 | * Copyright (C) 2012, by Texas Instruments |
| 5 | * |
| 6 | * Based on the am35x "glue layer" code. |
| 7 | * |
| 8 | * This file is part of the Inventra Controller Driver for Linux. |
| 9 | * |
| 10 | * The Inventra Controller Driver for Linux is free software; you |
| 11 | * can redistribute it and/or modify it under the terms of the GNU |
| 12 | * General Public License version 2 as published by the Free Software |
| 13 | * Foundation. |
| 14 | * |
| 15 | * The Inventra Controller Driver for Linux is distributed in |
| 16 | * the hope that it will be useful, but WITHOUT ANY WARRANTY; |
| 17 | * without even the implied warranty of MERCHANTABILITY or |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public |
| 19 | * License for more details. |
| 20 | * |
| 21 | * You should have received a copy of the GNU General Public License |
| 22 | * along with The Inventra Controller Driver for Linux ; if not, |
| 23 | * write to the Free Software Foundation, Inc., 59 Temple Place, |
| 24 | * Suite 330, Boston, MA 02111-1307 USA |
| 25 | * |
| 26 | * musb_dsps.c will be a common file for all the TI DSPS platforms |
| 27 | * such as dm64x, dm36x, dm35x, da8x, am35x and ti81x. |
| 28 | * For now only ti81x is using this and in future davinci.c, am35x.c |
| 29 | * da8xx.c would be merged to this file after testing. |
| 30 | */ |
| 31 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 32 | #include <linux/io.h> |
Kishon Vijay Abraham I | ded017e | 2012-06-26 17:40:32 +0530 | [diff] [blame] | 33 | #include <linux/err.h> |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 34 | #include <linux/platform_device.h> |
| 35 | #include <linux/dma-mapping.h> |
| 36 | #include <linux/pm_runtime.h> |
| 37 | #include <linux/module.h> |
Felipe Balbi | d7078df | 2014-04-16 15:28:32 -0500 | [diff] [blame] | 38 | #include <linux/usb/usb_phy_generic.h> |
Felipe Balbi | e8c4a7a | 2012-10-24 14:26:19 -0700 | [diff] [blame] | 39 | #include <linux/platform_data/usb-omap.h> |
Felipe Balbi | 0f53e48 | 2013-02-06 09:47:58 +0200 | [diff] [blame] | 40 | #include <linux/sizes.h> |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 41 | |
| 42 | #include <linux/of.h> |
| 43 | #include <linux/of_device.h> |
| 44 | #include <linux/of_address.h> |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 45 | #include <linux/of_irq.h> |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 46 | #include <linux/usb/of.h> |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 47 | |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 48 | #include <linux/debugfs.h> |
| 49 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 50 | #include "musb_core.h" |
| 51 | |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 52 | static const struct of_device_id musb_dsps_of_match[]; |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 53 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 54 | /** |
| 55 | * avoid using musb_readx()/musb_writex() as glue layer should not be |
| 56 | * dependent on musb core layer symbols. |
| 57 | */ |
| 58 | static inline u8 dsps_readb(const void __iomem *addr, unsigned offset) |
Lothar Waßmann | fc7af21 | 2014-06-30 13:17:26 +0200 | [diff] [blame] | 59 | { |
| 60 | return __raw_readb(addr + offset); |
| 61 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 62 | |
| 63 | static inline u32 dsps_readl(const void __iomem *addr, unsigned offset) |
Lothar Waßmann | fc7af21 | 2014-06-30 13:17:26 +0200 | [diff] [blame] | 64 | { |
| 65 | return __raw_readl(addr + offset); |
| 66 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 67 | |
| 68 | static inline void dsps_writeb(void __iomem *addr, unsigned offset, u8 data) |
Lothar Waßmann | fc7af21 | 2014-06-30 13:17:26 +0200 | [diff] [blame] | 69 | { |
| 70 | __raw_writeb(data, addr + offset); |
| 71 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 72 | |
| 73 | static inline void dsps_writel(void __iomem *addr, unsigned offset, u32 data) |
Lothar Waßmann | fc7af21 | 2014-06-30 13:17:26 +0200 | [diff] [blame] | 74 | { |
| 75 | __raw_writel(data, addr + offset); |
| 76 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 77 | |
| 78 | /** |
| 79 | * DSPS musb wrapper register offset. |
| 80 | * FIXME: This should be expanded to have all the wrapper registers from TI DSPS |
| 81 | * musb ips. |
| 82 | */ |
| 83 | struct dsps_musb_wrapper { |
| 84 | u16 revision; |
| 85 | u16 control; |
| 86 | u16 status; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 87 | u16 epintr_set; |
| 88 | u16 epintr_clear; |
| 89 | u16 epintr_status; |
| 90 | u16 coreintr_set; |
| 91 | u16 coreintr_clear; |
| 92 | u16 coreintr_status; |
| 93 | u16 phy_utmi; |
| 94 | u16 mode; |
Daniel Mack | b991f9b | 2013-11-25 22:26:42 +0100 | [diff] [blame] | 95 | u16 tx_mode; |
| 96 | u16 rx_mode; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 97 | |
| 98 | /* bit positions for control */ |
| 99 | unsigned reset:5; |
| 100 | |
| 101 | /* bit positions for interrupt */ |
| 102 | unsigned usb_shift:5; |
| 103 | u32 usb_mask; |
| 104 | u32 usb_bitmap; |
| 105 | unsigned drvvbus:5; |
| 106 | |
| 107 | unsigned txep_shift:5; |
| 108 | u32 txep_mask; |
| 109 | u32 txep_bitmap; |
| 110 | |
| 111 | unsigned rxep_shift:5; |
| 112 | u32 rxep_mask; |
| 113 | u32 rxep_bitmap; |
| 114 | |
| 115 | /* bit positions for phy_utmi */ |
| 116 | unsigned otg_disable:5; |
| 117 | |
| 118 | /* bit positions for mode */ |
| 119 | unsigned iddig:5; |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 120 | unsigned iddig_mux:5; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 121 | /* miscellaneous stuff */ |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 122 | u8 poll_seconds; |
| 123 | }; |
| 124 | |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 125 | /* |
| 126 | * register shadow for suspend |
| 127 | */ |
| 128 | struct dsps_context { |
| 129 | u32 control; |
| 130 | u32 epintr; |
| 131 | u32 coreintr; |
| 132 | u32 phy_utmi; |
| 133 | u32 mode; |
| 134 | u32 tx_mode; |
| 135 | u32 rx_mode; |
| 136 | }; |
| 137 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 138 | /** |
| 139 | * DSPS glue structure. |
| 140 | */ |
| 141 | struct dsps_glue { |
| 142 | struct device *dev; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 143 | struct platform_device *musb; /* child musb pdev */ |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 144 | const struct dsps_musb_wrapper *wrp; /* wrapper register offsets */ |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 145 | struct timer_list timer; /* otg_workaround timer */ |
| 146 | unsigned long last_timer; /* last timer data for each instance */ |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 147 | bool sw_babble_enabled; |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 148 | |
| 149 | struct dsps_context context; |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 150 | struct debugfs_regset32 regset; |
| 151 | struct dentry *dbgfs_root; |
| 152 | }; |
| 153 | |
| 154 | static const struct debugfs_reg32 dsps_musb_regs[] = { |
| 155 | { "revision", 0x00 }, |
| 156 | { "control", 0x14 }, |
| 157 | { "status", 0x18 }, |
| 158 | { "eoi", 0x24 }, |
| 159 | { "intr0_stat", 0x30 }, |
| 160 | { "intr1_stat", 0x34 }, |
| 161 | { "intr0_set", 0x38 }, |
| 162 | { "intr1_set", 0x3c }, |
| 163 | { "txmode", 0x70 }, |
| 164 | { "rxmode", 0x74 }, |
| 165 | { "autoreq", 0xd0 }, |
| 166 | { "srpfixtime", 0xd4 }, |
| 167 | { "tdown", 0xd8 }, |
| 168 | { "phy_utmi", 0xe0 }, |
| 169 | { "mode", 0xe8 }, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 170 | }; |
| 171 | |
Sebastian Andrzej Siewior | 807d0d2 | 2013-10-15 18:29:24 +0200 | [diff] [blame] | 172 | static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout) |
| 173 | { |
| 174 | struct device *dev = musb->controller; |
| 175 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
| 176 | |
| 177 | if (timeout == 0) |
| 178 | timeout = jiffies + msecs_to_jiffies(3); |
| 179 | |
| 180 | /* Never idle if active, or when VBUS timeout is not set as host */ |
| 181 | if (musb->is_active || (musb->a_wait_bcon == 0 && |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 182 | musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) { |
Sebastian Andrzej Siewior | 807d0d2 | 2013-10-15 18:29:24 +0200 | [diff] [blame] | 183 | dev_dbg(musb->controller, "%s active, deleting timer\n", |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 184 | usb_otg_state_string(musb->xceiv->otg->state)); |
Sebastian Andrzej Siewior | 807d0d2 | 2013-10-15 18:29:24 +0200 | [diff] [blame] | 185 | del_timer(&glue->timer); |
| 186 | glue->last_timer = jiffies; |
| 187 | return; |
| 188 | } |
Sebastian Andrzej Siewior | 24616eb | 2013-10-15 18:29:26 +0200 | [diff] [blame] | 189 | if (musb->port_mode != MUSB_PORT_MODE_DUAL_ROLE) |
Sebastian Andrzej Siewior | 807d0d2 | 2013-10-15 18:29:24 +0200 | [diff] [blame] | 190 | return; |
| 191 | |
| 192 | if (!musb->g.dev.driver) |
| 193 | return; |
| 194 | |
| 195 | if (time_after(glue->last_timer, timeout) && |
| 196 | timer_pending(&glue->timer)) { |
| 197 | dev_dbg(musb->controller, |
| 198 | "Longer idle timer already pending, ignoring...\n"); |
| 199 | return; |
| 200 | } |
| 201 | glue->last_timer = timeout; |
| 202 | |
| 203 | dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 204 | usb_otg_state_string(musb->xceiv->otg->state), |
Sebastian Andrzej Siewior | 807d0d2 | 2013-10-15 18:29:24 +0200 | [diff] [blame] | 205 | jiffies_to_msecs(timeout - jiffies)); |
| 206 | mod_timer(&glue->timer, timeout); |
| 207 | } |
| 208 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 209 | /** |
| 210 | * dsps_musb_enable - enable interrupts |
| 211 | */ |
| 212 | static void dsps_musb_enable(struct musb *musb) |
| 213 | { |
| 214 | struct device *dev = musb->controller; |
| 215 | struct platform_device *pdev = to_platform_device(dev->parent); |
| 216 | struct dsps_glue *glue = platform_get_drvdata(pdev); |
| 217 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 218 | void __iomem *reg_base = musb->ctrl_base; |
| 219 | u32 epmask, coremask; |
| 220 | |
| 221 | /* Workaround: setup IRQs through both register sets. */ |
| 222 | epmask = ((musb->epmask & wrp->txep_mask) << wrp->txep_shift) | |
| 223 | ((musb->epmask & wrp->rxep_mask) << wrp->rxep_shift); |
| 224 | coremask = (wrp->usb_bitmap & ~MUSB_INTR_SOF); |
| 225 | |
| 226 | dsps_writel(reg_base, wrp->epintr_set, epmask); |
| 227 | dsps_writel(reg_base, wrp->coreintr_set, coremask); |
| 228 | /* Force the DRVVBUS IRQ so we can start polling for ID change. */ |
Felipe Balbi | 032ec49 | 2011-11-24 15:46:26 +0200 | [diff] [blame] | 229 | dsps_writel(reg_base, wrp->coreintr_set, |
| 230 | (1 << wrp->drvvbus) << wrp->usb_shift); |
Sebastian Andrzej Siewior | 8b9fcce | 2013-10-15 18:29:23 +0200 | [diff] [blame] | 231 | dsps_musb_try_idle(musb, 0); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | /** |
| 235 | * dsps_musb_disable - disable HDRC and flush interrupts |
| 236 | */ |
| 237 | static void dsps_musb_disable(struct musb *musb) |
| 238 | { |
| 239 | struct device *dev = musb->controller; |
| 240 | struct platform_device *pdev = to_platform_device(dev->parent); |
| 241 | struct dsps_glue *glue = platform_get_drvdata(pdev); |
| 242 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 243 | void __iomem *reg_base = musb->ctrl_base; |
| 244 | |
| 245 | dsps_writel(reg_base, wrp->coreintr_clear, wrp->usb_bitmap); |
| 246 | dsps_writel(reg_base, wrp->epintr_clear, |
| 247 | wrp->txep_bitmap | wrp->rxep_bitmap); |
| 248 | dsps_writeb(musb->mregs, MUSB_DEVCTL, 0); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | static void otg_timer(unsigned long _musb) |
| 252 | { |
| 253 | struct musb *musb = (void *)_musb; |
| 254 | void __iomem *mregs = musb->mregs; |
| 255 | struct device *dev = musb->controller; |
B, Ravi | db4a932 | 2012-08-31 11:09:51 +0000 | [diff] [blame] | 256 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 257 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 258 | u8 devctl; |
| 259 | unsigned long flags; |
Sebastian Andrzej Siewior | 0f901c9 | 2013-10-15 18:29:25 +0200 | [diff] [blame] | 260 | int skip_session = 0; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 261 | |
| 262 | /* |
| 263 | * We poll because DSPS IP's won't expose several OTG-critical |
| 264 | * status change events (from the transceiver) otherwise. |
| 265 | */ |
| 266 | devctl = dsps_readb(mregs, MUSB_DEVCTL); |
| 267 | dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 268 | usb_otg_state_string(musb->xceiv->otg->state)); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 269 | |
| 270 | spin_lock_irqsave(&musb->lock, flags); |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 271 | switch (musb->xceiv->otg->state) { |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 272 | case OTG_STATE_A_WAIT_BCON: |
Sebastian Andrzej Siewior | 0f901c9 | 2013-10-15 18:29:25 +0200 | [diff] [blame] | 273 | dsps_writeb(musb->mregs, MUSB_DEVCTL, 0); |
| 274 | skip_session = 1; |
| 275 | /* fall */ |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 276 | |
Sebastian Andrzej Siewior | 0f901c9 | 2013-10-15 18:29:25 +0200 | [diff] [blame] | 277 | case OTG_STATE_A_IDLE: |
| 278 | case OTG_STATE_B_IDLE: |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 279 | if (devctl & MUSB_DEVCTL_BDEVICE) { |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 280 | musb->xceiv->otg->state = OTG_STATE_B_IDLE; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 281 | MUSB_DEV_MODE(musb); |
| 282 | } else { |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 283 | musb->xceiv->otg->state = OTG_STATE_A_IDLE; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 284 | MUSB_HST_MODE(musb); |
| 285 | } |
Sebastian Andrzej Siewior | 0f901c9 | 2013-10-15 18:29:25 +0200 | [diff] [blame] | 286 | if (!(devctl & MUSB_DEVCTL_SESSION) && !skip_session) |
| 287 | dsps_writeb(mregs, MUSB_DEVCTL, MUSB_DEVCTL_SESSION); |
| 288 | mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 289 | break; |
| 290 | case OTG_STATE_A_WAIT_VFALL: |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 291 | musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 292 | dsps_writel(musb->ctrl_base, wrp->coreintr_set, |
| 293 | MUSB_INTR_VBUSERROR << wrp->usb_shift); |
| 294 | break; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 295 | default: |
| 296 | break; |
| 297 | } |
| 298 | spin_unlock_irqrestore(&musb->lock, flags); |
| 299 | } |
| 300 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 301 | static irqreturn_t dsps_interrupt(int irq, void *hci) |
| 302 | { |
| 303 | struct musb *musb = hci; |
| 304 | void __iomem *reg_base = musb->ctrl_base; |
| 305 | struct device *dev = musb->controller; |
B, Ravi | db4a932 | 2012-08-31 11:09:51 +0000 | [diff] [blame] | 306 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 307 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 308 | unsigned long flags; |
| 309 | irqreturn_t ret = IRQ_NONE; |
| 310 | u32 epintr, usbintr; |
| 311 | |
| 312 | spin_lock_irqsave(&musb->lock, flags); |
| 313 | |
| 314 | /* Get endpoint interrupts */ |
| 315 | epintr = dsps_readl(reg_base, wrp->epintr_status); |
| 316 | musb->int_rx = (epintr & wrp->rxep_bitmap) >> wrp->rxep_shift; |
| 317 | musb->int_tx = (epintr & wrp->txep_bitmap) >> wrp->txep_shift; |
| 318 | |
| 319 | if (epintr) |
| 320 | dsps_writel(reg_base, wrp->epintr_status, epintr); |
| 321 | |
| 322 | /* Get usb core interrupts */ |
| 323 | usbintr = dsps_readl(reg_base, wrp->coreintr_status); |
| 324 | if (!usbintr && !epintr) |
Sebastian Andrzej Siewior | 9be73ba | 2013-07-26 11:11:38 +0200 | [diff] [blame] | 325 | goto out; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 326 | |
| 327 | musb->int_usb = (usbintr & wrp->usb_bitmap) >> wrp->usb_shift; |
| 328 | if (usbintr) |
| 329 | dsps_writel(reg_base, wrp->coreintr_status, usbintr); |
| 330 | |
| 331 | dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n", |
| 332 | usbintr, epintr); |
Daniel Mack | 1d57de3 | 2014-04-02 13:58:29 +0200 | [diff] [blame] | 333 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 334 | if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) { |
| 335 | int drvvbus = dsps_readl(reg_base, wrp->status); |
| 336 | void __iomem *mregs = musb->mregs; |
| 337 | u8 devctl = dsps_readb(mregs, MUSB_DEVCTL); |
| 338 | int err; |
| 339 | |
Felipe Balbi | 032ec49 | 2011-11-24 15:46:26 +0200 | [diff] [blame] | 340 | err = musb->int_usb & MUSB_INTR_VBUSERROR; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 341 | if (err) { |
| 342 | /* |
| 343 | * The Mentor core doesn't debounce VBUS as needed |
| 344 | * to cope with device connect current spikes. This |
| 345 | * means it's not uncommon for bus-powered devices |
| 346 | * to get VBUS errors during enumeration. |
| 347 | * |
| 348 | * This is a workaround, but newer RTL from Mentor |
| 349 | * seems to allow a better one: "re"-starting sessions |
| 350 | * without waiting for VBUS to stop registering in |
| 351 | * devctl. |
| 352 | */ |
| 353 | musb->int_usb &= ~MUSB_INTR_VBUSERROR; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 354 | musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 355 | mod_timer(&glue->timer, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 356 | jiffies + wrp->poll_seconds * HZ); |
| 357 | WARNING("VBUS error workaround (delay coming)\n"); |
Felipe Balbi | 032ec49 | 2011-11-24 15:46:26 +0200 | [diff] [blame] | 358 | } else if (drvvbus) { |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 359 | MUSB_HST_MODE(musb); |
| 360 | musb->xceiv->otg->default_a = 1; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 361 | musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 362 | del_timer(&glue->timer); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 363 | } else { |
| 364 | musb->is_active = 0; |
| 365 | MUSB_DEV_MODE(musb); |
| 366 | musb->xceiv->otg->default_a = 0; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 367 | musb->xceiv->otg->state = OTG_STATE_B_IDLE; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | /* NOTE: this must complete power-on within 100 ms. */ |
| 371 | dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", |
| 372 | drvvbus ? "on" : "off", |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 373 | usb_otg_state_string(musb->xceiv->otg->state), |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 374 | err ? " ERROR" : "", |
| 375 | devctl); |
| 376 | ret = IRQ_HANDLED; |
| 377 | } |
| 378 | |
| 379 | if (musb->int_tx || musb->int_rx || musb->int_usb) |
| 380 | ret |= musb_interrupt(musb); |
| 381 | |
Bin Liu | 5ace3d0 | 2013-10-30 09:38:23 -0500 | [diff] [blame] | 382 | /* Poll for ID change in OTG port mode */ |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 383 | if (musb->xceiv->otg->state == OTG_STATE_B_IDLE && |
Bin Liu | 5ace3d0 | 2013-10-30 09:38:23 -0500 | [diff] [blame] | 384 | musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE) |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 385 | mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ); |
Sebastian Andrzej Siewior | 9be73ba | 2013-07-26 11:11:38 +0200 | [diff] [blame] | 386 | out: |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 387 | spin_unlock_irqrestore(&musb->lock, flags); |
| 388 | |
| 389 | return ret; |
| 390 | } |
| 391 | |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 392 | static int dsps_musb_dbg_init(struct musb *musb, struct dsps_glue *glue) |
| 393 | { |
| 394 | struct dentry *root; |
| 395 | struct dentry *file; |
| 396 | char buf[128]; |
| 397 | |
| 398 | sprintf(buf, "%s.dsps", dev_name(musb->controller)); |
| 399 | root = debugfs_create_dir(buf, NULL); |
| 400 | if (!root) |
| 401 | return -ENOMEM; |
| 402 | glue->dbgfs_root = root; |
| 403 | |
| 404 | glue->regset.regs = dsps_musb_regs; |
| 405 | glue->regset.nregs = ARRAY_SIZE(dsps_musb_regs); |
| 406 | glue->regset.base = musb->ctrl_base; |
| 407 | |
| 408 | file = debugfs_create_regset32("regdump", S_IRUGO, root, &glue->regset); |
| 409 | if (!file) { |
| 410 | debugfs_remove_recursive(root); |
| 411 | return -ENOMEM; |
| 412 | } |
| 413 | return 0; |
| 414 | } |
| 415 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 416 | static int dsps_musb_init(struct musb *musb) |
| 417 | { |
| 418 | struct device *dev = musb->controller; |
B, Ravi | db4a932 | 2012-08-31 11:09:51 +0000 | [diff] [blame] | 419 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 420 | struct platform_device *parent = to_platform_device(dev->parent); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 421 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 422 | void __iomem *reg_base; |
| 423 | struct resource *r; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 424 | u32 rev, val; |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 425 | int ret; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 426 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 427 | r = platform_get_resource_byname(parent, IORESOURCE_MEM, "control"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 428 | reg_base = devm_ioremap_resource(dev, r); |
Julia Lawall | 51ef74f | 2013-08-19 18:00:08 +0200 | [diff] [blame] | 429 | if (IS_ERR(reg_base)) |
| 430 | return PTR_ERR(reg_base); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 431 | musb->ctrl_base = reg_base; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 432 | |
Afzal Mohammed | d755422 | 2012-11-06 20:47:24 +0530 | [diff] [blame] | 433 | /* NOP driver needs change if supporting dual instance */ |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 434 | musb->xceiv = devm_usb_get_phy_by_phandle(dev, "phys", 0); |
| 435 | if (IS_ERR(musb->xceiv)) |
| 436 | return PTR_ERR(musb->xceiv); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 437 | |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 438 | musb->phy = devm_phy_get(dev->parent, "usb2-phy"); |
| 439 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 440 | /* Returns zero if e.g. not clocked */ |
| 441 | rev = dsps_readl(reg_base, wrp->revision); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 442 | if (!rev) |
| 443 | return -ENODEV; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 444 | |
Sebastian Andrzej Siewior | 7557a57 | 2013-07-22 20:09:52 +0200 | [diff] [blame] | 445 | usb_phy_init(musb->xceiv); |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 446 | if (IS_ERR(musb->phy)) { |
| 447 | musb->phy = NULL; |
| 448 | } else { |
| 449 | ret = phy_init(musb->phy); |
| 450 | if (ret < 0) |
| 451 | return ret; |
| 452 | ret = phy_power_on(musb->phy); |
| 453 | if (ret) { |
| 454 | phy_exit(musb->phy); |
| 455 | return ret; |
| 456 | } |
| 457 | } |
| 458 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 459 | setup_timer(&glue->timer, otg_timer, (unsigned long) musb); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 460 | |
| 461 | /* Reset the musb */ |
| 462 | dsps_writel(reg_base, wrp->control, (1 << wrp->reset)); |
| 463 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 464 | musb->isr = dsps_interrupt; |
| 465 | |
| 466 | /* reset the otgdisable bit, needed for host mode to work */ |
| 467 | val = dsps_readl(reg_base, wrp->phy_utmi); |
| 468 | val &= ~(1 << wrp->otg_disable); |
| 469 | dsps_writel(musb->ctrl_base, wrp->phy_utmi, val); |
| 470 | |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 471 | /* |
| 472 | * Check whether the dsps version has babble control enabled. |
| 473 | * In latest silicon revision the babble control logic is enabled. |
| 474 | * If MUSB_BABBLE_CTL returns 0x4 then we have the babble control |
| 475 | * logic enabled. |
| 476 | */ |
| 477 | val = dsps_readb(musb->mregs, MUSB_BABBLE_CTL); |
Felipe Balbi | f860f0b | 2015-02-26 11:01:03 -0600 | [diff] [blame^] | 478 | if (val & MUSB_BABBLE_RCV_DISABLE) { |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 479 | glue->sw_babble_enabled = true; |
| 480 | val |= MUSB_BABBLE_SW_SESSION_CTRL; |
| 481 | dsps_writeb(musb->mregs, MUSB_BABBLE_CTL, val); |
| 482 | } |
| 483 | |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 484 | ret = dsps_musb_dbg_init(musb, glue); |
| 485 | if (ret) |
| 486 | return ret; |
| 487 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 488 | return 0; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | static int dsps_musb_exit(struct musb *musb) |
| 492 | { |
| 493 | struct device *dev = musb->controller; |
B, Ravi | db4a932 | 2012-08-31 11:09:51 +0000 | [diff] [blame] | 494 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 495 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 496 | del_timer_sync(&glue->timer); |
Sebastian Andrzej Siewior | 7557a57 | 2013-07-22 20:09:52 +0200 | [diff] [blame] | 497 | usb_phy_shutdown(musb->xceiv); |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 498 | phy_power_off(musb->phy); |
| 499 | phy_exit(musb->phy); |
Daniel Mack | 0fca91b | 2014-04-02 11:46:51 +0200 | [diff] [blame] | 500 | debugfs_remove_recursive(glue->dbgfs_root); |
| 501 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 502 | return 0; |
| 503 | } |
| 504 | |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 505 | static int dsps_musb_set_mode(struct musb *musb, u8 mode) |
| 506 | { |
| 507 | struct device *dev = musb->controller; |
| 508 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
| 509 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 510 | void __iomem *ctrl_base = musb->ctrl_base; |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 511 | u32 reg; |
| 512 | |
Lothar Waßmann | 8035691 | 2014-06-30 13:17:27 +0200 | [diff] [blame] | 513 | reg = dsps_readl(ctrl_base, wrp->mode); |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 514 | |
| 515 | switch (mode) { |
| 516 | case MUSB_HOST: |
| 517 | reg &= ~(1 << wrp->iddig); |
| 518 | |
| 519 | /* |
| 520 | * if we're setting mode to host-only or device-only, we're |
| 521 | * going to ignore whatever the PHY sends us and just force |
| 522 | * ID pin status by SW |
| 523 | */ |
| 524 | reg |= (1 << wrp->iddig_mux); |
| 525 | |
Lothar Waßmann | 8035691 | 2014-06-30 13:17:27 +0200 | [diff] [blame] | 526 | dsps_writel(ctrl_base, wrp->mode, reg); |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 527 | dsps_writel(ctrl_base, wrp->phy_utmi, 0x02); |
| 528 | break; |
| 529 | case MUSB_PERIPHERAL: |
| 530 | reg |= (1 << wrp->iddig); |
| 531 | |
| 532 | /* |
| 533 | * if we're setting mode to host-only or device-only, we're |
| 534 | * going to ignore whatever the PHY sends us and just force |
| 535 | * ID pin status by SW |
| 536 | */ |
| 537 | reg |= (1 << wrp->iddig_mux); |
| 538 | |
Lothar Waßmann | 8035691 | 2014-06-30 13:17:27 +0200 | [diff] [blame] | 539 | dsps_writel(ctrl_base, wrp->mode, reg); |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 540 | break; |
| 541 | case MUSB_OTG: |
Lothar Waßmann | 8035691 | 2014-06-30 13:17:27 +0200 | [diff] [blame] | 542 | dsps_writel(ctrl_base, wrp->phy_utmi, 0x02); |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 543 | break; |
| 544 | default: |
| 545 | dev_err(glue->dev, "unsupported mode %d\n", mode); |
| 546 | return -EINVAL; |
| 547 | } |
| 548 | |
| 549 | return 0; |
| 550 | } |
| 551 | |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 552 | static bool sw_babble_control(struct musb *musb) |
| 553 | { |
| 554 | u8 babble_ctl; |
| 555 | bool session_restart = false; |
| 556 | |
| 557 | babble_ctl = dsps_readb(musb->mregs, MUSB_BABBLE_CTL); |
| 558 | dev_dbg(musb->controller, "babble: MUSB_BABBLE_CTL value %x\n", |
| 559 | babble_ctl); |
| 560 | /* |
| 561 | * check line monitor flag to check whether babble is |
| 562 | * due to noise |
| 563 | */ |
| 564 | dev_dbg(musb->controller, "STUCK_J is %s\n", |
| 565 | babble_ctl & MUSB_BABBLE_STUCK_J ? "set" : "reset"); |
| 566 | |
| 567 | if (babble_ctl & MUSB_BABBLE_STUCK_J) { |
| 568 | int timeout = 10; |
| 569 | |
| 570 | /* |
| 571 | * babble is due to noise, then set transmit idle (d7 bit) |
| 572 | * to resume normal operation |
| 573 | */ |
| 574 | babble_ctl = dsps_readb(musb->mregs, MUSB_BABBLE_CTL); |
| 575 | babble_ctl |= MUSB_BABBLE_FORCE_TXIDLE; |
| 576 | dsps_writeb(musb->mregs, MUSB_BABBLE_CTL, babble_ctl); |
| 577 | |
| 578 | /* wait till line monitor flag cleared */ |
| 579 | dev_dbg(musb->controller, "Set TXIDLE, wait J to clear\n"); |
| 580 | do { |
| 581 | babble_ctl = dsps_readb(musb->mregs, MUSB_BABBLE_CTL); |
| 582 | udelay(1); |
| 583 | } while ((babble_ctl & MUSB_BABBLE_STUCK_J) && timeout--); |
| 584 | |
| 585 | /* check whether stuck_at_j bit cleared */ |
| 586 | if (babble_ctl & MUSB_BABBLE_STUCK_J) { |
| 587 | /* |
| 588 | * real babble condition has occurred |
| 589 | * restart the controller to start the |
| 590 | * session again |
| 591 | */ |
| 592 | dev_dbg(musb->controller, "J not cleared, misc (%x)\n", |
| 593 | babble_ctl); |
| 594 | session_restart = true; |
| 595 | } |
| 596 | } else { |
| 597 | session_restart = true; |
| 598 | } |
| 599 | |
| 600 | return session_restart; |
| 601 | } |
| 602 | |
George Cherian | d871c62 | 2014-07-16 18:22:11 +0530 | [diff] [blame] | 603 | static int dsps_musb_reset(struct musb *musb) |
Daniel Mack | 1d57de3 | 2014-04-02 13:58:29 +0200 | [diff] [blame] | 604 | { |
| 605 | struct device *dev = musb->controller; |
| 606 | struct dsps_glue *glue = dev_get_drvdata(dev->parent); |
| 607 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 608 | int session_restart = 0, error; |
Daniel Mack | 1d57de3 | 2014-04-02 13:58:29 +0200 | [diff] [blame] | 609 | |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 610 | if (glue->sw_babble_enabled) |
| 611 | session_restart = sw_babble_control(musb); |
| 612 | /* |
| 613 | * In case of new silicon version babble condition can be recovered |
| 614 | * without resetting the MUSB. But for older silicon versions, MUSB |
| 615 | * reset is needed |
| 616 | */ |
| 617 | if (session_restart || !glue->sw_babble_enabled) { |
| 618 | dev_info(musb->controller, "Restarting MUSB to recover from Babble\n"); |
| 619 | dsps_writel(musb->ctrl_base, wrp->control, (1 << wrp->reset)); |
| 620 | usleep_range(100, 200); |
| 621 | usb_phy_shutdown(musb->xceiv); |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 622 | error = phy_power_off(musb->phy); |
| 623 | if (error) |
| 624 | dev_err(dev, "phy shutdown failed: %i\n", error); |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 625 | usleep_range(100, 200); |
| 626 | usb_phy_init(musb->xceiv); |
Tony Lindgren | bb90600 | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 627 | error = phy_power_on(musb->phy); |
| 628 | if (error) |
| 629 | dev_err(dev, "phy powerup failed: %i\n", error); |
George Cherian | 371254c | 2014-07-16 18:22:12 +0530 | [diff] [blame] | 630 | session_restart = 1; |
| 631 | } |
George Cherian | 5670017 | 2014-05-26 14:50:10 +0530 | [diff] [blame] | 632 | |
Felipe Balbi | d0cddae | 2015-02-26 10:55:13 -0600 | [diff] [blame] | 633 | return session_restart ? 0 : -EPIPE; |
Daniel Mack | 1d57de3 | 2014-04-02 13:58:29 +0200 | [diff] [blame] | 634 | } |
| 635 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 636 | static struct musb_platform_ops dsps_ops = { |
Tony Lindgren | d026e9c | 2014-11-24 11:05:03 -0800 | [diff] [blame] | 637 | .quirks = MUSB_INDEXED_EP, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 638 | .init = dsps_musb_init, |
| 639 | .exit = dsps_musb_exit, |
| 640 | |
| 641 | .enable = dsps_musb_enable, |
| 642 | .disable = dsps_musb_disable, |
| 643 | |
| 644 | .try_idle = dsps_musb_try_idle, |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 645 | .set_mode = dsps_musb_set_mode, |
Daniel Mack | 1d57de3 | 2014-04-02 13:58:29 +0200 | [diff] [blame] | 646 | .reset = dsps_musb_reset, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 647 | }; |
| 648 | |
| 649 | static u64 musb_dmamask = DMA_BIT_MASK(32); |
| 650 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 651 | static int get_int_prop(struct device_node *dn, const char *s) |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 652 | { |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 653 | int ret; |
| 654 | u32 val; |
| 655 | |
| 656 | ret = of_property_read_u32(dn, s, &val); |
| 657 | if (ret) |
| 658 | return 0; |
| 659 | return val; |
| 660 | } |
| 661 | |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 662 | static int get_musb_port_mode(struct device *dev) |
| 663 | { |
| 664 | enum usb_dr_mode mode; |
| 665 | |
| 666 | mode = of_usb_get_dr_mode(dev->of_node); |
| 667 | switch (mode) { |
| 668 | case USB_DR_MODE_HOST: |
| 669 | return MUSB_PORT_MODE_HOST; |
| 670 | |
| 671 | case USB_DR_MODE_PERIPHERAL: |
| 672 | return MUSB_PORT_MODE_GADGET; |
| 673 | |
| 674 | case USB_DR_MODE_UNKNOWN: |
| 675 | case USB_DR_MODE_OTG: |
| 676 | default: |
| 677 | return MUSB_PORT_MODE_DUAL_ROLE; |
Joe Perches | 2b84f92 | 2013-10-08 16:01:37 -0700 | [diff] [blame] | 678 | } |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 679 | } |
| 680 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 681 | static int dsps_create_musb_pdev(struct dsps_glue *glue, |
| 682 | struct platform_device *parent) |
| 683 | { |
| 684 | struct musb_hdrc_platform_data pdata; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 685 | struct resource resources[2]; |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 686 | struct resource *res; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 687 | struct device *dev = &parent->dev; |
| 688 | struct musb_hdrc_config *config; |
| 689 | struct platform_device *musb; |
| 690 | struct device_node *dn = parent->dev.of_node; |
Tony Lindgren | 606bf4d | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 691 | int ret, val; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 692 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 693 | memset(resources, 0, sizeof(resources)); |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 694 | res = platform_get_resource_byname(parent, IORESOURCE_MEM, "mc"); |
| 695 | if (!res) { |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 696 | dev_err(dev, "failed to get memory.\n"); |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 697 | return -EINVAL; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 698 | } |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 699 | resources[0] = *res; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 700 | |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 701 | res = platform_get_resource_byname(parent, IORESOURCE_IRQ, "mc"); |
| 702 | if (!res) { |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 703 | dev_err(dev, "failed to get irq.\n"); |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 704 | return -EINVAL; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 705 | } |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 706 | resources[1] = *res; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 707 | |
B, Ravi | 65b3d52 | 2012-08-31 11:09:49 +0000 | [diff] [blame] | 708 | /* allocate the child platform device */ |
Sebastian Andrzej Siewior | 2f77116 | 2012-10-31 16:12:43 +0100 | [diff] [blame] | 709 | musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO); |
B, Ravi | 65b3d52 | 2012-08-31 11:09:49 +0000 | [diff] [blame] | 710 | if (!musb) { |
| 711 | dev_err(dev, "failed to allocate musb device\n"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 712 | return -ENOMEM; |
B, Ravi | 65b3d52 | 2012-08-31 11:09:49 +0000 | [diff] [blame] | 713 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 714 | |
| 715 | musb->dev.parent = dev; |
| 716 | musb->dev.dma_mask = &musb_dmamask; |
| 717 | musb->dev.coherent_dma_mask = musb_dmamask; |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 718 | musb->dev.of_node = of_node_get(dn); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 719 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 720 | glue->musb = musb; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 721 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 722 | ret = platform_device_add_resources(musb, resources, |
| 723 | ARRAY_SIZE(resources)); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 724 | if (ret) { |
| 725 | dev_err(dev, "failed to add resources\n"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 726 | goto err; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 727 | } |
| 728 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 729 | config = devm_kzalloc(&parent->dev, sizeof(*config), GFP_KERNEL); |
| 730 | if (!config) { |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 731 | ret = -ENOMEM; |
| 732 | goto err; |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 733 | } |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 734 | pdata.config = config; |
| 735 | pdata.platform_ops = &dsps_ops; |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 736 | |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 737 | config->num_eps = get_int_prop(dn, "mentor,num-eps"); |
| 738 | config->ram_bits = get_int_prop(dn, "mentor,ram-bits"); |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 739 | config->host_port_deassert_reset_at_resume = 1; |
Sebastian Andrzej Siewior | c031a7d | 2013-08-20 18:35:47 +0200 | [diff] [blame] | 740 | pdata.mode = get_musb_port_mode(dev); |
| 741 | /* DT keeps this entry in mA, musb expects it as per USB spec */ |
| 742 | pdata.power = get_int_prop(dn, "mentor,power") / 2; |
Tony Lindgren | 606bf4d | 2015-02-04 06:28:49 -0800 | [diff] [blame] | 743 | |
| 744 | ret = of_property_read_u32(dn, "mentor,multipoint", &val); |
| 745 | if (!ret && val) |
| 746 | config->multipoint = true; |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 747 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 748 | ret = platform_device_add_data(musb, &pdata, sizeof(pdata)); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 749 | if (ret) { |
| 750 | dev_err(dev, "failed to add platform_data\n"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 751 | goto err; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 752 | } |
| 753 | |
| 754 | ret = platform_device_add(musb); |
| 755 | if (ret) { |
| 756 | dev_err(dev, "failed to register musb device\n"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 757 | goto err; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 758 | } |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 759 | return 0; |
| 760 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 761 | err: |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 762 | platform_device_put(musb); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 763 | return ret; |
| 764 | } |
| 765 | |
Bill Pemberton | 41ac7b3 | 2012-11-19 13:21:48 -0500 | [diff] [blame] | 766 | static int dsps_probe(struct platform_device *pdev) |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 767 | { |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 768 | const struct of_device_id *match; |
| 769 | const struct dsps_musb_wrapper *wrp; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 770 | struct dsps_glue *glue; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 771 | int ret; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 772 | |
Sebastian Andrzej Siewior | 4fc4b27 | 2013-10-01 14:31:53 +0200 | [diff] [blame] | 773 | if (!strcmp(pdev->name, "musb-hdrc")) |
| 774 | return -ENODEV; |
| 775 | |
Felipe Balbi | cc50603 | 2013-02-06 09:57:18 +0200 | [diff] [blame] | 776 | match = of_match_node(musb_dsps_of_match, pdev->dev.of_node); |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 777 | if (!match) { |
| 778 | dev_err(&pdev->dev, "fail to get matching of_match struct\n"); |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 779 | return -EINVAL; |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 780 | } |
| 781 | wrp = match->data; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 782 | |
| 783 | /* allocate glue */ |
Markus Pargmann | de9db57 | 2014-01-17 10:22:36 +0100 | [diff] [blame] | 784 | glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL); |
Peter Chen | 0816ea2 | 2014-10-14 15:56:11 +0800 | [diff] [blame] | 785 | if (!glue) |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 786 | return -ENOMEM; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 787 | |
| 788 | glue->dev = &pdev->dev; |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 789 | glue->wrp = wrp; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 790 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 791 | platform_set_drvdata(pdev, glue); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 792 | pm_runtime_enable(&pdev->dev); |
| 793 | |
| 794 | ret = pm_runtime_get_sync(&pdev->dev); |
| 795 | if (ret < 0) { |
| 796 | dev_err(&pdev->dev, "pm_runtime_get_sync FAILED"); |
Ajay Kumar Gupta | 0e38c4e | 2012-07-03 17:37:11 +0530 | [diff] [blame] | 797 | goto err2; |
| 798 | } |
| 799 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 800 | ret = dsps_create_musb_pdev(glue, pdev); |
| 801 | if (ret) |
| 802 | goto err3; |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 803 | |
| 804 | return 0; |
| 805 | |
| 806 | err3: |
Ajay Kumar Gupta | 0e38c4e | 2012-07-03 17:37:11 +0530 | [diff] [blame] | 807 | pm_runtime_put(&pdev->dev); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 808 | err2: |
Ajay Kumar Gupta | 0e38c4e | 2012-07-03 17:37:11 +0530 | [diff] [blame] | 809 | pm_runtime_disable(&pdev->dev); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 810 | return ret; |
| 811 | } |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 812 | |
Bill Pemberton | fb4e98a | 2012-11-19 13:26:20 -0500 | [diff] [blame] | 813 | static int dsps_remove(struct platform_device *pdev) |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 814 | { |
| 815 | struct dsps_glue *glue = platform_get_drvdata(pdev); |
| 816 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 817 | platform_device_unregister(glue->musb); |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 818 | |
| 819 | /* disable usbss clocks */ |
| 820 | pm_runtime_put(&pdev->dev); |
| 821 | pm_runtime_disable(&pdev->dev); |
Markus Pargmann | 40f099e | 2014-01-17 10:22:35 +0100 | [diff] [blame] | 822 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 823 | return 0; |
| 824 | } |
| 825 | |
Sebastian Andrzej Siewior | fa7b4ca | 2013-07-26 11:11:37 +0200 | [diff] [blame] | 826 | static const struct dsps_musb_wrapper am33xx_driver_data = { |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 827 | .revision = 0x00, |
| 828 | .control = 0x14, |
| 829 | .status = 0x18, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 830 | .epintr_set = 0x38, |
| 831 | .epintr_clear = 0x40, |
| 832 | .epintr_status = 0x30, |
| 833 | .coreintr_set = 0x3c, |
| 834 | .coreintr_clear = 0x44, |
| 835 | .coreintr_status = 0x34, |
| 836 | .phy_utmi = 0xe0, |
| 837 | .mode = 0xe8, |
Daniel Mack | b991f9b | 2013-11-25 22:26:42 +0100 | [diff] [blame] | 838 | .tx_mode = 0x70, |
| 839 | .rx_mode = 0x74, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 840 | .reset = 0, |
| 841 | .otg_disable = 21, |
| 842 | .iddig = 8, |
Felipe Balbi | 943c139 | 2013-10-29 12:17:16 -0500 | [diff] [blame] | 843 | .iddig_mux = 7, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 844 | .usb_shift = 0, |
| 845 | .usb_mask = 0x1ff, |
| 846 | .usb_bitmap = (0x1ff << 0), |
| 847 | .drvvbus = 8, |
| 848 | .txep_shift = 0, |
| 849 | .txep_mask = 0xffff, |
| 850 | .txep_bitmap = (0xffff << 0), |
| 851 | .rxep_shift = 16, |
| 852 | .rxep_mask = 0xfffe, |
| 853 | .rxep_bitmap = (0xfffe << 16), |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 854 | .poll_seconds = 2, |
| 855 | }; |
| 856 | |
Bill Pemberton | 2f82686 | 2012-11-19 13:25:20 -0500 | [diff] [blame] | 857 | static const struct of_device_id musb_dsps_of_match[] = { |
Ajay Kumar Gupta | 6514567 | 2012-08-31 11:09:53 +0000 | [diff] [blame] | 858 | { .compatible = "ti,musb-am33xx", |
Sebastian Andrzej Siewior | fa7b4ca | 2013-07-26 11:11:37 +0200 | [diff] [blame] | 859 | .data = (void *) &am33xx_driver_data, }, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 860 | { }, |
| 861 | }; |
| 862 | MODULE_DEVICE_TABLE(of, musb_dsps_of_match); |
| 863 | |
Wolfram Sang | 5b78398 | 2014-04-17 10:20:32 +0200 | [diff] [blame] | 864 | #ifdef CONFIG_PM_SLEEP |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 865 | static int dsps_suspend(struct device *dev) |
| 866 | { |
| 867 | struct dsps_glue *glue = dev_get_drvdata(dev); |
| 868 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 869 | struct musb *musb = platform_get_drvdata(glue->musb); |
Sebastian Andrzej Siewior | f042e9c | 2014-10-13 11:04:21 +0200 | [diff] [blame] | 870 | void __iomem *mbase; |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 871 | |
Felipe Balbi | 468bcc2 | 2014-09-15 09:03:24 -0500 | [diff] [blame] | 872 | del_timer_sync(&glue->timer); |
Sebastian Andrzej Siewior | f042e9c | 2014-10-13 11:04:21 +0200 | [diff] [blame] | 873 | |
| 874 | if (!musb) |
| 875 | /* This can happen if the musb device is in -EPROBE_DEFER */ |
| 876 | return 0; |
| 877 | |
| 878 | mbase = musb->ctrl_base; |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 879 | glue->context.control = dsps_readl(mbase, wrp->control); |
| 880 | glue->context.epintr = dsps_readl(mbase, wrp->epintr_set); |
| 881 | glue->context.coreintr = dsps_readl(mbase, wrp->coreintr_set); |
| 882 | glue->context.phy_utmi = dsps_readl(mbase, wrp->phy_utmi); |
| 883 | glue->context.mode = dsps_readl(mbase, wrp->mode); |
| 884 | glue->context.tx_mode = dsps_readl(mbase, wrp->tx_mode); |
| 885 | glue->context.rx_mode = dsps_readl(mbase, wrp->rx_mode); |
| 886 | |
| 887 | return 0; |
| 888 | } |
| 889 | |
| 890 | static int dsps_resume(struct device *dev) |
| 891 | { |
| 892 | struct dsps_glue *glue = dev_get_drvdata(dev); |
| 893 | const struct dsps_musb_wrapper *wrp = glue->wrp; |
| 894 | struct musb *musb = platform_get_drvdata(glue->musb); |
Sebastian Andrzej Siewior | f042e9c | 2014-10-13 11:04:21 +0200 | [diff] [blame] | 895 | void __iomem *mbase; |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 896 | |
Sebastian Andrzej Siewior | f042e9c | 2014-10-13 11:04:21 +0200 | [diff] [blame] | 897 | if (!musb) |
| 898 | return 0; |
| 899 | |
| 900 | mbase = musb->ctrl_base; |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 901 | dsps_writel(mbase, wrp->control, glue->context.control); |
| 902 | dsps_writel(mbase, wrp->epintr_set, glue->context.epintr); |
| 903 | dsps_writel(mbase, wrp->coreintr_set, glue->context.coreintr); |
| 904 | dsps_writel(mbase, wrp->phy_utmi, glue->context.phy_utmi); |
| 905 | dsps_writel(mbase, wrp->mode, glue->context.mode); |
| 906 | dsps_writel(mbase, wrp->tx_mode, glue->context.tx_mode); |
| 907 | dsps_writel(mbase, wrp->rx_mode, glue->context.rx_mode); |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 908 | if (musb->xceiv->otg->state == OTG_STATE_B_IDLE && |
Sebastian Andrzej Siewior | 53185b3 | 2014-10-13 12:16:13 +0200 | [diff] [blame] | 909 | musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE) |
| 910 | mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ); |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 911 | |
| 912 | return 0; |
| 913 | } |
| 914 | #endif |
| 915 | |
| 916 | static SIMPLE_DEV_PM_OPS(dsps_pm_ops, dsps_suspend, dsps_resume); |
| 917 | |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 918 | static struct platform_driver dsps_usbss_driver = { |
| 919 | .probe = dsps_probe, |
Bill Pemberton | 7690417 | 2012-11-19 13:21:08 -0500 | [diff] [blame] | 920 | .remove = dsps_remove, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 921 | .driver = { |
| 922 | .name = "musb-dsps", |
Daniel Mack | 869c597 | 2013-11-26 13:31:14 +0100 | [diff] [blame] | 923 | .pm = &dsps_pm_ops, |
Sachin Kamat | b432cb8 | 2013-09-30 09:44:44 +0530 | [diff] [blame] | 924 | .of_match_table = musb_dsps_of_match, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 925 | }, |
Ajay Kumar Gupta | 9ecb887 | 2012-03-12 19:30:22 +0530 | [diff] [blame] | 926 | }; |
| 927 | |
| 928 | MODULE_DESCRIPTION("TI DSPS MUSB Glue Layer"); |
| 929 | MODULE_AUTHOR("Ravi B <ravibabu@ti.com>"); |
| 930 | MODULE_AUTHOR("Ajay Kumar Gupta <ajay.gupta@ti.com>"); |
| 931 | MODULE_LICENSE("GPL v2"); |
| 932 | |
Sebastian Andrzej Siewior | 97238b3 | 2013-07-05 14:51:33 +0200 | [diff] [blame] | 933 | module_platform_driver(dsps_usbss_driver); |