[ACPI] Disable EC burst mode w/o disabling EC interrupts
[linux-2.6] / drivers / acpi / resources / rsio.c
1 /*******************************************************************************
2  *
3  * Module Name: rsio - IO and DMA resource descriptors
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2005, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acresrc.h>
46
47 #define _COMPONENT          ACPI_RESOURCES
48 ACPI_MODULE_NAME("rsio")
49
50 /*******************************************************************************
51  *
52  * FUNCTION:    acpi_rs_io_resource
53  *
54  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
55  *                                        stream
56  *              bytes_consumed          - Pointer to where the number of bytes
57  *                                        consumed the byte_stream_buffer is
58  *                                        returned
59  *              output_buffer           - Pointer to the return data buffer
60  *              structure_size          - Pointer to where the number of bytes
61  *                                        in the return data struct is returned
62  *
63  * RETURN:      Status
64  *
65  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
66  *              structure pointed to by the output_buffer. Return the
67  *              number of bytes consumed from the byte stream.
68  *
69  ******************************************************************************/
70 acpi_status
71 acpi_rs_io_resource(u8 * byte_stream_buffer,
72                     acpi_size * bytes_consumed,
73                     u8 ** output_buffer, acpi_size * structure_size)
74 {
75         u8 *buffer = byte_stream_buffer;
76         struct acpi_resource *output_struct = (void *)*output_buffer;
77         u16 temp16 = 0;
78         u8 temp8 = 0;
79         acpi_size struct_size = ACPI_SIZEOF_RESOURCE(struct acpi_resource_io);
80
81         ACPI_FUNCTION_TRACE("rs_io_resource");
82
83         /* The number of bytes consumed are Constant */
84
85         *bytes_consumed = 8;
86
87         output_struct->id = ACPI_RSTYPE_IO;
88
89         /* Check Decode */
90
91         buffer += 1;
92         temp8 = *buffer;
93
94         output_struct->data.io.io_decode = temp8 & 0x01;
95
96         /* Check min_base Address */
97
98         buffer += 1;
99         ACPI_MOVE_16_TO_16(&temp16, buffer);
100
101         output_struct->data.io.min_base_address = temp16;
102
103         /* Check max_base Address */
104
105         buffer += 2;
106         ACPI_MOVE_16_TO_16(&temp16, buffer);
107
108         output_struct->data.io.max_base_address = temp16;
109
110         /* Check Base alignment */
111
112         buffer += 2;
113         temp8 = *buffer;
114
115         output_struct->data.io.alignment = temp8;
116
117         /* Check range_length */
118
119         buffer += 1;
120         temp8 = *buffer;
121
122         output_struct->data.io.range_length = temp8;
123
124         /* Set the Length parameter */
125
126         output_struct->length = (u32) struct_size;
127
128         /* Return the final size of the structure */
129
130         *structure_size = struct_size;
131         return_ACPI_STATUS(AE_OK);
132 }
133
134 /*******************************************************************************
135  *
136  * FUNCTION:    acpi_rs_fixed_io_resource
137  *
138  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
139  *                                        stream
140  *              bytes_consumed          - Pointer to where the number of bytes
141  *                                        consumed the byte_stream_buffer is
142  *                                        returned
143  *              output_buffer           - Pointer to the return data buffer
144  *              structure_size          - Pointer to where the number of bytes
145  *                                        in the return data struct is returned
146  *
147  * RETURN:      Status
148  *
149  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
150  *              structure pointed to by the output_buffer. Return the
151  *              number of bytes consumed from the byte stream.
152  *
153  ******************************************************************************/
154
155 acpi_status
156 acpi_rs_fixed_io_resource(u8 * byte_stream_buffer,
157                           acpi_size * bytes_consumed,
158                           u8 ** output_buffer, acpi_size * structure_size)
159 {
160         u8 *buffer = byte_stream_buffer;
161         struct acpi_resource *output_struct = (void *)*output_buffer;
162         u16 temp16 = 0;
163         u8 temp8 = 0;
164         acpi_size struct_size =
165             ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io);
166
167         ACPI_FUNCTION_TRACE("rs_fixed_io_resource");
168
169         /* The number of bytes consumed are Constant */
170
171         *bytes_consumed = 4;
172
173         output_struct->id = ACPI_RSTYPE_FIXED_IO;
174
175         /* Check Range Base Address */
176
177         buffer += 1;
178         ACPI_MOVE_16_TO_16(&temp16, buffer);
179
180         output_struct->data.fixed_io.base_address = temp16;
181
182         /* Check range_length */
183
184         buffer += 2;
185         temp8 = *buffer;
186
187         output_struct->data.fixed_io.range_length = temp8;
188
189         /* Set the Length parameter */
190
191         output_struct->length = (u32) struct_size;
192
193         /* Return the final size of the structure */
194
195         *structure_size = struct_size;
196         return_ACPI_STATUS(AE_OK);
197 }
198
199 /*******************************************************************************
200  *
201  * FUNCTION:    acpi_rs_io_stream
202  *
203  * PARAMETERS:  linked_list             - Pointer to the resource linked list
204  *              output_buffer           - Pointer to the user's return buffer
205  *              bytes_consumed          - Pointer to where the number of bytes
206  *                                        used in the output_buffer is returned
207  *
208  * RETURN:      Status
209  *
210  * DESCRIPTION: Take the linked list resource structure and fills in the
211  *              the appropriate bytes in a byte stream
212  *
213  ******************************************************************************/
214
215 acpi_status
216 acpi_rs_io_stream(struct acpi_resource *linked_list,
217                   u8 ** output_buffer, acpi_size * bytes_consumed)
218 {
219         u8 *buffer = *output_buffer;
220         u16 temp16 = 0;
221         u8 temp8 = 0;
222
223         ACPI_FUNCTION_TRACE("rs_io_stream");
224
225         /* The descriptor field is static */
226
227         *buffer = 0x47;
228         buffer += 1;
229
230         /* Io Information Byte */
231
232         temp8 = (u8) (linked_list->data.io.io_decode & 0x01);
233
234         *buffer = temp8;
235         buffer += 1;
236
237         /* Set the Range minimum base address */
238
239         temp16 = (u16) linked_list->data.io.min_base_address;
240
241         ACPI_MOVE_16_TO_16(buffer, &temp16);
242         buffer += 2;
243
244         /* Set the Range maximum base address */
245
246         temp16 = (u16) linked_list->data.io.max_base_address;
247
248         ACPI_MOVE_16_TO_16(buffer, &temp16);
249         buffer += 2;
250
251         /* Set the base alignment */
252
253         temp8 = (u8) linked_list->data.io.alignment;
254
255         *buffer = temp8;
256         buffer += 1;
257
258         /* Set the range length */
259
260         temp8 = (u8) linked_list->data.io.range_length;
261
262         *buffer = temp8;
263         buffer += 1;
264
265         /* Return the number of bytes consumed in this operation */
266
267         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
268         return_ACPI_STATUS(AE_OK);
269 }
270
271 /*******************************************************************************
272  *
273  * FUNCTION:    acpi_rs_fixed_io_stream
274  *
275  * PARAMETERS:  linked_list             - Pointer to the resource linked list
276  *              output_buffer           - Pointer to the user's return buffer
277  *              bytes_consumed          - Pointer to where the number of bytes
278  *                                        used in the output_buffer is returned
279  *
280  * RETURN:      Status
281  *
282  * DESCRIPTION: Take the linked list resource structure and fills in the
283  *              the appropriate bytes in a byte stream
284  *
285  ******************************************************************************/
286
287 acpi_status
288 acpi_rs_fixed_io_stream(struct acpi_resource *linked_list,
289                         u8 ** output_buffer, acpi_size * bytes_consumed)
290 {
291         u8 *buffer = *output_buffer;
292         u16 temp16 = 0;
293         u8 temp8 = 0;
294
295         ACPI_FUNCTION_TRACE("rs_fixed_io_stream");
296
297         /* The descriptor field is static */
298
299         *buffer = 0x4B;
300
301         buffer += 1;
302
303         /* Set the Range base address */
304
305         temp16 = (u16) linked_list->data.fixed_io.base_address;
306
307         ACPI_MOVE_16_TO_16(buffer, &temp16);
308         buffer += 2;
309
310         /* Set the range length */
311
312         temp8 = (u8) linked_list->data.fixed_io.range_length;
313
314         *buffer = temp8;
315         buffer += 1;
316
317         /* Return the number of bytes consumed in this operation */
318
319         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
320         return_ACPI_STATUS(AE_OK);
321 }
322
323 /*******************************************************************************
324  *
325  * FUNCTION:    acpi_rs_dma_resource
326  *
327  * PARAMETERS:  byte_stream_buffer      - Pointer to the resource input byte
328  *                                        stream
329  *              bytes_consumed          - Pointer to where the number of bytes
330  *                                        consumed the byte_stream_buffer is
331  *                                        returned
332  *              output_buffer           - Pointer to the return data buffer
333  *              structure_size          - Pointer to where the number of bytes
334  *                                        in the return data struct is returned
335  *
336  * RETURN:      Status
337  *
338  * DESCRIPTION: Take the resource byte stream and fill out the appropriate
339  *              structure pointed to by the output_buffer. Return the
340  *              number of bytes consumed from the byte stream.
341  *
342  ******************************************************************************/
343
344 acpi_status
345 acpi_rs_dma_resource(u8 * byte_stream_buffer,
346                      acpi_size * bytes_consumed,
347                      u8 ** output_buffer, acpi_size * structure_size)
348 {
349         u8 *buffer = byte_stream_buffer;
350         struct acpi_resource *output_struct = (void *)*output_buffer;
351         u8 temp8 = 0;
352         u8 index;
353         u8 i;
354         acpi_size struct_size = ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma);
355
356         ACPI_FUNCTION_TRACE("rs_dma_resource");
357
358         /* The number of bytes consumed are Constant */
359
360         *bytes_consumed = 3;
361         output_struct->id = ACPI_RSTYPE_DMA;
362
363         /* Point to the 8-bits of Byte 1 */
364
365         buffer += 1;
366         temp8 = *buffer;
367
368         /* Decode the DMA channel bits */
369
370         for (i = 0, index = 0; index < 8; index++) {
371                 if ((temp8 >> index) & 0x01) {
372                         output_struct->data.dma.channels[i] = index;
373                         i++;
374                 }
375         }
376
377         /* Zero DMA channels is valid */
378
379         output_struct->data.dma.number_of_channels = i;
380         if (i > 0) {
381                 /* Calculate the structure size based upon the number of interrupts */
382
383                 struct_size += ((acpi_size) i - 1) * 4;
384         }
385
386         /* Point to Byte 2 */
387
388         buffer += 1;
389         temp8 = *buffer;
390
391         /* Check for transfer preference (Bits[1:0]) */
392
393         output_struct->data.dma.transfer = temp8 & 0x03;
394
395         if (0x03 == output_struct->data.dma.transfer) {
396                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
397                                   "Invalid DMA.Transfer preference (3)\n"));
398                 return_ACPI_STATUS(AE_BAD_DATA);
399         }
400
401         /* Get bus master preference (Bit[2]) */
402
403         output_struct->data.dma.bus_master = (temp8 >> 2) & 0x01;
404
405         /* Get channel speed support (Bits[6:5]) */
406
407         output_struct->data.dma.type = (temp8 >> 5) & 0x03;
408
409         /* Set the Length parameter */
410
411         output_struct->length = (u32) struct_size;
412
413         /* Return the final size of the structure */
414
415         *structure_size = struct_size;
416         return_ACPI_STATUS(AE_OK);
417 }
418
419 /*******************************************************************************
420  *
421  * FUNCTION:    acpi_rs_dma_stream
422  *
423  * PARAMETERS:  linked_list             - Pointer to the resource linked list
424  *              output_buffer           - Pointer to the user's return buffer
425  *              bytes_consumed          - Pointer to where the number of bytes
426  *                                        used in the output_buffer is returned
427  *
428  * RETURN:      Status
429  *
430  * DESCRIPTION: Take the linked list resource structure and fills in the
431  *              the appropriate bytes in a byte stream
432  *
433  ******************************************************************************/
434
435 acpi_status
436 acpi_rs_dma_stream(struct acpi_resource *linked_list,
437                    u8 ** output_buffer, acpi_size * bytes_consumed)
438 {
439         u8 *buffer = *output_buffer;
440         u16 temp16 = 0;
441         u8 temp8 = 0;
442         u8 index;
443
444         ACPI_FUNCTION_TRACE("rs_dma_stream");
445
446         /* The descriptor field is static */
447
448         *buffer = 0x2A;
449         buffer += 1;
450         temp8 = 0;
451
452         /* Loop through all of the Channels and set the mask bits */
453
454         for (index = 0;
455              index < linked_list->data.dma.number_of_channels; index++) {
456                 temp16 = (u16) linked_list->data.dma.channels[index];
457                 temp8 |= 0x1 << temp16;
458         }
459
460         *buffer = temp8;
461         buffer += 1;
462
463         /* Set the DMA Info */
464
465         temp8 = (u8) ((linked_list->data.dma.type & 0x03) << 5);
466         temp8 |= ((linked_list->data.dma.bus_master & 0x01) << 2);
467         temp8 |= (linked_list->data.dma.transfer & 0x03);
468
469         *buffer = temp8;
470         buffer += 1;
471
472         /* Return the number of bytes consumed in this operation */
473
474         *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
475         return_ACPI_STATUS(AE_OK);
476 }