[linux.git] / drivers / pcmcia / au1000_db1x00.c

/*
 *
 * Alchemy Semi Db1x00 boards specific pcmcia routines.
 *
 * Copyright 2002 MontaVista Software Inc.
 * Author: MontaVista Software, Inc.
 *         	[email protected] or [email protected]
 *
 * Copyright 2004 Pete Popov, 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/kernel.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/init.h>

#include <asm/irq.h>
#include <asm/signal.h>
#include <asm/mach-au1x00/au1000.h>

#if defined(CONFIG_MIPS_DB1200)
	#include <db1200.h>
#elif defined(CONFIG_MIPS_PB1200)
	#include <pb1200.h>
#else
	#include <asm/mach-db1x00/db1x00.h>
	static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
#endif

#include "au1000_generic.h"

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


struct au1000_pcmcia_socket au1000_pcmcia_socket[PCMCIA_NUM_SOCKS];
extern int au1x00_pcmcia_socket_probe(struct device *, struct pcmcia_low_level *, int, int);

static int db1x00_pcmcia_hw_init(struct au1000_pcmcia_socket *skt)
{
#ifdef CONFIG_MIPS_DB1550
	skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_3;
#elif defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
	skt->irq = skt->nr ? BOARD_PC1_INT : BOARD_PC0_INT;
#else
	skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_2;
#endif
	return 0;
}

static void db1x00_pcmcia_shutdown(struct au1000_pcmcia_socket *skt)
{
	bcsr->pcmcia = 0; /* turn off power */
	au_sync_delay(2);
}

static void
db1x00_pcmcia_socket_state(struct au1000_pcmcia_socket *skt, struct pcmcia_state *state)
{
	u32 inserted;
	unsigned char vs;

	state->ready = 0;
	state->vs_Xv = 0;
	state->vs_3v = 0;
	state->detect = 0;

	switch (skt->nr) {
	case 0:
		vs = bcsr->status & 0x3;
#if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
		inserted = BOARD_CARD_INSERTED(0);
#else
		inserted = !(bcsr->status & (1<<4));
#endif
		break;
	case 1:
		vs = (bcsr->status & 0xC)>>2;
#if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
		inserted = BOARD_CARD_INSERTED(1);
#else
		inserted = !(bcsr->status & (1<<5));
#endif
		break;
	default:/* should never happen */
		return;
	}

	if (inserted)
		debug("db1x00 socket %d: inserted %d, vs %d pcmcia %x\n",
				skt->nr, inserted, vs, bcsr->pcmcia);

	if (inserted) {
		switch (vs) {
			case 0:
			case 2:
				state->vs_3v=1;
				break;
			case 3: /* 5V */
				break;
			default:
				/* return without setting 'detect' */
				printk(KERN_ERR "db1x00 bad VS (%d)\n",
						vs);
		}
		state->detect = 1;
		state->ready = 1;
	}
	else {
		/* if the card was previously inserted and then ejected,
		 * we should turn off power to it
		 */
		if ((skt->nr == 0) && (bcsr->pcmcia & BCSR_PCMCIA_PC0RST)) {
			bcsr->pcmcia &= ~(BCSR_PCMCIA_PC0RST |
					BCSR_PCMCIA_PC0DRVEN |
					BCSR_PCMCIA_PC0VPP |
					BCSR_PCMCIA_PC0VCC);
			au_sync_delay(10);
		}
		else if ((skt->nr == 1) && bcsr->pcmcia & BCSR_PCMCIA_PC1RST) {
			bcsr->pcmcia &= ~(BCSR_PCMCIA_PC1RST |
					BCSR_PCMCIA_PC1DRVEN |
					BCSR_PCMCIA_PC1VPP |
					BCSR_PCMCIA_PC1VCC);
			au_sync_delay(10);
		}
	}

	state->bvd1=1;
	state->bvd2=1;
	state->wrprot=0;
}

static int
db1x00_pcmcia_configure_socket(struct au1000_pcmcia_socket *skt, struct socket_state_t *state)
{
	u16 pwr;
	int sock = skt->nr;

	debug("config_skt %d Vcc %dV Vpp %dV, reset %d\n",
			sock, state->Vcc, state->Vpp,
			state->flags & SS_RESET);

	/* pcmcia reg was set to zero at init time. Be careful when
	 * initializing a socket not to wipe out the settings of the
	 * other socket.
	 */
	pwr = bcsr->pcmcia;
	pwr &= ~(0xf << sock*8); /* clear voltage settings */

	state->Vpp = 0;
	switch(state->Vcc){
		case 0:  /* Vcc 0 */
			pwr |= SET_VCC_VPP(0,0,sock);
			break;
		case 50: /* Vcc 5V */
			switch(state->Vpp) {
				case 0:
					pwr |= SET_VCC_VPP(2,0,sock);
					break;
				case 50:
					pwr |= SET_VCC_VPP(2,1,sock);
					break;
				case 12:
					pwr |= SET_VCC_VPP(2,2,sock);
					break;
				case 33:
				default:
					pwr |= SET_VCC_VPP(0,0,sock);
					printk("%s: bad Vcc/Vpp (%d:%d)\n",
							__FUNCTION__,
							state->Vcc,
							state->Vpp);
					break;
			}
			break;
		case 33: /* Vcc 3.3V */
			switch(state->Vpp) {
				case 0:
					pwr |= SET_VCC_VPP(1,0,sock);
					break;
				case 12:
					pwr |= SET_VCC_VPP(1,2,sock);
					break;
				case 33:
					pwr |= SET_VCC_VPP(1,1,sock);
					break;
				case 50:
				default:
					pwr |= SET_VCC_VPP(0,0,sock);
					printk("%s: bad Vcc/Vpp (%d:%d)\n",
							__FUNCTION__,
							state->Vcc,
							state->Vpp);
					break;
			}
			break;
		default: /* what's this ? */
			pwr |= SET_VCC_VPP(0,0,sock);
			printk(KERN_ERR "%s: bad Vcc %d\n",
					__FUNCTION__, state->Vcc);
			break;
	}

	bcsr->pcmcia = pwr;
	au_sync_delay(300);

	if (sock == 0) {
		if (!(state->flags & SS_RESET)) {
			pwr |= BCSR_PCMCIA_PC0DRVEN;
			bcsr->pcmcia = pwr;
			au_sync_delay(300);
			pwr |= BCSR_PCMCIA_PC0RST;
			bcsr->pcmcia = pwr;
			au_sync_delay(100);
		}
		else {
			pwr &= ~(BCSR_PCMCIA_PC0RST | BCSR_PCMCIA_PC0DRVEN);
			bcsr->pcmcia = pwr;
			au_sync_delay(100);
		}
	}
	else {
		if (!(state->flags & SS_RESET)) {
			pwr |= BCSR_PCMCIA_PC1DRVEN;
			bcsr->pcmcia = pwr;
			au_sync_delay(300);
			pwr |= BCSR_PCMCIA_PC1RST;
			bcsr->pcmcia = pwr;
			au_sync_delay(100);
		}
		else {
			pwr &= ~(BCSR_PCMCIA_PC1RST | BCSR_PCMCIA_PC1DRVEN);
			bcsr->pcmcia = pwr;
			au_sync_delay(100);
		}
	}
	return 0;
}

/*
 * Enable card status IRQs on (re-)initialisation.  This can
 * be called at initialisation, power management event, or
 * pcmcia event.
 */
void db1x00_socket_init(struct au1000_pcmcia_socket *skt)
{
	/* nothing to do for now */
}

/*
 * Disable card status IRQs and PCMCIA bus on suspend.
 */
void db1x00_socket_suspend(struct au1000_pcmcia_socket *skt)
{
	/* nothing to do for now */
}

struct pcmcia_low_level db1x00_pcmcia_ops = {
	.owner			= THIS_MODULE,

	.hw_init 		= db1x00_pcmcia_hw_init,
	.hw_shutdown		= db1x00_pcmcia_shutdown,

	.socket_state		= db1x00_pcmcia_socket_state,
	.configure_socket	= db1x00_pcmcia_configure_socket,

	.socket_init		= db1x00_socket_init,
	.socket_suspend		= db1x00_socket_suspend
};

int au1x_board_init(struct device *dev)
{
	int ret = -ENODEV;
	bcsr->pcmcia = 0; /* turn off power, if it's not already off */
	au_sync_delay(2);
	ret = au1x00_pcmcia_socket_probe(dev, &db1x00_pcmcia_ops, 0, 2);
	return ret;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Alchemy Semi Db1x00 boards specific pcmcia routines.
	4	*
	5	* Copyright 2002 MontaVista Software Inc.
	6	* Author: MontaVista Software, Inc.
	7	* [email protected] or [email protected]
	8	*
	9	* Copyright 2004 Pete Popov, updated the driver to 2.6.
	10	* Followed the sa11xx API and largely copied many of the hardware
	11	* 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/kernel.h>
	35	#include <linux/errno.h>
	36	#include <linux/interrupt.h>
	37	#include <linux/device.h>
	38	#include <linux/init.h>
	39
	40	#include <asm/irq.h>
	41	#include <asm/signal.h>
	42	#include <asm/mach-au1x00/au1000.h>
d6460827 PP	43
	44	#if defined(CONFIG_MIPS_DB1200)
	45	#include <db1200.h>
	46	#elif defined(CONFIG_MIPS_PB1200)
	47	#include <pb1200.h>
	48	#else
	49	#include <asm/mach-db1x00/db1x00.h>
	50	static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
	51	#endif
1da177e4 LT	52
	53	#include "au1000_generic.h"
	54
	55	#if 0
	56	#define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
	57	#else
	58	#define debug(x,args...)
	59	#endif
	60
1da177e4 LT	61
	62	struct au1000_pcmcia_socket au1000_pcmcia_socket[PCMCIA_NUM_SOCKS];
	63	extern int au1x00_pcmcia_socket_probe(struct device , struct pcmcia_low_level , int, int);
	64
	65	static int db1x00_pcmcia_hw_init(struct au1000_pcmcia_socket *skt)
	66	{
	67	#ifdef CONFIG_MIPS_DB1550
	68	skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_3;
d6460827 PP	69	#elif defined(CONFIG_MIPS_DB1200) \|\| defined(CONFIG_MIPS_PB1200)
d6460827 PP	70	skt->irq = skt->nr ? BOARD_PC1_INT : BOARD_PC0_INT;
1da177e4 LT	71	#else
	72	skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_2;
	73	#endif
	74	return 0;
	75	}
	76
	77	static void db1x00_pcmcia_shutdown(struct au1000_pcmcia_socket *skt)
	78	{
	79	bcsr->pcmcia = 0; /* turn off power */
	80	au_sync_delay(2);
	81	}
	82
	83	static void
	84	db1x00_pcmcia_socket_state(struct au1000_pcmcia_socket skt, struct pcmcia_state state)
	85	{
	86	u32 inserted;
	87	unsigned char vs;
	88
	89	state->ready = 0;
	90	state->vs_Xv = 0;
	91	state->vs_3v = 0;
	92	state->detect = 0;
	93
	94	switch (skt->nr) {
	95	case 0:
	96	vs = bcsr->status & 0x3;
d6460827 PP	97	#if defined(CONFIG_MIPS_DB1200) \|\| defined(CONFIG_MIPS_PB1200)
	98	inserted = BOARD_CARD_INSERTED(0);
	99	#else
1da177e4	100	inserted = !(bcsr->status & (1<<4));
d6460827	101	#endif
1da177e4 LT	102	break;
	103	case 1:
	104	vs = (bcsr->status & 0xC)>>2;
d6460827 PP	105	#if defined(CONFIG_MIPS_DB1200) \|\| defined(CONFIG_MIPS_PB1200)
	106	inserted = BOARD_CARD_INSERTED(1);
	107	#else
1da177e4	108	inserted = !(bcsr->status & (1<<5));
d6460827	109	#endif
1da177e4 LT	110	break;
	111	default:/* should never happen */
	112	return;
	113	}
	114
	115	if (inserted)
	116	debug("db1x00 socket %d: inserted %d, vs %d pcmcia %x\n",
	117	skt->nr, inserted, vs, bcsr->pcmcia);
	118
	119	if (inserted) {
	120	switch (vs) {
	121	case 0:
	122	case 2:
	123	state->vs_3v=1;
	124	break;
	125	case 3: /* 5V */
	126	break;
	127	default:
	128	/* return without setting 'detect' */
	129	printk(KERN_ERR "db1x00 bad VS (%d)\n",
	130	vs);
	131	}
	132	state->detect = 1;
	133	state->ready = 1;
	134	}
	135	else {
	136	/* if the card was previously inserted and then ejected,
	137	* we should turn off power to it
	138	*/
	139	if ((skt->nr == 0) && (bcsr->pcmcia & BCSR_PCMCIA_PC0RST)) {
	140	bcsr->pcmcia &= ~(BCSR_PCMCIA_PC0RST \|
	141	BCSR_PCMCIA_PC0DRVEN \|
	142	BCSR_PCMCIA_PC0VPP \|
	143	BCSR_PCMCIA_PC0VCC);
	144	au_sync_delay(10);
	145	}
	146	else if ((skt->nr == 1) && bcsr->pcmcia & BCSR_PCMCIA_PC1RST) {
	147	bcsr->pcmcia &= ~(BCSR_PCMCIA_PC1RST \|
	148	BCSR_PCMCIA_PC1DRVEN \|
	149	BCSR_PCMCIA_PC1VPP \|
	150	BCSR_PCMCIA_PC1VCC);
	151	au_sync_delay(10);
	152	}
	153	}
	154
	155	state->bvd1=1;
	156	state->bvd2=1;
	157	state->wrprot=0;
	158	}
	159
	160	static int
	161	db1x00_pcmcia_configure_socket(struct au1000_pcmcia_socket skt, struct socket_state_t state)
	162	{
	163	u16 pwr;
	164	int sock = skt->nr;
	165
	166	debug("config_skt %d Vcc %dV Vpp %dV, reset %d\n",
	167	sock, state->Vcc, state->Vpp,
	168	state->flags & SS_RESET);
	169
	170	/* pcmcia reg was set to zero at init time. Be careful when
	171	* initializing a socket not to wipe out the settings of the
	172	* other socket.
	173	*/
174	pwr = bcsr->pcmcia;
175	pwr &= ~(0xf << sock8); / clear voltage settings */
176
177	state->Vpp = 0;
178	switch(state->Vcc){
179	case 0: /* Vcc 0 */
180	pwr \|= SET_VCC_VPP(0,0,sock);
181	break;
182	case 50: /* Vcc 5V */
183	switch(state->Vpp) {
184	case 0:
185	pwr \|= SET_VCC_VPP(2,0,sock);
186	break;
187	case 50:
188	pwr \|= SET_VCC_VPP(2,1,sock);
189	break;
190	case 12:
191	pwr \|= SET_VCC_VPP(2,2,sock);
192	break;
193	case 33:
194	default:
195	pwr \|= SET_VCC_VPP(0,0,sock);
196	printk("%s: bad Vcc/Vpp (%d:%d)\n",
197	__FUNCTION__,
198	state->Vcc,
199	state->Vpp);
200	break;
201	}
202	break;
203	case 33: /* Vcc 3.3V */
204	switch(state->Vpp) {
205	case 0:
206	pwr \|= SET_VCC_VPP(1,0,sock);
207	break;
208	case 12:
209	pwr \|= SET_VCC_VPP(1,2,sock);
210	break;
211	case 33:
212	pwr \|= SET_VCC_VPP(1,1,sock);
213	break;
214	case 50:
215	default:
216	pwr \|= SET_VCC_VPP(0,0,sock);
217	printk("%s: bad Vcc/Vpp (%d:%d)\n",
218	__FUNCTION__,
219	state->Vcc,
220	state->Vpp);
221	break;
222	}
223	break;
224	default: /* what's this ? */
225	pwr \|= SET_VCC_VPP(0,0,sock);
226	printk(KERN_ERR "%s: bad Vcc %d\n",
227	__FUNCTION__, state->Vcc);
228	break;
229	}
230
231	bcsr->pcmcia = pwr;
232	au_sync_delay(300);
233
234	if (sock == 0) {
235	if (!(state->flags & SS_RESET)) {
236	pwr \|= BCSR_PCMCIA_PC0DRVEN;
237	bcsr->pcmcia = pwr;
238	au_sync_delay(300);
239	pwr \|= BCSR_PCMCIA_PC0RST;
240	bcsr->pcmcia = pwr;
241	au_sync_delay(100);
242	}
243	else {
244	pwr &= ~(BCSR_PCMCIA_PC0RST \| BCSR_PCMCIA_PC0DRVEN);
245	bcsr->pcmcia = pwr;
246	au_sync_delay(100);
247	}
248	}
249	else {
250	if (!(state->flags & SS_RESET)) {
251	pwr \|= BCSR_PCMCIA_PC1DRVEN;
252	bcsr->pcmcia = pwr;
253	au_sync_delay(300);
254	pwr \|= BCSR_PCMCIA_PC1RST;
255	bcsr->pcmcia = pwr;
256	au_sync_delay(100);
257	}
258	else {
259	pwr &= ~(BCSR_PCMCIA_PC1RST \| BCSR_PCMCIA_PC1DRVEN);
260	bcsr->pcmcia = pwr;
261	au_sync_delay(100);
262	}
263	}
264	return 0;
265	}
266
267	/*
268	* Enable card status IRQs on (re-)initialisation. This can
269	* be called at initialisation, power management event, or
270	* pcmcia event.
271	*/
272	void db1x00_socket_init(struct au1000_pcmcia_socket *skt)
273	{
274	/* nothing to do for now */
275	}
276
277	/*
278	* Disable card status IRQs and PCMCIA bus on suspend.
279	*/
280	void db1x00_socket_suspend(struct au1000_pcmcia_socket *skt)
281	{
282	/* nothing to do for now */
283	}
284
285	struct pcmcia_low_level db1x00_pcmcia_ops = {
286	.owner = THIS_MODULE,
287
288	.hw_init = db1x00_pcmcia_hw_init,
289	.hw_shutdown = db1x00_pcmcia_shutdown,
290
291	.socket_state = db1x00_pcmcia_socket_state,
292	.configure_socket = db1x00_pcmcia_configure_socket,
293
294	.socket_init = db1x00_socket_init,
295	.socket_suspend = db1x00_socket_suspend
296	};
297
0973dddd	298	int au1x_board_init(struct device *dev)
1da177e4 LT	299	{
	300	int ret = -ENODEV;
	301	bcsr->pcmcia = 0; /* turn off power, if it's not already off */
	302	au_sync_delay(2);
	303	ret = au1x00_pcmcia_socket_probe(dev, &db1x00_pcmcia_ops, 0, 2);
	304	return ret;
	305	}