Merge linux-2.6 into linux-acpi-2.6 test
[linux-2.6-microblaze.git] / 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/serial_core.h>
16
17 #include <acpi/acpi_bus.h>
18
19 #include <asm/io.h>
20
21 #include "8250.h"
22
23 struct serial_private {
24         int     line;
25 };
26
27 static acpi_status acpi_serial_mmio(struct uart_port *port,
28                                     struct acpi_resource_address64 *addr)
29 {
30         port->mapbase = addr->min_address_range;
31         port->iotype = UPIO_MEM;
32         port->flags |= UPF_IOREMAP;
33         return AE_OK;
34 }
35
36 static acpi_status acpi_serial_port(struct uart_port *port,
37                                     struct acpi_resource_io *io)
38 {
39         if (io->range_length) {
40                 port->iobase = io->min_base_address;
41                 port->iotype = UPIO_PORT;
42         } else
43                 printk(KERN_ERR "%s: zero-length IO port range?\n", __FUNCTION__);
44         return AE_OK;
45 }
46
47 static acpi_status acpi_serial_ext_irq(struct uart_port *port,
48                                        struct acpi_resource_ext_irq *ext_irq)
49 {
50         int rc;
51
52         if (ext_irq->number_of_interrupts > 0) {
53                 rc = acpi_register_gsi(ext_irq->interrupts[0],
54                            ext_irq->edge_level, ext_irq->active_high_low);
55                 if (rc < 0)
56                         return AE_ERROR;
57                 port->irq = rc;
58         }
59         return AE_OK;
60 }
61
62 static acpi_status acpi_serial_irq(struct uart_port *port,
63                                    struct acpi_resource_irq *irq)
64 {
65         int rc;
66
67         if (irq->number_of_interrupts > 0) {
68                 rc = acpi_register_gsi(irq->interrupts[0],
69                            irq->edge_level, irq->active_high_low);
70                 if (rc < 0)
71                         return AE_ERROR;
72                 port->irq = rc;
73         }
74         return AE_OK;
75 }
76
77 static acpi_status acpi_serial_resource(struct acpi_resource *res, void *data)
78 {
79         struct uart_port *port = (struct uart_port *) data;
80         struct acpi_resource_address64 addr;
81         acpi_status status;
82
83         status = acpi_resource_to_address64(res, &addr);
84         if (ACPI_SUCCESS(status))
85                 return acpi_serial_mmio(port, &addr);
86         else if (res->id == ACPI_RSTYPE_IO)
87                 return acpi_serial_port(port, &res->data.io);
88         else if (res->id == ACPI_RSTYPE_EXT_IRQ)
89                 return acpi_serial_ext_irq(port, &res->data.extended_irq);
90         else if (res->id == ACPI_RSTYPE_IRQ)
91                 return acpi_serial_irq(port, &res->data.irq);
92         return AE_OK;
93 }
94
95 static int acpi_serial_add(struct acpi_device *device)
96 {
97         struct serial_private *priv;
98         acpi_status status;
99         struct uart_port port;
100         int result;
101
102         memset(&port, 0, sizeof(struct uart_port));
103
104         port.uartclk = 1843200;
105         port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
106
107         priv = kmalloc(sizeof(struct serial_private), GFP_KERNEL);
108         if (!priv) {
109                 result = -ENOMEM;
110                 goto fail;
111         }
112         memset(priv, 0, sizeof(*priv));
113
114         status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
115                                      acpi_serial_resource, &port);
116         if (ACPI_FAILURE(status)) {
117                 result = -ENODEV;
118                 goto fail;
119         }
120
121         if (!port.mapbase && !port.iobase) {
122                 printk(KERN_ERR "%s: no iomem or port address in %s _CRS\n",
123                         __FUNCTION__, device->pnp.bus_id);
124                 result = -ENODEV;
125                 goto fail;
126         }
127
128         priv->line = serial8250_register_port(&port);
129         if (priv->line < 0) {
130                 printk(KERN_WARNING "Couldn't register serial port %s: %d\n",
131                         device->pnp.bus_id, priv->line);
132                 result = -ENODEV;
133                 goto fail;
134         }
135
136         acpi_driver_data(device) = priv;
137         return 0;
138
139 fail:
140         kfree(priv);
141
142         return result;
143 }
144
145 static int acpi_serial_remove(struct acpi_device *device, int type)
146 {
147         struct serial_private *priv;
148
149         if (!device || !acpi_driver_data(device))
150                 return -EINVAL;
151
152         priv = acpi_driver_data(device);
153         serial8250_unregister_port(priv->line);
154         kfree(priv);
155
156         return 0;
157 }
158
159 static struct acpi_driver acpi_serial_driver = {
160         .name =         "serial",
161         .class =        "",
162         .ids =          "PNP0501",
163         .ops =  {
164                 .add =          acpi_serial_add,
165                 .remove =       acpi_serial_remove,
166         },
167 };
168
169 static int __init acpi_serial_init(void)
170 {
171         return acpi_bus_register_driver(&acpi_serial_driver);
172 }
173
174 static void __exit acpi_serial_exit(void)
175 {
176         acpi_bus_unregister_driver(&acpi_serial_driver);
177 }
178
179 module_init(acpi_serial_init);
180 module_exit(acpi_serial_exit);
181
182 MODULE_LICENSE("GPL");
183 MODULE_DESCRIPTION("Generic 8250/16x50 ACPI serial driver");