drivers/usb/renesas_usbhs/mod.c

   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_dtch)
 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 }