1 /*
2 * os.c - OS-dependent functions
3 *
4 * Copyright (C) 2000 Andrew Henroid
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 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include <linux/kernel.h>
22 #include <linux/types.h>
23 #include <linux/slab.h>
24 #include <linux/mm.h>
25 #include <linux/pci.h>
26 #include <linux/acpi.h>
27 #include <asm/io.h>
28 #include <asm/delay.h>
29 #include "acpi.h"
30 #include "driver.h"
31
32 #define _COMPONENT OS_DEPENDENT
33 MODULE_NAME ("os")
34
35 static int acpi_irq_irq = 0;
36 static OSD_HANDLER acpi_irq_handler = NULL;
37 static void *acpi_irq_context = NULL;
38
39 #ifdef ENABLE_DEBUGGER
40
41 #include <linux/kdb.h>
42
43 /* stuff for debugger support */
44 int acpi_in_debugger = 0;
45 extern NATIVE_CHAR line_buf[80];
46
47 #endif
48
49
50 ACPI_STATUS
51 acpi_os_initialize(void)
52 {
53 return AE_OK;
54 }
55
56 ACPI_STATUS
57 acpi_os_terminate(void)
58 {
59 if (acpi_irq_handler) {
60 acpi_os_remove_interrupt_handler(acpi_irq_irq,
61 acpi_irq_handler);
62 }
63 return AE_OK;
64 }
65
66 s32
67 acpi_os_printf(const NATIVE_CHAR *fmt,...)
68 {
69 s32 size;
70 va_list args;
71 va_start(args, fmt);
72 size = acpi_os_vprintf(fmt, args);
73 va_end(args);
74 return size;
75 }
76
77 s32
78 acpi_os_vprintf(const NATIVE_CHAR *fmt, va_list args)
79 {
80 static char buffer[512];
81 int size = vsprintf(buffer, fmt, args);
82
83 #ifdef ENABLE_DEBUGGER
84 if (acpi_in_debugger) {
85 kdb_printf("%s", buffer);
86 } else {
87 printk("%s", buffer);
88 }
89 #else
90 printk("%s", buffer);
91 #endif
92
93 return size;
94 }
95
96 void *
97 acpi_os_allocate(u32 size)
98 {
99 return kmalloc(size, GFP_KERNEL);
100 }
101
102 void *
103 acpi_os_callocate(u32 size)
104 {
105 void *ptr = acpi_os_allocate(size);
106 if (ptr)
107 memset(ptr, 0, size);
108 return ptr;
109 }
110
111 void
112 acpi_os_free(void *ptr)
113 {
114 kfree(ptr);
115 }
116
117 ACPI_STATUS
118 acpi_os_map_memory(ACPI_PHYSICAL_ADDRESS phys, u32 size, void **virt)
119 {
120 if (phys > ULONG_MAX) {
121 printk(KERN_ERR "ACPI: Cannot map memory that high\n");
122 return AE_ERROR;
123 }
124
125 if ((unsigned long) phys < virt_to_phys(high_memory)) {
126 *virt = phys_to_virt((unsigned long) phys);
127 return AE_OK;
128 }
129
130 *virt = ioremap((unsigned long) phys, size);
131 if (!*virt)
132 return AE_ERROR;
133
134 return AE_OK;
135 }
136
137 void
138 acpi_os_unmap_memory(void *virt, u32 size)
139 {
140 if (virt >= high_memory)
141 iounmap(virt);
142 }
143
144 static void
145 acpi_irq(int irq, void *dev_id, struct pt_regs *regs)
146 {
147 (*acpi_irq_handler)(acpi_irq_context);
148 }
149
150 ACPI_STATUS
151 acpi_os_install_interrupt_handler(u32 irq, OSD_HANDLER handler, void *context)
152 {
153 acpi_irq_irq = irq;
154 acpi_irq_handler = handler;
155 acpi_irq_context = context;
156 if (request_irq(irq,
157 acpi_irq,
158 SA_SHIRQ,
159 "acpi",
160 acpi_irq)) {
161 printk(KERN_ERR "ACPI: SCI (IRQ%d) allocation failed\n", irq);
162 return AE_ERROR;
163 }
164 return AE_OK;
165 }
166
167 ACPI_STATUS
168 acpi_os_remove_interrupt_handler(u32 irq, OSD_HANDLER handler)
169 {
170 if (acpi_irq_handler) {
171 free_irq(irq, acpi_irq);
172 acpi_irq_handler = NULL;
173 }
174 return AE_OK;
175 }
176
177 /*
178 * Running in interpreter thread context, safe to sleep
179 */
180
181 void
182 acpi_os_sleep(u32 sec, u32 ms)
183 {
184 current->state = TASK_INTERRUPTIBLE;
185 schedule_timeout(HZ * sec + (ms * HZ) / 1000);
186 }
187
188 void
189 acpi_os_sleep_usec(u32 us)
190 {
191 udelay(us);
192 }
193
194 u8
195 acpi_os_in8(ACPI_IO_ADDRESS port)
196 {
197 return inb(port);
198 }
199
200 u16
201 acpi_os_in16(ACPI_IO_ADDRESS port)
202 {
203 return inw(port);
204 }
205
206 u32
207 acpi_os_in32(ACPI_IO_ADDRESS port)
208 {
209 return inl(port);
210 }
211
212 void
213 acpi_os_out8(ACPI_IO_ADDRESS port, u8 val)
214 {
215 outb(val, port);
216 }
217
218 void
219 acpi_os_out16(ACPI_IO_ADDRESS port, u16 val)
220 {
221 outw(val, port);
222 }
223
224 void
225 acpi_os_out32(ACPI_IO_ADDRESS port, u32 val)
226 {
227 outl(val, port);
228 }
229
230 UINT8
231 acpi_os_mem_in8 (ACPI_PHYSICAL_ADDRESS phys_addr)
232 {
233 return (*(u8*) (u32) phys_addr);
234 }
235
236 UINT16
237 acpi_os_mem_in16 (ACPI_PHYSICAL_ADDRESS phys_addr)
238 {
239 return (*(u16*) (u32) phys_addr);
240 }
241
242 UINT32
243 acpi_os_mem_in32 (ACPI_PHYSICAL_ADDRESS phys_addr)
244 {
245 return (*(u32*) (u32) phys_addr);
246 }
247
248 void
249 acpi_os_mem_out8 (ACPI_PHYSICAL_ADDRESS phys_addr, UINT8 value)
250 {
251 *(u8*) (u32) phys_addr = value;
252 }
253
254 void
255 acpi_os_mem_out16 (ACPI_PHYSICAL_ADDRESS phys_addr, UINT16 value)
256 {
257 *(u16*) (u32) phys_addr = value;
258 }
259
260 void
261 acpi_os_mem_out32 (ACPI_PHYSICAL_ADDRESS phys_addr, UINT32 value)
262 {
263 *(u32*) (u32) phys_addr = value;
264 }
265
266 ACPI_STATUS
267 acpi_os_read_pci_cfg_byte(
268 u32 bus,
269 u32 func,
270 u32 addr,
271 u8 * val)
272 {
273 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
274 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
275 if (!val || !dev || pci_read_config_byte(dev, addr, val))
276 return AE_ERROR;
277 return AE_OK;
278 }
279
280 ACPI_STATUS
281 acpi_os_read_pci_cfg_word(
282 u32 bus,
283 u32 func,
284 u32 addr,
285 u16 * val)
286 {
287 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
288 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
289 if (!val || !dev || pci_read_config_word(dev, addr, val))
290 return AE_ERROR;
291 return AE_OK;
292 }
293
294 ACPI_STATUS
295 acpi_os_read_pci_cfg_dword(
296 u32 bus,
297 u32 func,
298 u32 addr,
299 u32 * val)
300 {
301 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
302 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
303 if (!val || !dev || pci_read_config_dword(dev, addr, val))
304 return AE_ERROR;
305 return AE_OK;
306 }
307
308 ACPI_STATUS
309 acpi_os_write_pci_cfg_byte(
310 u32 bus,
311 u32 func,
312 u32 addr,
313 u8 val)
314 {
315 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
316 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
317 if (!dev || pci_write_config_byte(dev, addr, val))
318 return AE_ERROR;
319 return AE_OK;
320 }
321
322 ACPI_STATUS
323 acpi_os_write_pci_cfg_word(
324 u32 bus,
325 u32 func,
326 u32 addr,
327 u16 val)
328 {
329 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
330 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
331 if (!dev || pci_write_config_word(dev, addr, val))
332 return AE_ERROR;
333 return AE_OK;
334 }
335
336 ACPI_STATUS
337 acpi_os_write_pci_cfg_dword(
338 u32 bus,
339 u32 func,
340 u32 addr,
341 u32 val)
342 {
343 int devfn = PCI_DEVFN((func >> 16) & 0xffff, func & 0xffff);
344 struct pci_dev *dev = pci_find_slot(bus & 0xffff, devfn);
345 if (!dev || pci_write_config_dword(dev, addr, val))
346 return AE_ERROR;
347 return AE_OK;
348 }
349
350 /*
351 * Queue for interpreter thread
352 */
353
354 ACPI_STATUS
355 acpi_os_queue_for_execution(
356 u32 priority,
357 OSD_EXECUTION_CALLBACK callback,
358 void *context)
359 {
360 if (acpi_run(callback, context))
361 return AE_ERROR;
362 return AE_OK;
363 }
364
365 /*
366 * Semaphores are unused, interpreter access is single threaded
367 */
368
369 ACPI_STATUS
370 acpi_os_create_semaphore(u32 max_units, u32 init, ACPI_HANDLE * handle)
371 {
372 /* a hack to fake out sems until we implement them */
373 *handle = (ACPI_HANDLE) handle;
374 return AE_OK;
375 }
376
377 ACPI_STATUS
378 acpi_os_delete_semaphore(ACPI_HANDLE handle)
379 {
380 return AE_OK;
381 }
382
383 ACPI_STATUS
384 acpi_os_wait_semaphore(ACPI_HANDLE handle, u32 units, u32 timeout)
385 {
386 return AE_OK;
387 }
388
389 ACPI_STATUS
390 acpi_os_signal_semaphore(ACPI_HANDLE handle, u32 units)
391 {
392 return AE_OK;
393 }
394
395 ACPI_STATUS
396 acpi_os_breakpoint(NATIVE_CHAR *msg)
397 {
398 acpi_os_printf("breakpoint: %s", msg);
399 return AE_OK;
400 }
401
402 void
403 acpi_os_dbg_trap(char *msg)
404 {
405 acpi_os_printf("trap: %s", msg);
406 }
407
408 void
409 acpi_os_dbg_assert(void *failure, void *file, u32 line, NATIVE_CHAR *msg)
410 {
411 acpi_os_printf("assert: %s", msg);
412 }
413
414 u32
415 acpi_os_get_line(NATIVE_CHAR *buffer)
416 {
417
418 #ifdef ENABLE_DEBUGGER
419 if (acpi_in_debugger) {
420 u32 chars;
421
422 kdb_read(buffer, sizeof(line_buf));
423
424 /* remove the CR kdb includes */
425 chars = strlen(buffer) - 1;
426 buffer[chars] = '\0';
427 }
428 #endif
429
430 return 0;
431 }
432
433 /*
434 * We just have to assume we're dealing with valid memory
435 */
436
437 BOOLEAN
438 acpi_os_readable(void *ptr, u32 len)
439 {
440 return 1;
441 }
442
443 BOOLEAN
444 acpi_os_writable(void *ptr, u32 len)
445 {
446 return 1;
447 }
448
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.