2 * linux/drivers/mmc/sdhci.c - Secure Digital Host Controller Interface driver
4 * Copyright (C) 2005-2006 Pierre Ossman, All Rights Reserved.
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.
12 * Note that PIO transfer is rather crappy atm. The buffer full/empty
13 * interrupts aren't reliable so we currently transfer the entire buffer
14 * directly. Patches to solve the problem are welcome.
17 #include <linux/delay.h>
18 #include <linux/highmem.h>
19 #include <linux/pci.h>
20 #include <linux/dma-mapping.h>
22 #include <linux/mmc/host.h>
23 #include <linux/mmc/protocol.h>
25 #include <asm/scatterlist.h>
29 #define DRIVER_NAME "sdhci"
30 #define DRIVER_VERSION "0.11"
32 #define BUGMAIL "<sdhci-devel@list.drzeus.cx>"
34 #define DBG(f, x...) \
35 pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
37 static const struct pci_device_id pci_ids
[] __devinitdata
= {
38 /* handle any SD host controller */
39 {PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI
<< 8), 0xFFFF00)},
40 { /* end: all zeroes */ },
43 MODULE_DEVICE_TABLE(pci
, pci_ids
);
45 static void sdhci_prepare_data(struct sdhci_host
*, struct mmc_data
*);
46 static void sdhci_finish_data(struct sdhci_host
*);
48 static void sdhci_send_command(struct sdhci_host
*, struct mmc_command
*);
49 static void sdhci_finish_command(struct sdhci_host
*);
51 static void sdhci_dumpregs(struct sdhci_host
*host
)
53 printk(KERN_DEBUG DRIVER_NAME
": ============== REGISTER DUMP ==============\n");
55 printk(KERN_DEBUG DRIVER_NAME
": Sys addr: 0x%08x | Version: 0x%08x\n",
56 readl(host
->ioaddr
+ SDHCI_DMA_ADDRESS
),
57 readw(host
->ioaddr
+ SDHCI_HOST_VERSION
));
58 printk(KERN_DEBUG DRIVER_NAME
": Blk size: 0x%08x | Blk cnt: 0x%08x\n",
59 readw(host
->ioaddr
+ SDHCI_BLOCK_SIZE
),
60 readw(host
->ioaddr
+ SDHCI_BLOCK_COUNT
));
61 printk(KERN_DEBUG DRIVER_NAME
": Argument: 0x%08x | Trn mode: 0x%08x\n",
62 readl(host
->ioaddr
+ SDHCI_ARGUMENT
),
63 readw(host
->ioaddr
+ SDHCI_TRANSFER_MODE
));
64 printk(KERN_DEBUG DRIVER_NAME
": Present: 0x%08x | Host ctl: 0x%08x\n",
65 readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
),
66 readb(host
->ioaddr
+ SDHCI_HOST_CONTROL
));
67 printk(KERN_DEBUG DRIVER_NAME
": Power: 0x%08x | Blk gap: 0x%08x\n",
68 readb(host
->ioaddr
+ SDHCI_POWER_CONTROL
),
69 readb(host
->ioaddr
+ SDHCI_BLOCK_GAP_CONTROL
));
70 printk(KERN_DEBUG DRIVER_NAME
": Wake-up: 0x%08x | Clock: 0x%08x\n",
71 readb(host
->ioaddr
+ SDHCI_WALK_UP_CONTROL
),
72 readw(host
->ioaddr
+ SDHCI_CLOCK_CONTROL
));
73 printk(KERN_DEBUG DRIVER_NAME
": Timeout: 0x%08x | Int stat: 0x%08x\n",
74 readb(host
->ioaddr
+ SDHCI_TIMEOUT_CONTROL
),
75 readl(host
->ioaddr
+ SDHCI_INT_STATUS
));
76 printk(KERN_DEBUG DRIVER_NAME
": Int enab: 0x%08x | Sig enab: 0x%08x\n",
77 readl(host
->ioaddr
+ SDHCI_INT_ENABLE
),
78 readl(host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
));
79 printk(KERN_DEBUG DRIVER_NAME
": AC12 err: 0x%08x | Slot int: 0x%08x\n",
80 readw(host
->ioaddr
+ SDHCI_ACMD12_ERR
),
81 readw(host
->ioaddr
+ SDHCI_SLOT_INT_STATUS
));
82 printk(KERN_DEBUG DRIVER_NAME
": Caps: 0x%08x | Max curr: 0x%08x\n",
83 readl(host
->ioaddr
+ SDHCI_CAPABILITIES
),
84 readl(host
->ioaddr
+ SDHCI_MAX_CURRENT
));
86 printk(KERN_DEBUG DRIVER_NAME
": ===========================================\n");
89 /*****************************************************************************\
91 * Low level functions *
93 \*****************************************************************************/
95 static void sdhci_reset(struct sdhci_host
*host
, u8 mask
)
97 writeb(mask
, host
->ioaddr
+ SDHCI_SOFTWARE_RESET
);
99 if (mask
& SDHCI_RESET_ALL
) {
106 static void sdhci_init(struct sdhci_host
*host
)
110 sdhci_reset(host
, SDHCI_RESET_ALL
);
112 intmask
= ~(SDHCI_INT_CARD_INT
| SDHCI_INT_BUF_EMPTY
| SDHCI_INT_BUF_FULL
);
114 writel(intmask
, host
->ioaddr
+ SDHCI_INT_ENABLE
);
115 writel(intmask
, host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
117 /* This is unknown magic. */
118 writeb(0xE, host
->ioaddr
+ SDHCI_TIMEOUT_CONTROL
);
121 static void sdhci_activate_led(struct sdhci_host
*host
)
125 ctrl
= readb(host
->ioaddr
+ SDHCI_HOST_CONTROL
);
126 ctrl
|= SDHCI_CTRL_LED
;
127 writeb(ctrl
, host
->ioaddr
+ SDHCI_HOST_CONTROL
);
130 static void sdhci_deactivate_led(struct sdhci_host
*host
)
134 ctrl
= readb(host
->ioaddr
+ SDHCI_HOST_CONTROL
);
135 ctrl
&= ~SDHCI_CTRL_LED
;
136 writeb(ctrl
, host
->ioaddr
+ SDHCI_HOST_CONTROL
);
139 /*****************************************************************************\
143 \*****************************************************************************/
145 static inline char* sdhci_kmap_sg(struct sdhci_host
* host
)
147 host
->mapped_sg
= kmap_atomic(host
->cur_sg
->page
, KM_BIO_SRC_IRQ
);
148 return host
->mapped_sg
+ host
->cur_sg
->offset
;
151 static inline void sdhci_kunmap_sg(struct sdhci_host
* host
)
153 kunmap_atomic(host
->mapped_sg
, KM_BIO_SRC_IRQ
);
156 static inline int sdhci_next_sg(struct sdhci_host
* host
)
159 * Skip to next SG entry.
167 if (host
->num_sg
> 0) {
169 host
->remain
= host
->cur_sg
->length
;
175 static void sdhci_transfer_pio(struct sdhci_host
*host
)
180 unsigned long max_jiffies
;
184 if (host
->num_sg
== 0)
188 if (host
->data
->flags
& MMC_DATA_READ
)
189 mask
= SDHCI_DATA_AVAILABLE
;
191 mask
= SDHCI_SPACE_AVAILABLE
;
193 buffer
= sdhci_kmap_sg(host
) + host
->offset
;
195 /* Transfer shouldn't take more than 5 s */
196 max_jiffies
= jiffies
+ HZ
* 5;
198 while (host
->size
> 0) {
199 if (time_after(jiffies
, max_jiffies
)) {
200 printk(KERN_ERR
"%s: PIO transfer stalled. "
201 "Please report this to "
202 BUGMAIL
".\n", mmc_hostname(host
->mmc
));
203 sdhci_dumpregs(host
);
205 sdhci_kunmap_sg(host
);
207 host
->data
->error
= MMC_ERR_FAILED
;
208 sdhci_finish_data(host
);
212 if (!(readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
) & mask
))
215 size
= min(host
->size
, host
->remain
);
218 if (host
->data
->flags
& MMC_DATA_READ
)
219 *(u32
*)buffer
= readl(host
->ioaddr
+ SDHCI_BUFFER
);
221 writel(*(u32
*)buffer
, host
->ioaddr
+ SDHCI_BUFFER
);
223 } else if (size
>= 2) {
224 if (host
->data
->flags
& MMC_DATA_READ
)
225 *(u16
*)buffer
= readw(host
->ioaddr
+ SDHCI_BUFFER
);
227 writew(*(u16
*)buffer
, host
->ioaddr
+ SDHCI_BUFFER
);
230 if (host
->data
->flags
& MMC_DATA_READ
)
231 *(u8
*)buffer
= readb(host
->ioaddr
+ SDHCI_BUFFER
);
233 writeb(*(u8
*)buffer
, host
->ioaddr
+ SDHCI_BUFFER
);
238 host
->offset
+= size
;
239 host
->remain
-= size
;
244 if (host
->remain
== 0) {
245 sdhci_kunmap_sg(host
);
246 if (sdhci_next_sg(host
) == 0) {
247 DBG("PIO transfer: %d bytes\n", bytes
);
250 buffer
= sdhci_kmap_sg(host
);
254 sdhci_kunmap_sg(host
);
256 DBG("PIO transfer: %d bytes\n", bytes
);
259 static void sdhci_prepare_data(struct sdhci_host
*host
, struct mmc_data
*data
)
266 writew(0, host
->ioaddr
+ SDHCI_TRANSFER_MODE
);
270 DBG("blksz %04x blks %04x flags %08x\n",
271 data
->blksz
, data
->blocks
, data
->flags
);
272 DBG("tsac %d ms nsac %d clk\n",
273 data
->timeout_ns
/ 1000000, data
->timeout_clks
);
275 mode
= SDHCI_TRNS_BLK_CNT_EN
;
276 if (data
->blocks
> 1)
277 mode
|= SDHCI_TRNS_MULTI
;
278 if (data
->flags
& MMC_DATA_READ
)
279 mode
|= SDHCI_TRNS_READ
;
280 if (host
->flags
& SDHCI_USE_DMA
)
281 mode
|= SDHCI_TRNS_DMA
;
283 writew(mode
, host
->ioaddr
+ SDHCI_TRANSFER_MODE
);
285 writew(data
->blksz
, host
->ioaddr
+ SDHCI_BLOCK_SIZE
);
286 writew(data
->blocks
, host
->ioaddr
+ SDHCI_BLOCK_COUNT
);
288 if (host
->flags
& SDHCI_USE_DMA
) {
291 count
= pci_map_sg(host
->chip
->pdev
, data
->sg
, data
->sg_len
,
292 (data
->flags
& MMC_DATA_READ
)?PCI_DMA_FROMDEVICE
:PCI_DMA_TODEVICE
);
295 writel(sg_dma_address(data
->sg
), host
->ioaddr
+ SDHCI_DMA_ADDRESS
);
297 host
->size
= data
->blksz
* data
->blocks
;
299 host
->cur_sg
= data
->sg
;
300 host
->num_sg
= data
->sg_len
;
303 host
->remain
= host
->cur_sg
->length
;
307 static void sdhci_finish_data(struct sdhci_host
*host
)
309 struct mmc_data
*data
;
318 if (host
->flags
& SDHCI_USE_DMA
) {
319 pci_unmap_sg(host
->chip
->pdev
, data
->sg
, data
->sg_len
,
320 (data
->flags
& MMC_DATA_READ
)?PCI_DMA_FROMDEVICE
:PCI_DMA_TODEVICE
);
322 intmask
= readl(host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
323 intmask
&= ~(SDHCI_INT_BUF_EMPTY
| SDHCI_INT_BUF_FULL
);
324 writel(intmask
, host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
326 intmask
= readl(host
->ioaddr
+ SDHCI_INT_ENABLE
);
327 intmask
&= ~(SDHCI_INT_BUF_EMPTY
| SDHCI_INT_BUF_FULL
);
328 writel(intmask
, host
->ioaddr
+ SDHCI_INT_ENABLE
);
332 * Controller doesn't count down when in single block mode.
334 if ((data
->blocks
== 1) && (data
->error
== MMC_ERR_NONE
))
337 blocks
= readw(host
->ioaddr
+ SDHCI_BLOCK_COUNT
);
338 data
->bytes_xfered
= data
->blksz
* (data
->blocks
- blocks
);
340 if ((data
->error
== MMC_ERR_NONE
) && blocks
) {
341 printk(KERN_ERR
"%s: Controller signalled completion even "
342 "though there were blocks left. Please report this "
343 "to " BUGMAIL
".\n", mmc_hostname(host
->mmc
));
344 data
->error
= MMC_ERR_FAILED
;
347 if (host
->size
!= 0) {
348 printk(KERN_ERR
"%s: %d bytes were left untransferred. "
349 "Please report this to " BUGMAIL
".\n",
350 mmc_hostname(host
->mmc
), host
->size
);
351 data
->error
= MMC_ERR_FAILED
;
354 DBG("Ending data transfer (%d bytes)\n", data
->bytes_xfered
);
358 * The controller needs a reset of internal state machines
359 * upon error conditions.
361 if (data
->error
!= MMC_ERR_NONE
) {
362 sdhci_reset(host
, SDHCI_RESET_CMD
);
363 sdhci_reset(host
, SDHCI_RESET_DATA
);
366 sdhci_send_command(host
, data
->stop
);
368 tasklet_schedule(&host
->finish_tasklet
);
371 static void sdhci_send_command(struct sdhci_host
*host
, struct mmc_command
*cmd
)
374 unsigned long timeout
;
378 DBG("Sending cmd (%x)\n", cmd
->opcode
);
382 while (readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
) &
383 (SDHCI_CMD_INHIBIT
| SDHCI_DATA_INHIBIT
)) {
385 printk(KERN_ERR
"%s: Controller never released "
386 "inhibit bits. Please report this to "
387 BUGMAIL
".\n", mmc_hostname(host
->mmc
));
388 sdhci_dumpregs(host
);
389 cmd
->error
= MMC_ERR_FAILED
;
390 tasklet_schedule(&host
->finish_tasklet
);
397 mod_timer(&host
->timer
, jiffies
+ 10 * HZ
);
401 sdhci_prepare_data(host
, cmd
->data
);
403 writel(cmd
->arg
, host
->ioaddr
+ SDHCI_ARGUMENT
);
405 if ((cmd
->flags
& MMC_RSP_136
) && (cmd
->flags
& MMC_RSP_BUSY
)) {
406 printk(KERN_ERR
"%s: Unsupported response type! "
407 "Please report this to " BUGMAIL
".\n",
408 mmc_hostname(host
->mmc
));
409 cmd
->error
= MMC_ERR_INVALID
;
410 tasklet_schedule(&host
->finish_tasklet
);
414 if (!(cmd
->flags
& MMC_RSP_PRESENT
))
415 flags
= SDHCI_CMD_RESP_NONE
;
416 else if (cmd
->flags
& MMC_RSP_136
)
417 flags
= SDHCI_CMD_RESP_LONG
;
418 else if (cmd
->flags
& MMC_RSP_BUSY
)
419 flags
= SDHCI_CMD_RESP_SHORT_BUSY
;
421 flags
= SDHCI_CMD_RESP_SHORT
;
423 if (cmd
->flags
& MMC_RSP_CRC
)
424 flags
|= SDHCI_CMD_CRC
;
425 if (cmd
->flags
& MMC_RSP_OPCODE
)
426 flags
|= SDHCI_CMD_INDEX
;
428 flags
|= SDHCI_CMD_DATA
;
430 writel(SDHCI_MAKE_CMD(cmd
->opcode
, flags
),
431 host
->ioaddr
+ SDHCI_COMMAND
);
434 static void sdhci_finish_command(struct sdhci_host
*host
)
438 BUG_ON(host
->cmd
== NULL
);
440 if (host
->cmd
->flags
& MMC_RSP_PRESENT
) {
441 if (host
->cmd
->flags
& MMC_RSP_136
) {
442 /* CRC is stripped so we need to do some shifting. */
443 for (i
= 0;i
< 4;i
++) {
444 host
->cmd
->resp
[i
] = readl(host
->ioaddr
+
445 SDHCI_RESPONSE
+ (3-i
)*4) << 8;
447 host
->cmd
->resp
[i
] |=
449 SDHCI_RESPONSE
+ (3-i
)*4-1);
452 host
->cmd
->resp
[0] = readl(host
->ioaddr
+ SDHCI_RESPONSE
);
456 host
->cmd
->error
= MMC_ERR_NONE
;
458 DBG("Ending cmd (%x)\n", host
->cmd
->opcode
);
460 if (host
->cmd
->data
) {
463 host
->data
= host
->cmd
->data
;
465 if (!(host
->flags
& SDHCI_USE_DMA
)) {
467 * Don't enable the interrupts until now to make sure we
468 * get stable handling of the FIFO.
470 intmask
= readl(host
->ioaddr
+ SDHCI_INT_ENABLE
);
471 intmask
|= SDHCI_INT_BUF_EMPTY
| SDHCI_INT_BUF_FULL
;
472 writel(intmask
, host
->ioaddr
+ SDHCI_INT_ENABLE
);
474 intmask
= readl(host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
475 intmask
|= SDHCI_INT_BUF_EMPTY
| SDHCI_INT_BUF_FULL
;
476 writel(intmask
, host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
479 * The buffer interrupts are to unreliable so we
480 * start the transfer immediatly.
482 sdhci_transfer_pio(host
);
485 tasklet_schedule(&host
->finish_tasklet
);
490 static void sdhci_set_clock(struct sdhci_host
*host
, unsigned int clock
)
494 unsigned long timeout
;
496 if (clock
== host
->clock
)
499 writew(0, host
->ioaddr
+ SDHCI_CLOCK_CONTROL
);
504 for (div
= 1;div
< 256;div
*= 2) {
505 if ((host
->max_clk
/ div
) <= clock
)
510 clk
= div
<< SDHCI_DIVIDER_SHIFT
;
511 clk
|= SDHCI_CLOCK_INT_EN
;
512 writew(clk
, host
->ioaddr
+ SDHCI_CLOCK_CONTROL
);
516 while (!((clk
= readw(host
->ioaddr
+ SDHCI_CLOCK_CONTROL
))
517 & SDHCI_CLOCK_INT_STABLE
)) {
519 printk(KERN_ERR
"%s: Internal clock never stabilised. "
520 "Please report this to " BUGMAIL
".\n",
521 mmc_hostname(host
->mmc
));
522 sdhci_dumpregs(host
);
529 clk
|= SDHCI_CLOCK_CARD_EN
;
530 writew(clk
, host
->ioaddr
+ SDHCI_CLOCK_CONTROL
);
536 static void sdhci_set_power(struct sdhci_host
*host
, unsigned short power
)
540 if (host
->power
== power
)
543 writeb(0, host
->ioaddr
+ SDHCI_POWER_CONTROL
);
545 if (power
== (unsigned short)-1)
548 pwr
= SDHCI_POWER_ON
;
554 pwr
|= SDHCI_POWER_180
;
559 pwr
|= SDHCI_POWER_300
;
564 pwr
|= SDHCI_POWER_330
;
570 writeb(pwr
, host
->ioaddr
+ SDHCI_POWER_CONTROL
);
576 /*****************************************************************************\
580 \*****************************************************************************/
582 static void sdhci_request(struct mmc_host
*mmc
, struct mmc_request
*mrq
)
584 struct sdhci_host
*host
;
587 host
= mmc_priv(mmc
);
589 spin_lock_irqsave(&host
->lock
, flags
);
591 WARN_ON(host
->mrq
!= NULL
);
593 sdhci_activate_led(host
);
597 if (!(readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
) & SDHCI_CARD_PRESENT
)) {
598 host
->mrq
->cmd
->error
= MMC_ERR_TIMEOUT
;
599 tasklet_schedule(&host
->finish_tasklet
);
601 sdhci_send_command(host
, mrq
->cmd
);
603 spin_unlock_irqrestore(&host
->lock
, flags
);
606 static void sdhci_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
608 struct sdhci_host
*host
;
612 host
= mmc_priv(mmc
);
614 spin_lock_irqsave(&host
->lock
, flags
);
617 * Reset the chip on each power off.
618 * Should clear out any weird states.
620 if (ios
->power_mode
== MMC_POWER_OFF
) {
621 writel(0, host
->ioaddr
+ SDHCI_SIGNAL_ENABLE
);
622 spin_unlock_irqrestore(&host
->lock
, flags
);
624 spin_lock_irqsave(&host
->lock
, flags
);
627 sdhci_set_clock(host
, ios
->clock
);
629 if (ios
->power_mode
== MMC_POWER_OFF
)
630 sdhci_set_power(host
, -1);
632 sdhci_set_power(host
, ios
->vdd
);
634 ctrl
= readb(host
->ioaddr
+ SDHCI_HOST_CONTROL
);
635 if (ios
->bus_width
== MMC_BUS_WIDTH_4
)
636 ctrl
|= SDHCI_CTRL_4BITBUS
;
638 ctrl
&= ~SDHCI_CTRL_4BITBUS
;
639 writeb(ctrl
, host
->ioaddr
+ SDHCI_HOST_CONTROL
);
641 spin_unlock_irqrestore(&host
->lock
, flags
);
644 static int sdhci_get_ro(struct mmc_host
*mmc
)
646 struct sdhci_host
*host
;
650 host
= mmc_priv(mmc
);
652 spin_lock_irqsave(&host
->lock
, flags
);
654 present
= readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
);
656 spin_unlock_irqrestore(&host
->lock
, flags
);
658 return !(present
& SDHCI_WRITE_PROTECT
);
661 static struct mmc_host_ops sdhci_ops
= {
662 .request
= sdhci_request
,
663 .set_ios
= sdhci_set_ios
,
664 .get_ro
= sdhci_get_ro
,
667 /*****************************************************************************\
671 \*****************************************************************************/
673 static void sdhci_tasklet_card(unsigned long param
)
675 struct sdhci_host
*host
;
678 host
= (struct sdhci_host
*)param
;
680 spin_lock_irqsave(&host
->lock
, flags
);
682 if (!(readl(host
->ioaddr
+ SDHCI_PRESENT_STATE
) & SDHCI_CARD_PRESENT
)) {
684 printk(KERN_ERR
"%s: Card removed during transfer!\n",
685 mmc_hostname(host
->mmc
));
686 printk(KERN_ERR
"%s: Resetting controller.\n",
687 mmc_hostname(host
->mmc
));
689 sdhci_reset(host
, SDHCI_RESET_CMD
);
690 sdhci_reset(host
, SDHCI_RESET_DATA
);
692 host
->mrq
->cmd
->error
= MMC_ERR_FAILED
;
693 tasklet_schedule(&host
->finish_tasklet
);
697 spin_unlock_irqrestore(&host
->lock
, flags
);
699 mmc_detect_change(host
->mmc
, msecs_to_jiffies(500));
702 static void sdhci_tasklet_finish(unsigned long param
)
704 struct sdhci_host
*host
;
706 struct mmc_request
*mrq
;
708 host
= (struct sdhci_host
*)param
;
710 spin_lock_irqsave(&host
->lock
, flags
);
712 del_timer(&host
->timer
);
716 DBG("Ending request, cmd (%x)\n", mrq
->cmd
->opcode
);
719 * The controller needs a reset of internal state machines
720 * upon error conditions.
722 if ((mrq
->cmd
->error
!= MMC_ERR_NONE
) ||
723 (mrq
->data
&& ((mrq
->data
->error
!= MMC_ERR_NONE
) ||
724 (mrq
->data
->stop
&& (mrq
->data
->stop
->error
!= MMC_ERR_NONE
))))) {
725 sdhci_reset(host
, SDHCI_RESET_CMD
);
726 sdhci_reset(host
, SDHCI_RESET_DATA
);
733 sdhci_deactivate_led(host
);
735 spin_unlock_irqrestore(&host
->lock
, flags
);
737 mmc_request_done(host
->mmc
, mrq
);
740 static void sdhci_timeout_timer(unsigned long data
)
742 struct sdhci_host
*host
;
745 host
= (struct sdhci_host
*)data
;
747 spin_lock_irqsave(&host
->lock
, flags
);
750 printk(KERN_ERR
"%s: Timeout waiting for hardware interrupt. "
751 "Please report this to " BUGMAIL
".\n",
752 mmc_hostname(host
->mmc
));
753 sdhci_dumpregs(host
);
756 host
->data
->error
= MMC_ERR_TIMEOUT
;
757 sdhci_finish_data(host
);
760 host
->cmd
->error
= MMC_ERR_TIMEOUT
;
762 host
->mrq
->cmd
->error
= MMC_ERR_TIMEOUT
;
764 tasklet_schedule(&host
->finish_tasklet
);
768 spin_unlock_irqrestore(&host
->lock
, flags
);
771 /*****************************************************************************\
773 * Interrupt handling *
775 \*****************************************************************************/
777 static void sdhci_cmd_irq(struct sdhci_host
*host
, u32 intmask
)
779 BUG_ON(intmask
== 0);
782 printk(KERN_ERR
"%s: Got command interrupt even though no "
783 "command operation was in progress.\n",
784 mmc_hostname(host
->mmc
));
785 printk(KERN_ERR
"%s: Please report this to " BUGMAIL
".\n",
786 mmc_hostname(host
->mmc
));
787 sdhci_dumpregs(host
);
791 if (intmask
& SDHCI_INT_RESPONSE
)
792 sdhci_finish_command(host
);
794 if (intmask
& SDHCI_INT_TIMEOUT
)
795 host
->cmd
->error
= MMC_ERR_TIMEOUT
;
796 else if (intmask
& SDHCI_INT_CRC
)
797 host
->cmd
->error
= MMC_ERR_BADCRC
;
798 else if (intmask
& (SDHCI_INT_END_BIT
| SDHCI_INT_INDEX
))
799 host
->cmd
->error
= MMC_ERR_FAILED
;
801 host
->cmd
->error
= MMC_ERR_INVALID
;
803 tasklet_schedule(&host
->finish_tasklet
);
807 static void sdhci_data_irq(struct sdhci_host
*host
, u32 intmask
)
809 BUG_ON(intmask
== 0);
813 * A data end interrupt is sent together with the response
814 * for the stop command.
816 if (intmask
& SDHCI_INT_DATA_END
)
819 printk(KERN_ERR
"%s: Got data interrupt even though no "
820 "data operation was in progress.\n",
821 mmc_hostname(host
->mmc
));
822 printk(KERN_ERR
"%s: Please report this to " BUGMAIL
".\n",
823 mmc_hostname(host
->mmc
));
824 sdhci_dumpregs(host
);
829 if (intmask
& SDHCI_INT_DATA_TIMEOUT
)
830 host
->data
->error
= MMC_ERR_TIMEOUT
;
831 else if (intmask
& SDHCI_INT_DATA_CRC
)
832 host
->data
->error
= MMC_ERR_BADCRC
;
833 else if (intmask
& SDHCI_INT_DATA_END_BIT
)
834 host
->data
->error
= MMC_ERR_FAILED
;
836 if (host
->data
->error
!= MMC_ERR_NONE
)
837 sdhci_finish_data(host
);
839 if (intmask
& (SDHCI_INT_BUF_FULL
| SDHCI_INT_BUF_EMPTY
))
840 sdhci_transfer_pio(host
);
842 if (intmask
& SDHCI_INT_DATA_END
)
843 sdhci_finish_data(host
);
847 static irqreturn_t
sdhci_irq(int irq
, void *dev_id
, struct pt_regs
*regs
)
850 struct sdhci_host
* host
= dev_id
;
853 spin_lock(&host
->lock
);
855 intmask
= readl(host
->ioaddr
+ SDHCI_INT_STATUS
);
862 DBG("*** %s got interrupt: 0x%08x\n", host
->slot_descr
, intmask
);
864 if (intmask
& (SDHCI_INT_CARD_INSERT
| SDHCI_INT_CARD_REMOVE
))
865 tasklet_schedule(&host
->card_tasklet
);
867 if (intmask
& SDHCI_INT_CMD_MASK
) {
868 sdhci_cmd_irq(host
, intmask
& SDHCI_INT_CMD_MASK
);
870 writel(intmask
& SDHCI_INT_CMD_MASK
,
871 host
->ioaddr
+ SDHCI_INT_STATUS
);
874 if (intmask
& SDHCI_INT_DATA_MASK
) {
875 sdhci_data_irq(host
, intmask
& SDHCI_INT_DATA_MASK
);
877 writel(intmask
& SDHCI_INT_DATA_MASK
,
878 host
->ioaddr
+ SDHCI_INT_STATUS
);
881 intmask
&= ~(SDHCI_INT_CMD_MASK
| SDHCI_INT_DATA_MASK
);
883 if (intmask
& SDHCI_INT_CARD_INT
) {
884 printk(KERN_ERR
"%s: Unexpected card interrupt. Please "
885 "report this to " BUGMAIL
".\n",
886 mmc_hostname(host
->mmc
));
887 sdhci_dumpregs(host
);
890 if (intmask
& SDHCI_INT_BUS_POWER
) {
891 printk(KERN_ERR
"%s: Unexpected bus power interrupt. Please "
892 "report this to " BUGMAIL
".\n",
893 mmc_hostname(host
->mmc
));
894 sdhci_dumpregs(host
);
897 if (intmask
& SDHCI_INT_ACMD12ERR
) {
898 printk(KERN_ERR
"%s: Unexpected auto CMD12 error. Please "
899 "report this to " BUGMAIL
".\n",
900 mmc_hostname(host
->mmc
));
901 sdhci_dumpregs(host
);
903 writew(~0, host
->ioaddr
+ SDHCI_ACMD12_ERR
);
907 writel(intmask
, host
->ioaddr
+ SDHCI_INT_STATUS
);
909 result
= IRQ_HANDLED
;
912 spin_unlock(&host
->lock
);
917 /*****************************************************************************\
921 \*****************************************************************************/
925 static int sdhci_suspend (struct pci_dev
*pdev
, pm_message_t state
)
927 struct sdhci_chip
*chip
;
930 chip
= pci_get_drvdata(pdev
);
934 DBG("Suspending...\n");
936 for (i
= 0;i
< chip
->num_slots
;i
++) {
939 ret
= mmc_suspend_host(chip
->hosts
[i
]->mmc
, state
);
942 mmc_resume_host(chip
->hosts
[i
]->mmc
);
947 pci_save_state(pdev
);
948 pci_enable_wake(pdev
, pci_choose_state(pdev
, state
), 0);
949 pci_disable_device(pdev
);
950 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
955 static int sdhci_resume (struct pci_dev
*pdev
)
957 struct sdhci_chip
*chip
;
960 chip
= pci_get_drvdata(pdev
);
964 DBG("Resuming...\n");
966 pci_set_power_state(pdev
, PCI_D0
);
967 pci_restore_state(pdev
);
968 pci_enable_device(pdev
);
970 for (i
= 0;i
< chip
->num_slots
;i
++) {
973 if (chip
->hosts
[i
]->flags
& SDHCI_USE_DMA
)
974 pci_set_master(pdev
);
975 sdhci_init(chip
->hosts
[i
]);
976 ret
= mmc_resume_host(chip
->hosts
[i
]->mmc
);
984 #else /* CONFIG_PM */
986 #define sdhci_suspend NULL
987 #define sdhci_resume NULL
989 #endif /* CONFIG_PM */
991 /*****************************************************************************\
993 * Device probing/removal *
995 \*****************************************************************************/
997 static int __devinit
sdhci_probe_slot(struct pci_dev
*pdev
, int slot
)
1000 struct sdhci_chip
*chip
;
1001 struct mmc_host
*mmc
;
1002 struct sdhci_host
*host
;
1007 chip
= pci_get_drvdata(pdev
);
1010 ret
= pci_read_config_byte(pdev
, PCI_SLOT_INFO
, &first_bar
);
1014 first_bar
&= PCI_SLOT_INFO_FIRST_BAR_MASK
;
1016 if (first_bar
> 5) {
1017 printk(KERN_ERR DRIVER_NAME
": Invalid first BAR. Aborting.\n");
1021 if (!(pci_resource_flags(pdev
, first_bar
+ slot
) & IORESOURCE_MEM
)) {
1022 printk(KERN_ERR DRIVER_NAME
": BAR is not iomem. Aborting.\n");
1026 if (pci_resource_len(pdev
, first_bar
+ slot
) != 0x100) {
1027 printk(KERN_ERR DRIVER_NAME
": Invalid iomem size. Aborting.\n");
1031 mmc
= mmc_alloc_host(sizeof(struct sdhci_host
), &pdev
->dev
);
1035 host
= mmc_priv(mmc
);
1038 host
->bar
= first_bar
+ slot
;
1040 host
->addr
= pci_resource_start(pdev
, host
->bar
);
1041 host
->irq
= pdev
->irq
;
1043 DBG("slot %d at 0x%08lx, irq %d\n", slot
, host
->addr
, host
->irq
);
1045 snprintf(host
->slot_descr
, 20, "sdhci:slot%d", slot
);
1047 ret
= pci_request_region(pdev
, host
->bar
, host
->slot_descr
);
1051 host
->ioaddr
= ioremap_nocache(host
->addr
,
1052 pci_resource_len(pdev
, host
->bar
));
1053 if (!host
->ioaddr
) {
1058 caps
= readl(host
->ioaddr
+ SDHCI_CAPABILITIES
);
1060 if ((caps
& SDHCI_CAN_DO_DMA
) && ((pdev
->class & 0x0000FF) == 0x01))
1061 host
->flags
|= SDHCI_USE_DMA
;
1063 if (host
->flags
& SDHCI_USE_DMA
) {
1064 if (pci_set_dma_mask(pdev
, DMA_32BIT_MASK
)) {
1065 printk(KERN_WARNING
"%s: No suitable DMA available. "
1066 "Falling back to PIO.\n", host
->slot_descr
);
1067 host
->flags
&= ~SDHCI_USE_DMA
;
1071 if (host
->flags
& SDHCI_USE_DMA
)
1072 pci_set_master(pdev
);
1073 else /* XXX: Hack to get MMC layer to avoid highmem */
1077 (caps
& SDHCI_CLOCK_BASE_MASK
) >> SDHCI_CLOCK_BASE_SHIFT
;
1078 if (host
->max_clk
== 0) {
1079 printk(KERN_ERR
"%s: Hardware doesn't specify base clock "
1080 "frequency.\n", host
->slot_descr
);
1084 host
->max_clk
*= 1000000;
1087 * Set host parameters.
1089 mmc
->ops
= &sdhci_ops
;
1090 mmc
->f_min
= host
->max_clk
/ 256;
1091 mmc
->f_max
= host
->max_clk
;
1092 mmc
->caps
= MMC_CAP_4_BIT_DATA
;
1095 if (caps
& SDHCI_CAN_VDD_330
)
1096 mmc
->ocr_avail
|= MMC_VDD_32_33
|MMC_VDD_33_34
;
1097 else if (caps
& SDHCI_CAN_VDD_300
)
1098 mmc
->ocr_avail
|= MMC_VDD_29_30
|MMC_VDD_30_31
;
1099 else if (caps
& SDHCI_CAN_VDD_180
)
1100 mmc
->ocr_avail
|= MMC_VDD_17_18
|MMC_VDD_18_19
;
1102 if (mmc
->ocr_avail
== 0) {
1103 printk(KERN_ERR
"%s: Hardware doesn't report any "
1104 "support voltages.\n", host
->slot_descr
);
1109 spin_lock_init(&host
->lock
);
1112 * Maximum number of segments. Hardware cannot do scatter lists.
1114 if (host
->flags
& SDHCI_USE_DMA
)
1115 mmc
->max_hw_segs
= 1;
1117 mmc
->max_hw_segs
= 16;
1118 mmc
->max_phys_segs
= 16;
1121 * Maximum number of sectors in one transfer. Limited by sector
1124 mmc
->max_sectors
= 0x3FFF;
1127 * Maximum segment size. Could be one segment with the maximum number
1130 mmc
->max_seg_size
= mmc
->max_sectors
* 512;
1135 tasklet_init(&host
->card_tasklet
,
1136 sdhci_tasklet_card
, (unsigned long)host
);
1137 tasklet_init(&host
->finish_tasklet
,
1138 sdhci_tasklet_finish
, (unsigned long)host
);
1140 setup_timer(&host
->timer
, sdhci_timeout_timer
, (long)host
);
1142 ret
= request_irq(host
->irq
, sdhci_irq
, SA_SHIRQ
,
1143 host
->slot_descr
, host
);
1149 #ifdef CONFIG_MMC_DEBUG
1150 sdhci_dumpregs(host
);
1154 chip
->hosts
[slot
] = host
;
1158 printk(KERN_INFO
"%s: SDHCI at 0x%08lx irq %d %s\n", mmc_hostname(mmc
),
1159 host
->addr
, host
->irq
,
1160 (host
->flags
& SDHCI_USE_DMA
)?"DMA":"PIO");
1165 tasklet_kill(&host
->card_tasklet
);
1166 tasklet_kill(&host
->finish_tasklet
);
1168 iounmap(host
->ioaddr
);
1170 pci_release_region(pdev
, host
->bar
);
1177 static void sdhci_remove_slot(struct pci_dev
*pdev
, int slot
)
1179 struct sdhci_chip
*chip
;
1180 struct mmc_host
*mmc
;
1181 struct sdhci_host
*host
;
1183 chip
= pci_get_drvdata(pdev
);
1184 host
= chip
->hosts
[slot
];
1187 chip
->hosts
[slot
] = NULL
;
1189 mmc_remove_host(mmc
);
1191 sdhci_reset(host
, SDHCI_RESET_ALL
);
1193 free_irq(host
->irq
, host
);
1195 del_timer_sync(&host
->timer
);
1197 tasklet_kill(&host
->card_tasklet
);
1198 tasklet_kill(&host
->finish_tasklet
);
1200 iounmap(host
->ioaddr
);
1202 pci_release_region(pdev
, host
->bar
);
1207 static int __devinit
sdhci_probe(struct pci_dev
*pdev
,
1208 const struct pci_device_id
*ent
)
1212 struct sdhci_chip
*chip
;
1214 BUG_ON(pdev
== NULL
);
1215 BUG_ON(ent
== NULL
);
1217 pci_read_config_byte(pdev
, PCI_CLASS_REVISION
, &rev
);
1219 printk(KERN_INFO DRIVER_NAME
1220 ": SDHCI controller found at %s [%04x:%04x] (rev %x)\n",
1221 pci_name(pdev
), (int)pdev
->vendor
, (int)pdev
->device
,
1224 ret
= pci_read_config_byte(pdev
, PCI_SLOT_INFO
, &slots
);
1228 slots
= PCI_SLOT_INFO_SLOTS(slots
) + 1;
1229 DBG("found %d slot(s)\n", slots
);
1233 ret
= pci_enable_device(pdev
);
1237 chip
= kzalloc(sizeof(struct sdhci_chip
) +
1238 sizeof(struct sdhci_host
*) * slots
, GFP_KERNEL
);
1246 chip
->num_slots
= slots
;
1247 pci_set_drvdata(pdev
, chip
);
1249 for (i
= 0;i
< slots
;i
++) {
1250 ret
= sdhci_probe_slot(pdev
, i
);
1252 for (i
--;i
>= 0;i
--)
1253 sdhci_remove_slot(pdev
, i
);
1261 pci_set_drvdata(pdev
, NULL
);
1265 pci_disable_device(pdev
);
1269 static void __devexit
sdhci_remove(struct pci_dev
*pdev
)
1272 struct sdhci_chip
*chip
;
1274 chip
= pci_get_drvdata(pdev
);
1277 for (i
= 0;i
< chip
->num_slots
;i
++)
1278 sdhci_remove_slot(pdev
, i
);
1280 pci_set_drvdata(pdev
, NULL
);
1285 pci_disable_device(pdev
);
1288 static struct pci_driver sdhci_driver
= {
1289 .name
= DRIVER_NAME
,
1290 .id_table
= pci_ids
,
1291 .probe
= sdhci_probe
,
1292 .remove
= __devexit_p(sdhci_remove
),
1293 .suspend
= sdhci_suspend
,
1294 .resume
= sdhci_resume
,
1297 /*****************************************************************************\
1299 * Driver init/exit *
1301 \*****************************************************************************/
1303 static int __init
sdhci_drv_init(void)
1305 printk(KERN_INFO DRIVER_NAME
1306 ": Secure Digital Host Controller Interface driver, "
1307 DRIVER_VERSION
"\n");
1308 printk(KERN_INFO DRIVER_NAME
": Copyright(c) Pierre Ossman\n");
1310 return pci_register_driver(&sdhci_driver
);
1313 static void __exit
sdhci_drv_exit(void)
1317 pci_unregister_driver(&sdhci_driver
);
1320 module_init(sdhci_drv_init
);
1321 module_exit(sdhci_drv_exit
);
1323 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
1324 MODULE_DESCRIPTION("Secure Digital Host Controller Interface driver");
1325 MODULE_VERSION(DRIVER_VERSION
);
1326 MODULE_LICENSE("GPL");