driver now kinda works

Makefile

@@ -1,5 +1,5 @@
 obj-m = lcd.o
-lcd-y = src/lcd.o src/io.o src/checks.o
+lcd-y = src/lcd.o src/io.o src/checks.o src/interface.o src/proc.o
 
 KVERSION = $(shell uname -r)
 

src/checks.c

@@ -1,6 +1,7 @@
 #include "checks.h"
 
 #include <linux/module.h>
+#include <linux/gpio.h>
 #include "lcd.h"
 
 
@@ -16,12 +17,14 @@ int lcd_is_valid_gpio(int pin)
 
 int lcd_assign_gpio(int pin)
 {
-    if(lcd_is_valid_gpio(pin))
+    if(!lcd_is_valid_gpio(pin)) 
-        return pin;
+    {
+        printk(KERN_WARNING "%s: GPIO pin %d is invalid. Using %d instead\n", THIS_MODULE->name, pin, sub_pin);
+        pin = sub_pin++;
+    }
 
-
+    // gpio_request(pin, "no label");
-    printk(KERN_WARNING "%s: GPIO pin %d is invalid. Using %d instead\n", THIS_MODULE->name, pin, sub_pin);
+    return pin;
-    return sub_pin++;
 }
 
 int lcd_check_duplicates(const int* used_pins)

src/interface.c

@@ -0,0 +1,76 @@
+#include "interface.h"
+#include "lcd.h"
+
+#include <linux/gpio.h>
+#include <linux/delay.h>
+
+static void lcd_send_helper(const struct lcd_gpio_config* config, uint8_t data);
+
+void lcd_power_on(const struct lcd_gpio_config* config)
+{
+    gpio_set_value(config->power, 1);
+    gpio_set_value(config->rs, 0);
+    gpio_set_value(config->rw, 0);
+    gpio_set_value(config->enable, 0);
+
+    gpio_set_value(config->power, 0);
+
+    // 50ms power cycle
+    mdelay(50);
+    lcd_screen_init(config);
+}
+
+void lcd_power_off(const struct lcd_gpio_config* config)
+{
+    gpio_set_value(config->power, 1);
+}
+
+void lcd_send_command(const struct lcd_gpio_config* config, uint8_t command)
+{
+    gpio_set_value(config->rw, 0);
+    gpio_set_value(config->rs, 0);
+
+    lcd_send_helper(config, command);
+}
+
+void lcd_send_data(const struct lcd_gpio_config* config, uint8_t data)
+{
+    gpio_set_value(config->rw, 0);
+    gpio_set_value(config->rs, 1);
+
+    lcd_send_helper(config, data);
+}
+
+static void lcd_send_helper(const struct lcd_gpio_config* config, uint8_t data)
+{
+    gpio_set_value(config->enable, 1);
+
+    gpio_set_value(config->data[3], (data >> 7) & 0x1);
+    gpio_set_value(config->data[2], (data >> 6) & 0x1);
+    gpio_set_value(config->data[1], (data >> 5) & 0x1);
+    gpio_set_value(config->data[0], (data >> 4) & 0x1);
+
+    udelay(1000);
+    gpio_set_value(config->enable, 0);
+
+    mdelay(10);
+    gpio_set_value(config->enable, 1);
+
+    gpio_set_value(config->data[3], (data >> 3) & 0x1);
+    gpio_set_value(config->data[2], (data >> 2) & 0x1);
+    gpio_set_value(config->data[1], (data >> 1) & 0x1);
+    gpio_set_value(config->data[0], (data >> 0) & 0x1);
+
+    udelay(1000);
+    gpio_set_value(config->enable, 0);
+    mdelay(10);
+}
+
+void lcd_screen_init(const struct lcd_gpio_config* config)
+{
+    lcd_send_command(config, (LCD_FUNC_SET | LCD_FOUR_BIT) >> 4);
+    lcd_send_command(config, LCD_FUNC_SET | LCD_TWO_ROWS | LCD_FONT_5_7);
+    lcd_send_command(config, LCD_DISPLAY_SWITCH | LCD_DISPLAY_ON | LCD_CURSOR_ON | LCD_CURSOR_BLINK);
+    lcd_send_command(config, LCD_SCREEN_CLEAR);
+    lcd_send_command(config, LCD_INPUT_SET | LCD_LEFT_TO_RIGHT);
+}

src/interface.h

@@ -0,0 +1,42 @@
+#ifndef _LCD_INTERFACE_H
+#define _LCD_INTERFACE_H
+
+#include <linux/types.h>
+
+#define LCD_SCREEN_CLEAR    0x01
+#define LCD_CURSOR_RETURN   0x02
+#define LCD_INPUT_SET       0x04
+#define LCD_DISPLAY_SWITCH  0x08
+#define LCD_SHIFT_MODE      0x10
+#define LCD_FUNC_SET        0x20
+
+#define LCD_FOUR_BIT        0x00
+#define LCD_EIGHT_BIT       0x10
+#define LCD_ONE_ROW         0x00
+#define LCD_TWO_ROWS        0x08
+#define LCD_FONT_5_7        0x00
+#define LCD_FONT_5_10       0x04
+
+#define LCD_DISPLAY_OFF     0x00
+#define LCD_DISPLAY_ON      0x04
+#define LCD_CURSOR_OFF      0x00
+#define LCD_CURSOR_ON       0x02
+#define LCD_CURSOR_STATIC   0x00
+#define LCD_CURSOR_BLINK    0x01
+
+#define LCD_RIGHT_TO_LEFT   0x00
+#define LCD_LEFT_TO_RIGHT   0x02
+#define LCD_NO_SHIFT        0x00
+#define LCD_SHIFT           0x01
+
+struct lcd_gpio_config;
+
+void lcd_power_on(const struct lcd_gpio_config* config);
+void lcd_power_off(const struct lcd_gpio_config* config);
+
+void lcd_send_command(const struct lcd_gpio_config* config, uint8_t command);
+void lcd_send_data(const struct lcd_gpio_config* config, uint8_t data);
+
+void lcd_screen_init(const struct lcd_gpio_config* config);
+
+#endif

src/io.c

@@ -4,8 +4,7 @@
 #include <linux/fs.h>
 #include <linux/gpio.h>
 #include "lcd.h"
-
+#include "interface.h"
-static bool advance_ptr(const char* base, ssize_t size, char** ptr);
 
 loff_t lcd_llseek(struct file* filp, loff_t where, int whence)
 {
@@ -20,58 +19,26 @@ ssize_t lcd_read(struct file* filp, char __user* buf, size_t count, loff_t* off)
 ssize_t lcd_write(struct file* filp, const char __user* buf, size_t count, loff_t* off)
 {
     struct lcd_dev* dev = (struct lcd_dev*)filp->private_data;
-    char* kern_buf = NULL;
+    struct lcd_gpio_config* cfg = &dev->config;
-    char* cmd_start = NULL;
+    char* data = (char*)kmalloc(count, GFP_KERNEL);
-    char* cmd_end = NULL;
+    char* ptr;
-    ssize_t retval = 0;
-    struct lcd_gpio_config* config;
 
-    if(down_interruptible(&dev->sem))
+    printk(KERN_DEBUG "%s: test %d\n", THIS_MODULE->name, count);
-        return retval;
+    
-
+    if(copy_from_user((void*)data, (const void*)buf, count) != 0)
-    kern_buf = (char*)kmalloc(count, GFP_KERNEL);
-    if(kern_buf == NULL)
     {
-        printk(KERN_ERR "%s: Failed to allocate buffer (%d bytes), aborting write.\n", THIS_MODULE->name, count);
+        printk(KERN_WARNING "%s: Failed to copy some bytes from user.\n", THIS_MODULE->name);
-        retval = -ENOMEM;
         goto out;
     }
 
-    if(copy_from_user(kern_buf, buf, count))
+    for(ptr = data; *ptr != '\0' && *ptr != '\n'; ptr++)
     {
-        printk(KERN_ERR "%s: Failed to copy data from user, aborting write.\n", THIS_MODULE->name);
+        lcd_send_data(cfg, (uint8_t)*ptr);
-        retval = -EFAULT;
-        kfree(kern_buf);
-        goto out;
     }
 
-    cmd_start = kern_buf;
-    cmd_end = kern_buf;
-
-    config = &dev->config;
-
-    while(advance_ptr(kern_buf, count, &cmd_end))
-    {
-        *cmd_end = '\0';
-
-        if(strcmp(cmd_start, "0") == 0)
-            gpio_set_value(config->power, 0);
-        else if(strcmp(cmd_start, "1") == 0) {
-            printk(KERN_DEBUG "%s: Setting output of gpio %d to 1", THIS_MODULE->name, config->power);
-            gpio_set_value(config->power, 1);
-        }
-        else
-            printk(KERN_WARNING "%s: Unrecognized command \"%s\"\n", THIS_MODULE->name, cmd_start);
-
-        cmd_start = cmd_end + 1;
-    }
-
-    retval = count;
-    kfree(kern_buf);
-
 out:
-    up(&dev->sem);
+    kfree(data);
-    return retval;
+    return count;
 }
 
 long lcd_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
@@ -83,8 +50,14 @@ int lcd_open(struct inode* inode, struct file* filp)
 {
     struct lcd_dev* dev;
     dev = container_of(inode->i_cdev, struct lcd_dev, dev);
+
+    if(down_trylock(&dev->sem))
+        return -EACCES;
+
     filp->private_data = (void*)dev;
 
+    lcd_power_on(&dev->config);
+
     printk(KERN_DEBUG "%s: Opened device\n", THIS_MODULE->name);
     return 0;
 }
@@ -93,17 +66,13 @@ int lcd_release(struct inode* inode, struct file* filp)
 {
     struct lcd_dev* dev;
     dev = (struct lcd_dev*)filp->private_data;
-    
+
+    lcd_power_off(&dev->config);
+
+    up(&dev->sem);
+
     printk(KERN_DEBUG "%s: Released device\n", THIS_MODULE->name);
     return 0;
 }
 
-static bool advance_ptr(const char* base, ssize_t size, char** ptr)
-{
-    while(*ptr - base < size && **ptr != '\n')
-        (*ptr)++;
-
-    return *ptr - base < size;
-}
-
 #endif

src/lcd.c

@@ -3,6 +3,7 @@
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/gpio.h>
+#include <linux/proc_fs.h>
 
 #include "lcd.h"
 #include "checks.h" 
@@ -57,6 +58,19 @@ static struct file_operations lcd_fops =
     .release        = lcd_release
 };
 
+extern int      lcd_proc_open       (struct inode*, struct file*);
+extern ssize_t  lcd_proc_read       (struct file*, char __user*, size_t, loff_t*);
+extern loff_t   lcd_proc_lseek      (struct file*, loff_t, int);
+extern int      lcd_proc_release    (struct inode*, struct file*);
+
+static struct proc_ops lcd_pops = 
+{
+    .proc_open      = lcd_proc_open,
+    .proc_read      = lcd_proc_read,
+    .proc_lseek     = lcd_proc_lseek,
+    .proc_release   = lcd_proc_release
+};
+
 static int __init lcd_init_module(void)
 {
     int result = 0;
@@ -91,12 +105,17 @@ static int __init lcd_init_module(void)
         return result;
     }
 
+    gpio_set_value(lcddev.config.power, 1);
+
+    lcddev.proc_dir = proc_create_data("lcd", 0, NULL, &lcd_pops, (void*)&lcddev);
+
     printk(KERN_INFO "%s: Module loaded!\n", THIS_MODULE->name);
     return result;
 }
 
 static void __exit lcd_exit_module(void)
 {
+    proc_remove(lcddev.proc_dir);
     lcd_exit_gpio();
     lcd_exit_cdev();
     unregister_chrdev_region(lcddev.devno, 1);
@@ -131,8 +150,9 @@ static int  __init lcd_init_gpio(void)
     if(result < 0)
         return result;
     
-    for(i = 0; i < 8; i++)
+    for(i = 0; i < 8; i++) {
         gpio_direction_output(lcddev.used_pins[i], 0);
+    }
 
     return result;
 }

src/lcd.h

@@ -4,15 +4,16 @@
 #include <linux/module.h>
 #include <linux/cdev.h>
 #include <linux/semaphore.h>
+#include <linux/proc_fs.h>
 
 #define LCD_MAJOR 0
 #define LCD_MINOR 0
 
 #define LCD_PIN_POWER           14
-#define LCD_PIN_REGISTER_SELECT 11
+#define LCD_PIN_REGISTER_SELECT 22
-#define LCD_PIN_READ_WRITE      9
+#define LCD_PIN_READ_WRITE      27
-#define LCD_PIN_ENABLE          10
+#define LCD_PIN_ENABLE          17
-#define LCD_PIN_DATA            { 26, 19, 13, 06 }
+#define LCD_PIN_DATA            { 26, 19, 13, 6 }
 
 struct lcd_gpio_config
 {
@@ -28,6 +29,7 @@ struct lcd_dev
     struct semaphore sem;
     struct lcd_gpio_config config;
     int* used_pins;
+    struct proc_dir_entry* proc_dir;
 };
 
 #endif

src/proc.c

@@ -0,0 +1,58 @@
+#include <linux/proc_fs.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+#include "lcd.h"
+
+int lcd_proc_open(struct inode* inode, struct file* filp)
+{
+    struct lcd_dev* dev = PDE_DATA(inode);
+    filp->private_data = (void*)dev;
+
+    return 0;
+}
+
+ssize_t lcd_proc_read(struct file* filp, char __user* buf, size_t count, off_t* offset)
+{
+    struct lcd_dev* dev = (struct lcd_dev*)filp->private_data;
+
+    char* output;
+    size_t len = 0;
+
+    if(*offset > 0)
+        return 0;
+
+    if(count < 512)
+        return 0;
+
+    output = (char*)kmalloc(512, GFP_KERNEL);
+    if(output == NULL)
+        return 0;
+
+    len += sprintf(output + len, "Device maj %u min %u\n", MAJOR(dev->devno), MINOR(dev->devno));
+    len += sprintf(output + len, "=== PIN CONFIGURATION ===\n");
+
+    len += sprintf(output + len, "Power : %d\n", dev->config.power);
+    len += sprintf(output + len, "RS    : %d\n", dev->config.rs);
+    len += sprintf(output + len, "R/W   : %d\n", dev->config.rw);
+    len += sprintf(output + len, "Enable: %d\n", dev->config.enable);
+    len += sprintf(output + len, "D4-D7 : [%d, %d, %d, %d]\n", dev->config.data[0],  dev->config.data[1],  dev->config.data[2],  dev->config.data[3]);
+
+    if(copy_to_user(buf, output, len) != 0)
+    {
+        printk(KERN_WARNING "%s: Failed to copy some bytes to /proc\n", THIS_MODULE->name);
+    }
+
+    *offset += len;
+    return len;
+}
+
+extern loff_t lcd_proc_lseek (struct file* filp, loff_t offset, int whence)
+{
+    return 0;
+}
+
+int lcd_proc_release(struct inode* inode, struct file* filp)
+{
+    return 0;
+}