1/*******************************************************************************
2 *
3 * Module Name: rsdump - AML debugger support for resource structures.
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, Intel Corp.
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 "accommon.h"
46#include "acresrc.h"
47
48#define _COMPONENT          ACPI_RESOURCES
49ACPI_MODULE_NAME("rsdump")
50
51/*
52 * All functions in this module are used by the AML Debugger only
53 */
54/* Local prototypes */
55static void acpi_rs_out_string(char *title, char *value);
56
57static void acpi_rs_out_integer8(char *title, u8 value);
58
59static void acpi_rs_out_integer16(char *title, u16 value);
60
61static void acpi_rs_out_integer32(char *title, u32 value);
62
63static void acpi_rs_out_integer64(char *title, u64 value);
64
65static void acpi_rs_out_title(char *title);
66
67static void acpi_rs_dump_byte_list(u16 length, u8 *data);
68
69static void acpi_rs_dump_word_list(u16 length, u16 *data);
70
71static void acpi_rs_dump_dword_list(u8 length, u32 *data);
72
73static void acpi_rs_dump_short_byte_list(u8 length, u8 *data);
74
75static void
76acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source);
77
78static void acpi_rs_dump_address_common(union acpi_resource_data *resource);
79
80static void
81acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table);
82
83/*******************************************************************************
84 *
85 * FUNCTION:    acpi_rs_dump_resource_list
86 *
87 * PARAMETERS:  resource_list       - Pointer to a resource descriptor list
88 *
89 * RETURN:      None
90 *
91 * DESCRIPTION: Dispatches the structure to the correct dump routine.
92 *
93 ******************************************************************************/
94
95void acpi_rs_dump_resource_list(struct acpi_resource *resource_list)
96{
97	u32 count = 0;
98	u32 type;
99
100	ACPI_FUNCTION_ENTRY();
101
102	/* Check if debug output enabled */
103
104	if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_RESOURCES, _COMPONENT)) {
105		return;
106	}
107
108	/* Walk list and dump all resource descriptors (END_TAG terminates) */
109
110	do {
111		acpi_os_printf("\n[%02X] ", count);
112		count++;
113
114		/* Validate Type before dispatch */
115
116		type = resource_list->type;
117		if (type > ACPI_RESOURCE_TYPE_MAX) {
118			acpi_os_printf
119			    ("Invalid descriptor type (%X) in resource list\n",
120			     resource_list->type);
121			return;
122		}
123
124		/* Sanity check the length. It must not be zero, or we loop forever */
125
126		if (!resource_list->length) {
127			acpi_os_printf
128			    ("Invalid zero length descriptor in resource list\n");
129			return;
130		}
131
132		/* Dump the resource descriptor */
133
134		if (type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
135			acpi_rs_dump_descriptor(&resource_list->data,
136						acpi_gbl_dump_serial_bus_dispatch
137						[resource_list->data.
138						 common_serial_bus.type]);
139		} else {
140			acpi_rs_dump_descriptor(&resource_list->data,
141						acpi_gbl_dump_resource_dispatch
142						[type]);
143		}
144
145		/* Point to the next resource structure */
146
147		resource_list = ACPI_NEXT_RESOURCE(resource_list);
148
149		/* Exit when END_TAG descriptor is reached */
150
151	} while (type != ACPI_RESOURCE_TYPE_END_TAG);
152}
153
154/*******************************************************************************
155 *
156 * FUNCTION:    acpi_rs_dump_irq_list
157 *
158 * PARAMETERS:  route_table     - Pointer to the routing table to dump.
159 *
160 * RETURN:      None
161 *
162 * DESCRIPTION: Print IRQ routing table
163 *
164 ******************************************************************************/
165
166void acpi_rs_dump_irq_list(u8 *route_table)
167{
168	struct acpi_pci_routing_table *prt_element;
169	u8 count;
170
171	ACPI_FUNCTION_ENTRY();
172
173	/* Check if debug output enabled */
174
175	if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_RESOURCES, _COMPONENT)) {
176		return;
177	}
178
179	prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, route_table);
180
181	/* Dump all table elements, Exit on zero length element */
182
183	for (count = 0; prt_element->length; count++) {
184		acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n",
185			       count);
186		acpi_rs_dump_descriptor(prt_element, acpi_rs_dump_prt);
187
188		prt_element = ACPI_ADD_PTR(struct acpi_pci_routing_table,
189					   prt_element, prt_element->length);
190	}
191}
192
193/*******************************************************************************
194 *
195 * FUNCTION:    acpi_rs_dump_descriptor
196 *
197 * PARAMETERS:  resource            - Buffer containing the resource
198 *              table               - Table entry to decode the resource
199 *
200 * RETURN:      None
201 *
202 * DESCRIPTION: Dump a resource descriptor based on a dump table entry.
203 *
204 ******************************************************************************/
205
206static void
207acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table)
208{
209	u8 *target = NULL;
210	u8 *previous_target;
211	char *name;
212	u8 count;
213
214	/* First table entry must contain the table length (# of table entries) */
215
216	count = table->offset;
217
218	while (count) {
219		previous_target = target;
220		target = ACPI_ADD_PTR(u8, resource, table->offset);
221		name = table->name;
222
223		switch (table->opcode) {
224		case ACPI_RSD_TITLE:
225			/*
226			 * Optional resource title
227			 */
228			if (table->name) {
229				acpi_os_printf("%s Resource\n", name);
230			}
231			break;
232
233			/* Strings */
234
235		case ACPI_RSD_LITERAL:
236
237			acpi_rs_out_string(name,
238					   ACPI_CAST_PTR(char, table->pointer));
239			break;
240
241		case ACPI_RSD_STRING:
242
243			acpi_rs_out_string(name, ACPI_CAST_PTR(char, target));
244			break;
245
246			/* Data items, 8/16/32/64 bit */
247
248		case ACPI_RSD_UINT8:
249
250			if (table->pointer) {
251				acpi_rs_out_string(name, ACPI_CAST_PTR(char,
252								       table->
253								       pointer
254								       [*target]));
255			} else {
256				acpi_rs_out_integer8(name, ACPI_GET8(target));
257			}
258			break;
259
260		case ACPI_RSD_UINT16:
261
262			acpi_rs_out_integer16(name, ACPI_GET16(target));
263			break;
264
265		case ACPI_RSD_UINT32:
266
267			acpi_rs_out_integer32(name, ACPI_GET32(target));
268			break;
269
270		case ACPI_RSD_UINT64:
271
272			acpi_rs_out_integer64(name, ACPI_GET64(target));
273			break;
274
275			/* Flags: 1-bit and 2-bit flags supported */
276
277		case ACPI_RSD_1BITFLAG:
278
279			acpi_rs_out_string(name, ACPI_CAST_PTR(char,
280							       table->
281							       pointer[*target &
282								       0x01]));
283			break;
284
285		case ACPI_RSD_2BITFLAG:
286
287			acpi_rs_out_string(name, ACPI_CAST_PTR(char,
288							       table->
289							       pointer[*target &
290								       0x03]));
291			break;
292
293		case ACPI_RSD_3BITFLAG:
294
295			acpi_rs_out_string(name, ACPI_CAST_PTR(char,
296							       table->
297							       pointer[*target &
298								       0x07]));
299			break;
300
301		case ACPI_RSD_SHORTLIST:
302			/*
303			 * Short byte list (single line output) for DMA and IRQ resources
304			 * Note: The list length is obtained from the previous table entry
305			 */
306			if (previous_target) {
307				acpi_rs_out_title(name);
308				acpi_rs_dump_short_byte_list(*previous_target,
309							     target);
310			}
311			break;
312
313		case ACPI_RSD_SHORTLISTX:
314			/*
315			 * Short byte list (single line output) for GPIO vendor data
316			 * Note: The list length is obtained from the previous table entry
317			 */
318			if (previous_target) {
319				acpi_rs_out_title(name);
320				acpi_rs_dump_short_byte_list(*previous_target,
321							     *
322							     (ACPI_CAST_INDIRECT_PTR
323							      (u8, target)));
324			}
325			break;
326
327		case ACPI_RSD_LONGLIST:
328			/*
329			 * Long byte list for Vendor resource data
330			 * Note: The list length is obtained from the previous table entry
331			 */
332			if (previous_target) {
333				acpi_rs_dump_byte_list(ACPI_GET16
334						       (previous_target),
335						       target);
336			}
337			break;
338
339		case ACPI_RSD_DWORDLIST:
340			/*
341			 * Dword list for Extended Interrupt resources
342			 * Note: The list length is obtained from the previous table entry
343			 */
344			if (previous_target) {
345				acpi_rs_dump_dword_list(*previous_target,
346							ACPI_CAST_PTR(u32,
347								      target));
348			}
349			break;
350
351		case ACPI_RSD_WORDLIST:
352			/*
353			 * Word list for GPIO Pin Table
354			 * Note: The list length is obtained from the previous table entry
355			 */
356			if (previous_target) {
357				acpi_rs_dump_word_list(*previous_target,
358						       *(ACPI_CAST_INDIRECT_PTR
359							 (u16, target)));
360			}
361			break;
362
363		case ACPI_RSD_ADDRESS:
364			/*
365			 * Common flags for all Address resources
366			 */
367			acpi_rs_dump_address_common(ACPI_CAST_PTR
368						    (union acpi_resource_data,
369						     target));
370			break;
371
372		case ACPI_RSD_SOURCE:
373			/*
374			 * Optional resource_source for Address resources
375			 */
376			acpi_rs_dump_resource_source(ACPI_CAST_PTR
377						     (struct
378								   acpi_resource_source,
379								   target));
380			break;
381
382		default:
383
384			acpi_os_printf("**** Invalid table opcode [%X] ****\n",
385				       table->opcode);
386			return;
387		}
388
389		table++;
390		count--;
391	}
392}
393
394/*******************************************************************************
395 *
396 * FUNCTION:    acpi_rs_dump_resource_source
397 *
398 * PARAMETERS:  resource_source     - Pointer to a Resource Source struct
399 *
400 * RETURN:      None
401 *
402 * DESCRIPTION: Common routine for dumping the optional resource_source and the
403 *              corresponding resource_source_index.
404 *
405 ******************************************************************************/
406
407static void
408acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source)
409{
410	ACPI_FUNCTION_ENTRY();
411
412	if (resource_source->index == 0xFF) {
413		return;
414	}
415
416	acpi_rs_out_integer8("Resource Source Index", resource_source->index);
417
418	acpi_rs_out_string("Resource Source",
419			   resource_source->string_ptr ?
420			   resource_source->string_ptr : "[Not Specified]");
421}
422
423/*******************************************************************************
424 *
425 * FUNCTION:    acpi_rs_dump_address_common
426 *
427 * PARAMETERS:  resource        - Pointer to an internal resource descriptor
428 *
429 * RETURN:      None
430 *
431 * DESCRIPTION: Dump the fields that are common to all Address resource
432 *              descriptors
433 *
434 ******************************************************************************/
435
436static void acpi_rs_dump_address_common(union acpi_resource_data *resource)
437{
438	ACPI_FUNCTION_ENTRY();
439
440	/* Decode the type-specific flags */
441
442	switch (resource->address.resource_type) {
443	case ACPI_MEMORY_RANGE:
444
445		acpi_rs_dump_descriptor(resource, acpi_rs_dump_memory_flags);
446		break;
447
448	case ACPI_IO_RANGE:
449
450		acpi_rs_dump_descriptor(resource, acpi_rs_dump_io_flags);
451		break;
452
453	case ACPI_BUS_NUMBER_RANGE:
454
455		acpi_rs_out_string("Resource Type", "Bus Number Range");
456		break;
457
458	default:
459
460		acpi_rs_out_integer8("Resource Type",
461				     (u8) resource->address.resource_type);
462		break;
463	}
464
465	/* Decode the general flags */
466
467	acpi_rs_dump_descriptor(resource, acpi_rs_dump_general_flags);
468}
469
470/*******************************************************************************
471 *
472 * FUNCTION:    acpi_rs_out*
473 *
474 * PARAMETERS:  title       - Name of the resource field
475 *              value       - Value of the resource field
476 *
477 * RETURN:      None
478 *
479 * DESCRIPTION: Miscellaneous helper functions to consistently format the
480 *              output of the resource dump routines
481 *
482 ******************************************************************************/
483
484static void acpi_rs_out_string(char *title, char *value)
485{
486	acpi_os_printf("%27s : %s", title, value);
487	if (!*value) {
488		acpi_os_printf("[NULL NAMESTRING]");
489	}
490	acpi_os_printf("\n");
491}
492
493static void acpi_rs_out_integer8(char *title, u8 value)
494{
495	acpi_os_printf("%27s : %2.2X\n", title, value);
496}
497
498static void acpi_rs_out_integer16(char *title, u16 value)
499{
500	acpi_os_printf("%27s : %4.4X\n", title, value);
501}
502
503static void acpi_rs_out_integer32(char *title, u32 value)
504{
505	acpi_os_printf("%27s : %8.8X\n", title, value);
506}
507
508static void acpi_rs_out_integer64(char *title, u64 value)
509{
510	acpi_os_printf("%27s : %8.8X%8.8X\n", title, ACPI_FORMAT_UINT64(value));
511}
512
513static void acpi_rs_out_title(char *title)
514{
515	acpi_os_printf("%27s : ", title);
516}
517
518/*******************************************************************************
519 *
520 * FUNCTION:    acpi_rs_dump*List
521 *
522 * PARAMETERS:  length      - Number of elements in the list
523 *              data        - Start of the list
524 *
525 * RETURN:      None
526 *
527 * DESCRIPTION: Miscellaneous functions to dump lists of raw data
528 *
529 ******************************************************************************/
530
531static void acpi_rs_dump_byte_list(u16 length, u8 * data)
532{
533	u8 i;
534
535	for (i = 0; i < length; i++) {
536		acpi_os_printf("%25s%2.2X : %2.2X\n", "Byte", i, data[i]);
537	}
538}
539
540static void acpi_rs_dump_short_byte_list(u8 length, u8 * data)
541{
542	u8 i;
543
544	for (i = 0; i < length; i++) {
545		acpi_os_printf("%X ", data[i]);
546	}
547	acpi_os_printf("\n");
548}
549
550static void acpi_rs_dump_dword_list(u8 length, u32 * data)
551{
552	u8 i;
553
554	for (i = 0; i < length; i++) {
555		acpi_os_printf("%25s%2.2X : %8.8X\n", "Dword", i, data[i]);
556	}
557}
558
559static void acpi_rs_dump_word_list(u16 length, u16 *data)
560{
561	u16 i;
562
563	for (i = 0; i < length; i++) {
564		acpi_os_printf("%25s%2.2X : %4.4X\n", "Word", i, data[i]);
565	}
566}
567