[linux.git] / drivers / gpio / gpio-loongson.c

/*
 *  Loongson-2F/3A/3B GPIO Support
 *
 *  Copyright (c) 2008 Richard Liu,  STMicroelectronics	 <[email protected]>
 *  Copyright (c) 2008-2010 Arnaud Patard <[email protected]>
 *  Copyright (c) 2013 Hongbing Hu <[email protected]>
 *  Copyright (c) 2014 Huacai Chen <[email protected]>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/err.h>
#include <asm/types.h>
#include <loongson.h>
#include <linux/gpio.h>

#define STLS2F_N_GPIO		4
#define STLS3A_N_GPIO		16

#ifdef CONFIG_CPU_LOONGSON3
#define LOONGSON_N_GPIO	STLS3A_N_GPIO
#else
#define LOONGSON_N_GPIO	STLS2F_N_GPIO
#endif

#define LOONGSON_GPIO_IN_OFFSET	16

static DEFINE_SPINLOCK(gpio_lock);

static int loongson_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
{
	u32 temp;
	u32 mask;

	spin_lock(&gpio_lock);
	mask = 1 << gpio;
	temp = LOONGSON_GPIOIE;
	temp |= mask;
	LOONGSON_GPIOIE = temp;
	spin_unlock(&gpio_lock);

	return 0;
}

static int loongson_gpio_direction_output(struct gpio_chip *chip,
		unsigned gpio, int level)
{
	u32 temp;
	u32 mask;

	gpio_set_value(gpio, level);
	spin_lock(&gpio_lock);
	mask = 1 << gpio;
	temp = LOONGSON_GPIOIE;
	temp &= (~mask);
	LOONGSON_GPIOIE = temp;
	spin_unlock(&gpio_lock);

	return 0;
}

static int loongson_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
{
	u32 val;
	u32 mask;

	mask = 1 << (gpio + LOONGSON_GPIO_IN_OFFSET);
	spin_lock(&gpio_lock);
	val = LOONGSON_GPIODATA;
	spin_unlock(&gpio_lock);

	return (val & mask) != 0;
}

static void loongson_gpio_set_value(struct gpio_chip *chip,
		unsigned gpio, int value)
{
	u32 val;
	u32 mask;

	mask = 1 << gpio;

	spin_lock(&gpio_lock);
	val = LOONGSON_GPIODATA;
	if (value)
		val |= mask;
	else
		val &= (~mask);
	LOONGSON_GPIODATA = val;
	spin_unlock(&gpio_lock);
}

static struct gpio_chip loongson_chip = {
	.label                  = "Loongson-gpio-chip",
	.direction_input        = loongson_gpio_direction_input,
	.get                    = loongson_gpio_get_value,
	.direction_output       = loongson_gpio_direction_output,
	.set                    = loongson_gpio_set_value,
	.base			= 0,
	.ngpio                  = LOONGSON_N_GPIO,
	.can_sleep		= false,
};

static int __init loongson_gpio_setup(void)
{
	return gpiochip_add_data(&loongson_chip, NULL);
}
postcore_initcall(loongson_gpio_setup);
Commit	Line	Data
c197da91	1	/*
cbfb3ea7	2	* Loongson-2F/3A/3B GPIO Support
c197da91	3	*
70342287	4	* Copyright (c) 2008 Richard Liu, STMicroelectronics <[email protected]>
c197da91	5	* Copyright (c) 2008-2010 Arnaud Patard <[email protected]>
cbfb3ea7 HC	6	* Copyright (c) 2013 Hongbing Hu <[email protected]>
cbfb3ea7 HC	7	* Copyright (c) 2014 Huacai Chen <[email protected]>
c197da91 AP	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/module.h>
	18	#include <linux/spinlock.h>
	19	#include <linux/err.h>
	20	#include <asm/types.h>
	21	#include <loongson.h>
	22	#include <linux/gpio.h>
	23
	24	#define STLS2F_N_GPIO 4
cbfb3ea7 HC	25	#define STLS3A_N_GPIO 16
	26
	27	#ifdef CONFIG_CPU_LOONGSON3
	28	#define LOONGSON_N_GPIO STLS3A_N_GPIO
	29	#else
	30	#define LOONGSON_N_GPIO STLS2F_N_GPIO
	31	#endif
	32
	33	#define LOONGSON_GPIO_IN_OFFSET 16
c197da91 AP	34
	35	static DEFINE_SPINLOCK(gpio_lock);
	36
cbfb3ea7	37	static int loongson_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
c197da91 AP	38	{
	39	u32 temp;
	40	u32 mask;
	41
c197da91 AP	42	spin_lock(&gpio_lock);
	43	mask = 1 << gpio;
	44	temp = LOONGSON_GPIOIE;
	45	temp \|= mask;
	46	LOONGSON_GPIOIE = temp;
	47	spin_unlock(&gpio_lock);
	48
	49	return 0;
	50	}
	51
cbfb3ea7	52	static int loongson_gpio_direction_output(struct gpio_chip *chip,
c197da91 AP	53	unsigned gpio, int level)
	54	{
	55	u32 temp;
	56	u32 mask;
	57
c197da91 AP	58	gpio_set_value(gpio, level);
	59	spin_lock(&gpio_lock);
	60	mask = 1 << gpio;
	61	temp = LOONGSON_GPIOIE;
	62	temp &= (~mask);
	63	LOONGSON_GPIOIE = temp;
	64	spin_unlock(&gpio_lock);
	65
	66	return 0;
	67	}
	68
cbfb3ea7	69	static int loongson_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
c197da91	70	{
df5dade4 HC	71	u32 val;
	72	u32 mask;
	73
cbfb3ea7	74	mask = 1 << (gpio + LOONGSON_GPIO_IN_OFFSET);
df5dade4 HC	75	spin_lock(&gpio_lock);
	76	val = LOONGSON_GPIODATA;
	77	spin_unlock(&gpio_lock);
	78
	79	return (val & mask) != 0;
c197da91 AP	80	}
c197da91 AP	81
cbfb3ea7	82	static void loongson_gpio_set_value(struct gpio_chip *chip,
c197da91 AP	83	unsigned gpio, int value)
c197da91 AP	84	{
df5dade4 HC	85	u32 val;
	86	u32 mask;
	87
	88	mask = 1 << gpio;
	89
	90	spin_lock(&gpio_lock);
	91	val = LOONGSON_GPIODATA;
	92	if (value)
	93	val \|= mask;
	94	else
	95	val &= (~mask);
	96	LOONGSON_GPIODATA = val;
	97	spin_unlock(&gpio_lock);
c197da91 AP	98	}
c197da91 AP	99
cbfb3ea7 HC	100	static struct gpio_chip loongson_chip = {
	101	.label = "Loongson-gpio-chip",
	102	.direction_input = loongson_gpio_direction_input,
	103	.get = loongson_gpio_get_value,
	104	.direction_output = loongson_gpio_direction_output,
	105	.set = loongson_gpio_set_value,
70342287	106	.base = 0,
cbfb3ea7	107	.ngpio = LOONGSON_N_GPIO,
df5dade4	108	.can_sleep = false,
c197da91 AP	109	};
c197da91 AP	110
cbfb3ea7	111	static int __init loongson_gpio_setup(void)
c197da91	112	{
4eab22e7	113	return gpiochip_add_data(&loongson_chip, NULL);
c197da91	114	}
cbfb3ea7	115	postcore_initcall(loongson_gpio_setup);