Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+43
View File
@@ -0,0 +1,43 @@
#
# Phy drivers for Mediatek devices
#
config PHY_MTK_TPHY
tristate "MediaTek T-PHY Driver"
depends on ARCH_MEDIATEK && OF
select GENERIC_PHY
help
Say 'Y' here to add support for MediaTek T-PHY driver,
it supports multiple usb2.0, usb3.0 ports, PCIe and
SATA, and meanwhile supports two version T-PHY which have
different banks layout, the T-PHY with shared banks between
multi-ports is first version, otherwise is second veriosn,
so you can easily distinguish them by banks layout.
config PHY_MTK_UFS
tristate "MediaTek UFS M-PHY driver"
depends on ARCH_MEDIATEK && OF
select GENERIC_PHY
help
Support for UFS M-PHY on MediaTek chipsets.
Enable this to provide vendor-specific probing,
initialization, power on and power off flow of
specified M-PHYs.
config PHY_MTK_XSPHY
tristate "MediaTek XS-PHY Driver"
depends on ARCH_MEDIATEK && OF
select GENERIC_PHY
help
Enable this to support the SuperSpeedPlus XS-PHY transceiver for
USB3.1 GEN2 controllers on MediaTek chips. The driver supports
multiple USB2.0, USB3.1 GEN2 ports.
config PHY_MTK_USB
bool "Mediatek usb phy"
select GENERIC_PHY
help
Say Y here if your system using in-circuit Mediatek USB PHY.
If unsure, say N.
Enables support for ASIC PHY.
This driver provides interface to interact with USB 2.0 and
USB 3.0 PHY that is part of the Mediatek SOC.
+8
View File
@@ -0,0 +1,8 @@
# SPDX-License-Identifier: GPL-2.0
#
# Makefile for the phy drivers.
#
obj-$(CONFIG_PHY_MTK_TPHY) += phy-mtk-tphy.o
obj-$(CONFIG_PHY_MTK_UFS) += phy-mtk-ufs.o
obj-$(CONFIG_PHY_MTK_XSPHY) += phy-mtk-xsphy.o
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+744
View File
@@ -0,0 +1,744 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MTK_PROJECT_PHY_H
#define __MTK_PROJECT_PHY_H
#define SSUSB_SIFSLV_SPLLC_BASE (MTK_USB_PHY_SPLLC_BASE)
#define SSUSB_SIFSLV_FMREG (MTK_USB_PHY_FMREG_BASE)
#define SSUSB_SIFSLV_U2PHY_COM_BASE (MTK_USB_PHY_U2_BASE)
#define SSUSB_SIFSLV_U3PHYD_BASE (MTK_USB_PHY_U3PHYD_BASE)
#define SSUSB_USB30_PHYA_SIV_B2_BASE (MTK_USB_PHY_B2_BASE)
#define SSUSB_USB30_PHYA_SIV_B_BASE (MTK_USB_PHY_PHYA_BASE)
#define SSUSB_SIFSLV_U3PHYA_DA_BASE (MTK_USB_PHY_PHYA_DA_BASE)
/* ///////////////////////////////////////////// */
/** SSUSB_SIFSLV_SPLLC_BASE **/
#define U3D_SPLLC_XTALCTL3 (SSUSB_SIFSLV_SPLLC_BASE + 0x18)
/* XTALCTL3 */
#define RG_SSUSB_XTALCTL_REV (0xf<<12)
#define RG_SSUSB_BIASIMR_EN (0x1<<11)
#define RG_SSUSB_FORCE_BIASIMR_EN (0x1<<10)
#define RG_SSUSB_XTAL_RX_PWD (0x1<<9)
#define RG_SSUSB_FRC_XTAL_RX_PWD (0x1<<8)
#define RG_SSUSB_CKBG_PROB_SEL (0x3<<6)
#define RG_SSUSB_XTAL_PROB_SEL (0x3<<4)
#define RG_SSUSB_XTAL_VREGBIAS_LPF_ENB (0x1<<3)
#define RG_SSUSB_XTAL_FRC_VREGBIAS_LPF_ENB (0x1<<2)
#define RG_SSUSB_XTAL_VREGBIAS_PWD (0x1<<1)
#define RG_SSUSB_XTAL_FRC_VREGBIAS_PWD (0x1<<0)
#define RG_SSUSB_XTALCTL_REV_OFST (12)
#define RG_SSUSB_BIASIMR_EN_OFST (11)
#define RG_SSUSB_FORCE_BIASIMR_EN_OFST (10)
#define RG_SSUSB_XTAL_RX_PWD_OFST (9)
#define RG_SSUSB_FRC_XTAL_RX_PWD_OFST (8)
#define RG_SSUSB_CKBG_PROB_SEL_OFST (6)
#define RG_SSUSB_XTAL_PROB_SEL_OFST (4)
#define RG_SSUSB_XTAL_VREGBIAS_LPF_ENB_OFST (3)
#define RG_SSUSB_XTAL_FRC_VREGBIAS_LPF_ENB_OFST (2)
#define RG_SSUSB_XTAL_VREGBIAS_PWD_OFST (1)
#define RG_SSUSB_XTAL_FRC_VREGBIAS_PWD_OFST (0)
/* ///////////////////////////////////////////// */
/** SSUSB_SIFSLV_FMREG **/
#define RG_SSUSB_SIFSLV_FMCR0 (SSUSB_SIFSLV_FMREG + 0x00)
#define RG_SSUSB_SIFSLV_FMCR1 (SSUSB_SIFSLV_FMREG + 0x04)
#define RG_SSUSB_SIFSLV_FMCR2 (SSUSB_SIFSLV_FMREG + 0x08)
#define RG_SSUSB_SIFSLV_FMMONR0 (SSUSB_SIFSLV_FMREG + 0x0c)
#define RG_SSUSB_SIFSLV_FMMONR1 (SSUSB_SIFSLV_FMREG + 0x10)
/* RG_SSUSB_SIFSLV_FMCR0 */
#define RG_LOCKTH (0xf<<28)
#define RG_MONCLK_SEL (0x3<<26)
#define RG_FM_MODE (0x1<<25)
#define RG_FREQDET_EN (0x1<<24)
#define RG_CYCLECNT (0xffffff<<0)
#define RG_LOCKTH_OFST (28)
#define RG_MONCLK_SEL_OFST (26)
#define RG_FM_MODE_OFST (25)
#define RG_FREQDET_EN_OFST (24)
#define RG_CYCLECNT_OFST (0)
/* RG_SSUSB_SIFSLV_FMCR1 */
#define RG_TARGET (0xffffffff<<0)
#define RG_TARGET_OFST (0)
/* RG_SSUSB_SIFSLV_FMCR2 */
#define RG_OFFSET (0xffffffff<<0)
#define RG_OFFSET_OFST (0)
/* RG_SSUSB_SIFSLV_FMMONR0 */
#define USB_FM_OUT (0xffffffff<<0)
#define USB_FM_OUT_OFST (0)
/* RG_SSUSB_SIFSLV_FMMONR1 */
#define RG_MONCLK_SEL_2 (0x1<<9)
#define RG_FRCK_EN (0x1<<8)
#define USBPLL_LOCK (0x1<<1)
#define USB_FM_VLD (0x1<<0)
#define RG_MONCLK_SEL_2_OFST (9)
#define RG_FRCK_EN_OFST (8)
#define USBPLL_LOCK_OFST (1)
#define USB_FM_VLD_OFST (0)
#define U2_SR_COEF 28
#define U3D_PHY_REF_CK 26
/* ///////////////////////////////////////////// */
/** SSUSB_SIFSLV_U2PHY_COM_BASE **/
#define U3D_USBPHYACR0 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0000)
#define U3D_USBPHYACR1 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0004)
#define U3D_USBPHYACR2 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0008)
#define U3D_USBPHYACR5 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0014)
#define U3D_USBPHYACR6 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0018)
#define U3D_U2PHYACR3 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x001c)
#define U3D_U2PHYACR4 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0020)
#define U3D_U2PHYDCR0 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0060)
#define U3D_U2PHYDCR1 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0064)
#define U3D_U2PHYDTM0 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0068)
#define U3D_U2PHYDTM1 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x006C)
#define U3D_U2PHYDMON1 (SSUSB_SIFSLV_U2PHY_COM_BASE + 0x0074)
/* U3D_USBPHYACR0 */
#define RG_USB20_MPX_OUT_SEL (0x7<<28)
#define RG_USB20_TX_PH_ROT_SEL (0x7<<24)
#define RG_USB20_PLL_DIVEN (0x7<<20)
#define RG_USB20_PLL_BR (0x1<<18)
#define RG_USB20_PLL_BP (0x1<<17)
#define RG_USB20_PLL_BLP (0x1<<16)
#define RG_USB20_USBPLL_FORCE_ON (0x1<<15)
#define RG_USB20_PLL_FBDIV (0x7f<<8)
#define RG_USB20_PLL_PREDIV (0x3<<6)
#define RG_USB20_INTR_EN (0x1<<5)
#define RG_USB20_REF_EN (0x1<<4)
#define RG_USB20_BGR_DIV (0x3<<2)
#define RG_SIFSLV_CHP_EN (0x1<<1)
#define RG_SIFSLV_BGR_EN (0x1<<0)
#define RG_USB20_MPX_OUT_SEL_OFST (28)
#define RG_USB20_TX_PH_ROT_SEL_OFST (24)
#define RG_USB20_PLL_DIVEN_OFST (20)
#define RG_USB20_PLL_BR_OFST (18)
#define RG_USB20_PLL_BP_OFST (17)
#define RG_USB20_PLL_BLP_OFST (16)
#define RG_USB20_USBPLL_FORCE_ON_OFST (15)
#define RG_USB20_PLL_FBDIV_OFST (8)
#define RG_USB20_PLL_PREDIV_OFST (6)
#define RG_USB20_INTR_EN_OFST (5)
#define RG_USB20_REF_EN_OFST (4)
#define RG_USB20_BGR_DIV_OFST (2)
#define RG_SIFSLV_CHP_EN_OFST (1)
#define RG_SIFSLV_BGR_EN_OFST (0)
/* U3D_USBPHYACR1 */
#define RG_USB20_INTR_CAL (0x1f<<19)
#define RG_USB20_OTG_VBUSTH (0x7<<16)
#define RG_USB20_VRT_VREF_SEL (0x7<<12)
#define RG_USB20_TERM_VREF_SEL (0x7<<8)
#define RG_USB20_MPX_SEL (0xff<<0)
#define RG_USB20_INTR_CAL_OFST (19)
#define RG_USB20_OTG_VBUSTH_OFST (16)
#define RG_USB20_VRT_VREF_SEL_OFST (12)
#define RG_USB20_TERM_VREF_SEL_OFST (8)
#define RG_USB20_MPX_SEL_OFST (0)
/* U3D_USBPHYACR2 */
#define RG_SIFSLV_USB20_PLL_FORCE_MODE (0x1<<18)
#define RG_SIFSLV_MAC_BANDGAP_EN (0x1<<17)
#define RG_SIFSLV_MAC_CHOPPER_EN (0x1<<16)
#define RG_USB20_CLKREF_REV (0xffff<<0)
#define RG_SIFSLV_USB20_PLL_FORCE_MODE_OFST (18)
#define RG_SIFSLV_MAC_BANDGAP_EN_OFST (17)
#define RG_SIFSLV_MAC_CHOPPER_EN_OFST (16)
#define RG_USB20_CLKREF_REV_OFST (0)
/* U3D_USBPHYACR5 */
#define RG_USB20_DISC_FIT_EN (0x1<<28)
#define RG_USB20_INIT_SQ_EN_DG (0x3<<26)
#define RG_USB20_HSTX_TMODE_SEL (0x3<<24)
#define RG_USB20_SQD (0x3<<22)
#define RG_USB20_DISCD (0x3<<20)
#define RG_USB20_HSTX_TMODE_EN (0x1<<19)
#define RG_USB20_PHYD_MONEN (0x1<<18)
#define RG_USB20_INLPBK_EN (0x1<<17)
#define RG_USB20_CHIRP_EN (0x1<<16)
#define RG_USB20_HSTX_SRCAL_EN (0x1<<15)
#define RG_USB20_HSTX_SRCTRL (0x7<<12)
#define RG_USB20_HS_100U_U3_EN (0x1<<11)
#define RG_USB20_GBIAS_ENB (0x1<<10)
#define RG_USB20_DM_ABIST_SOURCE_EN (0x1<<7)
#define RG_USB20_DM_ABIST_SELE (0xf<<0)
#define RG_USB20_DISC_FIT_EN_OFST (28)
#define RG_USB20_INIT_SQ_EN_DG_OFST (26)
#define RG_USB20_HSTX_TMODE_SEL_OFST (24)
#define RG_USB20_SQD_OFST (22)
#define RG_USB20_DISCD_OFST (20)
#define RG_USB20_HSTX_TMODE_EN_OFST (19)
#define RG_USB20_PHYD_MONEN_OFST (18)
#define RG_USB20_INLPBK_EN_OFST (17)
#define RG_USB20_CHIRP_EN_OFST (16)
#define RG_USB20_HSTX_SRCAL_EN_OFST (15)
#define RG_USB20_HSTX_SRCTRL_OFST (12)
#define RG_USB20_HS_100U_U3_EN_OFST (11)
#define RG_USB20_GBIAS_ENB_OFST (10)
#define RG_USB20_DM_ABIST_SOURCE_EN_OFST (7)
#define RG_USB20_DM_ABIST_SELE_OFST (0)
/* U3D_USBPHYACR6 */
#define RG_USB20_PHY_REV_6 (0x3<<30)
#define RG_USB20_PHY_REV (0xef<<24)
#define RG_USB20_BC11_SW_EN (0x1<<23)
#define RG_USB20_SR_CLK_SEL (0x1<<22)
#define RG_USB20_OTG_VBUSCMP_EN (0x1<<20)
#define RG_USB20_OTG_ABIST_EN (0x1<<19)
#define RG_USB20_OTG_ABIST_SELE (0x7<<16)
#define RG_USB20_HSRX_MMODE_SELE (0x3<<12)
#define RG_USB20_HSRX_BIAS_EN_SEL (0x3<<9)
#define RG_USB20_HSRX_TMODE_EN (0x1<<8)
#define RG_USB20_DISCTH (0xf<<4)
#define RG_USB20_SQTH (0xf<<0)
#define RG_USB20_PHY_REV_6_OFST (30)
#define RG_USB20_PHY_REV_OFST (24)
#define RG_USB20_BC11_SW_EN_OFST (23)
#define RG_USB20_SR_CLK_SEL_OFST (22)
#define RG_USB20_OTG_VBUSCMP_EN_OFST (20)
#define RG_USB20_OTG_ABIST_EN_OFST (19)
#define RG_USB20_OTG_ABIST_SELE_OFST (16)
#define RG_USB20_HSRX_MMODE_SELE_OFST (12)
#define RG_USB20_HSRX_BIAS_EN_SEL_OFST (9)
#define RG_USB20_HSRX_TMODE_EN_OFST (8)
#define RG_USB20_DISCTH_OFST (4)
#define RG_USB20_SQTH_OFST (0)
/* U3D_U2PHYACR3 */
#define RG_USB20_HSTX_DBIST (0xf<<28)
#define RG_USB20_HSTX_BIST_EN (0x1<<26)
#define RG_USB20_HSTX_I_EN_MODE (0x3<<24)
#define RG_USB20_USB11_TMODE_EN (0x1<<19)
#define RG_USB20_TMODE_FS_LS_TX_EN (0x1<<18)
#define RG_USB20_TMODE_FS_LS_RCV_EN (0x1<<17)
#define RG_USB20_TMODE_FS_LS_MODE (0x1<<16)
#define RG_USB20_HS_TERM_EN_MODE (0x3<<13)
#define RG_USB20_PUPD_BIST_EN (0x1<<12)
#define RG_USB20_EN_PU_DM (0x1<<11)
#define RG_USB20_EN_PD_DM (0x1<<10)
#define RG_USB20_EN_PU_DP (0x1<<9)
#define RG_USB20_EN_PD_DP (0x1<<8)
#define RG_USB20_HSTX_DBIST_OFST (28)
#define RG_USB20_HSTX_BIST_EN_OFST (26)
#define RG_USB20_HSTX_I_EN_MODE_OFST (24)
#define RG_USB20_USB11_TMODE_EN_OFST (19)
#define RG_USB20_TMODE_FS_LS_TX_EN_OFST (18)
#define RG_USB20_TMODE_FS_LS_RCV_EN_OFST (17)
#define RG_USB20_TMODE_FS_LS_MODE_OFST (16)
#define RG_USB20_HS_TERM_EN_MODE_OFST (13)
#define RG_USB20_PUPD_BIST_EN_OFST (12)
#define RG_USB20_EN_PU_DM_OFST (11)
#define RG_USB20_EN_PD_DM_OFST (10)
#define RG_USB20_EN_PU_DP_OFST (9)
#define RG_USB20_EN_PD_DP_OFST (8)
/* U3D_U2PHYACR4 */
#define RG_USB20_DP_100K_MODE (0x1<<18)
#define RG_USB20_DM_100K_EN (0x1<<17)
#define USB20_DP_100K_EN (0x1<<16)
#define USB20_GPIO_DM_I (0x1<<15)
#define USB20_GPIO_DP_I (0x1<<14)
#define USB20_GPIO_DM_OE (0x1<<13)
#define USB20_GPIO_DP_OE (0x1<<12)
#define RG_USB20_GPIO_CTL (0x1<<9)
#define USB20_GPIO_MODE (0x1<<8)
#define RG_USB20_TX_BIAS_EN (0x1<<5)
#define RG_USB20_TX_VCMPDN_EN (0x1<<4)
#define RG_USB20_HS_SQ_EN_MODE (0x3<<2)
#define RG_USB20_HS_RCV_EN_MODE (0x3<<0)
#define RG_USB20_DP_100K_MODE_OFST (18)
#define RG_USB20_DM_100K_EN_OFST (17)
#define USB20_DP_100K_EN_OFST (16)
#define USB20_GPIO_DM_I_OFST (15)
#define USB20_GPIO_DP_I_OFST (14)
#define USB20_GPIO_DM_OE_OFST (13)
#define USB20_GPIO_DP_OE_OFST (12)
#define RG_USB20_GPIO_CTL_OFST (9)
#define USB20_GPIO_MODE_OFST (8)
#define RG_USB20_TX_BIAS_EN_OFST (5)
#define RG_USB20_TX_VCMPDN_EN_OFST (4)
#define RG_USB20_HS_SQ_EN_MODE_OFST (2)
#define RG_USB20_HS_RCV_EN_MODE_OFST (0)
/* U3D_U2PHYDCR0 */
#define RG_USB20_CDR_TST (0x3<<30)
#define RG_USB20_GATED_ENB (0x1<<29)
#define RG_USB20_TESTMODE (0x3<<26)
#define RG_SIFSLV_USB20_PLL_STABLE (0x1<<25)
#define RG_SIFSLV_USB20_PLL_FORCE_ON (0x1<<24)
#define RG_USB20_PHYD_RESERVE (0xffff<<8)
#define RG_USB20_EBTHRLD (0x1<<7)
#define RG_USB20_EARLY_HSTX_I (0x1<<6)
#define RG_USB20_TX_TST (0x1<<5)
#define RG_USB20_NEGEDGE_ENB (0x1<<4)
#define RG_USB20_CDR_FILT (0xf<<0)
#define RG_USB20_CDR_TST_OFST (30)
#define RG_USB20_GATED_ENB_OFST (29)
#define RG_USB20_TESTMODE_OFST (26)
#define RG_SIFSLV_USB20_PLL_STABLE_OFST (25)
#define RG_SIFSLV_USB20_PLL_FORCE_ON_OFST (24)
#define RG_USB20_PHYD_RESERVE_OFST (8)
#define RG_USB20_EBTHRLD_OFST (7)
#define RG_USB20_EARLY_HSTX_I_OFST (6)
#define RG_USB20_TX_TST_OFST (5)
#define RG_USB20_NEGEDGE_ENB_OFST (4)
#define RG_USB20_CDR_FILT_OFST (0)
/* U3D_U2PHYDCR1 */
#define RG_USB20_PROBE_SEL (0xff<<24)
#define RG_USB20_DRVVBUS (0x1<<23)
#define RG_DEBUG_EN (0x1<<22)
#define RG_USB20_OTG_PROBE (0x3<<20)
#define RG_USB20_SW_PLLMODE (0x3<<18)
#define E60802_RG_USB20_SW_PLLMODE (0x3<<18)
#define RG_USB20_BERTH (0x3<<16)
#define RG_USB20_LBMODE (0x3<<13)
#define RG_USB20_FORCE_TAP (0x1<<12)
#define RG_USB20_TAPSEL (0xfff<<0)
/* U3D_U2PHYDCR1 */
#define RG_USB20_PROBE_SEL_OFST (24)
#define RG_USB20_DRVVBUS_OFST (23)
#define RG_DEBUG_EN_OFST (22)
#define RG_USB20_OTG_PROBE_OFST (20)
#define RG_USB20_SW_PLLMODE_OFST (18)
#define E60802_RG_USB20_SW_PLLMODE_OFST (18)
#define RG_USB20_BERTH_OFST (16)
#define RG_USB20_LBMODE_OFST (13)
#define RG_USB20_FORCE_TAP_OFST (12)
#define RG_USB20_TAPSEL_OFST (0)
/* U3D_U2PHYDTM0 */
#define RG_UART_MODE (0x3<<30)
#define FORCE_UART_I (0x1<<29)
#define FORCE_UART_BIAS_EN (0x1<<28)
#define FORCE_UART_TX_OE (0x1<<27)
#define FORCE_UART_EN (0x1<<26)
#define FORCE_USB_CLKEN (0x1<<25)
#define FORCE_DRVVBUS (0x1<<24)
#define FORCE_DATAIN (0x1<<23)
#define FORCE_TXVALID (0x1<<22)
#define FORCE_DM_PULLDOWN (0x1<<21)
#define FORCE_DP_PULLDOWN (0x1<<20)
#define FORCE_XCVRSEL (0x1<<19)
#define FORCE_SUSPENDM (0x1<<18)
#define FORCE_TERMSEL (0x1<<17)
#define FORCE_OPMODE (0x1<<16)
#define UTMI_MUXSEL (0x1<<15)
#define RG_RESET (0x1<<14)
#define RG_DATAIN (0xf<<10)
#define RG_TXVALIDH (0x1<<9)
#define RG_TXVALID (0x1<<8)
#define RG_DMPULLDOWN (0x1<<7)
#define RG_DPPULLDOWN (0x1<<6)
#define RG_XCVRSEL (0x3<<4)
#define RG_SUSPENDM (0x1<<3)
#define RG_TERMSEL (0x1<<2)
#define RG_OPMODE (0x3<<0)
#define RG_UART_MODE_OFST (30)
#define FORCE_UART_I_OFST (29)
#define FORCE_UART_BIAS_EN_OFST (28)
#define FORCE_UART_TX_OE_OFST (27)
#define FORCE_UART_EN_OFST (26)
#define FORCE_USB_CLKEN_OFST (25)
#define FORCE_DRVVBUS_OFST (24)
#define FORCE_DATAIN_OFST (23)
#define FORCE_TXVALID_OFST (22)
#define FORCE_DM_PULLDOWN_OFST (21)
#define FORCE_DP_PULLDOWN_OFST (20)
#define FORCE_XCVRSEL_OFST (19)
#define FORCE_SUSPENDM_OFST (18)
#define FORCE_TERMSEL_OFST (17)
#define FORCE_OPMODE_OFST (16)
#define UTMI_MUXSEL_OFST (15)
#define RG_RESET_OFST (14)
#define RG_DATAIN_OFST (10)
#define RG_TXVALIDH_OFST (9)
#define RG_TXVALID_OFST (8)
#define RG_DMPULLDOWN_OFST (7)
#define RG_DPPULLDOWN_OFST (6)
#define RG_XCVRSEL_OFST (4)
#define RG_SUSPENDM_OFST (3)
#define RG_TERMSEL_OFST (2)
#define RG_OPMODE_OFST (0)
/* U3D_U2PHYDTM1 */
#define RG_USB20_PRBS7_EN (0x1<<31)
#define RG_USB20_PRBS7_BITCNT (0x3f<<24)
#define RG_USB20_CLK48M_EN (0x1<<23)
#define RG_USB20_CLK60M_EN (0x1<<22)
#define RG_UART_I (0x1<<19)
#define RG_UART_BIAS_EN (0x1<<18)
#define RG_UART_TX_OE (0x1<<17)
#define RG_UART_EN (0x1<<16)
#define RG_IP_U2_PORT_POWER (0x1<<15)
#define FORCE_IP_U2_PORT_POWER (0x1<<14)
#define FORCE_VBUSVALID (0x1<<13)
#define FORCE_SESSEND (0x1<<12)
#define FORCE_BVALID (0x1<<11)
#define FORCE_AVALID (0x1<<10)
#define FORCE_IDDIG (0x1<<9)
#define FORCE_IDPULLUP (0x1<<8)
#define RG_VBUSVALID (0x1<<5)
#define RG_SESSEND (0x1<<4)
#define RG_BVALID (0x1<<3)
#define RG_AVALID (0x1<<2)
#define RG_IDDIG (0x1<<1)
#define RG_IDPULLUP (0x1<<0)
#define RG_USB20_PRBS7_EN_OFST (31)
#define RG_USB20_PRBS7_BITCNT_OFST (24)
#define RG_USB20_CLK48M_EN_OFST (23)
#define RG_USB20_CLK60M_EN_OFST (22)
#define RG_UART_I_OFST (19)
#define RG_UART_BIAS_EN_OFST (18)
#define RG_UART_TX_OE_OFST (17)
#define RG_UART_EN_OFST (16)
#define RG_IP_U2_PORT_POWER_OFST (15)
#define FORCE_IP_U2_PORT_POWER_OFST (14)
#define FORCE_VBUSVALID_OFST (13)
#define FORCE_SESSEND_OFST (12)
#define FORCE_BVALID_OFST (11)
#define FORCE_AVALID_OFST (10)
#define FORCE_IDDIG_OFST (9)
#define FORCE_IDPULLUP_OFST (8)
#define RG_VBUSVALID_OFST (5)
#define RG_SESSEND_OFST (4)
#define RG_BVALID_OFST (3)
#define RG_AVALID_OFST (2)
#define RG_IDDIG_OFST (1)
#define RG_IDPULLUP_OFST (0)
/* U3D_U2PHYDMON1 */
#define USB20_UART_O (0x1<<31)
#define RGO_USB20_LB_PASS (0x1<<30)
#define RGO_USB20_LB_DONE (0x1<<29)
#define AD_USB20_BVALID (0x1<<28)
#define USB20_IDDIG (0x1<<27)
#define AD_USB20_VBUSVALID (0x1<<26)
#define AD_USB20_SESSEND (0x1<<25)
#define AD_USB20_AVALID (0x1<<24)
#define USB20_LINE_STATE (0x3<<22)
#define USB20_HST_DISCON (0x1<<21)
#define USB20_TX_READY (0x1<<20)
#define USB20_RX_ERROR (0x1<<19)
#define USB20_RX_ACTIVE (0x1<<18)
#define USB20_RX_VALIDH (0x1<<17)
#define USB20_RX_VALID (0x1<<16)
#define USB20_DATA_OUT (0xffff<<0)
#define USB20_UART_O_OFST (31)
#define RGO_USB20_LB_PASS_OFST (30)
#define RGO_USB20_LB_DONE_OFST (29)
#define AD_USB20_BVALID_OFST (28)
#define USB20_IDDIG_OFST (27)
#define AD_USB20_VBUSVALID_OFST (26)
#define AD_USB20_SESSEND_OFST (25)
#define AD_USB20_AVALID_OFST (24)
#define USB20_LINE_STATE_OFST (22)
#define USB20_HST_DISCON_OFST (21)
#define USB20_TX_READY_OFST (20)
#define USB20_RX_ERROR_OFST (19)
#define USB20_RX_ACTIVE_OFST (18)
#define USB20_RX_VALIDH_OFST (17)
#define USB20_RX_VALID_OFST (16)
#define USB20_DATA_OUT_OFST (0)
/* ///////////////////////////////////////////// */
/** SSUSB_SIFSLV_U3PHYD_BASE **/
#define U3D_PHYD_MIX0 (SSUSB_SIFSLV_U3PHYD_BASE + 0x00)
#define U3D_PHYD_IMPCAL0 (SSUSB_SIFSLV_U3PHYD_BASE + 0x10)
#define U3D_PHYD_IMPCAL1 (SSUSB_SIFSLV_U3PHYD_BASE + 0x14)
#define U3D_PHYD_RX0 (SSUSB_SIFSLV_U3PHYD_BASE + 0x2c)
#define U3D_PHYD_T2RLB (SSUSB_SIFSLV_U3PHYD_BASE + 0x30)
#define U3D_PHYD_PIPE0 (SSUSB_SIFSLV_U3PHYD_BASE + 0x40)
#define U3D_PHYD_CDR0 (SSUSB_SIFSLV_U3PHYD_BASE + 0x58)
#define U3D_PHYD_CDR1 (SSUSB_SIFSLV_U3PHYD_BASE + 0x5c)
#define U3D_PHYD_EQ_EYE3 (SSUSB_SIFSLV_U3PHYD_BASE + 0xdc)
#define U3D_PHYD_MIX6 (SSUSB_SIFSLV_U3PHYD_BASE + 0xe8)
/* U3D_PHYD_IMPCAL0 */
#define RG_SSUSB_FORCE_TX_IMPSEL (0x1<<31)
#define RG_SSUSB_TX_IMPCAL_EN (0x1<<30)
#define RG_SSUSB_FORCE_TX_IMPCAL_EN (0x1<<29)
#define RG_SSUSB_TX_IMPSEL (0x1f<<24)
#define RG_SSUSB_TX_IMPCAL_CALCYC (0x3f<<16)
#define RG_SSUSB_TX_IMPCAL_STBCYC (0x1f<<10)
#define RG_SSUSB_TX_IMPCAL_CYCCNT (0x3ff<<0)
#define RG_SSUSB_FORCE_TX_IMPSEL_OFST (31)
#define RG_SSUSB_TX_IMPCAL_EN_OFST (30)
#define RG_SSUSB_FORCE_TX_IMPCAL_EN_OFST (29)
#define RG_SSUSB_TX_IMPSEL_OFST (24)
#define RG_SSUSB_TX_IMPCAL_CALCYC_OFST (16)
#define RG_SSUSB_TX_IMPCAL_STBCYC_OFST (10)
#define RG_SSUSB_TX_IMPCAL_CYCCNT_OFST (0)
/* U3D_PHYD_IMPCAL1 */
#define RG_SSUSB_FORCE_RX_IMPSEL (0x1<<31)
#define RG_SSUSB_RX_IMPCAL_EN (0x1<<30)
#define RG_SSUSB_FORCE_RX_IMPCAL_EN (0x1<<29)
#define RG_SSUSB_RX_IMPSEL (0x1f<<24)
#define RG_SSUSB_RX_IMPCAL_CALCYC (0x3f<<16)
#define RG_SSUSB_RX_IMPCAL_STBCYC (0x1f<<10)
#define RG_SSUSB_RX_IMPCAL_CYCCNT (0x3ff<<0)
#define RG_SSUSB_FORCE_RX_IMPSEL_OFST (31)
#define RG_SSUSB_RX_IMPCAL_EN_OFST (30)
#define RG_SSUSB_FORCE_RX_IMPCAL_EN_OFST (29)
#define RG_SSUSB_RX_IMPSEL_OFST (24)
#define RG_SSUSB_RX_IMPCAL_CALCYC_OFST (16)
#define RG_SSUSB_RX_IMPCAL_STBCYC_OFST (10)
#define RG_SSUSB_RX_IMPCAL_CYCCNT_OFST (0)
/* U3D_PHYD_CDR0 */
#define RG_SSUSB_CDR_BIC_LTR (0xf<<28)
#define RG_SSUSB_CDR_BIC_LTR_OFST (28)
/* U3D_PHYD_CDR1 */
#define RG_SSUSB_CDR_BIR_LTD1 (0x1f<<24)
#define RG_SSUSB_CDR_BIR_LTR (0x1f<<16)
#define RG_SSUSB_CDR_BIR_LTD0 (0x1f<<8)
#define RG_SSUSB_CDR_BW_SEL (0x3<<6)
#define RG_SSUSB_CDR_BIC_LTD1 (0xf<<0)
#define RG_SSUSB_CDR_BIR_LTD1_OFST (24)
#define RG_SSUSB_CDR_BIR_LTR_OFST (16)
#define RG_SSUSB_CDR_BIR_LTD0_OFST (8)
#define RG_SSUSB_CDR_BW_SEL_OFST (6)
#define RG_SSUSB_CDR_BIC_LTD1_OFST (0)
/* U3D_PHYD_MIX6 */
#define RG_SSUSB_IDEMSEL (0x1f<<21)
#define RG_SSUSB_FORCE_IDEMSEL (0x1<<20)
#define RG_SSUSB_IDRVSEL (0x1f<<15)
#define RG_SSUSB_FORCE_IDRVSEL (0x1<<14)
#define RG_SSUSB_IDEMSEL_OFST (21)
#define RG_SSUSB_FORCE_IDEMSEL_OFST (20)
#define RG_SSUSB_IDRVSEL_OFST (15)
#define RG_SSUSB_FORCE_IDRVSEL_OFST (14)
/* ///////////////////////////////////////////// */
/** SSUSB_USB30_PHYA_SIV_B2_BASE **/
#define U3D_B2_PHYD_RXDET2 (SSUSB_USB30_PHYA_SIV_B2_BASE + 0x2c)
/* U3D_B2_PHYD_RXDET2 */
#define RG_SSUSB_PHYD_TRAINDEC_FORCE_CGEN (0x1<<31)
#define RG_SSUSB_PHYD_BERTLB_FORCE_CGEN (0x1<<30)
#define RG_SSUSB_PHYD_T2RLB_FORCE_CGEN (0x1<<29)
#define RG_SSUSB_LCK2REF_EXT_EN (0x1<<28)
#define RG_SSUSB_G2_LCK2REF_EXT_SEL (0xf<<24)
#define RG_SSUSB_LCK2REF_EXT_SEL (0xf<<20)
#define RG_SSUSB_PDN_T_SEL (0x3<<18)
#define RG_SSUSB_RXDET_STB3_SET_P3 (0x1ff<<9)
#define RG_SSUSB_RXDET_STB2_SET_P3 (0x1ff<<0)
#define RG_SSUSB_PHYD_TRAINDEC_FORCE_CGEN_OFST (31)
#define RG_SSUSB_PHYD_BERTLB_FORCE_CGEN_OFST (30)
#define RG_SSUSB_PHYD_T2RLB_FORCE_CGEN_OFST (29)
#define RG_SSUSB_LCK2REF_EXT_EN_OFST (28)
#define RG_SSUSB_G2_LCK2REF_EXT_SEL_OFST (24)
#define RG_SSUSB_LCK2REF_EXT_SEL_OFST (20)
#define RG_SSUSB_PDN_T_SEL_OFST (18)
#define RG_SSUSB_RXDET_STB3_SET_P3_OFST (9)
#define RG_SSUSB_RXDET_STB2_SET_P3_OFST (0)
/* ///////////////////////////////////////////// */
/** SSUSB_USB30_PHYA_SIV_B_BASE **/
#define U3D_USB30_PHYA_REG0 (SSUSB_USB30_PHYA_SIV_B_BASE + 0x0000)
#define U3D_USB30_PHYA_REG1 (SSUSB_USB30_PHYA_SIV_B_BASE + 0x0004)
#define U3D_USB30_PHYA_REG6 (SSUSB_USB30_PHYA_SIV_B_BASE + 0x0018)
#define U3D_USB30_PHYA_REG8 (SSUSB_USB30_PHYA_SIV_B_BASE + 0x0020)
#define U3D_USB30_PHYA_REGB (SSUSB_USB30_PHYA_SIV_B_BASE + 0x002C)
/* U3D_USB30_PHYA_REG0 */
#define RG_SSUSB_BGR_EN (0x1<<31)
#define RG_SSUSB_CHPEN (0x1<<30)
#define RG_SSUSB_BG_DIV (0x3<<28)
#define RG_SSUSB_INTR_EN (0x1<<26)
#define RG_SSUSB_MPX_EN (0x1<<24)
#define RG_SSUSB_MPX_SEL (0xff<<16)
#define RG_SSUSB_IEXT_INTR_CTRL (0x3f<<10)
#define RG_SSUSB_VRT_VREF_SEL (0xf<<6)
#define RG_SSUSB_REF_EN (0x1<<5)
#define RG_SSUSB_BG_MONEN (0x1<<4)
#define RG_SSUSB_INT_BIAS_SEL (0x1<<3)
#define RG_SSUSB_EXT_BIAS_SEL (0x1<<2)
#define RG_SSUSB_BGR_EN_OFST (31)
#define RG_SSUSB_CHPEN_OFST (30)
#define RG_SSUSB_BG_DIV_OFST (28)
#define RG_SSUSB_INTR_EN_OFST (26)
#define RG_SSUSB_MPX_EN_OFST (24)
#define RG_SSUSB_MPX_SEL_OFST (16)
#define RG_SSUSB_IEXT_INTR_CTRL_OFST (10)
#define RG_SSUSB_RG_SSUSB_VRT_VREF_SEL (6)
#define RG_SSUSB_REF_EN_OFST (5)
#define RG_SSUSB_BG_MONEN_OFST (4)
#define RG_SSUSB_INT_BIAS_SEL_OFST (3)
#define RG_SSUSB_EXT_BIAS_SEL_OFST (2)
/* U3D_USB30_PHYA_REG1 */
#define RG_SSUSB_VUSB10_ON (1<<29)
#define RG_SSUSB_VUSB10_ON_OFST (29)
/* U3D_USB30_PHYA_REG6 */
#define RG_SSUSB_TX_EIDLE_CM (0xf<<28)
#define RG_SSUSB_RXLBTX_EN (0x1<<27)
#define RG_SSUSB_TXLBRX_EN (0x1<<26)
#define RG_SSUSB_RESERVE6 (0x1<<22)
#define RG_SSUSB_RESERVE (0x3ff<<16)
#define RG_SSUSB_PLL_POSDIV (0x3<<14)
#define RG_SSUSB_PLL_AUTOK_LOAD (0x1<<13)
#define RG_SSUSB_PLL_VOD_EN (0x1<<12)
#define RG_SSUSB_PLL_MONREF_EN (0x1<<11)
#define RG_SSUSB_PLL_MONCK_EN (0x1<<10)
#define RG_SSUSB_PLL_MONVC_EN (0x1<<9)
#define RG_SSUSB_PLL_RLH_EN (0x1<<8)
#define RG_SSUSB_PLL_AUTOK_KS (0x3<<6)
#define RG_SSUSB_PLL_AUTOK_KF (0x3<<4)
#define RG_SSUSB_PLL_RST_DLY (0x3<<2)
#define RG_SSUSB_TX_EIDLE_CM_OFST (28)
#define RG_SSUSB_RXLBTX_EN_OFST (27)
#define RG_SSUSB_TXLBRX_EN_OFST (26)
#define RG_SSUSB_RESERVE6_OFST (22)
#define RG_SSUSB_RESERVE_OFST (16)
#define RG_SSUSB_PLL_POSDIV_OFST (14)
#define RG_SSUSB_PLL_AUTOK_LOAD_OFST (13)
#define RG_SSUSB_PLL_VOD_EN_OFST (12)
#define RG_SSUSB_PLL_MONREF_EN_OFST (11)
#define RG_SSUSB_PLL_MONCK_EN_OFST (10)
#define RG_SSUSB_PLL_MONVC_EN_OFST (9)
#define RG_SSUSB_PLL_RLH_EN_OFST (8)
#define RG_SSUSB_PLL_AUTOK_KS_OFST (6)
#define RG_SSUSB_PLL_AUTOK_KF_OFST (4)
#define RG_SSUSB_PLL_RST_DLY_OFST (2)
/* U3D_USB30_PHYA_REG8 */
#define RG_SSUSB_CDR_BYPASS (0x3<<3)
#define RG_SSUSB_CDR_BYPASS_OFST (3)
/* U3D_USB30_PHYA_REGB */
#define RG_SSUSB_RESERVE10 (0x1<<10)
#define RG_SSUSB_RESERVE10_OFST (10)
/* ///////////////////////////////////////////// */
/** SSUSB_SIFSLV_U3PHYA_DA_BASE **/
#define U3D_U3PHYA_DA_REG0 (SSUSB_SIFSLV_U3PHYA_DA_BASE + 0x0)
#define U3D_U3PHYA_DA_REG32 (SSUSB_SIFSLV_U3PHYA_DA_BASE + 0x0060)
#define U3D_U3PHYA_DA_REG36 (SSUSB_SIFSLV_U3PHYA_DA_BASE + 0x0070)
/* U3D_U3PHYA_DA_REG0 */
#define RG_PCIE_SPEED_PE2D (0x1<<24)
#define RG_PCIE_SPEED_PE2H (0x1<<23)
#define RG_PCIE_SPEED_PE1D (0x1<<22)
#define RG_PCIE_SPEED_PE1H (0x1<<21)
#define RG_PCIE_SPEED_U3 (0x1<<20)
#define RG_SSUSB_XTAL_EXT_EN_PE2D (0x3<<18)
#define RG_SSUSB_XTAL_EXT_EN_PE2H (0x3<<16)
#define RG_SSUSB_XTAL_EXT_EN_PE1D (0x3<<14)
#define RG_SSUSB_XTAL_EXT_EN_PE1H (0x3<<12)
#define RG_SSUSB_XTAL_EXT_EN_U3 (0x3<<10)
#define RG_SSUSB_CDR_REFCK_SEL_PE2D (0x3<<8)
#define RG_SSUSB_CDR_REFCK_SEL_PE2H (0x3<<6)
#define RG_SSUSB_CDR_REFCK_SEL_PE1D (0x3<<4)
#define RG_SSUSB_CDR_REFCK_SEL_PE1H (0x3<<2)
#define RG_SSUSB_CDR_REFCK_SEL_U3 (0x3<<0)
#define RG_PCIE_SPEED_PE2D_OFST (24)
#define RG_PCIE_SPEED_PE2H_OFST (23)
#define RG_PCIE_SPEED_PE1D_OFST (22)
#define RG_PCIE_SPEED_PE1H_OFST (21)
#define RG_PCIE_SPEED_U3_OFST (20)
#define RG_SSUSB_XTAL_EXT_EN_PE2D_OFST (18)
#define RG_SSUSB_XTAL_EXT_EN_PE2H_OFST (16)
#define RG_SSUSB_XTAL_EXT_EN_PE1D_OFST (14)
#define RG_SSUSB_XTAL_EXT_EN_PE1H_OFST (12)
#define RG_SSUSB_XTAL_EXT_EN_U3_OFST (10)
#define RG_SSUSB_CDR_REFCK_SEL_PE2D_OFST (8)
#define RG_SSUSB_CDR_REFCK_SEL_PE2H_OFST (6)
#define RG_SSUSB_CDR_REFCK_SEL_PE1D_OFST (4)
#define RG_SSUSB_CDR_REFCK_SEL_PE1H_OFST (2)
#define RG_SSUSB_CDR_REFCK_SEL_U3_OFST (0)
/* U3D_U3PHYA_DA_REG32 */
#define RG_SSUSB_EQ_RSTEP1_PE2D_OFST (30)
#define RG_SSUSB_EQ_RSTEP1_PE2H_OFST (28)
#define RG_SSUSB_EQ_RSTEP1_PE1D_OFST (26)
#define RG_SSUSB_EQ_RSTEP1_PE1H_OFST (24)
#define RG_SSUSB_EQ_RSTEP1_U3_OFST (22)
#define RG_SSUSB_LFPS_DEGLITCH_PE2D_OFST (20)
#define RG_SSUSB_LFPS_DEGLITCH_PE2H_OFST (18)
#define RG_SSUSB_LFPS_DEGLITCH_PE1D_OFST (16)
#define RG_SSUSB_LFPS_DEGLITCH_PE1H_OFST (14)
#define RG_SSUSB_LFPS_DEGLITCH_U3_OFST (12)
#define RG_SSUSB_CDR_KVSEL_PE2D_OFST (11)
#define RG_SSUSB_CDR_KVSEL_PE2H_OFST (10)
#define RG_SSUSB_CDR_KVSEL_PE1D_OFST (9)
#define RG_SSUSB_CDR_KVSEL_PE1H_OFST (8)
#define RG_SSUSB_CDR_KVSEL_U3_OFST (7)
#define RG_SSUSB_CDR_FBDIV_PE2D_OFST (0)
/* U3D_reg32 */
#define RG_SSUSB_EQ_RSTEP1_PE2D (0x3<<30)
#define RG_SSUSB_EQ_RSTEP1_PE2H (0x3<<28)
#define RG_SSUSB_EQ_RSTEP1_PE1D (0x3<<26)
#define RG_SSUSB_EQ_RSTEP1_PE1H (0x3<<24)
#define RG_SSUSB_EQ_RSTEP1_U3 (0x3<<22)
#define RG_SSUSB_LFPS_DEGLITCH_PE2D (0x3<<20)
#define RG_SSUSB_LFPS_DEGLITCH_PE2H (0x3<<18)
#define RG_SSUSB_LFPS_DEGLITCH_PE1D (0x3<<16)
#define RG_SSUSB_LFPS_DEGLITCH_PE1H (0x3<<14)
#define RG_SSUSB_LFPS_DEGLITCH_U3 (0x3<<12)
#define RG_SSUSB_CDR_KVSEL_PE2D (0x1<<11)
#define RG_SSUSB_CDR_KVSEL_PE2H (0x1<<10)
#define RG_SSUSB_CDR_KVSEL_PE1D (0x1<<9)
#define RG_SSUSB_CDR_KVSEL_PE1H (0x1<<8)
#define RG_SSUSB_CDR_KVSEL_U3 (0x1<<7)
#define RG_SSUSB_CDR_FBDIV_PE2D (0x7f<<0)
/* U3D_U3PHYA_DA_REG36*/
#define RG_SSUSB_DA_SSUSB_PLL_BAND (0x3F<<11)
#define RG_SSUSB_DA_SSUSB_PLL_BAND_OFST (11)
/* ///////////////////////////////////////////// */
extern u32 get_devinfo_with_index(u32 index);
#endif
File diff suppressed because it is too large. Load diff
+257
View File
@@ -0,0 +1,257 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
* Author: Stanley Chu <stanley.chu@mediatek.com>
*/
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/phy/phy.h>
#include <linux/platform_device.h>
/* mphy register and offsets */
#define MP_GLB_DIG_8C 0x008C
#define FRC_PLL_ISO_EN BIT(8)
#define PLL_ISO_EN BIT(9)
#define FRC_FRC_PWR_ON BIT(10)
#define PLL_PWR_ON BIT(11)
#define MP_LN_DIG_RX_9C 0xA09C
#define FSM_DIFZ_FRC BIT(18)
#define MP_LN_DIG_RX_AC 0xA0AC
#define FRC_RX_SQ_EN BIT(0)
#define RX_SQ_EN BIT(1)
#define MP_LN_RX_44 0xB044
#define FRC_CDR_PWR_ON BIT(17)
#define CDR_PWR_ON BIT(18)
#define FRC_CDR_ISO_EN BIT(19)
#define CDR_ISO_EN BIT(20)
struct ufs_mtk_phy {
struct device *dev;
void __iomem *mmio;
struct clk *mp_clk;
struct clk *unipro_clk;
};
static inline u32 mphy_readl(struct ufs_mtk_phy *phy, u32 reg)
{
return readl(phy->mmio + reg);
}
static inline void mphy_writel(struct ufs_mtk_phy *phy, u32 val, u32 reg)
{
writel(val, phy->mmio + reg);
}
static void mphy_set_bit(struct ufs_mtk_phy *phy, u32 reg, u32 bit)
{
u32 val;
val = mphy_readl(phy, reg);
val |= bit;
mphy_writel(phy, val, reg);
}
static void mphy_clr_bit(struct ufs_mtk_phy *phy, u32 reg, u32 bit)
{
u32 val;
val = mphy_readl(phy, reg);
val &= ~bit;
mphy_writel(phy, val, reg);
}
static struct ufs_mtk_phy *get_ufs_mtk_phy(struct phy *generic_phy)
{
return (struct ufs_mtk_phy *) phy_get_drvdata(generic_phy);
}
static int ufs_mtk_phy_clk_init(struct ufs_mtk_phy *phy)
{
struct device *dev = phy->dev;
phy->unipro_clk = devm_clk_get(dev, "unipro");
if (IS_ERR(phy->unipro_clk)) {
dev_info(dev, "unipro clock is not found, ignored.");
phy->unipro_clk = NULL;
}
phy->mp_clk = devm_clk_get(dev, "mp");
if (IS_ERR(phy->mp_clk)) {
dev_info(dev, "mp clock is not found, ignored.");
phy->mp_clk = NULL;
}
return 0;
}
static void ufs_mtk_phy_set_active(struct ufs_mtk_phy *phy)
{
/* release DA_MP_PLL_PWR_ON */
mphy_set_bit(phy, MP_GLB_DIG_8C, PLL_PWR_ON);
mphy_clr_bit(phy, MP_GLB_DIG_8C, FRC_FRC_PWR_ON);
/* release DA_MP_PLL_ISO_EN */
mphy_clr_bit(phy, MP_GLB_DIG_8C, PLL_ISO_EN);
mphy_clr_bit(phy, MP_GLB_DIG_8C, FRC_PLL_ISO_EN);
/* release DA_MP_CDR_PWR_ON */
mphy_set_bit(phy, MP_LN_RX_44, CDR_PWR_ON);
mphy_clr_bit(phy, MP_LN_RX_44, FRC_CDR_PWR_ON);
/* release DA_MP_CDR_ISO_EN */
mphy_clr_bit(phy, MP_LN_RX_44, CDR_ISO_EN);
mphy_clr_bit(phy, MP_LN_RX_44, FRC_CDR_ISO_EN);
/* release DA_MP_RX0_SQ_EN */
mphy_set_bit(phy, MP_LN_DIG_RX_AC, RX_SQ_EN);
mphy_clr_bit(phy, MP_LN_DIG_RX_AC, FRC_RX_SQ_EN);
/* delay 1us to wait DIFZ stable */
udelay(1);
/* release DIFZ */
mphy_clr_bit(phy, MP_LN_DIG_RX_9C, FSM_DIFZ_FRC);
}
static void ufs_mtk_phy_set_deep_hibern(struct ufs_mtk_phy *phy)
{
/* force DIFZ */
mphy_set_bit(phy, MP_LN_DIG_RX_9C, FSM_DIFZ_FRC);
/* force DA_MP_RX0_SQ_EN */
mphy_set_bit(phy, MP_LN_DIG_RX_AC, FRC_RX_SQ_EN);
mphy_clr_bit(phy, MP_LN_DIG_RX_AC, RX_SQ_EN);
/* force DA_MP_CDR_ISO_EN */
mphy_set_bit(phy, MP_LN_RX_44, FRC_CDR_ISO_EN);
mphy_set_bit(phy, MP_LN_RX_44, CDR_ISO_EN);
/* force DA_MP_CDR_PWR_ON */
mphy_set_bit(phy, MP_LN_RX_44, FRC_CDR_PWR_ON);
mphy_clr_bit(phy, MP_LN_RX_44, CDR_PWR_ON);
/* force DA_MP_PLL_ISO_EN */
mphy_set_bit(phy, MP_GLB_DIG_8C, FRC_PLL_ISO_EN);
mphy_set_bit(phy, MP_GLB_DIG_8C, PLL_ISO_EN);
/* force DA_MP_PLL_PWR_ON */
mphy_set_bit(phy, MP_GLB_DIG_8C, FRC_FRC_PWR_ON);
mphy_clr_bit(phy, MP_GLB_DIG_8C, PLL_PWR_ON);
}
#define ufs_mtk_phy_clk_prepare_enable(clk) \
clk ? clk_prepare_enable(clk) : 0
#define ufs_mtk_phy_clk_disable_unprepare(clk) \
clk ? clk_disable_unprepare(clk) : 0
static int ufs_mtk_phy_power_on(struct phy *generic_phy)
{
struct ufs_mtk_phy *phy = get_ufs_mtk_phy(generic_phy);
int ret;
ret = ufs_mtk_phy_clk_prepare_enable(phy->unipro_clk);
if (ret) {
dev_err(phy->dev, "unipro_clk enable failed %d\n", ret);
goto out;
}
ret = ufs_mtk_phy_clk_prepare_enable(phy->mp_clk);
if (ret) {
dev_err(phy->dev, "mp_clk enable failed %d\n", ret);
goto out_unprepare_unipro_clk;
}
ufs_mtk_phy_set_active(phy);
return 0;
out_unprepare_unipro_clk:
ufs_mtk_phy_clk_disable_unprepare(phy->unipro_clk);
out:
return ret;
}
static int ufs_mtk_phy_power_off(struct phy *generic_phy)
{
struct ufs_mtk_phy *phy = get_ufs_mtk_phy(generic_phy);
ufs_mtk_phy_set_deep_hibern(phy);
ufs_mtk_phy_clk_disable_unprepare(phy->unipro_clk);
ufs_mtk_phy_clk_disable_unprepare(phy->mp_clk);
return 0;
}
static const struct phy_ops ufs_mtk_phy_ops = {
.power_on = ufs_mtk_phy_power_on,
.power_off = ufs_mtk_phy_power_off,
.owner = THIS_MODULE,
};
static int ufs_mtk_phy_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct phy *generic_phy;
struct phy_provider *phy_provider;
struct resource *res;
struct ufs_mtk_phy *phy;
int ret;
phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
if (!phy)
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
phy->mmio = devm_ioremap_resource(dev, res);
if (IS_ERR(phy->mmio))
return PTR_ERR(phy->mmio);
phy->dev = dev;
ret = ufs_mtk_phy_clk_init(phy);
if (ret) {
dev_err(dev, "%s mtk phy clk init fail: %d\n", __func__, ret);
return ret;
}
generic_phy = devm_phy_create(dev, NULL, &ufs_mtk_phy_ops);
if (IS_ERR(generic_phy)) {
dev_err(dev, "%s mtk phy clk create fail: %d\n", __func__, PTR_ERR(generic_phy));
return PTR_ERR(generic_phy);
}
phy_set_drvdata(generic_phy, phy);
phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
if (IS_ERR(phy_provider)) {
dev_err(dev, "%s mtk phy clk register fail: %d\n", __func__, PTR_ERR(phy_provider));
}
return PTR_ERR_OR_ZERO(phy_provider);
}
static const struct of_device_id ufs_mtk_phy_of_match[] = {
{.compatible = "mediatek,mt8183-ufsphy"},
{},
};
MODULE_DEVICE_TABLE(of, ufs_mtk_phy_of_match);
static struct platform_driver ufs_mtk_phy_driver = {
.probe = ufs_mtk_phy_probe,
.driver = {
.of_match_table = ufs_mtk_phy_of_match,
.name = "ufs_mtk_phy",
},
};
module_platform_driver(ufs_mtk_phy_driver);
MODULE_DESCRIPTION("Universal Flash Storage (UFS) MediaTek MPHY");
MODULE_AUTHOR("Stanley Chu <stanley.chu@medaitek.com>");
MODULE_LICENSE("GPL v2");
+600
View File
@@ -0,0 +1,600 @@
// SPDX-License-Identifier: GPL-2.0
/*
* MediaTek USB3.1 gen2 xsphy Driver
*
* Copyright (c) 2018 MediaTek Inc.
* Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
*
*/
#include <dt-bindings/phy/phy.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/phy/phy.h>
#include <linux/platform_device.h>
/* u2 phy banks */
#define SSUSB_SIFSLV_MISC 0x000
#define SSUSB_SIFSLV_U2FREQ 0x100
#define SSUSB_SIFSLV_U2PHY_COM 0x300
/* u3 phy shared banks */
#define SSPXTP_SIFSLV_DIG_GLB 0x000
#define SSPXTP_SIFSLV_PHYA_GLB 0x100
/* u3 phy banks */
#define SSPXTP_SIFSLV_DIG_LN_TOP 0x000
#define SSPXTP_SIFSLV_DIG_LN_TX0 0x100
#define SSPXTP_SIFSLV_DIG_LN_RX0 0x200
#define SSPXTP_SIFSLV_DIG_LN_DAIF 0x300
#define SSPXTP_SIFSLV_PHYA_LN 0x400
#define XSP_U2FREQ_FMCR0 ((SSUSB_SIFSLV_U2FREQ) + 0x00)
#define P2F_RG_FREQDET_EN BIT(24)
#define P2F_RG_CYCLECNT GENMASK(23, 0)
#define P2F_RG_CYCLECNT_VAL(x) ((P2F_RG_CYCLECNT) & (x))
#define XSP_U2FREQ_MMONR0 ((SSUSB_SIFSLV_U2FREQ) + 0x0c)
#define XSP_U2FREQ_FMMONR1 ((SSUSB_SIFSLV_U2FREQ) + 0x10)
#define P2F_RG_FRCK_EN BIT(8)
#define P2F_USB_FM_VALID BIT(0)
#define XSP_USBPHYACR0 ((SSUSB_SIFSLV_U2PHY_COM) + 0x00)
#define P2A0_RG_INTR_EN BIT(5)
#define XSP_USBPHYACR1 ((SSUSB_SIFSLV_U2PHY_COM) + 0x04)
#define P2A1_RG_INTR_CAL GENMASK(23, 19)
#define P2A1_RG_INTR_CAL_VAL(x) ((0x1f & (x)) << 19)
#define P2A1_RG_VRT_SEL GENMASK(14, 12)
#define P2A1_RG_VRT_SEL_VAL(x) ((0x7 & (x)) << 12)
#define P2A1_RG_TERM_SEL GENMASK(10, 8)
#define P2A1_RG_TERM_SEL_VAL(x) ((0x7 & (x)) << 8)
#define XSP_USBPHYACR5 ((SSUSB_SIFSLV_U2PHY_COM) + 0x014)
#define P2A5_RG_HSTX_SRCAL_EN BIT(15)
#define P2A5_RG_HSTX_SRCTRL GENMASK(14, 12)
#define P2A5_RG_HSTX_SRCTRL_VAL(x) ((0x7 & (x)) << 12)
#define XSP_USBPHYACR6 ((SSUSB_SIFSLV_U2PHY_COM) + 0x018)
#define P2A6_RG_BC11_SW_EN BIT(23)
#define P2A6_RG_OTG_VBUSCMP_EN BIT(20)
#define XSP_U2PHYDTM1 ((SSUSB_SIFSLV_U2PHY_COM) + 0x06C)
#define P2D_FORCE_IDDIG BIT(9)
#define P2D_RG_VBUSVALID BIT(5)
#define P2D_RG_SESSEND BIT(4)
#define P2D_RG_AVALID BIT(2)
#define P2D_RG_IDDIG BIT(1)
#define SSPXTP_PHYA_GLB_00 ((SSPXTP_SIFSLV_PHYA_GLB) + 0x00)
#define RG_XTP_GLB_BIAS_INTR_CTRL GENMASK(21, 16)
#define RG_XTP_GLB_BIAS_INTR_CTRL_VAL(x) ((0x3f & (x)) << 16)
#define SSPXTP_PHYA_LN_04 ((SSPXTP_SIFSLV_PHYA_LN) + 0x04)
#define RG_XTP_LN0_TX_IMPSEL GENMASK(4, 0)
#define RG_XTP_LN0_TX_IMPSEL_VAL(x) (0x1f & (x))
#define SSPXTP_PHYA_LN_14 ((SSPXTP_SIFSLV_PHYA_LN) + 0x014)
#define RG_XTP_LN0_RX_IMPSEL GENMASK(4, 0)
#define RG_XTP_LN0_RX_IMPSEL_VAL(x) (0x1f & (x))
#define XSP_REF_CLK 26 /* MHZ */
#define XSP_SLEW_RATE_COEF 17
#define XSP_SR_COEF_DIVISOR 1000
#define XSP_FM_DET_CYCLE_CNT 1024
struct xsphy_instance {
struct phy *phy;
void __iomem *port_base;
struct clk *ref_clk; /* reference clock of anolog phy */
u32 index;
u32 type;
/* only for HQA test */
int efuse_intr;
int efuse_tx_imp;
int efuse_rx_imp;
/* u2 eye diagram */
int eye_src;
int eye_vrt;
int eye_term;
};
struct mtk_xsphy {
struct device *dev;
void __iomem *glb_base; /* only shared u3 sif */
struct xsphy_instance **phys;
int nphys;
int src_ref_clk; /* MHZ, reference clock for slew rate calibrate */
int src_coef; /* coefficient for slew rate calibrate */
};
static void u2_phy_slew_rate_calibrate(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
int calib_val;
int fm_out;
u32 tmp;
/* use force value */
if (inst->eye_src)
return;
/* enable USB ring oscillator */
tmp = readl(pbase + XSP_USBPHYACR5);
tmp |= P2A5_RG_HSTX_SRCAL_EN;
writel(tmp, pbase + XSP_USBPHYACR5);
udelay(1); /* wait clock stable */
/* enable free run clock */
tmp = readl(pbase + XSP_U2FREQ_FMMONR1);
tmp |= P2F_RG_FRCK_EN;
writel(tmp, pbase + XSP_U2FREQ_FMMONR1);
/* set cycle count as 1024 */
tmp = readl(pbase + XSP_U2FREQ_FMCR0);
tmp &= ~(P2F_RG_CYCLECNT);
tmp |= P2F_RG_CYCLECNT_VAL(XSP_FM_DET_CYCLE_CNT);
writel(tmp, pbase + XSP_U2FREQ_FMCR0);
/* enable frequency meter */
tmp = readl(pbase + XSP_U2FREQ_FMCR0);
tmp |= P2F_RG_FREQDET_EN;
writel(tmp, pbase + XSP_U2FREQ_FMCR0);
/* ignore return value */
readl_poll_timeout(pbase + XSP_U2FREQ_FMMONR1, tmp,
(tmp & P2F_USB_FM_VALID), 10, 200);
fm_out = readl(pbase + XSP_U2FREQ_MMONR0);
/* disable frequency meter */
tmp = readl(pbase + XSP_U2FREQ_FMCR0);
tmp &= ~P2F_RG_FREQDET_EN;
writel(tmp, pbase + XSP_U2FREQ_FMCR0);
/* disable free run clock */
tmp = readl(pbase + XSP_U2FREQ_FMMONR1);
tmp &= ~P2F_RG_FRCK_EN;
writel(tmp, pbase + XSP_U2FREQ_FMMONR1);
if (fm_out) {
/* (1024 / FM_OUT) x reference clock frequency x coefficient */
tmp = xsphy->src_ref_clk * xsphy->src_coef;
tmp = (tmp * XSP_FM_DET_CYCLE_CNT) / fm_out;
calib_val = DIV_ROUND_CLOSEST(tmp, XSP_SR_COEF_DIVISOR);
} else {
/* if FM detection fail, set default value */
calib_val = 3;
}
dev_dbg(xsphy->dev, "phy.%d, fm_out:%d, calib:%d (clk:%d, coef:%d)\n",
inst->index, fm_out, calib_val,
xsphy->src_ref_clk, xsphy->src_coef);
/* set HS slew rate */
tmp = readl(pbase + XSP_USBPHYACR5);
tmp &= ~P2A5_RG_HSTX_SRCTRL;
tmp |= P2A5_RG_HSTX_SRCTRL_VAL(calib_val);
writel(tmp, pbase + XSP_USBPHYACR5);
/* disable USB ring oscillator */
tmp = readl(pbase + XSP_USBPHYACR5);
tmp &= ~P2A5_RG_HSTX_SRCAL_EN;
writel(tmp, pbase + XSP_USBPHYACR5);
}
static void u2_phy_instance_init(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
u32 tmp;
/* DP/DM BC1.1 path Disable */
tmp = readl(pbase + XSP_USBPHYACR6);
tmp &= ~P2A6_RG_BC11_SW_EN;
writel(tmp, pbase + XSP_USBPHYACR6);
tmp = readl(pbase + XSP_USBPHYACR0);
tmp |= P2A0_RG_INTR_EN;
writel(tmp, pbase + XSP_USBPHYACR0);
}
static void u2_phy_instance_power_on(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
u32 index = inst->index;
u32 tmp;
tmp = readl(pbase + XSP_USBPHYACR6);
tmp |= P2A6_RG_OTG_VBUSCMP_EN;
writel(tmp, pbase + XSP_USBPHYACR6);
tmp = readl(pbase + XSP_U2PHYDTM1);
tmp |= P2D_RG_VBUSVALID | P2D_RG_AVALID;
tmp &= ~P2D_RG_SESSEND;
writel(tmp, pbase + XSP_U2PHYDTM1);
dev_dbg(xsphy->dev, "%s(%d)\n", __func__, index);
}
static void u2_phy_instance_power_off(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
u32 index = inst->index;
u32 tmp;
tmp = readl(pbase + XSP_USBPHYACR6);
tmp &= ~P2A6_RG_OTG_VBUSCMP_EN;
writel(tmp, pbase + XSP_USBPHYACR6);
tmp = readl(pbase + XSP_U2PHYDTM1);
tmp &= ~(P2D_RG_VBUSVALID | P2D_RG_AVALID);
tmp |= P2D_RG_SESSEND;
writel(tmp, pbase + XSP_U2PHYDTM1);
dev_dbg(xsphy->dev, "%s(%d)\n", __func__, index);
}
static void u2_phy_instance_set_mode(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst,
enum phy_mode mode)
{
u32 tmp;
tmp = readl(inst->port_base + XSP_U2PHYDTM1);
switch (mode) {
case PHY_MODE_USB_DEVICE:
tmp |= P2D_FORCE_IDDIG | P2D_RG_IDDIG;
break;
case PHY_MODE_USB_HOST:
tmp |= P2D_FORCE_IDDIG;
tmp &= ~P2D_RG_IDDIG;
break;
case PHY_MODE_USB_OTG:
tmp &= ~(P2D_FORCE_IDDIG | P2D_RG_IDDIG);
break;
default:
return;
}
writel(tmp, inst->port_base + XSP_U2PHYDTM1);
}
static void phy_parse_property(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
struct device *dev = &inst->phy->dev;
switch (inst->type) {
case PHY_TYPE_USB2:
device_property_read_u32(dev, "mediatek,efuse-intr",
&inst->efuse_intr);
device_property_read_u32(dev, "mediatek,eye-src",
&inst->eye_src);
device_property_read_u32(dev, "mediatek,eye-vrt",
&inst->eye_vrt);
device_property_read_u32(dev, "mediatek,eye-term",
&inst->eye_term);
dev_dbg(dev, "intr:%d, src:%d, vrt:%d, term:%d\n",
inst->efuse_intr, inst->eye_src,
inst->eye_vrt, inst->eye_term);
break;
case PHY_TYPE_USB3:
device_property_read_u32(dev, "mediatek,efuse-intr",
&inst->efuse_intr);
device_property_read_u32(dev, "mediatek,efuse-tx-imp",
&inst->efuse_tx_imp);
device_property_read_u32(dev, "mediatek,efuse-rx-imp",
&inst->efuse_rx_imp);
dev_dbg(dev, "intr:%d, tx-imp:%d, rx-imp:%d\n",
inst->efuse_intr, inst->efuse_tx_imp,
inst->efuse_rx_imp);
break;
default:
dev_err(xsphy->dev, "incompatible phy type\n");
return;
}
}
static void u2_phy_props_set(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
u32 tmp;
if (inst->efuse_intr) {
tmp = readl(pbase + XSP_USBPHYACR1);
tmp &= ~P2A1_RG_INTR_CAL;
tmp |= P2A1_RG_INTR_CAL_VAL(inst->efuse_intr);
writel(tmp, pbase + XSP_USBPHYACR1);
}
if (inst->eye_src) {
tmp = readl(pbase + XSP_USBPHYACR5);
tmp &= ~P2A5_RG_HSTX_SRCTRL;
tmp |= P2A5_RG_HSTX_SRCTRL_VAL(inst->eye_src);
writel(tmp, pbase + XSP_USBPHYACR5);
}
if (inst->eye_vrt) {
tmp = readl(pbase + XSP_USBPHYACR1);
tmp &= ~P2A1_RG_VRT_SEL;
tmp |= P2A1_RG_VRT_SEL_VAL(inst->eye_vrt);
writel(tmp, pbase + XSP_USBPHYACR1);
}
if (inst->eye_term) {
tmp = readl(pbase + XSP_USBPHYACR1);
tmp &= ~P2A1_RG_TERM_SEL;
tmp |= P2A1_RG_TERM_SEL_VAL(inst->eye_term);
writel(tmp, pbase + XSP_USBPHYACR1);
}
}
static void u3_phy_props_set(struct mtk_xsphy *xsphy,
struct xsphy_instance *inst)
{
void __iomem *pbase = inst->port_base;
u32 tmp;
if (inst->efuse_intr) {
tmp = readl(xsphy->glb_base + SSPXTP_PHYA_GLB_00);
tmp &= ~RG_XTP_GLB_BIAS_INTR_CTRL;
tmp |= RG_XTP_GLB_BIAS_INTR_CTRL_VAL(inst->efuse_intr);
writel(tmp, xsphy->glb_base + SSPXTP_PHYA_GLB_00);
}
if (inst->efuse_tx_imp) {
tmp = readl(pbase + SSPXTP_PHYA_LN_04);
tmp &= ~RG_XTP_LN0_TX_IMPSEL;
tmp |= RG_XTP_LN0_TX_IMPSEL_VAL(inst->efuse_tx_imp);
writel(tmp, pbase + SSPXTP_PHYA_LN_04);
}
if (inst->efuse_rx_imp) {
tmp = readl(pbase + SSPXTP_PHYA_LN_14);
tmp &= ~RG_XTP_LN0_RX_IMPSEL;
tmp |= RG_XTP_LN0_RX_IMPSEL_VAL(inst->efuse_rx_imp);
writel(tmp, pbase + SSPXTP_PHYA_LN_14);
}
}
static int mtk_phy_init(struct phy *phy)
{
struct xsphy_instance *inst = phy_get_drvdata(phy);
struct mtk_xsphy *xsphy = dev_get_drvdata(phy->dev.parent);
int ret;
ret = clk_prepare_enable(inst->ref_clk);
if (ret) {
dev_err(xsphy->dev, "failed to enable ref_clk\n");
return ret;
}
switch (inst->type) {
case PHY_TYPE_USB2:
u2_phy_instance_init(xsphy, inst);
u2_phy_props_set(xsphy, inst);
break;
case PHY_TYPE_USB3:
u3_phy_props_set(xsphy, inst);
break;
default:
dev_err(xsphy->dev, "incompatible phy type\n");
clk_disable_unprepare(inst->ref_clk);
return -EINVAL;
}
return 0;
}
static int mtk_phy_power_on(struct phy *phy)
{
struct xsphy_instance *inst = phy_get_drvdata(phy);
struct mtk_xsphy *xsphy = dev_get_drvdata(phy->dev.parent);
if (inst->type == PHY_TYPE_USB2) {
u2_phy_instance_power_on(xsphy, inst);
u2_phy_slew_rate_calibrate(xsphy, inst);
}
return 0;
}
static int mtk_phy_power_off(struct phy *phy)
{
struct xsphy_instance *inst = phy_get_drvdata(phy);
struct mtk_xsphy *xsphy = dev_get_drvdata(phy->dev.parent);
if (inst->type == PHY_TYPE_USB2)
u2_phy_instance_power_off(xsphy, inst);
return 0;
}
static int mtk_phy_exit(struct phy *phy)
{
struct xsphy_instance *inst = phy_get_drvdata(phy);
clk_disable_unprepare(inst->ref_clk);
return 0;
}
static int mtk_phy_set_mode(struct phy *phy, enum phy_mode mode, int submode)
{
struct xsphy_instance *inst = phy_get_drvdata(phy);
struct mtk_xsphy *xsphy = dev_get_drvdata(phy->dev.parent);
if (inst->type == PHY_TYPE_USB2)
u2_phy_instance_set_mode(xsphy, inst, mode);
return 0;
}
static struct phy *mtk_phy_xlate(struct device *dev,
struct of_phandle_args *args)
{
struct mtk_xsphy *xsphy = dev_get_drvdata(dev);
struct xsphy_instance *inst = NULL;
struct device_node *phy_np = args->np;
int index;
if (args->args_count != 1) {
dev_err(dev, "invalid number of cells in 'phy' property\n");
return ERR_PTR(-EINVAL);
}
for (index = 0; index < xsphy->nphys; index++)
if (phy_np == xsphy->phys[index]->phy->dev.of_node) {
inst = xsphy->phys[index];
break;
}
if (!inst) {
dev_err(dev, "failed to find appropriate phy\n");
return ERR_PTR(-EINVAL);
}
inst->type = args->args[0];
if (!(inst->type == PHY_TYPE_USB2 ||
inst->type == PHY_TYPE_USB3)) {
dev_err(dev, "unsupported phy type: %d\n", inst->type);
return ERR_PTR(-EINVAL);
}
phy_parse_property(xsphy, inst);
return inst->phy;
}
static const struct phy_ops mtk_xsphy_ops = {
.init = mtk_phy_init,
.exit = mtk_phy_exit,
.power_on = mtk_phy_power_on,
.power_off = mtk_phy_power_off,
.set_mode = mtk_phy_set_mode,
.owner = THIS_MODULE,
};
static const struct of_device_id mtk_xsphy_id_table[] = {
{ .compatible = "mediatek,xsphy", },
{ },
};
MODULE_DEVICE_TABLE(of, mtk_xsphy_id_table);
static int mtk_xsphy_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *np = dev->of_node;
struct device_node *child_np;
struct phy_provider *provider;
struct resource *glb_res;
struct mtk_xsphy *xsphy;
struct resource res;
int port, retval;
xsphy = devm_kzalloc(dev, sizeof(*xsphy), GFP_KERNEL);
if (!xsphy)
return -ENOMEM;
xsphy->nphys = of_get_child_count(np);
xsphy->phys = devm_kcalloc(dev, xsphy->nphys,
sizeof(*xsphy->phys), GFP_KERNEL);
if (!xsphy->phys)
return -ENOMEM;
xsphy->dev = dev;
platform_set_drvdata(pdev, xsphy);
glb_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
/* optional, may not exist if no u3 phys */
if (glb_res) {
/* get banks shared by multiple u3 phys */
xsphy->glb_base = devm_ioremap_resource(dev, glb_res);
if (IS_ERR(xsphy->glb_base)) {
dev_err(dev, "failed to remap glb regs\n");
return PTR_ERR(xsphy->glb_base);
}
}
xsphy->src_ref_clk = XSP_REF_CLK;
xsphy->src_coef = XSP_SLEW_RATE_COEF;
/* update parameters of slew rate calibrate if exist */
device_property_read_u32(dev, "mediatek,src-ref-clk-mhz",
&xsphy->src_ref_clk);
device_property_read_u32(dev, "mediatek,src-coef", &xsphy->src_coef);
port = 0;
for_each_child_of_node(np, child_np) {
struct xsphy_instance *inst;
struct phy *phy;
inst = devm_kzalloc(dev, sizeof(*inst), GFP_KERNEL);
if (!inst) {
retval = -ENOMEM;
goto put_child;
}
xsphy->phys[port] = inst;
phy = devm_phy_create(dev, child_np, &mtk_xsphy_ops);
if (IS_ERR(phy)) {
dev_err(dev, "failed to create phy\n");
retval = PTR_ERR(phy);
goto put_child;
}
retval = of_address_to_resource(child_np, 0, &res);
if (retval) {
dev_err(dev, "failed to get address resource(id-%d)\n",
port);
goto put_child;
}
inst->port_base = devm_ioremap_resource(&phy->dev, &res);
if (IS_ERR(inst->port_base)) {
dev_err(dev, "failed to remap phy regs\n");
retval = PTR_ERR(inst->port_base);
goto put_child;
}
inst->phy = phy;
inst->index = port;
phy_set_drvdata(phy, inst);
port++;
inst->ref_clk = devm_clk_get(&phy->dev, "ref");
if (IS_ERR(inst->ref_clk)) {
dev_err(dev, "failed to get ref_clk(id-%d)\n", port);
retval = PTR_ERR(inst->ref_clk);
goto put_child;
}
}
provider = devm_of_phy_provider_register(dev, mtk_phy_xlate);
return PTR_ERR_OR_ZERO(provider);
put_child:
of_node_put(child_np);
return retval;
}
static struct platform_driver mtk_xsphy_driver = {
.probe = mtk_xsphy_probe,
.driver = {
.name = "mtk-xsphy",
.of_match_table = mtk_xsphy_id_table,
},
};
module_platform_driver(mtk_xsphy_driver);
MODULE_AUTHOR("Chunfeng Yun <chunfeng.yun@mediatek.com>");
MODULE_DESCRIPTION("MediaTek USB XS-PHY driver");
MODULE_LICENSE("GPL v2");
+486
View File
@@ -0,0 +1,486 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/device.h>
#include <linux/of_device.h>
#include <linux/phy/phy.h>
#include <linux/phy/mediatek/mtk_usb_phy.h>
#include <phy-mtk.h>
#define DRIVER_NAME "mtk_phy"
u32 phy_debug_level = K_ERR | K_ALET;
module_param(phy_debug_level, int, 0644);
MODULE_PARM_DESC(phy_debug_level, "Debug Print Log for mtkphy");
int usb_mtkphy_switch_to_usb(struct phy *phy)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_switch_to_usb)
phycfg->usb_phy_switch_to_usb(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_switch_to_usb);
int usb_mtkphy_switch_to_uart(struct phy *phy)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_switch_to_uart)
phycfg->usb_phy_switch_to_uart(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_switch_to_uart);
int usb_mtkphy_check_in_uart_mode(struct phy *phy)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_check_in_uart_mode)
ret = phycfg->usb_phy_check_in_uart_mode(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_check_in_uart_mode);
int usb_mtkphy_dump_usb2uart_reg(struct phy *phy)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_dump_usb2uart_reg)
phycfg->usb_phy_dump_usb2uart_reg(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_dump_usb2uart_reg);
int usb_mtkphy_sib_enable_switch(struct phy *phy, bool enable)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_sib_enable_switch)
phycfg->usb_phy_sib_enable_switch(instance, enable);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_sib_enable_switch);
int usb_mtkphy_sib_enable_switch_status(struct phy *phy)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_sib_switch_status)
phycfg->usb_phy_sib_switch_status(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_sib_enable_switch_status);
int usb_mtkphy_u3_loop_back_test(struct phy *phy)
{
int ret;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_u3_loop_back_test)
ret = phycfg->usb_phy_u3_loop_back_test(instance);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_u3_loop_back_test);
int usb_mtkphy_slew_rate_calibration(struct phy *phy)
{
int ret = 0;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_slew_rate_calibration);
int usb_mtkphy_switch_to_bc11(struct phy *phy, bool on)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_switch_to_bc11)
phycfg->usb_phy_switch_to_bc11(instance, on);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_switch_to_bc11);
int usb_mtkphy_dpdm_pulldown(struct phy *phy, bool enable)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_dpdm_pulldown)
phycfg->usb_phy_dpdm_pulldown(instance, enable);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_dpdm_pulldown);
int usb_mtkphy_lpm_enable(struct phy *phy, bool on)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_lpm_enable)
ret = phycfg->usb_phy_lpm_enable(instance, on);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_lpm_enable);
int usb_mtkphy_host_mode(struct phy *phy, bool on)
{
int ret = 0;
if (!phy)
ret = -EINVAL;
if (phy) {
struct mtk_phy_instance *instance = phy_get_drvdata(phy);
const struct mtk_phy_interface *phycfg;
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_host_mode)
ret = phycfg->usb_phy_host_mode(instance, on);
else
ret = -ENOTSUPP;
} else
ret = -EINVAL;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_host_mode);
int usb_mtkphy_io_read(struct phy *phy, u32 reg)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_io_read)
ret = phycfg->usb_phy_io_read(instance, reg);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_io_read);
int usb_mtkphy_io_write(struct phy *phy, u32 val, u32 reg)
{
int ret = 0;
struct mtk_phy_instance *instance;
const struct mtk_phy_interface *phycfg;
if (!phy)
return -EINVAL;
instance = phy_get_drvdata(phy);
phycfg = instance->phycfg;
if (phycfg && phycfg->usb_phy_io_write)
phycfg->usb_phy_io_write(instance, val, reg);
else
ret = -ENOTSUPP;
return ret;
}
EXPORT_SYMBOL_GPL(usb_mtkphy_io_write);
static int mtk_phy_init(struct phy *phy)
{
struct mtk_phy_instance *instance = phy_get_drvdata(phy);
instance->phycfg->usb_phy_init(instance);
return 0;
}
static int mtk_phy_power_on(struct phy *phy)
{
struct mtk_phy_instance *instance = phy_get_drvdata(phy);
instance->phycfg->usb_phy_recover(instance);
return 0;
}
static int mtk_phy_power_off(struct phy *phy)
{
struct mtk_phy_instance *instance = phy_get_drvdata(phy);
instance->phycfg->usb_phy_savecurrent(instance);
return 0;
}
static struct phy_ops mtk_u3phy_ops = {
.init = mtk_phy_init,
.exit = NULL,
.power_on = mtk_phy_power_on,
.power_off = mtk_phy_power_off,
.owner = THIS_MODULE,
};
static struct phy *mtk_phy_xlate(struct device *dev,
struct of_phandle_args *args)
{
struct mtk_phy_drv *drv;
drv = dev_get_drvdata(dev);
if (!drv)
return ERR_PTR(-EINVAL);
if (WARN_ON(args->args[0] >= drv->phycfg->num_phys))
return ERR_PTR(-ENODEV);
return drv->phys[args->args[0]]->phy;
}
static int mtk_usb_phy_probe(struct platform_device *pdev)
{
int retval, i;
struct device *dev = &pdev->dev;
const struct of_device_id *match;
const struct mtk_usbphy_config *mtkcfg;
struct device_node *np = pdev->dev.of_node;
struct mtk_phy_drv *mtkphy;
struct phy_provider *provider;
if (!pdev->dev.of_node) {
dev_info(dev, "This driver is required to be instantiated from device tree\n");
return -EINVAL;
}
match = of_match_node(mtk_phy_of_match, pdev->dev.of_node);
if (!match) {
dev_info(dev, "of_match_node() failed\n");
return -EINVAL;
}
mtkcfg = match->data;
mtkphy = devm_kzalloc(dev, sizeof(*mtkphy), GFP_KERNEL);
if (!mtkphy)
return -ENOMEM;
mtkphy->nphys = mtkcfg->num_phys;
mtkphy->phys = devm_kcalloc(dev, mtkphy->nphys,
sizeof(*mtkphy->phys), GFP_KERNEL);
if (!mtkphy->phys) {
devm_kfree(dev, mtkphy);
return -ENOMEM;
}
mtkphy->phycfg = mtkcfg;
mtkphy->dev = dev;
platform_set_drvdata(pdev, mtkphy);
/* init phy driver */
retval = mtkcfg->usb_drv_init(pdev, mtkphy);
if (retval)
return retval;
pm_runtime_enable(dev);
retval = pm_runtime_get_sync(dev);
if (retval < 0)
goto err1;
pm_runtime_forbid(dev);
for (i = 0; i < mtkphy->phycfg->num_phys; i++) {
struct mtk_phy_instance *instance = mtkphy->phys[i];
char *name = mtkphy->phycfg->phys[i].name;
struct phy *phy;
instance = devm_kzalloc(dev, sizeof(*instance), GFP_KERNEL);
if (!instance) {
retval = -ENOMEM;
goto err2;
}
instance->port_base = mtkphy->phy_base
+ mtkphy->phycfg->phys[i].reg_offset;
phy = devm_phy_create(dev, np, &mtk_u3phy_ops);
if (IS_ERR(phy)) {
dev_info(dev, "Failed to create usb2_phy \"%s\"\n",
name);
retval = PTR_ERR(phy);
goto err2;
}
instance->phy = phy;
instance->phycfg = &mtkphy->phycfg->phys[i];
instance->phy_drv = mtkphy;
instance->phycfg->usb_phy_inst_init(instance);
mtkphy->phys[i] = instance;
phy_set_drvdata(instance->phy, instance);
}
provider = devm_of_phy_provider_register(dev,
mtk_phy_xlate);
return PTR_ERR_OR_ZERO(provider);
err2:
pm_runtime_allow(dev);
err1:
pm_runtime_put_sync(dev);
pm_runtime_disable(dev);
mtkcfg->usb_drv_exit(pdev, mtkphy);
return retval;
}
static int mtk_usb_phy_remove(struct platform_device *pdev)
{
/* pm_runtime_put_sync(&pdev->dev);*/
/* pm_runtime_disable(&pdev->dev);*/
return 0;
}
static struct platform_driver mtk_usb_phy_driver = {
.probe = mtk_usb_phy_probe,
.remove = mtk_usb_phy_remove,
.driver = {
.name = DRIVER_NAME,
.of_match_table = mtk_phy_of_match,
},
};
static int __init usb_phy_mtk_init(void)
{
return platform_driver_register(&mtk_usb_phy_driver);
}
module_init(usb_phy_mtk_init);
static void __exit usb_phy_mtk_exit(void)
{
platform_driver_unregister(&mtk_usb_phy_driver);
}
module_exit(usb_phy_mtk_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Mediatek USB transceiver driver");
+112
View File
@@ -0,0 +1,112 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __PHY_MTK_SSUSB_H
#define __PHY_MTK_SSUSB_H
#include <linux/types.h>
#include <linux/clk.h>
struct mtk_phy_tuning {
s32 u2_vrt_ref;
s32 u2_term_ref;
s32 u2_enhance;
bool inited;
};
struct mtk_phy_instance {
const struct mtk_phy_interface *phycfg;
struct mtk_phy_drv *phy_drv;
struct phy *phy;
void __iomem *port_base;
void __iomem *sif_misc;
void __iomem *sif_fmreg;
void __iomem *sif_u2phy_com;
void __iomem *sif_spllc;
void __iomem *sif_chip;
void __iomem *sif_u3phyd;
void __iomem *sif_u3phyd_bank2;
void __iomem *sif_u3phya;
void __iomem *sif_u3phya_da;
unsigned int port_rgsz;
bool sib_mode;
bool uart_mode;
int phy_number;
struct mtk_phy_tuning phy_tuning;
};
struct mtk_phy_interface {
int (*usb_phy_init)(struct mtk_phy_instance *instance);
void (*usb_phy_savecurrent)(struct mtk_phy_instance *instance);
void (*usb_phy_recover)(struct mtk_phy_instance *instance);
void (*usb_phy_switch_to_bc11)(struct mtk_phy_instance *instance,
bool on);
void (*usb_phy_dpdm_pulldown)(struct mtk_phy_instance *instance,
bool enable);
int (*usb_phy_lpm_enable)(struct mtk_phy_instance *instance, bool on);
int (*usb_phy_host_mode)(struct mtk_phy_instance *instance, bool on);
int (*usb_phy_io_read)(struct mtk_phy_instance *instance, u32 reg);
int (*usb_phy_io_write)(struct mtk_phy_instance *instance, u32 val,
u32 reg);
void (*usb_phy_switch_to_usb)(struct mtk_phy_instance *instance);
void (*usb_phy_switch_to_uart)(struct mtk_phy_instance *instance);
bool (*usb_phy_check_in_uart_mode)(struct mtk_phy_instance *instance);
void (*usb_phy_dump_usb2uart_reg)(struct mtk_phy_instance *instance);
void (*usb_phy_sib_enable_switch)(struct mtk_phy_instance *instance,
bool enable);
bool (*usb_phy_sib_switch_status)(struct mtk_phy_instance *instance);
bool (*usb_phy_u3_loop_back_test)(struct mtk_phy_instance *instance);
int (*usb_phy_inst_init)(struct mtk_phy_instance *instance);
unsigned int reg_offset;
char *name;
char *tuning_node_name;
u8 port_num;
u8 port_type;
};
struct mtk_usbphy_config {
const struct mtk_phy_interface *phys;
unsigned int num_phys;
unsigned int version;
int (*usb_drv_init)(struct platform_device *pdev,
struct mtk_phy_drv *drv);
int (*usb_drv_exit)(struct platform_device *pdev,
struct mtk_phy_drv *drv);
};
struct mtk_phy_drv {
struct device *dev;
const struct mtk_usbphy_config *phycfg;
void __iomem *phy_base;
void __iomem *ippc_base;
struct mtk_phy_instance **phys;
int nphys;
struct clk *clk;
struct regulator *vusb33;
struct regulator *vusb10;
};
/*Set the debug level for phy driver*/
#define K_ALET (1<<6)
#define K_CRIT (1<<5)
#define K_ERR (1<<4)
#define K_WARNIN (1<<3)
#define K_NOTICE (1<<2)
#define K_INFO (1<<1)
#define K_DEBUG (1<<0)
extern u32 phy_debug_level;
#define phy_printk(level, fmt, args...) do { \
if (phy_debug_level & level) { \
pr_info("[MTKPHY]" fmt, ## args); \
} \
} while (0)
extern const struct of_device_id mtk_phy_of_match[];
#endif