drivers/usb/cdns3/drd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence USBSS DRD Driver.
   4  *
   5  * Copyright (C) 2018-2019 Cadence.
   6  * Copyright (C) 2019 Texas Instruments
   7  *
   8  * Author: Pawel Laszczak <pawell@cadence.com>
   9  *         Roger Quadros <rogerq@ti.com>
  10  *
  11  *
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/delay.h>
  16 #include <linux/iopoll.h>
  17 #include <linux/usb/otg.h>
  18 #include <linux/phy/phy.h>
  19
  20 #include "gadget.h"
  21 #include "drd.h"
  22 #include "core.h"
  23
  24 /**
  25  * cdns3_set_mode - change mode of OTG Core
  26  * @cdns: pointer to context structure
  27  * @mode: selected mode from cdns_role
  28  *
  29  * Returns 0 on success otherwise negative errno
  30  */
  31 int cdns3_set_mode(struct cdns3 *cdns, enum usb_dr_mode mode)
  32 {
  33         u32 reg;
  34
  35         switch (mode) {
  36         case USB_DR_MODE_PERIPHERAL:
  37                 break;
  38         case USB_DR_MODE_HOST:
  39                 break;
  40         case USB_DR_MODE_OTG:
  41                 dev_dbg(cdns->dev, "Set controller to OTG mode\n");
  42                 if (cdns->version == CDNS3_CONTROLLER_V1) {
  43                         reg = readl(&cdns->otg_v1_regs->override);
  44                         reg |= OVERRIDE_IDPULLUP;
  45                         writel(reg, &cdns->otg_v1_regs->override);
  46
  47                         /*
  48                          * Enable work around feature built into the
  49                          * controller to address issue with RX Sensitivity
  50                          * est (EL_17) for USB2 PHY. The issue only occures
  51                          * for 0x0002450D controller version.
  52                          */
  53                         if (cdns->phyrst_a_enable) {
  54                                 reg = readl(&cdns->otg_v1_regs->phyrst_cfg);
  55                                 reg |= PHYRST_CFG_PHYRST_A_ENABLE;
  56                                 writel(reg, &cdns->otg_v1_regs->phyrst_cfg);
  57                         }
  58                 } else {
  59                         reg = readl(&cdns->otg_v0_regs->ctrl1);
  60                         reg |= OVERRIDE_IDPULLUP_V0;
  61                         writel(reg, &cdns->otg_v0_regs->ctrl1);
  62                 }
  63
  64                 /*
  65                  * Hardware specification says: "ID_VALUE must be valid within
  66                  * 50ms after idpullup is set to '1" so driver must wait
  67                  * 50ms before reading this pin.
  68                  */
  69                 usleep_range(50000, 60000);
  70                 break;
  71         default:
  72                 dev_err(cdns->dev, "Unsupported mode of operation %d\n", mode);
  73                 return -EINVAL;
  74         }
  75
  76         return 0;
  77 }
  78
  79 int cdns3_get_id(struct cdns3 *cdns)
  80 {
  81         int id;
  82
  83         id = readl(&cdns->otg_regs->sts) & OTGSTS_ID_VALUE;
  84         dev_dbg(cdns->dev, "OTG ID: %d", id);
  85
  86         return id;
  87 }
  88
  89 int cdns3_get_vbus(struct cdns3 *cdns)
  90 {
  91         int vbus;
  92
  93         vbus = !!(readl(&cdns->otg_regs->sts) & OTGSTS_VBUS_VALID);
  94         dev_dbg(cdns->dev, "OTG VBUS: %d", vbus);
  95
  96         return vbus;
  97 }
  98
  99 bool cdns3_is_host(struct cdns3 *cdns)
 100 {
 101         if (cdns->dr_mode == USB_DR_MODE_HOST)
 102                 return true;
 103         else if (cdns3_get_id(cdns) == CDNS3_ID_HOST)
 104                 return true;
 105
 106         return false;
 107 }
 108
 109 bool cdns3_is_device(struct cdns3 *cdns)
 110 {
 111         if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL)
 112                 return true;
 113         else if (cdns->dr_mode == USB_DR_MODE_OTG)
 114                 if (cdns3_get_id(cdns) == CDNS3_ID_PERIPHERAL)
 115                         return true;
 116
 117         return false;
 118 }
 119
 120 /**
 121  * cdns3_otg_disable_irq - Disable all OTG interrupts
 122  * @cdns: Pointer to controller context structure
 123  */
 124 static void cdns3_otg_disable_irq(struct cdns3 *cdns)
 125 {
 126         writel(0, &cdns->otg_regs->ien);
 127 }
 128
 129 /**
 130  * cdns3_otg_enable_irq - enable id and sess_valid interrupts
 131  * @cdns: Pointer to controller context structure
 132  */
 133 static void cdns3_otg_enable_irq(struct cdns3 *cdns)
 134 {
 135         writel(OTGIEN_ID_CHANGE_INT | OTGIEN_VBUSVALID_RISE_INT |
 136                OTGIEN_VBUSVALID_FALL_INT, &cdns->otg_regs->ien);
 137 }
 138
 139 /**
 140  * cdns3_drd_host_on - start host.
 141  * @cdns: Pointer to controller context structure.
 142  *
 143  * Returns 0 on success otherwise negative errno.
 144  */
 145 int cdns3_drd_host_on(struct cdns3 *cdns)
 146 {
 147         u32 val;
 148         int ret;
 149
 150         /* Enable host mode. */
 151         writel(OTGCMD_HOST_BUS_REQ | OTGCMD_OTG_DIS,
 152                &cdns->otg_regs->cmd);
 153
 154         dev_dbg(cdns->dev, "Waiting till Host mode is turned on\n");
 155         ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
 156                                         val & OTGSTS_XHCI_READY, 1, 100000);
 157
 158         if (ret)
 159                 dev_err(cdns->dev, "timeout waiting for xhci_ready\n");
 160
 161         phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_HOST);
 162         return ret;
 163 }
 164
 165 /**
 166  * cdns3_drd_host_off - stop host.
 167  * @cdns: Pointer to controller context structure.
 168  */
 169 void cdns3_drd_host_off(struct cdns3 *cdns)
 170 {
 171         u32 val;
 172
 173         writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
 174                OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
 175                &cdns->otg_regs->cmd);
 176
 177         /* Waiting till H_IDLE state.*/
 178         readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
 179                                   !(val & OTGSTATE_HOST_STATE_MASK),
 180                                   1, 2000000);
 181         phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
 182 }
 183
 184 /**
 185  * cdns3_drd_gadget_on - start gadget.
 186  * @cdns: Pointer to controller context structure.
 187  *
 188  * Returns 0 on success otherwise negative errno
 189  */
 190 int cdns3_drd_gadget_on(struct cdns3 *cdns)
 191 {
 192         int ret, val;
 193         u32 reg = OTGCMD_OTG_DIS;
 194
 195         /* switch OTG core */
 196         writel(OTGCMD_DEV_BUS_REQ | reg, &cdns->otg_regs->cmd);
 197
 198         dev_dbg(cdns->dev, "Waiting till Device mode is turned on\n");
 199
 200         ret = readl_poll_timeout_atomic(&cdns->otg_regs->sts, val,
 201                                         val & OTGSTS_DEV_READY,
 202                                         1, 100000);
 203         if (ret) {
 204                 dev_err(cdns->dev, "timeout waiting for dev_ready\n");
 205                 return ret;
 206         }
 207
 208         phy_set_mode(cdns->usb3_phy, PHY_MODE_USB_DEVICE);
 209         return 0;
 210 }
 211
 212 /**
 213  * cdns3_drd_gadget_off - stop gadget.
 214  * @cdns: Pointer to controller context structure.
 215  */
 216 void cdns3_drd_gadget_off(struct cdns3 *cdns)
 217 {
 218         u32 val;
 219
 220         /*
 221          * Driver should wait at least 10us after disabling Device
 222          * before turning-off Device (DEV_BUS_DROP).
 223          */
 224         usleep_range(20, 30);
 225         writel(OTGCMD_HOST_BUS_DROP | OTGCMD_DEV_BUS_DROP |
 226                OTGCMD_DEV_POWER_OFF | OTGCMD_HOST_POWER_OFF,
 227                &cdns->otg_regs->cmd);
 228         /* Waiting till DEV_IDLE state.*/
 229         readl_poll_timeout_atomic(&cdns->otg_regs->state, val,
 230                                   !(val & OTGSTATE_DEV_STATE_MASK),
 231                                   1, 2000000);
 232         phy_set_mode(cdns->usb3_phy, PHY_MODE_INVALID);
 233 }
 234
 235 /**
 236  * cdns3_init_otg_mode - initialize drd controller
 237  * @cdns: Pointer to controller context structure
 238  *
 239  * Returns 0 on success otherwise negative errno
 240  */
 241 static int cdns3_init_otg_mode(struct cdns3 *cdns)
 242 {
 243         int ret;
 244
 245         cdns3_otg_disable_irq(cdns);
 246         /* clear all interrupts */
 247         writel(~0, &cdns->otg_regs->ivect);
 248
 249         ret = cdns3_set_mode(cdns, USB_DR_MODE_OTG);
 250         if (ret)
 251                 return ret;
 252
 253         cdns3_otg_enable_irq(cdns);
 254
 255         return 0;
 256 }
 257
 258 /**
 259  * cdns3_drd_update_mode - initialize mode of operation
 260  * @cdns: Pointer to controller context structure
 261  *
 262  * Returns 0 on success otherwise negative errno
 263  */
 264 int cdns3_drd_update_mode(struct cdns3 *cdns)
 265 {
 266         int ret;
 267
 268         switch (cdns->dr_mode) {
 269         case USB_DR_MODE_PERIPHERAL:
 270                 ret = cdns3_set_mode(cdns, USB_DR_MODE_PERIPHERAL);
 271                 break;
 272         case USB_DR_MODE_HOST:
 273                 ret = cdns3_set_mode(cdns, USB_DR_MODE_HOST);
 274                 break;
 275         case USB_DR_MODE_OTG:
 276                 ret = cdns3_init_otg_mode(cdns);
 277                 break;
 278         default:
 279                 dev_err(cdns->dev, "Unsupported mode of operation %d\n",
 280                         cdns->dr_mode);
 281                 return -EINVAL;
 282         }
 283
 284         return ret;
 285 }
 286
 287 static irqreturn_t cdns3_drd_thread_irq(int irq, void *data)
 288 {
 289         struct cdns3 *cdns = data;
 290
 291         cdns3_hw_role_switch(cdns);
 292
 293         return IRQ_HANDLED;
 294 }
 295
 296 /**
 297  * cdns3_drd_irq - interrupt handler for OTG events
 298  *
 299  * @irq: irq number for cdns3 core device
 300  * @data: structure of cdns3
 301  *
 302  * Returns IRQ_HANDLED or IRQ_NONE
 303  */
 304 static irqreturn_t cdns3_drd_irq(int irq, void *data)
 305 {
 306         irqreturn_t ret = IRQ_NONE;
 307         struct cdns3 *cdns = data;
 308         u32 reg;
 309
 310         if (cdns->dr_mode != USB_DR_MODE_OTG)
 311                 return IRQ_NONE;
 312
 313         if (cdns->in_lpm)
 314                 return ret;
 315
 316         reg = readl(&cdns->otg_regs->ivect);
 317
 318         if (!reg)
 319                 return IRQ_NONE;
 320
 321         if (reg & OTGIEN_ID_CHANGE_INT) {
 322                 dev_dbg(cdns->dev, "OTG IRQ: new ID: %d\n",
 323                         cdns3_get_id(cdns));
 324
 325                 ret = IRQ_WAKE_THREAD;
 326         }
 327
 328         if (reg & (OTGIEN_VBUSVALID_RISE_INT | OTGIEN_VBUSVALID_FALL_INT)) {
 329                 dev_dbg(cdns->dev, "OTG IRQ: new VBUS: %d\n",
 330                         cdns3_get_vbus(cdns));
 331
 332                 ret = IRQ_WAKE_THREAD;
 333         }
 334
 335         writel(~0, &cdns->otg_regs->ivect);
 336         return ret;
 337 }
 338
 339 int cdns3_drd_init(struct cdns3 *cdns)
 340 {
 341         void __iomem *regs;
 342         u32 state;
 343         int ret;
 344
 345         regs = devm_ioremap_resource(cdns->dev, &cdns->otg_res);
 346         if (IS_ERR(regs))
 347                 return PTR_ERR(regs);
 348
 349         /* Detection of DRD version. Controller has been released
 350          * in two versions. Both are similar, but they have same changes
 351          * in register maps.
 352          * The first register in old version is command register and it's read
 353          * only, so driver should read 0 from it. On the other hand, in v1
 354          * the first register contains device ID number which is not set to 0.
 355          * Driver uses this fact to detect the proper version of
 356          * controller.
 357          */
 358         cdns->otg_v0_regs = regs;
 359         if (!readl(&cdns->otg_v0_regs->cmd)) {
 360                 cdns->version  = CDNS3_CONTROLLER_V0;
 361                 cdns->otg_v1_regs = NULL;
 362                 cdns->otg_regs = regs;
 363                 writel(1, &cdns->otg_v0_regs->simulate);
 364                 dev_dbg(cdns->dev, "DRD version v0 (%08x)\n",
 365                          readl(&cdns->otg_v0_regs->version));
 366         } else {
 367                 cdns->otg_v0_regs = NULL;
 368                 cdns->otg_v1_regs = regs;
 369                 cdns->otg_regs = (void *)&cdns->otg_v1_regs->cmd;
 370                 cdns->version  = CDNS3_CONTROLLER_V1;
 371                 writel(1, &cdns->otg_v1_regs->simulate);
 372                 dev_dbg(cdns->dev, "DRD version v1 (ID: %08x, rev: %08x)\n",
 373                          readl(&cdns->otg_v1_regs->did),
 374                          readl(&cdns->otg_v1_regs->rid));
 375         }
 376
 377         state = OTGSTS_STRAP(readl(&cdns->otg_regs->sts));
 378
 379         /* Update dr_mode according to STRAP configuration. */
 380         cdns->dr_mode = USB_DR_MODE_OTG;
 381         if (state == OTGSTS_STRAP_HOST) {
 382                 dev_dbg(cdns->dev, "Controller strapped to HOST\n");
 383                 cdns->dr_mode = USB_DR_MODE_HOST;
 384         } else if (state == OTGSTS_STRAP_GADGET) {
 385                 dev_dbg(cdns->dev, "Controller strapped to PERIPHERAL\n");
 386                 cdns->dr_mode = USB_DR_MODE_PERIPHERAL;
 387         }
 388
 389         ret = devm_request_threaded_irq(cdns->dev, cdns->otg_irq,
 390                                         cdns3_drd_irq,
 391                                         cdns3_drd_thread_irq,
 392                                         IRQF_SHARED,
 393                                         dev_name(cdns->dev), cdns);
 394         if (ret) {
 395                 dev_err(cdns->dev, "couldn't get otg_irq\n");
 396                 return ret;
 397         }
 398
 399         state = readl(&cdns->otg_regs->sts);
 400         if (OTGSTS_OTG_NRDY(state)) {
 401                 dev_err(cdns->dev, "Cadence USB3 OTG device not ready\n");
 402                 return -ENODEV;
 403         }
 404
 405         return 0;
 406 }
 407
 408 int cdns3_drd_exit(struct cdns3 *cdns)
 409 {
 410         cdns3_otg_disable_irq(cdns);
 411         return 0;
 412 }