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

/*
 * linux/drivers/pcmcia/sa1100_badge4.c
 *
 * BadgePAD 4 PCMCIA specific routines
 *
 *   Christopher Hoover <ch@hpl.hp.com>
 *
 * Copyright (C) 2002 Hewlett-Packard Company
 *
 * 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/kernel.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/init.h>

#include <mach/hardware.h>
#include <asm/mach-types.h>
#include <mach/badge4.h>
#include <asm/hardware/sa1111.h>

#include "sa1111_generic.h"

/*
 * BadgePAD 4 Details
 *
 * PCM Vcc:
 *
 *  PCM Vcc on BadgePAD 4 can be jumpered for 3v3 (short pins 1 and 3
 *  on JP6) or 5v0 (short pins 3 and 5 on JP6).
 *
 * PCM Vpp:
 *
 *  PCM Vpp on BadgePAD 4 can be jumpered for 12v0 (short pins 4 and 6
 *  on JP6) or tied to PCM Vcc (short pins 2 and 4 on JP6).  N.B.,
 *  12v0 operation requires that the power supply actually supply 12v0
 *  via pin 7 of JP7.
 *
 * CF Vcc:
 *
 *  CF Vcc on BadgePAD 4 can be jumpered either for 3v3 (short pins 1
 *  and 2 on JP10) or 5v0 (short pins 2 and 3 on JP10).
 *
 * Unfortunately there's no way programmatically to determine how a
 * given board is jumpered.  This code assumes a default jumpering
 * as described below.
 *
 * If the defaults aren't correct, you may override them with a pcmv
 * setup argument: pcmv=<pcm vcc>,<pcm vpp>,<cf vcc>.  The units are
 * tenths of volts; e.g. pcmv=33,120,50 indicates 3v3 PCM Vcc, 12v0
 * PCM Vpp, and 5v0 CF Vcc.
 *
 */

static int badge4_pcmvcc = 50;  /* pins 3 and 5 jumpered on JP6 */
static int badge4_pcmvpp = 50;  /* pins 2 and 4 jumpered on JP6 */
static int badge4_cfvcc = 33;   /* pins 1 and 2 jumpered on JP10 */

static void complain_about_jumpering(const char *whom,
				     const char *supply,
				     int given, int wanted)
{
	printk(KERN_ERR
	 "%s: %s %d.%dV wanted but board is jumpered for %s %d.%dV operation"
	 "; re-jumper the board and/or use pcmv=xx,xx,xx\n",
	       whom, supply,
	       wanted / 10, wanted % 10,
	       supply,
	       given / 10, given % 10);
}

static int
badge4_pcmcia_configure_socket(struct soc_pcmcia_socket *skt, const socket_state_t *state)
{
	int ret;

	switch (skt->nr) {
	case 0:
		if ((state->Vcc != 0) &&
		    (state->Vcc != badge4_pcmvcc)) {
			complain_about_jumpering(__func__, "pcmvcc",
						 badge4_pcmvcc, state->Vcc);
			// Apply power regardless of the jumpering.
			// return -1;
		}
		if ((state->Vpp != 0) &&
		    (state->Vpp != badge4_pcmvpp)) {
			complain_about_jumpering(__func__, "pcmvpp",
						 badge4_pcmvpp, state->Vpp);
			return -1;
		}
		break;

	case 1:
		if ((state->Vcc != 0) &&
		    (state->Vcc != badge4_cfvcc)) {
			complain_about_jumpering(__func__, "cfvcc",
						 badge4_cfvcc, state->Vcc);
			return -1;
		}
		break;

	default:
		return -1;
	}

	ret = sa1111_pcmcia_configure_socket(skt, state);
	if (ret == 0) {
		unsigned long flags;
		int need5V;

		local_irq_save(flags);

		need5V = ((state->Vcc == 50) || (state->Vpp == 50));

		badge4_set_5V(BADGE4_5V_PCMCIA_SOCK(skt->nr), need5V);

		local_irq_restore(flags);
	}

	return ret;
}

static struct pcmcia_low_level badge4_pcmcia_ops = {
	.owner			= THIS_MODULE,
	.configure_socket	= badge4_pcmcia_configure_socket,
	.first			= 0,
	.nr			= 2,
};

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

	if (machine_is_badge4()) {
		printk(KERN_INFO
		       "%s: badge4_pcmvcc=%d, badge4_pcmvpp=%d, badge4_cfvcc=%d\n",
		       __func__,
		       badge4_pcmvcc, badge4_pcmvpp, badge4_cfvcc);

		sa11xx_drv_pcmcia_ops(&badge4_pcmcia_ops);
		ret = sa1111_pcmcia_add(dev, &badge4_pcmcia_ops,
				sa11xx_drv_pcmcia_add_one);
	}

	return ret;
}

static int __init pcmv_setup(char *s)
{
	int v[4];

	s = get_options(s, ARRAY_SIZE(v), v);

	if (v[0] >= 1) badge4_pcmvcc = v[1];
	if (v[0] >= 2) badge4_pcmvpp = v[2];
	if (v[0] >= 3) badge4_cfvcc = v[3];

	return 1;
}

__setup("pcmv=", pcmv_setup);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/drivers/pcmcia/sa1100_badge4.c
	3	*
	4	* BadgePAD 4 PCMCIA specific routines
	5	*
	6	* Christopher Hoover <ch@hpl.hp.com>
	7	*
	8	* Copyright (C) 2002 Hewlett-Packard Company
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*
	14	*/
	15	#include <linux/module.h>
	16	#include <linux/kernel.h>
1da177e4 LT	17	#include <linux/device.h>
	18	#include <linux/errno.h>
	19	#include <linux/init.h>
	20
a09e64fb	21	#include <mach/hardware.h>
1da177e4	22	#include <asm/mach-types.h>
a09e64fb	23	#include <mach/badge4.h>
1da177e4 LT	24	#include <asm/hardware/sa1111.h>
	25
	26	#include "sa1111_generic.h"
	27
	28	/*
	29	* BadgePAD 4 Details
	30	*
	31	* PCM Vcc:
	32	*
	33	* PCM Vcc on BadgePAD 4 can be jumpered for 3v3 (short pins 1 and 3
	34	* on JP6) or 5v0 (short pins 3 and 5 on JP6).
	35	*
	36	* PCM Vpp:
	37	*
	38	* PCM Vpp on BadgePAD 4 can be jumpered for 12v0 (short pins 4 and 6
	39	* on JP6) or tied to PCM Vcc (short pins 2 and 4 on JP6). N.B.,
	40	* 12v0 operation requires that the power supply actually supply 12v0
	41	* via pin 7 of JP7.
	42	*
	43	* CF Vcc:
	44	*
	45	* CF Vcc on BadgePAD 4 can be jumpered either for 3v3 (short pins 1
	46	* and 2 on JP10) or 5v0 (short pins 2 and 3 on JP10).
	47	*
	48	* Unfortunately there's no way programmatically to determine how a
	49	* given board is jumpered. This code assumes a default jumpering
	50	* as described below.
	51	*
	52	* If the defaults aren't correct, you may override them with a pcmv
	53	* setup argument: pcmv=<pcm vcc>,<pcm vpp>,<cf vcc>. The units are
	54	* tenths of volts; e.g. pcmv=33,120,50 indicates 3v3 PCM Vcc, 12v0
	55	* PCM Vpp, and 5v0 CF Vcc.
	56	*
	57	*/
	58
	59	static int badge4_pcmvcc = 50; /* pins 3 and 5 jumpered on JP6 */
	60	static int badge4_pcmvpp = 50; /* pins 2 and 4 jumpered on JP6 */
	61	static int badge4_cfvcc = 33; /* pins 1 and 2 jumpered on JP10 */
	62
	63	static void complain_about_jumpering(const char *whom,
	64	const char *supply,
	65	int given, int wanted)
	66	{
	67	printk(KERN_ERR
	68	"%s: %s %d.%dV wanted but board is jumpered for %s %d.%dV operation"
	69	"; re-jumper the board and/or use pcmv=xx,xx,xx\n",
	70	whom, supply,
	71	wanted / 10, wanted % 10,
	72	supply,
	73	given / 10, given % 10);
	74	}
	75
	76	static int
	77	badge4_pcmcia_configure_socket(struct soc_pcmcia_socket skt, const socket_state_t state)
	78	{
	79	int ret;
	80
	81	switch (skt->nr) {
	82	case 0:
	83	if ((state->Vcc != 0) &&
	84	(state->Vcc != badge4_pcmvcc)) {
2e11cb4c	85	complain_about_jumpering(__func__, "pcmvcc",
1da177e4 LT	86	badge4_pcmvcc, state->Vcc);
	87	// Apply power regardless of the jumpering.
	88	// return -1;
	89	}
	90	if ((state->Vpp != 0) &&
	91	(state->Vpp != badge4_pcmvpp)) {
2e11cb4c	92	complain_about_jumpering(__func__, "pcmvpp",
1da177e4 LT	93	badge4_pcmvpp, state->Vpp);
	94	return -1;
	95	}
	96	break;
	97
	98	case 1:
	99	if ((state->Vcc != 0) &&
	100	(state->Vcc != badge4_cfvcc)) {
2e11cb4c	101	complain_about_jumpering(__func__, "cfvcc",
1da177e4 LT	102	badge4_cfvcc, state->Vcc);
	103	return -1;
	104	}
	105	break;
	106
	107	default:
	108	return -1;
	109	}
	110
	111	ret = sa1111_pcmcia_configure_socket(skt, state);
	112	if (ret == 0) {
	113	unsigned long flags;
	114	int need5V;
	115
	116	local_irq_save(flags);
	117
	118	need5V = ((state->Vcc == 50) \|\| (state->Vpp == 50));
	119
	120	badge4_set_5V(BADGE4_5V_PCMCIA_SOCK(skt->nr), need5V);
	121
	122	local_irq_restore(flags);
	123	}
	124
65c77dca	125	return ret;
1da177e4 LT	126	}
	127
	128	static struct pcmcia_low_level badge4_pcmcia_ops = {
	129	.owner = THIS_MODULE,
1da177e4	130	.configure_socket = badge4_pcmcia_configure_socket,
701a5dc0 RKAL	131	.first = 0,
701a5dc0 RKAL	132	.nr = 2,
1da177e4 LT	133	};
	134
	135	int pcmcia_badge4_init(struct device *dev)
	136	{
	137	int ret = -ENODEV;
	138
	139	if (machine_is_badge4()) {
	140	printk(KERN_INFO
	141	"%s: badge4_pcmvcc=%d, badge4_pcmvpp=%d, badge4_cfvcc=%d\n",
2e11cb4c	142	__func__,
1da177e4 LT	143	badge4_pcmvcc, badge4_pcmvpp, badge4_cfvcc);
1da177e4 LT	144
701a5dc0 RKAL	145	sa11xx_drv_pcmcia_ops(&badge4_pcmcia_ops);
	146	ret = sa1111_pcmcia_add(dev, &badge4_pcmcia_ops,
	147	sa11xx_drv_pcmcia_add_one);
1da177e4 LT	148	}
	149
	150	return ret;
	151	}
	152
	153	static int __init pcmv_setup(char *s)
	154	{
	155	int v[4];
	156
	157	s = get_options(s, ARRAY_SIZE(v), v);
	158
	159	if (v[0] >= 1) badge4_pcmvcc = v[1];
	160	if (v[0] >= 2) badge4_pcmvpp = v[2];
	161	if (v[0] >= 3) badge4_cfvcc = v[3];
	162
	163	return 1;
	164	}
	165
	166	__setup("pcmv=", pcmv_setup);