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