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