Raspberry Pi interrupt to signal conversion C source code, kernel module

---

This code is from project: Raspberry pi interrupt to signal conversion, kernel to user space

---

m_gpioSignal.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

#include <linux/interrupt.h>
#include <linux/gpio.h>

#include <asm/uaccess.h>
#include <linux/fs.h>

#include <linux/signal.h>
#include <linux/sched.h>


#define DRIVER_AUTHOR      "Igor <hardware.coder@gmail.com>"
#define DRIVER_DESC        "Test sending signal triggered by gpio."

#define DEVICE_NAME        "m_gpioSignal"
#define READ_BUFF_LEN      6

#define DEFAULT_GPIO_PIN   17
#define GPIO_PIN_DEV_STR   "pin"
#define GPIO_PIN_STR       "Signal trigger gpio pin."

#define DEFAULT_SIGNAL     34


/****************************************************************************/
/* Module params declaration block                                          */
/****************************************************************************/
static short int gpio_pin = DEFAULT_GPIO_PIN;


/****************************************************************************/
/* Interrupts variables block                                               */
/****************************************************************************/
short int irq_gpio_pin   = DEFAULT_GPIO_PIN;
short int irq_enabled    = 0;    // this is only a flag


/****************************************************************************/
/* Function variables block                                                 */
/****************************************************************************/
pid_t send_to_pid        = 0;    // here will be pid of process to which
                                 // signal will be send
short int signal_to_pid  = DEFAULT_SIGNAL;


/****************************************************************************/
/* Device variables block                                                   */
/****************************************************************************/
static int     major_device_num;
static int     device_open_counter = 0;

static int     r_open(struct inode *, struct file *);
static int     r_release(struct inode *, struct file *);

static ssize_t r_write(struct file *,  const char *, size_t, loff_t *);

static struct file_operations fops = {
   .write   = r_write,
   .open    = r_open,
   .release = r_release
};


/****************************************************************************/
/* Device funtions                                                          */
/****************************************************************************/
static int r_open(struct inode *inode, struct file *file) {

   if (device_open_counter)
      return -EBUSY;

   device_open_counter++;
   try_module_get(THIS_MODULE);

//    printk(KERN_INFO "Dev open\n");

   return 0;
}


static ssize_t r_write(struct file *f, const char *buff_in, size_t data_len,
                       loff_t * offset) {

   char readBuff[READ_BUFF_LEN];

   if (data_len > READ_BUFF_LEN) {
      printk(KERN_INFO "Read error, buffer overflow\n");
      return -EINVAL;
   }

   copy_from_user(readBuff, buff_in, data_len);    // copy char data from
                                                   // /dev/m_gpioSignal

   rcu_read_unlock();   // must be used, otherwise code will loop

   if (sscanf(readBuff, "%d", &send_to_pid)  == 1) {
      printk(KERN_INFO "send_to_pid set: %d\n", send_to_pid);

      irq_enabled = 1;     // enable interrupt processing flag

   } else {
      printk(KERN_INFO "Read error.\n");
   }

   return data_len;
}


static int r_release(struct inode *inode, struct file *file) {
   device_open_counter--;

   module_put(THIS_MODULE);

//    printk(KERN_INFO "Dev closed \n");

   return 0;
}


/****************************************************************************/
/* Module params binding block.                                             */
/****************************************************************************/
module_param(gpio_pin, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(gpio_pin, "Pin which is connected to button");

module_param(signal_to_pid, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(signal_to_pid, "Signal to send");


/****************************************************************************/
/* IRQ handler                                                              */
/****************************************************************************/
static irqreturn_t r_irq_handler(int irq, void *dev_id, struct pt_regs *regs) {


   struct task_struct *task_from_pid;

   if (irq_enabled == 0 )  // if interrupt flag is disabled, return
      return IRQ_HANDLED;

   irq_enabled = 0;

   // get the task from pid for funcion send_sig_info
   if ( (task_from_pid = pid_task(find_vpid(send_to_pid),
                                  PIDTYPE_PID)) == NULL ) {
      printk(KERN_INFO "Can't find task assocaied with pid: %d\n", send_to_pid);
      return IRQ_HANDLED;
   }

   // send signal (without info struct) to pid descriped by task
   if (send_sig_info(signal_to_pid, SEND_SIG_FORCED, task_from_pid) < 0 ) {
      printk(KERN_INFO "Signal not send\n");
   } else {
      printk(KERN_INFO "Signal %d was send to pid %d\n",
             signal_to_pid, send_to_pid);
   }


   return IRQ_HANDLED;
}


/****************************************************************************/
/* This function configures interrupts.                                     */
/****************************************************************************/
void r_int_config(void) {


   if (gpio_request(gpio_pin, GPIO_PIN_STR)) {
      printk(KERN_INFO "GPIO request faiure %d\n", gpio_pin);
      return;
   }

   if ( (irq_gpio_pin = gpio_to_irq(gpio_pin)) < 0 ) {
      printk(KERN_INFO "GPIO to IRQ mapping faiure %d\n", gpio_pin);
      return;
   }

   printk(KERN_INFO "Mapped int %d\n", irq_gpio_pin);

   if (request_irq(irq_gpio_pin,
                   (irq_handler_t ) r_irq_handler,
                   IRQF_TRIGGER_FALLING,
                   GPIO_PIN_STR,
                   GPIO_PIN_DEV_STR)) {
      printk("Irq Request failure\n");
      return;
   }

   printk(KERN_INFO "Info: signal_to_pid is %d, gpio_pin is %d\n",
          signal_to_pid, gpio_pin);

   return;
}


/****************************************************************************/
/* This function releases interrupts.                                       */
/****************************************************************************/
void r_int_release(void) {

   free_irq(irq_gpio_pin, GPIO_PIN_DEV_STR);
   gpio_free(gpio_pin);

   return;
}


/****************************************************************************/
/* Module init / cleanup block.                                             */
/****************************************************************************/
int r_init(void) {

   printk(KERN_INFO "Hello\n");
   r_int_config();

   if ((major_device_num = register_chrdev(0, DEVICE_NAME, &fops)) < 0 ) {
     printk(KERN_ALERT "Registering char device failed with %d\n",
            major_device_num);
     return major_device_num;
   }

   printk(KERN_INFO "'mknod /dev/%s c %d 0'\n", DEVICE_NAME,
         major_device_num);

   return 0;
}


void r_cleanup(void) {
   printk(KERN_INFO "Goodbye\n");
   r_int_release();

   unregister_chrdev(major_device_num, DEVICE_NAME);

   return;
}


module_init(r_init);
module_exit(r_cleanup);


/****************************************************************************/
/* Module licensing/description block.                                      */
/****************************************************************************/
MODULE_LICENSE("GPL");
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);


/****************************************************************************/
/* Module function blocks.                                                  */
/****************************************************************************/

Makefile

# my optional module name
MODULE=m_gpioSignal

# this two variables, depends where you have you raspberry kernel source and tools installed
CCPREFIX=/opt/raspberry_pi-kernel/tools/arm-bcm2708/arm-bcm2708-linux-gnueabi/bin/arm-bcm2708-linux-gnueabi-
KERNEL_SRC=/opt/raspberry_pi-kernel/linux


obj-m += ${MODULE}.o

module_upload=${MODULE}.ko

all: clean compile

compile:
 make ARCH=arm CROSS_COMPILE=${CCPREFIX} -C ${KERNEL_SRC} M=$(PWD) modules

clean:
 make -C ${KERNEL_SRC} M=$(PWD) clean

# this just copies a file to raspberry (rb is an alias in /etc/hosts as ip of my raspberry pi)
# install is depend to 'all' so after code change, you must only do 'make install'
# code will be compiled and send to your raspberry pi
install: all
 scp ${module_upload} pi@rb:progs/cpp/gpioSignal

# this invokes my test script which load module and do a small test
restart:
 ssh pi@rb 'progs/cpp/gpioSignal/mod_test' 

# show information about module
info:
 modinfo  ${module_upload}