[IA64] fix SBA IOMMU to handle allocation failure properly
[linux-2.6.git] / arch / ia64 / hp / common / aml_nfw.c
1 /*
2  * OpRegion handler to allow AML to call native firmware
3  *
4  * (c) Copyright 2007 Hewlett-Packard Development Company, L.P.
5  *      Bjorn Helgaas <bjorn.helgaas@hp.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This driver implements HP Open Source Review Board proposal 1842,
12  * which was approved on 9/20/2006.
13  *
14  * For technical documentation, see the HP SPPA Firmware EAS, Appendix F.
15  *
16  * ACPI does not define a mechanism for AML methods to call native firmware
17  * interfaces such as PAL or SAL.  This OpRegion handler adds such a mechanism.
18  * After the handler is installed, an AML method can call native firmware by
19  * storing the arguments and firmware entry point to specific offsets in the
20  * OpRegion.  When AML reads the "return value" offset from the OpRegion, this
21  * handler loads up the arguments, makes the firmware call, and returns the
22  * result.
23  */
24
25 #include <linux/module.h>
26 #include <acpi/acpi_bus.h>
27 #include <acpi/acpi_drivers.h>
28 #include <asm/sal.h>
29
30 MODULE_AUTHOR("Bjorn Helgaas <bjorn.helgaas@hp.com>");
31 MODULE_LICENSE("GPL");
32 MODULE_DESCRIPTION("ACPI opregion handler for native firmware calls");
33
34 static int force_register;
35 module_param_named(force, force_register, bool, 0);
36 MODULE_PARM_DESC(force, "Install opregion handler even without HPQ5001 device");
37
38 #define AML_NFW_SPACE           0xA1
39
40 struct ia64_pdesc {
41         void *ip;
42         void *gp;
43 };
44
45 /*
46  * N.B.  The layout of this structure is defined in the HP SPPA FW EAS, and
47  *       the member offsets are embedded in AML methods.
48  */
49 struct ia64_nfw_context {
50         u64 arg[8];
51         struct ia64_sal_retval ret;
52         u64 ip;
53         u64 gp;
54         u64 pad[2];
55 };
56
57 static void *virt_map(u64 address)
58 {
59         if (address & (1UL << 63))
60                 return (void *) (__IA64_UNCACHED_OFFSET | address);
61
62         return __va(address);
63 }
64
65 static void aml_nfw_execute(struct ia64_nfw_context *c)
66 {
67         struct ia64_pdesc virt_entry;
68         ia64_sal_handler entry;
69
70         virt_entry.ip = virt_map(c->ip);
71         virt_entry.gp = virt_map(c->gp);
72
73         entry = (ia64_sal_handler) &virt_entry;
74
75         IA64_FW_CALL(entry, c->ret,
76                      c->arg[0], c->arg[1], c->arg[2], c->arg[3],
77                      c->arg[4], c->arg[5], c->arg[6], c->arg[7]);
78 }
79
80 static void aml_nfw_read_arg(u8 *offset, u32 bit_width, acpi_integer *value)
81 {
82         switch (bit_width) {
83         case 8:
84                 *value = *(u8 *)offset;
85                 break;
86         case 16:
87                 *value = *(u16 *)offset;
88                 break;
89         case 32:
90                 *value = *(u32 *)offset;
91                 break;
92         case 64:
93                 *value = *(u64 *)offset;
94                 break;
95         }
96 }
97
98 static void aml_nfw_write_arg(u8 *offset, u32 bit_width, acpi_integer *value)
99 {
100         switch (bit_width) {
101         case 8:
102                 *(u8 *) offset = *value;
103                 break;
104         case 16:
105                 *(u16 *) offset = *value;
106                 break;
107         case 32:
108                 *(u32 *) offset = *value;
109                 break;
110         case 64:
111                 *(u64 *) offset = *value;
112                 break;
113         }
114 }
115
116 static acpi_status aml_nfw_handler(u32 function, acpi_physical_address address,
117         u32 bit_width, acpi_integer *value, void *handler_context,
118         void *region_context)
119 {
120         struct ia64_nfw_context *context = handler_context;
121         u8 *offset = (u8 *) context + address;
122
123         if (bit_width !=  8 && bit_width != 16 &&
124             bit_width != 32 && bit_width != 64)
125                 return AE_BAD_PARAMETER;
126
127         if (address + (bit_width >> 3) > sizeof(struct ia64_nfw_context))
128                 return AE_BAD_PARAMETER;
129
130         switch (function) {
131         case ACPI_READ:
132                 if (address == offsetof(struct ia64_nfw_context, ret))
133                         aml_nfw_execute(context);
134                 aml_nfw_read_arg(offset, bit_width, value);
135                 break;
136         case ACPI_WRITE:
137                 aml_nfw_write_arg(offset, bit_width, value);
138                 break;
139         }
140
141         return AE_OK;
142 }
143
144 static struct ia64_nfw_context global_context;
145 static int global_handler_registered;
146
147 static int aml_nfw_add_global_handler(void)
148 {
149         acpi_status status;
150
151         if (global_handler_registered)
152                 return 0;
153
154         status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
155                 AML_NFW_SPACE, aml_nfw_handler, NULL, &global_context);
156         if (ACPI_FAILURE(status))
157                 return -ENODEV;
158
159         global_handler_registered = 1;
160         printk(KERN_INFO "Global 0x%02X opregion handler registered\n",
161                 AML_NFW_SPACE);
162         return 0;
163 }
164
165 static int aml_nfw_remove_global_handler(void)
166 {
167         acpi_status status;
168
169         if (!global_handler_registered)
170                 return 0;
171
172         status = acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
173                 AML_NFW_SPACE, aml_nfw_handler);
174         if (ACPI_FAILURE(status))
175                 return -ENODEV;
176
177         global_handler_registered = 0;
178         printk(KERN_INFO "Global 0x%02X opregion handler removed\n",
179                 AML_NFW_SPACE);
180         return 0;
181 }
182
183 static int aml_nfw_add(struct acpi_device *device)
184 {
185         /*
186          * We would normally allocate a new context structure and install
187          * the address space handler for the specific device we found.
188          * But the HP-UX implementation shares a single global context
189          * and always puts the handler at the root, so we'll do the same.
190          */
191         return aml_nfw_add_global_handler();
192 }
193
194 static int aml_nfw_remove(struct acpi_device *device, int type)
195 {
196         return aml_nfw_remove_global_handler();
197 }
198
199 static const struct acpi_device_id aml_nfw_ids[] = {
200         {"HPQ5001", 0},
201         {"", 0}
202 };
203
204 static struct acpi_driver acpi_aml_nfw_driver = {
205         .name = "native firmware",
206         .ids = aml_nfw_ids,
207         .ops = {
208                 .add = aml_nfw_add,
209                 .remove = aml_nfw_remove,
210                 },
211 };
212
213 static int __init aml_nfw_init(void)
214 {
215         int result;
216
217         if (force_register)
218                 aml_nfw_add_global_handler();
219
220         result = acpi_bus_register_driver(&acpi_aml_nfw_driver);
221         if (result < 0) {
222                 aml_nfw_remove_global_handler();
223                 return result;
224         }
225
226         return 0;
227 }
228
229 static void __exit aml_nfw_exit(void)
230 {
231         acpi_bus_unregister_driver(&acpi_aml_nfw_driver);
232         aml_nfw_remove_global_handler();
233 }
234
235 module_init(aml_nfw_init);
236 module_exit(aml_nfw_exit);