[mirror_ubuntu-bionic-kernel.git] / drivers / pcmcia / pxa2xx_sharpsl.c

/*
 * Sharp SL-C7xx Series PCMCIA routines
 *
 * Copyright (c) 2004-2005 Richard Purdie
 *
 * Based on Sharp's 2.4 kernel patches and pxa2xx_mainstone.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>

#include <asm/mach-types.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/hardware/scoop.h>

#include "soc_common.h"

#define	NO_KEEP_VS 0x0001

/* PCMCIA to Scoop linkage

   There is no easy way to link multiple scoop devices into one
   single entity for the pxa2xx_pcmcia device so this structure
   is used which is setup by the platform code
*/
struct scoop_pcmcia_config *platform_scoop_config;
#define SCOOP_DEV platform_scoop_config->devs

static void sharpsl_pcmcia_init_reset(struct soc_pcmcia_socket *skt)
{
	struct scoop_pcmcia_dev *scoopdev = &SCOOP_DEV[skt->nr];

	reset_scoop(scoopdev->dev);

	/* Shared power controls need to be handled carefully */
	if (platform_scoop_config->power_ctrl)
		platform_scoop_config->power_ctrl(scoopdev->dev, 0x0000, skt->nr);
	else
		write_scoop_reg(scoopdev->dev, SCOOP_CPR, 0x0000);

	scoopdev->keep_vs = NO_KEEP_VS;
	scoopdev->keep_rd = 0;
}

static int sharpsl_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
{
	int ret;

	if (platform_scoop_config->pcmcia_init)
		platform_scoop_config->pcmcia_init();

	/* Register interrupts */
	if (SCOOP_DEV[skt->nr].cd_irq >= 0) {
		struct pcmcia_irqs cd_irq;

		cd_irq.sock = skt->nr;
		cd_irq.irq  = SCOOP_DEV[skt->nr].cd_irq;
		cd_irq.str  = SCOOP_DEV[skt->nr].cd_irq_str;
		ret = soc_pcmcia_request_irqs(skt, &cd_irq, 1);

		if (ret) {
			printk(KERN_ERR "Request for Compact Flash IRQ failed\n");
			return ret;
		}
	}

	skt->irq = SCOOP_DEV[skt->nr].irq;

	return 0;
}

static void sharpsl_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
{
	if (SCOOP_DEV[skt->nr].cd_irq >= 0) {
		struct pcmcia_irqs cd_irq;

		cd_irq.sock = skt->nr;
		cd_irq.irq  = SCOOP_DEV[skt->nr].cd_irq;
		cd_irq.str  = SCOOP_DEV[skt->nr].cd_irq_str;
		soc_pcmcia_free_irqs(skt, &cd_irq, 1);
	}
}


static void sharpsl_pcmcia_socket_state(struct soc_pcmcia_socket *skt,
				    struct pcmcia_state *state)
{
	unsigned short cpr, csr;
	struct device *scoop = SCOOP_DEV[skt->nr].dev;

	cpr = read_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_CPR);

	write_scoop_reg(scoop, SCOOP_IRM, 0x00FF);
	write_scoop_reg(scoop, SCOOP_ISR, 0x0000);
	write_scoop_reg(scoop, SCOOP_IRM, 0x0000);
	csr = read_scoop_reg(scoop, SCOOP_CSR);
	if (csr & 0x0004) {
		/* card eject */
		write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
		SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
	}
	else if (!(SCOOP_DEV[skt->nr].keep_vs & NO_KEEP_VS)) {
		/* keep vs1,vs2 */
		write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
		csr |= SCOOP_DEV[skt->nr].keep_vs;
	}
	else if (cpr & 0x0003) {
		/* power on */
		write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
		SCOOP_DEV[skt->nr].keep_vs = (csr & 0x00C0);
	}
	else {
		/* card detect */
	        if ((machine_is_spitz() || machine_is_borzoi()) && skt->nr == 1) {
	                write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
	        } else {
		        write_scoop_reg(scoop, SCOOP_CDR, 0x0002);
	        }
	}

	state->detect = (csr & 0x0004) ? 0 : 1;
	state->ready  = (csr & 0x0002) ? 1 : 0;
	state->bvd1   = (csr & 0x0010) ? 1 : 0;
	state->bvd2   = (csr & 0x0020) ? 1 : 0;
	state->wrprot = (csr & 0x0008) ? 1 : 0;
	state->vs_3v  = (csr & 0x0040) ? 0 : 1;
	state->vs_Xv  = (csr & 0x0080) ? 0 : 1;

	if ((cpr & 0x0080) && ((cpr & 0x8040) != 0x8040)) {
		printk(KERN_ERR "sharpsl_pcmcia_socket_state(): CPR=%04X, Low voltage!\n", cpr);
	}
}


static int sharpsl_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
				       const socket_state_t *state)
{
	unsigned long flags;
	struct device *scoop = SCOOP_DEV[skt->nr].dev;

	unsigned short cpr, ncpr, ccr, nccr, mcr, nmcr, imr, nimr;

	switch (state->Vcc) {
	case	0:  	break;
	case 	33: 	break;
	case	50: 	break;
	default:
		 printk(KERN_ERR "sharpsl_pcmcia_configure_socket(): bad Vcc %u\n", state->Vcc);
		 return -1;
	}

	if ((state->Vpp!=state->Vcc) && (state->Vpp!=0)) {
		printk(KERN_ERR "CF slot cannot support Vpp %u\n", state->Vpp);
		return -1;
	}

	local_irq_save(flags);

	nmcr = (mcr = read_scoop_reg(scoop, SCOOP_MCR)) & ~0x0010;
	ncpr = (cpr = read_scoop_reg(scoop, SCOOP_CPR)) & ~0x0083;
	nccr = (ccr = read_scoop_reg(scoop, SCOOP_CCR)) & ~0x0080;
	nimr = (imr = read_scoop_reg(scoop, SCOOP_IMR)) & ~0x003E;

	if ((machine_is_spitz() || machine_is_borzoi() || machine_is_akita()) && skt->nr == 0) {
	        ncpr |= (state->Vcc == 33) ? 0x0002 :
		        (state->Vcc == 50) ? 0x0002 : 0;
	} else {
	        ncpr |= (state->Vcc == 33) ? 0x0001 :
		        (state->Vcc == 50) ? 0x0002 : 0;
	}
	nmcr |= (state->flags&SS_IOCARD) ? 0x0010 : 0;
	ncpr |= (state->flags&SS_OUTPUT_ENA) ? 0x0080 : 0;
	nccr |= (state->flags&SS_RESET)? 0x0080: 0;
	nimr |=	((skt->status&SS_DETECT) ? 0x0004 : 0)|
			((skt->status&SS_READY)  ? 0x0002 : 0)|
			((skt->status&SS_BATDEAD)? 0x0010 : 0)|
			((skt->status&SS_BATWARN)? 0x0020 : 0)|
			((skt->status&SS_STSCHG) ? 0x0010 : 0)|
			((skt->status&SS_WRPROT) ? 0x0008 : 0);

	if (!(ncpr & 0x0003)) {
		SCOOP_DEV[skt->nr].keep_rd = 0;
	} else if (!SCOOP_DEV[skt->nr].keep_rd) {
		if (nccr & 0x0080)
			SCOOP_DEV[skt->nr].keep_rd = 1;
		else
			nccr |= 0x0080;
	}

	if (mcr != nmcr)
		write_scoop_reg(scoop, SCOOP_MCR, nmcr);
	if (cpr != ncpr) {
		if (platform_scoop_config->power_ctrl)
			platform_scoop_config->power_ctrl(scoop, ncpr , skt->nr);
		else
		        write_scoop_reg(scoop, SCOOP_CPR, ncpr);
	}
	if (ccr != nccr)
		write_scoop_reg(scoop, SCOOP_CCR, nccr);
	if (imr != nimr)
		write_scoop_reg(scoop, SCOOP_IMR, nimr);

	local_irq_restore(flags);

	return 0;
}

static void sharpsl_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
{
	sharpsl_pcmcia_init_reset(skt);

	/* Enable interrupt */
	write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_IMR, 0x00C0);
	write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_MCR, 0x0101);
	SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
}

static void sharpsl_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
{
	sharpsl_pcmcia_init_reset(skt);
}

static struct pcmcia_low_level sharpsl_pcmcia_ops = {
	.owner                  = THIS_MODULE,
	.hw_init                = sharpsl_pcmcia_hw_init,
	.hw_shutdown            = sharpsl_pcmcia_hw_shutdown,
	.socket_state           = sharpsl_pcmcia_socket_state,
	.configure_socket       = sharpsl_pcmcia_configure_socket,
	.socket_init            = sharpsl_pcmcia_socket_init,
	.socket_suspend         = sharpsl_pcmcia_socket_suspend,
	.first                  = 0,
	.nr                     = 0,
};

#ifdef CONFIG_SA1100_COLLIE
#include "sa11xx_base.h"

int __init pcmcia_collie_init(struct device *dev)
{
       int ret = -ENODEV;

       if (machine_is_collie())
               ret = sa11xx_drv_pcmcia_probe(dev, &sharpsl_pcmcia_ops, 0, 1);

       return ret;
}

#else

static struct platform_device *sharpsl_pcmcia_device;

static int __init sharpsl_pcmcia_init(void)
{
	int ret;

	sharpsl_pcmcia_ops.nr=platform_scoop_config->num_devs;
	sharpsl_pcmcia_device = kzalloc(sizeof(*sharpsl_pcmcia_device), GFP_KERNEL);
	if (!sharpsl_pcmcia_device)
		return -ENOMEM;

	sharpsl_pcmcia_device->name = "pxa2xx-pcmcia";
	sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops;
	sharpsl_pcmcia_device->dev.parent=platform_scoop_config->devs[0].dev;

	ret = platform_device_register(sharpsl_pcmcia_device);
	if (ret)
		kfree(sharpsl_pcmcia_device);

	return ret;
}

static void __exit sharpsl_pcmcia_exit(void)
{
	/*
	 * This call is supposed to free our sharpsl_pcmcia_device.
	 * Unfortunately platform_device don't have a free method, and
	 * we can't assume it's free of any reference at this point so we
	 * can't free it either.
	 */
	platform_device_unregister(sharpsl_pcmcia_device);
}

fs_initcall(sharpsl_pcmcia_init);
module_exit(sharpsl_pcmcia_exit);
#endif

MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Sharp SL-C7xx Series PCMCIA routines
	3	*
	4	* Copyright (c) 2004-2005 Richard Purdie
	5	*
	6	* Based on Sharp's 2.4 kernel patches and pxa2xx_mainstone.c
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/kernel.h>
	17	#include <linux/errno.h>
	18	#include <linux/interrupt.h>
d052d1be	19	#include <linux/platform_device.h>
1da177e4	20
77bb86a1	21	#include <asm/mach-types.h>
1da177e4 LT	22	#include <asm/hardware.h>
1da177e4 LT	23	#include <asm/irq.h>
1da177e4	24	#include <asm/hardware/scoop.h>
1da177e4 LT	25
	26	#include "soc_common.h"
	27
	28	#define NO_KEEP_VS 0x0001
	29
a63ae442 RP	30	/* PCMCIA to Scoop linkage
	31
	32	There is no easy way to link multiple scoop devices into one
	33	single entity for the pxa2xx_pcmcia device so this structure
	34	is used which is setup by the platform code
	35	*/
	36	struct scoop_pcmcia_config *platform_scoop_config;
	37	#define SCOOP_DEV platform_scoop_config->devs
	38
945b9579	39	static void sharpsl_pcmcia_init_reset(struct soc_pcmcia_socket *skt)
1da177e4	40	{
945b9579 RP	41	struct scoop_pcmcia_dev *scoopdev = &SCOOP_DEV[skt->nr];
945b9579 RP	42
0ce7625f	43	reset_scoop(scoopdev->dev);
945b9579 RP	44
	45	/* Shared power controls need to be handled carefully */
	46	if (platform_scoop_config->power_ctrl)
	47	platform_scoop_config->power_ctrl(scoopdev->dev, 0x0000, skt->nr);
	48	else
	49	write_scoop_reg(scoopdev->dev, SCOOP_CPR, 0x0000);
	50
0ce7625f RP	51	scoopdev->keep_vs = NO_KEEP_VS;
0ce7625f RP	52	scoopdev->keep_rd = 0;
1da177e4 LT	53	}
	54
	55	static int sharpsl_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
	56	{
	57	int ret;
	58
a63ae442 RP	59	if (platform_scoop_config->pcmcia_init)
a63ae442 RP	60	platform_scoop_config->pcmcia_init();
1da177e4 LT	61
1da177e4 LT	62	/* Register interrupts */
a63ae442	63	if (SCOOP_DEV[skt->nr].cd_irq >= 0) {
0ce7625f RP	64	struct pcmcia_irqs cd_irq;
	65
	66	cd_irq.sock = skt->nr;
a63ae442 RP	67	cd_irq.irq = SCOOP_DEV[skt->nr].cd_irq;
a63ae442 RP	68	cd_irq.str = SCOOP_DEV[skt->nr].cd_irq_str;
0ce7625f RP	69	ret = soc_pcmcia_request_irqs(skt, &cd_irq, 1);
	70
	71	if (ret) {
	72	printk(KERN_ERR "Request for Compact Flash IRQ failed\n");
	73	return ret;
	74	}
1da177e4 LT	75	}
1da177e4 LT	76
a63ae442	77	skt->irq = SCOOP_DEV[skt->nr].irq;
1da177e4 LT	78
	79	return 0;
	80	}
	81
	82	static void sharpsl_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
	83	{
a63ae442	84	if (SCOOP_DEV[skt->nr].cd_irq >= 0) {
0ce7625f	85	struct pcmcia_irqs cd_irq;
1da177e4	86
0ce7625f	87	cd_irq.sock = skt->nr;
a63ae442 RP	88	cd_irq.irq = SCOOP_DEV[skt->nr].cd_irq;
a63ae442 RP	89	cd_irq.str = SCOOP_DEV[skt->nr].cd_irq_str;
0ce7625f RP	90	soc_pcmcia_free_irqs(skt, &cd_irq, 1);
0ce7625f RP	91	}
1da177e4 LT	92	}
	93
	94
	95	static void sharpsl_pcmcia_socket_state(struct soc_pcmcia_socket *skt,
	96	struct pcmcia_state *state)
	97	{
	98	unsigned short cpr, csr;
a63ae442	99	struct device *scoop = SCOOP_DEV[skt->nr].dev;
1da177e4	100
a63ae442	101	cpr = read_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_CPR);
1da177e4	102
0ce7625f RP	103	write_scoop_reg(scoop, SCOOP_IRM, 0x00FF);
	104	write_scoop_reg(scoop, SCOOP_ISR, 0x0000);
	105	write_scoop_reg(scoop, SCOOP_IRM, 0x0000);
	106	csr = read_scoop_reg(scoop, SCOOP_CSR);
1da177e4 LT	107	if (csr & 0x0004) {
1da177e4 LT	108	/* card eject */
0ce7625f	109	write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
a63ae442	110	SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
1da177e4	111	}
a63ae442	112	else if (!(SCOOP_DEV[skt->nr].keep_vs & NO_KEEP_VS)) {
1da177e4	113	/* keep vs1,vs2 */
0ce7625f	114	write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
a63ae442	115	csr \|= SCOOP_DEV[skt->nr].keep_vs;
1da177e4 LT	116	}
	117	else if (cpr & 0x0003) {
	118	/* power on */
0ce7625f	119	write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
a63ae442	120	SCOOP_DEV[skt->nr].keep_vs = (csr & 0x00C0);
1da177e4 LT	121	}
	122	else {
	123	/* card detect */
a63ae442 RP	124	if ((machine_is_spitz() \|\| machine_is_borzoi()) && skt->nr == 1) {
	125	write_scoop_reg(scoop, SCOOP_CDR, 0x0000);
	126	} else {
	127	write_scoop_reg(scoop, SCOOP_CDR, 0x0002);
	128	}
1da177e4 LT	129	}
	130
	131	state->detect = (csr & 0x0004) ? 0 : 1;
	132	state->ready = (csr & 0x0002) ? 1 : 0;
	133	state->bvd1 = (csr & 0x0010) ? 1 : 0;
	134	state->bvd2 = (csr & 0x0020) ? 1 : 0;
	135	state->wrprot = (csr & 0x0008) ? 1 : 0;
	136	state->vs_3v = (csr & 0x0040) ? 0 : 1;
	137	state->vs_Xv = (csr & 0x0080) ? 0 : 1;
	138
	139	if ((cpr & 0x0080) && ((cpr & 0x8040) != 0x8040)) {
	140	printk(KERN_ERR "sharpsl_pcmcia_socket_state(): CPR=%04X, Low voltage!\n", cpr);
	141	}
1da177e4 LT	142	}
	143
	144
	145	static int sharpsl_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
	146	const socket_state_t *state)
	147	{
	148	unsigned long flags;
a63ae442	149	struct device *scoop = SCOOP_DEV[skt->nr].dev;
1da177e4 LT	150
	151	unsigned short cpr, ncpr, ccr, nccr, mcr, nmcr, imr, nimr;
	152
	153	switch (state->Vcc) {
	154	case 0: break;
	155	case 33: break;
	156	case 50: break;
	157	default:
	158	printk(KERN_ERR "sharpsl_pcmcia_configure_socket(): bad Vcc %u\n", state->Vcc);
	159	return -1;
	160	}
	161
	162	if ((state->Vpp!=state->Vcc) && (state->Vpp!=0)) {
	163	printk(KERN_ERR "CF slot cannot support Vpp %u\n", state->Vpp);
	164	return -1;
	165	}
	166
	167	local_irq_save(flags);
	168
0ce7625f RP	169	nmcr = (mcr = read_scoop_reg(scoop, SCOOP_MCR)) & ~0x0010;
	170	ncpr = (cpr = read_scoop_reg(scoop, SCOOP_CPR)) & ~0x0083;
	171	nccr = (ccr = read_scoop_reg(scoop, SCOOP_CCR)) & ~0x0080;
	172	nimr = (imr = read_scoop_reg(scoop, SCOOP_IMR)) & ~0x003E;
1da177e4	173
a63ae442 RP	174	if ((machine_is_spitz() \|\| machine_is_borzoi() \|\| machine_is_akita()) && skt->nr == 0) {
	175	ncpr \|= (state->Vcc == 33) ? 0x0002 :
	176	(state->Vcc == 50) ? 0x0002 : 0;
	177	} else {
	178	ncpr \|= (state->Vcc == 33) ? 0x0001 :
	179	(state->Vcc == 50) ? 0x0002 : 0;
	180	}
1da177e4 LT	181	nmcr \|= (state->flags&SS_IOCARD) ? 0x0010 : 0;
	182	ncpr \|= (state->flags&SS_OUTPUT_ENA) ? 0x0080 : 0;
	183	nccr \|= (state->flags&SS_RESET)? 0x0080: 0;
	184	nimr \|= ((skt->status&SS_DETECT) ? 0x0004 : 0)\|
	185	((skt->status&SS_READY) ? 0x0002 : 0)\|
	186	((skt->status&SS_BATDEAD)? 0x0010 : 0)\|
	187	((skt->status&SS_BATWARN)? 0x0020 : 0)\|
	188	((skt->status&SS_STSCHG) ? 0x0010 : 0)\|
	189	((skt->status&SS_WRPROT) ? 0x0008 : 0);
	190
	191	if (!(ncpr & 0x0003)) {
a63ae442 RP	192	SCOOP_DEV[skt->nr].keep_rd = 0;
a63ae442 RP	193	} else if (!SCOOP_DEV[skt->nr].keep_rd) {
1da177e4	194	if (nccr & 0x0080)
a63ae442	195	SCOOP_DEV[skt->nr].keep_rd = 1;
1da177e4 LT	196	else
	197	nccr \|= 0x0080;
	198	}
	199
	200	if (mcr != nmcr)
0ce7625f	201	write_scoop_reg(scoop, SCOOP_MCR, nmcr);
a63ae442 RP	202	if (cpr != ncpr) {
	203	if (platform_scoop_config->power_ctrl)
	204	platform_scoop_config->power_ctrl(scoop, ncpr , skt->nr);
	205	else
	206	write_scoop_reg(scoop, SCOOP_CPR, ncpr);
	207	}
1da177e4	208	if (ccr != nccr)
0ce7625f	209	write_scoop_reg(scoop, SCOOP_CCR, nccr);
1da177e4	210	if (imr != nimr)
0ce7625f	211	write_scoop_reg(scoop, SCOOP_IMR, nimr);
1da177e4 LT	212
	213	local_irq_restore(flags);
	214
	215	return 0;
	216	}
	217
	218	static void sharpsl_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
	219	{
945b9579	220	sharpsl_pcmcia_init_reset(skt);
0ce7625f RP	221
0ce7625f RP	222	/* Enable interrupt */
a63ae442 RP	223	write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_IMR, 0x00C0);
	224	write_scoop_reg(SCOOP_DEV[skt->nr].dev, SCOOP_MCR, 0x0101);
	225	SCOOP_DEV[skt->nr].keep_vs = NO_KEEP_VS;
1da177e4 LT	226	}
	227
	228	static void sharpsl_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
	229	{
945b9579	230	sharpsl_pcmcia_init_reset(skt);
1da177e4 LT	231	}
	232
	233	static struct pcmcia_low_level sharpsl_pcmcia_ops = {
a63ae442 RP	234	.owner = THIS_MODULE,
	235	.hw_init = sharpsl_pcmcia_hw_init,
	236	.hw_shutdown = sharpsl_pcmcia_hw_shutdown,
	237	.socket_state = sharpsl_pcmcia_socket_state,
	238	.configure_socket = sharpsl_pcmcia_configure_socket,
	239	.socket_init = sharpsl_pcmcia_socket_init,
	240	.socket_suspend = sharpsl_pcmcia_socket_suspend,
	241	.first = 0,
	242	.nr = 0,
1da177e4 LT	243	};
1da177e4 LT	244
77bb86a1	245	#ifdef CONFIG_SA1100_COLLIE
a63ae442 RP	246	#include "sa11xx_base.h"
a63ae442 RP	247
77bb86a1 PM	248	int __init pcmcia_collie_init(struct device *dev)
	249	{
	250	int ret = -ENODEV;
	251
	252	if (machine_is_collie())
	253	ret = sa11xx_drv_pcmcia_probe(dev, &sharpsl_pcmcia_ops, 0, 1);
	254
	255	return ret;
	256	}
	257
	258	#else
	259
a63ae442 RP	260	static struct platform_device *sharpsl_pcmcia_device;
a63ae442 RP	261
1da177e4 LT	262	static int __init sharpsl_pcmcia_init(void)
	263	{
	264	int ret;
	265
a63ae442	266	sharpsl_pcmcia_ops.nr=platform_scoop_config->num_devs;
8084b372	267	sharpsl_pcmcia_device = kzalloc(sizeof(*sharpsl_pcmcia_device), GFP_KERNEL);
1da177e4 LT	268	if (!sharpsl_pcmcia_device)
1da177e4 LT	269	return -ENOMEM;
0ce7625f	270
1da177e4 LT	271	sharpsl_pcmcia_device->name = "pxa2xx-pcmcia";
1da177e4 LT	272	sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops;
a63ae442	273	sharpsl_pcmcia_device->dev.parent=platform_scoop_config->devs[0].dev;
1da177e4 LT	274
	275	ret = platform_device_register(sharpsl_pcmcia_device);
	276	if (ret)
	277	kfree(sharpsl_pcmcia_device);
	278
	279	return ret;
	280	}
	281
	282	static void __exit sharpsl_pcmcia_exit(void)
	283	{
	284	/*
	285	* This call is supposed to free our sharpsl_pcmcia_device.
	286	* Unfortunately platform_device don't have a free method, and
	287	* we can't assume it's free of any reference at this point so we
	288	* can't free it either.
	289	*/
	290	platform_device_unregister(sharpsl_pcmcia_device);
	291	}
	292
f36598ae	293	fs_initcall(sharpsl_pcmcia_init);
1da177e4	294	module_exit(sharpsl_pcmcia_exit);
77bb86a1	295	#endif
1da177e4 LT	296
	297	MODULE_DESCRIPTION("Sharp SL Series PCMCIA Support");
	298	MODULE_LICENSE("GPL");