1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * WM8505/WM8650 SD/MMC Host Controller
4 *
5 * Copyright (C) 2010 Tony Prisk
6 * Copyright (C) 2008 WonderMedia Technologies, Inc.
7 */
8
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/platform_device.h>
12 #include <linux/ioport.h>
13 #include <linux/errno.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/delay.h>
16 #include <linux/io.h>
17 #include <linux/irq.h>
18 #include <linux/clk.h>
19 #include <linux/interrupt.h>
20
21 #include <linux/of.h>
22 #include <linux/of_address.h>
23 #include <linux/of_irq.h>
24 #include <linux/of_device.h>
25
26 #include <linux/mmc/host.h>
27 #include <linux/mmc/mmc.h>
28 #include <linux/mmc/sd.h>
29
30 #include <asm/byteorder.h>
31
32
33 #define DRIVER_NAME "wmt-sdhc"
34
35
36 /* MMC/SD controller registers */
37 #define SDMMC_CTLR 0x00
38 #define SDMMC_CMD 0x01
39 #define SDMMC_RSPTYPE 0x02
40 #define SDMMC_ARG 0x04
41 #define SDMMC_BUSMODE 0x08
42 #define SDMMC_BLKLEN 0x0C
43 #define SDMMC_BLKCNT 0x0E
44 #define SDMMC_RSP 0x10
45 #define SDMMC_CBCR 0x20
46 #define SDMMC_INTMASK0 0x24
47 #define SDMMC_INTMASK1 0x25
48 #define SDMMC_STS0 0x28
49 #define SDMMC_STS1 0x29
50 #define SDMMC_STS2 0x2A
51 #define SDMMC_STS3 0x2B
52 #define SDMMC_RSPTIMEOUT 0x2C
53 #define SDMMC_CLK 0x30 /* VT8500 only */
54 #define SDMMC_EXTCTRL 0x34
55 #define SDMMC_SBLKLEN 0x38
56 #define SDMMC_DMATIMEOUT 0x3C
57
58
59 /* SDMMC_CTLR bit fields */
60 #define CTLR_CMD_START 0x01
61 #define CTLR_CMD_WRITE 0x04
62 #define CTLR_FIFO_RESET 0x08
63
64 /* SDMMC_BUSMODE bit fields */
65 #define BM_SPI_MODE 0x01
66 #define BM_FOURBIT_MODE 0x02
67 #define BM_EIGHTBIT_MODE 0x04
68 #define BM_SD_OFF 0x10
69 #define BM_SPI_CS 0x20
70 #define BM_SD_POWER 0x40
71 #define BM_SOFT_RESET 0x80
72
73 /* SDMMC_BLKLEN bit fields */
74 #define BLKL_CRCERR_ABORT 0x0800
75 #define BLKL_CD_POL_HIGH 0x1000
76 #define BLKL_GPI_CD 0x2000
77 #define BLKL_DATA3_CD 0x4000
78 #define BLKL_INT_ENABLE 0x8000
79
80 /* SDMMC_INTMASK0 bit fields */
81 #define INT0_MBLK_TRAN_DONE_INT_EN 0x10
82 #define INT0_BLK_TRAN_DONE_INT_EN 0x20
83 #define INT0_CD_INT_EN 0x40
84 #define INT0_DI_INT_EN 0x80
85
86 /* SDMMC_INTMASK1 bit fields */
87 #define INT1_CMD_RES_TRAN_DONE_INT_EN 0x02
88 #define INT1_CMD_RES_TOUT_INT_EN 0x04
89 #define INT1_MBLK_AUTO_STOP_INT_EN 0x08
90 #define INT1_DATA_TOUT_INT_EN 0x10
91 #define INT1_RESCRC_ERR_INT_EN 0x20
92 #define INT1_RCRC_ERR_INT_EN 0x40
93 #define INT1_WCRC_ERR_INT_EN 0x80
94
95 /* SDMMC_STS0 bit fields */
96 #define STS0_WRITE_PROTECT 0x02
97 #define STS0_CD_DATA3 0x04
98 #define STS0_CD_GPI 0x08
99 #define STS0_MBLK_DONE 0x10
100 #define STS0_BLK_DONE 0x20
101 #define STS0_CARD_DETECT 0x40
102 #define STS0_DEVICE_INS 0x80
103
104 /* SDMMC_STS1 bit fields */
105 #define STS1_SDIO_INT 0x01
106 #define STS1_CMDRSP_DONE 0x02
107 #define STS1_RSP_TIMEOUT 0x04
108 #define STS1_AUTOSTOP_DONE 0x08
109 #define STS1_DATA_TIMEOUT 0x10
110 #define STS1_RSP_CRC_ERR 0x20
111 #define STS1_RCRC_ERR 0x40
112 #define STS1_WCRC_ERR 0x80
113
114 /* SDMMC_STS2 bit fields */
115 #define STS2_CMD_RES_BUSY 0x10
116 #define STS2_DATARSP_BUSY 0x20
117 #define STS2_DIS_FORCECLK 0x80
118
119 /* SDMMC_EXTCTRL bit fields */
120 #define EXT_EIGHTBIT 0x04
121
122 /* MMC/SD DMA Controller Registers */
123 #define SDDMA_GCR 0x100
124 #define SDDMA_IER 0x104
125 #define SDDMA_ISR 0x108
126 #define SDDMA_DESPR 0x10C
127 #define SDDMA_RBR 0x110
128 #define SDDMA_DAR 0x114
129 #define SDDMA_BAR 0x118
130 #define SDDMA_CPR 0x11C
131 #define SDDMA_CCR 0x120
132
133
134 /* SDDMA_GCR bit fields */
135 #define DMA_GCR_DMA_EN 0x00000001
136 #define DMA_GCR_SOFT_RESET 0x00000100
137
138 /* SDDMA_IER bit fields */
139 #define DMA_IER_INT_EN 0x00000001
140
141 /* SDDMA_ISR bit fields */
142 #define DMA_ISR_INT_STS 0x00000001
143
144 /* SDDMA_RBR bit fields */
145 #define DMA_RBR_FORMAT 0x40000000
146 #define DMA_RBR_END 0x80000000
147
148 /* SDDMA_CCR bit fields */
149 #define DMA_CCR_RUN 0x00000080
150 #define DMA_CCR_IF_TO_PERIPHERAL 0x00000000
151 #define DMA_CCR_PERIPHERAL_TO_IF 0x00400000
152
153 /* SDDMA_CCR event status */
154 #define DMA_CCR_EVT_NO_STATUS 0x00000000
155 #define DMA_CCR_EVT_UNDERRUN 0x00000001
156 #define DMA_CCR_EVT_OVERRUN 0x00000002
157 #define DMA_CCR_EVT_DESP_READ 0x00000003
158 #define DMA_CCR_EVT_DATA_RW 0x00000004
159 #define DMA_CCR_EVT_EARLY_END 0x00000005
160 #define DMA_CCR_EVT_SUCCESS 0x0000000F
161
162 #define PDMA_READ 0x00
163 #define PDMA_WRITE 0x01
164
165 #define WMT_SD_POWER_OFF 0
166 #define WMT_SD_POWER_ON 1
167
168 struct wmt_dma_descriptor {
169 u32 flags;
170 u32 data_buffer_addr;
171 u32 branch_addr;
172 u32 reserved1;
173 };
174
175 struct wmt_mci_caps {
176 unsigned int f_min;
177 unsigned int f_max;
178 u32 ocr_avail;
179 u32 caps;
180 u32 max_seg_size;
181 u32 max_segs;
182 u32 max_blk_size;
183 };
184
185 struct wmt_mci_priv {
186 struct mmc_host *mmc;
187 void __iomem *sdmmc_base;
188
189 int irq_regular;
190 int irq_dma;
191
192 void *dma_desc_buffer;
193 dma_addr_t dma_desc_device_addr;
194
195 struct completion cmdcomp;
196 struct completion datacomp;
197
198 struct completion *comp_cmd;
199 struct completion *comp_dma;
200
201 struct mmc_request *req;
202 struct mmc_command *cmd;
203
204 struct clk *clk_sdmmc;
205 struct device *dev;
206
207 u8 power_inverted;
208 u8 cd_inverted;
209 };
210
wmt_set_sd_power(struct wmt_mci_priv * priv,int enable)211 static void wmt_set_sd_power(struct wmt_mci_priv *priv, int enable)
212 {
213 u32 reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
214
215 if (enable ^ priv->power_inverted)
216 reg_tmp &= ~BM_SD_OFF;
217 else
218 reg_tmp |= BM_SD_OFF;
219
220 writeb(reg_tmp, priv->sdmmc_base + SDMMC_BUSMODE);
221 }
222
wmt_mci_read_response(struct mmc_host * mmc)223 static void wmt_mci_read_response(struct mmc_host *mmc)
224 {
225 struct wmt_mci_priv *priv;
226 int idx1, idx2;
227 u8 tmp_resp;
228 u32 response;
229
230 priv = mmc_priv(mmc);
231
232 for (idx1 = 0; idx1 < 4; idx1++) {
233 response = 0;
234 for (idx2 = 0; idx2 < 4; idx2++) {
235 if ((idx1 == 3) && (idx2 == 3))
236 tmp_resp = readb(priv->sdmmc_base + SDMMC_RSP);
237 else
238 tmp_resp = readb(priv->sdmmc_base + SDMMC_RSP +
239 (idx1*4) + idx2 + 1);
240 response |= (tmp_resp << (idx2 * 8));
241 }
242 priv->cmd->resp[idx1] = cpu_to_be32(response);
243 }
244 }
245
wmt_mci_start_command(struct wmt_mci_priv * priv)246 static void wmt_mci_start_command(struct wmt_mci_priv *priv)
247 {
248 u32 reg_tmp;
249
250 reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
251 writeb(reg_tmp | CTLR_CMD_START, priv->sdmmc_base + SDMMC_CTLR);
252 }
253
wmt_mci_send_command(struct mmc_host * mmc,u8 command,u8 cmdtype,u32 arg,u8 rsptype)254 static int wmt_mci_send_command(struct mmc_host *mmc, u8 command, u8 cmdtype,
255 u32 arg, u8 rsptype)
256 {
257 struct wmt_mci_priv *priv;
258 u32 reg_tmp;
259
260 priv = mmc_priv(mmc);
261
262 /* write command, arg, resptype registers */
263 writeb(command, priv->sdmmc_base + SDMMC_CMD);
264 writel(arg, priv->sdmmc_base + SDMMC_ARG);
265 writeb(rsptype, priv->sdmmc_base + SDMMC_RSPTYPE);
266
267 /* reset response FIFO */
268 reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
269 writeb(reg_tmp | CTLR_FIFO_RESET, priv->sdmmc_base + SDMMC_CTLR);
270
271 /* ensure clock enabled - VT3465 */
272 wmt_set_sd_power(priv, WMT_SD_POWER_ON);
273
274 /* clear status bits */
275 writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
276 writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
277 writeb(0xFF, priv->sdmmc_base + SDMMC_STS2);
278 writeb(0xFF, priv->sdmmc_base + SDMMC_STS3);
279
280 /* set command type */
281 reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
282 writeb((reg_tmp & 0x0F) | (cmdtype << 4),
283 priv->sdmmc_base + SDMMC_CTLR);
284
285 return 0;
286 }
287
wmt_mci_disable_dma(struct wmt_mci_priv * priv)288 static void wmt_mci_disable_dma(struct wmt_mci_priv *priv)
289 {
290 writel(DMA_ISR_INT_STS, priv->sdmmc_base + SDDMA_ISR);
291 writel(0, priv->sdmmc_base + SDDMA_IER);
292 }
293
wmt_complete_data_request(struct wmt_mci_priv * priv)294 static void wmt_complete_data_request(struct wmt_mci_priv *priv)
295 {
296 struct mmc_request *req;
297 req = priv->req;
298
299 req->data->bytes_xfered = req->data->blksz * req->data->blocks;
300
301 /* unmap the DMA pages used for write data */
302 if (req->data->flags & MMC_DATA_WRITE)
303 dma_unmap_sg(mmc_dev(priv->mmc), req->data->sg,
304 req->data->sg_len, DMA_TO_DEVICE);
305 else
306 dma_unmap_sg(mmc_dev(priv->mmc), req->data->sg,
307 req->data->sg_len, DMA_FROM_DEVICE);
308
309 /* Check if the DMA ISR returned a data error */
310 if ((req->cmd->error) || (req->data->error))
311 mmc_request_done(priv->mmc, req);
312 else {
313 wmt_mci_read_response(priv->mmc);
314 if (!req->data->stop) {
315 /* single-block read/write requests end here */
316 mmc_request_done(priv->mmc, req);
317 } else {
318 /*
319 * we change the priv->cmd variable so the response is
320 * stored in the stop struct rather than the original
321 * calling command struct
322 */
323 priv->comp_cmd = &priv->cmdcomp;
324 init_completion(priv->comp_cmd);
325 priv->cmd = req->data->stop;
326 wmt_mci_send_command(priv->mmc, req->data->stop->opcode,
327 7, req->data->stop->arg, 9);
328 wmt_mci_start_command(priv);
329 }
330 }
331 }
332
wmt_mci_dma_isr(int irq_num,void * data)333 static irqreturn_t wmt_mci_dma_isr(int irq_num, void *data)
334 {
335 struct wmt_mci_priv *priv;
336
337 int status;
338
339 priv = (struct wmt_mci_priv *)data;
340
341 status = readl(priv->sdmmc_base + SDDMA_CCR) & 0x0F;
342
343 if (status != DMA_CCR_EVT_SUCCESS) {
344 dev_err(priv->dev, "DMA Error: Status = %d\n", status);
345 priv->req->data->error = -ETIMEDOUT;
346 complete(priv->comp_dma);
347 return IRQ_HANDLED;
348 }
349
350 priv->req->data->error = 0;
351
352 wmt_mci_disable_dma(priv);
353
354 complete(priv->comp_dma);
355
356 if (priv->comp_cmd) {
357 if (completion_done(priv->comp_cmd)) {
358 /*
359 * if the command (regular) interrupt has already
360 * completed, finish off the request otherwise we wait
361 * for the command interrupt and finish from there.
362 */
363 wmt_complete_data_request(priv);
364 }
365 }
366
367 return IRQ_HANDLED;
368 }
369
wmt_mci_regular_isr(int irq_num,void * data)370 static irqreturn_t wmt_mci_regular_isr(int irq_num, void *data)
371 {
372 struct wmt_mci_priv *priv;
373 u32 status0;
374 u32 status1;
375 u32 status2;
376 u32 reg_tmp;
377 int cmd_done;
378
379 priv = (struct wmt_mci_priv *)data;
380 cmd_done = 0;
381 status0 = readb(priv->sdmmc_base + SDMMC_STS0);
382 status1 = readb(priv->sdmmc_base + SDMMC_STS1);
383 status2 = readb(priv->sdmmc_base + SDMMC_STS2);
384
385 /* Check for card insertion */
386 reg_tmp = readb(priv->sdmmc_base + SDMMC_INTMASK0);
387 if ((reg_tmp & INT0_DI_INT_EN) && (status0 & STS0_DEVICE_INS)) {
388 mmc_detect_change(priv->mmc, 0);
389 if (priv->cmd)
390 priv->cmd->error = -ETIMEDOUT;
391 if (priv->comp_cmd)
392 complete(priv->comp_cmd);
393 if (priv->comp_dma) {
394 wmt_mci_disable_dma(priv);
395 complete(priv->comp_dma);
396 }
397 writeb(STS0_DEVICE_INS, priv->sdmmc_base + SDMMC_STS0);
398 return IRQ_HANDLED;
399 }
400
401 if ((!priv->req->data) ||
402 ((priv->req->data->stop) && (priv->cmd == priv->req->data->stop))) {
403 /* handle non-data & stop_transmission requests */
404 if (status1 & STS1_CMDRSP_DONE) {
405 priv->cmd->error = 0;
406 cmd_done = 1;
407 } else if ((status1 & STS1_RSP_TIMEOUT) ||
408 (status1 & STS1_DATA_TIMEOUT)) {
409 priv->cmd->error = -ETIMEDOUT;
410 cmd_done = 1;
411 }
412
413 if (cmd_done) {
414 priv->comp_cmd = NULL;
415
416 if (!priv->cmd->error)
417 wmt_mci_read_response(priv->mmc);
418
419 priv->cmd = NULL;
420
421 mmc_request_done(priv->mmc, priv->req);
422 }
423 } else {
424 /* handle data requests */
425 if (status1 & STS1_CMDRSP_DONE) {
426 if (priv->cmd)
427 priv->cmd->error = 0;
428 if (priv->comp_cmd)
429 complete(priv->comp_cmd);
430 }
431
432 if ((status1 & STS1_RSP_TIMEOUT) ||
433 (status1 & STS1_DATA_TIMEOUT)) {
434 if (priv->cmd)
435 priv->cmd->error = -ETIMEDOUT;
436 if (priv->comp_cmd)
437 complete(priv->comp_cmd);
438 if (priv->comp_dma) {
439 wmt_mci_disable_dma(priv);
440 complete(priv->comp_dma);
441 }
442 }
443
444 if (priv->comp_dma) {
445 /*
446 * If the dma interrupt has already completed, finish
447 * off the request; otherwise we wait for the DMA
448 * interrupt and finish from there.
449 */
450 if (completion_done(priv->comp_dma))
451 wmt_complete_data_request(priv);
452 }
453 }
454
455 writeb(status0, priv->sdmmc_base + SDMMC_STS0);
456 writeb(status1, priv->sdmmc_base + SDMMC_STS1);
457 writeb(status2, priv->sdmmc_base + SDMMC_STS2);
458
459 return IRQ_HANDLED;
460 }
461
wmt_reset_hardware(struct mmc_host * mmc)462 static void wmt_reset_hardware(struct mmc_host *mmc)
463 {
464 struct wmt_mci_priv *priv;
465 u32 reg_tmp;
466
467 priv = mmc_priv(mmc);
468
469 /* reset controller */
470 reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
471 writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base + SDMMC_BUSMODE);
472
473 /* reset response FIFO */
474 reg_tmp = readb(priv->sdmmc_base + SDMMC_CTLR);
475 writeb(reg_tmp | CTLR_FIFO_RESET, priv->sdmmc_base + SDMMC_CTLR);
476
477 /* enable GPI pin to detect card */
478 writew(BLKL_INT_ENABLE | BLKL_GPI_CD, priv->sdmmc_base + SDMMC_BLKLEN);
479
480 /* clear interrupt status */
481 writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
482 writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
483
484 /* setup interrupts */
485 writeb(INT0_CD_INT_EN | INT0_DI_INT_EN, priv->sdmmc_base +
486 SDMMC_INTMASK0);
487 writeb(INT1_DATA_TOUT_INT_EN | INT1_CMD_RES_TRAN_DONE_INT_EN |
488 INT1_CMD_RES_TOUT_INT_EN, priv->sdmmc_base + SDMMC_INTMASK1);
489
490 /* set the DMA timeout */
491 writew(8191, priv->sdmmc_base + SDMMC_DMATIMEOUT);
492
493 /* auto clock freezing enable */
494 reg_tmp = readb(priv->sdmmc_base + SDMMC_STS2);
495 writeb(reg_tmp | STS2_DIS_FORCECLK, priv->sdmmc_base + SDMMC_STS2);
496
497 /* set a default clock speed of 400Khz */
498 clk_set_rate(priv->clk_sdmmc, 400000);
499 }
500
wmt_dma_init(struct mmc_host * mmc)501 static int wmt_dma_init(struct mmc_host *mmc)
502 {
503 struct wmt_mci_priv *priv;
504
505 priv = mmc_priv(mmc);
506
507 writel(DMA_GCR_SOFT_RESET, priv->sdmmc_base + SDDMA_GCR);
508 writel(DMA_GCR_DMA_EN, priv->sdmmc_base + SDDMA_GCR);
509 if ((readl(priv->sdmmc_base + SDDMA_GCR) & DMA_GCR_DMA_EN) != 0)
510 return 0;
511 else
512 return 1;
513 }
514
wmt_dma_init_descriptor(struct wmt_dma_descriptor * desc,u16 req_count,u32 buffer_addr,u32 branch_addr,int end)515 static void wmt_dma_init_descriptor(struct wmt_dma_descriptor *desc,
516 u16 req_count, u32 buffer_addr, u32 branch_addr, int end)
517 {
518 desc->flags = 0x40000000 | req_count;
519 if (end)
520 desc->flags |= 0x80000000;
521 desc->data_buffer_addr = buffer_addr;
522 desc->branch_addr = branch_addr;
523 }
524
wmt_dma_config(struct mmc_host * mmc,u32 descaddr,u8 dir)525 static void wmt_dma_config(struct mmc_host *mmc, u32 descaddr, u8 dir)
526 {
527 struct wmt_mci_priv *priv;
528 u32 reg_tmp;
529
530 priv = mmc_priv(mmc);
531
532 /* Enable DMA Interrupts */
533 writel(DMA_IER_INT_EN, priv->sdmmc_base + SDDMA_IER);
534
535 /* Write DMA Descriptor Pointer Register */
536 writel(descaddr, priv->sdmmc_base + SDDMA_DESPR);
537
538 writel(0x00, priv->sdmmc_base + SDDMA_CCR);
539
540 if (dir == PDMA_WRITE) {
541 reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
542 writel(reg_tmp & DMA_CCR_IF_TO_PERIPHERAL, priv->sdmmc_base +
543 SDDMA_CCR);
544 } else {
545 reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
546 writel(reg_tmp | DMA_CCR_PERIPHERAL_TO_IF, priv->sdmmc_base +
547 SDDMA_CCR);
548 }
549 }
550
wmt_dma_start(struct wmt_mci_priv * priv)551 static void wmt_dma_start(struct wmt_mci_priv *priv)
552 {
553 u32 reg_tmp;
554
555 reg_tmp = readl(priv->sdmmc_base + SDDMA_CCR);
556 writel(reg_tmp | DMA_CCR_RUN, priv->sdmmc_base + SDDMA_CCR);
557 }
558
wmt_mci_request(struct mmc_host * mmc,struct mmc_request * req)559 static void wmt_mci_request(struct mmc_host *mmc, struct mmc_request *req)
560 {
561 struct wmt_mci_priv *priv;
562 struct wmt_dma_descriptor *desc;
563 u8 command;
564 u8 cmdtype;
565 u32 arg;
566 u8 rsptype;
567 u32 reg_tmp;
568
569 struct scatterlist *sg;
570 int i;
571 int sg_cnt;
572 int offset;
573 u32 dma_address;
574 int desc_cnt;
575
576 priv = mmc_priv(mmc);
577 priv->req = req;
578
579 /*
580 * Use the cmd variable to pass a pointer to the resp[] structure
581 * This is required on multi-block requests to pass the pointer to the
582 * stop command
583 */
584 priv->cmd = req->cmd;
585
586 command = req->cmd->opcode;
587 arg = req->cmd->arg;
588 rsptype = mmc_resp_type(req->cmd);
589 cmdtype = 0;
590
591 /* rsptype=7 only valid for SPI commands - should be =2 for SD */
592 if (rsptype == 7)
593 rsptype = 2;
594 /* rsptype=21 is R1B, convert for controller */
595 if (rsptype == 21)
596 rsptype = 9;
597
598 if (!req->data) {
599 wmt_mci_send_command(mmc, command, cmdtype, arg, rsptype);
600 wmt_mci_start_command(priv);
601 /* completion is now handled in the regular_isr() */
602 }
603 if (req->data) {
604 priv->comp_cmd = &priv->cmdcomp;
605 init_completion(priv->comp_cmd);
606
607 wmt_dma_init(mmc);
608
609 /* set controller data length */
610 reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
611 writew((reg_tmp & 0xF800) | (req->data->blksz - 1),
612 priv->sdmmc_base + SDMMC_BLKLEN);
613
614 /* set controller block count */
615 writew(req->data->blocks, priv->sdmmc_base + SDMMC_BLKCNT);
616
617 desc = (struct wmt_dma_descriptor *)priv->dma_desc_buffer;
618
619 if (req->data->flags & MMC_DATA_WRITE) {
620 sg_cnt = dma_map_sg(mmc_dev(mmc), req->data->sg,
621 req->data->sg_len, DMA_TO_DEVICE);
622 cmdtype = 1;
623 if (req->data->blocks > 1)
624 cmdtype = 3;
625 } else {
626 sg_cnt = dma_map_sg(mmc_dev(mmc), req->data->sg,
627 req->data->sg_len, DMA_FROM_DEVICE);
628 cmdtype = 2;
629 if (req->data->blocks > 1)
630 cmdtype = 4;
631 }
632
633 dma_address = priv->dma_desc_device_addr + 16;
634 desc_cnt = 0;
635
636 for_each_sg(req->data->sg, sg, sg_cnt, i) {
637 offset = 0;
638 while (offset < sg_dma_len(sg)) {
639 wmt_dma_init_descriptor(desc, req->data->blksz,
640 sg_dma_address(sg)+offset,
641 dma_address, 0);
642 desc++;
643 desc_cnt++;
644 offset += req->data->blksz;
645 dma_address += 16;
646 if (desc_cnt == req->data->blocks)
647 break;
648 }
649 }
650 desc--;
651 desc->flags |= 0x80000000;
652
653 if (req->data->flags & MMC_DATA_WRITE)
654 wmt_dma_config(mmc, priv->dma_desc_device_addr,
655 PDMA_WRITE);
656 else
657 wmt_dma_config(mmc, priv->dma_desc_device_addr,
658 PDMA_READ);
659
660 wmt_mci_send_command(mmc, command, cmdtype, arg, rsptype);
661
662 priv->comp_dma = &priv->datacomp;
663 init_completion(priv->comp_dma);
664
665 wmt_dma_start(priv);
666 wmt_mci_start_command(priv);
667 }
668 }
669
wmt_mci_set_ios(struct mmc_host * mmc,struct mmc_ios * ios)670 static void wmt_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
671 {
672 struct wmt_mci_priv *priv;
673 u32 busmode, extctrl;
674
675 priv = mmc_priv(mmc);
676
677 if (ios->power_mode == MMC_POWER_UP) {
678 wmt_reset_hardware(mmc);
679
680 wmt_set_sd_power(priv, WMT_SD_POWER_ON);
681 }
682 if (ios->power_mode == MMC_POWER_OFF)
683 wmt_set_sd_power(priv, WMT_SD_POWER_OFF);
684
685 if (ios->clock != 0)
686 clk_set_rate(priv->clk_sdmmc, ios->clock);
687
688 busmode = readb(priv->sdmmc_base + SDMMC_BUSMODE);
689 extctrl = readb(priv->sdmmc_base + SDMMC_EXTCTRL);
690
691 busmode &= ~(BM_EIGHTBIT_MODE | BM_FOURBIT_MODE);
692 extctrl &= ~EXT_EIGHTBIT;
693
694 switch (ios->bus_width) {
695 case MMC_BUS_WIDTH_8:
696 busmode |= BM_EIGHTBIT_MODE;
697 extctrl |= EXT_EIGHTBIT;
698 break;
699 case MMC_BUS_WIDTH_4:
700 busmode |= BM_FOURBIT_MODE;
701 break;
702 case MMC_BUS_WIDTH_1:
703 break;
704 }
705
706 writeb(busmode, priv->sdmmc_base + SDMMC_BUSMODE);
707 writeb(extctrl, priv->sdmmc_base + SDMMC_EXTCTRL);
708 }
709
wmt_mci_get_ro(struct mmc_host * mmc)710 static int wmt_mci_get_ro(struct mmc_host *mmc)
711 {
712 struct wmt_mci_priv *priv = mmc_priv(mmc);
713
714 return !(readb(priv->sdmmc_base + SDMMC_STS0) & STS0_WRITE_PROTECT);
715 }
716
wmt_mci_get_cd(struct mmc_host * mmc)717 static int wmt_mci_get_cd(struct mmc_host *mmc)
718 {
719 struct wmt_mci_priv *priv = mmc_priv(mmc);
720 u32 cd = (readb(priv->sdmmc_base + SDMMC_STS0) & STS0_CD_GPI) >> 3;
721
722 return !(cd ^ priv->cd_inverted);
723 }
724
725 static const struct mmc_host_ops wmt_mci_ops = {
726 .request = wmt_mci_request,
727 .set_ios = wmt_mci_set_ios,
728 .get_ro = wmt_mci_get_ro,
729 .get_cd = wmt_mci_get_cd,
730 };
731
732 /* Controller capabilities */
733 static struct wmt_mci_caps wm8505_caps = {
734 .f_min = 390425,
735 .f_max = 50000000,
736 .ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34,
737 .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED |
738 MMC_CAP_SD_HIGHSPEED,
739 .max_seg_size = 65024,
740 .max_segs = 128,
741 .max_blk_size = 2048,
742 };
743
744 static const struct of_device_id wmt_mci_dt_ids[] = {
745 { .compatible = "wm,wm8505-sdhc", .data = &wm8505_caps },
746 { /* Sentinel */ },
747 };
748
wmt_mci_probe(struct platform_device * pdev)749 static int wmt_mci_probe(struct platform_device *pdev)
750 {
751 struct mmc_host *mmc;
752 struct wmt_mci_priv *priv;
753 struct device_node *np = pdev->dev.of_node;
754 const struct of_device_id *of_id =
755 of_match_device(wmt_mci_dt_ids, &pdev->dev);
756 const struct wmt_mci_caps *wmt_caps;
757 int ret;
758 int regular_irq, dma_irq;
759
760 if (!of_id || !of_id->data) {
761 dev_err(&pdev->dev, "Controller capabilities data missing\n");
762 return -EFAULT;
763 }
764
765 wmt_caps = of_id->data;
766
767 if (!np) {
768 dev_err(&pdev->dev, "Missing SDMMC description in devicetree\n");
769 return -EFAULT;
770 }
771
772 regular_irq = irq_of_parse_and_map(np, 0);
773 dma_irq = irq_of_parse_and_map(np, 1);
774
775 if (!regular_irq || !dma_irq) {
776 dev_err(&pdev->dev, "Getting IRQs failed!\n");
777 ret = -ENXIO;
778 goto fail1;
779 }
780
781 mmc = mmc_alloc_host(sizeof(struct wmt_mci_priv), &pdev->dev);
782 if (!mmc) {
783 dev_err(&pdev->dev, "Failed to allocate mmc_host\n");
784 ret = -ENOMEM;
785 goto fail1;
786 }
787
788 mmc->ops = &wmt_mci_ops;
789 mmc->f_min = wmt_caps->f_min;
790 mmc->f_max = wmt_caps->f_max;
791 mmc->ocr_avail = wmt_caps->ocr_avail;
792 mmc->caps = wmt_caps->caps;
793
794 mmc->max_seg_size = wmt_caps->max_seg_size;
795 mmc->max_segs = wmt_caps->max_segs;
796 mmc->max_blk_size = wmt_caps->max_blk_size;
797
798 mmc->max_req_size = (16*512*mmc->max_segs);
799 mmc->max_blk_count = mmc->max_req_size / 512;
800
801 priv = mmc_priv(mmc);
802 priv->mmc = mmc;
803 priv->dev = &pdev->dev;
804
805 priv->power_inverted = 0;
806 priv->cd_inverted = 0;
807
808 if (of_get_property(np, "sdon-inverted", NULL))
809 priv->power_inverted = 1;
810 if (of_get_property(np, "cd-inverted", NULL))
811 priv->cd_inverted = 1;
812
813 priv->sdmmc_base = of_iomap(np, 0);
814 if (!priv->sdmmc_base) {
815 dev_err(&pdev->dev, "Failed to map IO space\n");
816 ret = -ENOMEM;
817 goto fail2;
818 }
819
820 priv->irq_regular = regular_irq;
821 priv->irq_dma = dma_irq;
822
823 ret = request_irq(regular_irq, wmt_mci_regular_isr, 0, "sdmmc", priv);
824 if (ret) {
825 dev_err(&pdev->dev, "Register regular IRQ fail\n");
826 goto fail3;
827 }
828
829 ret = request_irq(dma_irq, wmt_mci_dma_isr, 0, "sdmmc", priv);
830 if (ret) {
831 dev_err(&pdev->dev, "Register DMA IRQ fail\n");
832 goto fail4;
833 }
834
835 /* alloc some DMA buffers for descriptors/transfers */
836 priv->dma_desc_buffer = dma_alloc_coherent(&pdev->dev,
837 mmc->max_blk_count * 16,
838 &priv->dma_desc_device_addr,
839 GFP_KERNEL);
840 if (!priv->dma_desc_buffer) {
841 dev_err(&pdev->dev, "DMA alloc fail\n");
842 ret = -EPERM;
843 goto fail5;
844 }
845
846 platform_set_drvdata(pdev, mmc);
847
848 priv->clk_sdmmc = of_clk_get(np, 0);
849 if (IS_ERR(priv->clk_sdmmc)) {
850 dev_err(&pdev->dev, "Error getting clock\n");
851 ret = PTR_ERR(priv->clk_sdmmc);
852 goto fail5_and_a_half;
853 }
854
855 ret = clk_prepare_enable(priv->clk_sdmmc);
856 if (ret)
857 goto fail6;
858
859 /* configure the controller to a known 'ready' state */
860 wmt_reset_hardware(mmc);
861
862 ret = mmc_add_host(mmc);
863 if (ret)
864 goto fail7;
865
866 dev_info(&pdev->dev, "WMT SDHC Controller initialized\n");
867
868 return 0;
869 fail7:
870 clk_disable_unprepare(priv->clk_sdmmc);
871 fail6:
872 clk_put(priv->clk_sdmmc);
873 fail5_and_a_half:
874 dma_free_coherent(&pdev->dev, mmc->max_blk_count * 16,
875 priv->dma_desc_buffer, priv->dma_desc_device_addr);
876 fail5:
877 free_irq(dma_irq, priv);
878 fail4:
879 free_irq(regular_irq, priv);
880 fail3:
881 iounmap(priv->sdmmc_base);
882 fail2:
883 mmc_free_host(mmc);
884 fail1:
885 return ret;
886 }
887
wmt_mci_remove(struct platform_device * pdev)888 static int wmt_mci_remove(struct platform_device *pdev)
889 {
890 struct mmc_host *mmc;
891 struct wmt_mci_priv *priv;
892 struct resource *res;
893 u32 reg_tmp;
894
895 mmc = platform_get_drvdata(pdev);
896 priv = mmc_priv(mmc);
897
898 /* reset SD controller */
899 reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
900 writel(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base + SDMMC_BUSMODE);
901 reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
902 writew(reg_tmp & ~(0xA000), priv->sdmmc_base + SDMMC_BLKLEN);
903 writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
904 writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
905
906 /* release the dma buffers */
907 dma_free_coherent(&pdev->dev, priv->mmc->max_blk_count * 16,
908 priv->dma_desc_buffer, priv->dma_desc_device_addr);
909
910 mmc_remove_host(mmc);
911
912 free_irq(priv->irq_regular, priv);
913 free_irq(priv->irq_dma, priv);
914
915 iounmap(priv->sdmmc_base);
916
917 clk_disable_unprepare(priv->clk_sdmmc);
918 clk_put(priv->clk_sdmmc);
919
920 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
921 release_mem_region(res->start, resource_size(res));
922
923 mmc_free_host(mmc);
924
925 dev_info(&pdev->dev, "WMT MCI device removed\n");
926
927 return 0;
928 }
929
930 #ifdef CONFIG_PM
wmt_mci_suspend(struct device * dev)931 static int wmt_mci_suspend(struct device *dev)
932 {
933 u32 reg_tmp;
934 struct mmc_host *mmc = dev_get_drvdata(dev);
935 struct wmt_mci_priv *priv;
936
937 if (!mmc)
938 return 0;
939
940 priv = mmc_priv(mmc);
941 reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
942 writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base +
943 SDMMC_BUSMODE);
944
945 reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
946 writew(reg_tmp & 0x5FFF, priv->sdmmc_base + SDMMC_BLKLEN);
947
948 writeb(0xFF, priv->sdmmc_base + SDMMC_STS0);
949 writeb(0xFF, priv->sdmmc_base + SDMMC_STS1);
950
951 clk_disable(priv->clk_sdmmc);
952 return 0;
953 }
954
wmt_mci_resume(struct device * dev)955 static int wmt_mci_resume(struct device *dev)
956 {
957 u32 reg_tmp;
958 struct mmc_host *mmc = dev_get_drvdata(dev);
959 struct wmt_mci_priv *priv;
960
961 if (mmc) {
962 priv = mmc_priv(mmc);
963 clk_enable(priv->clk_sdmmc);
964
965 reg_tmp = readb(priv->sdmmc_base + SDMMC_BUSMODE);
966 writeb(reg_tmp | BM_SOFT_RESET, priv->sdmmc_base +
967 SDMMC_BUSMODE);
968
969 reg_tmp = readw(priv->sdmmc_base + SDMMC_BLKLEN);
970 writew(reg_tmp | (BLKL_GPI_CD | BLKL_INT_ENABLE),
971 priv->sdmmc_base + SDMMC_BLKLEN);
972
973 reg_tmp = readb(priv->sdmmc_base + SDMMC_INTMASK0);
974 writeb(reg_tmp | INT0_DI_INT_EN, priv->sdmmc_base +
975 SDMMC_INTMASK0);
976
977 }
978
979 return 0;
980 }
981
982 static const struct dev_pm_ops wmt_mci_pm = {
983 .suspend = wmt_mci_suspend,
984 .resume = wmt_mci_resume,
985 };
986
987 #define wmt_mci_pm_ops (&wmt_mci_pm)
988
989 #else /* !CONFIG_PM */
990
991 #define wmt_mci_pm_ops NULL
992
993 #endif
994
995 static struct platform_driver wmt_mci_driver = {
996 .probe = wmt_mci_probe,
997 .remove = wmt_mci_remove,
998 .driver = {
999 .name = DRIVER_NAME,
1000 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1001 .pm = wmt_mci_pm_ops,
1002 .of_match_table = wmt_mci_dt_ids,
1003 },
1004 };
1005
1006 module_platform_driver(wmt_mci_driver);
1007
1008 MODULE_DESCRIPTION("Wondermedia MMC/SD Driver");
1009 MODULE_AUTHOR("Tony Prisk");
1010 MODULE_LICENSE("GPL v2");
1011 MODULE_DEVICE_TABLE(of, wmt_mci_dt_ids);
1012