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