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

/*
 *
 * Alchemy Semi Au1000 pcmcia driver
 *
 * Copyright 2001-2003 MontaVista Software Inc.
 * Author: MontaVista Software, Inc.
 *         	ppopov@embeddedalley.com or source@mvista.com
 *
 * Copyright 2004 Pete Popov, Embedded Alley Solutions, Inc.
 * Updated the driver to 2.6. Followed the sa11xx API and largely
 * copied many of the hardware independent functions.
 *
 * ########################################################################
 *
 *  This program is free software; you can distribute it and/or modify it
 *  under the terms of the GNU General Public License (Version 2) as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * ########################################################################
 *
 * 
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/notifier.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/system.h>

#include <asm/mach-au1x00/au1000.h>
#include "au1000_generic.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Pete Popov <ppopov@embeddedalley.com>");
MODULE_DESCRIPTION("Linux PCMCIA Card Services: Au1x00 Socket Controller");

#if 0
#define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
#else
#define debug(x,args...)
#endif

#define MAP_SIZE 0x100000
extern struct au1000_pcmcia_socket au1000_pcmcia_socket[];
#define PCMCIA_SOCKET(x)	(au1000_pcmcia_socket + (x))
#define to_au1000_socket(x)	container_of(x, struct au1000_pcmcia_socket, socket)

/* Some boards like to support CF cards as IDE root devices, so they
 * grab pcmcia sockets directly.
 */
u32 *pcmcia_base_vaddrs[2];
extern const unsigned long mips_io_port_base;

static DEFINE_MUTEX(pcmcia_sockets_lock);

static int (*au1x00_pcmcia_hw_init[])(struct device *dev) = {
	au1x_board_init,
};

static int
au1x00_pcmcia_skt_state(struct au1000_pcmcia_socket *skt)
{
	struct pcmcia_state state;
	unsigned int stat;

	memset(&state, 0, sizeof(struct pcmcia_state));

	skt->ops->socket_state(skt, &state);

	stat = state.detect  ? SS_DETECT : 0;
	stat |= state.ready  ? SS_READY  : 0;
	stat |= state.wrprot ? SS_WRPROT : 0;
	stat |= state.vs_3v  ? SS_3VCARD : 0;
	stat |= state.vs_Xv  ? SS_XVCARD : 0;
	stat |= skt->cs_state.Vcc ? SS_POWERON : 0;

	if (skt->cs_state.flags & SS_IOCARD)
		stat |= state.bvd1 ? SS_STSCHG : 0;
	else {
		if (state.bvd1 == 0)
			stat |= SS_BATDEAD;
		else if (state.bvd2 == 0)
			stat |= SS_BATWARN;
	}
	return stat;
}

/*
 * au100_pcmcia_config_skt
 *
 * Convert PCMCIA socket state to our socket configure structure.
 */
static int
au1x00_pcmcia_config_skt(struct au1000_pcmcia_socket *skt, socket_state_t *state)
{
	int ret;

	ret = skt->ops->configure_socket(skt, state);
	if (ret == 0) {
		skt->cs_state = *state;
	}

	if (ret < 0)
		debug("unable to configure socket %d\n", skt->nr);

	return ret;
}

/* au1x00_pcmcia_sock_init()
 *
 * (Re-)Initialise the socket, turning on status interrupts
 * and PCMCIA bus.  This must wait for power to stabilise
 * so that the card status signals report correctly.
 *
 * Returns: 0
 */
static int au1x00_pcmcia_sock_init(struct pcmcia_socket *sock)
{
	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);

	debug("initializing socket %u\n", skt->nr);

	skt->ops->socket_init(skt);
	return 0;
}

/*
 * au1x00_pcmcia_suspend()
 *
 * Remove power on the socket, disable IRQs from the card.
 * Turn off status interrupts, and disable the PCMCIA bus.
 *
 * Returns: 0
 */
static int au1x00_pcmcia_suspend(struct pcmcia_socket *sock)
{
	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);

	debug("suspending socket %u\n", skt->nr);

	skt->ops->socket_suspend(skt);

	return 0;
}

static DEFINE_SPINLOCK(status_lock);

/*
 * au1x00_check_status()
 */
static void au1x00_check_status(struct au1000_pcmcia_socket *skt)
{
	unsigned int events;

	debug("entering PCMCIA monitoring thread\n");

	do {
		unsigned int status;
		unsigned long flags;

		status = au1x00_pcmcia_skt_state(skt);

		spin_lock_irqsave(&status_lock, flags);
		events = (status ^ skt->status) & skt->cs_state.csc_mask;
		skt->status = status;
		spin_unlock_irqrestore(&status_lock, flags);

		debug("events: %s%s%s%s%s%s\n",
			events == 0         ? "<NONE>"   : "",
			events & SS_DETECT  ? "DETECT "  : "",
			events & SS_READY   ? "READY "   : "",
			events & SS_BATDEAD ? "BATDEAD " : "",
			events & SS_BATWARN ? "BATWARN " : "",
			events & SS_STSCHG  ? "STSCHG "  : "");

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

/* 
 * au1x00_pcmcia_poll_event()
 * Let's poll for events in addition to IRQs since IRQ only is unreliable...
 */
static void au1x00_pcmcia_poll_event(unsigned long dummy)
{
	struct au1000_pcmcia_socket *skt = (struct au1000_pcmcia_socket *)dummy;
	debug("polling for events\n");

	mod_timer(&skt->poll_timer, jiffies + AU1000_PCMCIA_POLL_PERIOD);

	au1x00_check_status(skt);
}

/* au1x00_pcmcia_get_status()
 *
 * From the sa11xx_core.c:
 * Implements the get_status() operation for the in-kernel PCMCIA
 * service (formerly SS_GetStatus in Card Services). Essentially just
 * fills in bits in `status' according to internal driver state or
 * the value of the voltage detect chipselect register.
 *
 * As a debugging note, during card startup, the PCMCIA core issues
 * three set_socket() commands in a row the first with RESET deasserted,
 * the second with RESET asserted, and the last with RESET deasserted
 * again. Following the third set_socket(), a get_status() command will
 * be issued. The kernel is looking for the SS_READY flag (see
 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 *
 * Returns: 0
 */
static int
au1x00_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
{
	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);

	skt->status = au1x00_pcmcia_skt_state(skt);
	*status = skt->status;

	return 0;
}

/* au1x00_pcmcia_set_socket()
 * 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.
 *
 * Returns: 0
 */
static int
au1x00_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
{
  struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);

  debug("for sock %u\n", skt->nr);

  debug("\tmask:  %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n",
	(state->csc_mask==0)?"<NONE>":"",
	(state->csc_mask&SS_DETECT)?"DETECT ":"",
	(state->csc_mask&SS_READY)?"READY ":"",
	(state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
	(state->csc_mask&SS_BATWARN)?"BATWARN ":"",
	(state->csc_mask&SS_STSCHG)?"STSCHG ":"",
	(state->flags==0)?"<NONE>":"",
	(state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
	(state->flags&SS_IOCARD)?"IOCARD ":"",
	(state->flags&SS_RESET)?"RESET ":"",
	(state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
	(state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"");
  debug("\tVcc %d  Vpp %d  irq %d\n",
	state->Vcc, state->Vpp, state->io_irq);

  return au1x00_pcmcia_config_skt(skt, state);
}

int 
au1x00_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
{
	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
	unsigned int speed;

	if(map->map>=MAX_IO_WIN){
		debug("map (%d) out of range\n", map->map);
		return -1;
	}

	if(map->flags&MAP_ACTIVE){
		speed=(map->speed>0)?map->speed:AU1000_PCMCIA_IO_SPEED;
		skt->spd_io[map->map] = speed;
	}

	map->start=(unsigned int)(u32)skt->virt_io;
	map->stop=map->start+MAP_SIZE;
	return 0;

}  /* au1x00_pcmcia_set_io_map() */


static int 
au1x00_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
{
	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
	unsigned short speed = map->speed;

	if(map->map>=MAX_WIN){
		debug("map (%d) out of range\n", map->map);
		return -1;
	}

	if (map->flags & MAP_ATTRIB) {
		skt->spd_attr[map->map] = speed;
		skt->spd_mem[map->map] = 0;
	} else {
		skt->spd_attr[map->map] = 0;
		skt->spd_mem[map->map] = speed;
	}

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

	debug("set_mem_map %d start %08lx card_start %08x\n",
			map->map, map->static_start, map->card_start);
	return 0;

}  /* au1x00_pcmcia_set_mem_map() */

static struct pccard_operations au1x00_pcmcia_operations = {
	.init			= au1x00_pcmcia_sock_init,
	.suspend		= au1x00_pcmcia_suspend,
	.get_status		= au1x00_pcmcia_get_status,
	.set_socket		= au1x00_pcmcia_set_socket,
	.set_io_map		= au1x00_pcmcia_set_io_map,
	.set_mem_map		= au1x00_pcmcia_set_mem_map,
};

static const char *skt_names[] = {
	"PCMCIA socket 0",
	"PCMCIA socket 1",
};

struct skt_dev_info {
	int nskt;
};

int au1x00_pcmcia_socket_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
{
	struct skt_dev_info *sinfo;
	struct au1000_pcmcia_socket *skt;
	int ret, i;

	sinfo = kzalloc(sizeof(struct skt_dev_info), GFP_KERNEL);
	if (!sinfo) {
		ret = -ENOMEM;
		goto out;
	}

	sinfo->nskt = nr;

	/*
	 * Initialise the per-socket structure.
	 */
	for (i = 0; i < nr; i++) {
		skt = PCMCIA_SOCKET(i);
		memset(skt, 0, sizeof(*skt));

		skt->socket.resource_ops = &pccard_static_ops;
		skt->socket.ops = &au1x00_pcmcia_operations;
		skt->socket.owner = ops->owner;
		skt->socket.dev.parent = dev;

		init_timer(&skt->poll_timer);
		skt->poll_timer.function = au1x00_pcmcia_poll_event;
		skt->poll_timer.data = (unsigned long)skt;
		skt->poll_timer.expires = jiffies + AU1000_PCMCIA_POLL_PERIOD;

		skt->nr		= first + i;
		skt->irq	= 255;
		skt->dev	= dev;
		skt->ops	= ops;

		skt->res_skt.name	= skt_names[skt->nr];
		skt->res_io.name	= "io";
		skt->res_io.flags	= IORESOURCE_MEM | IORESOURCE_BUSY;
		skt->res_mem.name	= "memory";
		skt->res_mem.flags	= IORESOURCE_MEM;
		skt->res_attr.name	= "attribute";
		skt->res_attr.flags	= IORESOURCE_MEM;

		/*
		 * 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.
		 */
		if (i == 0) {
			skt->virt_io = (void *)
				(ioremap((phys_t)AU1X_SOCK0_IO, 0x1000) -
				(u32)mips_io_port_base);
			skt->phys_attr = AU1X_SOCK0_PSEUDO_PHYS_ATTR;
			skt->phys_mem = AU1X_SOCK0_PSEUDO_PHYS_MEM;
		}
#ifndef CONFIG_MIPS_XXS1500
		else  {
			skt->virt_io = (void *)
				(ioremap((phys_t)AU1X_SOCK1_IO, 0x1000) -
				(u32)mips_io_port_base);
			skt->phys_attr = AU1X_SOCK1_PSEUDO_PHYS_ATTR;
			skt->phys_mem = AU1X_SOCK1_PSEUDO_PHYS_MEM;
		}
#endif
		pcmcia_base_vaddrs[i] = (u32 *)skt->virt_io;
		ret = ops->hw_init(skt);

		skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
		skt->socket.irq_mask = 0;
		skt->socket.map_size = MAP_SIZE;
		skt->socket.pci_irq = skt->irq;
		skt->socket.io_offset = (unsigned long)skt->virt_io;

		skt->status = au1x00_pcmcia_skt_state(skt);

		ret = pcmcia_register_socket(&skt->socket);
		if (ret)
			goto out_err;

		WARN_ON(skt->socket.sock != i);

		add_timer(&skt->poll_timer);
	}

	dev_set_drvdata(dev, sinfo);
	return 0;


out_err:
	flush_scheduled_work();
	ops->hw_shutdown(skt);
	while (i-- > 0) {
		skt = PCMCIA_SOCKET(i);

		del_timer_sync(&skt->poll_timer);
		pcmcia_unregister_socket(&skt->socket);
		flush_scheduled_work();
		if (i == 0) {
			iounmap(skt->virt_io + (u32)mips_io_port_base);
			skt->virt_io = NULL;
		}
#ifndef CONFIG_MIPS_XXS1500
		else {
			iounmap(skt->virt_io + (u32)mips_io_port_base);
			skt->virt_io = NULL;
		}
#endif
		ops->hw_shutdown(skt);

	}
	kfree(sinfo);
out:
	return ret;
}

int au1x00_drv_pcmcia_remove(struct platform_device *dev)
{
	struct skt_dev_info *sinfo = platform_get_drvdata(dev);
	int i;

	mutex_lock(&pcmcia_sockets_lock);
	platform_set_drvdata(dev, NULL);

	for (i = 0; i < sinfo->nskt; i++) {
		struct au1000_pcmcia_socket *skt = PCMCIA_SOCKET(i);

		del_timer_sync(&skt->poll_timer);
		pcmcia_unregister_socket(&skt->socket);
		flush_scheduled_work();
		skt->ops->hw_shutdown(skt);
		au1x00_pcmcia_config_skt(skt, &dead_socket);
		iounmap(skt->virt_io + (u32)mips_io_port_base);
		skt->virt_io = NULL;
	}

	kfree(sinfo);
	mutex_unlock(&pcmcia_sockets_lock);
	return 0;
}


/*
 * PCMCIA "Driver" API
 */

static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
{
	int i, ret = -ENODEV;

	mutex_lock(&pcmcia_sockets_lock);
	for (i=0; i < ARRAY_SIZE(au1x00_pcmcia_hw_init); i++) {
		ret = au1x00_pcmcia_hw_init[i](&dev->dev);
		if (ret == 0)
			break;
	}
	mutex_unlock(&pcmcia_sockets_lock);
	return ret;
}

static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
				     pm_message_t state)
{
	return pcmcia_socket_dev_suspend(&dev->dev);
}

static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
{
	return pcmcia_socket_dev_resume(&dev->dev);
}

static struct platform_driver au1x00_pcmcia_driver = {
	.driver = {
		.name		= "au1x00-pcmcia",
		.owner		= THIS_MODULE,
	},
	.probe		= au1x00_drv_pcmcia_probe,
	.remove		= au1x00_drv_pcmcia_remove,
	.suspend 	= au1x00_drv_pcmcia_suspend,
	.resume 	= au1x00_drv_pcmcia_resume,
};


/* au1x00_pcmcia_init()
 *
 * This routine performs low-level PCMCIA initialization and then
 * registers this socket driver with Card Services.
 *
 * Returns: 0 on success, -ve error code on failure
 */
static int __init au1x00_pcmcia_init(void)
{
	int error = 0;
	error = platform_driver_register(&au1x00_pcmcia_driver);
	return error;
}

/* au1x00_pcmcia_exit()
 * Invokes the low-level kernel service to free IRQs associated with this
 * socket controller and reset GPIO edge detection.
 */
static void __exit au1x00_pcmcia_exit(void)
{
	platform_driver_unregister(&au1x00_pcmcia_driver);
}

module_init(au1x00_pcmcia_init);
module_exit(au1x00_pcmcia_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Alchemy Semi Au1000 pcmcia driver
	4	*
	5	* Copyright 2001-2003 MontaVista Software Inc.
	6	* Author: MontaVista Software, Inc.
	7	* ppopov@embeddedalley.com or source@mvista.com
	8	*
	9	* Copyright 2004 Pete Popov, Embedded Alley Solutions, Inc.
	10	* Updated the driver to 2.6. Followed the sa11xx API and largely
	11	* copied many of the hardware independent functions.
	12	*
	13	* ########################################################################
	14	*
	15	* This program is free software; you can distribute it and/or modify it
	16	* under the terms of the GNU General Public License (Version 2) as
	17	* published by the Free Software Foundation.
	18	*
	19	* This program is distributed in the hope it will be useful, but WITHOUT
	20	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	21	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	22	* for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License along
	25	* with this program; if not, write to the Free Software Foundation, Inc.,
	26	* 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
	27	*
	28	* ########################################################################
	29	*
	30	*
	31	*/
	32
	33	#include <linux/module.h>
	34	#include <linux/moduleparam.h>
	35	#include <linux/init.h>
1da177e4 LT	36	#include <linux/cpufreq.h>
	37	#include <linux/ioport.h>
	38	#include <linux/kernel.h>
	39	#include <linux/timer.h>
	40	#include <linux/mm.h>
	41	#include <linux/notifier.h>
	42	#include <linux/interrupt.h>
	43	#include <linux/spinlock.h>
12d1e75d	44	#include <linux/mutex.h>
d052d1be	45	#include <linux/platform_device.h>
1da177e4 LT	46
	47	#include <asm/io.h>
	48	#include <asm/irq.h>
	49	#include <asm/system.h>
	50
	51	#include <asm/mach-au1x00/au1000.h>
	52	#include "au1000_generic.h"
	53
	54	MODULE_LICENSE("GPL");
	55	MODULE_AUTHOR("Pete Popov <ppopov@embeddedalley.com>");
	56	MODULE_DESCRIPTION("Linux PCMCIA Card Services: Au1x00 Socket Controller");
	57
	58	#if 0
	59	#define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
	60	#else
	61	#define debug(x,args...)
	62	#endif
	63
	64	#define MAP_SIZE 0x100000
	65	extern struct au1000_pcmcia_socket au1000_pcmcia_socket[];
	66	#define PCMCIA_SOCKET(x) (au1000_pcmcia_socket + (x))
	67	#define to_au1000_socket(x) container_of(x, struct au1000_pcmcia_socket, socket)
	68
	69	/* Some boards like to support CF cards as IDE root devices, so they
	70	* grab pcmcia sockets directly.
	71	*/
	72	u32 *pcmcia_base_vaddrs[2];
	73	extern const unsigned long mips_io_port_base;
	74
12d1e75d	75	static DEFINE_MUTEX(pcmcia_sockets_lock);
1da177e4 LT	76
	77	static int (au1x00_pcmcia_hw_init[])(struct device dev) = {
	78	au1x_board_init,
	79	};
	80
	81	static int
	82	au1x00_pcmcia_skt_state(struct au1000_pcmcia_socket *skt)
	83	{
	84	struct pcmcia_state state;
	85	unsigned int stat;
	86
	87	memset(&state, 0, sizeof(struct pcmcia_state));
	88
	89	skt->ops->socket_state(skt, &state);
	90
	91	stat = state.detect ? SS_DETECT : 0;
	92	stat \|= state.ready ? SS_READY : 0;
	93	stat \|= state.wrprot ? SS_WRPROT : 0;
	94	stat \|= state.vs_3v ? SS_3VCARD : 0;
	95	stat \|= state.vs_Xv ? SS_XVCARD : 0;
	96	stat \|= skt->cs_state.Vcc ? SS_POWERON : 0;
	97
	98	if (skt->cs_state.flags & SS_IOCARD)
	99	stat \|= state.bvd1 ? SS_STSCHG : 0;
	100	else {
	101	if (state.bvd1 == 0)
	102	stat \|= SS_BATDEAD;
	103	else if (state.bvd2 == 0)
	104	stat \|= SS_BATWARN;
	105	}
	106	return stat;
	107	}
	108
	109	/*
	110	* au100_pcmcia_config_skt
	111	*
	112	* Convert PCMCIA socket state to our socket configure structure.
	113	*/
	114	static int
	115	au1x00_pcmcia_config_skt(struct au1000_pcmcia_socket skt, socket_state_t state)
	116	{
	117	int ret;
	118
	119	ret = skt->ops->configure_socket(skt, state);
	120	if (ret == 0) {
	121	skt->cs_state = *state;
	122	}
	123
	124	if (ret < 0)
	125	debug("unable to configure socket %d\n", skt->nr);
	126
	127	return ret;
	128	}
	129
	130	/* au1x00_pcmcia_sock_init()
	131	*
	132	* (Re-)Initialise the socket, turning on status interrupts
	133	* and PCMCIA bus. This must wait for power to stabilise
	134	* so that the card status signals report correctly.
	135	*
	136	* Returns: 0
	137	*/
	138	static int au1x00_pcmcia_sock_init(struct pcmcia_socket *sock)
	139	{
140	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
141
142	debug("initializing socket %u\n", skt->nr);
143
144	skt->ops->socket_init(skt);
145	return 0;
146	}
147
148	/*
149	* au1x00_pcmcia_suspend()
150	*
151	* Remove power on the socket, disable IRQs from the card.
152	* Turn off status interrupts, and disable the PCMCIA bus.
153	*
154	* Returns: 0
155	*/
156	static int au1x00_pcmcia_suspend(struct pcmcia_socket *sock)
157	{
158	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
159
160	debug("suspending socket %u\n", skt->nr);
161
162	skt->ops->socket_suspend(skt);
163
164	return 0;
165	}
166
167	static DEFINE_SPINLOCK(status_lock);
168
169	/*
170	* au1x00_check_status()
171	*/
172	static void au1x00_check_status(struct au1000_pcmcia_socket *skt)
173	{
174	unsigned int events;
175
176	debug("entering PCMCIA monitoring thread\n");
177
178	do {
179	unsigned int status;
180	unsigned long flags;
181
182	status = au1x00_pcmcia_skt_state(skt);
183
184	spin_lock_irqsave(&status_lock, flags);
185	events = (status ^ skt->status) & skt->cs_state.csc_mask;
186	skt->status = status;
187	spin_unlock_irqrestore(&status_lock, flags);
188
189	debug("events: %s%s%s%s%s%s\n",
190	events == 0 ? "<NONE>" : "",
191	events & SS_DETECT ? "DETECT " : "",
192	events & SS_READY ? "READY " : "",
193	events & SS_BATDEAD ? "BATDEAD " : "",
194	events & SS_BATWARN ? "BATWARN " : "",
195	events & SS_STSCHG ? "STSCHG " : "");
196
197	if (events)
198	pcmcia_parse_events(&skt->socket, events);
199	} while (events);
200	}
201
202	/*
203	* au1x00_pcmcia_poll_event()
204	* Let's poll for events in addition to IRQs since IRQ only is unreliable...
205	*/
206	static void au1x00_pcmcia_poll_event(unsigned long dummy)
207	{
208	struct au1000_pcmcia_socket skt = (struct au1000_pcmcia_socket )dummy;
209	debug("polling for events\n");
210
211	mod_timer(&skt->poll_timer, jiffies + AU1000_PCMCIA_POLL_PERIOD);
212
213	au1x00_check_status(skt);
214	}
215
216	/* au1x00_pcmcia_get_status()
217	*
218	* From the sa11xx_core.c:
219	* Implements the get_status() operation for the in-kernel PCMCIA
220	* service (formerly SS_GetStatus in Card Services). Essentially just
221	* fills in bits in `status' according to internal driver state or
222	* the value of the voltage detect chipselect register.
223	*
224	* As a debugging note, during card startup, the PCMCIA core issues
225	* three set_socket() commands in a row the first with RESET deasserted,
226	* the second with RESET asserted, and the last with RESET deasserted
227	* again. Following the third set_socket(), a get_status() command will
228	* be issued. The kernel is looking for the SS_READY flag (see
229	* setup_socket(), reset_socket(), and unreset_socket() in cs.c).
230	*
231	* Returns: 0
232	*/
233	static int
234	au1x00_pcmcia_get_status(struct pcmcia_socket sock, unsigned int status)
235	{
236	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
237
238	skt->status = au1x00_pcmcia_skt_state(skt);
239	*status = skt->status;
240
241	return 0;
242	}
243
1da177e4 LT	244	/* au1x00_pcmcia_set_socket()
	245	* Implements the set_socket() operation for the in-kernel PCMCIA
	246	* service (formerly SS_SetSocket in Card Services). We more or
	247	* less punt all of this work and let the kernel handle the details
	248	* of power configuration, reset, &c. We also record the value of
	249	* `state' in order to regurgitate it to the PCMCIA core later.
	250	*
	251	* Returns: 0
	252	*/
	253	static int
	254	au1x00_pcmcia_set_socket(struct pcmcia_socket sock, socket_state_t state)
	255	{
	256	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
	257
	258	debug("for sock %u\n", skt->nr);
	259
	260	debug("\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n",
	261	(state->csc_mask==0)?"<NONE>":"",
	262	(state->csc_mask&SS_DETECT)?"DETECT ":"",
	263	(state->csc_mask&SS_READY)?"READY ":"",
	264	(state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
	265	(state->csc_mask&SS_BATWARN)?"BATWARN ":"",
	266	(state->csc_mask&SS_STSCHG)?"STSCHG ":"",
	267	(state->flags==0)?"<NONE>":"",
	268	(state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
	269	(state->flags&SS_IOCARD)?"IOCARD ":"",
	270	(state->flags&SS_RESET)?"RESET ":"",
	271	(state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
	272	(state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"");
	273	debug("\tVcc %d Vpp %d irq %d\n",
	274	state->Vcc, state->Vpp, state->io_irq);
	275
	276	return au1x00_pcmcia_config_skt(skt, state);
	277	}
	278
	279	int
	280	au1x00_pcmcia_set_io_map(struct pcmcia_socket sock, struct pccard_io_map map)
	281	{
	282	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
	283	unsigned int speed;
	284
	285	if(map->map>=MAX_IO_WIN){
	286	debug("map (%d) out of range\n", map->map);
	287	return -1;
	288	}
	289
	290	if(map->flags&MAP_ACTIVE){
	291	speed=(map->speed>0)?map->speed:AU1000_PCMCIA_IO_SPEED;
	292	skt->spd_io[map->map] = speed;
	293	}
	294
d39bd564	295	map->start=(unsigned int)(u32)skt->virt_io;
1da177e4 LT	296	map->stop=map->start+MAP_SIZE;
	297	return 0;
	298
	299	} /* au1x00_pcmcia_set_io_map() */
	300
	301
	302	static int
	303	au1x00_pcmcia_set_mem_map(struct pcmcia_socket sock, struct pccard_mem_map map)
	304	{
	305	struct au1000_pcmcia_socket *skt = to_au1000_socket(sock);
	306	unsigned short speed = map->speed;
	307
	308	if(map->map>=MAX_WIN){
	309	debug("map (%d) out of range\n", map->map);
	310	return -1;
	311	}
	312
	313	if (map->flags & MAP_ATTRIB) {
	314	skt->spd_attr[map->map] = speed;
	315	skt->spd_mem[map->map] = 0;
	316	} else {
	317	skt->spd_attr[map->map] = 0;
	318	skt->spd_mem[map->map] = speed;
	319	}
	320
	321	if (map->flags & MAP_ATTRIB) {
	322	map->static_start = skt->phys_attr + map->card_start;
	323	}
	324	else {
	325	map->static_start = skt->phys_mem + map->card_start;
	326	}
	327
	328	debug("set_mem_map %d start %08lx card_start %08x\n",
	329	map->map, map->static_start, map->card_start);
	330	return 0;
	331
	332	} /* au1x00_pcmcia_set_mem_map() */
	333
	334	static struct pccard_operations au1x00_pcmcia_operations = {
	335	.init = au1x00_pcmcia_sock_init,
	336	.suspend = au1x00_pcmcia_suspend,
	337	.get_status = au1x00_pcmcia_get_status,
1da177e4 LT	338	.set_socket = au1x00_pcmcia_set_socket,
	339	.set_io_map = au1x00_pcmcia_set_io_map,
	340	.set_mem_map = au1x00_pcmcia_set_mem_map,
	341	};
	342
	343	static const char *skt_names[] = {
	344	"PCMCIA socket 0",
	345	"PCMCIA socket 1",
	346	};
	347
	348	struct skt_dev_info {
	349	int nskt;
	350	};
	351
	352	int au1x00_pcmcia_socket_probe(struct device dev, struct pcmcia_low_level ops, int first, int nr)
	353	{
	354	struct skt_dev_info *sinfo;
a230a678	355	struct au1000_pcmcia_socket *skt;
1da177e4 LT	356	int ret, i;
1da177e4 LT	357
8084b372	358	sinfo = kzalloc(sizeof(struct skt_dev_info), GFP_KERNEL);
1da177e4 LT	359	if (!sinfo) {
	360	ret = -ENOMEM;
	361	goto out;
	362	}
	363
1da177e4 LT	364	sinfo->nskt = nr;
	365
	366	/*
	367	* Initialise the per-socket structure.
	368	*/
	369	for (i = 0; i < nr; i++) {
a230a678	370	skt = PCMCIA_SOCKET(i);
1da177e4 LT	371	memset(skt, 0, sizeof(*skt));
1da177e4 LT	372
dc33a4a3	373	skt->socket.resource_ops = &pccard_static_ops;
1da177e4 LT	374	skt->socket.ops = &au1x00_pcmcia_operations;
1da177e4 LT	375	skt->socket.owner = ops->owner;
88f45005	376	skt->socket.dev.parent = dev;
1da177e4 LT	377
	378	init_timer(&skt->poll_timer);
	379	skt->poll_timer.function = au1x00_pcmcia_poll_event;
	380	skt->poll_timer.data = (unsigned long)skt;
	381	skt->poll_timer.expires = jiffies + AU1000_PCMCIA_POLL_PERIOD;
	382
	383	skt->nr = first + i;
	384	skt->irq = 255;
	385	skt->dev = dev;
	386	skt->ops = ops;
	387
	388	skt->res_skt.name = skt_names[skt->nr];
	389	skt->res_io.name = "io";
	390	skt->res_io.flags = IORESOURCE_MEM \| IORESOURCE_BUSY;
	391	skt->res_mem.name = "memory";
	392	skt->res_mem.flags = IORESOURCE_MEM;
	393	skt->res_attr.name = "attribute";
	394	skt->res_attr.flags = IORESOURCE_MEM;
	395
	396	/*
	397	* PCMCIA client drivers use the inb/outb macros to access the
	398	* IO registers. Since mips_io_port_base is added to the
	399	* access address of the mips implementation of inb/outb,
	400	* we need to subtract it here because we want to access the
	401	* I/O or MEM address directly, without going through this
	402	* "mips_io_port_base" mechanism.
	403	*/
	404	if (i == 0) {
	405	skt->virt_io = (void *)
	406	(ioremap((phys_t)AU1X_SOCK0_IO, 0x1000) -
	407	(u32)mips_io_port_base);
	408	skt->phys_attr = AU1X_SOCK0_PSEUDO_PHYS_ATTR;
	409	skt->phys_mem = AU1X_SOCK0_PSEUDO_PHYS_MEM;
	410	}
	411	#ifndef CONFIG_MIPS_XXS1500
	412	else {
	413	skt->virt_io = (void *)
	414	(ioremap((phys_t)AU1X_SOCK1_IO, 0x1000) -
	415	(u32)mips_io_port_base);
	416	skt->phys_attr = AU1X_SOCK1_PSEUDO_PHYS_ATTR;
	417	skt->phys_mem = AU1X_SOCK1_PSEUDO_PHYS_MEM;
	418	}
	419	#endif
	420	pcmcia_base_vaddrs[i] = (u32 *)skt->virt_io;
	421	ret = ops->hw_init(skt);
	422
	423	skt->socket.features = SS_CAP_STATIC_MAP\|SS_CAP_PCCARD;
	424	skt->socket.irq_mask = 0;
	425	skt->socket.map_size = MAP_SIZE;
	426	skt->socket.pci_irq = skt->irq;
	427	skt->socket.io_offset = (unsigned long)skt->virt_io;
	428
	429	skt->status = au1x00_pcmcia_skt_state(skt);
	430
	431	ret = pcmcia_register_socket(&skt->socket);
	432	if (ret)
	433	goto out_err;
	434
	435	WARN_ON(skt->socket.sock != i);
	436
	437	add_timer(&skt->poll_timer);
	438	}
	439
	440	dev_set_drvdata(dev, sinfo);
441	return 0;
442
a230a678 ON	443
	444	out_err:
	445	flush_scheduled_work();
	446	ops->hw_shutdown(skt);
	447	while (i-- > 0) {
	448	skt = PCMCIA_SOCKET(i);
1da177e4 LT	449
	450	del_timer_sync(&skt->poll_timer);
	451	pcmcia_unregister_socket(&skt->socket);
1da177e4	452	flush_scheduled_work();
3efa9970 AL	453	if (i == 0) {
	454	iounmap(skt->virt_io + (u32)mips_io_port_base);
	455	skt->virt_io = NULL;
	456	}
	457	#ifndef CONFIG_MIPS_XXS1500
	458	else {
	459	iounmap(skt->virt_io + (u32)mips_io_port_base);
	460	skt->virt_io = NULL;
	461	}
	462	#endif
1da177e4 LT	463	ops->hw_shutdown(skt);
1da177e4 LT	464
a230a678	465	}
1da177e4 LT	466	kfree(sinfo);
	467	out:
	468	return ret;
	469	}
	470
7a192ec3	471	int au1x00_drv_pcmcia_remove(struct platform_device *dev)
1da177e4	472	{
7a192ec3	473	struct skt_dev_info *sinfo = platform_get_drvdata(dev);
1da177e4 LT	474	int i;
1da177e4 LT	475
12d1e75d	476	mutex_lock(&pcmcia_sockets_lock);
7a192ec3	477	platform_set_drvdata(dev, NULL);
1da177e4 LT	478
	479	for (i = 0; i < sinfo->nskt; i++) {
	480	struct au1000_pcmcia_socket *skt = PCMCIA_SOCKET(i);
	481
	482	del_timer_sync(&skt->poll_timer);
	483	pcmcia_unregister_socket(&skt->socket);
	484	flush_scheduled_work();
	485	skt->ops->hw_shutdown(skt);
	486	au1x00_pcmcia_config_skt(skt, &dead_socket);
efe29c0f	487	iounmap(skt->virt_io + (u32)mips_io_port_base);
1da177e4 LT	488	skt->virt_io = NULL;
	489	}
	490
	491	kfree(sinfo);
12d1e75d	492	mutex_unlock(&pcmcia_sockets_lock);
1da177e4 LT	493	return 0;
	494	}
	495
	496
	497	/*
	498	* PCMCIA "Driver" API
	499	*/
	500
7a192ec3	501	static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
1da177e4 LT	502	{
	503	int i, ret = -ENODEV;
	504
12d1e75d	505	mutex_lock(&pcmcia_sockets_lock);
1da177e4	506	for (i=0; i < ARRAY_SIZE(au1x00_pcmcia_hw_init); i++) {
7a192ec3	507	ret = au1x00_pcmcia_hw_init[i](&dev->dev);
1da177e4 LT	508	if (ret == 0)
	509	break;
	510	}
12d1e75d	511	mutex_unlock(&pcmcia_sockets_lock);
1da177e4 LT	512	return ret;
	513	}
	514
7a192ec3 ML	515	static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
	516	pm_message_t state)
	517	{
827b4649	518	return pcmcia_socket_dev_suspend(&dev->dev);
7a192ec3 ML	519	}
	520
	521	static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
	522	{
	523	return pcmcia_socket_dev_resume(&dev->dev);
	524	}
1da177e4	525
7a192ec3 ML	526	static struct platform_driver au1x00_pcmcia_driver = {
	527	.driver = {
	528	.name = "au1x00-pcmcia",
	529	.owner = THIS_MODULE,
	530	},
1da177e4 LT	531	.probe = au1x00_drv_pcmcia_probe,
1da177e4 LT	532	.remove = au1x00_drv_pcmcia_remove,
7a192ec3 ML	533	.suspend = au1x00_drv_pcmcia_suspend,
7a192ec3 ML	534	.resume = au1x00_drv_pcmcia_resume,
1da177e4 LT	535	};
1da177e4 LT	536
1da177e4 LT	537
	538	/* au1x00_pcmcia_init()
	539	*
	540	* This routine performs low-level PCMCIA initialization and then
	541	* registers this socket driver with Card Services.
	542	*
	543	* Returns: 0 on success, -ve error code on failure
	544	*/
	545	static int __init au1x00_pcmcia_init(void)
	546	{
	547	int error = 0;
7a192ec3	548	error = platform_driver_register(&au1x00_pcmcia_driver);
1da177e4 LT	549	return error;
	550	}
	551
	552	/* au1x00_pcmcia_exit()
	553	* Invokes the low-level kernel service to free IRQs associated with this
	554	* socket controller and reset GPIO edge detection.
	555	*/
	556	static void __exit au1x00_pcmcia_exit(void)
	557	{
7a192ec3	558	platform_driver_unregister(&au1x00_pcmcia_driver);
1da177e4 LT	559	}
	560
	561	module_init(au1x00_pcmcia_init);
	562	module_exit(au1x00_pcmcia_exit);