[linux-2.6-block.git] / drivers / pcmcia / db1xxx_ss.c

/*
 * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
 *
 * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
 *
 */

/* This is a fairly generic PCMCIA socket driver suitable for the
 * following Alchemy Development boards:
 *  Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200, Db1300
 *
 * The Db1000 is used as a reference:  Per-socket card-, carddetect- and
 *  statuschange IRQs connected to SoC GPIOs, control and status register
 *  bits arranged in per-socket groups in an external PLD.  All boards
 *  listed here use this layout, including bit positions and meanings.
 *  Of course there are exceptions in later boards:
 *
 *	- Pb1100/Pb1500:  single socket only; voltage key bits VS are
 *			  at STATUS[5:4] (instead of STATUS[1:0]).
 *	- Au1200-based:	  additional card-eject irqs, irqs not gpios!
 *	- Db1300:	  Db1200-like, no pwr ctrl, single socket (#1).
 */

#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/pm.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/resource.h>
#include <linux/slab.h>
#include <linux/spinlock.h>

#include <pcmcia/ss.h>

#include <asm/mach-au1x00/au1000.h>
#include <asm/mach-db1x00/bcsr.h>

#define MEM_MAP_SIZE	0x400000
#define IO_MAP_SIZE	0x1000

struct db1x_pcmcia_sock {
	struct pcmcia_socket	socket;
	int		nr;		/* socket number */
	void		*virt_io;

	phys_addr_t	phys_io;
	phys_addr_t	phys_attr;
	phys_addr_t	phys_mem;

	/* previous flags for set_socket() */
	unsigned int old_flags;

	/* interrupt sources: linux irq numbers! */
	int	insert_irq;	/* default carddetect irq */
	int	stschg_irq;	/* card-status-change irq */
	int	card_irq;	/* card irq */
	int	eject_irq;	/* db1200/pb1200 have these */
	int	insert_gpio;	/* db1000 carddetect gpio */

#define BOARD_TYPE_DEFAULT	0	/* most boards */
#define BOARD_TYPE_DB1200	1	/* IRQs aren't gpios */
#define BOARD_TYPE_PB1100	2	/* VS bits slightly different */
#define BOARD_TYPE_DB1300	3	/* no power control */
	int	board_type;
};

#define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)

static int db1300_card_inserted(struct db1x_pcmcia_sock *sock)
{
	return bcsr_read(BCSR_SIGSTAT) & (1 << 8);
}

/* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
{
	unsigned short sigstat;

	sigstat = bcsr_read(BCSR_SIGSTAT);
	return sigstat & 1 << (8 + 2 * sock->nr);
}

/* carddetect gpio: low-active */
static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
{
	return !gpio_get_value(sock->insert_gpio);
}

static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
{
	switch (sock->board_type) {
	case BOARD_TYPE_DB1200:
		return db1200_card_inserted(sock);
	case BOARD_TYPE_DB1300:
		return db1300_card_inserted(sock);
	default:
		return db1000_card_inserted(sock);
	}
}

/* STSCHG tends to bounce heavily when cards are inserted/ejected.
 * To avoid this, the interrupt is normally disabled and only enabled
 * after reset to a card has been de-asserted.
 */
static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
{
	if (sock->stschg_irq != -1) {
		if (en)
			enable_irq(sock->stschg_irq);
		else
			disable_irq(sock->stschg_irq);
	}
}

static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
{
	struct db1x_pcmcia_sock *sock = data;

	pcmcia_parse_events(&sock->socket, SS_DETECT);

	return IRQ_HANDLED;
}

static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
{
	struct db1x_pcmcia_sock *sock = data;

	pcmcia_parse_events(&sock->socket, SS_STSCHG);

	return IRQ_HANDLED;
}

static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
{
	struct db1x_pcmcia_sock *sock = data;

	/* Db/Pb1200 have separate per-socket insertion and ejection
	 * interrupts which stay asserted as long as the card is
	 * inserted/missing.  The one which caused us to be called
	 * needs to be disabled and the other one enabled.
	 */
	if (irq == sock->insert_irq) {
		disable_irq_nosync(sock->insert_irq);
		enable_irq(sock->eject_irq);
	} else {
		disable_irq_nosync(sock->eject_irq);
		enable_irq(sock->insert_irq);
	}

	pcmcia_parse_events(&sock->socket, SS_DETECT);

	return IRQ_HANDLED;
}

static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
{
	int ret;

	if (sock->stschg_irq != -1) {
		ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
				  0, "pcmcia_stschg", sock);
		if (ret)
			return ret;
	}

	/* Db/Pb1200 have separate per-socket insertion and ejection
	 * interrupts, which should show edge behaviour but don't.
	 * So interrupts are disabled until both insertion and
	 * ejection handler have been registered and the currently
	 * active one disabled.
	 */
	if ((sock->board_type == BOARD_TYPE_DB1200) ||
	    (sock->board_type == BOARD_TYPE_DB1300)) {
		ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq,
				  0, "pcmcia_insert", sock);
		if (ret)
			goto out1;

		ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq,
				  0, "pcmcia_eject", sock);
		if (ret) {
			free_irq(sock->insert_irq, sock);
			goto out1;
		}

		/* enable the currently silent one */
		if (db1x_card_inserted(sock))
			enable_irq(sock->eject_irq);
		else
			enable_irq(sock->insert_irq);
	} else {
		/* all other (older) Db1x00 boards use a GPIO to show
		 * card detection status:  use both-edge triggers.
		 */
		irq_set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
		ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
				  0, "pcmcia_carddetect", sock);

		if (ret)
			goto out1;
	}

	return 0;	/* all done */

out1:
	if (sock->stschg_irq != -1)
		free_irq(sock->stschg_irq, sock);

	return ret;
}

static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
{
	if (sock->stschg_irq != -1)
		free_irq(sock->stschg_irq, sock);

	free_irq(sock->insert_irq, sock);
	if (sock->eject_irq != -1)
		free_irq(sock->eject_irq, sock);
}

/*
 * configure a PCMCIA socket on the Db1x00 series of boards (and
 * compatibles).
 *
 * 2 external registers are involved:
 *   pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
 *   pcmcia_control(offset 0x10):
 *	bits[0:1] set vcc for card
 *	bits[2:3] set vpp for card
 *	bit 4:	enable data buffers
 *	bit 7:	reset# for card
 *	add 8 for second socket.
 */
static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
				 struct socket_state_t *state)
{
	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	unsigned short cr_clr, cr_set;
	unsigned int changed;
	int v, p, ret;

	/* card voltage setup */
	cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
	cr_set = 0;
	v = p = ret = 0;

	switch (state->Vcc) {
	case 50:
		++v;
	case 33:
		++v;
	case 0:
		break;
	default:
		printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
			sock->nr, state->Vcc);
	}

	switch (state->Vpp) {
	case 12:
		++p;
	case 33:
	case 50:
		++p;
	case 0:
		break;
	default:
		printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
			sock->nr, state->Vpp);
	}

	/* sanity check: Vpp must be 0, 12, or Vcc */
	if (((state->Vcc == 33) && (state->Vpp == 50)) ||
	    ((state->Vcc == 50) && (state->Vpp == 33))) {
		printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
			sock->nr, state->Vcc, state->Vpp);
		v = p = 0;
		ret = -EINVAL;
	}

	/* create new voltage code */
	if (sock->board_type != BOARD_TYPE_DB1300)
		cr_set |= ((v << 2) | p) << (sock->nr * 8);

	changed = state->flags ^ sock->old_flags;

	if (changed & SS_RESET) {
		if (state->flags & SS_RESET) {
			set_stschg(sock, 0);
			/* assert reset, disable io buffers */
			cr_clr |= (1 << (7 + (sock->nr * 8)));
			cr_clr |= (1 << (4 + (sock->nr * 8)));
		} else {
			/* de-assert reset, enable io buffers */
			cr_set |= 1 << (7 + (sock->nr * 8));
			cr_set |= 1 << (4 + (sock->nr * 8));
		}
	}

	/* update PCMCIA configuration */
	bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);

	sock->old_flags = state->flags;

	/* reset was taken away: give card time to initialize properly */
	if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
		msleep(500);
		set_stschg(sock, 1);
	}

	return ret;
}

/* VCC bits at [3:2]/[11:10] */
#define GET_VCC(cr, socknr)		\
	((((cr) >> 2) >> ((socknr) * 8)) & 3)

/* VS bits at [0:1]/[3:2] */
#define GET_VS(sr, socknr)		\
	(((sr) >> (2 * (socknr))) & 3)

/* reset bits at [7]/[15] */
#define GET_RESET(cr, socknr)		\
	((cr) & (1 << (7 + (8 * (socknr)))))

static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
				  unsigned int *value)
{
	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	unsigned short cr, sr;
	unsigned int status;

	status = db1x_card_inserted(sock) ? SS_DETECT : 0;

	cr = bcsr_read(BCSR_PCMCIA);
	sr = bcsr_read(BCSR_STATUS);

	/* PB1100/PB1500: voltage key bits are at [5:4] */
	if (sock->board_type == BOARD_TYPE_PB1100)
		sr >>= 4;

	/* determine card type */
	switch (GET_VS(sr, sock->nr)) {
	case 0:
	case 2:
		status |= SS_3VCARD;	/* 3V card */
	case 3:
		break;			/* 5V card: set nothing */
	default:
		status |= SS_XVCARD;	/* treated as unsupported in core */
	}

	/* if Vcc is not zero, we have applied power to a card */
	status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;

	/* DB1300: power always on, but don't tell when no card present */
	if ((sock->board_type == BOARD_TYPE_DB1300) && (status & SS_DETECT))
		status = SS_POWERON | SS_3VCARD | SS_DETECT;

	/* reset de-asserted? then we're ready */
	status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;

	*value = status;

	return 0;
}

static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
{
	return 0;
}

static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
{
	return 0;
}

static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
				    struct pccard_io_map *map)
{
	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);

	map->start = (u32)sock->virt_io;
	map->stop = map->start + IO_MAP_SIZE;

	return 0;
}

static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
				     struct pccard_mem_map *map)
{
	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);

	if (map->flags & MAP_ATTRIB)
		map->static_start = sock->phys_attr + map->card_start;
	else
		map->static_start = sock->phys_mem + map->card_start;

	return 0;
}

static struct pccard_operations db1x_pcmcia_operations = {
	.init			= db1x_pcmcia_sock_init,
	.suspend		= db1x_pcmcia_sock_suspend,
	.get_status		= db1x_pcmcia_get_status,
	.set_socket		= db1x_pcmcia_configure,
	.set_io_map		= au1x00_pcmcia_set_io_map,
	.set_mem_map		= au1x00_pcmcia_set_mem_map,
};

static int db1x_pcmcia_socket_probe(struct platform_device *pdev)
{
	struct db1x_pcmcia_sock *sock;
	struct resource *r;
	int ret, bid;

	sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
	if (!sock)
		return -ENOMEM;

	sock->nr = pdev->id;

	bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
	switch (bid) {
	case BCSR_WHOAMI_PB1500:
	case BCSR_WHOAMI_PB1500R2:
	case BCSR_WHOAMI_PB1100:
		sock->board_type = BOARD_TYPE_PB1100;
		break;
	case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
		sock->board_type = BOARD_TYPE_DEFAULT;
		break;
	case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
		sock->board_type = BOARD_TYPE_DB1200;
		break;
	case BCSR_WHOAMI_DB1300:
		sock->board_type = BOARD_TYPE_DB1300;
		break;
	default:
		printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
		ret = -ENODEV;
		goto out0;
	};

	/*
	 * gather resources necessary and optional nice-to-haves to
	 * operate a socket:
	 * This includes IRQs for Carddetection/ejection, the card
	 *  itself and optional status change detection.
	 * Also, the memory areas covered by a socket.  For these
	 *  we require the real 36bit addresses (see the au1000.h
	 *  header for more information).
	 */

	/* card: irq assigned to the card itself. */
	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
	sock->card_irq = r ? r->start : 0;

	/* insert: irq which triggers on card insertion/ejection
	 * BIG FAT NOTE: on DB1000/1100/1500/1550 we pass a GPIO here!
	 */
	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
	sock->insert_irq = r ? r->start : -1;
	if (sock->board_type == BOARD_TYPE_DEFAULT) {
		sock->insert_gpio = r ? r->start : -1;
		sock->insert_irq = r ? gpio_to_irq(r->start) : -1;
	}

	/* stschg: irq which trigger on card status change (optional) */
	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
	sock->stschg_irq = r ? r->start : -1;

	/* eject: irq which triggers on ejection (DB1200/PB1200 only) */
	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
	sock->eject_irq = r ? r->start : -1;

	ret = -ENODEV;

	/* 36bit PCMCIA Attribute area address */
	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-attr");
	if (!r) {
		printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
			sock->nr);
		goto out0;
	}
	sock->phys_attr = r->start;

	/* 36bit PCMCIA Memory area address */
	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-mem");
	if (!r) {
		printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
			sock->nr);
		goto out0;
	}
	sock->phys_mem = r->start;

	/* 36bit PCMCIA IO area address */
	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-io");
	if (!r) {
		printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
			sock->nr);
		goto out0;
	}
	sock->phys_io = r->start;

	/*
	 * PCMCIA client drivers use the inb/outb macros to access
	 * the IO registers.  Since mips_io_port_base is added
	 * to the access address of the mips implementation of
	 * inb/outb, we need to subtract it here because we want
	 * to access the I/O or MEM address directly, without
	 * going through this "mips_io_port_base" mechanism.
	 */
	sock->virt_io = (void *)(ioremap(sock->phys_io, IO_MAP_SIZE) -
				 mips_io_port_base);

	if (!sock->virt_io) {
		printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
			sock->nr);
		ret = -ENOMEM;
		goto out0;
	}

	sock->socket.ops	= &db1x_pcmcia_operations;
	sock->socket.owner	= THIS_MODULE;
	sock->socket.pci_irq	= sock->card_irq;
	sock->socket.features	= SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
	sock->socket.map_size	= MEM_MAP_SIZE;
	sock->socket.io_offset	= (unsigned long)sock->virt_io;
	sock->socket.dev.parent	= &pdev->dev;
	sock->socket.resource_ops = &pccard_static_ops;

	platform_set_drvdata(pdev, sock);

	ret = db1x_pcmcia_setup_irqs(sock);
	if (ret) {
		printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
			sock->nr);
		goto out1;
	}

	set_stschg(sock, 0);

	ret = pcmcia_register_socket(&sock->socket);
	if (ret) {
		printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
		goto out2;
	}

	printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %09llx"
		"(%p) %09llx %09llx  card/insert/stschg/eject irqs @ %d "
		"%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
		sock->phys_attr, sock->phys_mem, sock->card_irq,
		sock->insert_irq, sock->stschg_irq, sock->eject_irq);

	return 0;

out2:
	db1x_pcmcia_free_irqs(sock);
out1:
	iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
out0:
	kfree(sock);
	return ret;
}

static int db1x_pcmcia_socket_remove(struct platform_device *pdev)
{
	struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);

	db1x_pcmcia_free_irqs(sock);
	pcmcia_unregister_socket(&sock->socket);
	iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
	kfree(sock);

	return 0;
}

static struct platform_driver db1x_pcmcia_socket_driver = {
	.driver	= {
		.name	= "db1xxx_pcmcia",
	},
	.probe		= db1x_pcmcia_socket_probe,
	.remove		= db1x_pcmcia_socket_remove,
};

module_platform_driver(db1x_pcmcia_socket_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
MODULE_AUTHOR("Manuel Lauss");
Commit	Line	Data
66213b3c ML	1	/*
	2	* PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
	3	*
	4	* Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
	5	*
	6	*/
	7
	8	/* This is a fairly generic PCMCIA socket driver suitable for the
	9	* following Alchemy Development boards:
64cd04d0	10	* Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200, Db1300
66213b3c ML	11	*
	12	* The Db1000 is used as a reference: Per-socket card-, carddetect- and
	13	* statuschange IRQs connected to SoC GPIOs, control and status register
	14	* bits arranged in per-socket groups in an external PLD. All boards
	15	* listed here use this layout, including bit positions and meanings.
	16	* Of course there are exceptions in later boards:
	17	*
	18	* - Pb1100/Pb1500: single socket only; voltage key bits VS are
	19	* at STATUS[5:4] (instead of STATUS[1:0]).
	20	* - Au1200-based: additional card-eject irqs, irqs not gpios!
64cd04d0	21	* - Db1300: Db1200-like, no pwr ctrl, single socket (#1).
66213b3c ML	22	*/
	23
	24	#include <linux/delay.h>
	25	#include <linux/gpio.h>
	26	#include <linux/interrupt.h>
	27	#include <linux/pm.h>
3bf8d64d	28	#include <linux/module.h>
66213b3c ML	29	#include <linux/platform_device.h>
66213b3c ML	30	#include <linux/resource.h>
5a0e3ad6	31	#include <linux/slab.h>
66213b3c ML	32	#include <linux/spinlock.h>
66213b3c ML	33
66213b3c ML	34	#include <pcmcia/ss.h>
	35
	36	#include <asm/mach-au1x00/au1000.h>
	37	#include <asm/mach-db1x00/bcsr.h>
	38
	39	#define MEM_MAP_SIZE 0x400000
	40	#define IO_MAP_SIZE 0x1000
	41
	42	struct db1x_pcmcia_sock {
	43	struct pcmcia_socket socket;
	44	int nr; /* socket number */
	45	void *virt_io;
	46
11b897cf ML	47	phys_addr_t phys_io;
	48	phys_addr_t phys_attr;
	49	phys_addr_t phys_mem;
66213b3c ML	50
	51	/* previous flags for set_socket() */
	52	unsigned int old_flags;
	53
	54	/* interrupt sources: linux irq numbers! */
	55	int insert_irq; /* default carddetect irq */
	56	int stschg_irq; /* card-status-change irq */
	57	int card_irq; /* card irq */
	58	int eject_irq; /* db1200/pb1200 have these */
e34b6fcf	59	int insert_gpio; /* db1000 carddetect gpio */
66213b3c ML	60
	61	#define BOARD_TYPE_DEFAULT 0 /* most boards */
	62	#define BOARD_TYPE_DB1200 1 /* IRQs aren't gpios */
	63	#define BOARD_TYPE_PB1100 2 /* VS bits slightly different */
64cd04d0	64	#define BOARD_TYPE_DB1300 3 /* no power control */
66213b3c ML	65	int board_type;
	66	};
	67
	68	#define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)
	69
64cd04d0 ML	70	static int db1300_card_inserted(struct db1x_pcmcia_sock *sock)
	71	{
	72	return bcsr_read(BCSR_SIGSTAT) & (1 << 8);
	73	}
	74
66213b3c ML	75	/* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
	76	static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
	77	{
	78	unsigned short sigstat;
	79
	80	sigstat = bcsr_read(BCSR_SIGSTAT);
	81	return sigstat & 1 << (8 + 2 * sock->nr);
	82	}
	83
	84	/* carddetect gpio: low-active */
	85	static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
	86	{
e34b6fcf	87	return !gpio_get_value(sock->insert_gpio);
66213b3c ML	88	}
	89
	90	static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
	91	{
	92	switch (sock->board_type) {
	93	case BOARD_TYPE_DB1200:
	94	return db1200_card_inserted(sock);
64cd04d0 ML	95	case BOARD_TYPE_DB1300:
64cd04d0 ML	96	return db1300_card_inserted(sock);
66213b3c ML	97	default:
	98	return db1000_card_inserted(sock);
	99	}
	100	}
	101
	102	/* STSCHG tends to bounce heavily when cards are inserted/ejected.
	103	* To avoid this, the interrupt is normally disabled and only enabled
	104	* after reset to a card has been de-asserted.
	105	*/
	106	static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
	107	{
	108	if (sock->stschg_irq != -1) {
	109	if (en)
	110	enable_irq(sock->stschg_irq);
	111	else
	112	disable_irq(sock->stschg_irq);
	113	}
	114	}
	115
	116	static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
	117	{
	118	struct db1x_pcmcia_sock *sock = data;
	119
	120	pcmcia_parse_events(&sock->socket, SS_DETECT);
	121
	122	return IRQ_HANDLED;
	123	}
	124
	125	static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
	126	{
	127	struct db1x_pcmcia_sock *sock = data;
	128
	129	pcmcia_parse_events(&sock->socket, SS_STSCHG);
	130
	131	return IRQ_HANDLED;
	132	}
	133
	134	static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
	135	{
	136	struct db1x_pcmcia_sock *sock = data;
	137
	138	/* Db/Pb1200 have separate per-socket insertion and ejection
	139	* interrupts which stay asserted as long as the card is
	140	* inserted/missing. The one which caused us to be called
	141	* needs to be disabled and the other one enabled.
	142	*/
	143	if (irq == sock->insert_irq) {
	144	disable_irq_nosync(sock->insert_irq);
	145	enable_irq(sock->eject_irq);
	146	} else {
	147	disable_irq_nosync(sock->eject_irq);
	148	enable_irq(sock->insert_irq);
	149	}
	150
	151	pcmcia_parse_events(&sock->socket, SS_DETECT);
	152
	153	return IRQ_HANDLED;
	154	}
	155
	156	static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
	157	{
	158	int ret;
66213b3c ML	159
	160	if (sock->stschg_irq != -1) {
	161	ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
	162	0, "pcmcia_stschg", sock);
	163	if (ret)
	164	return ret;
	165	}
	166
	167	/* Db/Pb1200 have separate per-socket insertion and ejection
	168	* interrupts, which should show edge behaviour but don't.
	169	* So interrupts are disabled until both insertion and
	170	* ejection handler have been registered and the currently
	171	* active one disabled.
	172	*/
64cd04d0 ML	173	if ((sock->board_type == BOARD_TYPE_DB1200) \|\|
64cd04d0 ML	174	(sock->board_type == BOARD_TYPE_DB1300)) {
66213b3c	175	ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq,
d571c79e	176	0, "pcmcia_insert", sock);
0000a539	177	if (ret)
66213b3c ML	178	goto out1;
	179
	180	ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq,
d571c79e	181	0, "pcmcia_eject", sock);
66213b3c ML	182	if (ret) {
66213b3c ML	183	free_irq(sock->insert_irq, sock);
66213b3c ML	184	goto out1;
	185	}
	186
0000a539	187	/* enable the currently silent one */
64cd04d0	188	if (db1x_card_inserted(sock))
0000a539	189	enable_irq(sock->eject_irq);
66213b3c	190	else
0000a539	191	enable_irq(sock->insert_irq);
66213b3c ML	192	} else {
	193	/* all other (older) Db1x00 boards use a GPIO to show
	194	* card detection status: use both-edge triggers.
	195	*/
dced35ae	196	irq_set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
66213b3c ML	197	ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
	198	0, "pcmcia_carddetect", sock);
	199
	200	if (ret)
	201	goto out1;
	202	}
	203
	204	return 0; /* all done */
	205
	206	out1:
	207	if (sock->stschg_irq != -1)
	208	free_irq(sock->stschg_irq, sock);
	209
	210	return ret;
	211	}
	212
	213	static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
	214	{
	215	if (sock->stschg_irq != -1)
	216	free_irq(sock->stschg_irq, sock);
	217
	218	free_irq(sock->insert_irq, sock);
	219	if (sock->eject_irq != -1)
	220	free_irq(sock->eject_irq, sock);
	221	}
	222
	223	/*
	224	* configure a PCMCIA socket on the Db1x00 series of boards (and
	225	* compatibles).
	226	*
	227	* 2 external registers are involved:
	228	* pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
	229	* pcmcia_control(offset 0x10):
	230	* bits[0:1] set vcc for card
	231	* bits[2:3] set vpp for card
	232	* bit 4: enable data buffers
	233	* bit 7: reset# for card
	234	* add 8 for second socket.
	235	*/
	236	static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
	237	struct socket_state_t *state)
	238	{
	239	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	240	unsigned short cr_clr, cr_set;
	241	unsigned int changed;
	242	int v, p, ret;
	243
	244	/* card voltage setup */
	245	cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
	246	cr_set = 0;
	247	v = p = ret = 0;
	248
	249	switch (state->Vcc) {
	250	case 50:
	251	++v;
	252	case 33:
	253	++v;
	254	case 0:
	255	break;
	256	default:
	257	printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
	258	sock->nr, state->Vcc);
	259	}
	260
261	switch (state->Vpp) {
262	case 12:
263	++p;
264	case 33:
265	case 50:
266	++p;
267	case 0:
268	break;
269	default:
270	printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
271	sock->nr, state->Vpp);
272	}
273
274	/* sanity check: Vpp must be 0, 12, or Vcc */
275	if (((state->Vcc == 33) && (state->Vpp == 50)) \|\|
276	((state->Vcc == 50) && (state->Vpp == 33))) {
277	printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
278	sock->nr, state->Vcc, state->Vpp);
279	v = p = 0;
280	ret = -EINVAL;
281	}
282
283	/* create new voltage code */
64cd04d0 ML	284	if (sock->board_type != BOARD_TYPE_DB1300)
64cd04d0 ML	285	cr_set \|= ((v << 2) \| p) << (sock->nr * 8);
66213b3c ML	286
	287	changed = state->flags ^ sock->old_flags;
	288
	289	if (changed & SS_RESET) {
	290	if (state->flags & SS_RESET) {
	291	set_stschg(sock, 0);
	292	/* assert reset, disable io buffers */
	293	cr_clr \|= (1 << (7 + (sock->nr * 8)));
	294	cr_clr \|= (1 << (4 + (sock->nr * 8)));
	295	} else {
	296	/* de-assert reset, enable io buffers */
	297	cr_set \|= 1 << (7 + (sock->nr * 8));
	298	cr_set \|= 1 << (4 + (sock->nr * 8));
	299	}
	300	}
	301
	302	/* update PCMCIA configuration */
	303	bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);
	304
	305	sock->old_flags = state->flags;
	306
	307	/* reset was taken away: give card time to initialize properly */
	308	if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
	309	msleep(500);
	310	set_stschg(sock, 1);
	311	}
	312
	313	return ret;
	314	}
	315
	316	/* VCC bits at [3:2]/[11:10] */
	317	#define GET_VCC(cr, socknr) \
	318	((((cr) >> 2) >> ((socknr) * 8)) & 3)
	319
	320	/* VS bits at [0:1]/[3:2] */
	321	#define GET_VS(sr, socknr) \
	322	(((sr) >> (2 * (socknr))) & 3)
	323
	324	/* reset bits at [7]/[15] */
	325	#define GET_RESET(cr, socknr) \
	326	((cr) & (1 << (7 + (8 * (socknr)))))
	327
	328	static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
	329	unsigned int *value)
	330	{
	331	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	332	unsigned short cr, sr;
	333	unsigned int status;
	334
	335	status = db1x_card_inserted(sock) ? SS_DETECT : 0;
	336
	337	cr = bcsr_read(BCSR_PCMCIA);
	338	sr = bcsr_read(BCSR_STATUS);
	339
	340	/* PB1100/PB1500: voltage key bits are at [5:4] */
	341	if (sock->board_type == BOARD_TYPE_PB1100)
	342	sr >>= 4;
	343
	344	/* determine card type */
	345	switch (GET_VS(sr, sock->nr)) {
	346	case 0:
	347	case 2:
	348	status \|= SS_3VCARD; /* 3V card */
	349	case 3:
350	break; /* 5V card: set nothing */
351	default:
352	status \|= SS_XVCARD; /* treated as unsupported in core */
353	}
354
355	/* if Vcc is not zero, we have applied power to a card */
356	status \|= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;
357
64cd04d0 ML	358	/* DB1300: power always on, but don't tell when no card present */
	359	if ((sock->board_type == BOARD_TYPE_DB1300) && (status & SS_DETECT))
	360	status = SS_POWERON \| SS_3VCARD \| SS_DETECT;
	361
66213b3c ML	362	/* reset de-asserted? then we're ready */
	363	status \|= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;
	364
	365	*value = status;
	366
	367	return 0;
	368	}
	369
	370	static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
	371	{
	372	return 0;
	373	}
	374
	375	static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
	376	{
	377	return 0;
	378	}
	379
	380	static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
	381	struct pccard_io_map *map)
	382	{
	383	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	384
	385	map->start = (u32)sock->virt_io;
	386	map->stop = map->start + IO_MAP_SIZE;
	387
	388	return 0;
	389	}
	390
	391	static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
	392	struct pccard_mem_map *map)
	393	{
	394	struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
	395
	396	if (map->flags & MAP_ATTRIB)
	397	map->static_start = sock->phys_attr + map->card_start;
	398	else
	399	map->static_start = sock->phys_mem + map->card_start;
	400
	401	return 0;
	402	}
	403
	404	static struct pccard_operations db1x_pcmcia_operations = {
	405	.init = db1x_pcmcia_sock_init,
	406	.suspend = db1x_pcmcia_sock_suspend,
	407	.get_status = db1x_pcmcia_get_status,
	408	.set_socket = db1x_pcmcia_configure,
	409	.set_io_map = au1x00_pcmcia_set_io_map,
	410	.set_mem_map = au1x00_pcmcia_set_mem_map,
	411	};
	412
34cdf25a	413	static int db1x_pcmcia_socket_probe(struct platform_device *pdev)
66213b3c ML	414	{
	415	struct db1x_pcmcia_sock *sock;
	416	struct resource *r;
66213b3c ML	417	int ret, bid;
	418
	419	sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
	420	if (!sock)
	421	return -ENOMEM;
	422
	423	sock->nr = pdev->id;
	424
	425	bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
	426	switch (bid) {
	427	case BCSR_WHOAMI_PB1500:
	428	case BCSR_WHOAMI_PB1500R2:
	429	case BCSR_WHOAMI_PB1100:
	430	sock->board_type = BOARD_TYPE_PB1100;
	431	break;
	432	case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
	433	sock->board_type = BOARD_TYPE_DEFAULT;
	434	break;
	435	case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
	436	sock->board_type = BOARD_TYPE_DB1200;
	437	break;
64cd04d0 ML	438	case BCSR_WHOAMI_DB1300:
	439	sock->board_type = BOARD_TYPE_DB1300;
	440	break;
66213b3c ML	441	default:
	442	printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
	443	ret = -ENODEV;
	444	goto out0;
	445	};
	446
	447	/*
	448	* gather resources necessary and optional nice-to-haves to
	449	* operate a socket:
	450	* This includes IRQs for Carddetection/ejection, the card
	451	* itself and optional status change detection.
	452	* Also, the memory areas covered by a socket. For these
f25e188c	453	* we require the real 36bit addresses (see the au1000.h
66213b3c ML	454	* header for more information).
	455	*/
	456
	457	/* card: irq assigned to the card itself. */
	458	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
	459	sock->card_irq = r ? r->start : 0;
	460
e34b6fcf ML	461	/* insert: irq which triggers on card insertion/ejection
	462	* BIG FAT NOTE: on DB1000/1100/1500/1550 we pass a GPIO here!
	463	*/
66213b3c ML	464	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
66213b3c ML	465	sock->insert_irq = r ? r->start : -1;
e34b6fcf ML	466	if (sock->board_type == BOARD_TYPE_DEFAULT) {
	467	sock->insert_gpio = r ? r->start : -1;
	468	sock->insert_irq = r ? gpio_to_irq(r->start) : -1;
	469	}
66213b3c ML	470
	471	/* stschg: irq which trigger on card status change (optional) */
	472	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
	473	sock->stschg_irq = r ? r->start : -1;
	474
	475	/* eject: irq which triggers on ejection (DB1200/PB1200 only) */
	476	r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
	477	sock->eject_irq = r ? r->start : -1;
	478
	479	ret = -ENODEV;
	480
f25e188c	481	/* 36bit PCMCIA Attribute area address */
11b897cf	482	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-attr");
66213b3c ML	483	if (!r) {
	484	printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
	485	sock->nr);
	486	goto out0;
	487	}
	488	sock->phys_attr = r->start;
	489
f25e188c	490	/* 36bit PCMCIA Memory area address */
11b897cf	491	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-mem");
66213b3c ML	492	if (!r) {
	493	printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
	494	sock->nr);
	495	goto out0;
	496	}
	497	sock->phys_mem = r->start;
	498
f25e188c	499	/* 36bit PCMCIA IO area address */
11b897cf	500	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-io");
66213b3c ML	501	if (!r) {
	502	printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
	503	sock->nr);
	504	goto out0;
	505	}
	506	sock->phys_io = r->start;
	507
66213b3c ML	508	/*
	509	* PCMCIA client drivers use the inb/outb macros to access
	510	* the IO registers. Since mips_io_port_base is added
	511	* to the access address of the mips implementation of
	512	* inb/outb, we need to subtract it here because we want
	513	* to access the I/O or MEM address directly, without
	514	* going through this "mips_io_port_base" mechanism.
	515	*/
11b897cf	516	sock->virt_io = (void *)(ioremap(sock->phys_io, IO_MAP_SIZE) -
66213b3c ML	517	mips_io_port_base);
	518
	519	if (!sock->virt_io) {
	520	printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
	521	sock->nr);
	522	ret = -ENOMEM;
	523	goto out0;
	524	}
	525
	526	sock->socket.ops = &db1x_pcmcia_operations;
	527	sock->socket.owner = THIS_MODULE;
	528	sock->socket.pci_irq = sock->card_irq;
	529	sock->socket.features = SS_CAP_STATIC_MAP \| SS_CAP_PCCARD;
	530	sock->socket.map_size = MEM_MAP_SIZE;
	531	sock->socket.io_offset = (unsigned long)sock->virt_io;
	532	sock->socket.dev.parent = &pdev->dev;
	533	sock->socket.resource_ops = &pccard_static_ops;
	534
	535	platform_set_drvdata(pdev, sock);
	536
	537	ret = db1x_pcmcia_setup_irqs(sock);
	538	if (ret) {
	539	printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
	540	sock->nr);
	541	goto out1;
	542	}
	543
	544	set_stschg(sock, 0);
	545
	546	ret = pcmcia_register_socket(&sock->socket);
	547	if (ret) {
	548	printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
	549	goto out2;
	550	}
	551
11b897cf ML	552	printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %09llx"
11b897cf ML	553	"(%p) %09llx %09llx card/insert/stschg/eject irqs @ %d "
66213b3c ML	554	"%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
	555	sock->phys_attr, sock->phys_mem, sock->card_irq,
	556	sock->insert_irq, sock->stschg_irq, sock->eject_irq);
	557
	558	return 0;
	559
	560	out2:
	561	db1x_pcmcia_free_irqs(sock);
	562	out1:
	563	iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
	564	out0:
	565	kfree(sock);
	566	return ret;
	567	}
	568
e765a02c	569	static int db1x_pcmcia_socket_remove(struct platform_device *pdev)
66213b3c ML	570	{
	571	struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);
	572
	573	db1x_pcmcia_free_irqs(sock);
	574	pcmcia_unregister_socket(&sock->socket);
	575	iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
	576	kfree(sock);
	577
	578	return 0;
	579	}
	580
66213b3c ML	581	static struct platform_driver db1x_pcmcia_socket_driver = {
	582	.driver = {
	583	.name = "db1xxx_pcmcia",
66213b3c ML	584	},
66213b3c ML	585	.probe = db1x_pcmcia_socket_probe,
96364e3a	586	.remove = db1x_pcmcia_socket_remove,
66213b3c ML	587	};
66213b3c ML	588
5d95f8e2	589	module_platform_driver(db1x_pcmcia_socket_driver);
66213b3c ML	590
	591	MODULE_LICENSE("GPL");
	592	MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
	593	MODULE_AUTHOR("Manuel Lauss");