drivers/mmc/host/rk29_sdmmc.c

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