【0004】字符设备驱动之globalmem_v0.1

/************************************
*filename    :_001_globalmem.c
*func        :a character program
*bookpages:code_list 6.17 (page:164)
*versions    :v0.1
************************************/
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define MEMSIZE 100
#define GLOBALMEM_MAJOR 230
#define MEM_CLEAR 0x1

int  globalmem_major = GLOBALMEM_MAJOR;
struct globalmem_cdev{
    struct cdev;
    char mem[MEMSIZE];

};

struct globalmem_cdev globalmem;


static int globalmem_open (struct inode *inode, struct file *filep)
{    
    filep->private_data = globalmem;
    return 0;

}

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

static long globalmem_unlocked_ioctl (struct file * filep, unsigned int cmd, unsigned long arg)
{
    struct globalmem_cdev *dev = filep->private_data;

    switch(cmd){
    case MEM_CLEAR:
        memset(dev->mem, 0 , MEMSIZE );
        printk(KERN_INFO "globalmem is set to zero\n");
        break;
    default:
        return -EINVAL;


    }

    return 0;
}

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

     if (p >= MEMSIZE)
         return 0;

     if (count > MEMSIZE - p)
         count = MEMSIZE -p;

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

        printk(KERN_INFO " read %u bytes(s) form %lu\n    ", count ,p);
     }
     
    return ret;
}
static ssize_t globalmem_write (struct file *filep, const char __user  buf *, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct globalmem_cdev  *dev = filep->private_data;

    if ( p >= MEMSIZE)
        return 0;

    if (count > MEMSIZE - p)
        count = MEMSIZE -p;

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

        printk(KERN_INFO "written %u bytes(s) from %lu \n", count ,p);
    }
    
    return ret;
}

static loff_t globalmem_llseek (struct file *filep, loff_t offset, int orig)
{
    loff_t ret =0;
    switch(orig){
    case 0:
        if (offset < 0){
            ret = -EINVAL;
            break;
        }

        if ((unsigned int ) offset > MEMSIZE){
            ret = -EINVAL;
            break;
        }

        filep->f_ops = (unsigned int )offset;
        ret = filep->f_ops;
        break;
    case 1:
        if ((filep->f_ops + offset) > MEMSIZE){
            ret = -EINVAL;
            break;
        }

        if ((filep->f_pos + offset) < 0){
            ret = -EINVAL;
            break;
        }

        filep->f_ops += offset;
        ret = filep->f_ops;
        break;

    default:
            ret = -EINVAL;
            break;
    }
    
    return ret;
}

static int globalmem_mmap (struct file *, struct vm_area_struct *)
{
    return 0;
}

static void globalmem_setup_cdev(struct globalmem_cdev *dev,int index)
{
    int err,devno = MKDEV(globalmem_major,index);
    cdev_init(dev->cdev,&globalmem_ops);
    dev->cdev.owner    = THIS_MODULE;
    err = cdev_add(&dev,devno,1);
    if (err)
        printk(KERN_NOTICE "ERR %d adding globalmem %d",err,index);
}





static struct file_operations globalmem_ops = {
    .owner    = THIS_MODULE,
    .read    = globalmem_read,
    .write    = globalmem_write,
    .llseek    = globalmem_llseek,
    .unlocked_ioctl    =globalmem_unlocked_ioctl,
    .open    = globalmem_open,
    .release    = globalmem_release,
};







static int __init globalmem_init(void)
{
    int ret;
    dev_t devno = MKDEV(globalmem_major,0);
    if (globalmem_major){
        ret = register_chrdev_region(devno,1,"globalmem");
    }else{
        ret = alloc_chrdev_region(&devno,0,1,"globalmem");
        globalmem_major = MAJOR(devno);
    }

    if (ret < 0)
        return ret;

    globalmem = kzalloc(sizeof(struct globalmem_cdev),GFP_KERNEL);
    if (!globalmem){
        ret = -ENOMEM;
        goto fail_alloc;
    }

    globalmem_setup_cdev(globalmem,0);
    return 0;
    
fail_alloc:
    unregister_chrdev_region(devno,1);
    return ret;
}

static void __exit globalmem_exit(void)
{
    cdev_del(&globalmem->cdev);
    kfree(globalmem);
    unregister_chrdev_region(MKDEV(globalmem_major,0),1)

}

module_init(globalmem_init);
module_exit(globalmem_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("OzTaking");
MODULE_DESCRIPTION("a character program");