drivers/usb/musb-new/sunxi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Allwinner SUNXI "glue layer"
   4  *
   5  * Copyright © 2015 Hans de Goede <hdegoede@redhat.com>
   6  * Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
   7  *
   8  * Based on the sw_usb "Allwinner OTG Dual Role Controller" code.
   9  *  Copyright 2007-2012 (C) Allwinner Technology Co., Ltd.
  10  *  javen <javen@allwinnertech.com>
  11  *
  12  * Based on the DA8xx "glue layer" code.
  13  *  Copyright (c) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
  14  *  Copyright (C) 2005-2006 by Texas Instruments
  15  *
  16  * This file is part of the Inventra Controller Driver for Linux.
  17  */
  18 #include <common.h>
  19 #include <clk.h>
  20 #include <dm.h>
  21 #include <generic-phy.h>
  22 #include <log.h>
  23 #include <malloc.h>
  24 #include <phy-sun4i-usb.h>
  25 #include <reset.h>
  26 #include <asm/arch/cpu.h>
  27 #include <asm/arch/clock.h>
  28 #include <dm/device_compat.h>
  29 #include <dm/lists.h>
  30 #include <dm/root.h>
  31 #include <linux/bitops.h>
  32 #include <linux/delay.h>
  33 #include <linux/usb/musb.h>
  34 #include "linux-compat.h"
  35 #include "musb_core.h"
  36 #include "musb_uboot.h"
  37
  38 /******************************************************************************
  39  ******************************************************************************
  40  * From the Allwinner driver
  41  ******************************************************************************
  42  ******************************************************************************/
  43
  44 /******************************************************************************
  45  * From include/sunxi_usb_bsp.h
  46  ******************************************************************************/
  47
  48 /* reg offsets */
  49 #define  USBC_REG_o_ISCR        0x0400
  50 #define  USBC_REG_o_PHYCTL      0x0404
  51 #define  USBC_REG_o_PHYBIST     0x0408
  52 #define  USBC_REG_o_PHYTUNE     0x040c
  53
  54 #define  USBC_REG_o_VEND0       0x0043
  55
  56 /* Interface Status and Control */
  57 #define  USBC_BP_ISCR_VBUS_VALID_FROM_DATA      30
  58 #define  USBC_BP_ISCR_VBUS_VALID_FROM_VBUS      29
  59 #define  USBC_BP_ISCR_EXT_ID_STATUS             28
  60 #define  USBC_BP_ISCR_EXT_DM_STATUS             27
  61 #define  USBC_BP_ISCR_EXT_DP_STATUS             26
  62 #define  USBC_BP_ISCR_MERGED_VBUS_STATUS        25
  63 #define  USBC_BP_ISCR_MERGED_ID_STATUS          24
  64
  65 #define  USBC_BP_ISCR_ID_PULLUP_EN              17
  66 #define  USBC_BP_ISCR_DPDM_PULLUP_EN            16
  67 #define  USBC_BP_ISCR_FORCE_ID                  14
  68 #define  USBC_BP_ISCR_FORCE_VBUS_VALID          12
  69 #define  USBC_BP_ISCR_VBUS_VALID_SRC            10
  70
  71 #define  USBC_BP_ISCR_HOSC_EN                   7
  72 #define  USBC_BP_ISCR_VBUS_CHANGE_DETECT        6
  73 #define  USBC_BP_ISCR_ID_CHANGE_DETECT          5
  74 #define  USBC_BP_ISCR_DPDM_CHANGE_DETECT        4
  75 #define  USBC_BP_ISCR_IRQ_ENABLE                3
  76 #define  USBC_BP_ISCR_VBUS_CHANGE_DETECT_EN     2
  77 #define  USBC_BP_ISCR_ID_CHANGE_DETECT_EN       1
  78 #define  USBC_BP_ISCR_DPDM_CHANGE_DETECT_EN     0
  79
  80 /******************************************************************************
  81  * From usbc/usbc.c
  82  ******************************************************************************/
  83
  84 struct sunxi_musb_config {
  85         struct musb_hdrc_config *config;
  86 };
  87
  88 struct sunxi_glue {
  89         struct musb_host_data mdata;
  90         struct clk clk;
  91         struct reset_ctl rst;
  92         struct sunxi_musb_config *cfg;
  93         struct device dev;
  94         struct phy phy;
  95 };
  96 #define to_sunxi_glue(d)        container_of(d, struct sunxi_glue, dev)
  97
  98 static u32 USBC_WakeUp_ClearChangeDetect(u32 reg_val)
  99 {
 100         u32 temp = reg_val;
 101
 102         temp &= ~BIT(USBC_BP_ISCR_VBUS_CHANGE_DETECT);
 103         temp &= ~BIT(USBC_BP_ISCR_ID_CHANGE_DETECT);
 104         temp &= ~BIT(USBC_BP_ISCR_DPDM_CHANGE_DETECT);
 105
 106         return temp;
 107 }
 108
 109 static void USBC_EnableIdPullUp(__iomem void *base)
 110 {
 111         u32 reg_val;
 112
 113         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 114         reg_val |= BIT(USBC_BP_ISCR_ID_PULLUP_EN);
 115         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 116         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 117 }
 118
 119 static void USBC_EnableDpDmPullUp(__iomem void *base)
 120 {
 121         u32 reg_val;
 122
 123         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 124         reg_val |= BIT(USBC_BP_ISCR_DPDM_PULLUP_EN);
 125         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 126         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 127 }
 128
 129 static void USBC_ForceIdToLow(__iomem void *base)
 130 {
 131         u32 reg_val;
 132
 133         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 134         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
 135         reg_val |= (0x02 << USBC_BP_ISCR_FORCE_ID);
 136         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 137         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 138 }
 139
 140 static void USBC_ForceIdToHigh(__iomem void *base)
 141 {
 142         u32 reg_val;
 143
 144         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 145         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
 146         reg_val |= (0x03 << USBC_BP_ISCR_FORCE_ID);
 147         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 148         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 149 }
 150
 151 static void USBC_ForceVbusValidToLow(__iomem void *base)
 152 {
 153         u32 reg_val;
 154
 155         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 156         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 157         reg_val |= (0x02 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 158         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 159         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 160 }
 161
 162 static void USBC_ForceVbusValidToHigh(__iomem void *base)
 163 {
 164         u32 reg_val;
 165
 166         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 167         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 168         reg_val |= (0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 169         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 170         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 171 }
 172
 173 static void USBC_ConfigFIFO_Base(void)
 174 {
 175         u32 reg_value;
 176
 177         /* config usb fifo, 8kb mode */
 178         reg_value = readl(SUNXI_SRAMC_BASE + 0x04);
 179         reg_value &= ~(0x03 << 0);
 180         reg_value |= BIT(0);
 181         writel(reg_value, SUNXI_SRAMC_BASE + 0x04);
 182 }
 183
 184 /******************************************************************************
 185  * Needed for the DFU polling magic
 186  ******************************************************************************/
 187
 188 static u8 last_int_usb;
 189
 190 bool dfu_usb_get_reset(void)
 191 {
 192         return !!(last_int_usb & MUSB_INTR_RESET);
 193 }
 194
 195 /******************************************************************************
 196  * MUSB Glue code
 197  ******************************************************************************/
 198
 199 static irqreturn_t sunxi_musb_interrupt(int irq, void *__hci)
 200 {
 201         struct musb             *musb = __hci;
 202         irqreturn_t             retval = IRQ_NONE;
 203
 204         /* read and flush interrupts */
 205         musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
 206         last_int_usb = musb->int_usb;
 207         if (musb->int_usb)
 208                 musb_writeb(musb->mregs, MUSB_INTRUSB, musb->int_usb);
 209         musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
 210         if (musb->int_tx)
 211                 musb_writew(musb->mregs, MUSB_INTRTX, musb->int_tx);
 212         musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
 213         if (musb->int_rx)
 214                 musb_writew(musb->mregs, MUSB_INTRRX, musb->int_rx);
 215
 216         if (musb->int_usb || musb->int_tx || musb->int_rx)
 217                 retval |= musb_interrupt(musb);
 218
 219         return retval;
 220 }
 221
 222 /* musb_core does not call enable / disable in a balanced manner <sigh> */
 223 static bool enabled = false;
 224
 225 static int sunxi_musb_enable(struct musb *musb)
 226 {
 227         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 228         int ret;
 229
 230         pr_debug("%s():\n", __func__);
 231
 232         musb_ep_select(musb->mregs, 0);
 233         musb_writeb(musb->mregs, MUSB_FADDR, 0);
 234
 235         if (enabled)
 236                 return 0;
 237
 238         /* select PIO mode */
 239         musb_writeb(musb->mregs, USBC_REG_o_VEND0, 0);
 240
 241         if (is_host_enabled(musb)) {
 242                 ret = sun4i_usb_phy_id_detect(&glue->phy);
 243                 if (ret == 1) {
 244                         printf("No host cable detected: ");
 245                         return -ENODEV;
 246                 }
 247
 248                 ret = generic_phy_power_on(&glue->phy);
 249                 if (ret) {
 250                         pr_debug("failed to power on USB PHY\n");
 251                         return ret;
 252                 }
 253         }
 254
 255         USBC_ForceVbusValidToHigh(musb->mregs);
 256
 257         enabled = true;
 258         return 0;
 259 }
 260
 261 static void sunxi_musb_disable(struct musb *musb)
 262 {
 263         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 264         int ret;
 265
 266         pr_debug("%s():\n", __func__);
 267
 268         if (!enabled)
 269                 return;
 270
 271         if (is_host_enabled(musb)) {
 272                 ret = generic_phy_power_off(&glue->phy);
 273                 if (ret) {
 274                         pr_debug("failed to power off USB PHY\n");
 275                         return;
 276                 }
 277         }
 278
 279         USBC_ForceVbusValidToLow(musb->mregs);
 280         mdelay(200); /* Wait for the current session to timeout */
 281
 282         enabled = false;
 283 }
 284
 285 static int sunxi_musb_init(struct musb *musb)
 286 {
 287         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 288         int ret;
 289
 290         pr_debug("%s():\n", __func__);
 291
 292         ret = clk_enable(&glue->clk);
 293         if (ret) {
 294                 dev_err(musb->controller, "failed to enable clock\n");
 295                 return ret;
 296         }
 297
 298         if (reset_valid(&glue->rst)) {
 299                 ret = reset_deassert(&glue->rst);
 300                 if (ret) {
 301                         dev_err(musb->controller, "failed to deassert reset\n");
 302                         goto err_clk;
 303                 }
 304         }
 305
 306         ret = generic_phy_init(&glue->phy);
 307         if (ret) {
 308                 dev_dbg(musb->controller, "failed to init USB PHY\n");
 309                 goto err_rst;
 310         }
 311
 312         musb->isr = sunxi_musb_interrupt;
 313
 314         USBC_ConfigFIFO_Base();
 315         USBC_EnableDpDmPullUp(musb->mregs);
 316         USBC_EnableIdPullUp(musb->mregs);
 317
 318         if (is_host_enabled(musb)) {
 319                 /* Host mode */
 320                 USBC_ForceIdToLow(musb->mregs);
 321         } else {
 322                 /* Peripheral mode */
 323                 USBC_ForceIdToHigh(musb->mregs);
 324         }
 325         USBC_ForceVbusValidToHigh(musb->mregs);
 326
 327         return 0;
 328
 329 err_rst:
 330         if (reset_valid(&glue->rst))
 331                 reset_assert(&glue->rst);
 332 err_clk:
 333         clk_disable(&glue->clk);
 334         return ret;
 335 }
 336
 337 static int sunxi_musb_exit(struct musb *musb)
 338 {
 339         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 340         int ret = 0;
 341
 342         if (generic_phy_valid(&glue->phy)) {
 343                 ret = generic_phy_exit(&glue->phy);
 344                 if (ret) {
 345                         dev_dbg(musb->controller,
 346                                 "failed to power off usb phy\n");
 347                         return ret;
 348                 }
 349         }
 350
 351         if (reset_valid(&glue->rst))
 352                 reset_assert(&glue->rst);
 353         clk_disable(&glue->clk);
 354
 355         return 0;
 356 }
 357
 358 static void sunxi_musb_pre_root_reset_end(struct musb *musb)
 359 {
 360         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 361
 362         sun4i_usb_phy_set_squelch_detect(&glue->phy, false);
 363 }
 364
 365 static void sunxi_musb_post_root_reset_end(struct musb *musb)
 366 {
 367         struct sunxi_glue *glue = to_sunxi_glue(musb->controller);
 368
 369         sun4i_usb_phy_set_squelch_detect(&glue->phy, true);
 370 }
 371
 372 static const struct musb_platform_ops sunxi_musb_ops = {
 373         .init           = sunxi_musb_init,
 374         .exit           = sunxi_musb_exit,
 375         .enable         = sunxi_musb_enable,
 376         .disable        = sunxi_musb_disable,
 377         .pre_root_reset_end = sunxi_musb_pre_root_reset_end,
 378         .post_root_reset_end = sunxi_musb_post_root_reset_end,
 379 };
 380
 381 /* Allwinner OTG supports up to 5 endpoints */
 382 #define SUNXI_MUSB_MAX_EP_NUM           6
 383 #define SUNXI_MUSB_RAM_BITS             11
 384
 385 static struct musb_fifo_cfg sunxi_musb_mode_cfg[] = {
 386         MUSB_EP_FIFO_SINGLE(1, FIFO_TX, 512),
 387         MUSB_EP_FIFO_SINGLE(1, FIFO_RX, 512),
 388         MUSB_EP_FIFO_SINGLE(2, FIFO_TX, 512),
 389         MUSB_EP_FIFO_SINGLE(2, FIFO_RX, 512),
 390         MUSB_EP_FIFO_SINGLE(3, FIFO_TX, 512),
 391         MUSB_EP_FIFO_SINGLE(3, FIFO_RX, 512),
 392         MUSB_EP_FIFO_SINGLE(4, FIFO_TX, 512),
 393         MUSB_EP_FIFO_SINGLE(4, FIFO_RX, 512),
 394         MUSB_EP_FIFO_SINGLE(5, FIFO_TX, 512),
 395         MUSB_EP_FIFO_SINGLE(5, FIFO_RX, 512),
 396 };
 397
 398 /* H3/V3s OTG supports only 4 endpoints */
 399 #define SUNXI_MUSB_MAX_EP_NUM_H3        5
 400
 401 static struct musb_fifo_cfg sunxi_musb_mode_cfg_h3[] = {
 402         MUSB_EP_FIFO_SINGLE(1, FIFO_TX, 512),
 403         MUSB_EP_FIFO_SINGLE(1, FIFO_RX, 512),
 404         MUSB_EP_FIFO_SINGLE(2, FIFO_TX, 512),
 405         MUSB_EP_FIFO_SINGLE(2, FIFO_RX, 512),
 406         MUSB_EP_FIFO_SINGLE(3, FIFO_TX, 512),
 407         MUSB_EP_FIFO_SINGLE(3, FIFO_RX, 512),
 408         MUSB_EP_FIFO_SINGLE(4, FIFO_TX, 512),
 409         MUSB_EP_FIFO_SINGLE(4, FIFO_RX, 512),
 410 };
 411
 412 static struct musb_hdrc_config musb_config = {
 413         .fifo_cfg       = sunxi_musb_mode_cfg,
 414         .fifo_cfg_size  = ARRAY_SIZE(sunxi_musb_mode_cfg),
 415         .multipoint     = true,
 416         .dyn_fifo       = true,
 417         .num_eps        = SUNXI_MUSB_MAX_EP_NUM,
 418         .ram_bits       = SUNXI_MUSB_RAM_BITS,
 419 };
 420
 421 static struct musb_hdrc_config musb_config_h3 = {
 422         .fifo_cfg       = sunxi_musb_mode_cfg_h3,
 423         .fifo_cfg_size  = ARRAY_SIZE(sunxi_musb_mode_cfg_h3),
 424         .multipoint     = true,
 425         .dyn_fifo       = true,
 426         .soft_con       = true,
 427         .num_eps        = SUNXI_MUSB_MAX_EP_NUM_H3,
 428         .ram_bits       = SUNXI_MUSB_RAM_BITS,
 429 };
 430
 431 static int musb_usb_probe(struct udevice *dev)
 432 {
 433         struct sunxi_glue *glue = dev_get_priv(dev);
 434         struct musb_host_data *host = &glue->mdata;
 435         struct musb_hdrc_platform_data pdata;
 436         void *base = dev_read_addr_ptr(dev);
 437         int ret;
 438
 439 #ifdef CONFIG_USB_MUSB_HOST
 440         struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
 441 #endif
 442
 443         if (!base)
 444                 return -EINVAL;
 445
 446         glue->cfg = (struct sunxi_musb_config *)dev_get_driver_data(dev);
 447         if (!glue->cfg)
 448                 return -EINVAL;
 449
 450         ret = clk_get_by_index(dev, 0, &glue->clk);
 451         if (ret) {
 452                 dev_err(dev, "failed to get clock\n");
 453                 return ret;
 454         }
 455
 456         ret = reset_get_by_index(dev, 0, &glue->rst);
 457         if (ret && ret != -ENOENT) {
 458                 dev_err(dev, "failed to get reset\n");
 459                 return ret;
 460         }
 461
 462         ret = generic_phy_get_by_name(dev, "usb", &glue->phy);
 463         if (ret) {
 464                 pr_err("failed to get usb PHY\n");
 465                 return ret;
 466         }
 467
 468         memset(&pdata, 0, sizeof(pdata));
 469         pdata.power = 250;
 470         pdata.platform_ops = &sunxi_musb_ops;
 471         pdata.config = glue->cfg->config;
 472
 473 #ifdef CONFIG_USB_MUSB_HOST
 474         priv->desc_before_addr = true;
 475
 476         pdata.mode = MUSB_HOST;
 477         host->host = musb_init_controller(&pdata, &glue->dev, base);
 478         if (!host->host)
 479                 return -EIO;
 480
 481         ret = musb_lowlevel_init(host);
 482         if (!ret)
 483                 printf("Allwinner mUSB OTG (Host)\n");
 484 #else
 485         pdata.mode = MUSB_PERIPHERAL;
 486         host->host = musb_register(&pdata, &glue->dev, base);
 487         if (IS_ERR_OR_NULL(host->host))
 488                 return -EIO;
 489
 490         printf("Allwinner mUSB OTG (Peripheral)\n");
 491 #endif
 492
 493         return ret;
 494 }
 495
 496 static int musb_usb_remove(struct udevice *dev)
 497 {
 498         struct sunxi_glue *glue = dev_get_priv(dev);
 499         struct musb_host_data *host = &glue->mdata;
 500
 501         musb_stop(host->host);
 502         free(host->host);
 503         host->host = NULL;
 504
 505         return 0;
 506 }
 507
 508 static const struct sunxi_musb_config sun4i_a10_cfg = {
 509         .config = &musb_config,
 510 };
 511
 512 static const struct sunxi_musb_config sun6i_a31_cfg = {
 513         .config = &musb_config,
 514 };
 515
 516 static const struct sunxi_musb_config sun8i_h3_cfg = {
 517         .config = &musb_config_h3,
 518 };
 519
 520 static const struct udevice_id sunxi_musb_ids[] = {
 521         { .compatible = "allwinner,sun4i-a10-musb",
 522                         .data = (ulong)&sun4i_a10_cfg },
 523         { .compatible = "allwinner,sun6i-a31-musb",
 524                         .data = (ulong)&sun6i_a31_cfg },
 525         { .compatible = "allwinner,sun8i-a33-musb",
 526                         .data = (ulong)&sun6i_a31_cfg },
 527         { .compatible = "allwinner,sun8i-h3-musb",
 528                         .data = (ulong)&sun8i_h3_cfg },
 529         { }
 530 };
 531
 532 U_BOOT_DRIVER(usb_musb) = {
 533         .name           = "sunxi-musb",
 534 #ifdef CONFIG_USB_MUSB_HOST
 535         .id             = UCLASS_USB,
 536 #else
 537         .id             = UCLASS_USB_GADGET_GENERIC,
 538 #endif
 539         .of_match       = sunxi_musb_ids,
 540         .probe          = musb_usb_probe,
 541         .remove         = musb_usb_remove,
 542 #ifdef CONFIG_USB_MUSB_HOST
 543         .ops            = &musb_usb_ops,
 544 #endif
 545         .plat_auto      = sizeof(struct usb_plat),
 546         .priv_auto      = sizeof(struct sunxi_glue),
 547 };