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