memdriver

//==============memdriver.c===================================================
#ifndef __KERNEL__
    #define __KERNEL__
#endif
#ifndef MODULE
    #define MODULE
#endif

#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>    /* printk() */
#include <linux/init.h>    /* __init __exit */

#include <linux/types.h>    /* size_t */
#include <linux/fs.h>    /* file_operation */
#include <linux/errno.h>    /* Error number */
#include <linux/delay.h>    /* udelay */
#include <asm/uaccess.h>    /* copy_to_user, copy_from_user */
#include <asm/hardware.h>

#include "memdriver.h"

#define DRIVER_NAME    "myDriver"

#ifdef DEBUG
#define PRINTK(fmt, arg...)        printk(KERN_NOTICE fmt, ##arg)
#else
#define PRINTK(fmt, arg...)
#endif
/*
    KERN_EMERG        用于紧急事件,一般是系统崩溃前的提示信息
    KERN_ALERT        用于需要立即采取动作的场合
    KERN_CRIT        临界状态,通常设计验证的硬件或软件操作失败
    KERN_ERR        用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题
    KERN_WARNING    就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏
    KERN_NOTICE        有必要提示的正常情况.许多安全相关的情况用这个级别汇报
    KERN_INFO        提示性信息.有很多驱动程序在启动时用这个级别打印相关信息
    KERN_DEBUG        用于调试的信息
*/

static int myDriver_Major = 0;        /* Driver Major Number */

/* Vitual Driver Buffer */
static unsigned char myDriver_Buffer[1024*1024];

/* Driver Operation Functions */
static int myDriver_open(struct inode *inode, struct file *filp)
{
//    int Minor = MINOR(inode->i_rdev);
//    filp->private_data = 0;
    MOD_INC_USE_COUNT;
    PRINTK("myDriver open called!\n");
    return 0;
}

static int myDriver_release(struct inode *inode, struct file *filp)
{
//    int Minor = MINOR(inode->i_rdev);
    MOD_DEC_USE_COUNT;
    PRINTK("myDriver release called!\n");
    return 0;
}

static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
    size_t read_size = count;
    PRINTK("myDriver read called!\n");
    PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);
    if(*f_pos >= sizeof(myDriver_Buffer))
    {
        PRINTK("[myDriver read]Buffer Overlap\n");
        *f_pos = sizeof(myDriver_Buffer);
        return 0;
    }
    if((count + *f_pos) > sizeof(myDriver_Buffer))
    {
        PRINTK("count + f_pos > sizeof buffer\n");
        read_size = sizeof(myDriver_Buffer) - *f_pos;
    }
    copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size);
    *f_pos += read_size;
    return read_size;
}

static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
    size_t fill_size = count;
    PRINTK("myDriver write called!\n");
    PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);
    if(*f_pos >= sizeof(myDriver_Buffer))
    {
        PRINTK("[myDriver write]Buffer Overlap\n");
        *f_pos = sizeof(myDriver_Buffer);
        return 0;
    }
    if((count + *f_pos) > sizeof(myDriver_Buffer))
    {
        PRINTK("count + f_pos > sizeof buffer\n");
        fill_size = sizeof(myDriver_Buffer) - *f_pos;
    }
    copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size);
    *f_pos += fill_size;
    return fill_size;
}

static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    char mem_value=arg;

    PRINTK("myDriver ioctl called(%d)!\n", cmd);
    if(_IOC_TYPE(cmd) != TSTDRV_MAGIC)
    {
        return -ENOTTY;
    }

    if(_IOC_NR(cmd) >= TSTDRV_MAXNR)
    {
        return -ENOTTY;
    }
    switch(cmd)
    {
        case CLEAR_MEM:
            memset(myDriver_Buffer,mem_value,1024*1024);
            
            PRINTK("IOCTRL 0 called(0x%lx)!\n", arg);
            break;
        case MYDRV_IOCTL1:
            PRINTK("IOCTRL 1 called(0x%lx)!\n", arg);
            break;
        case MYDRV_IOCTL2:
            PRINTK("IOCTRL 2 called(0x%lx)!\n", arg);
            break;
        case MYDRV_IOCTL3:
            PRINTK("IOCTRL 3 called(0x%lx)!\n", arg);
            break;
    }
    return 0;
}

/* Driver Operation structure */
static struct file_operations myDriver_fops = {
    owner:        THIS_MODULE,
    write:        myDriver_write,
    read:        myDriver_read,
    ioctl:        myDriver_ioctl,
    open:        myDriver_open,
    release:    myDriver_release,
};

/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_myDriver_dir;
devfs_handle_t devfs_myDriver_raw;
#endif

static int __init myModule_init(void)
{
    /* Module init code */
    PRINTK("myModule_init\n");
    /* Driver register */
    myDriver_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);
    if(myDriver_Major < 0)
    {
        PRINTK("register char device fail!\n");
        return myDriver_Major;
    }
    PRINTK("register myDriver OK! Major = %d\n", myDriver_Major);
#ifdef CONFIG_DEVFS_FS
    devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);
    devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);
    PRINTK("add dev file to devfs OK!\n");
#endif
    return 0;
}

static void __exit myModule_exit(void)
{
    /* Module exit code */
    PRINTK("myModule_exit\n");
    /* Driver unregister */
    if(myDriver_Major > 0)
    {
        #ifdef CONFIG_DEVFS_FS
            devfs_unregister(devfs_myDriver_raw);
            devfs_unregister(devfs_myDriver_dir);
        #endif
            unregister_chrdev(myDriver_Major, DRIVER_NAME);
    }
    return;
}

MODULE_AUTHOR("dengwei");
MODULE_LICENSE("Dual BSD/GPL");
module_init(myModule_init);
module_exit(myModule_exit);
//================memdriver.h================================================
#ifndef __TST_DRIVER_H__
#define __TST_DRIVER_H__

#define TSTDRV_MAGIC                0xd0

#define CLEAR_MEM                    _IO(TSTDRV_MAGIC, 0)
#define MYDRV_IOCTL1                _IO(TSTDRV_MAGIC, 1)
#define MYDRV_IOCTL2                _IO(TSTDRV_MAGIC, 2)
#define MYDRV_IOCTL3                _IO(TSTDRV_MAGIC, 3)

#define TSTDRV_MAXNR                4

#endif    //#ifndef __TST_DRIVER_H__
//==================Makefile===================================================
OUTPUT = memdriver.o
OUTPUT_DIR = output

#s3c2410
KERNEL = /home/dengwei/driver_test/kernel_2.4.18
CROSSPREFIX = /usr/local/arm/2.95.3/bin/arm-linux-

#pc 2.4
#KERNEL = /usr/src/linux-2.4
#CROSSPREFIX =

CFLAGS = -Wall -I$(KERNEL)/include -c -DDEBUG
#CFLAGS += -DEXPORT_SYMTAB -DMODVERSIONS -include $(KERNEL)/include/linux/modversions.h

DEST = $(foreach fn, $(OUTPUT), $(OUTPUT_DIR)/$(fn))

all: $(OUTPUT_DIR)/install.sh

$(OUTPUT_DIR)/install.sh: $(OUTPUT_DIR) $(DEST)
    @rm $@ -f
    @echo -e " $(foreach fn, $(OUTPUT), "insmod $(fn)\\n")" >> $@
    @echo "Finished!"

$(OUTPUT_DIR):
    @mkdir $@
    @chmod 777 -R $@

$(OUTPUT_DIR)/%.o: %.c
    @echo -n "Compling $^..."
    @$(CROSSPREFIX)gcc $(CFLAGS) $^ -o $@
    @echo "OK"

clean:
    @find . \( -name '*.[oas]' -o -name install.sh \) -type f -print | xargs rm -f
    @echo "Cleaned!"

//==================test.c=====================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#include "memdriver.h"
#include <asm/hardware.h>    //_IO(MAGIC,num)

int main()
{
    int num;
    int mem;
    char name_in[20]={0};
    char name_out[20]={0};
   
     if ( (mem = open("/dev/myDriver/raw0", O_RDWR)) ==-1)
     {
        printf("file open error");
        exit(1);
     }   
    printf("the memDriver test\n");
    while(1)
    {   
        printf("please input your cmd\n 1:write 2:read 3:clear all\n");
        scanf("%d",&num);
        switch(num)
        {
            case 1:
                printf("please intput a string and it will be write into memdriver\n");
                scanf("%s",name_in);
                write(mem,name_in,strlen(name_in));
                break;
            case 2:
                printf("please input a num and the date will be read out\n");
                lseek(mem,0,SEEK_SET);    //rewind the file point
                scanf("%d",&num);
                read(mem,name_out,num);
                name_out[num]='\0';
                printf("name_out=%s\n",name_out);
                break;
            case 3:
                lseek(mem,0,SEEK_SET);    //rewind the file point
                memset(name_in,0,20);
                memset(name_out,0,20);
                ioctl(mem,CLEAR_MEM,0);
                printf("please wait\n");
                break;
            default:

                break;
        }
   
    }
}