drivers/mmc/host/rk29_sdmmc.c

   1 /* drivers/mmc/host/rk29_sdmmc.c
   2  *
   3  * Copyright (C) 2010 ROCKCHIP, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * mount -t debugfs debugfs /data/debugfs;cat /data/debugfs/mmc0/status
  15  * echo 't' >/proc/sysrq-trigger
  16  * echo 19 >/sys/module/wakelock/parameters/debug_mask
  17  * vdc volume uevent on
  18  */
  19
  20 #include <linux/blkdev.h>
  21 #include <linux/clk.h>
  22 #include <linux/debugfs.h>
  23 #include <linux/device.h>
  24 #include <linux/dma-mapping.h>
  25 #include <linux/err.h>
  26 #include <linux/init.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/ioport.h>
  29 #include <linux/module.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/scatterlist.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/stat.h>
  34 #include <linux/delay.h>
  35 #include <linux/irq.h>
  36 #include <linux/mmc/host.h>
  37 #include <linux/mmc/mmc.h>
  38 #include <linux/mmc/card.h>
  39
  40 #include <mach/board.h>
  41 #include <mach/rk29_iomap.h>
  42 #include <mach/gpio.h>
  43 #include <mach/iomux.h>
  44
  45 #include <asm/dma.h>
  46 #include <mach/rk29-dma-pl330.h>
  47 #include <asm/scatterlist.h>
  48
  49 #include "rk29_sdmmc.h"
  50
  51
  52 #define RK29_SDMMC_xbw_Debug 0
  53
  54 #if RK29_SDMMC_xbw_Debug
  55 int debug_level = 7;
  56 #define xbwprintk(n, format, arg...) \
  57         if (n <= debug_level) {  \
  58                 printk(format,##arg); \
  59         }
  60 #else
  61 #define xbwprintk(n, arg...)
  62 #endif
  63
  64 #define RK29_SDMMC_ERROR_FLAGS          (SDMMC_INT_FRUN | SDMMC_INT_RTO | SDMMC_INT_HLE )
  65
  66 #define RK29_SDMMC_INTMASK_USEDMA   (SDMMC_INT_CMD_DONE | SDMMC_INT_DTO | RK29_SDMMC_ERROR_FLAGS | SDMMC_INT_CD)
  67 #define RK29_SDMMC_INTMASK_USEIO    (SDMMC_INT_CMD_DONE | SDMMC_INT_DTO | RK29_SDMMC_ERROR_FLAGS | SDMMC_INT_CD| SDMMC_INT_TXDR | SDMMC_INT_RXDR )
  68
  69
  70 #define RK29_SDMMC_SEND_START_TIMEOUT   2000  //The time interval from the time SEND_CMD to START_CMD_BIT cleared.
  71 #define RK29_ERROR_PRINTK_INTERVAL      200   //The time interval between the two printk for the same error.
  72 #define RK29_SDMMC_WAIT_DTO_INTERNVAL   1500  //The time interval from the CMD_DONE_INT to DTO_INT
  73 #define RK29_SDMMC_REMOVAL_DELAY        2000  //The time interval from the CD_INT to detect_timer react.
  74
  75 #define RK29_SDMMC_VERSION "Ver.2.01 The last modify date is 2011-08-19,modifyed by XBW."
  76
  77 #define RK29_CTRL_SDMMC_ID   0  //mainly used by SDMMC
  78 #define RK29_CTRL_SDIO1_ID   1  //mainly used by sdio-wifi
  79 #define RK29_CTRL_SDIO2_ID   2  //mainly used by sdio-card
  80
  81 #define RK29_SDMMC_NOTIFY_REMOVE_INSERTION /* use sysfs to notify the removal or insertion of sd-card*/
  82 //#define RK29_SDMMC_LIST_QUEUE            /* use list-queue for multi-card*/
  83
  84 #define RK29_SDMMC_DEFAULT_SDIO_FREQ   0 // 1--run in default frequency(50Mhz); 0---run in 25Mhz,
  85 #define RK29_MAX_SDIO_FREQ   25000000    //set max-sdio-frequency 25Mhz at the present time¡£
  86
  87 enum {
  88         EVENT_CMD_COMPLETE = 0,
  89         EVENT_DATA_COMPLETE,
  90         EVENT_DATA_ERROR,
  91         EVENT_XFER_ERROR
  92 };
  93
  94 enum rk29_sdmmc_state {
  95         STATE_IDLE = 0,
  96         STATE_SENDING_CMD,
  97         STATE_DATA_BUSY,
  98         STATE_SENDING_STOP,
  99 };
 100
 101 struct rk29_sdmmc_dma_info {
 102         enum dma_ch chn;
 103         char *name;
 104         struct rk29_dma_client client;
 105 };
 106
 107 static struct rk29_sdmmc_dma_info rk29_sdmmc_dma_infos[]= {
 108         {
 109                 .chn = DMACH_SDMMC,
 110                 .client = {
 111                         .name = "rk29-dma-sdmmc0",
 112                 }
 113         },
 114         {
 115                 .chn = DMACH_SDIO,
 116                 .client = {
 117                         .name = "rk29-dma-sdio1",
 118                 }
 119         },
 120
 121         {
 122                 .chn = DMACH_EMMC,
 123                 .client = {
 124                         .name = "rk29-dma-sdio2",
 125                 }
 126         },
 127 };
 128
 129
 130 /* Interrupt Information */
 131 typedef struct TagSDC_INT_INFO
 132 {
 133     u32     transLen;               //the length of data sent.
 134     u32     desLen;                 //the total length of the all data.
 135     u32    *pBuf;                   //the data buffer for interrupt read or write.
 136 }SDC_INT_INFO_T;
 137
 138
 139 struct rk29_sdmmc {
 140         spinlock_t              lock;
 141         spinlock_t              request_lock;
 142         void __iomem    *regs;
 143         struct clk              *clk;
 144
 145         struct mmc_request      *mrq;
 146         struct mmc_request      *new_mrq;
 147         struct mmc_command      *cmd;
 148         struct mmc_data         *data;
 149
 150         dma_addr_t              dma_addr;;
 151         unsigned int    use_dma:1;
 152         char                    dma_name[8];
 153         u32                     cmd_status;
 154         u32                     data_status;
 155         u32                     stop_cmdr;
 156
 157     u32         old_div;
 158         u32                     cmdr;   //the value setted into command-register
 159         u32                     dodma;  //sign the DMA used for transfer.
 160         u32         errorstep;//record the error point.
 161         u32         *pbuf;
 162         SDC_INT_INFO_T    intInfo;
 163     struct rk29_sdmmc_dma_info  dma_info;
 164
 165         int error_times;
 166         u32 old_cmd;
 167
 168         struct tasklet_struct   tasklet;
 169         unsigned long           pending_events;
 170         unsigned long           completed_events;
 171         enum rk29_sdmmc_state   state;
 172
 173 #ifdef RK29_SDMMC_LIST_QUEUE
 174         struct list_head        queue;
 175         struct list_head        queue_node;
 176 #endif
 177
 178         u32                     bus_hz;
 179         struct platform_device  *pdev;
 180         struct mmc_host         *mmc;
 181         u32                     ctype;
 182         unsigned int            clock;
 183         unsigned long           flags;
 184
 185 #define RK29_SDMMC_CARD_PRESENT 0
 186
 187         int                     id;
 188
 189         struct timer_list       detect_timer;
 190         struct timer_list       request_timer; //the timer for INT_CMD_DONE
 191         struct timer_list       DTO_timer;     //the timer for INT_DTO
 192         struct mmc_command      stopcmd;
 193
 194         /* flag for current bus settings */
 195     u32 bus_mode;
 196
 197     unsigned int            oldstatus;
 198     unsigned int            complete_done;
 199 #ifdef CONFIG_PM
 200     int gpio_irq;
 201         int gpio_det;
 202 #endif
 203 };
 204
 205
 206 #ifdef RK29_SDMMC_NOTIFY_REMOVE_INSERTION
 207 static struct rk29_sdmmc    *globalSDhost[3];
 208 #endif
 209
 210 #define rk29_sdmmc_test_and_clear_pending(host, event)          \
 211         test_and_clear_bit(event, &host->pending_events)
 212 #define rk29_sdmmc_set_completed(host, event)                   \
 213         set_bit(event, &host->completed_events)
 214
 215 #define rk29_sdmmc_set_pending(host, event)                             \
 216         set_bit(event, &host->pending_events)
 217
 218 static void rk29_sdmmc_start_error(struct rk29_sdmmc *host);
 219
 220 static void rk29_sdmmc_write(unsigned char  __iomem     *regbase, unsigned int regOff,unsigned int val)
 221 {
 222         __raw_writel(val,regbase + regOff);
 223 }
 224
 225 static unsigned int rk29_sdmmc_read(unsigned char  __iomem      *regbase, unsigned int regOff)
 226 {
 227         return __raw_readl(regbase + regOff);
 228 }
 229
 230 static int rk29_sdmmc_regs_printk(struct rk29_sdmmc *host)
 231 {
 232         printk("SDMMC_CTRL:   \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CTRL));
 233         printk("SDMMC_PWREN:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_PWREN));
 234         printk("SDMMC_CLKDIV: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKDIV));
 235         printk("SDMMC_CLKSRC: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKSRC));
 236         printk("SDMMC_CLKENA: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKENA));
 237         printk("SDMMC_TMOUT:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TMOUT));
 238         printk("SDMMC_CTYPE:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CTYPE));
 239         printk("SDMMC_BLKSIZ: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_BLKSIZ));
 240         printk("SDMMC_BYTCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_BYTCNT));
 241         printk("SDMMC_INTMASK:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_INTMASK));
 242         printk("SDMMC_CMDARG: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CMDARG));
 243         printk("SDMMC_CMD:    \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CMD));
 244         printk("SDMMC_RESP0:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP0));
 245         printk("SDMMC_RESP1:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP1));
 246         printk("SDMMC_RESP2:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP2));
 247         printk("SDMMC_RESP3:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP3));
 248         printk("SDMMC_MINTSTS:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_MINTSTS));
 249         printk("SDMMC_RINTSTS:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RINTSTS));
 250         printk("SDMMC_STATUS: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_STATUS));
 251         printk("SDMMC_FIFOTH: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_FIFOTH));
 252         printk("SDMMC_CDETECT:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CDETECT));
 253         printk("SDMMC_WRTPRT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_WRTPRT));
 254         printk("SDMMC_TCBCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TCBCNT));
 255         printk("SDMMC_TBBCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TBBCNT));
 256         printk("SDMMC_DEBNCE: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_DEBNCE));
 257         printk("=======printk %s-register end =========\n", host->dma_name);
 258         return 0;
 259 }
 260
 261
 262 #ifdef RK29_SDMMC_NOTIFY_REMOVE_INSERTION
 263 ssize_t rk29_sdmmc_progress_store(struct kobject *kobj, struct kobj_attribute *attr,
 264                          const char *buf, size_t count)
 265 {
 266     struct rk29_sdmmc   *host = NULL;
 267     static u32 unmounting_times = 0;
 268     static char oldbuf[64];
 269
 270     if( !strncmp(buf,"version" , strlen("version")))
 271     {
 272         printk("The driver SDMMC named 'rk29_sdmmc.c' is %s. ====xbw====\n", RK29_SDMMC_VERSION);
 273         return count;
 274     }
 275
 276     spin_lock(&host->lock);
 277
 278     //envalue the address of host base on input-parameter.
 279     if( !strncmp(buf,"sd-" , strlen("sd-")) )
 280     {
 281         host = (struct rk29_sdmmc       *)globalSDhost[RK29_CTRL_SDMMC_ID];
 282         if(!host)
 283         {
 284             printk("%s..%d.. fail to call progress_store because the host is null. ==xbw==\n",__FUNCTION__,__LINE__);
 285             goto progress_store_out;
 286         }
 287     }
 288     else if(  !strncmp(buf,"sdio1-" , strlen("sdio1-")) )
 289     {
 290         host = (struct rk29_sdmmc       *)globalSDhost[RK29_CTRL_SDIO1_ID];
 291         if(!host)
 292         {
 293             printk("%s..%d.. fail to call progress_store because the host-sdio1 is null. ==xbw==\n",__FUNCTION__,__LINE__);
 294             goto progress_store_out;
 295         }
 296     }
 297     else if(  !strncmp(buf,"sdio2-" , strlen("sdio2-")) )
 298     {
 299         host = (struct rk29_sdmmc       *)globalSDhost[RK29_CTRL_SDIO2_ID];
 300         if(!host)
 301         {
 302             printk("%s..%d.. fail to call progress_store because the host-sdio2 is null. ==xbw==\n",__FUNCTION__,__LINE__);
 303             goto progress_store_out;
 304         }
 305     }
 306     else
 307     {
 308         printk("%s..%d.. You want to use sysfs for SDMMC but input-parameter is wrong.====xbw====\n",__FUNCTION__,__LINE__);
 309         goto progress_store_out;//return count;
 310     }
 311
 312     if(strncmp(buf,oldbuf , strlen(buf)))
 313     {
 314             printk(".%d.. MMC0 receive the message %s from VOLD.====xbw[%s]====\n", __LINE__, buf, host->dma_name);
 315             strcpy(oldbuf, buf);
 316         }
 317
 318         /*
 319      *  //deal with the message
 320      *  insert card state-change:  No-Media ==> Pending ==> Idle-Unmounted ==> Checking ==>Mounted
 321      *  remove card state-change:  Unmounting ==> Idle-Unmounted ==> No-Media
 322     */
 323     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
 324     {
 325         if(!strncmp(buf, "sd-Unmounting", strlen("sd-Unmounting")))
 326         {
 327             if(unmounting_times++%10 == 0)
 328             {
 329                 printk(".%d.. MMC0 receive the message Unmounting(waitTimes=%d) from VOLD.====xbw[%s]====\n", \
 330                     __LINE__, unmounting_times, host->dma_name);
 331             }
 332             host->mmc->re_initialized_flags = 0;
 333             mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_REMOVAL_DELAY));
 334         }
 335         else if( !strncmp(buf, "sd-No-Media", strlen("sd-No-Media")))
 336         {
 337             printk(".%d.. MMC0 receive the message No-Media from VOLD. waitTimes=%d ====xbw[%s]====\n" ,\
 338                 __LINE__,unmounting_times, host->dma_name);
 339
 340             del_timer_sync(&host->detect_timer);
 341             host->mmc->re_initialized_flags = 1;
 342             unmounting_times = 0;
 343
 344             if(test_bit(RK29_SDMMC_CARD_PRESENT, &host->flags))
 345             {
 346                 mmc_detect_change(host->mmc, 0);
 347             }
 348         }
 349         else if( !strncmp(buf, "sd-Ready", strlen("sd-Ready")))
 350         {
 351             printk(".%d.. MMC0 receive the message Ready(ReInitFlag=%d) from VOLD. waitTimes=%d====xbw[%s]====\n" ,\
 352                 __LINE__, host->mmc->re_initialized_flags, unmounting_times, host->dma_name);
 353
 354             unmounting_times = 0;
 355                         host->mmc->re_initialized_flags = 1;
 356         }
 357         else if( !strncmp(buf,"sd-reset" , strlen("sd-reset")) )
 358         {
 359             printk(".%d.. Now manual reset for SDMMC0. ====xbw[%s]====\n",__LINE__, host->dma_name);
 360             mmc_detect_change(host->mmc, 0);
 361         }
 362         else if( !strncmp(buf, "sd-regs", strlen("sd-regs")))
 363         {
 364             printk(".%d.. Now printk the register of SDMMC0. ====xbw[%s]====\n",__LINE__, host->dma_name);
 365             rk29_sdmmc_regs_printk(host);
 366         }
 367
 368     }
 369     else if(RK29_CTRL_SDIO1_ID == host->pdev->id)
 370     {
 371         if( !strncmp(buf, "sdio1-regs", strlen("sdio1-regs")))
 372         {
 373             printk(".%d.. Now printk the register of SDMMC1. ====xbw[%s]====\n",__LINE__, host->dma_name);
 374             rk29_sdmmc_regs_printk(host);
 375         }
 376         else if( !strncmp(buf,"sdio1-reset" , strlen("sdio1-reset")) )
 377         {
 378             printk(".%d.. Now manual reset for SDMMC1. ====xbw[%s]====\n",__LINE__, host->dma_name);
 379             mmc_detect_change(host->mmc, 0);
 380         }
 381     }
 382     else if(RK29_CTRL_SDIO2_ID == host->pdev->id)
 383     {
 384         if( !strncmp(buf, "sdio2-regs", strlen("sdio2-regs")))
 385         {
 386             printk(".%d.. Now printk the register of SDMMC2. ====xbw[%s]====\n",__LINE__, host->dma_name);
 387             rk29_sdmmc_regs_printk(host);
 388         }
 389         else if( !strncmp(buf,"sdio2-reset" , strlen("sdio2-reset")) )
 390         {
 391             printk(".%d.. Now manual reset for SDMMC2. ====xbw[%s]====\n",__LINE__, host->dma_name);
 392             mmc_detect_change(host->mmc, 0);
 393         }
 394     }
 395
 396 progress_store_out:
 397     spin_unlock(&host->lock);
 398
 399     return count;
 400 }
 401
 402
 403
 404 struct kobj_attribute mmc_reset_attrs =
 405 {
 406         .attr = {
 407                 .name = "rescan",
 408                 .mode = 0777},
 409         .show = NULL,
 410         .store = rk29_sdmmc_progress_store,
 411 };
 412 struct attribute *mmc_attrs[] =
 413 {
 414         &mmc_reset_attrs.attr,
 415         NULL
 416 };
 417
 418 static struct kobj_type mmc_kset_ktype = {
 419         .sysfs_ops      = &kobj_sysfs_ops,
 420         .default_attrs = &mmc_attrs[0],
 421 };
 422
 423 static int rk29_sdmmc_progress_add_attr( struct platform_device *pdev )
 424 {
 425         int result;
 426                  struct kobject *parentkobject;
 427         struct kobject * me = kmalloc(sizeof(struct kobject) , GFP_KERNEL );
 428         if(!me)
 429         {
 430             return -ENOMEM;
 431         }
 432         memset(me ,0,sizeof(struct kobject));
 433         kobject_init( me , &mmc_kset_ktype );
 434
 435         parentkobject = &pdev->dev.kobj ;
 436                 result = kobject_add( me , parentkobject->parent->parent->parent,"%s", "sd-sdio" );
 437
 438         return result;
 439 }
 440 #endif
 441
 442 #if defined (CONFIG_DEBUG_FS)
 443 static int rk29_sdmmc_regs_show(struct seq_file *s, void *v)
 444 {
 445         struct rk29_sdmmc       *host = s->private;
 446
 447         seq_printf(s, "SDMMC_CTRL:   \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CTRL));
 448         seq_printf(s, "SDMMC_PWREN:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_PWREN));
 449         seq_printf(s, "SDMMC_CLKDIV: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKDIV));
 450         seq_printf(s, "SDMMC_CLKSRC: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKSRC));
 451         seq_printf(s, "SDMMC_CLKENA: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CLKENA));
 452         seq_printf(s, "SDMMC_TMOUT:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TMOUT));
 453         seq_printf(s, "SDMMC_CTYPE:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CTYPE));
 454         seq_printf(s, "SDMMC_BLKSIZ: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_BLKSIZ));
 455         seq_printf(s, "SDMMC_BYTCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_BYTCNT));
 456         seq_printf(s, "SDMMC_INTMASK:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_INTMASK));
 457         seq_printf(s, "SDMMC_CMDARG: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CMDARG));
 458         seq_printf(s, "SDMMC_CMD:    \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CMD));
 459         seq_printf(s, "SDMMC_RESP0:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP0));
 460         seq_printf(s, "SDMMC_RESP1:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP1));
 461         seq_printf(s, "SDMMC_RESP2:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP2));
 462         seq_printf(s, "SDMMC_RESP3:  \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RESP3));
 463         seq_printf(s, "SDMMC_MINTSTS:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_MINTSTS));
 464         seq_printf(s, "SDMMC_RINTSTS:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_RINTSTS));
 465         seq_printf(s, "SDMMC_STATUS: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_STATUS));
 466         seq_printf(s, "SDMMC_FIFOTH: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_FIFOTH));
 467         seq_printf(s, "SDMMC_CDETECT:\t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_CDETECT));
 468         seq_printf(s, "SDMMC_WRTPRT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_WRTPRT));
 469         seq_printf(s, "SDMMC_TCBCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TCBCNT));
 470         seq_printf(s, "SDMMC_TBBCNT: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_TBBCNT));
 471         seq_printf(s, "SDMMC_DEBNCE: \t0x%08x\n", rk29_sdmmc_read(host->regs, SDMMC_DEBNCE));
 472
 473         return 0;
 474 }
 475
 476
 477 /*
 478  * The debugfs stuff below is mostly optimized away when
 479  * CONFIG_DEBUG_FS is not set.
 480  */
 481 static int rk29_sdmmc_req_show(struct seq_file *s, void *v)
 482 {
 483         struct rk29_sdmmc       *host = s->private;
 484         struct mmc_request      *mrq;
 485         struct mmc_command      *cmd;
 486         struct mmc_command      *stop;
 487         struct mmc_data         *data;
 488
 489         /* Make sure we get a consistent snapshot */
 490         spin_lock(&host->lock);
 491         mrq = host->mrq;
 492
 493         if (mrq) {
 494                 cmd = mrq->cmd;
 495                 data = mrq->data;
 496                 stop = mrq->stop;
 497
 498                 if (cmd)
 499                         seq_printf(s,
 500                                 "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
 501                                 cmd->opcode, cmd->arg, cmd->flags,
 502                                 cmd->resp[0], cmd->resp[1], cmd->resp[2],
 503                                 cmd->resp[2], cmd->error);
 504                 if (data)
 505                         seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
 506                                 data->bytes_xfered, data->blocks,
 507                                 data->blksz, data->flags, data->error);
 508                 if (stop)
 509                         seq_printf(s,
 510                                 "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
 511                                 stop->opcode, stop->arg, stop->flags,
 512                                 stop->resp[0], stop->resp[1], stop->resp[2],
 513                                 stop->resp[2], stop->error);
 514         }
 515
 516         spin_unlock(&host->lock);
 517
 518         return 0;
 519 }
 520
 521 static int rk29_sdmmc_req_open(struct inode *inode, struct file *file)
 522 {
 523         return single_open(file, rk29_sdmmc_req_show, inode->i_private);
 524 }
 525
 526 static const struct file_operations rk29_sdmmc_req_fops = {
 527         .owner          = THIS_MODULE,
 528         .open           = rk29_sdmmc_req_open,
 529         .read           = seq_read,
 530         .llseek         = seq_lseek,
 531         .release        = single_release,
 532 };
 533
 534
 535 static int rk29_sdmmc_regs_open(struct inode *inode, struct file *file)
 536 {
 537         return single_open(file, rk29_sdmmc_regs_show, inode->i_private);
 538 }
 539
 540 static const struct file_operations rk29_sdmmc_regs_fops = {
 541         .owner          = THIS_MODULE,
 542         .open           = rk29_sdmmc_regs_open,
 543         .read           = seq_read,
 544         .llseek         = seq_lseek,
 545         .release        = single_release,
 546 };
 547
 548 static void rk29_sdmmc_init_debugfs(struct rk29_sdmmc *host)
 549 {
 550         struct mmc_host         *mmc = host->mmc;
 551         struct dentry           *root;
 552         struct dentry           *node;
 553
 554         root = mmc->debugfs_root;
 555         if (!root)
 556                 return;
 557
 558         node = debugfs_create_file("regs", S_IRUSR, root, host,
 559                         &rk29_sdmmc_regs_fops);
 560         if (IS_ERR(node))
 561                 return;
 562         if (!node)
 563                 goto err;
 564
 565         node = debugfs_create_file("req", S_IRUSR, root, host, &rk29_sdmmc_req_fops);
 566         if (!node)
 567                 goto err;
 568
 569         node = debugfs_create_u32("state", S_IRUSR, root, (u32 *)&host->state);
 570         if (!node)
 571                 goto err;
 572
 573         node = debugfs_create_x32("pending_events", S_IRUSR, root,
 574                                      (u32 *)&host->pending_events);
 575         if (!node)
 576                 goto err;
 577
 578         node = debugfs_create_x32("completed_events", S_IRUSR, root,
 579                                      (u32 *)&host->completed_events);
 580         if (!node)
 581                 goto err;
 582
 583         return;
 584
 585 err:
 586         dev_err(&mmc->class_dev, "failed to initialize debugfs for host\n");
 587 }
 588 #endif
 589
 590
 591 static u32 rk29_sdmmc_prepare_command(struct mmc_command *cmd)
 592 {
 593         u32             cmdr = cmd->opcode;
 594
 595         switch(cmdr)
 596         {
 597             case MMC_GO_IDLE_STATE:
 598             cmdr |= (SDMMC_CMD_INIT | SDMMC_CMD_PRV_DAT_NO_WAIT);
 599             break;
 600
 601         case MMC_STOP_TRANSMISSION:
 602             cmdr |= (SDMMC_CMD_STOP | SDMMC_CMD_PRV_DAT_NO_WAIT);
 603             break;
 604         case MMC_SEND_STATUS:
 605         case MMC_GO_INACTIVE_STATE:
 606             cmdr |= SDMMC_CMD_PRV_DAT_NO_WAIT;
 607             break;
 608
 609         default:
 610             cmdr |= SDMMC_CMD_PRV_DAT_WAIT;
 611             break;
 612         }
 613
 614     /* response type */
 615         switch(mmc_resp_type(cmd))
 616         {
 617             case MMC_RSP_R1:
 618         case MMC_RSP_R1B:
 619             // case MMC_RSP_R5:  //R5,R6,R7 is same with the R1
 620             //case MMC_RSP_R6:
 621             // case R6m_TYPE:
 622             // case MMC_RSP_R7:
 623             cmdr |= (SDMMC_CMD_RESP_CRC | SDMMC_CMD_RESP_SHORT | SDMMC_CMD_RESP_EXP);
 624             break;
 625         case MMC_RSP_R3:
 626             //case MMC_RSP_R4:
 627             /* these response not contain crc7, so don't care crc error and response error */
 628             cmdr |= (SDMMC_CMD_RESP_NO_CRC | SDMMC_CMD_RESP_SHORT | SDMMC_CMD_RESP_EXP);
 629             break;
 630         case MMC_RSP_R2:
 631             cmdr |= (SDMMC_CMD_RESP_CRC | SDMMC_CMD_RESP_LONG | SDMMC_CMD_RESP_EXP);
 632             break;
 633         case MMC_RSP_NONE:
 634             cmdr |= (SDMMC_CMD_RESP_CRC_NOCARE | SDMMC_CMD_RESP_NOCARE | SDMMC_CMD_RESP_NO_EXP);
 635             break;
 636         default:
 637             cmdr |= (SDMMC_CMD_RESP_CRC_NOCARE | SDMMC_CMD_RESP_NOCARE | SDMMC_CMD_RESP_NO_EXP);
 638             break;
 639         }
 640
 641         return cmdr;
 642 }
 643
 644
 645 static int rk29_sdmmc_start_command(struct rk29_sdmmc *host, struct mmc_command *cmd, u32 cmd_flags)
 646 {
 647         int tmo = RK29_SDMMC_SEND_START_TIMEOUT*2;
 648
 649         host->cmd = cmd;
 650         host->old_cmd = cmd->opcode;
 651
 652         rk29_sdmmc_write(host->regs, SDMMC_CMDARG, cmd->arg); // write to SDMMC_CMDARG register
 653         rk29_sdmmc_write(host->regs, SDMMC_CMD, cmd_flags | SDMMC_CMD_START); // write to SDMMC_CMD register
 654
 655
 656     xbwprintk(5, "\n%s..%d..************.start cmd=%d, arg=0x%x ********=====xbw[%s]=======\n", \
 657                         __FUNCTION__, __LINE__, cmd->opcode, cmd->arg, host->dma_name);
 658
 659         /* wait until CIU accepts the command */
 660         while (--tmo && (rk29_sdmmc_read(host->regs, SDMMC_CMD) & SDMMC_CMD_START))
 661         {
 662                 udelay(2);//cpu_relax();
 663         }
 664
 665         if(!tmo)
 666         {
 667             if(0==cmd->retries)
 668             {
 669                 printk("%s..%d..  CMD_START timeout! CMD%d(arg=0x%x, retries=%d) ======xbw[%s]======\n",\
 670                                 __FUNCTION__,__LINE__, cmd->opcode, cmd->arg, cmd->retries,host->dma_name);
 671                 }
 672
 673                 cmd->error = -ETIMEDOUT;
 674                 host->mrq->cmd->error = -ETIMEDOUT;
 675                 del_timer_sync(&host->request_timer);
 676
 677                 host->errorstep = 0x1;
 678                 return SDM_WAIT_FOR_CMDSTART_TIMEOUT;
 679         }
 680
 681         return SDM_SUCCESS;
 682 }
 683
 684 static int rk29_sdmmc_reset_fifo(struct rk29_sdmmc *host)
 685 {
 686     u32     value;
 687         int     timeout;
 688         int     ret = SDM_SUCCESS;
 689
 690     value = rk29_sdmmc_read(host->regs, SDMMC_STATUS);
 691     if (!(value & SDMMC_STAUTS_FIFO_EMPTY))
 692     {
 693         value = rk29_sdmmc_read(host->regs, SDMMC_CTRL);
 694         value |= SDMMC_CTRL_FIFO_RESET;
 695         rk29_sdmmc_write(host->regs, SDMMC_CTRL, value);
 696
 697         timeout = 1000;
 698         while (((value = rk29_sdmmc_read(host->regs, SDMMC_CTRL)) & (SDMMC_CTRL_FIFO_RESET)) && (timeout > 0))
 699         {
 700             udelay(1);
 701             timeout--;
 702         }
 703         if (timeout == 0)
 704         {
 705             host->errorstep = 0x2;
 706             ret = SDM_WAIT_FOR_FIFORESET_TIMEOUT;
 707         }
 708     }
 709
 710         return ret;
 711
 712 }
 713
 714 static int rk29_sdmmc_wait_unbusy(struct rk29_sdmmc *host)
 715 {
 716         int time_out = 250000; //max is 250ms
 717
 718         while (rk29_sdmmc_read(host->regs, SDMMC_STATUS) & SDMMC_STAUTS_DATA_BUSY)
 719         {
 720                 udelay(1);
 721                 time_out--;
 722
 723                 if(time_out == 0)
 724                 {
 725                     host->errorstep = 0x3;
 726                     return SDM_BUSY_TIMEOUT;
 727                 }
 728         }
 729
 730         return SDM_SUCCESS;
 731 }
 732
 733 static void send_stop_cmd(struct rk29_sdmmc *host)
 734 {
 735     mod_timer(&host->request_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_SEND_START_TIMEOUT+250));
 736
 737     host->stopcmd.opcode = MMC_STOP_TRANSMISSION;
 738     host->stopcmd.flags  = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;;
 739     host->stopcmd.arg = 0;
 740     host->stopcmd.data = NULL;
 741     host->stopcmd.mrq = NULL;
 742     host->stopcmd.retries = 0;
 743     host->stopcmd.error = 0;
 744
 745     host->cmdr = rk29_sdmmc_prepare_command(&host->stopcmd);
 746     rk29_sdmmc_start_command(host, &host->stopcmd, host->cmdr);
 747 }
 748
 749 static void rk29_sdmmc_dma_cleanup(struct rk29_sdmmc *host)
 750 {
 751         if (host->data)
 752         {
 753                 dma_unmap_sg(&host->pdev->dev, host->data->sg, host->data->sg_len,
 754                      ((host->data->flags & MMC_DATA_WRITE)
 755                       ? DMA_TO_DEVICE : DMA_FROM_DEVICE));
 756     }
 757 }
 758
 759 static void rk29_sdmmc_stop_dma(struct rk29_sdmmc *host)
 760 {
 761     int ret = 0;
 762
 763         if(host->use_dma == 0)
 764                 return;
 765
 766         if (host->dma_info.chn> 0)
 767         {
 768                 rk29_sdmmc_dma_cleanup(host);
 769
 770                 ret = rk29_dma_ctrl(host->dma_info.chn,RK29_DMAOP_STOP);
 771                 if(ret < 0)
 772                 {
 773             printk("%s..%d...rk29_dma_ctrl STOP error!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 774             host->errorstep = 0x95;
 775             return;
 776                 }
 777
 778                 ret = rk29_dma_ctrl(host->dma_info.chn,RK29_DMAOP_FLUSH);
 779                 if(ret < 0)
 780                 {
 781             printk("%s..%d...rk29_dma_ctrl FLUSH error!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 782             host->errorstep = 0x96;
 783             return;
 784                 }
 785
 786         }
 787         else
 788         {
 789                 /* Data transfer was stopped by the interrupt handler */
 790                 rk29_sdmmc_set_pending(host, EVENT_DATA_COMPLETE);
 791         }
 792 }
 793
 794 static void rk29_sdmmc_control_host_dma(struct rk29_sdmmc *host, bool enable)
 795 {
 796     u32 value = rk29_sdmmc_read(host->regs, SDMMC_CTRL);
 797
 798     if (enable)
 799     {
 800         value |= SDMMC_CTRL_DMA_ENABLE;
 801     }
 802     else
 803     {
 804         value &= ~(SDMMC_CTRL_DMA_ENABLE);
 805     }
 806
 807     rk29_sdmmc_write(host->regs, SDMMC_CTRL, value);
 808 }
 809
 810
 811 /* This function is called by the DMA driver from tasklet context. */
 812 static void rk29_sdmmc_dma_complete(void *arg, int size, enum rk29_dma_buffresult result)
 813 {
 814         struct rk29_sdmmc       *host = arg;
 815
 816         if(host->use_dma == 0)
 817                 return;
 818
 819         host->intInfo.transLen = host->intInfo.desLen;
 820 }
 821
 822 static int rk29_sdmmc_submit_data_dma(struct rk29_sdmmc *host, struct mmc_data *data)
 823 {
 824         struct scatterlist              *sg;
 825         unsigned int                    i,direction, sgDirection;
 826         int ret, dma_len=0;
 827
 828         if(host->use_dma == 0)
 829         {
 830             printk("%s..%d...setup DMA fail!!!!!!. host->use_dma=0 ===xbw=[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 831             host->errorstep = 0x4;
 832                 return -ENOSYS;
 833         }
 834         /* If we don't have a channel, we can't do DMA */
 835         if (host->dma_info.chn < 0)
 836         {
 837             printk("%s..%d...setup DMA fail!!!!!!!. dma_info.chn < 0  ===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 838             host->errorstep = 0x5;
 839                 return -ENODEV;
 840         }
 841
 842         if (data->blksz & 3)
 843                 return -EINVAL;
 844         for_each_sg(data->sg, sg, data->sg_len, i)
 845         {
 846                 if (sg->offset & 3 || sg->length & 3)
 847                 {
 848                     printk("%s..%d...call for_each_sg() fail !!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 849                     host->errorstep = 0x7;
 850                         return -EINVAL;
 851                 }
 852         }
 853         if (data->flags & MMC_DATA_READ)
 854         {
 855                 direction = RK29_DMASRC_HW;
 856                 sgDirection = DMA_FROM_DEVICE;
 857         }
 858         else
 859         {
 860                 direction = RK29_DMASRC_MEM;
 861                 sgDirection = DMA_TO_DEVICE;
 862         }
 863
 864         ret = rk29_dma_ctrl(host->dma_info.chn,RK29_DMAOP_STOP);
 865         if(ret < 0)
 866         {
 867             printk("%s..%d...rk29_dma_ctrl stop error!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 868             host->errorstep = 0x91;
 869                 return -ENOSYS;
 870         }
 871
 872         ret = rk29_dma_ctrl(host->dma_info.chn,RK29_DMAOP_FLUSH);
 873         if(ret < 0)
 874         {
 875         printk("%s..%d...rk29_dma_ctrl flush error!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 876         host->errorstep = 0x91;
 877         return -ENOSYS;
 878         }
 879
 880
 881     ret = rk29_dma_devconfig(host->dma_info.chn, direction, (unsigned long )(host->dma_addr));
 882     if(0 != ret)
 883     {
 884         printk("%s..%d...call rk29_dma_devconfig() fail !!!!===xbw=[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 885         host->errorstep = 0x8;
 886         return -ENOSYS;
 887     }
 888
 889         dma_len = dma_map_sg(&host->pdev->dev, data->sg, data->sg_len, sgDirection);
 890         for (i = 0; i < dma_len; i++)
 891         {
 892         ret = rk29_dma_enqueue(host->dma_info.chn, host, sg_dma_address(&data->sg[i]),sg_dma_len(&data->sg[i]));
 893         if(ret < 0)
 894         {
 895             printk("%s..%d...call rk29_dma_devconfig() fail !!!!===xbw=[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 896             host->errorstep = 0x93;
 897             return -ENOSYS;
 898         }
 899     }
 900
 901         rk29_sdmmc_control_host_dma(host, TRUE);// enable dma
 902         ret = rk29_dma_ctrl(host->dma_info.chn, RK29_DMAOP_START);
 903         if(ret < 0)
 904         {
 905         printk("%s..%d...rk29_dma_ctrl start error!===xbw[%s]====\n", __FUNCTION__, __LINE__, host->dma_name);
 906         host->errorstep = 0x94;
 907         return -ENOSYS;
 908         }
 909
 910         return 0;
 911 }
 912
 913
 914 static int rk29_sdmmc_prepare_write_data(struct rk29_sdmmc *host, struct mmc_data *data)
 915 {
 916     //uint32 value;
 917     int     output;
 918     u32    i = 0;
 919     u32     dataLen;
 920     u32     count, *pBuf = (u32 *)host->pbuf;
 921
 922     output = SDM_SUCCESS;
 923     dataLen = data->blocks*data->blksz;
 924
 925     host->dodma = 0; //DMA still no request;
 926
 927     //SDMMC controller request the data is multiple of 4.
 928     count = (dataLen >> 2) + ((dataLen & 0x3) ? 1:0);
 929
 930     if (count <= FIFO_DEPTH)
 931     {
 932         for (i=0; i<count; i++)
 933         {
 934             rk29_sdmmc_write(host->regs, SDMMC_DATA, pBuf[i]);
 935         }
 936     }
 937     else
 938     {
 939         host->intInfo.desLen = count;
 940         host->intInfo.transLen = 0;
 941         host->intInfo.pBuf = (u32 *)pBuf;
 942
 943         if(0)//(host->intInfo.desLen <= 512 )
 944         {
 945             //use pio-mode
 946             return SDM_SUCCESS;
 947         }
 948         else
 949         {
 950             xbwprintk(3, "%s..%d...   trace data,   ======xbw=[%s]====\n", __FUNCTION__, __LINE__,  host->dma_name);
 951             output = rk29_sdmmc_submit_data_dma(host, data);
 952             if(output)
 953             {
 954                         host->dodma = 0;
 955
 956                     printk("%s..%d... CMD%d setupDMA failure!!!!!  ==xbw[%s]==\n", \
 957                                                 __FUNCTION__, __LINE__, host->cmd->opcode, host->dma_name);
 958
 959                                 host->errorstep = 0x81;
 960
 961                         rk29_sdmmc_control_host_dma(host, FALSE);
 962                 }
 963                 else
 964                 {
 965                     host->dodma = 1;
 966                 }
 967         }
 968
 969     }
 970
 971     return output;
 972 }
 973
 974
 975
 976
 977 static int rk29_sdmmc_prepare_read_data(struct rk29_sdmmc *host, struct mmc_data *data)
 978 {
 979     u32  count = 0;
 980     u32  dataLen;
 981     int   output;
 982
 983     output = SDM_SUCCESS;
 984     dataLen = data->blocks*data->blksz;
 985
 986     host->dodma = 0;//DMA still no request;
 987
 988     //SDMMC controller request the data is multiple of 4.
 989     count = (dataLen >> 2) ;//+ ((dataLen & 0x3) ? 1:0);
 990
 991     host->intInfo.desLen = (dataLen >> 2);
 992     host->intInfo.transLen = 0;
 993     host->intInfo.pBuf = (u32 *)host->pbuf;
 994
 995     if (count > (RX_WMARK+1))  //datasheet error.actually, it can nont waken the interrupt when less and equal than RX_WMARK+1
 996     {
 997         if(0) //(host->intInfo.desLen <= 512 )
 998         {
 999             //use pio-mode
1000             return SDM_SUCCESS;
1001         }
1002         else
1003         {
1004             output = rk29_sdmmc_submit_data_dma(host, data);
1005             if(output)
1006             {
1007                         host->dodma = 0;
1008
1009                     printk("%s..%d... CMD%d setupDMA  failure!!!  ==xbw[%s]==\n", \
1010                                                 __FUNCTION__, __LINE__, host->cmd->opcode, host->dma_name);
1011
1012                     host->errorstep = 0x82;
1013
1014                         rk29_sdmmc_control_host_dma(host, FALSE);
1015                 }
1016                 else
1017                 {
1018                     host->dodma = 1;
1019                 }
1020         }
1021     }
1022
1023     return output;
1024 }
1025
1026
1027
1028 static int rk29_sdmmc_read_remain_data(struct rk29_sdmmc *host, u32 originalLen, void *pDataBuf)
1029 {
1030     u32  value = 0;
1031
1032     u32     i = 0;
1033     u32     *pBuf = (u32 *)pDataBuf;
1034     u8      *pByteBuf = (u8 *)pDataBuf;
1035     u32     lastData = 0;
1036
1037     //SDMMC controller must be multiple of 32. so if transfer 13, then actuall we should write or read 16 byte.
1038     u32  count = (originalLen >> 2) + ((originalLen & 0x3) ? 1:0);
1039
1040     if(1 == host->dodma)
1041     {
1042         //when use DMA, there are remain data only when datalen/4 less than  RX_WMARK+1 same as equaltion. or not multiple of 4
1043         if (!((value = rk29_sdmmc_read(host->regs, SDMMC_STATUS)) & SDMMC_STAUTS_FIFO_EMPTY))
1044         {
1045             if (count <= (RX_WMARK+1))
1046             {
1047                 i = 0;
1048                 while ((i<(originalLen >> 2))&&(!(value & SDMMC_STAUTS_FIFO_EMPTY)))
1049                 {
1050                     pBuf[i++] = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1051                     value = rk29_sdmmc_read(host->regs, SDMMC_STATUS);
1052                 }
1053             }
1054
1055             if (count > (originalLen >> 2))
1056             {
1057                 lastData = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1058
1059                 //fill the 1 to 3 byte.
1060                 for (i=0; i<(originalLen & 0x3); i++)
1061                 {
1062                     pByteBuf[(originalLen & 0xFFFFFFFC) + i] = (u8)((lastData >> (i << 3)) & 0xFF); //default little-endian
1063                 }
1064             }
1065         }
1066     }
1067     else
1068     {
1069         if (!((value = rk29_sdmmc_read(host->regs, SDMMC_STATUS)) & SDMMC_STAUTS_FIFO_EMPTY))
1070         {
1071              while ( (host->intInfo.transLen < host->intInfo.desLen)  && (!(value & SDMMC_STAUTS_FIFO_EMPTY)) )
1072             {
1073                 pBuf[host->intInfo.transLen++] = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1074                 value = rk29_sdmmc_read(host->regs, SDMMC_STATUS);
1075             }
1076
1077             if (count > (originalLen >> 2))
1078             {
1079                 lastData = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1080
1081                 //fill the 1 to 3 byte.
1082                 for (i=0; i<(originalLen & 0x3); i++)
1083                 {
1084                     pByteBuf[(originalLen & 0xFFFFFFFC) + i] = (u8)((lastData >> (i << 3)) & 0xFF);  //default little-endian
1085                 }
1086             }
1087         }
1088     }
1089
1090     return SDM_SUCCESS;
1091 }
1092
1093
1094 static void rk29_sdmmc_do_pio_read(struct rk29_sdmmc *host)
1095 {
1096     int i;
1097     for (i=0; i<(RX_WMARK+1); i++)
1098     {
1099         host->intInfo.pBuf[host->intInfo.transLen + i] = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1100     }
1101     host->intInfo.transLen += (RX_WMARK+1);
1102 }
1103
1104 static void rk29_sdmmc_do_pio_write(struct rk29_sdmmc *host)
1105 {
1106     int i;
1107     if ( (host->intInfo.desLen - host->intInfo.transLen) > (FIFO_DEPTH - TX_WMARK) )
1108     {
1109         for (i=0; i<(FIFO_DEPTH - TX_WMARK); i++)
1110         {
1111             rk29_sdmmc_write(host->regs, SDMMC_DATA, host->intInfo.pBuf[host->intInfo.transLen + i]);
1112         }
1113         host->intInfo.transLen += (FIFO_DEPTH - TX_WMARK);
1114     }
1115     else
1116     {
1117         for (i=0; i<(host->intInfo.desLen - host->intInfo.transLen); i++)
1118         {
1119             rk29_sdmmc_write(host->regs, SDMMC_DATA, host->intInfo.pBuf[host->intInfo.transLen + i]);
1120         }
1121         host->intInfo.transLen =  host->intInfo.desLen;
1122     }
1123
1124 }
1125
1126
1127 static void rk29_sdmmc_submit_data(struct rk29_sdmmc *host, struct mmc_data *data)
1128 {
1129     int ret;
1130
1131     if(data)
1132     {
1133         host->data = data;
1134         data->error = 0;
1135
1136         data->bytes_xfered = 0;
1137         host->pbuf = (u32*)sg_virt(data->sg);
1138
1139         if (data->flags & MMC_DATA_STREAM)
1140                 {
1141                         host->cmdr |= SDMMC_CMD_STRM_MODE;    //set stream mode
1142                 }
1143                 else
1144                 {
1145                     host->cmdr |= SDMMC_CMD_BLOCK_MODE;   //set block mode
1146                 }
1147
1148         //set the blocks and blocksize
1149                 rk29_sdmmc_write(host->regs, SDMMC_BYTCNT,data->blksz*data->blocks);
1150                 rk29_sdmmc_write(host->regs, SDMMC_BLKSIZ,data->blksz);
1151
1152         xbwprintk(3, "%s..%d...   trace data,  CMD%d, data->blksz=%d, data->blocks=%d   ======xbw=[%s]====\n", \
1153             __FUNCTION__, __LINE__, host->cmd->opcode,data->blksz, data->blocks,  host->dma_name);
1154
1155                 if (data->flags & MMC_DATA_WRITE)
1156                 {
1157                     host->cmdr |= (SDMMC_CMD_DAT_WRITE | SDMMC_CMD_DAT_EXP);
1158             xbwprintk(3, "%s..%d...   write data, len=%d     ======xbw=[%s]====\n", \
1159                                         __FUNCTION__, __LINE__, data->blksz*data->blocks, host->dma_name);
1160
1161                         ret = rk29_sdmmc_prepare_write_data(host, data);
1162             }
1163             else
1164             {
1165                 host->cmdr |= (SDMMC_CMD_DAT_READ | SDMMC_CMD_DAT_EXP);
1166             xbwprintk(3, "%s..%d...   read data  len=%d   ======xbw=[%s]====\n", \
1167                                         __FUNCTION__, __LINE__, data->blksz*data->blocks, host->dma_name);
1168
1169                         ret = rk29_sdmmc_prepare_read_data(host, data);
1170             }
1171
1172     }
1173     else
1174     {
1175         rk29_sdmmc_write(host->regs, SDMMC_BLKSIZ, 0);
1176         rk29_sdmmc_write(host->regs, SDMMC_BYTCNT, 0);
1177     }
1178 }
1179
1180
1181 static int sdmmc_send_cmd_start(struct rk29_sdmmc *host, unsigned int cmd)
1182 {
1183         int tmo = 1000;
1184
1185         rk29_sdmmc_write(host->regs, SDMMC_CMD, SDMMC_CMD_START | cmd);
1186         while (--tmo && readl(host->regs + SDMMC_CMD) & SDMMC_CMD_START)
1187         {
1188             cpu_relax();
1189         }
1190
1191         if(!tmo)
1192         {
1193                 printk("%s.. %d   set cmd(value=0x%x) register timeout error !   ====xbw[%s]====\n",\
1194                                 __FUNCTION__,__LINE__, cmd, host->dma_name);
1195
1196                 host->errorstep = 0x9;
1197                 return SDM_START_CMD_FAIL;
1198         }
1199
1200         return SDM_SUCCESS;
1201 }
1202
1203 static int rk29_sdmmc_get_cd(struct mmc_host *mmc)
1204 {
1205         struct rk29_sdmmc *host = mmc_priv(mmc);
1206         u32 cdetect;
1207
1208 #ifdef CONFIG_PM
1209         if(host->gpio_det == INVALID_GPIO)
1210                 return 1;
1211 #endif
1212
1213         cdetect = rk29_sdmmc_read(host->regs, SDMMC_CDETECT);
1214
1215         return (cdetect & SDMMC_CARD_DETECT_N)?0:1;
1216 }
1217
1218
1219 /****************************************************************/
1220 //reset the SDMMC controller of the current host
1221 /****************************************************************/
1222 int rk29_sdmmc_reset_controller(struct rk29_sdmmc *host)
1223 {
1224     u32  value = 0;
1225     int  timeOut = 0;
1226
1227     rk29_sdmmc_write(host->regs, SDMMC_PWREN, POWER_ENABLE);
1228
1229     /* reset SDMMC IP */
1230     //SDPAM_SDCClkEnable(host, TRUE);
1231
1232     //Clean the fifo.
1233     for(timeOut=0; timeOut<FIFO_DEPTH; timeOut++)
1234     {
1235         if(rk29_sdmmc_read(host->regs, SDMMC_STATUS) & SDMMC_STAUTS_FIFO_EMPTY)
1236             break;
1237
1238         value = rk29_sdmmc_read(host->regs, SDMMC_DATA);
1239     }
1240
1241     /* reset */
1242     rk29_sdmmc_write(host->regs, SDMMC_CTRL,(SDMMC_CTRL_RESET | SDMMC_CTRL_FIFO_RESET ));
1243
1244     timeOut = 1000;
1245     value = rk29_sdmmc_read(host->regs, SDMMC_CTRL);
1246     while (( value & (SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_RESET)) && (timeOut > 0))
1247     {
1248         udelay(1);
1249         timeOut--;
1250         value = rk29_sdmmc_read(host->regs, SDMMC_CTRL);
1251     }
1252
1253     if (timeOut == 0)
1254     {
1255         printk("%s..%s..%d..  reset controller fail!!! =====xbw[%s]=====\n",\
1256                                 __FILE__, __FUNCTION__,__LINE__, host->dma_name);
1257
1258         host->errorstep = 0x0A;
1259         return SDM_WAIT_FOR_FIFORESET_TIMEOUT;
1260     }
1261
1262      /* FIFO threshold settings  */
1263         rk29_sdmmc_write(host->regs, SDMMC_FIFOTH, (SD_MSIZE_16 | (RX_WMARK << RX_WMARK_SHIFT) | (TX_WMARK << TX_WMARK_SHIFT)));
1264
1265     rk29_sdmmc_write(host->regs, SDMMC_CTYPE, SDMMC_CTYPE_1BIT);
1266     rk29_sdmmc_write(host->regs, SDMMC_CLKSRC, CLK_DIV_SRC_0);
1267     /* config debounce */
1268     host->bus_hz = clk_get_rate(host->clk);
1269     if((host->bus_hz > 52000000) || (host->bus_hz <= 0))
1270     {
1271         printk("%s..%s..%d..****Error!!!!!!  Bus clock %d hz is beyond the prescribed limits ====xbw[%s]===\n",\
1272             __FILE__, __FUNCTION__,__LINE__,host->bus_hz, host->dma_name);
1273
1274                 host->errorstep = 0x0B;
1275         return SDM_PARAM_ERROR;
1276     }
1277
1278     rk29_sdmmc_write(host->regs, SDMMC_DEBNCE, (DEBOUNCE_TIME*host->bus_hz)&0xFFFFFF);
1279
1280     /* config interrupt */
1281     rk29_sdmmc_write(host->regs, SDMMC_RINTSTS, 0xFFFFFFFF);
1282
1283     if(host->use_dma)
1284     {
1285         if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1286         {
1287                     rk29_sdmmc_write(host->regs, SDMMC_INTMASK,RK29_SDMMC_INTMASK_USEDMA);
1288                 }
1289                 else
1290                 {
1291                     rk29_sdmmc_write(host->regs, SDMMC_INTMASK,RK29_SDMMC_INTMASK_USEDMA | SDMMC_INT_SDIO);
1292                 }
1293         }
1294         else
1295         {
1296                 if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1297         {
1298                     rk29_sdmmc_write(host->regs, SDMMC_INTMASK,RK29_SDMMC_INTMASK_USEIO);
1299                 }
1300                 else
1301                 {
1302                     rk29_sdmmc_write(host->regs, SDMMC_INTMASK,RK29_SDMMC_INTMASK_USEIO | SDMMC_INT_SDIO);
1303                 }
1304     }
1305
1306         rk29_sdmmc_write(host->regs, SDMMC_PWREN, POWER_ENABLE);
1307
1308         rk29_sdmmc_write(host->regs, SDMMC_CTRL,SDMMC_CTRL_INT_ENABLE); // enable mci interrupt
1309
1310     return SDM_SUCCESS;
1311 }
1312
1313
1314
1315
1316 //enable/disnable the clk.
1317 static int rk29_sdmmc_control_clock(struct rk29_sdmmc *host, bool enable)
1318 {
1319     u32           value = 0;
1320     int           tmo = 0;
1321     int           ret = SDM_SUCCESS;
1322
1323     //wait previous start to clear
1324     tmo = 1000;
1325         while (--tmo && (rk29_sdmmc_read(host->regs, SDMMC_CMD) & SDMMC_CMD_START))
1326         {
1327                 cpu_relax();
1328         }
1329         if(!tmo)
1330         {
1331             host->errorstep = 0x0C;
1332             ret = SDM_START_CMD_FAIL;
1333                 goto Error_exit;
1334     }
1335
1336     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1337     {
1338         //SDMMC use low-power mode
1339         if (enable)
1340         {
1341             value = (SDMMC_CLKEN_LOW_PWR | SDMMC_CLKEN_ENABLE);
1342         }
1343         else
1344         {
1345             value = (SDMMC_CLKEN_LOW_PWR | SDMMC_CLKEN_DISABLE);
1346         }
1347     }
1348     else
1349     {
1350         //SDIO-card use non-low-power mode
1351         if (enable)
1352         {
1353             value = (SDMMC_CLKEN_ENABLE);
1354         }
1355         else
1356         {
1357             value = (SDMMC_CLKEN_DISABLE);
1358         }
1359     }
1360
1361     rk29_sdmmc_write(host->regs, SDMMC_CLKENA, value);
1362
1363         /* inform CIU */
1364         ret = sdmmc_send_cmd_start(host, SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT);
1365     if(ret != SDM_SUCCESS)
1366     {
1367         goto Error_exit;
1368     }
1369
1370     return SDM_SUCCESS;
1371
1372 Error_exit:
1373     printk("\n%s....%d..  control clock fail!!! Enable=%d, ret=%d ===xbw[%s]====\n",\
1374                         __FILE__,__LINE__,enable,ret, host->dma_name);
1375
1376     return ret;
1377
1378 }
1379
1380
1381 //adjust the frequency.ie, to set the frequency division control
1382 int rk29_sdmmc_change_clk_div(struct rk29_sdmmc *host, u32 freqHz)
1383 {
1384     u32 div;
1385     u32 tmo;
1386     int ret = SDM_SUCCESS;
1387
1388     if(0 == freqHz)
1389     {
1390         ret =  SDM_PARAM_ERROR;
1391         goto  SetFreq_error;
1392     }
1393
1394     ret = rk29_sdmmc_control_clock(host, FALSE);
1395     if (ret != SDM_SUCCESS)
1396     {
1397         goto SetFreq_error;
1398     }
1399
1400
1401     host->bus_hz = clk_get_rate(host->clk);
1402     if((host->bus_hz > 52000000) || (host->bus_hz <= 0))
1403     {
1404         printk("%s..%s..%d..****Error!!!!!!  Bus clock %d hz is beyond the prescribed limits ====xbw[%s]===\n",\
1405             __FILE__, __FUNCTION__,__LINE__,host->bus_hz, host->dma_name);
1406
1407         host->errorstep = 0x0D;
1408         ret = SDM_PARAM_ERROR;
1409         goto SetFreq_error;
1410     }
1411
1412     //calculate the divider
1413     div = host->bus_hz/freqHz + ((( host->bus_hz%freqHz ) > 0) ? 1:0 );
1414     if( (div & 0x01) && (1 != div) )
1415     {
1416         //It is sure that the value of div is even.
1417         ++div;
1418     }
1419
1420     if(div > 1)
1421     {
1422         host->clock = host->bus_hz/div;
1423     }
1424     else
1425     {
1426         host->clock = host->bus_hz;
1427     }
1428     div = (div >> 1);
1429
1430     //wait previous start to clear
1431     tmo = 1000;
1432         while (--tmo && (rk29_sdmmc_read(host->regs, SDMMC_CMD) & SDMMC_CMD_START))
1433         {
1434                 cpu_relax();
1435         }
1436         if(!tmo)
1437         {
1438             host->errorstep = 0x0E;
1439             ret = SDM_START_CMD_FAIL;
1440                 goto SetFreq_error;
1441     }
1442
1443     /* set clock to desired speed */
1444     rk29_sdmmc_write(host->regs, SDMMC_CLKDIV, div);
1445
1446     /* inform CIU */
1447     ret = sdmmc_send_cmd_start(host, SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT);
1448     if(ret != SDM_SUCCESS)
1449     {
1450         host->errorstep = 0x0E1;
1451         goto SetFreq_error;
1452     }
1453
1454     if(host->old_div != div)
1455     {
1456         printk("%s..%d..  newDiv=%u, newCLK=%uKhz====xbw[%s]=====\n", \
1457             __FUNCTION__, __LINE__,div, host->clock/1000, host->dma_name);
1458     }
1459
1460     ret = rk29_sdmmc_control_clock(host, TRUE);
1461     if(ret != SDM_SUCCESS)
1462     {
1463         goto SetFreq_error;
1464     }
1465     host->old_div = div;
1466
1467     return SDM_SUCCESS;
1468
1469 SetFreq_error:
1470
1471     printk("%s..%s..%d..  change division fail, ret=%d  !!! ====xbw[%s]====\n",\
1472         __FILE__, __FUNCTION__,__LINE__,ret, host->dma_name);
1473
1474     return ret;
1475
1476 }
1477
1478
1479
1480 static int rk29_sdmmc_hw_init(struct rk29_sdmmc *host)
1481 {
1482     /* reset controller */
1483     rk29_sdmmc_reset_controller(host);
1484     rk29_sdmmc_change_clk_div(host, FOD_FREQ);
1485
1486     return SDM_SUCCESS;
1487 }
1488
1489
1490
1491 int rk29_sdmmc_set_iomux(struct rk29_sdmmc *host)
1492 {
1493     #if 0
1494     switch (host->busWidth)
1495     {
1496         case
1497         rk29_mux_api_set(GPIO1D1_SDMMC0CMD_NAME, GPIO1H_SDMMC0_CMD);
1498         rk29_mux_api_set(GPIO1D0_SDMMC0CLKOUT_NAME, GPIO1H_SDMMC0_CLKOUT);
1499         rk29_mux_api_set(GPIO1D2_SDMMC0DATA0_NAME, GPIO1H_SDMMC0_DATA0);
1500         rk29_mux_api_set(GPIO1D3_SDMMC0DATA1_NAME, GPIO1H_SDMMC0_DATA1);
1501         rk29_mux_api_set(GPIO1D4_SDMMC0DATA2_NAME, GPIO1H_SDMMC0_DATA2);
1502         }
1503     #endif
1504
1505         return 0;
1506 }
1507
1508 int rk29_sdmmc_set_buswidth(struct rk29_sdmmc *host)
1509 {
1510     //int ret;
1511     switch (host->ctype)
1512     {
1513         case SDMMC_CTYPE_1BIT:
1514         case SDMMC_CTYPE_4BIT:
1515             break;
1516         case SDMMC_CTYPE_8BIT:
1517             return SDM_PARAM_ERROR; //Now, not support 8 bit width
1518         default:
1519             return SDM_PARAM_ERROR;
1520     }
1521     rk29_sdmmc_set_iomux(host);
1522
1523     /* Set the current  bus width */
1524         rk29_sdmmc_write(host->regs, SDMMC_CTYPE, host->ctype);
1525
1526     return SDM_SUCCESS;
1527 }
1528
1529
1530 void  rk29_sdmmc_set_frq(struct rk29_sdmmc *host)
1531 {
1532     struct mmc_host *mmchost = platform_get_drvdata(host->pdev);
1533     struct mmc_card     *card;
1534     struct mmc_ios *ios;
1535         unsigned int max_dtr;
1536
1537     extern void mmc_set_clock(struct mmc_host *host, unsigned int hz);
1538
1539     if(!mmchost)
1540         return;
1541
1542     card = (struct mmc_card     *)mmchost->card;
1543     ios  = ( struct mmc_ios *)&mmchost->ios;
1544
1545     if(!card && !ios)
1546         return;
1547
1548     if(MMC_POWER_ON == ios->power_mode)
1549         return;
1550
1551     max_dtr = (unsigned int)-1;
1552
1553     if (mmc_card_highspeed(card))
1554     {
1555         if (max_dtr > card->ext_csd.hs_max_dtr)
1556             max_dtr = card->ext_csd.hs_max_dtr;
1557
1558     }
1559     else if (max_dtr > card->csd.max_dtr)
1560     {
1561         if(MMC_TYPE_SD == card->type)
1562         {
1563                 max_dtr = (card->csd.max_dtr > SD_FPP_FREQ) ? SD_FPP_FREQ : (card->csd.max_dtr);
1564             }
1565             else
1566             {
1567             max_dtr = (card->csd.max_dtr > MMC_FPP_FREQ) ? MMC_FPP_FREQ : (card->csd.max_dtr);
1568             }
1569     }
1570
1571     xbwprintk(7, "%s..%d...  call mmc_set_clock() set clk=%d ===xbw[%s]===\n", \
1572                         __FUNCTION__, __LINE__, max_dtr, host->dma_name);
1573
1574
1575     mmc_set_clock(mmchost, max_dtr);
1576
1577 }
1578
1579 static void rk29_sdmmc_dealwith_timeout(struct rk29_sdmmc *host)
1580 {
1581     switch(host->state)
1582     {
1583         case STATE_IDLE:
1584         {
1585             #if 1
1586             break;
1587             #else
1588             if(!host->cmd)
1589                 break;
1590
1591             host->cmd->error = -EIO;
1592
1593             if(host->cmd->data)
1594             {
1595                 host->cmd->data->error = -EILSEQ;
1596             }
1597             host->state = STATE_SENDING_CMD;
1598             /* fall through */
1599             #endif
1600         }
1601
1602         case STATE_SENDING_CMD:
1603             host->cmd_status |= SDMMC_INT_RTO;
1604             host->cmd->error = -ETIME;
1605             rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,(SDMMC_INT_CMD_DONE | SDMMC_INT_RTO));  //  clear interrupt
1606             rk29_sdmmc_set_pending(host, EVENT_CMD_COMPLETE);
1607             tasklet_schedule(&host->tasklet);
1608             break;
1609          case STATE_DATA_BUSY:
1610             host->data_status |= (SDMMC_INT_DCRC|SDMMC_INT_EBE);
1611             host->cmd->data->error = -EILSEQ;
1612             rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_DTO);  // clear interrupt
1613             rk29_sdmmc_set_pending(host, EVENT_DATA_COMPLETE);
1614             tasklet_schedule(&host->tasklet);
1615             break;
1616          case STATE_SENDING_STOP:
1617             host->cmd_status |= SDMMC_INT_RTO;
1618             host->cmd->error = -ETIME;
1619             rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,(SDMMC_INT_CMD_DONE | SDMMC_INT_RTO));  //  clear interrupt
1620             rk29_sdmmc_set_pending(host, EVENT_CMD_COMPLETE);
1621             tasklet_schedule(&host->tasklet);
1622             break;
1623     }
1624 }
1625
1626
1627 static void rk29_sdmmc_INT_CMD_DONE_timeout(unsigned long host_data)
1628 {
1629         struct rk29_sdmmc *host = (struct rk29_sdmmc *) host_data;
1630
1631         if(STATE_SENDING_CMD == host->state)
1632         {
1633             if(0==host->cmd->retries)
1634             {
1635             printk("%s..%d... cmd=%d, INT_CMD_DONE timeout, errorStep=0x%x, host->state=%x ===xbw[%s]===\n",\
1636                 __FUNCTION__, __LINE__,host->cmd->opcode, host->errorstep,host->state,host->dma_name);
1637         }
1638
1639         rk29_sdmmc_dealwith_timeout(host);
1640         }
1641
1642 }
1643
1644
1645 static void rk29_sdmmc_INT_DTO_timeout(unsigned long host_data)
1646 {
1647         struct rk29_sdmmc *host = (struct rk29_sdmmc *) host_data;
1648
1649
1650         if( (host->cmdr & SDMMC_CMD_DAT_EXP) && (STATE_DATA_BUSY == host->state))
1651         {
1652             if(0==host->cmd->retries)
1653             {
1654            printk("%s..%d...cmd=%d DTO_timeout,cmdr=0x%x, errorStep=0x%x, Hoststate=%x===xbw[%s]===\n", \
1655                 __FUNCTION__, __LINE__,host->cmd->opcode,host->cmdr ,host->errorstep,host->state,host->dma_name);
1656             }
1657
1658             rk29_sdmmc_dealwith_timeout(host);
1659         }
1660
1661 }
1662
1663
1664 //to excute a  request
1665 static int rk29_sdmmc_start_request(struct mmc_host *mmc )
1666 {
1667     struct rk29_sdmmc *host = mmc_priv(mmc);
1668         struct mmc_request      *mrq;
1669         struct mmc_command      *cmd;
1670
1671         u32             cmdr, ret;
1672         unsigned long iflags;
1673
1674         spin_lock_irqsave(&host->lock, iflags);
1675
1676         mrq = host->new_mrq;
1677         cmd = mrq->cmd;
1678         cmd->error = 0;
1679         host->complete_done = 0;
1680
1681         cmdr = rk29_sdmmc_prepare_command(cmd);
1682         ret = SDM_SUCCESS;
1683
1684
1685         /*clean FIFO if it is a new request*/
1686     if((RK29_CTRL_SDMMC_ID == host->pdev->id) && ( !(cmdr & SDMMC_CMD_STOP)))
1687     {
1688         ret = rk29_sdmmc_reset_fifo(host);
1689         if(SDM_SUCCESS != ret)
1690         {
1691                         host->mrq = host->new_mrq;///
1692             cmd->error = -ENOMEDIUM;
1693             host->errorstep = 0x0F;
1694             ret = SDM_FALSE;
1695             goto start_request_Err;
1696         }
1697     }
1698
1699     //check data-busy if the current command has the bit13 in command register.
1700     if( cmdr & SDMMC_CMD_PRV_DAT_WAIT )
1701     {
1702         if(rk29_sdmmc_read(host->regs, SDMMC_STATUS) & SDMMC_STAUTS_DATA_BUSY)
1703         {
1704                 host->mrq = host->new_mrq;///
1705             cmd->error = -ETIMEDOUT;
1706             ret = SDM_BUSY_TIMEOUT;
1707             host->errorstep = 0x10;
1708             if(0 == cmd->retries)
1709             {
1710                 printk("%s..Error happen in CMD_PRV_DAT_WAIT. STATUS-reg=0x%x ===xbw[%s]===\n", \
1711                     __FUNCTION__, rk29_sdmmc_read(host->regs, SDMMC_STATUS),host->dma_name);
1712             }
1713             goto start_request_Err;
1714         }
1715     }
1716
1717     host->state = STATE_SENDING_CMD;
1718     host->mrq = host->new_mrq;
1719         mrq = host->mrq;
1720         cmd = mrq->cmd;
1721         cmd->error = 0;
1722
1723     host->cmdr = cmdr;
1724     host->cmd = cmd;
1725         host->pending_events = 0;
1726         host->completed_events = 0;
1727         host->data_status = 0;
1728         host->data = NULL;
1729
1730         host->errorstep = 0;
1731         host->dodma = 0;
1732
1733     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1734     {
1735         //adjust the frequency division control of SDMMC0 every time.
1736         rk29_sdmmc_set_frq(host);
1737     }
1738
1739
1740     //setting for the data
1741         rk29_sdmmc_submit_data(host, mrq->data);
1742
1743
1744         xbwprintk(7, "%s..%d...    CMD%d  begin to call rk29_sdmmc_start_command() ===xbw[%s]===\n", \
1745                         __FUNCTION__, __LINE__ , cmd->opcode,host->dma_name);
1746
1747         if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1748         {
1749             mod_timer(&host->request_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_SEND_START_TIMEOUT+700));
1750         }
1751         else
1752         {
1753             mod_timer(&host->request_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_SEND_START_TIMEOUT+500));
1754         }
1755
1756
1757         ret = rk29_sdmmc_start_command(host, cmd, host->cmdr);
1758         if(SDM_SUCCESS != ret)
1759         {
1760         cmd->error = -ETIMEDOUT;
1761         if(0==cmd->retries)
1762         {
1763             printk("%s..%d...   start_command(CMD%d, arg=%x, retries=%d)  fail! ret=%d  =========xbw=[%s]===\n",\
1764                 __FUNCTION__, __LINE__ , cmd->opcode,cmd->arg, cmd->retries,ret, host->dma_name);
1765         }
1766         host->errorstep = 0x11;
1767         del_timer_sync(&host->request_timer);
1768
1769         goto start_request_Err;
1770         }
1771
1772     xbwprintk(7, "%s..%d...  CMD=%d, wait for INT_CMD_DONE, ret=%d , \n  \
1773         host->state=0x%x, cmdINT=0x%x \n    host->pendingEvent=0x%lu, host->completeEvents=0x%lu =========xbw=[%s]=====\n\n",\
1774         __FUNCTION__, __LINE__, host->cmd->opcode,ret, \
1775         host->state,host->cmd_status, host->pending_events,host->completed_events,host->dma_name);
1776
1777     spin_unlock_irqrestore(&host->lock, iflags);
1778         return SDM_SUCCESS;
1779
1780 start_request_Err:
1781     rk29_sdmmc_start_error(host);
1782
1783     if(0 == cmd->retries)
1784     {
1785         printk("%s: CMD%d(arg=%x)  fail to start request.  err=%d, Errorstep=0x%x ===xbw[%s]==\n\n",\
1786             __FUNCTION__,  cmd->opcode, cmd->arg,ret,host->errorstep,host->dma_name);
1787     }
1788
1789     host->state = STATE_IDLE;  //modifyed by xbw  at 2011-08-15
1790     spin_unlock_irqrestore(&host->lock, iflags);
1791
1792     mmc_request_done(host->mmc, host->mrq);
1793
1794     return ret;
1795
1796 }
1797
1798
1799 static void rk29_sdmmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
1800 {
1801     unsigned long iflags;
1802         struct rk29_sdmmc *host = mmc_priv(mmc);
1803
1804     spin_lock(&host->request_lock);
1805
1806     spin_lock_irqsave(&host->lock, iflags);
1807
1808         #if 0
1809         //set 1 to close the controller for Debug.
1810         if(RK29_CTRL_SDIO1_ID==host->pdev->id)//if(RK29_CTRL_SDMMC_ID==host->pdev->id)//
1811         {
1812             mrq->cmd->error = -ENOMEDIUM;
1813             printk("%s..%d..  ==== The %s had been closed by myself for the experiment. ====xbw[%s]===\n",\
1814                                 __FUNCTION__, __LINE__, host->dma_name, host->dma_name);
1815
1816         spin_unlock_irqrestore(&host->lock, iflags);
1817             mmc_request_done(mmc, mrq);
1818                 goto request_ext;//return;
1819         }
1820         #endif
1821
1822     xbwprintk(3, "\n%s..%d..New cmd=%2d(arg=0x%8x)=== cardPresent=0x%lu, state=0x%x ==xbw[%s]==\n", \
1823         __FUNCTION__, __LINE__,mrq->cmd->opcode, mrq->cmd->arg,host->flags,host->state, host->dma_name);
1824
1825     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1826     {
1827         if(!rk29_sdmmc_get_cd(mmc) || ((0==mmc->re_initialized_flags)&&(MMC_GO_IDLE_STATE != mrq->cmd->opcode)))
1828         {
1829                 mrq->cmd->error = -ENOMEDIUM;
1830
1831                 if((RK29_CTRL_SDMMC_ID == host->pdev->id)&&(0==mrq->cmd->retries))
1832                 {
1833                 if(host->old_cmd != mrq->cmd->opcode)
1834                 {
1835                     if( ((17==host->old_cmd)&&(18==mrq->cmd->opcode)) || ((18==host->old_cmd)&&(17==mrq->cmd->opcode)) ||\
1836                          ((24==host->old_cmd)&&(25==mrq->cmd->opcode)) || ((25==host->old_cmd)&&(24==mrq->cmd->opcode)))
1837                     {
1838                         host->old_cmd = mrq->cmd->opcode;
1839                         if(host->error_times++ %RK29_ERROR_PRINTK_INTERVAL ==0)
1840                         {
1841                                 printk("%s: Refuse to run CMD%2d(arg=0x%8x) due to the removal of card.  1==xbw[%s]==\n", \
1842                                     __FUNCTION__, mrq->cmd->opcode, mrq->cmd->arg, host->dma_name);
1843                                 }
1844                     }
1845                     else
1846                     {
1847                         host->old_cmd = mrq->cmd->opcode;
1848                         host->error_times = 0;
1849                         printk("%s: Refuse to run CMD%2d(arg=0x%8x) due to the removal of card.  2==xbw[%s]==\n", \
1850                                     __FUNCTION__, mrq->cmd->opcode, mrq->cmd->arg, host->dma_name);
1851                         }
1852                     }
1853                     else
1854                     {
1855                         if(host->error_times++ % (RK29_ERROR_PRINTK_INTERVAL*2) ==0)
1856                         {
1857                                 printk("%s: Refuse to run CMD%2d(arg=0x%8x) due to the removal of card.  3==xbw[%s]==\n", \
1858                                     __FUNCTION__, mrq->cmd->opcode, mrq->cmd->arg, host->dma_name);
1859                         }
1860                     }
1861                 }
1862
1863             spin_unlock_irqrestore(&host->lock, iflags);
1864                 mmc_request_done(mmc, mrq);
1865                 goto request_ext;//return;
1866         }
1867         else
1868         {
1869                 if(host->old_cmd != mrq->cmd->opcode)
1870                 {
1871                         host->old_cmd = mrq->cmd->opcode;
1872                                 host->error_times = 0;
1873                         }
1874         }
1875         }
1876         else
1877         {
1878         host->old_cmd = mrq->cmd->opcode;
1879         host->error_times = 0;
1880         }
1881
1882         #if 1
1883         if(host->state != STATE_IDLE)
1884         {
1885              printk("%s..%d..state Error! ,old_state=%d, OldCMD=%d ,NewCMD%2d,arg=0x%x ===xbw[%s]===\n", \
1886                                 __FUNCTION__, __LINE__, host->state, host->cmd->opcode,mrq->cmd->opcode,mrq->cmd->arg, host->dma_name);
1887         }
1888
1889
1890         spin_unlock_irqrestore(&host->lock, iflags);
1891
1892     host->new_mrq = mrq;
1893     rk29_sdmmc_start_request(mmc);
1894
1895         #else
1896         if (host->state == STATE_IDLE)
1897         {
1898         spin_unlock_irqrestore(&host->lock, iflags);
1899
1900         host->new_mrq = mrq;
1901         rk29_sdmmc_start_request(mmc);
1902         }
1903         else
1904         {
1905         #ifdef RK29_SDMMC_LIST_QUEUE
1906
1907         printk("%s..%d...Danger! Danger! New request was added to queue. ===xbw[%s]===\n", \
1908                                 __FUNCTION__, __LINE__,host->dma_name);
1909         list_add_tail(&host->queue_node, &host->queue);
1910
1911         #else
1912
1913         printk("%s..%d..state Error! ,old_state=%d, OldCMD=%d ,NewCMD%2d,arg=0x%x ===xbw[%s]===\n", \
1914                                 __FUNCTION__, __LINE__, host->state, host->cmd->opcode,mrq->cmd->opcode,mrq->cmd->arg, host->dma_name);
1915
1916                 mrq->cmd->error = -ENOMEDIUM;
1917
1918                 spin_unlock_irqrestore(&host->lock, iflags);
1919                 mmc_request_done(mmc, mrq);
1920
1921                 goto request_ext;//return;
1922
1923         #endif
1924         }
1925         #endif
1926
1927 request_ext:
1928     spin_unlock(&host->request_lock);
1929 }
1930
1931
1932
1933 static void rk29_sdmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
1934 {
1935     int timeout = 250;
1936     unsigned int value;
1937     unsigned long iflags;
1938         struct rk29_sdmmc *host = mmc_priv(mmc);
1939
1940     spin_lock_irqsave(&host->lock, iflags);
1941
1942     /*
1943      * Waiting SDIO controller to be IDLE.
1944     */
1945     while (timeout-- > 0)
1946         {
1947                 value = rk29_sdmmc_read(host->regs, SDMMC_STATUS);
1948                 if ((value & SDMMC_STAUTS_DATA_BUSY) == 0 &&(value & SDMMC_CMD_FSM_MASK) == SDMMC_CMD_FSM_IDLE)
1949                 {
1950                         break;
1951                 }
1952
1953                 mdelay(1);
1954         }
1955         if (timeout <= 0)
1956         {
1957                 printk("%s..%d...Waiting for SDMMC%d controller to be IDLE timeout.==xbw[%s]===\n", \
1958                                 __FUNCTION__, __LINE__, host->pdev->id, host->dma_name);
1959
1960                 goto out;
1961         }
1962
1963     //if(host->bus_mode != ios->power_mode)
1964     {
1965         switch (ios->power_mode)
1966         {
1967             case MMC_POWER_UP:
1968                 rk29_sdmmc_write(host->regs, SDMMC_PWREN, POWER_ENABLE);
1969
1970                 //reset the controller if it is SDMMC0
1971                 if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1972                 {
1973                     xbwprintk(7, "%s..%d..POWER_UP, call reset_controller, initialized_flags=%d ====xbw[%s]=====\n",\
1974                         __FUNCTION__, __LINE__, host->mmc->re_initialized_flags,host->dma_name);
1975
1976                     mdelay(5);
1977
1978                     rk29_sdmmc_hw_init(host);
1979                 }
1980
1981                 break;
1982             case MMC_POWER_OFF:
1983
1984                 if(RK29_CTRL_SDMMC_ID == host->pdev->id)
1985                 {
1986                         rk29_sdmmc_control_clock(host, FALSE);
1987                         rk29_sdmmc_write(host->regs, SDMMC_PWREN, POWER_DISABLE);
1988
1989                         if(5 == host->bus_mode)
1990                         {
1991                         mdelay(5);
1992                         xbwprintk(7, "%s..%d..Fisrt powerOFF, call reset_controller ======xbw[%s]====\n", \
1993                             __FUNCTION__, __LINE__,host->dma_name);
1994
1995                         rk29_sdmmc_reset_controller(host);
1996                         }
1997
1998                 }
1999
2000                 break;
2001             default:
2002                 break;
2003         }
2004
2005         host->bus_mode = ios->power_mode;
2006
2007         }
2008
2009
2010         if(host->ctype != ios->bus_width)
2011         {
2012         switch (ios->bus_width)
2013         {
2014             case MMC_BUS_WIDTH_1:
2015                 host->ctype = SDMMC_CTYPE_1BIT;
2016                 break;
2017             case MMC_BUS_WIDTH_4:
2018                 host->ctype = SDMMC_CTYPE_4BIT;
2019                 break;
2020             case MMC_BUS_WIDTH_8:
2021                 host->ctype = SDMMC_CTYPE_8BIT;
2022                 break;
2023             default:
2024                 host->ctype = 0;
2025                 break;
2026         }
2027
2028             rk29_sdmmc_set_buswidth(host);
2029
2030         }
2031
2032         if (ios->clock && (ios->clock != host->clock))
2033         {
2034                 /*
2035                  * Use mirror of ios->clock to prevent race with mmc
2036                  * core ios update when finding the minimum.
2037                  */
2038                 //host->clock = ios->clock;
2039                 rk29_sdmmc_change_clk_div(host, ios->clock);
2040         }
2041 out:
2042
2043     spin_unlock_irqrestore(&host->lock, iflags);
2044 }
2045
2046 static int rk29_sdmmc_get_ro(struct mmc_host *mmc)
2047 {
2048         struct rk29_sdmmc *host = mmc_priv(mmc);
2049         u32 wrtprt = rk29_sdmmc_read(host->regs, SDMMC_WRTPRT);
2050
2051         return (wrtprt & SDMMC_WRITE_PROTECT)?1:0;
2052 }
2053
2054
2055 static void rk29_sdmmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
2056 {
2057         u32 intmask;
2058         unsigned long flags;
2059         struct rk29_sdmmc *host = mmc_priv(mmc);
2060
2061         spin_lock_irqsave(&host->lock, flags);
2062         intmask = rk29_sdmmc_read(host->regs, SDMMC_INTMASK);
2063
2064         if(enable)
2065                 rk29_sdmmc_write(host->regs, SDMMC_INTMASK, intmask | SDMMC_INT_SDIO);
2066         else
2067                 rk29_sdmmc_write(host->regs, SDMMC_INTMASK, intmask & ~SDMMC_INT_SDIO);
2068         spin_unlock_irqrestore(&host->lock, flags);
2069 }
2070
2071 static void  rk29_sdmmc_init_card(struct mmc_host *mmc, struct mmc_card *card)
2072 {
2073         card->quirks = MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
2074
2075 }
2076
2077
2078 static const struct mmc_host_ops rk29_sdmmc_ops[] = {
2079         {
2080                 .request        = rk29_sdmmc_request,
2081                 .set_ios        = rk29_sdmmc_set_ios,
2082                 .get_ro         = rk29_sdmmc_get_ro,
2083                 .get_cd         = rk29_sdmmc_get_cd,
2084         },
2085         {
2086                 .request        = rk29_sdmmc_request,
2087                 .set_ios        = rk29_sdmmc_set_ios,
2088                 .enable_sdio_irq = rk29_sdmmc_enable_sdio_irq,
2089                 .init_card       = rk29_sdmmc_init_card,
2090         },
2091 };
2092
2093 static void rk29_sdmmc_request_end(struct rk29_sdmmc *host, struct mmc_command *cmd)
2094 {
2095         u32 status;
2096         int output=SDM_SUCCESS;
2097
2098         xbwprintk(7, "%s..%d...  cmd=%d, host->state=0x%x,\n   pendingEvent=0x%lu, completeEvents=0x%lu ====xbw=[%s]====\n\n",\
2099         __FUNCTION__, __LINE__,cmd->opcode,host->state, host->pending_events,host->completed_events,host->dma_name);
2100
2101     del_timer_sync(&host->DTO_timer);
2102
2103     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
2104     {
2105         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS, 0xFFFFFFFF); //added by xbw at 2011-08-15
2106     }
2107
2108     //stop DMA
2109     if(host->dodma)
2110     {
2111         rk29_sdmmc_stop_dma(host);
2112         rk29_sdmmc_control_host_dma(host, FALSE);
2113         host->dodma = 0;
2114     }
2115
2116     if(cmd->error)
2117     {
2118         goto exit;//It need not to wait-for-busy if the CMD-ERROR happen.
2119     }
2120
2121     if(cmd->data)
2122     {
2123
2124         status = host->data_status;
2125
2126         if(host->cmdr & SDMMC_CMD_DAT_WRITE)
2127         {
2128             if(status & (SDMMC_INT_DCRC | SDMMC_INT_EBE))
2129             {
2130                 cmd->data->error = -EILSEQ;;//mrq->data->error = -EILSEQ;
2131                 output = SDM_DATA_CRC_ERROR;
2132                 host->errorstep = 0x16;
2133             }
2134             else
2135             {
2136                 output = rk29_sdmmc_wait_unbusy(host);
2137                 if(SDM_SUCCESS != output)
2138                 {
2139                     host->errorstep = 0x17;
2140                     cmd->data->error = -ETIMEDOUT;
2141                 }
2142
2143                 host->data->bytes_xfered = host->data->blocks * host->data->blksz;
2144             }
2145         }
2146         else
2147         {
2148             if( status  & SDMMC_INT_SBE)
2149             {
2150                 cmd->data->error = -EIO;
2151                 host->errorstep = 0x18;
2152                 output = SDM_START_BIT_ERROR;
2153             }
2154             else if((status  & SDMMC_INT_EBE) && (cmd->opcode != 14)) //MMC4.0, BUSTEST_R, A host read the reserved bus testing data parttern from a card.
2155             {
2156                 cmd->data->error = -EILSEQ;
2157                 host->errorstep = 0x19;
2158                 output = SDM_END_BIT_ERROR;
2159             }
2160             else if(status  & SDMMC_INT_DRTO)
2161             {
2162                 cmd->data->error = -ETIMEDOUT;
2163                 host->errorstep = 0x1A;
2164                 output = SDM_DATA_READ_TIMEOUT;
2165             }
2166             else if(status  & SDMMC_INT_DCRC)
2167             {
2168                 host->errorstep = 0x1B;
2169                 cmd->data->error = -EILSEQ;
2170                 output = SDM_DATA_CRC_ERROR;
2171             }
2172             else
2173             {
2174                 output = rk29_sdmmc_read_remain_data(host, (host->data->blocks * host->data->blksz), host->pbuf);
2175                 if(SDM_SUCCESS == output)
2176                 {
2177                     host->data->bytes_xfered = host->data->blocks * host->data->blksz;
2178                 }
2179             }
2180         }
2181     }
2182
2183     if(SDM_SUCCESS == output)
2184     {
2185         if ((mmc_resp_type(cmd) == MMC_RSP_R1B) || (MMC_STOP_TRANSMISSION == cmd->opcode))
2186         {
2187             output = rk29_sdmmc_wait_unbusy(host);
2188             if(SDM_SUCCESS != output)
2189             {
2190                 cmd->error = -ETIMEDOUT;
2191                 host->mrq->cmd->error = -ETIMEDOUT;
2192                 host->errorstep = 0x1C;
2193                 printk("%s..%d...   CMD12 wait busy timeout!!!!!      ====xbw=[%s]====\n", \
2194                                                 __FUNCTION__, __LINE__,  host->dma_name);
2195             }
2196         }
2197     }
2198
2199     //trace error
2200     if(cmd->data && cmd->data->error)
2201     {
2202         if( (!cmd->error) && (0==cmd->retries) && (host->error_times++%RK29_ERROR_PRINTK_INTERVAL == 0))
2203         {
2204             printk("%s..%d......CMD=%d error!!!, arg=%x, errorTimes=%d, errorStep=0x%x ! ====xbw[%s]====\n",\
2205                 __FUNCTION__, __LINE__, cmd->opcode, cmd->arg, host->error_times,host->errorstep, host->dma_name);
2206         }
2207     }
2208
2209 exit:
2210
2211 #ifdef RK29_SDMMC_LIST_QUEUE
2212         if (!list_empty(&host->queue))
2213         {
2214                 printk("%s..%d..  Danger!Danger!. continue the next request in the queue.  ====xbw[%s]====\n",\
2215                         __FUNCTION__, __LINE__, host->dma_name);
2216
2217                 host = list_entry(host->queue.next,
2218                                 struct rk29_sdmmc, queue_node);
2219                 list_del(&host->queue_node);
2220                 host->state = STATE_SENDING_CMD;
2221                 rk29_sdmmc_start_request(host->mmc);
2222         }
2223         else
2224         {
2225                 dev_vdbg(&host->pdev->dev, "list empty\n");
2226                 host->state = STATE_IDLE;
2227         }
2228 #else
2229     dev_vdbg(&host->pdev->dev, "list empty\n");
2230         host->state = STATE_IDLE;
2231 #endif
2232
2233 }
2234
2235 static int rk29_sdmmc_command_complete(struct rk29_sdmmc *host,
2236                         struct mmc_command *cmd)
2237 {
2238         u32      value, status = host->cmd_status;
2239         int  timeout, output= SDM_SUCCESS;
2240
2241     xbwprintk(7, "%s..%d.  cmd=%d, host->state=0x%x, cmdINT=0x%x\n,pendingEvent=0x%lu,completeEvents=0x%lu ===xbw[%s]===\n\n",\
2242         __FUNCTION__, __LINE__,cmd->opcode,host->state,status, host->pending_events,host->completed_events,host->dma_name);
2243
2244
2245     del_timer_sync(&host->request_timer);
2246
2247     host->cmd_status = 0;
2248
2249         if((RK29_CTRL_SDMMC_ID == host->pdev->id) && (host->cmdr & SDMMC_CMD_STOP))
2250     {
2251         output = rk29_sdmmc_reset_fifo(host);
2252         if (SDM_SUCCESS != output)
2253         {
2254             printk("%s..%d......reset fifo fail! CMD%d(arg=0x%x, Retries=%d) =======xbw[%s]=====\n",__FUNCTION__, __LINE__, \
2255                 cmd->opcode, cmd->arg, cmd->retries,host->dma_name);
2256
2257             cmd->error = -ETIMEDOUT;
2258             host->mrq->cmd->error = cmd->error;
2259             output = SDM_ERROR;
2260             host->errorstep = 0x1C;
2261             goto CMD_Errror;
2262         }
2263     }
2264
2265     if(status & SDMMC_INT_RTO)
2266         {
2267             cmd->error = -ENOMEM;
2268             host->mrq->cmd->error = cmd->error;
2269         output = SDM_BUSY_TIMEOUT;
2270
2271         //rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_RTO);
2272         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,0xFFFFFFFF);  //modifyed by xbw at 2011-08-15
2273
2274         if(host->use_dma)//if(host->dodma)
2275         {
2276            if(host->dodma)
2277            {
2278                 rk29_sdmmc_stop_dma(host);
2279                 rk29_sdmmc_control_host_dma(host, FALSE);
2280                 host->dodma = 0;
2281            }
2282
2283             value = rk29_sdmmc_read(host->regs, SDMMC_CTRL);
2284             value |= SDMMC_CTRL_FIFO_RESET;
2285             rk29_sdmmc_write(host->regs, SDMMC_CTRL, value);
2286
2287             timeout = 1000;
2288             while (((value = rk29_sdmmc_read(host->regs, SDMMC_CTRL)) & (SDMMC_CTRL_FIFO_RESET)) && (timeout > 0))
2289             {
2290                 udelay(1);
2291                 timeout--;
2292             }
2293             if (timeout == 0)
2294             {
2295                 output = SDM_FALSE;
2296                 host->errorstep = 0x1D;
2297                 printk("%s..%d......reset CTRL fail! CMD%d(arg=0x%x, Retries=%d) ===xbw[%s]===\n",\
2298                     __FUNCTION__, __LINE__, cmd->opcode, cmd->arg, cmd->retries,host->dma_name);
2299
2300                goto CMD_Errror;
2301             }
2302         }
2303
2304         }
2305
2306         if(cmd->flags & MMC_RSP_PRESENT)
2307         {
2308             if(cmd->flags & MMC_RSP_136)
2309             {
2310             cmd->resp[3] = rk29_sdmmc_read(host->regs, SDMMC_RESP0);
2311             cmd->resp[2] = rk29_sdmmc_read(host->regs, SDMMC_RESP1);
2312             cmd->resp[1] = rk29_sdmmc_read(host->regs, SDMMC_RESP2);
2313             cmd->resp[0] = rk29_sdmmc_read(host->regs, SDMMC_RESP3);
2314             }
2315             else
2316             {
2317                 cmd->resp[0] = rk29_sdmmc_read(host->regs, SDMMC_RESP0);
2318             }
2319         }
2320
2321         if(cmd->error)
2322         {
2323             del_timer_sync(&host->DTO_timer);
2324
2325         //trace error
2326             if((0==cmd->retries) && (host->error_times++%RK29_ERROR_PRINTK_INTERVAL == 0) && (12 != cmd->opcode))
2327             {
2328                 if( ((RK29_CTRL_SDMMC_ID==host->pdev->id)&&(MMC_SLEEP_AWAKE!=cmd->opcode)) ||
2329                      ((RK29_CTRL_SDMMC_ID!=host->pdev->id)&&(MMC_SEND_EXT_CSD!=cmd->opcode))  )
2330                 {
2331                     printk("%s..%d...CMD%d(arg=0x%x), hoststate=%d, errorTimes=%d, errorStep=0x%x ! ===xbw[%s]===\n",\
2332                     __FUNCTION__, __LINE__, cmd->opcode, cmd->arg, host->state,host->error_times,host->errorstep, host->dma_name);
2333                 }
2334             }
2335
2336         }
2337     del_timer_sync(&host->request_timer);
2338
2339
2340         return SDM_SUCCESS;
2341
2342 CMD_Errror:
2343     del_timer_sync(&host->request_timer);
2344         del_timer_sync(&host->DTO_timer);
2345
2346         if((0==cmd->retries) && (host->error_times++%RK29_ERROR_PRINTK_INTERVAL == 0))
2347     {
2348         printk("%s..%d....command_complete(CMD=%d, arg=%x) error=%d =======xbw[%s]=====\n",\
2349             __FUNCTION__, __LINE__, host->cmd->opcode,host->cmd->arg, output, host->dma_name);
2350     }
2351
2352     return output;
2353
2354 }
2355
2356
2357 static void rk29_sdmmc_start_error(struct rk29_sdmmc *host)
2358 {
2359     host->cmd->error = -EIO;
2360     host->mrq->cmd->error = -EIO;
2361     host->cmd_status = SDMMC_INT_RTO;
2362
2363     del_timer_sync(&host->request_timer);
2364
2365     rk29_sdmmc_command_complete(host, host->mrq->cmd);
2366     rk29_sdmmc_request_end(host, host->mrq->cmd);
2367
2368 }
2369
2370 static void rk29_sdmmc_tasklet_func(unsigned long priv)
2371 {
2372         struct rk29_sdmmc       *host = (struct rk29_sdmmc *)priv;
2373         struct mmc_data         *data = host->cmd->data;
2374         enum rk29_sdmmc_state   state = host->state;
2375
2376         spin_lock(&host->lock);
2377
2378         state = host->state;
2379
2380         do
2381         {
2382         switch (state)
2383         {
2384             case STATE_IDLE:
2385             {
2386                 xbwprintk(7, "%s..%d..   prev_state=  STATE_IDLE  ====xbw[%s]====\n", \
2387                                                 __FUNCTION__, __LINE__, host->dma_name);
2388                 break;
2389             }
2390
2391             case STATE_SENDING_CMD:
2392             {
2393                 xbwprintk(7, "%s..%d..   prev_state=  STATE_SENDING_CMD, pendingEvernt=0x%lu  ====xbw[%s]====\n",\
2394                     __FUNCTION__, __LINE__,host->completed_events, host->dma_name);
2395
2396                 if (!rk29_sdmmc_test_and_clear_pending(host, EVENT_CMD_COMPLETE))
2397                         break;
2398
2399                 del_timer_sync(&host->request_timer); //delete the timer for INT_COME_DONE
2400
2401                 rk29_sdmmc_set_completed(host, EVENT_CMD_COMPLETE);
2402                 rk29_sdmmc_command_complete(host, host->cmd);
2403
2404
2405                 if (!data)
2406                 {
2407                     rk29_sdmmc_request_end(host, host->cmd);
2408
2409                     xbwprintk(7, "%s..%d..  CMD%d call mmc_request_done()====xbw[%s]====\n", \
2410                                                         __FUNCTION__, __LINE__,host->cmd->opcode,host->dma_name);
2411
2412                     host->complete_done = 1;
2413                     goto unlock;
2414                 }
2415
2416                 if(host->cmd->error)
2417                 {
2418                     del_timer_sync(&host->DTO_timer); //delete the timer for INT_DTO
2419
2420                     if(data->stop)
2421                     {
2422                         xbwprintk(7, "%s..%d..  cmderr, so call send_stop_cmd() ====xbw[%s]====\n", \
2423                                                                 __FUNCTION__, __LINE__, host->dma_name);
2424
2425                         state = STATE_SENDING_CMD;//STATE_SENDING_STOP;
2426                         send_stop_cmd(host);
2427                         break;
2428                     }
2429
2430                     rk29_sdmmc_set_pending(host, EVENT_DATA_COMPLETE);
2431                 }
2432
2433
2434                 state = STATE_DATA_BUSY;
2435                 /* fall through */
2436             }
2437
2438             case STATE_DATA_BUSY:
2439             {
2440                 xbwprintk(7, "%s..%d..   prev_state= STATE_DATA_BUSY, pendingEvernt=0x%lu ====xbw[%s]====\n", \
2441                                                 __FUNCTION__, __LINE__,host->pending_events, host->dma_name);
2442
2443                 if (!rk29_sdmmc_test_and_clear_pending(host, EVENT_DATA_COMPLETE))
2444                         break;
2445
2446                 rk29_sdmmc_set_completed(host, EVENT_DATA_COMPLETE);
2447                 del_timer_sync(&host->DTO_timer); //delete the timer for INT_DTO
2448
2449                 rk29_sdmmc_request_end(host, host->cmd);
2450
2451                 if (data && !data->stop)
2452                 {
2453                     xbwprintk(7, "%s..%d..  CMD%d call mmc_request_done()====xbw[%s]====\n", \
2454                                                         __FUNCTION__, __LINE__,host->cmd->opcode,host->dma_name);
2455
2456                     if(!( (MMC_READ_SINGLE_BLOCK == host->cmd->opcode)&&( -EIO == data->error))) //deal with START_BIT_ERROR
2457                     {
2458                         host->complete_done = 1;
2459                         goto unlock;
2460                     }
2461
2462                 }
2463
2464                 xbwprintk(7, "%s..%d..  after DATA_COMPLETE, so call send_stop_cmd() ====xbw[%s]====\n", \
2465                                                 __FUNCTION__, __LINE__, host->dma_name);
2466
2467                 state = STATE_SENDING_CMD;
2468                 send_stop_cmd(host);
2469                 break;
2470             }
2471
2472             case STATE_SENDING_STOP:
2473             {
2474                 xbwprintk(7, "%s..%d..   prev_state=  STATE_SENDING_STOP, pendingEvernt=0x%lu  ====xbw[%s]====\n", \
2475                                                 __FUNCTION__, __LINE__, host->pending_events, host->dma_name);
2476
2477                 if (!rk29_sdmmc_test_and_clear_pending(host, EVENT_CMD_COMPLETE))
2478                         break;
2479
2480                 rk29_sdmmc_command_complete(host, host->cmd);
2481                 del_timer_sync(&host->request_timer); //delete the timer for INT_CMD_DONE int CMD12
2482                 rk29_sdmmc_request_end(host, host->cmd);
2483
2484                 host->complete_done = 1;
2485                 goto unlock;
2486             }
2487
2488         }
2489         } while(0);
2490
2491         host->state = state;
2492
2493 unlock:
2494     if(0==host->complete_done)
2495     {
2496         spin_unlock(&host->lock);
2497         return;
2498     }
2499
2500          host->state = STATE_IDLE;
2501          spin_unlock(&host->lock);
2502
2503          mmc_request_done(host->mmc, host->mrq);
2504 }
2505
2506
2507 static inline void rk29_sdmmc_cmd_interrupt(struct rk29_sdmmc *host, u32 status)
2508 {
2509     u32 multi, unit;
2510
2511         if(!host->cmd_status)
2512                 host->cmd_status = status;
2513
2514     if((MMC_STOP_TRANSMISSION != host->cmd->opcode) && (host->cmdr & SDMMC_CMD_DAT_EXP))
2515     {
2516         unit = 5*1024*1024;
2517         multi = rk29_sdmmc_read(host->regs, SDMMC_BYTCNT)/unit;
2518         multi += ((rk29_sdmmc_read(host->regs, SDMMC_BYTCNT)%unit) ? 1 :0 );
2519         multi = (multi>0) ? multi : 1;
2520             mod_timer(&host->DTO_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_WAIT_DTO_INTERNVAL*multi));
2521         }
2522
2523         smp_wmb();
2524         rk29_sdmmc_set_pending(host, EVENT_CMD_COMPLETE);
2525         tasklet_schedule(&host->tasklet);
2526 }
2527
2528 static irqreturn_t rk29_sdmmc_interrupt(int irq, void *dev_id)
2529 {
2530         struct rk29_sdmmc       *host = dev_id;
2531         u32                     status,  pending;
2532         bool present;
2533         bool present_old;
2534         unsigned long iflags;
2535
2536         spin_lock_irqsave(&host->lock, iflags);
2537
2538     status = rk29_sdmmc_read(host->regs, SDMMC_RINTSTS);
2539     pending = rk29_sdmmc_read(host->regs, SDMMC_MINTSTS);// read only mask reg
2540     if (!pending)
2541     {
2542         spin_unlock_irqrestore(&host->lock, iflags);
2543         return IRQ_HANDLED;
2544     }
2545
2546
2547     if(pending & SDMMC_INT_CD)
2548     {
2549         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS, SDMMC_INT_CD); // clear sd detect int
2550         present = rk29_sdmmc_get_cd(host->mmc);
2551         present_old = test_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2552
2553         if(present != present_old)
2554         {
2555                 printk("\n******************\n%s:INT_CD=0x%x,INT-En=%d,hostState=%d,  present Old=%d ==> New=%d ==xbw[%s]==\n",\
2556                     __FUNCTION__, pending, host->mmc->re_initialized_flags, host->state, present_old, present,  host->dma_name);
2557
2558             rk28_send_wakeup_key(); //wake up backlight
2559             host->error_times = 0;
2560
2561             #if 1
2562             rk29_sdmmc_dealwith_timeout(host);
2563             #endif
2564
2565             if(present)
2566             {
2567                 set_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2568
2569                 if(host->mmc->re_initialized_flags)
2570                     {
2571                         mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_REMOVAL_DELAY/2));
2572                     }
2573                     else
2574                     {
2575                         mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(RK29_SDMMC_REMOVAL_DELAY*2));
2576                     }
2577             }
2578             else
2579             {
2580                 clear_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2581                 host->mmc->re_initialized_flags = 0;
2582
2583                 mmc_detect_change(host->mmc, 200);
2584             }
2585
2586         }
2587
2588         spin_unlock_irqrestore(&host->lock, iflags);
2589         return IRQ_HANDLED;
2590
2591     }
2592
2593
2594     if (pending & SDMMC_INT_CMD_DONE) {
2595
2596         xbwprintk(6, "%s..%d..  CMD%d INT_CMD_DONE  INT=0x%x   ====xbw[%s]====\n", \
2597                                 __FUNCTION__, __LINE__, host->cmd->opcode,pending, host->dma_name);
2598
2599         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_CMD_DONE);  //  clear interrupt
2600
2601         rk29_sdmmc_cmd_interrupt(host, status);
2602     }
2603
2604     if(pending & SDMMC_INT_SDIO)
2605     {
2606         xbwprintk(7, "%s..%d..  INT_SDIO  INT=0x%x   ====xbw[%s]====\n", \
2607                                 __FUNCTION__, __LINE__, pending, host->dma_name);
2608
2609         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_SDIO);
2610         mmc_signal_sdio_irq(host->mmc);
2611     }
2612
2613
2614     if(pending & SDMMC_INT_RTO)
2615     {
2616         xbwprintk(7, "%s..%d..  CMD%d CMD_ERROR_FLAGS  INT=0x%x   ====xbw[%s]====\n", \
2617                                 __FUNCTION__, __LINE__, host->cmd->opcode,pending, host->dma_name);
2618
2619         //rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_RTO);
2620         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,0xFFFFFFFF); //Modifyed by xbw at 2011-08-15
2621         host->cmd_status = status;
2622         smp_wmb();
2623         rk29_sdmmc_set_pending(host, EVENT_CMD_COMPLETE);
2624
2625         if(!(pending & SDMMC_INT_CMD_DONE))
2626             tasklet_schedule(&host->tasklet);
2627
2628         spin_unlock_irqrestore(&host->lock, iflags);
2629         return IRQ_HANDLED;
2630     }
2631
2632
2633     if(pending & SDMMC_INT_HLE)
2634     {
2635         printk("%s: Error due to hardware locked. Please check your hardware. INT=0x%x, CMD%d(arg=0x%x, retries=%d)==xbw[%s]==\n",\
2636                                 __FUNCTION__, pending,host->cmd->opcode, host->cmd->arg, host->cmd->retries, host->dma_name);
2637
2638         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_HLE);
2639         spin_unlock_irqrestore(&host->lock, iflags);
2640         return IRQ_HANDLED;
2641     }
2642
2643
2644     if(pending & SDMMC_INT_DTO)
2645     {
2646         xbwprintk(7, "%s..%d..  CMD%d  INT_DTO  INT=0x%x   ==xbw[%s]==\n", \
2647                                 __FUNCTION__, __LINE__,host->cmd->opcode,pending, host->dma_name);
2648
2649         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_DTO);
2650         del_timer_sync(&host->DTO_timer); //delete the timer for INT_DTO
2651
2652         if (!host->data_status)
2653                 host->data_status = status;
2654
2655         smp_wmb();
2656
2657         rk29_sdmmc_set_pending(host, EVENT_DATA_COMPLETE);
2658         tasklet_schedule(&host->tasklet);
2659
2660         spin_unlock_irqrestore(&host->lock, iflags);
2661         return IRQ_HANDLED;
2662     }
2663
2664
2665     if (pending & SDMMC_INT_FRUN)
2666     {
2667         printk("%s: INT=0x%x Oh!My God,let me see!What happened?Why?Where? CMD%d(arg=0x%x, retries=%d) ==xbw[%s]==\n", \
2668                                 __FUNCTION__, pending, host->cmd->opcode, host->cmd->arg, host->cmd->retries,host->dma_name);
2669
2670         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_FRUN);
2671         spin_unlock_irqrestore(&host->lock, iflags);
2672         return IRQ_HANDLED;
2673     }
2674
2675     if (pending & SDMMC_INT_RXDR)
2676     {
2677         xbwprintk(6, "%s..%d..  SDMMC_INT_RXDR  INT=0x%x   ====xbw[%s]====\n", \
2678                                 __FUNCTION__, __LINE__, pending, host->dma_name);
2679
2680         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_RXDR);  //  clear interrupt
2681         rk29_sdmmc_do_pio_read(host);
2682     }
2683
2684     if (pending & SDMMC_INT_TXDR)
2685     {
2686         xbwprintk(6, "%s..%d..  SDMMC_INT_TXDR  INT=0x%x   ====xbw[%s]====\n", \
2687                                 __FUNCTION__, __LINE__, pending, host->dma_name);
2688
2689         rk29_sdmmc_do_pio_write(host);
2690
2691         rk29_sdmmc_write(host->regs, SDMMC_RINTSTS,SDMMC_INT_TXDR);  //  clear interrupt
2692     }
2693
2694         spin_unlock_irqrestore(&host->lock, iflags);
2695         return IRQ_HANDLED;
2696 }
2697
2698 /*
2699  *
2700  * MMC card detect thread, kicked off from detect interrupt, 1 timer
2701  *
2702  */
2703 static void rk29_sdmmc_detect_change(unsigned long data)
2704 {
2705         struct rk29_sdmmc *host = (struct rk29_sdmmc *)data;
2706
2707         if(!host->mmc)
2708             return;
2709
2710         smp_rmb();
2711
2712     if(RK29_CTRL_SDMMC_ID == host->pdev->id)
2713     {
2714         host->mmc->re_initialized_flags =1;
2715     }
2716
2717         mmc_detect_change(host->mmc, 0);
2718
2719 }
2720
2721 static void rk29_sdmmc1_check_status(unsigned long data)
2722 {
2723         struct rk29_sdmmc *host = (struct rk29_sdmmc *)data;
2724         struct rk29_sdmmc_platform_data *pdata = host->pdev->dev.platform_data;
2725         unsigned int status;
2726
2727     status = pdata->status(mmc_dev(host->mmc));
2728
2729     if (status ^ host->oldstatus)
2730     {
2731         pr_info("%s: slot status change detected(%d-%d)\n",mmc_hostname(host->mmc), host->oldstatus, status);
2732         if (status)
2733         {
2734             set_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2735             mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(200));
2736         }
2737         else
2738         {
2739             clear_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2740             rk29_sdmmc_detect_change((unsigned long)host);
2741         }
2742     }
2743
2744     host->oldstatus = status;
2745 }
2746
2747 static void rk29_sdmmc1_status_notify_cb(int card_present, void *dev_id)
2748 {
2749         struct rk29_sdmmc *host = dev_id;
2750         printk(KERN_INFO "%s, card_present %d\n", mmc_hostname(host->mmc), card_present);
2751         rk29_sdmmc1_check_status((unsigned long)host);
2752 }
2753
2754
2755 static int rk29_sdmmc_probe(struct platform_device *pdev)
2756 {
2757         struct mmc_host                 *mmc;
2758         struct rk29_sdmmc               *host;
2759         struct resource                 *regs;
2760         struct rk29_sdmmc_platform_data *pdata;
2761         int                             irq;
2762         int                             ret = 0;
2763
2764     /* must have platform data */
2765         pdata = pdev->dev.platform_data;
2766         if (!pdata) {
2767                 dev_err(&pdev->dev, "Platform data missing\n");
2768                 ret = -ENODEV;
2769                 host->errorstep = 0x87;
2770                 goto out;
2771         }
2772
2773         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2774         if (!regs)
2775         {
2776             host->errorstep = 0x88;
2777                 return -ENXIO;
2778         }
2779
2780         mmc = mmc_alloc_host(sizeof(struct rk29_sdmmc), &pdev->dev);
2781         if (!mmc)
2782         {
2783             host->errorstep = 0x89;
2784                 ret = -ENOMEM;
2785                 goto rel_regions;
2786         }
2787
2788         host = mmc_priv(mmc);
2789         host->mmc = mmc;
2790         host->pdev = pdev;
2791
2792         host->ctype = 0; // set default 1 bit mode
2793         host->errorstep = 0;
2794         host->bus_mode = 5;
2795         host->old_cmd = 100;
2796         host->clock =0;
2797         host->old_div = 0xFF;
2798         host->error_times = 0;
2799         host->state = STATE_IDLE;
2800         host->complete_done = 0;
2801
2802 #ifdef CONFIG_PM
2803     host->gpio_det = pdata->detect_irq;
2804 #endif
2805
2806         if(pdata->io_init)
2807                 pdata->io_init();
2808
2809         spin_lock_init(&host->lock);
2810     spin_lock_init(&host->request_lock);
2811
2812 #ifdef RK29_SDMMC_LIST_QUEUE
2813         INIT_LIST_HEAD(&host->queue);
2814 #endif
2815
2816         host->clk = clk_get(&pdev->dev, "mmc");
2817
2818 #if RK29_SDMMC_DEFAULT_SDIO_FREQ
2819     clk_set_rate(host->clk,SDHC_FPP_FREQ);
2820 #else
2821     if(RK29_CTRL_SDMMC_ID== host->pdev->id)
2822             clk_set_rate(host->clk,SDHC_FPP_FREQ);
2823         else
2824             clk_set_rate(host->clk,RK29_MAX_SDIO_FREQ);
2825
2826 #endif
2827
2828         clk_enable(host->clk);
2829         clk_enable(clk_get(&pdev->dev, "hclk_mmc"));
2830
2831         ret = -ENOMEM;
2832         host->regs = ioremap(regs->start, regs->end - regs->start + 1);
2833         if (!host->regs)
2834         {
2835             host->errorstep = 0x8A;
2836             goto err_freemap;
2837         }
2838
2839     mmc->ops = &rk29_sdmmc_ops[pdev->id];
2840         mmc->f_min = FOD_FREQ;
2841
2842 #if RK29_SDMMC_DEFAULT_SDIO_FREQ
2843     mmc->f_max = SDHC_FPP_FREQ;
2844 #else
2845     if(RK29_CTRL_SDMMC_ID== host->pdev->id)
2846     {
2847         mmc->f_max = SDHC_FPP_FREQ;
2848     }
2849     else
2850     {
2851         mmc->f_max = RK29_MAX_SDIO_FREQ;//SDHC_FPP_FREQ / 2;
2852     }
2853
2854 #endif
2855         //mmc->ocr_avail = pdata->host_ocr_avail;
2856         mmc->ocr_avail = MMC_VDD_27_28|MMC_VDD_28_29|MMC_VDD_29_30|MMC_VDD_30_31
2857                      | MMC_VDD_31_32|MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_34_35| MMC_VDD_35_36;    ///set valid volage 2.7---3.6v
2858         mmc->caps = pdata->host_caps;
2859         mmc->re_initialized_flags = 1;
2860
2861     /*
2862          * We can do SGIO
2863         */
2864         mmc->max_phys_segs = 64;
2865         mmc->max_hw_segs = 64;
2866
2867         /*
2868          * Block size can be up to 2048 bytes, but must be a power of two.
2869         */
2870         mmc->max_blk_size = 4095;
2871
2872         /*
2873          * No limit on the number of blocks transferred.
2874         */
2875         mmc->max_blk_count = 4096;
2876
2877         /*
2878          * Since we only have a 16-bit data length register, we must
2879          * ensure that we don't exceed 2^16-1 bytes in a single request.
2880         */
2881         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; //8M bytes(2K*4K)
2882
2883     /*
2884          * Set the maximum segment size.  Since we aren't doing DMA
2885          * (yet) we are only limited by the data length register.
2886         */
2887         mmc->max_seg_size = mmc->max_req_size;
2888
2889         tasklet_init(&host->tasklet, rk29_sdmmc_tasklet_func, (unsigned long)host);
2890
2891         irq = platform_get_irq(pdev, 0);
2892         if (irq < 0)
2893         {
2894             host->errorstep = 0x8B;
2895                 ret = -EINVAL;
2896                 goto err_freemap;
2897         }
2898
2899     memcpy(host->dma_name, pdata->dma_name, 8);
2900         host->use_dma = pdata->use_dma;
2901
2902         /*DMA init*/
2903         if(host->use_dma)
2904         {
2905         host->dma_info = rk29_sdmmc_dma_infos[host->pdev->id];
2906         ret = rk29_dma_request(host->dma_info.chn, &(host->dma_info.client), NULL);
2907         if (ret < 0)
2908         {
2909                 printk("%s..%d...rk29_dma_request error=%d.===xbw[%s]====\n", \
2910                                         __FUNCTION__, __LINE__,ret, host->dma_name);
2911                 host->errorstep = 0x97;
2912             goto err_freemap;
2913         }
2914
2915 #if 0  //deal with the old API of DMA-module
2916                 ret = rk29_dma_config(host->dma_info.chn, 4);
2917 #else  //deal with the new API of DMA-module
2918         if(RK29_CTRL_SDMMC_ID== host->pdev->id)
2919         {
2920             ret = rk29_dma_config(host->dma_info.chn, 4, 16);
2921         }
2922         else
2923         {
2924             ret = rk29_dma_config(host->dma_info.chn, 4, 1);
2925         }
2926 #endif
2927         if(ret < 0)
2928                 {
2929             printk("%s..%d..  rk29_dma_config error=%d ====xbw[%s]====\n", \
2930                                         __FUNCTION__, __LINE__, ret, host->dma_name);
2931             host->errorstep = 0x98;
2932             goto err_dmaunmap;
2933                 }
2934
2935         ret = rk29_dma_set_buffdone_fn(host->dma_info.chn, rk29_sdmmc_dma_complete);
2936                 if(ret < 0)
2937                 {
2938             printk("%s..%d..  dma_set_buffdone_fn error=%d ====xbw[%s]====\n", \
2939                                         __FUNCTION__, __LINE__, ret, host->dma_name);
2940             host->errorstep = 0x99;
2941             goto err_dmaunmap;
2942                 }
2943
2944                 host->dma_addr = regs->start + SDMMC_DATA;
2945         }
2946
2947     rk29_sdmmc_hw_init(host);
2948
2949     ret = request_irq(irq, rk29_sdmmc_interrupt, 0, dev_name(&pdev->dev), host);
2950         if (ret)
2951         {
2952
2953             printk("%s..%d..  request_irq error=%d ====xbw[%s]====\n", \
2954                                 __FUNCTION__, __LINE__, ret, host->dma_name);
2955             host->errorstep = 0x8C;
2956             goto err_dmaunmap;
2957         }
2958
2959     /* setup sdmmc1 wifi card detect change */
2960     if (pdata->register_status_notify) {
2961         pdata->register_status_notify(rk29_sdmmc1_status_notify_cb, host);
2962     }
2963
2964     if(RK29_CTRL_SDMMC_ID== host->pdev->id)
2965     {
2966         clear_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2967     }
2968
2969
2970     /* sdmmc1 wifi card slot status initially */
2971     if (pdata->status) {
2972         host->oldstatus = pdata->status(mmc_dev(host->mmc));
2973         if (host->oldstatus)  {
2974             set_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2975         }else {
2976             clear_bit(RK29_SDMMC_CARD_PRESENT, &host->flags);
2977         }
2978     }
2979
2980     /* Create card detect handler thread  */
2981         setup_timer(&host->detect_timer, rk29_sdmmc_detect_change,(unsigned long)host);
2982         setup_timer(&host->request_timer,rk29_sdmmc_INT_CMD_DONE_timeout,(unsigned long)host);
2983         setup_timer(&host->DTO_timer,rk29_sdmmc_INT_DTO_timeout,(unsigned long)host);
2984
2985         platform_set_drvdata(pdev, mmc);
2986
2987         mmc_add_host(mmc);
2988
2989 #ifdef RK29_SDMMC_NOTIFY_REMOVE_INSERTION
2990
2991     globalSDhost[pdev->id] = (struct rk29_sdmmc *)host;
2992     if(RK29_CTRL_SDMMC_ID== host->pdev->id)
2993     {
2994         rk29_sdmmc_progress_add_attr(pdev);
2995     }
2996 #endif
2997
2998 #if defined (CONFIG_DEBUG_FS)
2999         rk29_sdmmc_init_debugfs(host);
3000 #endif
3001
3002     printk(".Line%d..The End of SDMMC-probe %s ===xbw[%s]===\n\n", __LINE__, RK29_SDMMC_VERSION,host->dma_name);
3003         return 0;
3004
3005
3006 err_dmaunmap:
3007         if(host->use_dma)
3008         {
3009             rk29_dma_free(host->dma_info.chn, &host->dma_info.client);
3010         }
3011
3012 err_freemap:
3013         iounmap(host->regs);
3014
3015 rel_regions:
3016     mmc_free_host(mmc);
3017
3018 out:
3019
3020         return ret;
3021 }
3022
3023
3024
3025 static int __exit rk29_sdmmc_remove(struct platform_device *pdev)
3026 {
3027
3028     struct mmc_host *mmc = platform_get_drvdata(pdev);
3029     struct rk29_sdmmc *host;
3030     struct resource             *regs;
3031
3032     if (!mmc)
3033         return -1;
3034
3035     host = mmc_priv(mmc);
3036
3037         smp_wmb();
3038     rk29_sdmmc_control_clock(host, 0);
3039
3040     /* Shutdown detect IRQ and kill detect thread */
3041         del_timer_sync(&host->detect_timer);
3042         del_timer_sync(&host->request_timer);
3043         del_timer_sync(&host->DTO_timer);
3044
3045         tasklet_disable(&host->tasklet);
3046         free_irq(platform_get_irq(pdev, 0), host);
3047         if(host->use_dma)
3048         {
3049                 rk29_dma_free(host->dma_info.chn, &host->dma_info.client);
3050         }
3051
3052         mmc_remove_host(mmc);
3053
3054         iounmap(host->regs);
3055
3056         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3057         release_mem_region(regs->start,resource_size(regs));
3058
3059     mmc_free_host(mmc);
3060     platform_set_drvdata(pdev, NULL);
3061
3062         return 0;
3063 }
3064
3065
3066 #ifdef CONFIG_PM
3067
3068 static irqreturn_t det_keys_isr(int irq, void *dev_id)
3069 {
3070         struct rk29_sdmmc *host = dev_id;
3071         dev_info(&host->pdev->dev, "sd det_gpio changed(%s), send wakeup key!\n",
3072                 gpio_get_value(RK29_PIN2_PA2)?"removed":"insert");
3073         rk29_sdmmc_detect_change((unsigned long)dev_id);
3074
3075         return IRQ_HANDLED;
3076 }
3077
3078 static int rk29_sdmmc_sdcard_suspend(struct rk29_sdmmc *host)
3079 {
3080         int ret = 0;
3081         rk29_mux_api_set(GPIO2A2_SDMMC0DETECTN_NAME, GPIO2L_GPIO2A2);
3082         gpio_request(RK29_PIN2_PA2, "sd_detect");
3083         gpio_direction_input(RK29_PIN2_PA2);
3084
3085         host->gpio_irq = gpio_to_irq(RK29_PIN2_PA2);
3086         ret = request_irq(host->gpio_irq, det_keys_isr,
3087                                             (gpio_get_value(RK29_PIN2_PA2))?IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING,
3088                                             "sd_detect",
3089                                             host);
3090
3091         enable_irq_wake(host->gpio_irq);
3092
3093         return ret;
3094 }
3095 static void rk29_sdmmc_sdcard_resume(struct rk29_sdmmc *host)
3096 {
3097         disable_irq_wake(host->gpio_irq);
3098         free_irq(host->gpio_irq,host);
3099         gpio_free(RK29_PIN2_PA2);
3100         rk29_mux_api_set(GPIO2A2_SDMMC0DETECTN_NAME, GPIO2L_SDMMC0_DETECT_N);
3101 }
3102
3103
3104
3105 static int rk29_sdmmc_suspend(struct platform_device *pdev, pm_message_t state)
3106 {
3107     struct mmc_host *mmc = platform_get_drvdata(pdev);
3108     struct rk29_sdmmc *host = mmc_priv(mmc);
3109     int ret = 0;
3110
3111     if(host && host->pdev && (RK29_CTRL_SDMMC_ID == host->pdev->id)) //only the SDMMC0 have suspend-resume; noted by xbw
3112     {
3113         if (mmc)
3114             ret = mmc_suspend_host(mmc, state);
3115
3116         if(rk29_sdmmc_sdcard_suspend(host) < 0)
3117                         dev_info(&host->pdev->dev, "rk29_sdmmc_sdcard_suspend error\n");
3118     }
3119
3120     return ret;
3121 }
3122
3123 static int rk29_sdmmc_resume(struct platform_device *pdev)
3124 {
3125     struct mmc_host *mmc = platform_get_drvdata(pdev);
3126     struct rk29_sdmmc *host = mmc_priv(mmc);
3127     int ret = 0;
3128
3129     if(host && host->pdev && (RK29_CTRL_SDMMC_ID == host->pdev->id)) //only the SDMMC0 have suspend-resume; noted by xbw
3130     {
3131         if (mmc)
3132         {
3133             rk29_sdmmc_sdcard_resume(host);
3134                 ret = mmc_resume_host(mmc);
3135         }
3136         }
3137
3138         return ret;
3139 }
3140 #else
3141 #define rk29_sdmmc_suspend      NULL
3142 #define rk29_sdmmc_resume       NULL
3143 #endif
3144
3145 static struct platform_driver rk29_sdmmc_driver = {
3146         .suspend    = rk29_sdmmc_suspend,
3147         .resume     = rk29_sdmmc_resume,
3148         .remove         = __exit_p(rk29_sdmmc_remove),
3149         .driver         = {
3150                 .name           = "rk29_sdmmc",
3151         },
3152 };
3153
3154 static int __init rk29_sdmmc_init(void)
3155 {
3156         return platform_driver_probe(&rk29_sdmmc_driver, rk29_sdmmc_probe);
3157 }
3158
3159 static void __exit rk29_sdmmc_exit(void)
3160 {
3161         platform_driver_unregister(&rk29_sdmmc_driver);
3162 }
3163
3164 module_init(rk29_sdmmc_init);
3165 module_exit(rk29_sdmmc_exit);
3166
3167 MODULE_DESCRIPTION("Rk29 Multimedia Card Interface driver");
3168 MODULE_AUTHOR("xbw@rock-chips.com");
3169 MODULE_LICENSE("GPL v2");
3170