[deliverable/linux.git] / drivers / video / via / via-gpio.c

/*
 * Support for viafb GPIO ports.
 *
 * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
 * Distributable under version 2 of the GNU General Public License.
 */

#include <linux/spinlock.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/via-core.h>
#include <linux/via-gpio.h>

/*
 * The ports we know about.  Note that the port-25 gpios are not
 * mentioned in the datasheet.
 */

struct viafb_gpio {
	char *vg_name;	/* Data sheet name */
	u16 vg_io_port;
	u8  vg_port_index;
	int  vg_mask_shift;
};

static struct viafb_gpio viafb_all_gpios[] = {
	{
		.vg_name = "VGPIO0",  /* Guess - not in datasheet */
		.vg_io_port = VIASR,
		.vg_port_index = 0x25,
		.vg_mask_shift = 1
	},
	{
		.vg_name = "VGPIO1",
		.vg_io_port = VIASR,
		.vg_port_index = 0x25,
		.vg_mask_shift = 0
	},
	{
		.vg_name = "VGPIO2",  /* aka DISPCLKI0 */
		.vg_io_port = VIASR,
		.vg_port_index = 0x2c,
		.vg_mask_shift = 1
	},
	{
		.vg_name = "VGPIO3",  /* aka DISPCLKO0 */
		.vg_io_port = VIASR,
		.vg_port_index = 0x2c,
		.vg_mask_shift = 0
	},
	{
		.vg_name = "VGPIO4",  /* DISPCLKI1 */
		.vg_io_port = VIASR,
		.vg_port_index = 0x3d,
		.vg_mask_shift = 1
	},
	{
		.vg_name = "VGPIO5",  /* DISPCLKO1 */
		.vg_io_port = VIASR,
		.vg_port_index = 0x3d,
		.vg_mask_shift = 0
	},
};

#define VIAFB_NUM_GPIOS ARRAY_SIZE(viafb_all_gpios)

/*
 * This structure controls the active GPIOs, which may be a subset
 * of those which are known.
 */

struct viafb_gpio_cfg {
	struct gpio_chip gpio_chip;
	struct viafb_dev *vdev;
	struct viafb_gpio *active_gpios[VIAFB_NUM_GPIOS];
	const char *gpio_names[VIAFB_NUM_GPIOS];
};

/*
 * GPIO access functions
 */
static void via_gpio_set(struct gpio_chip *chip, unsigned int nr,
			 int value)
{
	struct viafb_gpio_cfg *cfg = container_of(chip,
						  struct viafb_gpio_cfg,
						  gpio_chip);
	u8 reg;
	struct viafb_gpio *gpio;
	unsigned long flags;

	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	gpio = cfg->active_gpios[nr];
	reg = via_read_reg(VIASR, gpio->vg_port_index);
	reg |= 0x40 << gpio->vg_mask_shift;  /* output enable */
	if (value)
		reg |= 0x10 << gpio->vg_mask_shift;
	else
		reg &= ~(0x10 << gpio->vg_mask_shift);
	via_write_reg(VIASR, gpio->vg_port_index, reg);
	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
}

static int via_gpio_dir_out(struct gpio_chip *chip, unsigned int nr,
			    int value)
{
	via_gpio_set(chip, nr, value);
	return 0;
}

/*
 * Set the input direction.  I'm not sure this is right; we should
 * be able to do input without disabling output.
 */
static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
{
	struct viafb_gpio_cfg *cfg = container_of(chip,
						  struct viafb_gpio_cfg,
						  gpio_chip);
	struct viafb_gpio *gpio;
	unsigned long flags;

	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	gpio = cfg->active_gpios[nr];
	via_write_reg_mask(VIASR, gpio->vg_port_index, 0,
			0x40 << gpio->vg_mask_shift);
	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
	return 0;
}

static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
{
	struct viafb_gpio_cfg *cfg = container_of(chip,
						  struct viafb_gpio_cfg,
						  gpio_chip);
	u8 reg;
	struct viafb_gpio *gpio;
	unsigned long flags;

	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	gpio = cfg->active_gpios[nr];
	reg = via_read_reg(VIASR, gpio->vg_port_index);
	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
	return reg & (0x04 << gpio->vg_mask_shift);
}


static struct viafb_gpio_cfg gpio_config = {
	.gpio_chip = {
		.label = "VIAFB onboard GPIO",
		.owner = THIS_MODULE,
		.direction_output = via_gpio_dir_out,
		.set = via_gpio_set,
		.direction_input = via_gpio_dir_input,
		.get = via_gpio_get,
		.base = -1,
		.ngpio = 0,
		.can_sleep = 0
	}
};

/*
 * Manage the software enable bit.
 */
static void viafb_gpio_enable(struct viafb_gpio *gpio)
{
	via_write_reg_mask(VIASR, gpio->vg_port_index, 0x02, 0x02);
}

static void viafb_gpio_disable(struct viafb_gpio *gpio)
{
	via_write_reg_mask(VIASR, gpio->vg_port_index, 0, 0x02);
}

#ifdef CONFIG_PM

static int viafb_gpio_suspend(void *private)
{
	return 0;
}

static int viafb_gpio_resume(void *private)
{
	int i;

	for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
		viafb_gpio_enable(gpio_config.active_gpios[i]);
	return 0;
}

static struct viafb_pm_hooks viafb_gpio_pm_hooks = {
	.suspend = viafb_gpio_suspend,
	.resume = viafb_gpio_resume
};
#endif /* CONFIG_PM */

/*
 * Look up a specific gpio and return the number it was assigned.
 */
int viafb_gpio_lookup(const char *name)
{
	int i;

	for (i = 0; i < gpio_config.gpio_chip.ngpio; i++)
		if (!strcmp(name, gpio_config.active_gpios[i]->vg_name))
			return gpio_config.gpio_chip.base + i;
	return -1;
}
EXPORT_SYMBOL_GPL(viafb_gpio_lookup);

/*
 * Platform device stuff.
 */
static __devinit int viafb_gpio_probe(struct platform_device *platdev)
{
	struct viafb_dev *vdev = platdev->dev.platform_data;
	struct via_port_cfg *port_cfg = vdev->port_cfg;
	int i, ngpio = 0, ret;
	struct viafb_gpio *gpio;
	unsigned long flags;

	/*
	 * Set up entries for all GPIOs which have been configured to
	 * operate as such (as opposed to as i2c ports).
	 */
	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
		if (port_cfg[i].mode != VIA_MODE_GPIO)
			continue;
		for (gpio = viafb_all_gpios;
		     gpio < viafb_all_gpios + VIAFB_NUM_GPIOS; gpio++)
			if (gpio->vg_port_index == port_cfg[i].ioport_index) {
				gpio_config.active_gpios[ngpio] = gpio;
				gpio_config.gpio_names[ngpio] = gpio->vg_name;
				ngpio++;
			}
	}
	gpio_config.gpio_chip.ngpio = ngpio;
	gpio_config.gpio_chip.names = gpio_config.gpio_names;
	gpio_config.vdev = vdev;
	if (ngpio == 0) {
		printk(KERN_INFO "viafb: no GPIOs configured\n");
		return 0;
	}
	/*
	 * Enable the ports.  They come in pairs, with a single
	 * enable bit for both.
	 */
	spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
	for (i = 0; i < ngpio; i += 2)
		viafb_gpio_enable(gpio_config.active_gpios[i]);
	spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
	/*
	 * Get registered.
	 */
	gpio_config.gpio_chip.base = -1;  /* Dynamic */
	ret = gpiochip_add(&gpio_config.gpio_chip);
	if (ret) {
		printk(KERN_ERR "viafb: failed to add gpios (%d)\n", ret);
		gpio_config.gpio_chip.ngpio = 0;
	}
#ifdef CONFIG_PM
	viafb_pm_register(&viafb_gpio_pm_hooks);
#endif
	return ret;
}


static int viafb_gpio_remove(struct platform_device *platdev)
{
	unsigned long flags;
	int ret = 0, i;

#ifdef CONFIG_PM
	viafb_pm_unregister(&viafb_gpio_pm_hooks);
#endif

	/*
	 * Get unregistered.
	 */
	if (gpio_config.gpio_chip.ngpio > 0) {
		ret = gpiochip_remove(&gpio_config.gpio_chip);
		if (ret) { /* Somebody still using it? */
			printk(KERN_ERR "Viafb: GPIO remove failed\n");
			return ret;
		}
	}
	/*
	 * Disable the ports.
	 */
	spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
	for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
		viafb_gpio_disable(gpio_config.active_gpios[i]);
	gpio_config.gpio_chip.ngpio = 0;
	spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
	return ret;
}

static struct platform_driver via_gpio_driver = {
	.driver = {
		.name = "viafb-gpio",
	},
	.probe = viafb_gpio_probe,
	.remove = viafb_gpio_remove,
};

int viafb_gpio_init(void)
{
	return platform_driver_register(&via_gpio_driver);
}

void viafb_gpio_exit(void)
{
	platform_driver_unregister(&via_gpio_driver);
}
Commit	Line	Data
7e0de022 JC	1	/*
	2	* Support for viafb GPIO ports.
	3	*
	4	* Copyright 2009 Jonathan Corbet <corbet@lwn.net>
	5	* Distributable under version 2 of the GNU General Public License.
	6	*/
	7
	8	#include <linux/spinlock.h>
	9	#include <linux/gpio.h>
7582eb9b	10	#include <linux/platform_device.h>
ec66841e JC	11	#include <linux/via-core.h>
ec66841e JC	12	#include <linux/via-gpio.h>
7e0de022 JC	13
	14	/*
	15	* The ports we know about. Note that the port-25 gpios are not
	16	* mentioned in the datasheet.
	17	*/
	18
	19	struct viafb_gpio {
	20	char vg_name; / Data sheet name */
	21	u16 vg_io_port;
	22	u8 vg_port_index;
	23	int vg_mask_shift;
	24	};
	25
	26	static struct viafb_gpio viafb_all_gpios[] = {
	27	{
	28	.vg_name = "VGPIO0", /* Guess - not in datasheet */
	29	.vg_io_port = VIASR,
	30	.vg_port_index = 0x25,
	31	.vg_mask_shift = 1
	32	},
	33	{
	34	.vg_name = "VGPIO1",
	35	.vg_io_port = VIASR,
	36	.vg_port_index = 0x25,
	37	.vg_mask_shift = 0
	38	},
	39	{
	40	.vg_name = "VGPIO2", /* aka DISPCLKI0 */
	41	.vg_io_port = VIASR,
	42	.vg_port_index = 0x2c,
	43	.vg_mask_shift = 1
	44	},
	45	{
	46	.vg_name = "VGPIO3", /* aka DISPCLKO0 */
	47	.vg_io_port = VIASR,
	48	.vg_port_index = 0x2c,
	49	.vg_mask_shift = 0
	50	},
	51	{
	52	.vg_name = "VGPIO4", /* DISPCLKI1 */
	53	.vg_io_port = VIASR,
	54	.vg_port_index = 0x3d,
	55	.vg_mask_shift = 1
	56	},
	57	{
	58	.vg_name = "VGPIO5", /* DISPCLKO1 */
	59	.vg_io_port = VIASR,
	60	.vg_port_index = 0x3d,
	61	.vg_mask_shift = 0
	62	},
	63	};
	64
	65	#define VIAFB_NUM_GPIOS ARRAY_SIZE(viafb_all_gpios)
	66
	67	/*
	68	* This structure controls the active GPIOs, which may be a subset
	69	* of those which are known.
	70	*/
	71
	72	struct viafb_gpio_cfg {
	73	struct gpio_chip gpio_chip;
	74	struct viafb_dev *vdev;
	75	struct viafb_gpio *active_gpios[VIAFB_NUM_GPIOS];
f2709837	76	const char *gpio_names[VIAFB_NUM_GPIOS];
7e0de022 JC	77	};
	78
	79	/*
	80	* GPIO access functions
	81	*/
	82	static void via_gpio_set(struct gpio_chip *chip, unsigned int nr,
	83	int value)
	84	{
	85	struct viafb_gpio_cfg *cfg = container_of(chip,
	86	struct viafb_gpio_cfg,
	87	gpio_chip);
	88	u8 reg;
	89	struct viafb_gpio *gpio;
	90	unsigned long flags;
	91
	92	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	93	gpio = cfg->active_gpios[nr];
75b035ac	94	reg = via_read_reg(VIASR, gpio->vg_port_index);
7e0de022 JC	95	reg \|= 0x40 << gpio->vg_mask_shift; /* output enable */
	96	if (value)
	97	reg \|= 0x10 << gpio->vg_mask_shift;
	98	else
	99	reg &= ~(0x10 << gpio->vg_mask_shift);
75b035ac	100	via_write_reg(VIASR, gpio->vg_port_index, reg);
7e0de022 JC	101	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
	102	}
	103
	104	static int via_gpio_dir_out(struct gpio_chip *chip, unsigned int nr,
	105	int value)
	106	{
	107	via_gpio_set(chip, nr, value);
	108	return 0;
	109	}
	110
	111	/*
	112	* Set the input direction. I'm not sure this is right; we should
	113	* be able to do input without disabling output.
	114	*/
	115	static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
	116	{
	117	struct viafb_gpio_cfg *cfg = container_of(chip,
	118	struct viafb_gpio_cfg,
	119	gpio_chip);
	120	struct viafb_gpio *gpio;
	121	unsigned long flags;
	122
	123	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	124	gpio = cfg->active_gpios[nr];
75b035ac JC	125	via_write_reg_mask(VIASR, gpio->vg_port_index, 0,
75b035ac JC	126	0x40 << gpio->vg_mask_shift);
7e0de022 JC	127	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
	128	return 0;
	129	}
	130
	131	static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
	132	{
	133	struct viafb_gpio_cfg *cfg = container_of(chip,
	134	struct viafb_gpio_cfg,
	135	gpio_chip);
	136	u8 reg;
	137	struct viafb_gpio *gpio;
	138	unsigned long flags;
	139
	140	spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
	141	gpio = cfg->active_gpios[nr];
75b035ac	142	reg = via_read_reg(VIASR, gpio->vg_port_index);
7e0de022 JC	143	spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
	144	return reg & (0x04 << gpio->vg_mask_shift);
	145	}
	146
	147
	148	static struct viafb_gpio_cfg gpio_config = {
	149	.gpio_chip = {
	150	.label = "VIAFB onboard GPIO",
	151	.owner = THIS_MODULE,
	152	.direction_output = via_gpio_dir_out,
	153	.set = via_gpio_set,
	154	.direction_input = via_gpio_dir_input,
	155	.get = via_gpio_get,
	156	.base = -1,
	157	.ngpio = 0,
	158	.can_sleep = 0
	159	}
	160	};
	161
	162	/*
	163	* Manage the software enable bit.
	164	*/
	165	static void viafb_gpio_enable(struct viafb_gpio *gpio)
	166	{
75b035ac	167	via_write_reg_mask(VIASR, gpio->vg_port_index, 0x02, 0x02);
7e0de022 JC	168	}
	169
	170	static void viafb_gpio_disable(struct viafb_gpio *gpio)
	171	{
75b035ac	172	via_write_reg_mask(VIASR, gpio->vg_port_index, 0, 0x02);
7e0de022 JC	173	}
7e0de022 JC	174
67eb6f96 JC	175	#ifdef CONFIG_PM
	176
	177	static int viafb_gpio_suspend(void *private)
	178	{
	179	return 0;
	180	}
	181
	182	static int viafb_gpio_resume(void *private)
	183	{
	184	int i;
	185
	186	for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
	187	viafb_gpio_enable(gpio_config.active_gpios[i]);
	188	return 0;
	189	}
	190
	191	static struct viafb_pm_hooks viafb_gpio_pm_hooks = {
	192	.suspend = viafb_gpio_suspend,
	193	.resume = viafb_gpio_resume
	194	};
	195	#endif /* CONFIG_PM */
	196
7582eb9b JC	197	/*
	198	* Look up a specific gpio and return the number it was assigned.
	199	*/
	200	int viafb_gpio_lookup(const char *name)
	201	{
	202	int i;
7e0de022	203
7582eb9b JC	204	for (i = 0; i < gpio_config.gpio_chip.ngpio; i++)
	205	if (!strcmp(name, gpio_config.active_gpios[i]->vg_name))
	206	return gpio_config.gpio_chip.base + i;
	207	return -1;
	208	}
	209	EXPORT_SYMBOL_GPL(viafb_gpio_lookup);
7e0de022	210
7582eb9b JC	211	/*
	212	* Platform device stuff.
	213	*/
	214	static __devinit int viafb_gpio_probe(struct platform_device *platdev)
7e0de022	215	{
7582eb9b JC	216	struct viafb_dev *vdev = platdev->dev.platform_data;
7582eb9b JC	217	struct via_port_cfg *port_cfg = vdev->port_cfg;
7e0de022 JC	218	int i, ngpio = 0, ret;
	219	struct viafb_gpio *gpio;
	220	unsigned long flags;
	221
	222	/*
	223	* Set up entries for all GPIOs which have been configured to
	224	* operate as such (as opposed to as i2c ports).
	225	*/
	226	for (i = 0; i < VIAFB_NUM_PORTS; i++) {
	227	if (port_cfg[i].mode != VIA_MODE_GPIO)
	228	continue;
	229	for (gpio = viafb_all_gpios;
	230	gpio < viafb_all_gpios + VIAFB_NUM_GPIOS; gpio++)
	231	if (gpio->vg_port_index == port_cfg[i].ioport_index) {
	232	gpio_config.active_gpios[ngpio] = gpio;
	233	gpio_config.gpio_names[ngpio] = gpio->vg_name;
	234	ngpio++;
	235	}
	236	}
	237	gpio_config.gpio_chip.ngpio = ngpio;
	238	gpio_config.gpio_chip.names = gpio_config.gpio_names;
	239	gpio_config.vdev = vdev;
	240	if (ngpio == 0) {
	241	printk(KERN_INFO "viafb: no GPIOs configured\n");
	242	return 0;
	243	}
	244	/*
	245	* Enable the ports. They come in pairs, with a single
	246	* enable bit for both.
	247	*/
	248	spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
	249	for (i = 0; i < ngpio; i += 2)
	250	viafb_gpio_enable(gpio_config.active_gpios[i]);
	251	spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
	252	/*
	253	* Get registered.
	254	*/
	255	gpio_config.gpio_chip.base = -1; /* Dynamic */
	256	ret = gpiochip_add(&gpio_config.gpio_chip);
	257	if (ret) {
	258	printk(KERN_ERR "viafb: failed to add gpios (%d)\n", ret);
	259	gpio_config.gpio_chip.ngpio = 0;
	260	}
67eb6f96 JC	261	#ifdef CONFIG_PM
	262	viafb_pm_register(&viafb_gpio_pm_hooks);
	263	#endif
7e0de022	264	return ret;
7e0de022 JC	265	}
	266
	267
7582eb9b	268	static int viafb_gpio_remove(struct platform_device *platdev)
7e0de022 JC	269	{
	270	unsigned long flags;
	271	int ret = 0, i;
	272
67eb6f96 JC	273	#ifdef CONFIG_PM
	274	viafb_pm_unregister(&viafb_gpio_pm_hooks);
	275	#endif
	276
7e0de022 JC	277	/*
	278	* Get unregistered.
	279	*/
	280	if (gpio_config.gpio_chip.ngpio > 0) {
	281	ret = gpiochip_remove(&gpio_config.gpio_chip);
	282	if (ret) { /* Somebody still using it? */
	283	printk(KERN_ERR "Viafb: GPIO remove failed\n");
27fe971d	284	return ret;
7e0de022 JC	285	}
	286	}
	287	/*
	288	* Disable the ports.
	289	*/
27fe971d	290	spin_lock_irqsave(&gpio_config.vdev->reg_lock, flags);
7e0de022 JC	291	for (i = 0; i < gpio_config.gpio_chip.ngpio; i += 2)
	292	viafb_gpio_disable(gpio_config.active_gpios[i]);
	293	gpio_config.gpio_chip.ngpio = 0;
7e0de022 JC	294	spin_unlock_irqrestore(&gpio_config.vdev->reg_lock, flags);
	295	return ret;
	296	}
	297
7582eb9b JC	298	static struct platform_driver via_gpio_driver = {
	299	.driver = {
	300	.name = "viafb-gpio",
	301	},
	302	.probe = viafb_gpio_probe,
	303	.remove = viafb_gpio_remove,
	304	};
	305
	306	int viafb_gpio_init(void)
7e0de022	307	{
7582eb9b JC	308	return platform_driver_register(&via_gpio_driver);
7582eb9b JC	309	}
7e0de022	310
7582eb9b JC	311	void viafb_gpio_exit(void)
	312	{
	313	platform_driver_unregister(&via_gpio_driver);
7e0de022	314	}