在Linux内核驱动中，构建一个环形队列，struct ring_buffer { int head; int tail; struct msg *data; int size; unsigned int capacity; };其中存放的是定义如下的结构体struct msg { u16 module_id; u16 cmd_id; u16 cmd_subid; u16 complete; u8 data[128]; };，请你给出操作这个环形队列的功能函数，分别为：初始化、入队、出队、注销、判断空、判断满，再写两个函数，函数一构建msg，除msg中的data数组外，其他成员赋值为常数，并将两个unsigned int 类型的值使用移位的方式放入data数组中，并向队列中放置msg，使用usleep_range()函数等待函数二将complete设置为1后，再退出函数；函数二将msg从队列中取出来，解析msg中的module_id，如果该值不为0x1，则报错，否则使用switch函数解析cmd_id，并根据不同的cmd_id再解析cmd_subid，将msg内data数组中放入的两个unsigned int值还原，并将msg中的complete成员设置为1，函数一和函数二需要使用队列的操作函数，函数二使用msg结构体指针直接修改comoplete值即可，同时模拟一个中断，在函数一将msg放入队列后，使用模拟中断调用函数二

下面是操作环形队列的功能函数的实现：

1. 初始化

void ring_buffer_init(struct ring_buffer *ring, int size) {
    ring->head = 0;
    ring->tail = 0;
    ring->data = kmalloc(size * sizeof(struct msg), GFP_KERNEL);
    ring->size = size;
    ring->capacity = size - 1;
}

2. 入队

int ring_buffer_push(struct ring_buffer *ring, struct msg *msg) {
    if (ring_buffer_full(ring)) {
        return -1;
    }
    memcpy(&ring->data[ring->tail], msg, sizeof(struct msg));
    ring->tail = (ring->tail + 1) % ring->size;
    return 0;
}

3. 出队

int ring_buffer_pop(struct ring_buffer *ring, struct msg *msg) {
    if (ring_buffer_empty(ring)) {
        return -1;
    }
    memcpy(msg, &ring->data[ring->head], sizeof(struct msg));
    ring->head = (ring->head + 1) % ring->size;
    return 0;
}

4. 注销

void ring_buffer_cleanup(struct ring_buffer *ring) {
    kfree(ring->data);
}

5. 判断空

int ring_buffer_empty(struct ring_buffer *ring) {
    return ring->head == ring->tail;
}

6. 判断满

int ring_buffer_full(struct ring_buffer *ring) {
    return (ring->tail + 1) % ring->size == ring->head;
}

7. 函数一：构建msg并放入队列中

void function_one(struct ring_buffer *ring) {
    struct msg msg;
    msg.module_id = 0x1;
    msg.cmd_id = 0x2;
    msg.cmd_subid = 0x3;
    msg.complete = 0;
    unsigned int val1 = 0x12345678;
    unsigned int val2 = 0x9abcdef0;
    memcpy(msg.data, &val1, sizeof(unsigned int));
    memcpy(msg.data + sizeof(unsigned int), &val2, sizeof(unsigned int));
    ring_buffer_push(ring, &msg);
    while (!msg.complete) {
        usleep_range(1000, 2000);
    }
}

8. 函数二：从队列中取出msg并解析

void function_two(struct ring_buffer *ring) {
    struct msg msg;
    ring_buffer_pop(ring, &msg);
    if (msg.module_id != 0x1) {
        printk(KERN_ERR "Invalid module_id: %hu\n", msg.module_id);
        return;
    }
    switch (msg.cmd_id) {
        case 0x2:
            switch (msg.cmd_subid) {
                case 0x3:
                    unsigned int val1, val2;
                    memcpy(&val1, msg.data, sizeof(unsigned int));
                    memcpy(&val2, msg.data + sizeof(unsigned int), sizeof(unsigned int));
                    val1 = be32_to_cpu(val1);
                    val2 = be32_to_cpu(val2);
                    printk(KERN_INFO "Received msg: val1=%u, val2=%u\n", val1, val2);
                    msg.complete = 1;
                    break;
                default:
                    printk(KERN_ERR "Invalid cmd_subid: %hu\n", msg.cmd_subid);
                    break;
            }
            break;
        default:
            printk(KERN_ERR "Invalid cmd_id: %hu\n", msg.cmd_id);
            break;
    }
}

9. 模拟中断调用函数二

irqreturn_t interrupt_handler(int irq, void *dev_id) {
    function_two((struct ring_buffer *)dev_id);
    return IRQ_HANDLED;
}