[Kernel] Linux GPIO Subsystem

bool gpio_is_valid(int number);
 int gpio_request(unsigned gpio, const char *label);
void gpio_free(unsigned gpio);
 int gpio_direction_input(unsigned gpio);
 int gpio_direction_output(unsigned gpio, int value);
 int gpio_get_value(unsigned gpio);
void gpio_set_value(unsigned gpio, int value);
 int gpio_export(unsigned gpio, bool direction_may_change);
void gpio_unexport(unsigned gpio);
 int gpio_to_irq(unsigned gpio);

/*
 * test module for kernel gpio subsystem
 * module functions:
 *     set a certain pin to output, then set it as high
 *     set a specific pin to input, rising edge as external interrupt and
 *     interrupt handler will print some message to kernel log
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/errno.h>

#define USR0_PIN        (32*1 + 21)
#define USR1_PIN        (32*1 + 22)
#define USR2_PIN        (32*1 + 23)
#define USR3_PIN        (32*1 + 24)
#define BUZZER_PIN      (32*1 + 28)

irqreturn_t gpio_interrupt(int irq, void *dev_id)
{
        printk(KERN_ALERT "irq-%d occurs\n", irq);

        return IRQ_HANDLED;
}

static int __init gpio_init(void)
{
        const char *pin_name = "buzzer";
        int ret = 0;
        int pin_val, pin_irq_no;

        if (gpio_is_valid(BUZZER_PIN) == false) {
                printk(KERN_ERR "Error: gpio%d[%d] invalid\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                ret = -EINVAL;
                goto validate_failed;
        }

        ret = gpio_request(BUZZER_PIN, pin_name);
        if (ret == -EBUSY) {
                printk(KERN_ERR "Error: gpio%d[%d] busy\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                goto request_failed;
        } else if (ret < 0) {
                printk(KERN_ERR "Error: gpio%d[%d] request failed\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                goto request_failed;
        }

        ret = gpio_export(BUZZER_PIN, true);
        if (ret != 0) {
                printk(KERN_ERR "Error: gpio%d[%d] export failed\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                goto export_failed;
        }

        ret = gpio_direction_output(BUZZER_PIN, 1);
        if (ret != 0) {
                printk(KERN_ERR "Error: gpio%d[%d] set direction failed\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                goto direction_failed;
        }

        gpio_set_value(BUZZER_PIN, 1);
        mdelay(50);
        gpio_set_value(BUZZER_PIN, 0);

        ret = gpio_direction_input(BUZZER_PIN);
        if (ret != 0) {
                printk(KERN_ERR "Error: gpio%d[%d] set direction failed\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
                goto direction_failed;
        }

        pin_val = gpio_get_value(BUZZER_PIN);
        printk(KERN_ALERT "value of gpio%d[%d] is %d\n",
                        BUZZER_PIN/32, BUZZER_PIN%32, pin_val);

        pin_irq_no = gpio_to_irq(BUZZER_PIN);
        if (pin_irq_no < 0) {
                printk(KERN_ERR "Error: gpio%d[%d] has no irq\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
        }
        printk(KERN_ALERT "irq of gpio%d[%d] is %d\n",
                        BUZZER_PIN/32, BUZZER_PIN%32, pin_irq_no);

        ret = request_irq(pin_irq_no,
                          gpio_interrupt,
                          IRQF_TRIGGER_RISING,
                          "buzzer_pin",
                          NULL);

        printk(KERN_INFO "gpio.ko: init ok\n");
        return 0;

direction_failed:
        gpio_unexport(BUZZER_PIN);
export_failed:
        gpio_free(BUZZER_PIN);
request_failed:
validate_failed:
        return ret;
}

static void __exit gpio_exit(void)
{
        int pin_irq_no;

        pin_irq_no = gpio_to_irq(BUZZER_PIN);
        if (pin_irq_no < 0) {
                printk(KERN_ERR "Error: gpio%d[%d] has no irq\n",
                                BUZZER_PIN/32, BUZZER_PIN%32);
        }

        gpio_set_value(BUZZER_PIN, 0);
        gpio_unexport(BUZZER_PIN);
        gpio_free(BUZZER_PIN);
        free_irq(pin_irq_no, NULL);

        printk(KERN_INFO "gpio.ko: exit ok\n");
}

module_init(gpio_init);
module_exit(gpio_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Xiaojie Yuan <yxj0207@gmail.com>");