MyIrMod.c

Go to the documentation of this file.

/********************************************************************************/
/* Use a raspberry pi with a IR led as remote control for your Tv, Dvd etc.     */
/* Copyright (C) 2016  Ed Kapitein                                              */
/*                                                                              */
/* This program is free software: you can redistribute it and/or modify         */
/* it under the terms of the GNU General Public License as published by         */
/* the Free Software Foundation, either version 3 of the License, or            */
/* (at your option) any later version.                                          */
/*                                                                              */
/* This program is distributed in the hope that it will be useful,              */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of               */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
/* GNU General Public License for more details.                                 */
/*                                                                              */
/* You should have received a copy of the GNU General Public License            */
/* along with this program.  If not, see <http://www.gnu.org/licenses/>.        */
/********************************************************************************/
/*
 * \brief Create a device to send IR commands.
 *
 * Create an input/output character device to send IR commands to a TV, setopbox etc
 * Thanks to all the people who share code and explain how to do things.
 * I could not have done it without them
 * Most is taken from: http://www.tldp.org/LDP/lkmpg/2.6/html/x892.html
 */

#include <linux/kernel.h>       /* We're doing kernel work              */
#include <linux/module.h>       /* Specifically, a module               */
#include <linux/device.h>       /* and we create a device               */
#include <linux/fs.h>
#include <asm/uaccess.h>        /* for get_user and put_user            */
#include "../Kmod/Kmod.h"
#include <linux/gpio.h>
#include <linux/delay.h>

MODULE_LICENSE("GPL");                  
MODULE_AUTHOR("Ed Kapitein");

static short int gpionr = 14;           
module_param(gpionr, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(gpionr, "gpio number used for modulating the carrier");

static short int invert = 1;
module_param(invert, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(invert, "invert value (gpio=low means CarrierOn ), default=1");

static short int debug = 0;                     
module_param(debug, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(debug, "debug level");

char                    *label = "MyLabel";     
unsigned long           flags;                  
static struct   class*  MyIrClass  = NULL;      /*/< The device-driver class struct pointer                                                     */
static struct   device* MyIrDevice = NULL;      /*/< The device-driver device struct pointer                                                    */
static int              majorNumber;            /*/< Stores the device number - determined automatically                                        */
static int              Device_Open = 0;        
static char Message[BUF_LEN];                   
int IoctlRange( int Range )
 {
 volatile uint32_t      *GpioBase;              
 volatile uint32_t      *Pwm;                   
 uint32_t               Mask;

 /* initialize a pointer to the gpio registers */
 if( ( GpioBase = ioremap( IO_BASE + GPIO_CONTROL, SZ_4K ) ) == NULL )
  {
  printk(KERN_ALERT "201608202038 mapping GpioBase failed.\n");
  return(-1);
  }

 /***************************************************************************************************************************************/
 /* This whole section could be written as:                                                                                             */
 /* #define     INP_GPIO(g)             *(GpioBase + ( (g)/10) ) &= ~(7<<(((g)%10)*3))                                                  */
 /* #define     SET_GPIO_ALT(g,a)       *(GpioBase + (((g)/10))) |= (((a)<=3?(a) + 4:(a)==4?3:2)<<(((g)%10)*3))                         */
 /* INP_GPIO(PwmPin);                                                                                                                   */
 /* SET_GPIO_ALT(PwmPin,5);                                                                                                             */
 /* But i can't seem to get my head around it...                                                                                        */
 /* the gpio pins are controlled by 32 bit registers for their Alt functions                                                            */
 /* the Alt functions have 3 bits, and there are 10 gpio per register.                                                                  */
 /* So setting gpio pin 18 is done by selecting register 1 (=18/10), ( register 0 holds gpio 0-9 ),                                     */
 /* and shift the disired 3 bit Alt function pattern 8 times to the left. ( (PwmPin-(10*(PwmPin/10))*3) = (18-10)*3 = 24 )              */
 /* That will put it at bit 24-26.                                                                                                      */
 /* To only affected the bits we want and to leave the other bits as they are, we use OR and AND functions                              */
 /* Alt function 5 has bit battern 010, so you need to select bit patern 101 (=0x005), shift it and invert it so it becomes 010         */
 /***************************************************************************************************************************************/
 Mask = 0x0007 << ( ( PwmPin - 10 * (PwmPin/10) ) * 3 );        /* set all AltReg bits to 1 and shift them into place                   */
 Mask = ~Mask;                                                  /* invert the mask so all AltReg bits are 0                             */

 *( GpioBase + PwmPin/10 ) = *(GpioBase + PwmPin/10 ) &  Mask;  /* AND the mask, so only the AltReg are set to 0                        */
 Mask = ~Mask;                                                  /* invert the mask so all AltReg bits are 1                             */
 *( GpioBase + PwmPin/10 ) = *(GpioBase + PwmPin/10 ) |  Mask;  /* OR the mask, so only the AltReg bits are set to 1                    */

 Mask = 0x0005 << ( ( PwmPin - 10 * (PwmPin/10) ) * 3 );        /* select the AltReg bits that need to become 0 (010) and shift them    */
 Mask = ~Mask;                                                  /* invert the mask so all bits are 1 except the selected AltReg bits    */
 *(GpioBase + PwmPin/10) = *(GpioBase + PwmPin/10) &  Mask;     /* AND the mask, so only the selected AltReg are set to 0               */

 udelay(110);

 /* initialize a pointer to the pwm registers */
 if( ( Pwm = ioremap( IO_BASE + GPIO_CONTROL +  GPIO_PWM, SZ_4K ) ) == NULL )
  {
  printk(KERN_ALERT "201608202039 mapping Pwm failed.\n");
  return(-1);
  }

 /* set Pwm to balanced mode. */
 *(Pwm + PWM_CONTROL) = PWM0_ENABLE | PWM0_MODE_BAL;

 /* set the range for the Pwm channel. */
 *(Pwm + PWM0_RANGE) = Range ; 

 udelay(10);

 if( debug > 0 )
  {
  printk( KERN_INFO "201608202219 Range   is: %i\n", Range );
  }

 return(0);

 }

int IoctlDivisor( int Divisor )
 {
 long                   PwmControl;
 volatile uint32_t      *Pwm;
 volatile uint32_t      *Clk;

 /* initialize a pointer to the pwm registers */
 if( ( Pwm = ioremap( IO_BASE + GPIO_CONTROL + GPIO_PWM, SZ_4K ) ) == NULL )
  {
  printk(KERN_ALERT "201608202039 mapping Pwm failed.\n");
  return(-1);
  }

 if( ( Clk = ioremap( IO_BASE + GPIO_CLK, SZ_4K ) ) == NULL )
  {
  printk(KERN_ALERT "201608202040 mapping Clk failed.\n");
  return(-1);
  }

 /* set clock */
 Divisor &= 4095 ;
 PwmControl = *(Pwm + PWM_CONTROL) ;                            /* preserve PWM_CONTROL */
 *(Pwm + PWM_CONTROL) = 0 ;                                     /* Stop PWM             */
 *(Clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ;                   /* Stop PWM Clock       */

 udelay(110);                                                   /* 110 uS prevents clock going sloooow */

 while ((*(Clk + PWMCLK_CNTL) & 0x80) != 0)                     /* Wait for clock to be !BUSY           */
  {
  udelay(1);
  }

 *(Clk + PWMCLK_DIV)  = BCM_PASSWORD | (Divisor << 12) ;        /* Set the Divisor      */

 *(Clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11;                    /* Start PWM clock      */
 *(Pwm + PWM_CONTROL) = PwmControl;                             /* restore PWM_CONTROL  */

 if( debug > 0 )
  {
  printk( KERN_INFO "201608202220 Divisor is: %i\n", Divisor );
  }

 return(0);

 }

int IoctlDuty( int DutyCycle )
 {
 static volatile uint32_t       *Pwm;
 volatile uint16_t              Range;

 /* initialize a pointer to the Pwm registers */
 if( ( Pwm = ioremap( IO_BASE + GPIO_CONTROL + GPIO_PWM, SZ_4K) ) == NULL )
  {
  printk( KERN_ALERT "201608201747 mapping Pwm failed\n" );
  return(-1);
  }

 /* read the Range for the pwm channel. */
 if( ( Range = *( Pwm + PWM0_RANGE ) ) < 1 ) 
  {
  printk( KERN_ALERT "201608201747 readin Range failed\n" );
  return(-1);
  }

 if( debug > 0 )
  {
  printk( KERN_INFO "201608201830 Range is: %i\n", Range );
  }

 *( Pwm + PWM0_DATA ) = Range * DutyCycle / 100;                /* Set the dutycycle    */

 return(0);
 }

static int device_open(struct inode *inode, struct file *file)
 {
 if( debug > 0 )
  {
  printk(KERN_INFO "device_open(%p)\n", file);
  }

 /* We don't want to talk to two processes at the same time */
 if(Device_Open)
  {
  return -EBUSY;
  }

 Device_Open++;
 try_module_get(THIS_MODULE);
 return 0;
 }

static int device_release(struct inode *inode, struct file *file)
 {
 if( debug > 0 )
  {
  printk(KERN_INFO "device_release(%p,%p)\n", inode, file);
  }

 /* We're now ready for our next caller */
 Device_Open--;

 module_put(THIS_MODULE);
 return 0;
 }

static ssize_t device_read(struct file *file, char __user * buffer, size_t length, loff_t * offset)
 {
 printk(KERN_ALERT "201608131202 Sorry, this operation isn't supported.\n");
 return -EINVAL;
 }

static ssize_t device_write(struct file *file, const char __user * buffer, size_t length, loff_t * offset)
 {
 int                            i;
 int                            n;
 int                            NrOfStates=0;                           /* use a counter for the state and duration elements    */
 static char                    TempBuf[BUF_LEN];                       /* a buffers to store the values before computation     */
 volatile static uint64_t       *Timer;
 uint64_t                       Prev;
 static long int                State[BUF_LEN];                         /* State is 0 or 1                                      */
 static long int                Duration[BUF_LEN];                      /* Duration in usecs                                    */
 int                            BytesRead;

 if( debug > 0 )
  {
  printk(KERN_INFO "device_write(%p,%s,%d)", file, buffer, length);
  }

 /* set a pointer to the 1MHz clock we use for time stamps */
 if( ( Timer = ioremap( IO_BASE + TIMER_CONTROL + ONE_MHZ_COUNTER, SZ_4K) ) == NULL )
  {
  printk(KERN_ALERT "201608111618 ioremap() failed.\n");
  return -1;
  }

 /* request our gpionr */
 if( ( gpio_request(gpionr, label) ) != 0 )
  {
  printk(KERN_ALERT "201608112230 gpio_request failed\n");
  return(-1);
  }

 /* set it to output */
 if( ( gpio_direction_output(gpionr,1) ) != 0 )
  {
  printk(KERN_ALERT "201608112231 gpio_direction_output failed\n");
  return(-1);
  }
 
 /* read the user data and store it in a Message buffer */
 for (i = 0; i < length && i < BUF_LEN; i++)
  {
  get_user(Message[i], buffer + i);
  }
 BytesRead=i;

 /* split the comma seperated values in the Message buffer into Element buffers, one value per element */
 NrOfStates=0;
 for (i = 0; i < length && i < BUF_LEN; i++)
  {
  /* Read first element (State) and save it in its array */
  n=0;
  while( Message[i] != ',' && i < length && i < BUF_LEN )               /* state and duration are comma seperated */
   {
   TempBuf[n]=Message[i];
   i++;
   n++;
   }
  TempBuf[n]=0;                                                 /* NULL terminate the string */
 
  if( ( kstrtol( TempBuf, 10, &State[NrOfStates] ) ) != 0 )     /* and convert it to a long integer */
   {
   printk(KERN_ALERT "201608151349 kstrtol failed\n" );
   }

  if( State[NrOfStates] < 0 || State[NrOfStates] > 1 )
   {
   if( State[NrOfStates] != -1 )        /* -1 means end of frame */
    {
    printk(KERN_ALERT "201608151309 State is not 1 or 0 or -1 (End of Frame)\n" );
    }
   }

  /* Read second element (Duration) and save it in its array */
  i++;
  n=0;
  while( Message[i] != ',' && i < length && i < BUF_LEN )       /* state and duration are comma seperated */
   {
   TempBuf[n]=Message[i];
   i++;
   n++;
   }
  TempBuf[n]=0;                                                 /* NULL terminate the string */
 
  if( ( kstrtol( TempBuf, 10, &Duration[NrOfStates] ) ) != 0 )  /* and convert it to a long integer */
   {
   printk(KERN_ALERT "20160808122108 kstrtol failed\n" );
   }

  if( Duration[NrOfStates] < 0 || Duration[NrOfStates] > MaxFrameTime  )
   {
   if( Duration[NrOfStates] != -1 )     /* -1 means end of frame */
    {
    printk(KERN_ALERT "201608151352 Duration is too small or to big\n" );
    }
   }

  NrOfStates++;                                 
  }

 /* pulse the gpio pin acording to the info in the frame */

 /* switch the pin off to have a known state            */
 /* the XOR inverts the 0x00 if invert is set to 1      */
 /* the AND ignores the other bits                      */
 gpio_set_value(gpionr, ( 0x00 ^ invert ) & 0x01 );

 /* This code runs with interrupts disabled */
 local_irq_save(flags);

 for( n=0; n< NrOfStates; n++ )
  {
  /* check if this is the last element of the frame (,-1,-1) */
  if( State[n] == -1 )
   {
   local_irq_restore(flags);
   gpio_free(gpionr);
   return(BytesRead);
   }

  if( debug > 0 )
   {
   printk(KERN_INFO "State In Loop: %i = %li\n", n, State[n]);
   printk(KERN_INFO "Duration In Loop: %i = %li\n", n, Duration[n]);
   }

  gpio_set_value(gpionr, ( State[n] ^ invert ) & 0x01 );

  if( Duration[n] > 2000 )                              /* keeping interrupts off for to long seems to fail     */
   {
   Prev = *Timer;                                       /* save the hardware timer                              */
   local_irq_restore(flags);                            /* restore interrupts                                   */

   while( *Timer - Prev < Duration[n] )                 /* run a loose loop, it works better than msleep/mdelay */
    {
    udelay(100);
    }

   if( debug > 0 )
    {
    printk(KERN_INFO "Slept in loop: %llu\n", *Timer - Prev);
    }

   local_irq_save(flags);
   }
  else
   {
   Prev = *Timer;                                       /* save the hardware timer */
   udelay(Duration[n]);

   if( debug > 0 )
    {
    printk(KERN_INFO "uSlept in loop: %llu\n", *Timer - Prev);
    }

   }

  }

 /* we should never reach this, as the frame should end with -1,-1 and that is checked earlier */
 /* but just in case a frame is uncorectly terminated ... */
 local_irq_restore(flags);
 mdelay(10);
 gpio_free(gpionr);
 return(BytesRead);

 }

static long device_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 {
 switch(cmd)    {
                case IOCTL_RANGE: 
                IoctlRange( arg );
                break;

                case IOCTL_DIVISOR: 
                IoctlDivisor( arg );
                break;

                case IOCTL_DUTY: 
                IoctlDuty( arg );
                break;

                default: 
                printk(KERN_ALERT "201608151725 Sorry, this operation isn't supported.\n");
                return -EINVAL;
                }

 return 0;
 }

/* Module Declarations */

struct file_operations Fops = {
        .read           = device_read,
        .write          = device_write,
        .open           = device_open,
        .unlocked_ioctl = device_ioctl,
        .release        = device_release,       /* a.k.a. close */
};

int init_module()
 {
 if( debug > 0 )
  {
  printk(KERN_INFO "Using Gpio %hd", gpionr); 
  }

 /* Try to dynamically allocate a major number for the device -- more difficult but worth it    */
 majorNumber = register_chrdev(0, DEVICE_NAME, &Fops);
 if (majorNumber<0)
  {
  printk(KERN_ALERT "MyIrMod failed to register a major number\n");
  return majorNumber;
  }
 printk(KERN_INFO "MyIrMod: registered correctly with major number %d\n", majorNumber);
 
 /* Register the device class   */
 MyIrClass = class_create(THIS_MODULE, CLASS_NAME);

 /* Check for error and clean up if there is    */
 if(IS_ERR(MyIrClass))
  {
  unregister_chrdev(majorNumber, DEVICE_NAME);
  printk(KERN_ALERT "Failed to register device class\n");
  return PTR_ERR(MyIrClass);          /* Correct way to return an error on a pointer    */
  }
 printk(KERN_INFO "MyIrMod: device class registered correctly\n");
 
 /* Register the device driver  */
 MyIrDevice = device_create(MyIrClass, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME);

 /* Clean up if there is an error       */
 if (IS_ERR(MyIrDevice))
  {
  class_destroy(MyIrClass);           /* Repeated code but the alternative is goto statements   */
  unregister_chrdev(majorNumber, DEVICE_NAME);
  printk(KERN_ALERT "Failed to create the device\n");
  return PTR_ERR(MyIrDevice);
  }
 printk(KERN_INFO "MyIrMod: device class created correctly\n"); 
 
 return 0;
 }

void cleanup_module()
 {
 /*Unregister the device */
 device_destroy(MyIrClass, MKDEV(majorNumber, 0));     /* remove the device             */
 class_unregister(MyIrClass);                          /* unregister the device class   */
 class_destroy(MyIrClass);                             /* remove the device class       */
 unregister_chrdev(majorNumber, DEVICE_NAME);          /* unregister the major number   */
 }