Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/mmc/host/dw_mmc.c

  1 /*
  2  * Synopsys DesignWare Multimedia Card Interface driver
  3  *  (Based on NXP driver for lpc 31xx)
  4  *
  5  * Copyright (C) 2009 NXP Semiconductors
  6  * Copyright (C) 2009, 2010 Imagination Technologies Ltd.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  */
 13 
 14 #include <linux/blkdev.h>
 15 #include <linux/clk.h>
 16 #include <linux/debugfs.h>
 17 #include <linux/device.h>
 18 #include <linux/dma-mapping.h>
 19 #include <linux/err.h>
 20 #include <linux/init.h>
 21 #include <linux/interrupt.h>
 22 #include <linux/ioport.h>
 23 #include <linux/module.h>
 24 #include <linux/platform_device.h>
 25 #include <linux/seq_file.h>
 26 #include <linux/slab.h>
 27 #include <linux/stat.h>
 28 #include <linux/delay.h>
 29 #include <linux/irq.h>
 30 #include <linux/mmc/host.h>
 31 #include <linux/mmc/mmc.h>
 32 #include <linux/mmc/sdio.h>
 33 #include <linux/mmc/dw_mmc.h>
 34 #include <linux/bitops.h>
 35 #include <linux/regulator/consumer.h>
 36 #include <linux/workqueue.h>
 37 #include <linux/of.h>
 38 #include <linux/of_gpio.h>
 39 #include <linux/mmc/slot-gpio.h>
 40 
 41 #include "dw_mmc.h"
 42 
 43 /* Common flag combinations */
 44 #define DW_MCI_DATA_ERROR_FLAGS (SDMMC_INT_DRTO | SDMMC_INT_DCRC | \
 45                                  SDMMC_INT_HTO | SDMMC_INT_SBE  | \
 46                                  SDMMC_INT_EBE)
 47 #define DW_MCI_CMD_ERROR_FLAGS  (SDMMC_INT_RTO | SDMMC_INT_RCRC | \
 48                                  SDMMC_INT_RESP_ERR)
 49 #define DW_MCI_ERROR_FLAGS      (DW_MCI_DATA_ERROR_FLAGS | \
 50                                  DW_MCI_CMD_ERROR_FLAGS  | SDMMC_INT_HLE)
 51 #define DW_MCI_SEND_STATUS      1
 52 #define DW_MCI_RECV_STATUS      2
 53 #define DW_MCI_DMA_THRESHOLD    16
 54 
 55 #define DW_MCI_FREQ_MAX 200000000       /* unit: HZ */
 56 #define DW_MCI_FREQ_MIN 400000          /* unit: HZ */
 57 
 58 #ifdef CONFIG_MMC_DW_IDMAC
 59 #define IDMAC_INT_CLR           (SDMMC_IDMAC_INT_AI | SDMMC_IDMAC_INT_NI | \
 60                                  SDMMC_IDMAC_INT_CES | SDMMC_IDMAC_INT_DU | \
 61                                  SDMMC_IDMAC_INT_FBE | SDMMC_IDMAC_INT_RI | \
 62                                  SDMMC_IDMAC_INT_TI)
 63 
 64 struct idmac_desc {
 65         u32             des0;   /* Control Descriptor */
 66 #define IDMAC_DES0_DIC  BIT(1)
 67 #define IDMAC_DES0_LD   BIT(2)
 68 #define IDMAC_DES0_FD   BIT(3)
 69 #define IDMAC_DES0_CH   BIT(4)
 70 #define IDMAC_DES0_ER   BIT(5)
 71 #define IDMAC_DES0_CES  BIT(30)
 72 #define IDMAC_DES0_OWN  BIT(31)
 73 
 74         u32             des1;   /* Buffer sizes */
 75 #define IDMAC_SET_BUFFER1_SIZE(d, s) \
 76         ((d)->des1 = ((d)->des1 & 0x03ffe000) | ((s) & 0x1fff))
 77 
 78         u32             des2;   /* buffer 1 physical address */
 79 
 80         u32             des3;   /* buffer 2 physical address */
 81 };
 82 #endif /* CONFIG_MMC_DW_IDMAC */
 83 
 84 static const u8 tuning_blk_pattern_4bit[] = {
 85         0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
 86         0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
 87         0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
 88         0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
 89         0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
 90         0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
 91         0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
 92         0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
 93 };
 94 
 95 static const u8 tuning_blk_pattern_8bit[] = {
 96         0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
 97         0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
 98         0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
 99         0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
100         0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
101         0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
102         0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
103         0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
104         0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
105         0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
106         0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
107         0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
108         0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
109         0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
110         0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
111         0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
112 };
113 
114 static inline bool dw_mci_fifo_reset(struct dw_mci *host);
115 static inline bool dw_mci_ctrl_all_reset(struct dw_mci *host);
116 
117 #if defined(CONFIG_DEBUG_FS)
118 static int dw_mci_req_show(struct seq_file *s, void *v)
119 {
120         struct dw_mci_slot *slot = s->private;
121         struct mmc_request *mrq;
122         struct mmc_command *cmd;
123         struct mmc_command *stop;
124         struct mmc_data *data;
125 
126         /* Make sure we get a consistent snapshot */
127         spin_lock_bh(&slot->host->lock);
128         mrq = slot->mrq;
129 
130         if (mrq) {
131                 cmd = mrq->cmd;
132                 data = mrq->data;
133                 stop = mrq->stop;
134 
135                 if (cmd)
136                         seq_printf(s,
137                                    "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
138                                    cmd->opcode, cmd->arg, cmd->flags,
139                                    cmd->resp[0], cmd->resp[1], cmd->resp[2],
140                                    cmd->resp[2], cmd->error);
141                 if (data)
142                         seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
143                                    data->bytes_xfered, data->blocks,
144                                    data->blksz, data->flags, data->error);
145                 if (stop)
146                         seq_printf(s,
147                                    "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
148                                    stop->opcode, stop->arg, stop->flags,
149                                    stop->resp[0], stop->resp[1], stop->resp[2],
150                                    stop->resp[2], stop->error);
151         }
152 
153         spin_unlock_bh(&slot->host->lock);
154 
155         return 0;
156 }
157 
158 static int dw_mci_req_open(struct inode *inode, struct file *file)
159 {
160         return single_open(file, dw_mci_req_show, inode->i_private);
161 }
162 
163 static const struct file_operations dw_mci_req_fops = {
164         .owner          = THIS_MODULE,
165         .open           = dw_mci_req_open,
166         .read           = seq_read,
167         .llseek         = seq_lseek,
168         .release        = single_release,
169 };
170 
171 static int dw_mci_regs_show(struct seq_file *s, void *v)
172 {
173         seq_printf(s, "STATUS:\t0x%08x\n", SDMMC_STATUS);
174         seq_printf(s, "RINTSTS:\t0x%08x\n", SDMMC_RINTSTS);
175         seq_printf(s, "CMD:\t0x%08x\n", SDMMC_CMD);
176         seq_printf(s, "CTRL:\t0x%08x\n", SDMMC_CTRL);
177         seq_printf(s, "INTMASK:\t0x%08x\n", SDMMC_INTMASK);
178         seq_printf(s, "CLKENA:\t0x%08x\n", SDMMC_CLKENA);
179 
180         return 0;
181 }
182 
183 static int dw_mci_regs_open(struct inode *inode, struct file *file)
184 {
185         return single_open(file, dw_mci_regs_show, inode->i_private);
186 }
187 
188 static const struct file_operations dw_mci_regs_fops = {
189         .owner          = THIS_MODULE,
190         .open           = dw_mci_regs_open,
191         .read           = seq_read,
192         .llseek         = seq_lseek,
193         .release        = single_release,
194 };
195 
196 static void dw_mci_init_debugfs(struct dw_mci_slot *slot)
197 {
198         struct mmc_host *mmc = slot->mmc;
199         struct dw_mci *host = slot->host;
200         struct dentry *root;
201         struct dentry *node;
202 
203         root = mmc->debugfs_root;
204         if (!root)
205                 return;
206 
207         node = debugfs_create_file("regs", S_IRUSR, root, host,
208                                    &dw_mci_regs_fops);
209         if (!node)
210                 goto err;
211 
212         node = debugfs_create_file("req", S_IRUSR, root, slot,
213                                    &dw_mci_req_fops);
214         if (!node)
215                 goto err;
216 
217         node = debugfs_create_u32("state", S_IRUSR, root, (u32 *)&host->state);
218         if (!node)
219                 goto err;
220 
221         node = debugfs_create_x32("pending_events", S_IRUSR, root,
222                                   (u32 *)&host->pending_events);
223         if (!node)
224                 goto err;
225 
226         node = debugfs_create_x32("completed_events", S_IRUSR, root,
227                                   (u32 *)&host->completed_events);
228         if (!node)
229                 goto err;
230 
231         return;
232 
233 err:
234         dev_err(&mmc->class_dev, "failed to initialize debugfs for slot\n");
235 }
236 #endif /* defined(CONFIG_DEBUG_FS) */
237 
238 static void dw_mci_set_timeout(struct dw_mci *host)
239 {
240         /* timeout (maximum) */
241         mci_writel(host, TMOUT, 0xffffffff);
242 }
243 
244 static u32 dw_mci_prepare_command(struct mmc_host *mmc, struct mmc_command *cmd)
245 {
246         struct mmc_data *data;
247         struct dw_mci_slot *slot = mmc_priv(mmc);
248         const struct dw_mci_drv_data *drv_data = slot->host->drv_data;
249         u32 cmdr;
250         cmd->error = -EINPROGRESS;
251 
252         cmdr = cmd->opcode;
253 
254         if (cmd->opcode == MMC_STOP_TRANSMISSION ||
255             cmd->opcode == MMC_GO_IDLE_STATE ||
256             cmd->opcode == MMC_GO_INACTIVE_STATE ||
257             (cmd->opcode == SD_IO_RW_DIRECT &&
258              ((cmd->arg >> 9) & 0x1FFFF) == SDIO_CCCR_ABORT))
259                 cmdr |= SDMMC_CMD_STOP;
260         else
261                 if (cmd->opcode != MMC_SEND_STATUS && cmd->data)
262                         cmdr |= SDMMC_CMD_PRV_DAT_WAIT;
263 
264         if (cmd->flags & MMC_RSP_PRESENT) {
265                 /* We expect a response, so set this bit */
266                 cmdr |= SDMMC_CMD_RESP_EXP;
267                 if (cmd->flags & MMC_RSP_136)
268                         cmdr |= SDMMC_CMD_RESP_LONG;
269         }
270 
271         if (cmd->flags & MMC_RSP_CRC)
272                 cmdr |= SDMMC_CMD_RESP_CRC;
273 
274         data = cmd->data;
275         if (data) {
276                 cmdr |= SDMMC_CMD_DAT_EXP;
277                 if (data->flags & MMC_DATA_STREAM)
278                         cmdr |= SDMMC_CMD_STRM_MODE;
279                 if (data->flags & MMC_DATA_WRITE)
280                         cmdr |= SDMMC_CMD_DAT_WR;
281         }
282 
283         if (drv_data && drv_data->prepare_command)
284                 drv_data->prepare_command(slot->host, &cmdr);
285 
286         return cmdr;
287 }
288 
289 static u32 dw_mci_prep_stop_abort(struct dw_mci *host, struct mmc_command *cmd)
290 {
291         struct mmc_command *stop;
292         u32 cmdr;
293 
294         if (!cmd->data)
295                 return 0;
296 
297         stop = &host->stop_abort;
298         cmdr = cmd->opcode;
299         memset(stop, 0, sizeof(struct mmc_command));
300 
301         if (cmdr == MMC_READ_SINGLE_BLOCK ||
302             cmdr == MMC_READ_MULTIPLE_BLOCK ||
303             cmdr == MMC_WRITE_BLOCK ||
304             cmdr == MMC_WRITE_MULTIPLE_BLOCK) {
305                 stop->opcode = MMC_STOP_TRANSMISSION;
306                 stop->arg = 0;
307                 stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
308         } else if (cmdr == SD_IO_RW_EXTENDED) {
309                 stop->opcode = SD_IO_RW_DIRECT;
310                 stop->arg |= (1 << 31) | (0 << 28) | (SDIO_CCCR_ABORT << 9) |
311                              ((cmd->arg >> 28) & 0x7);
312                 stop->flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
313         } else {
314                 return 0;
315         }
316 
317         cmdr = stop->opcode | SDMMC_CMD_STOP |
318                 SDMMC_CMD_RESP_CRC | SDMMC_CMD_RESP_EXP;
319 
320         return cmdr;
321 }
322 
323 static void dw_mci_start_command(struct dw_mci *host,
324                                  struct mmc_command *cmd, u32 cmd_flags)
325 {
326         host->cmd = cmd;
327         dev_vdbg(host->dev,
328                  "start command: ARGR=0x%08x CMDR=0x%08x\n",
329                  cmd->arg, cmd_flags);
330 
331         mci_writel(host, CMDARG, cmd->arg);
332         wmb();
333 
334         mci_writel(host, CMD, cmd_flags | SDMMC_CMD_START);
335 }
336 
337 static inline void send_stop_abort(struct dw_mci *host, struct mmc_data *data)
338 {
339         struct mmc_command *stop = data->stop ? data->stop : &host->stop_abort;
340         dw_mci_start_command(host, stop, host->stop_cmdr);
341 }
342 
343 /* DMA interface functions */
344 static void dw_mci_stop_dma(struct dw_mci *host)
345 {
346         if (host->using_dma) {
347                 host->dma_ops->stop(host);
348                 host->dma_ops->cleanup(host);
349         }
350 
351         /* Data transfer was stopped by the interrupt handler */
352         set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
353 }
354 
355 static int dw_mci_get_dma_dir(struct mmc_data *data)
356 {
357         if (data->flags & MMC_DATA_WRITE)
358                 return DMA_TO_DEVICE;
359         else
360                 return DMA_FROM_DEVICE;
361 }
362 
363 #ifdef CONFIG_MMC_DW_IDMAC
364 static void dw_mci_dma_cleanup(struct dw_mci *host)
365 {
366         struct mmc_data *data = host->data;
367 
368         if (data)
369                 if (!data->host_cookie)
370                         dma_unmap_sg(host->dev,
371                                      data->sg,
372                                      data->sg_len,
373                                      dw_mci_get_dma_dir(data));
374 }
375 
376 static void dw_mci_idmac_reset(struct dw_mci *host)
377 {
378         u32 bmod = mci_readl(host, BMOD);
379         /* Software reset of DMA */
380         bmod |= SDMMC_IDMAC_SWRESET;
381         mci_writel(host, BMOD, bmod);
382 }
383 
384 static void dw_mci_idmac_stop_dma(struct dw_mci *host)
385 {
386         u32 temp;
387 
388         /* Disable and reset the IDMAC interface */
389         temp = mci_readl(host, CTRL);
390         temp &= ~SDMMC_CTRL_USE_IDMAC;
391         temp |= SDMMC_CTRL_DMA_RESET;
392         mci_writel(host, CTRL, temp);
393 
394         /* Stop the IDMAC running */
395         temp = mci_readl(host, BMOD);
396         temp &= ~(SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB);
397         temp |= SDMMC_IDMAC_SWRESET;
398         mci_writel(host, BMOD, temp);
399 }
400 
401 static void dw_mci_idmac_complete_dma(struct dw_mci *host)
402 {
403         struct mmc_data *data = host->data;
404 
405         dev_vdbg(host->dev, "DMA complete\n");
406 
407         host->dma_ops->cleanup(host);
408 
409         /*
410          * If the card was removed, data will be NULL. No point in trying to
411          * send the stop command or waiting for NBUSY in this case.
412          */
413         if (data) {
414                 set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
415                 tasklet_schedule(&host->tasklet);
416         }
417 }
418 
419 static void dw_mci_translate_sglist(struct dw_mci *host, struct mmc_data *data,
420                                     unsigned int sg_len)
421 {
422         int i;
423         struct idmac_desc *desc = host->sg_cpu;
424 
425         for (i = 0; i < sg_len; i++, desc++) {
426                 unsigned int length = sg_dma_len(&data->sg[i]);
427                 u32 mem_addr = sg_dma_address(&data->sg[i]);
428 
429                 /* Set the OWN bit and disable interrupts for this descriptor */
430                 desc->des0 = IDMAC_DES0_OWN | IDMAC_DES0_DIC | IDMAC_DES0_CH;
431 
432                 /* Buffer length */
433                 IDMAC_SET_BUFFER1_SIZE(desc, length);
434 
435                 /* Physical address to DMA to/from */
436                 desc->des2 = mem_addr;
437         }
438 
439         /* Set first descriptor */
440         desc = host->sg_cpu;
441         desc->des0 |= IDMAC_DES0_FD;
442 
443         /* Set last descriptor */
444         desc = host->sg_cpu + (i - 1) * sizeof(struct idmac_desc);
445         desc->des0 &= ~(IDMAC_DES0_CH | IDMAC_DES0_DIC);
446         desc->des0 |= IDMAC_DES0_LD;
447 
448         wmb();
449 }
450 
451 static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
452 {
453         u32 temp;
454 
455         dw_mci_translate_sglist(host, host->data, sg_len);
456 
457         /* Select IDMAC interface */
458         temp = mci_readl(host, CTRL);
459         temp |= SDMMC_CTRL_USE_IDMAC;
460         mci_writel(host, CTRL, temp);
461 
462         wmb();
463 
464         /* Enable the IDMAC */
465         temp = mci_readl(host, BMOD);
466         temp |= SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB;
467         mci_writel(host, BMOD, temp);
468 
469         /* Start it running */
470         mci_writel(host, PLDMND, 1);
471 }
472 
473 static int dw_mci_idmac_init(struct dw_mci *host)
474 {
475         struct idmac_desc *p;
476         int i;
477 
478         /* Number of descriptors in the ring buffer */
479         host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
480 
481         /* Forward link the descriptor list */
482         for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
483                 p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
484 
485         /* Set the last descriptor as the end-of-ring descriptor */
486         p->des3 = host->sg_dma;
487         p->des0 = IDMAC_DES0_ER;
488 
489         dw_mci_idmac_reset(host);
490 
491         /* Mask out interrupts - get Tx & Rx complete only */
492         mci_writel(host, IDSTS, IDMAC_INT_CLR);
493         mci_writel(host, IDINTEN, SDMMC_IDMAC_INT_NI | SDMMC_IDMAC_INT_RI |
494                    SDMMC_IDMAC_INT_TI);
495 
496         /* Set the descriptor base address */
497         mci_writel(host, DBADDR, host->sg_dma);
498         return 0;
499 }
500 
501 static const struct dw_mci_dma_ops dw_mci_idmac_ops = {
502         .init = dw_mci_idmac_init,
503         .start = dw_mci_idmac_start_dma,
504         .stop = dw_mci_idmac_stop_dma,
505         .complete = dw_mci_idmac_complete_dma,
506         .cleanup = dw_mci_dma_cleanup,
507 };
508 #endif /* CONFIG_MMC_DW_IDMAC */
509 
510 static int dw_mci_pre_dma_transfer(struct dw_mci *host,
511                                    struct mmc_data *data,
512                                    bool next)
513 {
514         struct scatterlist *sg;
515         unsigned int i, sg_len;
516 
517         if (!next && data->host_cookie)
518                 return data->host_cookie;
519 
520         /*
521          * We don't do DMA on "complex" transfers, i.e. with
522          * non-word-aligned buffers or lengths. Also, we don't bother
523          * with all the DMA setup overhead for short transfers.
524          */
525         if (data->blocks * data->blksz < DW_MCI_DMA_THRESHOLD)
526                 return -EINVAL;
527 
528         if (data->blksz & 3)
529                 return -EINVAL;
530 
531         for_each_sg(data->sg, sg, data->sg_len, i) {
532                 if (sg->offset & 3 || sg->length & 3)
533                         return -EINVAL;
534         }
535 
536         sg_len = dma_map_sg(host->dev,
537                             data->sg,
538                             data->sg_len,
539                             dw_mci_get_dma_dir(data));
540         if (sg_len == 0)
541                 return -EINVAL;
542 
543         if (next)
544                 data->host_cookie = sg_len;
545 
546         return sg_len;
547 }
548 
549 static void dw_mci_pre_req(struct mmc_host *mmc,
550                            struct mmc_request *mrq,
551                            bool is_first_req)
552 {
553         struct dw_mci_slot *slot = mmc_priv(mmc);
554         struct mmc_data *data = mrq->data;
555 
556         if (!slot->host->use_dma || !data)
557                 return;
558 
559         if (data->host_cookie) {
560                 data->host_cookie = 0;
561                 return;
562         }
563 
564         if (dw_mci_pre_dma_transfer(slot->host, mrq->data, 1) < 0)
565                 data->host_cookie = 0;
566 }
567 
568 static void dw_mci_post_req(struct mmc_host *mmc,
569                             struct mmc_request *mrq,
570                             int err)
571 {
572         struct dw_mci_slot *slot = mmc_priv(mmc);
573         struct mmc_data *data = mrq->data;
574 
575         if (!slot->host->use_dma || !data)
576                 return;
577 
578         if (data->host_cookie)
579                 dma_unmap_sg(slot->host->dev,
580                              data->sg,
581                              data->sg_len,
582                              dw_mci_get_dma_dir(data));
583         data->host_cookie = 0;
584 }
585 
586 static void dw_mci_adjust_fifoth(struct dw_mci *host, struct mmc_data *data)
587 {
588 #ifdef CONFIG_MMC_DW_IDMAC
589         unsigned int blksz = data->blksz;
590         const u32 mszs[] = {1, 4, 8, 16, 32, 64, 128, 256};
591         u32 fifo_width = 1 << host->data_shift;
592         u32 blksz_depth = blksz / fifo_width, fifoth_val;
593         u32 msize = 0, rx_wmark = 1, tx_wmark, tx_wmark_invers;
594         int idx = (sizeof(mszs) / sizeof(mszs[0])) - 1;
595 
596         tx_wmark = (host->fifo_depth) / 2;
597         tx_wmark_invers = host->fifo_depth - tx_wmark;
598 
599         /*
600          * MSIZE is '1',
601          * if blksz is not a multiple of the FIFO width
602          */
603         if (blksz % fifo_width) {
604                 msize = 0;
605                 rx_wmark = 1;
606                 goto done;
607         }
608 
609         do {
610                 if (!((blksz_depth % mszs[idx]) ||
611                      (tx_wmark_invers % mszs[idx]))) {
612                         msize = idx;
613                         rx_wmark = mszs[idx] - 1;
614                         break;
615                 }
616         } while (--idx > 0);
617         /*
618          * If idx is '', it won't be tried
619          * Thus, initial values are uesed
620          */
621 done:
622         fifoth_val = SDMMC_SET_FIFOTH(msize, rx_wmark, tx_wmark);
623         mci_writel(host, FIFOTH, fifoth_val);
624 #endif
625 }
626 
627 static void dw_mci_ctrl_rd_thld(struct dw_mci *host, struct mmc_data *data)
628 {
629         unsigned int blksz = data->blksz;
630         u32 blksz_depth, fifo_depth;
631         u16 thld_size;
632 
633         WARN_ON(!(data->flags & MMC_DATA_READ));
634 
635         if (host->timing != MMC_TIMING_MMC_HS200 &&
636             host->timing != MMC_TIMING_UHS_SDR104)
637                 goto disable;
638 
639         blksz_depth = blksz / (1 << host->data_shift);
640         fifo_depth = host->fifo_depth;
641 
642         if (blksz_depth > fifo_depth)
643                 goto disable;
644 
645         /*
646          * If (blksz_depth) >= (fifo_depth >> 1), should be 'thld_size <= blksz'
647          * If (blksz_depth) <  (fifo_depth >> 1), should be thld_size = blksz
648          * Currently just choose blksz.
649          */
650         thld_size = blksz;
651         mci_writel(host, CDTHRCTL, SDMMC_SET_RD_THLD(thld_size, 1));
652         return;
653 
654 disable:
655         mci_writel(host, CDTHRCTL, SDMMC_SET_RD_THLD(0, 0));
656 }
657 
658 static int dw_mci_submit_data_dma(struct dw_mci *host, struct mmc_data *data)
659 {
660         int sg_len;
661         u32 temp;
662 
663         host->using_dma = 0;
664 
665         /* If we don't have a channel, we can't do DMA */
666         if (!host->use_dma)
667                 return -ENODEV;
668 
669         sg_len = dw_mci_pre_dma_transfer(host, data, 0);
670         if (sg_len < 0) {
671                 host->dma_ops->stop(host);
672                 return sg_len;
673         }
674 
675         host->using_dma = 1;
676 
677         dev_vdbg(host->dev,
678                  "sd sg_cpu: %#lx sg_dma: %#lx sg_len: %d\n",
679                  (unsigned long)host->sg_cpu, (unsigned long)host->sg_dma,
680                  sg_len);
681 
682         /*
683          * Decide the MSIZE and RX/TX Watermark.
684          * If current block size is same with previous size,
685          * no need to update fifoth.
686          */
687         if (host->prev_blksz != data->blksz)
688                 dw_mci_adjust_fifoth(host, data);
689 
690         /* Enable the DMA interface */
691         temp = mci_readl(host, CTRL);
692         temp |= SDMMC_CTRL_DMA_ENABLE;
693         mci_writel(host, CTRL, temp);
694 
695         /* Disable RX/TX IRQs, let DMA handle it */
696         temp = mci_readl(host, INTMASK);
697         temp  &= ~(SDMMC_INT_RXDR | SDMMC_INT_TXDR);
698         mci_writel(host, INTMASK, temp);
699 
700         host->dma_ops->start(host, sg_len);
701 
702         return 0;
703 }
704 
705 static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data)
706 {
707         u32 temp;
708 
709         data->error = -EINPROGRESS;
710 
711         WARN_ON(host->data);
712         host->sg = NULL;
713         host->data = data;
714 
715         if (data->flags & MMC_DATA_READ) {
716                 host->dir_status = DW_MCI_RECV_STATUS;
717                 dw_mci_ctrl_rd_thld(host, data);
718         } else {
719                 host->dir_status = DW_MCI_SEND_STATUS;
720         }
721 
722         if (dw_mci_submit_data_dma(host, data)) {
723                 int flags = SG_MITER_ATOMIC;
724                 if (host->data->flags & MMC_DATA_READ)
725                         flags |= SG_MITER_TO_SG;
726                 else
727                         flags |= SG_MITER_FROM_SG;
728 
729                 sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
730                 host->sg = data->sg;
731                 host->part_buf_start = 0;
732                 host->part_buf_count = 0;
733 
734                 mci_writel(host, RINTSTS, SDMMC_INT_TXDR | SDMMC_INT_RXDR);
735                 temp = mci_readl(host, INTMASK);
736                 temp |= SDMMC_INT_TXDR | SDMMC_INT_RXDR;
737                 mci_writel(host, INTMASK, temp);
738 
739                 temp = mci_readl(host, CTRL);
740                 temp &= ~SDMMC_CTRL_DMA_ENABLE;
741                 mci_writel(host, CTRL, temp);
742 
743                 /*
744                  * Use the initial fifoth_val for PIO mode.
745                  * If next issued data may be transfered by DMA mode,
746                  * prev_blksz should be invalidated.
747                  */
748                 mci_writel(host, FIFOTH, host->fifoth_val);
749                 host->prev_blksz = 0;
750         } else {
751                 /*
752                  * Keep the current block size.
753                  * It will be used to decide whether to update
754                  * fifoth register next time.
755                  */
756                 host->prev_blksz = data->blksz;
757         }
758 }
759 
760 static void mci_send_cmd(struct dw_mci_slot *slot, u32 cmd, u32 arg)
761 {
762         struct dw_mci *host = slot->host;
763         unsigned long timeout = jiffies + msecs_to_jiffies(500);
764         unsigned int cmd_status = 0;
765 
766         mci_writel(host, CMDARG, arg);
767         wmb();
768         mci_writel(host, CMD, SDMMC_CMD_START | cmd);
769 
770         while (time_before(jiffies, timeout)) {
771                 cmd_status = mci_readl(host, CMD);
772                 if (!(cmd_status & SDMMC_CMD_START))
773                         return;
774         }
775         dev_err(&slot->mmc->class_dev,
776                 "Timeout sending command (cmd %#x arg %#x status %#x)\n",
777                 cmd, arg, cmd_status);
778 }
779 
780 static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)
781 {
782         struct dw_mci *host = slot->host;
783         unsigned int clock = slot->clock;
784         u32 div;
785         u32 clk_en_a;
786 
787         if (!clock) {
788                 mci_writel(host, CLKENA, 0);
789                 mci_send_cmd(slot,
790                              SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
791         } else if (clock != host->current_speed || force_clkinit) {
792                 div = host->bus_hz / clock;
793                 if (host->bus_hz % clock && host->bus_hz > clock)
794                         /*
795                          * move the + 1 after the divide to prevent
796                          * over-clocking the card.
797                          */
798                         div += 1;
799 
800                 div = (host->bus_hz != clock) ? DIV_ROUND_UP(div, 2) : 0;
801 
802                 if ((clock << div) != slot->__clk_old || force_clkinit)
803                         dev_info(&slot->mmc->class_dev,
804                                  "Bus speed (slot %d) = %dHz (slot req %dHz, actual %dHZ div = %d)\n",
805                                  slot->id, host->bus_hz, clock,
806                                  div ? ((host->bus_hz / div) >> 1) :
807                                  host->bus_hz, div);
808 
809                 /* disable clock */
810                 mci_writel(host, CLKENA, 0);
811                 mci_writel(host, CLKSRC, 0);
812 
813                 /* inform CIU */
814                 mci_send_cmd(slot,
815                              SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
816 
817                 /* set clock to desired speed */
818                 mci_writel(host, CLKDIV, div);
819 
820                 /* inform CIU */
821                 mci_send_cmd(slot,
822                              SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
823 
824                 /* enable clock; only low power if no SDIO */
825                 clk_en_a = SDMMC_CLKEN_ENABLE << slot->id;
826                 if (!(mci_readl(host, INTMASK) & SDMMC_INT_SDIO(slot->id)))
827                         clk_en_a |= SDMMC_CLKEN_LOW_PWR << slot->id;
828                 mci_writel(host, CLKENA, clk_en_a);
829 
830                 /* inform CIU */
831                 mci_send_cmd(slot,
832                              SDMMC_CMD_UPD_CLK | SDMMC_CMD_PRV_DAT_WAIT, 0);
833 
834                 /* keep the clock with reflecting clock dividor */
835                 slot->__clk_old = clock << div;
836         }
837 
838         host->current_speed = clock;
839 
840         /* Set the current slot bus width */
841         mci_writel(host, CTYPE, (slot->ctype << slot->id));
842 }
843 
844 static void __dw_mci_start_request(struct dw_mci *host,
845                                    struct dw_mci_slot *slot,
846                                    struct mmc_command *cmd)
847 {
848         struct mmc_request *mrq;
849         struct mmc_data *data;
850         u32 cmdflags;
851 
852         mrq = slot->mrq;
853         if (host->pdata->select_slot)
854                 host->pdata->select_slot(slot->id);
855 
856         host->cur_slot = slot;
857         host->mrq = mrq;
858 
859         host->pending_events = 0;
860         host->completed_events = 0;
861         host->cmd_status = 0;
862         host->data_status = 0;
863         host->dir_status = 0;
864 
865         data = cmd->data;
866         if (data) {
867                 dw_mci_set_timeout(host);
868                 mci_writel(host, BYTCNT, data->blksz*data->blocks);
869                 mci_writel(host, BLKSIZ, data->blksz);
870         }
871 
872         cmdflags = dw_mci_prepare_command(slot->mmc, cmd);
873 
874         /* this is the first command, send the initialization clock */
875         if (test_and_clear_bit(DW_MMC_CARD_NEED_INIT, &slot->flags))
876                 cmdflags |= SDMMC_CMD_INIT;
877 
878         if (data) {
879                 dw_mci_submit_data(host, data);
880                 wmb();
881         }
882 
883         dw_mci_start_command(host, cmd, cmdflags);
884 
885         if (mrq->stop)
886                 host->stop_cmdr = dw_mci_prepare_command(slot->mmc, mrq->stop);
887         else
888                 host->stop_cmdr = dw_mci_prep_stop_abort(host, cmd);
889 }
890 
891 static void dw_mci_start_request(struct dw_mci *host,
892                                  struct dw_mci_slot *slot)
893 {
894         struct mmc_request *mrq = slot->mrq;
895         struct mmc_command *cmd;
896 
897         cmd = mrq->sbc ? mrq->sbc : mrq->cmd;
898         __dw_mci_start_request(host, slot, cmd);
899 }
900 
901 /* must be called with host->lock held */
902 static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
903                                  struct mmc_request *mrq)
904 {
905         dev_vdbg(&slot->mmc->class_dev, "queue request: state=%d\n",
906                  host->state);
907 
908         slot->mrq = mrq;
909 
910         if (host->state == STATE_IDLE) {
911                 host->state = STATE_SENDING_CMD;
912                 dw_mci_start_request(host, slot);
913         } else {
914                 list_add_tail(&slot->queue_node, &host->queue);
915         }
916 }
917 
918 static void dw_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
919 {
920         struct dw_mci_slot *slot = mmc_priv(mmc);
921         struct dw_mci *host = slot->host;
922 
923         WARN_ON(slot->mrq);
924 
925         /*
926          * The check for card presence and queueing of the request must be
927          * atomic, otherwise the card could be removed in between and the
928          * request wouldn't fail until another card was inserted.
929          */
930         spin_lock_bh(&host->lock);
931 
932         if (!test_bit(DW_MMC_CARD_PRESENT, &slot->flags)) {
933                 spin_unlock_bh(&host->lock);
934                 mrq->cmd->error = -ENOMEDIUM;
935                 mmc_request_done(mmc, mrq);
936                 return;
937         }
938 
939         dw_mci_queue_request(host, slot, mrq);
940 
941         spin_unlock_bh(&host->lock);
942 }
943 
944 static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
945 {
946         struct dw_mci_slot *slot = mmc_priv(mmc);
947         const struct dw_mci_drv_data *drv_data = slot->host->drv_data;
948         u32 regs;
949 
950         switch (ios->bus_width) {
951         case MMC_BUS_WIDTH_4:
952                 slot->ctype = SDMMC_CTYPE_4BIT;
953                 break;
954         case MMC_BUS_WIDTH_8:
955                 slot->ctype = SDMMC_CTYPE_8BIT;
956                 break;
957         default:
958                 /* set default 1 bit mode */
959                 slot->ctype = SDMMC_CTYPE_1BIT;
960         }
961 
962         regs = mci_readl(slot->host, UHS_REG);
963 
964         /* DDR mode set */
965         if (ios->timing == MMC_TIMING_UHS_DDR50)
966                 regs |= ((0x1 << slot->id) << 16);
967         else
968                 regs &= ~((0x1 << slot->id) << 16);
969 
970         mci_writel(slot->host, UHS_REG, regs);
971         slot->host->timing = ios->timing;
972 
973         /*
974          * Use mirror of ios->clock to prevent race with mmc
975          * core ios update when finding the minimum.
976          */
977         slot->clock = ios->clock;
978 
979         if (drv_data && drv_data->set_ios)
980                 drv_data->set_ios(slot->host, ios);
981 
982         /* Slot specific timing and width adjustment */
983         dw_mci_setup_bus(slot, false);
984 
985         switch (ios->power_mode) {
986         case MMC_POWER_UP:
987                 set_bit(DW_MMC_CARD_NEED_INIT, &slot->flags);
988                 /* Power up slot */
989                 if (slot->host->pdata->setpower)
990                         slot->host->pdata->setpower(slot->id, mmc->ocr_avail);
991                 regs = mci_readl(slot->host, PWREN);
992                 regs |= (1 << slot->id);
993                 mci_writel(slot->host, PWREN, regs);
994                 break;
995         case MMC_POWER_OFF:
996                 /* Power down slot */
997                 if (slot->host->pdata->setpower)
998                         slot->host->pdata->setpower(slot->id, 0);
999                 regs = mci_readl(slot->host, PWREN);
1000                 regs &= ~(1 << slot->id);
1001                 mci_writel(slot->host, PWREN, regs);
1002                 break;
1003         default:
1004                 break;
1005         }
1006 }
1007 
1008 static int dw_mci_get_ro(struct mmc_host *mmc)
1009 {
1010         int read_only;
1011         struct dw_mci_slot *slot = mmc_priv(mmc);
1012         struct dw_mci_board *brd = slot->host->pdata;
1013 
1014         /* Use platform get_ro function, else try on board write protect */
1015         if (slot->quirks & DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT)
1016                 read_only = 0;
1017         else if (brd->get_ro)
1018                 read_only = brd->get_ro(slot->id);
1019         else if (gpio_is_valid(slot->wp_gpio))
1020                 read_only = gpio_get_value(slot->wp_gpio);
1021         else
1022                 read_only =
1023                         mci_readl(slot->host, WRTPRT) & (1 << slot->id) ? 1 : 0;
1024 
1025         dev_dbg(&mmc->class_dev, "card is %s\n",
1026                 read_only ? "read-only" : "read-write");
1027 
1028         return read_only;
1029 }
1030 
1031 static int dw_mci_get_cd(struct mmc_host *mmc)
1032 {
1033         int present;
1034         struct dw_mci_slot *slot = mmc_priv(mmc);
1035         struct dw_mci_board *brd = slot->host->pdata;
1036         struct dw_mci *host = slot->host;
1037         int gpio_cd = mmc_gpio_get_cd(mmc);
1038 
1039         /* Use platform get_cd function, else try onboard card detect */
1040         if (brd->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION)
1041                 present = 1;
1042         else if (brd->get_cd)
1043                 present = !brd->get_cd(slot->id);
1044         else if (!IS_ERR_VALUE(gpio_cd))
1045                 present = gpio_cd;
1046         else
1047                 present = (mci_readl(slot->host, CDETECT) & (1 << slot->id))
1048                         == 0 ? 1 : 0;
1049 
1050         spin_lock_bh(&host->lock);
1051         if (present) {
1052                 set_bit(DW_MMC_CARD_PRESENT, &slot->flags);
1053                 dev_dbg(&mmc->class_dev, "card is present\n");
1054         } else {
1055                 clear_bit(DW_MMC_CARD_PRESENT, &slot->flags);
1056                 dev_dbg(&mmc->class_dev, "card is not present\n");
1057         }
1058         spin_unlock_bh(&host->lock);
1059 
1060         return present;
1061 }
1062 
1063 /*
1064  * Disable lower power mode.
1065  *
1066  * Low power mode will stop the card clock when idle.  According to the
1067  * description of the CLKENA register we should disable low power mode
1068  * for SDIO cards if we need SDIO interrupts to work.
1069  *
1070  * This function is fast if low power mode is already disabled.
1071  */
1072 static void dw_mci_disable_low_power(struct dw_mci_slot *slot)
1073 {
1074         struct dw_mci *host = slot->host;
1075         u32 clk_en_a;
1076         const u32 clken_low_pwr = SDMMC_CLKEN_LOW_PWR << slot->id;
1077 
1078         clk_en_a = mci_readl(host, CLKENA);
1079 
1080         if (clk_en_a & clken_low_pwr) {
1081                 mci_writel(host, CLKENA, clk_en_a & ~clken_low_pwr);
1082                 mci_send_cmd(slot, SDMMC_CMD_UPD_CLK |
1083                              SDMMC_CMD_PRV_DAT_WAIT, 0);
1084         }
1085 }
1086 
1087 static void dw_mci_enable_sdio_irq(struct mmc_host *mmc, int enb)
1088 {
1089         struct dw_mci_slot *slot = mmc_priv(mmc);
1090         struct dw_mci *host = slot->host;
1091         u32 int_mask;
1092 
1093         /* Enable/disable Slot Specific SDIO interrupt */
1094         int_mask = mci_readl(host, INTMASK);
1095         if (enb) {
1096                 /*
1097                  * Turn off low power mode if it was enabled.  This is a bit of
1098                  * a heavy operation and we disable / enable IRQs a lot, so
1099                  * we'll leave low power mode disabled and it will get
1100                  * re-enabled again in dw_mci_setup_bus().
1101                  */
1102                 dw_mci_disable_low_power(slot);
1103 
1104                 mci_writel(host, INTMASK,
1105                            (int_mask | SDMMC_INT_SDIO(slot->id)));
1106         } else {
1107                 mci_writel(host, INTMASK,
1108                            (int_mask & ~SDMMC_INT_SDIO(slot->id)));
1109         }
1110 }
1111 
1112 static int dw_mci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1113 {
1114         struct dw_mci_slot *slot = mmc_priv(mmc);
1115         struct dw_mci *host = slot->host;
1116         const struct dw_mci_drv_data *drv_data = host->drv_data;
1117         struct dw_mci_tuning_data tuning_data;
1118         int err = -ENOSYS;
1119 
1120         if (opcode == MMC_SEND_TUNING_BLOCK_HS200) {
1121                 if (mmc->ios.bus_width == MMC_BUS_WIDTH_8) {
1122                         tuning_data.blk_pattern = tuning_blk_pattern_8bit;
1123                         tuning_data.blksz = sizeof(tuning_blk_pattern_8bit);
1124                 } else if (mmc->ios.bus_width == MMC_BUS_WIDTH_4) {
1125                         tuning_data.blk_pattern = tuning_blk_pattern_4bit;
1126                         tuning_data.blksz = sizeof(tuning_blk_pattern_4bit);
1127                 } else {
1128                         return -EINVAL;
1129                 }
1130         } else if (opcode == MMC_SEND_TUNING_BLOCK) {
1131                 tuning_data.blk_pattern = tuning_blk_pattern_4bit;
1132                 tuning_data.blksz = sizeof(tuning_blk_pattern_4bit);
1133         } else {
1134                 dev_err(host->dev,
1135                         "Undefined command(%d) for tuning\n", opcode);
1136                 return -EINVAL;
1137         }
1138 
1139         if (drv_data && drv_data->execute_tuning)
1140                 err = drv_data->execute_tuning(slot, opcode, &tuning_data);
1141         return err;
1142 }
1143 
1144 static const struct mmc_host_ops dw_mci_ops = {
1145         .request                = dw_mci_request,
1146         .pre_req                = dw_mci_pre_req,
1147         .post_req               = dw_mci_post_req,
1148         .set_ios                = dw_mci_set_ios,
1149         .get_ro                 = dw_mci_get_ro,
1150         .get_cd                 = dw_mci_get_cd,
1151         .enable_sdio_irq        = dw_mci_enable_sdio_irq,
1152         .execute_tuning         = dw_mci_execute_tuning,
1153 };
1154 
1155 static void dw_mci_request_end(struct dw_mci *host, struct mmc_request *mrq)
1156         __releases(&host->lock)
1157         __acquires(&host->lock)
1158 {
1159         struct dw_mci_slot *slot;
1160         struct mmc_host *prev_mmc = host->cur_slot->mmc;
1161 
1162         WARN_ON(host->cmd || host->data);
1163 
1164         host->cur_slot->mrq = NULL;
1165         host->mrq = NULL;
1166         if (!list_empty(&host->queue)) {
1167                 slot = list_entry(host->queue.next,
1168                                   struct dw_mci_slot, queue_node);
1169                 list_del(&slot->queue_node);
1170                 dev_vdbg(host->dev, "list not empty: %s is next\n",
1171                          mmc_hostname(slot->mmc));
1172                 host->state = STATE_SENDING_CMD;
1173                 dw_mci_start_request(host, slot);
1174         } else {
1175                 dev_vdbg(host->dev, "list empty\n");
1176                 host->state = STATE_IDLE;
1177         }
1178 
1179         spin_unlock(&host->lock);
1180         mmc_request_done(prev_mmc, mrq);
1181         spin_lock(&host->lock);
1182 }
1183 
1184 static int dw_mci_command_complete(struct dw_mci *host, struct mmc_command *cmd)
1185 {
1186         u32 status = host->cmd_status;
1187 
1188         host->cmd_status = 0;
1189 
1190         /* Read the response from the card (up to 16 bytes) */
1191         if (cmd->flags & MMC_RSP_PRESENT) {
1192                 if (cmd->flags & MMC_RSP_136) {
1193                         cmd->resp[3] = mci_readl(host, RESP0);
1194                         cmd->resp[2] = mci_readl(host, RESP1);
1195                         cmd->resp[1] = mci_readl(host, RESP2);
1196                         cmd->resp[0] = mci_readl(host, RESP3);
1197                 } else {
1198                         cmd->resp[0] = mci_readl(host, RESP0);
1199                         cmd->resp[1] = 0;
1200                         cmd->resp[2] = 0;
1201                         cmd->resp[3] = 0;
1202                 }
1203         }
1204 
1205         if (status & SDMMC_INT_RTO)
1206                 cmd->error = -ETIMEDOUT;
1207         else if ((cmd->flags & MMC_RSP_CRC) && (status & SDMMC_INT_RCRC))
1208                 cmd->error = -EILSEQ;
1209         else if (status & SDMMC_INT_RESP_ERR)
1210                 cmd->error = -EIO;
1211         else
1212                 cmd->error = 0;
1213 
1214         if (cmd->error) {
1215                 /* newer ip versions need a delay between retries */
1216                 if (host->quirks & DW_MCI_QUIRK_RETRY_DELAY)
1217                         mdelay(20);
1218         }
1219 
1220         return cmd->error;
1221 }
1222 
1223 static int dw_mci_data_complete(struct dw_mci *host, struct mmc_data *data)
1224 {
1225         u32 status = host->data_status;
1226 
1227         if (status & DW_MCI_DATA_ERROR_FLAGS) {
1228                 if (status & SDMMC_INT_DRTO) {
1229                         data->error = -ETIMEDOUT;
1230                 } else if (status & SDMMC_INT_DCRC) {
1231                         data->error = -EILSEQ;
1232                 } else if (status & SDMMC_INT_EBE) {
1233                         if (host->dir_status ==
1234                                 DW_MCI_SEND_STATUS) {
1235                                 /*
1236                                  * No data CRC status was returned.
1237                                  * The number of bytes transferred
1238                                  * will be exaggerated in PIO mode.
1239                                  */
1240                                 data->bytes_xfered = 0;
1241                                 data->error = -ETIMEDOUT;
1242                         } else if (host->dir_status ==
1243                                         DW_MCI_RECV_STATUS) {
1244                                 data->error = -EIO;
1245                         }
1246                 } else {
1247                         /* SDMMC_INT_SBE is included */
1248                         data->error = -EIO;
1249                 }
1250 
1251                 dev_err(host->dev, "data error, status 0x%08x\n", status);
1252 
1253                 /*
1254                  * After an error, there may be data lingering
1255                  * in the FIFO
1256                  */
1257                 dw_mci_fifo_reset(host);
1258         } else {
1259                 data->bytes_xfered = data->blocks * data->blksz;
1260                 data->error = 0;
1261         }
1262 
1263         return data->error;
1264 }
1265 
1266 static void dw_mci_tasklet_func(unsigned long priv)
1267 {
1268         struct dw_mci *host = (struct dw_mci *)priv;
1269         struct mmc_data *data;
1270         struct mmc_command *cmd;
1271         struct mmc_request *mrq;
1272         enum dw_mci_state state;
1273         enum dw_mci_state prev_state;
1274         unsigned int err;
1275 
1276         spin_lock(&host->lock);
1277 
1278         state = host->state;
1279         data = host->data;
1280         mrq = host->mrq;
1281 
1282         do {
1283                 prev_state = state;
1284 
1285                 switch (state) {
1286                 case STATE_IDLE:
1287                         break;
1288 
1289                 case STATE_SENDING_CMD:
1290                         if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
1291                                                 &host->pending_events))
1292                                 break;
1293 
1294                         cmd = host->cmd;
1295                         host->cmd = NULL;
1296                         set_bit(EVENT_CMD_COMPLETE, &host->completed_events);
1297                         err = dw_mci_command_complete(host, cmd);
1298                         if (cmd == mrq->sbc && !err) {
1299                                 prev_state = state = STATE_SENDING_CMD;
1300                                 __dw_mci_start_request(host, host->cur_slot,
1301                                                        mrq->cmd);
1302                                 goto unlock;
1303                         }
1304 
1305                         if (cmd->data && err) {
1306                                 dw_mci_stop_dma(host);
1307                                 send_stop_abort(host, data);
1308                                 state = STATE_SENDING_STOP;
1309                                 break;
1310                         }
1311 
1312                         if (!cmd->data || err) {
1313                                 dw_mci_request_end(host, mrq);
1314                                 goto unlock;
1315                         }
1316 
1317                         prev_state = state = STATE_SENDING_DATA;
1318                         /* fall through */
1319 
1320                 case STATE_SENDING_DATA:
1321                         if (test_and_clear_bit(EVENT_DATA_ERROR,
1322                                                &host->pending_events)) {
1323                                 dw_mci_stop_dma(host);
1324                                 send_stop_abort(host, data);
1325                                 state = STATE_DATA_ERROR;
1326                                 break;
1327                         }
1328 
1329                         if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
1330                                                 &host->pending_events))
1331                                 break;
1332 
1333                         set_bit(EVENT_XFER_COMPLETE, &host->completed_events);
1334                         prev_state = state = STATE_DATA_BUSY;
1335                         /* fall through */
1336 
1337                 case STATE_DATA_BUSY:
1338                         if (!test_and_clear_bit(EVENT_DATA_COMPLETE,
1339                                                 &host->pending_events))
1340                                 break;
1341 
1342                         host->data = NULL;
1343                         set_bit(EVENT_DATA_COMPLETE, &host->completed_events);
1344                         err = dw_mci_data_complete(host, data);
1345 
1346                         if (!err) {
1347                                 if (!data->stop || mrq->sbc) {
1348                                         if (mrq->sbc && data->stop)
1349                                                 data->stop->error = 0;
1350                                         dw_mci_request_end(host, mrq);
1351                                         goto unlock;
1352                                 }
1353 
1354                                 /* stop command for open-ended transfer*/
1355                                 if (data->stop)
1356                                         send_stop_abort(host, data);
1357                         }
1358 
1359                         /*
1360                          * If err has non-zero,
1361                          * stop-abort command has been already issued.
1362                          */
1363                         prev_state = state = STATE_SENDING_STOP;
1364 
1365                         /* fall through */
1366 
1367                 case STATE_SENDING_STOP:
1368                         if (!test_and_clear_bit(EVENT_CMD_COMPLETE,
1369                                                 &host->pending_events))
1370                                 break;
1371 
1372                         /* CMD error in data command */
1373                         if (mrq->cmd->error && mrq->data)
1374                                 dw_mci_fifo_reset(host);
1375 
1376                         host->cmd = NULL;
1377                         host->data = NULL;
1378 
1379                         if (mrq->stop)
1380                                 dw_mci_command_complete(host, mrq->stop);
1381                         else
1382                                 host->cmd_status = 0;
1383 
1384                         dw_mci_request_end(host, mrq);
1385                         goto unlock;
1386 
1387                 case STATE_DATA_ERROR:
1388                         if (!test_and_clear_bit(EVENT_XFER_COMPLETE,
1389                                                 &host->pending_events))
1390                                 break;
1391 
1392                         state = STATE_DATA_BUSY;
1393                         break;
1394                 }
1395         } while (state != prev_state);
1396 
1397         host->state = state;
1398 unlock:
1399         spin_unlock(&host->lock);
1400 
1401 }
1402 
1403 /* push final bytes to part_buf, only use during push */
1404 static void dw_mci_set_part_bytes(struct dw_mci *host, void *buf, int cnt)
1405 {
1406         memcpy((void *)&host->part_buf, buf, cnt);
1407         host->part_buf_count = cnt;
1408 }
1409 
1410 /* append bytes to part_buf, only use during push */
1411 static int dw_mci_push_part_bytes(struct dw_mci *host, void *buf, int cnt)
1412 {
1413         cnt = min(cnt, (1 << host->data_shift) - host->part_buf_count);
1414         memcpy((void *)&host->part_buf + host->part_buf_count, buf, cnt);
1415         host->part_buf_count += cnt;
1416         return cnt;
1417 }
1418 
1419 /* pull first bytes from part_buf, only use during pull */
1420 static int dw_mci_pull_part_bytes(struct dw_mci *host, void *buf, int cnt)
1421 {
1422         cnt = min(cnt, (int)host->part_buf_count);
1423         if (cnt) {
1424                 memcpy(buf, (void *)&host->part_buf + host->part_buf_start,
1425                        cnt);
1426                 host->part_buf_count -= cnt;
1427                 host->part_buf_start += cnt;
1428         }
1429         return cnt;
1430 }
1431 
1432 /* pull final bytes from the part_buf, assuming it's just been filled */
1433 static void dw_mci_pull_final_bytes(struct dw_mci *host, void *buf, int cnt)
1434 {
1435         memcpy(buf, &host->part_buf, cnt);
1436         host->part_buf_start = cnt;
1437         host->part_buf_count = (1 << host->data_shift) - cnt;
1438 }
1439 
1440 static void dw_mci_push_data16(struct dw_mci *host, void *buf, int cnt)
1441 {
1442         struct mmc_data *data = host->data;
1443         int init_cnt = cnt;
1444 
1445         /* try and push anything in the part_buf */
1446         if (unlikely(host->part_buf_count)) {
1447                 int len = dw_mci_push_part_bytes(host, buf, cnt);
1448                 buf += len;
1449                 cnt -= len;
1450                 if (host->part_buf_count == 2) {
1451                         mci_writew(host, DATA(host->data_offset),
1452                                         host->part_buf16);
1453                         host->part_buf_count = 0;
1454                 }
1455         }
1456 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1457         if (unlikely((unsigned long)buf & 0x1)) {
1458                 while (cnt >= 2) {
1459                         u16 aligned_buf[64];
1460                         int len = min(cnt & -2, (int)sizeof(aligned_buf));
1461                         int items = len >> 1;
1462                         int i;
1463                         /* memcpy from input buffer into aligned buffer */
1464                         memcpy(aligned_buf, buf, len);
1465                         buf += len;
1466                         cnt -= len;
1467                         /* push data from aligned buffer into fifo */
1468                         for (i = 0; i < items; ++i)
1469                                 mci_writew(host, DATA(host->data_offset),
1470                                                 aligned_buf[i]);
1471                 }
1472         } else
1473 #endif
1474         {
1475                 u16 *pdata = buf;
1476                 for (; cnt >= 2; cnt -= 2)
1477                         mci_writew(host, DATA(host->data_offset), *pdata++);
1478                 buf = pdata;
1479         }
1480         /* put anything remaining in the part_buf */
1481         if (cnt) {
1482                 dw_mci_set_part_bytes(host, buf, cnt);
1483                  /* Push data if we have reached the expected data length */
1484                 if ((data->bytes_xfered + init_cnt) ==
1485                     (data->blksz * data->blocks))
1486                         mci_writew(host, DATA(host->data_offset),
1487                                    host->part_buf16);
1488         }
1489 }
1490 
1491 static void dw_mci_pull_data16(struct dw_mci *host, void *buf, int cnt)
1492 {
1493 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1494         if (unlikely((unsigned long)buf & 0x1)) {
1495                 while (cnt >= 2) {
1496                         /* pull data from fifo into aligned buffer */
1497                         u16 aligned_buf[64];
1498                         int len = min(cnt & -2, (int)sizeof(aligned_buf));
1499                         int items = len >> 1;
1500                         int i;
1501                         for (i = 0; i < items; ++i)
1502                                 aligned_buf[i] = mci_readw(host,
1503                                                 DATA(host->data_offset));
1504                         /* memcpy from aligned buffer into output buffer */
1505                         memcpy(buf, aligned_buf, len);
1506                         buf += len;
1507                         cnt -= len;
1508                 }
1509         } else
1510 #endif
1511         {
1512                 u16 *pdata = buf;
1513                 for (; cnt >= 2; cnt -= 2)
1514                         *pdata++ = mci_readw(host, DATA(host->data_offset));
1515                 buf = pdata;
1516         }
1517         if (cnt) {
1518                 host->part_buf16 = mci_readw(host, DATA(host->data_offset));
1519                 dw_mci_pull_final_bytes(host, buf, cnt);
1520         }
1521 }
1522 
1523 static void dw_mci_push_data32(struct dw_mci *host, void *buf, int cnt)
1524 {
1525         struct mmc_data *data = host->data;
1526         int init_cnt = cnt;
1527 
1528         /* try and push anything in the part_buf */
1529         if (unlikely(host->part_buf_count)) {
1530                 int len = dw_mci_push_part_bytes(host, buf, cnt);
1531                 buf += len;
1532                 cnt -= len;
1533                 if (host->part_buf_count == 4) {
1534                         mci_writel(host, DATA(host->data_offset),
1535                                         host->part_buf32);
1536                         host->part_buf_count = 0;
1537                 }
1538         }
1539 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1540         if (unlikely((unsigned long)buf & 0x3)) {
1541                 while (cnt >= 4) {
1542                         u32 aligned_buf[32];
1543                         int len = min(cnt & -4, (int)sizeof(aligned_buf));
1544                         int items = len >> 2;
1545                         int i;
1546                         /* memcpy from input buffer into aligned buffer */
1547                         memcpy(aligned_buf, buf, len);
1548                         buf += len;
1549                         cnt -= len;
1550                         /* push data from aligned buffer into fifo */
1551                         for (i = 0; i < items; ++i)
1552                                 mci_writel(host, DATA(host->data_offset),
1553                                                 aligned_buf[i]);
1554                 }
1555         } else
1556 #endif
1557         {
1558                 u32 *pdata = buf;
1559                 for (; cnt >= 4; cnt -= 4)
1560                         mci_writel(host, DATA(host->data_offset), *pdata++);
1561                 buf = pdata;
1562         }
1563         /* put anything remaining in the part_buf */
1564         if (cnt) {
1565                 dw_mci_set_part_bytes(host, buf, cnt);
1566                  /* Push data if we have reached the expected data length */
1567                 if ((data->bytes_xfered + init_cnt) ==
1568                     (data->blksz * data->blocks))
1569                         mci_writel(host, DATA(host->data_offset),
1570                                    host->part_buf32);
1571         }
1572 }
1573 
1574 static void dw_mci_pull_data32(struct dw_mci *host, void *buf, int cnt)
1575 {
1576 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1577         if (unlikely((unsigned long)buf & 0x3)) {
1578                 while (cnt >= 4) {
1579                         /* pull data from fifo into aligned buffer */
1580                         u32 aligned_buf[32];
1581                         int len = min(cnt & -4, (int)sizeof(aligned_buf));
1582                         int items = len >> 2;
1583                         int i;
1584                         for (i = 0; i < items; ++i)
1585                                 aligned_buf[i] = mci_readl(host,
1586                                                 DATA(host->data_offset));
1587                         /* memcpy from aligned buffer into output buffer */
1588                         memcpy(buf, aligned_buf, len);
1589                         buf += len;
1590                         cnt -= len;
1591                 }
1592         } else
1593 #endif
1594         {
1595                 u32 *pdata = buf;
1596                 for (; cnt >= 4; cnt -= 4)
1597                         *pdata++ = mci_readl(host, DATA(host->data_offset));
1598                 buf = pdata;
1599         }
1600         if (cnt) {
1601                 host->part_buf32 = mci_readl(host, DATA(host->data_offset));
1602                 dw_mci_pull_final_bytes(host, buf, cnt);
1603         }
1604 }
1605 
1606 static void dw_mci_push_data64(struct dw_mci *host, void *buf, int cnt)
1607 {
1608         struct mmc_data *data = host->data;
1609         int init_cnt = cnt;
1610 
1611         /* try and push anything in the part_buf */
1612         if (unlikely(host->part_buf_count)) {
1613                 int len = dw_mci_push_part_bytes(host, buf, cnt);
1614                 buf += len;
1615                 cnt -= len;
1616 
1617                 if (host->part_buf_count == 8) {
1618                         mci_writeq(host, DATA(host->data_offset),
1619                                         host->part_buf);
1620                         host->part_buf_count = 0;
1621                 }
1622         }
1623 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1624         if (unlikely((unsigned long)buf & 0x7)) {
1625                 while (cnt >= 8) {
1626                         u64 aligned_buf[16];
1627                         int len = min(cnt & -8, (int)sizeof(aligned_buf));
1628                         int items = len >> 3;
1629                         int i;
1630                         /* memcpy from input buffer into aligned buffer */
1631                         memcpy(aligned_buf, buf, len);
1632                         buf += len;
1633                         cnt -= len;
1634                         /* push data from aligned buffer into fifo */
1635                         for (i = 0; i < items; ++i)
1636                                 mci_writeq(host, DATA(host->data_offset),
1637                                                 aligned_buf[i]);
1638                 }
1639         } else
1640 #endif
1641         {
1642                 u64 *pdata = buf;
1643                 for (; cnt >= 8; cnt -= 8)
1644                         mci_writeq(host, DATA(host->data_offset), *pdata++);
1645                 buf = pdata;
1646         }
1647         /* put anything remaining in the part_buf */
1648         if (cnt) {
1649                 dw_mci_set_part_bytes(host, buf, cnt);
1650                 /* Push data if we have reached the expected data length */
1651                 if ((data->bytes_xfered + init_cnt) ==
1652                     (data->blksz * data->blocks))
1653                         mci_writeq(host, DATA(host->data_offset),
1654                                    host->part_buf);
1655         }
1656 }
1657 
1658 static void dw_mci_pull_data64(struct dw_mci *host, void *buf, int cnt)
1659 {
1660 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1661         if (unlikely((unsigned long)buf & 0x7)) {
1662                 while (cnt >= 8) {
1663                         /* pull data from fifo into aligned buffer */
1664                         u64 aligned_buf[16];
1665                         int len = min(cnt & -8, (int)sizeof(aligned_buf));
1666                         int items = len >> 3;
1667                         int i;
1668                         for (i = 0; i < items; ++i)
1669                                 aligned_buf[i] = mci_readq(host,
1670                                                 DATA(host->data_offset));
1671                         /* memcpy from aligned buffer into output buffer */
1672                         memcpy(buf, aligned_buf, len);
1673                         buf += len;
1674                         cnt -= len;
1675                 }
1676         } else
1677 #endif
1678         {
1679                 u64 *pdata = buf;
1680                 for (; cnt >= 8; cnt -= 8)
1681                         *pdata++ = mci_readq(host, DATA(host->data_offset));
1682                 buf = pdata;
1683         }
1684         if (cnt) {
1685                 host->part_buf = mci_readq(host, DATA(host->data_offset));
1686                 dw_mci_pull_final_bytes(host, buf, cnt);
1687         }
1688 }
1689 
1690 static void dw_mci_pull_data(struct dw_mci *host, void *buf, int cnt)
1691 {
1692         int len;
1693 
1694         /* get remaining partial bytes */
1695         len = dw_mci_pull_part_bytes(host, buf, cnt);
1696         if (unlikely(len == cnt))
1697                 return;
1698         buf += len;
1699         cnt -= len;
1700 
1701         /* get the rest of the data */
1702         host->pull_data(host, buf, cnt);
1703 }
1704 
1705 static void dw_mci_read_data_pio(struct dw_mci *host, bool dto)
1706 {
1707         struct sg_mapping_iter *sg_miter = &host->sg_miter;
1708         void *buf;
1709         unsigned int offset;
1710         struct mmc_data *data = host->data;
1711         int shift = host->data_shift;
1712         u32 status;
1713         unsigned int len;
1714         unsigned int remain, fcnt;
1715 
1716         do {
1717                 if (!sg_miter_next(sg_miter))
1718                         goto done;
1719 
1720                 host->sg = sg_miter->piter.sg;
1721                 buf = sg_miter->addr;
1722                 remain = sg_miter->length;
1723                 offset = 0;
1724 
1725                 do {
1726                         fcnt = (SDMMC_GET_FCNT(mci_readl(host, STATUS))
1727                                         << shift) + host->part_buf_count;
1728                         len = min(remain, fcnt);
1729                         if (!len)
1730                                 break;
1731                         dw_mci_pull_data(host, (void *)(buf + offset), len);
1732                         data->bytes_xfered += len;
1733                         offset += len;
1734                         remain -= len;
1735                 } while (remain);
1736 
1737                 sg_miter->consumed = offset;
1738                 status = mci_readl(host, MINTSTS);
1739                 mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
1740         /* if the RXDR is ready read again */
1741         } while ((status & SDMMC_INT_RXDR) ||
1742                  (dto && SDMMC_GET_FCNT(mci_readl(host, STATUS))));
1743 
1744         if (!remain) {
1745                 if (!sg_miter_next(sg_miter))
1746                         goto done;
1747                 sg_miter->consumed = 0;
1748         }
1749         sg_miter_stop(sg_miter);
1750         return;
1751 
1752 done:
1753         sg_miter_stop(sg_miter);
1754         host->sg = NULL;
1755         smp_wmb();
1756         set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
1757 }
1758 
1759 static void dw_mci_write_data_pio(struct dw_mci *host)
1760 {
1761         struct sg_mapping_iter *sg_miter = &host->sg_miter;
1762         void *buf;
1763         unsigned int offset;
1764         struct mmc_data *data = host->data;
1765         int shift = host->data_shift;
1766         u32 status;
1767         unsigned int len;
1768         unsigned int fifo_depth = host->fifo_depth;
1769         unsigned int remain, fcnt;
1770 
1771         do {
1772                 if (!sg_miter_next(sg_miter))
1773                         goto done;
1774 
1775                 host->sg = sg_miter->piter.sg;
1776                 buf = sg_miter->addr;
1777                 remain = sg_miter->length;
1778                 offset = 0;
1779 
1780                 do {
1781                         fcnt = ((fifo_depth -
1782                                  SDMMC_GET_FCNT(mci_readl(host, STATUS)))
1783                                         << shift) - host->part_buf_count;
1784                         len = min(remain, fcnt);
1785                         if (!len)
1786                                 break;
1787                         host->push_data(host, (void *)(buf + offset), len);
1788                         data->bytes_xfered += len;
1789                         offset += len;
1790                         remain -= len;
1791                 } while (remain);
1792 
1793                 sg_miter->consumed = offset;
1794                 status = mci_readl(host, MINTSTS);
1795                 mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
1796         } while (status & SDMMC_INT_TXDR); /* if TXDR write again */
1797 
1798         if (!remain) {
1799                 if (!sg_miter_next(sg_miter))
1800                         goto done;
1801                 sg_miter->consumed = 0;
1802         }
1803         sg_miter_stop(sg_miter);
1804         return;
1805 
1806 done:
1807         sg_miter_stop(sg_miter);
1808         host->sg = NULL;
1809         smp_wmb();
1810         set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
1811 }
1812 
1813 static void dw_mci_cmd_interrupt(struct dw_mci *host, u32 status)
1814 {
1815         if (!host->cmd_status)
1816                 host->cmd_status = status;
1817 
1818         smp_wmb();
1819 
1820         set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
1821         tasklet_schedule(&host->tasklet);
1822 }
1823 
1824 static irqreturn_t dw_mci_interrupt(int irq, void *dev_id)
1825 {
1826         struct dw_mci *host = dev_id;
1827         u32 pending;
1828         int i;
1829 
1830         pending = mci_readl(host, MINTSTS); /* read-only mask reg */
1831 
1832         /*
1833          * DTO fix - version 2.10a and below, and only if internal DMA
1834          * is configured.
1835          */
1836         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO) {
1837                 if (!pending &&
1838                     ((mci_readl(host, STATUS) >> 17) & 0x1fff))
1839                         pending |= SDMMC_INT_DATA_OVER;
1840         }
1841 
1842         if (pending) {
1843                 if (pending & DW_MCI_CMD_ERROR_FLAGS) {
1844                         mci_writel(host, RINTSTS, DW_MCI_CMD_ERROR_FLAGS);
1845                         host->cmd_status = pending;
1846                         smp_wmb();
1847                         set_bit(EVENT_CMD_COMPLETE, &host->pending_events);
1848                 }
1849 
1850                 if (pending & DW_MCI_DATA_ERROR_FLAGS) {
1851                         /* if there is an error report DATA_ERROR */
1852                         mci_writel(host, RINTSTS, DW_MCI_DATA_ERROR_FLAGS);
1853                         host->data_status = pending;
1854                         smp_wmb();
1855                         set_bit(EVENT_DATA_ERROR, &host->pending_events);
1856                         tasklet_schedule(&host->tasklet);
1857                 }
1858 
1859                 if (pending & SDMMC_INT_DATA_OVER) {
1860                         mci_writel(host, RINTSTS, SDMMC_INT_DATA_OVER);
1861                         if (!host->data_status)
1862                                 host->data_status = pending;
1863                         smp_wmb();
1864                         if (host->dir_status == DW_MCI_RECV_STATUS) {
1865                                 if (host->sg != NULL)
1866                                         dw_mci_read_data_pio(host, true);
1867                         }
1868                         set_bit(EVENT_DATA_COMPLETE, &host->pending_events);
1869                         tasklet_schedule(&host->tasklet);
1870                 }
1871 
1872                 if (pending & SDMMC_INT_RXDR) {
1873                         mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
1874                         if (host->dir_status == DW_MCI_RECV_STATUS && host->sg)
1875                                 dw_mci_read_data_pio(host, false);
1876                 }
1877 
1878                 if (pending & SDMMC_INT_TXDR) {
1879                         mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
1880                         if (host->dir_status == DW_MCI_SEND_STATUS && host->sg)
1881                                 dw_mci_write_data_pio(host);
1882                 }
1883 
1884                 if (pending & SDMMC_INT_CMD_DONE) {
1885                         mci_writel(host, RINTSTS, SDMMC_INT_CMD_DONE);
1886                         dw_mci_cmd_interrupt(host, pending);
1887                 }
1888 
1889                 if (pending & SDMMC_INT_CD) {
1890                         mci_writel(host, RINTSTS, SDMMC_INT_CD);
1891                         queue_work(host->card_workqueue, &host->card_work);
1892                 }
1893 
1894                 /* Handle SDIO Interrupts */
1895                 for (i = 0; i < host->num_slots; i++) {
1896                         struct dw_mci_slot *slot = host->slot[i];
1897                         if (pending & SDMMC_INT_SDIO(i)) {
1898                                 mci_writel(host, RINTSTS, SDMMC_INT_SDIO(i));
1899                                 mmc_signal_sdio_irq(slot->mmc);
1900                         }
1901                 }
1902 
1903         }
1904 
1905 #ifdef CONFIG_MMC_DW_IDMAC
1906         /* Handle DMA interrupts */
1907         pending = mci_readl(host, IDSTS);
1908         if (pending & (SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI)) {
1909                 mci_writel(host, IDSTS, SDMMC_IDMAC_INT_TI | SDMMC_IDMAC_INT_RI);
1910                 mci_writel(host, IDSTS, SDMMC_IDMAC_INT_NI);
1911                 host->dma_ops->complete(host);
1912         }
1913 #endif
1914 
1915         return IRQ_HANDLED;
1916 }
1917 
1918 static void dw_mci_work_routine_card(struct work_struct *work)
1919 {
1920         struct dw_mci *host = container_of(work, struct dw_mci, card_work);
1921         int i;
1922 
1923         for (i = 0; i < host->num_slots; i++) {
1924                 struct dw_mci_slot *slot = host->slot[i];
1925                 struct mmc_host *mmc = slot->mmc;
1926                 struct mmc_request *mrq;
1927                 int present;
1928 
1929                 present = dw_mci_get_cd(mmc);
1930                 while (present != slot->last_detect_state) {
1931                         dev_dbg(&slot->mmc->class_dev, "card %s\n",
1932                                 present ? "inserted" : "removed");
1933 
1934                         spin_lock_bh(&host->lock);
1935 
1936                         /* Card change detected */
1937                         slot->last_detect_state = present;
1938 
1939                         /* Clean up queue if present */
1940                         mrq = slot->mrq;
1941                         if (mrq) {
1942                                 if (mrq == host->mrq) {
1943                                         host->data = NULL;
1944                                         host->cmd = NULL;
1945 
1946                                         switch (host->state) {
1947                                         case STATE_IDLE:
1948                                                 break;
1949                                         case STATE_SENDING_CMD:
1950                                                 mrq->cmd->error = -ENOMEDIUM;
1951                                                 if (!mrq->data)
1952                                                         break;
1953                                                 /* fall through */
1954                                         case STATE_SENDING_DATA:
1955                                                 mrq->data->error = -ENOMEDIUM;
1956                                                 dw_mci_stop_dma(host);
1957                                                 break;
1958                                         case STATE_DATA_BUSY:
1959                                         case STATE_DATA_ERROR:
1960                                                 if (mrq->data->error == -EINPROGRESS)
1961                                                         mrq->data->error = -ENOMEDIUM;
1962                                                 /* fall through */
1963                                         case STATE_SENDING_STOP:
1964                                                 if (mrq->stop)
1965                                                         mrq->stop->error = -ENOMEDIUM;
1966                                                 break;
1967                                         }
1968 
1969                                         dw_mci_request_end(host, mrq);
1970                                 } else {
1971                                         list_del(&slot->queue_node);
1972                                         mrq->cmd->error = -ENOMEDIUM;
1973                                         if (mrq->data)
1974                                                 mrq->data->error = -ENOMEDIUM;
1975                                         if (mrq->stop)
1976                                                 mrq->stop->error = -ENOMEDIUM;
1977 
1978                                         spin_unlock(&host->lock);
1979                                         mmc_request_done(slot->mmc, mrq);
1980                                         spin_lock(&host->lock);
1981                                 }
1982                         }
1983 
1984                         /* Power down slot */
1985                         if (present == 0) {
1986                                 /* Clear down the FIFO */
1987                                 dw_mci_fifo_reset(host);
1988 #ifdef CONFIG_MMC_DW_IDMAC
1989                                 dw_mci_idmac_reset(host);
1990 #endif
1991 
1992                         }
1993 
1994                         spin_unlock_bh(&host->lock);
1995 
1996                         present = dw_mci_get_cd(mmc);
1997                 }
1998 
1999                 mmc_detect_change(slot->mmc,
2000                         msecs_to_jiffies(host->pdata->detect_delay_ms));
2001         }
2002 }
2003 
2004 #ifdef CONFIG_OF
2005 /* given a slot id, find out the device node representing that slot */
2006 static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
2007 {
2008         struct device_node *np;
2009         const __be32 *addr;
2010         int len;
2011 
2012         if (!dev || !dev->of_node)
2013                 return NULL;
2014 
2015         for_each_child_of_node(dev->of_node, np) {
2016                 addr = of_get_property(np, "reg", &len);
2017                 if (!addr || (len < sizeof(int)))
2018                         continue;
2019                 if (be32_to_cpup(addr) == slot)
2020                         return np;
2021         }
2022         return NULL;
2023 }
2024 
2025 static struct dw_mci_of_slot_quirks {
2026         char *quirk;
2027         int id;
2028 } of_slot_quirks[] = {
2029         {
2030                 .quirk  = "disable-wp",
2031                 .id     = DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT,
2032         },
2033 };
2034 
2035 static int dw_mci_of_get_slot_quirks(struct device *dev, u8 slot)
2036 {
2037         struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
2038         int quirks = 0;
2039         int idx;
2040 
2041         /* get quirks */
2042         for (idx = 0; idx < ARRAY_SIZE(of_slot_quirks); idx++)
2043                 if (of_get_property(np, of_slot_quirks[idx].quirk, NULL))
2044                         quirks |= of_slot_quirks[idx].id;
2045 
2046         return quirks;
2047 }
2048 
2049 /* find out bus-width for a given slot */
2050 static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
2051 {
2052         struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
2053         u32 bus_wd = 1;
2054 
2055         if (!np)
2056                 return 1;
2057 
2058         if (of_property_read_u32(np, "bus-width", &bus_wd))
2059                 dev_err(dev, "bus-width property not found, assuming width"
2060                                " as 1\n");
2061         return bus_wd;
2062 }
2063 
2064 /* find the write protect gpio for a given slot; or -1 if none specified */
2065 static int dw_mci_of_get_wp_gpio(struct device *dev, u8 slot)
2066 {
2067         struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
2068         int gpio;
2069 
2070         if (!np)
2071                 return -EINVAL;
2072 
2073         gpio = of_get_named_gpio(np, "wp-gpios", 0);
2074 
2075         /* Having a missing entry is valid; return silently */
2076         if (!gpio_is_valid(gpio))
2077                 return -EINVAL;
2078 
2079         if (devm_gpio_request(dev, gpio, "dw-mci-wp")) {
2080                 dev_warn(dev, "gpio [%d] request failed\n", gpio);
2081                 return -EINVAL;
2082         }
2083 
2084         return gpio;
2085 }
2086 
2087 /* find the cd gpio for a given slot */
2088 static void dw_mci_of_get_cd_gpio(struct device *dev, u8 slot,
2089                                         struct mmc_host *mmc)
2090 {
2091         struct device_node *np = dw_mci_of_find_slot_node(dev, slot);
2092         int gpio;
2093 
2094         if (!np)
2095                 return;
2096 
2097         gpio = of_get_named_gpio(np, "cd-gpios", 0);
2098 
2099         /* Having a missing entry is valid; return silently */
2100         if (!gpio_is_valid(gpio))
2101                 return;
2102 
2103         if (mmc_gpio_request_cd(mmc, gpio, 0))
2104                 dev_warn(dev, "gpio [%d] request failed\n", gpio);
2105 }
2106 #else /* CONFIG_OF */
2107 static int dw_mci_of_get_slot_quirks(struct device *dev, u8 slot)
2108 {
2109         return 0;
2110 }
2111 static u32 dw_mci_of_get_bus_wd(struct device *dev, u8 slot)
2112 {
2113         return 1;
2114 }
2115 static struct device_node *dw_mci_of_find_slot_node(struct device *dev, u8 slot)
2116 {
2117         return NULL;
2118 }
2119 static int dw_mci_of_get_wp_gpio(struct device *dev, u8 slot)
2120 {
2121         return -EINVAL;
2122 }
2123 static void dw_mci_of_get_cd_gpio(struct device *dev, u8 slot,
2124                                         struct mmc_host *mmc)
2125 {
2126         return;
2127 }
2128 #endif /* CONFIG_OF */
2129 
2130 static int dw_mci_init_slot(struct dw_mci *host, unsigned int id)
2131 {
2132         struct mmc_host *mmc;
2133         struct dw_mci_slot *slot;
2134         const struct dw_mci_drv_data *drv_data = host->drv_data;
2135         int ctrl_id, ret;
2136         u32 freq[2];
2137         u8 bus_width;
2138 
2139         mmc = mmc_alloc_host(sizeof(struct dw_mci_slot), host->dev);
2140         if (!mmc)
2141                 return -ENOMEM;
2142 
2143         slot = mmc_priv(mmc);
2144         slot->id = id;
2145         slot->mmc = mmc;
2146         slot->host = host;
2147         host->slot[id] = slot;
2148 
2149         slot->quirks = dw_mci_of_get_slot_quirks(host->dev, slot->id);
2150 
2151         mmc->ops = &dw_mci_ops;
2152         if (of_property_read_u32_array(host->dev->of_node,
2153                                        "clock-freq-min-max", freq, 2)) {
2154                 mmc->f_min = DW_MCI_FREQ_MIN;
2155                 mmc->f_max = DW_MCI_FREQ_MAX;
2156         } else {
2157                 mmc->f_min = freq[0];
2158                 mmc->f_max = freq[1];
2159         }
2160 
2161         if (host->pdata->get_ocr)
2162                 mmc->ocr_avail = host->pdata->get_ocr(id);
2163         else
2164                 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
2165 
2166         /*
2167          * Start with slot power disabled, it will be enabled when a card
2168          * is detected.
2169          */
2170         if (host->pdata->setpower)
2171                 host->pdata->setpower(id, 0);
2172 
2173         if (host->pdata->caps)
2174                 mmc->caps = host->pdata->caps;
2175 
2176         if (host->pdata->pm_caps)
2177                 mmc->pm_caps = host->pdata->pm_caps;
2178 
2179         if (host->dev->of_node) {
2180                 ctrl_id = of_alias_get_id(host->dev->of_node, "mshc");
2181                 if (ctrl_id < 0)
2182                         ctrl_id = 0;
2183         } else {
2184                 ctrl_id = to_platform_device(host->dev)->id;
2185         }
2186         if (drv_data && drv_data->caps)
2187                 mmc->caps |= drv_data->caps[ctrl_id];
2188 
2189         if (host->pdata->caps2)
2190                 mmc->caps2 = host->pdata->caps2;
2191 
2192         if (host->pdata->get_bus_wd)
2193                 bus_width = host->pdata->get_bus_wd(slot->id);
2194         else if (host->dev->of_node)
2195                 bus_width = dw_mci_of_get_bus_wd(host->dev, slot->id);
2196         else
2197                 bus_width = 1;
2198 
2199         switch (bus_width) {
2200         case 8:
2201                 mmc->caps |= MMC_CAP_8_BIT_DATA;
2202         case 4:
2203                 mmc->caps |= MMC_CAP_4_BIT_DATA;
2204         }
2205 
2206         if (host->pdata->blk_settings) {
2207                 mmc->max_segs = host->pdata->blk_settings->max_segs;
2208                 mmc->max_blk_size = host->pdata->blk_settings->max_blk_size;
2209                 mmc->max_blk_count = host->pdata->blk_settings->max_blk_count;
2210                 mmc->max_req_size = host->pdata->blk_settings->max_req_size;
2211                 mmc->max_seg_size = host->pdata->blk_settings->max_seg_size;
2212         } else {
2213                 /* Useful defaults if platform data is unset. */
2214 #ifdef CONFIG_MMC_DW_IDMAC
2215                 mmc->max_segs = host->ring_size;
2216                 mmc->max_blk_size = 65536;
2217                 mmc->max_blk_count = host->ring_size;
2218                 mmc->max_seg_size = 0x1000;
2219                 mmc->max_req_size = mmc->max_seg_size * mmc->max_blk_count;
2220 #else
2221                 mmc->max_segs = 64;
2222                 mmc->max_blk_size = 65536; /* BLKSIZ is 16 bits */
2223                 mmc->max_blk_count = 512;
2224                 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
2225                 mmc->max_seg_size = mmc->max_req_size;
2226 #endif /* CONFIG_MMC_DW_IDMAC */
2227         }
2228 
2229         slot->wp_gpio = dw_mci_of_get_wp_gpio(host->dev, slot->id);
2230         dw_mci_of_get_cd_gpio(host->dev, slot->id, mmc);
2231 
2232         ret = mmc_add_host(mmc);
2233         if (ret)
2234                 goto err_setup_bus;
2235 
2236 #if defined(CONFIG_DEBUG_FS)
2237         dw_mci_init_debugfs(slot);
2238 #endif
2239 
2240         /* Card initially undetected */
2241         slot->last_detect_state = 0;
2242 
2243         return 0;
2244 
2245 err_setup_bus:
2246         mmc_free_host(mmc);
2247         return -EINVAL;
2248 }
2249 
2250 static void dw_mci_cleanup_slot(struct dw_mci_slot *slot, unsigned int id)
2251 {
2252         /* Shutdown detect IRQ */
2253         if (slot->host->pdata->exit)
2254                 slot->host->pdata->exit(id);
2255 
2256         /* Debugfs stuff is cleaned up by mmc core */
2257         mmc_remove_host(slot->mmc);
2258         slot->host->slot[id] = NULL;
2259         mmc_free_host(slot->mmc);
2260 }
2261 
2262 static void dw_mci_init_dma(struct dw_mci *host)
2263 {
2264         /* Alloc memory for sg translation */
2265         host->sg_cpu = dmam_alloc_coherent(host->dev, PAGE_SIZE,
2266                                           &host->sg_dma, GFP_KERNEL);
2267         if (!host->sg_cpu) {
2268                 dev_err(host->dev, "%s: could not alloc DMA memory\n",
2269                         __func__);
2270                 goto no_dma;
2271         }
2272 
2273         /* Determine which DMA interface to use */
2274 #ifdef CONFIG_MMC_DW_IDMAC
2275         host->dma_ops = &dw_mci_idmac_ops;
2276         dev_info(host->dev, "Using internal DMA controller.\n");
2277 #endif
2278 
2279         if (!host->dma_ops)
2280                 goto no_dma;
2281 
2282         if (host->dma_ops->init && host->dma_ops->start &&
2283             host->dma_ops->stop && host->dma_ops->cleanup) {
2284                 if (host->dma_ops->init(host)) {
2285                         dev_err(host->dev, "%s: Unable to initialize "
2286                                 "DMA Controller.\n", __func__);
2287                         goto no_dma;
2288                 }
2289         } else {
2290                 dev_err(host->dev, "DMA initialization not found.\n");
2291                 goto no_dma;
2292         }
2293 
2294         host->use_dma = 1;
2295         return;
2296 
2297 no_dma:
2298         dev_info(host->dev, "Using PIO mode.\n");
2299         host->use_dma = 0;
2300         return;
2301 }
2302 
2303 static bool dw_mci_ctrl_reset(struct dw_mci *host, u32 reset)
2304 {
2305         unsigned long timeout = jiffies + msecs_to_jiffies(500);
2306         u32 ctrl;
2307 
2308         ctrl = mci_readl(host, CTRL);
2309         ctrl |= reset;
2310         mci_writel(host, CTRL, ctrl);
2311 
2312         /* wait till resets clear */
2313         do {
2314                 ctrl = mci_readl(host, CTRL);
2315                 if (!(ctrl & reset))
2316                         return true;
2317         } while (time_before(jiffies, timeout));
2318 
2319         dev_err(host->dev,
2320                 "Timeout resetting block (ctrl reset %#x)\n",
2321                 ctrl & reset);
2322 
2323         return false;
2324 }
2325 
2326 static inline bool dw_mci_fifo_reset(struct dw_mci *host)
2327 {
2328         /*
2329          * Reseting generates a block interrupt, hence setting
2330          * the scatter-gather pointer to NULL.
2331          */
2332         if (host->sg) {
2333                 sg_miter_stop(&host->sg_miter);
2334                 host->sg = NULL;
2335         }
2336 
2337         return dw_mci_ctrl_reset(host, SDMMC_CTRL_FIFO_RESET);
2338 }
2339 
2340 static inline bool dw_mci_ctrl_all_reset(struct dw_mci *host)
2341 {
2342         return dw_mci_ctrl_reset(host,
2343                                  SDMMC_CTRL_FIFO_RESET |
2344                                  SDMMC_CTRL_RESET |
2345                                  SDMMC_CTRL_DMA_RESET);
2346 }
2347 
2348 #ifdef CONFIG_OF
2349 static struct dw_mci_of_quirks {
2350         char *quirk;
2351         int id;
2352 } of_quirks[] = {
2353         {
2354                 .quirk  = "broken-cd",
2355                 .id     = DW_MCI_QUIRK_BROKEN_CARD_DETECTION,
2356         },
2357 };
2358 
2359 static struct dw_mci_board *dw_mci_parse_dt(struct dw_mci *host)
2360 {
2361         struct dw_mci_board *pdata;
2362         struct device *dev = host->dev;
2363         struct device_node *np = dev->of_node;
2364         const struct dw_mci_drv_data *drv_data = host->drv_data;
2365         int idx, ret;
2366         u32 clock_frequency;
2367 
2368         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
2369         if (!pdata) {
2370                 dev_err(dev, "could not allocate memory for pdata\n");
2371                 return ERR_PTR(-ENOMEM);
2372         }
2373 
2374         /* find out number of slots supported */
2375         if (of_property_read_u32(dev->of_node, "num-slots",
2376                                 &pdata->num_slots)) {
2377                 dev_info(dev, "num-slots property not found, "
2378                                 "assuming 1 slot is available\n");
2379                 pdata->num_slots = 1;
2380         }
2381 
2382         /* get quirks */
2383         for (idx = 0; idx < ARRAY_SIZE(of_quirks); idx++)
2384                 if (of_get_property(np, of_quirks[idx].quirk, NULL))
2385                         pdata->quirks |= of_quirks[idx].id;
2386 
2387         if (of_property_read_u32(np, "fifo-depth", &pdata->fifo_depth))
2388                 dev_info(dev, "fifo-depth property not found, using "
2389                                 "value of FIFOTH register as default\n");
2390 
2391         of_property_read_u32(np, "card-detect-delay", &pdata->detect_delay_ms);
2392 
2393         if (!of_property_read_u32(np, "clock-frequency", &clock_frequency))
2394                 pdata->bus_hz = clock_frequency;
2395 
2396         if (drv_data && drv_data->parse_dt) {
2397                 ret = drv_data->parse_dt(host);
2398                 if (ret)
2399                         return ERR_PTR(ret);
2400         }
2401 
2402         if (of_find_property(np, "keep-power-in-suspend", NULL))
2403                 pdata->pm_caps |= MMC_PM_KEEP_POWER;
2404 
2405         if (of_find_property(np, "enable-sdio-wakeup", NULL))
2406                 pdata->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
2407 
2408         if (of_find_property(np, "supports-highspeed", NULL))
2409                 pdata->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
2410 
2411         if (of_find_property(np, "caps2-mmc-hs200-1_8v", NULL))
2412                 pdata->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
2413 
2414         if (of_find_property(np, "caps2-mmc-hs200-1_2v", NULL))
2415                 pdata->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
2416 
2417         if (of_get_property(np, "cd-inverted", NULL))
2418                 pdata->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
2419 
2420         return pdata;
2421 }
2422 
2423 #else /* CONFIG_OF */
2424 static struct dw_mci_board *dw_mci_parse_dt(struct dw_mci *host)
2425 {
2426         return ERR_PTR(-EINVAL);
2427 }
2428 #endif /* CONFIG_OF */
2429 
2430 int dw_mci_probe(struct dw_mci *host)
2431 {
2432         const struct dw_mci_drv_data *drv_data = host->drv_data;
2433         int width, i, ret = 0;
2434         u32 fifo_size;
2435         int init_slots = 0;
2436 
2437         if (!host->pdata) {
2438                 host->pdata = dw_mci_parse_dt(host);
2439                 if (IS_ERR(host->pdata)) {
2440                         dev_err(host->dev, "platform data not available\n");
2441                         return -EINVAL;
2442                 }
2443         }
2444 
2445         if (!host->pdata->select_slot && host->pdata->num_slots > 1) {
2446                 dev_err(host->dev,
2447                         "Platform data must supply select_slot function\n");
2448                 return -ENODEV;
2449         }
2450 
2451         host->biu_clk = devm_clk_get(host->dev, "biu");
2452         if (IS_ERR(host->biu_clk)) {
2453                 dev_dbg(host->dev, "biu clock not available\n");
2454         } else {
2455                 ret = clk_prepare_enable(host->biu_clk);
2456                 if (ret) {
2457                         dev_err(host->dev, "failed to enable biu clock\n");
2458                         return ret;
2459                 }
2460         }
2461 
2462         host->ciu_clk = devm_clk_get(host->dev, "ciu");
2463         if (IS_ERR(host->ciu_clk)) {
2464                 dev_dbg(host->dev, "ciu clock not available\n");
2465                 host->bus_hz = host->pdata->bus_hz;
2466         } else {
2467                 ret = clk_prepare_enable(host->ciu_clk);
2468                 if (ret) {
2469                         dev_err(host->dev, "failed to enable ciu clock\n");
2470                         goto err_clk_biu;
2471                 }
2472 
2473                 if (host->pdata->bus_hz) {
2474                         ret = clk_set_rate(host->ciu_clk, host->pdata->bus_hz);
2475                         if (ret)
2476                                 dev_warn(host->dev,
2477                                          "Unable to set bus rate to %ul\n",
2478                                          host->pdata->bus_hz);
2479                 }
2480                 host->bus_hz = clk_get_rate(host->ciu_clk);
2481         }
2482 
2483         if (drv_data && drv_data->init) {
2484                 ret = drv_data->init(host);
2485                 if (ret) {
2486                         dev_err(host->dev,
2487                                 "implementation specific init failed\n");
2488                         goto err_clk_ciu;
2489                 }
2490         }
2491 
2492         if (drv_data && drv_data->setup_clock) {
2493                 ret = drv_data->setup_clock(host);
2494                 if (ret) {
2495                         dev_err(host->dev,
2496                                 "implementation specific clock setup failed\n");
2497                         goto err_clk_ciu;
2498                 }
2499         }
2500 
2501         host->vmmc = devm_regulator_get_optional(host->dev, "vmmc");
2502         if (IS_ERR(host->vmmc)) {
2503                 ret = PTR_ERR(host->vmmc);
2504                 if (ret == -EPROBE_DEFER)
2505                         goto err_clk_ciu;
2506 
2507                 dev_info(host->dev, "no vmmc regulator found: %d\n", ret);
2508                 host->vmmc = NULL;
2509         } else {
2510                 ret = regulator_enable(host->vmmc);
2511                 if (ret) {
2512                         if (ret != -EPROBE_DEFER)
2513                                 dev_err(host->dev,
2514                                         "regulator_enable fail: %d\n", ret);
2515                         goto err_clk_ciu;
2516                 }
2517         }
2518 
2519         if (!host->bus_hz) {
2520                 dev_err(host->dev,
2521                         "Platform data must supply bus speed\n");
2522                 ret = -ENODEV;
2523                 goto err_regulator;
2524         }
2525 
2526         host->quirks = host->pdata->quirks;
2527 
2528         spin_lock_init(&host->lock);
2529         INIT_LIST_HEAD(&host->queue);
2530 
2531         /*
2532          * Get the host data width - this assumes that HCON has been set with
2533          * the correct values.
2534          */
2535         i = (mci_readl(host, HCON) >> 7) & 0x7;
2536         if (!i) {
2537                 host->push_data = dw_mci_push_data16;
2538                 host->pull_data = dw_mci_pull_data16;
2539                 width = 16;
2540                 host->data_shift = 1;
2541         } else if (i == 2) {
2542                 host->push_data = dw_mci_push_data64;
2543                 host->pull_data = dw_mci_pull_data64;
2544                 width = 64;
2545                 host->data_shift = 3;
2546         } else {
2547                 /* Check for a reserved value, and warn if it is */
2548                 WARN((i != 1),
2549                      "HCON reports a reserved host data width!\n"
2550                      "Defaulting to 32-bit access.\n");
2551                 host->push_data = dw_mci_push_data32;
2552                 host->pull_data = dw_mci_pull_data32;
2553                 width = 32;
2554                 host->data_shift = 2;
2555         }
2556 
2557         /* Reset all blocks */
2558         if (!dw_mci_ctrl_all_reset(host))
2559                 return -ENODEV;
2560 
2561         host->dma_ops = host->pdata->dma_ops;
2562         dw_mci_init_dma(host);
2563 
2564         /* Clear the interrupts for the host controller */
2565         mci_writel(host, RINTSTS, 0xFFFFFFFF);
2566         mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
2567 
2568         /* Put in max timeout */
2569         mci_writel(host, TMOUT, 0xFFFFFFFF);
2570 
2571         /*
2572          * FIFO threshold settings  RxMark  = fifo_size / 2 - 1,
2573          *                          Tx Mark = fifo_size / 2 DMA Size = 8
2574          */
2575         if (!host->pdata->fifo_depth) {
2576                 /*
2577                  * Power-on value of RX_WMark is FIFO_DEPTH-1, but this may
2578                  * have been overwritten by the bootloader, just like we're
2579                  * about to do, so if you know the value for your hardware, you
2580                  * should put it in the platform data.
2581                  */
2582                 fifo_size = mci_readl(host, FIFOTH);
2583                 fifo_size = 1 + ((fifo_size >> 16) & 0xfff);
2584         } else {
2585                 fifo_size = host->pdata->fifo_depth;
2586         }
2587         host->fifo_depth = fifo_size;
2588         host->fifoth_val =
2589                 SDMMC_SET_FIFOTH(0x2, fifo_size / 2 - 1, fifo_size / 2);
2590         mci_writel(host, FIFOTH, host->fifoth_val);
2591 
2592         /* disable clock to CIU */
2593         mci_writel(host, CLKENA, 0);
2594         mci_writel(host, CLKSRC, 0);
2595 
2596         /*
2597          * In 2.40a spec, Data offset is changed.
2598          * Need to check the version-id and set data-offset for DATA register.
2599          */
2600         host->verid = SDMMC_GET_VERID(mci_readl(host, VERID));
2601         dev_info(host->dev, "Version ID is %04x\n", host->verid);
2602 
2603         if (host->verid < DW_MMC_240A)
2604                 host->data_offset = DATA_OFFSET;
2605         else
2606                 host->data_offset = DATA_240A_OFFSET;
2607 
2608         tasklet_init(&host->tasklet, dw_mci_tasklet_func, (unsigned long)host);
2609         host->card_workqueue = alloc_workqueue("dw-mci-card",
2610                         WQ_MEM_RECLAIM, 1);
2611         if (!host->card_workqueue) {
2612                 ret = -ENOMEM;
2613                 goto err_dmaunmap;
2614         }
2615         INIT_WORK(&host->card_work, dw_mci_work_routine_card);
2616         ret = devm_request_irq(host->dev, host->irq, dw_mci_interrupt,
2617                                host->irq_flags, "dw-mci", host);
2618         if (ret)
2619                 goto err_workqueue;
2620 
2621         if (host->pdata->num_slots)
2622                 host->num_slots = host->pdata->num_slots;
2623         else
2624                 host->num_slots = ((mci_readl(host, HCON) >> 1) & 0x1F) + 1;
2625 
2626         /*
2627          * Enable interrupts for command done, data over, data empty, card det,
2628          * receive ready and error such as transmit, receive timeout, crc error
2629          */
2630         mci_writel(host, RINTSTS, 0xFFFFFFFF);
2631         mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
2632                    SDMMC_INT_TXDR | SDMMC_INT_RXDR |
2633                    DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
2634         mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE); /* Enable mci interrupt */
2635 
2636         dev_info(host->dev, "DW MMC controller at irq %d, "
2637                  "%d bit host data width, "
2638                  "%u deep fifo\n",
2639                  host->irq, width, fifo_size);
2640 
2641         /* We need at least one slot to succeed */
2642         for (i = 0; i < host->num_slots; i++) {
2643                 ret = dw_mci_init_slot(host, i);
2644                 if (ret)
2645                         dev_dbg(host->dev, "slot %d init failed\n", i);
2646                 else
2647                         init_slots++;
2648         }
2649 
2650         if (init_slots) {
2651                 dev_info(host->dev, "%d slots initialized\n", init_slots);
2652         } else {
2653                 dev_dbg(host->dev, "attempted to initialize %d slots, "
2654                                         "but failed on all\n", host->num_slots);
2655                 goto err_workqueue;
2656         }
2657 
2658         if (host->quirks & DW_MCI_QUIRK_IDMAC_DTO)
2659                 dev_info(host->dev, "Internal DMAC interrupt fix enabled.\n");
2660 
2661         return 0;
2662 
2663 err_workqueue:
2664         destroy_workqueue(host->card_workqueue);
2665 
2666 err_dmaunmap:
2667         if (host->use_dma && host->dma_ops->exit)
2668                 host->dma_ops->exit(host);
2669 
2670 err_regulator:
2671         if (host->vmmc)
2672                 regulator_disable(host->vmmc);
2673 
2674 err_clk_ciu:
2675         if (!IS_ERR(host->ciu_clk))
2676                 clk_disable_unprepare(host->ciu_clk);
2677 
2678 err_clk_biu:
2679         if (!IS_ERR(host->biu_clk))
2680                 clk_disable_unprepare(host->biu_clk);
2681 
2682         return ret;
2683 }
2684 EXPORT_SYMBOL(dw_mci_probe);
2685 
2686 void dw_mci_remove(struct dw_mci *host)
2687 {
2688         int i;
2689 
2690         mci_writel(host, RINTSTS, 0xFFFFFFFF);
2691         mci_writel(host, INTMASK, 0); /* disable all mmc interrupt first */
2692 
2693         for (i = 0; i < host->num_slots; i++) {
2694                 dev_dbg(host->dev, "remove slot %d\n", i);
2695                 if (host->slot[i])
2696                         dw_mci_cleanup_slot(host->slot[i], i);
2697         }
2698 
2699         /* disable clock to CIU */
2700         mci_writel(host, CLKENA, 0);
2701         mci_writel(host, CLKSRC, 0);
2702 
2703         destroy_workqueue(host->card_workqueue);
2704 
2705         if (host->use_dma && host->dma_ops->exit)
2706                 host->dma_ops->exit(host);
2707 
2708         if (host->vmmc)
2709                 regulator_disable(host->vmmc);
2710 
2711         if (!IS_ERR(host->ciu_clk))
2712                 clk_disable_unprepare(host->ciu_clk);
2713 
2714         if (!IS_ERR(host->biu_clk))
2715                 clk_disable_unprepare(host->biu_clk);
2716 }
2717 EXPORT_SYMBOL(dw_mci_remove);
2718 
2719 
2720 
2721 #ifdef CONFIG_PM_SLEEP
2722 /*
2723  * TODO: we should probably disable the clock to the card in the suspend path.
2724  */
2725 int dw_mci_suspend(struct dw_mci *host)
2726 {
2727         if (host->vmmc)
2728                 regulator_disable(host->vmmc);
2729 
2730         return 0;
2731 }
2732 EXPORT_SYMBOL(dw_mci_suspend);
2733 
2734 int dw_mci_resume(struct dw_mci *host)
2735 {
2736         int i, ret;
2737 
2738         if (host->vmmc) {
2739                 ret = regulator_enable(host->vmmc);
2740                 if (ret) {
2741                         dev_err(host->dev,
2742                                 "failed to enable regulator: %d\n", ret);
2743                         return ret;
2744                 }
2745         }
2746 
2747         if (!dw_mci_ctrl_all_reset(host)) {
2748                 ret = -ENODEV;
2749                 return ret;
2750         }
2751 
2752         if (host->use_dma && host->dma_ops->init)
2753                 host->dma_ops->init(host);
2754 
2755         /*
2756          * Restore the initial value at FIFOTH register
2757          * And Invalidate the prev_blksz with zero
2758          */
2759         mci_writel(host, FIFOTH, host->fifoth_val);
2760         host->prev_blksz = 0;
2761 
2762         /* Put in max timeout */
2763         mci_writel(host, TMOUT, 0xFFFFFFFF);
2764 
2765         mci_writel(host, RINTSTS, 0xFFFFFFFF);
2766         mci_writel(host, INTMASK, SDMMC_INT_CMD_DONE | SDMMC_INT_DATA_OVER |
2767                    SDMMC_INT_TXDR | SDMMC_INT_RXDR |
2768                    DW_MCI_ERROR_FLAGS | SDMMC_INT_CD);
2769         mci_writel(host, CTRL, SDMMC_CTRL_INT_ENABLE);
2770 
2771         for (i = 0; i < host->num_slots; i++) {
2772                 struct dw_mci_slot *slot = host->slot[i];
2773                 if (!slot)
2774                         continue;
2775                 if (slot->mmc->pm_flags & MMC_PM_KEEP_POWER) {
2776                         dw_mci_set_ios(slot->mmc, &slot->mmc->ios);
2777                         dw_mci_setup_bus(slot, true);
2778                 }
2779         }
2780         return 0;
2781 }
2782 EXPORT_SYMBOL(dw_mci_resume);
2783 #endif /* CONFIG_PM_SLEEP */
2784 
2785 static int __init dw_mci_init(void)
2786 {
2787         pr_info("Synopsys Designware Multimedia Card Interface Driver\n");
2788         return 0;
2789 }
2790 
2791 static void __exit dw_mci_exit(void)
2792 {
2793 }
2794 
2795 module_init(dw_mci_init);
2796 module_exit(dw_mci_exit);
2797 
2798 MODULE_DESCRIPTION("DW Multimedia Card Interface driver");
2799 MODULE_AUTHOR("NXP Semiconductor VietNam");
2800 MODULE_AUTHOR("Imagination Technologies Ltd");
2801 MODULE_LICENSE("GPL v2");
2802 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us