[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / pcmcia / bcm63xx_pcmcia.c

/*
 * 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 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 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	= bcm63xx_drv_pcmcia_remove,
	.driver	= {
		.name	= "bcm63xx_pcmcia",
		.owner  = THIS_MODULE,
	},
};

#ifdef CONFIG_CARDBUS
static int 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 bcm63xx_cb_exit(struct pci_dev *dev)
{
	platform_driver_unregister(&bcm63xx_pcmcia_driver);
	bcm63xx_cb_dev = NULL;
}

static DEFINE_PCI_DEVICE_TABLE(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		= 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");
Commit	Line	Data
553d6d5f MB	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/ioport.h>
	12	#include <linux/timer.h>
	13	#include <linux/platform_device.h>
5a0e3ad6	14	#include <linux/slab.h>
553d6d5f MB	15	#include <linux/delay.h>
	16	#include <linux/pci.h>
	17	#include <linux/gpio.h>
	18
	19	#include <bcm63xx_regs.h>
	20	#include <bcm63xx_io.h>
	21	#include "bcm63xx_pcmcia.h"
	22
	23	#define PFX "bcm63xx_pcmcia: "
	24
	25	#ifdef CONFIG_CARDBUS
	26	/* if cardbus is used, platform device needs reference to actual pci
	27	* device */
	28	static struct pci_dev *bcm63xx_cb_dev;
	29	#endif
	30
	31	/*
	32	* read/write helper for pcmcia regs
	33	*/
	34	static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off)
	35	{
	36	return bcm_readl(skt->base + off);
	37	}
	38
	39	static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt,
	40	u32 val, u32 off)
	41	{
	42	bcm_writel(val, skt->base + off);
	43	}
	44
	45	/*
	46	* This callback should (re-)initialise the socket, turn on status
	47	* interrupts and PCMCIA bus, and wait for power to stabilise so that
	48	* the card status signals report correctly.
	49	*
	50	* Hardware cannot do that.
	51	*/
	52	static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock)
	53	{
	54	return 0;
	55	}
	56
	57	/*
	58	* This callback should remove power on the socket, disable IRQs from
	59	* the card, turn off status interrupts, and disable the PCMCIA bus.
	60	*
	61	* Hardware cannot do that.
	62	*/
	63	static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock)
	64	{
	65	return 0;
	66	}
	67
	68	/*
	69	* Implements the set_socket() operation for the in-kernel PCMCIA
	70	* service (formerly SS_SetSocket in Card Services). We more or
	71	* less punt all of this work and let the kernel handle the details
	72	* of power configuration, reset, &c. We also record the value of
	73	* `state' in order to regurgitate it to the PCMCIA core later.
	74	*/
	75	static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock,
	76	socket_state_t *state)
	77	{
	78	struct bcm63xx_pcmcia_socket *skt;
79	unsigned long flags;
80	u32 val;
81
82	skt = sock->driver_data;
83
84	spin_lock_irqsave(&skt->lock, flags);
85
86	/* note: hardware cannot control socket power, so we will
87	* always report SS_POWERON */
88
89	/* apply socket reset */
90	val = pcmcia_readl(skt, PCMCIA_C1_REG);
91	if (state->flags & SS_RESET)
92	val \|= PCMCIA_C1_RESET_MASK;
93	else
94	val &= ~PCMCIA_C1_RESET_MASK;
95
96	/* reverse reset logic for cardbus card */
97	if (skt->card_detected && (skt->card_type & CARD_CARDBUS))
98	val ^= PCMCIA_C1_RESET_MASK;
99
100	pcmcia_writel(skt, val, PCMCIA_C1_REG);
101
102	/* keep requested state for event reporting */
103	skt->requested_state = *state;
104
105	spin_unlock_irqrestore(&skt->lock, flags);
106
107	return 0;
108	}
109
110	/*
111	* identity cardtype from VS[12] input, CD[12] input while only VS2 is
112	* floating, and CD[12] input while only VS1 is floating
113	*/
114	enum {
115	IN_VS1 = (1 << 0),
116	IN_VS2 = (1 << 1),
117	IN_CD1_VS2H = (1 << 2),
118	IN_CD2_VS2H = (1 << 3),
119	IN_CD1_VS1H = (1 << 4),
120	IN_CD2_VS1H = (1 << 5),
121	};
122
123	static const u8 vscd_to_cardtype[] = {
124
125	/* VS1 float, VS2 float */
126	[IN_VS1 \| IN_VS2] = (CARD_PCCARD \| CARD_5V),
127
128	/* VS1 grounded, VS2 float */
129	[IN_VS2] = (CARD_PCCARD \| CARD_5V \| CARD_3V),
130
131	/* VS1 grounded, VS2 grounded */
132	[0] = (CARD_PCCARD \| CARD_5V \| CARD_3V \| CARD_XV),
133
134	/* VS1 tied to CD1, VS2 float */
135	[IN_VS1 \| IN_VS2 \| IN_CD1_VS1H] = (CARD_CARDBUS \| CARD_3V),
136
137	/* VS1 grounded, VS2 tied to CD2 */
138	[IN_VS2 \| IN_CD2_VS2H] = (CARD_CARDBUS \| CARD_3V \| CARD_XV),
139
140	/* VS1 tied to CD2, VS2 grounded */
141	[IN_VS1 \| IN_CD2_VS1H] = (CARD_CARDBUS \| CARD_3V \| CARD_XV \| CARD_YV),
142
143	/* VS1 float, VS2 grounded */
144	[IN_VS1] = (CARD_PCCARD \| CARD_XV),
145
146	/* VS1 float, VS2 tied to CD2 */
147	[IN_VS1 \| IN_VS2 \| IN_CD2_VS2H] = (CARD_CARDBUS \| CARD_3V),
148
149	/* VS1 float, VS2 tied to CD1 */
150	[IN_VS1 \| IN_VS2 \| IN_CD1_VS2H] = (CARD_CARDBUS \| CARD_XV \| CARD_YV),
151
152	/* VS1 tied to CD2, VS2 float */
153	[IN_VS1 \| IN_VS2 \| IN_CD2_VS1H] = (CARD_CARDBUS \| CARD_YV),
154
155	/* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */
156	[IN_VS1 \| IN_CD1_VS1H] = 0, /* ignore cardbay */
157	};
158
159	/*
160	* poll hardware to check card insertion status
161	*/
162	static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt)
163	{
164	unsigned int stat;
165	u32 val;
166
167	stat = 0;
168
169	/* check CD for card presence */
170	val = pcmcia_readl(skt, PCMCIA_C1_REG);
171
172	if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK))
173	stat \|= SS_DETECT;
174
175	/* if new insertion, detect cardtype */
176	if ((stat & SS_DETECT) && !skt->card_detected) {
177	unsigned int stat = 0;
178
179	/* float VS1, float VS2 */
180	val \|= PCMCIA_C1_VS1OE_MASK;
181	val \|= PCMCIA_C1_VS2OE_MASK;
182	pcmcia_writel(skt, val, PCMCIA_C1_REG);
183
184	/* wait for output to stabilize and read VS[12] */
185	udelay(10);
186	val = pcmcia_readl(skt, PCMCIA_C1_REG);
187	stat \|= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0;
188	stat \|= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0;
189
190	/* drive VS1 low, float VS2 */
191	val &= ~PCMCIA_C1_VS1OE_MASK;
192	val \|= PCMCIA_C1_VS2OE_MASK;
193	pcmcia_writel(skt, val, PCMCIA_C1_REG);
194
195	/* wait for output to stabilize and read CD[12] */
196	udelay(10);
197	val = pcmcia_readl(skt, PCMCIA_C1_REG);
198	stat \|= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0;
199	stat \|= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0;
200
201	/* float VS1, drive VS2 low */
202	val \|= PCMCIA_C1_VS1OE_MASK;
203	val &= ~PCMCIA_C1_VS2OE_MASK;
204	pcmcia_writel(skt, val, PCMCIA_C1_REG);
205
206	/* wait for output to stabilize and read CD[12] */
207	udelay(10);
208	val = pcmcia_readl(skt, PCMCIA_C1_REG);
209	stat \|= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0;
210	stat \|= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0;
211
212	/* guess cardtype from all this */
213	skt->card_type = vscd_to_cardtype[stat];
214	if (!skt->card_type)
215	dev_err(&skt->socket.dev, "unsupported card type\n");
216
217	/* drive both VS pin to 0 again */
218	val &= ~(PCMCIA_C1_VS1OE_MASK \| PCMCIA_C1_VS2OE_MASK);
219
220	/* enable correct logic */
221	val &= ~(PCMCIA_C1_EN_PCMCIA_MASK \| PCMCIA_C1_EN_CARDBUS_MASK);
222	if (skt->card_type & CARD_PCCARD)
223	val \|= PCMCIA_C1_EN_PCMCIA_MASK;
224	else
225	val \|= PCMCIA_C1_EN_CARDBUS_MASK;
226
227	pcmcia_writel(skt, val, PCMCIA_C1_REG);
228	}
229	skt->card_detected = (stat & SS_DETECT) ? 1 : 0;
230
231	/* report card type/voltage */
232	if (skt->card_type & CARD_CARDBUS)
233	stat \|= SS_CARDBUS;
234	if (skt->card_type & CARD_3V)
235	stat \|= SS_3VCARD;
236	if (skt->card_type & CARD_XV)
237	stat \|= SS_XVCARD;
238	stat \|= SS_POWERON;
239
240	if (gpio_get_value(skt->pd->ready_gpio))
241	stat \|= SS_READY;
242
243	return stat;
244	}
245
246	/*
247	* core request to get current socket status
248	*/
249	static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock,
250	unsigned int *status)
251	{
252	struct bcm63xx_pcmcia_socket *skt;
253
254	skt = sock->driver_data;
255
256	spin_lock_bh(&skt->lock);
257	*status = __get_socket_status(skt);
258	spin_unlock_bh(&skt->lock);
259
260	return 0;
261	}
262
263	/*
264	* socket polling timer callback
265	*/
266	static void bcm63xx_pcmcia_poll(unsigned long data)
267	{
268	struct bcm63xx_pcmcia_socket *skt;
269	unsigned int stat, events;
270
271	skt = (struct bcm63xx_pcmcia_socket *)data;
272
273	spin_lock_bh(&skt->lock);
274
275	stat = __get_socket_status(skt);
276
277	/* keep only changed bits, and mask with required one from the
278	* core */
279	events = (stat ^ skt->old_status) & skt->requested_state.csc_mask;
280	skt->old_status = stat;
281	spin_unlock_bh(&skt->lock);
282
283	if (events)
284	pcmcia_parse_events(&skt->socket, events);
285
286	mod_timer(&skt->timer,
287	jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
288	}
289
290	static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock,
291	struct pccard_io_map *map)
292	{
293	/* this doesn't seem to be called by pcmcia layer if static
294	* mapping is used */
295	return 0;
296	}
297
298	static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock,
299	struct pccard_mem_map *map)
300	{
301	struct bcm63xx_pcmcia_socket *skt;
302	struct resource *res;
303
304	skt = sock->driver_data;
305	if (map->flags & MAP_ATTRIB)
306	res = skt->attr_res;
307	else
308	res = skt->common_res;
309
310	map->static_start = res->start + map->card_start;
311	return 0;
312	}
313
314	static struct pccard_operations bcm63xx_pcmcia_operations = {
315	.init = bcm63xx_pcmcia_sock_init,
316	.suspend = bcm63xx_pcmcia_suspend,
317	.get_status = bcm63xx_pcmcia_get_status,
318	.set_socket = bcm63xx_pcmcia_set_socket,
319	.set_io_map = bcm63xx_pcmcia_set_io_map,
320	.set_mem_map = bcm63xx_pcmcia_set_mem_map,
321	};
322
323	/*
324	* register pcmcia socket to core
325	*/
34cdf25a	326	static int bcm63xx_drv_pcmcia_probe(struct platform_device *pdev)
553d6d5f MB	327	{
	328	struct bcm63xx_pcmcia_socket *skt;
	329	struct pcmcia_socket *sock;
	330	struct resource res, irq_res;
	331	unsigned int regmem_size = 0, iomem_size = 0;
	332	u32 val;
	333	int ret;
	334
	335	skt = kzalloc(sizeof(*skt), GFP_KERNEL);
	336	if (!skt)
	337	return -ENOMEM;
	338	spin_lock_init(&skt->lock);
	339	sock = &skt->socket;
	340	sock->driver_data = skt;
	341
	342	/* make sure we have all resources we need */
	343	skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	344	skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	345	irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	346	skt->pd = pdev->dev.platform_data;
	347	if (!skt->common_res \|\| !skt->attr_res \|\| !irq_res \|\| !skt->pd) {
	348	ret = -EINVAL;
	349	goto err;
	350	}
	351
	352	/* remap pcmcia registers */
	353	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	354	regmem_size = resource_size(res);
	355	if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) {
	356	ret = -EINVAL;
	357	goto err;
	358	}
	359	skt->reg_res = res;
	360
	361	skt->base = ioremap(res->start, regmem_size);
	362	if (!skt->base) {
	363	ret = -ENOMEM;
	364	goto err;
	365	}
	366
	367	/* remap io registers */
	368	res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
	369	iomem_size = resource_size(res);
	370	skt->io_base = ioremap(res->start, iomem_size);
	371	if (!skt->io_base) {
	372	ret = -ENOMEM;
	373	goto err;
	374	}
	375
	376	/* resources are static */
	377	sock->resource_ops = &pccard_static_ops;
	378	sock->ops = &bcm63xx_pcmcia_operations;
	379	sock->owner = THIS_MODULE;
	380	sock->dev.parent = &pdev->dev;
	381	sock->features = SS_CAP_STATIC_MAP \| SS_CAP_PCCARD;
	382	sock->io_offset = (unsigned long)skt->io_base;
	383	sock->pci_irq = irq_res->start;
	384
	385	#ifdef CONFIG_CARDBUS
	386	sock->cb_dev = bcm63xx_cb_dev;
	387	if (bcm63xx_cb_dev)
	388	sock->features \|= SS_CAP_CARDBUS;
	389	#endif
	390
391	/* assume common & attribute memory have the same size */
392	sock->map_size = resource_size(skt->common_res);
393
394	/* initialize polling timer */
395	setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt);
396
397	/* initialize pcmcia control register, drive VS[12] to 0,
398	* leave CB IDSEL to the old value since it is set by the PCI
399	* layer */
400	val = pcmcia_readl(skt, PCMCIA_C1_REG);
401	val &= PCMCIA_C1_CBIDSEL_MASK;
402	val \|= PCMCIA_C1_EN_PCMCIA_GPIO_MASK;
403	pcmcia_writel(skt, val, PCMCIA_C1_REG);
404
405	/*
406	* Hardware has only one set of timings registers, not one for
407	* each memory access type, so we configure them for the
408	* slowest one: attribute memory.
409	*/
410	val = PCMCIA_C2_DATA16_MASK;
411	val \|= 10 << PCMCIA_C2_RWCOUNT_SHIFT;
412	val \|= 6 << PCMCIA_C2_INACTIVE_SHIFT;
413	val \|= 3 << PCMCIA_C2_SETUP_SHIFT;
414	val \|= 3 << PCMCIA_C2_HOLD_SHIFT;
415	pcmcia_writel(skt, val, PCMCIA_C2_REG);
416
417	ret = pcmcia_register_socket(sock);
418	if (ret)
419	goto err;
420
421	/* start polling socket */
422	mod_timer(&skt->timer,
423	jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
424
425	platform_set_drvdata(pdev, skt);
426	return 0;
427
428	err:
429	if (skt->io_base)
430	iounmap(skt->io_base);
431	if (skt->base)
432	iounmap(skt->base);
433	if (skt->reg_res)
434	release_mem_region(skt->reg_res->start, regmem_size);
435	kfree(skt);
436	return ret;
437	}
438
e765a02c	439	static int bcm63xx_drv_pcmcia_remove(struct platform_device *pdev)
553d6d5f MB	440	{
	441	struct bcm63xx_pcmcia_socket *skt;
	442	struct resource *res;
	443
	444	skt = platform_get_drvdata(pdev);
	445	del_timer_sync(&skt->timer);
	446	iounmap(skt->base);
	447	iounmap(skt->io_base);
	448	res = skt->reg_res;
	449	release_mem_region(res->start, resource_size(res));
	450	kfree(skt);
	451	return 0;
	452	}
	453
	454	struct platform_driver bcm63xx_pcmcia_driver = {
	455	.probe = bcm63xx_drv_pcmcia_probe,
96364e3a	456	.remove = bcm63xx_drv_pcmcia_remove,
553d6d5f MB	457	.driver = {
	458	.name = "bcm63xx_pcmcia",
	459	.owner = THIS_MODULE,
	460	},
	461	};
	462
	463	#ifdef CONFIG_CARDBUS
34cdf25a	464	static int bcm63xx_cb_probe(struct pci_dev *dev,
553d6d5f MB	465	const struct pci_device_id *id)
	466	{
	467	/* keep pci device */
	468	bcm63xx_cb_dev = dev;
	469	return platform_driver_register(&bcm63xx_pcmcia_driver);
	470	}
	471
e765a02c	472	static void bcm63xx_cb_exit(struct pci_dev *dev)
553d6d5f MB	473	{
	474	platform_driver_unregister(&bcm63xx_pcmcia_driver);
	475	bcm63xx_cb_dev = NULL;
	476	}
	477
2b2c5d8c	478	static DEFINE_PCI_DEVICE_TABLE(bcm63xx_cb_table) = {
553d6d5f MB	479	{
	480	.vendor = PCI_VENDOR_ID_BROADCOM,
	481	.device = BCM6348_CPU_ID,
	482	.subvendor = PCI_VENDOR_ID_BROADCOM,
	483	.subdevice = PCI_ANY_ID,
	484	.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
	485	.class_mask = ~0,
	486	},
	487
	488	{
	489	.vendor = PCI_VENDOR_ID_BROADCOM,
	490	.device = BCM6358_CPU_ID,
	491	.subvendor = PCI_VENDOR_ID_BROADCOM,
	492	.subdevice = PCI_ANY_ID,
	493	.class = PCI_CLASS_BRIDGE_CARDBUS << 8,
	494	.class_mask = ~0,
	495	},
	496
	497	{ },
	498	};
	499
	500	MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table);
	501
	502	static struct pci_driver bcm63xx_cardbus_driver = {
	503	.name = "bcm63xx_cardbus",
	504	.id_table = bcm63xx_cb_table,
	505	.probe = bcm63xx_cb_probe,
96364e3a	506	.remove = bcm63xx_cb_exit,
553d6d5f MB	507	};
	508	#endif
	509
	510	/*
	511	* if cardbus support is enabled, register our platform device after
	512	* our fake cardbus bridge has been registered
	513	*/
	514	static int __init bcm63xx_pcmcia_init(void)
	515	{
	516	#ifdef CONFIG_CARDBUS
	517	return pci_register_driver(&bcm63xx_cardbus_driver);
	518	#else
	519	return platform_driver_register(&bcm63xx_pcmcia_driver);
	520	#endif
	521	}
	522
	523	static void __exit bcm63xx_pcmcia_exit(void)
	524	{
	525	#ifdef CONFIG_CARDBUS
	526	return pci_unregister_driver(&bcm63xx_cardbus_driver);
	527	#else
	528	platform_driver_unregister(&bcm63xx_pcmcia_driver);
	529	#endif
	530	}
	531
	532	module_init(bcm63xx_pcmcia_init);
	533	module_exit(bcm63xx_pcmcia_exit);
	534
	535	MODULE_LICENSE("GPL");
	536	MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
	537	MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller");