Colony » Colony Scout

#include <linux/init.h>

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/slab.h>

#include <linux/device.h>

#include <linux/semaphore.h>

#include <asm/uaccess.h>

MODULE_AUTHOR("Tom Mullins");

MODULE_LICENSE("GPL");

/*

 * TODO

 *

 * clean up before final move to gumstix

 * add interrupt counting

 *

 */

typedef long enc_val_t;

#define BUF_LEN 20

#define N_ENCODERS 4

int enc_pins[N_ENCODERS][2] = {{78, 79}, {80, 81}, {82, 83}, {84, 85}};

struct class *enc_class = NULL;

dev_t first_dev;

struct enc_t

{

  char buf[BUF_LEN+1];

  struct cdev cdev;

  struct semaphore sem;

  struct device *device;

  int status;

  enc_val_t value;

  dev_t dev;

}

encs[N_ENCODERS];

static int enc_open(struct inode *inode, struct file *file);

static ssize_t enc_read(struct file *file, char __user *udata, size_t count,

    loff_t *offset);

static ssize_t enc_write(struct file *file, const char __user *udata,

    size_t count, loff_t *offset);

static void enc_free(struct enc_t *enc);

static int enc_init(dev_t dev, struct enc_t *enc);

struct file_operations fops =

{

  .owner = THIS_MODULE,

  .open = enc_open,

  .read = enc_read,

  .write = enc_write

};

static int enc_open(struct inode *inode, struct file *file)

{

  int i = iminor(inode);

  if (i < 0 || i >= N_ENCODERS)

  {

    return -ENXIO;

  }

  file->private_data = &encs[i];

  return 0;

}

static ssize_t enc_read(struct file *file, char __user *udata, size_t count,

    loff_t *offset)

{

  int len;

  struct enc_t *enc = file->private_data;

  if (down_interruptible(&enc->sem))

  {

    return -ERESTARTSYS;

  }

  len = snprintf(enc->buf, BUF_LEN+1, "%ld\n", enc->value);

  if (*offset > len)

  {

    return 0;

  }

  len -= *offset;

  if (len > count)

  {

    len = count;

  }

  copy_to_user(udata, enc->buf + *offset, len);

  *offset += len;

  up(&enc->sem);

  return len;

}

static ssize_t enc_write(struct file *file, const char __user *udata,

    size_t count, loff_t *offset)

{

  char *end;

  struct enc_t *enc = file->private_data;

  if (down_interruptible(&enc->sem))

  {

    return -ERESTARTSYS;

  }

  if (count > BUF_LEN)

  {

    count = BUF_LEN;

  }

  copy_from_user(enc->buf, udata, count);

  enc->buf[count] = '\0';

  enc->value = simple_strtol(enc->buf, &end, 10);

  *offset += count;

  up(&enc->sem);

  return count;

}

static int enc_init(dev_t dev, struct enc_t *enc)

{

  int err;

  // initialize members

  cdev_init(&enc->cdev, &fops);

  enc->cdev.owner = THIS_MODULE;

  enc->dev = dev;

  enc->status = 0;

  sema_init(&enc->sem, 1);

  // make cdev file operations accessible

  err = cdev_add(&enc->cdev, enc->dev, N_ENCODERS);

  if (err)

  {

    enc_free(enc);

    return err;

  }

  enc->status = 1;

  // make file in /dev

  enc->device = device_create(enc_class, NULL, enc->dev, NULL, "enc%d",

      MINOR(enc->dev));

  if (IS_ERR(enc->device))

  {

    err = PTR_ERR(enc->device);

    enc->device = NULL;

    enc_free(enc);

    return err;

  }

  enc->status = 2;

  return 0;

}

static void enc_free(struct enc_t *enc)

{

  switch (enc->status)

  {

    case 2:

      device_destroy(enc_class, enc->dev);

      enc->device = NULL;

    case 1:

      cdev_del(&enc->cdev);

  }

  enc->status = 0;

}

static void enc_exit_module(void)

{

  int i;

  for (i = 0; i < N_ENCODERS; i++)

  {

    enc_free(&encs[i]);

  }

  if (enc_class) {

    class_destroy(enc_class);

    enc_class = NULL;

  }

  unregister_chrdev_region(first_dev, N_ENCODERS);

}

module_exit(enc_exit_module);

static int __init enc_init_module(void)

{

  int i, err;

  // allocate character devices and get major number

  err = alloc_chrdev_region(&first_dev, 0, N_ENCODERS, "encoder");

  if (err)

  {

    printk(KERN_ALERT "Error %d in alloc_chrdev_region\n", err);

    return 1;

  }

  // register our device class for files in /dev

  enc_class = class_create(THIS_MODULE, "encoder");

  if (IS_ERR(enc_class))

  {

    err = PTR_ERR(enc_class);

    enc_class = NULL;

    printk(KERN_WARNING "Error %d creating device class\n", err);

  }

  else

  {

    // initialize enc structures

    for (i = 0; i < N_ENCODERS; i++) {

      err = enc_init(first_dev + i, &encs[i]);

      if (err)

      {

        printk(KERN_WARNING "Error %d adding enc%d\n", err, i);

        enc_exit_module();

        return 1;

      }

    }

  }

  return 0;

}

module_init(enc_init_module);