drivers/usb/renesas_usbhs/mod.c

   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 }