blob: 402c2d661fb2814d06983d6a6f0e3c89c110e89f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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/device.h>
30#include <linux/interrupt.h>
Pierre Ossman85bcc132005-05-08 19:35:27 +010031#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/delay.h>
Pierre Ossman85bcc132005-05-08 19:35:27 +010033#include <linux/pnp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#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"
Pierre Ossman3462b922005-07-11 14:19:35 +020045#define DRIVER_VERSION "1.3"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070057/*
Pierre Ossman85bcc132005-05-08 19:35:27 +010058 * Device resources
59 */
60
61#ifdef CONFIG_PNP
62
63static const struct pnp_device_id pnp_dev_table[] = {
64 { "WEC0517", 0 },
65 { "WEC0518", 0 },
66 { "", 0 },
67};
68
69MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
70
71#endif /* CONFIG_PNP */
72
Adrian Bunk3eee0d02005-07-01 13:07:37 +010073static const int config_ports[] = { 0x2E, 0x4E };
74static const int unlock_codes[] = { 0x83, 0x87 };
75
76static const int valid_ids[] = {
77 0x7112,
78 };
79
Pierre Ossman85bcc132005-05-08 19:35:27 +010080#ifdef CONFIG_PNP
81static unsigned int nopnp = 0;
82#else
83static const unsigned int nopnp = 1;
84#endif
85static unsigned int io = 0x248;
86static unsigned int irq = 6;
87static int dma = 2;
88
89/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 * Basic functions
91 */
92
93static inline void wbsd_unlock_config(struct wbsd_host* host)
94{
Pierre Ossman85bcc132005-05-08 19:35:27 +010095 BUG_ON(host->config == 0);
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 outb(host->unlock_code, host->config);
98 outb(host->unlock_code, host->config);
99}
100
101static inline void wbsd_lock_config(struct wbsd_host* host)
102{
Pierre Ossman85bcc132005-05-08 19:35:27 +0100103 BUG_ON(host->config == 0);
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 outb(LOCK_CODE, host->config);
106}
107
108static inline void wbsd_write_config(struct wbsd_host* host, u8 reg, u8 value)
109{
Pierre Ossman85bcc132005-05-08 19:35:27 +0100110 BUG_ON(host->config == 0);
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 outb(reg, host->config);
113 outb(value, host->config + 1);
114}
115
116static inline u8 wbsd_read_config(struct wbsd_host* host, u8 reg)
117{
Pierre Ossman85bcc132005-05-08 19:35:27 +0100118 BUG_ON(host->config == 0);
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 outb(reg, host->config);
121 return inb(host->config + 1);
122}
123
124static 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
130static 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
140static 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 /*
Pierre Ossman85bcc132005-05-08 19:35:27 +0100152 * 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 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 * 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 /*
Pierre Ossman85bcc132005-05-08 19:35:27 +0100174 * 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 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * 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
200static void wbsd_reset(struct wbsd_host* host)
201{
202 u8 setup;
203
204 printk(KERN_ERR DRIVER_NAME ": Resetting chip\n");
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
214static 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 /*
223 * Release ISA DMA controller.
224 */
225 dmaflags = claim_dma_lock();
226 disable_dma(host->dma);
227 clear_dma_ff(host->dma);
228 release_dma_lock(dmaflags);
229
230 /*
231 * Disable DMA on host.
232 */
233 wbsd_write_index(host, WBSD_IDX_DMA, 0);
234 }
235
236 host->mrq = NULL;
237
238 /*
239 * MMC layer might call back into the driver so first unlock.
240 */
241 spin_unlock(&host->lock);
242 mmc_request_done(host->mmc, mrq);
243 spin_lock(&host->lock);
244}
245
246/*
247 * Scatter/gather functions
248 */
249
250static inline void wbsd_init_sg(struct wbsd_host* host, struct mmc_data* data)
251{
252 /*
253 * Get info. about SG list from data structure.
254 */
255 host->cur_sg = data->sg;
256 host->num_sg = data->sg_len;
257
258 host->offset = 0;
259 host->remain = host->cur_sg->length;
260}
261
262static inline int wbsd_next_sg(struct wbsd_host* host)
263{
264 /*
265 * Skip to next SG entry.
266 */
267 host->cur_sg++;
268 host->num_sg--;
269
270 /*
271 * Any entries left?
272 */
273 if (host->num_sg > 0)
274 {
275 host->offset = 0;
276 host->remain = host->cur_sg->length;
277 }
278
279 return host->num_sg;
280}
281
282static inline char* wbsd_kmap_sg(struct wbsd_host* host)
283{
284 host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ) +
285 host->cur_sg->offset;
286 return host->mapped_sg;
287}
288
289static inline void wbsd_kunmap_sg(struct wbsd_host* host)
290{
291 kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
292}
293
294static inline void wbsd_sg_to_dma(struct wbsd_host* host, struct mmc_data* data)
295{
296 unsigned int len, i, size;
297 struct scatterlist* sg;
298 char* dmabuf = host->dma_buffer;
299 char* sgbuf;
300
301 size = host->size;
302
303 sg = data->sg;
304 len = data->sg_len;
305
306 /*
307 * Just loop through all entries. Size might not
308 * be the entire list though so make sure that
309 * we do not transfer too much.
310 */
311 for (i = 0;i < len;i++)
312 {
313 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
314 if (size < sg[i].length)
315 memcpy(dmabuf, sgbuf, size);
316 else
317 memcpy(dmabuf, sgbuf, sg[i].length);
318 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
319 dmabuf += sg[i].length;
320
321 if (size < sg[i].length)
322 size = 0;
323 else
324 size -= sg[i].length;
325
326 if (size == 0)
327 break;
328 }
329
330 /*
331 * Check that we didn't get a request to transfer
332 * more data than can fit into the SG list.
333 */
334
335 BUG_ON(size != 0);
336
337 host->size -= size;
338}
339
340static inline void wbsd_dma_to_sg(struct wbsd_host* host, struct mmc_data* data)
341{
342 unsigned int len, i, size;
343 struct scatterlist* sg;
344 char* dmabuf = host->dma_buffer;
345 char* sgbuf;
346
347 size = host->size;
348
349 sg = data->sg;
350 len = data->sg_len;
351
352 /*
353 * Just loop through all entries. Size might not
354 * be the entire list though so make sure that
355 * we do not transfer too much.
356 */
357 for (i = 0;i < len;i++)
358 {
359 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
360 if (size < sg[i].length)
361 memcpy(sgbuf, dmabuf, size);
362 else
363 memcpy(sgbuf, dmabuf, sg[i].length);
364 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
365 dmabuf += sg[i].length;
366
367 if (size < sg[i].length)
368 size = 0;
369 else
370 size -= sg[i].length;
371
372 if (size == 0)
373 break;
374 }
375
376 /*
377 * Check that we didn't get a request to transfer
378 * more data than can fit into the SG list.
379 */
380
381 BUG_ON(size != 0);
382
383 host->size -= size;
384}
385
386/*
387 * Command handling
388 */
389
390static inline void wbsd_get_short_reply(struct wbsd_host* host,
391 struct mmc_command* cmd)
392{
393 /*
394 * Correct response type?
395 */
396 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT)
397 {
398 cmd->error = MMC_ERR_INVALID;
399 return;
400 }
401
402 cmd->resp[0] =
403 wbsd_read_index(host, WBSD_IDX_RESP12) << 24;
404 cmd->resp[0] |=
405 wbsd_read_index(host, WBSD_IDX_RESP13) << 16;
406 cmd->resp[0] |=
407 wbsd_read_index(host, WBSD_IDX_RESP14) << 8;
408 cmd->resp[0] |=
409 wbsd_read_index(host, WBSD_IDX_RESP15) << 0;
410 cmd->resp[1] =
411 wbsd_read_index(host, WBSD_IDX_RESP16) << 24;
412}
413
414static inline void wbsd_get_long_reply(struct wbsd_host* host,
415 struct mmc_command* cmd)
416{
417 int i;
418
419 /*
420 * Correct response type?
421 */
422 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG)
423 {
424 cmd->error = MMC_ERR_INVALID;
425 return;
426 }
427
428 for (i = 0;i < 4;i++)
429 {
430 cmd->resp[i] =
431 wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
432 cmd->resp[i] |=
433 wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
434 cmd->resp[i] |=
435 wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
436 cmd->resp[i] |=
437 wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
438 }
439}
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441static void wbsd_send_command(struct wbsd_host* host, struct mmc_command* cmd)
442{
443 int i;
444 u8 status, isr;
445
446 DBGF("Sending cmd (%x)\n", cmd->opcode);
447
448 /*
449 * Clear accumulated ISR. The interrupt routine
450 * will fill this one with events that occur during
451 * transfer.
452 */
453 host->isr = 0;
454
455 /*
456 * Send the command (CRC calculated by host).
457 */
458 outb(cmd->opcode, host->base + WBSD_CMDR);
459 for (i = 3;i >= 0;i--)
460 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
461
462 cmd->error = MMC_ERR_NONE;
463
464 /*
465 * Wait for the request to complete.
466 */
467 do {
468 status = wbsd_read_index(host, WBSD_IDX_STATUS);
469 } while (status & WBSD_CARDTRAFFIC);
470
471 /*
472 * Do we expect a reply?
473 */
474 if ((cmd->flags & MMC_RSP_MASK) != MMC_RSP_NONE)
475 {
476 /*
477 * Read back status.
478 */
479 isr = host->isr;
480
481 /* Card removed? */
482 if (isr & WBSD_INT_CARD)
483 cmd->error = MMC_ERR_TIMEOUT;
484 /* Timeout? */
485 else if (isr & WBSD_INT_TIMEOUT)
486 cmd->error = MMC_ERR_TIMEOUT;
487 /* CRC? */
488 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
489 cmd->error = MMC_ERR_BADCRC;
490 /* All ok */
491 else
492 {
493 if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_SHORT)
494 wbsd_get_short_reply(host, cmd);
495 else
496 wbsd_get_long_reply(host, cmd);
497 }
498 }
499
500 DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
501}
502
503/*
504 * Data functions
505 */
506
507static void wbsd_empty_fifo(struct wbsd_host* host)
508{
509 struct mmc_data* data = host->mrq->cmd->data;
510 char* buffer;
511 int i, fsr, fifo;
512
513 /*
514 * Handle excessive data.
515 */
516 if (data->bytes_xfered == host->size)
517 return;
518
519 buffer = wbsd_kmap_sg(host) + host->offset;
520
521 /*
522 * Drain the fifo. This has a tendency to loop longer
523 * than the FIFO length (usually one block).
524 */
525 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY))
526 {
527 /*
528 * The size field in the FSR is broken so we have to
529 * do some guessing.
530 */
531 if (fsr & WBSD_FIFO_FULL)
532 fifo = 16;
533 else if (fsr & WBSD_FIFO_FUTHRE)
534 fifo = 8;
535 else
536 fifo = 1;
537
538 for (i = 0;i < fifo;i++)
539 {
540 *buffer = inb(host->base + WBSD_DFR);
541 buffer++;
542 host->offset++;
543 host->remain--;
544
545 data->bytes_xfered++;
546
547 /*
548 * Transfer done?
549 */
550 if (data->bytes_xfered == host->size)
551 {
552 wbsd_kunmap_sg(host);
553 return;
554 }
555
556 /*
557 * End of scatter list entry?
558 */
559 if (host->remain == 0)
560 {
561 wbsd_kunmap_sg(host);
562
563 /*
564 * Get next entry. Check if last.
565 */
566 if (!wbsd_next_sg(host))
567 {
568 /*
569 * We should never reach this point.
570 * It means that we're trying to
571 * transfer more blocks than can fit
572 * into the scatter list.
573 */
574 BUG_ON(1);
575
576 host->size = data->bytes_xfered;
577
578 return;
579 }
580
581 buffer = wbsd_kmap_sg(host);
582 }
583 }
584 }
585
586 wbsd_kunmap_sg(host);
587
588 /*
589 * This is a very dirty hack to solve a
590 * hardware problem. The chip doesn't trigger
591 * FIFO threshold interrupts properly.
592 */
593 if ((host->size - data->bytes_xfered) < 16)
594 tasklet_schedule(&host->fifo_tasklet);
595}
596
597static void wbsd_fill_fifo(struct wbsd_host* host)
598{
599 struct mmc_data* data = host->mrq->cmd->data;
600 char* buffer;
601 int i, fsr, fifo;
602
603 /*
604 * Check that we aren't being called after the
605 * entire buffer has been transfered.
606 */
607 if (data->bytes_xfered == host->size)
608 return;
609
610 buffer = wbsd_kmap_sg(host) + host->offset;
611
612 /*
613 * Fill the fifo. This has a tendency to loop longer
614 * than the FIFO length (usually one block).
615 */
616 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL))
617 {
618 /*
619 * The size field in the FSR is broken so we have to
620 * do some guessing.
621 */
622 if (fsr & WBSD_FIFO_EMPTY)
623 fifo = 0;
624 else if (fsr & WBSD_FIFO_EMTHRE)
625 fifo = 8;
626 else
627 fifo = 15;
628
629 for (i = 16;i > fifo;i--)
630 {
631 outb(*buffer, host->base + WBSD_DFR);
632 buffer++;
633 host->offset++;
634 host->remain--;
635
636 data->bytes_xfered++;
637
638 /*
639 * Transfer done?
640 */
641 if (data->bytes_xfered == host->size)
642 {
643 wbsd_kunmap_sg(host);
644 return;
645 }
646
647 /*
648 * End of scatter list entry?
649 */
650 if (host->remain == 0)
651 {
652 wbsd_kunmap_sg(host);
653
654 /*
655 * Get next entry. Check if last.
656 */
657 if (!wbsd_next_sg(host))
658 {
659 /*
660 * We should never reach this point.
661 * It means that we're trying to
662 * transfer more blocks than can fit
663 * into the scatter list.
664 */
665 BUG_ON(1);
666
667 host->size = data->bytes_xfered;
668
669 return;
670 }
671
672 buffer = wbsd_kmap_sg(host);
673 }
674 }
675 }
676
677 wbsd_kunmap_sg(host);
Pierre Ossman85bcc132005-05-08 19:35:27 +0100678
679 /*
680 * The controller stops sending interrupts for
681 * 'FIFO empty' under certain conditions. So we
682 * need to be a bit more pro-active.
683 */
684 tasklet_schedule(&host->fifo_tasklet);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}
686
687static void wbsd_prepare_data(struct wbsd_host* host, struct mmc_data* data)
688{
689 u16 blksize;
690 u8 setup;
691 unsigned long dmaflags;
692
693 DBGF("blksz %04x blks %04x flags %08x\n",
694 1 << data->blksz_bits, data->blocks, data->flags);
695 DBGF("tsac %d ms nsac %d clk\n",
696 data->timeout_ns / 1000000, data->timeout_clks);
697
698 /*
699 * Calculate size.
700 */
701 host->size = data->blocks << data->blksz_bits;
702
703 /*
704 * Check timeout values for overflow.
705 * (Yes, some cards cause this value to overflow).
706 */
707 if (data->timeout_ns > 127000000)
708 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
709 else
710 wbsd_write_index(host, WBSD_IDX_TAAC, data->timeout_ns/1000000);
711
712 if (data->timeout_clks > 255)
713 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
714 else
715 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
716
717 /*
718 * Inform the chip of how large blocks will be
719 * sent. It needs this to determine when to
720 * calculate CRC.
721 *
722 * Space for CRC must be included in the size.
723 */
724 blksize = (1 << data->blksz_bits) + 2;
725
726 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
727 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
728
729 /*
730 * Clear the FIFO. This is needed even for DMA
731 * transfers since the chip still uses the FIFO
732 * internally.
733 */
734 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
735 setup |= WBSD_FIFO_RESET;
736 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
737
738 /*
739 * DMA transfer?
740 */
741 if (host->dma >= 0)
742 {
743 /*
744 * The buffer for DMA is only 64 kB.
745 */
746 BUG_ON(host->size > 0x10000);
747 if (host->size > 0x10000)
748 {
749 data->error = MMC_ERR_INVALID;
750 return;
751 }
752
753 /*
754 * Transfer data from the SG list to
755 * the DMA buffer.
756 */
757 if (data->flags & MMC_DATA_WRITE)
758 wbsd_sg_to_dma(host, data);
759
760 /*
761 * Initialise the ISA DMA controller.
762 */
763 dmaflags = claim_dma_lock();
764 disable_dma(host->dma);
765 clear_dma_ff(host->dma);
766 if (data->flags & MMC_DATA_READ)
767 set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
768 else
769 set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
770 set_dma_addr(host->dma, host->dma_addr);
771 set_dma_count(host->dma, host->size);
772
773 enable_dma(host->dma);
774 release_dma_lock(dmaflags);
775
776 /*
777 * Enable DMA on the host.
778 */
779 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
780 }
781 else
782 {
783 /*
784 * This flag is used to keep printk
785 * output to a minimum.
786 */
787 host->firsterr = 1;
788
789 /*
790 * Initialise the SG list.
791 */
792 wbsd_init_sg(host, data);
793
794 /*
795 * Turn off DMA.
796 */
797 wbsd_write_index(host, WBSD_IDX_DMA, 0);
798
799 /*
800 * Set up FIFO threshold levels (and fill
801 * buffer if doing a write).
802 */
803 if (data->flags & MMC_DATA_READ)
804 {
805 wbsd_write_index(host, WBSD_IDX_FIFOEN,
806 WBSD_FIFOEN_FULL | 8);
807 }
808 else
809 {
810 wbsd_write_index(host, WBSD_IDX_FIFOEN,
811 WBSD_FIFOEN_EMPTY | 8);
812 wbsd_fill_fifo(host);
813 }
814 }
815
816 data->error = MMC_ERR_NONE;
817}
818
819static void wbsd_finish_data(struct wbsd_host* host, struct mmc_data* data)
820{
821 unsigned long dmaflags;
822 int count;
823 u8 status;
824
825 WARN_ON(host->mrq == NULL);
826
827 /*
828 * Send a stop command if needed.
829 */
830 if (data->stop)
831 wbsd_send_command(host, data->stop);
832
833 /*
834 * Wait for the controller to leave data
835 * transfer state.
836 */
837 do
838 {
839 status = wbsd_read_index(host, WBSD_IDX_STATUS);
840 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
841
842 /*
843 * DMA transfer?
844 */
845 if (host->dma >= 0)
846 {
847 /*
848 * Disable DMA on the host.
849 */
850 wbsd_write_index(host, WBSD_IDX_DMA, 0);
851
852 /*
853 * Turn of ISA DMA controller.
854 */
855 dmaflags = claim_dma_lock();
856 disable_dma(host->dma);
857 clear_dma_ff(host->dma);
858 count = get_dma_residue(host->dma);
859 release_dma_lock(dmaflags);
860
861 /*
862 * Any leftover data?
863 */
864 if (count)
865 {
866 printk(KERN_ERR DRIVER_NAME ": Incomplete DMA "
867 "transfer. %d bytes left.\n", count);
868
869 data->error = MMC_ERR_FAILED;
870 }
871 else
872 {
873 /*
874 * Transfer data from DMA buffer to
875 * SG list.
876 */
877 if (data->flags & MMC_DATA_READ)
878 wbsd_dma_to_sg(host, data);
879
880 data->bytes_xfered = host->size;
881 }
882 }
883
884 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
885
886 wbsd_request_end(host, host->mrq);
887}
888
Pierre Ossman85bcc132005-05-08 19:35:27 +0100889/*****************************************************************************\
890 * *
891 * MMC layer callbacks *
892 * *
893\*****************************************************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
895static void wbsd_request(struct mmc_host* mmc, struct mmc_request* mrq)
896{
897 struct wbsd_host* host = mmc_priv(mmc);
898 struct mmc_command* cmd;
899
900 /*
901 * Disable tasklets to avoid a deadlock.
902 */
903 spin_lock_bh(&host->lock);
904
905 BUG_ON(host->mrq != NULL);
906
907 cmd = mrq->cmd;
908
909 host->mrq = mrq;
910
911 /*
912 * If there is no card in the slot then
913 * timeout immediatly.
914 */
Pierre Ossman85bcc132005-05-08 19:35:27 +0100915 if (!(host->flags & WBSD_FCARD_PRESENT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 {
917 cmd->error = MMC_ERR_TIMEOUT;
918 goto done;
919 }
920
921 /*
922 * Does the request include data?
923 */
924 if (cmd->data)
925 {
926 wbsd_prepare_data(host, cmd->data);
927
928 if (cmd->data->error != MMC_ERR_NONE)
929 goto done;
930 }
931
932 wbsd_send_command(host, cmd);
933
934 /*
935 * If this is a data transfer the request
936 * will be finished after the data has
937 * transfered.
938 */
939 if (cmd->data && (cmd->error == MMC_ERR_NONE))
940 {
941 /*
942 * Dirty fix for hardware bug.
943 */
944 if (host->dma == -1)
945 tasklet_schedule(&host->fifo_tasklet);
946
947 spin_unlock_bh(&host->lock);
948
949 return;
950 }
951
952done:
953 wbsd_request_end(host, mrq);
954
955 spin_unlock_bh(&host->lock);
956}
957
958static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
959{
960 struct wbsd_host* host = mmc_priv(mmc);
961 u8 clk, setup, pwr;
962
963 DBGF("clock %uHz busmode %u powermode %u Vdd %u\n",
964 ios->clock, ios->bus_mode, ios->power_mode, ios->vdd);
965
966 spin_lock_bh(&host->lock);
967
968 /*
969 * Reset the chip on each power off.
970 * Should clear out any weird states.
971 */
972 if (ios->power_mode == MMC_POWER_OFF)
973 wbsd_init_device(host);
974
975 if (ios->clock >= 24000000)
976 clk = WBSD_CLK_24M;
977 else if (ios->clock >= 16000000)
978 clk = WBSD_CLK_16M;
979 else if (ios->clock >= 12000000)
980 clk = WBSD_CLK_12M;
981 else
982 clk = WBSD_CLK_375K;
983
984 /*
985 * Only write to the clock register when
986 * there is an actual change.
987 */
988 if (clk != host->clk)
989 {
990 wbsd_write_index(host, WBSD_IDX_CLK, clk);
991 host->clk = clk;
992 }
993
Pierre Ossman85bcc132005-05-08 19:35:27 +0100994 /*
995 * Power up card.
996 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 if (ios->power_mode != MMC_POWER_OFF)
998 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 pwr = inb(host->base + WBSD_CSR);
1000 pwr &= ~WBSD_POWER_N;
1001 outb(pwr, host->base + WBSD_CSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
1003
Pierre Ossman85bcc132005-05-08 19:35:27 +01001004 /*
1005 * MMC cards need to have pin 1 high during init.
1006 * Init time corresponds rather nicely with the bus mode.
1007 * It wreaks havoc with the card detection though so
1008 * that needs to be disabed.
1009 */
1010 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
1011 if ((ios->power_mode == MMC_POWER_ON) &&
1012 (ios->bus_mode == MMC_BUSMODE_OPENDRAIN))
1013 {
1014 setup |= WBSD_DAT3_H;
1015 host->flags |= WBSD_FIGNORE_DETECT;
1016 }
1017 else
1018 {
1019 setup &= ~WBSD_DAT3_H;
1020 host->flags &= ~WBSD_FIGNORE_DETECT;
1021 }
1022 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 spin_unlock_bh(&host->lock);
1025}
1026
Pierre Ossman85bcc132005-05-08 19:35:27 +01001027static struct mmc_host_ops wbsd_ops = {
1028 .request = wbsd_request,
1029 .set_ios = wbsd_set_ios,
1030};
1031
1032/*****************************************************************************\
1033 * *
1034 * Interrupt handling *
1035 * *
1036\*****************************************************************************/
1037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038/*
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001039 * Helper function for card detection
1040 */
1041static void wbsd_detect_card(unsigned long data)
1042{
1043 struct wbsd_host *host = (struct wbsd_host*)data;
1044
1045 BUG_ON(host == NULL);
1046
1047 DBG("Executing card detection\n");
1048
1049 mmc_detect_change(host->mmc);
1050}
1051
1052/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 * Tasklets
1054 */
1055
Jesper Juhl77933d72005-07-27 11:46:09 -07001056static inline struct mmc_data* wbsd_get_data(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057{
1058 WARN_ON(!host->mrq);
1059 if (!host->mrq)
1060 return NULL;
1061
1062 WARN_ON(!host->mrq->cmd);
1063 if (!host->mrq->cmd)
1064 return NULL;
1065
1066 WARN_ON(!host->mrq->cmd->data);
1067 if (!host->mrq->cmd->data)
1068 return NULL;
1069
1070 return host->mrq->cmd->data;
1071}
1072
1073static void wbsd_tasklet_card(unsigned long param)
1074{
1075 struct wbsd_host* host = (struct wbsd_host*)param;
1076 u8 csr;
1077
1078 spin_lock(&host->lock);
1079
Pierre Ossman85bcc132005-05-08 19:35:27 +01001080 if (host->flags & WBSD_FIGNORE_DETECT)
1081 {
1082 spin_unlock(&host->lock);
1083 return;
1084 }
1085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 csr = inb(host->base + WBSD_CSR);
1087 WARN_ON(csr == 0xff);
1088
1089 if (csr & WBSD_CARDPRESENT)
Pierre Ossman85bcc132005-05-08 19:35:27 +01001090 {
1091 if (!(host->flags & WBSD_FCARD_PRESENT))
1092 {
1093 DBG("Card inserted\n");
1094 host->flags |= WBSD_FCARD_PRESENT;
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001095
1096 /*
1097 * Delay card detection to allow electrical connections
1098 * to stabilise.
1099 */
1100 mod_timer(&host->timer, jiffies + HZ/2);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001101 }
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001102
1103 spin_unlock(&host->lock);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001104 }
1105 else if (host->flags & WBSD_FCARD_PRESENT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 {
1107 DBG("Card removed\n");
Pierre Ossman85bcc132005-05-08 19:35:27 +01001108 host->flags &= ~WBSD_FCARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109
1110 if (host->mrq)
1111 {
1112 printk(KERN_ERR DRIVER_NAME
1113 ": Card removed during transfer!\n");
1114 wbsd_reset(host);
1115
1116 host->mrq->cmd->error = MMC_ERR_FAILED;
1117 tasklet_schedule(&host->finish_tasklet);
1118 }
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001119
1120 /*
1121 * Unlock first since we might get a call back.
1122 */
1123 spin_unlock(&host->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Pierre Ossman85bcc132005-05-08 19:35:27 +01001125 mmc_detect_change(host->mmc);
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001126 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127}
1128
1129static void wbsd_tasklet_fifo(unsigned long param)
1130{
1131 struct wbsd_host* host = (struct wbsd_host*)param;
1132 struct mmc_data* data;
1133
1134 spin_lock(&host->lock);
1135
1136 if (!host->mrq)
1137 goto end;
1138
1139 data = wbsd_get_data(host);
1140 if (!data)
1141 goto end;
1142
1143 if (data->flags & MMC_DATA_WRITE)
1144 wbsd_fill_fifo(host);
1145 else
1146 wbsd_empty_fifo(host);
1147
1148 /*
1149 * Done?
1150 */
1151 if (host->size == data->bytes_xfered)
1152 {
1153 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1154 tasklet_schedule(&host->finish_tasklet);
1155 }
1156
1157end:
1158 spin_unlock(&host->lock);
1159}
1160
1161static 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
1181end:
1182 spin_unlock(&host->lock);
1183}
1184
1185static 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
1205end:
1206 spin_unlock(&host->lock);
1207}
1208
1209static 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
1226end:
1227 spin_unlock(&host->lock);
1228}
1229
1230static 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 {
1240 data = wbsd_get_data(host);
1241 if (!data)
1242 goto end;
1243
1244 DBGF("CRC error\n");
1245
1246 data->error = MMC_ERR_BADCRC;
1247
1248 tasklet_schedule(&host->finish_tasklet);
1249 }
1250
1251end:
1252 spin_unlock(&host->lock);
1253}
1254
1255/*
1256 * Interrupt handling
1257 */
1258
1259static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs)
1260{
1261 struct wbsd_host* host = dev_id;
1262 int isr;
1263
1264 isr = inb(host->base + WBSD_ISR);
1265
1266 /*
1267 * Was it actually our hardware that caused the interrupt?
1268 */
1269 if (isr == 0xff || isr == 0x00)
1270 return IRQ_NONE;
1271
1272 host->isr |= isr;
1273
1274 /*
1275 * Schedule tasklets as needed.
1276 */
1277 if (isr & WBSD_INT_CARD)
1278 tasklet_schedule(&host->card_tasklet);
1279 if (isr & WBSD_INT_FIFO_THRE)
1280 tasklet_schedule(&host->fifo_tasklet);
1281 if (isr & WBSD_INT_CRC)
1282 tasklet_hi_schedule(&host->crc_tasklet);
1283 if (isr & WBSD_INT_TIMEOUT)
1284 tasklet_hi_schedule(&host->timeout_tasklet);
1285 if (isr & WBSD_INT_BUSYEND)
1286 tasklet_hi_schedule(&host->block_tasklet);
1287 if (isr & WBSD_INT_TC)
1288 tasklet_schedule(&host->finish_tasklet);
1289
1290 return IRQ_HANDLED;
1291}
1292
Pierre Ossman85bcc132005-05-08 19:35:27 +01001293/*****************************************************************************\
1294 * *
1295 * Device initialisation and shutdown *
1296 * *
1297\*****************************************************************************/
1298
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299/*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001300 * Allocate/free MMC structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 */
1302
Pierre Ossman85bcc132005-05-08 19:35:27 +01001303static int __devinit wbsd_alloc_mmc(struct device* dev)
1304{
1305 struct mmc_host* mmc;
1306 struct wbsd_host* host;
1307
1308 /*
1309 * Allocate MMC structure.
1310 */
1311 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1312 if (!mmc)
1313 return -ENOMEM;
1314
1315 host = mmc_priv(mmc);
1316 host->mmc = mmc;
1317
1318 host->dma = -1;
1319
1320 /*
1321 * Set host parameters.
1322 */
1323 mmc->ops = &wbsd_ops;
1324 mmc->f_min = 375000;
1325 mmc->f_max = 24000000;
1326 mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
1327
1328 spin_lock_init(&host->lock);
1329
1330 /*
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001331 * Set up detection timer
1332 */
1333 init_timer(&host->timer);
1334 host->timer.data = (unsigned long)host;
1335 host->timer.function = wbsd_detect_card;
1336
1337 /*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001338 * 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
1361static void __devexit wbsd_free_mmc(struct device* dev)
1362{
1363 struct mmc_host* mmc;
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001364 struct wbsd_host* host;
Pierre Ossman85bcc132005-05-08 19:35:27 +01001365
1366 mmc = dev_get_drvdata(dev);
1367 if (!mmc)
1368 return;
1369
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001370 host = mmc_priv(mmc);
1371 BUG_ON(host == NULL);
1372
1373 del_timer_sync(&host->timer);
1374
Pierre Ossman85bcc132005-05-08 19:35:27 +01001375 mmc_free_host(mmc);
1376
1377 dev_set_drvdata(dev, NULL);
1378}
1379
1380/*
1381 * Scan for known chip id:s
1382 */
1383
1384static int __devinit wbsd_scan(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
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 < sizeof(config_ports)/sizeof(int);i++)
1394 {
1395 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1396 continue;
1397
1398 for (j = 0;j < sizeof(unlock_codes)/sizeof(int);j++)
1399 {
1400 id = 0xFFFF;
1401
1402 outb(unlock_codes[j], config_ports[i]);
1403 outb(unlock_codes[j], config_ports[i]);
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 for (k = 0;k < sizeof(valid_ids)/sizeof(int);k++)
1412 {
1413 if (id == valid_ids[k])
1414 {
1415 host->chip_id = id;
1416 host->config = config_ports[i];
1417 host->unlock_code = unlock_codes[i];
1418
1419 return 0;
1420 }
1421 }
1422
1423 if (id != 0xFFFF)
1424 {
1425 DBG("Unknown hardware (id %x) found at %x\n",
1426 id, config_ports[i]);
1427 }
1428
1429 outb(LOCK_CODE, config_ports[i]);
1430 }
1431
1432 release_region(config_ports[i], 2);
1433 }
1434
1435 return -ENODEV;
1436}
1437
Pierre Ossman85bcc132005-05-08 19:35:27 +01001438/*
1439 * Allocate/free io port ranges
1440 */
1441
1442static int __devinit wbsd_request_region(struct wbsd_host* host, int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443{
1444 if (io & 0x7)
1445 return -EINVAL;
1446
Pierre Ossman85bcc132005-05-08 19:35:27 +01001447 if (!request_region(base, 8, DRIVER_NAME))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 return -EIO;
1449
1450 host->base = io;
1451
1452 return 0;
1453}
1454
Pierre Ossman85bcc132005-05-08 19:35:27 +01001455static void __devexit wbsd_release_regions(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456{
1457 if (host->base)
1458 release_region(host->base, 8);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001459
1460 host->base = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462 if (host->config)
1463 release_region(host->config, 2);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001464
1465 host->config = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466}
1467
Pierre Ossman85bcc132005-05-08 19:35:27 +01001468/*
1469 * Allocate/free DMA port and buffer
1470 */
1471
1472static void __devinit wbsd_request_dma(struct wbsd_host* host, int dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 if (dma < 0)
1475 return;
1476
1477 if (request_dma(dma, DRIVER_NAME))
1478 goto err;
1479
1480 /*
1481 * We need to allocate a special buffer in
1482 * order for ISA to be able to DMA to it.
1483 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001484 host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1486 if (!host->dma_buffer)
1487 goto free;
1488
1489 /*
1490 * Translate the address to a physical address.
1491 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001492 host->dma_addr = dma_map_single(host->mmc->dev, host->dma_buffer,
1493 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 /*
1496 * ISA DMA must be aligned on a 64k basis.
1497 */
1498 if ((host->dma_addr & 0xffff) != 0)
1499 goto kfree;
1500 /*
1501 * ISA cannot access memory above 16 MB.
1502 */
1503 else if (host->dma_addr >= 0x1000000)
1504 goto kfree;
1505
1506 host->dma = dma;
1507
1508 return;
1509
1510kfree:
1511 /*
1512 * If we've gotten here then there is some kind of alignment bug
1513 */
1514 BUG_ON(1);
1515
Pierre Ossman85bcc132005-05-08 19:35:27 +01001516 dma_unmap_single(host->mmc->dev, host->dma_addr, WBSD_DMA_SIZE,
1517 DMA_BIDIRECTIONAL);
1518 host->dma_addr = (dma_addr_t)NULL;
1519
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 kfree(host->dma_buffer);
1521 host->dma_buffer = NULL;
1522
1523free:
1524 free_dma(dma);
1525
1526err:
1527 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1528 "Falling back on FIFO.\n", dma);
1529}
1530
Pierre Ossman85bcc132005-05-08 19:35:27 +01001531static void __devexit wbsd_release_dma(struct wbsd_host* host)
1532{
1533 if (host->dma_addr)
1534 dma_unmap_single(host->mmc->dev, host->dma_addr, WBSD_DMA_SIZE,
1535 DMA_BIDIRECTIONAL);
1536 if (host->dma_buffer)
1537 kfree(host->dma_buffer);
1538 if (host->dma >= 0)
1539 free_dma(host->dma);
1540
1541 host->dma = -1;
1542 host->dma_buffer = NULL;
1543 host->dma_addr = (dma_addr_t)NULL;
1544}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
1546/*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001547 * Allocate/free IRQ.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 */
1549
Pierre Ossman85bcc132005-05-08 19:35:27 +01001550static int __devinit wbsd_request_irq(struct wbsd_host* host, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 int ret;
1553
1554 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 * Allocate interrupt.
1556 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001557
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 ret = request_irq(irq, wbsd_irq, SA_SHIRQ, DRIVER_NAME, host);
1559 if (ret)
Pierre Ossman85bcc132005-05-08 19:35:27 +01001560 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
1562 host->irq = irq;
Pierre Ossman85bcc132005-05-08 19:35:27 +01001563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 /*
1565 * Set up tasklets.
1566 */
1567 tasklet_init(&host->card_tasklet, wbsd_tasklet_card, (unsigned long)host);
1568 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo, (unsigned long)host);
1569 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc, (unsigned long)host);
1570 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout, (unsigned long)host);
1571 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish, (unsigned long)host);
1572 tasklet_init(&host->block_tasklet, wbsd_tasklet_block, (unsigned long)host);
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575}
1576
Pierre Ossman85bcc132005-05-08 19:35:27 +01001577static void __devexit wbsd_release_irq(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578{
Pierre Ossman85bcc132005-05-08 19:35:27 +01001579 if (!host->irq)
1580 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
1582 free_irq(host->irq, host);
1583
Pierre Ossman85bcc132005-05-08 19:35:27 +01001584 host->irq = 0;
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 tasklet_kill(&host->card_tasklet);
1587 tasklet_kill(&host->fifo_tasklet);
1588 tasklet_kill(&host->crc_tasklet);
1589 tasklet_kill(&host->timeout_tasklet);
1590 tasklet_kill(&host->finish_tasklet);
1591 tasklet_kill(&host->block_tasklet);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001592}
1593
1594/*
1595 * Allocate all resources for the host.
1596 */
1597
1598static int __devinit wbsd_request_resources(struct wbsd_host* host,
1599 int base, int irq, int dma)
1600{
1601 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
Pierre Ossman85bcc132005-05-08 19:35:27 +01001603 /*
1604 * Allocate I/O ports.
1605 */
1606 ret = wbsd_request_region(host, base);
1607 if (ret)
1608 return ret;
1609
1610 /*
1611 * Allocate interrupt.
1612 */
1613 ret = wbsd_request_irq(host, irq);
1614 if (ret)
1615 return ret;
1616
1617 /*
1618 * Allocate DMA.
1619 */
1620 wbsd_request_dma(host, dma);
1621
1622 return 0;
1623}
1624
1625/*
1626 * Release all resources for the host.
1627 */
1628
1629static void __devexit wbsd_release_resources(struct wbsd_host* host)
1630{
1631 wbsd_release_dma(host);
1632 wbsd_release_irq(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 wbsd_release_regions(host);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001634}
1635
1636/*
1637 * Configure the resources the chip should use.
1638 */
1639
1640static void __devinit wbsd_chip_config(struct wbsd_host* host)
1641{
1642 /*
1643 * Reset the chip.
1644 */
1645 wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1646 wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1647
1648 /*
1649 * Select SD/MMC function.
1650 */
1651 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
Pierre Ossman85bcc132005-05-08 19:35:27 +01001653 /*
1654 * Set up card detection.
1655 */
1656 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1657
1658 /*
1659 * Configure chip
1660 */
1661 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1662 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1663
1664 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1665
1666 if (host->dma >= 0)
1667 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1668
1669 /*
1670 * Enable and power up chip.
1671 */
1672 wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1673 wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1674}
1675
1676/*
1677 * Check that configured resources are correct.
1678 */
1679
1680static int __devinit wbsd_chip_validate(struct wbsd_host* host)
1681{
1682 int base, irq, dma;
1683
1684 /*
1685 * Select SD/MMC function.
1686 */
1687 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1688
1689 /*
1690 * Read configuration.
1691 */
1692 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1693 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1694
1695 irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1696
1697 dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1698
1699 /*
1700 * Validate against given configuration.
1701 */
1702 if (base != host->base)
1703 return 0;
1704 if (irq != host->irq)
1705 return 0;
1706 if ((dma != host->dma) && (host->dma != -1))
1707 return 0;
1708
1709 return 1;
1710}
1711
1712/*****************************************************************************\
1713 * *
1714 * Devices setup and shutdown *
1715 * *
1716\*****************************************************************************/
1717
1718static int __devinit wbsd_init(struct device* dev, int base, int irq, int dma,
1719 int pnp)
1720{
1721 struct wbsd_host* host = NULL;
1722 struct mmc_host* mmc = NULL;
1723 int ret;
1724
1725 ret = wbsd_alloc_mmc(dev);
1726 if (ret)
1727 return ret;
1728
1729 mmc = dev_get_drvdata(dev);
1730 host = mmc_priv(mmc);
1731
1732 /*
1733 * Scan for hardware.
1734 */
1735 ret = wbsd_scan(host);
1736 if (ret)
1737 {
1738 if (pnp && (ret == -ENODEV))
1739 {
1740 printk(KERN_WARNING DRIVER_NAME
1741 ": Unable to confirm device presence. You may "
1742 "experience lock-ups.\n");
1743 }
1744 else
1745 {
1746 wbsd_free_mmc(dev);
1747 return ret;
1748 }
1749 }
1750
1751 /*
1752 * Request resources.
1753 */
1754 ret = wbsd_request_resources(host, io, irq, dma);
1755 if (ret)
1756 {
1757 wbsd_release_resources(host);
1758 wbsd_free_mmc(dev);
1759 return ret;
1760 }
1761
1762 /*
1763 * See if chip needs to be configured.
1764 */
1765 if (pnp && (host->config != 0))
1766 {
1767 if (!wbsd_chip_validate(host))
1768 {
1769 printk(KERN_WARNING DRIVER_NAME
1770 ": PnP active but chip not configured! "
1771 "You probably have a buggy BIOS. "
1772 "Configuring chip manually.\n");
1773 wbsd_chip_config(host);
1774 }
1775 }
1776 else
1777 wbsd_chip_config(host);
1778
1779 /*
1780 * Power Management stuff. No idea how this works.
1781 * Not tested.
1782 */
1783#ifdef CONFIG_PM
1784 if (host->config)
1785 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1786#endif
1787 /*
1788 * Allow device to initialise itself properly.
1789 */
1790 mdelay(5);
1791
1792 /*
1793 * Reset the chip into a known state.
1794 */
1795 wbsd_init_device(host);
1796
1797 mmc_add_host(mmc);
1798
Russell Kingd366b642005-08-19 09:40:08 +01001799 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
Pierre Ossman85bcc132005-05-08 19:35:27 +01001800 if (host->chip_id != 0)
1801 printk(" id %x", (int)host->chip_id);
1802 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1803 if (host->dma >= 0)
1804 printk(" dma %d", (int)host->dma);
1805 else
1806 printk(" FIFO");
1807 if (pnp)
1808 printk(" PnP");
1809 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
1811 return 0;
1812}
1813
Pierre Ossman85bcc132005-05-08 19:35:27 +01001814static void __devexit wbsd_shutdown(struct device* dev, int pnp)
1815{
1816 struct mmc_host* mmc = dev_get_drvdata(dev);
1817 struct wbsd_host* host;
1818
1819 if (!mmc)
1820 return;
1821
1822 host = mmc_priv(mmc);
1823
1824 mmc_remove_host(mmc);
1825
1826 if (!pnp)
1827 {
1828 /*
1829 * Power down the SD/MMC function.
1830 */
1831 wbsd_unlock_config(host);
1832 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1833 wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1834 wbsd_lock_config(host);
1835 }
1836
1837 wbsd_release_resources(host);
1838
1839 wbsd_free_mmc(dev);
1840}
1841
1842/*
1843 * Non-PnP
1844 */
1845
1846static int __devinit wbsd_probe(struct device* dev)
1847{
1848 return wbsd_init(dev, io, irq, dma, 0);
1849}
1850
1851static int __devexit wbsd_remove(struct device* dev)
1852{
1853 wbsd_shutdown(dev, 0);
1854
1855 return 0;
1856}
1857
1858/*
1859 * PnP
1860 */
1861
1862#ifdef CONFIG_PNP
1863
1864static int __devinit
1865wbsd_pnp_probe(struct pnp_dev * pnpdev, const struct pnp_device_id *dev_id)
1866{
1867 int io, irq, dma;
1868
1869 /*
1870 * Get resources from PnP layer.
1871 */
1872 io = pnp_port_start(pnpdev, 0);
1873 irq = pnp_irq(pnpdev, 0);
1874 if (pnp_dma_valid(pnpdev, 0))
1875 dma = pnp_dma(pnpdev, 0);
1876 else
1877 dma = -1;
1878
1879 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1880
1881 return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1882}
1883
1884static void __devexit wbsd_pnp_remove(struct pnp_dev * dev)
1885{
1886 wbsd_shutdown(&dev->dev, 1);
1887}
1888
1889#endif /* CONFIG_PNP */
1890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891/*
1892 * Power management
1893 */
1894
1895#ifdef CONFIG_PM
Pavel Macheke5378ca2005-04-16 15:25:29 -07001896static int wbsd_suspend(struct device *dev, pm_message_t state, u32 level)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 DBGF("Not yet supported\n");
1899
1900 return 0;
1901}
1902
1903static int wbsd_resume(struct device *dev, u32 level)
1904{
1905 DBGF("Not yet supported\n");
1906
1907 return 0;
1908}
1909#else
1910#define wbsd_suspend NULL
1911#define wbsd_resume NULL
1912#endif
1913
Pierre Ossman85bcc132005-05-08 19:35:27 +01001914static struct platform_device *wbsd_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916static struct device_driver wbsd_driver = {
1917 .name = DRIVER_NAME,
1918 .bus = &platform_bus_type,
1919 .probe = wbsd_probe,
1920 .remove = wbsd_remove,
1921
1922 .suspend = wbsd_suspend,
1923 .resume = wbsd_resume,
1924};
1925
Pierre Ossman85bcc132005-05-08 19:35:27 +01001926#ifdef CONFIG_PNP
1927
1928static struct pnp_driver wbsd_pnp_driver = {
1929 .name = DRIVER_NAME,
1930 .id_table = pnp_dev_table,
1931 .probe = wbsd_pnp_probe,
1932 .remove = wbsd_pnp_remove,
1933};
1934
1935#endif /* CONFIG_PNP */
1936
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937/*
1938 * Module loading/unloading
1939 */
1940
1941static int __init wbsd_drv_init(void)
1942{
1943 int result;
1944
1945 printk(KERN_INFO DRIVER_NAME
1946 ": Winbond W83L51xD SD/MMC card interface driver, "
1947 DRIVER_VERSION "\n");
1948 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
Pierre Ossman85bcc132005-05-08 19:35:27 +01001950#ifdef CONFIG_PNP
1951
1952 if (!nopnp)
1953 {
1954 result = pnp_register_driver(&wbsd_pnp_driver);
1955 if (result < 0)
1956 return result;
1957 }
1958
1959#endif /* CONFIG_PNP */
1960
1961 if (nopnp)
1962 {
1963 result = driver_register(&wbsd_driver);
1964 if (result < 0)
1965 return result;
1966
1967 wbsd_device = platform_device_register_simple(DRIVER_NAME, -1,
1968 NULL, 0);
1969 if (IS_ERR(wbsd_device))
1970 return PTR_ERR(wbsd_device);
1971 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 return 0;
1974}
1975
1976static void __exit wbsd_drv_exit(void)
1977{
Pierre Ossman85bcc132005-05-08 19:35:27 +01001978#ifdef CONFIG_PNP
1979
1980 if (!nopnp)
1981 pnp_unregister_driver(&wbsd_pnp_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982
Pierre Ossman85bcc132005-05-08 19:35:27 +01001983#endif /* CONFIG_PNP */
1984
1985 if (nopnp)
1986 {
1987 platform_device_unregister(wbsd_device);
1988
1989 driver_unregister(&wbsd_driver);
1990 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992 DBG("unloaded\n");
1993}
1994
1995module_init(wbsd_drv_init);
1996module_exit(wbsd_drv_exit);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001997#ifdef CONFIG_PNP
1998module_param(nopnp, uint, 0444);
1999#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000module_param(io, uint, 0444);
2001module_param(irq, uint, 0444);
2002module_param(dma, int, 0444);
2003
2004MODULE_LICENSE("GPL");
2005MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2006MODULE_VERSION(DRIVER_VERSION);
2007
Pierre Ossman85bcc132005-05-08 19:35:27 +01002008#ifdef CONFIG_PNP
2009MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2010#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2012MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2013MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");