blob: dec01d38c782fce5935ffb575ca90122934260e7 [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 Ossman1656fa52005-09-03 16:45:49 +010045#define DRIVER_VERSION "1.4"
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.
Pierre Ossman65ae2112005-09-06 15:18:57 -0700723 * Two bytes are needed for each data line.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 */
Pierre Ossman65ae2112005-09-06 15:18:57 -0700725 if (host->bus_width == MMC_BUS_WIDTH_1)
726 {
727 blksize = (1 << data->blksz_bits) + 2;
728
729 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
730 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
731 }
732 else if (host->bus_width == MMC_BUS_WIDTH_4)
733 {
734 blksize = (1 << data->blksz_bits) + 2 * 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Pierre Ossman65ae2112005-09-06 15:18:57 -0700736 wbsd_write_index(host, WBSD_IDX_PBSMSB, ((blksize >> 4) & 0xF0)
737 | WBSD_DATA_WIDTH);
738 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
739 }
740 else
741 {
742 data->error = MMC_ERR_INVALID;
743 return;
744 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 /*
747 * Clear the FIFO. This is needed even for DMA
748 * transfers since the chip still uses the FIFO
749 * internally.
750 */
751 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
752 setup |= WBSD_FIFO_RESET;
753 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
754
755 /*
756 * DMA transfer?
757 */
758 if (host->dma >= 0)
759 {
760 /*
761 * The buffer for DMA is only 64 kB.
762 */
763 BUG_ON(host->size > 0x10000);
764 if (host->size > 0x10000)
765 {
766 data->error = MMC_ERR_INVALID;
767 return;
768 }
769
770 /*
771 * Transfer data from the SG list to
772 * the DMA buffer.
773 */
774 if (data->flags & MMC_DATA_WRITE)
775 wbsd_sg_to_dma(host, data);
776
777 /*
778 * Initialise the ISA DMA controller.
779 */
780 dmaflags = claim_dma_lock();
781 disable_dma(host->dma);
782 clear_dma_ff(host->dma);
783 if (data->flags & MMC_DATA_READ)
784 set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
785 else
786 set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
787 set_dma_addr(host->dma, host->dma_addr);
788 set_dma_count(host->dma, host->size);
789
790 enable_dma(host->dma);
791 release_dma_lock(dmaflags);
792
793 /*
794 * Enable DMA on the host.
795 */
796 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
797 }
798 else
799 {
800 /*
801 * This flag is used to keep printk
802 * output to a minimum.
803 */
804 host->firsterr = 1;
805
806 /*
807 * Initialise the SG list.
808 */
809 wbsd_init_sg(host, data);
810
811 /*
812 * Turn off DMA.
813 */
814 wbsd_write_index(host, WBSD_IDX_DMA, 0);
815
816 /*
817 * Set up FIFO threshold levels (and fill
818 * buffer if doing a write).
819 */
820 if (data->flags & MMC_DATA_READ)
821 {
822 wbsd_write_index(host, WBSD_IDX_FIFOEN,
823 WBSD_FIFOEN_FULL | 8);
824 }
825 else
826 {
827 wbsd_write_index(host, WBSD_IDX_FIFOEN,
828 WBSD_FIFOEN_EMPTY | 8);
829 wbsd_fill_fifo(host);
830 }
831 }
832
833 data->error = MMC_ERR_NONE;
834}
835
836static void wbsd_finish_data(struct wbsd_host* host, struct mmc_data* data)
837{
838 unsigned long dmaflags;
839 int count;
840 u8 status;
841
842 WARN_ON(host->mrq == NULL);
843
844 /*
845 * Send a stop command if needed.
846 */
847 if (data->stop)
848 wbsd_send_command(host, data->stop);
849
850 /*
851 * Wait for the controller to leave data
852 * transfer state.
853 */
854 do
855 {
856 status = wbsd_read_index(host, WBSD_IDX_STATUS);
857 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
858
859 /*
860 * DMA transfer?
861 */
862 if (host->dma >= 0)
863 {
864 /*
865 * Disable DMA on the host.
866 */
867 wbsd_write_index(host, WBSD_IDX_DMA, 0);
868
869 /*
870 * Turn of ISA DMA controller.
871 */
872 dmaflags = claim_dma_lock();
873 disable_dma(host->dma);
874 clear_dma_ff(host->dma);
875 count = get_dma_residue(host->dma);
876 release_dma_lock(dmaflags);
877
878 /*
879 * Any leftover data?
880 */
881 if (count)
882 {
883 printk(KERN_ERR DRIVER_NAME ": Incomplete DMA "
884 "transfer. %d bytes left.\n", count);
885
886 data->error = MMC_ERR_FAILED;
887 }
888 else
889 {
890 /*
891 * Transfer data from DMA buffer to
892 * SG list.
893 */
894 if (data->flags & MMC_DATA_READ)
895 wbsd_dma_to_sg(host, data);
896
897 data->bytes_xfered = host->size;
898 }
899 }
900
901 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
902
903 wbsd_request_end(host, host->mrq);
904}
905
Pierre Ossman85bcc132005-05-08 19:35:27 +0100906/*****************************************************************************\
907 * *
908 * MMC layer callbacks *
909 * *
910\*****************************************************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912static void wbsd_request(struct mmc_host* mmc, struct mmc_request* mrq)
913{
914 struct wbsd_host* host = mmc_priv(mmc);
915 struct mmc_command* cmd;
916
917 /*
918 * Disable tasklets to avoid a deadlock.
919 */
920 spin_lock_bh(&host->lock);
921
922 BUG_ON(host->mrq != NULL);
923
924 cmd = mrq->cmd;
925
926 host->mrq = mrq;
927
928 /*
929 * If there is no card in the slot then
930 * timeout immediatly.
931 */
Pierre Ossman85bcc132005-05-08 19:35:27 +0100932 if (!(host->flags & WBSD_FCARD_PRESENT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 {
934 cmd->error = MMC_ERR_TIMEOUT;
935 goto done;
936 }
937
938 /*
939 * Does the request include data?
940 */
941 if (cmd->data)
942 {
943 wbsd_prepare_data(host, cmd->data);
944
945 if (cmd->data->error != MMC_ERR_NONE)
946 goto done;
947 }
948
949 wbsd_send_command(host, cmd);
950
951 /*
952 * If this is a data transfer the request
953 * will be finished after the data has
954 * transfered.
955 */
956 if (cmd->data && (cmd->error == MMC_ERR_NONE))
957 {
958 /*
959 * Dirty fix for hardware bug.
960 */
961 if (host->dma == -1)
962 tasklet_schedule(&host->fifo_tasklet);
963
964 spin_unlock_bh(&host->lock);
965
966 return;
967 }
968
969done:
970 wbsd_request_end(host, mrq);
971
972 spin_unlock_bh(&host->lock);
973}
974
975static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
976{
977 struct wbsd_host* host = mmc_priv(mmc);
978 u8 clk, setup, pwr;
979
Pierre Ossman65ae2112005-09-06 15:18:57 -0700980 DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
981 ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
982 ios->vdd, ios->bus_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 spin_lock_bh(&host->lock);
985
986 /*
987 * Reset the chip on each power off.
988 * Should clear out any weird states.
989 */
990 if (ios->power_mode == MMC_POWER_OFF)
991 wbsd_init_device(host);
992
993 if (ios->clock >= 24000000)
994 clk = WBSD_CLK_24M;
995 else if (ios->clock >= 16000000)
996 clk = WBSD_CLK_16M;
997 else if (ios->clock >= 12000000)
998 clk = WBSD_CLK_12M;
999 else
1000 clk = WBSD_CLK_375K;
1001
1002 /*
1003 * Only write to the clock register when
1004 * there is an actual change.
1005 */
1006 if (clk != host->clk)
1007 {
1008 wbsd_write_index(host, WBSD_IDX_CLK, clk);
1009 host->clk = clk;
1010 }
1011
Pierre Ossman85bcc132005-05-08 19:35:27 +01001012 /*
1013 * Power up card.
1014 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (ios->power_mode != MMC_POWER_OFF)
1016 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 pwr = inb(host->base + WBSD_CSR);
1018 pwr &= ~WBSD_POWER_N;
1019 outb(pwr, host->base + WBSD_CSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 }
1021
Pierre Ossman85bcc132005-05-08 19:35:27 +01001022 /*
1023 * MMC cards need to have pin 1 high during init.
Pierre Ossman85bcc132005-05-08 19:35:27 +01001024 * It wreaks havoc with the card detection though so
Pierre Ossman1656fa52005-09-03 16:45:49 +01001025 * that needs to be disabled.
Pierre Ossman85bcc132005-05-08 19:35:27 +01001026 */
1027 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
Pierre Ossman1656fa52005-09-03 16:45:49 +01001028 if (ios->chip_select == MMC_CS_HIGH)
Pierre Ossman85bcc132005-05-08 19:35:27 +01001029 {
Pierre Ossman65ae2112005-09-06 15:18:57 -07001030 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001031 setup |= WBSD_DAT3_H;
1032 host->flags |= WBSD_FIGNORE_DETECT;
1033 }
1034 else
1035 {
1036 setup &= ~WBSD_DAT3_H;
Pierre Ossman1656fa52005-09-03 16:45:49 +01001037
1038 /*
1039 * We cannot resume card detection immediatly
1040 * because of capacitance and delays in the chip.
1041 */
1042 mod_timer(&host->ignore_timer, jiffies + HZ/100);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001043 }
1044 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
1045
Pierre Ossman65ae2112005-09-06 15:18:57 -07001046 /*
1047 * Store bus width for later. Will be used when
1048 * setting up the data transfer.
1049 */
1050 host->bus_width = ios->bus_width;
1051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 spin_unlock_bh(&host->lock);
1053}
1054
Pierre Ossman65ae2112005-09-06 15:18:57 -07001055static int wbsd_get_ro(struct mmc_host* mmc)
1056{
1057 struct wbsd_host* host = mmc_priv(mmc);
1058 u8 csr;
1059
1060 spin_lock_bh(&host->lock);
1061
1062 csr = inb(host->base + WBSD_CSR);
1063 csr |= WBSD_MSLED;
1064 outb(csr, host->base + WBSD_CSR);
1065
1066 mdelay(1);
1067
1068 csr = inb(host->base + WBSD_CSR);
1069 csr &= ~WBSD_MSLED;
1070 outb(csr, host->base + WBSD_CSR);
1071
1072 spin_unlock_bh(&host->lock);
1073
1074 return csr & WBSD_WRPT;
1075}
1076
Pierre Ossman85bcc132005-05-08 19:35:27 +01001077static struct mmc_host_ops wbsd_ops = {
1078 .request = wbsd_request,
1079 .set_ios = wbsd_set_ios,
Pierre Ossman65ae2112005-09-06 15:18:57 -07001080 .get_ro = wbsd_get_ro,
Pierre Ossman85bcc132005-05-08 19:35:27 +01001081};
1082
1083/*****************************************************************************\
1084 * *
1085 * Interrupt handling *
1086 * *
1087\*****************************************************************************/
1088
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089/*
Pierre Ossman1656fa52005-09-03 16:45:49 +01001090 * Helper function to reset detection ignore
1091 */
1092
1093static void wbsd_reset_ignore(unsigned long data)
1094{
1095 struct wbsd_host *host = (struct wbsd_host*)data;
1096
1097 BUG_ON(host == NULL);
1098
1099 DBG("Resetting card detection ignore\n");
1100
1101 spin_lock_bh(&host->lock);
1102
1103 host->flags &= ~WBSD_FIGNORE_DETECT;
1104
1105 /*
1106 * Card status might have changed during the
1107 * blackout.
1108 */
1109 tasklet_schedule(&host->card_tasklet);
1110
1111 spin_unlock_bh(&host->lock);
1112}
1113
1114/*
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001115 * Helper function for card detection
1116 */
1117static void wbsd_detect_card(unsigned long data)
1118{
1119 struct wbsd_host *host = (struct wbsd_host*)data;
1120
1121 BUG_ON(host == NULL);
1122
1123 DBG("Executing card detection\n");
1124
1125 mmc_detect_change(host->mmc);
1126}
1127
1128/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 * Tasklets
1130 */
1131
Jesper Juhl77933d72005-07-27 11:46:09 -07001132static inline struct mmc_data* wbsd_get_data(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133{
1134 WARN_ON(!host->mrq);
1135 if (!host->mrq)
1136 return NULL;
1137
1138 WARN_ON(!host->mrq->cmd);
1139 if (!host->mrq->cmd)
1140 return NULL;
1141
1142 WARN_ON(!host->mrq->cmd->data);
1143 if (!host->mrq->cmd->data)
1144 return NULL;
1145
1146 return host->mrq->cmd->data;
1147}
1148
1149static void wbsd_tasklet_card(unsigned long param)
1150{
1151 struct wbsd_host* host = (struct wbsd_host*)param;
1152 u8 csr;
1153
1154 spin_lock(&host->lock);
1155
Pierre Ossman85bcc132005-05-08 19:35:27 +01001156 if (host->flags & WBSD_FIGNORE_DETECT)
1157 {
1158 spin_unlock(&host->lock);
1159 return;
1160 }
1161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 csr = inb(host->base + WBSD_CSR);
1163 WARN_ON(csr == 0xff);
1164
1165 if (csr & WBSD_CARDPRESENT)
Pierre Ossman85bcc132005-05-08 19:35:27 +01001166 {
1167 if (!(host->flags & WBSD_FCARD_PRESENT))
1168 {
1169 DBG("Card inserted\n");
1170 host->flags |= WBSD_FCARD_PRESENT;
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001171
1172 /*
1173 * Delay card detection to allow electrical connections
1174 * to stabilise.
1175 */
Pierre Ossman1656fa52005-09-03 16:45:49 +01001176 mod_timer(&host->detect_timer, jiffies + HZ/2);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001177 }
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001178
1179 spin_unlock(&host->lock);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001180 }
1181 else if (host->flags & WBSD_FCARD_PRESENT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 {
1183 DBG("Card removed\n");
Pierre Ossman85bcc132005-05-08 19:35:27 +01001184 host->flags &= ~WBSD_FCARD_PRESENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
1186 if (host->mrq)
1187 {
1188 printk(KERN_ERR DRIVER_NAME
1189 ": Card removed during transfer!\n");
1190 wbsd_reset(host);
1191
1192 host->mrq->cmd->error = MMC_ERR_FAILED;
1193 tasklet_schedule(&host->finish_tasklet);
1194 }
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001195
1196 /*
1197 * Unlock first since we might get a call back.
1198 */
1199 spin_unlock(&host->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200
Pierre Ossman85bcc132005-05-08 19:35:27 +01001201 mmc_detect_change(host->mmc);
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001202 }
Pierre Ossman1656fa52005-09-03 16:45:49 +01001203 else
1204 spin_unlock(&host->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205}
1206
1207static void wbsd_tasklet_fifo(unsigned long param)
1208{
1209 struct wbsd_host* host = (struct wbsd_host*)param;
1210 struct mmc_data* data;
1211
1212 spin_lock(&host->lock);
1213
1214 if (!host->mrq)
1215 goto end;
1216
1217 data = wbsd_get_data(host);
1218 if (!data)
1219 goto end;
1220
1221 if (data->flags & MMC_DATA_WRITE)
1222 wbsd_fill_fifo(host);
1223 else
1224 wbsd_empty_fifo(host);
1225
1226 /*
1227 * Done?
1228 */
1229 if (host->size == data->bytes_xfered)
1230 {
1231 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1232 tasklet_schedule(&host->finish_tasklet);
1233 }
1234
1235end:
1236 spin_unlock(&host->lock);
1237}
1238
1239static void wbsd_tasklet_crc(unsigned long param)
1240{
1241 struct wbsd_host* host = (struct wbsd_host*)param;
1242 struct mmc_data* data;
1243
1244 spin_lock(&host->lock);
1245
1246 if (!host->mrq)
1247 goto end;
1248
1249 data = wbsd_get_data(host);
1250 if (!data)
1251 goto end;
1252
1253 DBGF("CRC error\n");
1254
1255 data->error = MMC_ERR_BADCRC;
1256
1257 tasklet_schedule(&host->finish_tasklet);
1258
1259end:
1260 spin_unlock(&host->lock);
1261}
1262
1263static void wbsd_tasklet_timeout(unsigned long param)
1264{
1265 struct wbsd_host* host = (struct wbsd_host*)param;
1266 struct mmc_data* data;
1267
1268 spin_lock(&host->lock);
1269
1270 if (!host->mrq)
1271 goto end;
1272
1273 data = wbsd_get_data(host);
1274 if (!data)
1275 goto end;
1276
1277 DBGF("Timeout\n");
1278
1279 data->error = MMC_ERR_TIMEOUT;
1280
1281 tasklet_schedule(&host->finish_tasklet);
1282
1283end:
1284 spin_unlock(&host->lock);
1285}
1286
1287static void wbsd_tasklet_finish(unsigned long param)
1288{
1289 struct wbsd_host* host = (struct wbsd_host*)param;
1290 struct mmc_data* data;
1291
1292 spin_lock(&host->lock);
1293
1294 WARN_ON(!host->mrq);
1295 if (!host->mrq)
1296 goto end;
1297
1298 data = wbsd_get_data(host);
1299 if (!data)
1300 goto end;
1301
1302 wbsd_finish_data(host, data);
1303
1304end:
1305 spin_unlock(&host->lock);
1306}
1307
1308static void wbsd_tasklet_block(unsigned long param)
1309{
1310 struct wbsd_host* host = (struct wbsd_host*)param;
1311 struct mmc_data* data;
1312
1313 spin_lock(&host->lock);
1314
1315 if ((wbsd_read_index(host, WBSD_IDX_CRCSTATUS) & WBSD_CRC_MASK) !=
1316 WBSD_CRC_OK)
1317 {
1318 data = wbsd_get_data(host);
1319 if (!data)
1320 goto end;
1321
1322 DBGF("CRC error\n");
1323
1324 data->error = MMC_ERR_BADCRC;
1325
1326 tasklet_schedule(&host->finish_tasklet);
1327 }
1328
1329end:
1330 spin_unlock(&host->lock);
1331}
1332
1333/*
1334 * Interrupt handling
1335 */
1336
1337static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs)
1338{
1339 struct wbsd_host* host = dev_id;
1340 int isr;
1341
1342 isr = inb(host->base + WBSD_ISR);
1343
1344 /*
1345 * Was it actually our hardware that caused the interrupt?
1346 */
1347 if (isr == 0xff || isr == 0x00)
1348 return IRQ_NONE;
1349
1350 host->isr |= isr;
1351
1352 /*
1353 * Schedule tasklets as needed.
1354 */
1355 if (isr & WBSD_INT_CARD)
1356 tasklet_schedule(&host->card_tasklet);
1357 if (isr & WBSD_INT_FIFO_THRE)
1358 tasklet_schedule(&host->fifo_tasklet);
1359 if (isr & WBSD_INT_CRC)
1360 tasklet_hi_schedule(&host->crc_tasklet);
1361 if (isr & WBSD_INT_TIMEOUT)
1362 tasklet_hi_schedule(&host->timeout_tasklet);
1363 if (isr & WBSD_INT_BUSYEND)
1364 tasklet_hi_schedule(&host->block_tasklet);
1365 if (isr & WBSD_INT_TC)
1366 tasklet_schedule(&host->finish_tasklet);
1367
1368 return IRQ_HANDLED;
1369}
1370
Pierre Ossman85bcc132005-05-08 19:35:27 +01001371/*****************************************************************************\
1372 * *
1373 * Device initialisation and shutdown *
1374 * *
1375\*****************************************************************************/
1376
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377/*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001378 * Allocate/free MMC structure.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 */
1380
Pierre Ossman85bcc132005-05-08 19:35:27 +01001381static int __devinit wbsd_alloc_mmc(struct device* dev)
1382{
1383 struct mmc_host* mmc;
1384 struct wbsd_host* host;
1385
1386 /*
1387 * Allocate MMC structure.
1388 */
1389 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1390 if (!mmc)
1391 return -ENOMEM;
1392
1393 host = mmc_priv(mmc);
1394 host->mmc = mmc;
1395
1396 host->dma = -1;
1397
1398 /*
1399 * Set host parameters.
1400 */
1401 mmc->ops = &wbsd_ops;
1402 mmc->f_min = 375000;
1403 mmc->f_max = 24000000;
1404 mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
Pierre Ossman65ae2112005-09-06 15:18:57 -07001405 mmc->caps = MMC_CAP_4_BIT_DATA;
Pierre Ossman85bcc132005-05-08 19:35:27 +01001406
1407 spin_lock_init(&host->lock);
1408
1409 /*
Pierre Ossman1656fa52005-09-03 16:45:49 +01001410 * Set up timers
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001411 */
Pierre Ossman1656fa52005-09-03 16:45:49 +01001412 init_timer(&host->detect_timer);
1413 host->detect_timer.data = (unsigned long)host;
1414 host->detect_timer.function = wbsd_detect_card;
1415
1416 init_timer(&host->ignore_timer);
1417 host->ignore_timer.data = (unsigned long)host;
1418 host->ignore_timer.function = wbsd_reset_ignore;
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001419
1420 /*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001421 * Maximum number of segments. Worst case is one sector per segment
1422 * so this will be 64kB/512.
1423 */
1424 mmc->max_hw_segs = 128;
1425 mmc->max_phys_segs = 128;
1426
1427 /*
1428 * Maximum number of sectors in one transfer. Also limited by 64kB
1429 * buffer.
1430 */
1431 mmc->max_sectors = 128;
1432
1433 /*
1434 * Maximum segment size. Could be one segment with the maximum number
1435 * of segments.
1436 */
1437 mmc->max_seg_size = mmc->max_sectors * 512;
1438
1439 dev_set_drvdata(dev, mmc);
1440
1441 return 0;
1442}
1443
1444static void __devexit wbsd_free_mmc(struct device* dev)
1445{
1446 struct mmc_host* mmc;
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001447 struct wbsd_host* host;
Pierre Ossman85bcc132005-05-08 19:35:27 +01001448
1449 mmc = dev_get_drvdata(dev);
1450 if (!mmc)
1451 return;
1452
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001453 host = mmc_priv(mmc);
1454 BUG_ON(host == NULL);
1455
Pierre Ossman1656fa52005-09-03 16:45:49 +01001456 del_timer_sync(&host->ignore_timer);
1457 del_timer_sync(&host->detect_timer);
Pierre Ossman6e6293d2005-07-01 12:13:55 +01001458
Pierre Ossman85bcc132005-05-08 19:35:27 +01001459 mmc_free_host(mmc);
1460
1461 dev_set_drvdata(dev, NULL);
1462}
1463
1464/*
1465 * Scan for known chip id:s
1466 */
1467
1468static int __devinit wbsd_scan(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469{
1470 int i, j, k;
1471 int id;
1472
1473 /*
1474 * Iterate through all ports, all codes to
1475 * find hardware that is in our known list.
1476 */
1477 for (i = 0;i < sizeof(config_ports)/sizeof(int);i++)
1478 {
1479 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1480 continue;
1481
1482 for (j = 0;j < sizeof(unlock_codes)/sizeof(int);j++)
1483 {
1484 id = 0xFFFF;
1485
1486 outb(unlock_codes[j], config_ports[i]);
1487 outb(unlock_codes[j], config_ports[i]);
1488
1489 outb(WBSD_CONF_ID_HI, config_ports[i]);
1490 id = inb(config_ports[i] + 1) << 8;
1491
1492 outb(WBSD_CONF_ID_LO, config_ports[i]);
1493 id |= inb(config_ports[i] + 1);
1494
1495 for (k = 0;k < sizeof(valid_ids)/sizeof(int);k++)
1496 {
1497 if (id == valid_ids[k])
1498 {
1499 host->chip_id = id;
1500 host->config = config_ports[i];
1501 host->unlock_code = unlock_codes[i];
1502
1503 return 0;
1504 }
1505 }
1506
1507 if (id != 0xFFFF)
1508 {
1509 DBG("Unknown hardware (id %x) found at %x\n",
1510 id, config_ports[i]);
1511 }
1512
1513 outb(LOCK_CODE, config_ports[i]);
1514 }
1515
1516 release_region(config_ports[i], 2);
1517 }
1518
1519 return -ENODEV;
1520}
1521
Pierre Ossman85bcc132005-05-08 19:35:27 +01001522/*
1523 * Allocate/free io port ranges
1524 */
1525
1526static int __devinit wbsd_request_region(struct wbsd_host* host, int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527{
1528 if (io & 0x7)
1529 return -EINVAL;
1530
Pierre Ossman85bcc132005-05-08 19:35:27 +01001531 if (!request_region(base, 8, DRIVER_NAME))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 return -EIO;
1533
1534 host->base = io;
1535
1536 return 0;
1537}
1538
Pierre Ossman85bcc132005-05-08 19:35:27 +01001539static void __devexit wbsd_release_regions(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540{
1541 if (host->base)
1542 release_region(host->base, 8);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001543
1544 host->base = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
1546 if (host->config)
1547 release_region(host->config, 2);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001548
1549 host->config = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550}
1551
Pierre Ossman85bcc132005-05-08 19:35:27 +01001552/*
1553 * Allocate/free DMA port and buffer
1554 */
1555
1556static void __devinit wbsd_request_dma(struct wbsd_host* host, int dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 if (dma < 0)
1559 return;
1560
1561 if (request_dma(dma, DRIVER_NAME))
1562 goto err;
1563
1564 /*
1565 * We need to allocate a special buffer in
1566 * order for ISA to be able to DMA to it.
1567 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001568 host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1570 if (!host->dma_buffer)
1571 goto free;
1572
1573 /*
1574 * Translate the address to a physical address.
1575 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001576 host->dma_addr = dma_map_single(host->mmc->dev, host->dma_buffer,
1577 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
1579 /*
1580 * ISA DMA must be aligned on a 64k basis.
1581 */
1582 if ((host->dma_addr & 0xffff) != 0)
1583 goto kfree;
1584 /*
1585 * ISA cannot access memory above 16 MB.
1586 */
1587 else if (host->dma_addr >= 0x1000000)
1588 goto kfree;
1589
1590 host->dma = dma;
1591
1592 return;
1593
1594kfree:
1595 /*
1596 * If we've gotten here then there is some kind of alignment bug
1597 */
1598 BUG_ON(1);
1599
Pierre Ossman85bcc132005-05-08 19:35:27 +01001600 dma_unmap_single(host->mmc->dev, host->dma_addr, WBSD_DMA_SIZE,
1601 DMA_BIDIRECTIONAL);
1602 host->dma_addr = (dma_addr_t)NULL;
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 kfree(host->dma_buffer);
1605 host->dma_buffer = NULL;
1606
1607free:
1608 free_dma(dma);
1609
1610err:
1611 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1612 "Falling back on FIFO.\n", dma);
1613}
1614
Pierre Ossman85bcc132005-05-08 19:35:27 +01001615static void __devexit wbsd_release_dma(struct wbsd_host* host)
1616{
1617 if (host->dma_addr)
1618 dma_unmap_single(host->mmc->dev, host->dma_addr, WBSD_DMA_SIZE,
1619 DMA_BIDIRECTIONAL);
1620 if (host->dma_buffer)
1621 kfree(host->dma_buffer);
1622 if (host->dma >= 0)
1623 free_dma(host->dma);
1624
1625 host->dma = -1;
1626 host->dma_buffer = NULL;
1627 host->dma_addr = (dma_addr_t)NULL;
1628}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630/*
Pierre Ossman85bcc132005-05-08 19:35:27 +01001631 * Allocate/free IRQ.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 */
1633
Pierre Ossman85bcc132005-05-08 19:35:27 +01001634static int __devinit wbsd_request_irq(struct wbsd_host* host, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 int ret;
1637
1638 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 * Allocate interrupt.
1640 */
Pierre Ossman85bcc132005-05-08 19:35:27 +01001641
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 ret = request_irq(irq, wbsd_irq, SA_SHIRQ, DRIVER_NAME, host);
1643 if (ret)
Pierre Ossman85bcc132005-05-08 19:35:27 +01001644 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
1646 host->irq = irq;
Pierre Ossman85bcc132005-05-08 19:35:27 +01001647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 /*
1649 * Set up tasklets.
1650 */
1651 tasklet_init(&host->card_tasklet, wbsd_tasklet_card, (unsigned long)host);
1652 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo, (unsigned long)host);
1653 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc, (unsigned long)host);
1654 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout, (unsigned long)host);
1655 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish, (unsigned long)host);
1656 tasklet_init(&host->block_tasklet, wbsd_tasklet_block, (unsigned long)host);
1657
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659}
1660
Pierre Ossman85bcc132005-05-08 19:35:27 +01001661static void __devexit wbsd_release_irq(struct wbsd_host* host)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662{
Pierre Ossman85bcc132005-05-08 19:35:27 +01001663 if (!host->irq)
1664 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 free_irq(host->irq, host);
1667
Pierre Ossman85bcc132005-05-08 19:35:27 +01001668 host->irq = 0;
1669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 tasklet_kill(&host->card_tasklet);
1671 tasklet_kill(&host->fifo_tasklet);
1672 tasklet_kill(&host->crc_tasklet);
1673 tasklet_kill(&host->timeout_tasklet);
1674 tasklet_kill(&host->finish_tasklet);
1675 tasklet_kill(&host->block_tasklet);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001676}
1677
1678/*
1679 * Allocate all resources for the host.
1680 */
1681
1682static int __devinit wbsd_request_resources(struct wbsd_host* host,
1683 int base, int irq, int dma)
1684{
1685 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Pierre Ossman85bcc132005-05-08 19:35:27 +01001687 /*
1688 * Allocate I/O ports.
1689 */
1690 ret = wbsd_request_region(host, base);
1691 if (ret)
1692 return ret;
1693
1694 /*
1695 * Allocate interrupt.
1696 */
1697 ret = wbsd_request_irq(host, irq);
1698 if (ret)
1699 return ret;
1700
1701 /*
1702 * Allocate DMA.
1703 */
1704 wbsd_request_dma(host, dma);
1705
1706 return 0;
1707}
1708
1709/*
1710 * Release all resources for the host.
1711 */
1712
1713static void __devexit wbsd_release_resources(struct wbsd_host* host)
1714{
1715 wbsd_release_dma(host);
1716 wbsd_release_irq(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 wbsd_release_regions(host);
Pierre Ossman85bcc132005-05-08 19:35:27 +01001718}
1719
1720/*
1721 * Configure the resources the chip should use.
1722 */
1723
1724static void __devinit wbsd_chip_config(struct wbsd_host* host)
1725{
1726 /*
1727 * Reset the chip.
1728 */
1729 wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1730 wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1731
1732 /*
1733 * Select SD/MMC function.
1734 */
1735 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
Pierre Ossman85bcc132005-05-08 19:35:27 +01001737 /*
1738 * Set up card detection.
1739 */
1740 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1741
1742 /*
1743 * Configure chip
1744 */
1745 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1746 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1747
1748 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1749
1750 if (host->dma >= 0)
1751 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1752
1753 /*
1754 * Enable and power up chip.
1755 */
1756 wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1757 wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1758}
1759
1760/*
1761 * Check that configured resources are correct.
1762 */
1763
1764static int __devinit wbsd_chip_validate(struct wbsd_host* host)
1765{
1766 int base, irq, dma;
1767
1768 /*
1769 * Select SD/MMC function.
1770 */
1771 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1772
1773 /*
1774 * Read configuration.
1775 */
1776 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1777 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1778
1779 irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1780
1781 dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1782
1783 /*
1784 * Validate against given configuration.
1785 */
1786 if (base != host->base)
1787 return 0;
1788 if (irq != host->irq)
1789 return 0;
1790 if ((dma != host->dma) && (host->dma != -1))
1791 return 0;
1792
1793 return 1;
1794}
1795
1796/*****************************************************************************\
1797 * *
1798 * Devices setup and shutdown *
1799 * *
1800\*****************************************************************************/
1801
1802static int __devinit wbsd_init(struct device* dev, int base, int irq, int dma,
1803 int pnp)
1804{
1805 struct wbsd_host* host = NULL;
1806 struct mmc_host* mmc = NULL;
1807 int ret;
1808
1809 ret = wbsd_alloc_mmc(dev);
1810 if (ret)
1811 return ret;
1812
1813 mmc = dev_get_drvdata(dev);
1814 host = mmc_priv(mmc);
1815
1816 /*
1817 * Scan for hardware.
1818 */
1819 ret = wbsd_scan(host);
1820 if (ret)
1821 {
1822 if (pnp && (ret == -ENODEV))
1823 {
1824 printk(KERN_WARNING DRIVER_NAME
1825 ": Unable to confirm device presence. You may "
1826 "experience lock-ups.\n");
1827 }
1828 else
1829 {
1830 wbsd_free_mmc(dev);
1831 return ret;
1832 }
1833 }
1834
1835 /*
1836 * Request resources.
1837 */
1838 ret = wbsd_request_resources(host, io, irq, dma);
1839 if (ret)
1840 {
1841 wbsd_release_resources(host);
1842 wbsd_free_mmc(dev);
1843 return ret;
1844 }
1845
1846 /*
1847 * See if chip needs to be configured.
1848 */
1849 if (pnp && (host->config != 0))
1850 {
1851 if (!wbsd_chip_validate(host))
1852 {
1853 printk(KERN_WARNING DRIVER_NAME
1854 ": PnP active but chip not configured! "
1855 "You probably have a buggy BIOS. "
1856 "Configuring chip manually.\n");
1857 wbsd_chip_config(host);
1858 }
1859 }
1860 else
1861 wbsd_chip_config(host);
1862
1863 /*
1864 * Power Management stuff. No idea how this works.
1865 * Not tested.
1866 */
1867#ifdef CONFIG_PM
1868 if (host->config)
1869 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1870#endif
1871 /*
1872 * Allow device to initialise itself properly.
1873 */
1874 mdelay(5);
1875
1876 /*
1877 * Reset the chip into a known state.
1878 */
1879 wbsd_init_device(host);
1880
1881 mmc_add_host(mmc);
1882
Russell Kingd366b642005-08-19 09:40:08 +01001883 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
Pierre Ossman85bcc132005-05-08 19:35:27 +01001884 if (host->chip_id != 0)
1885 printk(" id %x", (int)host->chip_id);
1886 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1887 if (host->dma >= 0)
1888 printk(" dma %d", (int)host->dma);
1889 else
1890 printk(" FIFO");
1891 if (pnp)
1892 printk(" PnP");
1893 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
1895 return 0;
1896}
1897
Pierre Ossman85bcc132005-05-08 19:35:27 +01001898static void __devexit wbsd_shutdown(struct device* dev, int pnp)
1899{
1900 struct mmc_host* mmc = dev_get_drvdata(dev);
1901 struct wbsd_host* host;
1902
1903 if (!mmc)
1904 return;
1905
1906 host = mmc_priv(mmc);
1907
1908 mmc_remove_host(mmc);
1909
1910 if (!pnp)
1911 {
1912 /*
1913 * Power down the SD/MMC function.
1914 */
1915 wbsd_unlock_config(host);
1916 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1917 wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1918 wbsd_lock_config(host);
1919 }
1920
1921 wbsd_release_resources(host);
1922
1923 wbsd_free_mmc(dev);
1924}
1925
1926/*
1927 * Non-PnP
1928 */
1929
1930static int __devinit wbsd_probe(struct device* dev)
1931{
1932 return wbsd_init(dev, io, irq, dma, 0);
1933}
1934
1935static int __devexit wbsd_remove(struct device* dev)
1936{
1937 wbsd_shutdown(dev, 0);
1938
1939 return 0;
1940}
1941
1942/*
1943 * PnP
1944 */
1945
1946#ifdef CONFIG_PNP
1947
1948static int __devinit
1949wbsd_pnp_probe(struct pnp_dev * pnpdev, const struct pnp_device_id *dev_id)
1950{
1951 int io, irq, dma;
1952
1953 /*
1954 * Get resources from PnP layer.
1955 */
1956 io = pnp_port_start(pnpdev, 0);
1957 irq = pnp_irq(pnpdev, 0);
1958 if (pnp_dma_valid(pnpdev, 0))
1959 dma = pnp_dma(pnpdev, 0);
1960 else
1961 dma = -1;
1962
1963 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1964
1965 return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1966}
1967
1968static void __devexit wbsd_pnp_remove(struct pnp_dev * dev)
1969{
1970 wbsd_shutdown(&dev->dev, 1);
1971}
1972
1973#endif /* CONFIG_PNP */
1974
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975/*
1976 * Power management
1977 */
1978
1979#ifdef CONFIG_PM
Pavel Macheke5378ca2005-04-16 15:25:29 -07001980static int wbsd_suspend(struct device *dev, pm_message_t state, u32 level)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981{
1982 DBGF("Not yet supported\n");
1983
1984 return 0;
1985}
1986
1987static int wbsd_resume(struct device *dev, u32 level)
1988{
1989 DBGF("Not yet supported\n");
1990
1991 return 0;
1992}
1993#else
1994#define wbsd_suspend NULL
1995#define wbsd_resume NULL
1996#endif
1997
Pierre Ossman85bcc132005-05-08 19:35:27 +01001998static struct platform_device *wbsd_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
2000static struct device_driver wbsd_driver = {
2001 .name = DRIVER_NAME,
2002 .bus = &platform_bus_type,
2003 .probe = wbsd_probe,
2004 .remove = wbsd_remove,
2005
2006 .suspend = wbsd_suspend,
2007 .resume = wbsd_resume,
2008};
2009
Pierre Ossman85bcc132005-05-08 19:35:27 +01002010#ifdef CONFIG_PNP
2011
2012static struct pnp_driver wbsd_pnp_driver = {
2013 .name = DRIVER_NAME,
2014 .id_table = pnp_dev_table,
2015 .probe = wbsd_pnp_probe,
2016 .remove = wbsd_pnp_remove,
2017};
2018
2019#endif /* CONFIG_PNP */
2020
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021/*
2022 * Module loading/unloading
2023 */
2024
2025static int __init wbsd_drv_init(void)
2026{
2027 int result;
2028
2029 printk(KERN_INFO DRIVER_NAME
2030 ": Winbond W83L51xD SD/MMC card interface driver, "
2031 DRIVER_VERSION "\n");
2032 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
Pierre Ossman85bcc132005-05-08 19:35:27 +01002034#ifdef CONFIG_PNP
2035
2036 if (!nopnp)
2037 {
2038 result = pnp_register_driver(&wbsd_pnp_driver);
2039 if (result < 0)
2040 return result;
2041 }
2042
2043#endif /* CONFIG_PNP */
2044
2045 if (nopnp)
2046 {
2047 result = driver_register(&wbsd_driver);
2048 if (result < 0)
2049 return result;
2050
2051 wbsd_device = platform_device_register_simple(DRIVER_NAME, -1,
2052 NULL, 0);
2053 if (IS_ERR(wbsd_device))
2054 return PTR_ERR(wbsd_device);
2055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056
2057 return 0;
2058}
2059
2060static void __exit wbsd_drv_exit(void)
2061{
Pierre Ossman85bcc132005-05-08 19:35:27 +01002062#ifdef CONFIG_PNP
2063
2064 if (!nopnp)
2065 pnp_unregister_driver(&wbsd_pnp_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Pierre Ossman85bcc132005-05-08 19:35:27 +01002067#endif /* CONFIG_PNP */
2068
2069 if (nopnp)
2070 {
2071 platform_device_unregister(wbsd_device);
2072
2073 driver_unregister(&wbsd_driver);
2074 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075
2076 DBG("unloaded\n");
2077}
2078
2079module_init(wbsd_drv_init);
2080module_exit(wbsd_drv_exit);
Pierre Ossman85bcc132005-05-08 19:35:27 +01002081#ifdef CONFIG_PNP
2082module_param(nopnp, uint, 0444);
2083#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084module_param(io, uint, 0444);
2085module_param(irq, uint, 0444);
2086module_param(dma, int, 0444);
2087
2088MODULE_LICENSE("GPL");
2089MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2090MODULE_VERSION(DRIVER_VERSION);
2091
Pierre Ossman85bcc132005-05-08 19:35:27 +01002092#ifdef CONFIG_PNP
2093MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2094#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2096MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2097MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");