Commit | Line | Data |
---|---|---|
73b4390f RB |
1 | /* |
2 | * Miscellaneous functions for IDT EB434 board | |
3 | * | |
4 | * Copyright 2004 IDT Inc. (rischelp@idt.com) | |
5 | * Copyright 2006 Phil Sutter <n0-1@freewrt.org> | |
6 | * Copyright 2007 Florian Fainelli <florian@openwrt.org> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the | |
10 | * Free Software Foundation; either version 2 of the License, or (at your | |
11 | * option) any later version. | |
12 | * | |
13 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
14 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
15 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN | |
16 | * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
17 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
18 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | |
19 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | |
20 | * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
21 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
22 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
23 | * | |
24 | * You should have received a copy of the GNU General Public License along | |
25 | * with this program; if not, write to the Free Software Foundation, Inc., | |
26 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
27 | */ | |
28 | ||
29 | #include <linux/kernel.h> | |
30 | #include <linux/gpio.h> | |
31 | #include <linux/init.h> | |
32 | #include <linux/types.h> | |
33 | #include <linux/pci.h> | |
34 | #include <linux/spinlock.h> | |
35 | #include <linux/io.h> | |
36 | #include <linux/platform_device.h> | |
37 | ||
38 | #include <asm/addrspace.h> | |
39 | ||
40 | #include <asm/mach-rc32434/rb.h> | |
41 | ||
42 | struct rb532_gpio_reg __iomem *rb532_gpio_reg0; | |
43 | EXPORT_SYMBOL(rb532_gpio_reg0); | |
44 | ||
45 | struct mpmc_device dev3; | |
46 | ||
47 | static struct resource rb532_gpio_reg0_res[] = { | |
48 | { | |
49 | .name = "gpio_reg0", | |
50 | .start = (u32)(IDT434_REG_BASE + GPIOBASE), | |
51 | .end = (u32)(IDT434_REG_BASE + GPIOBASE + sizeof(struct rb532_gpio_reg)), | |
52 | .flags = IORESOURCE_MEM, | |
53 | } | |
54 | }; | |
55 | ||
56 | static struct resource rb532_dev3_ctl_res[] = { | |
57 | { | |
58 | .name = "dev3_ctl", | |
59 | .start = (u32)(IDT434_REG_BASE + DEV3BASE), | |
60 | .end = (u32)(IDT434_REG_BASE + DEV3BASE + sizeof(struct dev_reg)), | |
61 | .flags = IORESOURCE_MEM, | |
62 | } | |
63 | }; | |
64 | ||
65 | void set_434_reg(unsigned reg_offs, unsigned bit, unsigned len, unsigned val) | |
66 | { | |
8b32d6d0 AB |
67 | unsigned long flags; |
68 | unsigned data; | |
73b4390f RB |
69 | unsigned i = 0; |
70 | ||
71 | spin_lock_irqsave(&dev3.lock, flags); | |
72 | ||
73 | data = *(volatile unsigned *) (IDT434_REG_BASE + reg_offs); | |
74 | for (i = 0; i != len; ++i) { | |
75 | if (val & (1 << i)) | |
76 | data |= (1 << (i + bit)); | |
77 | else | |
78 | data &= ~(1 << (i + bit)); | |
79 | } | |
80 | writel(data, (IDT434_REG_BASE + reg_offs)); | |
81 | ||
82 | spin_unlock_irqrestore(&dev3.lock, flags); | |
83 | } | |
84 | EXPORT_SYMBOL(set_434_reg); | |
85 | ||
86 | unsigned get_434_reg(unsigned reg_offs) | |
87 | { | |
88 | return readl(IDT434_REG_BASE + reg_offs); | |
89 | } | |
90 | EXPORT_SYMBOL(get_434_reg); | |
91 | ||
92 | void set_latch_u5(unsigned char or_mask, unsigned char nand_mask) | |
93 | { | |
8b32d6d0 | 94 | unsigned long flags; |
73b4390f RB |
95 | |
96 | spin_lock_irqsave(&dev3.lock, flags); | |
97 | ||
98 | dev3.state = (dev3.state | or_mask) & ~nand_mask; | |
99 | writel(dev3.state, &dev3.base); | |
100 | ||
101 | spin_unlock_irqrestore(&dev3.lock, flags); | |
102 | } | |
103 | EXPORT_SYMBOL(set_latch_u5); | |
104 | ||
105 | unsigned char get_latch_u5(void) | |
106 | { | |
107 | return dev3.state; | |
108 | } | |
109 | EXPORT_SYMBOL(get_latch_u5); | |
110 | ||
111 | int rb532_gpio_get_value(unsigned gpio) | |
112 | { | |
113 | return readl(&rb532_gpio_reg0->gpiod) & (1 << gpio); | |
114 | } | |
115 | EXPORT_SYMBOL(rb532_gpio_get_value); | |
116 | ||
117 | void rb532_gpio_set_value(unsigned gpio, int value) | |
118 | { | |
119 | unsigned tmp; | |
120 | ||
121 | tmp = readl(&rb532_gpio_reg0->gpiod) & ~(1 << gpio); | |
122 | if (value) | |
123 | tmp |= 1 << gpio; | |
124 | ||
125 | writel(tmp, (void *)&rb532_gpio_reg0->gpiod); | |
126 | } | |
127 | EXPORT_SYMBOL(rb532_gpio_set_value); | |
128 | ||
129 | int rb532_gpio_direction_input(unsigned gpio) | |
130 | { | |
131 | writel(readl(&rb532_gpio_reg0->gpiocfg) & ~(1 << gpio), | |
132 | (void *)&rb532_gpio_reg0->gpiocfg); | |
133 | ||
134 | return 0; | |
135 | } | |
136 | EXPORT_SYMBOL(rb532_gpio_direction_input); | |
137 | ||
138 | int rb532_gpio_direction_output(unsigned gpio, int value) | |
139 | { | |
140 | gpio_set_value(gpio, value); | |
141 | writel(readl(&rb532_gpio_reg0->gpiocfg) | (1 << gpio), | |
142 | (void *)&rb532_gpio_reg0->gpiocfg); | |
143 | ||
144 | return 0; | |
145 | } | |
146 | EXPORT_SYMBOL(rb532_gpio_direction_output); | |
147 | ||
148 | void rb532_gpio_set_int_level(unsigned gpio, int value) | |
149 | { | |
150 | unsigned tmp; | |
151 | ||
152 | tmp = readl(&rb532_gpio_reg0->gpioilevel) & ~(1 << gpio); | |
153 | if (value) | |
154 | tmp |= 1 << gpio; | |
155 | writel(tmp, (void *)&rb532_gpio_reg0->gpioilevel); | |
156 | } | |
157 | EXPORT_SYMBOL(rb532_gpio_set_int_level); | |
158 | ||
159 | int rb532_gpio_get_int_level(unsigned gpio) | |
160 | { | |
161 | return readl(&rb532_gpio_reg0->gpioilevel) & (1 << gpio); | |
162 | } | |
163 | EXPORT_SYMBOL(rb532_gpio_get_int_level); | |
164 | ||
165 | void rb532_gpio_set_int_status(unsigned gpio, int value) | |
166 | { | |
167 | unsigned tmp; | |
168 | ||
169 | tmp = readl(&rb532_gpio_reg0->gpioistat); | |
170 | if (value) | |
171 | tmp |= 1 << gpio; | |
172 | writel(tmp, (void *)&rb532_gpio_reg0->gpioistat); | |
173 | } | |
174 | EXPORT_SYMBOL(rb532_gpio_set_int_status); | |
175 | ||
176 | int rb532_gpio_get_int_status(unsigned gpio) | |
177 | { | |
178 | return readl(&rb532_gpio_reg0->gpioistat) & (1 << gpio); | |
179 | } | |
180 | EXPORT_SYMBOL(rb532_gpio_get_int_status); | |
181 | ||
182 | void rb532_gpio_set_func(unsigned gpio, int value) | |
183 | { | |
184 | unsigned tmp; | |
185 | ||
186 | tmp = readl(&rb532_gpio_reg0->gpiofunc); | |
187 | if (value) | |
188 | tmp |= 1 << gpio; | |
189 | writel(tmp, (void *)&rb532_gpio_reg0->gpiofunc); | |
190 | } | |
191 | EXPORT_SYMBOL(rb532_gpio_set_func); | |
192 | ||
193 | int rb532_gpio_get_func(unsigned gpio) | |
194 | { | |
195 | return readl(&rb532_gpio_reg0->gpiofunc) & (1 << gpio); | |
196 | } | |
197 | EXPORT_SYMBOL(rb532_gpio_get_func); | |
198 | ||
199 | int __init rb532_gpio_init(void) | |
200 | { | |
201 | rb532_gpio_reg0 = ioremap_nocache(rb532_gpio_reg0_res[0].start, | |
202 | rb532_gpio_reg0_res[0].end - | |
203 | rb532_gpio_reg0_res[0].start); | |
204 | ||
205 | if (!rb532_gpio_reg0) { | |
206 | printk(KERN_ERR "rb532: cannot remap GPIO register 0\n"); | |
207 | return -ENXIO; | |
208 | } | |
209 | ||
210 | dev3.base = ioremap_nocache(rb532_dev3_ctl_res[0].start, | |
211 | rb532_dev3_ctl_res[0].end - | |
212 | rb532_dev3_ctl_res[0].start); | |
213 | ||
214 | if (!dev3.base) { | |
215 | printk(KERN_ERR "rb532: cannot remap device controller 3\n"); | |
216 | return -ENXIO; | |
217 | } | |
218 | ||
219 | return 0; | |
220 | } | |
221 | arch_initcall(rb532_gpio_init); |