/scout_gumstix/encoder/encoder.c - Diff - Colony Scout OS - Robotics Club

Revision f024710b

ID	f024710be92a87d10ad8c50d0784a7e1f3f4a5fe

Added by Thomas Mullins over 11 years ago

Added actual reads from hardware to encoder.ko

Not yet tested on Gumstix (especially since I don't think we have the
encoders yet).

     #include <linux/slab.h>
     #include <linux/device.h>
     #include <linux/semaphore.h>
     #include <linux/interrupt.h>
     #include <linux/gpio.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}};
     const int enc_pins[N_ENCODERS][2] = {{78, 79}, {80, 81}, {82, 83}, {84, 85}};
     struct class *enc_class = NULL;
     dev_t first_dev;
-...
       struct cdev cdev;
       struct semaphore sem;
       struct device *device;
       int irq[2];
       int status;
       enc_val_t value;
       atomic_t value;
       dev_t dev;
+    }
     encs[N_ENCODERS];
-...
+      {
         return -ERESTARTSYS;
+      }
       len = snprintf(enc->buf, BUF_LEN+1, "%ld\n", enc->value);
       len = snprintf(enc->buf, BUF_LEN+1, "%d\n", atomic_read(&enc->value));
       if (*offset > len)
+      {
         return 0;
-...
         size_t count, loff_t *offset)
+    {
       char *end;
       int new_value;
       struct enc_t *enc = file->private_data;
       if (down_interruptible(&enc->sem))
+      {
-...
+      }
       copy_from_user(enc->buf, udata, count);
       enc->buf[count] = '\0';
       enc->value = simple_strtol(enc->buf, &end, 10);
       new_value = simple_strtoi(enc->buf, &end, 10);
       atomic_set(&enc->value, new_value);
       *offset += count;
       up(&enc->sem);
       return count;
+    }
     static int enc_init(dev_t dev, struct enc_t *enc)
     irqreturn_t intA(int irq, void *enc, struct pt_regs *regs) {
       int this = gpio_get_value(enc->pins[0]);
       int other = gpio_get_value(enc->pins[1]);
       if (this == other) {
         atomic_inc(&enc->value);
       } else {
         atomic_dec(&enc->value);
+      }
       return IRQ_HANDLED;
+    }
     irqreturn_t intB(int irq, void *enc, struct pt_regs *regs) {
       int this = gpio_get_value(enc->pins[1]);
       int other = gpio_get_value(enc->pins[0]);
       if (this == other) {
         atomic_dec(&enc->value);
       } else {
         atomic_inc(&enc->value);
+      }
       return IRQ_HANDLED;
+    }
     static int enc_init(dev_t dev, struct enc_t *enc, int *pins)
+    {
       int err;
       int err, i;
       // initialize members
       cdev_init(&enc->cdev, &fops);
-...
+      }
       enc->status = 1;
       // register gpio and interrupts
       for (i = 0; i < 2; i++) {
         enc->pins[i] = pins[i];
         enc->irq[i] = gpio_to_irq(pins[i]);
         if (enc->irq[i] < 0) {
           printk("Error %d requesting irq number for gpio %d\n", enc->irq[i],
               enc->pins[i]);
           return 1;
+        }
         err = gpio_direction_input(enc->pins[i]);
         if (err < 0) {
           printk("Error %d setting gpio %d to input\n", err, enc->pins[i]);
           return 1;
+        }
         err = request_irq(enc->irq[i], i? intB : intA, SA_INTERRUPT, "encoder", enc);
         if (err < 0) {
           printk("Error %d requesting irq %d\n", err, enc->irq[i]);
           return 1;
+        }
         // TODO the error checking here does not properly clean up after itself
         // TODO perhaps we should use gpio_request? probably not necessary...
+      }
       enc->status = 2;
       return 0;
+    }
     int enc_create_dev(struct enc_t *enc) {
       // make file in /dev
       enc->device = device_create(enc_class, NULL, enc->dev, NULL, "enc%d",
           MINOR(enc->dev));
-...
         enc_free(enc);
         return err;
+      }
       enc->status = 2;
       enc->status = 3;
       return 0;
+    }
-...
+    {
       switch (enc->status)
+      {
         case 2:
         case 3:
           device_destroy(enc_class, enc->dev);
           enc->device = NULL;
         case 2:
           free_irq(enc->irq[0], enc);
           free_irq(enc->irq[1], enc);
         case 1:
           cdev_del(&enc->cdev);
+      }
-...
         return 1;
+      }
       // initialize enc structures
       for (i = 0; i < N_ENCODERS; i++) {
         err = enc_init(first_dev + i, &encs[i], enc_pins[i]);
         if (err)
+        {
           printk(KERN_WARNING "Error %d initializing encoder %d\n", err, i);
           enc_exit_module();
           return 1;
+        }
+      }
       // register our device class for files in /dev
       enc_class = class_create(THIS_MODULE, "encoder");
       if (IS_ERR(enc_class))
-...
+      }
       else
+      {
         // initialize enc structures
         // create each device
         for (i = 0; i < N_ENCODERS; i++) {
           err = enc_init(first_dev + i, &encs[i]);
           err = enc_create_dev(&encs[i]);
           if (err)
+          {
             printk(KERN_WARNING "Error %d adding enc%d\n", err, i);
             printk(KERN_WARNING "Error %d creating enc%d\n", err, i);
             enc_exit_module();
             return 1;
+          }

Also available in: Unified diff

Project

General

Profile

Colony » Colony Scout » Colony Scout OS

Revision f024710b