1 // SPDX-License-Identifier: GPL-1.0+ 2 /* 3 * Renesas USB driver 4 * 5 * Copyright (C) 2011 Renesas Solutions Corp. 6 * Copyright (C) 2019 Renesas Electronics Corporation 7 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 8 */ 9 #include <linux/interrupt.h> 10 11 #include "common.h" 12 #include "mod.h" 13 14 /* 15 * autonomy 16 * 17 * these functions are used if platform doesn't have external phy. 18 * -> there is no "notify_hotplug" callback from platform 19 * -> call "notify_hotplug" by itself 20 * -> use own interrupt to connect/disconnect 21 * -> it mean module clock is always ON 22 * ~~~~~~~~~~~~~~~~~~~~~~~~~ 23 */ 24 static int usbhsm_autonomy_get_vbus(struct platform_device *pdev) 25 { 26 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 27 28 return VBSTS & usbhs_read(priv, INTSTS0); 29 } 30 31 static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv, 32 struct usbhs_irq_state *irq_state) 33 { 34 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 35 36 usbhsc_schedule_notify_hotplug(pdev); 37 38 return 0; 39 } 40 41 void usbhs_mod_autonomy_mode(struct usbhs_priv *priv) 42 { 43 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 44 45 info->irq_vbus = usbhsm_autonomy_irq_vbus; 46 info->get_vbus = usbhsm_autonomy_get_vbus; 47 48 usbhs_irq_callback_update(priv, NULL); 49 } 50 51 void usbhs_mod_non_autonomy_mode(struct usbhs_priv *priv) 52 { 53 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 54 55 info->get_vbus = priv->pfunc->get_vbus; 56 } 57 58 /* 59 * host / gadget functions 60 * 61 * renesas_usbhs host/gadget can register itself by below functions. 62 * these functions are called when probe 63 * 64 */ 65 void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id) 66 { 67 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 68 69 info->mod[id] = mod; 70 mod->priv = priv; 71 } 72 73 struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id) 74 { 75 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 76 struct usbhs_mod *ret = NULL; 77 78 switch (id) { 79 case USBHS_HOST: 80 case USBHS_GADGET: 81 ret = info->mod[id]; 82 break; 83 } 84 85 return ret; 86 } 87 88 int usbhs_mod_is_host(struct usbhs_priv *priv) 89 { 90 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 91 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 92 93 if (!mod) 94 return -EINVAL; 95 96 return info->mod[USBHS_HOST] == mod; 97 } 98 99 struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv) 100 { 101 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 102 103 return info->curt; 104 } 105 106 int usbhs_mod_change(struct usbhs_priv *priv, int id) 107 { 108 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 109 struct usbhs_mod *mod = NULL; 110 int ret = 0; 111 112 /* id < 0 mean no current */ 113 switch (id) { 114 case USBHS_HOST: 115 case USBHS_GADGET: 116 mod = info->mod[id]; 117 break; 118 default: 119 ret = -EINVAL; 120 } 121 info->curt = mod; 122 123 return ret; 124 } 125 126 static irqreturn_t usbhs_interrupt(int irq, void *data); 127 int usbhs_mod_probe(struct usbhs_priv *priv) 128 { 129 struct device *dev = usbhs_priv_to_dev(priv); 130 int ret; 131 132 /* 133 * install host/gadget driver 134 */ 135 ret = usbhs_mod_host_probe(priv); 136 if (ret < 0) 137 return ret; 138 139 ret = usbhs_mod_gadget_probe(priv); 140 if (ret < 0) 141 goto mod_init_host_err; 142 143 /* irq settings */ 144 ret = devm_request_irq(dev, priv->irq, usbhs_interrupt, 145 priv->irqflags, dev_name(dev), priv); 146 if (ret) { 147 dev_err(dev, "irq request err\n"); 148 goto mod_init_gadget_err; 149 } 150 151 return ret; 152 153 mod_init_gadget_err: 154 usbhs_mod_gadget_remove(priv); 155 mod_init_host_err: 156 usbhs_mod_host_remove(priv); 157 158 return ret; 159 } 160 161 void usbhs_mod_remove(struct usbhs_priv *priv) 162 { 163 usbhs_mod_host_remove(priv); 164 usbhs_mod_gadget_remove(priv); 165 } 166 167 /* 168 * status functions 169 */ 170 int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state) 171 { 172 return (int)irq_state->intsts0 & DVSQ_MASK; 173 } 174 175 int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state) 176 { 177 /* 178 * return value 179 * 180 * IDLE_SETUP_STAGE 181 * READ_DATA_STAGE 182 * READ_STATUS_STAGE 183 * WRITE_DATA_STAGE 184 * WRITE_STATUS_STAGE 185 * NODATA_STATUS_STAGE 186 * SEQUENCE_ERROR 187 */ 188 return (int)irq_state->intsts0 & CTSQ_MASK; 189 } 190 191 static int usbhs_status_get_each_irq(struct usbhs_priv *priv, 192 struct usbhs_irq_state *state) 193 { 194 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 195 u16 intenb0, intenb1; 196 unsigned long flags; 197 198 /******************** spin lock ********************/ 199 usbhs_lock(priv, flags); 200 state->intsts0 = usbhs_read(priv, INTSTS0); 201 intenb0 = usbhs_read(priv, INTENB0); 202 203 if (usbhs_mod_is_host(priv)) { 204 state->intsts1 = usbhs_read(priv, INTSTS1); 205 intenb1 = usbhs_read(priv, INTENB1); 206 } else { 207 state->intsts1 = intenb1 = 0; 208 } 209 210 /* mask */ 211 if (mod) { 212 state->brdysts = usbhs_read(priv, BRDYSTS); 213 state->nrdysts = usbhs_read(priv, NRDYSTS); 214 state->bempsts = usbhs_read(priv, BEMPSTS); 215 216 state->bempsts &= mod->irq_bempsts; 217 state->brdysts &= mod->irq_brdysts; 218 } 219 usbhs_unlock(priv, flags); 220 /******************** spin unlock ******************/ 221 222 /* 223 * Check whether the irq enable registers and the irq status are set 224 * when IRQF_SHARED is set. 225 */ 226 if (priv->irqflags & IRQF_SHARED) { 227 if (!(intenb0 & state->intsts0) && 228 !(intenb1 & state->intsts1) && 229 !(state->bempsts) && 230 !(state->brdysts)) 231 return -EIO; 232 } 233 234 return 0; 235 } 236 237 /* 238 * interrupt 239 */ 240 #define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */ 241 #define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */ 242 static irqreturn_t usbhs_interrupt(int irq, void *data) 243 { 244 struct usbhs_priv *priv = data; 245 struct usbhs_irq_state irq_state; 246 247 if (usbhs_status_get_each_irq(priv, &irq_state) < 0) 248 return IRQ_NONE; 249 250 /* 251 * clear interrupt 252 * 253 * The hardware is _very_ picky to clear interrupt bit. 254 * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value. 255 * 256 * see 257 * "Operation" 258 * - "Control Transfer (DCP)" 259 * - Function :: VALID bit should 0 260 */ 261 usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC); 262 if (usbhs_mod_is_host(priv)) 263 usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC); 264 265 /* 266 * The driver should not clear the xxxSTS after the line of 267 * "call irq callback functions" because each "if" statement is 268 * possible to call the callback function for avoiding any side effects. 269 */ 270 if (irq_state.intsts0 & BRDY) 271 usbhs_write(priv, BRDYSTS, ~irq_state.brdysts); 272 usbhs_write(priv, NRDYSTS, ~irq_state.nrdysts); 273 if (irq_state.intsts0 & BEMP) 274 usbhs_write(priv, BEMPSTS, ~irq_state.bempsts); 275 276 /* 277 * call irq callback functions 278 * see also 279 * usbhs_irq_setting_update 280 */ 281 282 /* INTSTS0 */ 283 if (irq_state.intsts0 & VBINT) 284 usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state); 285 286 if (irq_state.intsts0 & DVST) 287 usbhs_mod_call(priv, irq_dev_state, priv, &irq_state); 288 289 if (irq_state.intsts0 & CTRT) 290 usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state); 291 292 if (irq_state.intsts0 & BEMP) 293 usbhs_mod_call(priv, irq_empty, priv, &irq_state); 294 295 if (irq_state.intsts0 & BRDY) 296 usbhs_mod_call(priv, irq_ready, priv, &irq_state); 297 298 if (usbhs_mod_is_host(priv)) { 299 /* INTSTS1 */ 300 if (irq_state.intsts1 & ATTCH) 301 usbhs_mod_call(priv, irq_attch, priv, &irq_state); 302 303 if (irq_state.intsts1 & DTCH) 304 usbhs_mod_call(priv, irq_dtch, priv, &irq_state); 305 306 if (irq_state.intsts1 & SIGN) 307 usbhs_mod_call(priv, irq_sign, priv, &irq_state); 308 309 if (irq_state.intsts1 & SACK) 310 usbhs_mod_call(priv, irq_sack, priv, &irq_state); 311 } 312 return IRQ_HANDLED; 313 } 314 315 void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod) 316 { 317 u16 intenb0 = 0; 318 u16 intenb1 = 0; 319 struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv); 320 321 /* 322 * BEMPENB/BRDYENB are picky. 323 * below method is required 324 * 325 * - clear INTSTS0 326 * - update BEMPENB/BRDYENB 327 * - update INTSTS0 328 */ 329 usbhs_write(priv, INTENB0, 0); 330 if (usbhs_mod_is_host(priv)) 331 usbhs_write(priv, INTENB1, 0); 332 333 usbhs_write(priv, BEMPENB, 0); 334 usbhs_write(priv, BRDYENB, 0); 335 336 /* 337 * see also 338 * usbhs_interrupt 339 */ 340 341 if (info->irq_vbus) 342 intenb0 |= VBSE; 343 344 if (mod) { 345 /* 346 * INTSTS0 347 */ 348 if (mod->irq_ctrl_stage) 349 intenb0 |= CTRE; 350 351 if (mod->irq_dev_state) 352 intenb0 |= DVSE; 353 354 if (mod->irq_empty && mod->irq_bempsts) { 355 usbhs_write(priv, BEMPENB, mod->irq_bempsts); 356 intenb0 |= BEMPE; 357 } 358 359 if (mod->irq_ready && mod->irq_brdysts) { 360 usbhs_write(priv, BRDYENB, mod->irq_brdysts); 361 intenb0 |= BRDYE; 362 } 363 364 if (usbhs_mod_is_host(priv)) { 365 /* 366 * INTSTS1 367 */ 368 if (mod->irq_attch) 369 intenb1 |= ATTCHE; 370 371 if (mod->irq_dtch) 372 intenb1 |= DTCHE; 373 374 if (mod->irq_sign) 375 intenb1 |= SIGNE; 376 377 if (mod->irq_sack) 378 intenb1 |= SACKE; 379 } 380 } 381 382 if (intenb0) 383 usbhs_write(priv, INTENB0, intenb0); 384 385 if (usbhs_mod_is_host(priv) && intenb1) 386 usbhs_write(priv, INTENB1, intenb1); 387 } 388