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

   1 /* Copyright Statement:
   2  *
   3  * This software/firmware and related documentation ("MediaTek Software") are
   4  * protected under relevant copyright laws. The information contained herein
   5  * is confidential and proprietary to MediaTek Inc. and/or its licensors.
   6  * Without the prior written permission of MediaTek inc. and/or its licensors,
   7  * any reproduction, modification, use or disclosure of MediaTek Software,
   8  * and information contained herein, in whole or in part, shall be strictly prohibited.
   9  *
  10  * MediaTek Inc. (C) 2010. All rights reserved.
  11  *
  12  * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  13  * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  14  * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
  15  * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  18  * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  19  * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  20  * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
  21  * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
  22  * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
  23  * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
  24  * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
  25  * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
  26  * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  27  * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  28  * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
  29  * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  30  *
  31  * The following software/firmware and/or related documentation ("MediaTek Software")
  32  * have been modified by MediaTek Inc. All revisions are subject to any receiver's
  33  * applicable license agreements with MediaTek Inc.
  34  */
  35
  36 #include <linux/version.h>
  37 #include <linux/kernel.h>
  38 #include <linux/sched.h>
  39 #include <linux/kthread.h>
  40 #include <linux/delay.h>
  41 #include <linux/module.h>
  42 #include <linux/init.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/string.h>
  45 #include <linux/uaccess.h>
  46 // #include <mach/mt6575_gpt.h> /* --- by chhung */
  47 #include "dbg.h"
  48 #include "mt6575_sd.h"
  49 #include <linux/seq_file.h>
  50
  51 static char cmd_buf[256];
  52
  53 /* for debug zone */
  54 unsigned int sd_debug_zone[4] = {
  55         0,
  56         0,
  57         0,
  58         0
  59 };
  60
  61 #if defined(MT6575_SD_DEBUG)
  62 /* for driver profile */
  63 #define TICKS_ONE_MS  (13000)
  64 u32 gpt_enable;
  65 u32 sdio_pro_enable;   /* make sure gpt is enabled */
  66 u32 sdio_pro_time;     /* no more than 30s */
  67 struct sdio_profile sdio_perfomance = {0};
  68
  69 #if 0 /* --- chhung */
  70 void msdc_init_gpt(void)
  71 {
  72         GPT_CONFIG config;
  73
  74         config.num  = GPT6;
  75         config.mode = GPT_FREE_RUN;
  76         config.clkSrc = GPT_CLK_SRC_SYS;
  77         config.clkDiv = GPT_CLK_DIV_1;   /* 13MHz GPT6 */
  78
  79         if (GPT_Config(config) == FALSE)
  80                 return;
  81
  82         GPT_Start(GPT6);
  83 }
  84 #endif /* end of --- */
  85
  86 u32 msdc_time_calc(u32 old_L32, u32 old_H32, u32 new_L32, u32 new_H32)
  87 {
  88         u32 ret = 0;
  89
  90         if (new_H32 == old_H32) {
  91                 ret = new_L32 - old_L32;
  92         } else if (new_H32 == (old_H32 + 1)) {
  93                 if (new_L32 > old_L32)
  94                         printk("msdc old_L<0x%x> new_L<0x%x>\n", old_L32, new_L32);
  95                 ret = (0xffffffff - old_L32);
  96                 ret += new_L32;
  97         } else {
  98                 printk("msdc old_H<0x%x> new_H<0x%x>\n", old_H32, new_H32);
  99         }
 100
 101         return ret;
 102 }
 103
 104 void msdc_sdio_profile(struct sdio_profile *result)
 105 {
 106         struct cmd_profile *cmd;
 107         u32 i;
 108
 109         printk("sdio === performance dump ===\n");
 110         printk("sdio === total execute tick<%d> time<%dms> Tx<%dB> Rx<%dB>\n",
 111                 result->total_tc, result->total_tc / TICKS_ONE_MS,
 112                 result->total_tx_bytes, result->total_rx_bytes);
 113
 114         /* CMD52 Dump */
 115         cmd = &result->cmd52_rx;
 116         printk("sdio === CMD52 Rx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc,
 117                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count);
 118         cmd = &result->cmd52_tx;
 119         printk("sdio === CMD52 Tx <%d>times tick<%d> Max<%d> Min<%d> Aver<%d>\n", cmd->count, cmd->tot_tc,
 120                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count);
 121
 122         /* CMD53 Rx bytes + block mode */
 123         for (i = 0; i < 512; i++) {
 124                 cmd = &result->cmd53_rx_byte[i];
 125                 if (cmd->count) {
 126                         printk("sdio<%6d><%3dB>_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
 127                                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
 128                                cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
 129                 }
 130         }
 131         for (i = 0; i < 100; i++) {
 132                 cmd = &result->cmd53_rx_blk[i];
 133                 if (cmd->count) {
 134                         printk("sdio<%6d><%3d>B_Rx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
 135                                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
 136                                cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
 137                 }
 138         }
 139
 140         /* CMD53 Tx bytes + block mode */
 141         for (i = 0; i < 512; i++) {
 142                 cmd = &result->cmd53_tx_byte[i];
 143                 if (cmd->count) {
 144                         printk("sdio<%6d><%3dB>_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
 145                                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
 146                                cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
 147                 }
 148         }
 149         for (i = 0; i < 100; i++) {
 150                 cmd = &result->cmd53_tx_blk[i];
 151                 if (cmd->count) {
 152                         printk("sdio<%6d><%3d>B_Tx_<%9d><%9d><%6d><%6d>_<%9dB><%2dM>\n", cmd->count, i, cmd->tot_tc,
 153                                cmd->max_tc, cmd->min_tc, cmd->tot_tc / cmd->count,
 154                                cmd->tot_bytes, (cmd->tot_bytes / 10) * 13 / (cmd->tot_tc / 10));
 155                 }
 156         }
 157
 158         printk("sdio === performance dump done ===\n");
 159 }
 160
 161 //========= sdio command table ===========
 162 void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks)
 163 {
 164         struct sdio_profile *result = &sdio_perfomance;
 165         struct cmd_profile *cmd;
 166         u32 block;
 167
 168         if (sdio_pro_enable == 0)
 169                 return;
 170
 171         if (opcode == 52) {
 172                 cmd = bRx ?  &result->cmd52_rx : &result->cmd52_tx;
 173         } else if (opcode == 53) {
 174                 if (sizes < 512) {
 175                         cmd = bRx ?  &result->cmd53_rx_byte[sizes] : &result->cmd53_tx_byte[sizes];
 176                 } else {
 177                         block = sizes / 512;
 178                         if (block >= 99) {
 179                                 printk("cmd53 error blocks\n");
 180                                 while (1)
 181                                         ;
 182                         }
 183                         cmd = bRx ?  &result->cmd53_rx_blk[block] : &result->cmd53_tx_blk[block];
 184                 }
 185         } else {
 186                 return;
 187         }
 188
 189         /* update the members */
 190         if (ticks > cmd->max_tc)
 191                 cmd->max_tc = ticks;
 192         if (cmd->min_tc == 0 || ticks < cmd->min_tc)
 193                 cmd->min_tc = ticks;
 194         cmd->tot_tc += ticks;
 195         cmd->tot_bytes += sizes;
 196         cmd->count++;
 197
 198         if (bRx)
 199                 result->total_rx_bytes += sizes;
 200         else
 201                 result->total_tx_bytes += sizes;
 202         result->total_tc += ticks;
 203
 204         /* dump when total_tc > 30s */
 205         if (result->total_tc >= sdio_pro_time * TICKS_ONE_MS * 1000) {
 206                 msdc_sdio_profile(result);
 207                 memset(result, 0, sizeof(struct sdio_profile));
 208         }
 209 }
 210
 211 //========== driver proc interface ===========
 212 static int msdc_debug_proc_read(struct seq_file *s, void *p)
 213 {
 214         seq_puts(s, "\n=========================================\n");
 215         seq_puts(s, "Index<0> + Id + Zone\n");
 216         seq_puts(s, "-> PWR<9> WRN<8> | FIO<7> OPS<6> FUN<5> CFG<4> | INT<3> RSP<2> CMD<1> DMA<0>\n");
 217         seq_puts(s, "-> echo 0 3 0x3ff >msdc_bebug -> host[3] debug zone set to 0x3ff\n");
 218         seq_printf(s, "-> MSDC[0] Zone: 0x%.8x\n", sd_debug_zone[0]);
 219         seq_printf(s, "-> MSDC[1] Zone: 0x%.8x\n", sd_debug_zone[1]);
 220         seq_printf(s, "-> MSDC[2] Zone: 0x%.8x\n", sd_debug_zone[2]);
 221         seq_printf(s, "-> MSDC[3] Zone: 0x%.8x\n", sd_debug_zone[3]);
 222
 223         seq_puts(s, "Index<3> + SDIO_PROFILE + TIME\n");
 224         seq_puts(s, "-> echo 3 1 0x1E >msdc_bebug -> enable sdio_profile, 30s\n");
 225         seq_printf(s, "-> SDIO_PROFILE<%d> TIME<%ds>\n", sdio_pro_enable, sdio_pro_time);
 226         seq_puts(s, "=========================================\n\n");
 227
 228         return 0;
 229 }
 230
 231 static ssize_t msdc_debug_proc_write(struct file *file,
 232                                 const char __user *buf, size_t count, loff_t *data)
 233 {
 234         int ret;
 235
 236         int cmd, p1, p2;
 237         int id, zone;
 238         int mode, size;
 239
 240         if (count == 0)
 241                 return -1;
 242         if (count > 255)
 243                 count = 255;
 244
 245         if (copy_from_user(cmd_buf, buf, count))
 246                 return -EFAULT;
 247
 248         cmd_buf[count] = '\0';
 249         printk("msdc Write %s\n", cmd_buf);
 250
 251         sscanf(cmd_buf, "%x %x %x", &cmd, &p1, &p2);
 252
 253         if (cmd == SD_TOOL_ZONE) {
 254                 id = p1;
 255                 zone = p2;
 256                 zone &= 0x3ff;
 257                 printk("msdc host_id<%d> zone<0x%.8x>\n", id, zone);
 258                 if (id >= 0 && id <= 3) {
 259                         sd_debug_zone[id] = zone;
 260                 } else if (id == 4) {
 261                         sd_debug_zone[0] = sd_debug_zone[1] = zone;
 262                         sd_debug_zone[2] = sd_debug_zone[3] = zone;
 263                 } else {
 264                         printk("msdc host_id error when set debug zone\n");
 265                 }
 266         } else if (cmd == SD_TOOL_SDIO_PROFILE) {
 267                 if (p1 == 1) { /* enable profile */
 268                         if (gpt_enable == 0) {
 269                                 // msdc_init_gpt(); /* --- by chhung */
 270                                 gpt_enable = 1;
 271                         }
 272                         sdio_pro_enable = 1;
 273                         if (p2 == 0)
 274                                 p2 = 1;
 275                         if (p2 >= 30)
 276                                 p2 = 30;
 277                         sdio_pro_time = p2;
 278                 } else if (p1 == 0) {
 279                         /* todo */
 280                         sdio_pro_enable = 0;
 281                 }
 282         }
 283
 284         return count;
 285 }
 286
 287 static int msdc_debug_show(struct inode *inode, struct file *file)
 288 {
 289         return single_open(file, msdc_debug_proc_read, NULL);
 290 }
 291
 292 static const struct file_operations msdc_debug_fops = {
 293         .owner          = THIS_MODULE,
 294         .open           = msdc_debug_show,
 295         .read           = seq_read,
 296         .write          = msdc_debug_proc_write,
 297         .llseek         = seq_lseek,
 298         .release        = single_release,
 299 };
 300
 301 void msdc_debug_proc_init(void)
 302 {
 303         proc_create("msdc_debug", 0660, NULL, &msdc_debug_fops);
 304 }
 305 EXPORT_SYMBOL_GPL(msdc_debug_proc_init);
 306 #endif