drivers/usb/cdns3/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence USBSS and USBSSP DRD Driver.
   4  *
   5  * Copyright (C) 2018-2019 Cadence.
   6  * Copyright (C) 2017-2018 NXP
   7  * Copyright (C) 2019 Texas Instruments
   8  *
   9  * Author: Peter Chen <[email protected]>
  10  *         Pawel Laszczak <[email protected]>
  11  *         Roger Quadros <[email protected]>
  12  */
  13
  14 #include <linux/dma-mapping.h>
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/of.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/io.h>
  21 #include <linux/pm_runtime.h>
  22
  23 #include "core.h"
  24 #include "host-export.h"
  25 #include "drd.h"
  26
  27 static int cdns_idle_init(struct cdns *cdns);
  28
  29 static int cdns_role_start(struct cdns *cdns, enum usb_role role)
  30 {
  31         int ret;
  32
  33         if (WARN_ON(role > USB_ROLE_DEVICE))
  34                 return 0;
  35
  36         mutex_lock(&cdns->mutex);
  37         cdns->role = role;
  38         mutex_unlock(&cdns->mutex);
  39
  40         if (!cdns->roles[role])
  41                 return -ENXIO;
  42
  43         if (cdns->roles[role]->state == CDNS_ROLE_STATE_ACTIVE)
  44                 return 0;
  45
  46         mutex_lock(&cdns->mutex);
  47         ret = cdns->roles[role]->start(cdns);
  48         if (!ret)
  49                 cdns->roles[role]->state = CDNS_ROLE_STATE_ACTIVE;
  50         mutex_unlock(&cdns->mutex);
  51
  52         return ret;
  53 }
  54
  55 static void cdns_role_stop(struct cdns *cdns)
  56 {
  57         enum usb_role role = cdns->role;
  58
  59         if (WARN_ON(role > USB_ROLE_DEVICE))
  60                 return;
  61
  62         if (cdns->roles[role]->state == CDNS_ROLE_STATE_INACTIVE)
  63                 return;
  64
  65         mutex_lock(&cdns->mutex);
  66         cdns->roles[role]->stop(cdns);
  67         cdns->roles[role]->state = CDNS_ROLE_STATE_INACTIVE;
  68         mutex_unlock(&cdns->mutex);
  69 }
  70
  71 static void cdns_exit_roles(struct cdns *cdns)
  72 {
  73         cdns_role_stop(cdns);
  74         cdns_drd_exit(cdns);
  75 }
  76
  77 /**
  78  * cdns_core_init_role - initialize role of operation
  79  * @cdns: Pointer to cdns structure
  80  *
  81  * Returns 0 on success otherwise negative errno
  82  */
  83 static int cdns_core_init_role(struct cdns *cdns)
  84 {
  85         struct device *dev = cdns->dev;
  86         enum usb_dr_mode best_dr_mode;
  87         enum usb_dr_mode dr_mode;
  88         int ret;
  89
  90         dr_mode = usb_get_dr_mode(dev);
  91         cdns->role = USB_ROLE_NONE;
  92
  93         /*
  94          * If driver can't read mode by means of usb_get_dr_mode function then
  95          * chooses mode according with Kernel configuration. This setting
  96          * can be restricted later depending on strap pin configuration.
  97          */
  98         if (dr_mode == USB_DR_MODE_UNKNOWN) {
  99                 if (cdns->version == CDNSP_CONTROLLER_V2) {
 100                         if (IS_ENABLED(CONFIG_USB_CDNSP_HOST) &&
 101                             IS_ENABLED(CONFIG_USB_CDNSP_GADGET))
 102                                 dr_mode = USB_DR_MODE_OTG;
 103                         else if (IS_ENABLED(CONFIG_USB_CDNSP_HOST))
 104                                 dr_mode = USB_DR_MODE_HOST;
 105                         else if (IS_ENABLED(CONFIG_USB_CDNSP_GADGET))
 106                                 dr_mode = USB_DR_MODE_PERIPHERAL;
 107                 } else {
 108                         if (IS_ENABLED(CONFIG_USB_CDNS3_HOST) &&
 109                             IS_ENABLED(CONFIG_USB_CDNS3_GADGET))
 110                                 dr_mode = USB_DR_MODE_OTG;
 111                         else if (IS_ENABLED(CONFIG_USB_CDNS3_HOST))
 112                                 dr_mode = USB_DR_MODE_HOST;
 113                         else if (IS_ENABLED(CONFIG_USB_CDNS3_GADGET))
 114                                 dr_mode = USB_DR_MODE_PERIPHERAL;
 115                 }
 116         }
 117
 118         /*
 119          * At this point cdns->dr_mode contains strap configuration.
 120          * Driver try update this setting considering kernel configuration
 121          */
 122         best_dr_mode = cdns->dr_mode;
 123
 124         ret = cdns_idle_init(cdns);
 125         if (ret)
 126                 return ret;
 127
 128         if (dr_mode == USB_DR_MODE_OTG) {
 129                 best_dr_mode = cdns->dr_mode;
 130         } else if (cdns->dr_mode == USB_DR_MODE_OTG) {
 131                 best_dr_mode = dr_mode;
 132         } else if (cdns->dr_mode != dr_mode) {
 133                 dev_err(dev, "Incorrect DRD configuration\n");
 134                 return -EINVAL;
 135         }
 136
 137         dr_mode = best_dr_mode;
 138
 139         if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) {
 140                 if ((cdns->version == CDNSP_CONTROLLER_V2 &&
 141                      IS_ENABLED(CONFIG_USB_CDNSP_HOST)) ||
 142                     (cdns->version < CDNSP_CONTROLLER_V2 &&
 143                      IS_ENABLED(CONFIG_USB_CDNS3_HOST)))
 144                         ret = cdns_host_init(cdns);
 145                 else
 146                         ret = -ENXIO;
 147
 148                 if (ret) {
 149                         dev_err(dev, "Host initialization failed with %d\n",
 150                                 ret);
 151                         goto err;
 152                 }
 153         }
 154
 155         if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) {
 156                 if (cdns->gadget_init)
 157                         ret = cdns->gadget_init(cdns);
 158                 else
 159                         ret = -ENXIO;
 160
 161                 if (ret) {
 162                         dev_err(dev, "Device initialization failed with %d\n",
 163                                 ret);
 164                         goto err;
 165                 }
 166         }
 167
 168         cdns->dr_mode = dr_mode;
 169
 170         ret = cdns_drd_update_mode(cdns);
 171         if (ret)
 172                 goto err;
 173
 174         /* Initialize idle role to start with */
 175         ret = cdns_role_start(cdns, USB_ROLE_NONE);
 176         if (ret)
 177                 goto err;
 178
 179         switch (cdns->dr_mode) {
 180         case USB_DR_MODE_OTG:
 181                 ret = cdns_hw_role_switch(cdns);
 182                 if (ret)
 183                         goto err;
 184                 break;
 185         case USB_DR_MODE_PERIPHERAL:
 186                 ret = cdns_role_start(cdns, USB_ROLE_DEVICE);
 187                 if (ret)
 188                         goto err;
 189                 break;
 190         case USB_DR_MODE_HOST:
 191                 ret = cdns_role_start(cdns, USB_ROLE_HOST);
 192                 if (ret)
 193                         goto err;
 194                 break;
 195         default:
 196                 ret = -EINVAL;
 197                 goto err;
 198         }
 199
 200         return 0;
 201 err:
 202         cdns_exit_roles(cdns);
 203         return ret;
 204 }
 205
 206 /**
 207  * cdns_hw_role_state_machine  - role switch state machine based on hw events.
 208  * @cdns: Pointer to controller structure.
 209  *
 210  * Returns next role to be entered based on hw events.
 211  */
 212 static enum usb_role cdns_hw_role_state_machine(struct cdns *cdns)
 213 {
 214         enum usb_role role = USB_ROLE_NONE;
 215         int id, vbus;
 216
 217         if (cdns->dr_mode != USB_DR_MODE_OTG) {
 218                 if (cdns_is_host(cdns))
 219                         role = USB_ROLE_HOST;
 220                 if (cdns_is_device(cdns))
 221                         role = USB_ROLE_DEVICE;
 222
 223                 return role;
 224         }
 225
 226         id = cdns_get_id(cdns);
 227         vbus = cdns_get_vbus(cdns);
 228
 229         /*
 230          * Role change state machine
 231          * Inputs: ID, VBUS
 232          * Previous state: cdns->role
 233          * Next state: role
 234          */
 235         role = cdns->role;
 236
 237         switch (role) {
 238         case USB_ROLE_NONE:
 239                 /*
 240                  * Driver treats USB_ROLE_NONE synonymous to IDLE state from
 241                  * controller specification.
 242                  */
 243                 if (!id)
 244                         role = USB_ROLE_HOST;
 245                 else if (vbus)
 246                         role = USB_ROLE_DEVICE;
 247                 break;
 248         case USB_ROLE_HOST: /* from HOST, we can only change to NONE */
 249                 if (id)
 250                         role = USB_ROLE_NONE;
 251                 break;
 252         case USB_ROLE_DEVICE: /* from GADGET, we can only change to NONE*/
 253                 if (!vbus)
 254                         role = USB_ROLE_NONE;
 255                 break;
 256         }
 257
 258         dev_dbg(cdns->dev, "role %d -> %d\n", cdns->role, role);
 259
 260         return role;
 261 }
 262
 263 static int cdns_idle_role_start(struct cdns *cdns)
 264 {
 265         return 0;
 266 }
 267
 268 static void cdns_idle_role_stop(struct cdns *cdns)
 269 {
 270         /* Program Lane swap and bring PHY out of RESET */
 271         phy_reset(cdns->usb3_phy);
 272 }
 273
 274 static int cdns_idle_init(struct cdns *cdns)
 275 {
 276         struct cdns_role_driver *rdrv;
 277
 278         rdrv = devm_kzalloc(cdns->dev, sizeof(*rdrv), GFP_KERNEL);
 279         if (!rdrv)
 280                 return -ENOMEM;
 281
 282         rdrv->start = cdns_idle_role_start;
 283         rdrv->stop = cdns_idle_role_stop;
 284         rdrv->state = CDNS_ROLE_STATE_INACTIVE;
 285         rdrv->suspend = NULL;
 286         rdrv->resume = NULL;
 287         rdrv->name = "idle";
 288
 289         cdns->roles[USB_ROLE_NONE] = rdrv;
 290
 291         return 0;
 292 }
 293
 294 /**
 295  * cdns_hw_role_switch - switch roles based on HW state
 296  * @cdns: controller
 297  */
 298 int cdns_hw_role_switch(struct cdns *cdns)
 299 {
 300         enum usb_role real_role, current_role;
 301         int ret = 0;
 302
 303         /* Depends on role switch class */
 304         if (cdns->role_sw)
 305                 return 0;
 306
 307         pm_runtime_get_sync(cdns->dev);
 308
 309         current_role = cdns->role;
 310         real_role = cdns_hw_role_state_machine(cdns);
 311
 312         /* Do nothing if nothing changed */
 313         if (current_role == real_role)
 314                 goto exit;
 315
 316         cdns_role_stop(cdns);
 317
 318         dev_dbg(cdns->dev, "Switching role %d -> %d", current_role, real_role);
 319
 320         ret = cdns_role_start(cdns, real_role);
 321         if (ret) {
 322                 /* Back to current role */
 323                 dev_err(cdns->dev, "set %d has failed, back to %d\n",
 324                         real_role, current_role);
 325                 ret = cdns_role_start(cdns, current_role);
 326                 if (ret)
 327                         dev_err(cdns->dev, "back to %d failed too\n",
 328                                 current_role);
 329         }
 330 exit:
 331         pm_runtime_put_sync(cdns->dev);
 332         return ret;
 333 }
 334
 335 /**
 336  * cdns_role_get - get current role of controller.
 337  *
 338  * @sw: pointer to USB role switch structure
 339  *
 340  * Returns role
 341  */
 342 static enum usb_role cdns_role_get(struct usb_role_switch *sw)
 343 {
 344         struct cdns *cdns = usb_role_switch_get_drvdata(sw);
 345
 346         return cdns->role;
 347 }
 348
 349 /**
 350  * cdns_role_set - set current role of controller.
 351  *
 352  * @sw: pointer to USB role switch structure
 353  * @role: the previous role
 354  * Handles below events:
 355  * - Role switch for dual-role devices
 356  * - USB_ROLE_GADGET <--> USB_ROLE_NONE for peripheral-only devices
 357  */
 358 static int cdns_role_set(struct usb_role_switch *sw, enum usb_role role)
 359 {
 360         struct cdns *cdns = usb_role_switch_get_drvdata(sw);
 361         int ret = 0;
 362
 363         pm_runtime_get_sync(cdns->dev);
 364
 365         if (cdns->role == role)
 366                 goto pm_put;
 367
 368         if (cdns->dr_mode == USB_DR_MODE_HOST) {
 369                 switch (role) {
 370                 case USB_ROLE_NONE:
 371                 case USB_ROLE_HOST:
 372                         break;
 373                 default:
 374                         goto pm_put;
 375                 }
 376         }
 377
 378         if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL) {
 379                 switch (role) {
 380                 case USB_ROLE_NONE:
 381                 case USB_ROLE_DEVICE:
 382                         break;
 383                 default:
 384                         goto pm_put;
 385                 }
 386         }
 387
 388         cdns_role_stop(cdns);
 389         ret = cdns_role_start(cdns, role);
 390         if (ret)
 391                 dev_err(cdns->dev, "set role %d has failed\n", role);
 392
 393 pm_put:
 394         pm_runtime_put_sync(cdns->dev);
 395         return ret;
 396 }
 397
 398
 399 /**
 400  * cdns_wakeup_irq - interrupt handler for wakeup events
 401  * @irq: irq number for cdns3/cdnsp core device
 402  * @data: structure of cdns
 403  *
 404  * Returns IRQ_HANDLED or IRQ_NONE
 405  */
 406 static irqreturn_t cdns_wakeup_irq(int irq, void *data)
 407 {
 408         struct cdns *cdns = data;
 409
 410         if (cdns->in_lpm) {
 411                 disable_irq_nosync(irq);
 412                 cdns->wakeup_pending = true;
 413                 if ((cdns->role == USB_ROLE_HOST) && cdns->host_dev)
 414                         pm_request_resume(&cdns->host_dev->dev);
 415
 416                 return IRQ_HANDLED;
 417         }
 418
 419         return IRQ_NONE;
 420 }
 421
 422 /**
 423  * cdns_init - probe for cdns3/cdnsp core device
 424  * @cdns: Pointer to cdns structure.
 425  *
 426  * Returns 0 on success otherwise negative errno
 427  */
 428 int cdns_init(struct cdns *cdns)
 429 {
 430         struct device *dev = cdns->dev;
 431         int ret;
 432
 433         ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 434         if (ret) {
 435                 dev_err(dev, "error setting dma mask: %d\n", ret);
 436                 return ret;
 437         }
 438
 439         mutex_init(&cdns->mutex);
 440
 441         if (device_property_read_bool(dev, "usb-role-switch")) {
 442                 struct usb_role_switch_desc sw_desc = { };
 443
 444                 sw_desc.set = cdns_role_set;
 445                 sw_desc.get = cdns_role_get;
 446                 sw_desc.allow_userspace_control = true;
 447                 sw_desc.driver_data = cdns;
 448                 sw_desc.fwnode = dev->fwnode;
 449
 450                 cdns->role_sw = usb_role_switch_register(dev, &sw_desc);
 451                 if (IS_ERR(cdns->role_sw)) {
 452                         dev_warn(dev, "Unable to register Role Switch\n");
 453                         return PTR_ERR(cdns->role_sw);
 454                 }
 455         }
 456
 457         if (cdns->wakeup_irq) {
 458                 ret = devm_request_irq(cdns->dev, cdns->wakeup_irq,
 459                                                 cdns_wakeup_irq,
 460                                                 IRQF_SHARED,
 461                                                 dev_name(cdns->dev), cdns);
 462
 463                 if (ret) {
 464                         dev_err(cdns->dev, "couldn't register wakeup irq handler\n");
 465                         goto role_switch_unregister;
 466                 }
 467         }
 468
 469         ret = cdns_drd_init(cdns);
 470         if (ret)
 471                 goto init_failed;
 472
 473         ret = cdns_core_init_role(cdns);
 474         if (ret)
 475                 goto init_failed;
 476
 477         spin_lock_init(&cdns->lock);
 478
 479         dev_dbg(dev, "Cadence USB3 core: probe succeed\n");
 480
 481         return 0;
 482 init_failed:
 483         cdns_drd_exit(cdns);
 484 role_switch_unregister:
 485         if (cdns->role_sw)
 486                 usb_role_switch_unregister(cdns->role_sw);
 487
 488         return ret;
 489 }
 490 EXPORT_SYMBOL_GPL(cdns_init);
 491
 492 /**
 493  * cdns_remove - unbind drd driver and clean up
 494  * @cdns: Pointer to cdns structure.
 495  *
 496  * Returns 0 on success otherwise negative errno
 497  */
 498 int cdns_remove(struct cdns *cdns)
 499 {
 500         cdns_exit_roles(cdns);
 501         usb_role_switch_unregister(cdns->role_sw);
 502
 503         return 0;
 504 }
 505 EXPORT_SYMBOL_GPL(cdns_remove);
 506
 507 #ifdef CONFIG_PM_SLEEP
 508 int cdns_suspend(struct cdns *cdns)
 509 {
 510         struct device *dev = cdns->dev;
 511         unsigned long flags;
 512
 513         if (pm_runtime_status_suspended(dev))
 514                 pm_runtime_resume(dev);
 515
 516         if (cdns->roles[cdns->role]->suspend) {
 517                 spin_lock_irqsave(&cdns->lock, flags);
 518                 cdns->roles[cdns->role]->suspend(cdns, false);
 519                 spin_unlock_irqrestore(&cdns->lock, flags);
 520         }
 521
 522         return 0;
 523 }
 524 EXPORT_SYMBOL_GPL(cdns_suspend);
 525
 526 int cdns_resume(struct cdns *cdns)
 527 {
 528         enum usb_role real_role;
 529         bool role_changed = false;
 530         int ret = 0;
 531
 532         if (cdns_power_is_lost(cdns)) {
 533                 if (cdns->role_sw) {
 534                         cdns->role = cdns_role_get(cdns->role_sw);
 535                 } else {
 536                         real_role = cdns_hw_role_state_machine(cdns);
 537                         if (real_role != cdns->role) {
 538                                 ret = cdns_hw_role_switch(cdns);
 539                                 if (ret)
 540                                         return ret;
 541                                 role_changed = true;
 542                         }
 543                 }
 544
 545                 if (!role_changed) {
 546                         if (cdns->role == USB_ROLE_HOST)
 547                                 ret = cdns_drd_host_on(cdns);
 548                         else if (cdns->role == USB_ROLE_DEVICE)
 549                                 ret = cdns_drd_gadget_on(cdns);
 550
 551                         if (ret)
 552                                 return ret;
 553                 }
 554         }
 555
 556         if (cdns->roles[cdns->role]->resume)
 557                 cdns->roles[cdns->role]->resume(cdns, cdns_power_is_lost(cdns));
 558
 559         return 0;
 560 }
 561 EXPORT_SYMBOL_GPL(cdns_resume);
 562
 563 void cdns_set_active(struct cdns *cdns, u8 set_active)
 564 {
 565         struct device *dev = cdns->dev;
 566
 567         if (set_active) {
 568                 pm_runtime_disable(dev);
 569                 pm_runtime_set_active(dev);
 570                 pm_runtime_enable(dev);
 571         }
 572
 573         return;
 574 }
 575 EXPORT_SYMBOL_GPL(cdns_set_active);
 576 #endif /* CONFIG_PM_SLEEP */
 577
 578 MODULE_AUTHOR("Peter Chen <[email protected]>");
 579 MODULE_AUTHOR("Pawel Laszczak <[email protected]>");
 580 MODULE_AUTHOR("Roger Quadros <[email protected]>");
 581 MODULE_DESCRIPTION("Cadence USBSS and USBSSP DRD Driver");
 582 MODULE_LICENSE("GPL");