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