drivers/serial/8250_acpi.c

   1 /*
   2  * Copyright (c) 2002-2003 Matthew Wilcox for Hewlett-Packard
   3  * Copyright (C) 2004 Hewlett-Packard Co
   4  *      Bjorn Helgaas <bjorn.helgaas@hp.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/acpi.h>
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/tty.h>
  16 #include <linux/serial.h>
  17 #include <linux/tty.h>
  18 #include <linux/serial_core.h>
  19
  20 #include <acpi/acpi_bus.h>
  21
  22 #include <asm/io.h>
  23 #include <asm/serial.h>
  24
  25 struct serial_private {
  26         int     line;
  27         void    *iomem_base;
  28 };
  29
  30 static acpi_status acpi_serial_mmio(struct serial_struct *req,
  31                                     struct acpi_resource_address64 *addr)
  32 {
  33         unsigned long size;
  34
  35         size = addr->max_address_range - addr->min_address_range + 1;
  36         req->iomap_base = addr->min_address_range;
  37         req->iomem_base = ioremap(req->iomap_base, size);
  38         if (!req->iomem_base) {
  39                 printk(KERN_ERR "%s: couldn't ioremap 0x%lx-0x%lx\n",
  40                         __FUNCTION__, req->iomap_base, req->iomap_base + size);
  41                 return AE_ERROR;
  42         }
  43         req->io_type = SERIAL_IO_MEM;
  44         return AE_OK;
  45 }
  46
  47 static acpi_status acpi_serial_port(struct serial_struct *req,
  48                                     struct acpi_resource_io *io)
  49 {
  50         if (io->range_length) {
  51                 req->port = io->min_base_address;
  52                 req->io_type = SERIAL_IO_PORT;
  53         } else
  54                 printk(KERN_ERR "%s: zero-length IO port range?\n", __FUNCTION__);
  55         return AE_OK;
  56 }
  57
  58 static acpi_status acpi_serial_ext_irq(struct serial_struct *req,
  59                                        struct acpi_resource_ext_irq *ext_irq)
  60 {
  61         if (ext_irq->number_of_interrupts > 0) {
  62 #ifdef CONFIG_IA64
  63                 req->irq = acpi_register_irq(ext_irq->interrupts[0],
  64                           ext_irq->active_high_low, ext_irq->edge_level);
  65 #else
  66                 req->irq = ext_irq->interrupts[0];
  67 #endif
  68         }
  69         return AE_OK;
  70 }
  71
  72 static acpi_status acpi_serial_irq(struct serial_struct *req,
  73                                    struct acpi_resource_irq *irq)
  74 {
  75         if (irq->number_of_interrupts > 0) {
  76 #ifdef CONFIG_IA64
  77                 req->irq = acpi_register_irq(irq->interrupts[0],
  78                           irq->active_high_low, irq->edge_level);
  79 #else
  80                 req->irq = irq->interrupts[0];
  81 #endif
  82         }
  83         return AE_OK;
  84 }
  85
  86 static acpi_status acpi_serial_resource(struct acpi_resource *res, void *data)
  87 {
  88         struct serial_struct *serial_req = (struct serial_struct *) data;
  89         struct acpi_resource_address64 addr;
  90         acpi_status status;
  91
  92         status = acpi_resource_to_address64(res, &addr);
  93         if (ACPI_SUCCESS(status))
  94                 return acpi_serial_mmio(serial_req, &addr);
  95         else if (res->id == ACPI_RSTYPE_IO)
  96                 return acpi_serial_port(serial_req, &res->data.io);
  97         else if (res->id == ACPI_RSTYPE_EXT_IRQ)
  98                 return acpi_serial_ext_irq(serial_req, &res->data.extended_irq);
  99         else if (res->id == ACPI_RSTYPE_IRQ)
 100                 return acpi_serial_irq(serial_req, &res->data.irq);
 101         return AE_OK;
 102 }
 103
 104 static int acpi_serial_add(struct acpi_device *device)
 105 {
 106         struct serial_private *priv;
 107         acpi_status status;
 108         struct serial_struct serial_req;
 109         int result;
 110
 111         memset(&serial_req, 0, sizeof(serial_req));
 112
 113         priv = kmalloc(sizeof(struct serial_private), GFP_KERNEL);
 114         if (!priv) {
 115                 result = -ENOMEM;
 116                 goto fail;
 117         }
 118         memset(priv, 0, sizeof(*priv));
 119
 120         status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
 121                                      acpi_serial_resource, &serial_req);
 122         if (ACPI_FAILURE(status)) {
 123                 result = -ENODEV;
 124                 goto fail;
 125         }
 126
 127         if (serial_req.iomem_base)
 128                 priv->iomem_base = serial_req.iomem_base;
 129         else if (!serial_req.port) {
 130                 printk(KERN_ERR "%s: no iomem or port address in %s _CRS\n",
 131                         __FUNCTION__, device->pnp.bus_id);
 132                 result = -ENODEV;
 133                 goto fail;
 134         }
 135
 136         serial_req.baud_base = BASE_BAUD;
 137         serial_req.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF | UPF_RESOURCES;
 138
 139         priv->line = register_serial(&serial_req);
 140         if (priv->line < 0) {
 141                 printk(KERN_WARNING "Couldn't register serial port %s: %d\n",
 142                         device->pnp.bus_id, priv->line);
 143                 result = -ENODEV;
 144                 goto fail;
 145         }
 146
 147         acpi_driver_data(device) = priv;
 148         return 0;
 149
 150 fail:
 151         if (serial_req.iomem_base)
 152                 iounmap(serial_req.iomem_base);
 153         kfree(priv);
 154
 155         return result;
 156 }
 157
 158 static int acpi_serial_remove(struct acpi_device *device, int type)
 159 {
 160         struct serial_private *priv;
 161
 162         if (!device || !acpi_driver_data(device))
 163                 return -EINVAL;
 164
 165         priv = acpi_driver_data(device);
 166         unregister_serial(priv->line);
 167         if (priv->iomem_base)
 168                 iounmap(priv->iomem_base);
 169         kfree(priv);
 170
 171         return 0;
 172 }
 173
 174 static struct acpi_driver acpi_serial_driver = {
 175         .name =         "serial",
 176         .class =        "",
 177         .ids =          "PNP0501",
 178         .ops =  {
 179                 .add =          acpi_serial_add,
 180                 .remove =       acpi_serial_remove,
 181         },
 182 };
 183
 184 static int __init acpi_serial_init(void)
 185 {
 186         return acpi_bus_register_driver(&acpi_serial_driver);
 187 }
 188
 189 static void __exit acpi_serial_exit(void)
 190 {
 191         acpi_bus_unregister_driver(&acpi_serial_driver);
 192 }
 193
 194 module_init(acpi_serial_init);
 195 module_exit(acpi_serial_exit);
 196
 197 MODULE_LICENSE("GPL");
 198 MODULE_DESCRIPTION("Generic 8250/16x50 ACPI serial driver");