1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* linux/drivers/mmc/host/sdhci-pci.c - SDHCI on PCI bus interface
4 * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
6 * Thanks to the following companies for their support:
8 * - JMicron (hardware and technical support)
11 #include <linux/bitfield.h>
12 #include <linux/string.h>
13 #include <linux/delay.h>
14 #include <linux/highmem.h>
15 #include <linux/module.h>
16 #include <linux/pci.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/slab.h>
19 #include <linux/device.h>
20 #include <linux/mmc/host.h>
21 #include <linux/mmc/mmc.h>
22 #include <linux/scatterlist.h>
24 #include <linux/gpio.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/mmc/slot-gpio.h>
27 #include <linux/mmc/sdhci-pci-data.h>
28 #include <linux/acpi.h>
31 #include <asm/iosf_mbi.h>
37 #include "sdhci-pci.h"
39 static void sdhci_pci_hw_reset(struct sdhci_host
*host
);
41 #ifdef CONFIG_PM_SLEEP
42 static int sdhci_pci_init_wakeup(struct sdhci_pci_chip
*chip
)
44 mmc_pm_flag_t pm_flags
= 0;
45 bool cap_cd_wake
= false;
48 for (i
= 0; i
< chip
->num_slots
; i
++) {
49 struct sdhci_pci_slot
*slot
= chip
->slots
[i
];
52 pm_flags
|= slot
->host
->mmc
->pm_flags
;
53 if (slot
->host
->mmc
->caps
& MMC_CAP_CD_WAKE
)
58 if ((pm_flags
& MMC_PM_KEEP_POWER
) && (pm_flags
& MMC_PM_WAKE_SDIO_IRQ
))
59 return device_wakeup_enable(&chip
->pdev
->dev
);
60 else if (!cap_cd_wake
)
61 return device_wakeup_disable(&chip
->pdev
->dev
);
66 static int sdhci_pci_suspend_host(struct sdhci_pci_chip
*chip
)
70 sdhci_pci_init_wakeup(chip
);
72 for (i
= 0; i
< chip
->num_slots
; i
++) {
73 struct sdhci_pci_slot
*slot
= chip
->slots
[i
];
74 struct sdhci_host
*host
;
81 if (chip
->pm_retune
&& host
->tuning_mode
!= SDHCI_TUNING_MODE_3
)
82 mmc_retune_needed(host
->mmc
);
84 ret
= sdhci_suspend_host(host
);
88 if (device_may_wakeup(&chip
->pdev
->dev
))
89 mmc_gpio_set_cd_wake(host
->mmc
, true);
96 sdhci_resume_host(chip
->slots
[i
]->host
);
100 int sdhci_pci_resume_host(struct sdhci_pci_chip
*chip
)
102 struct sdhci_pci_slot
*slot
;
105 for (i
= 0; i
< chip
->num_slots
; i
++) {
106 slot
= chip
->slots
[i
];
110 ret
= sdhci_resume_host(slot
->host
);
114 mmc_gpio_set_cd_wake(slot
->host
->mmc
, false);
120 static int sdhci_cqhci_suspend(struct sdhci_pci_chip
*chip
)
124 ret
= cqhci_suspend(chip
->slots
[0]->host
->mmc
);
128 return sdhci_pci_suspend_host(chip
);
131 static int sdhci_cqhci_resume(struct sdhci_pci_chip
*chip
)
135 ret
= sdhci_pci_resume_host(chip
);
139 return cqhci_resume(chip
->slots
[0]->host
->mmc
);
144 static int sdhci_pci_runtime_suspend_host(struct sdhci_pci_chip
*chip
)
146 struct sdhci_pci_slot
*slot
;
147 struct sdhci_host
*host
;
150 for (i
= 0; i
< chip
->num_slots
; i
++) {
151 slot
= chip
->slots
[i
];
157 ret
= sdhci_runtime_suspend_host(host
);
159 goto err_pci_runtime_suspend
;
161 if (chip
->rpm_retune
&&
162 host
->tuning_mode
!= SDHCI_TUNING_MODE_3
)
163 mmc_retune_needed(host
->mmc
);
168 err_pci_runtime_suspend
:
170 sdhci_runtime_resume_host(chip
->slots
[i
]->host
, 0);
174 static int sdhci_pci_runtime_resume_host(struct sdhci_pci_chip
*chip
)
176 struct sdhci_pci_slot
*slot
;
179 for (i
= 0; i
< chip
->num_slots
; i
++) {
180 slot
= chip
->slots
[i
];
184 ret
= sdhci_runtime_resume_host(slot
->host
, 0);
192 static int sdhci_cqhci_runtime_suspend(struct sdhci_pci_chip
*chip
)
196 ret
= cqhci_suspend(chip
->slots
[0]->host
->mmc
);
200 return sdhci_pci_runtime_suspend_host(chip
);
203 static int sdhci_cqhci_runtime_resume(struct sdhci_pci_chip
*chip
)
207 ret
= sdhci_pci_runtime_resume_host(chip
);
211 return cqhci_resume(chip
->slots
[0]->host
->mmc
);
215 static u32
sdhci_cqhci_irq(struct sdhci_host
*host
, u32 intmask
)
220 if (!sdhci_cqe_irq(host
, intmask
, &cmd_error
, &data_error
))
223 cqhci_irq(host
->mmc
, intmask
, cmd_error
, data_error
);
228 static void sdhci_pci_dumpregs(struct mmc_host
*mmc
)
230 sdhci_dumpregs(mmc_priv(mmc
));
233 /*****************************************************************************\
235 * Hardware specific quirk handling *
237 \*****************************************************************************/
239 static int ricoh_probe(struct sdhci_pci_chip
*chip
)
241 if (chip
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_SAMSUNG
||
242 chip
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_SONY
)
243 chip
->quirks
|= SDHCI_QUIRK_NO_CARD_NO_RESET
;
247 static int ricoh_mmc_probe_slot(struct sdhci_pci_slot
*slot
)
250 ((0x21 << SDHCI_TIMEOUT_CLK_SHIFT
)
251 & SDHCI_TIMEOUT_CLK_MASK
) |
253 ((0x21 << SDHCI_CLOCK_BASE_SHIFT
)
254 & SDHCI_CLOCK_BASE_MASK
) |
256 SDHCI_TIMEOUT_CLK_UNIT
|
263 #ifdef CONFIG_PM_SLEEP
264 static int ricoh_mmc_resume(struct sdhci_pci_chip
*chip
)
266 /* Apply a delay to allow controller to settle */
267 /* Otherwise it becomes confused if card state changed
270 return sdhci_pci_resume_host(chip
);
274 static const struct sdhci_pci_fixes sdhci_ricoh
= {
275 .probe
= ricoh_probe
,
276 .quirks
= SDHCI_QUIRK_32BIT_DMA_ADDR
|
277 SDHCI_QUIRK_FORCE_DMA
|
278 SDHCI_QUIRK_CLOCK_BEFORE_RESET
,
281 static const struct sdhci_pci_fixes sdhci_ricoh_mmc
= {
282 .probe_slot
= ricoh_mmc_probe_slot
,
283 #ifdef CONFIG_PM_SLEEP
284 .resume
= ricoh_mmc_resume
,
286 .quirks
= SDHCI_QUIRK_32BIT_DMA_ADDR
|
287 SDHCI_QUIRK_CLOCK_BEFORE_RESET
|
288 SDHCI_QUIRK_NO_CARD_NO_RESET
|
289 SDHCI_QUIRK_MISSING_CAPS
292 static const struct sdhci_pci_fixes sdhci_ene_712
= {
293 .quirks
= SDHCI_QUIRK_SINGLE_POWER_WRITE
|
294 SDHCI_QUIRK_BROKEN_DMA
,
297 static const struct sdhci_pci_fixes sdhci_ene_714
= {
298 .quirks
= SDHCI_QUIRK_SINGLE_POWER_WRITE
|
299 SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS
|
300 SDHCI_QUIRK_BROKEN_DMA
,
303 static const struct sdhci_pci_fixes sdhci_cafe
= {
304 .quirks
= SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER
|
305 SDHCI_QUIRK_NO_BUSY_IRQ
|
306 SDHCI_QUIRK_BROKEN_CARD_DETECTION
|
307 SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
,
310 static const struct sdhci_pci_fixes sdhci_intel_qrk
= {
311 .quirks
= SDHCI_QUIRK_NO_HISPD_BIT
,
314 static int mrst_hc_probe_slot(struct sdhci_pci_slot
*slot
)
316 slot
->host
->mmc
->caps
|= MMC_CAP_8_BIT_DATA
;
321 * ADMA operation is disabled for Moorestown platform due to
324 static int mrst_hc_probe(struct sdhci_pci_chip
*chip
)
327 * slots number is fixed here for MRST as SDIO3/5 are never used and
328 * have hardware bugs.
334 static int pch_hc_probe_slot(struct sdhci_pci_slot
*slot
)
336 slot
->host
->mmc
->caps
|= MMC_CAP_8_BIT_DATA
;
342 static irqreturn_t
sdhci_pci_sd_cd(int irq
, void *dev_id
)
344 struct sdhci_pci_slot
*slot
= dev_id
;
345 struct sdhci_host
*host
= slot
->host
;
347 mmc_detect_change(host
->mmc
, msecs_to_jiffies(200));
351 static void sdhci_pci_add_own_cd(struct sdhci_pci_slot
*slot
)
353 int err
, irq
, gpio
= slot
->cd_gpio
;
355 slot
->cd_gpio
= -EINVAL
;
356 slot
->cd_irq
= -EINVAL
;
358 if (!gpio_is_valid(gpio
))
361 err
= devm_gpio_request(&slot
->chip
->pdev
->dev
, gpio
, "sd_cd");
365 err
= gpio_direction_input(gpio
);
369 irq
= gpio_to_irq(gpio
);
373 err
= request_irq(irq
, sdhci_pci_sd_cd
, IRQF_TRIGGER_RISING
|
374 IRQF_TRIGGER_FALLING
, "sd_cd", slot
);
378 slot
->cd_gpio
= gpio
;
384 devm_gpio_free(&slot
->chip
->pdev
->dev
, gpio
);
386 dev_warn(&slot
->chip
->pdev
->dev
, "failed to setup card detect wake up\n");
389 static void sdhci_pci_remove_own_cd(struct sdhci_pci_slot
*slot
)
391 if (slot
->cd_irq
>= 0)
392 free_irq(slot
->cd_irq
, slot
);
397 static inline void sdhci_pci_add_own_cd(struct sdhci_pci_slot
*slot
)
401 static inline void sdhci_pci_remove_own_cd(struct sdhci_pci_slot
*slot
)
407 static int mfd_emmc_probe_slot(struct sdhci_pci_slot
*slot
)
409 slot
->host
->mmc
->caps
|= MMC_CAP_8_BIT_DATA
| MMC_CAP_NONREMOVABLE
;
410 slot
->host
->mmc
->caps2
|= MMC_CAP2_BOOTPART_NOACC
;
414 static int mfd_sdio_probe_slot(struct sdhci_pci_slot
*slot
)
416 slot
->host
->mmc
->caps
|= MMC_CAP_POWER_OFF_CARD
| MMC_CAP_NONREMOVABLE
;
420 static const struct sdhci_pci_fixes sdhci_intel_mrst_hc0
= {
421 .quirks
= SDHCI_QUIRK_BROKEN_ADMA
| SDHCI_QUIRK_NO_HISPD_BIT
,
422 .probe_slot
= mrst_hc_probe_slot
,
425 static const struct sdhci_pci_fixes sdhci_intel_mrst_hc1_hc2
= {
426 .quirks
= SDHCI_QUIRK_BROKEN_ADMA
| SDHCI_QUIRK_NO_HISPD_BIT
,
427 .probe
= mrst_hc_probe
,
430 static const struct sdhci_pci_fixes sdhci_intel_mfd_sd
= {
431 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
,
432 .allow_runtime_pm
= true,
433 .own_cd_for_runtime_pm
= true,
436 static const struct sdhci_pci_fixes sdhci_intel_mfd_sdio
= {
437 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
,
438 .quirks2
= SDHCI_QUIRK2_HOST_OFF_CARD_ON
,
439 .allow_runtime_pm
= true,
440 .probe_slot
= mfd_sdio_probe_slot
,
443 static const struct sdhci_pci_fixes sdhci_intel_mfd_emmc
= {
444 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
,
445 .allow_runtime_pm
= true,
446 .probe_slot
= mfd_emmc_probe_slot
,
449 static const struct sdhci_pci_fixes sdhci_intel_pch_sdio
= {
450 .quirks
= SDHCI_QUIRK_BROKEN_ADMA
,
451 .probe_slot
= pch_hc_probe_slot
,
456 #define BYT_IOSF_SCCEP 0x63
457 #define BYT_IOSF_OCP_NETCTRL0 0x1078
458 #define BYT_IOSF_OCP_TIMEOUT_BASE GENMASK(10, 8)
460 static void byt_ocp_setting(struct pci_dev
*pdev
)
464 if (pdev
->device
!= PCI_DEVICE_ID_INTEL_BYT_EMMC
&&
465 pdev
->device
!= PCI_DEVICE_ID_INTEL_BYT_SDIO
&&
466 pdev
->device
!= PCI_DEVICE_ID_INTEL_BYT_SD
&&
467 pdev
->device
!= PCI_DEVICE_ID_INTEL_BYT_EMMC2
)
470 if (iosf_mbi_read(BYT_IOSF_SCCEP
, MBI_CR_READ
, BYT_IOSF_OCP_NETCTRL0
,
472 dev_err(&pdev
->dev
, "%s read error\n", __func__
);
476 if (!(val
& BYT_IOSF_OCP_TIMEOUT_BASE
))
479 val
&= ~BYT_IOSF_OCP_TIMEOUT_BASE
;
481 if (iosf_mbi_write(BYT_IOSF_SCCEP
, MBI_CR_WRITE
, BYT_IOSF_OCP_NETCTRL0
,
483 dev_err(&pdev
->dev
, "%s write error\n", __func__
);
487 dev_dbg(&pdev
->dev
, "%s completed\n", __func__
);
492 static inline void byt_ocp_setting(struct pci_dev
*pdev
)
500 INTEL_DSM_V18_SWITCH
= 3,
501 INTEL_DSM_V33_SWITCH
= 4,
502 INTEL_DSM_DRV_STRENGTH
= 9,
503 INTEL_DSM_D3_RETUNE
= 10,
515 static const guid_t intel_dsm_guid
=
516 GUID_INIT(0xF6C13EA5, 0x65CD, 0x461F,
517 0xAB, 0x7A, 0x29, 0xF7, 0xE8, 0xD5, 0xBD, 0x61);
519 static int __intel_dsm(struct intel_host
*intel_host
, struct device
*dev
,
520 unsigned int fn
, u32
*result
)
522 union acpi_object
*obj
;
526 obj
= acpi_evaluate_dsm(ACPI_HANDLE(dev
), &intel_dsm_guid
, 0, fn
, NULL
);
530 if (obj
->type
!= ACPI_TYPE_BUFFER
|| obj
->buffer
.length
< 1) {
535 len
= min_t(size_t, obj
->buffer
.length
, 4);
538 memcpy(result
, obj
->buffer
.pointer
, len
);
545 static int intel_dsm(struct intel_host
*intel_host
, struct device
*dev
,
546 unsigned int fn
, u32
*result
)
548 if (fn
> 31 || !(intel_host
->dsm_fns
& (1 << fn
)))
551 return __intel_dsm(intel_host
, dev
, fn
, result
);
554 static void intel_dsm_init(struct intel_host
*intel_host
, struct device
*dev
,
555 struct mmc_host
*mmc
)
560 intel_host
->d3_retune
= true;
562 err
= __intel_dsm(intel_host
, dev
, INTEL_DSM_FNS
, &intel_host
->dsm_fns
);
564 pr_debug("%s: DSM not supported, error %d\n",
565 mmc_hostname(mmc
), err
);
569 pr_debug("%s: DSM function mask %#x\n",
570 mmc_hostname(mmc
), intel_host
->dsm_fns
);
572 err
= intel_dsm(intel_host
, dev
, INTEL_DSM_DRV_STRENGTH
, &val
);
573 intel_host
->drv_strength
= err
? 0 : val
;
575 err
= intel_dsm(intel_host
, dev
, INTEL_DSM_D3_RETUNE
, &val
);
576 intel_host
->d3_retune
= err
? true : !!val
;
579 static void sdhci_pci_int_hw_reset(struct sdhci_host
*host
)
583 reg
= sdhci_readb(host
, SDHCI_POWER_CONTROL
);
585 sdhci_writeb(host
, reg
, SDHCI_POWER_CONTROL
);
586 /* For eMMC, minimum is 1us but give it 9us for good measure */
589 sdhci_writeb(host
, reg
, SDHCI_POWER_CONTROL
);
590 /* For eMMC, minimum is 200us but give it 300us for good measure */
591 usleep_range(300, 1000);
594 static int intel_select_drive_strength(struct mmc_card
*card
,
595 unsigned int max_dtr
, int host_drv
,
596 int card_drv
, int *drv_type
)
598 struct sdhci_host
*host
= mmc_priv(card
->host
);
599 struct sdhci_pci_slot
*slot
= sdhci_priv(host
);
600 struct intel_host
*intel_host
= sdhci_pci_priv(slot
);
602 return intel_host
->drv_strength
;
605 static int bxt_get_cd(struct mmc_host
*mmc
)
607 int gpio_cd
= mmc_gpio_get_cd(mmc
);
608 struct sdhci_host
*host
= mmc_priv(mmc
);
615 spin_lock_irqsave(&host
->lock
, flags
);
617 if (host
->flags
& SDHCI_DEVICE_DEAD
)
620 ret
= !!(sdhci_readl(host
, SDHCI_PRESENT_STATE
) & SDHCI_CARD_PRESENT
);
622 spin_unlock_irqrestore(&host
->lock
, flags
);
627 #define SDHCI_INTEL_PWR_TIMEOUT_CNT 20
628 #define SDHCI_INTEL_PWR_TIMEOUT_UDELAY 100
630 static void sdhci_intel_set_power(struct sdhci_host
*host
, unsigned char mode
,
636 sdhci_set_power(host
, mode
, vdd
);
638 if (mode
== MMC_POWER_OFF
)
642 * Bus power might not enable after D3 -> D0 transition due to the
643 * present state not yet having propagated. Retry for up to 2ms.
645 for (cntr
= 0; cntr
< SDHCI_INTEL_PWR_TIMEOUT_CNT
; cntr
++) {
646 reg
= sdhci_readb(host
, SDHCI_POWER_CONTROL
);
647 if (reg
& SDHCI_POWER_ON
)
649 udelay(SDHCI_INTEL_PWR_TIMEOUT_UDELAY
);
650 reg
|= SDHCI_POWER_ON
;
651 sdhci_writeb(host
, reg
, SDHCI_POWER_CONTROL
);
655 #define INTEL_HS400_ES_REG 0x78
656 #define INTEL_HS400_ES_BIT BIT(0)
658 static void intel_hs400_enhanced_strobe(struct mmc_host
*mmc
,
661 struct sdhci_host
*host
= mmc_priv(mmc
);
664 val
= sdhci_readl(host
, INTEL_HS400_ES_REG
);
665 if (ios
->enhanced_strobe
)
666 val
|= INTEL_HS400_ES_BIT
;
668 val
&= ~INTEL_HS400_ES_BIT
;
669 sdhci_writel(host
, val
, INTEL_HS400_ES_REG
);
672 static int intel_start_signal_voltage_switch(struct mmc_host
*mmc
,
675 struct device
*dev
= mmc_dev(mmc
);
676 struct sdhci_host
*host
= mmc_priv(mmc
);
677 struct sdhci_pci_slot
*slot
= sdhci_priv(host
);
678 struct intel_host
*intel_host
= sdhci_pci_priv(slot
);
683 err
= sdhci_start_signal_voltage_switch(mmc
, ios
);
687 switch (ios
->signal_voltage
) {
688 case MMC_SIGNAL_VOLTAGE_330
:
689 fn
= INTEL_DSM_V33_SWITCH
;
691 case MMC_SIGNAL_VOLTAGE_180
:
692 fn
= INTEL_DSM_V18_SWITCH
;
698 err
= intel_dsm(intel_host
, dev
, fn
, &result
);
699 pr_debug("%s: %s DSM fn %u error %d result %u\n",
700 mmc_hostname(mmc
), __func__
, fn
, err
, result
);
705 static const struct sdhci_ops sdhci_intel_byt_ops
= {
706 .set_clock
= sdhci_set_clock
,
707 .set_power
= sdhci_intel_set_power
,
708 .enable_dma
= sdhci_pci_enable_dma
,
709 .set_bus_width
= sdhci_set_bus_width
,
710 .reset
= sdhci_reset
,
711 .set_uhs_signaling
= sdhci_set_uhs_signaling
,
712 .hw_reset
= sdhci_pci_hw_reset
,
715 static const struct sdhci_ops sdhci_intel_glk_ops
= {
716 .set_clock
= sdhci_set_clock
,
717 .set_power
= sdhci_intel_set_power
,
718 .enable_dma
= sdhci_pci_enable_dma
,
719 .set_bus_width
= sdhci_set_bus_width
,
720 .reset
= sdhci_reset
,
721 .set_uhs_signaling
= sdhci_set_uhs_signaling
,
722 .hw_reset
= sdhci_pci_hw_reset
,
723 .irq
= sdhci_cqhci_irq
,
726 static void byt_read_dsm(struct sdhci_pci_slot
*slot
)
728 struct intel_host
*intel_host
= sdhci_pci_priv(slot
);
729 struct device
*dev
= &slot
->chip
->pdev
->dev
;
730 struct mmc_host
*mmc
= slot
->host
->mmc
;
732 intel_dsm_init(intel_host
, dev
, mmc
);
733 slot
->chip
->rpm_retune
= intel_host
->d3_retune
;
736 static int intel_execute_tuning(struct mmc_host
*mmc
, u32 opcode
)
738 int err
= sdhci_execute_tuning(mmc
, opcode
);
739 struct sdhci_host
*host
= mmc_priv(mmc
);
745 * Tuning can leave the IP in an active state (Buffer Read Enable bit
746 * set) which prevents the entry to low power states (i.e. S0i3). Data
747 * reset will clear it.
749 sdhci_reset(host
, SDHCI_RESET_DATA
);
754 static void byt_probe_slot(struct sdhci_pci_slot
*slot
)
756 struct mmc_host_ops
*ops
= &slot
->host
->mmc_host_ops
;
757 struct device
*dev
= &slot
->chip
->pdev
->dev
;
758 struct mmc_host
*mmc
= slot
->host
->mmc
;
762 byt_ocp_setting(slot
->chip
->pdev
);
764 ops
->execute_tuning
= intel_execute_tuning
;
765 ops
->start_signal_voltage_switch
= intel_start_signal_voltage_switch
;
767 device_property_read_u32(dev
, "max-frequency", &mmc
->f_max
);
770 static int byt_emmc_probe_slot(struct sdhci_pci_slot
*slot
)
772 byt_probe_slot(slot
);
773 slot
->host
->mmc
->caps
|= MMC_CAP_8_BIT_DATA
| MMC_CAP_NONREMOVABLE
|
774 MMC_CAP_HW_RESET
| MMC_CAP_1_8V_DDR
|
775 MMC_CAP_CMD_DURING_TFR
|
776 MMC_CAP_WAIT_WHILE_BUSY
;
777 slot
->hw_reset
= sdhci_pci_int_hw_reset
;
778 if (slot
->chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_BSW_EMMC
)
779 slot
->host
->timeout_clk
= 1000; /* 1000 kHz i.e. 1 MHz */
780 slot
->host
->mmc_host_ops
.select_drive_strength
=
781 intel_select_drive_strength
;
785 static int glk_emmc_probe_slot(struct sdhci_pci_slot
*slot
)
787 int ret
= byt_emmc_probe_slot(slot
);
789 slot
->host
->mmc
->caps2
|= MMC_CAP2_CQE
;
791 if (slot
->chip
->pdev
->device
!= PCI_DEVICE_ID_INTEL_GLK_EMMC
) {
792 slot
->host
->mmc
->caps2
|= MMC_CAP2_HS400_ES
,
793 slot
->host
->mmc_host_ops
.hs400_enhanced_strobe
=
794 intel_hs400_enhanced_strobe
;
795 slot
->host
->mmc
->caps2
|= MMC_CAP2_CQE_DCMD
;
801 static const struct cqhci_host_ops glk_cqhci_ops
= {
802 .enable
= sdhci_cqe_enable
,
803 .disable
= sdhci_cqe_disable
,
804 .dumpregs
= sdhci_pci_dumpregs
,
807 static int glk_emmc_add_host(struct sdhci_pci_slot
*slot
)
809 struct device
*dev
= &slot
->chip
->pdev
->dev
;
810 struct sdhci_host
*host
= slot
->host
;
811 struct cqhci_host
*cq_host
;
815 ret
= sdhci_setup_host(host
);
819 cq_host
= devm_kzalloc(dev
, sizeof(*cq_host
), GFP_KERNEL
);
825 cq_host
->mmio
= host
->ioaddr
+ 0x200;
826 cq_host
->quirks
|= CQHCI_QUIRK_SHORT_TXFR_DESC_SZ
;
827 cq_host
->ops
= &glk_cqhci_ops
;
829 dma64
= host
->flags
& SDHCI_USE_64_BIT_DMA
;
831 cq_host
->caps
|= CQHCI_TASK_DESC_SZ_128
;
833 ret
= cqhci_init(cq_host
, host
->mmc
, dma64
);
837 ret
= __sdhci_add_host(host
);
844 sdhci_cleanup_host(host
);
849 #define GLK_RX_CTRL1 0x834
850 #define GLK_TUN_VAL 0x840
851 #define GLK_PATH_PLL GENMASK(13, 8)
852 #define GLK_DLY GENMASK(6, 0)
853 /* Workaround firmware failing to restore the tuning value */
854 static void glk_rpm_retune_wa(struct sdhci_pci_chip
*chip
, bool susp
)
856 struct sdhci_pci_slot
*slot
= chip
->slots
[0];
857 struct intel_host
*intel_host
= sdhci_pci_priv(slot
);
858 struct sdhci_host
*host
= slot
->host
;
863 if (intel_host
->rpm_retune_ok
|| !mmc_can_retune(host
->mmc
))
866 glk_rx_ctrl1
= sdhci_readl(host
, GLK_RX_CTRL1
);
867 glk_tun_val
= sdhci_readl(host
, GLK_TUN_VAL
);
870 intel_host
->glk_rx_ctrl1
= glk_rx_ctrl1
;
871 intel_host
->glk_tun_val
= glk_tun_val
;
875 if (!intel_host
->glk_tun_val
)
878 if (glk_rx_ctrl1
!= intel_host
->glk_rx_ctrl1
) {
879 intel_host
->rpm_retune_ok
= true;
883 dly
= FIELD_PREP(GLK_DLY
, FIELD_GET(GLK_PATH_PLL
, glk_rx_ctrl1
) +
884 (intel_host
->glk_tun_val
<< 1));
885 if (dly
== FIELD_GET(GLK_DLY
, glk_rx_ctrl1
))
888 glk_rx_ctrl1
= (glk_rx_ctrl1
& ~GLK_DLY
) | dly
;
889 sdhci_writel(host
, glk_rx_ctrl1
, GLK_RX_CTRL1
);
891 intel_host
->rpm_retune_ok
= true;
892 chip
->rpm_retune
= true;
893 mmc_retune_needed(host
->mmc
);
894 pr_info("%s: Requiring re-tune after rpm resume", mmc_hostname(host
->mmc
));
897 static void glk_rpm_retune_chk(struct sdhci_pci_chip
*chip
, bool susp
)
899 if (chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_GLK_EMMC
&&
901 glk_rpm_retune_wa(chip
, susp
);
904 static int glk_runtime_suspend(struct sdhci_pci_chip
*chip
)
906 glk_rpm_retune_chk(chip
, true);
908 return sdhci_cqhci_runtime_suspend(chip
);
911 static int glk_runtime_resume(struct sdhci_pci_chip
*chip
)
913 glk_rpm_retune_chk(chip
, false);
915 return sdhci_cqhci_runtime_resume(chip
);
920 static int ni_set_max_freq(struct sdhci_pci_slot
*slot
)
923 unsigned long long max_freq
;
925 status
= acpi_evaluate_integer(ACPI_HANDLE(&slot
->chip
->pdev
->dev
),
926 "MXFQ", NULL
, &max_freq
);
927 if (ACPI_FAILURE(status
)) {
928 dev_err(&slot
->chip
->pdev
->dev
,
929 "MXFQ not found in acpi table\n");
933 slot
->host
->mmc
->f_max
= max_freq
* 1000000;
938 static inline int ni_set_max_freq(struct sdhci_pci_slot
*slot
)
944 static int ni_byt_sdio_probe_slot(struct sdhci_pci_slot
*slot
)
948 byt_probe_slot(slot
);
950 err
= ni_set_max_freq(slot
);
954 slot
->host
->mmc
->caps
|= MMC_CAP_POWER_OFF_CARD
| MMC_CAP_NONREMOVABLE
|
955 MMC_CAP_WAIT_WHILE_BUSY
;
959 static int byt_sdio_probe_slot(struct sdhci_pci_slot
*slot
)
961 byt_probe_slot(slot
);
962 slot
->host
->mmc
->caps
|= MMC_CAP_POWER_OFF_CARD
| MMC_CAP_NONREMOVABLE
|
963 MMC_CAP_WAIT_WHILE_BUSY
;
967 static int byt_sd_probe_slot(struct sdhci_pci_slot
*slot
)
969 byt_probe_slot(slot
);
970 slot
->host
->mmc
->caps
|= MMC_CAP_WAIT_WHILE_BUSY
|
971 MMC_CAP_AGGRESSIVE_PM
| MMC_CAP_CD_WAKE
;
973 slot
->cd_override_level
= true;
974 if (slot
->chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_BXT_SD
||
975 slot
->chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_BXTM_SD
||
976 slot
->chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_APL_SD
||
977 slot
->chip
->pdev
->device
== PCI_DEVICE_ID_INTEL_GLK_SD
)
978 slot
->host
->mmc_host_ops
.get_cd
= bxt_get_cd
;
980 if (slot
->chip
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_NI
&&
981 slot
->chip
->pdev
->subsystem_device
== PCI_SUBDEVICE_ID_NI_78E3
)
982 slot
->host
->mmc
->caps2
|= MMC_CAP2_AVOID_3_3V
;
987 #ifdef CONFIG_PM_SLEEP
989 static int byt_resume(struct sdhci_pci_chip
*chip
)
991 byt_ocp_setting(chip
->pdev
);
993 return sdhci_pci_resume_host(chip
);
1000 static int byt_runtime_resume(struct sdhci_pci_chip
*chip
)
1002 byt_ocp_setting(chip
->pdev
);
1004 return sdhci_pci_runtime_resume_host(chip
);
1009 static const struct sdhci_pci_fixes sdhci_intel_byt_emmc
= {
1010 #ifdef CONFIG_PM_SLEEP
1011 .resume
= byt_resume
,
1014 .runtime_resume
= byt_runtime_resume
,
1016 .allow_runtime_pm
= true,
1017 .probe_slot
= byt_emmc_probe_slot
,
1018 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
|
1020 .quirks2
= SDHCI_QUIRK2_PRESET_VALUE_BROKEN
|
1021 SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400
|
1022 SDHCI_QUIRK2_STOP_WITH_TC
,
1023 .ops
= &sdhci_intel_byt_ops
,
1024 .priv_size
= sizeof(struct intel_host
),
1027 static const struct sdhci_pci_fixes sdhci_intel_glk_emmc
= {
1028 .allow_runtime_pm
= true,
1029 .probe_slot
= glk_emmc_probe_slot
,
1030 .add_host
= glk_emmc_add_host
,
1031 #ifdef CONFIG_PM_SLEEP
1032 .suspend
= sdhci_cqhci_suspend
,
1033 .resume
= sdhci_cqhci_resume
,
1036 .runtime_suspend
= glk_runtime_suspend
,
1037 .runtime_resume
= glk_runtime_resume
,
1039 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
|
1041 .quirks2
= SDHCI_QUIRK2_PRESET_VALUE_BROKEN
|
1042 SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400
|
1043 SDHCI_QUIRK2_STOP_WITH_TC
,
1044 .ops
= &sdhci_intel_glk_ops
,
1045 .priv_size
= sizeof(struct intel_host
),
1048 static const struct sdhci_pci_fixes sdhci_ni_byt_sdio
= {
1049 #ifdef CONFIG_PM_SLEEP
1050 .resume
= byt_resume
,
1053 .runtime_resume
= byt_runtime_resume
,
1055 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
|
1057 .quirks2
= SDHCI_QUIRK2_HOST_OFF_CARD_ON
|
1058 SDHCI_QUIRK2_PRESET_VALUE_BROKEN
,
1059 .allow_runtime_pm
= true,
1060 .probe_slot
= ni_byt_sdio_probe_slot
,
1061 .ops
= &sdhci_intel_byt_ops
,
1062 .priv_size
= sizeof(struct intel_host
),
1065 static const struct sdhci_pci_fixes sdhci_intel_byt_sdio
= {
1066 #ifdef CONFIG_PM_SLEEP
1067 .resume
= byt_resume
,
1070 .runtime_resume
= byt_runtime_resume
,
1072 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
|
1074 .quirks2
= SDHCI_QUIRK2_HOST_OFF_CARD_ON
|
1075 SDHCI_QUIRK2_PRESET_VALUE_BROKEN
,
1076 .allow_runtime_pm
= true,
1077 .probe_slot
= byt_sdio_probe_slot
,
1078 .ops
= &sdhci_intel_byt_ops
,
1079 .priv_size
= sizeof(struct intel_host
),
1082 static const struct sdhci_pci_fixes sdhci_intel_byt_sd
= {
1083 #ifdef CONFIG_PM_SLEEP
1084 .resume
= byt_resume
,
1087 .runtime_resume
= byt_runtime_resume
,
1089 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
|
1091 .quirks2
= SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON
|
1092 SDHCI_QUIRK2_PRESET_VALUE_BROKEN
|
1093 SDHCI_QUIRK2_STOP_WITH_TC
,
1094 .allow_runtime_pm
= true,
1095 .own_cd_for_runtime_pm
= true,
1096 .probe_slot
= byt_sd_probe_slot
,
1097 .ops
= &sdhci_intel_byt_ops
,
1098 .priv_size
= sizeof(struct intel_host
),
1101 /* Define Host controllers for Intel Merrifield platform */
1102 #define INTEL_MRFLD_EMMC_0 0
1103 #define INTEL_MRFLD_EMMC_1 1
1104 #define INTEL_MRFLD_SD 2
1105 #define INTEL_MRFLD_SDIO 3
1108 static void intel_mrfld_mmc_fix_up_power_slot(struct sdhci_pci_slot
*slot
)
1110 struct acpi_device
*device
, *child
;
1112 device
= ACPI_COMPANION(&slot
->chip
->pdev
->dev
);
1116 acpi_device_fix_up_power(device
);
1117 list_for_each_entry(child
, &device
->children
, node
)
1118 if (child
->status
.present
&& child
->status
.enabled
)
1119 acpi_device_fix_up_power(child
);
1122 static inline void intel_mrfld_mmc_fix_up_power_slot(struct sdhci_pci_slot
*slot
) {}
1125 static int intel_mrfld_mmc_probe_slot(struct sdhci_pci_slot
*slot
)
1127 unsigned int func
= PCI_FUNC(slot
->chip
->pdev
->devfn
);
1130 case INTEL_MRFLD_EMMC_0
:
1131 case INTEL_MRFLD_EMMC_1
:
1132 slot
->host
->mmc
->caps
|= MMC_CAP_NONREMOVABLE
|
1133 MMC_CAP_8_BIT_DATA
|
1136 case INTEL_MRFLD_SD
:
1137 slot
->host
->quirks2
|= SDHCI_QUIRK2_NO_1_8_V
;
1139 case INTEL_MRFLD_SDIO
:
1140 /* Advertise 2.0v for compatibility with the SDIO card's OCR */
1141 slot
->host
->ocr_mask
= MMC_VDD_20_21
| MMC_VDD_165_195
;
1142 slot
->host
->mmc
->caps
|= MMC_CAP_NONREMOVABLE
|
1143 MMC_CAP_POWER_OFF_CARD
;
1149 intel_mrfld_mmc_fix_up_power_slot(slot
);
1153 static const struct sdhci_pci_fixes sdhci_intel_mrfld_mmc
= {
1154 .quirks
= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
,
1155 .quirks2
= SDHCI_QUIRK2_BROKEN_HS200
|
1156 SDHCI_QUIRK2_PRESET_VALUE_BROKEN
,
1157 .allow_runtime_pm
= true,
1158 .probe_slot
= intel_mrfld_mmc_probe_slot
,
1161 static int jmicron_pmos(struct sdhci_pci_chip
*chip
, int on
)
1166 ret
= pci_read_config_byte(chip
->pdev
, 0xAE, &scratch
);
1171 * Turn PMOS on [bit 0], set over current detection to 2.4 V
1172 * [bit 1:2] and enable over current debouncing [bit 6].
1179 return pci_write_config_byte(chip
->pdev
, 0xAE, scratch
);
1182 static int jmicron_probe(struct sdhci_pci_chip
*chip
)
1187 if (chip
->pdev
->revision
== 0) {
1188 chip
->quirks
|= SDHCI_QUIRK_32BIT_DMA_ADDR
|
1189 SDHCI_QUIRK_32BIT_DMA_SIZE
|
1190 SDHCI_QUIRK_32BIT_ADMA_SIZE
|
1191 SDHCI_QUIRK_RESET_AFTER_REQUEST
|
1192 SDHCI_QUIRK_BROKEN_SMALL_PIO
;
1196 * JMicron chips can have two interfaces to the same hardware
1197 * in order to work around limitations in Microsoft's driver.
1198 * We need to make sure we only bind to one of them.
1200 * This code assumes two things:
1202 * 1. The PCI code adds subfunctions in order.
1204 * 2. The MMC interface has a lower subfunction number
1205 * than the SD interface.
1207 if (chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB38X_SD
)
1208 mmcdev
= PCI_DEVICE_ID_JMICRON_JMB38X_MMC
;
1209 else if (chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_SD
)
1210 mmcdev
= PCI_DEVICE_ID_JMICRON_JMB388_ESD
;
1213 struct pci_dev
*sd_dev
;
1216 while ((sd_dev
= pci_get_device(PCI_VENDOR_ID_JMICRON
,
1217 mmcdev
, sd_dev
)) != NULL
) {
1218 if ((PCI_SLOT(chip
->pdev
->devfn
) ==
1219 PCI_SLOT(sd_dev
->devfn
)) &&
1220 (chip
->pdev
->bus
== sd_dev
->bus
))
1225 pci_dev_put(sd_dev
);
1226 dev_info(&chip
->pdev
->dev
, "Refusing to bind to "
1227 "secondary interface.\n");
1233 * JMicron chips need a bit of a nudge to enable the power
1236 ret
= jmicron_pmos(chip
, 1);
1238 dev_err(&chip
->pdev
->dev
, "Failure enabling card power\n");
1242 /* quirk for unsable RO-detection on JM388 chips */
1243 if (chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_SD
||
1244 chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
)
1245 chip
->quirks
|= SDHCI_QUIRK_UNSTABLE_RO_DETECT
;
1250 static void jmicron_enable_mmc(struct sdhci_host
*host
, int on
)
1254 scratch
= readb(host
->ioaddr
+ 0xC0);
1261 writeb(scratch
, host
->ioaddr
+ 0xC0);
1264 static int jmicron_probe_slot(struct sdhci_pci_slot
*slot
)
1266 if (slot
->chip
->pdev
->revision
== 0) {
1269 version
= readl(slot
->host
->ioaddr
+ SDHCI_HOST_VERSION
);
1270 version
= (version
& SDHCI_VENDOR_VER_MASK
) >>
1271 SDHCI_VENDOR_VER_SHIFT
;
1274 * Older versions of the chip have lots of nasty glitches
1275 * in the ADMA engine. It's best just to avoid it
1279 slot
->host
->quirks
|= SDHCI_QUIRK_BROKEN_ADMA
;
1282 /* JM388 MMC doesn't support 1.8V while SD supports it */
1283 if (slot
->chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
) {
1284 slot
->host
->ocr_avail_sd
= MMC_VDD_32_33
| MMC_VDD_33_34
|
1285 MMC_VDD_29_30
| MMC_VDD_30_31
|
1286 MMC_VDD_165_195
; /* allow 1.8V */
1287 slot
->host
->ocr_avail_mmc
= MMC_VDD_32_33
| MMC_VDD_33_34
|
1288 MMC_VDD_29_30
| MMC_VDD_30_31
; /* no 1.8V for MMC */
1292 * The secondary interface requires a bit set to get the
1295 if (slot
->chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB38X_MMC
||
1296 slot
->chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
)
1297 jmicron_enable_mmc(slot
->host
, 1);
1299 slot
->host
->mmc
->caps
|= MMC_CAP_BUS_WIDTH_TEST
;
1304 static void jmicron_remove_slot(struct sdhci_pci_slot
*slot
, int dead
)
1309 if (slot
->chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB38X_MMC
||
1310 slot
->chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
)
1311 jmicron_enable_mmc(slot
->host
, 0);
1314 #ifdef CONFIG_PM_SLEEP
1315 static int jmicron_suspend(struct sdhci_pci_chip
*chip
)
1319 ret
= sdhci_pci_suspend_host(chip
);
1323 if (chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB38X_MMC
||
1324 chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
) {
1325 for (i
= 0; i
< chip
->num_slots
; i
++)
1326 jmicron_enable_mmc(chip
->slots
[i
]->host
, 0);
1332 static int jmicron_resume(struct sdhci_pci_chip
*chip
)
1336 if (chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB38X_MMC
||
1337 chip
->pdev
->device
== PCI_DEVICE_ID_JMICRON_JMB388_ESD
) {
1338 for (i
= 0; i
< chip
->num_slots
; i
++)
1339 jmicron_enable_mmc(chip
->slots
[i
]->host
, 1);
1342 ret
= jmicron_pmos(chip
, 1);
1344 dev_err(&chip
->pdev
->dev
, "Failure enabling card power\n");
1348 return sdhci_pci_resume_host(chip
);
1352 static const struct sdhci_pci_fixes sdhci_jmicron
= {
1353 .probe
= jmicron_probe
,
1355 .probe_slot
= jmicron_probe_slot
,
1356 .remove_slot
= jmicron_remove_slot
,
1358 #ifdef CONFIG_PM_SLEEP
1359 .suspend
= jmicron_suspend
,
1360 .resume
= jmicron_resume
,
1364 /* SysKonnect CardBus2SDIO extra registers */
1365 #define SYSKT_CTRL 0x200
1366 #define SYSKT_RDFIFO_STAT 0x204
1367 #define SYSKT_WRFIFO_STAT 0x208
1368 #define SYSKT_POWER_DATA 0x20c
1369 #define SYSKT_POWER_330 0xef
1370 #define SYSKT_POWER_300 0xf8
1371 #define SYSKT_POWER_184 0xcc
1372 #define SYSKT_POWER_CMD 0x20d
1373 #define SYSKT_POWER_START (1 << 7)
1374 #define SYSKT_POWER_STATUS 0x20e
1375 #define SYSKT_POWER_STATUS_OK (1 << 0)
1376 #define SYSKT_BOARD_REV 0x210
1377 #define SYSKT_CHIP_REV 0x211
1378 #define SYSKT_CONF_DATA 0x212
1379 #define SYSKT_CONF_DATA_1V8 (1 << 2)
1380 #define SYSKT_CONF_DATA_2V5 (1 << 1)
1381 #define SYSKT_CONF_DATA_3V3 (1 << 0)
1383 static int syskt_probe(struct sdhci_pci_chip
*chip
)
1385 if ((chip
->pdev
->class & 0x0000FF) == PCI_SDHCI_IFVENDOR
) {
1386 chip
->pdev
->class &= ~0x0000FF;
1387 chip
->pdev
->class |= PCI_SDHCI_IFDMA
;
1392 static int syskt_probe_slot(struct sdhci_pci_slot
*slot
)
1396 u8 board_rev
= readb(slot
->host
->ioaddr
+ SYSKT_BOARD_REV
);
1397 u8 chip_rev
= readb(slot
->host
->ioaddr
+ SYSKT_CHIP_REV
);
1398 dev_info(&slot
->chip
->pdev
->dev
, "SysKonnect CardBus2SDIO, "
1399 "board rev %d.%d, chip rev %d.%d\n",
1400 board_rev
>> 4, board_rev
& 0xf,
1401 chip_rev
>> 4, chip_rev
& 0xf);
1402 if (chip_rev
>= 0x20)
1403 slot
->host
->quirks
|= SDHCI_QUIRK_FORCE_DMA
;
1405 writeb(SYSKT_POWER_330
, slot
->host
->ioaddr
+ SYSKT_POWER_DATA
);
1406 writeb(SYSKT_POWER_START
, slot
->host
->ioaddr
+ SYSKT_POWER_CMD
);
1408 tm
= 10; /* Wait max 1 ms */
1410 ps
= readw(slot
->host
->ioaddr
+ SYSKT_POWER_STATUS
);
1411 if (ps
& SYSKT_POWER_STATUS_OK
)
1416 dev_err(&slot
->chip
->pdev
->dev
,
1417 "power regulator never stabilized");
1418 writeb(0, slot
->host
->ioaddr
+ SYSKT_POWER_CMD
);
1425 static const struct sdhci_pci_fixes sdhci_syskt
= {
1426 .quirks
= SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER
,
1427 .probe
= syskt_probe
,
1428 .probe_slot
= syskt_probe_slot
,
1431 static int via_probe(struct sdhci_pci_chip
*chip
)
1433 if (chip
->pdev
->revision
== 0x10)
1434 chip
->quirks
|= SDHCI_QUIRK_DELAY_AFTER_POWER
;
1439 static const struct sdhci_pci_fixes sdhci_via
= {
1443 static int rtsx_probe_slot(struct sdhci_pci_slot
*slot
)
1445 slot
->host
->mmc
->caps2
|= MMC_CAP2_HS200
;
1449 static const struct sdhci_pci_fixes sdhci_rtsx
= {
1450 .quirks2
= SDHCI_QUIRK2_PRESET_VALUE_BROKEN
|
1451 SDHCI_QUIRK2_BROKEN_64_BIT_DMA
|
1452 SDHCI_QUIRK2_BROKEN_DDR50
,
1453 .probe_slot
= rtsx_probe_slot
,
1456 /*AMD chipset generation*/
1457 enum amd_chipset_gen
{
1458 AMD_CHIPSET_BEFORE_ML
,
1461 AMD_CHIPSET_UNKNOWN
,
1465 #define AMD_SD_AUTO_PATTERN 0xB8
1466 #define AMD_MSLEEP_DURATION 4
1467 #define AMD_SD_MISC_CONTROL 0xD0
1468 #define AMD_MAX_TUNE_VALUE 0x0B
1469 #define AMD_AUTO_TUNE_SEL 0x10800
1470 #define AMD_FIFO_PTR 0x30
1471 #define AMD_BIT_MASK 0x1F
1473 static void amd_tuning_reset(struct sdhci_host
*host
)
1477 val
= sdhci_readw(host
, SDHCI_HOST_CONTROL2
);
1478 val
|= SDHCI_CTRL_PRESET_VAL_ENABLE
| SDHCI_CTRL_EXEC_TUNING
;
1479 sdhci_writew(host
, val
, SDHCI_HOST_CONTROL2
);
1481 val
= sdhci_readw(host
, SDHCI_HOST_CONTROL2
);
1482 val
&= ~SDHCI_CTRL_EXEC_TUNING
;
1483 sdhci_writew(host
, val
, SDHCI_HOST_CONTROL2
);
1486 static void amd_config_tuning_phase(struct pci_dev
*pdev
, u8 phase
)
1490 pci_read_config_dword(pdev
, AMD_SD_AUTO_PATTERN
, &val
);
1491 val
&= ~AMD_BIT_MASK
;
1492 val
|= (AMD_AUTO_TUNE_SEL
| (phase
<< 1));
1493 pci_write_config_dword(pdev
, AMD_SD_AUTO_PATTERN
, val
);
1496 static void amd_enable_manual_tuning(struct pci_dev
*pdev
)
1500 pci_read_config_dword(pdev
, AMD_SD_MISC_CONTROL
, &val
);
1501 val
|= AMD_FIFO_PTR
;
1502 pci_write_config_dword(pdev
, AMD_SD_MISC_CONTROL
, val
);
1505 static int amd_execute_tuning_hs200(struct sdhci_host
*host
, u32 opcode
)
1507 struct sdhci_pci_slot
*slot
= sdhci_priv(host
);
1508 struct pci_dev
*pdev
= slot
->chip
->pdev
;
1510 u8 valid_win_max
= 0;
1511 u8 valid_win_end
= 0;
1512 u8 ctrl
, tune_around
;
1514 amd_tuning_reset(host
);
1516 for (tune_around
= 0; tune_around
< 12; tune_around
++) {
1517 amd_config_tuning_phase(pdev
, tune_around
);
1519 if (mmc_send_tuning(host
->mmc
, opcode
, NULL
)) {
1521 msleep(AMD_MSLEEP_DURATION
);
1522 ctrl
= SDHCI_RESET_CMD
| SDHCI_RESET_DATA
;
1523 sdhci_writeb(host
, ctrl
, SDHCI_SOFTWARE_RESET
);
1524 } else if (++valid_win
> valid_win_max
) {
1525 valid_win_max
= valid_win
;
1526 valid_win_end
= tune_around
;
1530 if (!valid_win_max
) {
1531 dev_err(&pdev
->dev
, "no tuning point found\n");
1535 amd_config_tuning_phase(pdev
, valid_win_end
- valid_win_max
/ 2);
1537 amd_enable_manual_tuning(pdev
);
1539 host
->mmc
->retune_period
= 0;
1544 static int amd_execute_tuning(struct mmc_host
*mmc
, u32 opcode
)
1546 struct sdhci_host
*host
= mmc_priv(mmc
);
1548 /* AMD requires custom HS200 tuning */
1549 if (host
->timing
== MMC_TIMING_MMC_HS200
)
1550 return amd_execute_tuning_hs200(host
, opcode
);
1552 /* Otherwise perform standard SDHCI tuning */
1553 return sdhci_execute_tuning(mmc
, opcode
);
1556 static int amd_probe_slot(struct sdhci_pci_slot
*slot
)
1558 struct mmc_host_ops
*ops
= &slot
->host
->mmc_host_ops
;
1560 ops
->execute_tuning
= amd_execute_tuning
;
1565 static int amd_probe(struct sdhci_pci_chip
*chip
)
1567 struct pci_dev
*smbus_dev
;
1568 enum amd_chipset_gen gen
;
1570 smbus_dev
= pci_get_device(PCI_VENDOR_ID_AMD
,
1571 PCI_DEVICE_ID_AMD_HUDSON2_SMBUS
, NULL
);
1573 gen
= AMD_CHIPSET_BEFORE_ML
;
1575 smbus_dev
= pci_get_device(PCI_VENDOR_ID_AMD
,
1576 PCI_DEVICE_ID_AMD_KERNCZ_SMBUS
, NULL
);
1578 if (smbus_dev
->revision
< 0x51)
1579 gen
= AMD_CHIPSET_CZ
;
1581 gen
= AMD_CHIPSET_NL
;
1583 gen
= AMD_CHIPSET_UNKNOWN
;
1587 if (gen
== AMD_CHIPSET_BEFORE_ML
|| gen
== AMD_CHIPSET_CZ
)
1588 chip
->quirks2
|= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD
;
1593 static const struct sdhci_ops amd_sdhci_pci_ops
= {
1594 .set_clock
= sdhci_set_clock
,
1595 .enable_dma
= sdhci_pci_enable_dma
,
1596 .set_bus_width
= sdhci_set_bus_width
,
1597 .reset
= sdhci_reset
,
1598 .set_uhs_signaling
= sdhci_set_uhs_signaling
,
1601 static const struct sdhci_pci_fixes sdhci_amd
= {
1603 .ops
= &amd_sdhci_pci_ops
,
1604 .probe_slot
= amd_probe_slot
,
1607 static const struct pci_device_id pci_ids
[] = {
1608 SDHCI_PCI_DEVICE(RICOH
, R5C822
, ricoh
),
1609 SDHCI_PCI_DEVICE(RICOH
, R5C843
, ricoh_mmc
),
1610 SDHCI_PCI_DEVICE(RICOH
, R5CE822
, ricoh_mmc
),
1611 SDHCI_PCI_DEVICE(RICOH
, R5CE823
, ricoh_mmc
),
1612 SDHCI_PCI_DEVICE(ENE
, CB712_SD
, ene_712
),
1613 SDHCI_PCI_DEVICE(ENE
, CB712_SD_2
, ene_712
),
1614 SDHCI_PCI_DEVICE(ENE
, CB714_SD
, ene_714
),
1615 SDHCI_PCI_DEVICE(ENE
, CB714_SD_2
, ene_714
),
1616 SDHCI_PCI_DEVICE(MARVELL
, 88ALP01_SD
, cafe
),
1617 SDHCI_PCI_DEVICE(JMICRON
, JMB38X_SD
, jmicron
),
1618 SDHCI_PCI_DEVICE(JMICRON
, JMB38X_MMC
, jmicron
),
1619 SDHCI_PCI_DEVICE(JMICRON
, JMB388_SD
, jmicron
),
1620 SDHCI_PCI_DEVICE(JMICRON
, JMB388_ESD
, jmicron
),
1621 SDHCI_PCI_DEVICE(SYSKONNECT
, 8000, syskt
),
1622 SDHCI_PCI_DEVICE(VIA
, 95D0
, via
),
1623 SDHCI_PCI_DEVICE(REALTEK
, 5250, rtsx
),
1624 SDHCI_PCI_DEVICE(INTEL
, QRK_SD
, intel_qrk
),
1625 SDHCI_PCI_DEVICE(INTEL
, MRST_SD0
, intel_mrst_hc0
),
1626 SDHCI_PCI_DEVICE(INTEL
, MRST_SD1
, intel_mrst_hc1_hc2
),
1627 SDHCI_PCI_DEVICE(INTEL
, MRST_SD2
, intel_mrst_hc1_hc2
),
1628 SDHCI_PCI_DEVICE(INTEL
, MFD_SD
, intel_mfd_sd
),
1629 SDHCI_PCI_DEVICE(INTEL
, MFD_SDIO1
, intel_mfd_sdio
),
1630 SDHCI_PCI_DEVICE(INTEL
, MFD_SDIO2
, intel_mfd_sdio
),
1631 SDHCI_PCI_DEVICE(INTEL
, MFD_EMMC0
, intel_mfd_emmc
),
1632 SDHCI_PCI_DEVICE(INTEL
, MFD_EMMC1
, intel_mfd_emmc
),
1633 SDHCI_PCI_DEVICE(INTEL
, PCH_SDIO0
, intel_pch_sdio
),
1634 SDHCI_PCI_DEVICE(INTEL
, PCH_SDIO1
, intel_pch_sdio
),
1635 SDHCI_PCI_DEVICE(INTEL
, BYT_EMMC
, intel_byt_emmc
),
1636 SDHCI_PCI_SUBDEVICE(INTEL
, BYT_SDIO
, NI
, 7884, ni_byt_sdio
),
1637 SDHCI_PCI_DEVICE(INTEL
, BYT_SDIO
, intel_byt_sdio
),
1638 SDHCI_PCI_DEVICE(INTEL
, BYT_SD
, intel_byt_sd
),
1639 SDHCI_PCI_DEVICE(INTEL
, BYT_EMMC2
, intel_byt_emmc
),
1640 SDHCI_PCI_DEVICE(INTEL
, BSW_EMMC
, intel_byt_emmc
),
1641 SDHCI_PCI_DEVICE(INTEL
, BSW_SDIO
, intel_byt_sdio
),
1642 SDHCI_PCI_DEVICE(INTEL
, BSW_SD
, intel_byt_sd
),
1643 SDHCI_PCI_DEVICE(INTEL
, CLV_SDIO0
, intel_mfd_sd
),
1644 SDHCI_PCI_DEVICE(INTEL
, CLV_SDIO1
, intel_mfd_sdio
),
1645 SDHCI_PCI_DEVICE(INTEL
, CLV_SDIO2
, intel_mfd_sdio
),
1646 SDHCI_PCI_DEVICE(INTEL
, CLV_EMMC0
, intel_mfd_emmc
),
1647 SDHCI_PCI_DEVICE(INTEL
, CLV_EMMC1
, intel_mfd_emmc
),
1648 SDHCI_PCI_DEVICE(INTEL
, MRFLD_MMC
, intel_mrfld_mmc
),
1649 SDHCI_PCI_DEVICE(INTEL
, SPT_EMMC
, intel_byt_emmc
),
1650 SDHCI_PCI_DEVICE(INTEL
, SPT_SDIO
, intel_byt_sdio
),
1651 SDHCI_PCI_DEVICE(INTEL
, SPT_SD
, intel_byt_sd
),
1652 SDHCI_PCI_DEVICE(INTEL
, DNV_EMMC
, intel_byt_emmc
),
1653 SDHCI_PCI_DEVICE(INTEL
, CDF_EMMC
, intel_glk_emmc
),
1654 SDHCI_PCI_DEVICE(INTEL
, BXT_EMMC
, intel_byt_emmc
),
1655 SDHCI_PCI_DEVICE(INTEL
, BXT_SDIO
, intel_byt_sdio
),
1656 SDHCI_PCI_DEVICE(INTEL
, BXT_SD
, intel_byt_sd
),
1657 SDHCI_PCI_DEVICE(INTEL
, BXTM_EMMC
, intel_byt_emmc
),
1658 SDHCI_PCI_DEVICE(INTEL
, BXTM_SDIO
, intel_byt_sdio
),
1659 SDHCI_PCI_DEVICE(INTEL
, BXTM_SD
, intel_byt_sd
),
1660 SDHCI_PCI_DEVICE(INTEL
, APL_EMMC
, intel_byt_emmc
),
1661 SDHCI_PCI_DEVICE(INTEL
, APL_SDIO
, intel_byt_sdio
),
1662 SDHCI_PCI_DEVICE(INTEL
, APL_SD
, intel_byt_sd
),
1663 SDHCI_PCI_DEVICE(INTEL
, GLK_EMMC
, intel_glk_emmc
),
1664 SDHCI_PCI_DEVICE(INTEL
, GLK_SDIO
, intel_byt_sdio
),
1665 SDHCI_PCI_DEVICE(INTEL
, GLK_SD
, intel_byt_sd
),
1666 SDHCI_PCI_DEVICE(INTEL
, CNP_EMMC
, intel_glk_emmc
),
1667 SDHCI_PCI_DEVICE(INTEL
, CNP_SD
, intel_byt_sd
),
1668 SDHCI_PCI_DEVICE(INTEL
, CNPH_SD
, intel_byt_sd
),
1669 SDHCI_PCI_DEVICE(INTEL
, ICP_EMMC
, intel_glk_emmc
),
1670 SDHCI_PCI_DEVICE(INTEL
, ICP_SD
, intel_byt_sd
),
1671 SDHCI_PCI_DEVICE(INTEL
, EHL_EMMC
, intel_glk_emmc
),
1672 SDHCI_PCI_DEVICE(INTEL
, EHL_SD
, intel_byt_sd
),
1673 SDHCI_PCI_DEVICE(INTEL
, CML_EMMC
, intel_glk_emmc
),
1674 SDHCI_PCI_DEVICE(INTEL
, CML_SD
, intel_byt_sd
),
1675 SDHCI_PCI_DEVICE(O2
, 8120, o2
),
1676 SDHCI_PCI_DEVICE(O2
, 8220, o2
),
1677 SDHCI_PCI_DEVICE(O2
, 8221, o2
),
1678 SDHCI_PCI_DEVICE(O2
, 8320, o2
),
1679 SDHCI_PCI_DEVICE(O2
, 8321, o2
),
1680 SDHCI_PCI_DEVICE(O2
, FUJIN2
, o2
),
1681 SDHCI_PCI_DEVICE(O2
, SDS0
, o2
),
1682 SDHCI_PCI_DEVICE(O2
, SDS1
, o2
),
1683 SDHCI_PCI_DEVICE(O2
, SEABIRD0
, o2
),
1684 SDHCI_PCI_DEVICE(O2
, SEABIRD1
, o2
),
1685 SDHCI_PCI_DEVICE(ARASAN
, PHY_EMMC
, arasan
),
1686 SDHCI_PCI_DEVICE(SYNOPSYS
, DWC_MSHC
, snps
),
1687 SDHCI_PCI_DEVICE_CLASS(AMD
, SYSTEM_SDHCI
, PCI_CLASS_MASK
, amd
),
1688 /* Generic SD host controller */
1689 {PCI_DEVICE_CLASS(SYSTEM_SDHCI
, PCI_CLASS_MASK
)},
1690 { /* end: all zeroes */ },
1693 MODULE_DEVICE_TABLE(pci
, pci_ids
);
1695 /*****************************************************************************\
1697 * SDHCI core callbacks *
1699 \*****************************************************************************/
1701 int sdhci_pci_enable_dma(struct sdhci_host
*host
)
1703 struct sdhci_pci_slot
*slot
;
1704 struct pci_dev
*pdev
;
1706 slot
= sdhci_priv(host
);
1707 pdev
= slot
->chip
->pdev
;
1709 if (((pdev
->class & 0xFFFF00) == (PCI_CLASS_SYSTEM_SDHCI
<< 8)) &&
1710 ((pdev
->class & 0x0000FF) != PCI_SDHCI_IFDMA
) &&
1711 (host
->flags
& SDHCI_USE_SDMA
)) {
1712 dev_warn(&pdev
->dev
, "Will use DMA mode even though HW "
1713 "doesn't fully claim to support it.\n");
1716 pci_set_master(pdev
);
1721 static void sdhci_pci_gpio_hw_reset(struct sdhci_host
*host
)
1723 struct sdhci_pci_slot
*slot
= sdhci_priv(host
);
1724 int rst_n_gpio
= slot
->rst_n_gpio
;
1726 if (!gpio_is_valid(rst_n_gpio
))
1728 gpio_set_value_cansleep(rst_n_gpio
, 0);
1729 /* For eMMC, minimum is 1us but give it 10us for good measure */
1731 gpio_set_value_cansleep(rst_n_gpio
, 1);
1732 /* For eMMC, minimum is 200us but give it 300us for good measure */
1733 usleep_range(300, 1000);
1736 static void sdhci_pci_hw_reset(struct sdhci_host
*host
)
1738 struct sdhci_pci_slot
*slot
= sdhci_priv(host
);
1741 slot
->hw_reset(host
);
1744 static const struct sdhci_ops sdhci_pci_ops
= {
1745 .set_clock
= sdhci_set_clock
,
1746 .enable_dma
= sdhci_pci_enable_dma
,
1747 .set_bus_width
= sdhci_set_bus_width
,
1748 .reset
= sdhci_reset
,
1749 .set_uhs_signaling
= sdhci_set_uhs_signaling
,
1750 .hw_reset
= sdhci_pci_hw_reset
,
1753 /*****************************************************************************\
1757 \*****************************************************************************/
1759 #ifdef CONFIG_PM_SLEEP
1760 static int sdhci_pci_suspend(struct device
*dev
)
1762 struct pci_dev
*pdev
= to_pci_dev(dev
);
1763 struct sdhci_pci_chip
*chip
= pci_get_drvdata(pdev
);
1768 if (chip
->fixes
&& chip
->fixes
->suspend
)
1769 return chip
->fixes
->suspend(chip
);
1771 return sdhci_pci_suspend_host(chip
);
1774 static int sdhci_pci_resume(struct device
*dev
)
1776 struct pci_dev
*pdev
= to_pci_dev(dev
);
1777 struct sdhci_pci_chip
*chip
= pci_get_drvdata(pdev
);
1782 if (chip
->fixes
&& chip
->fixes
->resume
)
1783 return chip
->fixes
->resume(chip
);
1785 return sdhci_pci_resume_host(chip
);
1790 static int sdhci_pci_runtime_suspend(struct device
*dev
)
1792 struct pci_dev
*pdev
= to_pci_dev(dev
);
1793 struct sdhci_pci_chip
*chip
= pci_get_drvdata(pdev
);
1798 if (chip
->fixes
&& chip
->fixes
->runtime_suspend
)
1799 return chip
->fixes
->runtime_suspend(chip
);
1801 return sdhci_pci_runtime_suspend_host(chip
);
1804 static int sdhci_pci_runtime_resume(struct device
*dev
)
1806 struct pci_dev
*pdev
= to_pci_dev(dev
);
1807 struct sdhci_pci_chip
*chip
= pci_get_drvdata(pdev
);
1812 if (chip
->fixes
&& chip
->fixes
->runtime_resume
)
1813 return chip
->fixes
->runtime_resume(chip
);
1815 return sdhci_pci_runtime_resume_host(chip
);
1819 static const struct dev_pm_ops sdhci_pci_pm_ops
= {
1820 SET_SYSTEM_SLEEP_PM_OPS(sdhci_pci_suspend
, sdhci_pci_resume
)
1821 SET_RUNTIME_PM_OPS(sdhci_pci_runtime_suspend
,
1822 sdhci_pci_runtime_resume
, NULL
)
1825 /*****************************************************************************\
1827 * Device probing/removal *
1829 \*****************************************************************************/
1831 static struct sdhci_pci_slot
*sdhci_pci_probe_slot(
1832 struct pci_dev
*pdev
, struct sdhci_pci_chip
*chip
, int first_bar
,
1835 struct sdhci_pci_slot
*slot
;
1836 struct sdhci_host
*host
;
1837 int ret
, bar
= first_bar
+ slotno
;
1838 size_t priv_size
= chip
->fixes
? chip
->fixes
->priv_size
: 0;
1840 if (!(pci_resource_flags(pdev
, bar
) & IORESOURCE_MEM
)) {
1841 dev_err(&pdev
->dev
, "BAR %d is not iomem. Aborting.\n", bar
);
1842 return ERR_PTR(-ENODEV
);
1845 if (pci_resource_len(pdev
, bar
) < 0x100) {
1846 dev_err(&pdev
->dev
, "Invalid iomem size. You may "
1847 "experience problems.\n");
1850 if ((pdev
->class & 0x0000FF) == PCI_SDHCI_IFVENDOR
) {
1851 dev_err(&pdev
->dev
, "Vendor specific interface. Aborting.\n");
1852 return ERR_PTR(-ENODEV
);
1855 if ((pdev
->class & 0x0000FF) > PCI_SDHCI_IFVENDOR
) {
1856 dev_err(&pdev
->dev
, "Unknown interface. Aborting.\n");
1857 return ERR_PTR(-ENODEV
);
1860 host
= sdhci_alloc_host(&pdev
->dev
, sizeof(*slot
) + priv_size
);
1862 dev_err(&pdev
->dev
, "cannot allocate host\n");
1863 return ERR_CAST(host
);
1866 slot
= sdhci_priv(host
);
1870 slot
->rst_n_gpio
= -EINVAL
;
1871 slot
->cd_gpio
= -EINVAL
;
1874 /* Retrieve platform data if there is any */
1875 if (*sdhci_pci_get_data
)
1876 slot
->data
= sdhci_pci_get_data(pdev
, slotno
);
1879 if (slot
->data
->setup
) {
1880 ret
= slot
->data
->setup(slot
->data
);
1882 dev_err(&pdev
->dev
, "platform setup failed\n");
1886 slot
->rst_n_gpio
= slot
->data
->rst_n_gpio
;
1887 slot
->cd_gpio
= slot
->data
->cd_gpio
;
1890 host
->hw_name
= "PCI";
1891 host
->ops
= chip
->fixes
&& chip
->fixes
->ops
?
1894 host
->quirks
= chip
->quirks
;
1895 host
->quirks2
= chip
->quirks2
;
1897 host
->irq
= pdev
->irq
;
1899 ret
= pcim_iomap_regions(pdev
, BIT(bar
), mmc_hostname(host
->mmc
));
1901 dev_err(&pdev
->dev
, "cannot request region\n");
1905 host
->ioaddr
= pcim_iomap_table(pdev
)[bar
];
1907 if (chip
->fixes
&& chip
->fixes
->probe_slot
) {
1908 ret
= chip
->fixes
->probe_slot(slot
);
1913 if (gpio_is_valid(slot
->rst_n_gpio
)) {
1914 if (!devm_gpio_request(&pdev
->dev
, slot
->rst_n_gpio
, "eMMC_reset")) {
1915 gpio_direction_output(slot
->rst_n_gpio
, 1);
1916 slot
->host
->mmc
->caps
|= MMC_CAP_HW_RESET
;
1917 slot
->hw_reset
= sdhci_pci_gpio_hw_reset
;
1919 dev_warn(&pdev
->dev
, "failed to request rst_n_gpio\n");
1920 slot
->rst_n_gpio
= -EINVAL
;
1924 host
->mmc
->pm_caps
= MMC_PM_KEEP_POWER
;
1925 host
->mmc
->slotno
= slotno
;
1926 host
->mmc
->caps2
|= MMC_CAP2_NO_PRESCAN_POWERUP
;
1928 if (device_can_wakeup(&pdev
->dev
))
1929 host
->mmc
->pm_caps
|= MMC_PM_WAKE_SDIO_IRQ
;
1931 if (host
->mmc
->caps
& MMC_CAP_CD_WAKE
)
1932 device_init_wakeup(&pdev
->dev
, true);
1934 if (slot
->cd_idx
>= 0) {
1935 ret
= mmc_gpiod_request_cd(host
->mmc
, "cd", slot
->cd_idx
,
1936 slot
->cd_override_level
, 0, NULL
);
1937 if (ret
&& ret
!= -EPROBE_DEFER
)
1938 ret
= mmc_gpiod_request_cd(host
->mmc
, NULL
,
1940 slot
->cd_override_level
,
1942 if (ret
== -EPROBE_DEFER
)
1946 dev_warn(&pdev
->dev
, "failed to setup card detect gpio\n");
1951 if (chip
->fixes
&& chip
->fixes
->add_host
)
1952 ret
= chip
->fixes
->add_host(slot
);
1954 ret
= sdhci_add_host(host
);
1958 sdhci_pci_add_own_cd(slot
);
1961 * Check if the chip needs a separate GPIO for card detect to wake up
1962 * from runtime suspend. If it is not there, don't allow runtime PM.
1963 * Note sdhci_pci_add_own_cd() sets slot->cd_gpio to -EINVAL on failure.
1965 if (chip
->fixes
&& chip
->fixes
->own_cd_for_runtime_pm
&&
1966 !gpio_is_valid(slot
->cd_gpio
) && slot
->cd_idx
< 0)
1967 chip
->allow_runtime_pm
= false;
1972 if (chip
->fixes
&& chip
->fixes
->remove_slot
)
1973 chip
->fixes
->remove_slot(slot
, 0);
1976 if (slot
->data
&& slot
->data
->cleanup
)
1977 slot
->data
->cleanup(slot
->data
);
1980 sdhci_free_host(host
);
1982 return ERR_PTR(ret
);
1985 static void sdhci_pci_remove_slot(struct sdhci_pci_slot
*slot
)
1990 sdhci_pci_remove_own_cd(slot
);
1993 scratch
= readl(slot
->host
->ioaddr
+ SDHCI_INT_STATUS
);
1994 if (scratch
== (u32
)-1)
1997 sdhci_remove_host(slot
->host
, dead
);
1999 if (slot
->chip
->fixes
&& slot
->chip
->fixes
->remove_slot
)
2000 slot
->chip
->fixes
->remove_slot(slot
, dead
);
2002 if (slot
->data
&& slot
->data
->cleanup
)
2003 slot
->data
->cleanup(slot
->data
);
2005 sdhci_free_host(slot
->host
);
2008 static void sdhci_pci_runtime_pm_allow(struct device
*dev
)
2010 pm_suspend_ignore_children(dev
, 1);
2011 pm_runtime_set_autosuspend_delay(dev
, 50);
2012 pm_runtime_use_autosuspend(dev
);
2013 pm_runtime_allow(dev
);
2014 /* Stay active until mmc core scans for a card */
2015 pm_runtime_put_noidle(dev
);
2018 static void sdhci_pci_runtime_pm_forbid(struct device
*dev
)
2020 pm_runtime_forbid(dev
);
2021 pm_runtime_get_noresume(dev
);
2024 static int sdhci_pci_probe(struct pci_dev
*pdev
,
2025 const struct pci_device_id
*ent
)
2027 struct sdhci_pci_chip
*chip
;
2028 struct sdhci_pci_slot
*slot
;
2030 u8 slots
, first_bar
;
2033 BUG_ON(pdev
== NULL
);
2034 BUG_ON(ent
== NULL
);
2036 dev_info(&pdev
->dev
, "SDHCI controller found [%04x:%04x] (rev %x)\n",
2037 (int)pdev
->vendor
, (int)pdev
->device
, (int)pdev
->revision
);
2039 ret
= pci_read_config_byte(pdev
, PCI_SLOT_INFO
, &slots
);
2043 slots
= PCI_SLOT_INFO_SLOTS(slots
) + 1;
2044 dev_dbg(&pdev
->dev
, "found %d slot(s)\n", slots
);
2046 BUG_ON(slots
> MAX_SLOTS
);
2048 ret
= pci_read_config_byte(pdev
, PCI_SLOT_INFO
, &first_bar
);
2052 first_bar
&= PCI_SLOT_INFO_FIRST_BAR_MASK
;
2054 if (first_bar
> 5) {
2055 dev_err(&pdev
->dev
, "Invalid first BAR. Aborting.\n");
2059 ret
= pcim_enable_device(pdev
);
2063 chip
= devm_kzalloc(&pdev
->dev
, sizeof(*chip
), GFP_KERNEL
);
2068 chip
->fixes
= (const struct sdhci_pci_fixes
*)ent
->driver_data
;
2070 chip
->quirks
= chip
->fixes
->quirks
;
2071 chip
->quirks2
= chip
->fixes
->quirks2
;
2072 chip
->allow_runtime_pm
= chip
->fixes
->allow_runtime_pm
;
2074 chip
->num_slots
= slots
;
2075 chip
->pm_retune
= true;
2076 chip
->rpm_retune
= true;
2078 pci_set_drvdata(pdev
, chip
);
2080 if (chip
->fixes
&& chip
->fixes
->probe
) {
2081 ret
= chip
->fixes
->probe(chip
);
2086 slots
= chip
->num_slots
; /* Quirk may have changed this */
2088 for (i
= 0; i
< slots
; i
++) {
2089 slot
= sdhci_pci_probe_slot(pdev
, chip
, first_bar
, i
);
2091 for (i
--; i
>= 0; i
--)
2092 sdhci_pci_remove_slot(chip
->slots
[i
]);
2093 return PTR_ERR(slot
);
2096 chip
->slots
[i
] = slot
;
2099 if (chip
->allow_runtime_pm
)
2100 sdhci_pci_runtime_pm_allow(&pdev
->dev
);
2105 static void sdhci_pci_remove(struct pci_dev
*pdev
)
2108 struct sdhci_pci_chip
*chip
= pci_get_drvdata(pdev
);
2110 if (chip
->allow_runtime_pm
)
2111 sdhci_pci_runtime_pm_forbid(&pdev
->dev
);
2113 for (i
= 0; i
< chip
->num_slots
; i
++)
2114 sdhci_pci_remove_slot(chip
->slots
[i
]);
2117 static struct pci_driver sdhci_driver
= {
2118 .name
= "sdhci-pci",
2119 .id_table
= pci_ids
,
2120 .probe
= sdhci_pci_probe
,
2121 .remove
= sdhci_pci_remove
,
2123 .pm
= &sdhci_pci_pm_ops
2127 module_pci_driver(sdhci_driver
);
2129 MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
2130 MODULE_DESCRIPTION("Secure Digital Host Controller Interface PCI driver");
2131 MODULE_LICENSE("GPL");