Linux驱动程序

已于 2024-05-23 14:33:02 修改
阅读量1.6k 收藏 26
点赞数 33
文章标签： linux 算法 运维
于 2024-05-21 20:46:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74126856/article/details/139101850
版权

驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "custom_char_dev"
#define BUFFER_SIZE 1024

static int major_num;
static char buffer[BUFFER_SIZE];
static int pRead = 0;
static int pWrite = 0;
static int bytes_in_buffer = 0;

static int dev_open(struct inode *, struct file *);
static int dev_release(struct inode *, struct file *);
static ssize_t dev_read(struct file *, char *, size_t, loff_t *);
static ssize_t dev_write(struct file *, const char *, size_t, loff_t *);

static struct file_operations fops = {
    .open = dev_open,
    .release = dev_release,
    .read = dev_read,
    .write = dev_write,
};

static int __init char_dev_init(void) {
    major_num = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_num < 0) {
        printk(KERN_ALERT "Failed to register a major number\n");
        return major_num;
    }
    printk(KERN_INFO "Registered correctly with major number %d\n", major_num);
    return 0;
}

static void __exit char_dev_exit(void) {
    unregister_chrdev(major_num, DEVICE_NAME);
    printk(KERN_INFO "Unregistered correctly\n");
}

static int dev_open(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset) {
    int bytes_to_read;
    if (bytes_in_buffer == 0) {
        printk(KERN_INFO "Buffer is empty\n");
        return 0; // Return 0 to indicate end of file (EOF)
    }
    bytes_to_read = min(len, bytes_in_buffer);
    if (copy_to_user(buffer, &buffer[pRead], bytes_to_read) != 0) {
        printk(KERN_ALERT "Failed to read from device\n");
        return -EFAULT;
    }
    pRead = (pRead + bytes_to_read) % BUFFER_SIZE;
    bytes_in_buffer -= bytes_to_read;
    printk(KERN_INFO "Read %d bytes from the device\n", bytes_to_read);
    return bytes_to_read;
}

static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    int space_available = BUFFER_SIZE - bytes_in_buffer;
    int bytes_to_write = min(len, space_available);
    if (bytes_to_write == 0) {
        printk(KERN_ALERT "Buffer is full, cannot write\n");
        return -ENOMEM;
    }
    if (copy_from_user(&buffer[pWrite], buffer, bytes_to_write) != 0) {
        printk(KERN_ALERT "Failed to write to device\n");
        return -EFAULT;
    }
    pWrite = (pWrite + bytes_to_write) % BUFFER_SIZE;
    bytes_in_buffer += bytes_to_write;
    printk(KERN_INFO "Wrote %d bytes to the device\n", bytes_to_write);
    return bytes_to_write;
}

static int dev_release(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "Device successfully closed\n");
    return 0;
}

module_init(char_dev_init);
module_exit(char_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple character device driver with fixed size buffer");
 

Makefile文件

obj-m += custom_char_dev.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
 

测试程序

读：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_FILE "/dev/custom_char_dev"

int main() {
    int fd;
    char buffer[256];

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 读取数据
    if (read(fd, buffer, sizeof(buffer)) < 0) {
        perror("Failed to read from the device");
        close(fd);
        return -1;
    }

    // 打印读取的数据
    printf("Data read from device: %s\n", buffer);

    // 关闭设备文件
    close(fd);

    return 0;
}
 

写：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define DEVICE_FILE "/dev/custom_char_dev"

int main() {
    int fd;
    char buffer[] = "Hello, device!";

    // 打开设备文件
    fd = open(DEVICE_FILE, O_WRONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 写入数据
    if (write(fd, buffer, strlen(buffer)) < 0) {
        perror("Failed to write to the device");
        close(fd);
        return -1;
    }

    printf("Data written to device: %s\n", buffer);

    // 关闭设备文件
    close(fd);

    return 0;
}

第二版驱动程序

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/wait.h>

#define FIFO_SIZE 32

static char fifo_buffer[FIFO_SIZE];
static int read_pointer = 0;
static int write_pointer = 0;
static int buffer_count = 0;

static DEFINE_MUTEX(fifo_mutex);
static DECLARE_WAIT_QUEUE_HEAD(read_queue);
static DECLARE_WAIT_QUEUE_HEAD(write_queue);

static int custom_open(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Custom character device opened\n");
    return 0;
}

static int custom_release(struct inode *inode, struct file *file)
{
    printk(KERN_INFO "Custom character device closed\n");
    return 0;
}

static ssize_t custom_read(struct file *file, char __user *user_buffer, size_t size, loff_t *offset)
{
    int bytes_read = 0;
    int bytes_to_read = size;

    mutex_lock(&fifo_mutex);

    while (buffer_count == 0) {
        mutex_unlock(&fifo_mutex);
        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;
        if (wait_event_interruptible(read_queue, buffer_count > 0))
            return -ERESTARTSYS;
        mutex_lock(&fifo_mutex);
    }

    while (bytes_read < size && buffer_count > 0) {
        put_user(fifo_buffer[read_pointer], &user_buffer[bytes_read]);
        read_pointer = (read_pointer + 1) % FIFO_SIZE;
        buffer_count--;
        bytes_read++;
    }

    mutex_unlock(&fifo_mutex);
    wake_up_interruptible(&write_queue);

    return bytes_read;
}

static ssize_t custom_write(struct file *file, const char __user *user_buffer, size_t size, loff_t *offset)
{
    int bytes_written = 0;
    int bytes_to_write = size;

    mutex_lock(&fifo_mutex);

    while (buffer_count == FIFO_SIZE) {
        mutex_unlock(&fifo_mutex);
        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;
        if (wait_event_interruptible(write_queue, buffer_count < FIFO_SIZE))
            return -ERESTARTSYS;
        mutex_lock(&fifo_mutex);
    }

    while (bytes_written < size && buffer_count < FIFO_SIZE) {
        get_user(fifo_buffer[write_pointer], &user_buffer[bytes_written]);
        write_pointer = (write_pointer + 1) % FIFO_SIZE;
        buffer_count++;
        bytes_written++;
    }

    mutex_unlock(&fifo_mutex);
    wake_up_interruptible(&read_queue);

    return bytes_written;
}

static const struct file_operations custom_fops = {
    .owner = THIS_MODULE,
    .open = custom_open,
    .release = custom_release,
    .read = custom_read,
    .write = custom_write,
};

static struct miscdevice custom_misc_device = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "custom_char_dev",
    .fops = &custom_fops,
};

static int __init custom_init(void)
{
    int ret = misc_register(&custom_misc_device);
    if (ret) {
        printk(KERN_ERR "Failed to register misc device\n");
        return ret;
    }

    printk(KERN_INFO "Custom character device initialized\n");
    return 0;
}

static void __exit custom_exit(void)
{
    misc_deregister(&custom_misc_device);
    printk(KERN_INFO "Custom character device exited\n");
}

module_init(custom_init);
module_exit(custom_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("LLLRY");
MODULE_DESCRIPTION("Custom character device driver");
 

第二版测试程序

reader.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_FILE "/dev/my_device"

int main() {
    int fd;
    char buf[BUF_SIZE];
    ssize_t bytes_read;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open device file");
        return EXIT_FAILURE;
    }

    // 读取数据
    bytes_read = read(fd, buf, sizeof(buf));
    if (bytes_read < 0) {
        perror("Failed to read from device");
        close(fd);
        return EXIT_FAILURE;
    }

    // 打印读取的数据
    printf("Read from device: %s\n", buf);

    // 关闭设备文件
    close(fd);

    return EXIT_SUCCESS;
}
writer.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define DEVICE_FILE "/dev/my_device"

int main() {
    int fd;
    const char *data = "Hello, device!";
    ssize_t bytes_written;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_WRONLY);
    if (fd < 0) {
        perror("Failed to open device file");
        return EXIT_FAILURE;
    }

    // 写入数据
    bytes_written = write(fd, data, strlen(data));
    if (bytes_written < 0) {
        perror("Failed to write to device");
        close(fd);
        return EXIT_FAILURE;
    }

    printf("Wrote to device: %s\n", data);

    // 关闭设备文件
    close(fd);

    return EXIT_SUCCESS;
}
 

第三版

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/wait.h>

#define DEVICE_NAME "FIFODevice"
#define BUFFER_SIZE 1024

static char buffer[BUFFER_SIZE];
static int head = 0;
static int tail = 0;
static unsigned int fifo_count = 0;
static DEFINE_MUTEX(fifo_mutex);
static wait_queue_head_t read_queue;
static wait_queue_head_t write_queue;

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .read = my_read,
    .write = my_write,
};

static int __init DevInit(void) {
    mutex_init(&fifo_mutex);
    init_waitqueue_head(&read_queue);
    init_waitqueue_head(&write_queue);

    // 注册杂项设备
    my_miscdevice = misc_register(MISC_DYNAMIC_MINOR, DEVICE_NAME);
    if (my_miscdevice == NULL) {
        printk(KERN_ALERT "Failed to register misc device\n");
        return -ENODEV;
    }
    printk(KERN_INFO "Misc device registered as /dev/%s\n", DEVICE_NAME);

    return 0;
}

static void __exit DevExit(void) {
    // 注销杂项设备
    misc_deregister(my_miscdevice);
    printk(KERN_INFO "Misc device unregistered\n");
}

static int my_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device opened\n");
    return 0;
}

static int my_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device closed\n");
    return 0;
}

static ssize_t my_read(struct file *file, char *buf, size_t count, loff_t *f_pos) {
    unsigned long copied;

    wait_event_interruptible(read_queue, (fifo_count > 0));
    if (signal_pending(current)) {
        return -ERESTARTSYS;
    }

    mutex_lock(&fifo_mutex);
    copied = min_t(unsigned int, count, BUFFER_SIZE - head);
    if (head < tail && copied > fifo_count) {
        copied = fifo_count;
    }
    memcpy(buf, &buffer[head], copied);
    head = (head + copied) % BUFFER_SIZE;
    fifo_count -= copied;
    mutex_unlock(&fifo_mutex);

    printk(KERN_INFO "Read %lu bytes from the device\n", copied);
    wake_up_interruptible(&write_queue); // 唤醒写进程

    return copied;
}

static ssize_t my_write(struct file *file, const char *buf, size_t count, loff_t *f_pos) {
    unsigned long copied;

    wait_event_interruptible(write_queue, (fifo_count < (BUFFER_SIZE - 1)));
    if (signal_pending(current)) {
        return -ERESTARTSYS;
    }

    mutex_lock(&fifo_mutex);
    copied = min_t(unsigned int, count, tail + 1);
    memcpy(&buffer[tail], buf, copied);
    tail = (tail + copied) % BUFFER_SIZE;
    fifo_count += copied;
    mutex_unlock(&fifo_mutex);

    printk(KERN_INFO "Wrote %lu bytes to the device\n", copied);
    wake_up_interruptible(&read_queue); // 唤醒读进程

    return copied;
}

module_init(DevInit);
module_exit(DevExit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple FIFO character device with mutex and wait queues");

测试文件

write

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/FIFODevice"

int main() {
    int fd;
    ssize_t written;
    char *message = "Hello, this is a test message!\n";
    size_t message_len = strlen(message);

    // 打开设备
    fd = open(DEVICE_NAME, O_WRONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    // 写入数据
    written = write(fd, message, message_len);
    if (written < 0) {
        perror("Error writing to device");
        close(fd);
        exit(EXIT_FAILURE);
    }

    printf("Written %zu bytes to device\n", written);

    // 关闭设备
    close(fd);

    return 0;
}

read

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_NAME "/dev/FIFODevice"

int main() {
    int fd;
    ssize_t read_bytes;
    char buffer[1024];

    // 打开设备
    fd = open(DEVICE_NAME, O_RDONLY);
    if (fd < 0) {
        perror("Error opening device");
        exit(EXIT_FAILURE);
    }

    // 读取数据
    read_bytes = read(fd, buffer, sizeof(buffer));
    if (read_bytes < 0) {
        perror("Error reading from device");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 打印读取的数据
    printf("Read %zu bytes from device:\n%s", read_bytes, buffer);

    // 关闭设备
    close(fd);

    return 0;
}

3.2测试程序

写

// write.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define DATA_TO_WRITE "Hello, device!" // 自动写入的数据
#define WRITE_INTERVAL_US 1000000 // 写入间隔，单位：微秒（这里是1秒）

int main() {
    int fd;
    int write_count = 0;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_WRONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 循环自动写入数据
    while (1) {
        // 写入数据
        ssize_t bytes_written = write(fd, DATA_TO_WRITE, strlen(DATA_TO_WRITE));
        if (bytes_written < 0) {
            if (errno == EAGAIN) { // 缓冲区已满，重试写入
                continue;
            } else {
                perror("Failed to write to the device");
                close(fd);
                return -1;
            }
        }
        
        // 更新已写入的总字节数
        write_count += bytes_written;
        printf("Data written to device: %s\n", DATA_TO_WRITE);
        
        // 在此添加适当的延时，以控制写入速率
        usleep(WRITE_INTERVAL_US);
    }

    // 关闭设备文件（永远不会执行到这里）
    close(fd);

    return 0;
}
 

读：

// read.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256
#define READ_INTERVAL_US 1000000 // 读取间隔，单位：微秒（这里是1秒）

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_read;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 循环每隔一秒读取数据并打印
    while (1) {
        // 读取数据
        bytes_read = read(fd, buffer, sizeof(buffer));
        if (bytes_read < 0) {
            perror("Failed to read from the device");
            close(fd);
            return -1;
        } else if (bytes_read == 0) {
            printf("No data available from the device\n");
        } else {
            // 打印读取到的数据
            buffer[bytes_read] = '\0'; // 添加字符串结束符
            printf("Data read from device: %s\n", buffer);
        }
        
        // 在此添加适当的延时，以控制读取速率
        usleep(READ_INTERVAL_US);
    }

    // 关闭设备文件（永远不会执行到这里）
    close(fd);

    return 0;
}

3.3

// write.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256
#define WRITE_INTERVAL_US 1000000 // 写入间隔，单位：微秒（这里是1秒）

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_written;
    int write_count = 0;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_WRONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 每隔一秒写入数据直到写满
    while (write_count < MAX_BUFFER_SIZE) {
        // 构造要写入的数据
        sprintf(buffer, "hello device %d", write_count);

        // 写入数据
        bytes_written = write(fd, buffer, strlen(buffer));
        if (bytes_written < 0) {
            perror("Failed to write to the device");
            close(fd);
            return -1;
        }

        // 更新写入计数
        write_count++;

        // 在此添加适当的延时，以控制写入速率
        usleep(WRITE_INTERVAL_US);

        // 每秒报告一次写入信息
        printf("Wrote: %s\n", buffer);
    }

    // 关闭设备文件
    close(fd);

    // 写入成功后打印信息
    printf("Data written to device successfully.\n");

    return 0;
}
 

读：

// read.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256
#define READ_INTERVAL_US 1000000 // 读取间隔，单位：微秒（这里是1秒）

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_read;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 每隔一秒读取数据直到读完
    while (1) {
        // 读取数据
        bytes_read = read(fd, buffer, sizeof(buffer));
        if (bytes_read < 0) {
            perror("Failed to read from the device");
            close(fd);
            return -1;
        } else if (bytes_read == 0) {
            printf("No data available from the device\n");
        } else {
            // 打印读取到的数据
            buffer[bytes_read] = '\0'; // 添加字符串结束符
            printf("Data read from device: %s\n", buffer);
        }

        // 在此添加适当的延时，以控制读取速率
        usleep(READ_INTERVAL_US);

        // 每秒报告一次读取信息
        printf("Read complete.\n");
    }

    // 关闭设备文件（永远不会执行到这里）
    close(fd);

    return 0;
}
3.4

// write.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256
#define WRITE_INTERVAL_US 1000000 // 写入间隔，单位：微秒（这里是1秒）

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_written;
    int write_count = 0;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_WRONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 每隔一秒写入数据直到缓冲区写满
    while (write_count < MAX_BUFFER_SIZE) {
        // 构造要写入的数据
        sprintf(buffer, "hello device %d", write_count);

        // 写入数据
        bytes_written = write(fd, buffer, strlen(buffer));
        if (bytes_written < 0) {
            perror("Failed to write to the device");
            close(fd);
            return -1;
        }

        // 更新写入计数
        write_count++;

        // 在此添加适当的延时，以控制写入速率
        usleep(WRITE_INTERVAL_US);

        // 每秒报告一次写入信息
        printf("Wrote: %s\n", buffer);
    }

    // 关闭设备文件
    close(fd);

    printf("Buffer is full. Stopped writing.\n");

    return 0;
}

// read.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_read;
    int read_count = 0;
    int ioctl_ret;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 读取数据直到缓冲区为空
    while (1) {
        // 读取数据
        bytes_read = read(fd, buffer, MAX_BUFFER_SIZE);
        if (bytes_read < 0) {
            perror("Failed to read from the device");
            close(fd);
            return -1;
        } else if (bytes_read == 0) {
            // 缓冲区为空，退出循环
            break;
        }

        // 输出读取的数据
        printf("Read: %s\n", buffer);

        // 清空缓冲区
        ioctl_ret = ioctl(fd, IOCTL_CLEAR_BUFFER);
        if (ioctl_ret < 0) {
            perror("Failed to clear buffer");
            close(fd);
            return -1;
        }

        // 更新读取计数
        read_count++;
    }

    // 关闭设备文件
    close(fd);

    printf("Read complete. Read %d times.\n", read_count);

    return 0;
}
 

// read.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_read;
    int read_count = 0;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 读取数据直到缓冲区为空
    while (1) {
        // 读取数据
        bytes_read = read(fd, buffer, MAX_BUFFER_SIZE);
        if (bytes_read < 0) {
            perror("Failed to read from the device");
            close(fd);
            return -1;
        } else if (bytes_read == 0) {
            // 缓冲区为空，退出循环
            break;
        }

        // 输出读取的数据
        printf("Read: %s\n", buffer);

        // 清空缓冲区
        if (lseek(fd, 0, SEEK_SET) < 0) {
            perror("Failed to seek to the beginning of the buffer");
            close(fd);
            return -1;
        }
        if (write(fd, "", 1) != 1) {
            perror("Failed to write to clear the buffer");
            close(fd);
            return -1;
        }

        // 更新读取计数
        read_count++;
    }

    // 关闭设备文件
    close(fd);

    printf("Read complete. Read %d times.\n", read_count);

    return 0;
}

// read.c
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define DEVICE_FILE "/dev/custom_char_dev"
#define MAX_BUFFER_SIZE 256

int main() {
    int fd;
    char buffer[MAX_BUFFER_SIZE];
    ssize_t bytes_read;
    int read_count = 0;

    // 打开设备文件
    fd = open(DEVICE_FILE, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open the device file");
        return -1;
    }

    // 读取数据直到缓冲区为空
    while (1) {
        // 读取数据
        bytes_read = read(fd, buffer, MAX_BUFFER_SIZE);
        if (bytes_read < 0) {
            perror("Failed to read from the device");
            close(fd);
            return -1;
        } else if (bytes_read == 0) {
            // 缓冲区为空，退出循环
            break;
        }

        // 输出读取的数据
        printf("Read: %s\n", buffer);

        // 更新读取计数
        read_count++;
    }

    // 关闭设备文件
    close(fd);

    printf("Read complete. Read %d times.\n", read_count);

    return 0;
}

羊村你喜哥哥
关注
  • 33
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux提取驱动程序,学会linux驱动程序的步骤
weixin_35544017的博客
05-01 1285
第一步：建立Linux驱动的骨架linux内核使用驱动时候，需要先初始化，包括建立设备文件，分配内存地址空间等，退出的时候要释放资源，删除设备文件，释放内存地址空间等。所以在linux驱动中需要提供两个函数来分别处理驱动初始化和退出的工作，这两个函数分别用module_init和module_exit宏来指定，linux驱动一般都需要指定这两个函数，所以linux驱动有一个C文件，文件中包含处理驱...
linux 驱动程序安装,如何在Linux上安装设备驱动程序
weixin_42376118的博客
05-01 1558
了解Linux设备驱动程序如何工作以及如何使用它们.对于想要切换到Linux的熟悉Windows或MacOS的人，他们将面临如何安装和配置设备驱动程序的难题. 这是可以理解的，因为Windows和MacOS都有使该过程非常友好的机制. 例如，当您插入新的硬件设备时，Windows会自动检测并弹出一个窗口，询问您是否要继续安装驱动程序. 您也可以从Internet下载驱动程序，只需双击以通过设备管理...
Linux驱动程序和应用程序
amateur_dabai的博客
03-21 1504
应用编程需要做些什么，应用层与驱动层怎么联系起来的？
Linux驱动程序概述以及框架
打不倒的程序猿
07-07 1713
狭义上来说，驱动程序专指操作系统中的用来操控硬件的代码。下面的驱动框架中也会提到，我们在上层应用写好程序，要求实现某一个硬件的功能，比如点亮LED等等，这里面会通过一系列调用，在内核态找到我们所需要的驱动，通过函数操作直接与硬件交互。而在裸机开发中我们也经常会听到裸机驱动，其实严格意义上来说，没有操作系统是没有驱动概念的，如果非要说裸机驱动的话，也是指裸机中操作硬件的那部分程序。驱动与底层硬件直接打交道，按照硬件设备的具体工作方式。读写设备的寄存器，完成设备的轮询，中断处理，DMA通信，进行物理内存向虚拟内
基于I.MX6ULL + LINUX驱动程序 Qt车载系统
qq_75130201的博客
04-14 8449
Qt车载系统都是基本功和API调用，硬件也涉及的少，交叉编译的话WEB模块是编译不过去的，当时我问了正点原子官方 他们原话:(6ull不支持webengewidgets。就算你能交叉编译出来，6ull估计跑不动。6ull上有webview。webengine编译相关源码500MB。mp157和rk3568上有webengine，如果你有这两板子）还有一个bug 板子上Qt程序对两个驱动文件读数据时会直接卡死了，我查了好久资料都查不到原因，最后也懒得管了直接找工作了，都无所谓，能跑就行。
linux驱动程序的编译方法有两种,Linux驱动程序编写演示----编译驱动程序
weixin_34416909的博客
05-10 3407
Linux驱动程序编写演示----编译驱动程序1驱动编写：#include #include static int __init test_driver_init(void){/* register this driver */printk("Hello test_driver , init this driver");return 0;}static void __exit test_drive...
Linux驱动程序框架以及概述
hanhan的博客
01-13 5555
设备驱动程序功能： 1、对设备初始化和释放 2、把数据从内核传送到硬件和从硬件读取数据 3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据 4、检测和处理设备出现的错误 访问特定硬件： 访问特定硬件就是访问物理地址(如处理器内设备的寄存器、外设的地址映射)。然而由于MMU的内存映射以及对操作系统的保护，运行在用户态的应用程序一般不能直接访问硬件地址。因此需要驱动程序作为应用程序和访问硬件之间的媒介。 驱动程序三种基本类型 1、字符设备(Char Device) 2、块设备(Block Device
【操作系统】课程设计：新增linux驱动程序
zombotany的博客
02-15 6387
写在前面 请先阅读https://blog.csdn.net/qq_46640863/article/details/122684580 对linux内核进行编译。 目录写在前面一、设计内容及具体要求二、设计思想三、 设计实现与源码剖析四、操作流程五、测试与分析附录Makefilezombotany_blkdev.c 一、设计内容及具体要求 新增Linux驱动程序 增加一个驱动程序（使用内存模拟设备），使用模块编译方式。 要求： （1）可以动态加载和卸载新的驱动。 （2）通过程序或命令行使用该驱动。 （3）
基于块的Linux驱动程序 操作系统课程设计 最详细教程 块设备驱动 linux内核编译
m0_46362426的博客
07-18 7611
本博客是本次课程设计的记录，关于这个题目的完整详细的博客内容较少，故作一篇详细教程并且写出一些报错内容、解决办法以供参考。 以下是我的课设题目要求，读者可以酌情参考： 需要重新编译Linux内核 增加一个驱动程序（使用内存模拟设备），使用模块编译方式 动态加载和卸载新的驱动 通过程序或命令行使用该驱动。 （至少能通过该驱动保存1MB的数据，还能将这些数据读取出来。可以模仿ramdisk的实现方式。） 1. 前期准备：下载和安装虚拟机以及centos 虚拟机我下载的是VMware Worksta
linux驱动目录在哪里,详细讲解Linux驱动程序
weixin_36443053的博客
04-28 4966
一 ?编写Linux驱动程序1.建立Linux驱动骨架? Linux内核在使用驱动时需要装载与卸载驱动?装载驱动：建立设备文件、分配内存地址空间等；module_init 函数处理驱动初始化?卸载驱动：删除设备文件、释放内存地址空间等；module_exit函数处理退出包含这两个函数的两个宏的C程序文件也可看做是Linux驱动的骨架2.注册和注销设备文件任何一个Linux驱动都需要有一个设备文件，...
linux-Linux驱动程序模板.zip
02-26
Linux驱动程序是操作系统与硬件设备之间的重要桥梁，它允许Linux内核识别并有效管理硬件资源。在Linux系统中，编写驱动程序是实现设备控制的关键步骤。"Linux驱动程序模板"通常包含了一些基本的结构和函数，帮助...
linux驱动程序
12-10
linux驱动程序Linux下驱动模板的要素,以及Linux上应用程序到驱动的执行过程
Linux驱动程序 嵌入式.pdf
06-17
文档
Xilinx-FPGA-PCIE-Linux驱动程序.rar_FPGA Linux 驱动_PCIe FPGA_pcie_pci
07-14
标题中的“Xilinx-FPGA-PCIE-Linux驱动程序”是指针对Xilinx FPGA在Linux操作系统下与PCI Express（PCIe）接口交互的驱动程序。这一主题涵盖了FPGA设计、PCIe协议、Linux内核驱动开发等多个关键知识点。 1. **FPGA*...
Linux驱动程序开发
12-02
Linux驱动程序开发是软件开发领域中的一个重要组成部分，主要目的是为了让操作系统能够有效管理和使用硬件设备。在Linux系统中，驱动程序是连接硬件与操作系统内核的关键桥梁，它实现了硬件功能的抽象化，使得应用...
Linux 下 Anaconda/Miniconda 环境安装教程
蜡笔小新星的博客
08-04 644
通过以上步骤，你应该能够详尽地完成 Anaconda 或 Miniconda 的安装，创建和管理环境。
Linux｜最佳命令行下载加速器
冷冻工厂
08-04 318
它兼容多种网络协议，包括但不限于 DICT、FILE、FTP、FTPS、GOPHER、HTTP、HTTPS、IMAP、IMAPS、LDAP、LDAPS、POP3、POP3S、RTMP、RTSP、SCP、SFTP、SMB、SMBS、SMTP、SMTPS、TELNET 和 TFTP，根据其官方文档所述。wget 提供了丰富的选项，包括进行需要认证的下载、设置递归下载的深度限制、支持 URL 的正则表达式匹配、允许排除特定内容、从文件中读取 URL 等。可以想象，有了这样的支持，curl 的应用场景非常广泛。
Linux初学基本命令
yuan20010401的博客
07-25 1304
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
Linux 6: 正则表达式 - 2024-08-Week1
最新发布
weixin_48029567的博客
08-04 141
正则表达式：Regular expression是处理字符串的方法，常常用来某些特定的字符串。
Linux驱动程序开发详解
“Linux驱动程序开发概述，包括驱动程序的基本概念、设备驱动的作用、系统调用、内核与驱动的关系、驱动类型（字符设备和块设备）、设备号、内核模块的初始化与清理函数。” 在Linux操作系统中，驱动程序开发是一项...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值