[linux-2.6-block.git] / drivers / mmc / host / sdhci-pci.c

/*  linux/drivers/mmc/host/sdhci-pci.c - SDHCI on PCI bus interface
 *
 *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * Thanks to the following companies for their support:
 *
 *     - JMicron (hardware and technical support)
 */

#include <linux/delay.h>
#include <linux/highmem.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>

#include <linux/mmc/host.h>

#include <asm/scatterlist.h>
#include <asm/io.h>

#include "sdhci.h"

/*
 * PCI registers
 */

#define PCI_SDHCI_IFPIO			0x00
#define PCI_SDHCI_IFDMA			0x01
#define PCI_SDHCI_IFVENDOR		0x02

#define PCI_SLOT_INFO			0x40	/* 8 bits */
#define  PCI_SLOT_INFO_SLOTS(x)		((x >> 4) & 7)
#define  PCI_SLOT_INFO_FIRST_BAR_MASK	0x07

#define MAX_SLOTS			8

struct sdhci_pci_chip;

struct sdhci_pci_fixes {
	unsigned int		quirks;

	int			(*probe)(struct sdhci_pci_chip*);
};

struct sdhci_pci_slot {
	struct sdhci_pci_chip	*chip;
	struct sdhci_host	*host;

	int			pci_bar;
};

struct sdhci_pci_chip {
	struct pci_dev		*pdev;

	unsigned int		quirks;
	const struct sdhci_pci_fixes *fixes;

	int			num_slots;	/* Slots on controller */
	struct sdhci_pci_slot	*slots[MAX_SLOTS]; /* Pointers to host slots */
};


/*****************************************************************************\
 *                                                                           *
 * Hardware specific quirk handling                                          *
 *                                                                           *
\*****************************************************************************/

static int ricoh_probe(struct sdhci_pci_chip *chip)
{
	if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
		chip->quirks |= SDHCI_QUIRK_CLOCK_BEFORE_RESET;

	if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG)
		chip->quirks |= SDHCI_QUIRK_NO_CARD_NO_RESET;

	return 0;
}

static const struct sdhci_pci_fixes sdhci_ricoh = {
	.probe		= ricoh_probe,
};

static const struct sdhci_pci_fixes sdhci_ene_712 = {
	.quirks		= SDHCI_QUIRK_SINGLE_POWER_WRITE |
			  SDHCI_QUIRK_BROKEN_DMA,
};

static const struct sdhci_pci_fixes sdhci_ene_714 = {
	.quirks		= SDHCI_QUIRK_SINGLE_POWER_WRITE |
			  SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS |
			  SDHCI_QUIRK_BROKEN_DMA,
};

static const struct sdhci_pci_fixes sdhci_cafe = {
	.quirks		= SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
			  SDHCI_QUIRK_INCR_TIMEOUT_CONTROL,
};

static const struct sdhci_pci_fixes sdhci_jmicron = {
	.quirks		= SDHCI_QUIRK_32BIT_DMA_ADDR |
			  SDHCI_QUIRK_32BIT_DMA_SIZE |
			  SDHCI_QUIRK_RESET_AFTER_REQUEST,
};

static const struct pci_device_id pci_ids[] __devinitdata = {
	{
		.vendor		= PCI_VENDOR_ID_RICOH,
		.device		= PCI_DEVICE_ID_RICOH_R5C822,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_ricoh,
	},

	{
		.vendor		= PCI_VENDOR_ID_ENE,
		.device		= PCI_DEVICE_ID_ENE_CB712_SD,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_ene_712,
	},

	{
		.vendor		= PCI_VENDOR_ID_ENE,
		.device		= PCI_DEVICE_ID_ENE_CB712_SD_2,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_ene_712,
	},

	{
		.vendor		= PCI_VENDOR_ID_ENE,
		.device		= PCI_DEVICE_ID_ENE_CB714_SD,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_ene_714,
	},

	{
		.vendor		= PCI_VENDOR_ID_ENE,
		.device		= PCI_DEVICE_ID_ENE_CB714_SD_2,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_ene_714,
	},

	{
		.vendor         = PCI_VENDOR_ID_MARVELL,
		.device         = PCI_DEVICE_ID_MARVELL_CAFE_SD,
		.subvendor      = PCI_ANY_ID,
		.subdevice      = PCI_ANY_ID,
		.driver_data    = (kernel_ulong_t)&sdhci_cafe,
	},

	{
		.vendor		= PCI_VENDOR_ID_JMICRON,
		.device		= PCI_DEVICE_ID_JMICRON_JMB38X_SD,
		.subvendor	= PCI_ANY_ID,
		.subdevice	= PCI_ANY_ID,
		.driver_data	= (kernel_ulong_t)&sdhci_jmicron,
	},

	{	/* Generic SD host controller */
		PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)
	},

	{ /* end: all zeroes */ },
};

MODULE_DEVICE_TABLE(pci, pci_ids);

/*****************************************************************************\
 *                                                                           *
 * SDHCI core callbacks                                                      *
 *                                                                           *
\*****************************************************************************/

static int sdhci_pci_enable_dma(struct sdhci_host *host)
{
	struct sdhci_pci_slot *slot;
	struct pci_dev *pdev;
	int ret;

	slot = sdhci_priv(host);
	pdev = slot->chip->pdev;

	if (((pdev->class & 0xFFFF00) == (PCI_CLASS_SYSTEM_SDHCI << 8)) &&
		((pdev->class & 0x0000FF) != PCI_SDHCI_IFDMA) &&
		(host->flags & SDHCI_USE_DMA)) {
		dev_warn(&pdev->dev, "Will use DMA mode even though HW "
			"doesn't fully claim to support it.\n");
	}

	ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	if (ret)
		return ret;

	pci_set_master(pdev);

	return 0;
}

static struct sdhci_ops sdhci_pci_ops = {
	.enable_dma	= sdhci_pci_enable_dma,
};

/*****************************************************************************\
 *                                                                           *
 * Suspend/resume                                                            *
 *                                                                           *
\*****************************************************************************/

#ifdef CONFIG_PM

static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
{
	struct sdhci_pci_chip *chip;
	struct sdhci_pci_slot *slot;
	int i, ret;

	chip = pci_get_drvdata(pdev);
	if (!chip)
		return 0;

	for (i = 0;i < chip->num_slots;i++) {
		slot = chip->slots[i];
		if (!slot)
			continue;

		ret = sdhci_suspend_host(slot->host, state);

		if (ret) {
			for (i--;i >= 0;i--)
				sdhci_resume_host(chip->slots[i]->host);
			return ret;
		}
	}

	pci_save_state(pdev);
	pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));

	return 0;
}

static int sdhci_pci_resume (struct pci_dev *pdev)
{
	struct sdhci_pci_chip *chip;
	struct sdhci_pci_slot *slot;
	int i, ret;

	chip = pci_get_drvdata(pdev);
	if (!chip)
		return 0;

	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;

	for (i = 0;i < chip->num_slots;i++) {
		slot = chip->slots[i];
		if (!slot)
			continue;

		ret = sdhci_resume_host(slot->host);
		if (ret)
			return ret;
	}

	return 0;
}

#else /* CONFIG_PM */

#define sdhci_pci_suspend NULL
#define sdhci_pci_resume NULL

#endif /* CONFIG_PM */

/*****************************************************************************\
 *                                                                           *
 * Device probing/removal                                                    *
 *                                                                           *
\*****************************************************************************/

static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
	struct pci_dev *pdev, struct sdhci_pci_chip *chip, int bar)
{
	struct sdhci_pci_slot *slot;
	struct sdhci_host *host;

	resource_size_t addr;

	int ret;

	if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
		dev_err(&pdev->dev, "BAR %d is not iomem. Aborting.\n", bar);
		return ERR_PTR(-ENODEV);
	}

	if (pci_resource_len(pdev, bar) != 0x100) {
		dev_err(&pdev->dev, "Invalid iomem size. You may "
			"experience problems.\n");
	}

	if ((pdev->class & 0x0000FF) == PCI_SDHCI_IFVENDOR) {
		dev_err(&pdev->dev, "Vendor specific interface. Aborting.\n");
		return ERR_PTR(-ENODEV);
	}

	if ((pdev->class & 0x0000FF) > PCI_SDHCI_IFVENDOR) {
		dev_err(&pdev->dev, "Unknown interface. Aborting.\n");
		return ERR_PTR(-ENODEV);
	}

	host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pci_slot));
	if (IS_ERR(host)) {
		ret = PTR_ERR(host);
		goto unmap;
	}

	slot = sdhci_priv(host);

	slot->chip = chip;
	slot->host = host;
	slot->pci_bar = bar;

	host->hw_name = "PCI";
	host->ops = &sdhci_pci_ops;
	host->quirks = chip->quirks;

	host->irq = pdev->irq;

	ret = pci_request_region(pdev, bar, mmc_hostname(host->mmc));
	if (ret) {
		dev_err(&pdev->dev, "cannot request region\n");
		return ERR_PTR(ret);
	}

	addr = pci_resource_start(pdev, bar);
	host->ioaddr = ioremap_nocache(addr, pci_resource_len(pdev, bar));
	if (!host->ioaddr) {
		dev_err(&pdev->dev, "failed to remap registers\n");
		goto release;
	}

	ret = sdhci_add_host(host);
	if (ret)
		goto unmap;

	return slot;

unmap:
	iounmap(host->ioaddr);

release:
	pci_release_region(pdev, bar);
	sdhci_free_host(host);

	return ERR_PTR(ret);
}

static void sdhci_pci_remove_slot(struct sdhci_pci_slot *slot)
{
	sdhci_remove_host(slot->host);
	pci_release_region(slot->chip->pdev, slot->pci_bar);
	sdhci_free_host(slot->host);
}

static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
				     const struct pci_device_id *ent)
{
	struct sdhci_pci_chip *chip;
	struct sdhci_pci_slot *slot;

	u8 slots, rev, first_bar;
	int ret, i;

	BUG_ON(pdev == NULL);
	BUG_ON(ent == NULL);

	pci_read_config_byte(pdev, PCI_CLASS_REVISION, &rev);

	dev_info(&pdev->dev, "SDHCI controller found [%04x:%04x] (rev %x)\n",
		 (int)pdev->vendor, (int)pdev->device, (int)rev);

	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
	if (ret)
		return ret;

	slots = PCI_SLOT_INFO_SLOTS(slots) + 1;
	dev_dbg(&pdev->dev, "found %d slot(s)\n", slots);
	if (slots == 0)
		return -ENODEV;

	BUG_ON(slots > MAX_SLOTS);

	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &first_bar);
	if (ret)
		return ret;

	first_bar &= PCI_SLOT_INFO_FIRST_BAR_MASK;

	if (first_bar > 5) {
		dev_err(&pdev->dev, "Invalid first BAR. Aborting.\n");
		return -ENODEV;
	}

	ret = pci_enable_device(pdev);
	if (ret)
		return ret;

	chip = kzalloc(sizeof(struct sdhci_pci_chip), GFP_KERNEL);
	if (!chip) {
		ret = -ENOMEM;
		goto err;
	}

	chip->pdev = pdev;
	chip->fixes = (const struct sdhci_pci_fixes*)ent->driver_data;
	if (chip->fixes)
		chip->quirks = chip->fixes->quirks;
	chip->num_slots = slots;

	pci_set_drvdata(pdev, chip);

	if (chip->fixes && chip->fixes->probe) {
		ret = chip->fixes->probe(chip);
		if (ret)
			goto free;
	}

	for (i = 0;i < slots;i++) {
		slot = sdhci_pci_probe_slot(pdev, chip, first_bar + i);
		if (IS_ERR(slot)) {
			for (i--;i >= 0;i--)
				sdhci_pci_remove_slot(chip->slots[i]);
			ret = PTR_ERR(slot);
			goto free;
		}

		chip->slots[i] = slot;
	}

	return 0;

free:
	pci_set_drvdata(pdev, NULL);
	kfree(chip);

err:
	pci_disable_device(pdev);
	return ret;
}

static void __devexit sdhci_pci_remove(struct pci_dev *pdev)
{
	int i;
	struct sdhci_pci_chip *chip;

	chip = pci_get_drvdata(pdev);

	if (chip) {
		for (i = 0;i < chip->num_slots; i++)
			sdhci_pci_remove_slot(chip->slots[i]);

		pci_set_drvdata(pdev, NULL);
		kfree(chip);
	}

	pci_disable_device(pdev);
}

static struct pci_driver sdhci_driver = {
	.name = 	"sdhci-pci",
	.id_table =	pci_ids,
	.probe = 	sdhci_pci_probe,
	.remove =	__devexit_p(sdhci_pci_remove),
	.suspend =	sdhci_pci_suspend,
	.resume	=	sdhci_pci_resume,
};

/*****************************************************************************\
 *                                                                           *
 * Driver init/exit                                                          *
 *                                                                           *
\*****************************************************************************/

static int __init sdhci_drv_init(void)
{
	return pci_register_driver(&sdhci_driver);
}

static void __exit sdhci_drv_exit(void)
{
	pci_unregister_driver(&sdhci_driver);
}

module_init(sdhci_drv_init);
module_exit(sdhci_drv_exit);

MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
MODULE_DESCRIPTION("Secure Digital Host Controller Interface PCI driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
b8c86fc5 PO	1	/* linux/drivers/mmc/host/sdhci-pci.c - SDHCI on PCI bus interface
	2	*
	3	* Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or (at
	8	* your option) any later version.
	9	*
	10	* Thanks to the following companies for their support:
	11	*
	12	* - JMicron (hardware and technical support)
	13	*/
	14
	15	#include <linux/delay.h>
	16	#include <linux/highmem.h>
	17	#include <linux/pci.h>
	18	#include <linux/dma-mapping.h>
	19
	20	#include <linux/mmc/host.h>
	21
	22	#include <asm/scatterlist.h>
	23	#include <asm/io.h>
	24
	25	#include "sdhci.h"
	26
	27	/*
	28	* PCI registers
	29	*/
	30
	31	#define PCI_SDHCI_IFPIO 0x00
	32	#define PCI_SDHCI_IFDMA 0x01
	33	#define PCI_SDHCI_IFVENDOR 0x02
	34
	35	#define PCI_SLOT_INFO 0x40 /* 8 bits */
	36	#define PCI_SLOT_INFO_SLOTS(x) ((x >> 4) & 7)
	37	#define PCI_SLOT_INFO_FIRST_BAR_MASK 0x07
	38
	39	#define MAX_SLOTS 8
	40
22606405 PO	41	struct sdhci_pci_chip;
	42
	43	struct sdhci_pci_fixes {
	44	unsigned int quirks;
	45
	46	int (probe)(struct sdhci_pci_chip);
	47	};
	48
	49	struct sdhci_pci_slot {
	50	struct sdhci_pci_chip *chip;
	51	struct sdhci_host *host;
b8c86fc5	52
22606405 PO	53	int pci_bar;
	54	};
	55
	56	struct sdhci_pci_chip {
	57	struct pci_dev *pdev;
	58
	59	unsigned int quirks;
	60	const struct sdhci_pci_fixes *fixes;
	61
	62	int num_slots; /* Slots on controller */
	63	struct sdhci_pci_slot slots[MAX_SLOTS]; / Pointers to host slots */
	64	};
	65
	66
	67	/*****************************************************************************\
	68	* *
	69	* Hardware specific quirk handling *
	70	* *
	71	\*****************************************************************************/
	72
	73	static int ricoh_probe(struct sdhci_pci_chip *chip)
	74	{
	75	if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
	76	chip->quirks \|= SDHCI_QUIRK_CLOCK_BEFORE_RESET;
	77
	78	if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG)
	79	chip->quirks \|= SDHCI_QUIRK_NO_CARD_NO_RESET;
	80
	81	return 0;
	82	}
	83
	84	static const struct sdhci_pci_fixes sdhci_ricoh = {
	85	.probe = ricoh_probe,
	86	};
	87
	88	static const struct sdhci_pci_fixes sdhci_ene_712 = {
	89	.quirks = SDHCI_QUIRK_SINGLE_POWER_WRITE \|
	90	SDHCI_QUIRK_BROKEN_DMA,
	91	};
	92
	93	static const struct sdhci_pci_fixes sdhci_ene_714 = {
	94	.quirks = SDHCI_QUIRK_SINGLE_POWER_WRITE \|
	95	SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS \|
	96	SDHCI_QUIRK_BROKEN_DMA,
	97	};
	98
	99	static const struct sdhci_pci_fixes sdhci_cafe = {
	100	.quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER \|
	101	SDHCI_QUIRK_INCR_TIMEOUT_CONTROL,
	102	};
	103
	104	static const struct sdhci_pci_fixes sdhci_jmicron = {
	105	.quirks = SDHCI_QUIRK_32BIT_DMA_ADDR \|
	106	SDHCI_QUIRK_32BIT_DMA_SIZE \|
	107	SDHCI_QUIRK_RESET_AFTER_REQUEST,
	108	};
	109
	110	static const struct pci_device_id pci_ids[] __devinitdata = {
b8c86fc5 PO	111	{
	112	.vendor = PCI_VENDOR_ID_RICOH,
	113	.device = PCI_DEVICE_ID_RICOH_R5C822,
22606405	114	.subvendor = PCI_ANY_ID,
b8c86fc5	115	.subdevice = PCI_ANY_ID,
22606405	116	.driver_data = (kernel_ulong_t)&sdhci_ricoh,
b8c86fc5 PO	117	},
	118
	119	{
	120	.vendor = PCI_VENDOR_ID_ENE,
	121	.device = PCI_DEVICE_ID_ENE_CB712_SD,
	122	.subvendor = PCI_ANY_ID,
	123	.subdevice = PCI_ANY_ID,
22606405	124	.driver_data = (kernel_ulong_t)&sdhci_ene_712,
b8c86fc5 PO	125	},
	126
	127	{
	128	.vendor = PCI_VENDOR_ID_ENE,
	129	.device = PCI_DEVICE_ID_ENE_CB712_SD_2,
	130	.subvendor = PCI_ANY_ID,
	131	.subdevice = PCI_ANY_ID,
22606405	132	.driver_data = (kernel_ulong_t)&sdhci_ene_712,
b8c86fc5 PO	133	},
	134
	135	{
	136	.vendor = PCI_VENDOR_ID_ENE,
	137	.device = PCI_DEVICE_ID_ENE_CB714_SD,
	138	.subvendor = PCI_ANY_ID,
	139	.subdevice = PCI_ANY_ID,
22606405	140	.driver_data = (kernel_ulong_t)&sdhci_ene_714,
b8c86fc5 PO	141	},
	142
	143	{
	144	.vendor = PCI_VENDOR_ID_ENE,
	145	.device = PCI_DEVICE_ID_ENE_CB714_SD_2,
	146	.subvendor = PCI_ANY_ID,
	147	.subdevice = PCI_ANY_ID,
22606405	148	.driver_data = (kernel_ulong_t)&sdhci_ene_714,
b8c86fc5 PO	149	},
	150
	151	{
	152	.vendor = PCI_VENDOR_ID_MARVELL,
	153	.device = PCI_DEVICE_ID_MARVELL_CAFE_SD,
	154	.subvendor = PCI_ANY_ID,
	155	.subdevice = PCI_ANY_ID,
22606405	156	.driver_data = (kernel_ulong_t)&sdhci_cafe,
b8c86fc5 PO	157	},
	158
	159	{
	160	.vendor = PCI_VENDOR_ID_JMICRON,
	161	.device = PCI_DEVICE_ID_JMICRON_JMB38X_SD,
	162	.subvendor = PCI_ANY_ID,
	163	.subdevice = PCI_ANY_ID,
22606405	164	.driver_data = (kernel_ulong_t)&sdhci_jmicron,
b8c86fc5 PO	165	},
	166
	167	{ /* Generic SD host controller */
	168	PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)
	169	},
	170
	171	{ /* end: all zeroes */ },
	172	};
	173
	174	MODULE_DEVICE_TABLE(pci, pci_ids);
	175
b8c86fc5 PO	176	/*****************************************************************************\
	177	* *
	178	* SDHCI core callbacks *
	179	* *
	180	\*****************************************************************************/
	181
	182	static int sdhci_pci_enable_dma(struct sdhci_host *host)
	183	{
	184	struct sdhci_pci_slot *slot;
	185	struct pci_dev *pdev;
	186	int ret;
	187
	188	slot = sdhci_priv(host);
	189	pdev = slot->chip->pdev;
	190
	191	if (((pdev->class & 0xFFFF00) == (PCI_CLASS_SYSTEM_SDHCI << 8)) &&
	192	((pdev->class & 0x0000FF) != PCI_SDHCI_IFDMA) &&
	193	(host->flags & SDHCI_USE_DMA)) {
	194	dev_warn(&pdev->dev, "Will use DMA mode even though HW "
	195	"doesn't fully claim to support it.\n");
	196	}
	197
	198	ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	199	if (ret)
	200	return ret;
	201
	202	pci_set_master(pdev);
	203
	204	return 0;
	205	}
	206
	207	static struct sdhci_ops sdhci_pci_ops = {
	208	.enable_dma = sdhci_pci_enable_dma,
	209	};
	210
	211	/*****************************************************************************\
	212	* *
	213	* Suspend/resume *
	214	* *
	215	\*****************************************************************************/
	216
	217	#ifdef CONFIG_PM
	218
	219	static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
	220	{
	221	struct sdhci_pci_chip *chip;
	222	struct sdhci_pci_slot *slot;
	223	int i, ret;
	224
	225	chip = pci_get_drvdata(pdev);
	226	if (!chip)
	227	return 0;
	228
	229	for (i = 0;i < chip->num_slots;i++) {
	230	slot = chip->slots[i];
	231	if (!slot)
	232	continue;
	233
	234	ret = sdhci_suspend_host(slot->host, state);
	235
	236	if (ret) {
	237	for (i--;i >= 0;i--)
	238	sdhci_resume_host(chip->slots[i]->host);
	239	return ret;
240	}
241	}
242
243	pci_save_state(pdev);
244	pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
245	pci_disable_device(pdev);
246	pci_set_power_state(pdev, pci_choose_state(pdev, state));
247
248	return 0;
249	}
250
251	static int sdhci_pci_resume (struct pci_dev *pdev)
252	{
253	struct sdhci_pci_chip *chip;
254	struct sdhci_pci_slot *slot;
255	int i, ret;
256
257	chip = pci_get_drvdata(pdev);
258	if (!chip)
259	return 0;
260
261	pci_set_power_state(pdev, PCI_D0);
262	pci_restore_state(pdev);
263	ret = pci_enable_device(pdev);
264	if (ret)
265	return ret;
266
267	for (i = 0;i < chip->num_slots;i++) {
268	slot = chip->slots[i];
269	if (!slot)
270	continue;
271
272	ret = sdhci_resume_host(slot->host);
273	if (ret)
274	return ret;
275	}
276
277	return 0;
278	}
279
280	#else /* CONFIG_PM */
281
282	#define sdhci_pci_suspend NULL
283	#define sdhci_pci_resume NULL
284
285	#endif /* CONFIG_PM */
286
287	/*****************************************************************************\
288	* *
289	* Device probing/removal *
290	* *
291	\*****************************************************************************/
292
293	static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
294	struct pci_dev pdev, struct sdhci_pci_chip chip, int bar)
295	{
296	struct sdhci_pci_slot *slot;
297	struct sdhci_host *host;
298
299	resource_size_t addr;
300
301	int ret;
302
303	if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
304	dev_err(&pdev->dev, "BAR %d is not iomem. Aborting.\n", bar);
305	return ERR_PTR(-ENODEV);
306	}
307
308	if (pci_resource_len(pdev, bar) != 0x100) {
309	dev_err(&pdev->dev, "Invalid iomem size. You may "
310	"experience problems.\n");
311	}
312
313	if ((pdev->class & 0x0000FF) == PCI_SDHCI_IFVENDOR) {
314	dev_err(&pdev->dev, "Vendor specific interface. Aborting.\n");
315	return ERR_PTR(-ENODEV);
316	}
317
318	if ((pdev->class & 0x0000FF) > PCI_SDHCI_IFVENDOR) {
319	dev_err(&pdev->dev, "Unknown interface. Aborting.\n");
320	return ERR_PTR(-ENODEV);
321	}
322
323	host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pci_slot));
324	if (IS_ERR(host)) {
325	ret = PTR_ERR(host);
326	goto unmap;
327	}
328
329	slot = sdhci_priv(host);
330
331	slot->chip = chip;
332	slot->host = host;
333	slot->pci_bar = bar;
334
335	host->hw_name = "PCI";
336	host->ops = &sdhci_pci_ops;
337	host->quirks = chip->quirks;
338
339	host->irq = pdev->irq;
340
341	ret = pci_request_region(pdev, bar, mmc_hostname(host->mmc));
342	if (ret) {
343	dev_err(&pdev->dev, "cannot request region\n");
344	return ERR_PTR(ret);
345	}
346
347	addr = pci_resource_start(pdev, bar);
348	host->ioaddr = ioremap_nocache(addr, pci_resource_len(pdev, bar));
349	if (!host->ioaddr) {
350	dev_err(&pdev->dev, "failed to remap registers\n");
351	goto release;
352	}
353
354	ret = sdhci_add_host(host);
355	if (ret)
356	goto unmap;
357
358	return slot;
359
360	unmap:
361	iounmap(host->ioaddr);
362
363	release:
364	pci_release_region(pdev, bar);
365	sdhci_free_host(host);
366
367	return ERR_PTR(ret);
368	}
369
370	static void sdhci_pci_remove_slot(struct sdhci_pci_slot *slot)
371	{
372	sdhci_remove_host(slot->host);
373	pci_release_region(slot->chip->pdev, slot->pci_bar);
374	sdhci_free_host(slot->host);
375	}
376
377	static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
378	const struct pci_device_id *ent)
379	{
380	struct sdhci_pci_chip *chip;
381	struct sdhci_pci_slot *slot;
382
383	u8 slots, rev, first_bar;
384	int ret, i;
385
386	BUG_ON(pdev == NULL);
387	BUG_ON(ent == NULL);
388
389	pci_read_config_byte(pdev, PCI_CLASS_REVISION, &rev);
390
391	dev_info(&pdev->dev, "SDHCI controller found [%04x:%04x] (rev %x)\n",
392	(int)pdev->vendor, (int)pdev->device, (int)rev);
393
394	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
395	if (ret)
396	return ret;
397
398	slots = PCI_SLOT_INFO_SLOTS(slots) + 1;
399	dev_dbg(&pdev->dev, "found %d slot(s)\n", slots);
400	if (slots == 0)
401	return -ENODEV;
402
403	BUG_ON(slots > MAX_SLOTS);
404
405	ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &first_bar);
406	if (ret)
407	return ret;
408
409	first_bar &= PCI_SLOT_INFO_FIRST_BAR_MASK;
410
411	if (first_bar > 5) {
412	dev_err(&pdev->dev, "Invalid first BAR. Aborting.\n");
413	return -ENODEV;
414	}
415
416	ret = pci_enable_device(pdev);
417	if (ret)
418	return ret;
419
420	chip = kzalloc(sizeof(struct sdhci_pci_chip), GFP_KERNEL);
421	if (!chip) {
422	ret = -ENOMEM;
423	goto err;
424	}
425
426	chip->pdev = pdev;
22606405 PO	427	chip->fixes = (const struct sdhci_pci_fixes*)ent->driver_data;
	428	if (chip->fixes)
	429	chip->quirks = chip->fixes->quirks;
b8c86fc5 PO	430	chip->num_slots = slots;
	431
	432	pci_set_drvdata(pdev, chip);
	433
22606405 PO	434	if (chip->fixes && chip->fixes->probe) {
	435	ret = chip->fixes->probe(chip);
	436	if (ret)
	437	goto free;
	438	}
	439
b8c86fc5 PO	440	for (i = 0;i < slots;i++) {
	441	slot = sdhci_pci_probe_slot(pdev, chip, first_bar + i);
	442	if (IS_ERR(slot)) {
	443	for (i--;i >= 0;i--)
	444	sdhci_pci_remove_slot(chip->slots[i]);
	445	ret = PTR_ERR(slot);
	446	goto free;
	447	}
	448
	449	chip->slots[i] = slot;
	450	}
	451
	452	return 0;
	453
	454	free:
	455	pci_set_drvdata(pdev, NULL);
	456	kfree(chip);
	457
	458	err:
	459	pci_disable_device(pdev);
	460	return ret;
	461	}
	462
	463	static void __devexit sdhci_pci_remove(struct pci_dev *pdev)
	464	{
	465	int i;
	466	struct sdhci_pci_chip *chip;
	467
	468	chip = pci_get_drvdata(pdev);
	469
	470	if (chip) {
	471	for (i = 0;i < chip->num_slots; i++)
	472	sdhci_pci_remove_slot(chip->slots[i]);
	473
	474	pci_set_drvdata(pdev, NULL);
	475	kfree(chip);
	476	}
	477
	478	pci_disable_device(pdev);
	479	}
	480
	481	static struct pci_driver sdhci_driver = {
	482	.name = "sdhci-pci",
	483	.id_table = pci_ids,
	484	.probe = sdhci_pci_probe,
	485	.remove = __devexit_p(sdhci_pci_remove),
	486	.suspend = sdhci_pci_suspend,
	487	.resume = sdhci_pci_resume,
	488	};
	489
	490	/*****************************************************************************\
	491	* *
	492	* Driver init/exit *
	493	* *
	494	\*****************************************************************************/
	495
	496	static int __init sdhci_drv_init(void)
	497	{
	498	return pci_register_driver(&sdhci_driver);
	499	}
	500
	501	static void __exit sdhci_drv_exit(void)
	502	{
	503	pci_unregister_driver(&sdhci_driver);
504	}
505
506	module_init(sdhci_drv_init);
507	module_exit(sdhci_drv_exit);
508
509	MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
510	MODULE_DESCRIPTION("Secure Digital Host Controller Interface PCI driver");
511	MODULE_LICENSE("GPL");