drivers/pcmcia/bcm63xx_pcmcia.c - kernel/msm - Gitiles

 /*
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
  */

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/ioport.h>
 #include <linux/timer.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/gpio.h>

 #include <bcm63xx_regs.h>
 #include <bcm63xx_io.h>
 #include "bcm63xx_pcmcia.h"

 #define PFX	"bcm63xx_pcmcia: "

 #ifdef CONFIG_CARDBUS
 /* if cardbus is used, platform device needs reference to actual pci
  * device */
 static struct pci_dev *bcm63xx_cb_dev;
 #endif

 /*
  * read/write helper for pcmcia regs
  */
 static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off)
 {
 	return bcm_readl(skt->base + off);
 }

 static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt,
 				 u32 val, u32 off)
 {
 	bcm_writel(val, skt->base + off);
 }

 /*
  * This callback should (re-)initialise the socket, turn on status
  * interrupts and PCMCIA bus, and wait for power to stabilise so that
  * the card status signals report correctly.
  *
  * Hardware cannot do that.
  */
 static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock)
 {
 	return 0;
 }

 /*
  * This callback should remove power on the socket, disable IRQs from
  * the card, turn off status interrupts, and disable the PCMCIA bus.
  *
  * Hardware cannot do that.
  */
 static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock)
 {
 	return 0;
 }

 /*
  * Implements the set_socket() operation for the in-kernel PCMCIA
  * service (formerly SS_SetSocket in Card Services). We more or
  * less punt all of this work and let the kernel handle the details
  * of power configuration, reset, &c. We also record the value of
  * `state' in order to regurgitate it to the PCMCIA core later.
  */
 static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock,
 				     socket_state_t *state)
 {
 	struct bcm63xx_pcmcia_socket *skt;
 	unsigned long flags;
 	u32 val;

 	skt = sock->driver_data;

 	spin_lock_irqsave(&skt->lock, flags);

 	/* note: hardware cannot control socket power, so we will
 	 * always report SS_POWERON */

 	/* apply socket reset */
 	val = pcmcia_readl(skt, PCMCIA_C1_REG);
 	if (state->flags & SS_RESET)
 		val |= PCMCIA_C1_RESET_MASK;
 	else
 		val &= ~PCMCIA_C1_RESET_MASK;

 	/* reverse reset logic for cardbus card */
 	if (skt->card_detected && (skt->card_type & CARD_CARDBUS))
 		val ^= PCMCIA_C1_RESET_MASK;

 	pcmcia_writel(skt, val, PCMCIA_C1_REG);

 	/* keep requested state for event reporting */
 	skt->requested_state = *state;

 	spin_unlock_irqrestore(&skt->lock, flags);

 	return 0;
 }

 /*
  * identity cardtype from VS[12] input, CD[12] input while only VS2 is
  * floating, and CD[12] input while only VS1 is floating
  */
 enum {
 	IN_VS1 = (1 << 0),
 	IN_VS2 = (1 << 1),
 	IN_CD1_VS2H = (1 << 2),
 	IN_CD2_VS2H = (1 << 3),
 	IN_CD1_VS1H = (1 << 4),
 	IN_CD2_VS1H = (1 << 5),
 };

 static const u8 vscd_to_cardtype[] = {

 	/* VS1 float, VS2 float */
 	[IN_VS1 | IN_VS2] = (CARD_PCCARD | CARD_5V),

 	/* VS1 grounded, VS2 float */
 	[IN_VS2] = (CARD_PCCARD | CARD_5V | CARD_3V),

 	/* VS1 grounded, VS2 grounded */
 	[0] = (CARD_PCCARD | CARD_5V | CARD_3V | CARD_XV),

 	/* VS1 tied to CD1, VS2 float */
 	[IN_VS1 | IN_VS2 | IN_CD1_VS1H] = (CARD_CARDBUS | CARD_3V),

 	/* VS1 grounded, VS2 tied to CD2 */
 	[IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V | CARD_XV),

 	/* VS1 tied to CD2, VS2 grounded */
 	[IN_VS1 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_3V | CARD_XV | CARD_YV),

 	/* VS1 float, VS2 grounded */
 	[IN_VS1] = (CARD_PCCARD | CARD_XV),

 	/* VS1 float, VS2 tied to CD2 */
 	[IN_VS1 | IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V),

 	/* VS1 float, VS2 tied to CD1 */
 	[IN_VS1 | IN_VS2 | IN_CD1_VS2H] = (CARD_CARDBUS | CARD_XV | CARD_YV),

 	/* VS1 tied to CD2, VS2 float */
 	[IN_VS1 | IN_VS2 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_YV),

 	/* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */
 	[IN_VS1 | IN_CD1_VS1H] = 0, /* ignore cardbay */
 };

 /*
  * poll hardware to check card insertion status
  */
 static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt)
 {
 	unsigned int stat;
 	u32 val;

 	stat = 0;

 	/* check CD for card presence */
 	val = pcmcia_readl(skt, PCMCIA_C1_REG);

 	if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK))
 		stat |= SS_DETECT;

 	/* if new insertion, detect cardtype */
 	if ((stat & SS_DETECT) && !skt->card_detected) {
 		unsigned int stat = 0;

 		/* float VS1, float VS2 */
 		val |= PCMCIA_C1_VS1OE_MASK;
 		val |= PCMCIA_C1_VS2OE_MASK;
 		pcmcia_writel(skt, val, PCMCIA_C1_REG);

 		/* wait for output to stabilize and read VS[12] */
 		udelay(10);
 		val = pcmcia_readl(skt, PCMCIA_C1_REG);
 		stat |= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0;
 		stat |= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0;

 		/* drive VS1 low, float VS2 */
 		val &= ~PCMCIA_C1_VS1OE_MASK;
 		val |= PCMCIA_C1_VS2OE_MASK;
 		pcmcia_writel(skt, val, PCMCIA_C1_REG);

 		/* wait for output to stabilize and read CD[12] */
 		udelay(10);
 		val = pcmcia_readl(skt, PCMCIA_C1_REG);
 		stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0;
 		stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0;

 		/* float VS1, drive VS2 low */
 		val |= PCMCIA_C1_VS1OE_MASK;
 		val &= ~PCMCIA_C1_VS2OE_MASK;
 		pcmcia_writel(skt, val, PCMCIA_C1_REG);

 		/* wait for output to stabilize and read CD[12] */
 		udelay(10);
 		val = pcmcia_readl(skt, PCMCIA_C1_REG);
 		stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0;
 		stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0;

 		/* guess cardtype from all this */
 		skt->card_type = vscd_to_cardtype[stat];
 		if (!skt->card_type)
 			dev_err(&skt->socket.dev, "unsupported card type\n");

 		/* drive both VS pin to 0 again */
 		val &= ~(PCMCIA_C1_VS1OE_MASK | PCMCIA_C1_VS2OE_MASK);

 		/* enable correct logic */
 		val &= ~(PCMCIA_C1_EN_PCMCIA_MASK | PCMCIA_C1_EN_CARDBUS_MASK);
 		if (skt->card_type & CARD_PCCARD)
 			val |= PCMCIA_C1_EN_PCMCIA_MASK;
 		else
 			val |= PCMCIA_C1_EN_CARDBUS_MASK;

 		pcmcia_writel(skt, val, PCMCIA_C1_REG);
 	}
 	skt->card_detected = (stat & SS_DETECT) ? 1 : 0;

 	/* report card type/voltage */
 	if (skt->card_type & CARD_CARDBUS)
 		stat |= SS_CARDBUS;
 	if (skt->card_type & CARD_3V)
 		stat |= SS_3VCARD;
 	if (skt->card_type & CARD_XV)
 		stat |= SS_XVCARD;
 	stat |= SS_POWERON;

 	if (gpio_get_value(skt->pd->ready_gpio))
 		stat |= SS_READY;

 	return stat;
 }

 /*
  * core request to get current socket status
  */
 static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock,
 				     unsigned int *status)
 {
 	struct bcm63xx_pcmcia_socket *skt;

 	skt = sock->driver_data;

 	spin_lock_bh(&skt->lock);
 	*status = __get_socket_status(skt);
 	spin_unlock_bh(&skt->lock);

 	return 0;
 }

 /*
  * socket polling timer callback
  */
 static void bcm63xx_pcmcia_poll(unsigned long data)
 {
 	struct bcm63xx_pcmcia_socket *skt;
 	unsigned int stat, events;

 	skt = (struct bcm63xx_pcmcia_socket *)data;

 	spin_lock_bh(&skt->lock);

 	stat = __get_socket_status(skt);

 	/* keep only changed bits, and mask with required one from the
 	 * core */
 	events = (stat ^ skt->old_status) & skt->requested_state.csc_mask;
 	skt->old_status = stat;
 	spin_unlock_bh(&skt->lock);

 	if (events)
 		pcmcia_parse_events(&skt->socket, events);

 	mod_timer(&skt->timer,
 		  jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
 }

 static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock,
 				     struct pccard_io_map *map)
 {
 	/* this doesn't seem to be called by pcmcia layer if static
 	 * mapping is used */
 	return 0;
 }

 static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock,
 				      struct pccard_mem_map *map)
 {
 	struct bcm63xx_pcmcia_socket *skt;
 	struct resource *res;

 	skt = sock->driver_data;
 	if (map->flags & MAP_ATTRIB)
 		res = skt->attr_res;
 	else
 		res = skt->common_res;

 	map->static_start = res->start + map->card_start;
 	return 0;
 }

 static struct pccard_operations bcm63xx_pcmcia_operations = {
 	.init			= bcm63xx_pcmcia_sock_init,
 	.suspend		= bcm63xx_pcmcia_suspend,
 	.get_status		= bcm63xx_pcmcia_get_status,
 	.set_socket		= bcm63xx_pcmcia_set_socket,
 	.set_io_map		= bcm63xx_pcmcia_set_io_map,
 	.set_mem_map		= bcm63xx_pcmcia_set_mem_map,
 };

 /*
  * register pcmcia socket to core
  */
 static int __devinit bcm63xx_drv_pcmcia_probe(struct platform_device *pdev)
 {
 	struct bcm63xx_pcmcia_socket *skt;
 	struct pcmcia_socket *sock;
 	struct resource *res, *irq_res;
 	unsigned int regmem_size = 0, iomem_size = 0;
 	u32 val;
 	int ret;

 	skt = kzalloc(sizeof(*skt), GFP_KERNEL);
 	if (!skt)
 		return -ENOMEM;
 	spin_lock_init(&skt->lock);
 	sock = &skt->socket;
 	sock->driver_data = skt;

 	/* make sure we have all resources we need */
 	skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 	skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 	irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 	skt->pd = pdev->dev.platform_data;
 	if (!skt->common_res || !skt->attr_res || !irq_res || !skt->pd) {
 		ret = -EINVAL;
 		goto err;
 	}

 	/* remap pcmcia registers */
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	regmem_size = resource_size(res);
 	if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) {
 		ret = -EINVAL;
 		goto err;
 	}
 	skt->reg_res = res;

 	skt->base = ioremap(res->start, regmem_size);
 	if (!skt->base) {
 		ret = -ENOMEM;
 		goto err;
 	}

 	/* remap io registers */
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
 	iomem_size = resource_size(res);
 	skt->io_base = ioremap(res->start, iomem_size);
 	if (!skt->io_base) {
 		ret = -ENOMEM;
 		goto err;
 	}

 	/* resources are static */
 	sock->resource_ops = &pccard_static_ops;
 	sock->ops = &bcm63xx_pcmcia_operations;
 	sock->owner = THIS_MODULE;
 	sock->dev.parent = &pdev->dev;
 	sock->features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
 	sock->io_offset = (unsigned long)skt->io_base;
 	sock->pci_irq = irq_res->start;

 #ifdef CONFIG_CARDBUS
 	sock->cb_dev = bcm63xx_cb_dev;
 	if (bcm63xx_cb_dev)
 		sock->features |= SS_CAP_CARDBUS;
 #endif

 	/* assume common & attribute memory have the same size */
 	sock->map_size = resource_size(skt->common_res);

 	/* initialize polling timer */
 	setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt);

 	/* initialize  pcmcia  control register,  drive  VS[12] to  0,
 	 * leave CB IDSEL to the old  value since it is set by the PCI
 	 * layer */
 	val = pcmcia_readl(skt, PCMCIA_C1_REG);
 	val &= PCMCIA_C1_CBIDSEL_MASK;
 	val |= PCMCIA_C1_EN_PCMCIA_GPIO_MASK;
 	pcmcia_writel(skt, val, PCMCIA_C1_REG);

 	/*
 	 * Hardware has only one set of timings registers, not one for
 	 * each memory access type, so we configure them for the
 	 * slowest one: attribute memory.
 	 */
 	val = PCMCIA_C2_DATA16_MASK;
 	val |= 10 << PCMCIA_C2_RWCOUNT_SHIFT;
 	val |= 6 << PCMCIA_C2_INACTIVE_SHIFT;
 	val |= 3 << PCMCIA_C2_SETUP_SHIFT;
 	val |= 3 << PCMCIA_C2_HOLD_SHIFT;
 	pcmcia_writel(skt, val, PCMCIA_C2_REG);

 	ret = pcmcia_register_socket(sock);
 	if (ret)
 		goto err;

 	/* start polling socket */
 	mod_timer(&skt->timer,
 		  jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));

 	platform_set_drvdata(pdev, skt);
 	return 0;

 err:
 	if (skt->io_base)
 		iounmap(skt->io_base);
 	if (skt->base)
 		iounmap(skt->base);
 	if (skt->reg_res)
 		release_mem_region(skt->reg_res->start, regmem_size);
 	kfree(skt);
 	return ret;
 }

 static int __devexit bcm63xx_drv_pcmcia_remove(struct platform_device *pdev)
 {
 	struct bcm63xx_pcmcia_socket *skt;
 	struct resource *res;

 	skt = platform_get_drvdata(pdev);
 	del_timer_sync(&skt->timer);
 	iounmap(skt->base);
 	iounmap(skt->io_base);
 	res = skt->reg_res;
 	release_mem_region(res->start, resource_size(res));
 	kfree(skt);
 	return 0;
 }

 struct platform_driver bcm63xx_pcmcia_driver = {
 	.probe	= bcm63xx_drv_pcmcia_probe,
 	.remove	= __devexit_p(bcm63xx_drv_pcmcia_remove),
 	.driver	= {
 		.name	= "bcm63xx_pcmcia",
 		.owner  = THIS_MODULE,
 	},
 };

 #ifdef CONFIG_CARDBUS
 static int __devinit bcm63xx_cb_probe(struct pci_dev *dev,
 				      const struct pci_device_id *id)
 {
 	/* keep pci device */
 	bcm63xx_cb_dev = dev;
 	return platform_driver_register(&bcm63xx_pcmcia_driver);
 }

 static void __devexit bcm63xx_cb_exit(struct pci_dev *dev)
 {
 	platform_driver_unregister(&bcm63xx_pcmcia_driver);
 	bcm63xx_cb_dev = NULL;
 }

 static struct pci_device_id bcm63xx_cb_table[] = {
 	{
 		.vendor		= PCI_VENDOR_ID_BROADCOM,
 		.device		= BCM6348_CPU_ID,
 		.subvendor	= PCI_VENDOR_ID_BROADCOM,
 		.subdevice	= PCI_ANY_ID,
 		.class		= PCI_CLASS_BRIDGE_CARDBUS << 8,
 		.class_mask	= ~0,
 	},

 	{
 		.vendor		= PCI_VENDOR_ID_BROADCOM,
 		.device		= BCM6358_CPU_ID,
 		.subvendor	= PCI_VENDOR_ID_BROADCOM,
 		.subdevice	= PCI_ANY_ID,
 		.class		= PCI_CLASS_BRIDGE_CARDBUS << 8,
 		.class_mask	= ~0,
 	},

 	{ },
 };

 MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table);

 static struct pci_driver bcm63xx_cardbus_driver = {
 	.name		= "bcm63xx_cardbus",
 	.id_table	= bcm63xx_cb_table,
 	.probe		= bcm63xx_cb_probe,
 	.remove		= __devexit_p(bcm63xx_cb_exit),
 };
 #endif

 /*
  * if cardbus support is enabled, register our platform device after
  * our fake cardbus bridge has been registered
  */
 static int __init bcm63xx_pcmcia_init(void)
 {
 #ifdef CONFIG_CARDBUS
 	return pci_register_driver(&bcm63xx_cardbus_driver);
 #else
 	return platform_driver_register(&bcm63xx_pcmcia_driver);
 #endif
 }

 static void __exit bcm63xx_pcmcia_exit(void)
 {
 #ifdef CONFIG_CARDBUS
 	return pci_unregister_driver(&bcm63xx_cardbus_driver);
 #else
 	platform_driver_unregister(&bcm63xx_pcmcia_driver);
 #endif
 }

 module_init(bcm63xx_pcmcia_init);
 module_exit(bcm63xx_pcmcia_exit);

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
 MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller");
	/*
	* This file is subject to the terms and conditions of the GNU General Public
	* License. See the file "COPYING" in the main directory of this archive
	* for more details.
	*
	* Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
	*/

	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/ioport.h>
	#include <linux/timer.h>
	#include <linux/platform_device.h>
	#include <linux/slab.h>
	#include <linux/delay.h>
	#include <linux/pci.h>
	#include <linux/gpio.h>

	#include <bcm63xx_regs.h>
	#include <bcm63xx_io.h>
	#include "bcm63xx_pcmcia.h"

	#define PFX "bcm63xx_pcmcia: "

	#ifdef CONFIG_CARDBUS
	/* if cardbus is used, platform device needs reference to actual pci
	* device */
	static struct pci_dev *bcm63xx_cb_dev;
	#endif

	/*
	* read/write helper for pcmcia regs
	*/
	static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off)
	{
	return bcm_readl(skt->base + off);
	}

	static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt,
	u32 val, u32 off)
	{
	bcm_writel(val, skt->base + off);
	}

	/*
	* This callback should (re-)initialise the socket, turn on status
	* interrupts and PCMCIA bus, and wait for power to stabilise so that
	* the card status signals report correctly.
	*
	* Hardware cannot do that.
	*/
	static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock)
	{
	return 0;
	}

	/*
	* This callback should remove power on the socket, disable IRQs from
	* the card, turn off status interrupts, and disable the PCMCIA bus.
	*
	* Hardware cannot do that.
	*/
	static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock)
	{
	return 0;
	}

	/*
	* Implements the set_socket() operation for the in-kernel PCMCIA
	* service (formerly SS_SetSocket in Card Services). We more or
	* less punt all of this work and let the kernel handle the details
	* of power configuration, reset, &c. We also record the value of
	* `state' in order to regurgitate it to the PCMCIA core later.
	*/
	static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock,
	socket_state_t *state)
	{
	struct bcm63xx_pcmcia_socket *skt;
	unsigned long flags;
	u32 val;

	skt = sock->driver_data;

	spin_lock_irqsave(&skt->lock, flags);

	/* note: hardware cannot control socket power, so we will
	* always report SS_POWERON */

	/* apply socket reset */
	val = pcmcia_readl(skt, PCMCIA_C1_REG);
	if (state->flags & SS_RESET)
	val \|= PCMCIA_C1_RESET_MASK;
	else
	val &= ~PCMCIA_C1_RESET_MASK;

	/* reverse reset logic for cardbus card */
	if (skt->card_detected && (skt->card_type & CARD_CARDBUS))
	val ^= PCMCIA_C1_RESET_MASK;

	pcmcia_writel(skt, val, PCMCIA_C1_REG);

	/* keep requested state for event reporting */
	skt->requested_state = *state;

	spin_unlock_irqrestore(&skt->lock, flags);

	return 0;
	}

	/*
	* identity cardtype from VS[12] input, CD[12] input while only VS2 is
	* floating, and CD[12] input while only VS1 is floating
	*/
	enum {
	IN_VS1 = (1 << 0),
	IN_VS2 = (1 << 1),
	IN_CD1_VS2H = (1 << 2),
	IN_CD2_VS2H = (1 << 3),
	IN_CD1_VS1H = (1 << 4),
	IN_CD2_VS1H = (1 << 5),
	};

	static const u8 vscd_to_cardtype[] = {

	/* VS1 float, VS2 float */
	[IN_VS1 \| IN_VS2] = (CARD_PCCARD \| CARD_5V),

	/* VS1 grounded, VS2 float */
	[IN_VS2] = (CARD_PCCARD \| CARD_5V \| CARD_3V),

	/* VS1 grounded, VS2 grounded */
	[0] = (CARD_PCCARD \| CARD_5V \| CARD_3V \| CARD_XV),

	/* VS1 tied to CD1, VS2 float */
	[IN_VS1 \| IN_VS2 \| IN_CD1_VS1H] = (CARD_CARDBUS \| CARD_3V),

	/* VS1 grounded, VS2 tied to CD2 */
	[IN_VS2 \| IN_CD2_VS2H] = (CARD_CARDBUS \| CARD_3V \| CARD_XV),

	/* VS1 tied to CD2, VS2 grounded */
	[IN_VS1 \| IN_CD2_VS1H] = (CARD_CARDBUS \| CARD_3V \| CARD_XV \| CARD_YV),

	/* VS1 float, VS2 grounded */
	[IN_VS1] = (CARD_PCCARD \| CARD_XV),

	/* VS1 float, VS2 tied to CD2 */
	[IN_VS1 \| IN_VS2 \| IN_CD2_VS2H] = (CARD_CARDBUS \| CARD_3V),

	/* VS1 float, VS2 tied to CD1 */
	[IN_VS1 \| IN_VS2 \| IN_CD1_VS2H] = (CARD_CARDBUS \| CARD_XV \| CARD_YV),

	/* VS1 tied to CD2, VS2 float */
	[IN_VS1 \| IN_VS2 \| IN_CD2_VS1H] = (CARD_CARDBUS \| CARD_YV),

	/* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */
	[IN_VS1 \| IN_CD1_VS1H] = 0, /* ignore cardbay */
	};

	/*
	* poll hardware to check card insertion status
	*/
	static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt)
	{
	unsigned int stat;
	u32 val;

	stat = 0;

	/* check CD for card presence */
	val = pcmcia_readl(skt, PCMCIA_C1_REG);

	if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK))
	stat \|= SS_DETECT;

	/* if new insertion, detect cardtype */
	if ((stat & SS_DETECT) && !skt->card_detected) {
	unsigned int stat = 0;

	/* float VS1, float VS2 */
	val \|= PCMCIA_C1_VS1OE_MASK;
	val \|= PCMCIA_C1_VS2OE_MASK;
	pcmcia_writel(skt, val, PCMCIA_C1_REG);

	/* wait for output to stabilize and read VS[12] */
	udelay(10);
	val = pcmcia_readl(skt, PCMCIA_C1_REG);
	stat \|= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0;
	stat \|= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0;

	/* drive VS1 low, float VS2 */
	val &= ~PCMCIA_C1_VS1OE_MASK;
	val \|= PCMCIA_C1_VS2OE_MASK;
	pcmcia_writel(skt, val, PCMCIA_C1_REG);

	/* wait for output to stabilize and read CD[12] */
	udelay(10);
	val = pcmcia_readl(skt, PCMCIA_C1_REG);
	stat \|= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0;
	stat \|= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0;

	/* float VS1, drive VS2 low */
	val \|= PCMCIA_C1_VS1OE_MASK;
	val &= ~PCMCIA_C1_VS2OE_MASK;
	pcmcia_writel(skt, val, PCMCIA_C1_REG);

	/* wait for output to stabilize and read CD[12] */
	udelay(10);
	val = pcmcia_readl(skt, PCMCIA_C1_REG);
	stat \|= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0;
	stat \|= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0;

	/* guess cardtype from all this */
	skt->card_type = vscd_to_cardtype[stat];
	if (!skt->card_type)
	dev_err(&skt->socket.dev, "unsupported card type\n");

	/* drive both VS pin to 0 again */
	val &= ~(PCMCIA_C1_VS1OE_MASK \| PCMCIA_C1_VS2OE_MASK);

	/* enable correct logic */
	val &= ~(PCMCIA_C1_EN_PCMCIA_MASK \| PCMCIA_C1_EN_CARDBUS_MASK);
	if (skt->card_type & CARD_PCCARD)
	val \|= PCMCIA_C1_EN_PCMCIA_MASK;
	else
	val \|= PCMCIA_C1_EN_CARDBUS_MASK;

	pcmcia_writel(skt, val, PCMCIA_C1_REG);
	}
	skt->card_detected = (stat & SS_DETECT) ? 1 : 0;

	/* report card type/voltage */
	if (skt->card_type & CARD_CARDBUS)
	stat \|= SS_CARDBUS;
	if (skt->card_type & CARD_3V)
	stat \|= SS_3VCARD;
	if (skt->card_type & CARD_XV)
	stat \|= SS_XVCARD;
	stat \|= SS_POWERON;

	if (gpio_get_value(skt->pd->ready_gpio))
	stat \|= SS_READY;

	return stat;
	}

	/*
	* core request to get current socket status
	*/
	static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock,
	unsigned int *status)
	{
	struct bcm63xx_pcmcia_socket *skt;

	skt = sock->driver_data;

	spin_lock_bh(&skt->lock);
	*status = __get_socket_status(skt);
	spin_unlock_bh(&skt->lock);

	return 0;
	}

	/*
	* socket polling timer callback
	*/
	static void bcm63xx_pcmcia_poll(unsigned long data)
	{
	struct bcm63xx_pcmcia_socket *skt;
	unsigned int stat, events;

	skt = (struct bcm63xx_pcmcia_socket *)data;

	spin_lock_bh(&skt->lock);

	stat = __get_socket_status(skt);

	/* keep only changed bits, and mask with required one from the
	* core */
	events = (stat ^ skt->old_status) & skt->requested_state.csc_mask;
	skt->old_status = stat;
	spin_unlock_bh(&skt->lock);

	if (events)
	pcmcia_parse_events(&skt->socket, events);

	mod_timer(&skt->timer,
	jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
	}

	static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock,
	struct pccard_io_map *map)
	{
	/* this doesn't seem to be called by pcmcia layer if static
	* mapping is used */
	return 0;
	}

	static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock,
	struct pccard_mem_map *map)
	{
	struct bcm63xx_pcmcia_socket *skt;
	struct resource *res;

	skt = sock->driver_data;
	if (map->flags & MAP_ATTRIB)
	res = skt->attr_res;
	else
	res = skt->common_res;

	map->static_start = res->start + map->card_start;
	return 0;
	}

	static struct pccard_operations bcm63xx_pcmcia_operations = {
	.init = bcm63xx_pcmcia_sock_init,
	.suspend = bcm63xx_pcmcia_suspend,
	.get_status = bcm63xx_pcmcia_get_status,
	.set_socket = bcm63xx_pcmcia_set_socket,
	.set_io_map = bcm63xx_pcmcia_set_io_map,
	.set_mem_map = bcm63xx_pcmcia_set_mem_map,
	};

	/*
	* register pcmcia socket to core
	*/
	static int __devinit bcm63xx_drv_pcmcia_probe(struct platform_device *pdev)
	{
	struct bcm63xx_pcmcia_socket *skt;
	struct pcmcia_socket *sock;
	struct resource res, irq_res;
	unsigned int regmem_size = 0, iomem_size = 0;
	u32 val;
	int ret;

	skt = kzalloc(sizeof(*skt), GFP_KERNEL);
	if (!skt)
	return -ENOMEM;
	spin_lock_init(&skt->lock);
	sock = &skt->socket;
	sock->driver_data = skt;

	/* make sure we have all resources we need */
	skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	skt->pd = pdev->dev.platform_data;
	if (!skt->common_res \|\| !skt->attr_res \|\| !irq_res \|\| !skt->pd) {
	ret = -EINVAL;
	goto err;
	}

	/* remap pcmcia registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	regmem_size = resource_size(res);
	if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) {
	ret = -EINVAL;
	goto err;
	}
	skt->reg_res = res;

	skt->base = ioremap(res->start, regmem_size);
	if (!skt->base) {
	ret = -ENOMEM;
	goto err;
	}

	/* remap io registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
	iomem_size = resource_size(res);
	skt->io_base = ioremap(res->start, iomem_size);
	if (!skt->io_base) {
	ret = -ENOMEM;
	goto err;
	}

	/* resources are static */
	sock->resource_ops = &pccard_static_ops;
	sock->ops = &bcm63xx_pcmcia_operations;
	sock->owner = THIS_MODULE;
	sock->dev.parent = &pdev->dev;
	sock->features = SS_CAP_STATIC_MAP \| SS_CAP_PCCARD;
	sock->io_offset = (unsigned long)skt->io_base;
	sock->pci_irq = irq_res->start;

	#ifdef CONFIG_CARDBUS
	sock->cb_dev = bcm63xx_cb_dev;
	if (bcm63xx_cb_dev)
	sock->features \|= SS_CAP_CARDBUS;
	#endif

	/* assume common & attribute memory have the same size */
	sock->map_size = resource_size(skt->common_res);

	/* initialize polling timer */
	setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt);

	/* initialize pcmcia control register, drive VS[12] to 0,
	* leave CB IDSEL to the old value since it is set by the PCI
	* layer */
	val = pcmcia_readl(skt, PCMCIA_C1_REG);
	val &= PCMCIA_C1_CBIDSEL_MASK;
	val \|= PCMCIA_C1_EN_PCMCIA_GPIO_MASK;
	pcmcia_writel(skt, val, PCMCIA_C1_REG);

	/*
	* Hardware has only one set of timings registers, not one for
	* each memory access type, so we configure them for the
	* slowest one: attribute memory.
	*/
	val = PCMCIA_C2_DATA16_MASK;
	val \|= 10 << PCMCIA_C2_RWCOUNT_SHIFT;
	val \|= 6 << PCMCIA_C2_INACTIVE_SHIFT;
	val \|= 3 << PCMCIA_C2_SETUP_SHIFT;
	val \|= 3 << PCMCIA_C2_HOLD_SHIFT;
	pcmcia_writel(skt, val, PCMCIA_C2_REG);

	ret = pcmcia_register_socket(sock);
	if (ret)
	goto err;

	/* start polling socket */
	mod_timer(&skt->timer,
	jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));

	platform_set_drvdata(pdev, skt);
	return 0;

	err:
	if (skt->io_base)
	iounmap(skt->io_base);
	if (skt->base)
	iounmap(skt->base);
	if (skt->reg_res)
	release_mem_region(skt->reg_res->start, regmem_size);
	kfree(skt);
	return ret;
	}

	static int __devexit bcm63xx_drv_pcmcia_remove(struct platform_device *pdev)
	{
	struct bcm63xx_pcmcia_socket *skt;
	struct resource *res;

	skt = platform_get_drvdata(pdev);
	del_timer_sync(&skt->timer);
	iounmap(skt->base);
	iounmap(skt->io_base);
	res = skt->reg_res;
	release_mem_region(res->start, resource_size(res));
	kfree(skt);
	return 0;
	}

	struct platform_driver bcm63xx_pcmcia_driver = {
	.probe = bcm63xx_drv_pcmcia_probe,
	.remove = __devexit_p(bcm63xx_drv_pcmcia_remove),
	.driver = {
	.name = "bcm63xx_pcmcia",
	.owner = THIS_MODULE,
	},
	};

	#ifdef CONFIG_CARDBUS
	static int __devinit bcm63xx_cb_probe(struct pci_dev *dev,
	const struct pci_device_id *id)
	{
	/* keep pci device */
	bcm63xx_cb_dev = dev;
	return platform_driver_register(&bcm63xx_pcmcia_driver);
	}

	static void __devexit bcm63xx_cb_exit(struct pci_dev *dev)
	{
	platform_driver_unregister(&bcm63xx_pcmcia_driver);
	bcm63xx_cb_dev = NULL;
	}

	static struct pci_device_id bcm63xx_cb_table[] = {
	{
	.vendor = PCI_VENDOR_ID_BROADCOM,
	.device = BCM6348_CPU_ID,
	.subvendor = PCI_VENDOR_ID_BROADCOM,
	.subdevice = PCI_ANY_ID,
	.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
	.class_mask = ~0,
	},

	{
	.vendor = PCI_VENDOR_ID_BROADCOM,
	.device = BCM6358_CPU_ID,
	.subvendor = PCI_VENDOR_ID_BROADCOM,
	.subdevice = PCI_ANY_ID,
	.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
	.class_mask = ~0,
	},

	{ },
	};

	MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table);

	static struct pci_driver bcm63xx_cardbus_driver = {
	.name = "bcm63xx_cardbus",
	.id_table = bcm63xx_cb_table,
	.probe = bcm63xx_cb_probe,
	.remove = __devexit_p(bcm63xx_cb_exit),
	};
	#endif

	/*
	* if cardbus support is enabled, register our platform device after
	* our fake cardbus bridge has been registered
	*/
	static int __init bcm63xx_pcmcia_init(void)
	{
	#ifdef CONFIG_CARDBUS
	return pci_register_driver(&bcm63xx_cardbus_driver);
	#else
	return platform_driver_register(&bcm63xx_pcmcia_driver);
	#endif
	}

	static void __exit bcm63xx_pcmcia_exit(void)
	{
	#ifdef CONFIG_CARDBUS
	return pci_unregister_driver(&bcm63xx_cardbus_driver);
	#else
	platform_driver_unregister(&bcm63xx_pcmcia_driver);
	#endif
	}

	module_init(bcm63xx_pcmcia_init);
	module_exit(bcm63xx_pcmcia_exit);

	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
	MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller");