drivers/usb/cdns3/drd.c

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