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