?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Kai Germaschewski: ISDN update (including Makefiles)
[davej-history.git] / drivers / acpi / resources / rsirq.c
blob28a3a5045c16dbd205e2f9bf25539133c3b3c6e9
1 /*******************************************************************************
2 *
3 * Module Name: rsirq - Acpi_rs_irq_resource,
4 * Acpi_rs_irq_stream
5 * Acpi_rs_extended_irq_resource
6 * Acpi_rs_extended_irq_stream
7 * $Revision: 11 $
8 *
9 ******************************************************************************/
10
11 /*
12 * Copyright (C) 2000 R. Byron Moore
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 */
28
29
30 #include "acpi.h"
31 #include "acresrc.h"
32
33 #define _COMPONENT RESOURCE_MANAGER
34 MODULE_NAME ("rsirq")
35
36
37 /*******************************************************************************
38 *
39 * FUNCTION: Acpi_rs_irq_resource
40 *
41 * PARAMETERS: Byte_stream_buffer - Pointer to the resource input byte
42 * stream
43 * Bytes_consumed - u32 pointer that is filled with
44 * the number of bytes consumed from
45 * the Byte_stream_buffer
46 * Output_buffer - Pointer to the user's return buffer
47 * Structure_size - u32 pointer that is filled with
48 * the number of bytes in the filled
49 * in structure
50 *
51 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
52 *
53 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
54 * structure pointed to by the Output_buffer. Return the
55 * number of bytes consumed from the byte stream.
56 *
57 ******************************************************************************/
58
59 ACPI_STATUS
60 acpi_rs_irq_resource (
61 u8 *byte_stream_buffer,
62 u32 *bytes_consumed,
63 u8 **output_buffer,
64 u32 *structure_size)
65 {
66 u8 *buffer = byte_stream_buffer;
67 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
68 u16 temp16 = 0;
69 u8 temp8 = 0;
70 u8 index;
71 u8 i;
72 u32 struct_size = sizeof (IRQ_RESOURCE) +
73 RESOURCE_LENGTH_NO_DATA;
74
75
76 /*
77 * The number of bytes consumed are contained in the descriptor
78 * (Bits:0-1)
79 */
80 temp8 = *buffer;
81 *bytes_consumed = (temp8 & 0x03) + 1;
82 output_struct->id = irq;
83
84 /*
85 * Point to the 16-bits of Bytes 1 and 2
86 */
87 buffer += 1;
88 MOVE_UNALIGNED16_TO_16 (&temp16, buffer);
89
90 output_struct->data.irq.number_of_interrupts = 0;
91
92 /* Decode the IRQ bits */
93
94 for (i = 0, index = 0; index < 16; index++) {
95 if((temp16 >> index) & 0x01) {
96 output_struct->data.irq.interrupts[i] = index;
97 i++;
98 }
99 }
100 output_struct->data.irq.number_of_interrupts = i;
101
102 /*
103 * Calculate the structure size based upon the number of interrupts
104 */
105 struct_size += (output_struct->data.irq.number_of_interrupts - 1) * 4;
106
107 /*
108 * Point to Byte 3 if it is used
109 */
110 if (4 == *bytes_consumed) {
111 buffer += 2;
112 temp8 = *buffer;
113
114 /*
115 * Check for HE, LL or HL
116 */
117 if (temp8 & 0x01) {
118 output_struct->data.irq.edge_level = EDGE_SENSITIVE;
119 output_struct->data.irq.active_high_low = ACTIVE_HIGH;
120 }
121
122 else {
123 if (temp8 & 0x8) {
124 output_struct->data.irq.edge_level = LEVEL_SENSITIVE;
125 output_struct->data.irq.active_high_low = ACTIVE_LOW;
126 }
127
128 else {
129 /*
130 * Only _LL and _HE polarity/trigger interrupts
131 * are allowed (ACPI spec v1.0b ection 6.4.2.1),
132 * so an error will occur if we reach this point
133 */
134 return (AE_BAD_DATA);
135 }
136 }
137
138 /*
139 * Check for sharable
140 */
141 output_struct->data.irq.shared_exclusive = (temp8 >> 3) & 0x01;
142 }
143
144 else {
145 /*
146 * Assume Edge Sensitive, Active High, Non-Sharable
147 * per ACPI Specification
148 */
149 output_struct->data.irq.edge_level = EDGE_SENSITIVE;
150 output_struct->data.irq.active_high_low = ACTIVE_HIGH;
151 output_struct->data.irq.shared_exclusive = EXCLUSIVE;
152 }
153
154 /*
155 * Set the Length parameter
156 */
157 output_struct->length = struct_size;
158
159 /*
160 * Return the final size of the structure
161 */
162 *structure_size = struct_size;
163
164 return (AE_OK);
165 }
166
167
168 /*******************************************************************************
169 *
170 * FUNCTION: Acpi_rs_irq_stream
171 *
172 * PARAMETERS: Linked_list - Pointer to the resource linked list
173 * Output_buffer - Pointer to the user's return buffer
174 * Bytes_consumed - u32 pointer that is filled with
175 * the number of bytes of the
176 * Output_buffer used
177 *
178 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
179 *
180 * DESCRIPTION: Take the linked list resource structure and fills in the
181 * the appropriate bytes in a byte stream
182 *
183 ******************************************************************************/
184
185 ACPI_STATUS
186 acpi_rs_irq_stream (
187 RESOURCE *linked_list,
188 u8 **output_buffer,
189 u32 *bytes_consumed)
190 {
191 u8 *buffer = *output_buffer;
192 u16 temp16 = 0;
193 u8 temp8 = 0;
194 u8 index;
195 u8 IRQinfo_byte_needed;
196
197
198 /*
199 * The descriptor field is set based upon whether a third byte is
200 * needed to contain the IRQ Information.
201 */
202 if (EDGE_SENSITIVE == linked_list->data.irq.edge_level &&
203 ACTIVE_HIGH == linked_list->data.irq.active_high_low &&
204 EXCLUSIVE == linked_list->data.irq.shared_exclusive)
205 {
206 *buffer = 0x22;
207 IRQinfo_byte_needed = FALSE;
208 }
209 else {
210 *buffer = 0x23;
211 IRQinfo_byte_needed = TRUE;
212 }
213
214 buffer += 1;
215 temp16 = 0;
216
217 /*
218 * Loop through all of the interrupts and set the mask bits
219 */
220 for(index = 0;
221 index < linked_list->data.irq.number_of_interrupts;
222 index++)
223 {
224 temp8 = (u8) linked_list->data.irq.interrupts[index];
225 temp16 |= 0x1 << temp8;
226 }
227
228 MOVE_UNALIGNED16_TO_16 (buffer, &temp16);
229 buffer += 2;
230
231 /*
232 * Set the IRQ Info byte if needed.
233 */
234 if (IRQinfo_byte_needed) {
235 temp8 = 0;
236 temp8 = (u8) ((linked_list->data.irq.shared_exclusive &
237 0x01) << 4);
238
239 if (LEVEL_SENSITIVE == linked_list->data.irq.edge_level &&
240 ACTIVE_LOW == linked_list->data.irq.active_high_low)
241 {
242 temp8 |= 0x08;
243 }
244
245 else {
246 temp8 |= 0x01;
247 }
248
249 *buffer = temp8;
250 buffer += 1;
251 }
252
253 /*
254 * Return the number of bytes consumed in this operation
255 */
256 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
257 (NATIVE_UINT) *output_buffer);
258
259 return (AE_OK);
260 }
261
262
263 /*******************************************************************************
264 *
265 * FUNCTION: Acpi_rs_extended_irq_resource
266 *
267 * PARAMETERS: Byte_stream_buffer - Pointer to the resource input byte
268 * stream
269 * Bytes_consumed - u32 pointer that is filled with
270 * the number of bytes consumed from
271 * the Byte_stream_buffer
272 * Output_buffer - Pointer to the user's return buffer
273 * Structure_size - u32 pointer that is filled with
274 * the number of bytes in the filled
275 * in structure
276 *
277 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
278 *
279 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
280 * structure pointed to by the Output_buffer. Return the
281 * number of bytes consumed from the byte stream.
282 *
283 ******************************************************************************/
284
285 ACPI_STATUS
286 acpi_rs_extended_irq_resource (
287 u8 *byte_stream_buffer,
288 u32 *bytes_consumed,
289 u8 **output_buffer,
290 u32 *structure_size)
291 {
292 u8 *buffer = byte_stream_buffer;
293 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
294 u16 temp16 = 0;
295 u8 temp8 = 0;
296 u8 index;
297 u32 struct_size = sizeof (EXTENDED_IRQ_RESOURCE) +
298 RESOURCE_LENGTH_NO_DATA;
299
300
301 /*
302 * Point past the Descriptor to get the number of bytes consumed
303 */
304 buffer += 1;
305 MOVE_UNALIGNED16_TO_16 (&temp16, buffer);
306
307 *bytes_consumed = temp16 + 3;
308 output_struct->id = extended_irq;
309
310 /*
311 * Point to the Byte3
312 */
313 buffer += 2;
314 temp8 = *buffer;
315
316 output_struct->data.extended_irq.producer_consumer = temp8 & 0x01;
317
318 /*
319 * Check for HE, LL or HL
320 */
321 if(temp8 & 0x02) {
322 output_struct->data.extended_irq.edge_level = EDGE_SENSITIVE;
323 output_struct->data.extended_irq.active_high_low = ACTIVE_HIGH;
324 }
325
326 else {
327 if(temp8 & 0x4) {
328 output_struct->data.extended_irq.edge_level = LEVEL_SENSITIVE;
329 output_struct->data.extended_irq.active_high_low = ACTIVE_LOW;
330 }
331
332 else {
333 /*
334 * Only _LL and _HE polarity/trigger interrupts
335 * are allowed (ACPI spec v1.0b ection 6.4.2.1),
336 * so an error will occur if we reach this point
337 */
338 return (AE_BAD_DATA);
339 }
340 }
341
342 /*
343 * Check for sharable
344 */
345 output_struct->data.extended_irq.shared_exclusive =
346 (temp8 >> 3) & 0x01;
347
348 /*
349 * Point to Byte4 (IRQ Table length)
350 */
351 buffer += 1;
352 temp8 = *buffer;
353
354 output_struct->data.extended_irq.number_of_interrupts = temp8;
355
356 /*
357 * Add any additional structure size to properly calculate
358 * the next pointer at the end of this function
359 */
360 struct_size += (temp8 - 1) * 4;
361
362 /*
363 * Point to Byte5 (First IRQ Number)
364 */
365 buffer += 1;
366
367 /*
368 * Cycle through every IRQ in the table
369 */
370 for (index = 0; index < temp8; index++) {
371 output_struct->data.extended_irq.interrupts[index] =
372 (u32)*buffer;
373
374 /* Point to the next IRQ */
375
376 buffer += 4;
377 }
378
379 /*
380 * This will leave us pointing to the Resource Source Index
381 * If it is present, then save it off and calculate the
382 * pointer to where the null terminated string goes:
383 * Each Interrupt takes 32-bits + the 5 bytes of the
384 * stream that are default.
385 */
386 if (*bytes_consumed >
387 (u32)(output_struct->data.extended_irq.number_of_interrupts *
388 4) + 5)
389 {
390 /* Dereference the Index */
391
392 temp8 = *buffer;
393 output_struct->data.extended_irq.resource_source_index =
394 (u32)temp8;
395
396 /* Point to the String */
397
398 buffer += 1;
399
400 /* Copy the string into the buffer */
401
402 index = 0;
403
404 while (0x00 != *buffer) {
405 output_struct->data.extended_irq.resource_source[index] =
406 *buffer;
407
408 buffer += 1;
409 index += 1;
410 }
411
412 /*
413 * Add the terminating null
414 */
415 output_struct->data.extended_irq.resource_source[index] = 0x00;
416 output_struct->data.extended_irq.resource_source_string_length =
417 index + 1;
418
419 /*
420 * In order for the Struct_size to fall on a 32-bit boundry,
421 * calculate the length of the string and expand the
422 * Struct_size to the next 32-bit boundry.
423 */
424 temp8 = (u8) (index + 1);
425 temp8 = (u8) ROUND_UP_TO_32_bITS (temp8);
426 }
427
428 else {
429 output_struct->data.extended_irq.resource_source_index = 0x00;
430 output_struct->data.extended_irq.resource_source_string_length = 0;
431 output_struct->data.extended_irq.resource_source[0] = 0x00;
432 }
433
434 /*
435 * Set the Length parameter
436 */
437 output_struct->length = struct_size;
438
439 /*
440 * Return the final size of the structure
441 */
442 *structure_size = struct_size;
443
444 return (AE_OK);
445 }
446
447
448 /*******************************************************************************
449 *
450 * FUNCTION: Acpi_rs_extended_irq_stream
451 *
452 * PARAMETERS: Linked_list - Pointer to the resource linked list
453 * Output_buffer - Pointer to the user's return buffer
454 * Bytes_consumed - u32 pointer that is filled with
455 * the number of bytes of the
456 * Output_buffer used
457 *
458 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
459 *
460 * DESCRIPTION: Take the linked list resource structure and fills in the
461 * the appropriate bytes in a byte stream
462 *
463 ******************************************************************************/
464
465 ACPI_STATUS
466 acpi_rs_extended_irq_stream (
467 RESOURCE *linked_list,
468 u8 **output_buffer,
469 u32 *bytes_consumed)
470 {
471 u8 *buffer = *output_buffer;
472 u16 *length_field;
473 u8 temp8 = 0;
474 u8 index;
475 NATIVE_CHAR *temp_pointer = NULL;
476
477
478 /*
479 * The descriptor field is static
480 */
481 *buffer = 0x89;
482 buffer += 1;
483
484 /*
485 * Set a pointer to the Length field - to be filled in later
486 */
487
488 length_field = (u16 *)buffer;
489 buffer += 2;
490
491 /*
492 * Set the Interrupt vector flags
493 */
494 temp8 = (u8)(linked_list->data.extended_irq.producer_consumer & 0x01);
495
496 temp8 |= ((linked_list->data.extended_irq.shared_exclusive & 0x01) << 3);
497
498 if (LEVEL_SENSITIVE == linked_list->data.extended_irq.edge_level &&
499 ACTIVE_LOW == linked_list->data.extended_irq.active_high_low)
500 {
501 temp8 |= 0x04;
502 }
503 else {
504 temp8 |= 0x02;
505 }
506
507 *buffer = temp8;
508 buffer += 1;
509
510 /*
511 * Set the Interrupt table length
512 */
513 temp8 = (u8) linked_list->data.extended_irq.number_of_interrupts;
514
515 *buffer = temp8;
516 buffer += 1;
517
518 for (index = 0;
519 index < linked_list->data.extended_irq.number_of_interrupts;
520 index++)
521 {
522 MOVE_UNALIGNED32_TO_32 (buffer,
523 &linked_list->data.extended_irq.interrupts[index]);
524 buffer += 4;
525 }
526
527 /*
528 * Resource Source Index and Resource Source are optional
529 */
530 if (0 != linked_list->data.extended_irq.resource_source_string_length) {
531 *buffer = (u8) linked_list->data.extended_irq.resource_source_index;
532 buffer += 1;
533
534 temp_pointer = (NATIVE_CHAR *) buffer;
535
536 /*
537 * Copy the string
538 */
539 STRCPY (temp_pointer, linked_list->data.extended_irq.resource_source);
540
541 /*
542 * Buffer needs to be set to the length of the sting + one for the
543 * terminating null
544 */
545 buffer += (STRLEN (linked_list->data.extended_irq.resource_source) + 1);
546 }
547
548 /*
549 * Return the number of bytes consumed in this operation
550 */
551 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
552 (NATIVE_UINT) *output_buffer);
553
554 /*
555 * Set the length field to the number of bytes consumed
556 * minus the header size (3 bytes)
557 */
558 *length_field = (u16) (*bytes_consumed - 3);
559
560 return (AE_OK);
561 }
562
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux