OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mmc/] [host/] [wbsd.c] - Blame information for rev 62

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.