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