aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mmc/host/wbsd.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mmc/host/wbsd.c')
-rw-r--r--drivers/mmc/host/wbsd.c2061
1 files changed, 2061 insertions, 0 deletions
diff --git a/drivers/mmc/host/wbsd.c b/drivers/mmc/host/wbsd.c
new file mode 100644
index 000000000000..867ca6a69298
--- /dev/null
+++ b/drivers/mmc/host/wbsd.c
@@ -0,0 +1,2061 @@
1/*
2 * linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
3 *
4 * Copyright (C) 2004-2007 Pierre Ossman, All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 *
12 * Warning!
13 *
14 * Changes to the FIFO system should be done with extreme care since
15 * the hardware is full of bugs related to the FIFO. Known issues are:
16 *
17 * - FIFO size field in FSR is always zero.
18 *
19 * - FIFO interrupts tend not to work as they should. Interrupts are
20 * triggered only for full/empty events, not for threshold values.
21 *
22 * - On APIC systems the FIFO empty interrupt is sometimes lost.
23 */
24
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/init.h>
28#include <linux/ioport.h>
29#include <linux/platform_device.h>
30#include <linux/interrupt.h>
31#include <linux/dma-mapping.h>
32#include <linux/delay.h>
33#include <linux/pnp.h>
34#include <linux/highmem.h>
35#include <linux/mmc/host.h>
36
37#include <asm/io.h>
38#include <asm/dma.h>
39#include <asm/scatterlist.h>
40
41#include "wbsd.h"
42
43#define DRIVER_NAME "wbsd"
44
45#define DBG(x...) \
46 pr_debug(DRIVER_NAME ": " x)
47#define DBGF(f, x...) \
48 pr_debug(DRIVER_NAME " [%s()]: " f, __func__ , ##x)
49
50/*
51 * Device resources
52 */
53
54#ifdef CONFIG_PNP
55
56static const struct pnp_device_id pnp_dev_table[] = {
57 { "WEC0517", 0 },
58 { "WEC0518", 0 },
59 { "", 0 },
60};
61
62MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
63
64#endif /* CONFIG_PNP */
65
66static const int config_ports[] = { 0x2E, 0x4E };
67static const int unlock_codes[] = { 0x83, 0x87 };
68
69static const int valid_ids[] = {
70 0x7112,
71 };
72
73#ifdef CONFIG_PNP
74static unsigned int nopnp = 0;
75#else
76static const unsigned int nopnp = 1;
77#endif
78static unsigned int io = 0x248;
79static unsigned int irq = 6;
80static int dma = 2;
81
82/*
83 * Basic functions
84 */
85
86static inline void wbsd_unlock_config(struct wbsd_host *host)
87{
88 BUG_ON(host->config == 0);
89
90 outb(host->unlock_code, host->config);
91 outb(host->unlock_code, host->config);
92}
93
94static inline void wbsd_lock_config(struct wbsd_host *host)
95{
96 BUG_ON(host->config == 0);
97
98 outb(LOCK_CODE, host->config);
99}
100
101static inline void wbsd_write_config(struct wbsd_host *host, u8 reg, u8 value)
102{
103 BUG_ON(host->config == 0);
104
105 outb(reg, host->config);
106 outb(value, host->config + 1);
107}
108
109static inline u8 wbsd_read_config(struct wbsd_host *host, u8 reg)
110{
111 BUG_ON(host->config == 0);
112
113 outb(reg, host->config);
114 return inb(host->config + 1);
115}
116
117static inline void wbsd_write_index(struct wbsd_host *host, u8 index, u8 value)
118{
119 outb(index, host->base + WBSD_IDXR);
120 outb(value, host->base + WBSD_DATAR);
121}
122
123static inline u8 wbsd_read_index(struct wbsd_host *host, u8 index)
124{
125 outb(index, host->base + WBSD_IDXR);
126 return inb(host->base + WBSD_DATAR);
127}
128
129/*
130 * Common routines
131 */
132
133static void wbsd_init_device(struct wbsd_host *host)
134{
135 u8 setup, ier;
136
137 /*
138 * Reset chip (SD/MMC part) and fifo.
139 */
140 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
141 setup |= WBSD_FIFO_RESET | WBSD_SOFT_RESET;
142 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
143
144 /*
145 * Set DAT3 to input
146 */
147 setup &= ~WBSD_DAT3_H;
148 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
149 host->flags &= ~WBSD_FIGNORE_DETECT;
150
151 /*
152 * Read back default clock.
153 */
154 host->clk = wbsd_read_index(host, WBSD_IDX_CLK);
155
156 /*
157 * Power down port.
158 */
159 outb(WBSD_POWER_N, host->base + WBSD_CSR);
160
161 /*
162 * Set maximum timeout.
163 */
164 wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F);
165
166 /*
167 * Test for card presence
168 */
169 if (inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT)
170 host->flags |= WBSD_FCARD_PRESENT;
171 else
172 host->flags &= ~WBSD_FCARD_PRESENT;
173
174 /*
175 * Enable interesting interrupts.
176 */
177 ier = 0;
178 ier |= WBSD_EINT_CARD;
179 ier |= WBSD_EINT_FIFO_THRE;
180 ier |= WBSD_EINT_CRC;
181 ier |= WBSD_EINT_TIMEOUT;
182 ier |= WBSD_EINT_TC;
183
184 outb(ier, host->base + WBSD_EIR);
185
186 /*
187 * Clear interrupts.
188 */
189 inb(host->base + WBSD_ISR);
190}
191
192static void wbsd_reset(struct wbsd_host *host)
193{
194 u8 setup;
195
196 printk(KERN_ERR "%s: Resetting chip\n", mmc_hostname(host->mmc));
197
198 /*
199 * Soft reset of chip (SD/MMC part).
200 */
201 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
202 setup |= WBSD_SOFT_RESET;
203 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
204}
205
206static void wbsd_request_end(struct wbsd_host *host, struct mmc_request *mrq)
207{
208 unsigned long dmaflags;
209
210 DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode);
211
212 if (host->dma >= 0) {
213 /*
214 * Release ISA DMA controller.
215 */
216 dmaflags = claim_dma_lock();
217 disable_dma(host->dma);
218 clear_dma_ff(host->dma);
219 release_dma_lock(dmaflags);
220
221 /*
222 * Disable DMA on host.
223 */
224 wbsd_write_index(host, WBSD_IDX_DMA, 0);
225 }
226
227 host->mrq = NULL;
228
229 /*
230 * MMC layer might call back into the driver so first unlock.
231 */
232 spin_unlock(&host->lock);
233 mmc_request_done(host->mmc, mrq);
234 spin_lock(&host->lock);
235}
236
237/*
238 * Scatter/gather functions
239 */
240
241static inline void wbsd_init_sg(struct wbsd_host *host, struct mmc_data *data)
242{
243 /*
244 * Get info. about SG list from data structure.
245 */
246 host->cur_sg = data->sg;
247 host->num_sg = data->sg_len;
248
249 host->offset = 0;
250 host->remain = host->cur_sg->length;
251}
252
253static inline int wbsd_next_sg(struct wbsd_host *host)
254{
255 /*
256 * Skip to next SG entry.
257 */
258 host->cur_sg++;
259 host->num_sg--;
260
261 /*
262 * Any entries left?
263 */
264 if (host->num_sg > 0) {
265 host->offset = 0;
266 host->remain = host->cur_sg->length;
267 }
268
269 return host->num_sg;
270}
271
272static inline char *wbsd_sg_to_buffer(struct wbsd_host *host)
273{
274 return page_address(host->cur_sg->page) + host->cur_sg->offset;
275}
276
277static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
278{
279 unsigned int len, i;
280 struct scatterlist *sg;
281 char *dmabuf = host->dma_buffer;
282 char *sgbuf;
283
284 sg = data->sg;
285 len = data->sg_len;
286
287 for (i = 0; i < len; i++) {
288 sgbuf = page_address(sg[i].page) + sg[i].offset;
289 memcpy(dmabuf, sgbuf, sg[i].length);
290 dmabuf += sg[i].length;
291 }
292}
293
294static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data)
295{
296 unsigned int len, i;
297 struct scatterlist *sg;
298 char *dmabuf = host->dma_buffer;
299 char *sgbuf;
300
301 sg = data->sg;
302 len = data->sg_len;
303
304 for (i = 0; i < len; i++) {
305 sgbuf = page_address(sg[i].page) + sg[i].offset;
306 memcpy(sgbuf, dmabuf, sg[i].length);
307 dmabuf += sg[i].length;
308 }
309}
310
311/*
312 * Command handling
313 */
314
315static inline void wbsd_get_short_reply(struct wbsd_host *host,
316 struct mmc_command *cmd)
317{
318 /*
319 * Correct response type?
320 */
321 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
322 cmd->error = MMC_ERR_INVALID;
323 return;
324 }
325
326 cmd->resp[0] = wbsd_read_index(host, WBSD_IDX_RESP12) << 24;
327 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP13) << 16;
328 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP14) << 8;
329 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP15) << 0;
330 cmd->resp[1] = wbsd_read_index(host, WBSD_IDX_RESP16) << 24;
331}
332
333static inline void wbsd_get_long_reply(struct wbsd_host *host,
334 struct mmc_command *cmd)
335{
336 int i;
337
338 /*
339 * Correct response type?
340 */
341 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
342 cmd->error = MMC_ERR_INVALID;
343 return;
344 }
345
346 for (i = 0; i < 4; i++) {
347 cmd->resp[i] =
348 wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
349 cmd->resp[i] |=
350 wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
351 cmd->resp[i] |=
352 wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
353 cmd->resp[i] |=
354 wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
355 }
356}
357
358static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
359{
360 int i;
361 u8 status, isr;
362
363 DBGF("Sending cmd (%x)\n", cmd->opcode);
364
365 /*
366 * Clear accumulated ISR. The interrupt routine
367 * will fill this one with events that occur during
368 * transfer.
369 */
370 host->isr = 0;
371
372 /*
373 * Send the command (CRC calculated by host).
374 */
375 outb(cmd->opcode, host->base + WBSD_CMDR);
376 for (i = 3; i >= 0; i--)
377 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
378
379 cmd->error = MMC_ERR_NONE;
380
381 /*
382 * Wait for the request to complete.
383 */
384 do {
385 status = wbsd_read_index(host, WBSD_IDX_STATUS);
386 } while (status & WBSD_CARDTRAFFIC);
387
388 /*
389 * Do we expect a reply?
390 */
391 if (cmd->flags & MMC_RSP_PRESENT) {
392 /*
393 * Read back status.
394 */
395 isr = host->isr;
396
397 /* Card removed? */
398 if (isr & WBSD_INT_CARD)
399 cmd->error = MMC_ERR_TIMEOUT;
400 /* Timeout? */
401 else if (isr & WBSD_INT_TIMEOUT)
402 cmd->error = MMC_ERR_TIMEOUT;
403 /* CRC? */
404 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
405 cmd->error = MMC_ERR_BADCRC;
406 /* All ok */
407 else {
408 if (cmd->flags & MMC_RSP_136)
409 wbsd_get_long_reply(host, cmd);
410 else
411 wbsd_get_short_reply(host, cmd);
412 }
413 }
414
415 DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
416}
417
418/*
419 * Data functions
420 */
421
422static void wbsd_empty_fifo(struct wbsd_host *host)
423{
424 struct mmc_data *data = host->mrq->cmd->data;
425 char *buffer;
426 int i, fsr, fifo;
427
428 /*
429 * Handle excessive data.
430 */
431 if (host->num_sg == 0)
432 return;
433
434 buffer = wbsd_sg_to_buffer(host) + host->offset;
435
436 /*
437 * Drain the fifo. This has a tendency to loop longer
438 * than the FIFO length (usually one block).
439 */
440 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY)) {
441 /*
442 * The size field in the FSR is broken so we have to
443 * do some guessing.
444 */
445 if (fsr & WBSD_FIFO_FULL)
446 fifo = 16;
447 else if (fsr & WBSD_FIFO_FUTHRE)
448 fifo = 8;
449 else
450 fifo = 1;
451
452 for (i = 0; i < fifo; i++) {
453 *buffer = inb(host->base + WBSD_DFR);
454 buffer++;
455 host->offset++;
456 host->remain--;
457
458 data->bytes_xfered++;
459
460 /*
461 * End of scatter list entry?
462 */
463 if (host->remain == 0) {
464 /*
465 * Get next entry. Check if last.
466 */
467 if (!wbsd_next_sg(host))
468 return;
469
470 buffer = wbsd_sg_to_buffer(host);
471 }
472 }
473 }
474
475 /*
476 * This is a very dirty hack to solve a
477 * hardware problem. The chip doesn't trigger
478 * FIFO threshold interrupts properly.
479 */
480 if ((data->blocks * data->blksz - data->bytes_xfered) < 16)
481 tasklet_schedule(&host->fifo_tasklet);
482}
483
484static void wbsd_fill_fifo(struct wbsd_host *host)
485{
486 struct mmc_data *data = host->mrq->cmd->data;
487 char *buffer;
488 int i, fsr, fifo;
489
490 /*
491 * Check that we aren't being called after the
492 * entire buffer has been transfered.
493 */
494 if (host->num_sg == 0)
495 return;
496
497 buffer = wbsd_sg_to_buffer(host) + host->offset;
498
499 /*
500 * Fill the fifo. This has a tendency to loop longer
501 * than the FIFO length (usually one block).
502 */
503 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL)) {
504 /*
505 * The size field in the FSR is broken so we have to
506 * do some guessing.
507 */
508 if (fsr & WBSD_FIFO_EMPTY)
509 fifo = 0;
510 else if (fsr & WBSD_FIFO_EMTHRE)
511 fifo = 8;
512 else
513 fifo = 15;
514
515 for (i = 16; i > fifo; i--) {
516 outb(*buffer, host->base + WBSD_DFR);
517 buffer++;
518 host->offset++;
519 host->remain--;
520
521 data->bytes_xfered++;
522
523 /*
524 * End of scatter list entry?
525 */
526 if (host->remain == 0) {
527 /*
528 * Get next entry. Check if last.
529 */
530 if (!wbsd_next_sg(host))
531 return;
532
533 buffer = wbsd_sg_to_buffer(host);
534 }
535 }
536 }
537
538 /*
539 * The controller stops sending interrupts for
540 * 'FIFO empty' under certain conditions. So we
541 * need to be a bit more pro-active.
542 */
543 tasklet_schedule(&host->fifo_tasklet);
544}
545
546static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
547{
548 u16 blksize;
549 u8 setup;
550 unsigned long dmaflags;
551 unsigned int size;
552
553 DBGF("blksz %04x blks %04x flags %08x\n",
554 data->blksz, data->blocks, data->flags);
555 DBGF("tsac %d ms nsac %d clk\n",
556 data->timeout_ns / 1000000, data->timeout_clks);
557
558 /*
559 * Calculate size.
560 */
561 size = data->blocks * data->blksz;
562
563 /*
564 * Check timeout values for overflow.
565 * (Yes, some cards cause this value to overflow).
566 */
567 if (data->timeout_ns > 127000000)
568 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
569 else {
570 wbsd_write_index(host, WBSD_IDX_TAAC,
571 data->timeout_ns / 1000000);
572 }
573
574 if (data->timeout_clks > 255)
575 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
576 else
577 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
578
579 /*
580 * Inform the chip of how large blocks will be
581 * sent. It needs this to determine when to
582 * calculate CRC.
583 *
584 * Space for CRC must be included in the size.
585 * Two bytes are needed for each data line.
586 */
587 if (host->bus_width == MMC_BUS_WIDTH_1) {
588 blksize = data->blksz + 2;
589
590 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
591 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
592 } else if (host->bus_width == MMC_BUS_WIDTH_4) {
593 blksize = data->blksz + 2 * 4;
594
595 wbsd_write_index(host, WBSD_IDX_PBSMSB,
596 ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH);
597 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
598 } else {
599 data->error = MMC_ERR_INVALID;
600 return;
601 }
602
603 /*
604 * Clear the FIFO. This is needed even for DMA
605 * transfers since the chip still uses the FIFO
606 * internally.
607 */
608 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
609 setup |= WBSD_FIFO_RESET;
610 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
611
612 /*
613 * DMA transfer?
614 */
615 if (host->dma >= 0) {
616 /*
617 * The buffer for DMA is only 64 kB.
618 */
619 BUG_ON(size > 0x10000);
620 if (size > 0x10000) {
621 data->error = MMC_ERR_INVALID;
622 return;
623 }
624
625 /*
626 * Transfer data from the SG list to
627 * the DMA buffer.
628 */
629 if (data->flags & MMC_DATA_WRITE)
630 wbsd_sg_to_dma(host, data);
631
632 /*
633 * Initialise the ISA DMA controller.
634 */
635 dmaflags = claim_dma_lock();
636 disable_dma(host->dma);
637 clear_dma_ff(host->dma);
638 if (data->flags & MMC_DATA_READ)
639 set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
640 else
641 set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
642 set_dma_addr(host->dma, host->dma_addr);
643 set_dma_count(host->dma, size);
644
645 enable_dma(host->dma);
646 release_dma_lock(dmaflags);
647
648 /*
649 * Enable DMA on the host.
650 */
651 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
652 } else {
653 /*
654 * This flag is used to keep printk
655 * output to a minimum.
656 */
657 host->firsterr = 1;
658
659 /*
660 * Initialise the SG list.
661 */
662 wbsd_init_sg(host, data);
663
664 /*
665 * Turn off DMA.
666 */
667 wbsd_write_index(host, WBSD_IDX_DMA, 0);
668
669 /*
670 * Set up FIFO threshold levels (and fill
671 * buffer if doing a write).
672 */
673 if (data->flags & MMC_DATA_READ) {
674 wbsd_write_index(host, WBSD_IDX_FIFOEN,
675 WBSD_FIFOEN_FULL | 8);
676 } else {
677 wbsd_write_index(host, WBSD_IDX_FIFOEN,
678 WBSD_FIFOEN_EMPTY | 8);
679 wbsd_fill_fifo(host);
680 }
681 }
682
683 data->error = MMC_ERR_NONE;
684}
685
686static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
687{
688 unsigned long dmaflags;
689 int count;
690 u8 status;
691
692 WARN_ON(host->mrq == NULL);
693
694 /*
695 * Send a stop command if needed.
696 */
697 if (data->stop)
698 wbsd_send_command(host, data->stop);
699
700 /*
701 * Wait for the controller to leave data
702 * transfer state.
703 */
704 do {
705 status = wbsd_read_index(host, WBSD_IDX_STATUS);
706 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
707
708 /*
709 * DMA transfer?
710 */
711 if (host->dma >= 0) {
712 /*
713 * Disable DMA on the host.
714 */
715 wbsd_write_index(host, WBSD_IDX_DMA, 0);
716
717 /*
718 * Turn of ISA DMA controller.
719 */
720 dmaflags = claim_dma_lock();
721 disable_dma(host->dma);
722 clear_dma_ff(host->dma);
723 count = get_dma_residue(host->dma);
724 release_dma_lock(dmaflags);
725
726 data->bytes_xfered = host->mrq->data->blocks *
727 host->mrq->data->blksz - count;
728 data->bytes_xfered -= data->bytes_xfered % data->blksz;
729
730 /*
731 * Any leftover data?
732 */
733 if (count) {
734 printk(KERN_ERR "%s: Incomplete DMA transfer. "
735 "%d bytes left.\n",
736 mmc_hostname(host->mmc), count);
737
738 if (data->error == MMC_ERR_NONE)
739 data->error = MMC_ERR_FAILED;
740 } else {
741 /*
742 * Transfer data from DMA buffer to
743 * SG list.
744 */
745 if (data->flags & MMC_DATA_READ)
746 wbsd_dma_to_sg(host, data);
747 }
748
749 if (data->error != MMC_ERR_NONE) {
750 if (data->bytes_xfered)
751 data->bytes_xfered -= data->blksz;
752 }
753 }
754
755 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
756
757 wbsd_request_end(host, host->mrq);
758}
759
760/*****************************************************************************\
761 * *
762 * MMC layer callbacks *
763 * *
764\*****************************************************************************/
765
766static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
767{
768 struct wbsd_host *host = mmc_priv(mmc);
769 struct mmc_command *cmd;
770
771 /*
772 * Disable tasklets to avoid a deadlock.
773 */
774 spin_lock_bh(&host->lock);
775
776 BUG_ON(host->mrq != NULL);
777
778 cmd = mrq->cmd;
779
780 host->mrq = mrq;
781
782 /*
783 * If there is no card in the slot then
784 * timeout immediatly.
785 */
786 if (!(host->flags & WBSD_FCARD_PRESENT)) {
787 cmd->error = MMC_ERR_TIMEOUT;
788 goto done;
789 }
790
791 if (cmd->data) {
792 /*
793 * The hardware is so delightfully stupid that it has a list
794 * of "data" commands. If a command isn't on this list, it'll
795 * just go back to the idle state and won't send any data
796 * interrupts.
797 */
798 switch (cmd->opcode) {
799 case 11:
800 case 17:
801 case 18:
802 case 20:
803 case 24:
804 case 25:
805 case 26:
806 case 27:
807 case 30:
808 case 42:
809 case 56:
810 break;
811
812 /* ACMDs. We don't keep track of state, so we just treat them
813 * like any other command. */
814 case 51:
815 break;
816
817 default:
818#ifdef CONFIG_MMC_DEBUG
819 printk(KERN_WARNING "%s: Data command %d is not "
820 "supported by this controller.\n",
821 mmc_hostname(host->mmc), cmd->opcode);
822#endif
823 cmd->error = MMC_ERR_INVALID;
824
825 goto done;
826 };
827 }
828
829 /*
830 * Does the request include data?
831 */
832 if (cmd->data) {
833 wbsd_prepare_data(host, cmd->data);
834
835 if (cmd->data->error != MMC_ERR_NONE)
836 goto done;
837 }
838
839 wbsd_send_command(host, cmd);
840
841 /*
842 * If this is a data transfer the request
843 * will be finished after the data has
844 * transfered.
845 */
846 if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
847 /*
848 * Dirty fix for hardware bug.
849 */
850 if (host->dma == -1)
851 tasklet_schedule(&host->fifo_tasklet);
852
853 spin_unlock_bh(&host->lock);
854
855 return;
856 }
857
858done:
859 wbsd_request_end(host, mrq);
860
861 spin_unlock_bh(&host->lock);
862}
863
864static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
865{
866 struct wbsd_host *host = mmc_priv(mmc);
867 u8 clk, setup, pwr;
868
869 spin_lock_bh(&host->lock);
870
871 /*
872 * Reset the chip on each power off.
873 * Should clear out any weird states.
874 */
875 if (ios->power_mode == MMC_POWER_OFF)
876 wbsd_init_device(host);
877
878 if (ios->clock >= 24000000)
879 clk = WBSD_CLK_24M;
880 else if (ios->clock >= 16000000)
881 clk = WBSD_CLK_16M;
882 else if (ios->clock >= 12000000)
883 clk = WBSD_CLK_12M;
884 else
885 clk = WBSD_CLK_375K;
886
887 /*
888 * Only write to the clock register when
889 * there is an actual change.
890 */
891 if (clk != host->clk) {
892 wbsd_write_index(host, WBSD_IDX_CLK, clk);
893 host->clk = clk;
894 }
895
896 /*
897 * Power up card.
898 */
899 if (ios->power_mode != MMC_POWER_OFF) {
900 pwr = inb(host->base + WBSD_CSR);
901 pwr &= ~WBSD_POWER_N;
902 outb(pwr, host->base + WBSD_CSR);
903 }
904
905 /*
906 * MMC cards need to have pin 1 high during init.
907 * It wreaks havoc with the card detection though so
908 * that needs to be disabled.
909 */
910 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
911 if (ios->chip_select == MMC_CS_HIGH) {
912 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
913 setup |= WBSD_DAT3_H;
914 host->flags |= WBSD_FIGNORE_DETECT;
915 } else {
916 if (setup & WBSD_DAT3_H) {
917 setup &= ~WBSD_DAT3_H;
918
919 /*
920 * We cannot resume card detection immediatly
921 * because of capacitance and delays in the chip.
922 */
923 mod_timer(&host->ignore_timer, jiffies + HZ / 100);
924 }
925 }
926 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
927
928 /*
929 * Store bus width for later. Will be used when
930 * setting up the data transfer.
931 */
932 host->bus_width = ios->bus_width;
933
934 spin_unlock_bh(&host->lock);
935}
936
937static int wbsd_get_ro(struct mmc_host *mmc)
938{
939 struct wbsd_host *host = mmc_priv(mmc);
940 u8 csr;
941
942 spin_lock_bh(&host->lock);
943
944 csr = inb(host->base + WBSD_CSR);
945 csr |= WBSD_MSLED;
946 outb(csr, host->base + WBSD_CSR);
947
948 mdelay(1);
949
950 csr = inb(host->base + WBSD_CSR);
951 csr &= ~WBSD_MSLED;
952 outb(csr, host->base + WBSD_CSR);
953
954 spin_unlock_bh(&host->lock);
955
956 return csr & WBSD_WRPT;
957}
958
959static const struct mmc_host_ops wbsd_ops = {
960 .request = wbsd_request,
961 .set_ios = wbsd_set_ios,
962 .get_ro = wbsd_get_ro,
963};
964
965/*****************************************************************************\
966 * *
967 * Interrupt handling *
968 * *
969\*****************************************************************************/
970
971/*
972 * Helper function to reset detection ignore
973 */
974
975static void wbsd_reset_ignore(unsigned long data)
976{
977 struct wbsd_host *host = (struct wbsd_host *)data;
978
979 BUG_ON(host == NULL);
980
981 DBG("Resetting card detection ignore\n");
982
983 spin_lock_bh(&host->lock);
984
985 host->flags &= ~WBSD_FIGNORE_DETECT;
986
987 /*
988 * Card status might have changed during the
989 * blackout.
990 */
991 tasklet_schedule(&host->card_tasklet);
992
993 spin_unlock_bh(&host->lock);
994}
995
996/*
997 * Tasklets
998 */
999
1000static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
1001{
1002 WARN_ON(!host->mrq);
1003 if (!host->mrq)
1004 return NULL;
1005
1006 WARN_ON(!host->mrq->cmd);
1007 if (!host->mrq->cmd)
1008 return NULL;
1009
1010 WARN_ON(!host->mrq->cmd->data);
1011 if (!host->mrq->cmd->data)
1012 return NULL;
1013
1014 return host->mrq->cmd->data;
1015}
1016
1017static void wbsd_tasklet_card(unsigned long param)
1018{
1019 struct wbsd_host *host = (struct wbsd_host *)param;
1020 u8 csr;
1021 int delay = -1;
1022
1023 spin_lock(&host->lock);
1024
1025 if (host->flags & WBSD_FIGNORE_DETECT) {
1026 spin_unlock(&host->lock);
1027 return;
1028 }
1029
1030 csr = inb(host->base + WBSD_CSR);
1031 WARN_ON(csr == 0xff);
1032
1033 if (csr & WBSD_CARDPRESENT) {
1034 if (!(host->flags & WBSD_FCARD_PRESENT)) {
1035 DBG("Card inserted\n");
1036 host->flags |= WBSD_FCARD_PRESENT;
1037
1038 delay = 500;
1039 }
1040 } else if (host->flags & WBSD_FCARD_PRESENT) {
1041 DBG("Card removed\n");
1042 host->flags &= ~WBSD_FCARD_PRESENT;
1043
1044 if (host->mrq) {
1045 printk(KERN_ERR "%s: Card removed during transfer!\n",
1046 mmc_hostname(host->mmc));
1047 wbsd_reset(host);
1048
1049 host->mrq->cmd->error = MMC_ERR_FAILED;
1050 tasklet_schedule(&host->finish_tasklet);
1051 }
1052
1053 delay = 0;
1054 }
1055
1056 /*
1057 * Unlock first since we might get a call back.
1058 */
1059
1060 spin_unlock(&host->lock);
1061
1062 if (delay != -1)
1063 mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1064}
1065
1066static void wbsd_tasklet_fifo(unsigned long param)
1067{
1068 struct wbsd_host *host = (struct wbsd_host *)param;
1069 struct mmc_data *data;
1070
1071 spin_lock(&host->lock);
1072
1073 if (!host->mrq)
1074 goto end;
1075
1076 data = wbsd_get_data(host);
1077 if (!data)
1078 goto end;
1079
1080 if (data->flags & MMC_DATA_WRITE)
1081 wbsd_fill_fifo(host);
1082 else
1083 wbsd_empty_fifo(host);
1084
1085 /*
1086 * Done?
1087 */
1088 if (host->num_sg == 0) {
1089 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1090 tasklet_schedule(&host->finish_tasklet);
1091 }
1092
1093end:
1094 spin_unlock(&host->lock);
1095}
1096
1097static void wbsd_tasklet_crc(unsigned long param)
1098{
1099 struct wbsd_host *host = (struct wbsd_host *)param;
1100 struct mmc_data *data;
1101
1102 spin_lock(&host->lock);
1103
1104 if (!host->mrq)
1105 goto end;
1106
1107 data = wbsd_get_data(host);
1108 if (!data)
1109 goto end;
1110
1111 DBGF("CRC error\n");
1112
1113 data->error = MMC_ERR_BADCRC;
1114
1115 tasklet_schedule(&host->finish_tasklet);
1116
1117end:
1118 spin_unlock(&host->lock);
1119}
1120
1121static void wbsd_tasklet_timeout(unsigned long param)
1122{
1123 struct wbsd_host *host = (struct wbsd_host *)param;
1124 struct mmc_data *data;
1125
1126 spin_lock(&host->lock);
1127
1128 if (!host->mrq)
1129 goto end;
1130
1131 data = wbsd_get_data(host);
1132 if (!data)
1133 goto end;
1134
1135 DBGF("Timeout\n");
1136
1137 data->error = MMC_ERR_TIMEOUT;
1138
1139 tasklet_schedule(&host->finish_tasklet);
1140
1141end:
1142 spin_unlock(&host->lock);
1143}
1144
1145static void wbsd_tasklet_finish(unsigned long param)
1146{
1147 struct wbsd_host *host = (struct wbsd_host *)param;
1148 struct mmc_data *data;
1149
1150 spin_lock(&host->lock);
1151
1152 WARN_ON(!host->mrq);
1153 if (!host->mrq)
1154 goto end;
1155
1156 data = wbsd_get_data(host);
1157 if (!data)
1158 goto end;
1159
1160 wbsd_finish_data(host, data);
1161
1162end:
1163 spin_unlock(&host->lock);
1164}
1165
1166/*
1167 * Interrupt handling
1168 */
1169
1170static irqreturn_t wbsd_irq(int irq, void *dev_id)
1171{
1172 struct wbsd_host *host = dev_id;
1173 int isr;
1174
1175 isr = inb(host->base + WBSD_ISR);
1176
1177 /*
1178 * Was it actually our hardware that caused the interrupt?
1179 */
1180 if (isr == 0xff || isr == 0x00)
1181 return IRQ_NONE;
1182
1183 host->isr |= isr;
1184
1185 /*
1186 * Schedule tasklets as needed.
1187 */
1188 if (isr & WBSD_INT_CARD)
1189 tasklet_schedule(&host->card_tasklet);
1190 if (isr & WBSD_INT_FIFO_THRE)
1191 tasklet_schedule(&host->fifo_tasklet);
1192 if (isr & WBSD_INT_CRC)
1193 tasklet_hi_schedule(&host->crc_tasklet);
1194 if (isr & WBSD_INT_TIMEOUT)
1195 tasklet_hi_schedule(&host->timeout_tasklet);
1196 if (isr & WBSD_INT_TC)
1197 tasklet_schedule(&host->finish_tasklet);
1198
1199 return IRQ_HANDLED;
1200}
1201
1202/*****************************************************************************\
1203 * *
1204 * Device initialisation and shutdown *
1205 * *
1206\*****************************************************************************/
1207
1208/*
1209 * Allocate/free MMC structure.
1210 */
1211
1212static int __devinit wbsd_alloc_mmc(struct device *dev)
1213{
1214 struct mmc_host *mmc;
1215 struct wbsd_host *host;
1216
1217 /*
1218 * Allocate MMC structure.
1219 */
1220 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1221 if (!mmc)
1222 return -ENOMEM;
1223
1224 host = mmc_priv(mmc);
1225 host->mmc = mmc;
1226
1227 host->dma = -1;
1228
1229 /*
1230 * Set host parameters.
1231 */
1232 mmc->ops = &wbsd_ops;
1233 mmc->f_min = 375000;
1234 mmc->f_max = 24000000;
1235 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1236 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE | MMC_CAP_BYTEBLOCK;
1237
1238 spin_lock_init(&host->lock);
1239
1240 /*
1241 * Set up timers
1242 */
1243 init_timer(&host->ignore_timer);
1244 host->ignore_timer.data = (unsigned long)host;
1245 host->ignore_timer.function = wbsd_reset_ignore;
1246
1247 /*
1248 * Maximum number of segments. Worst case is one sector per segment
1249 * so this will be 64kB/512.
1250 */
1251 mmc->max_hw_segs = 128;
1252 mmc->max_phys_segs = 128;
1253
1254 /*
1255 * Maximum request size. Also limited by 64KiB buffer.
1256 */
1257 mmc->max_req_size = 65536;
1258
1259 /*
1260 * Maximum segment size. Could be one segment with the maximum number
1261 * of bytes.
1262 */
1263 mmc->max_seg_size = mmc->max_req_size;
1264
1265 /*
1266 * Maximum block size. We have 12 bits (= 4095) but have to subtract
1267 * space for CRC. So the maximum is 4095 - 4*2 = 4087.
1268 */
1269 mmc->max_blk_size = 4087;
1270
1271 /*
1272 * Maximum block count. There is no real limit so the maximum
1273 * request size will be the only restriction.
1274 */
1275 mmc->max_blk_count = mmc->max_req_size;
1276
1277 dev_set_drvdata(dev, mmc);
1278
1279 return 0;
1280}
1281
1282static void __devexit wbsd_free_mmc(struct device *dev)
1283{
1284 struct mmc_host *mmc;
1285 struct wbsd_host *host;
1286
1287 mmc = dev_get_drvdata(dev);
1288 if (!mmc)
1289 return;
1290
1291 host = mmc_priv(mmc);
1292 BUG_ON(host == NULL);
1293
1294 del_timer_sync(&host->ignore_timer);
1295
1296 mmc_free_host(mmc);
1297
1298 dev_set_drvdata(dev, NULL);
1299}
1300
1301/*
1302 * Scan for known chip id:s
1303 */
1304
1305static int __devinit wbsd_scan(struct wbsd_host *host)
1306{
1307 int i, j, k;
1308 int id;
1309
1310 /*
1311 * Iterate through all ports, all codes to
1312 * find hardware that is in our known list.
1313 */
1314 for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1315 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1316 continue;
1317
1318 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1319 id = 0xFFFF;
1320
1321 host->config = config_ports[i];
1322 host->unlock_code = unlock_codes[j];
1323
1324 wbsd_unlock_config(host);
1325
1326 outb(WBSD_CONF_ID_HI, config_ports[i]);
1327 id = inb(config_ports[i] + 1) << 8;
1328
1329 outb(WBSD_CONF_ID_LO, config_ports[i]);
1330 id |= inb(config_ports[i] + 1);
1331
1332 wbsd_lock_config(host);
1333
1334 for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1335 if (id == valid_ids[k]) {
1336 host->chip_id = id;
1337
1338 return 0;
1339 }
1340 }
1341
1342 if (id != 0xFFFF) {
1343 DBG("Unknown hardware (id %x) found at %x\n",
1344 id, config_ports[i]);
1345 }
1346 }
1347
1348 release_region(config_ports[i], 2);
1349 }
1350
1351 host->config = 0;
1352 host->unlock_code = 0;
1353
1354 return -ENODEV;
1355}
1356
1357/*
1358 * Allocate/free io port ranges
1359 */
1360
1361static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1362{
1363 if (base & 0x7)
1364 return -EINVAL;
1365
1366 if (!request_region(base, 8, DRIVER_NAME))
1367 return -EIO;
1368
1369 host->base = base;
1370
1371 return 0;
1372}
1373
1374static void __devexit wbsd_release_regions(struct wbsd_host *host)
1375{
1376 if (host->base)
1377 release_region(host->base, 8);
1378
1379 host->base = 0;
1380
1381 if (host->config)
1382 release_region(host->config, 2);
1383
1384 host->config = 0;
1385}
1386
1387/*
1388 * Allocate/free DMA port and buffer
1389 */
1390
1391static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1392{
1393 if (dma < 0)
1394 return;
1395
1396 if (request_dma(dma, DRIVER_NAME))
1397 goto err;
1398
1399 /*
1400 * We need to allocate a special buffer in
1401 * order for ISA to be able to DMA to it.
1402 */
1403 host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1404 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1405 if (!host->dma_buffer)
1406 goto free;
1407
1408 /*
1409 * Translate the address to a physical address.
1410 */
1411 host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer,
1412 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1413
1414 /*
1415 * ISA DMA must be aligned on a 64k basis.
1416 */
1417 if ((host->dma_addr & 0xffff) != 0)
1418 goto kfree;
1419 /*
1420 * ISA cannot access memory above 16 MB.
1421 */
1422 else if (host->dma_addr >= 0x1000000)
1423 goto kfree;
1424
1425 host->dma = dma;
1426
1427 return;
1428
1429kfree:
1430 /*
1431 * If we've gotten here then there is some kind of alignment bug
1432 */
1433 BUG_ON(1);
1434
1435 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1436 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1437 host->dma_addr = (dma_addr_t)NULL;
1438
1439 kfree(host->dma_buffer);
1440 host->dma_buffer = NULL;
1441
1442free:
1443 free_dma(dma);
1444
1445err:
1446 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1447 "Falling back on FIFO.\n", dma);
1448}
1449
1450static void __devexit wbsd_release_dma(struct wbsd_host *host)
1451{
1452 if (host->dma_addr) {
1453 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1454 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1455 }
1456 kfree(host->dma_buffer);
1457 if (host->dma >= 0)
1458 free_dma(host->dma);
1459
1460 host->dma = -1;
1461 host->dma_buffer = NULL;
1462 host->dma_addr = (dma_addr_t)NULL;
1463}
1464
1465/*
1466 * Allocate/free IRQ.
1467 */
1468
1469static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1470{
1471 int ret;
1472
1473 /*
1474 * Allocate interrupt.
1475 */
1476
1477 ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host);
1478 if (ret)
1479 return ret;
1480
1481 host->irq = irq;
1482
1483 /*
1484 * Set up tasklets.
1485 */
1486 tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1487 (unsigned long)host);
1488 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1489 (unsigned long)host);
1490 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1491 (unsigned long)host);
1492 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1493 (unsigned long)host);
1494 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1495 (unsigned long)host);
1496
1497 return 0;
1498}
1499
1500static void __devexit wbsd_release_irq(struct wbsd_host *host)
1501{
1502 if (!host->irq)
1503 return;
1504
1505 free_irq(host->irq, host);
1506
1507 host->irq = 0;
1508
1509 tasklet_kill(&host->card_tasklet);
1510 tasklet_kill(&host->fifo_tasklet);
1511 tasklet_kill(&host->crc_tasklet);
1512 tasklet_kill(&host->timeout_tasklet);
1513 tasklet_kill(&host->finish_tasklet);
1514}
1515
1516/*
1517 * Allocate all resources for the host.
1518 */
1519
1520static int __devinit wbsd_request_resources(struct wbsd_host *host,
1521 int base, int irq, int dma)
1522{
1523 int ret;
1524
1525 /*
1526 * Allocate I/O ports.
1527 */
1528 ret = wbsd_request_region(host, base);
1529 if (ret)
1530 return ret;
1531
1532 /*
1533 * Allocate interrupt.
1534 */
1535 ret = wbsd_request_irq(host, irq);
1536 if (ret)
1537 return ret;
1538
1539 /*
1540 * Allocate DMA.
1541 */
1542 wbsd_request_dma(host, dma);
1543
1544 return 0;
1545}
1546
1547/*
1548 * Release all resources for the host.
1549 */
1550
1551static void __devexit wbsd_release_resources(struct wbsd_host *host)
1552{
1553 wbsd_release_dma(host);
1554 wbsd_release_irq(host);
1555 wbsd_release_regions(host);
1556}
1557
1558/*
1559 * Configure the resources the chip should use.
1560 */
1561
1562static void wbsd_chip_config(struct wbsd_host *host)
1563{
1564 wbsd_unlock_config(host);
1565
1566 /*
1567 * Reset the chip.
1568 */
1569 wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1570 wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1571
1572 /*
1573 * Select SD/MMC function.
1574 */
1575 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1576
1577 /*
1578 * Set up card detection.
1579 */
1580 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1581
1582 /*
1583 * Configure chip
1584 */
1585 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1586 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1587
1588 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1589
1590 if (host->dma >= 0)
1591 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1592
1593 /*
1594 * Enable and power up chip.
1595 */
1596 wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1597 wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1598
1599 wbsd_lock_config(host);
1600}
1601
1602/*
1603 * Check that configured resources are correct.
1604 */
1605
1606static int wbsd_chip_validate(struct wbsd_host *host)
1607{
1608 int base, irq, dma;
1609
1610 wbsd_unlock_config(host);
1611
1612 /*
1613 * Select SD/MMC function.
1614 */
1615 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1616
1617 /*
1618 * Read configuration.
1619 */
1620 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1621 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1622
1623 irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1624
1625 dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1626
1627 wbsd_lock_config(host);
1628
1629 /*
1630 * Validate against given configuration.
1631 */
1632 if (base != host->base)
1633 return 0;
1634 if (irq != host->irq)
1635 return 0;
1636 if ((dma != host->dma) && (host->dma != -1))
1637 return 0;
1638
1639 return 1;
1640}
1641
1642/*
1643 * Powers down the SD function
1644 */
1645
1646static void wbsd_chip_poweroff(struct wbsd_host *host)
1647{
1648 wbsd_unlock_config(host);
1649
1650 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1651 wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1652
1653 wbsd_lock_config(host);
1654}
1655
1656/*****************************************************************************\
1657 * *
1658 * Devices setup and shutdown *
1659 * *
1660\*****************************************************************************/
1661
1662static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1663 int pnp)
1664{
1665 struct wbsd_host *host = NULL;
1666 struct mmc_host *mmc = NULL;
1667 int ret;
1668
1669 ret = wbsd_alloc_mmc(dev);
1670 if (ret)
1671 return ret;
1672
1673 mmc = dev_get_drvdata(dev);
1674 host = mmc_priv(mmc);
1675
1676 /*
1677 * Scan for hardware.
1678 */
1679 ret = wbsd_scan(host);
1680 if (ret) {
1681 if (pnp && (ret == -ENODEV)) {
1682 printk(KERN_WARNING DRIVER_NAME
1683 ": Unable to confirm device presence. You may "
1684 "experience lock-ups.\n");
1685 } else {
1686 wbsd_free_mmc(dev);
1687 return ret;
1688 }
1689 }
1690
1691 /*
1692 * Request resources.
1693 */
1694 ret = wbsd_request_resources(host, base, irq, dma);
1695 if (ret) {
1696 wbsd_release_resources(host);
1697 wbsd_free_mmc(dev);
1698 return ret;
1699 }
1700
1701 /*
1702 * See if chip needs to be configured.
1703 */
1704 if (pnp) {
1705 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1706 printk(KERN_WARNING DRIVER_NAME
1707 ": PnP active but chip not configured! "
1708 "You probably have a buggy BIOS. "
1709 "Configuring chip manually.\n");
1710 wbsd_chip_config(host);
1711 }
1712 } else
1713 wbsd_chip_config(host);
1714
1715 /*
1716 * Power Management stuff. No idea how this works.
1717 * Not tested.
1718 */
1719#ifdef CONFIG_PM
1720 if (host->config) {
1721 wbsd_unlock_config(host);
1722 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1723 wbsd_lock_config(host);
1724 }
1725#endif
1726 /*
1727 * Allow device to initialise itself properly.
1728 */
1729 mdelay(5);
1730
1731 /*
1732 * Reset the chip into a known state.
1733 */
1734 wbsd_init_device(host);
1735
1736 mmc_add_host(mmc);
1737
1738 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1739 if (host->chip_id != 0)
1740 printk(" id %x", (int)host->chip_id);
1741 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1742 if (host->dma >= 0)
1743 printk(" dma %d", (int)host->dma);
1744 else
1745 printk(" FIFO");
1746 if (pnp)
1747 printk(" PnP");
1748 printk("\n");
1749
1750 return 0;
1751}
1752
1753static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1754{
1755 struct mmc_host *mmc = dev_get_drvdata(dev);
1756 struct wbsd_host *host;
1757
1758 if (!mmc)
1759 return;
1760
1761 host = mmc_priv(mmc);
1762
1763 mmc_remove_host(mmc);
1764
1765 /*
1766 * Power down the SD/MMC function.
1767 */
1768 if (!pnp)
1769 wbsd_chip_poweroff(host);
1770
1771 wbsd_release_resources(host);
1772
1773 wbsd_free_mmc(dev);
1774}
1775
1776/*
1777 * Non-PnP
1778 */
1779
1780static int __devinit wbsd_probe(struct platform_device *dev)
1781{
1782 /* Use the module parameters for resources */
1783 return wbsd_init(&dev->dev, io, irq, dma, 0);
1784}
1785
1786static int __devexit wbsd_remove(struct platform_device *dev)
1787{
1788 wbsd_shutdown(&dev->dev, 0);
1789
1790 return 0;
1791}
1792
1793/*
1794 * PnP
1795 */
1796
1797#ifdef CONFIG_PNP
1798
1799static int __devinit
1800wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1801{
1802 int io, irq, dma;
1803
1804 /*
1805 * Get resources from PnP layer.
1806 */
1807 io = pnp_port_start(pnpdev, 0);
1808 irq = pnp_irq(pnpdev, 0);
1809 if (pnp_dma_valid(pnpdev, 0))
1810 dma = pnp_dma(pnpdev, 0);
1811 else
1812 dma = -1;
1813
1814 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1815
1816 return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1817}
1818
1819static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1820{
1821 wbsd_shutdown(&dev->dev, 1);
1822}
1823
1824#endif /* CONFIG_PNP */
1825
1826/*
1827 * Power management
1828 */
1829
1830#ifdef CONFIG_PM
1831
1832static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1833{
1834 BUG_ON(host == NULL);
1835
1836 return mmc_suspend_host(host->mmc, state);
1837}
1838
1839static int wbsd_resume(struct wbsd_host *host)
1840{
1841 BUG_ON(host == NULL);
1842
1843 wbsd_init_device(host);
1844
1845 return mmc_resume_host(host->mmc);
1846}
1847
1848static int wbsd_platform_suspend(struct platform_device *dev,
1849 pm_message_t state)
1850{
1851 struct mmc_host *mmc = platform_get_drvdata(dev);
1852 struct wbsd_host *host;
1853 int ret;
1854
1855 if (mmc == NULL)
1856 return 0;
1857
1858 DBGF("Suspending...\n");
1859
1860 host = mmc_priv(mmc);
1861
1862 ret = wbsd_suspend(host, state);
1863 if (ret)
1864 return ret;
1865
1866 wbsd_chip_poweroff(host);
1867
1868 return 0;
1869}
1870
1871static int wbsd_platform_resume(struct platform_device *dev)
1872{
1873 struct mmc_host *mmc = platform_get_drvdata(dev);
1874 struct wbsd_host *host;
1875
1876 if (mmc == NULL)
1877 return 0;
1878
1879 DBGF("Resuming...\n");
1880
1881 host = mmc_priv(mmc);
1882
1883 wbsd_chip_config(host);
1884
1885 /*
1886 * Allow device to initialise itself properly.
1887 */
1888 mdelay(5);
1889
1890 return wbsd_resume(host);
1891}
1892
1893#ifdef CONFIG_PNP
1894
1895static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1896{
1897 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1898 struct wbsd_host *host;
1899
1900 if (mmc == NULL)
1901 return 0;
1902
1903 DBGF("Suspending...\n");
1904
1905 host = mmc_priv(mmc);
1906
1907 return wbsd_suspend(host, state);
1908}
1909
1910static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1911{
1912 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1913 struct wbsd_host *host;
1914
1915 if (mmc == NULL)
1916 return 0;
1917
1918 DBGF("Resuming...\n");
1919
1920 host = mmc_priv(mmc);
1921
1922 /*
1923 * See if chip needs to be configured.
1924 */
1925 if (host->config != 0) {
1926 if (!wbsd_chip_validate(host)) {
1927 printk(KERN_WARNING DRIVER_NAME
1928 ": PnP active but chip not configured! "
1929 "You probably have a buggy BIOS. "
1930 "Configuring chip manually.\n");
1931 wbsd_chip_config(host);
1932 }
1933 }
1934
1935 /*
1936 * Allow device to initialise itself properly.
1937 */
1938 mdelay(5);
1939
1940 return wbsd_resume(host);
1941}
1942
1943#endif /* CONFIG_PNP */
1944
1945#else /* CONFIG_PM */
1946
1947#define wbsd_platform_suspend NULL
1948#define wbsd_platform_resume NULL
1949
1950#define wbsd_pnp_suspend NULL
1951#define wbsd_pnp_resume NULL
1952
1953#endif /* CONFIG_PM */
1954
1955static struct platform_device *wbsd_device;
1956
1957static struct platform_driver wbsd_driver = {
1958 .probe = wbsd_probe,
1959 .remove = __devexit_p(wbsd_remove),
1960
1961 .suspend = wbsd_platform_suspend,
1962 .resume = wbsd_platform_resume,
1963 .driver = {
1964 .name = DRIVER_NAME,
1965 },
1966};
1967
1968#ifdef CONFIG_PNP
1969
1970static struct pnp_driver wbsd_pnp_driver = {
1971 .name = DRIVER_NAME,
1972 .id_table = pnp_dev_table,
1973 .probe = wbsd_pnp_probe,
1974 .remove = __devexit_p(wbsd_pnp_remove),
1975
1976 .suspend = wbsd_pnp_suspend,
1977 .resume = wbsd_pnp_resume,
1978};
1979
1980#endif /* CONFIG_PNP */
1981
1982/*
1983 * Module loading/unloading
1984 */
1985
1986static int __init wbsd_drv_init(void)
1987{
1988 int result;
1989
1990 printk(KERN_INFO DRIVER_NAME
1991 ": Winbond W83L51xD SD/MMC card interface driver\n");
1992 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1993
1994#ifdef CONFIG_PNP
1995
1996 if (!nopnp) {
1997 result = pnp_register_driver(&wbsd_pnp_driver);
1998 if (result < 0)
1999 return result;
2000 }
2001#endif /* CONFIG_PNP */
2002
2003 if (nopnp) {
2004 result = platform_driver_register(&wbsd_driver);
2005 if (result < 0)
2006 return result;
2007
2008 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2009 if (!wbsd_device) {
2010 platform_driver_unregister(&wbsd_driver);
2011 return -ENOMEM;
2012 }
2013
2014 result = platform_device_add(wbsd_device);
2015 if (result) {
2016 platform_device_put(wbsd_device);
2017 platform_driver_unregister(&wbsd_driver);
2018 return result;
2019 }
2020 }
2021
2022 return 0;
2023}
2024
2025static void __exit wbsd_drv_exit(void)
2026{
2027#ifdef CONFIG_PNP
2028
2029 if (!nopnp)
2030 pnp_unregister_driver(&wbsd_pnp_driver);
2031
2032#endif /* CONFIG_PNP */
2033
2034 if (nopnp) {
2035 platform_device_unregister(wbsd_device);
2036
2037 platform_driver_unregister(&wbsd_driver);
2038 }
2039
2040 DBG("unloaded\n");
2041}
2042
2043module_init(wbsd_drv_init);
2044module_exit(wbsd_drv_exit);
2045#ifdef CONFIG_PNP
2046module_param(nopnp, uint, 0444);
2047#endif
2048module_param(io, uint, 0444);
2049module_param(irq, uint, 0444);
2050module_param(dma, int, 0444);
2051
2052MODULE_LICENSE("GPL");
2053MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2054MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2055
2056#ifdef CONFIG_PNP
2057MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2058#endif
2059MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2060MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2061MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-07 05:53:52 -0500