Root/target/linux/ubicom32/files/arch/ubicom32/mach-common/ubi32-gpio.c

1/*
2 * arch/ubicom32/mach-common/ubi32-gpio.c
3 * Ubicom gpio driver
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28
29#include <linux/module.h>
30#include <linux/init.h>
31#include <linux/errno.h>
32#include <linux/kernel.h>
33#include <linux/io.h>
34#include <linux/gpio.h>
35#include <linux/irq.h>
36#include <linux/version.h>
37
38#if defined(CONFIG_PROC_FS)
39#include <linux/proc_fs.h>
40#endif
41
42#include <linux/io.h>
43#include <asm/ip5000.h>
44#include <linux/gpio.h>
45
46#define UBI_GPIO_CHECK_RANGE 0 /* !0 enables range checking */
47
48
49/*
50 * Each I/O port can be configured to operate in one of several
51 * functional modes. One of these modes is GPIO, which causes the
52 * entire port to function as a GPIO port. Since the various port
53 * registers serve the system with other important functions, such as
54 * ethernet, serial, USB, etc., it isn't advantageous to set any of
55 * the ports to be entirely dedicated for GPIO use. The processor
56 * alternatively allows individual bits of a port to be assigned to be
57 * used as GPIO independently from the overall port function. This
58 * bit-by-bit assignment is selected by setting the corresponding bit
59 * in the port's gpio_mask register. When set, the selected bit is
60 * then enabled as a GPIO. If the corresponding bit is set in the
61 * gpio_ctl register of the port, the bit is configured as a GPIO
62 * output. Otherwise, it is an input.
63 *
64 * NOTE: This driver uses the bit-by-bit GPIO function assignment
65 * exclusively and *never* sets the port function registers to the
66 * GPIO function.
67 *
68 * GPIO is not the main function of any of the I/O ports. The port
69 * bit widths are variable from one port to the next, determined by
70 * the more common I/O functions of the ports. For simplicity, this
71 * driver assumes all the ports are 32 bits wide regardless of the
72 * real bit width of the port. GPIO bits are numbered from zero to
73 * MAX_UBICOM_GPIOS. Within a port, the least significant bit is
74 * numbered bit zero, the most significant is bit 31. Since the ports
75 * are considered logically contiguous, GPIO #32 is the zeroth bit in
76 * port #1, and so on. Due to the hardware definition, there are
77 * large gaps in the GPIO numbers representing real pins.
78 *
79 * NOTE: It is up to the programmer to refer to the processor data
80 * sheet to determine which bits in which ports can be accessed and
81 * used for GPIO.
82 *
83 */
84
85
86/* There are 9 ports, A through I. Not all 32 bits in each
87 * port can be a GPIO, but we pretend they are. Its up to the
88 * programmer to refer to the processor data sheet.
89 */
90#define MAX_UBICOM_GPIOS (9 * 32) /* ARCH_NR_GPIOS */
91#define NUM_GPIO_PORTS (gpio_bank(MAX_UBICOM_GPIOS))
92
93
94/* GPIO reservation bit map array */
95static int reserved_gpio_map[NUM_GPIO_PORTS];
96
97
98/* Array of hardware io_port addresses */
99static struct ubicom32_io_port *gpio_bank_addr[NUM_GPIO_PORTS] =
100{
101    UBICOM32_IO_PORT(RA),
102    UBICOM32_IO_PORT(RB),
103    UBICOM32_IO_PORT(RC),
104    UBICOM32_IO_PORT(RD),
105    UBICOM32_IO_PORT(RE),
106    UBICOM32_IO_PORT(RF),
107    UBICOM32_IO_PORT(RG),
108    UBICOM32_IO_PORT(RH),
109    UBICOM32_IO_PORT(RI)
110};
111
112
113struct ubi_gpio_chip {
114    /*
115     * Right now, nothing else lives here.
116     */
117    struct gpio_chip gpio_chip;
118};
119
120
121#if UBI_GPIO_CHECK_RANGE
122inline int check_gpio(unsigned gpio)
123{
124    if (gpio >= MAX_UBICOM_GPIOS)
125        return -EINVAL;
126    return 0;
127}
128#else
129#define check_gpio(n) (0)
130#endif
131
132/*
133 * ubi_gpio_get_port
134 * Get the IO port associated with a certain gpio
135 */
136struct ubicom32_io_port *ubi_gpio_get_port(unsigned gpio)
137{
138    if (gpio_bank(gpio) > NUM_GPIO_PORTS) {
139        return NULL;
140    }
141    return gpio_bank_addr[gpio_bank(gpio)];
142}
143
144/*
145 * ubi_gpio_error()
146 */
147static void ubi_gpio_error(unsigned gpio)
148{
149    printk(KERN_ERR "ubicom-gpio: GPIO %d wasn't requested!\n", gpio);
150}
151
152/*
153 * ubi_port_setup()
154 */
155static void ubi_port_setup(unsigned gpio, unsigned short usage)
156{
157    if (!check_gpio(gpio)) {
158        if (usage) {
159            UBICOM32_GPIO_ENABLE(gpio);
160        } else {
161            UBICOM32_GPIO_DISABLE(gpio);
162        }
163    }
164}
165
166/*
167 * ubi_gpio_request()
168 */
169static int ubi_gpio_request(struct gpio_chip *chip, unsigned gpio)
170{
171    unsigned long flags;
172
173    if (check_gpio(gpio) < 0)
174        return -EINVAL;
175
176    local_irq_save(flags);
177
178    if (unlikely(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
179        printk(KERN_ERR "ubi-gpio: GPIO %d is already reserved!\n",
180               gpio);
181        local_irq_restore(flags);
182        return -EBUSY;
183    }
184
185    reserved_gpio_map[gpio_bank(gpio)] |= gpio_bit(gpio);
186
187    ubi_port_setup(gpio, 1);
188
189    local_irq_restore(flags);
190
191    return 0;
192}
193
194/*
195 * ubi_gpio_free()
196 */
197static void ubi_gpio_free(struct gpio_chip *chip, unsigned gpio)
198{
199    unsigned long flags;
200
201    if (check_gpio(gpio) < 0)
202        return;
203
204    local_irq_save(flags);
205
206    if (unlikely(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)))) {
207        ubi_gpio_error(gpio);
208        local_irq_restore(flags);
209        return;
210    }
211
212    /* Assert the pin is no longer claimed */
213    reserved_gpio_map[gpio_bank(gpio)] &= ~gpio_bit(gpio);
214
215    /* Revert port bit to use specified by port->function */
216    ubi_port_setup(gpio, 0);
217
218    local_irq_restore(flags);
219}
220
221/*
222 * ubi_gpio_direction_input()
223 */
224static int ubi_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
225{
226    unsigned long flags;
227
228    if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
229        ubi_gpio_error(gpio);
230        return -EINVAL;
231    }
232
233    local_irq_save(flags);
234
235    /* Configure pin as gpio */
236    ubi_port_setup(gpio, 1);
237
238    /* Assert pin is an input */
239    UBICOM32_GPIO_SET_PIN_INPUT(gpio);
240
241    local_irq_restore(flags);
242
243    return 0;
244}
245
246
247/*
248 * ubi_gpio_direction_output()
249 */
250static int ubi_gpio_direction_output(struct gpio_chip *chip,
251                     unsigned gpio, int value)
252{
253    unsigned long flags;
254
255    if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
256        ubi_gpio_error(gpio);
257        return -EINVAL;
258    }
259
260    local_irq_save(flags);
261
262    /* Configure pin as gpio and set initial value in gpio_out register
263     * so that when we enable it as an output, it will have the correct
264     * initial value.
265     */
266    ubi_port_setup(gpio, 1);
267    if (value) {
268        UBICOM32_GPIO_SET_PIN_HIGH(gpio);
269    } else {
270        UBICOM32_GPIO_SET_PIN_LOW(gpio);
271    }
272
273    /* Enable the pin as an output */
274    UBICOM32_GPIO_SET_PIN_OUTPUT(gpio);
275
276    local_irq_restore(flags);
277
278    return 0;
279}
280
281
282/*
283 * ubi_gpio_get_value()
284 */
285static int ubi_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
286{
287    return 0 != (gpio_bank_addr[gpio_bank(gpio)]->gpio_in & gpio_bit(gpio));
288}
289
290
291/*
292 * ubi_gpio_set_value()
293 */
294static void ubi_gpio_set_value(struct gpio_chip *chip, unsigned gpio,
295                   int arg)
296{
297    unsigned long flags;
298    local_irq_save(flags);
299
300    if (arg) {
301        UBICOM32_GPIO_SET_PIN_HIGH(gpio);
302    } else {
303        UBICOM32_GPIO_SET_PIN_LOW(gpio);
304    }
305
306    local_irq_restore(flags);
307}
308
309
310/*
311 * ubi_gpio_to_irq()
312 */
313static int ubi_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
314{
315    return gpio_to_irq(gpio);
316}
317
318
319/*
320 * ubi_gpio_init()
321 */
322int __init ubi_gpio_init(void)
323{
324    int k;
325    int status;
326    struct ubi_gpio_chip *chip;
327    struct gpio_chip *gc;
328
329    printk(KERN_INFO "Ubicom GPIO Controller\n");
330
331    chip = kzalloc(sizeof(struct ubi_gpio_chip), GFP_KERNEL);
332    if (chip == NULL)
333        return -ENOMEM;
334
335    gc = &chip->gpio_chip;
336    gc->request = ubi_gpio_request;
337    gc->free = ubi_gpio_free;
338    gc->to_irq = ubi_gpio_to_irq;
339    gc->direction_input = ubi_gpio_direction_input;
340    gc->direction_output = ubi_gpio_direction_output;
341    gc->get = ubi_gpio_get_value;
342    gc->set = ubi_gpio_set_value;
343    gc->can_sleep = 0;
344    gc->base = 0;
345    gc->ngpio = MAX_UBICOM_GPIOS; /* ARCH_NR_GPIOS - 1 */
346    gc->label = "ubi_gpio";
347
348    status = gpiochip_add(gc);
349    if (status != 0) {
350        kfree(chip);
351        return status;
352    }
353
354    /* Assert all pins are free */
355    for (k = 0; k < NUM_GPIO_PORTS; k++) {
356        reserved_gpio_map[k] = 0;
357    }
358
359    return 0;
360}
361
362#if defined(CONFIG_PROC_FS)
363/*
364 * ubi_get_gpio_dir()
365 */
366static int ubi_get_gpio_dir(unsigned gpio)
367{
368    if (gpio_bank_addr[gpio_bank(gpio)]->gpio_ctl & gpio_bit(gpio))
369        return 1;
370    else
371        return 0;
372}
373
374/*
375 * gpio_proc_read()
376 */
377static int ubi_gpio_proc_read(char *buf, char **start, off_t offset,
378              int len, int *unused_i, void *unused_v)
379{
380    int c, outlen = 0;
381
382    for (c = 0; c < MAX_UBICOM_GPIOS; c++) {
383        if (!check_gpio(c) &&
384            (reserved_gpio_map[gpio_bank(c)] & gpio_bit(c))) {
385            len = sprintf(buf, "GPIO_%d:\t\tGPIO %s\n", c,
386                      ubi_get_gpio_dir(c) ? "OUTPUT" : "INPUT");
387        } else {
388            continue;
389        }
390
391        buf += len;
392        outlen += len;
393    }
394    return outlen;
395}
396
397/*
398 * ubi_gpio_register_proc()
399 */
400static __init int ubi_gpio_register_proc(void)
401{
402    struct proc_dir_entry *proc_gpio;
403
404    proc_gpio = create_proc_entry("gpio", S_IRUGO, NULL);
405    if (proc_gpio)
406        proc_gpio->read_proc = ubi_gpio_proc_read;
407
408    return proc_gpio != NULL;
409}
410device_initcall(ubi_gpio_register_proc);
411#endif
412

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive