C180_oyster_driver/ssegment.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/stat.h>

#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/workqueue.h>

#include <linux/delay.h>

#include <linux/io.h>
#include "gpioregs.h"

#define DEVICE_NAME "ssegment"
#define CLASS_NAME "ssegment_class"
#define DRIVER_NAME     "port80_seg7"
#define BUFFER_SIZE 4

static int major = 56; 
static int minor = 40; 
module_param(major, int, S_IRUGO);
module_param(minor, int, S_IRUGO);
MODULE_PARM_DESC(major, "Major device number");
MODULE_PARM_DESC(minor, "Minor device number");

static struct class *char_class = NULL;
static struct device *char_device = NULL;
// static struct cdev my_cdev;
static dev_t dev_num;

struct ssegment_dev
{
    unsigned char *buffer;
    size_t size;
    struct mutex lock;
    struct cdev cdev;
    struct delayed_work delay_work1;
};

static struct ssegment_dev *dev = NULL;


static int wait_ibf(void)
{
    int i = 0;
    while (inb(EC_CMD_PORT) & EC_IBF)
    {
        if (++i > TIMEOUT_LOOPS)
        {
            return -1;
        }
        udelay(1);
    }
    return 0;
}

static int wait_obf(void)
{
    int i = 0;
    while (!(inb(EC_CMD_PORT) & EC_OBF))
    {
        if (++i > TIMEOUT_LOOPS)
        {
            return -1;
        }
        udelay(1);
    }
    return 0;
}

#if 0
static int ec_read_ram(uint8_t offset, uint8_t *data)
{
    if (wait_ibf() < 0)
        return -1;
    outb(CMD_READ_RAM, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_obf() < 0)
        return -1;
    *data = inb(EC_DATA_PORT);

    return 0;
}

static int ec_write_ram(uint8_t offset, uint8_t data)
{
    if (wait_ibf() < 0)
        return -1;
    outb(CMD_WRITE_RAM, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(data, EC_DATA_PORT);

    return 0;
}
#endif

static int oem_ec_read_ram(uint8_t page, uint8_t offset, uint8_t *data)
{
    unsigned char WEC, REC;
    switch(page)
    {
        case 0:
        {
            WEC = 0x96;
            REC = 0x95;
            break;
        }
        
        case 1:
        {
            WEC = 0x98;
            REC = 0x97;
            break;
        }
        
        default:
        {
            WEC = 0x81;
            REC = 0x80;
            break;
        }
    }    
    if (wait_ibf() < 0)
        return -1;
    outb(REC, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_obf() < 0)
        return -1;
    *data = inb(EC_DATA_PORT);

    return 0;
}

static int oem_ec_write_ram(uint8_t page, uint8_t offset, uint8_t data)
{
    unsigned char WEC, REC;
    switch(page)
    {
        case 0:
        {
            WEC = 0x96;
            REC = 0x95;
            break;
        }
        
        case 1:
        {
            WEC = 0x98;
            REC = 0x97;
            break;
        }
        
        default:
        {
            WEC = 0x81;
            REC = 0x80;
            break;
        }
    }
    if (wait_ibf() < 0)
        return -1;
    outb(WEC, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(data, EC_DATA_PORT);

    return 0;
}

unsigned int readl_cust(unsigned int addr)
{
    unsigned int val;
    void __iomem *reg_base;
    reg_base = ioremap(addr, 4);
    val = readl(reg_base);
    iounmap(reg_base);
    return val;
}

int writel_cust(unsigned int addr, unsigned int val)
{
    void __iomem *reg_base;
    reg_base = ioremap(addr, 4);
    writel(val, reg_base);
    iounmap(reg_base);
    return 0;
}

static void delay_work_func(struct work_struct *work)
{
    int ret = 0;
    unsigned int val = 0;
    unsigned char display_value = 0;
    static unsigned int flag = 0;
    if(dev->size != 0)
    {
        if((dev->buffer[1] & 0x80))
        {
            // blink
            flag++;
            if(flag % 2 == 1)
            {
                // blink on
                if((dev->buffer[1] & 0x02))
                {
                    val = readl_cust(SSEGMENT_POINT);
                    val = val | 0x01;
                    ret = writel_cust(SSEGMENT_POINT, val);
                }
                else
                {
                    val = readl_cust(SSEGMENT_POINT);
                    val = val & 0xFFFFFFFE;
                    ret = writel_cust(SSEGMENT_POINT, val);
                }
                display_value = dev->buffer[0];                
                outb(display_value, PORT_80);
                oem_ec_write_ram(1, 0x06, 0);
            }
            else
            {
                // blink off
                display_value = 0;
                // off point
                val = readl_cust(SSEGMENT_POINT);
                val = val & 0xFFFFFFFE;
                ret = writel_cust(SSEGMENT_POINT, val);

                // off segment
                oem_ec_write_ram(1, 0x06, 1);
            }
            schedule_delayed_work(&dev->delay_work1, msecs_to_jiffies(500));
        }
        else
        {
            if((dev->buffer[1] & 0x02))
            {
                val = readl_cust(SSEGMENT_POINT);
                val = val | 0x01;
                ret = writel_cust(SSEGMENT_POINT, val);
            }
            else
            {
                val = readl_cust(SSEGMENT_POINT);
                val = val & 0xFFFFFFFE;
                ret = writel_cust(SSEGMENT_POINT, val);
            }
            flag = 0;
            display_value = dev->buffer[0];
            outb(display_value, PORT_80);
            oem_ec_write_ram(1, 0x06, 0);
        }

    }
    
    // printk(KERN_INFO "delay_work_func\n");
}

static int ssegment_open(struct inode *inode, struct file *filp)
{
    struct ssegment_dev *dev;

    // if (!request_region(PORT_80, 1, DRIVER_NAME))
    // {
    //     pr_err("Port 80 I/O region busy\n");
    //     return -EBUSY;
    // }

    dev = container_of(inode->i_cdev, struct ssegment_dev, cdev);
    filp->private_data = dev;

    printk(KERN_INFO "ssegment: Device opened (major=%d, minor=%d)\n",
           imajor(inode), iminor(inode));
    return 0;
}

static int ssegment_release(struct inode *inode, struct file *filp)
{
    // release_region(PORT_80, 1);
    printk(KERN_INFO "ssegment: Device closed\n");
    return 0;
}

static ssize_t ssegment_read(struct file *filp, char __user *buf,
                             size_t count, loff_t *f_pos)
{
    struct ssegment_dev *dev = filp->private_data;
    // ssize_t retval = 0;
    // size_t available;
    int read_count = 0;
    int ret = 0;

    if (mutex_lock_interruptible(&dev->lock))
        return -ERESTARTSYS;

    if (count > dev->size)
    {
        read_count = dev->size;
    }
    else
    {
        read_count = count;
    }
    ret = copy_to_user(buf, dev->buffer, read_count);
    if (ret != 0)
    {
        printk(KERN_INFO "ssegment: copy_to_user failed\n");
        goto out;
    }

    printk(KERN_INFO "ssegment: Read %zu bytes\n", count);

out:
    mutex_unlock(&dev->lock);
    return ret;
}

static ssize_t ssegment_write(struct file *filp, const char __user *buf,
                              size_t count, loff_t *f_pos)
{
    struct ssegment_dev *dev = filp->private_data;
    // ssize_t retval = 0;
    // size_t available;
    int ret = 0;

    if (mutex_lock_interruptible(&dev->lock))
    {
        return -ERESTARTSYS;
    }

    if (count > BUFFER_SIZE)
    {
        count = BUFFER_SIZE;
    }

    ret = copy_from_user(dev->buffer, buf, count);
    if (ret != 0)
    {
        printk(KERN_INFO "ssegment: copy_from_user failed\n");
        goto out;
    }

    printk("%02x %02x %02x %02x\n", dev->buffer[0], dev->buffer[1], dev->buffer[2], dev->buffer[3]);

    dev->size = count;

    printk(KERN_INFO "ssegment: Written %zu bytes\n", count);

out:
    mutex_unlock(&dev->lock);

    if (ret == 0)
    {
        schedule_delayed_work(&dev->delay_work1, msecs_to_jiffies(10));
    }
    return count;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = ssegment_open,
    .release = ssegment_release,
    .read = ssegment_read,
    .write = ssegment_write,
};

static char *my_devnode(struct device *dev, umode_t *mode) {
    if (mode) {
        *mode = 0666;
    }
    return NULL;
}

int ssegment_init(void)
{
    int result;

    printk(KERN_INFO "ssegment: Initializing driver with major=%d, minor=%d\n",
           major, minor);

    if (major <= 0)
    {
        printk(KERN_ALERT "ssegment: Invalid major number %d\n", major);
        return -EINVAL;
    }

    dev_num = MKDEV(major, minor);

    result = register_chrdev_region(dev_num, 1, DEVICE_NAME);
    if (result < 0)
    {
        printk(KERN_ALERT "ssegment: Failed to register major number %d\n", major);
        printk(KERN_ALERT "ssegment: Try using a different major number\n");
        return result;
    }

    printk(KERN_INFO "ssegment: Registered with major=%d, minor=%d\n",
           MAJOR(dev_num), MINOR(dev_num));

    dev = kmalloc(sizeof(struct ssegment_dev), GFP_KERNEL);
    if (!dev)
    {
        result = -ENOMEM;
        goto fail_malloc;
    }
    memset(dev, 0, sizeof(struct ssegment_dev));

    dev->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!dev->buffer)
    {
        result = -ENOMEM;
        goto fail_buffer;
    }

    dev->buffer[0] = inb(PORT_80);

    mutex_init(&dev->lock);

    INIT_DELAYED_WORK(&dev->delay_work1, delay_work_func);

    cdev_init(&dev->cdev, &fops);
    dev->cdev.owner = THIS_MODULE;

    result = cdev_add(&dev->cdev, dev_num, 1);
    if (result)
    {
        printk(KERN_ALERT "ssegment: Failed to add cdev\n");
        goto fail_cdev;
    }

    char_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(char_class))
    {
        result = PTR_ERR(char_class);
        printk(KERN_ALERT "ssegment: Failed to create class\n");
        goto fail_class;
    }

    char_class->devnode = my_devnode;

    char_device = device_create(char_class, NULL, dev_num, NULL, DEVICE_NAME);
    if (IS_ERR(char_device))
    {
        result = PTR_ERR(char_device);
        printk(KERN_ALERT "ssegment: Failed to create device\n");
        goto fail_device;
    }

    printk(KERN_INFO "ssegment: Driver initialized successfully\n");
    printk(KERN_INFO "ssegment: Device node: /dev/%s (major=%d, minor=%d)\n",
           DEVICE_NAME, major, minor);
    return 0;

fail_device:
    class_destroy(char_class);
fail_class:
    cdev_del(&dev->cdev);
fail_cdev:
    kfree(dev->buffer);
fail_buffer:
    kfree(dev);
fail_malloc:
    unregister_chrdev_region(dev_num, 1);
    return result;
}

void ssegment_exit(void)
{
    cancel_delayed_work_sync(&dev->delay_work1);
    device_destroy(char_class, dev_num);
    class_destroy(char_class);

    if (dev)
    {
        cdev_del(&dev->cdev);
        if (dev->buffer)
            kfree(dev->buffer);
        kfree(dev);
    }

    unregister_chrdev_region(dev_num, 1);
    printk(KERN_INFO "ssegment: Driver removed (major=%d, minor=%d)\n",
           major, minor);
}