drivers/usb/musb-new/sunxi.c

   1 /*
   2  * Allwinner SUNXI "glue layer"
   3  *
   4  * Copyright © 2015 Hans de Goede <hdegoede@redhat.com>
   5  * Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
   6  *
   7  * Based on the sw_usb "Allwinner OTG Dual Role Controller" code.
   8  *  Copyright 2007-2012 (C) Allwinner Technology Co., Ltd.
   9  *  javen <javen@allwinnertech.com>
  10  *
  11  * Based on the DA8xx "glue layer" code.
  12  *  Copyright (c) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
  13  *  Copyright (C) 2005-2006 by Texas Instruments
  14  *
  15  * This file is part of the Inventra Controller Driver for Linux.
  16  *
  17  * The Inventra Controller Driver for Linux is free software; you
  18  * can redistribute it and/or modify it under the terms of the GNU
  19  * General Public License version 2 as published by the Free Software
  20  * Foundation.
  21  *
  22  */
  23 #include <common.h>
  24 #include <asm/arch/cpu.h>
  25 #include <asm/arch/clock.h>
  26 #include <asm/arch/gpio.h>
  27 #include <asm/arch/usbc.h>
  28 #include <asm-generic/gpio.h>
  29 #include "linux-compat.h"
  30 #include "musb_core.h"
  31 #ifdef CONFIG_AXP152_POWER
  32 #include <axp152.h>
  33 #endif
  34 #ifdef CONFIG_AXP209_POWER
  35 #include <axp209.h>
  36 #endif
  37 #ifdef CONFIG_AXP221_POWER
  38 #include <axp221.h>
  39 #endif
  40
  41 /******************************************************************************
  42  ******************************************************************************
  43  * From the Allwinner driver
  44  ******************************************************************************
  45  ******************************************************************************/
  46
  47 /******************************************************************************
  48  * From include/sunxi_usb_bsp.h
  49  ******************************************************************************/
  50
  51 /* reg offsets */
  52 #define  USBC_REG_o_ISCR        0x0400
  53 #define  USBC_REG_o_PHYCTL      0x0404
  54 #define  USBC_REG_o_PHYBIST     0x0408
  55 #define  USBC_REG_o_PHYTUNE     0x040c
  56
  57 #define  USBC_REG_o_VEND0       0x0043
  58
  59 /* Interface Status and Control */
  60 #define  USBC_BP_ISCR_VBUS_VALID_FROM_DATA      30
  61 #define  USBC_BP_ISCR_VBUS_VALID_FROM_VBUS      29
  62 #define  USBC_BP_ISCR_EXT_ID_STATUS             28
  63 #define  USBC_BP_ISCR_EXT_DM_STATUS             27
  64 #define  USBC_BP_ISCR_EXT_DP_STATUS             26
  65 #define  USBC_BP_ISCR_MERGED_VBUS_STATUS        25
  66 #define  USBC_BP_ISCR_MERGED_ID_STATUS          24
  67
  68 #define  USBC_BP_ISCR_ID_PULLUP_EN              17
  69 #define  USBC_BP_ISCR_DPDM_PULLUP_EN            16
  70 #define  USBC_BP_ISCR_FORCE_ID                  14
  71 #define  USBC_BP_ISCR_FORCE_VBUS_VALID          12
  72 #define  USBC_BP_ISCR_VBUS_VALID_SRC            10
  73
  74 #define  USBC_BP_ISCR_HOSC_EN                   7
  75 #define  USBC_BP_ISCR_VBUS_CHANGE_DETECT        6
  76 #define  USBC_BP_ISCR_ID_CHANGE_DETECT          5
  77 #define  USBC_BP_ISCR_DPDM_CHANGE_DETECT        4
  78 #define  USBC_BP_ISCR_IRQ_ENABLE                3
  79 #define  USBC_BP_ISCR_VBUS_CHANGE_DETECT_EN     2
  80 #define  USBC_BP_ISCR_ID_CHANGE_DETECT_EN       1
  81 #define  USBC_BP_ISCR_DPDM_CHANGE_DETECT_EN     0
  82
  83 /******************************************************************************
  84  * From usbc/usbc.c
  85  ******************************************************************************/
  86
  87 static u32 USBC_WakeUp_ClearChangeDetect(u32 reg_val)
  88 {
  89         u32 temp = reg_val;
  90
  91         temp &= ~(1 << USBC_BP_ISCR_VBUS_CHANGE_DETECT);
  92         temp &= ~(1 << USBC_BP_ISCR_ID_CHANGE_DETECT);
  93         temp &= ~(1 << USBC_BP_ISCR_DPDM_CHANGE_DETECT);
  94
  95         return temp;
  96 }
  97
  98 static void USBC_EnableIdPullUp(__iomem void *base)
  99 {
 100         u32 reg_val;
 101
 102         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 103         reg_val |= (1 << USBC_BP_ISCR_ID_PULLUP_EN);
 104         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 105         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 106 }
 107
 108 static void USBC_DisableIdPullUp(__iomem void *base)
 109 {
 110         u32 reg_val;
 111
 112         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 113         reg_val &= ~(1 << USBC_BP_ISCR_ID_PULLUP_EN);
 114         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 115         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 116 }
 117
 118 static void USBC_EnableDpDmPullUp(__iomem void *base)
 119 {
 120         u32 reg_val;
 121
 122         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 123         reg_val |= (1 << USBC_BP_ISCR_DPDM_PULLUP_EN);
 124         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 125         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 126 }
 127
 128 static void USBC_DisableDpDmPullUp(__iomem void *base)
 129 {
 130         u32 reg_val;
 131
 132         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 133         reg_val &= ~(1 << USBC_BP_ISCR_DPDM_PULLUP_EN);
 134         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 135         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 136 }
 137
 138 static void USBC_ForceIdToLow(__iomem void *base)
 139 {
 140         u32 reg_val;
 141
 142         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 143         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
 144         reg_val |= (0x02 << USBC_BP_ISCR_FORCE_ID);
 145         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 146         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 147 }
 148
 149 static void USBC_ForceIdToHigh(__iomem void *base)
 150 {
 151         u32 reg_val;
 152
 153         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 154         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_ID);
 155         reg_val |= (0x03 << USBC_BP_ISCR_FORCE_ID);
 156         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 157         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 158 }
 159
 160 static void USBC_ForceVbusValidToHigh(__iomem void *base)
 161 {
 162         u32 reg_val;
 163
 164         reg_val = musb_readl(base, USBC_REG_o_ISCR);
 165         reg_val &= ~(0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 166         reg_val |= (0x03 << USBC_BP_ISCR_FORCE_VBUS_VALID);
 167         reg_val = USBC_WakeUp_ClearChangeDetect(reg_val);
 168         musb_writel(base, USBC_REG_o_ISCR, reg_val);
 169 }
 170
 171 static void USBC_ConfigFIFO_Base(void)
 172 {
 173         u32 reg_value;
 174
 175         /* config usb fifo, 8kb mode */
 176         reg_value = readl(SUNXI_SRAMC_BASE + 0x04);
 177         reg_value &= ~(0x03 << 0);
 178         reg_value |= (1 << 0);
 179         writel(reg_value, SUNXI_SRAMC_BASE + 0x04);
 180 }
 181
 182 /******************************************************************************
 183  * MUSB Glue code
 184  ******************************************************************************/
 185
 186 static irqreturn_t sunxi_musb_interrupt(int irq, void *__hci)
 187 {
 188         struct musb             *musb = __hci;
 189         irqreturn_t             retval = IRQ_NONE;
 190
 191         /* read and flush interrupts */
 192         musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
 193         if (musb->int_usb)
 194                 musb_writeb(musb->mregs, MUSB_INTRUSB, musb->int_usb);
 195         musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
 196         if (musb->int_tx)
 197                 musb_writew(musb->mregs, MUSB_INTRTX, musb->int_tx);
 198         musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
 199         if (musb->int_rx)
 200                 musb_writew(musb->mregs, MUSB_INTRRX, musb->int_rx);
 201
 202         if (musb->int_usb || musb->int_tx || musb->int_rx)
 203                 retval |= musb_interrupt(musb);
 204
 205         return retval;
 206 }
 207
 208 static void sunxi_musb_enable(struct musb *musb)
 209 {
 210         pr_debug("%s():\n", __func__);
 211
 212         /* select PIO mode */
 213         musb_writeb(musb->mregs, USBC_REG_o_VEND0, 0);
 214
 215         if (is_host_enabled(musb)) {
 216                 /* port power on */
 217                 sunxi_usbc_vbus_enable(0);
 218         }
 219 }
 220
 221 static void sunxi_musb_disable(struct musb *musb)
 222 {
 223         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 224
 225         pr_debug("%s():\n", __func__);
 226
 227         /* Put the controller back in a pristane state for "usb reset" */
 228         if (musb->is_active) {
 229                 sunxi_usbc_disable(0);
 230 #ifdef CONFIG_SUNXI_GEN_SUN6I
 231                 clrbits_le32(&ccm->ahb_reset0_cfg, 1 << AHB_GATE_OFFSET_USB0);
 232 #endif
 233                 clrbits_le32(&ccm->ahb_gate0, 1 << AHB_GATE_OFFSET_USB0);
 234
 235                 mdelay(10);
 236
 237                 setbits_le32(&ccm->ahb_gate0, 1 << AHB_GATE_OFFSET_USB0);
 238 #ifdef CONFIG_SUNXI_GEN_SUN6I
 239                 setbits_le32(&ccm->ahb_reset0_cfg, 1 << AHB_GATE_OFFSET_USB0);
 240 #endif
 241                 sunxi_usbc_enable(0);
 242                 musb->is_active = 0;
 243         }
 244 }
 245
 246 static int sunxi_musb_init(struct musb *musb)
 247 {
 248         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 249         int err;
 250
 251         pr_debug("%s():\n", __func__);
 252
 253         err = sunxi_usbc_request_resources(0);
 254         if (err)
 255                 return err;
 256
 257         if (is_host_enabled(musb)) {
 258                 err = sunxi_usbc_vbus_detect(0);
 259                 if (err) {
 260                         eprintf("Error: A charger is plugged into the OTG\n");
 261                         sunxi_usbc_free_resources(0);
 262                         return -EIO;
 263                 }
 264         }
 265
 266         musb->isr = sunxi_musb_interrupt;
 267
 268         setbits_le32(&ccm->ahb_gate0, 1 << AHB_GATE_OFFSET_USB0);
 269 #ifdef CONFIG_SUNXI_GEN_SUN6I
 270         setbits_le32(&ccm->ahb_reset0_cfg, 1 << AHB_GATE_OFFSET_USB0);
 271 #endif
 272         sunxi_usbc_enable(0);
 273
 274         USBC_ConfigFIFO_Base();
 275         USBC_EnableDpDmPullUp(musb->mregs);
 276         USBC_EnableIdPullUp(musb->mregs);
 277
 278         if (is_host_enabled(musb)) {
 279                 /* Host mode */
 280                 USBC_ForceIdToLow(musb->mregs);
 281         } else {
 282                 /* Peripheral mode */
 283                 USBC_ForceIdToHigh(musb->mregs);
 284         }
 285         USBC_ForceVbusValidToHigh(musb->mregs);
 286
 287         return 0;
 288 }
 289
 290 static int sunxi_musb_exit(struct musb *musb)
 291 {
 292         pr_debug("%s():\n", __func__);
 293
 294         USBC_DisableDpDmPullUp(musb->mregs);
 295         USBC_DisableIdPullUp(musb->mregs);
 296         sunxi_usbc_vbus_disable(0);
 297         sunxi_usbc_disable(0);
 298
 299         return sunxi_usbc_free_resources(0);
 300 }
 301
 302 const struct musb_platform_ops sunxi_musb_ops = {
 303         .init           = sunxi_musb_init,
 304         .exit           = sunxi_musb_exit,
 305
 306         .enable         = sunxi_musb_enable,
 307         .disable        = sunxi_musb_disable,
 308 };