字符设备驱动

/* 文件名：kpad.c */
/* 说明：kpad 字符设备驱动例程 */

#include <linux/module.h> /* 模块编程 */
#include <linux/fs.h> /* 设备号、文件操作接口 */
#include <linux/cdev.h> /* 字符设备编程接口 */
#include <linux/uaccess.h> /* 访问用户态内存接口 */

MODULE_LICENSE("GPL"); /* 版权声明 */

#define BUF_SIZE 256 /* 内核缓冲区的大小 */

/* 以下类型表示 kpad 设备 */
struct kpad_dev {
    struct cdev cdev; /* 内嵌一个字符设备作为代表向内核注册 */
    char *buf; /* 保存内核缓冲区的首地址 */
    int len; /* 保存内核缓冲区的长度 */
    dev_t dev; /* 保存对应的设备号 */
};

/* 打开操作 */
static int kpad_open(struct inode *inode, struct file *file)
{
    /* 由 inode 对应的字符设备指针得到 kpad 设备的地址 */
    struct kpad_dev *dev = container_of(inode->i_cdev, struct kpad_dev, cdev);
    pr_debug("kpad_open: be called!\n");
    /* 将 kpad 设备的地址保存在打开的文件中 */
    file->private_data = dev;
    /* 返回 0 表示打开成功 */
    return 0;
}

/* 关闭操作 */
static int kpad_release(struct inode *inode, struct file *file)
{
    pr_debug("kpad_release: be called!\n");
    /* 无操作，返回 0 表示成功 */
    return 0;
}

/* 读操作 */
static ssize_t kpad_read(struct file *file, char __user *buf,
        size_t count, loff_t *pos)
{
    /* 从 file 中得到对应的 kpad 设备 */
    struct kpad_dev *dev = (struct kpad_dev *)file->private_data;
    pr_debug("kpad_read: pos = %d, count = %d.\n", (int)*pos, count);
    /* 参数合法性检查 */
    if (count < 0) return -EINVAL; /* 非法参数 */
    if (count == 0) return 0; /* 直接返回 0 */
    /* 控制读取的长度，不能超过当前读写位置到内核缓冲区末尾的长度 */
    if (*pos+count > dev->len) count = dev->len-*pos;
    if (count == 0) return 0; /* 无数据可读，返回 0 */
    /* 从内核缓冲区复制数据到 buf 指向的用户态内存 */
    if (copy_to_user(buf, dev->buf+*pos, count) > 0) {
        pr_debug("kpad_read: copy_to_user() FAILED!\n");
        return -EFAULT;
    }
    /* 修改文件的读写位置 */
    *pos += count;
    /* 返回读到的字节数 */
    return count;
}

/* 写操作 */
static ssize_t kpad_write(struct file *file, const char __user *buf,
        size_t count, loff_t *pos)
{
    /* 从 file 中得到对应的 kpad 设备 */
    struct kpad_dev *dev = (struct kpad_dev *)file->private_data;
    pr_debug("kpad_write: pos = %d, count = %d.\n", (int)*pos, count);
    /* 参数合法性检查 */
    if (count < 0) return -EINVAL; /* 非法参数 */
    if (count == 0) return 0; /* 直接返回 0 */
    /* 控制写入的长度，不能超过当前读写位置到内核缓冲区末尾的长度 */
    if (*pos+count > dev->len) count = dev->len-*pos;
    if (count == 0) return -ENOSPC; /* 无空间可写，返回错误：设备无空间 */
    /* 从 buf 指向的用户态内存复制数据到内核缓冲区 */
    if (copy_from_user(dev->buf+*pos, buf, count) > 0) {
        pr_debug("kpad_write: copy_from_user() FAILED!\n");
        return -EFAULT;
    }
    /* 修改文件的读写位置 */
    *pos += count;
    /* 返回写入的字节数 */
    return count;
}

/* 定位操作 */
static loff_t kpad_llseek(struct file *file, loff_t offset, int whence)
{
    /* 从 file 中得到对应的 kpad 设备 */
    struct kpad_dev *dev = (struct kpad_dev *)file->private_data;
    loff_t pos; /* 用于暂存新的读写位置 */
    pr_debug("kpad_llseek: f_pos = %d.\n", (int)file->f_pos);
    switch (whence) { /* 根据 whence 参数采用不同的操作 */
    case SEEK_SET: /* 相对于文件开始 */
        pos = offset;
        break;
    case SEEK_CUR: /* 相对于当前位置 */
        pos = file->f_pos+offset;
        break;
    case SEEK_END: /* 相对于文件结尾 */
        pos = dev->len+offset;
        break;
    default:
        return -EINVAL;
    }
    /* 新的读写位置应在合理范围之内 */
    if (pos < 0 || pos > dev->len) return -EINVAL;
    file->f_pos = pos; /* 修改文件的读写位置 */
    return pos; /* 返回新的读写位置 */
}

/* 设备的文件操作，全局变量 */
static struct file_operations kpad_fops = {
    .owner = THIS_MODULE, /* 所属模块 */
    .open = kpad_open, /* 打开操作 */
    .release = kpad_release, /* 关闭操作 */
    .read = kpad_read, /* 读操作 */
    .write = kpad_write, /* 写操作 */
    .llseek = kpad_llseek, /* 定位操作 */
};

/* 全局变量，表示一个 kpad 设备 */
static struct kpad_dev kpad;

/* 模块的初始化函数 */
static __init int kpad_init(void)
{
    int err; /* 用于保存错误码 */
    pr_debug("kpad_init: be called!\n");
    /* 分配设备号 */
    if ((err = alloc_chrdev_region(&kpad.dev, 0, 1, "kpad")) < 0) {
        pr_debug("kpad_init: alloc_chrdev_region() ERR = %d!\n", -err);
        goto alloc_chrdev_region_fail;
    }
    pr_debug("kpad_init: dev = (%d, %d).\n", MAJOR(kpad.dev), MINOR(kpad.dev));
    /* 分配内核缓冲区 */
    if ((kpad.buf = kmalloc(BUF_SIZE, GFP_KERNEL)) == NULL) {
        pr_debug("kpad_init: kmalloc() ERR!\n");
        err = -ENOMEM; /* 此错误号表示内存不足 */
        goto kmalloc_kpad_buf_fail;
    }
    /* 保存缓冲区的长度 */
    kpad.len = BUF_SIZE;
    /* 初始化字符设备 */
    cdev_init(&kpad.cdev, &kpad_fops);
    kpad.cdev.owner = kpad_fops.owner;
    /* 注册字符设备 */
    if ((err = cdev_add(&kpad.cdev, kpad.dev, 1)) < 0) {
        pr_debug("kpad_init: cdev_add() ERR = %d!\n", -err);
        goto cdev_add_fail;
    }
    return 0; /* 返回 0 表示初始化成功 */
/* 以下为出错处理，各个清理操作按初始化时的倒序排列，出错时跳转到相应的位置，
 * 这是驱动编程中常用的做法 */
cdev_add_fail:
    kfree(kpad.buf); /* 释放所分配的内存 */
kmalloc_kpad_buf_fail:
    unregister_chrdev_region(kpad.dev, 1); /* 注销所注册的设备号 */
alloc_chrdev_region_fail:
    return err;
}
module_init(kpad_init); /* 指定 kpad_init 为模块的初始化函数 */

/* 模块的退出函数 */
static __exit void kpad_exit(void)
{
    pr_debug("kpad_exit: be called!\n");
    /* 模块退出时进行清理，按初始化时的倒序操作 */
    cdev_del(&kpad.cdev); /* 注销字符设备 */
    kfree(kpad.buf); /* 释放所分配的内存 */
    unregister_chrdev_region(kpad.dev, 1); /* 注销所注册的设备号 */
}
module_exit(kpad_exit); /* 指定 kpad_exit 为模块的退出函数 */

# 文件名：Makefile
# 说明：kpad 例程 Makefile

# 模块名
MOD_NAME := kpad

# 模块源码（不能出现与模块名相同的文件名）
SRCS := \

EXTRA_CFLAGS = -DDEBUG

OBJS := $(SRCS:.c=.o)

ifeq ($(KERNELRELEASE),)

  KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  PWD := $(shell pwd)

default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

clean:
    -rm -f $(MOD_NAME).ko
    -rm -f $(MOD_NAME).o
    -rm -f $(OBJS)
    -rm -rf .tmp_versions
    -rm -f .*.cmd
    -rm -f *.mod.c
    -rm -f *.mod.o
    -rm -f Module.symvers
    -rm -f modules.order

else

  $(MOD_NAME)-objs := $(OBJS)
  obj-m := $(MOD_NAME).o

endif