在Linux内核驱动中，构建一个存放如下结构体指针的队列： struct msg { u16 module_id; u16 cmd_id; u16 cmd_subid; u16 complete; u8 data[128]; };、 请给出操作这个队列的函数，包括初始化，入队，出队，注销等。 再构建两个函数，在函数中使用操作队列的函数完成如下功能： 函数一初始化msg结构体，将msg所有成员设置为常数（其中msg的complete成员设置为0），向msg的data数组内放置两个unsigned int 类型数据a和b，之后将msg结构体放入队列中，触发函数二，使用usleep_range()函数等待函数二将msg的complete成员设置为1后，获取函数二放入的c并还原成unsigned int 类型。 函数二需要从队列中取出msg，并进行解析：判断msg的module_id是否为0x1，如果不是，报错，如果是0x1,使用switch函数解析msg的cmd_id，再根据不同的cmd_id解析cmd_subid，具体解析内容为，取出在函数一向msg的data数组中放入的a和b，还原成unsigned int 类型数据，再将一个unsigned int 类型数据c=1000，放到msg的data数组内，之后，再将msg中的complete置1；请在驱动的probe函数中注册这个队列，在remove函数中注销队列，使用移位的方式放置和还原unsigned int类型数据

以下是操作队列的函数实现：

#include <linux/slab.h>
#include <linux/wait.h>
#include <linux/list.h>

struct msg {
    u16 module_id;
    u16 cmd_id;
    u16 cmd_subid;
    u16 complete;
    u8 data[128];
};

struct msg_queue {
    wait_queue_head_t waitq;
    spinlock_t lock;
    struct list_head msg_list;
};

static struct msg_queue *msgq;

int msg_queue_init(void)
{
    msgq = kmalloc(sizeof(*msgq), GFP_KERNEL);
    if (!msgq)
        return -ENOMEM;

    spin_lock_init(&msgq->lock);
    init_waitqueue_head(&msgq->waitq);
    INIT_LIST_HEAD(&msgq->msg_list);

    return 0;
}

void msg_queue_exit(void)
{
    struct msg *msg, *next;

    spin_lock(&msgq->lock);
    list_for_each_entry_safe(msg, next, &msgq->msg_list, list) {
        list_del(&msg->list);
        kfree(msg);
    }
    spin_unlock(&msgq->lock);

    kfree(msgq);
}

int msg_enqueue(struct msg *msg)
{
    spin_lock(&msgq->lock);
    list_add_tail(&msg->list, &msgq->msg_list);
    spin_unlock(&msgq->lock);

    wake_up(&msgq->waitq);

    return 0;
}

struct msg *msg_dequeue(void)
{
    struct msg *msg = NULL;

    spin_lock(&msgq->lock);
    if (!list_empty(&msgq->msg_list)) {
        msg = list_first_entry(&msgq->msg_list, struct msg, list);
        list_del(&msg->list);
    }
    spin_unlock(&msgq->lock);

    return msg;
}

以下是使用操作队列的函数实现：

#include <linux/delay.h>

void func1(void)
{
    struct msg *msg = kmalloc(sizeof(*msg), GFP_KERNEL);
    if (!msg)
        return;

    msg->module_id = 0x1;
    msg->cmd_id = 0x2;
    msg->cmd_subid = 0x3;
    msg->complete = 0;
    *(unsigned int *)msg->data = 0x12345678;
    *(unsigned int *)(msg->data + 4) = 0xabcdef01;

    msg_enqueue(msg);

    do {
        usleep_range(1000, 2000);
    } while (!msg->complete);

    printk(KERN_INFO "func1: c = 0x%08x\n", *(unsigned int *)(msg->data + 8));
    kfree(msg);
}

void func2(void)
{
    struct msg *msg = msg_dequeue();
    if (!msg)
        return;

    if (msg->module_id != 0x1) {
        printk(KERN_ERR "func2: invalid module_id\n");
        kfree(msg);
        return;
    }

    switch (msg->cmd_id) {
    case 0x1:
        switch (msg->cmd_subid) {
        case 0x1:
            *(unsigned int *)(msg->data) = 0x87654321;
            *(unsigned int *)(msg->data + 4) = 0x10fedcba;
            *(unsigned int *)(msg->data + 8) = 1000;
            msg->complete = 1;
            break;
        default:
            printk(KERN_ERR "func2: invalid cmd_subid\n");
            break;
        }
        break;
    default:
        printk(KERN_ERR "func2: invalid cmd_id\n");
        break;
    }

    wake_up(&msgq->waitq);
}

在驱动的probe函数中，注册这个队列：

static int my_driver_probe(struct platform_device *pdev)
{
    int ret;

    ret = msg_queue_init();
    if (ret) {
        dev_err(&pdev->dev, "failed to initialize message queue\n");
        return ret;
    }

    /* other initialization */

    return 0;
}

在remove函数中注销队列：

static int my_driver_remove(struct platform_device *pdev)
{
    /* other cleanup */

    msg_queue_exit();

    return 0;
}

使用移位的方式放置和还原unsigned int类型数据，可以使用下面的宏：

#define PUT_UINT32_LE(n, b, i) { (b)[(i)] = (n) & 0xff; (b)[(i) + 1] = ((n) >> 8) & 0xff; (b)[(i) + 2] = ((n) >> 16) & 0xff; (b)[(i) + 3] = ((n) >> 24) & 0xff; }
#define GET_UINT32_LE(n, b, i) { (n) = ((unsigned int)(b)[(i)]) | ((unsigned int)(b)[(i) + 1] << 8) | ((unsigned int)(b)[(i) + 2] << 16) | ((unsigned int)(b)[(i) + 3] << 24); }