726 lines
20 KiB
C
726 lines
20 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Copyright (c) 2019 MediaTek Inc.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/uaccess.h>
|
|
#include <musb_core.h>
|
|
#include <musb_debug.h>
|
|
#include <mtk_musb.h>
|
|
|
|
/* general */
|
|
#define BIT_WIDTH_1 1
|
|
#define MSK_WIDTH_1 0x1
|
|
#define VAL_MAX_WDITH_1 0x1
|
|
#define VAL_0_WIDTH_1 0x0
|
|
#define VAL_1_WIDTH_1 0x1
|
|
#define STRNG_0_WIDTH_1 "0"
|
|
#define STRNG_1_WIDTH_1 "1"
|
|
|
|
#define BIT_WIDTH_2 2
|
|
#define MSK_WIDTH_2 0x3
|
|
#define VAL_MAX_WDITH_2 0x3
|
|
#define VAL_0_WIDTH_2 0x0
|
|
#define VAL_1_WIDTH_2 0x1
|
|
#define VAL_2_WIDTH_2 0x2
|
|
#define VAL_3_WIDTH_2 0x3
|
|
#define STRNG_0_WIDTH_2 "00"
|
|
#define STRNG_1_WIDTH_2 "01"
|
|
#define STRNG_2_WIDTH_2 "10"
|
|
#define STRNG_3_WIDTH_2 "11"
|
|
|
|
#define BIT_WIDTH_3 3
|
|
#define MSK_WIDTH_3 0x7
|
|
#define VAL_MAX_WDITH_3 0x7
|
|
#define VAL_0_WIDTH_3 0x0
|
|
#define VAL_1_WIDTH_3 0x1
|
|
#define VAL_2_WIDTH_3 0x2
|
|
#define VAL_3_WIDTH_3 0x3
|
|
#define VAL_4_WIDTH_3 0x4
|
|
#define VAL_5_WIDTH_3 0x5
|
|
#define VAL_6_WIDTH_3 0x6
|
|
#define VAL_7_WIDTH_3 0x7
|
|
#define STRNG_0_WIDTH_3 "000"
|
|
#define STRNG_1_WIDTH_3 "001"
|
|
#define STRNG_2_WIDTH_3 "010"
|
|
#define STRNG_3_WIDTH_3 "011"
|
|
#define STRNG_4_WIDTH_3 "100"
|
|
#define STRNG_5_WIDTH_3 "101"
|
|
#define STRNG_6_WIDTH_3 "110"
|
|
#define STRNG_7_WIDTH_3 "111"
|
|
|
|
/* specific */
|
|
#define FILE_USB_DRIVING_CAPABILITY "USB_DRIVING_CAPABILITY"
|
|
|
|
#define FILE_RG_USB20_TERM_VREF_SEL "RG_USB20_TERM_VREF_SEL"
|
|
#define MSK_RG_USB20_TERM_VREF_SEL MSK_WIDTH_3
|
|
#define SHFT_RG_USB20_TERM_VREF_SEL 8
|
|
#define OFFSET_RG_USB20_TERM_VREF_SEL 0x4
|
|
|
|
#define FILE_RG_USB20_HSTX_SRCTRL "RG_USB20_HSTX_SRCTRL"
|
|
#define MSK_RG_USB20_HSTX_SRCTRL MSK_WIDTH_3
|
|
#define SHFT_RG_USB20_HSTX_SRCTRL 12
|
|
#define OFFSET_RG_USB20_HSTX_SRCTRL 0x14
|
|
|
|
#define FILE_RG_USB20_VRT_VREF_SEL "RG_USB20_VRT_VREF_SEL"
|
|
#define MSK_RG_USB20_VRT_VREF_SEL MSK_WIDTH_3
|
|
#define SHFT_RG_USB20_VRT_VREF_SEL 12
|
|
#define OFFSET_RG_USB20_VRT_VREF_SEL 0x4
|
|
|
|
#define FILE_RG_USB20_INTR_EN "RG_USB20_INTR_EN"
|
|
#define MSK_RG_USB20_INTR_EN MSK_WIDTH_1
|
|
#define SHFT_RG_USB20_INTR_EN 5
|
|
#define OFFSET_RG_USB20_INTR_EN 0x0
|
|
|
|
#define FILE_RG_USB20_PHY_REV6 "RG_USB20_PHY_REV6"
|
|
#define MSK_RG_USB20_PHY_REV6 MSK_WIDTH_2
|
|
#define SHFT_RG_USB20_PHY_REV6 30
|
|
#define OFFSET_RG_USB20_PHY_REV6 0x18
|
|
|
|
static struct proc_dir_entry *usb20_phy_procfs_root;
|
|
|
|
void usb20_phy_debugfs_write_width1(u8 offset, u8 shift, char *buf)
|
|
{
|
|
u32 clr_val = 0, set_val = 0;
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> s(%s)\n",
|
|
__func__, __LINE__, buf);
|
|
if (!strncmp(buf, STRNG_0_WIDTH_1, BIT_WIDTH_1)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_0_WIDTH_1);
|
|
clr_val = VAL_1_WIDTH_1;
|
|
}
|
|
if (!strncmp(buf, STRNG_1_WIDTH_1, BIT_WIDTH_1)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_1_WIDTH_1);
|
|
set_val = VAL_1_WIDTH_1;
|
|
}
|
|
|
|
if (clr_val || set_val) {
|
|
clr_val = VAL_MAX_WDITH_1 - set_val;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, clr_val:%x, set_val:%x, before shft\n",
|
|
__func__, __LINE__,
|
|
offset, clr_val,
|
|
set_val);
|
|
clr_val <<= shift;
|
|
set_val <<= shift;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, clr_val:%x, set_val:%x, after shft\n",
|
|
__func__, __LINE__,
|
|
offset, clr_val,
|
|
set_val);
|
|
|
|
USBPHY_CLR32(offset, clr_val);
|
|
USBPHY_SET32(offset, set_val);
|
|
} else {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> do nothing\n"
|
|
, __func__, __LINE__);
|
|
}
|
|
}
|
|
|
|
void usb20_phy_debugfs_rev6_write(u8 offset, u8 shift, char *buf)
|
|
{
|
|
u8 set_val = 0xFF;
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> s(%s)\n",
|
|
__func__, __LINE__, buf);
|
|
if (!strncmp(buf, STRNG_0_WIDTH_2, BIT_WIDTH_2)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_0_WIDTH_2);
|
|
set_val = VAL_0_WIDTH_2;
|
|
}
|
|
if (!strncmp(buf, STRNG_1_WIDTH_2, BIT_WIDTH_2)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_1_WIDTH_2);
|
|
set_val = VAL_1_WIDTH_2;
|
|
}
|
|
if (!strncmp(buf, STRNG_2_WIDTH_2, BIT_WIDTH_2)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_2_WIDTH_2);
|
|
set_val = VAL_2_WIDTH_2;
|
|
}
|
|
if (!strncmp(buf, STRNG_3_WIDTH_2, BIT_WIDTH_2)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_3_WIDTH_2);
|
|
set_val = VAL_3_WIDTH_2;
|
|
}
|
|
|
|
if (set_val <= VAL_MAX_WDITH_2) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> case offset:%x, set_val:%x, before shft\n",
|
|
__func__, __LINE__, offset, set_val);
|
|
USBPHY_CLR32(offset, (VAL_MAX_WDITH_2<<shift));
|
|
USBPHY_SET32(offset, (set_val<<shift));
|
|
} else {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> do nothing\n",
|
|
__func__, __LINE__);
|
|
}
|
|
}
|
|
|
|
void usb20_phy_debugfs_write_width3(u8 offset, u8 shift, char *buf)
|
|
{
|
|
u32 clr_val = 0, set_val = 0;
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> s(%s)\n",
|
|
__func__, __LINE__, buf);
|
|
if (!strncmp(buf, STRNG_0_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_0_WIDTH_3);
|
|
clr_val = VAL_7_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_1_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_1_WIDTH_3);
|
|
set_val = VAL_1_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_2_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_2_WIDTH_3);
|
|
set_val = VAL_2_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_3_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_3_WIDTH_3);
|
|
set_val = VAL_3_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_4_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_4_WIDTH_3);
|
|
set_val = VAL_4_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_5_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_5_WIDTH_3);
|
|
set_val = VAL_5_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_6_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_6_WIDTH_3);
|
|
set_val = VAL_6_WIDTH_3;
|
|
}
|
|
if (!strncmp(buf, STRNG_7_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_7_WIDTH_3);
|
|
set_val = VAL_7_WIDTH_3;
|
|
}
|
|
|
|
if (clr_val || set_val) {
|
|
clr_val = VAL_MAX_WDITH_3 - set_val;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, clr_val:%x, set_val:%x, before shft\n",
|
|
__func__, __LINE__, offset, clr_val, set_val);
|
|
clr_val <<= shift;
|
|
set_val <<= shift;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, clr_val:%x, set_val:%x, after shft\n",
|
|
__func__, __LINE__, offset, clr_val, set_val);
|
|
|
|
USBPHY_CLR32(offset, clr_val);
|
|
USBPHY_SET32(offset, set_val);
|
|
} else {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> do nothing\n",
|
|
__func__, __LINE__);
|
|
}
|
|
}
|
|
|
|
u8 usb20_phy_debugfs_read_val(u8 offset, u8 shft, u8 msk, u8 width, char *str)
|
|
{
|
|
u32 val;
|
|
int i, temp;
|
|
|
|
val = USBPHY_READ32(offset);
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, val:%x, shft:%x, msk:%x\n",
|
|
__func__, __LINE__, offset, val, shft, msk);
|
|
val = val >> shft;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, val:%x, shft:%x, msk:%x\n",
|
|
__func__, __LINE__, offset, val, shft, msk);
|
|
val = val & msk;
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> offset:%x, val:%x, shft:%x, msk:%x\n",
|
|
__func__, __LINE__, offset, val, shft, msk);
|
|
|
|
temp = val;
|
|
str[width] = '\0';
|
|
for (i = (width - 1); i >= 0; i--) {
|
|
if (val % 2)
|
|
str[i] = '1';
|
|
else
|
|
str[i] = '0';
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> str[%d]:%c\n\n",
|
|
__func__, __LINE__, i, str[i]);
|
|
val /= 2;
|
|
}
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> str(%s)\n",
|
|
__func__, __LINE__, str);
|
|
return val;
|
|
}
|
|
|
|
static int usb_driving_capability_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
u8 combined_val, tmp_val = 0xff;
|
|
|
|
val = usb20_phy_debugfs_read_val(OFFSET_RG_USB20_TERM_VREF_SEL,
|
|
SHFT_RG_USB20_TERM_VREF_SEL,
|
|
MSK_RG_USB20_TERM_VREF_SEL, BIT_WIDTH_3, str);
|
|
if (!strncmp(str, STRNG_0_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_0_WIDTH_3);
|
|
tmp_val = VAL_0_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_1_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_1_WIDTH_3);
|
|
tmp_val = VAL_1_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_2_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_2_WIDTH_3);
|
|
tmp_val = VAL_2_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_3_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_3_WIDTH_3);
|
|
tmp_val = VAL_3_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_4_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_4_WIDTH_3);
|
|
tmp_val = VAL_4_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_5_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_5_WIDTH_3);
|
|
tmp_val = VAL_5_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_6_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_6_WIDTH_3);
|
|
tmp_val = VAL_6_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_7_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_7_WIDTH_3);
|
|
tmp_val = VAL_7_WIDTH_3;
|
|
}
|
|
|
|
combined_val = tmp_val;
|
|
|
|
val = usb20_phy_debugfs_read_val(OFFSET_RG_USB20_VRT_VREF_SEL,
|
|
SHFT_RG_USB20_VRT_VREF_SEL,
|
|
MSK_RG_USB20_VRT_VREF_SEL,
|
|
BIT_WIDTH_3, str);
|
|
if (!strncmp(str, STRNG_0_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_0_WIDTH_3);
|
|
tmp_val = VAL_0_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_1_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_1_WIDTH_3);
|
|
tmp_val = VAL_1_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_2_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_2_WIDTH_3);
|
|
tmp_val = VAL_2_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_3_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_3_WIDTH_3);
|
|
tmp_val = VAL_3_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_4_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_4_WIDTH_3);
|
|
tmp_val = VAL_4_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_5_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_5_WIDTH_3);
|
|
tmp_val = VAL_5_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_6_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_6_WIDTH_3);
|
|
tmp_val = VAL_6_WIDTH_3;
|
|
}
|
|
if (!strncmp(str, STRNG_7_WIDTH_3, BIT_WIDTH_3)) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> %s case\n",
|
|
__func__, __LINE__, STRNG_7_WIDTH_3);
|
|
tmp_val = VAL_7_WIDTH_3;
|
|
}
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> combined_val(%d), tmp_val(%d)\n",
|
|
__func__, __LINE__, combined_val, tmp_val);
|
|
|
|
if ((tmp_val == (combined_val - 1)) || (tmp_val == combined_val))
|
|
combined_val += tmp_val;
|
|
else
|
|
combined_val = tmp_val * (VAL_MAX_WDITH_3 + 1) + combined_val;
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> combined_val(%d), tmp_val(%d)\n",
|
|
__func__, __LINE__, combined_val, tmp_val);
|
|
|
|
seq_printf(s, "\n%s = %d\n", FILE_USB_DRIVING_CAPABILITY, combined_val);
|
|
return 0;
|
|
}
|
|
|
|
static int rg_usb20_term_vref_sel_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
|
|
val =
|
|
usb20_phy_debugfs_read_val(OFFSET_RG_USB20_TERM_VREF_SEL,
|
|
SHFT_RG_USB20_TERM_VREF_SEL,
|
|
MSK_RG_USB20_TERM_VREF_SEL,
|
|
BIT_WIDTH_3, str);
|
|
seq_printf(s, "\n%s = %s\n", FILE_RG_USB20_TERM_VREF_SEL, str);
|
|
return 0;
|
|
}
|
|
|
|
static int rg_usb20_hstx_srctrl_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
|
|
val =
|
|
usb20_phy_debugfs_read_val(OFFSET_RG_USB20_HSTX_SRCTRL,
|
|
SHFT_RG_USB20_HSTX_SRCTRL,
|
|
MSK_RG_USB20_HSTX_SRCTRL, BIT_WIDTH_3, str);
|
|
seq_printf(s, "\n%s = %s\n", FILE_RG_USB20_HSTX_SRCTRL, str);
|
|
return 0;
|
|
}
|
|
|
|
static int rg_usb20_vrt_vref_sel_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
|
|
val =
|
|
usb20_phy_debugfs_read_val(OFFSET_RG_USB20_VRT_VREF_SEL,
|
|
SHFT_RG_USB20_VRT_VREF_SEL,
|
|
MSK_RG_USB20_VRT_VREF_SEL, BIT_WIDTH_3, str);
|
|
seq_printf(s, "\n%s = %s\n", FILE_RG_USB20_VRT_VREF_SEL, str);
|
|
return 0;
|
|
}
|
|
|
|
static int rg_usb20_intr_en_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
|
|
val =
|
|
usb20_phy_debugfs_read_val(OFFSET_RG_USB20_INTR_EN,
|
|
SHFT_RG_USB20_INTR_EN,
|
|
MSK_RG_USB20_INTR_EN, BIT_WIDTH_1, str);
|
|
seq_printf(s, "\n%s = %s\n", FILE_RG_USB20_INTR_EN, str);
|
|
return 0;
|
|
}
|
|
|
|
static int rg_usb20_rev6_show(struct seq_file *s, void *unused)
|
|
{
|
|
u8 val;
|
|
char str[16];
|
|
|
|
val =
|
|
usb20_phy_debugfs_read_val(OFFSET_RG_USB20_PHY_REV6,
|
|
SHFT_RG_USB20_PHY_REV6,
|
|
MSK_RG_USB20_PHY_REV6, BIT_WIDTH_2, str);
|
|
|
|
seq_printf(s, "\n%s = %s\n", FILE_RG_USB20_PHY_REV6, str);
|
|
return 0;
|
|
}
|
|
|
|
static int usb_driving_capability_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, usb_driving_capability_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int rg_usb20_term_vref_sel_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, rg_usb20_term_vref_sel_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int rg_usb20_hstx_srctrl_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, rg_usb20_hstx_srctrl_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int rg_usb20_vrt_vref_sel_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, rg_usb20_vrt_vref_sel_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int rg_usb20_intr_en_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, rg_usb20_intr_en_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int rg_usb20_rev6_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, rg_usb20_rev6_show, PDE_DATA(inode));
|
|
}
|
|
|
|
void val_to_bstring_width3(u8 val, char *str)
|
|
{
|
|
|
|
if (val == VAL_0_WIDTH_3)
|
|
memcpy(str, STRNG_0_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_1_WIDTH_3)
|
|
memcpy(str, STRNG_1_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_2_WIDTH_3)
|
|
memcpy(str, STRNG_2_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_3_WIDTH_3)
|
|
memcpy(str, STRNG_3_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_4_WIDTH_3)
|
|
memcpy(str, STRNG_4_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_5_WIDTH_3)
|
|
memcpy(str, STRNG_5_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_6_WIDTH_3)
|
|
memcpy(str, STRNG_6_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
if (val == VAL_7_WIDTH_3)
|
|
memcpy(str, STRNG_7_WIDTH_3, BIT_WIDTH_3 + 1);
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> val(%d), str(%s)\n",
|
|
__func__, __LINE__, val, str);
|
|
}
|
|
|
|
static ssize_t usb_driving_capability_write(struct file *file,
|
|
const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
u8 val, tmp_val;
|
|
char str_rg_usb20_term_vref_sel[18], str_rg_usb20_vrt_vref_sel[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
pr_notice("\n");
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
|
|
if (kstrtol(buf, 10, (long *)&val) != 0) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> kstrtol, err(%d)\n)\n",
|
|
__func__, __LINE__, kstrtol(buf, 10, (long *)&val));
|
|
return count;
|
|
}
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> kstrtol, val(%d)\n)\n",
|
|
__func__, __LINE__, val);
|
|
|
|
if (val > VAL_7_WIDTH_3 * 2) {
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> wrong val set(%d), direct return\n",
|
|
__func__, __LINE__, val);
|
|
return count;
|
|
}
|
|
tmp_val = val;
|
|
val /= 2;
|
|
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> val(%d), tmp_val(%d)\n",
|
|
__func__, __LINE__, val, tmp_val);
|
|
|
|
val_to_bstring_width3(tmp_val - val, str_rg_usb20_term_vref_sel);
|
|
val_to_bstring_width3(val, str_rg_usb20_vrt_vref_sel);
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> Config TERM_VREF_SEL %s\n",
|
|
__func__, __LINE__, str_rg_usb20_term_vref_sel);
|
|
usb20_phy_debugfs_write_width3(OFFSET_RG_USB20_TERM_VREF_SEL,
|
|
SHFT_RG_USB20_TERM_VREF_SEL,
|
|
str_rg_usb20_term_vref_sel);
|
|
pr_notice("MTK_ICUSB [DBG], <%s(), %d> Config VRT_VREF_SEL %s\n\n",
|
|
__func__, __LINE__, str_rg_usb20_vrt_vref_sel);
|
|
usb20_phy_debugfs_write_width3(OFFSET_RG_USB20_VRT_VREF_SEL,
|
|
SHFT_RG_USB20_VRT_VREF_SEL,
|
|
str_rg_usb20_vrt_vref_sel);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rg_usb20_term_vref_sel_write(struct file *file,
|
|
const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
usb20_phy_debugfs_write_width3(OFFSET_RG_USB20_TERM_VREF_SEL,
|
|
SHFT_RG_USB20_TERM_VREF_SEL, buf);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rg_usb20_hstx_srctrl_write(struct file *file,
|
|
const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
usb20_phy_debugfs_write_width3(OFFSET_RG_USB20_HSTX_SRCTRL,
|
|
SHFT_RG_USB20_HSTX_SRCTRL, buf);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rg_usb20_vrt_vref_sel_write(struct file *file,
|
|
const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
usb20_phy_debugfs_write_width3(OFFSET_RG_USB20_VRT_VREF_SEL,
|
|
SHFT_RG_USB20_VRT_VREF_SEL, buf);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rg_usb20_intr_en_write(struct file *file,
|
|
const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
usb20_phy_debugfs_write_width1(OFFSET_RG_USB20_INTR_EN,
|
|
SHFT_RG_USB20_INTR_EN, buf);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t rg_usb20_rev6_write(struct file *file,
|
|
const char __user *ubuf, size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
char buf[18];
|
|
|
|
memset(buf, 0x00, sizeof(buf));
|
|
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
|
|
return -EFAULT;
|
|
usb20_phy_debugfs_rev6_write(OFFSET_RG_USB20_PHY_REV6,
|
|
SHFT_RG_USB20_PHY_REV6, buf);
|
|
return count;
|
|
}
|
|
|
|
|
|
static const struct file_operations usb_driving_capability_fops = {
|
|
.open = usb_driving_capability_open,
|
|
.write = usb_driving_capability_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations rg_usb20_term_vref_sel_fops = {
|
|
.open = rg_usb20_term_vref_sel_open,
|
|
.write = rg_usb20_term_vref_sel_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations rg_usb20_hstx_srctrl_fops = {
|
|
.open = rg_usb20_hstx_srctrl_open,
|
|
.write = rg_usb20_hstx_srctrl_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations rg_usb20_vrt_vref_sel_fops = {
|
|
.open = rg_usb20_vrt_vref_sel_open,
|
|
.write = rg_usb20_vrt_vref_sel_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations rg_usb20_intr_en_fops = {
|
|
.open = rg_usb20_intr_en_open,
|
|
.write = rg_usb20_intr_en_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations rg_usb20_rev6_fops = {
|
|
.open = rg_usb20_rev6_open,
|
|
.write = rg_usb20_rev6_write,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
int usb20_phy_init_debugfs(void)
|
|
{
|
|
struct proc_dir_entry *root;
|
|
struct proc_dir_entry *file;
|
|
int ret;
|
|
|
|
proc_mkdir("mtk_usb", NULL);
|
|
|
|
root = proc_mkdir("mtk_usb/usb20_phy", NULL);
|
|
if (!root) {
|
|
ret = -ENOMEM;
|
|
goto err0;
|
|
}
|
|
|
|
file = proc_create(FILE_USB_DRIVING_CAPABILITY, 0644,
|
|
root, &usb_driving_capability_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
file = proc_create(FILE_RG_USB20_TERM_VREF_SEL, 0644,
|
|
root, &rg_usb20_term_vref_sel_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
file = proc_create(FILE_RG_USB20_HSTX_SRCTRL, 0644,
|
|
root, &rg_usb20_hstx_srctrl_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
file = proc_create(FILE_RG_USB20_VRT_VREF_SEL, 0644,
|
|
root, &rg_usb20_vrt_vref_sel_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
file = proc_create(FILE_RG_USB20_INTR_EN, 0644,
|
|
root, &rg_usb20_intr_en_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
file = proc_create(FILE_RG_USB20_PHY_REV6, 0644,
|
|
root, &rg_usb20_rev6_fops);
|
|
if (!file) {
|
|
ret = -ENOMEM;
|
|
goto err1;
|
|
}
|
|
|
|
usb20_phy_procfs_root = root;
|
|
return 0;
|
|
|
|
err1:
|
|
proc_remove(root);
|
|
|
|
err0:
|
|
return ret;
|
|
}
|
|
|
|
void /* __init_or_exit */ usb20_phy_exit_debugfs(struct musb *musb)
|
|
{
|
|
proc_remove(usb20_phy_procfs_root);
|
|
}
|