drivers/staging/mt7621-mmc/sd.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/module.h>
  37 #include <linux/moduleparam.h>
  38 #include <linux/init.h>
  39 #include <linux/spinlock.h>
  40 #include <linux/timer.h>
  41 #include <linux/ioport.h>
  42 #include <linux/device.h>
  43 #include <linux/platform_device.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/delay.h>
  46 #include <linux/blkdev.h>
  47 #include <linux/slab.h>
  48 #include <linux/mmc/host.h>
  49 #include <linux/mmc/card.h>
  50 #include <linux/mmc/core.h>
  51 #include <linux/mmc/mmc.h>
  52 #include <linux/mmc/sd.h>
  53 #include <linux/mmc/sdio.h>
  54 #include <linux/dma-mapping.h>
  55
  56 /* +++ by chhung */
  57 #include <linux/types.h>
  58 #include <linux/kernel.h>
  59 #include <linux/version.h>
  60 #include <linux/pm.h>
  61 #include <linux/of.h>
  62
  63 //#define IRQ_SDC 14    //MT7620 /*FIXME*/
  64 #ifdef CONFIG_SOC_MT7621
  65 #define RALINK_SYSCTL_BASE              0xbe000000
  66 #define RALINK_MSDC_BASE                0xbe130000
  67 #else
  68 #define RALINK_SYSCTL_BASE              0xb0000000
  69 #define RALINK_MSDC_BASE                0xb0130000
  70 #endif
  71 #define IRQ_SDC                 22      /*FIXME*/
  72
  73 #include <asm/dma.h>
  74 /* end of +++ */
  75
  76 #include <asm/mach-ralink/ralink_regs.h>
  77
  78 #if 0 /* --- by chhung */
  79 #include <mach/board.h>
  80 #include <mach/mt6575_devs.h>
  81 #include <mach/mt6575_typedefs.h>
  82 #include <mach/mt6575_clock_manager.h>
  83 #include <mach/mt6575_pm_ldo.h>
  84 //#include <mach/mt6575_pll.h>
  85 //#include <mach/mt6575_gpio.h>
  86 //#include <mach/mt6575_gpt_sw.h>
  87 #include <asm/tcm.h>
  88 // #include <mach/mt6575_gpt.h>
  89 #endif /* end of --- */
  90
  91 #include "mt6575_sd.h"
  92 #include "dbg.h"
  93
  94 /* +++ by chhung */
  95 #include "board.h"
  96 /* end of +++ */
  97
  98 #if 0 /* --- by chhung */
  99 #define isb() __asm__ __volatile__ ("" : : : "memory")
 100 #define dsb() __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 4" \
 101                                     : : "r" (0) : "memory")
 102 #define dmb() __asm__ __volatile__ ("" : : : "memory")
 103 #endif /* end of --- */
 104
 105 #define DRV_NAME            "mtk-sd"
 106
 107 #define HOST_MAX_NUM        (1) /* +/- by chhung */
 108
 109 #if defined(CONFIG_SOC_MT7620)
 110 #define HOST_MAX_MCLK       (48000000) /* +/- by chhung */
 111 #elif defined(CONFIG_SOC_MT7621)
 112 #define HOST_MAX_MCLK       (50000000) /* +/- by chhung */
 113 #endif
 114 #define HOST_MIN_MCLK       (260000)
 115
 116 #define HOST_MAX_BLKSZ      (2048)
 117
 118 #define MSDC_OCR_AVAIL      (MMC_VDD_28_29 | MMC_VDD_29_30 | MMC_VDD_30_31 | MMC_VDD_31_32 | MMC_VDD_32_33)
 119
 120 #define GPIO_PULL_DOWN      (0)
 121 #define GPIO_PULL_UP        (1)
 122
 123 #if 0 /* --- by chhung */
 124 #define MSDC_CLKSRC_REG     (0xf100000C)
 125 #define PDN_REG           (0xF1000010)
 126 #endif /* end of --- */
 127
 128 #define DEFAULT_DEBOUNCE    (8)       /* 8 cycles */
 129 #define DEFAULT_DTOC        (40)      /* data timeout counter. 65536x40 sclk. */
 130
 131 #define CMD_TIMEOUT         (HZ / 10)     /* 100ms */
 132 #define DAT_TIMEOUT         (HZ / 2 * 5)  /* 500ms x5 */
 133
 134 #define MAX_DMA_CNT         (64 * 1024 - 512)   /* a single transaction for WIFI may be 50K*/
 135
 136 #define MAX_GPD_NUM         (1 + 1)  /* one null gpd */
 137 #define MAX_BD_NUM          (1024)
 138 #define MAX_BD_PER_GPD      (MAX_BD_NUM)
 139
 140 #define MAX_HW_SGMTS        (MAX_BD_NUM)
 141 #define MAX_PHY_SGMTS       (MAX_BD_NUM)
 142 #define MAX_SGMT_SZ         (MAX_DMA_CNT)
 143 #define MAX_REQ_SZ          (MAX_SGMT_SZ * 8)
 144
 145 #ifdef MT6575_SD_DEBUG
 146 static struct msdc_regs *msdc_reg[HOST_MAX_NUM];
 147 #endif
 148
 149 static int cd_active_low = 1;
 150
 151 //=================================
 152 #define PERI_MSDC0_PDN      (15)
 153 //#define PERI_MSDC1_PDN    (16)
 154 //#define PERI_MSDC2_PDN    (17)
 155 //#define PERI_MSDC3_PDN    (18)
 156
 157 #if 0 /* --- by chhung */
 158 /* gate means clock power down */
 159 static int g_clk_gate = 0;
 160 #define msdc_gate_clock(id) \
 161         do {                                           \
 162                 g_clk_gate &= ~(1 << ((id) + PERI_MSDC0_PDN));  \
 163         } while (0)
 164 /* not like power down register. 1 means clock on. */
 165 #define msdc_ungate_clock(id) \
 166         do {                                        \
 167                 g_clk_gate |= 1 << ((id) + PERI_MSDC0_PDN);     \
 168         } while (0)
 169
 170 // do we need sync object or not
 171 void msdc_clk_status(int *status)
 172 {
 173         *status = g_clk_gate;
 174 }
 175 #endif /* end of --- */
 176
 177 /* +++ by chhung */
 178 struct msdc_hw msdc0_hw = {
 179         .clk_src        = 0,
 180         .clk_drv        = 4,
 181         .flags          = MSDC_CD_PIN_EN | MSDC_REMOVABLE,
 182 //      .flags          = MSDC_WP_PIN_EN | MSDC_CD_PIN_EN | MSDC_REMOVABLE,
 183 };
 184
 185 /* end of +++ */
 186
 187 static int msdc_rsp[] = {
 188         0,  /* RESP_NONE */
 189         1,  /* RESP_R1 */
 190         2,  /* RESP_R2 */
 191         3,  /* RESP_R3 */
 192         4,  /* RESP_R4 */
 193         1,  /* RESP_R5 */
 194         1,  /* RESP_R6 */
 195         1,  /* RESP_R7 */
 196         7,  /* RESP_R1b */
 197 };
 198
 199 /* For Inhanced DMA */
 200 #define msdc_init_gpd_ex(_gpd, extlen, cmd, arg, blknum) \
 201         do {                                        \
 202                 ((struct gpd *)_gpd)->extlen = extlen;      \
 203                 ((struct gpd *)_gpd)->cmd    = cmd;         \
 204                 ((struct gpd *)_gpd)->arg    = arg;         \
 205                 ((struct gpd *)_gpd)->blknum = blknum;      \
 206         } while (0)
 207
 208 #define msdc_txfifocnt()   ((sdr_read32(MSDC_FIFOCS) & MSDC_FIFOCS_TXCNT) >> 16)
 209 #define msdc_rxfifocnt()   ((sdr_read32(MSDC_FIFOCS) & MSDC_FIFOCS_RXCNT) >> 0)
 210 #define msdc_fifo_write32(v)   sdr_write32(MSDC_TXDATA, (v))
 211 #define msdc_fifo_write8(v)    sdr_write8(MSDC_TXDATA, (v))
 212 #define msdc_fifo_read32()   sdr_read32(MSDC_RXDATA)
 213 #define msdc_fifo_read8()    sdr_read8(MSDC_RXDATA)
 214
 215 #define msdc_dma_on()        sdr_clr_bits(MSDC_CFG, MSDC_CFG_PIO)
 216 #define msdc_dma_off()       sdr_set_bits(MSDC_CFG, MSDC_CFG_PIO)
 217
 218 #define msdc_retry(expr, retry, cnt) \
 219         do {                                                            \
 220                 int backup = cnt;                                       \
 221                 while (retry) {                                         \
 222                         if (!(expr))                                    \
 223                                 break;                                  \
 224                         if (cnt-- == 0) {                               \
 225                                 retry--; mdelay(1); cnt = backup;       \
 226                         }                                               \
 227                 }                                                       \
 228                 WARN_ON(retry == 0);                                    \
 229         } while (0)
 230
 231 static void msdc_reset_hw(struct msdc_host *host)
 232 {
 233         void __iomem *base = host->base;
 234
 235         sdr_set_bits(MSDC_CFG, MSDC_CFG_RST);
 236         while (sdr_read32(MSDC_CFG) & MSDC_CFG_RST)
 237                 cpu_relax();
 238 }
 239
 240 #define msdc_clr_int() \
 241         do {                                                    \
 242                 volatile u32 val = sdr_read32(MSDC_INT);        \
 243                 sdr_write32(MSDC_INT, val);                     \
 244         } while (0)
 245
 246 #define msdc_clr_fifo() \
 247         do {                                                            \
 248                 int retry = 3, cnt = 1000;                              \
 249                 sdr_set_bits(MSDC_FIFOCS, MSDC_FIFOCS_CLR);             \
 250                 msdc_retry(sdr_read32(MSDC_FIFOCS) & MSDC_FIFOCS_CLR, retry, cnt); \
 251         } while (0)
 252
 253 #define msdc_irq_save(val) \
 254         do {                                    \
 255                 val = sdr_read32(MSDC_INTEN);   \
 256                 sdr_clr_bits(MSDC_INTEN, val);  \
 257         } while (0)
 258
 259 #define msdc_irq_restore(val) \
 260         do {                                    \
 261                 sdr_set_bits(MSDC_INTEN, val);  \
 262         } while (0)
 263
 264 /* clock source for host: global */
 265 #if defined(CONFIG_SOC_MT7620)
 266 static u32 hclks[] = {48000000}; /* +/- by chhung */
 267 #elif defined(CONFIG_SOC_MT7621)
 268 static u32 hclks[] = {50000000}; /* +/- by chhung */
 269 #endif
 270
 271 //============================================
 272 // the power for msdc host controller: global
 273 //    always keep the VMC on.
 274 //============================================
 275 #define msdc_vcore_on(host) \
 276         do {                                                            \
 277                 INIT_MSG("[+]VMC ref. count<%d>", ++host->pwr_ref);     \
 278                 (void)hwPowerOn(MT65XX_POWER_LDO_VMC, VOL_3300, "SD");  \
 279         } while (0)
 280 #define msdc_vcore_off(host) \
 281         do {                                                            \
 282                 INIT_MSG("[-]VMC ref. count<%d>", --host->pwr_ref);     \
 283                 (void)hwPowerDown(MT65XX_POWER_LDO_VMC, "SD");          \
 284         } while (0)
 285
 286 //====================================
 287 // the vdd output for card: global
 288 //   always keep the VMCH on.
 289 //====================================
 290 #define msdc_vdd_on(host) \
 291         do {                                                            \
 292                 (void)hwPowerOn(MT65XX_POWER_LDO_VMCH, VOL_3300, "SD"); \
 293         } while (0)
 294 #define msdc_vdd_off(host) \
 295         do {                                                    \
 296                 (void)hwPowerDown(MT65XX_POWER_LDO_VMCH, "SD"); \
 297         } while (0)
 298
 299 #define sdc_is_busy()          (sdr_read32(SDC_STS) & SDC_STS_SDCBUSY)
 300 #define sdc_is_cmd_busy()      (sdr_read32(SDC_STS) & SDC_STS_CMDBUSY)
 301
 302 #define sdc_send_cmd(cmd, arg) \
 303         do {                                    \
 304                 sdr_write32(SDC_ARG, (arg));    \
 305                 sdr_write32(SDC_CMD, (cmd));    \
 306         } while (0)
 307
 308 // can modify to read h/w register.
 309 //#define is_card_present(h)   ((sdr_read32(MSDC_PS) & MSDC_PS_CDSTS) ? 0 : 1);
 310 #define is_card_present(h)     (((struct msdc_host *)(h))->card_inserted)
 311
 312 /* +++ by chhung */
 313 #ifndef __ASSEMBLY__
 314 #define PHYSADDR(a)             (((unsigned long)(a)) & 0x1fffffff)
 315 #else
 316 #define PHYSADDR(a)             ((a) & 0x1fffffff)
 317 #endif
 318 /* end of +++ */
 319 static unsigned int msdc_do_command(struct msdc_host   *host,
 320                                     struct mmc_command *cmd,
 321                                     int                 tune,
 322                                     unsigned long       timeout);
 323
 324 static int msdc_tune_cmdrsp(struct msdc_host *host, struct mmc_command *cmd);
 325
 326 #ifdef MT6575_SD_DEBUG
 327 static void msdc_dump_card_status(struct msdc_host *host, u32 status)
 328 {
 329 /* N_MSG is currently a no-op */
 330 #if 0
 331         static char *state[] = {
 332                 "Idle",                 /* 0 */
 333                 "Ready",                /* 1 */
 334                 "Ident",                /* 2 */
 335                 "Stby",                 /* 3 */
 336                 "Tran",                 /* 4 */
 337                 "Data",                 /* 5 */
 338                 "Rcv",                  /* 6 */
 339                 "Prg",                  /* 7 */
 340                 "Dis",                  /* 8 */
 341                 "Reserved",             /* 9 */
 342                 "Reserved",             /* 10 */
 343                 "Reserved",             /* 11 */
 344                 "Reserved",             /* 12 */
 345                 "Reserved",             /* 13 */
 346                 "Reserved",             /* 14 */
 347                 "I/O mode",             /* 15 */
 348         };
 349 #endif
 350         if (status & R1_OUT_OF_RANGE)
 351                 N_MSG(RSP, "[CARD_STATUS] Out of Range");
 352         if (status & R1_ADDRESS_ERROR)
 353                 N_MSG(RSP, "[CARD_STATUS] Address Error");
 354         if (status & R1_BLOCK_LEN_ERROR)
 355                 N_MSG(RSP, "[CARD_STATUS] Block Len Error");
 356         if (status & R1_ERASE_SEQ_ERROR)
 357                 N_MSG(RSP, "[CARD_STATUS] Erase Seq Error");
 358         if (status & R1_ERASE_PARAM)
 359                 N_MSG(RSP, "[CARD_STATUS] Erase Param");
 360         if (status & R1_WP_VIOLATION)
 361                 N_MSG(RSP, "[CARD_STATUS] WP Violation");
 362         if (status & R1_CARD_IS_LOCKED)
 363                 N_MSG(RSP, "[CARD_STATUS] Card is Locked");
 364         if (status & R1_LOCK_UNLOCK_FAILED)
 365                 N_MSG(RSP, "[CARD_STATUS] Lock/Unlock Failed");
 366         if (status & R1_COM_CRC_ERROR)
 367                 N_MSG(RSP, "[CARD_STATUS] Command CRC Error");
 368         if (status & R1_ILLEGAL_COMMAND)
 369                 N_MSG(RSP, "[CARD_STATUS] Illegal Command");
 370         if (status & R1_CARD_ECC_FAILED)
 371                 N_MSG(RSP, "[CARD_STATUS] Card ECC Failed");
 372         if (status & R1_CC_ERROR)
 373                 N_MSG(RSP, "[CARD_STATUS] CC Error");
 374         if (status & R1_ERROR)
 375                 N_MSG(RSP, "[CARD_STATUS] Error");
 376         if (status & R1_UNDERRUN)
 377                 N_MSG(RSP, "[CARD_STATUS] Underrun");
 378         if (status & R1_OVERRUN)
 379                 N_MSG(RSP, "[CARD_STATUS] Overrun");
 380         if (status & R1_CID_CSD_OVERWRITE)
 381                 N_MSG(RSP, "[CARD_STATUS] CID/CSD Overwrite");
 382         if (status & R1_WP_ERASE_SKIP)
 383                 N_MSG(RSP, "[CARD_STATUS] WP Eraser Skip");
 384         if (status & R1_CARD_ECC_DISABLED)
 385                 N_MSG(RSP, "[CARD_STATUS] Card ECC Disabled");
 386         if (status & R1_ERASE_RESET)
 387                 N_MSG(RSP, "[CARD_STATUS] Erase Reset");
 388         if (status & R1_READY_FOR_DATA)
 389                 N_MSG(RSP, "[CARD_STATUS] Ready for Data");
 390         if (status & R1_SWITCH_ERROR)
 391                 N_MSG(RSP, "[CARD_STATUS] Switch error");
 392         if (status & R1_APP_CMD)
 393                 N_MSG(RSP, "[CARD_STATUS] App Command");
 394
 395         N_MSG(RSP, "[CARD_STATUS] '%s' State", state[R1_CURRENT_STATE(status)]);
 396 }
 397
 398 static void msdc_dump_ocr_reg(struct msdc_host *host, u32 resp)
 399 {
 400         if (resp & (1 << 7))
 401                 N_MSG(RSP, "[OCR] Low Voltage Range");
 402         if (resp & (1 << 15))
 403                 N_MSG(RSP, "[OCR] 2.7-2.8 volt");
 404         if (resp & (1 << 16))
 405                 N_MSG(RSP, "[OCR] 2.8-2.9 volt");
 406         if (resp & (1 << 17))
 407                 N_MSG(RSP, "[OCR] 2.9-3.0 volt");
 408         if (resp & (1 << 18))
 409                 N_MSG(RSP, "[OCR] 3.0-3.1 volt");
 410         if (resp & (1 << 19))
 411                 N_MSG(RSP, "[OCR] 3.1-3.2 volt");
 412         if (resp & (1 << 20))
 413                 N_MSG(RSP, "[OCR] 3.2-3.3 volt");
 414         if (resp & (1 << 21))
 415                 N_MSG(RSP, "[OCR] 3.3-3.4 volt");
 416         if (resp & (1 << 22))
 417                 N_MSG(RSP, "[OCR] 3.4-3.5 volt");
 418         if (resp & (1 << 23))
 419                 N_MSG(RSP, "[OCR] 3.5-3.6 volt");
 420         if (resp & (1 << 24))
 421                 N_MSG(RSP, "[OCR] Switching to 1.8V Accepted (S18A)");
 422         if (resp & (1 << 30))
 423                 N_MSG(RSP, "[OCR] Card Capacity Status (CCS)");
 424         if (resp & (1 << 31))
 425                 N_MSG(RSP, "[OCR] Card Power Up Status (Idle)");
 426         else
 427                 N_MSG(RSP, "[OCR] Card Power Up Status (Busy)");
 428 }
 429
 430 static void msdc_dump_rca_resp(struct msdc_host *host, u32 resp)
 431 {
 432         u32 status = (((resp >> 15) & 0x1) << 23) |
 433                      (((resp >> 14) & 0x1) << 22) |
 434                      (((resp >> 13) & 0x1) << 19) |
 435                      (resp & 0x1fff);
 436
 437         N_MSG(RSP, "[RCA] 0x%.4x", resp >> 16);
 438         msdc_dump_card_status(host, status);
 439 }
 440
 441 static void msdc_dump_io_resp(struct msdc_host *host, u32 resp)
 442 {
 443         u32 flags = (resp >> 8) & 0xFF;
 444 #if 0
 445         char *state[] = {"DIS", "CMD", "TRN", "RFU"};
 446 #endif
 447         if (flags & (1 << 7))
 448                 N_MSG(RSP, "[IO] COM_CRC_ERR");
 449         if (flags & (1 << 6))
 450                 N_MSG(RSP, "[IO] Illgal command");
 451         if (flags & (1 << 3))
 452                 N_MSG(RSP, "[IO] Error");
 453         if (flags & (1 << 2))
 454                 N_MSG(RSP, "[IO] RFU");
 455         if (flags & (1 << 1))
 456                 N_MSG(RSP, "[IO] Function number error");
 457         if (flags & (1 << 0))
 458                 N_MSG(RSP, "[IO] Out of range");
 459
 460         N_MSG(RSP, "[IO] State: %s, Data:0x%x", state[(resp >> 12) & 0x3], resp & 0xFF);
 461 }
 462 #endif
 463
 464 static void msdc_set_timeout(struct msdc_host *host, u32 ns, u32 clks)
 465 {
 466         void __iomem *base = host->base;
 467         u32 timeout, clk_ns;
 468
 469         host->timeout_ns   = ns;
 470         host->timeout_clks = clks;
 471
 472         clk_ns  = 1000000000UL / host->sclk;
 473         timeout = ns / clk_ns + clks;
 474         timeout = timeout >> 16; /* in 65536 sclk cycle unit */
 475         timeout = timeout > 1 ? timeout - 1 : 0;
 476         timeout = timeout > 255 ? 255 : timeout;
 477
 478         sdr_set_field(SDC_CFG, SDC_CFG_DTOC, timeout);
 479
 480         N_MSG(OPS, "Set read data timeout: %dns %dclks -> %d x 65536 cycles",
 481               ns, clks, timeout + 1);
 482 }
 483
 484 static void msdc_tasklet_card(struct work_struct *work)
 485 {
 486         struct msdc_host *host = (struct msdc_host *)container_of(work,
 487                                 struct msdc_host, card_delaywork.work);
 488         void __iomem *base = host->base;
 489         u32 inserted;
 490         u32 status = 0;
 491     //u32 change = 0;
 492
 493         spin_lock(&host->lock);
 494
 495         status = sdr_read32(MSDC_PS);
 496         if (cd_active_low)
 497                 inserted = (status & MSDC_PS_CDSTS) ? 0 : 1;
 498         else
 499                 inserted = (status & MSDC_PS_CDSTS) ? 1 : 0;
 500
 501 #if 0
 502         change = host->card_inserted ^ inserted;
 503         host->card_inserted = inserted;
 504
 505         if (change && !host->suspend) {
 506                 if (inserted)
 507                         host->mmc->f_max = HOST_MAX_MCLK;  // work around
 508                 mmc_detect_change(host->mmc, msecs_to_jiffies(20));
 509         }
 510 #else  /* Make sure: handle the last interrupt */
 511         host->card_inserted = inserted;
 512
 513         if (!host->suspend) {
 514                 host->mmc->f_max = HOST_MAX_MCLK;
 515                 mmc_detect_change(host->mmc, msecs_to_jiffies(20));
 516         }
 517
 518         IRQ_MSG("card found<%s>", inserted ? "inserted" : "removed");
 519 #endif
 520
 521         spin_unlock(&host->lock);
 522 }
 523
 524 #if 0 /* --- by chhung */
 525 /* For E2 only */
 526 static u8 clk_src_bit[4] = {
 527         0, 3, 5, 7
 528 };
 529
 530 static void msdc_select_clksrc(struct msdc_host *host, unsigned char clksrc)
 531 {
 532         u32 val;
 533         void __iomem *base = host->base;
 534
 535         BUG_ON(clksrc > 3);
 536         INIT_MSG("set clock source to <%d>", clksrc);
 537
 538         val = sdr_read32(MSDC_CLKSRC_REG);
 539         if (sdr_read32(MSDC_ECO_VER) >= 4) {
 540                 val &= ~(0x3  << clk_src_bit[host->id]);
 541                 val |= clksrc << clk_src_bit[host->id];
 542         } else {
 543                 val &= ~0x3; val |= clksrc;
 544         }
 545         sdr_write32(MSDC_CLKSRC_REG, val);
 546
 547         host->hclk = hclks[clksrc];
 548         host->hw->clk_src = clksrc;
 549 }
 550 #endif /* end of --- */
 551
 552 static void msdc_set_mclk(struct msdc_host *host, int ddr, unsigned int hz)
 553 {
 554         //struct msdc_hw *hw = host->hw;
 555         void __iomem *base = host->base;
 556         u32 mode;
 557         u32 flags;
 558         u32 div;
 559         u32 sclk;
 560         u32 hclk = host->hclk;
 561         //u8  clksrc = hw->clk_src;
 562
 563         if (!hz) { // set mmc system clock to 0 ?
 564                 //ERR_MSG("set mclk to 0!!!");
 565                 msdc_reset_hw(host);
 566                 return;
 567         }
 568
 569         msdc_irq_save(flags);
 570
 571         if (ddr) {
 572                 mode = 0x2; /* ddr mode and use divisor */
 573                 if (hz >= (hclk >> 2)) {
 574                         div  = 1;         /* mean div = 1/4 */
 575                         sclk = hclk >> 2; /* sclk = clk / 4 */
 576                 } else {
 577                         div  = (hclk + ((hz << 2) - 1)) / (hz << 2);
 578                         sclk = (hclk >> 2) / div;
 579                 }
 580         } else if (hz >= hclk) { /* bug fix */
 581                 mode = 0x1; /* no divisor and divisor is ignored */
 582                 div  = 0;
 583                 sclk = hclk;
 584         } else {
 585                 mode = 0x0; /* use divisor */
 586                 if (hz >= (hclk >> 1)) {
 587                         div  = 0;         /* mean div = 1/2 */
 588                         sclk = hclk >> 1; /* sclk = clk / 2 */
 589                 } else {
 590                         div  = (hclk + ((hz << 2) - 1)) / (hz << 2);
 591                         sclk = (hclk >> 2) / div;
 592                 }
 593         }
 594
 595         /* set clock mode and divisor */
 596         sdr_set_field(MSDC_CFG, MSDC_CFG_CKMOD, mode);
 597         sdr_set_field(MSDC_CFG, MSDC_CFG_CKDIV, div);
 598
 599         /* wait clock stable */
 600         while (!(sdr_read32(MSDC_CFG) & MSDC_CFG_CKSTB))
 601                 cpu_relax();
 602
 603         host->sclk = sclk;
 604         host->mclk = hz;
 605         msdc_set_timeout(host, host->timeout_ns, host->timeout_clks); // need?
 606
 607         INIT_MSG("================");
 608         INIT_MSG("!!! Set<%dKHz> Source<%dKHz> -> sclk<%dKHz>", hz / 1000, hclk / 1000, sclk / 1000);
 609         INIT_MSG("================");
 610
 611         msdc_irq_restore(flags);
 612 }
 613
 614 /* Fix me. when need to abort */
 615 static void msdc_abort_data(struct msdc_host *host)
 616 {
 617         void __iomem *base = host->base;
 618         struct mmc_command *stop = host->mrq->stop;
 619
 620         ERR_MSG("Need to Abort. dma<%d>", host->dma_xfer);
 621
 622         msdc_reset_hw(host);
 623         msdc_clr_fifo();
 624         msdc_clr_int();
 625
 626         // need to check FIFO count 0 ?
 627
 628         if (stop) {  /* try to stop, but may not success */
 629                 ERR_MSG("stop when abort CMD<%d>", stop->opcode);
 630                 (void)msdc_do_command(host, stop, 0, CMD_TIMEOUT);
 631         }
 632
 633         //if (host->mclk >= 25000000) {
 634         //      msdc_set_mclk(host, 0, host->mclk >> 1);
 635         //}
 636 }
 637
 638 #if 0 /* --- by chhung */
 639 static void msdc_pin_config(struct msdc_host *host, int mode)
 640 {
 641         struct msdc_hw *hw = host->hw;
 642         void __iomem *base = host->base;
 643         int pull = (mode == MSDC_PIN_PULL_UP) ? GPIO_PULL_UP : GPIO_PULL_DOWN;
 644
 645         /* Config WP pin */
 646         if (hw->flags & MSDC_WP_PIN_EN) {
 647                 if (hw->config_gpio_pin) /* NULL */
 648                         hw->config_gpio_pin(MSDC_WP_PIN, pull);
 649         }
 650
 651         switch (mode) {
 652         case MSDC_PIN_PULL_UP:
 653                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPU, 1); /* Check & FIXME */
 654                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPD, 0); /* Check & FIXME */
 655                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU, 1);
 656                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD, 0);
 657                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU, 1);
 658                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD, 0);
 659                 break;
 660         case MSDC_PIN_PULL_DOWN:
 661                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPU, 0); /* Check & FIXME */
 662                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPD, 1); /* Check & FIXME */
 663                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU, 0);
 664                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD, 1);
 665                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU, 0);
 666                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD, 1);
 667                 break;
 668         case MSDC_PIN_PULL_NONE:
 669         default:
 670                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPU, 0); /* Check & FIXME */
 671                 //sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKPD, 0); /* Check & FIXME */
 672                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPU, 0);
 673                 sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDPD, 0);
 674                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPU, 0);
 675                 sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATPD, 0);
 676                 break;
 677         }
 678
 679         N_MSG(CFG, "Pins mode(%d), down(%d), up(%d)",
 680               mode, MSDC_PIN_PULL_DOWN, MSDC_PIN_PULL_UP);
 681 }
 682
 683 void msdc_pin_reset(struct msdc_host *host, int mode)
 684 {
 685         struct msdc_hw *hw = (struct msdc_hw *)host->hw;
 686         void __iomem *base = host->base;
 687         int pull = (mode == MSDC_PIN_PULL_UP) ? GPIO_PULL_UP : GPIO_PULL_DOWN;
 688
 689         /* Config reset pin */
 690         if (hw->flags & MSDC_RST_PIN_EN) {
 691                 if (hw->config_gpio_pin) /* NULL */
 692                         hw->config_gpio_pin(MSDC_RST_PIN, pull);
 693
 694                 if (mode == MSDC_PIN_PULL_UP)
 695                         sdr_clr_bits(EMMC_IOCON, EMMC_IOCON_BOOTRST);
 696                 else
 697                         sdr_set_bits(EMMC_IOCON, EMMC_IOCON_BOOTRST);
 698         }
 699 }
 700
 701 static void msdc_core_power(struct msdc_host *host, int on)
 702 {
 703         N_MSG(CFG, "Turn %s %s power (copower: %d -> %d)",
 704                 on ? "on" : "off", "core", host->core_power, on);
 705
 706         if (on && host->core_power == 0) {
 707                 msdc_vcore_on(host);
 708                 host->core_power = 1;
 709                 msleep(1);
 710         } else if (!on && host->core_power == 1) {
 711                 msdc_vcore_off(host);
 712                 host->core_power = 0;
 713                 msleep(1);
 714         }
 715 }
 716
 717 static void msdc_host_power(struct msdc_host *host, int on)
 718 {
 719         N_MSG(CFG, "Turn %s %s power ", on ? "on" : "off", "host");
 720
 721         if (on) {
 722                 //msdc_core_power(host, 1); // need do card detection.
 723                 msdc_pin_reset(host, MSDC_PIN_PULL_UP);
 724         } else {
 725                 msdc_pin_reset(host, MSDC_PIN_PULL_DOWN);
 726                 //msdc_core_power(host, 0);
 727         }
 728 }
 729
 730 static void msdc_card_power(struct msdc_host *host, int on)
 731 {
 732         N_MSG(CFG, "Turn %s %s power ", on ? "on" : "off", "card");
 733
 734         if (on) {
 735                 msdc_pin_config(host, MSDC_PIN_PULL_UP);
 736                 //msdc_vdd_on(host);  // need todo card detection.
 737                 msleep(1);
 738         } else {
 739                 //msdc_vdd_off(host);
 740                 msdc_pin_config(host, MSDC_PIN_PULL_DOWN);
 741                 msleep(1);
 742         }
 743 }
 744
 745 static void msdc_set_power_mode(struct msdc_host *host, u8 mode)
 746 {
 747         N_MSG(CFG, "Set power mode(%d)", mode);
 748
 749         if (host->power_mode == MMC_POWER_OFF && mode != MMC_POWER_OFF) {
 750                 msdc_host_power(host, 1);
 751                 msdc_card_power(host, 1);
 752         } else if (host->power_mode != MMC_POWER_OFF && mode == MMC_POWER_OFF) {
 753                 msdc_card_power(host, 0);
 754                 msdc_host_power(host, 0);
 755         }
 756         host->power_mode = mode;
 757 }
 758 #endif /* end of --- */
 759
 760 #ifdef CONFIG_PM
 761 /*
 762    register as callback function of WIFI(combo_sdio_register_pm) .
 763    can called by msdc_drv_suspend/resume too.
 764 */
 765 static void msdc_pm(pm_message_t state, void *data)
 766 {
 767         struct msdc_host *host = (struct msdc_host *)data;
 768         int evt = state.event;
 769
 770         if (evt == PM_EVENT_USER_RESUME || evt == PM_EVENT_USER_SUSPEND) {
 771                 INIT_MSG("USR_%s: suspend<%d> power<%d>",
 772                         evt == PM_EVENT_USER_RESUME ? "EVENT_USER_RESUME" : "EVENT_USER_SUSPEND",
 773                         host->suspend, host->power_mode);
 774         }
 775
 776         if (evt == PM_EVENT_SUSPEND || evt == PM_EVENT_USER_SUSPEND) {
 777                 if (host->suspend) /* already suspend */  /* default 0*/
 778                         return;
 779
 780                 /* for memory card. already power off by mmc */
 781                 if (evt == PM_EVENT_SUSPEND && host->power_mode == MMC_POWER_OFF)
 782                         return;
 783
 784                 host->suspend = 1;
 785                 host->pm_state = state;  /* default PMSG_RESUME */
 786
 787         } else if (evt == PM_EVENT_RESUME || evt == PM_EVENT_USER_RESUME) {
 788                 if (!host->suspend) {
 789                         //ERR_MSG("warning: already resume");
 790                         return;
 791                 }
 792
 793                 /* No PM resume when USR suspend */
 794                 if (evt == PM_EVENT_RESUME && host->pm_state.event == PM_EVENT_USER_SUSPEND) {
 795                         ERR_MSG("PM Resume when in USR Suspend");               /* won't happen. */
 796                         return;
 797                 }
 798
 799                 host->suspend = 0;
 800                 host->pm_state = state;
 801
 802         }
 803 }
 804 #endif
 805
 806 /*--------------------------------------------------------------------------*/
 807 /* mmc_host_ops members                                                      */
 808 /*--------------------------------------------------------------------------*/
 809 static unsigned int msdc_command_start(struct msdc_host   *host,
 810                                        struct mmc_command *cmd,
 811                                        int                 tune,   /* not used */
 812                                        unsigned long       timeout)
 813 {
 814         void __iomem *base = host->base;
 815         u32 opcode = cmd->opcode;
 816         u32 rawcmd;
 817         u32 wints = MSDC_INT_CMDRDY  | MSDC_INT_RSPCRCERR  | MSDC_INT_CMDTMO  |
 818                     MSDC_INT_ACMDRDY | MSDC_INT_ACMDCRCERR | MSDC_INT_ACMDTMO |
 819                     MSDC_INT_ACMD19_DONE;
 820
 821         u32 resp;
 822         unsigned long tmo;
 823
 824         /* Protocol layer does not provide response type, but our hardware needs
 825          * to know exact type, not just size!
 826          */
 827         if (opcode == MMC_SEND_OP_COND || opcode == SD_APP_OP_COND) {
 828                 resp = RESP_R3;
 829         } else if (opcode == MMC_SET_RELATIVE_ADDR) {
 830                 resp = (mmc_cmd_type(cmd) == MMC_CMD_BCR) ? RESP_R6 : RESP_R1;
 831         } else if (opcode == MMC_FAST_IO) {
 832                 resp = RESP_R4;
 833         } else if (opcode == MMC_GO_IRQ_STATE) {
 834                 resp = RESP_R5;
 835         } else if (opcode == MMC_SELECT_CARD) {
 836                 resp = (cmd->arg != 0) ? RESP_R1B : RESP_NONE;
 837         } else if (opcode == SD_IO_RW_DIRECT || opcode == SD_IO_RW_EXTENDED) {
 838                 resp = RESP_R1; /* SDIO workaround. */
 839         } else if (opcode == SD_SEND_IF_COND && (mmc_cmd_type(cmd) == MMC_CMD_BCR)) {
 840                 resp = RESP_R1;
 841         } else {
 842                 switch (mmc_resp_type(cmd)) {
 843                 case MMC_RSP_R1:
 844                         resp = RESP_R1;
 845                         break;
 846                 case MMC_RSP_R1B:
 847                         resp = RESP_R1B;
 848                         break;
 849                 case MMC_RSP_R2:
 850                         resp = RESP_R2;
 851                         break;
 852                 case MMC_RSP_R3:
 853                         resp = RESP_R3;
 854                         break;
 855                 case MMC_RSP_NONE:
 856                 default:
 857                         resp = RESP_NONE;
 858                         break;
 859                 }
 860         }
 861
 862         cmd->error = 0;
 863         /* rawcmd :
 864          * vol_swt << 30 | auto_cmd << 28 | blklen << 16 | go_irq << 15 |
 865          * stop << 14 | rw << 13 | dtype << 11 | rsptyp << 7 | brk << 6 | opcode
 866          */
 867         rawcmd = opcode | msdc_rsp[resp] << 7 | host->blksz << 16;
 868
 869         if (opcode == MMC_READ_MULTIPLE_BLOCK) {
 870                 rawcmd |= (2 << 11);
 871         } else if (opcode == MMC_READ_SINGLE_BLOCK) {
 872                 rawcmd |= (1 << 11);
 873         } else if (opcode == MMC_WRITE_MULTIPLE_BLOCK) {
 874                 rawcmd |= ((2 << 11) | (1 << 13));
 875         } else if (opcode == MMC_WRITE_BLOCK) {
 876                 rawcmd |= ((1 << 11) | (1 << 13));
 877         } else if (opcode == SD_IO_RW_EXTENDED) {
 878                 if (cmd->data->flags & MMC_DATA_WRITE)
 879                         rawcmd |= (1 << 13);
 880                 if (cmd->data->blocks > 1)
 881                         rawcmd |= (2 << 11);
 882                 else
 883                         rawcmd |= (1 << 11);
 884         } else if (opcode == SD_IO_RW_DIRECT && cmd->flags == (unsigned int)-1) {
 885                 rawcmd |= (1 << 14);
 886         } else if ((opcode == SD_APP_SEND_SCR) ||
 887                 (opcode == SD_APP_SEND_NUM_WR_BLKS) ||
 888                 (opcode == SD_SWITCH && (mmc_cmd_type(cmd) == MMC_CMD_ADTC)) ||
 889                 (opcode == SD_APP_SD_STATUS && (mmc_cmd_type(cmd) == MMC_CMD_ADTC)) ||
 890                 (opcode == MMC_SEND_EXT_CSD && (mmc_cmd_type(cmd) == MMC_CMD_ADTC))) {
 891                 rawcmd |= (1 << 11);
 892         } else if (opcode == MMC_STOP_TRANSMISSION) {
 893                 rawcmd |= (1 << 14);
 894                 rawcmd &= ~(0x0FFF << 16);
 895         }
 896
 897         N_MSG(CMD, "CMD<%d><0x%.8x> Arg<0x%.8x>", opcode, rawcmd, cmd->arg);
 898
 899         tmo = jiffies + timeout;
 900
 901         if (opcode == MMC_SEND_STATUS) {
 902                 for (;;) {
 903                         if (!sdc_is_cmd_busy())
 904                                 break;
 905
 906                         if (time_after(jiffies, tmo)) {
 907                                 ERR_MSG("XXX cmd_busy timeout: before CMD<%d>", opcode);
 908                                 cmd->error = (unsigned int)-ETIMEDOUT;
 909                                 msdc_reset_hw(host);
 910                                 goto end;
 911                         }
 912                 }
 913         } else {
 914                 for (;;) {
 915                         if (!sdc_is_busy())
 916                                 break;
 917                         if (time_after(jiffies, tmo)) {
 918                                 ERR_MSG("XXX sdc_busy timeout: before CMD<%d>", opcode);
 919                                 cmd->error = (unsigned int)-ETIMEDOUT;
 920                                 msdc_reset_hw(host);
 921                                 goto end;
 922                         }
 923                 }
 924         }
 925
 926         //BUG_ON(in_interrupt());
 927         host->cmd     = cmd;
 928         host->cmd_rsp = resp;
 929
 930         init_completion(&host->cmd_done);
 931
 932         sdr_set_bits(MSDC_INTEN, wints);
 933         sdc_send_cmd(rawcmd, cmd->arg);
 934
 935 end:
 936         return cmd->error;
 937 }
 938
 939 static unsigned int msdc_command_resp(struct msdc_host   *host,
 940                                       struct mmc_command *cmd,
 941                                       int                 tune,
 942                                       unsigned long       timeout)
 943         __must_hold(&host->lock)
 944 {
 945         void __iomem *base = host->base;
 946         u32 opcode = cmd->opcode;
 947         //u32 rawcmd;
 948         u32 resp;
 949         u32 wints = MSDC_INT_CMDRDY  | MSDC_INT_RSPCRCERR  | MSDC_INT_CMDTMO  |
 950                     MSDC_INT_ACMDRDY | MSDC_INT_ACMDCRCERR | MSDC_INT_ACMDTMO |
 951                     MSDC_INT_ACMD19_DONE;
 952
 953         resp = host->cmd_rsp;
 954
 955         BUG_ON(in_interrupt());
 956         //init_completion(&host->cmd_done);
 957         //sdr_set_bits(MSDC_INTEN, wints);
 958
 959         spin_unlock(&host->lock);
 960         if (!wait_for_completion_timeout(&host->cmd_done, 10 * timeout)) {
 961                 ERR_MSG("XXX CMD<%d> wait_for_completion timeout ARG<0x%.8x>", opcode, cmd->arg);
 962                 cmd->error = (unsigned int)-ETIMEDOUT;
 963                 msdc_reset_hw(host);
 964         }
 965         spin_lock(&host->lock);
 966
 967         sdr_clr_bits(MSDC_INTEN, wints);
 968         host->cmd = NULL;
 969
 970 //end:
 971 #ifdef MT6575_SD_DEBUG
 972         switch (resp) {
 973         case RESP_NONE:
 974                 N_MSG(RSP, "CMD_RSP(%d): %d RSP(%d)", opcode, cmd->error, resp);
 975                 break;
 976         case RESP_R2:
 977                 N_MSG(RSP, "CMD_RSP(%d): %d RSP(%d)= %.8x %.8x %.8x %.8x",
 978                         opcode, cmd->error, resp, cmd->resp[0], cmd->resp[1],
 979                         cmd->resp[2], cmd->resp[3]);
 980                 break;
 981         default: /* Response types 1, 3, 4, 5, 6, 7(1b) */
 982                 N_MSG(RSP, "CMD_RSP(%d): %d RSP(%d)= 0x%.8x",
 983                         opcode, cmd->error, resp, cmd->resp[0]);
 984                 if (cmd->error == 0) {
 985                         switch (resp) {
 986                         case RESP_R1:
 987                         case RESP_R1B:
 988                                 msdc_dump_card_status(host, cmd->resp[0]);
 989                                 break;
 990                         case RESP_R3:
 991                                 msdc_dump_ocr_reg(host, cmd->resp[0]);
 992                                 break;
 993                         case RESP_R5:
 994                                 msdc_dump_io_resp(host, cmd->resp[0]);
 995                                 break;
 996                         case RESP_R6:
 997                                 msdc_dump_rca_resp(host, cmd->resp[0]);
 998                                 break;
 999                         }
1000                 }
1001                 break;
1002         }
1003 #endif
1004
1005         /* do we need to save card's RCA when SD_SEND_RELATIVE_ADDR */
1006
1007         if (!tune)
1008                 return cmd->error;
1009
1010         /* memory card CRC */
1011         if (host->hw->flags & MSDC_REMOVABLE && cmd->error == (unsigned int)(-EIO)) {
1012                 if (sdr_read32(SDC_CMD) & 0x1800) { /* check if has data phase */
1013                         msdc_abort_data(host);
1014                 } else {
1015                         /* do basic: reset*/
1016                         msdc_reset_hw(host);
1017                         msdc_clr_fifo();
1018                         msdc_clr_int();
1019                 }
1020                 cmd->error = msdc_tune_cmdrsp(host, cmd);
1021         }
1022
1023         //  check DAT0
1024         /* if (resp == RESP_R1B) {
1025            while ((sdr_read32(MSDC_PS) & 0x10000) != 0x10000);
1026            } */
1027         /* CMD12 Error Handle */
1028
1029         return cmd->error;
1030 }
1031
1032 static unsigned int msdc_do_command(struct msdc_host   *host,
1033                                     struct mmc_command *cmd,
1034                                     int                 tune,
1035                                     unsigned long       timeout)
1036 {
1037         if (msdc_command_start(host, cmd, tune, timeout))
1038                 goto end;
1039
1040         if (msdc_command_resp(host, cmd, tune, timeout))
1041                 goto end;
1042
1043 end:
1044
1045         N_MSG(CMD, "        return<%d> resp<0x%.8x>", cmd->error, cmd->resp[0]);
1046         return cmd->error;
1047 }
1048
1049 /* The abort condition when PIO read/write
1050    tmo:
1051 */
1052 static int msdc_pio_abort(struct msdc_host *host, struct mmc_data *data, unsigned long tmo)
1053 {
1054         int  ret = 0;
1055         void __iomem *base = host->base;
1056
1057         if (atomic_read(&host->abort))
1058                 ret = 1;
1059
1060         if (time_after(jiffies, tmo)) {
1061                 data->error = (unsigned int)-ETIMEDOUT;
1062                 ERR_MSG("XXX PIO Data Timeout: CMD<%d>", host->mrq->cmd->opcode);
1063                 ret = 1;
1064         }
1065
1066         if (ret) {
1067                 msdc_reset_hw(host);
1068                 msdc_clr_fifo();
1069                 msdc_clr_int();
1070                 ERR_MSG("msdc pio find abort");
1071         }
1072         return ret;
1073 }
1074
1075 /*
1076    Need to add a timeout, or WDT timeout, system reboot.
1077 */
1078 // pio mode data read/write
1079 static int msdc_pio_read(struct msdc_host *host, struct mmc_data *data)
1080 {
1081         struct scatterlist *sg = data->sg;
1082         void __iomem *base = host->base;
1083         u32  num = data->sg_len;
1084         u32 *ptr;
1085         u8  *u8ptr;
1086         u32  left = 0;
1087         u32  count, size = 0;
1088         u32  wints = MSDC_INTEN_DATTMO | MSDC_INTEN_DATCRCERR;
1089         unsigned long tmo = jiffies + DAT_TIMEOUT;
1090
1091         sdr_set_bits(MSDC_INTEN, wints);
1092         while (num) {
1093                 left = sg_dma_len(sg);
1094                 ptr = sg_virt(sg);
1095                 while (left) {
1096                         if ((left >=  MSDC_FIFO_THD) && (msdc_rxfifocnt() >= MSDC_FIFO_THD)) {
1097                                 count = MSDC_FIFO_THD >> 2;
1098                                 do {
1099                                         *ptr++ = msdc_fifo_read32();
1100                                 } while (--count);
1101                                 left -= MSDC_FIFO_THD;
1102                         } else if ((left < MSDC_FIFO_THD) && msdc_rxfifocnt() >= left) {
1103                                 while (left > 3) {
1104                                         *ptr++ = msdc_fifo_read32();
1105                                         left -= 4;
1106                                 }
1107
1108                                 u8ptr = (u8 *)ptr;
1109                                 while (left) {
1110                                         *u8ptr++ = msdc_fifo_read8();
1111                                         left--;
1112                                 }
1113                         }
1114
1115                         if (msdc_pio_abort(host, data, tmo))
1116                                 goto end;
1117                 }
1118                 size += sg_dma_len(sg);
1119                 sg = sg_next(sg); num--;
1120         }
1121 end:
1122         data->bytes_xfered += size;
1123         N_MSG(FIO, "        PIO Read<%d>bytes", size);
1124
1125         sdr_clr_bits(MSDC_INTEN, wints);
1126         if (data->error)
1127                 ERR_MSG("read pio data->error<%d> left<%d> size<%d>", data->error, left, size);
1128         return data->error;
1129 }
1130
1131 /* please make sure won't using PIO when size >= 512
1132    which means, memory card block read/write won't using pio
1133    then don't need to handle the CMD12 when data error.
1134 */
1135 static int msdc_pio_write(struct msdc_host *host, struct mmc_data *data)
1136 {
1137         void __iomem *base = host->base;
1138         struct scatterlist *sg = data->sg;
1139         u32  num = data->sg_len;
1140         u32 *ptr;
1141         u8  *u8ptr;
1142         u32  left;
1143         u32  count, size = 0;
1144         u32  wints = MSDC_INTEN_DATTMO | MSDC_INTEN_DATCRCERR;
1145         unsigned long tmo = jiffies + DAT_TIMEOUT;
1146
1147         sdr_set_bits(MSDC_INTEN, wints);
1148         while (num) {
1149                 left = sg_dma_len(sg);
1150                 ptr = sg_virt(sg);
1151
1152                 while (left) {
1153                         if (left >= MSDC_FIFO_SZ && msdc_txfifocnt() == 0) {
1154                                 count = MSDC_FIFO_SZ >> 2;
1155                                 do {
1156                                         msdc_fifo_write32(*ptr); ptr++;
1157                                 } while (--count);
1158                                 left -= MSDC_FIFO_SZ;
1159                         } else if (left < MSDC_FIFO_SZ && msdc_txfifocnt() == 0) {
1160                                 while (left > 3) {
1161                                         msdc_fifo_write32(*ptr); ptr++;
1162                                         left -= 4;
1163                                 }
1164
1165                                 u8ptr = (u8 *)ptr;
1166                                 while (left) {
1167                                         msdc_fifo_write8(*u8ptr);       u8ptr++;
1168                                         left--;
1169                                 }
1170                         }
1171
1172                         if (msdc_pio_abort(host, data, tmo))
1173                                 goto end;
1174                 }
1175                 size += sg_dma_len(sg);
1176                 sg = sg_next(sg); num--;
1177         }
1178 end:
1179         data->bytes_xfered += size;
1180         N_MSG(FIO, "        PIO Write<%d>bytes", size);
1181         if (data->error)
1182                 ERR_MSG("write pio data->error<%d>", data->error);
1183
1184         sdr_clr_bits(MSDC_INTEN, wints);
1185         return data->error;
1186 }
1187
1188 #if 0 /* --- by chhung */
1189 // DMA resume / start / stop
1190 static void msdc_dma_resume(struct msdc_host *host)
1191 {
1192         void __iomem *base = host->base;
1193
1194         sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_RESUME, 1);
1195
1196         N_MSG(DMA, "DMA resume");
1197 }
1198 #endif /* end of --- */
1199
1200 static void msdc_dma_start(struct msdc_host *host)
1201 {
1202         void __iomem *base = host->base;
1203         u32 wints = MSDC_INTEN_XFER_COMPL | MSDC_INTEN_DATTMO | MSDC_INTEN_DATCRCERR;
1204
1205         sdr_set_bits(MSDC_INTEN, wints);
1206         //dsb(); /* --- by chhung */
1207         sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_START, 1);
1208
1209         N_MSG(DMA, "DMA start");
1210 }
1211
1212 static void msdc_dma_stop(struct msdc_host *host)
1213 {
1214         void __iomem *base = host->base;
1215         //u32 retries=500;
1216         u32 wints = MSDC_INTEN_XFER_COMPL | MSDC_INTEN_DATTMO | MSDC_INTEN_DATCRCERR;
1217
1218         N_MSG(DMA, "DMA status: 0x%.8x", sdr_read32(MSDC_DMA_CFG));
1219         //while (sdr_read32(MSDC_DMA_CFG) & MSDC_DMA_CFG_STS);
1220
1221         sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_STOP, 1);
1222         while (sdr_read32(MSDC_DMA_CFG) & MSDC_DMA_CFG_STS)
1223                 ;
1224
1225         //dsb(); /* --- by chhung */
1226         sdr_clr_bits(MSDC_INTEN, wints); /* Not just xfer_comp */
1227
1228         N_MSG(DMA, "DMA stop");
1229 }
1230
1231 /* calc checksum */
1232 static u8 msdc_dma_calcs(u8 *buf, u32 len)
1233 {
1234         u32 i, sum = 0;
1235
1236         for (i = 0; i < len; i++)
1237                 sum += buf[i];
1238         return 0xFF - (u8)sum;
1239 }
1240
1241 /* gpd bd setup + dma registers */
1242 static int msdc_dma_config(struct msdc_host *host, struct msdc_dma *dma)
1243 {
1244         void __iomem *base = host->base;
1245         //u32 i, j, num, bdlen, arg, xfersz;
1246         u32 j, num;
1247         struct scatterlist *sg = dma->sg;
1248         struct gpd *gpd;
1249         struct bd *bd;
1250
1251         switch (dma->mode) {
1252         case MSDC_MODE_DMA_BASIC:
1253                 BUG_ON(host->xfer_size > 65535);
1254                 BUG_ON(dma->sglen != 1);
1255                 sdr_write32(MSDC_DMA_SA, PHYSADDR(sg_dma_address(sg)));
1256                 sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_LASTBUF, 1);
1257 //#if defined (CONFIG_RALINK_MT7620)
1258                 if (ralink_soc == MT762X_SOC_MT7620A)
1259                         sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_XFERSZ, sg_dma_len(sg));
1260 //#elif defined (CONFIG_RALINK_MT7621) || defined (CONFIG_RALINK_MT7628)
1261                 else
1262                         sdr_write32((void __iomem *)(RALINK_MSDC_BASE + 0xa8), sg_dma_len(sg));
1263 //#endif
1264                 sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_BRUSTSZ,
1265                               MSDC_BRUST_64B);
1266                 sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_MODE, 0);
1267                 break;
1268         case MSDC_MODE_DMA_DESC:
1269
1270                 /* calculate the required number of gpd */
1271                 num = (dma->sglen + MAX_BD_PER_GPD - 1) / MAX_BD_PER_GPD;
1272                 BUG_ON(num != 1);
1273
1274                 gpd = dma->gpd;
1275                 bd  = dma->bd;
1276
1277                 /* modify gpd*/
1278                 //gpd->intr = 0;
1279                 gpd->hwo = 1;  /* hw will clear it */
1280                 gpd->bdp = 1;
1281                 gpd->chksum = 0;  /* need to clear first. */
1282                 gpd->chksum = msdc_dma_calcs((u8 *)gpd, 16);
1283
1284                 /* modify bd*/
1285                 for_each_sg(dma->sg, sg, dma->sglen, j) {
1286                         bd[j].blkpad = 0;
1287                         bd[j].dwpad = 0;
1288                         bd[j].ptr = (void *)sg_dma_address(sg);
1289                         bd[j].buflen = sg_dma_len(sg);
1290
1291                         if (j == dma->sglen - 1)
1292                                 bd[j].eol = 1;  /* the last bd */
1293                         else
1294                                 bd[j].eol = 0;
1295
1296                         bd[j].chksum = 0; /* checksume need to clear first */
1297                         bd[j].chksum = msdc_dma_calcs((u8 *)(&bd[j]), 16);
1298                 }
1299
1300                 sdr_set_field(MSDC_DMA_CFG, MSDC_DMA_CFG_DECSEN, 1);
1301                 sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_BRUSTSZ,
1302                               MSDC_BRUST_64B);
1303                 sdr_set_field(MSDC_DMA_CTRL, MSDC_DMA_CTRL_MODE, 1);
1304
1305                 sdr_write32(MSDC_DMA_SA, PHYSADDR((u32)dma->gpd_addr));
1306                 break;
1307
1308         default:
1309                 break;
1310         }
1311
1312         N_MSG(DMA, "DMA_CTRL = 0x%x", sdr_read32(MSDC_DMA_CTRL));
1313         N_MSG(DMA, "DMA_CFG  = 0x%x", sdr_read32(MSDC_DMA_CFG));
1314         N_MSG(DMA, "DMA_SA   = 0x%x", sdr_read32(MSDC_DMA_SA));
1315
1316         return 0;
1317 }
1318
1319 static void msdc_dma_setup(struct msdc_host *host, struct msdc_dma *dma,
1320                            struct scatterlist *sg, unsigned int sglen)
1321 {
1322         BUG_ON(sglen > MAX_BD_NUM); /* not support currently */
1323
1324         dma->sg = sg;
1325         dma->sglen = sglen;
1326
1327         if (sglen == 1 && sg_dma_len(sg) <= MAX_DMA_CNT)
1328                 dma->mode = MSDC_MODE_DMA_BASIC;
1329         else
1330                 dma->mode = MSDC_MODE_DMA_DESC;
1331
1332         N_MSG(DMA, "DMA mode<%d> sglen<%d> xfersz<%d>", dma->mode, dma->sglen,
1333               host->xfer_size);
1334
1335         msdc_dma_config(host, dma);
1336 }
1337
1338 /* set block number before send command */
1339 static void msdc_set_blknum(struct msdc_host *host, u32 blknum)
1340 {
1341         void __iomem *base = host->base;
1342
1343         sdr_write32(SDC_BLK_NUM, blknum);
1344 }
1345
1346 static int msdc_do_request(struct mmc_host *mmc, struct mmc_request *mrq)
1347         __must_hold(&host->lock)
1348 {
1349         struct msdc_host *host = mmc_priv(mmc);
1350         struct mmc_command *cmd;
1351         struct mmc_data *data;
1352         void __iomem *base = host->base;
1353         //u32 intsts = 0;
1354         unsigned int left = 0;
1355         int dma = 0, read = 1, send_type = 0;
1356
1357 #define SND_DAT 0
1358 #define SND_CMD 1
1359
1360         BUG_ON(mmc == NULL);
1361         BUG_ON(mrq == NULL);
1362
1363         host->error = 0;
1364         atomic_set(&host->abort, 0);
1365
1366         cmd  = mrq->cmd;
1367         data = mrq->cmd->data;
1368
1369 #if 0 /* --- by chhung */
1370         //if(host->id ==1){
1371         N_MSG(OPS, "enable clock!");
1372         msdc_ungate_clock(host->id);
1373         //}
1374 #endif /* end of --- */
1375
1376         if (!data) {
1377                 send_type = SND_CMD;
1378                 if (msdc_do_command(host, cmd, 1, CMD_TIMEOUT) != 0)
1379                         goto done;
1380         } else {
1381                 BUG_ON(data->blksz > HOST_MAX_BLKSZ);
1382                 send_type = SND_DAT;
1383
1384                 data->error = 0;
1385                 read = data->flags & MMC_DATA_READ ? 1 : 0;
1386                 host->data = data;
1387                 host->xfer_size = data->blocks * data->blksz;
1388                 host->blksz = data->blksz;
1389
1390                 /* deside the transfer mode */
1391                 if (drv_mode[host->id] == MODE_PIO)
1392                         host->dma_xfer = 0;
1393                 else if (drv_mode[host->id] == MODE_DMA)
1394                         host->dma_xfer = 1;
1395                 else if (drv_mode[host->id] == MODE_SIZE_DEP)
1396                         host->dma_xfer = ((host->xfer_size >= dma_size[host->id]) ? 1 : 0);
1397                 dma = host->dma_xfer;
1398
1399                 if (read) {
1400                         if ((host->timeout_ns != data->timeout_ns) ||
1401                                 (host->timeout_clks != data->timeout_clks)) {
1402                                 msdc_set_timeout(host, data->timeout_ns, data->timeout_clks);
1403                         }
1404                 }
1405
1406                 msdc_set_blknum(host, data->blocks);
1407                 //msdc_clr_fifo();  /* no need */
1408
1409                 if (dma) {
1410                         msdc_dma_on();  /* enable DMA mode first!! */
1411                         init_completion(&host->xfer_done);
1412
1413                         /* start the command first*/
1414                         if (msdc_command_start(host, cmd, 1, CMD_TIMEOUT) != 0)
1415                                 goto done;
1416
1417                         data->sg_count = dma_map_sg(mmc_dev(mmc), data->sg,
1418                                                     data->sg_len,
1419                                                     mmc_get_dma_dir(data));
1420                         msdc_dma_setup(host, &host->dma, data->sg,
1421                                        data->sg_count);
1422
1423                         /* then wait command done */
1424                         if (msdc_command_resp(host, cmd, 1, CMD_TIMEOUT) != 0)
1425                                 goto done;
1426
1427                         /* for read, the data coming too fast, then CRC error
1428                            start DMA no business with CRC. */
1429                         //init_completion(&host->xfer_done);
1430                         msdc_dma_start(host);
1431
1432                         spin_unlock(&host->lock);
1433                         if (!wait_for_completion_timeout(&host->xfer_done, DAT_TIMEOUT)) {
1434                                 ERR_MSG("XXX CMD<%d> wait xfer_done<%d> timeout!!", cmd->opcode, data->blocks * data->blksz);
1435                                 ERR_MSG("    DMA_SA   = 0x%x", sdr_read32(MSDC_DMA_SA));
1436                                 ERR_MSG("    DMA_CA   = 0x%x", sdr_read32(MSDC_DMA_CA));
1437                                 ERR_MSG("    DMA_CTRL = 0x%x", sdr_read32(MSDC_DMA_CTRL));
1438                                 ERR_MSG("    DMA_CFG  = 0x%x", sdr_read32(MSDC_DMA_CFG));
1439                                 data->error = (unsigned int)-ETIMEDOUT;
1440
1441                                 msdc_reset_hw(host);
1442                                 msdc_clr_fifo();
1443                                 msdc_clr_int();
1444                         }
1445                         spin_lock(&host->lock);
1446                         msdc_dma_stop(host);
1447                 } else {
1448                         /* Firstly: send command */
1449                         if (msdc_do_command(host, cmd, 1, CMD_TIMEOUT) != 0)
1450                                 goto done;
1451
1452                         /* Secondly: pio data phase */
1453                         if (read) {
1454                                 if (msdc_pio_read(host, data))
1455                                         goto done;
1456                         } else {
1457                                 if (msdc_pio_write(host, data))
1458                                         goto done;
1459                         }
1460
1461                         /* For write case: make sure contents in fifo flushed to device */
1462                         if (!read) {
1463                                 while (1) {
1464                                         left = msdc_txfifocnt();
1465                                         if (left == 0)
1466                                                 break;
1467                                         if (msdc_pio_abort(host, data, jiffies + DAT_TIMEOUT)) {
1468                                                 break;
1469                                                 /* Fix me: what about if data error, when stop ? how to? */
1470                                         }
1471                                 }
1472                         } else {
1473                                 /* Fix me: read case: need to check CRC error */
1474                         }
1475
1476                         /* For write case: SDCBUSY and Xfer_Comp will assert when DAT0 not busy.
1477                            For read case : SDCBUSY and Xfer_Comp will assert when last byte read out from FIFO.
1478                         */
1479
1480                         /* try not to wait xfer_comp interrupt.
1481                            the next command will check SDC_BUSY.
1482                            SDC_BUSY means xfer_comp assert
1483                         */
1484
1485                 } // PIO mode
1486
1487                 /* Last: stop transfer */
1488                 if (data->stop) {
1489                         if (msdc_do_command(host, data->stop, 0, CMD_TIMEOUT) != 0)
1490                                 goto done;
1491                 }
1492         }
1493
1494 done:
1495         if (data != NULL) {
1496                 host->data = NULL;
1497                 host->dma_xfer = 0;
1498                 if (dma != 0) {
1499                         msdc_dma_off();
1500                         dma_unmap_sg(mmc_dev(mmc), data->sg, data->sg_len,
1501                                      mmc_get_dma_dir(data));
1502                 }
1503                 host->blksz = 0;
1504
1505 #if 0 // don't stop twice!
1506                 if (host->hw->flags & MSDC_REMOVABLE && data->error) {
1507                         msdc_abort_data(host);
1508                         /* reset in IRQ, stop command has issued. -> No need */
1509                 }
1510 #endif
1511
1512                 N_MSG(OPS, "CMD<%d> data<%s %s> blksz<%d> block<%d> error<%d>", cmd->opcode, (dma ? "dma" : "pio"),
1513                         (read ? "read " : "write"), data->blksz, data->blocks, data->error);
1514         }
1515
1516 #if 0 /* --- by chhung */
1517 #if 1
1518         //if(host->id==1) {
1519         if (send_type == SND_CMD) {
1520                 if (cmd->opcode == MMC_SEND_STATUS) {
1521                         if ((cmd->resp[0] & CARD_READY_FOR_DATA) || (CARD_CURRENT_STATE(cmd->resp[0]) != 7)) {
1522                                 N_MSG(OPS, "disable clock, CMD13 IDLE");
1523                                 msdc_gate_clock(host->id);
1524                         }
1525                 } else {
1526                         N_MSG(OPS, "disable clock, CMD<%d>", cmd->opcode);
1527                         msdc_gate_clock(host->id);
1528                 }
1529         } else {
1530                 if (read) {
1531                         N_MSG(OPS, "disable clock!!! Read CMD<%d>", cmd->opcode);
1532                         msdc_gate_clock(host->id);
1533                 }
1534         }
1535         //}
1536 #else
1537         msdc_gate_clock(host->id);
1538 #endif
1539 #endif /* end of --- */
1540
1541         if (mrq->cmd->error)
1542                 host->error = 0x001;
1543         if (mrq->data && mrq->data->error)
1544                 host->error |= 0x010;
1545         if (mrq->stop && mrq->stop->error)
1546                 host->error |= 0x100;
1547
1548         //if (host->error) ERR_MSG("host->error<%d>", host->error);
1549
1550         return host->error;
1551 }
1552
1553 static int msdc_app_cmd(struct mmc_host *mmc, struct msdc_host *host)
1554 {
1555         struct mmc_command cmd;
1556         struct mmc_request mrq;
1557         u32 err;
1558
1559         memset(&cmd, 0, sizeof(struct mmc_command));
1560         cmd.opcode = MMC_APP_CMD;
1561 #if 0   /* bug: we meet mmc->card is null when ACMD6 */
1562         cmd.arg = mmc->card->rca << 16;
1563 #else
1564         cmd.arg = host->app_cmd_arg;
1565 #endif
1566         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1567
1568         memset(&mrq, 0, sizeof(struct mmc_request));
1569         mrq.cmd = &cmd; cmd.mrq = &mrq;
1570         cmd.data = NULL;
1571
1572         err = msdc_do_command(host, &cmd, 0, CMD_TIMEOUT);
1573         return err;
1574 }
1575
1576 static int msdc_tune_cmdrsp(struct msdc_host *host, struct mmc_command *cmd)
1577 {
1578         int result = -1;
1579         void __iomem *base = host->base;
1580         u32 rsmpl, cur_rsmpl, orig_rsmpl;
1581         u32 rrdly, cur_rrdly = 0xffffffff, orig_rrdly;
1582         u32 skip = 1;
1583
1584         /* ==== don't support 3.0 now ====
1585            1: R_SMPL[1]
1586            2: PAD_CMD_RESP_RXDLY[26:22]
1587            ==========================*/
1588
1589         // save the previous tune result
1590         sdr_get_field(MSDC_IOCON,    MSDC_IOCON_RSPL,        orig_rsmpl);
1591         sdr_get_field(MSDC_PAD_TUNE, MSDC_PAD_TUNE_CMDRRDLY, orig_rrdly);
1592
1593         rrdly = 0;
1594         do {
1595                 for (rsmpl = 0; rsmpl < 2; rsmpl++) {
1596                         /* Lv1: R_SMPL[1] */
1597                         cur_rsmpl = (orig_rsmpl + rsmpl) % 2;
1598                         if (skip == 1) {
1599                                 skip = 0;
1600                                 continue;
1601                         }
1602                         sdr_set_field(MSDC_IOCON, MSDC_IOCON_RSPL, cur_rsmpl);
1603
1604                         if (host->app_cmd) {
1605                                 result = msdc_app_cmd(host->mmc, host);
1606                                 if (result) {
1607                                         ERR_MSG("TUNE_CMD app_cmd<%d> failed: RESP_RXDLY<%d>,R_SMPL<%d>",
1608                                                 host->mrq->cmd->opcode, cur_rrdly, cur_rsmpl);
1609                                         continue;
1610                                 }
1611                         }
1612                         result = msdc_do_command(host, cmd, 0, CMD_TIMEOUT); // not tune.
1613                         ERR_MSG("TUNE_CMD<%d> %s PAD_CMD_RESP_RXDLY[26:22]<%d> R_SMPL[1]<%d>", cmd->opcode,
1614                                 (result == 0) ? "PASS" : "FAIL", cur_rrdly, cur_rsmpl);
1615
1616                         if (result == 0)
1617                                 return 0;
1618                         if (result != (unsigned int)(-EIO)) {
1619                                 ERR_MSG("TUNE_CMD<%d> Error<%d> not -EIO", cmd->opcode, result);
1620                                 return result;
1621                         }
1622
1623                         /* should be EIO */
1624                         if (sdr_read32(SDC_CMD) & 0x1800) { /* check if has data phase */
1625                                 msdc_abort_data(host);
1626                         }
1627                 }
1628
1629                 /* Lv2: PAD_CMD_RESP_RXDLY[26:22] */
1630                 cur_rrdly = (orig_rrdly + rrdly + 1) % 32;
1631                 sdr_set_field(MSDC_PAD_TUNE, MSDC_PAD_TUNE_CMDRRDLY, cur_rrdly);
1632         } while (++rrdly < 32);
1633
1634         return result;
1635 }
1636
1637 /* Support SD2.0 Only */
1638 static int msdc_tune_bread(struct mmc_host *mmc, struct mmc_request *mrq)
1639 {
1640         struct msdc_host *host = mmc_priv(mmc);
1641         void __iomem *base = host->base;
1642         u32 ddr = 0;
1643         u32 dcrc = 0;
1644         u32 rxdly, cur_rxdly0, cur_rxdly1;
1645         u32 dsmpl, cur_dsmpl,  orig_dsmpl;
1646         u32 cur_dat0,  cur_dat1,  cur_dat2,  cur_dat3;
1647         u32 cur_dat4,  cur_dat5,  cur_dat6,  cur_dat7;
1648         u32 orig_dat0, orig_dat1, orig_dat2, orig_dat3;
1649         u32 orig_dat4, orig_dat5, orig_dat6, orig_dat7;
1650         int result = -1;
1651         u32 skip = 1;
1652
1653         sdr_get_field(MSDC_IOCON, MSDC_IOCON_DSPL, orig_dsmpl);
1654
1655         /* Tune Method 2. */
1656         sdr_set_field(MSDC_IOCON, MSDC_IOCON_DDLSEL, 1);
1657
1658         rxdly = 0;
1659         do {
1660                 for (dsmpl = 0; dsmpl < 2; dsmpl++) {
1661                         cur_dsmpl = (orig_dsmpl + dsmpl) % 2;
1662                         if (skip == 1) {
1663                                 skip = 0;
1664                                 continue;
1665                         }
1666                         sdr_set_field(MSDC_IOCON, MSDC_IOCON_DSPL, cur_dsmpl);
1667
1668                         if (host->app_cmd) {
1669                                 result = msdc_app_cmd(host->mmc, host);
1670                                 if (result) {
1671                                         ERR_MSG("TUNE_BREAD app_cmd<%d> failed", host->mrq->cmd->opcode);
1672                                         continue;
1673                                 }
1674                         }
1675                         result = msdc_do_request(mmc, mrq);
1676
1677                         sdr_get_field(SDC_DCRC_STS, SDC_DCRC_STS_POS | SDC_DCRC_STS_NEG, dcrc); /* RO */
1678                         if (!ddr)
1679                                 dcrc &= ~SDC_DCRC_STS_NEG;
1680                         ERR_MSG("TUNE_BREAD<%s> dcrc<0x%x> DATRDDLY0/1<0x%x><0x%x> dsmpl<0x%x>",
1681                                 (result == 0 && dcrc == 0) ? "PASS" : "FAIL", dcrc,
1682                                 sdr_read32(MSDC_DAT_RDDLY0), sdr_read32(MSDC_DAT_RDDLY1), cur_dsmpl);
1683
1684                         /* Fix me: result is 0, but dcrc is still exist */
1685                         if (result == 0 && dcrc == 0) {
1686                                 goto done;
1687                         } else {
1688                                 /* there is a case: command timeout, and data phase not processed */
1689                                 if (mrq->data->error != 0 && mrq->data->error != (unsigned int)(-EIO)) {
1690                                         ERR_MSG("TUNE_READ: result<0x%x> cmd_error<%d> data_error<%d>",
1691                                                 result, mrq->cmd->error, mrq->data->error);
1692                                         goto done;
1693                                 }
1694                         }
1695                 }
1696
1697                 cur_rxdly0 = sdr_read32(MSDC_DAT_RDDLY0);
1698                 cur_rxdly1 = sdr_read32(MSDC_DAT_RDDLY1);
1699
1700                 /* E1 ECO. YD: Reverse */
1701                 if (sdr_read32(MSDC_ECO_VER) >= 4) {
1702                         orig_dat0 = (cur_rxdly0 >> 24) & 0x1F;
1703                         orig_dat1 = (cur_rxdly0 >> 16) & 0x1F;
1704                         orig_dat2 = (cur_rxdly0 >>  8) & 0x1F;
1705                         orig_dat3 = (cur_rxdly0 >>  0) & 0x1F;
1706                         orig_dat4 = (cur_rxdly1 >> 24) & 0x1F;
1707                         orig_dat5 = (cur_rxdly1 >> 16) & 0x1F;
1708                         orig_dat6 = (cur_rxdly1 >>  8) & 0x1F;
1709                         orig_dat7 = (cur_rxdly1 >>  0) & 0x1F;
1710                 } else {
1711                         orig_dat0 = (cur_rxdly0 >>  0) & 0x1F;
1712                         orig_dat1 = (cur_rxdly0 >>  8) & 0x1F;
1713                         orig_dat2 = (cur_rxdly0 >> 16) & 0x1F;
1714                         orig_dat3 = (cur_rxdly0 >> 24) & 0x1F;
1715                         orig_dat4 = (cur_rxdly1 >>  0) & 0x1F;
1716                         orig_dat5 = (cur_rxdly1 >>  8) & 0x1F;
1717                         orig_dat6 = (cur_rxdly1 >> 16) & 0x1F;
1718                         orig_dat7 = (cur_rxdly1 >> 24) & 0x1F;
1719                 }
1720
1721                 if (ddr) {
1722                         cur_dat0 = (dcrc & (1 << 0) || dcrc & (1 << 8))  ? ((orig_dat0 + 1) % 32) : orig_dat0;
1723                         cur_dat1 = (dcrc & (1 << 1) || dcrc & (1 << 9))  ? ((orig_dat1 + 1) % 32) : orig_dat1;
1724                         cur_dat2 = (dcrc & (1 << 2) || dcrc & (1 << 10)) ? ((orig_dat2 + 1) % 32) : orig_dat2;
1725                         cur_dat3 = (dcrc & (1 << 3) || dcrc & (1 << 11)) ? ((orig_dat3 + 1) % 32) : orig_dat3;
1726                 } else {
1727                         cur_dat0 = (dcrc & (1 << 0)) ? ((orig_dat0 + 1) % 32) : orig_dat0;
1728                         cur_dat1 = (dcrc & (1 << 1)) ? ((orig_dat1 + 1) % 32) : orig_dat1;
1729                         cur_dat2 = (dcrc & (1 << 2)) ? ((orig_dat2 + 1) % 32) : orig_dat2;
1730                         cur_dat3 = (dcrc & (1 << 3)) ? ((orig_dat3 + 1) % 32) : orig_dat3;
1731                 }
1732                 cur_dat4 = (dcrc & (1 << 4)) ? ((orig_dat4 + 1) % 32) : orig_dat4;
1733                 cur_dat5 = (dcrc & (1 << 5)) ? ((orig_dat5 + 1) % 32) : orig_dat5;
1734                 cur_dat6 = (dcrc & (1 << 6)) ? ((orig_dat6 + 1) % 32) : orig_dat6;
1735                 cur_dat7 = (dcrc & (1 << 7)) ? ((orig_dat7 + 1) % 32) : orig_dat7;
1736
1737                 cur_rxdly0 = (cur_dat0 << 24) | (cur_dat1 << 16) | (cur_dat2 << 8) | (cur_dat3 << 0);
1738                 cur_rxdly1 = (cur_dat4 << 24) | (cur_dat5 << 16) | (cur_dat6 << 8) | (cur_dat7 << 0);
1739
1740                 sdr_write32(MSDC_DAT_RDDLY0, cur_rxdly0);
1741                 sdr_write32(MSDC_DAT_RDDLY1, cur_rxdly1);
1742
1743         } while (++rxdly < 32);
1744
1745 done:
1746         return result;
1747 }
1748
1749 static int msdc_tune_bwrite(struct mmc_host *mmc, struct mmc_request *mrq)
1750 {
1751         struct msdc_host *host = mmc_priv(mmc);
1752         void __iomem *base = host->base;
1753
1754         u32 wrrdly, cur_wrrdly = 0xffffffff, orig_wrrdly;
1755         u32 dsmpl,  cur_dsmpl,  orig_dsmpl;
1756         u32 rxdly,  cur_rxdly0;
1757         u32 orig_dat0, orig_dat1, orig_dat2, orig_dat3;
1758         u32 cur_dat0,  cur_dat1,  cur_dat2,  cur_dat3;
1759         int result = -1;
1760         u32 skip = 1;
1761
1762         // MSDC_IOCON_DDR50CKD need to check. [Fix me]
1763
1764         sdr_get_field(MSDC_PAD_TUNE, MSDC_PAD_TUNE_DATWRDLY, orig_wrrdly);
1765         sdr_get_field(MSDC_IOCON,    MSDC_IOCON_DSPL,        orig_dsmpl);
1766
1767         /* Tune Method 2. just DAT0 */
1768         sdr_set_field(MSDC_IOCON, MSDC_IOCON_DDLSEL, 1);
1769         cur_rxdly0 = sdr_read32(MSDC_DAT_RDDLY0);
1770
1771         /* E1 ECO. YD: Reverse */
1772         if (sdr_read32(MSDC_ECO_VER) >= 4) {
1773                 orig_dat0 = (cur_rxdly0 >> 24) & 0x1F;
1774                 orig_dat1 = (cur_rxdly0 >> 16) & 0x1F;
1775                 orig_dat2 = (cur_rxdly0 >>  8) & 0x1F;
1776                 orig_dat3 = (cur_rxdly0 >>  0) & 0x1F;
1777         } else {
1778                 orig_dat0 = (cur_rxdly0 >>  0) & 0x1F;
1779                 orig_dat1 = (cur_rxdly0 >>  8) & 0x1F;
1780                 orig_dat2 = (cur_rxdly0 >> 16) & 0x1F;
1781                 orig_dat3 = (cur_rxdly0 >> 24) & 0x1F;
1782         }
1783
1784         rxdly = 0;
1785         do {
1786                 wrrdly = 0;
1787                 do {
1788                         for (dsmpl = 0; dsmpl < 2; dsmpl++) {
1789                                 cur_dsmpl = (orig_dsmpl + dsmpl) % 2;
1790                                 if (skip == 1) {
1791                                         skip = 0;
1792                                         continue;
1793                                 }
1794                                 sdr_set_field(MSDC_IOCON, MSDC_IOCON_DSPL, cur_dsmpl);
1795
1796                                 if (host->app_cmd) {
1797                                         result = msdc_app_cmd(host->mmc, host);
1798                                         if (result) {
1799                                                 ERR_MSG("TUNE_BWRITE app_cmd<%d> failed", host->mrq->cmd->opcode);
1800                                                 continue;
1801                                         }
1802                                 }
1803                                 result = msdc_do_request(mmc, mrq);
1804
1805                                 ERR_MSG("TUNE_BWRITE<%s> DSPL<%d> DATWRDLY<%d> MSDC_DAT_RDDLY0<0x%x>",
1806                                         result == 0 ? "PASS" : "FAIL",
1807                                         cur_dsmpl, cur_wrrdly, cur_rxdly0);
1808
1809                                 if (result == 0) {
1810                                         goto done;
1811                                 } else {
1812                                         /* there is a case: command timeout, and data phase not processed */
1813                                         if (mrq->data->error != (unsigned int)(-EIO)) {
1814                                                 ERR_MSG("TUNE_READ: result<0x%x> cmd_error<%d> data_error<%d>",
1815                                                         result, mrq->cmd->error, mrq->data->error);
1816                                                 goto done;
1817                                         }
1818                                 }
1819                         }
1820                         cur_wrrdly = (orig_wrrdly + wrrdly + 1) % 32;
1821                         sdr_set_field(MSDC_PAD_TUNE, MSDC_PAD_TUNE_DATWRDLY, cur_wrrdly);
1822                 } while (++wrrdly < 32);
1823
1824                 cur_dat0 = (orig_dat0 + rxdly) % 32; /* only adjust bit-1 for crc */
1825                 cur_dat1 = orig_dat1;
1826                 cur_dat2 = orig_dat2;
1827                 cur_dat3 = orig_dat3;
1828
1829                 cur_rxdly0 = (cur_dat0 << 24) | (cur_dat1 << 16) | (cur_dat2 << 8) | (cur_dat3 << 0);
1830                 sdr_write32(MSDC_DAT_RDDLY0, cur_rxdly0);
1831         } while (++rxdly < 32);
1832
1833 done:
1834         return result;
1835 }
1836
1837 static int msdc_get_card_status(struct mmc_host *mmc, struct msdc_host *host, u32 *status)
1838 {
1839         struct mmc_command cmd;
1840         struct mmc_request mrq;
1841         u32 err;
1842
1843         memset(&cmd, 0, sizeof(struct mmc_command));
1844         cmd.opcode = MMC_SEND_STATUS;
1845         if (mmc->card) {
1846                 cmd.arg = mmc->card->rca << 16;
1847         } else {
1848                 ERR_MSG("cmd13 mmc card is null");
1849                 cmd.arg = host->app_cmd_arg;
1850         }
1851         cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
1852
1853         memset(&mrq, 0, sizeof(struct mmc_request));
1854         mrq.cmd = &cmd; cmd.mrq = &mrq;
1855         cmd.data = NULL;
1856
1857         err = msdc_do_command(host, &cmd, 1, CMD_TIMEOUT);
1858
1859         if (status)
1860                 *status = cmd.resp[0];
1861
1862         return err;
1863 }
1864
1865 static int msdc_check_busy(struct mmc_host *mmc, struct msdc_host *host)
1866 {
1867         u32 err = 0;
1868         u32 status = 0;
1869
1870         do {
1871                 err = msdc_get_card_status(mmc, host, &status);
1872                 if (err)
1873                         return err;
1874                 /* need cmd12? */
1875                 ERR_MSG("cmd<13> resp<0x%x>", status);
1876         } while (R1_CURRENT_STATE(status) == 7);
1877
1878         return err;
1879 }
1880
1881 /* failed when msdc_do_request */
1882 static int msdc_tune_request(struct mmc_host *mmc, struct mmc_request *mrq)
1883 {
1884         struct msdc_host *host = mmc_priv(mmc);
1885         struct mmc_command *cmd;
1886         struct mmc_data *data;
1887         //u32 base = host->base;
1888         int ret = 0, read;
1889
1890         cmd  = mrq->cmd;
1891         data = mrq->cmd->data;
1892
1893         read = data->flags & MMC_DATA_READ ? 1 : 0;
1894
1895         if (read) {
1896                 if (data->error == (unsigned int)(-EIO))
1897                         ret = msdc_tune_bread(mmc, mrq);
1898         } else {
1899                 ret = msdc_check_busy(mmc, host);
1900                 if (ret) {
1901                         ERR_MSG("XXX cmd13 wait program done failed");
1902                         return ret;
1903                 }
1904                 /* CRC and TO */
1905                 /* Fix me: don't care card status? */
1906                 ret = msdc_tune_bwrite(mmc, mrq);
1907         }
1908
1909         return ret;
1910 }
1911
1912 /* ops.request */
1913 static void msdc_ops_request(struct mmc_host *mmc, struct mmc_request *mrq)
1914 {
1915         struct msdc_host *host = mmc_priv(mmc);
1916
1917         //=== for sdio profile ===
1918 #if 0 /* --- by chhung */
1919         u32 old_H32, old_L32, new_H32, new_L32;
1920         u32 ticks = 0, opcode = 0, sizes = 0, bRx = 0;
1921 #endif /* end of --- */
1922
1923         if (host->mrq) {
1924                 ERR_MSG("XXX host->mrq<0x%.8x>", (int)host->mrq);
1925                 BUG();
1926         }
1927
1928         if (!is_card_present(host) || host->power_mode == MMC_POWER_OFF) {
1929                 ERR_MSG("cmd<%d> card<%d> power<%d>", mrq->cmd->opcode, is_card_present(host), host->power_mode);
1930                 mrq->cmd->error = (unsigned int)-ENOMEDIUM;
1931
1932 #if 1
1933                 mrq->done(mrq);         // call done directly.
1934 #else
1935                 mrq->cmd->retries = 0;  // please don't retry.
1936                 mmc_request_done(mmc, mrq);
1937 #endif
1938
1939                 return;
1940         }
1941
1942         /* start to process */
1943         spin_lock(&host->lock);
1944 #if 0 /* --- by chhung */
1945         if (sdio_pro_enable) {  //=== for sdio profile ===
1946                 if (mrq->cmd->opcode == 52 || mrq->cmd->opcode == 53)
1947                         GPT_GetCounter64(&old_L32, &old_H32);
1948         }
1949 #endif /* end of --- */
1950
1951         host->mrq = mrq;
1952
1953         if (msdc_do_request(mmc, mrq)) {
1954                 if (host->hw->flags & MSDC_REMOVABLE && ralink_soc == MT762X_SOC_MT7621AT && mrq->data && mrq->data->error)
1955                         msdc_tune_request(mmc, mrq);
1956         }
1957
1958         /* ==== when request done, check if app_cmd ==== */
1959         if (mrq->cmd->opcode == MMC_APP_CMD) {
1960                 host->app_cmd = 1;
1961                 host->app_cmd_arg = mrq->cmd->arg;  /* save the RCA */
1962         } else {
1963                 host->app_cmd = 0;
1964                 //host->app_cmd_arg = 0;
1965         }
1966
1967         host->mrq = NULL;
1968
1969 #if 0 /* --- by chhung */
1970         //=== for sdio profile ===
1971         if (sdio_pro_enable) {
1972                 if (mrq->cmd->opcode == 52 || mrq->cmd->opcode == 53) {
1973                         GPT_GetCounter64(&new_L32, &new_H32);
1974                         ticks = msdc_time_calc(old_L32, old_H32, new_L32, new_H32);
1975
1976                         opcode = mrq->cmd->opcode;
1977                         if (mrq->cmd->data) {
1978                                 sizes = mrq->cmd->data->blocks * mrq->cmd->data->blksz;
1979                                 bRx = mrq->cmd->data->flags & MMC_DATA_READ ? 1 : 0;
1980                         } else {
1981                                 bRx = mrq->cmd->arg     & 0x80000000 ? 1 : 0;
1982                         }
1983
1984                         if (!mrq->cmd->error)
1985                                 msdc_performance(opcode, sizes, bRx, ticks);
1986                 }
1987         }
1988 #endif /* end of --- */
1989         spin_unlock(&host->lock);
1990
1991         mmc_request_done(mmc, mrq);
1992
1993         return;
1994 }
1995
1996 /* called by ops.set_ios */
1997 static void msdc_set_buswidth(struct msdc_host *host, u32 width)
1998 {
1999         void __iomem *base = host->base;
2000         u32 val = sdr_read32(SDC_CFG);
2001
2002         val &= ~SDC_CFG_BUSWIDTH;
2003
2004         switch (width) {
2005         default:
2006         case MMC_BUS_WIDTH_1:
2007                 width = 1;
2008                 val |= (MSDC_BUS_1BITS << 16);
2009                 break;
2010         case MMC_BUS_WIDTH_4:
2011                 val |= (MSDC_BUS_4BITS << 16);
2012                 break;
2013         case MMC_BUS_WIDTH_8:
2014                 val |= (MSDC_BUS_8BITS << 16);
2015                 break;
2016         }
2017
2018         sdr_write32(SDC_CFG, val);
2019
2020         N_MSG(CFG, "Bus Width = %d", width);
2021 }
2022
2023 /* ops.set_ios */
2024 static void msdc_ops_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
2025 {
2026         struct msdc_host *host = mmc_priv(mmc);
2027         void __iomem *base = host->base;
2028         u32 ddr = 0;
2029
2030 #ifdef MT6575_SD_DEBUG
2031         static char *vdd[] = {
2032                 "1.50v", "1.55v", "1.60v", "1.65v", "1.70v", "1.80v", "1.90v",
2033                 "2.00v", "2.10v", "2.20v", "2.30v", "2.40v", "2.50v", "2.60v",
2034                 "2.70v", "2.80v", "2.90v", "3.00v", "3.10v", "3.20v", "3.30v",
2035                 "3.40v", "3.50v", "3.60v"
2036         };
2037         static char *power_mode[] = {
2038                 "OFF", "UP", "ON"
2039         };
2040         static char *bus_mode[] = {
2041                 "UNKNOWN", "OPENDRAIN", "PUSHPULL"
2042         };
2043         static char *timing[] = {
2044                 "LEGACY", "MMC_HS", "SD_HS"
2045         };
2046
2047         printk("SET_IOS: CLK(%dkHz), BUS(%s), BW(%u), PWR(%s), VDD(%s), TIMING(%s)",
2048                 ios->clock / 1000, bus_mode[ios->bus_mode],
2049                 (ios->bus_width == MMC_BUS_WIDTH_4) ? 4 : 1,
2050                 power_mode[ios->power_mode], vdd[ios->vdd], timing[ios->timing]);
2051 #endif
2052
2053         msdc_set_buswidth(host, ios->bus_width);
2054
2055         /* Power control ??? */
2056         switch (ios->power_mode) {
2057         case MMC_POWER_OFF:
2058         case MMC_POWER_UP:
2059                 // msdc_set_power_mode(host, ios->power_mode); /* --- by chhung */
2060                 break;
2061         case MMC_POWER_ON:
2062                 host->power_mode = MMC_POWER_ON;
2063                 break;
2064         default:
2065                 break;
2066         }
2067
2068         /* Clock control */
2069         if (host->mclk != ios->clock) {
2070                 if (ios->clock > 25000000) {
2071                         //if (!(host->hw->flags & MSDC_REMOVABLE)) {
2072                         INIT_MSG("SD data latch edge<%d>", MSDC_SMPL_FALLING);
2073                         sdr_set_field(MSDC_IOCON, MSDC_IOCON_RSPL,
2074                                       MSDC_SMPL_FALLING);
2075                         sdr_set_field(MSDC_IOCON, MSDC_IOCON_DSPL,
2076                                       MSDC_SMPL_FALLING);
2077                         //} /* for tuning debug */
2078                 } else { /* default value */
2079                         sdr_write32(MSDC_IOCON,      0x00000000);
2080                         // sdr_write32(MSDC_DAT_RDDLY0, 0x00000000);
2081                         sdr_write32(MSDC_DAT_RDDLY0, 0x10101010);               // for MT7620 E2 and afterward
2082                         sdr_write32(MSDC_DAT_RDDLY1, 0x00000000);
2083                         // sdr_write32(MSDC_PAD_TUNE,   0x00000000);
2084                         sdr_write32(MSDC_PAD_TUNE,   0x84101010);               // for MT7620 E2 and afterward
2085                 }
2086                 msdc_set_mclk(host, ddr, ios->clock);
2087         }
2088 }
2089
2090 /* ops.get_ro */
2091 static int msdc_ops_get_ro(struct mmc_host *mmc)
2092 {
2093         struct msdc_host *host = mmc_priv(mmc);
2094         void __iomem *base = host->base;
2095         unsigned long flags;
2096         int ro = 0;
2097
2098         if (host->hw->flags & MSDC_WP_PIN_EN) { /* set for card */
2099                 spin_lock_irqsave(&host->lock, flags);
2100                 ro = (sdr_read32(MSDC_PS) >> 31);
2101                 spin_unlock_irqrestore(&host->lock, flags);
2102         }
2103         return ro;
2104 }
2105
2106 /* ops.get_cd */
2107 static int msdc_ops_get_cd(struct mmc_host *mmc)
2108 {
2109         struct msdc_host *host = mmc_priv(mmc);
2110         void __iomem *base = host->base;
2111         unsigned long flags;
2112         int present = 1;
2113
2114         /* for sdio, MSDC_REMOVABLE not set, always return 1 */
2115         if (!(host->hw->flags & MSDC_REMOVABLE)) {
2116                 /* For sdio, read H/W always get<1>, but may timeout some times */
2117 #if 1
2118                 host->card_inserted = 1;
2119                 return 1;
2120 #else
2121                 host->card_inserted = (host->pm_state.event == PM_EVENT_USER_RESUME) ? 1 : 0;
2122                 INIT_MSG("sdio ops_get_cd<%d>", host->card_inserted);
2123                 return host->card_inserted;
2124 #endif
2125         }
2126
2127         /* MSDC_CD_PIN_EN set for card */
2128         if (host->hw->flags & MSDC_CD_PIN_EN) {
2129                 spin_lock_irqsave(&host->lock, flags);
2130 #if 0
2131                 present = host->card_inserted;  /* why not read from H/W: Fix me*/
2132 #else
2133                 // CD
2134                 if (cd_active_low)
2135                         present = (sdr_read32(MSDC_PS) & MSDC_PS_CDSTS) ? 0 : 1;
2136                 else
2137                         present = (sdr_read32(MSDC_PS) & MSDC_PS_CDSTS) ? 1 : 0;
2138                 host->card_inserted = present;
2139 #endif
2140                 spin_unlock_irqrestore(&host->lock, flags);
2141         } else {
2142                 present = 0; /* TODO? Check DAT3 pins for card detection */
2143         }
2144
2145         INIT_MSG("ops_get_cd return<%d>", present);
2146         return present;
2147 }
2148
2149 /* ops.enable_sdio_irq */
2150 static void msdc_ops_enable_sdio_irq(struct mmc_host *mmc, int enable)
2151 {
2152         struct msdc_host *host = mmc_priv(mmc);
2153         struct msdc_hw *hw = host->hw;
2154         void __iomem *base = host->base;
2155         u32 tmp;
2156
2157         if (hw->flags & MSDC_EXT_SDIO_IRQ) { /* yes for sdio */
2158         } else {
2159                 ERR_MSG("XXX ");  /* so never enter here */
2160                 tmp = sdr_read32(SDC_CFG);
2161                 /* FIXME. Need to interrupt gap detection */
2162                 if (enable)
2163                         tmp |= (SDC_CFG_SDIOIDE | SDC_CFG_SDIOINTWKUP);
2164                 else
2165                         tmp &= ~(SDC_CFG_SDIOIDE | SDC_CFG_SDIOINTWKUP);
2166                 sdr_write32(SDC_CFG, tmp);
2167         }
2168 }
2169
2170 static struct mmc_host_ops mt_msdc_ops = {
2171         .request         = msdc_ops_request,
2172         .set_ios         = msdc_ops_set_ios,
2173         .get_ro          = msdc_ops_get_ro,
2174         .get_cd          = msdc_ops_get_cd,
2175         .enable_sdio_irq = msdc_ops_enable_sdio_irq,
2176 };
2177
2178 /*--------------------------------------------------------------------------*/
2179 /* interrupt handler                                                    */
2180 /*--------------------------------------------------------------------------*/
2181 static irqreturn_t msdc_irq(int irq, void *dev_id)
2182 {
2183         struct msdc_host  *host = (struct msdc_host *)dev_id;
2184         struct mmc_data   *data = host->data;
2185         struct mmc_command *cmd = host->cmd;
2186         void __iomem *base = host->base;
2187
2188         u32 cmdsts = MSDC_INT_RSPCRCERR  | MSDC_INT_CMDTMO  | MSDC_INT_CMDRDY  |
2189                 MSDC_INT_ACMDCRCERR | MSDC_INT_ACMDTMO | MSDC_INT_ACMDRDY |
2190                 MSDC_INT_ACMD19_DONE;
2191         u32 datsts = MSDC_INT_DATCRCERR | MSDC_INT_DATTMO;
2192
2193         u32 intsts = sdr_read32(MSDC_INT);
2194         u32 inten  = sdr_read32(MSDC_INTEN); inten &= intsts;
2195
2196         sdr_write32(MSDC_INT, intsts);  /* clear interrupts */
2197         /* MSG will cause fatal error */
2198
2199         /* card change interrupt */
2200         if (intsts & MSDC_INT_CDSC) {
2201                 if (host->mmc->caps & MMC_CAP_NEEDS_POLL)
2202                         return IRQ_HANDLED;
2203                 IRQ_MSG("MSDC_INT_CDSC irq<0x%.8x>", intsts);
2204                 schedule_delayed_work(&host->card_delaywork, HZ);
2205                 /* tuning when plug card ? */
2206         }
2207
2208         /* sdio interrupt */
2209         if (intsts & MSDC_INT_SDIOIRQ) {
2210                 IRQ_MSG("XXX MSDC_INT_SDIOIRQ");  /* seems not sdio irq */
2211                 //mmc_signal_sdio_irq(host->mmc);
2212         }
2213
2214         /* transfer complete interrupt */
2215         if (data != NULL) {
2216                 if (inten & MSDC_INT_XFER_COMPL) {
2217                         data->bytes_xfered = host->xfer_size;
2218                         complete(&host->xfer_done);
2219                 }
2220
2221                 if (intsts & datsts) {
2222                         /* do basic reset, or stop command will sdc_busy */
2223                         msdc_reset_hw(host);
2224                         msdc_clr_fifo();
2225                         msdc_clr_int();
2226                         atomic_set(&host->abort, 1);  /* For PIO mode exit */
2227
2228                         if (intsts & MSDC_INT_DATTMO) {
2229                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_DATTMO", host->mrq->cmd->opcode);
2230                                 data->error = (unsigned int)-ETIMEDOUT;
2231                         } else if (intsts & MSDC_INT_DATCRCERR) {
2232                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_DATCRCERR, SDC_DCRC_STS<0x%x>", host->mrq->cmd->opcode, sdr_read32(SDC_DCRC_STS));
2233                                 data->error = (unsigned int)-EIO;
2234                         }
2235
2236                         //if(sdr_read32(MSDC_INTEN) & MSDC_INT_XFER_COMPL) {
2237                         if (host->dma_xfer)
2238                                 complete(&host->xfer_done); /* Read CRC come fast, XFER_COMPL not enabled */
2239                         /* PIO mode can't do complete, because not init */
2240                 }
2241         }
2242
2243         /* command interrupts */
2244         if ((cmd != NULL) && (intsts & cmdsts)) {
2245                 if ((intsts & MSDC_INT_CMDRDY) || (intsts & MSDC_INT_ACMDRDY) ||
2246                         (intsts & MSDC_INT_ACMD19_DONE)) {
2247                         u32 *rsp = &cmd->resp[0];
2248
2249                         switch (host->cmd_rsp) {
2250                         case RESP_NONE:
2251                                 break;
2252                         case RESP_R2:
2253                                 *rsp++ = sdr_read32(SDC_RESP3); *rsp++ = sdr_read32(SDC_RESP2);
2254                                 *rsp++ = sdr_read32(SDC_RESP1); *rsp++ = sdr_read32(SDC_RESP0);
2255                                 break;
2256                         default: /* Response types 1, 3, 4, 5, 6, 7(1b) */
2257                                 if ((intsts & MSDC_INT_ACMDRDY) || (intsts & MSDC_INT_ACMD19_DONE))
2258                                         *rsp = sdr_read32(SDC_ACMD_RESP);
2259                                 else
2260                                         *rsp = sdr_read32(SDC_RESP0);
2261                                 break;
2262                         }
2263                 } else if ((intsts & MSDC_INT_RSPCRCERR) || (intsts & MSDC_INT_ACMDCRCERR)) {
2264                         if (intsts & MSDC_INT_ACMDCRCERR)
2265                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_ACMDCRCERR", cmd->opcode);
2266                         else
2267                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_RSPCRCERR", cmd->opcode);
2268                         cmd->error = (unsigned int)-EIO;
2269                 } else if ((intsts & MSDC_INT_CMDTMO) || (intsts & MSDC_INT_ACMDTMO)) {
2270                         if (intsts & MSDC_INT_ACMDTMO)
2271                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_ACMDTMO", cmd->opcode);
2272                         else
2273                                 IRQ_MSG("XXX CMD<%d> MSDC_INT_CMDTMO", cmd->opcode);
2274                         cmd->error = (unsigned int)-ETIMEDOUT;
2275                         msdc_reset_hw(host);
2276                         msdc_clr_fifo();
2277                         msdc_clr_int();
2278                 }
2279                 complete(&host->cmd_done);
2280         }
2281
2282         /* mmc irq interrupts */
2283         if (intsts & MSDC_INT_MMCIRQ)
2284                 printk(KERN_INFO "msdc[%d] MMCIRQ: SDC_CSTS=0x%.8x\r\n", host->id, sdr_read32(SDC_CSTS));
2285
2286 #ifdef MT6575_SD_DEBUG
2287         {
2288 /*        msdc_int_reg *int_reg = (msdc_int_reg*)&intsts;*/
2289                 N_MSG(INT, "IRQ_EVT(0x%x): MMCIRQ(%d) CDSC(%d), ACRDY(%d), ACTMO(%d), ACCRE(%d) AC19DN(%d)",
2290                         intsts,
2291                         int_reg->mmcirq,
2292                         int_reg->cdsc,
2293                         int_reg->atocmdrdy,
2294                         int_reg->atocmdtmo,
2295                         int_reg->atocmdcrc,
2296                         int_reg->atocmd19done);
2297                 N_MSG(INT, "IRQ_EVT(0x%x): SDIO(%d) CMDRDY(%d), CMDTMO(%d), RSPCRC(%d), CSTA(%d)",
2298                         intsts,
2299                         int_reg->sdioirq,
2300                         int_reg->cmdrdy,
2301                         int_reg->cmdtmo,
2302                         int_reg->rspcrc,
2303                         int_reg->csta);
2304                 N_MSG(INT, "IRQ_EVT(0x%x): XFCMP(%d) DXDONE(%d), DATTMO(%d), DATCRC(%d), DMAEMP(%d)",
2305                         intsts,
2306                         int_reg->xfercomp,
2307                         int_reg->dxferdone,
2308                         int_reg->dattmo,
2309                         int_reg->datcrc,
2310                         int_reg->dmaqempty);
2311         }
2312 #endif
2313
2314         return IRQ_HANDLED;
2315 }
2316
2317 /*--------------------------------------------------------------------------*/
2318 /* platform_driver members                                                      */
2319 /*--------------------------------------------------------------------------*/
2320 /* called by msdc_drv_probe/remove */
2321 static void msdc_enable_cd_irq(struct msdc_host *host, int enable)
2322 {
2323         struct msdc_hw *hw = host->hw;
2324         void __iomem *base = host->base;
2325
2326         /* for sdio, not set */
2327         if ((hw->flags & MSDC_CD_PIN_EN) == 0) {
2328                 /* Pull down card detection pin since it is not avaiable */
2329                 /*
2330                   if (hw->config_gpio_pin)
2331                   hw->config_gpio_pin(MSDC_CD_PIN, GPIO_PULL_DOWN);
2332                 */
2333                 sdr_clr_bits(MSDC_PS, MSDC_PS_CDEN);
2334                 sdr_clr_bits(MSDC_INTEN, MSDC_INTEN_CDSC);
2335                 sdr_clr_bits(SDC_CFG, SDC_CFG_INSWKUP);
2336                 return;
2337         }
2338
2339         N_MSG(CFG, "CD IRQ Eanable(%d)", enable);
2340
2341         if (enable) {
2342                 /* card detection circuit relies on the core power so that the core power
2343                  * shouldn't be turned off. Here adds a reference count to keep
2344                  * the core power alive.
2345                  */
2346                 //msdc_vcore_on(host); //did in msdc_init_hw()
2347
2348                 if (hw->config_gpio_pin) /* NULL */
2349                         hw->config_gpio_pin(MSDC_CD_PIN, GPIO_PULL_UP);
2350
2351                 sdr_set_field(MSDC_PS, MSDC_PS_CDDEBOUNCE, DEFAULT_DEBOUNCE);
2352                 sdr_set_bits(MSDC_PS, MSDC_PS_CDEN);
2353                 sdr_set_bits(MSDC_INTEN, MSDC_INTEN_CDSC);
2354                 sdr_set_bits(SDC_CFG, SDC_CFG_INSWKUP);  /* not in document! Fix me */
2355         } else {
2356                 if (hw->config_gpio_pin) /* NULL */
2357                         hw->config_gpio_pin(MSDC_CD_PIN, GPIO_PULL_DOWN);
2358
2359                 sdr_clr_bits(SDC_CFG, SDC_CFG_INSWKUP);
2360                 sdr_clr_bits(MSDC_PS, MSDC_PS_CDEN);
2361                 sdr_clr_bits(MSDC_INTEN, MSDC_INTEN_CDSC);
2362
2363                 /* Here decreases a reference count to core power since card
2364                  * detection circuit is shutdown.
2365                  */
2366                 //msdc_vcore_off(host);
2367         }
2368 }
2369
2370 /* called by msdc_drv_probe */
2371 static void msdc_init_hw(struct msdc_host *host)
2372 {
2373         void __iomem *base = host->base;
2374         struct msdc_hw *hw = host->hw;
2375
2376 #ifdef MT6575_SD_DEBUG
2377         msdc_reg[host->id] = (struct msdc_regs *)host->base;
2378 #endif
2379
2380         /* Power on */
2381 #if 0 /* --- by chhung */
2382         msdc_vcore_on(host);
2383         msdc_pin_reset(host, MSDC_PIN_PULL_UP);
2384         msdc_select_clksrc(host, hw->clk_src);
2385         enable_clock(PERI_MSDC0_PDN + host->id, "SD");
2386         msdc_vdd_on(host);
2387 #endif /* end of --- */
2388         /* Configure to MMC/SD mode */
2389         sdr_set_field(MSDC_CFG, MSDC_CFG_MODE, MSDC_SDMMC);
2390
2391         /* Reset */
2392         msdc_reset_hw(host);
2393         msdc_clr_fifo();
2394
2395         /* Disable card detection */
2396         sdr_clr_bits(MSDC_PS, MSDC_PS_CDEN);
2397
2398         /* Disable and clear all interrupts */
2399         sdr_clr_bits(MSDC_INTEN, sdr_read32(MSDC_INTEN));
2400         sdr_write32(MSDC_INT, sdr_read32(MSDC_INT));
2401
2402 #if 1
2403         /* reset tuning parameter */
2404         sdr_write32(MSDC_PAD_CTL0,   0x00090000);
2405         sdr_write32(MSDC_PAD_CTL1,   0x000A0000);
2406         sdr_write32(MSDC_PAD_CTL2,   0x000A0000);
2407         // sdr_write32(MSDC_PAD_TUNE,   0x00000000);
2408         sdr_write32(MSDC_PAD_TUNE,   0x84101010);               // for MT7620 E2 and afterward
2409         // sdr_write32(MSDC_DAT_RDDLY0, 0x00000000);
2410         sdr_write32(MSDC_DAT_RDDLY0, 0x10101010);               // for MT7620 E2 and afterward
2411         sdr_write32(MSDC_DAT_RDDLY1, 0x00000000);
2412         sdr_write32(MSDC_IOCON,      0x00000000);
2413 #if 0 // use MT7620 default value: 0x403c004f
2414         sdr_write32(MSDC_PATCH_BIT0, 0x003C000F); /* bit0 modified: Rx Data Clock Source: 1 -> 2.0*/
2415 #endif
2416
2417         if (sdr_read32(MSDC_ECO_VER) >= 4) {
2418                 if (host->id == 1) {
2419                         sdr_set_field(MSDC_PATCH_BIT1, MSDC_PATCH_BIT1_WRDAT_CRCS, 1);
2420                         sdr_set_field(MSDC_PATCH_BIT1, MSDC_PATCH_BIT1_CMD_RSP,    1);
2421
2422                         /* internal clock: latch read data */
2423                         sdr_set_bits(MSDC_PATCH_BIT0, MSDC_PATCH_BIT_CKGEN_CK);
2424                 }
2425         }
2426 #endif
2427
2428         /* for safety, should clear SDC_CFG.SDIO_INT_DET_EN & set SDC_CFG.SDIO in
2429            pre-loader,uboot,kernel drivers. and SDC_CFG.SDIO_INT_DET_EN will be only
2430            set when kernel driver wants to use SDIO bus interrupt */
2431         /* Configure to enable SDIO mode. it's must otherwise sdio cmd5 failed */
2432         sdr_set_bits(SDC_CFG, SDC_CFG_SDIO);
2433
2434         /* disable detect SDIO device interupt function */
2435         sdr_clr_bits(SDC_CFG, SDC_CFG_SDIOIDE);
2436
2437         /* eneable SMT for glitch filter */
2438         sdr_set_bits(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKSMT);
2439         sdr_set_bits(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDSMT);
2440         sdr_set_bits(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATSMT);
2441
2442 #if 1
2443         /* set clk, cmd, dat pad driving */
2444         sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRVN, hw->clk_drv);
2445         sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRVP, hw->clk_drv);
2446         sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRVN, 4);
2447         sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRVP, 4);
2448         sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRVN, 4);
2449         sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRVP, 4);
2450 #else
2451         sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRVN, 0);
2452         sdr_set_field(MSDC_PAD_CTL0, MSDC_PAD_CTL0_CLKDRVP, 0);
2453         sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRVN, 0);
2454         sdr_set_field(MSDC_PAD_CTL1, MSDC_PAD_CTL1_CMDDRVP, 0);
2455         sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRVN, 0);
2456         sdr_set_field(MSDC_PAD_CTL2, MSDC_PAD_CTL2_DATDRVP, 0);
2457 #endif
2458
2459         /* set sampling edge */
2460
2461         /* write crc timeout detection */
2462         sdr_set_field(MSDC_PATCH_BIT0, 1 << 30, 1);
2463
2464         /* Configure to default data timeout */
2465         sdr_set_field(SDC_CFG, SDC_CFG_DTOC, DEFAULT_DTOC);
2466
2467         msdc_set_buswidth(host, MMC_BUS_WIDTH_1);
2468
2469         N_MSG(FUC, "init hardware done!");
2470 }
2471
2472 /* called by msdc_drv_remove */
2473 static void msdc_deinit_hw(struct msdc_host *host)
2474 {
2475         void __iomem *base = host->base;
2476
2477         /* Disable and clear all interrupts */
2478         sdr_clr_bits(MSDC_INTEN, sdr_read32(MSDC_INTEN));
2479         sdr_write32(MSDC_INT, sdr_read32(MSDC_INT));
2480
2481         /* Disable card detection */
2482         msdc_enable_cd_irq(host, 0);
2483         // msdc_set_power_mode(host, MMC_POWER_OFF);   /* make sure power down */ /* --- by chhung */
2484 }
2485
2486 /* init gpd and bd list in msdc_drv_probe */
2487 static void msdc_init_gpd_bd(struct msdc_host *host, struct msdc_dma *dma)
2488 {
2489         struct gpd *gpd = dma->gpd;
2490         struct bd  *bd  = dma->bd;
2491         int i;
2492
2493         /* we just support one gpd, but gpd->next must be set for desc
2494          * DMA. That's why we alloc 2 gpd structurs.
2495          */
2496
2497         memset(gpd, 0, sizeof(struct gpd) * 2);
2498
2499         gpd->bdp  = 1;   /* hwo, cs, bd pointer */
2500         gpd->ptr = (void *)dma->bd_addr; /* physical address */
2501         gpd->next = (void *)((u32)dma->gpd_addr + sizeof(struct gpd));
2502
2503         memset(bd, 0, sizeof(struct bd) * MAX_BD_NUM);
2504         for (i = 0; i < (MAX_BD_NUM - 1); i++)
2505                 bd[i].next = (void *)(dma->bd_addr + sizeof(*bd) * (i + 1));
2506 }
2507
2508 static int msdc_drv_probe(struct platform_device *pdev)
2509 {
2510         struct resource *res;
2511         __iomem void *base;
2512         struct mmc_host *mmc;
2513         struct msdc_host *host;
2514         struct msdc_hw *hw;
2515         int ret;
2516
2517         hw = &msdc0_hw;
2518
2519         if (of_property_read_bool(pdev->dev.of_node, "mtk,wp-en"))
2520                 msdc0_hw.flags |= MSDC_WP_PIN_EN;
2521
2522         /* Allocate MMC host for this device */
2523         mmc = mmc_alloc_host(sizeof(struct msdc_host), &pdev->dev);
2524         if (!mmc)
2525                 return -ENOMEM;
2526
2527         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2528         base = devm_ioremap_resource(&pdev->dev, res);
2529         if (IS_ERR(base)) {
2530                 ret = PTR_ERR(base);
2531                 goto host_free;
2532         }
2533
2534         /* Set host parameters to mmc */
2535         mmc->ops        = &mt_msdc_ops;
2536         mmc->f_min      = HOST_MIN_MCLK;
2537         mmc->f_max      = HOST_MAX_MCLK;
2538         mmc->ocr_avail  = MSDC_OCR_AVAIL;
2539
2540         mmc->caps   = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;
2541
2542         //TODO: read this as bus-width from dt (via mmc_of_parse)
2543         mmc->caps  |= MMC_CAP_4_BIT_DATA;
2544
2545         if ((hw->flags & MSDC_SDIO_IRQ) || (hw->flags & MSDC_EXT_SDIO_IRQ))
2546                 mmc->caps |= MMC_CAP_SDIO_IRQ;  /* yes for sdio */
2547
2548         cd_active_low = !of_property_read_bool(pdev->dev.of_node, "mediatek,cd-high");
2549
2550         if (of_property_read_bool(pdev->dev.of_node, "mediatek,cd-poll"))
2551                 mmc->caps |= MMC_CAP_NEEDS_POLL;
2552
2553         /* MMC core transfer sizes tunable parameters */
2554         mmc->max_segs      = MAX_HW_SGMTS;
2555
2556         mmc->max_seg_size  = MAX_SGMT_SZ;
2557         mmc->max_blk_size  = HOST_MAX_BLKSZ;
2558         mmc->max_req_size  = MAX_REQ_SZ;
2559         mmc->max_blk_count = mmc->max_req_size;
2560
2561         host = mmc_priv(mmc);
2562         host->hw        = hw;
2563         host->mmc       = mmc;
2564         host->id        = pdev->id;
2565         if (host->id < 0 || host->id >= 4)
2566                 host->id = 0;
2567         host->error     = 0;
2568
2569         host->irq       = platform_get_irq(pdev, 0);
2570         if (host->irq < 0) {
2571                 ret = -EINVAL;
2572                 goto host_free;
2573         }
2574
2575         host->base      = base;
2576         host->mclk      = 0;                   /* mclk: the request clock of mmc sub-system */
2577         host->hclk      = hclks[hw->clk_src];  /* hclk: clock of clock source to msdc controller */
2578         host->sclk      = 0;                   /* sclk: the really clock after divition */
2579         host->pm_state  = PMSG_RESUME;
2580         host->suspend   = 0;
2581         host->core_clkon = 0;
2582         host->card_clkon = 0;
2583         host->core_power = 0;
2584         host->power_mode = MMC_POWER_OFF;
2585 //    host->card_inserted = hw->flags & MSDC_REMOVABLE ? 0 : 1;
2586         host->timeout_ns = 0;
2587         host->timeout_clks = DEFAULT_DTOC * 65536;
2588
2589         host->mrq = NULL;
2590         //init_MUTEX(&host->sem); /* we don't need to support multiple threads access */
2591
2592         mmc_dev(mmc)->dma_mask = NULL;
2593
2594         /* using dma_alloc_coherent*/  /* todo: using 1, for all 4 slots */
2595         host->dma.gpd = dma_alloc_coherent(&pdev->dev,
2596                                            MAX_GPD_NUM * sizeof(struct gpd),
2597                                            &host->dma.gpd_addr, GFP_KERNEL);
2598         host->dma.bd =  dma_alloc_coherent(&pdev->dev,
2599                                            MAX_BD_NUM  * sizeof(struct bd),
2600                                            &host->dma.bd_addr,  GFP_KERNEL);
2601         if (!host->dma.gpd || !host->dma.bd) {
2602                 ret = -ENOMEM;
2603                 goto release_mem;
2604         }
2605         msdc_init_gpd_bd(host, &host->dma);
2606
2607         INIT_DELAYED_WORK(&host->card_delaywork, msdc_tasklet_card);
2608         spin_lock_init(&host->lock);
2609         msdc_init_hw(host);
2610
2611         /* TODO check weather flags 0 is correct, the mtk-sd driver uses
2612          * IRQF_TRIGGER_LOW | IRQF_ONESHOT for flags
2613          *
2614          * for flags 0 the trigger polarity is determined by the
2615          * device tree, but not the oneshot flag, but maybe it is also
2616          * not needed because the soc could be oneshot safe.
2617          */
2618         ret = devm_request_irq(&pdev->dev, host->irq, msdc_irq, 0, pdev->name,
2619                                host);
2620         if (ret)
2621                 goto release;
2622
2623         platform_set_drvdata(pdev, mmc);
2624
2625         ret = mmc_add_host(mmc);
2626         if (ret)
2627                 goto release;
2628
2629         /* Config card detection pin and enable interrupts */
2630         if (hw->flags & MSDC_CD_PIN_EN) {  /* set for card */
2631                 msdc_enable_cd_irq(host, 1);
2632         } else {
2633                 msdc_enable_cd_irq(host, 0);
2634         }
2635
2636         return 0;
2637
2638 release:
2639         platform_set_drvdata(pdev, NULL);
2640         msdc_deinit_hw(host);
2641         cancel_delayed_work_sync(&host->card_delaywork);
2642
2643 release_mem:
2644         if (host->dma.gpd)
2645                 dma_free_coherent(&pdev->dev, MAX_GPD_NUM * sizeof(struct gpd),
2646                                   host->dma.gpd, host->dma.gpd_addr);
2647         if (host->dma.bd)
2648                 dma_free_coherent(&pdev->dev, MAX_BD_NUM * sizeof(struct bd),
2649                                   host->dma.bd, host->dma.bd_addr);
2650 host_free:
2651         mmc_free_host(mmc);
2652
2653         return ret;
2654 }
2655
2656 /* 4 device share one driver, using "drvdata" to show difference */
2657 static int msdc_drv_remove(struct platform_device *pdev)
2658 {
2659         struct mmc_host *mmc;
2660         struct msdc_host *host;
2661
2662         mmc  = platform_get_drvdata(pdev);
2663         BUG_ON(!mmc);
2664
2665         host = mmc_priv(mmc);
2666         BUG_ON(!host);
2667
2668         ERR_MSG("removed !!!");
2669
2670         platform_set_drvdata(pdev, NULL);
2671         mmc_remove_host(host->mmc);
2672         msdc_deinit_hw(host);
2673
2674         cancel_delayed_work_sync(&host->card_delaywork);
2675
2676         dma_free_coherent(&pdev->dev, MAX_GPD_NUM * sizeof(struct gpd),
2677                           host->dma.gpd, host->dma.gpd_addr);
2678         dma_free_coherent(&pdev->dev, MAX_BD_NUM  * sizeof(struct bd),
2679                           host->dma.bd,  host->dma.bd_addr);
2680
2681         mmc_free_host(host->mmc);
2682
2683         return 0;
2684 }
2685
2686 /* Fix me: Power Flow */
2687 #ifdef CONFIG_PM
2688
2689 static void msdc_drv_pm(struct platform_device *pdev, pm_message_t state)
2690 {
2691         struct mmc_host *mmc = platform_get_drvdata(pdev);
2692         if (mmc) {
2693                 struct msdc_host *host = mmc_priv(mmc);
2694                 msdc_pm(state, (void *)host);
2695         }
2696 }
2697
2698 static int msdc_drv_suspend(struct platform_device *pdev, pm_message_t state)
2699 {
2700         if (state.event == PM_EVENT_SUSPEND)
2701                 msdc_drv_pm(pdev, state);
2702         return 0;
2703 }
2704
2705 static int msdc_drv_resume(struct platform_device *pdev)
2706 {
2707         struct pm_message state;
2708
2709         state.event = PM_EVENT_RESUME;
2710         msdc_drv_pm(pdev, state);
2711         return 0;
2712 }
2713 #endif
2714
2715 static const struct of_device_id mt7620_sdhci_match[] = {
2716         { .compatible = "ralink,mt7620-sdhci" },
2717         {},
2718 };
2719 MODULE_DEVICE_TABLE(of, mt7620_sdhci_match);
2720
2721 static struct platform_driver mt_msdc_driver = {
2722         .probe   = msdc_drv_probe,
2723         .remove  = msdc_drv_remove,
2724 #ifdef CONFIG_PM
2725         .suspend = msdc_drv_suspend,
2726         .resume  = msdc_drv_resume,
2727 #endif
2728         .driver  = {
2729                 .name  = DRV_NAME,
2730                 .of_match_table = mt7620_sdhci_match,
2731         },
2732 };
2733
2734 /*--------------------------------------------------------------------------*/
2735 /* module init/exit                                                      */
2736 /*--------------------------------------------------------------------------*/
2737 static int __init mt_msdc_init(void)
2738 {
2739         int ret;
2740         u32 reg;
2741
2742         // Set the pins for sdxc to sdxc mode
2743         //FIXME: this should be done by pinctl and not by the sd driver
2744         reg = sdr_read32((void __iomem *)(RALINK_SYSCTL_BASE + 0x60)) & ~(0x3 << 18);
2745         sdr_write32((void __iomem *)(RALINK_SYSCTL_BASE + 0x60), reg);
2746
2747         ret = platform_driver_register(&mt_msdc_driver);
2748         if (ret) {
2749                 printk(KERN_ERR DRV_NAME ": Can't register driver");
2750                 return ret;
2751         }
2752
2753 #if defined(MT6575_SD_DEBUG)
2754         msdc_debug_proc_init();
2755 #endif
2756         return 0;
2757 }
2758
2759 static void __exit mt_msdc_exit(void)
2760 {
2761         platform_driver_unregister(&mt_msdc_driver);
2762 }
2763
2764 module_init(mt_msdc_init);
2765 module_exit(mt_msdc_exit);
2766 MODULE_LICENSE("GPL");
2767 MODULE_DESCRIPTION("MediaTek MT6575 SD/MMC Card Driver");
2768 MODULE_AUTHOR("Infinity Chen <infinity.chen@mediatek.com>");