drivers/mmc/host/rk29_sdmmc.c

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