两个字符驱动实例second 及 globalfifo

最新推荐文章于 2020-04-06 00:12:55 发布

qq_22340085

最新推荐文章于 2020-04-06 00:12:55 发布

阅读量223

点赞数

分类专栏： linux-driver

本文链接：https://blog.csdn.net/qq_22340085/article/details/77185084

版权

linux-driver 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

second_dri.c

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/of_device.h>
#include <linux/delay.h>

#define SECOND_MAJOR  237
#define USE_MUTEX

static int second_major = SECOND_MAJOR;
module_param(second_major, int, S_IRUGO);

static struct class *second_class;
struct second_dev *second_devp;

struct second_dev {
    struct cdev cdev;
#ifndef  USE_MUTEX
    atomic_t counter;
#else
    int counter;
#endif
    unsigned long state;  // 1 start timer, 0 timer stop
    struct mutex mutex;
    struct timer_list s_timer;
    struct device   *dev;
    struct miscdevice miscdev;
    const struct attribute_group    **groups;
    struct work_struct mywork;
};

//static struct second_dev *second_devp_; 

static void second_timer_handler(unsigned long arg)
{
    struct second_dev *dev = (void *) arg;
    mod_timer(&dev->s_timer, jiffies + HZ);
#ifndef  USE_MUTEX
     atomic_inc(&dev->counter);
#else
    printk(KERN_INFO "%s mutex lock\n", __func__);
    mutex_lock(&dev->mutex);
    dev->counter++;
    mutex_unlock(&dev->mutex);
#endif
//    printk(KERN_INFO "current jiffies is %ld\n", jiffies);
}

static void second_timer_ctl(struct work_struct *ws)
{
    struct second_dev *dev =
        container_of(ws, struct second_dev, mywork);
    int ret = 0;

    printk(KERN_INFO "%s trigger_store test\n", __func__);
    msleep(500);
    return;
}

static int second_open(struct inode *inode, struct file *filp)
{
 /*   init_timer(&second_devp->s_timer);
    second_devp->s_timer.function   = &second_timer_handler;
    second_devp->s_timer.expires    = jiffies + HZ;
    add_timer(&second_devp->s_timer);
*/

//  struct second_dev *second_devp = container_of(filp->private_data, 
//       struct second_dev, miscdev);

 //   struct  second_dev *second_devp = container_of(inode->i_cdev, struct second_dev, cdev);


    mutex_lock(&second_devp->mutex);
    if(second_devp->state == 0)
    {
       setup_timer(&second_devp->s_timer, second_timer_handler, (unsigned long)second_devp);
       add_timer(&second_devp->s_timer);
       second_devp->state = 1;
    }
    mutex_unlock(&second_devp->mutex);

//    filp->private_data = second_devp;
    printk(KERN_INFO "%s-open 1\n", __func__);
    return 0;
}

static int second_release(struct inode *inode, struct file *filp)
{
    return 0;
}

static ssize_t second_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
    int counter;
//    struct second_dev *second_devp = filp->private_data;

//    struct second_dev *second_devp = container_of(filp->private_data, 
//        struct second_dev, miscdev);  
#ifndef  USE_MUTEX
    counter = atomic_read(&second_devp->counter);
#else
    printk(KERN_INFO "%s mutex lock\n", __func__);
    mutex_lock(&second_devp->mutex);
    counter = second_devp->counter;
    mutex_unlock(&second_devp->mutex);
#endif
    if(put_user(counter, (int *)buf))
        return -EFAULT;
    else
        return sizeof(unsigned int);
}

static ssize_t second_write(struct file *filp, const char __user *buf,
                size_t count, loff_t *ppos)
{
    return 0;
}

ssize_t trigger_store(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
{
    struct second_dev *sdev = dev_get_drvdata(dev);
    unsigned long state;
    ssize_t ret = 0;
    printk(KERN_INFO "%s: 0 -state \n", __func__);
    return 0;

#ifdef  USE_MUTEX
    mutex_lock(&sdev->mutex);

    ret = kstrtoul(buf, 10, &state);
    if (ret)
        goto unlock;
    printk(KERN_INFO "%s: 0 - mutex lock, state = %ld\n", __func__, state);

    schedule_work(&sdev->mywork);

    goto unlock;

    if (state == 1)
    {
        printk(KERN_INFO "%s: 1 - mutex lock, state = %ld\n", __func__, state);
        if (sdev->state == 0)
        {
            setup_timer(&second_devp->s_timer, second_timer_handler, (unsigned long)second_devp);
            add_timer(&sdev->s_timer);
            sdev->state = 1;
        }
    }
    else
    {
        printk(KERN_INFO "%s: 2 - mutex lock, state = %ld\n", __func__, state);
        if(sdev->state == 1)
        {
            del_timer(&sdev->s_timer);
            sdev->state = 0;
        }
    }
   printk(KERN_INFO "%s: 3 - mutex lock, state = %ld\n", __func__, state);
unlock:
    mutex_unlock(&dev->mutex);
#endif
    return ret;
}

ssize_t trigger_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    int cnt = -1;

    struct second_dev *sdev = dev_get_drvdata(dev);

//    int *counter =  dev_get_drvdata(dev);
    //printk(KERN_INFO "counter_addr=%p", counter);
#ifndef  USE_MUTEX
    cnt = atomic_read(&sdev->counter);
#else
    printk(KERN_INFO "%s mutex lock\n", __func__);
    mutex_lock(&sdev->mutex);
//    mutex_lock_interruptible(&second_devp->mutex);
    cnt = sdev->counter;
    mutex_unlock(&sdev->mutex);
#endif   

     return sprintf(buf, "second_trigger_show: count =%d\n", cnt);
//    return sprintf(buf, "second_trigger_show: count = %d, counter_addr=%p\n", *counter, counter);
}
//static DEVICE_ATTR_RW(trigger);
static DEVICE_ATTR(trigger, 0644, trigger_show, trigger_store);
static struct attribute *second_trigger_attrs[] = {
    &dev_attr_trigger.attr,
    NULL,
};
static const struct attribute_group second_trigger_group = {
    .attrs = second_trigger_attrs,
};

static const struct attribute_group *second_groups[] = {
    &second_trigger_group,
};

static const struct file_operations second_fops = {
    .owner  = THIS_MODULE,
    .open   = second_open,
    .release= second_release,
    .read   = second_read,
    .write  = second_write,
};

static int second_probe(struct platform_device *pdev)
{
    int ret, err;
    struct device *dev = &pdev->dev;
    dev_t devno = MKDEV(SECOND_MAJOR, 0);

    if(SECOND_MAJOR)    {
        ret = register_chrdev_region(devno, 1, "second");
    }    else {
         ret = alloc_chrdev_region(&devno, 0, 1, "second");
         second_major = MAJOR(devno);
    }
    if(ret < 0)
        return ret;

    second_devp = devm_kzalloc(dev, sizeof(*second_devp), GFP_KERNEL);
    if(!second_devp)
    {
        dev_info(&pdev->dev, "second_devp  devm_kzalloc failed\n");
        return -ENOMEM;
    }

#ifndef  USE_MUTEX
   atomic_set(&second_devp->counter, 0);
#else
    printk(KERN_INFO "%s mutex lock\n", __func__);
    mutex_init(&second_devp->mutex);
    mutex_lock(&second_devp->mutex);
    second_devp->counter = 0;
    second_devp->state = 0;
    mutex_unlock(&second_devp->mutex); 
#endif

    INIT_WORK(&second_devp->mywork, second_timer_ctl);

    cdev_init(&second_devp->cdev, &second_fops);
    second_devp->cdev.owner = THIS_MODULE;
    err = cdev_add(&second_devp->cdev, devno, 1);
    if(err)
    {
         printk(KERN_DEBUG "Error %d adding second\n", err);
         goto fail_malloc;
    }

    second_devp->dev = device_create(second_class,  dev,
                    MKDEV(SECOND_MAJOR, 0), second_devp, "second"); 

//    platform_set_drvdata(pdev, second_devp);

    dev_info(&pdev->dev, "second_dev drv proded\n");
    return 0;

fail_malloc:
    printk(KERN_INFO "6 - probe failed\n");
    unregister_chrdev_region( MKDEV(SECOND_MAJOR, 0), 1);
    return ret;        
}


static int second_remove(struct platform_device *pdev)
{
    return 0;
}

static struct platform_driver second_driver = {
    .driver = {
        .name  = "second_dev",
        .owner = THIS_MODULE, 
    },
    .probe  = second_probe,
    .remove = second_remove,
};

static int __init second_init(void)
{
    int ret;

    second_class = class_create(THIS_MODULE, "second");
    if (IS_ERR(second_class))
        return PTR_ERR(second_class);
    second_class->dev_groups = second_groups;

    ret = platform_driver_register(&second_driver);
    if (ret)
        printk(KERN_ERR "second: probe failed: %d\n", ret);

    return ret;
}
module_init(second_init);

static void __exit second_exit(void)
{
    if(second_devp)
    {
        cdev_del(&second_devp->cdev);
        del_timer(&second_devp->s_timer);   
    }

    device_destroy(second_class, MKDEV(SECOND_MAJOR, 0));
    class_destroy(second_class);
    unregister_chrdev_region(MKDEV(SECOND_MAJOR, 0), 1);

    platform_driver_unregister(&second_driver);
    printk(KERN_INFO "second: exit\n");
}
module_exit(second_exit);

//module_platform_driver(second_driver);

MODULE_AUTHOR("Bao hua");
MODULE_LICENSE("GPL v2");

second_dev.c

#include <linux/module.h>
#include <linux/of_device.h>

static struct platform_device *second_pdev;

static int __init seconddev_init(void)
{
    int ret;
    second_pdev = platform_device_alloc("second_dev", -1);
    if(!second_pdev)
        return -ENOMEM;

    ret = platform_device_add(second_pdev);
    if(ret) {
        platform_device_put(second_pdev);
        return ret;
    }

    return 0;
}

module_init(seconddev_init);

static void __exit seconddev_exit(void)
{
    platform_device_unregister(second_pdev);
}
module_exit(seconddev_exit);
MODULE_AUTHOR("Bao hua");
MODULE_LICENSE("GPL v2");

Makefile

KVERS = $(shell uname -r)

#Kernel modules
obj-m += second.o
obj-m += second_test.o
#obj-m += second_mutex.o
obj-m += second_dri.o
obj-m += second_dev.o

build: kernel_modules

kernel_modules:
    make -C /lib/modules/$(KVERS)/build M=$(CURDIR) modules

user_test:
    gcc test.c -o test

clean:
    make -c /lib/modules/$(KVERS)/build M=$(CURDIR) clean

驱动与设备分开，此驱动还有缺陷当通过echo 0 >/sys/class/second/second/trigger ，会一直进行这个重复操作，原因待查。

globalfifo.c

/*
 * a simple char device driver: globalfifo
 *
 * Copyright (C) 2014 Barry Song  (baohua@kernel.org)
 *
 * Licensed under GPLv2 or later.
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/of_device.h>

#define GLOBALFIFO_SIZE 0x1000
#define FIFO_CLEAR 0x1
#define GLOBALFIFO_MAJOR 235

static int globalfifo_major = GLOBALFIFO_MAJOR;
module_param(globalfifo_major, int, S_IRUGO);

static struct class *globalfifo_class;

struct globalfifo_dev {
    struct cdev cdev;
    unsigned int current_len;
    unsigned char mem[GLOBALFIFO_SIZE];
    struct mutex mutex;
    wait_queue_head_t r_wait;
    wait_queue_head_t w_wait;
    struct device *dev;
    struct fasync_struct *async_queue;
};

struct globalfifo_dev *globalfifo_devp;

static int globalfifo_fasync(int fd, struct file *filp, int mode)
{
    struct globalfifo_dev *dev = filp->private_data;
    return fasync_helper(fd, filp, mode, &dev->async_queue);
}

static int globalfifo_open(struct inode *inode, struct file *filp)
{
    filp->private_data = globalfifo_devp;
    return 0;
}

static int globalfifo_release(struct inode *inode, struct file *filp)
{
    globalfifo_fasync(-1, filp, 0);
    return 0;
}

static long globalfifo_ioctl(struct file *filp, unsigned int cmd,
                 unsigned long arg)
{
    struct globalfifo_dev *dev = filp->private_data;

    switch (cmd) {
    case FIFO_CLEAR:
        mutex_lock(&dev->mutex);
        dev->current_len = 0;
        memset(dev->mem, 0, GLOBALFIFO_SIZE);
        mutex_unlock(&dev->mutex);

        printk(KERN_INFO "globalfifo is set to zero\n");
        break;

    default:
        return -EINVAL;
    }
    return 0;
}

static unsigned int globalfifo_poll(struct file *filp, poll_table * wait)
{
    unsigned int mask = 0;
    struct globalfifo_dev *dev = filp->private_data;

    mutex_lock(&dev->mutex);

    poll_wait(filp, &dev->r_wait, wait);
    poll_wait(filp, &dev->w_wait, wait);

    if (dev->current_len != 0) {
        mask |= POLLIN | POLLRDNORM;
    }

    if (dev->current_len != GLOBALFIFO_SIZE) {
        mask |= POLLOUT | POLLWRNORM;
    }

    mutex_unlock(&dev->mutex);
    return mask;
}

static ssize_t globalfifo_read(struct file *filp, char __user *buf,
                   size_t count, loff_t *ppos)
{
    int ret;
    struct globalfifo_dev *dev = filp->private_data;
    DECLARE_WAITQUEUE(wait, current);

    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->r_wait, &wait);

    while (dev->current_len == 0) {
        if (filp->f_flags & O_NONBLOCK) {
            ret = -EAGAIN;
            goto out;
        }
        __set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&dev->mutex);

        schedule();
        if (signal_pending(current)) {
            ret = -ERESTARTSYS;
            goto out2;
        }

        mutex_lock(&dev->mutex);
    }

    if (count > dev->current_len)
        count = dev->current_len;

    if (copy_to_user(buf, dev->mem, count)) {
        ret = -EFAULT;
        goto out;
    } else {
        memcpy(dev->mem, dev->mem + count, dev->current_len - count);
        dev->current_len -= count;
        printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count,
               dev->current_len);

        wake_up_interruptible(&dev->w_wait);

        ret = count;
    }
 out:
    mutex_unlock(&dev->mutex);
 out2:
    remove_wait_queue(&dev->w_wait, &wait);
    set_current_state(TASK_RUNNING);
    return ret;
}

static ssize_t globalfifo_write(struct file *filp, const char __user *buf,
                size_t count, loff_t *ppos)
{
    struct globalfifo_dev *dev = filp->private_data;
    int ret;
    DECLARE_WAITQUEUE(wait, current);

    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->w_wait, &wait);

    while (dev->current_len == GLOBALFIFO_SIZE) {
        if (filp->f_flags & O_NONBLOCK) {
            ret = -EAGAIN;
            goto out;
        }
        __set_current_state(TASK_INTERRUPTIBLE);

        mutex_unlock(&dev->mutex);

        schedule();
        if (signal_pending(current)) {
            ret = -ERESTARTSYS;
            goto out2;
        }

        mutex_lock(&dev->mutex);
    }

    if (count > GLOBALFIFO_SIZE - dev->current_len)
        count = GLOBALFIFO_SIZE - dev->current_len;

    if (copy_from_user(dev->mem + dev->current_len, buf, count)) {
        ret = -EFAULT;
        goto out;
    } else {
        dev->current_len += count;
        printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count,
               dev->current_len);

        wake_up_interruptible(&dev->r_wait);

        if (dev->async_queue) {
            kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
            printk(KERN_DEBUG "%s kill SIGIO\n", __func__);
        }

        ret = count;
    }

 out:
    mutex_unlock(&dev->mutex);
 out2:
    remove_wait_queue(&dev->w_wait, &wait);
    set_current_state(TASK_RUNNING);
    return ret;
}

ssize_t globalfifo_trigger_store(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
{
    int cnt = -1;

    struct globalfifo_dev *gdev = dev_get_drvdata(dev);

    mutex_lock(&gdev->mutex);
//  count = gdev->current_len;
    printk(KERN_INFO "%s - buf=%s, len=%d\n", __func__, buf, count);
//  cnt = copy_from_user(gdev->mem + gdev->current_len, buf, count);
    count = snprintf(gdev->mem + gdev->current_len, GLOBALFIFO_SIZE, "%s", buf);
    gdev->current_len += count;
    mutex_unlock(&gdev->mutex);

    return count;
}

ssize_t globalfifo_trigger_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    int count;
    struct globalfifo_dev *gdev = dev_get_drvdata(dev);

    mutex_lock(&gdev->mutex);
    count = gdev->current_len;
    if(count == 0 )
    {
        count = sprintf(buf, "NO data put in. current_len=0\n");
    }
    else
    {       
         count = sprintf(buf, "current_len=%d, data=%s\n", count, gdev->mem);
         buf[count] = 0; 
    }

    mutex_unlock(&gdev->mutex);

     return count;
//    return sprintf(buf, "globalfifo_trigger_show: count = %d, counter_addr=%p\n", *counter, counter);
}

static DEVICE_ATTR(trigger, 0644, globalfifo_trigger_show, globalfifo_trigger_store);
static struct attribute *globalfifo_trigger_attrs[] = {
    &dev_attr_trigger.attr,
    NULL,
};
static const struct attribute_group globalfifo_trigger_group = {
    .attrs = globalfifo_trigger_attrs,
};

static const struct attribute_group *globalfifo_groups[] = {
    &globalfifo_trigger_group,
};


static const struct file_operations globalfifo_fops = {
    .owner = THIS_MODULE,
    .read = globalfifo_read,
    .write = globalfifo_write,
    .unlocked_ioctl = globalfifo_ioctl,
    .poll = globalfifo_poll,
    .fasync = globalfifo_fasync,
    .open = globalfifo_open,
    .release = globalfifo_release,
};


static int globalfifo_prove(struct platform_device *pdev)
{
//    struct globalfifo_dev *gl;
    int ret;
    dev_t devno = MKDEV(GLOBALFIFO_MAJOR, 0);

    printk(KERN_INFO "0 %s - probe failed\n", __func__);
  if(GLOBALFIFO_MAJOR)  {
        printk(KERN_INFO "00 %s - probe failed\n", __func__);
        ret = register_chrdev_region(devno, 1, "gblobalfifo");
        printk(KERN_INFO "000 %s - probe failed\n", __func__);
    }    else {
        printk(KERN_INFO "01 %s - probe failed\n", __func__);
         ret = alloc_chrdev_region(&devno, 0, 1, "gblobalfifo");
         globalfifo_major = MAJOR(devno);
    }
    if(ret < 0)
        return ret;

    printk(KERN_INFO "1 %s - probe failed\n", __func__);
    globalfifo_devp = devm_kzalloc(&pdev->dev, sizeof(*globalfifo_devp), GFP_KERNEL);
    if(!globalfifo_devp) {
        ret = -ENOMEM;
        goto fail_malloc;
    }

    printk(KERN_INFO "2 %s - probe failed\n", __func__);   
    cdev_init(&globalfifo_devp->cdev, &globalfifo_fops);
    globalfifo_devp->cdev.owner = THIS_MODULE;
    ret = cdev_add(&globalfifo_devp->cdev, devno, 1);

    if(ret < 0)
    {
         printk(KERN_INFO "Error %d adding globalfifo\n", ret);
         goto fail_malloc;
    }

    printk(KERN_INFO "5 %s - probe failed\n", __func__);
    mutex_init(&globalfifo_devp->mutex);
    init_waitqueue_head(&globalfifo_devp->r_wait);
    init_waitqueue_head(&globalfifo_devp->w_wait);

   globalfifo_devp->dev = device_create(globalfifo_class, &pdev->dev, 
     MKDEV(GLOBALFIFO_MAJOR, 0), globalfifo_devp, "globalfifo");    

    dev_info(&pdev->dev, "globalfifo drv proded\n");
    return 0;

fail_malloc:
    printk(KERN_INFO "6 - probe failed\n");
    unregister_chrdev_region(devno, 1);
    return ret;   
}

static int globalfifo_remove(struct platform_device *pdev)
{
    return 0;
}

static struct platform_driver globalfifo_driver = {
    .driver = {
        .name  = "globalfifo",
        .owner = THIS_MODULE, 
    },
    .probe  = globalfifo_prove,
    .remove = globalfifo_remove,
};

static int __init globalfifo_init(void)
{
    int ret;

    globalfifo_class = class_create(THIS_MODULE, "globalfifo");
    if (IS_ERR(globalfifo_class))
        return PTR_ERR(globalfifo_class);
    globalfifo_class->dev_groups = globalfifo_groups;

    ret = platform_driver_register(&globalfifo_driver);
    if (ret)
        printk(KERN_ERR "globalfifo: probe failed: %d\n", ret);

    return ret;
}
module_init(globalfifo_init);

static void __exit globalfifo_exit(void)
{
    if(globalfifo_devp)
       cdev_del(&globalfifo_devp->cdev);
    device_destroy(globalfifo_class, MKDEV(GLOBALFIFO_MAJOR, 0));
    unregister_chrdev_region(MKDEV(GLOBALFIFO_MAJOR, 0), 1);
    class_destroy(globalfifo_class);
    platform_driver_unregister(&globalfifo_driver);
    printk(KERN_INFO "globalfifo: exit\n");
}
module_exit(globalfifo_exit);

MODULE_AUTHOR("Barry Song <baohua@kernel.org>");
MODULE_LICENSE("GPL v2");

globalfifo-dev.c

#include <linux/module.h>
#include <linux/of_device.h>

static struct platform_device *globalfifo_pdev;

static int __init globalfifodev_init(void)
{
    int ret;
    globalfifo_pdev = platform_device_alloc("globalfifo", -1);
    if(!globalfifo_pdev)
        return -ENOMEM;

    ret = platform_device_add(globalfifo_pdev);
    if(ret) {
        platform_device_put(globalfifo_pdev);
        return ret;
    }

    return 0;
}
module_init(globalfifodev_init);

static void __exit globalfifodev_exit(void)
{
    platform_device_unregister(globalfifo_pdev);
}
module_exit(globalfifodev_exit);
MODULE_AUTHOR("Bao hua");
MODULE_LICENSE("GPL v2");