在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()函数等待函数二将msg的complete成员设置为1后，再退出函数；函数二将msg从队列中取出来，解析msg中的module_id，如果该值不为0x1，则报错，否则使用switch函数解析cmd_id，并根据不同的cmd_id再解析cmd_subid，将msg内data数组中放入的两个unsigned int值还原，并将其作为两个参数用在下列函数前两个参数中，static unsigned int phytuart_msg_cmd_set_txim(unsigned int im, unsigned int txim, struct pokemon_uart_port *pup) { if (txim == 0) { im &= ~REG_IMSC_TXIM; pokemon_uart_write(im, pup, REG_IMSC); } else{ im |= REG_IMSC_TXIM; pokemon_uart_write(im, pup, REG_IMSC); } return im; }并将msg中的complete成员设置为1，函数一和函数二需要使用队列的操作函数，注意函数一中将msg放进队列后，需要调用函数二解析，请在驱动注册时注册队列，在驱动卸载时注销队列请给出详细代码

初始化函数：

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

入队函数：

int ring_buffer_enqueue(struct ring_buffer *rb, struct msg *msg) {
    if (ring_buffer_is_full(rb)) {
        return -1;
    }
    memcpy(&rb->data[rb->tail], msg, sizeof(struct msg));
    rb->tail = (rb->tail + 1) % rb->capacity;
    return 0;
}

出队函数：

int ring_buffer_dequeue(struct ring_buffer *rb, struct msg *msg) {
    if (ring_buffer_is_empty(rb)) {
        return -1;
    }
    memcpy(msg, &rb->data[rb->head], sizeof(struct msg));
    rb->head = (rb->head + 1) % rb->capacity;
    return 0;
}

注销函数：

void ring_buffer_destroy(struct ring_buffer *rb) {
    kfree(rb->data);
    rb->data = NULL;
}

构建msg的函数：

void build_msg(struct msg *msg) {
    msg->module_id = 0x1234;
    msg->cmd_id = 0x5678;
    msg->cmd_subid = 0x9abc;
    msg->complete = 0;
    unsigned int value1 = 0x12345678;
    unsigned int value2 = 0x9abcdef0;
    memcpy(msg->data, &value1, sizeof(unsigned int));
    memcpy(msg->data + sizeof(unsigned int), &value2, sizeof(unsigned int));
}

函数一：

void function1(struct ring_buffer *rb) {
    struct msg msg;
    build_msg(&msg);
    ring_buffer_enqueue(rb, &msg);
    while (msg.complete == 0) {
        usleep_range(100, 200);
        ring_buffer_dequeue(rb, &msg);
    }
}

函数二：

void function2(struct ring_buffer *rb) {
    struct msg msg;
    ring_buffer_dequeue(rb, &msg);
    if (msg.module_id != 0x1) {
        pr_err("module_id error\n");
        return;
    }
    switch(msg.cmd_id) {
        case 0x5678:
            switch(msg.cmd_subid) {
                case 0x9abc:
                    unsigned int value1, value2;
                    memcpy(&value1, msg.data, sizeof(unsigned int));
                    memcpy(&value2, msg.data + sizeof(unsigned int), sizeof(unsigned int));
                    struct pokemon_uart_port *pup = ...; // 获取结构体指针
                    unsigned int im = ...; // 获取变量值
                    unsigned int txim = value1 >> 16;
                    im = phytuart_msg_cmd_set_txim(im, txim, pup);
                    msg.complete = 1;
                    break;
                default:
                    pr_err("cmd_subid error\n");
                    break;
            }
            break;
        default:
            pr_err("cmd_id error\n");
            break;
    }
    ring_buffer_enqueue(rb, &msg);
}

注册队列：

struct ring_buffer *rb = kmalloc(sizeof(struct ring_buffer), GFP_KERNEL);
ring_buffer_init(rb, 1024);
// 将rb传入驱动其他函数中使用

注销队列：

ring_buffer_destroy(rb);
kfree(rb);
rb = NULL;