在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，函数一和函数二需要使用队列的操作函数

请注意，以下代码仅供参考，并未经过完整的测试和验证。

初始化：

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

入队：

int ring_buffer_enqueue(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->capacity;
    ring->size++;

    return 0;
}

出队：

int ring_buffer_dequeue(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->capacity;
    ring->size--;

    return 0;
}

注销：

void ring_buffer_free(struct ring_buffer *ring)
{
    kfree(ring->data);
    ring->data = NULL;
}

判断空：

int ring_buffer_empty(struct ring_buffer *ring)
{
    return ring->size == 0;
}

判断满：

int ring_buffer_full(struct ring_buffer *ring)
{
    return ring->size == ring->capacity;
}

构建msg并入队：

void build_and_enqueue_msg(struct ring_buffer *ring)
{
    struct msg msg;
    memset(&msg, 0, sizeof(struct msg));
    msg.module_id = 0x1;

    // 构建data数组
    unsigned int val1 = 0x12345678;
    unsigned int val2 = 0x87654321;
    msg.data[0] = (val1 >> 24) & 0xFF;
    msg.data[1] = (val1 >> 16) & 0xFF;
    msg.data[2] = (val1 >> 8) & 0xFF;
    msg.data[3] = val1 & 0xFF;
    msg.data[4] = (val2 >> 24) & 0xFF;
    msg.data[5] = (val2 >> 16) & 0xFF;
    msg.data[6] = (val2 >> 8) & 0xFF;
    msg.data[7] = val2 & 0xFF;

    ring_buffer_enqueue(ring, &msg);

    // 等待complete被设置为1
    while (msg.complete == 0) {
        usleep_range(1000, 2000);
        ring_buffer_dequeue(ring, &msg);
        ring_buffer_enqueue(ring, &msg);
    }
}

取出msg并解析：

void dequeue_and_parse_msg(struct ring_buffer *ring)
{
    struct msg msg;
    memset(&msg, 0, sizeof(struct msg));

    ring_buffer_dequeue(ring, &msg);

    if (msg.module_id != 0x1) {
        printk(KERN_ERR "Invalid module id\n");
        return;
    }

    switch (msg.cmd_id) {
        case 0x1:
            switch (msg.cmd_subid) {
                // 解析data数组中的两个unsigned int值
                unsigned int val1, val2;
                val1 = (msg.data[0] << 24) | (msg.data[1] << 16) | (msg.data[2] << 8) | msg.data[3];
                val2 = (msg.data[4] << 24) | (msg.data[5] << 16) | (msg.data[6] << 8) | msg.data[7];

                // 处理其他逻辑

                // 设置complete为1
                msg.complete = 1;
                ring_buffer_enqueue(ring, &msg);
                break;
            }
            break;
        default:
            printk(KERN_ERR "Invalid cmd id\n");
            break;
    }
}