title: How to implement poll function into Linux kernel module?
body: <p>I'm trying to implement polling functionality into my simple Linux kernel module called gpio_driver for my Raspberry Pi which should notify the user space poll function about the change of state of one of the GPIO pins (button push).</p>
  
  <p>What I did in my gpio_driver is set the internal pull down on my GPIO_04 pin and direction to input, so when I press the button connected to the pin on one side and +5V on the other, it should generate a pulse which should notify the user space poll function that the button push happened and end the user space program.</p>
  
  <p>The user space program code:</p>
  
  <pre><code>#include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;fcntl.h&gt;
  #include &lt;unistd.h&gt;
  #include &lt;sys/time.h&gt;
  #include &lt;poll.h&gt;
  
  int main(int argc, char *argv[])
  {
     char str[256];
     struct pollfd pfd;
     int fd, gpio;
     char buf[8];
  
     sprintf(str, "/dev/gpio_driver");
  
     if ((fd = open(str, O_RDONLY)) &lt; 0)
     {
        fprintf(stderr, "Failed, gpio %d not exported.\n", gpio);
        exit(1);
     }
  
     pfd.fd = fd;
  
     pfd.events = POLLPRI;
  
     lseek(fd, 0, SEEK_SET);    /* consume any prior interrupt */
     read(fd, buf, sizeof buf);
  
     poll(&amp;pfd, 1, -1);         /* wait for interrupt */
  
     lseek(fd, 0, SEEK_SET);    /* consume interrupt */
     read(fd, buf, sizeof buf);
  
     exit(0);
  }
  </code></pre>
  
  <p>Complete driver code (poll function implementation at the end of file):</p>
  
  <pre><code>#include &lt;linux/init.h&gt;
  #include &lt;linux/module.h&gt;
  #include &lt;linux/kernel.h&gt;
  #include &lt;linux/slab.h&gt;
  #include &lt;linux/fs.h&gt;
  #include &lt;linux/errno.h&gt;
  #include &lt;linux/types.h&gt;
  #include &lt;linux/fcntl.h&gt;
  #include &lt;linux/proc_fs.h&gt;
  #include &lt;linux/string.h&gt;
  #include &lt;linux/ioport.h&gt;
  #include &lt;linux/ktime.h&gt;
  #include &lt;linux/hrtimer.h&gt;
  #include &lt;asm/io.h&gt;
  #include &lt;asm/uaccess.h&gt;
  #include &lt;linux/uaccess.h&gt;
  #include &lt;linux/ioctl.h&gt; 
  #include &lt;linux/poll.h&gt;
  
  MODULE_LICENSE("Dual BSD/GPL");
  
  /* if defined, timer callback will implement LED0 flashing and
     SW0 reading after each interval */
  #define TEST
  
  // timer interval defined as (TIMER_SEC + TIMER_NANO_SEC)
  #define TIMER_SEC    0
  #define TIMER_NANO_SEC  250*1000*1000 /* 250ms */
  
  // NOTE: Check Broadcom BCM8325 datasheet, page 91+
  // NOTE: GPIO Base address is set to 0x7E200000,
  //       but it is VC CPU BUS address, while the
  //       ARM physical address is 0x3F200000, what
  //       can be seen in pages 5-7 of Broadcom
  //       BCM8325 datasheet, having in mind that
  //       total system ram is 0x3F000000 (1GB - 16MB)
  //       instead of 0x20000000 (512 MB)
  
  /* GPIO registers base address. */
  #define BCM2708_PERI_BASE   (0x3F000000)
  #define GPIO_BASE           (BCM2708_PERI_BASE + 0x200000)
  #define GPIO_ADDR_SPACE_LEN (0xB4)
  //--
  
  //Handle GPIO: 0-9
  /* GPIO Function Select 0. */
  #define GPFSEL0_OFFSET (0x00000000)
  
  //Handle GPIO: 10-19
  /* GPIO Function Select 1. */
  #define GPFSEL1_OFFSET (0x00000004)
  
  //Handle GPIO: 20-29
  /* GPIO Function Select 2. */
  #define GPFSEL2_OFFSET (0x00000008)
  
  //Handle GPIO: 30-39
  /* GPIO Function Select 3. */
  #define GPFSEL3_OFFSET (0x0000000C)
  
  //Handle GPIO: 40-49
  /* GPIO Function Select 4. */
  #define GPFSEL4_OFFSET (0x00000010)
  
  //Handle GPIO: 50-53
  /* GPIO Function Select 5. */
  #define GPFSEL5_OFFSET (0x00000014)
  //--
  
  //GPIO: 0-31
  /* GPIO Pin Output Set 0. */
  #define GPSET0_OFFSET (0x0000001C)
  
  //GPIO: 32-53
  /* GPIO Pin Output Set 1. */
  #define GPSET1_OFFSET (0x00000020)
  //--
  
  //GPIO: 0-31
  /* GPIO Pin Output Clear 0. */
  #define GPCLR0_OFFSET (0x00000028)
  
  //GPIO: 32-53
  /* GPIO Pin Output Clear 1. */
  #define GPCLR1_OFFSET (0x0000002C)
  //--
  
  //GPIO: 0-31
  /* GPIO Pin Level 0. */
  #define GPLEV0_OFFSET (0x00000034)
  
  //GPIO: 32-53
  /* GPIO Pin Level 1. */
  #define GPLEV1_OFFSET (0x00000038)
  //--
  
  //GPIO: 0-53
  /* GPIO Pin Pull-up/down Enable. */
  #define GPPUD_OFFSET (0x00000094)
  
  //GPIO: 0-31
  /* GPIO Pull-up/down Clock Register 0. */
  #define GPPUDCLK0_OFFSET (0x00000098)
  
  //GPIO: 32-53
  /* GPIO Pull-up/down Clock Register 1. */
  #define GPPUDCLK1_OFFSET (0x0000009C)
  //--
  
  /* PUD - GPIO Pin Pull-up/down */
  typedef enum {PULL_NONE = 0, PULL_DOWN = 1, PULL_UP = 2} PUD;
  //--
  
  //000 = GPIO Pin 'x' is an input
  //001 = GPIO Pin 'x' is an output
  // By default GPIO pin is being used as an input
  typedef enum {GPIO_DIRECTION_IN = 0, GPIO_DIRECTION_OUT = 1} DIRECTION;
  //--
  
  /* GPIO pins available on connector p1. */
  #define GPIO_02 (2)
  #define GPIO_03 (3)
  #define GPIO_04 (4)
  #define GPIO_05 (5)
  #define GPIO_06 (6)
  #define GPIO_07 (7)
  #define GPIO_08 (8)
  #define GPIO_09 (9)
  #define GPIO_10 (10)
  #define GPIO_11 (11)
  #define GPIO_12 (12)
  #define GPIO_13 (13)
  #define GPIO_14 (14)
  #define GPIO_15 (15)
  #define GPIO_16 (16)
  #define GPIO_17 (17)
  #define GPIO_18 (18)
  #define GPIO_19 (19)
  #define GPIO_20 (20)
  #define GPIO_21 (21)
  #define GPIO_22 (22)
  #define GPIO_23 (23)
  #define GPIO_24 (24)
  #define GPIO_25 (25)
  #define GPIO_26 (26)
  #define GPIO_27 (27)
  
  /* Declaration of gpio_driver.c functions */
  int gpio_driver_init(void);
  void gpio_driver_exit(void);
  static int gpio_driver_open(struct inode *, struct file *);
  static int gpio_driver_release(struct inode *, struct file *);
  static ssize_t gpio_driver_read(struct file *, char *buf, size_t , loff_t *);
  static ssize_t gpio_driver_write(struct file *, const char *buf, size_t , loff_t *);
  static unsigned int gpio_driver_poll(struct file *, poll_table *);
  
  /* Structure that declares the usual file access functions. */
  struct file_operations gpio_driver_fops =
  {
      open            :   gpio_driver_open,
      release         :   gpio_driver_release,
      read            :   gpio_driver_read,
      write           :   gpio_driver_write,
      poll            :   gpio_driver_poll
  };
  
  static DECLARE_WAIT_QUEUE_HEAD(gpio_driver_wait);
  
  /* Declaration of the init and exit functions. */
  module_init(gpio_driver_init);
  module_exit(gpio_driver_exit);
  
  /* Major number. */
  int gpio_driver_major;
  
  /* Buffer to store data. */
  #define BUF_LEN 80
  char* gpio_driver_buffer;
  
  /* Virtual address where the physical GPIO address is mapped */
  void* virt_gpio_base;
  
  /*
   * GetGPFSELReg function
   *  Parameters:
   *   pin    - number of GPIO pin;
   *
   *   return - GPFSELn offset from GPIO base address, for containing desired pin control
   *  Operation:
   *   Based on the passed GPIO pin number, finds the corresponding GPFSELn reg and
   *   returns its offset from GPIO base address.
   */
  unsigned int GetGPFSELReg(char pin)
  {
      unsigned int addr;
  
      if(pin &gt;= 0 &amp;&amp; pin &lt;10)
          addr = GPFSEL0_OFFSET;
      else if(pin &gt;= 10 &amp;&amp; pin &lt;20)
          addr = GPFSEL1_OFFSET;
      else if(pin &gt;= 20 &amp;&amp; pin &lt;30)
          addr = GPFSEL2_OFFSET;
      else if(pin &gt;= 30 &amp;&amp; pin &lt;40)
          addr = GPFSEL3_OFFSET;
      else if(pin &gt;= 40 &amp;&amp; pin &lt;50)
          addr = GPFSEL4_OFFSET;
      else /*if(pin &gt;= 50 &amp;&amp; pin &lt;53) */
          addr = GPFSEL5_OFFSET;
  
    return addr;
  }
  
  /*
   * GetGPIOPinOffset function
   *  Parameters:
   *   pin    - number of GPIO pin;
   *
   *   return - offset of the pin control bit, position in control registers
   *  Operation:
   *   Based on the passed GPIO pin number, finds the position of its control bit
   *   in corresponding control registers.
   */
  char GetGPIOPinOffset(char pin)
  {
      if(pin &gt;= 0 &amp;&amp; pin &lt;10)
          pin = pin;
      else if(pin &gt;= 10 &amp;&amp; pin &lt;20)
          pin -= 10;
      else if(pin &gt;= 20 &amp;&amp; pin &lt;30)
          pin -= 20;
      else if(pin &gt;= 30 &amp;&amp; pin &lt;40)
          pin -= 30;
      else if(pin &gt;= 40 &amp;&amp; pin &lt;50)
          pin -= 40;
      else /*if(pin &gt;= 50 &amp;&amp; pin &lt;53) */
          pin -= 50;
  
      return pin;
  }
  
  /*
   * SetInternalPullUpDown function
   *  Parameters:
   *   pin    - number of GPIO pin;
   *   pull   - set internal pull up/down/none if PULL_UP/PULL_DOWN/PULL_NONE selected
   *  Operation:
   *   Sets to use internal pull-up or pull-down resistor, or not to use it if pull-none
   *   selected for desired GPIO pin.
   */
  void SetInternalPullUpDown(char pin, PUD pull)
  {
      unsigned int gppud_offset;
      unsigned int gppudclk_offset;
      unsigned int tmp;
      unsigned int mask;
  
      /* Get the offset of GPIO Pull-up/down Register (GPPUD) from GPIO base address. */
      gppud_offset = GPPUD_OFFSET;
  
      /* Get the offset of GPIO Pull-up/down Clock Register (GPPUDCLK) from GPIO base address. */
      gppudclk_offset = (pin &lt; 32) ? GPPUDCLK0_OFFSET : GPPUDCLK1_OFFSET;
  
      /* Get pin offset in register . */
      pin = (pin &lt; 32) ? pin : pin - 32;
  
      /* Write to GPPUD to set the required control signal (i.e. Pull-up or Pull-Down or neither
         to remove the current Pull-up/down). */
      iowrite32(pull, virt_gpio_base + gppud_offset);
  
      /* Wait 150 cycles – this provides the required set-up time for the control signal */
  
      /* Write to GPPUDCLK0/1 to clock the control signal into the GPIO pads you wish to
         modify – NOTE only the pads which receive a clock will be modified, all others will
         retain their previous state. */
      tmp = ioread32(virt_gpio_base + gppudclk_offset);
      mask = 0x1 &lt;&lt; pin;
      tmp |= mask;
      iowrite32(tmp, virt_gpio_base + gppudclk_offset);
  
      /* Wait 150 cycles – this provides the required hold time for the control signal */
  
      /* Write to GPPUD to remove the control signal. */
      iowrite32(PULL_NONE, virt_gpio_base + gppud_offset);
  
      /* Write to GPPUDCLK0/1 to remove the clock. */
      tmp = ioread32(virt_gpio_base + gppudclk_offset);
      mask = 0x1 &lt;&lt; pin;
      tmp &amp;= (~mask);
      iowrite32(tmp, virt_gpio_base + gppudclk_offset);
  }
  
  /*
   * SetGpioPinDirection function
   *  Parameters:
   *   pin       - number of GPIO pin;
   *   direction - GPIO_DIRECTION_IN or GPIO_DIRECTION_OUT
   *  Operation:
   *   Sets the desired GPIO pin to be used as input or output based on the direcation value.
   */
  void SetGpioPinDirection(char pin, DIRECTION direction)
  {
      unsigned int GPFSELReg_offset;
      unsigned int tmp;
      unsigned int mask;
  
      /* Get base address of function selection register. */
      GPFSELReg_offset = GetGPFSELReg(pin);
  
      /* Calculate gpio pin offset. */
      pin = GetGPIOPinOffset(pin);
  
      /* Set gpio pin direction. */
      tmp = ioread32(virt_gpio_base + GPFSELReg_offset);
      if(direction)
      { //set as output: set 1
        mask = 0x1 &lt;&lt; (pin*3);
        tmp |= mask;
      }
      else
      { //set as input: set 0
        mask = ~(0x1 &lt;&lt; (pin*3));
        tmp &amp;= mask;
      }
      iowrite32(tmp, virt_gpio_base + GPFSELReg_offset);
  }
  
  /*
   * GetGpioPinDirection function
   *  Parameters:
   *   pin       - number of GPIO pin;
   *  Operation:
   *   Gets the desired GPIO pin's direction and returns 0 for IN and 1 for OUT.
   */
  int  GetGpioPinDirection(char pin)
  {
      unsigned int GPFSELReg_offset;
      unsigned int tmp;
      unsigned int mask;
  
      /* Get base address of function selection register. */
      GPFSELReg_offset = GetGPFSELReg(pin);
  
      /* Calculate gpio pin offset. */
      pin = GetGPIOPinOffset(pin);
  
      /* Get gpio pin direction. */
      tmp = ioread32(virt_gpio_base + GPFSELReg_offset);
  
      mask = 0x1 &lt;&lt; (pin*3);
      tmp &amp;= mask;
      tmp=tmp&gt;&gt;(pin*3);
      return tmp;
   }
  
  /*
   * SetGpioPin function
   *  Parameters:
   *   pin       - number of GPIO pin;
   *  Operation:
   *   Sets the desired GPIO pin to HIGH level. The pin should previously be defined as output.
   */
  void SetGpioPin(char pin)
  {
      unsigned int GPSETreg_offset;
      unsigned int tmp;
  
      /* Get base address of gpio set register. */
      GPSETreg_offset = (pin &lt; 32) ? GPSET0_OFFSET : GPSET1_OFFSET;
      pin = (pin &lt; 32) ? pin : pin - 32;
  
      /* Set gpio. */
      tmp = 0x1 &lt;&lt; pin;
      iowrite32(tmp, virt_gpio_base + GPSETreg_offset);
  }
  
  /*
   * ClearGpioPin function
   *  Parameters:
   *   pin       - number of GPIO pin;
   *  Operation:
   *   Sets the desired GPIO pin to LOW level. The pin should previously be defined as output.
   */
  void ClearGpioPin(char pin)
  {
      unsigned int GPCLRreg_offset;
      unsigned int tmp;
  
      /* Get base address of gpio clear register. */
      GPCLRreg_offset = (pin &lt; 32) ? GPCLR0_OFFSET : GPCLR1_OFFSET;
      pin = (pin &lt; 32) ? pin : pin - 32;
  
      /* Clear gpio. */
      tmp = 0x1 &lt;&lt; pin;
      iowrite32(tmp, virt_gpio_base + GPCLRreg_offset);
  }
  
  /*
   * GetGpioPinValue function
   *  Parameters:
   *   pin       - number of GPIO pin;
   *
   *   return    - the level read from desired GPIO pin
   *  Operation:
   *   Reads the level from the desired GPIO pin and returns the read value.
   */
  char GetGpioPinValue(char pin)
  {
      unsigned int GPLEVreg_offset;
      unsigned int tmp;
      unsigned int mask;
  
      /* Get base address of gpio level register. */
      GPLEVreg_offset = (pin &lt; 32) ?  GPLEV0_OFFSET : GPLEV1_OFFSET;
      pin = (pin &lt; 32) ? pin : pin - 32;
  
      /* Read gpio pin level. */
      tmp = ioread32(virt_gpio_base + GPLEVreg_offset);
      mask = 0x1 &lt;&lt; pin;
      tmp &amp;= mask;
  
      return (tmp &gt;&gt; pin);
  }
  
  /*
   * Initialization:
   *  1. Register device driver
   *  2. Allocate buffer
   *  3. Initialize buffer
   *  4. Map GPIO Physical address space to virtual address
   *  5. Initialize GPIO pin
   */
  int gpio_driver_init(void)
  {
      int result = -1;
  
      printk(KERN_INFO "Inserting gpio_driver module\n");
  
      /* Registering device. */
      result = register_chrdev(0, "gpio_driver", &amp;gpio_driver_fops);
      if (result &lt; 0)
      {
          printk(KERN_INFO "gpio_driver: cannot obtain major number %d\n", gpio_driver_major);
          return result;
      }
  
      gpio_driver_major = result;
      printk(KERN_INFO "gpio_driver major number is %d\n", gpio_driver_major);
  
      /* Allocating memory for the buffer. */
      gpio_driver_buffer = kmalloc(BUF_LEN, GFP_KERNEL);
      if (!gpio_driver_buffer)
      {
          result = -ENOMEM;
          goto fail_no_mem;
      }
  
      /* Initialize data buffer. */
      memset(gpio_driver_buffer, 0, BUF_LEN);
  
      /* map the GPIO register space from PHYSICAL address space to virtual address space */
      virt_gpio_base = ioremap(GPIO_BASE, GPIO_ADDR_SPACE_LEN);
      if(!virt_gpio_base)
      {
          result = -ENOMEM;
          goto fail_no_virt_mem;
      }
  
      /* Initialize GPIO pin. */
      SetGpioPinDirection(GPIO_04, GPIO_DIRECTION_IN);
      SetInternalPullUpDown(GPIO_04, PULL_DOWN); // rising edge
  
      return 0;
  
  fail_no_virt_mem:
      /* Freeing buffer gpio_driver_buffer. */
      if (gpio_driver_buffer)
      {
          kfree(gpio_driver_buffer);
      }
  fail_no_mem:
      /* Freeing the major number. */
      unregister_chrdev(gpio_driver_major, "gpio_driver");
  
      return result;
  }
  
  /*
   * Cleanup:
   *  1. stop the timer
   *  2. release GPIO pins (clear all outputs, set all as inputs and pull-none to minimize the power consumption)
   *  3. Unmap GPIO Physical address space from virtual address
   *  4. Free buffer
   *  5. Unregister device driver
   */
  void gpio_driver_exit(void)
  {
      printk(KERN_INFO "Removing gpio_driver module..\n");
  
      /* Clear GPIO pins. */
      ClearGpioPin(GPIO_04);
  
      /* Set GPIO pins as inputs and disable pull-ups. */
      SetGpioPinDirection(GPIO_04, GPIO_DIRECTION_IN);
      SetInternalPullUpDown(GPIO_04, PULL_NONE);
  
      /* Unmap GPIO Physical address space. */
      if (virt_gpio_base)
      {
          iounmap(virt_gpio_base);
      }
  
      /* Freeing buffer gpio_driver_buffer. */
      if (gpio_driver_buffer)
      {
          kfree(gpio_driver_buffer);
      }
  
      /* Freeing the major number. */
      unregister_chrdev(gpio_driver_major, "gpio_driver");
  }
  
  /* File open function. */
  static int gpio_driver_open(struct inode *inode, struct file *filp)
  {
      /* Success. */
      return 0;
  }
  
  /* File close function. */
  static int gpio_driver_release(struct inode *inode, struct file *filp)
  {
      /* Success. */
      return 0;
  }
  
  /* File read function */
  static ssize_t gpio_driver_read(struct file *filp, char *buf, size_t len, loff_t *f_pos)
  {
      /* Size of valid data in gpio_driver - data to send in user space. */
      int data_size = 0;
  
      /* Copy GPIO pin state to user space. */
      gpio_driver_buffer[0]=GetGpioPinValue(GPIO_04);
  
      /* TODO: fill gpio_driver_buffer here. */
  
      if (*f_pos == 0)
      {
          /* Get size of valid data. */
          data_size = strlen(gpio_driver_buffer);
  
          /* Send data to user space. */
          if (copy_to_user(buf, gpio_driver_buffer, data_size) != 0)
          {
              return -EFAULT;
          }
          else
          {
              (*f_pos) += data_size;
  
              return data_size;
          }
      }
      else
      {
          return 0;
      }
  }
  
  /* File write function */
  static ssize_t gpio_driver_write(struct file *filp, const char *buf, size_t len, loff_t *f_pos)
  {
      printk(KERN_ALERT "Sorry, this operation isn't supported.\n");
  
      return -EPERM; // Operation not permitted error
  }
  
  static unsigned int gpio_driver_poll(struct file *filp, poll_table *wait)
  {
      unsigned int mask = 0;
      poll_wait(filp, &amp;gpio_driver_wait, wait);
      if(GetGpioPinValue(GPIO_04)!=0)
          gpio_driver_buffer[0] = 1;
      if(gpio_driver_buffer[0] == 1)
      {
          mask |= POLLIN | POLLPRI;
          wake_up_interruptible(&amp;gpio_driver_wait);
      }
      gpio_driver_buffer[0] = 0;
      return mask;
  }
  </code></pre>
  
  <p>However, when I run my user space program, it doesn't react to my button pushes and it never exits. I'm pretty new to polling all the code written in the driver related to polling and user program I picked up online from different sources and some books (mainly Linux Device Drivers, 3rd edition, chapter 6). What am I doing wrong?</p>