Difuse/difos
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert "ramips: mmc: Sync with staging drivers"

Browse source 
This reverts commit 2d401925b9.

Signed-off-by: John Crispin <john@phrozen.org>
This commit is contained in:
John Crispin 2018-05-15 12:42:40 +02:00
parent 87c254c87e
commit 7e15e21766
5 changed files with 3302 additions and 2577 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
target/linux/ramips/files-4.14/drivers/mmc/host/mtk-mmc/board.h
View file

@ -36,10 +36,27 @@
#ifndef __ARCH_ARM_MACH_BOARD_H #ifndef __ARCH_ARM_MACH_BOARD_H
#define __ARCH_ARM_MACH_BOARD_H #define __ARCH_ARM_MACH_BOARD_H
#include <generated/autoconf.h>
#include <linux/pm.h>
/* --- chhung */
// #include <mach/mt6575.h>
// #include <board-custom.h>
/* end of chhung */
typedef void (*sdio_irq_handler_t)(void*); /* external irq handler */
typedef void (*pm_callback_t)(pm_message_t state, void *data);
#define MSDC_CD_PIN_EN (1 << 0) /* card detection pin is wired */ #define MSDC_CD_PIN_EN (1 << 0) /* card detection pin is wired */
#define MSDC_WP_PIN_EN (1 << 1) /* write protection pin is wired */ #define MSDC_WP_PIN_EN (1 << 1) /* write protection pin is wired */
#define MSDC_RST_PIN_EN (1 << 2) /* emmc reset pin is wired */ #define MSDC_RST_PIN_EN (1 << 2) /* emmc reset pin is wired */
#define MSDC_SDIO_IRQ (1 << 3) /* use internal sdio irq (bus) */
#define MSDC_EXT_SDIO_IRQ (1 << 4) /* use external sdio irq */
#define MSDC_REMOVABLE (1 << 5) /* removable slot */ #define MSDC_REMOVABLE (1 << 5) /* removable slot */
#define MSDC_SYS_SUSPEND (1 << 6) /* suspended by system */
#define MSDC_HIGHSPEED (1 << 7) /* high-speed mode support */
#define MSDC_UHS1 (1 << 8) /* uhs-1 mode support */
#define MSDC_DDR (1 << 9) /* ddr mode support */
#define MSDC_SMPL_RISING (0) #define MSDC_SMPL_RISING (0)
#define MSDC_SMPL_FALLING (1) #define MSDC_SMPL_FALLING (1)
@ -50,14 +67,71 @@
#define MSDC_WP_PIN (3) #define MSDC_WP_PIN (3)
#define MSDC_RST_PIN (4) #define MSDC_RST_PIN (4)
struct msdc_hw { enum {
unsigned char clk_src; /* host clock source */ MSDC_CLKSRC_48MHZ = 0,
unsigned long flags; /* hardware capability flags */ // MSDC_CLKSRC_26MHZ = 0,
// MSDC_CLKSRC_197MHZ = 1,
// MSDC_CLKSRC_208MHZ = 2
};
/* config gpio pull mode */ struct msdc_hw {
void (*config_gpio_pin)(int type, int pull); unsigned char clk_src; /* host clock source */
unsigned char cmd_edge; /* command latch edge */
unsigned char data_edge; /* data latch edge */
unsigned char clk_drv; /* clock pad driving */
unsigned char cmd_drv; /* command pad driving */
unsigned char dat_drv; /* data pad driving */
unsigned long flags; /* hardware capability flags */
unsigned long data_pins; /* data pins */
unsigned long data_offset; /* data address offset */
/* config gpio pull mode */
void (*config_gpio_pin)(int type, int pull);
/* external power control for card */
void (*ext_power_on)(void);
void (*ext_power_off)(void);
/* external sdio irq operations */
void (*request_sdio_eirq)(sdio_irq_handler_t sdio_irq_handler, void *data);
void (*enable_sdio_eirq)(void);
void (*disable_sdio_eirq)(void);
/* external cd irq operations */
void (*request_cd_eirq)(sdio_irq_handler_t cd_irq_handler, void *data);
void (*enable_cd_eirq)(void);
void (*disable_cd_eirq)(void);
int (*get_cd_status)(void);
/* power management callback for external module */
void (*register_pm)(pm_callback_t pm_cb, void *data);
}; };
extern struct msdc_hw msdc0_hw; extern struct msdc_hw msdc0_hw;
extern struct msdc_hw msdc1_hw;
extern struct msdc_hw msdc2_hw;
extern struct msdc_hw msdc3_hw;
/*GPS driver*/
#define GPS_FLAG_FORCE_OFF 0x0001
struct mt3326_gps_hardware {
int (*ext_power_on)(int);
int (*ext_power_off)(int);
};
extern struct mt3326_gps_hardware mt3326_gps_hw;
/* NAND driver */
struct mt6575_nand_host_hw {
unsigned int nfi_bus_width; /* NFI_BUS_WIDTH */
unsigned int nfi_access_timing; /* NFI_ACCESS_TIMING */
unsigned int nfi_cs_num; /* NFI_CS_NUM */
unsigned int nand_sec_size; /* NAND_SECTOR_SIZE */
unsigned int nand_sec_shift; /* NAND_SECTOR_SHIFT */
unsigned int nand_ecc_size;
unsigned int nand_ecc_bytes;
unsigned int nand_ecc_mode;
};
extern struct mt6575_nand_host_hw mt6575_nand_hw;
#endif /* __ARCH_ARM_MACH_BOARD_H */ #endif /* __ARCH_ARM_MACH_BOARD_H */

386
target/linux/ramips/files-4.14/drivers/mmc/host/mtk-mmc/dbg.c
View file

@ -32,7 +32,7 @@
* have been modified by MediaTek Inc. All revisions are subject to any receiver's * have been modified by MediaTek Inc. All revisions are subject to any receiver's
* applicable license agreements with MediaTek Inc. * applicable license agreements with MediaTek Inc.
*/ */
#include <linux/version.h> #include <linux/version.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/sched.h> #include <linux/sched.h>
@ -48,239 +48,276 @@
#include "mt6575_sd.h" #include "mt6575_sd.h"
#include <linux/seq_file.h> #include <linux/seq_file.h>
/* mode select */
u32 dma_size[4]={
512,
512,
512,
512
};
msdc_mode drv_mode[4]={
MODE_SIZE_DEP, /* using DMA or not depend on the size */
MODE_SIZE_DEP,
MODE_SIZE_DEP,
MODE_SIZE_DEP
};
#if defined (MT6575_SD_DEBUG)
static char cmd_buf[256]; static char cmd_buf[256];
/* for debug zone */ /* for debug zone */
unsigned int sd_debug_zone[4] = { static unsigned int sd_debug_zone[4]={
0, 0,
0, 0,
0, 0,
0 0
}; };
#if defined(MT6575_SD_DEBUG)
/* for driver profile */ /* for driver profile */
#define TICKS_ONE_MS (13000) #define TICKS_ONE_MS (13000)
u32 gpt_enable; u32 gpt_enable = 0;
u32 sdio_pro_enable; /* make sure gpt is enabled */ u32 sdio_pro_enable = 0; /* make sure gpt is enabled */
u32 sdio_pro_time; /* no more than 30s */ u32 sdio_pro_time = 0; /* no more than 30s */
struct sdio_profile sdio_perfomance = {0}; struct sdio_profile sdio_perfomance = {0};
#if 0 /* --- chhung */ #if 0 /* --- chhung */
void msdc_init_gpt(void) void msdc_init_gpt(void)
{ {
GPT_CONFIG config; GPT_CONFIG config;
config.num = GPT6; config.num = GPT6;
config.mode = GPT_FREE_RUN; config.mode = GPT_FREE_RUN;
config.clkSrc = GPT_CLK_SRC_SYS; config.clkSrc = GPT_CLK_SRC_SYS;
config.clkDiv = GPT_CLK_DIV_1; /* 13MHz GPT6 */ config.clkDiv = GPT_CLK_DIV_1; /* 13MHz GPT6 */
if (GPT_Config(config) == FALSE) if (GPT_Config(config) == FALSE )
return; return;
GPT_Start(GPT6); GPT_Start(GPT6);
} }
#endif /* end of --- */ #endif /* end of --- */
u32 msdc_time_calc(u32 old_L32, u32 old_H32, u32 new_L32, u32 new_H32) u32 msdc_time_calc(u32 old_L32, u32 old_H32, u32 new_L32, u32 new_H32)
{ {
u32 ret = 0; u32 ret = 0;
if (new_H32 == old_H32) {
ret = new_L32 - old_L32;
} else if(new_H32 == (old_H32 + 1)) {
if (new_L32 > old_L32) {
printk("msdc old_L<0x%x> new_L<0x%x>\n", old_L32, new_L32);
}
ret = (0xffffffff - old_L32);
ret += new_L32;
} else {
printk("msdc old_H<0x%x> new_H<0x%x>\n", old_H32, new_H32);
}
if (new_H32 == old_H32) { return ret;
ret = new_L32 - old_L32;
} else if (new_H32 == (old_H32 + 1)) {
if (new_L32 > old_L32)
printk("msdc old_L<0x%x> new_L<0x%x>\n", old_L32, new_L32);
ret = (0xffffffff - old_L32);
ret += new_L32;
} else {
printk("msdc old_H<0x%x> new_H<0x%x>\n", old_H32, new_H32);
}
return ret;
} }
void msdc_sdio_profile(struct sdio_profile *result) void msdc_sdio_profile(struct sdio_profile* result)
{ {
struct cmd_profile *cmd; struct cmd_profile* cmd;
u32 i; u32 i;
printk("sdio === performance dump ===\n");
printk("sdio === total execute tick<%d> time<%dms> Tx<%dB> Rx<%dB>\n",
result->total_tc, result->total_tc / TICKS_ONE_MS,
result->total_tx_bytes, result->total_rx_bytes);
printk("sdio === performance dump ===\n"); /* CMD52 Dump */
printk("sdio === total execute tick<%d> time<%dms> Tx<%dB> Rx<%dB>\n", cmd = &result->cmd52_rx;
result->total_tc, result->total_tc / TICKS_ONE_MS, printk("sdio === CMD52 Rx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc,
result->total_tx_bytes, result->total_rx_bytes); cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count);
cmd = &result->cmd52_tx;
printk("sdio === CMD52 Tx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count);
/* CMD53 Rx bytes + block mode */
for (i=0; i<512; i++) {
cmd = &result->cmd53_rx_byte[i];
if (cmd->count) {
printk("sdio<%6d><%3dB>_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count,
cmd->tot_bytes, (cmd->tot_bytes/10)*13 / (cmd->tot_tc/10));
}
}
for (i=0; i<100; i++) {
cmd = &result->cmd53_rx_blk[i];
if (cmd->count) {
printk("sdio<%6d><%3d>B_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count,
cmd->tot_bytes, (cmd->tot_bytes/10)*13 / (cmd->tot_tc/10));
}
}
/* CMD52 Dump */ /* CMD53 Tx bytes + block mode */
cmd = &result->cmd52_rx; for (i=0; i<512; i++) {
printk("sdio === CMD52 Rx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc, cmd = &result->cmd53_tx_byte[i];
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count); if (cmd->count) {
cmd = &result->cmd52_tx; printk("sdio<%6d><%3dB>_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
printk("sdio === CMD52 Tx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc, cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count,
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count); cmd->tot_bytes, (cmd->tot_bytes/10)*13 / (cmd->tot_tc/10));
}
/* CMD53 Rx bytes + block mode */ }
for (i = 0; i < 512; i++) { for (i=0; i<100; i++) {
cmd = &result->cmd53_rx_byte[i]; cmd = &result->cmd53_tx_blk[i];
if (cmd->count) { if (cmd->count) {
printk("sdio<%6d><%3dB>_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc, printk("sdio<%6d><%3d>B_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count, cmd->max_tc, cmd->min_tc, cmd->tot_tc/cmd->count,
cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10)); cmd->tot_bytes, (cmd->tot_bytes/10)*13 / (cmd->tot_tc/10));
} }
} }
for (i = 0; i < 100; i++) {
cmd = &result->cmd53_rx_blk[i]; printk("sdio === performance dump done ===\n");
if (cmd->count) {
printk("sdio<%6d><%3d>B_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
}
}
/* CMD53 Tx bytes + block mode */
for (i = 0; i < 512; i++) {
cmd = &result->cmd53_tx_byte[i];
if (cmd->count) {
printk("sdio<%6d><%3dB>_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
}
}
for (i = 0; i < 100; i++) {
cmd = &result->cmd53_tx_blk[i];
if (cmd->count) {
printk("sdio<%6d><%3d>B_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
}
}
printk("sdio === performance dump done ===\n");
} }
//========= sdio command table =========== //========= sdio command table ===========
void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks) void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks)
{ {
struct sdio_profile *result = &sdio_perfomance; struct sdio_profile* result = &sdio_perfomance;
struct cmd_profile *cmd; struct cmd_profile* cmd;
u32 block; u32 block;
if (sdio_pro_enable == 0) if (sdio_pro_enable == 0) {
return; return;
}
if (opcode == 52) { if (opcode == 52) {
cmd = bRx ? &result->cmd52_rx : &result->cmd52_tx; cmd = bRx ? &result->cmd52_rx : &result->cmd52_tx;
} else if (opcode == 53) { } else if (opcode == 53) {
if (sizes < 512) { if (sizes < 512) {
cmd = bRx ? &result->cmd53_rx_byte[sizes] : &result->cmd53_tx_byte[sizes]; cmd = bRx ? &result->cmd53_rx_byte[sizes] : &result->cmd53_tx_byte[sizes];
} else { } else {
block = sizes / 512; block = sizes / 512;
if (block >= 99) { if (block >= 99) {
printk("cmd53 error blocks\n"); printk("cmd53 error blocks\n");
while (1) while(1);
; }
} cmd = bRx ? &result->cmd53_rx_blk[block] : &result->cmd53_tx_blk[block];
cmd = bRx ? &result->cmd53_rx_blk[block] : &result->cmd53_tx_blk[block]; }
} } else {
} else { return;
return; }
}
/* update the members */
/* update the members */ if (ticks > cmd->max_tc){
if (ticks > cmd->max_tc) cmd->max_tc = ticks;
cmd->max_tc = ticks; }
if (cmd->min_tc == 0 || ticks < cmd->min_tc) if (cmd->min_tc == 0 || ticks < cmd->min_tc) {
cmd->min_tc = ticks; cmd->min_tc = ticks;
cmd->tot_tc += ticks; }
cmd->tot_bytes += sizes; cmd->tot_tc += ticks;
cmd->count++; cmd->tot_bytes += sizes;
cmd->count ++;
if (bRx)
result->total_rx_bytes += sizes; if (bRx) {
else result->total_rx_bytes += sizes;
result->total_tx_bytes += sizes; } else {
result->total_tc += ticks; result->total_tx_bytes += sizes;
}
/* dump when total_tc > 30s */ result->total_tc += ticks;
if (result->total_tc >= sdio_pro_time * TICKS_ONE_MS * 1000) {
msdc_sdio_profile(result); /* dump when total_tc > 30s */
memset(result, 0, sizeof(struct sdio_profile)); if (result->total_tc >= sdio_pro_time * TICKS_ONE_MS * 1000) {
} msdc_sdio_profile(result);
memset(result, 0 , sizeof(struct sdio_profile));
}
} }
//========== driver proc interface =========== //========== driver proc interface ===========
static int msdc_debug_proc_read(struct seq_file *s, void *p) static int msdc_debug_proc_read(struct seq_file *s, void *p)
{ {
seq_puts(s, "\n=========================================\n"); seq_printf(s, "\n=========================================\n");
seq_puts(s, "Index<0> + Id + Zone\n"); seq_printf(s, "Index<0> + Id + Zone\n");
seq_puts(s, "-> PWR<9> WRN<8> | FIO<7> OPS<6> FUN<5> CFG<4> | INT<3> RSP<2> CMD<1> DMA<0>\n"); seq_printf(s, "-> PWR<9> WRN<8> | FIO<7> OPS<6> FUN<5> CFG<4> | INT<3> RSP<2> CMD<1> DMA<0>\n");
seq_puts(s, "-> echo 0 3 0x3ff >msdc_bebug -> host[3] debug zone set to 0x3ff\n"); seq_printf(s, "-> echo 0 3 0x3ff >msdc_bebug -> host[3] debug zone set to 0x3ff\n");
seq_printf(s, "-> MSDC[0] Zone: 0x%.8x\n", sd_debug_zone[0]); seq_printf(s, "-> MSDC[0] Zone: 0x%.8x\n", sd_debug_zone[0]);
seq_printf(s, "-> MSDC[1] Zone: 0x%.8x\n", sd_debug_zone[1]); seq_printf(s, "-> MSDC[1] Zone: 0x%.8x\n", sd_debug_zone[1]);
seq_printf(s, "-> MSDC[2] Zone: 0x%.8x\n", sd_debug_zone[2]); seq_printf(s, "-> MSDC[2] Zone: 0x%.8x\n", sd_debug_zone[2]);
seq_printf(s, "-> MSDC[3] Zone: 0x%.8x\n", sd_debug_zone[3]); seq_printf(s, "-> MSDC[3] Zone: 0x%.8x\n", sd_debug_zone[3]);
seq_puts(s, "Index<3> + SDIO_PROFILE + TIME\n"); seq_printf(s, "Index<1> + ID:4|Mode:4 + DMA_SIZE\n");
seq_puts(s, "-> echo 3 1 0x1E >msdc_bebug -> enable sdio_profile, 30s\n"); seq_printf(s, "-> 0)PIO 1)DMA 2)SIZE\n");
seq_printf(s, "-> echo 1 22 0x200 >msdc_bebug -> host[2] size mode, dma when >= 512\n");
seq_printf(s, "-> MSDC[0] mode<%d> size<%d>\n", drv_mode[0], dma_size[0]);
seq_printf(s, "-> MSDC[1] mode<%d> size<%d>\n", drv_mode[1], dma_size[1]);
seq_printf(s, "-> MSDC[2] mode<%d> size<%d>\n", drv_mode[2], dma_size[2]);
seq_printf(s, "-> MSDC[3] mode<%d> size<%d>\n", drv_mode[3], dma_size[3]);
seq_printf(s, "Index<3> + SDIO_PROFILE + TIME\n");
seq_printf(s, "-> echo 3 1 0x1E >msdc_bebug -> enable sdio_profile, 30s\n");
seq_printf(s, "-> SDIO_PROFILE<%d> TIME<%ds>\n", sdio_pro_enable, sdio_pro_time); seq_printf(s, "-> SDIO_PROFILE<%d> TIME<%ds>\n", sdio_pro_enable, sdio_pro_time);
seq_puts(s, "=========================================\n\n"); seq_printf(s, "=========================================\n\n");
return 0; return 0;
} }
static ssize_t msdc_debug_proc_write(struct file *file, static ssize_t msdc_debug_proc_write(struct file *file,
const char __user *buf, size_t count, loff_t *data) const char __user *buf, size_t count, loff_t *data)
{ {
int ret; int ret;
int cmd, p1, p2; int cmd, p1, p2;
int id, zone; int id, zone;
int mode, size; int mode, size;
if (count == 0) if (count == 0)return -1;
return -1; if(count > 255)count = 255;
if (count > 255)
count = 255;
if (copy_from_user(cmd_buf, buf, count))
return -EFAULT;
ret = copy_from_user(cmd_buf, buf, count);
if (ret < 0)return -1;
cmd_buf[count] = '\0'; cmd_buf[count] = '\0';
printk("msdc Write %s\n", cmd_buf); printk("msdc Write %s\n", cmd_buf);
sscanf(cmd_buf, "%x %x %x", &cmd, &p1, &p2); sscanf(cmd_buf, "%x %x %x", &cmd, &p1, &p2);
if (cmd == SD_TOOL_ZONE) { if(cmd == SD_TOOL_ZONE) {
id = p1; id = p1; zone = p2; zone &= 0x3ff;
zone = p2;
zone &= 0x3ff;
printk("msdc host_id<%d> zone<0x%.8x>\n", id, zone); printk("msdc host_id<%d> zone<0x%.8x>\n", id, zone);
if (id >= 0 && id <= 3) { if(id >=0 && id<=3){
sd_debug_zone[id] = zone; sd_debug_zone[id] = zone;
} else if (id == 4) { }
else if(id == 4){
sd_debug_zone[0] = sd_debug_zone[1] = zone; sd_debug_zone[0] = sd_debug_zone[1] = zone;
sd_debug_zone[2] = sd_debug_zone[3] = zone; sd_debug_zone[2] = sd_debug_zone[3] = zone;
} else { }
else{
printk("msdc host_id error when set debug zone\n"); printk("msdc host_id error when set debug zone\n");
} }
} else if (cmd == SD_TOOL_DMA_SIZE) {
id = p1>>4; mode = (p1&0xf); size = p2;
if(id >=0 && id<=3){
drv_mode[id] = mode;
dma_size[id] = p2;
}
else if(id == 4){
drv_mode[0] = drv_mode[1] = mode;
drv_mode[2] = drv_mode[3] = mode;
dma_size[0] = dma_size[1] = p2;
dma_size[2] = dma_size[3] = p2;
}
else{
printk("msdc host_id error when select mode\n");
}
} else if (cmd == SD_TOOL_SDIO_PROFILE) { } else if (cmd == SD_TOOL_SDIO_PROFILE) {
if (p1 == 1) { /* enable profile */ if (p1 == 1) { /* enable profile */
if (gpt_enable == 0) { if (gpt_enable == 0) {
// msdc_init_gpt(); /* --- by chhung */ // msdc_init_gpt(); /* --- by chhung */
gpt_enable = 1; gpt_enable = 1;
} }
sdio_pro_enable = 1; sdio_pro_enable = 1;
if (p2 == 0) if (p2 == 0) p2 = 1; if (p2 >= 30) p2 = 30;
p2 = 1; sdio_pro_time = p2 ;
if (p2 >= 30) } else if (p1 == 0) {
p2 = 30;
sdio_pro_time = p2;
} else if (p1 == 0) {
/* todo */ /* todo */
sdio_pro_enable = 0; sdio_pro_enable = 0;
} }
} }
return count; return count;
} }
@ -290,17 +327,22 @@ static int msdc_debug_show(struct inode *inode, struct file *file)
} }
static const struct file_operations msdc_debug_fops = { static const struct file_operations msdc_debug_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.open = msdc_debug_show, .open = msdc_debug_show,
.read = seq_read, .read = seq_read,
.write = msdc_debug_proc_write, .write = msdc_debug_proc_write,
.llseek = seq_lseek, .llseek = seq_lseek,
.release = single_release, .release = single_release,
}; };
void msdc_debug_proc_init(void) int msdc_debug_proc_init(void)
{ {
proc_create("msdc_debug", 0660, NULL, &msdc_debug_fops); struct proc_dir_entry *de = proc_create("msdc_debug", 0667, NULL, &msdc_debug_fops);
if (!de || IS_ERR(de))
printk("!! Create MSDC debug PROC fail !!\n");
return 0 ;
} }
EXPORT_SYMBOL_GPL(msdc_debug_proc_init); EXPORT_SYMBOL_GPL(msdc_debug_proc_init);
#endif #endif

93
target/linux/ramips/files-4.14/drivers/mmc/host/mtk-mmc/dbg.h
View file

@ -39,45 +39,47 @@
extern u32 sdio_pro_enable; extern u32 sdio_pro_enable;
/* for a type command, e.g. CMD53, 2 blocks */ /* for a type command, e.g. CMD53, 2 blocks */
struct cmd_profile { struct cmd_profile {
u32 max_tc; /* Max tick count */ u32 max_tc; /* Max tick count */
u32 min_tc; u32 min_tc;
u32 tot_tc; /* total tick count */ u32 tot_tc; /* total tick count */
u32 tot_bytes; u32 tot_bytes;
u32 count; /* the counts of the command */ u32 count; /* the counts of the command */
}; };
/* dump when total_tc and total_bytes */ /* dump when total_tc and total_bytes */
struct sdio_profile { struct sdio_profile {
u32 total_tc; /* total tick count of CMD52 and CMD53 */ u32 total_tc; /* total tick count of CMD52 and CMD53 */
u32 total_tx_bytes; /* total bytes of CMD53 Tx */ u32 total_tx_bytes; /* total bytes of CMD53 Tx */
u32 total_rx_bytes; /* total bytes of CMD53 Rx */ u32 total_rx_bytes; /* total bytes of CMD53 Rx */
/*CMD52*/
struct cmd_profile cmd52_tx;
struct cmd_profile cmd52_rx;
/*CMD52*/ /*CMD53 in byte unit */
struct cmd_profile cmd52_tx; struct cmd_profile cmd53_tx_byte[512];
struct cmd_profile cmd52_rx; struct cmd_profile cmd53_rx_byte[512];
/*CMD53 in byte unit */ /*CMD53 in block unit */
struct cmd_profile cmd53_tx_byte[512]; struct cmd_profile cmd53_tx_blk[100];
struct cmd_profile cmd53_rx_byte[512]; struct cmd_profile cmd53_rx_blk[100];
/*CMD53 in block unit */
struct cmd_profile cmd53_tx_blk[100];
struct cmd_profile cmd53_rx_blk[100];
}; };
//========================== //==========================
enum msdc_dbg { typedef enum {
SD_TOOL_ZONE = 0, SD_TOOL_ZONE = 0,
SD_TOOL_DMA_SIZE = 1, SD_TOOL_DMA_SIZE = 1,
SD_TOOL_PM_ENABLE = 2, SD_TOOL_PM_ENABLE = 2,
SD_TOOL_SDIO_PROFILE = 3, SD_TOOL_SDIO_PROFILE = 3,
}; } msdc_dbg;
enum msdc_mode { typedef enum {
MODE_PIO = 0, MODE_PIO = 0,
MODE_DMA = 1, MODE_DMA = 1,
MODE_SIZE_DEP = 2, MODE_SIZE_DEP = 2,
}; } msdc_mode;
extern msdc_mode drv_mode[4];
extern u32 dma_size[4];
/* Debug message event */ /* Debug message event */
#define DBG_EVT_NONE (0) /* No event */ #define DBG_EVT_NONE (0) /* No event */
@ -102,10 +104,9 @@ extern unsigned int sd_debug_zone[4];
do { \ do { \
if (x) { \ if (x) { \
printk("[BUG] %s LINE:%d FILE:%s\n", #x, __LINE__, __FILE__); \ printk("[BUG] %s LINE:%d FILE:%s\n", #x, __LINE__, __FILE__); \
while (1) \ while(1); \
; \
} \ } \
} while (0) }while(0)
#endif /* end of +++ */ #endif /* end of +++ */
#define N_MSG(evt, fmt, args...) #define N_MSG(evt, fmt, args...)
@ -120,36 +121,36 @@ do { \
#define ERR_MSG(fmt, args...) \ #define ERR_MSG(fmt, args...) \
do { \ do { \
printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \ printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __FUNCTION__, __LINE__, current->comm, current->pid); \ host->id, ##args , __FUNCTION__, __LINE__, current->comm, current->pid); \
} while (0); } while(0);
#if 1 #if 1
//defined CONFIG_MTK_MMC_CD_POLL //defined CONFIG_MTK_MMC_CD_POLL
#define INIT_MSG(fmt, args...) #define INIT_MSG(fmt, args...)
#define IRQ_MSG(fmt, args...) #define IRQ_MSG(fmt, args...)
#else #else
#define INIT_MSG(fmt, args...) \ #define INIT_MSG(fmt, args...) \
do { \ do { \
printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \ printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __FUNCTION__, __LINE__, current->comm, current->pid); \ host->id, ##args , __FUNCTION__, __LINE__, current->comm, current->pid); \
} while (0); } while(0);
/* PID in ISR in not corrent */ /* PID in ISR in not corrent */
#define IRQ_MSG(fmt, args...) \ #define IRQ_MSG(fmt, args...) \
do { \ do { \
printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d>\n", \ printk(KERN_ERR TAG"%d -> "fmt" <- %s() : L<%d>\n", \
host->id, ##args, __FUNCTION__, __LINE__); \ host->id, ##args , __FUNCTION__, __LINE__); \
} while (0); } while(0);
#endif #endif
void msdc_debug_proc_init(void); int msdc_debug_proc_init(void);
#if 0 /* --- chhung */ #if 0 /* --- chhung */
void msdc_init_gpt(void); void msdc_init_gpt(void);
extern void GPT_GetCounter64(UINT32 *cntL32, UINT32 *cntH32); extern void GPT_GetCounter64(UINT32 *cntL32, UINT32 *cntH32);
#endif /* end of --- */ #endif /* end of --- */
u32 msdc_time_calc(u32 old_L32, u32 old_H32, u32 new_L32, u32 new_H32); u32 msdc_time_calc(u32 old_L32, u32 old_H32, u32 new_L32, u32 new_H32);
void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks); void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks);
#endif #endif

1068
target/linux/ramips/files-4.14/drivers/mmc/host/mtk-mmc/mt6575_sd.h
View file

File diff suppressed because it is too large Load diff

4248
target/linux/ramips/files-4.14/drivers/mmc/host/mtk-mmc/sd.c
View file

File diff suppressed because it is too large Load diff