?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mvsdio: ignore high speed timing requests from the core
[linux-2.6/linux-2.6-openrd.git] / drivers / mmc / host / mvsdio.c
blob9d3cfa9909c9c0f5d48247300462f9f82b6341f5
1 /*
2 * Marvell MMC/SD/SDIO driver
3 *
4 * Authors: Maen Suleiman, Nicolas Pitre
5 * Copyright (C) 2008-2009 Marvell Ltd.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/io.h>
15 #include <linux/platform_device.h>
16 #include <linux/mbus.h>
17 #include <linux/delay.h>
18 #include <linux/interrupt.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/scatterlist.h>
21 #include <linux/irq.h>
22 #include <linux/gpio.h>
23 #include <linux/mmc/host.h>
24
25 #include <asm/sizes.h>
26 #include <asm/unaligned.h>
27 #include <plat/mvsdio.h>
28
29 #include "mvsdio.h"
30
31 #define DRIVER_NAME "mvsdio"
32
33 static int maxfreq = MVSD_CLOCKRATE_MAX;
34 static int nodma;
35
36 struct mvsd_host {
37 void __iomem *base;
38 struct mmc_request *mrq;
39 spinlock_t lock;
40 unsigned int xfer_mode;
41 unsigned int intr_en;
42 unsigned int ctrl;
43 unsigned int pio_size;
44 void *pio_ptr;
45 unsigned int sg_frags;
46 unsigned int ns_per_clk;
47 unsigned int clock;
48 unsigned int base_clock;
49 struct timer_list timer;
50 struct mmc_host *mmc;
51 struct device *dev;
52 struct resource *res;
53 int irq;
54 int gpio_card_detect;
55 int gpio_write_protect;
56 };
57
58 #define mvsd_write(offs, val) writel(val, iobase + (offs))
59 #define mvsd_read(offs) readl(iobase + (offs))
60
61 static int mvsd_setup_data(struct mvsd_host *host, struct mmc_data *data)
62 {
63 void __iomem *iobase = host->base;
64 unsigned int tmout;
65 int tmout_index;
66
67 /* If timeout=0 then maximum timeout index is used. */
68 tmout = DIV_ROUND_UP(data->timeout_ns, host->ns_per_clk);
69 tmout += data->timeout_clks;
70 tmout_index = fls(tmout - 1) - 12;
71 if (tmout_index < 0)
72 tmout_index = 0;
73 if (tmout_index > MVSD_HOST_CTRL_TMOUT_MAX)
74 tmout_index = MVSD_HOST_CTRL_TMOUT_MAX;
75
76 dev_dbg(host->dev, "data %s at 0x%08x: blocks=%d blksz=%d tmout=%u (%d)\n",
77 (data->flags & MMC_DATA_READ) ? "read" : "write",
78 (u32)sg_virt(data->sg), data->blocks, data->blksz,
79 tmout, tmout_index);
80
81 host->ctrl &= ~MVSD_HOST_CTRL_TMOUT_MASK;
82 host->ctrl |= MVSD_HOST_CTRL_TMOUT(tmout_index);
83 mvsd_write(MVSD_HOST_CTRL, host->ctrl);
84 mvsd_write(MVSD_BLK_COUNT, data->blocks);
85 mvsd_write(MVSD_BLK_SIZE, data->blksz);
86
87 if (nodma || (data->blksz | data->sg->offset) & 3) {
88 /*
89 * We cannot do DMA on a buffer which offset or size
90 * is not aligned on a 4-byte boundary.
91 */
92 host->pio_size = data->blocks * data->blksz;
93 host->pio_ptr = sg_virt(data->sg);
94 if (!nodma)
95 printk(KERN_DEBUG "%s: fallback to PIO for data "
96 "at 0x%p size %d\n",
97 mmc_hostname(host->mmc),
98 host->pio_ptr, host->pio_size);
99 return 1;
100 } else {
101 dma_addr_t phys_addr;
102 int dma_dir = (data->flags & MMC_DATA_READ) ?
103 DMA_FROM_DEVICE : DMA_TO_DEVICE;
104 host->sg_frags = dma_map_sg(mmc_dev(host->mmc), data->sg,
105 data->sg_len, dma_dir);
106 phys_addr = sg_dma_address(data->sg);
107 mvsd_write(MVSD_SYS_ADDR_LOW, (u32)phys_addr & 0xffff);
108 mvsd_write(MVSD_SYS_ADDR_HI, (u32)phys_addr >> 16);
109 return 0;
110 }
111 }
112
113 static void mvsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
114 {
115 struct mvsd_host *host = mmc_priv(mmc);
116 void __iomem *iobase = host->base;
117 struct mmc_command *cmd = mrq->cmd;
118 u32 cmdreg = 0, xfer = 0, intr = 0;
119 unsigned long flags;
120
121 BUG_ON(host->mrq != NULL);
122 host->mrq = mrq;
123
124 dev_dbg(host->dev, "cmd %d (hw state 0x%04x)\n",
125 cmd->opcode, mvsd_read(MVSD_HW_STATE));
126
127 cmdreg = MVSD_CMD_INDEX(cmd->opcode);
128
129 if (cmd->flags & MMC_RSP_BUSY)
130 cmdreg |= MVSD_CMD_RSP_48BUSY;
131 else if (cmd->flags & MMC_RSP_136)
132 cmdreg |= MVSD_CMD_RSP_136;
133 else if (cmd->flags & MMC_RSP_PRESENT)
134 cmdreg |= MVSD_CMD_RSP_48;
135 else
136 cmdreg |= MVSD_CMD_RSP_NONE;
137
138 if (cmd->flags & MMC_RSP_CRC)
139 cmdreg |= MVSD_CMD_CHECK_CMDCRC;
140
141 if (cmd->flags & MMC_RSP_OPCODE)
142 cmdreg |= MVSD_CMD_INDX_CHECK;
143
144 if (cmd->flags & MMC_RSP_PRESENT) {
145 cmdreg |= MVSD_UNEXPECTED_RESP;
146 intr |= MVSD_NOR_UNEXP_RSP;
147 }
148
149 if (mrq->data) {
150 struct mmc_data *data = mrq->data;
151 int pio;
152
153 cmdreg |= MVSD_CMD_DATA_PRESENT | MVSD_CMD_CHECK_DATACRC16;
154 xfer |= MVSD_XFER_MODE_HW_WR_DATA_EN;
155 if (data->flags & MMC_DATA_READ)
156 xfer |= MVSD_XFER_MODE_TO_HOST;
157
158 pio = mvsd_setup_data(host, data);
159 if (pio) {
160 xfer |= MVSD_XFER_MODE_PIO;
161 /* PIO section of mvsd_irq has comments on those bits */
162 if (data->flags & MMC_DATA_WRITE)
163 intr |= MVSD_NOR_TX_AVAIL;
164 else if (host->pio_size > 32)
165 intr |= MVSD_NOR_RX_FIFO_8W;
166 else
167 intr |= MVSD_NOR_RX_READY;
168 }
169
170 if (data->stop) {
171 struct mmc_command *stop = data->stop;
172 u32 cmd12reg = 0;
173
174 mvsd_write(MVSD_AUTOCMD12_ARG_LOW, stop->arg & 0xffff);
175 mvsd_write(MVSD_AUTOCMD12_ARG_HI, stop->arg >> 16);
176
177 if (stop->flags & MMC_RSP_BUSY)
178 cmd12reg |= MVSD_AUTOCMD12_BUSY;
179 if (stop->flags & MMC_RSP_OPCODE)
180 cmd12reg |= MVSD_AUTOCMD12_INDX_CHECK;
181 cmd12reg |= MVSD_AUTOCMD12_INDEX(stop->opcode);
182 mvsd_write(MVSD_AUTOCMD12_CMD, cmd12reg);
183
184 xfer |= MVSD_XFER_MODE_AUTO_CMD12;
185 intr |= MVSD_NOR_AUTOCMD12_DONE;
186 } else {
187 intr |= MVSD_NOR_XFER_DONE;
188 }
189 } else {
190 intr |= MVSD_NOR_CMD_DONE;
191 }
192
193 mvsd_write(MVSD_ARG_LOW, cmd->arg & 0xffff);
194 mvsd_write(MVSD_ARG_HI, cmd->arg >> 16);
195
196 spin_lock_irqsave(&host->lock, flags);
197
198 host->xfer_mode &= MVSD_XFER_MODE_INT_CHK_EN;
199 host->xfer_mode |= xfer;
200 mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
201
202 mvsd_write(MVSD_NOR_INTR_STATUS, ~MVSD_NOR_CARD_INT);
203 mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
204 mvsd_write(MVSD_CMD, cmdreg);
205
206 host->intr_en &= MVSD_NOR_CARD_INT;
207 host->intr_en |= intr | MVSD_NOR_ERROR;
208 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
209 mvsd_write(MVSD_ERR_INTR_EN, 0xffff);
210
211 mod_timer(&host->timer, jiffies + 5 * HZ);
212
213 spin_unlock_irqrestore(&host->lock, flags);
214 }
215
216 static u32 mvsd_finish_cmd(struct mvsd_host *host, struct mmc_command *cmd,
217 u32 err_status)
218 {
219 void __iomem *iobase = host->base;
220
221 if (cmd->flags & MMC_RSP_136) {
222 unsigned int response[8], i;
223 for (i = 0; i < 8; i++)
224 response[i] = mvsd_read(MVSD_RSP(i));
225 cmd->resp[0] = ((response[0] & 0x03ff) << 22) |
226 ((response[1] & 0xffff) << 6) |
227 ((response[2] & 0xfc00) >> 10);
228 cmd->resp[1] = ((response[2] & 0x03ff) << 22) |
229 ((response[3] & 0xffff) << 6) |
230 ((response[4] & 0xfc00) >> 10);
231 cmd->resp[2] = ((response[4] & 0x03ff) << 22) |
232 ((response[5] & 0xffff) << 6) |
233 ((response[6] & 0xfc00) >> 10);
234 cmd->resp[3] = ((response[6] & 0x03ff) << 22) |
235 ((response[7] & 0x3fff) << 8);
236 } else if (cmd->flags & MMC_RSP_PRESENT) {
237 unsigned int response[3], i;
238 for (i = 0; i < 3; i++)
239 response[i] = mvsd_read(MVSD_RSP(i));
240 cmd->resp[0] = ((response[2] & 0x003f) << (8 - 8)) |
241 ((response[1] & 0xffff) << (14 - 8)) |
242 ((response[0] & 0x03ff) << (30 - 8));
243 cmd->resp[1] = ((response[0] & 0xfc00) >> 10);
244 cmd->resp[2] = 0;
245 cmd->resp[3] = 0;
246 }
247
248 if (err_status & MVSD_ERR_CMD_TIMEOUT) {
249 cmd->error = -ETIMEDOUT;
250 } else if (err_status & (MVSD_ERR_CMD_CRC | MVSD_ERR_CMD_ENDBIT |
251 MVSD_ERR_CMD_INDEX | MVSD_ERR_CMD_STARTBIT)) {
252 cmd->error = -EILSEQ;
253 }
254 err_status &= ~(MVSD_ERR_CMD_TIMEOUT | MVSD_ERR_CMD_CRC |
255 MVSD_ERR_CMD_ENDBIT | MVSD_ERR_CMD_INDEX |
256 MVSD_ERR_CMD_STARTBIT);
257
258 return err_status;
259 }
260
261 static u32 mvsd_finish_data(struct mvsd_host *host, struct mmc_data *data,
262 u32 err_status)
263 {
264 void __iomem *iobase = host->base;
265
266 if (host->pio_ptr) {
267 host->pio_ptr = NULL;
268 host->pio_size = 0;
269 } else {
270 dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->sg_frags,
271 (data->flags & MMC_DATA_READ) ?
272 DMA_FROM_DEVICE : DMA_TO_DEVICE);
273 }
274
275 if (err_status & MVSD_ERR_DATA_TIMEOUT)
276 data->error = -ETIMEDOUT;
277 else if (err_status & (MVSD_ERR_DATA_CRC | MVSD_ERR_DATA_ENDBIT))
278 data->error = -EILSEQ;
279 else if (err_status & MVSD_ERR_XFER_SIZE)
280 data->error = -EBADE;
281 err_status &= ~(MVSD_ERR_DATA_TIMEOUT | MVSD_ERR_DATA_CRC |
282 MVSD_ERR_DATA_ENDBIT | MVSD_ERR_XFER_SIZE);
283
284 dev_dbg(host->dev, "data done: blocks_left=%d, bytes_left=%d\n",
285 mvsd_read(MVSD_CURR_BLK_LEFT), mvsd_read(MVSD_CURR_BYTE_LEFT));
286 data->bytes_xfered =
287 (data->blocks - mvsd_read(MVSD_CURR_BLK_LEFT)) * data->blksz;
288 /* We can't be sure about the last block when errors are detected */
289 if (data->bytes_xfered && data->error)
290 data->bytes_xfered -= data->blksz;
291
292 /* Handle Auto cmd 12 response */
293 if (data->stop) {
294 unsigned int response[3], i;
295 for (i = 0; i < 3; i++)
296 response[i] = mvsd_read(MVSD_AUTO_RSP(i));
297 data->stop->resp[0] = ((response[2] & 0x003f) << (8 - 8)) |
298 ((response[1] & 0xffff) << (14 - 8)) |
299 ((response[0] & 0x03ff) << (30 - 8));
300 data->stop->resp[1] = ((response[0] & 0xfc00) >> 10);
301 data->stop->resp[2] = 0;
302 data->stop->resp[3] = 0;
303
304 if (err_status & MVSD_ERR_AUTOCMD12) {
305 u32 err_cmd12 = mvsd_read(MVSD_AUTOCMD12_ERR_STATUS);
306 dev_dbg(host->dev, "c12err 0x%04x\n", err_cmd12);
307 if (err_cmd12 & MVSD_AUTOCMD12_ERR_NOTEXE)
308 data->stop->error = -ENOEXEC;
309 else if (err_cmd12 & MVSD_AUTOCMD12_ERR_TIMEOUT)
310 data->stop->error = -ETIMEDOUT;
311 else if (err_cmd12)
312 data->stop->error = -EILSEQ;
313 err_status &= ~MVSD_ERR_AUTOCMD12;
314 }
315 }
316
317 return err_status;
318 }
319
320 static irqreturn_t mvsd_irq(int irq, void *dev)
321 {
322 struct mvsd_host *host = dev;
323 void __iomem *iobase = host->base;
324 u32 intr_status, intr_done_mask;
325 int irq_handled = 0;
326
327 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
328 dev_dbg(host->dev, "intr 0x%04x intr_en 0x%04x hw_state 0x%04x\n",
329 intr_status, mvsd_read(MVSD_NOR_INTR_EN),
330 mvsd_read(MVSD_HW_STATE));
331
332 spin_lock(&host->lock);
333
334 /* PIO handling, if needed. Messy business... */
335 if (host->pio_size &&
336 (intr_status & host->intr_en &
337 (MVSD_NOR_RX_READY | MVSD_NOR_RX_FIFO_8W))) {
338 u16 *p = host->pio_ptr;
339 int s = host->pio_size;
340 while (s >= 32 && (intr_status & MVSD_NOR_RX_FIFO_8W)) {
341 readsw(iobase + MVSD_FIFO, p, 16);
342 p += 16;
343 s -= 32;
344 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
345 }
346 /*
347 * Normally we'd use < 32 here, but the RX_FIFO_8W bit
348 * doesn't appear to assert when there is exactly 32 bytes
349 * (8 words) left to fetch in a transfer.
350 */
351 if (s <= 32) {
352 while (s >= 4 && (intr_status & MVSD_NOR_RX_READY)) {
353 put_unaligned(mvsd_read(MVSD_FIFO), p++);
354 put_unaligned(mvsd_read(MVSD_FIFO), p++);
355 s -= 4;
356 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
357 }
358 if (s && s < 4 && (intr_status & MVSD_NOR_RX_READY)) {
359 u16 val[2] = {0, 0};
360 val[0] = mvsd_read(MVSD_FIFO);
361 val[1] = mvsd_read(MVSD_FIFO);
362 memcpy(p, &val, s);
363 s = 0;
364 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
365 }
366 if (s == 0) {
367 host->intr_en &=
368 ~(MVSD_NOR_RX_READY | MVSD_NOR_RX_FIFO_8W);
369 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
370 } else if (host->intr_en & MVSD_NOR_RX_FIFO_8W) {
371 host->intr_en &= ~MVSD_NOR_RX_FIFO_8W;
372 host->intr_en |= MVSD_NOR_RX_READY;
373 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
374 }
375 }
376 dev_dbg(host->dev, "pio %d intr 0x%04x hw_state 0x%04x\n",
377 s, intr_status, mvsd_read(MVSD_HW_STATE));
378 host->pio_ptr = p;
379 host->pio_size = s;
380 irq_handled = 1;
381 } else if (host->pio_size &&
382 (intr_status & host->intr_en &
383 (MVSD_NOR_TX_AVAIL | MVSD_NOR_TX_FIFO_8W))) {
384 u16 *p = host->pio_ptr;
385 int s = host->pio_size;
386 /*
387 * The TX_FIFO_8W bit is unreliable. When set, bursting
388 * 16 halfwords all at once in the FIFO drops data. Actually
389 * TX_AVAIL does go off after only one word is pushed even if
390 * TX_FIFO_8W remains set.
391 */
392 while (s >= 4 && (intr_status & MVSD_NOR_TX_AVAIL)) {
393 mvsd_write(MVSD_FIFO, get_unaligned(p++));
394 mvsd_write(MVSD_FIFO, get_unaligned(p++));
395 s -= 4;
396 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
397 }
398 if (s < 4) {
399 if (s && (intr_status & MVSD_NOR_TX_AVAIL)) {
400 u16 val[2] = {0, 0};
401 memcpy(&val, p, s);
402 mvsd_write(MVSD_FIFO, val[0]);
403 mvsd_write(MVSD_FIFO, val[1]);
404 s = 0;
405 intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
406 }
407 if (s == 0) {
408 host->intr_en &=
409 ~(MVSD_NOR_TX_AVAIL | MVSD_NOR_TX_FIFO_8W);
410 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
411 }
412 }
413 dev_dbg(host->dev, "pio %d intr 0x%04x hw_state 0x%04x\n",
414 s, intr_status, mvsd_read(MVSD_HW_STATE));
415 host->pio_ptr = p;
416 host->pio_size = s;
417 irq_handled = 1;
418 }
419
420 mvsd_write(MVSD_NOR_INTR_STATUS, intr_status);
421
422 intr_done_mask = MVSD_NOR_CARD_INT | MVSD_NOR_RX_READY |
423 MVSD_NOR_RX_FIFO_8W | MVSD_NOR_TX_FIFO_8W;
424 if (intr_status & host->intr_en & ~intr_done_mask) {
425 struct mmc_request *mrq = host->mrq;
426 struct mmc_command *cmd = mrq->cmd;
427 u32 err_status = 0;
428
429 del_timer(&host->timer);
430 host->mrq = NULL;
431
432 host->intr_en &= MVSD_NOR_CARD_INT;
433 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
434 mvsd_write(MVSD_ERR_INTR_EN, 0);
435
436 spin_unlock(&host->lock);
437
438 if (intr_status & MVSD_NOR_UNEXP_RSP) {
439 cmd->error = -EPROTO;
440 } else if (intr_status & MVSD_NOR_ERROR) {
441 err_status = mvsd_read(MVSD_ERR_INTR_STATUS);
442 dev_dbg(host->dev, "err 0x%04x\n", err_status);
443 }
444
445 err_status = mvsd_finish_cmd(host, cmd, err_status);
446 if (mrq->data)
447 err_status = mvsd_finish_data(host, mrq->data, err_status);
448 if (err_status) {
449 printk(KERN_ERR "%s: unhandled error status %#04x\n",
450 mmc_hostname(host->mmc), err_status);
451 cmd->error = -ENOMSG;
452 }
453
454 mmc_request_done(host->mmc, mrq);
455 irq_handled = 1;
456 } else
457 spin_unlock(&host->lock);
458
459 if (intr_status & MVSD_NOR_CARD_INT) {
460 mmc_signal_sdio_irq(host->mmc);
461 irq_handled = 1;
462 }
463
464 if (irq_handled)
465 return IRQ_HANDLED;
466
467 printk(KERN_ERR "%s: unhandled interrupt status=0x%04x en=0x%04x "
468 "pio=%d\n", mmc_hostname(host->mmc), intr_status,
469 host->intr_en, host->pio_size);
470 return IRQ_NONE;
471 }
472
473 static void mvsd_timeout_timer(unsigned long data)
474 {
475 struct mvsd_host *host = (struct mvsd_host *)data;
476 void __iomem *iobase = host->base;
477 struct mmc_request *mrq;
478 unsigned long flags;
479
480 spin_lock_irqsave(&host->lock, flags);
481 mrq = host->mrq;
482 if (mrq) {
483 printk(KERN_ERR "%s: Timeout waiting for hardware interrupt.\n",
484 mmc_hostname(host->mmc));
485 printk(KERN_ERR "%s: hw_state=0x%04x, intr_status=0x%04x "
486 "intr_en=0x%04x\n", mmc_hostname(host->mmc),
487 mvsd_read(MVSD_HW_STATE),
488 mvsd_read(MVSD_NOR_INTR_STATUS),
489 mvsd_read(MVSD_NOR_INTR_EN));
490
491 host->mrq = NULL;
492
493 mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
494
495 host->xfer_mode &= MVSD_XFER_MODE_INT_CHK_EN;
496 mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
497
498 host->intr_en &= MVSD_NOR_CARD_INT;
499 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
500 mvsd_write(MVSD_ERR_INTR_EN, 0);
501 mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
502
503 mrq->cmd->error = -ETIMEDOUT;
504 mvsd_finish_cmd(host, mrq->cmd, 0);
505 if (mrq->data) {
506 mrq->data->error = -ETIMEDOUT;
507 mvsd_finish_data(host, mrq->data, 0);
508 }
509 }
510 spin_unlock_irqrestore(&host->lock, flags);
511
512 if (mrq)
513 mmc_request_done(host->mmc, mrq);
514 }
515
516 static irqreturn_t mvsd_card_detect_irq(int irq, void *dev)
517 {
518 struct mvsd_host *host = dev;
519 mmc_detect_change(host->mmc, msecs_to_jiffies(100));
520 return IRQ_HANDLED;
521 }
522
523 static void mvsd_enable_sdio_irq(struct mmc_host *mmc, int enable)
524 {
525 struct mvsd_host *host = mmc_priv(mmc);
526 void __iomem *iobase = host->base;
527 unsigned long flags;
528
529 spin_lock_irqsave(&host->lock, flags);
530 if (enable) {
531 host->xfer_mode |= MVSD_XFER_MODE_INT_CHK_EN;
532 host->intr_en |= MVSD_NOR_CARD_INT;
533 } else {
534 host->xfer_mode &= ~MVSD_XFER_MODE_INT_CHK_EN;
535 host->intr_en &= ~MVSD_NOR_CARD_INT;
536 }
537 mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
538 mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
539 spin_unlock_irqrestore(&host->lock, flags);
540 }
541
542 static int mvsd_get_ro(struct mmc_host *mmc)
543 {
544 struct mvsd_host *host = mmc_priv(mmc);
545
546 if (host->gpio_write_protect)
547 return gpio_get_value(host->gpio_write_protect);
548
549 /*
550 * Board doesn't support read only detection; let the mmc core
551 * decide what to do.
552 */
553 return -ENOSYS;
554 }
555
556 static void mvsd_power_up(struct mvsd_host *host)
557 {
558 void __iomem *iobase = host->base;
559 dev_dbg(host->dev, "power up\n");
560 mvsd_write(MVSD_NOR_INTR_EN, 0);
561 mvsd_write(MVSD_ERR_INTR_EN, 0);
562 mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
563 mvsd_write(MVSD_XFER_MODE, 0);
564 mvsd_write(MVSD_NOR_STATUS_EN, 0xffff);
565 mvsd_write(MVSD_ERR_STATUS_EN, 0xffff);
566 mvsd_write(MVSD_NOR_INTR_STATUS, 0xffff);
567 mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
568 }
569
570 static void mvsd_power_down(struct mvsd_host *host)
571 {
572 void __iomem *iobase = host->base;
573 dev_dbg(host->dev, "power down\n");
574 mvsd_write(MVSD_NOR_INTR_EN, 0);
575 mvsd_write(MVSD_ERR_INTR_EN, 0);
576 mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
577 mvsd_write(MVSD_XFER_MODE, MVSD_XFER_MODE_STOP_CLK);
578 mvsd_write(MVSD_NOR_STATUS_EN, 0);
579 mvsd_write(MVSD_ERR_STATUS_EN, 0);
580 mvsd_write(MVSD_NOR_INTR_STATUS, 0xffff);
581 mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
582 }
583
584 static void mvsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
585 {
586 struct mvsd_host *host = mmc_priv(mmc);
587 void __iomem *iobase = host->base;
588 u32 ctrl_reg = 0;
589
590 if (ios->power_mode == MMC_POWER_UP)
591 mvsd_power_up(host);
592
593 if (ios->clock == 0) {
594 mvsd_write(MVSD_XFER_MODE, MVSD_XFER_MODE_STOP_CLK);
595 mvsd_write(MVSD_CLK_DIV, MVSD_BASE_DIV_MAX);
596 host->clock = 0;
597 dev_dbg(host->dev, "clock off\n");
598 } else if (ios->clock != host->clock) {
599 u32 m = DIV_ROUND_UP(host->base_clock, ios->clock) - 1;
600 if (m > MVSD_BASE_DIV_MAX)
601 m = MVSD_BASE_DIV_MAX;
602 mvsd_write(MVSD_CLK_DIV, m);
603 host->clock = ios->clock;
604 host->ns_per_clk = 1000000000 / (host->base_clock / (m+1));
605 dev_dbg(host->dev, "clock=%d (%d), div=0x%04x\n",
606 ios->clock, host->base_clock / (m+1), m);
607 }
608
609 /* default transfer mode */
610 ctrl_reg |= MVSD_HOST_CTRL_BIG_ENDIAN;
611 ctrl_reg &= ~MVSD_HOST_CTRL_LSB_FIRST;
612
613 /* default to maximum timeout */
614 ctrl_reg |= MVSD_HOST_CTRL_TMOUT_MASK;
615 ctrl_reg |= MVSD_HOST_CTRL_TMOUT_EN;
616
617 if (ios->bus_mode == MMC_BUSMODE_PUSHPULL)
618 ctrl_reg |= MVSD_HOST_CTRL_PUSH_PULL_EN;
619
620 if (ios->bus_width == MMC_BUS_WIDTH_4)
621 ctrl_reg |= MVSD_HOST_CTRL_DATA_WIDTH_4_BITS;
622
623 /*
624 * The HI_SPEED_EN bit is causing trouble with many (but not all)
625 * high speed SD, SDHC and SDIO cards. Not enabling that bit
626 * makes all cards work. So let's just ignore that bit for now
627 * and revisit this issue if problems for not enabling this bit
628 * are ever reported.
629 */
630 #if 0
631 if (ios->timing == MMC_TIMING_MMC_HS ||
632 ios->timing == MMC_TIMING_SD_HS)
633 ctrl_reg |= MVSD_HOST_CTRL_HI_SPEED_EN;
634 #endif
635
636 host->ctrl = ctrl_reg;
637 mvsd_write(MVSD_HOST_CTRL, ctrl_reg);
638 dev_dbg(host->dev, "ctrl 0x%04x: %s %s %s\n", ctrl_reg,
639 (ctrl_reg & MVSD_HOST_CTRL_PUSH_PULL_EN) ?
640 "push-pull" : "open-drain",
641 (ctrl_reg & MVSD_HOST_CTRL_DATA_WIDTH_4_BITS) ?
642 "4bit-width" : "1bit-width",
643 (ctrl_reg & MVSD_HOST_CTRL_HI_SPEED_EN) ?
644 "high-speed" : "");
645
646 if (ios->power_mode == MMC_POWER_OFF)
647 mvsd_power_down(host);
648 }
649
650 static const struct mmc_host_ops mvsd_ops = {
651 .request = mvsd_request,
652 .get_ro = mvsd_get_ro,
653 .set_ios = mvsd_set_ios,
654 .enable_sdio_irq = mvsd_enable_sdio_irq,
655 };
656
657 static void __init mv_conf_mbus_windows(struct mvsd_host *host,
658 struct mbus_dram_target_info *dram)
659 {
660 void __iomem *iobase = host->base;
661 int i;
662
663 for (i = 0; i < 4; i++) {
664 writel(0, iobase + MVSD_WINDOW_CTRL(i));
665 writel(0, iobase + MVSD_WINDOW_BASE(i));
666 }
667
668 for (i = 0; i < dram->num_cs; i++) {
669 struct mbus_dram_window *cs = dram->cs + i;
670 writel(((cs->size - 1) & 0xffff0000) |
671 (cs->mbus_attr << 8) |
672 (dram->mbus_dram_target_id << 4) | 1,
673 iobase + MVSD_WINDOW_CTRL(i));
674 writel(cs->base, iobase + MVSD_WINDOW_BASE(i));
675 }
676 }
677
678 static int __init mvsd_probe(struct platform_device *pdev)
679 {
680 struct mmc_host *mmc = NULL;
681 struct mvsd_host *host = NULL;
682 const struct mvsdio_platform_data *mvsd_data;
683 struct resource *r;
684 int ret, irq;
685
686 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
687 irq = platform_get_irq(pdev, 0);
688 mvsd_data = pdev->dev.platform_data;
689 if (!r || irq < 0 || !mvsd_data)
690 return -ENXIO;
691
692 r = request_mem_region(r->start, SZ_1K, DRIVER_NAME);
693 if (!r)
694 return -EBUSY;
695
696 mmc = mmc_alloc_host(sizeof(struct mvsd_host), &pdev->dev);
697 if (!mmc) {
698 ret = -ENOMEM;
699 goto out;
700 }
701
702 host = mmc_priv(mmc);
703 host->mmc = mmc;
704 host->dev = &pdev->dev;
705 host->res = r;
706 host->base_clock = mvsd_data->clock / 2;
707
708 mmc->ops = &mvsd_ops;
709
710 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
711 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ |
712 MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
713
714 mmc->f_min = DIV_ROUND_UP(host->base_clock, MVSD_BASE_DIV_MAX);
715 mmc->f_max = maxfreq;
716
717 mmc->max_blk_size = 2048;
718 mmc->max_blk_count = 65535;
719
720 mmc->max_hw_segs = 1;
721 mmc->max_phys_segs = 1;
722 mmc->max_seg_size = mmc->max_blk_size * mmc->max_blk_count;
723 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
724
725 spin_lock_init(&host->lock);
726
727 host->base = ioremap(r->start, SZ_4K);
728 if (!host->base) {
729 ret = -ENOMEM;
730 goto out;
731 }
732
733 /* (Re-)program MBUS remapping windows if we are asked to. */
734 if (mvsd_data->dram != NULL)
735 mv_conf_mbus_windows(host, mvsd_data->dram);
736
737 mvsd_power_down(host);
738
739 ret = request_irq(irq, mvsd_irq, 0, DRIVER_NAME, host);
740 if (ret) {
741 printk(KERN_ERR "%s: cannot assign irq %d\n", DRIVER_NAME, irq);
742 goto out;
743 } else
744 host->irq = irq;
745
746 if (mvsd_data->gpio_card_detect) {
747 ret = gpio_request(mvsd_data->gpio_card_detect,
748 DRIVER_NAME " cd");
749 if (ret == 0) {
750 gpio_direction_input(mvsd_data->gpio_card_detect);
751 irq = gpio_to_irq(mvsd_data->gpio_card_detect);
752 ret = request_irq(irq, mvsd_card_detect_irq,
753 IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING,
754 DRIVER_NAME " cd", host);
755 if (ret == 0)
756 host->gpio_card_detect =
757 mvsd_data->gpio_card_detect;
758 else
759 gpio_free(mvsd_data->gpio_card_detect);
760 }
761 }
762 if (!host->gpio_card_detect)
763 mmc->caps |= MMC_CAP_NEEDS_POLL;
764
765 if (mvsd_data->gpio_write_protect) {
766 ret = gpio_request(mvsd_data->gpio_write_protect,
767 DRIVER_NAME " wp");
768 if (ret == 0) {
769 gpio_direction_input(mvsd_data->gpio_write_protect);
770 host->gpio_write_protect =
771 mvsd_data->gpio_write_protect;
772 }
773 }
774
775 setup_timer(&host->timer, mvsd_timeout_timer, (unsigned long)host);
776 platform_set_drvdata(pdev, mmc);
777 ret = mmc_add_host(mmc);
778 if (ret)
779 goto out;
780
781 printk(KERN_NOTICE "%s: %s driver initialized, ",
782 mmc_hostname(mmc), DRIVER_NAME);
783 if (host->gpio_card_detect)
784 printk("using GPIO %d for card detection\n",
785 host->gpio_card_detect);
786 else
787 printk("lacking card detect (fall back to polling)\n");
788 return 0;
789
790 out:
791 if (host) {
792 if (host->irq)
793 free_irq(host->irq, host);
794 if (host->gpio_card_detect) {
795 free_irq(gpio_to_irq(host->gpio_card_detect), host);
796 gpio_free(host->gpio_card_detect);
797 }
798 if (host->gpio_write_protect)
799 gpio_free(host->gpio_write_protect);
800 if (host->base)
801 iounmap(host->base);
802 }
803 if (r)
804 release_resource(r);
805 if (mmc)
806 mmc_free_host(mmc);
807
808 return ret;
809 }
810
811 static int __exit mvsd_remove(struct platform_device *pdev)
812 {
813 struct mmc_host *mmc = platform_get_drvdata(pdev);
814
815 if (mmc) {
816 struct mvsd_host *host = mmc_priv(mmc);
817
818 if (host->gpio_card_detect) {
819 free_irq(gpio_to_irq(host->gpio_card_detect), host);
820 gpio_free(host->gpio_card_detect);
821 }
822 mmc_remove_host(mmc);
823 free_irq(host->irq, host);
824 if (host->gpio_write_protect)
825 gpio_free(host->gpio_write_protect);
826 del_timer_sync(&host->timer);
827 mvsd_power_down(host);
828 iounmap(host->base);
829 release_resource(host->res);
830 mmc_free_host(mmc);
831 }
832 platform_set_drvdata(pdev, NULL);
833 return 0;
834 }
835
836 #ifdef CONFIG_PM
837 static int mvsd_suspend(struct platform_device *dev, pm_message_t state)
838 {
839 struct mmc_host *mmc = platform_get_drvdata(dev);
840 int ret = 0;
841
842 if (mmc)
843 ret = mmc_suspend_host(mmc, state);
844
845 return ret;
846 }
847
848 static int mvsd_resume(struct platform_device *dev)
849 {
850 struct mmc_host *mmc = platform_get_drvdata(dev);
851 int ret = 0;
852
853 if (mmc)
854 ret = mmc_resume_host(mmc);
855
856 return ret;
857 }
858 #else
859 #define mvsd_suspend NULL
860 #define mvsd_resume NULL
861 #endif
862
863 static struct platform_driver mvsd_driver = {
864 .remove = __exit_p(mvsd_remove),
865 .suspend = mvsd_suspend,
866 .resume = mvsd_resume,
867 .driver = {
868 .name = DRIVER_NAME,
869 },
870 };
871
872 static int __init mvsd_init(void)
873 {
874 return platform_driver_probe(&mvsd_driver, mvsd_probe);
875 }
876
877 static void __exit mvsd_exit(void)
878 {
879 platform_driver_unregister(&mvsd_driver);
880 }
881
882 module_init(mvsd_init);
883 module_exit(mvsd_exit);
884
885 /* maximum card clock frequency (default 50MHz) */
886 module_param(maxfreq, int, 0);
887
888 /* force PIO transfers all the time */
889 module_param(nodma, int, 0);
890
891 MODULE_AUTHOR("Maen Suleiman, Nicolas Pitre");
892 MODULE_DESCRIPTION("Marvell MMC,SD,SDIO Host Controller driver");
893 MODULE_LICENSE("GPL");
894 MODULE_ALIAS("platform:mvsdio");
linux 2.6 git repository for openrd