Linux Audio

Check our new training course

Loading...
Note: File does not exist in v4.17.
  1/*
  2 *  Atheros AR71XX/AR724X/AR913X GPIO API support
  3 *
  4 *  Copyright (C) 2010-2011 Jaiganesh Narayanan <jnarayanan@atheros.com>
  5 *  Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org>
  6 *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
  7 *
  8 *  Parts of this file are based on Atheros' 2.6.15/2.6.31 BSP
  9 *
 10 *  This program is free software; you can redistribute it and/or modify it
 11 *  under the terms of the GNU General Public License version 2 as published
 12 *  by the Free Software Foundation.
 13 */
 14
 15#include <linux/kernel.h>
 16#include <linux/init.h>
 17#include <linux/module.h>
 18#include <linux/types.h>
 19#include <linux/spinlock.h>
 20#include <linux/io.h>
 21#include <linux/ioport.h>
 22#include <linux/gpio.h>
 23
 24#include <asm/mach-ath79/ar71xx_regs.h>
 25#include <asm/mach-ath79/ath79.h>
 26#include "common.h"
 27
 28static void __iomem *ath79_gpio_base;
 29static unsigned long ath79_gpio_count;
 30static DEFINE_SPINLOCK(ath79_gpio_lock);
 31
 32static void __ath79_gpio_set_value(unsigned gpio, int value)
 33{
 34	void __iomem *base = ath79_gpio_base;
 35
 36	if (value)
 37		__raw_writel(1 << gpio, base + AR71XX_GPIO_REG_SET);
 38	else
 39		__raw_writel(1 << gpio, base + AR71XX_GPIO_REG_CLEAR);
 40}
 41
 42static int __ath79_gpio_get_value(unsigned gpio)
 43{
 44	return (__raw_readl(ath79_gpio_base + AR71XX_GPIO_REG_IN) >> gpio) & 1;
 45}
 46
 47static int ath79_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 48{
 49	return __ath79_gpio_get_value(offset);
 50}
 51
 52static void ath79_gpio_set_value(struct gpio_chip *chip,
 53				  unsigned offset, int value)
 54{
 55	__ath79_gpio_set_value(offset, value);
 56}
 57
 58static int ath79_gpio_direction_input(struct gpio_chip *chip,
 59				       unsigned offset)
 60{
 61	void __iomem *base = ath79_gpio_base;
 62	unsigned long flags;
 63
 64	spin_lock_irqsave(&ath79_gpio_lock, flags);
 65
 66	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) & ~(1 << offset),
 67		     base + AR71XX_GPIO_REG_OE);
 68
 69	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
 70
 71	return 0;
 72}
 73
 74static int ath79_gpio_direction_output(struct gpio_chip *chip,
 75					unsigned offset, int value)
 76{
 77	void __iomem *base = ath79_gpio_base;
 78	unsigned long flags;
 79
 80	spin_lock_irqsave(&ath79_gpio_lock, flags);
 81
 82	if (value)
 83		__raw_writel(1 << offset, base + AR71XX_GPIO_REG_SET);
 84	else
 85		__raw_writel(1 << offset, base + AR71XX_GPIO_REG_CLEAR);
 86
 87	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) | (1 << offset),
 88		     base + AR71XX_GPIO_REG_OE);
 89
 90	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
 91
 92	return 0;
 93}
 94
 95static int ar934x_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 96{
 97	void __iomem *base = ath79_gpio_base;
 98	unsigned long flags;
 99
100	spin_lock_irqsave(&ath79_gpio_lock, flags);
101
102	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) | (1 << offset),
103		     base + AR71XX_GPIO_REG_OE);
104
105	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
106
107	return 0;
108}
109
110static int ar934x_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
111					int value)
112{
113	void __iomem *base = ath79_gpio_base;
114	unsigned long flags;
115
116	spin_lock_irqsave(&ath79_gpio_lock, flags);
117
118	if (value)
119		__raw_writel(1 << offset, base + AR71XX_GPIO_REG_SET);
120	else
121		__raw_writel(1 << offset, base + AR71XX_GPIO_REG_CLEAR);
122
123	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_OE) & ~(1 << offset),
124		     base + AR71XX_GPIO_REG_OE);
125
126	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
127
128	return 0;
129}
130
131static struct gpio_chip ath79_gpio_chip = {
132	.label			= "ath79",
133	.get			= ath79_gpio_get_value,
134	.set			= ath79_gpio_set_value,
135	.direction_input	= ath79_gpio_direction_input,
136	.direction_output	= ath79_gpio_direction_output,
137	.base			= 0,
138};
139
140void ath79_gpio_function_enable(u32 mask)
141{
142	void __iomem *base = ath79_gpio_base;
143	unsigned long flags;
144
145	spin_lock_irqsave(&ath79_gpio_lock, flags);
146
147	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_FUNC) | mask,
148		     base + AR71XX_GPIO_REG_FUNC);
149	/* flush write */
150	__raw_readl(base + AR71XX_GPIO_REG_FUNC);
151
152	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
153}
154
155void ath79_gpio_function_disable(u32 mask)
156{
157	void __iomem *base = ath79_gpio_base;
158	unsigned long flags;
159
160	spin_lock_irqsave(&ath79_gpio_lock, flags);
161
162	__raw_writel(__raw_readl(base + AR71XX_GPIO_REG_FUNC) & ~mask,
163		     base + AR71XX_GPIO_REG_FUNC);
164	/* flush write */
165	__raw_readl(base + AR71XX_GPIO_REG_FUNC);
166
167	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
168}
169
170void ath79_gpio_function_setup(u32 set, u32 clear)
171{
172	void __iomem *base = ath79_gpio_base;
173	unsigned long flags;
174
175	spin_lock_irqsave(&ath79_gpio_lock, flags);
176
177	__raw_writel((__raw_readl(base + AR71XX_GPIO_REG_FUNC) & ~clear) | set,
178		     base + AR71XX_GPIO_REG_FUNC);
179	/* flush write */
180	__raw_readl(base + AR71XX_GPIO_REG_FUNC);
181
182	spin_unlock_irqrestore(&ath79_gpio_lock, flags);
183}
184
185void __init ath79_gpio_init(void)
186{
187	int err;
188
189	if (soc_is_ar71xx())
190		ath79_gpio_count = AR71XX_GPIO_COUNT;
191	else if (soc_is_ar724x())
192		ath79_gpio_count = AR724X_GPIO_COUNT;
193	else if (soc_is_ar913x())
194		ath79_gpio_count = AR913X_GPIO_COUNT;
195	else if (soc_is_ar933x())
196		ath79_gpio_count = AR933X_GPIO_COUNT;
197	else if (soc_is_ar934x())
198		ath79_gpio_count = AR934X_GPIO_COUNT;
199	else
200		BUG();
201
202	ath79_gpio_base = ioremap_nocache(AR71XX_GPIO_BASE, AR71XX_GPIO_SIZE);
203	ath79_gpio_chip.ngpio = ath79_gpio_count;
204	if (soc_is_ar934x()) {
205		ath79_gpio_chip.direction_input = ar934x_gpio_direction_input;
206		ath79_gpio_chip.direction_output = ar934x_gpio_direction_output;
207	}
208
209	err = gpiochip_add(&ath79_gpio_chip);
210	if (err)
211		panic("cannot add AR71xx GPIO chip, error=%d", err);
212}
213
214int gpio_get_value(unsigned gpio)
215{
216	if (gpio < ath79_gpio_count)
217		return __ath79_gpio_get_value(gpio);
218
219	return __gpio_get_value(gpio);
220}
221EXPORT_SYMBOL(gpio_get_value);
222
223void gpio_set_value(unsigned gpio, int value)
224{
225	if (gpio < ath79_gpio_count)
226		__ath79_gpio_set_value(gpio, value);
227	else
228		__gpio_set_value(gpio, value);
229}
230EXPORT_SYMBOL(gpio_set_value);
231
232int gpio_to_irq(unsigned gpio)
233{
234	/* FIXME */
235	return -EINVAL;
236}
237EXPORT_SYMBOL(gpio_to_irq);
238
239int irq_to_gpio(unsigned irq)
240{
241	/* FIXME */
242	return -EINVAL;
243}
244EXPORT_SYMBOL(irq_to_gpio);