字符设备总结

简单字符设备
原创 于 2010-12-15 14:42:00 发布 · 372 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#struct #module #file #user #semaphore #cmd

下面是对简单字符设备的总结，以后可以作为模板使用。当然一下代码主要以ldd的例子抄下来的，呵呵。

1、单个设备

/************************************************************
*                                                            *
*                        GlobalMem.c                            *
*                            wjb                                *
************************************************************/

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#define MAX_SIZE 0x1000
#define MEM_CLEAR 0

struct globalmem_dev
{
    struct cdev cdev;
    unsigned char mem[MAX_SIZE];
};

struct globalmem_dev* globalmem_devp;

int globalmem_open(struct inode* inode, struct file *filp)
{
    filp->private_data = globalmem_devp;
    return 0;
}

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

static ssize_t globalmem_read(struct file * filp, char __user * buf, size_t size, loff_t* ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct globalmem_dev* dev = filp->private_data;

    if(p >= MAX_SIZE)
    {
        return count ? -ENXIO : 0;
    }

    if(p + count > MAX_SIZE)
    {
        count = MAX_SIZE - p;
    }

    if(copy_to_user(buf, (void *)(dev->mem + p), count))
    {
        return -EFAULT;
    }
    else
    {
        *ppos += count;
        ret = count;
    }

    return ret;
}

static ssize_t globalmem_write(struct file* filp, char __user *buf, size_t size, loff_t* ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;

    struct globalmem_dev* dev = filp->private_data;

    if(p >= MAX_SIZE)
    {
        return count ? -ENXIO : 0;
    }

    if(p + count > MAX_SIZE)
    {
        count = MAX_SIZE - p;
    }

    if(copy_from_user((void *)(dev->mem + p), buf, count)
    {
        return -EFAULT;
    }
    else
    {
        *ppos += count;
        ret = count;
    }

    return ret;
}

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

    switch(cmd)
    {
    case MEM_CLEAR:
        memset(dev->mem, 0, MAX_SIZE);
        break;
    default:
        return -EINVAL;
        break;
    }

    return 0;
}

static loff_t llseek(struct file* filp, loff_t offset, int orig)
{
    loff_t ret = 0;
    switch(orig)
    {
    case 0:
        if(offset < 0)
        {
            return -EINVAL;
            break;
        }
        if(offset > MAX_SIZE)
        {
            return -EINVAL;
            break;
        }
        filp->f_pos = (unsigned int)offset;
        ret = filp->f_pos;
        break;
    case 1:
        if(offset + filp->f_pos < 0)
        {
            return -EINVAL;
        }
        if(offset + filp->f_pos > MAX_SIZE)
        {
            return -EINVAL;
        }
        filp->f_pos += (unsigned int)offset;
        ret = filp->f_pos;
        break;
    default:
        ret = -EINVAL;
        break;
    }

    return ret;
}

static const struct file_operations globalmem_fops =
{
    .owner = THIS_MODULE,
    .open = globalmem_open,
    .release = globalmem_release,
    .read = globalmem_read,
    .write = globalmem_write,
    .ioctl = globalmem_ioctl,
};

static void globalmem_setup_cdev(struct globalmem_dev* dev, int index)
{
    int err, devno = MKDEV(globalmem_major, index);

    cdev_init(&dev->cdev, &globalmem_fops);
    dev->cdev.owner = THIS_MODULE;
    dev->cdev.ops = globalmem_fops;
    err = cdev_add(&dev-cdev, devno, 1);

    if(err)
    {
        printk("Adding device error. Error : %d , index %d/n", err, index);
    }
}

int globalmem_init(void)
{
    int result;
    dev_t devno = MKDEV(globalmem_major, 0);

    if(globalmem_major)
    {
        result = register_chrdev_region(devno, 1, "globalmem");
    }
    else
    {
        result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
        globalmem_major = MAJOR(devno);
    }

    globalmem_devp = kmalloc(sizeof(globalmem_dev), GFP_KERNEL);
    if(!globalmem_devp)
    {
        result = -ENOMEM;
        goto fail_malloc;
    }
    memset(globalmem_devp, 0, sizeof(globalmem_dev));
    globalmem_setup_cdev(globalmem_devp, 0);

    return 0;

fail_malloc:
    unregister_chrdev_region(devno, 1);
    return result;
}

void globalmem_exit(void)
{
    cdev_del(&globalmem_devp->cdev);
    kfree(globalmem_devp->mem);
    unregister_chrdev_region(MKDEV(global_major, 0), 1);
}

MODULE_AUTHOR("wjb");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);

 

2、两个设备

 

/************************************************************
*                                                            *
*                        GlobalMem2.c                        *
*                            wjb                                *
************************************************************/

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/init.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#define MAX_SIZE 0x1000

static globalmem_major = 211;

struct globalmem_dev
{
    struct cdev cdev;
    unsigned char mem[MAX_SIZE];
    struct semaphore sem;
}

struct globalmem_dev* globalmem_devp;

int globalmem_open(struct inode* inode, struct file* filp)
{
    struct globalmem_dev* dev;
    dev = container_of(inode->i_cdev, struct globalmem_dev, cdev);
    filp->private_data = dev;

    return 0;
}

int globalmem_release(struct inode* inode, struct file* file)
{
    return 0;
}

int globalmem_read(struct file* filp, char __user* buf,  size_t size, loff_t *ppos)
{
    unsigned int count = size;
    unsigned long p = *ppos;
    globalmem_dev* dev = filp->private_data;
    int ret = 0;

    if(p >= MAX_SIZE)
    {
        return count ? -ENXIO : 0;
    }
    if(p + count > MAX_SIZE)
    {
        count = MAX_SIZE - p;
    }

    if(down_interruptible(&dev->sem))
    {
        return -ERESTARTSYS;
    }

    if(copy_to_user(buf, (void *)(dev->mem + p), count))
    {
        return -EINVAL;
    }
    else
    {
        *ppos += count;
        ret = count;
    }

    up(&dev->sem);

    return ret;
}

int globalmem_write(struct file* filp, char __user* buf, size_t size, loff_t *ppos)
{
    unsigned long count = size;
    unsigned int p = *ppos;
    globalmem_dev* dev = filp->private_data;

    if(p > MAX_SIZE)
    {
        return count ? -ENXIO : 0;
    }

    if(count > MAX_SIZE - p)
    {
        count = MAX_SIZE - p;
    }

    if(down_interruptable(&dev->sem))
    {
        return -ERESTARTSYS;
    }

    if(copy_from_user(dev->mem + p, buf, count))
    {
        return -EINVAL;
    }
    else
    {
        *ppos += count;
        ret = count;
    }

    up(&dev->sem);

    return ret;
}

int globalmem_llseek(struct file* filp, loff_t offset, int orig)
{
    globalmem_dev* dev = filp->private_data;
    int ret = 0;
    switch(orig)
    {
    case 0:
        if(offset > MAX_SIZE)
        {
            return -EINVAL;
        }
        if(offset < 0)
        {
            return -EINVAL;
        }
        filp->f_pos = offset;
        ret = filp->f_pos;
        break;
    case 1:
        if(offset + filp->f_pos > MAX_SIZE)
        {
            return -EINVAL;
        }
        if(offset + filp->f_pos < 0)
        {
            return -EINVAL;
        }
        filp->f_pos += offset;
        ret = filp->f_pos;
        break;
    default:
        break;
    }

    return ret;
}

int globalmem_ioctl(struct inode* inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct globalmem_dev* dev = filp->private_data;

    switch(cmd)
    {
    case 0:
        if(down_interruptible(&dev->sem))
        {
            return -ERESTARTSYS;
        }
        memset(dev->mem, 0, MAX_SIZE);
        up(&dev->sem);
        break;
    default:
        break;
    }

    return 0;
}

static struct file_operations globalmem_fops = {
    .owner = THIS_MODULE,
    .open = globalmem_open,
    .release = globalmem_release,
    .read = globalmem_read,
    .write = globalmem_write,
   
   
}

void globalmem_setup_dev(struct globalmem_dev* dev, int index)
{
    int err, devno = MKDEV(globalmem_major, index);

    cdev_init(&dev->cdev, &globalmem_fops);
    dev->cdev.owner = THIS_MODULE;
    dev->cdev.ops = &globalmem_fops;
    err = cdev_add(&dev->cdev, devno, 1);

    init_MUTEX(&dev->sem);

}
int globalmem_init(void)
{
    int devno = MKDEV(globalmem_major, 0);
    int result = 0;

    if(globalmem_major)
    {
        result = register_chrdev_region(devno, 2, "globalmem");
    }
    else
    {
        result = alloc_chrdev_region(&devno, 0, 2, "globalmem");
        globalmem_major = MAJOR(devno);
    }

    globalmem_devp = kmalloc(sizeof(struct globalmem_dev)*2, GPF_KERNEL);
    if(!globalmem_devp)
    {   
        result = -ENOMEM;
        goto fail_malloc;
    }

    globalmem_setup_dev(&globalmem_devp[0],0);
    globalmem_setup_dev(&globalmem_devp[1],1);

fail_malloc:
    unregister_chrdev_region(devno, 2);

    return 0;
}

void globalmem_exit(void)
{
    cdev_del(&(globalmem_devp[0].cdev));
    cdev_del(&(globalmem_devp[1].cdev));
    kfree(globalmem_devp);
    unregister_chrdev_region(MKDEV(globalmem_major, 0), 2);

    return;
}

module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值