linux内核uart驱动，使用acpi匹配方式注册设备驱动，并在acpi表里指定波特率，在注册时读取这个波特率并进行设定，给出详细代码

好的，根据您的要求，以下是一个示例代码，实现在 Linux 内核中使用 ACPI 匹配方式注册 UART 设备驱动，并在 ACPI 表中指定波特率并进行设定：

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/acpi.h>
#include <linux/serial_core.h>
#include <linux/serial_sci.h>

static int uart_acpi_match(struct device *dev, struct device_driver *drv)
{
    struct acpi_device *adev = to_acpi_device(dev);
    const char *hid = "ACPI000C"; // HID for UART devices

    if (!adev || !adev->pnp.unique_id)
        return 0;

    if (strcmp(adev->pnp.unique_id, hid) == 0)
        return 1;

    return 0;
}

static int uart_acpi_probe(struct platform_device *pdev)
{
    struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
    struct device_node *np = NULL;
    struct resource *res = NULL;
    struct uart_port *port;
    struct uart_driver *drv;
    int ret, baud_rate = 9600; // default baud rate

    /* Get the baud rate from ACPI table */
    if (adev && adev->handle) {
        union acpi_object *obj;
        struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
        char *str;

        ret = acpi_evaluate_object(adev->handle, "BAUD_RATE", NULL, &buf);
        if (ret) {
            pr_err("Cannot evaluate BAUD_RATE object\n");
            goto err;
        }

        obj = buf.pointer;
        if (obj->type == ACPI_TYPE_STRING) {
            str = obj->string.pointer;
            if (kstrtoint(str, 10, &baud_rate) != 0) {
                pr_err("Cannot parse BAUD_RATE string\n");
                goto err;
            }
        }
        else {
            pr_err("Unexpected BAUD_RATE object type %d\n", obj->type);
            goto err;
        }

        kfree(buf.pointer);
    }

    /* Allocate and initialize UART port */
    port = kzalloc(sizeof(*port), GFP_KERNEL);
    if (!port) {
        ret = -ENOMEM;
        goto err;
    }

    drv = uart_get_driver(dev_name(&pdev->dev));
    if (!drv) {
        ret = -ENODEV;
        goto err_port;
    }

    port->type = drv->type;
    port->dev = &pdev->dev;
    port->iotype = UPIO_MEM;
    port->membase = res->start;
    port->mapbase = res->start;
    port->irq = platform_get_irq(pdev, 0);
    port->uartclk = clk_get_rate(drv->clk);
    port->regshift = 0;
    port->fifosize = 16;  // default fifo size

    /* Set the baud rate */
    if (serial_sci_set_baud_rate(port, baud_rate)) {
        pr_err("Cannot set baud rate\n");
        ret = -EINVAL;
        goto err_drv;
    }

    /* Register the UART port */
    ret = uart_add_one_port(drv, port);
    if (ret) {
        pr_err("Cannot add UART port\n");
        goto err_drv;
    }

    return 0;

err_drv:
    uart_put_driver(drv);
err_port:
    kfree(port);
err:
    return ret;
}

static int uart_acpi_remove(struct platform_device *pdev)
{
    struct uart_port *port = platform_get_drvdata(pdev);
    struct uart_driver *drv = uart_get_driver(dev_name(&pdev->dev));

    if (port)
        uart_remove_one_port(drv, port);

    uart_put_driver(drv);

    return 0;
}

static const struct acpi_device_id uart_acpi_device_ids[] = {
    {"ACPI000C", 0},
    {""},
};
MODULE_DEVICE_TABLE(acpi, uart_acpi_device_ids);

static struct platform_driver uart_acpi_driver = {
    .driver = {
        .name = "acpi-uart",
        .acpi_match_table = (const struct acpi_device_id *)uart_acpi_device_ids,
    },
    .probe = uart_acpi_probe,
    .remove = uart_acpi_remove,
};

module_platform_driver(uart_acpi_driver);

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("ACPI UART driver");
MODULE_LICENSE("GPL");

在这个示例代码中，我们首先定义了一个名为 `uart_acpi_match` 的函数，用于检查设备是否符合我们的条件。我们在这里使用了 HID（硬件 ID）来匹配 UART 设备。如果设备符合条件，该函数返回 1，否则返回 0。

接下来，我们定义了一个名为 `uart_acpi_probe` 的函数，用于驱动设备。我们首先从 ACPI 表中获取波特率信息，然后根据波特率初始化 UART 端口，并将其添加到内核中。在这里，我们使用了 Linux 内核中的 `serial_sci_set_baud_rate` 函数来设置波特率。

最后，我们定义了一个名为 `uart_acpi_remove` 的函数，用于在设备被卸载时清理资源。

注意：这是一个简化的示例代码，并未包含完整的错误处理和设备初始化代码。在实际应用中，您需要根据具体情况进行修改和完善。