1/******************************************************************************* 2 * 3 * Module Name: rscreate - Create resource lists/tables 4 * 5 ******************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2012, 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#include "acnamesp.h" 48 49#define _COMPONENT ACPI_RESOURCES 50ACPI_MODULE_NAME("rscreate") 51 52/******************************************************************************* 53 * 54 * FUNCTION: acpi_buffer_to_resource 55 * 56 * PARAMETERS: aml_buffer - Pointer to the resource byte stream 57 * aml_buffer_length - Length of the aml_buffer 58 * resource_ptr - Where the converted resource is returned 59 * 60 * RETURN: Status 61 * 62 * DESCRIPTION: Convert a raw AML buffer to a resource list 63 * 64 ******************************************************************************/ 65acpi_status 66acpi_buffer_to_resource(u8 *aml_buffer, 67 u16 aml_buffer_length, 68 struct acpi_resource **resource_ptr) 69{ 70 acpi_status status; 71 acpi_size list_size_needed; 72 void *resource; 73 void *current_resource_ptr; 74 75 /* 76 * Note: we allow AE_AML_NO_RESOURCE_END_TAG, since an end tag 77 * is not required here. 78 */ 79 80 /* Get the required length for the converted resource */ 81 82 status = acpi_rs_get_list_length(aml_buffer, aml_buffer_length, 83 &list_size_needed); 84 if (status == AE_AML_NO_RESOURCE_END_TAG) { 85 status = AE_OK; 86 } 87 if (ACPI_FAILURE(status)) { 88 return (status); 89 } 90 91 /* Allocate a buffer for the converted resource */ 92 93 resource = ACPI_ALLOCATE_ZEROED(list_size_needed); 94 current_resource_ptr = resource; 95 if (!resource) { 96 return (AE_NO_MEMORY); 97 } 98 99 /* Perform the AML-to-Resource conversion */ 100 101 status = acpi_ut_walk_aml_resources(aml_buffer, aml_buffer_length, 102 acpi_rs_convert_aml_to_resources, 103 ¤t_resource_ptr); 104 if (status == AE_AML_NO_RESOURCE_END_TAG) { 105 status = AE_OK; 106 } 107 if (ACPI_FAILURE(status)) { 108 ACPI_FREE(resource); 109 } else { 110 *resource_ptr = resource; 111 } 112 113 return (status); 114} 115 116/******************************************************************************* 117 * 118 * FUNCTION: acpi_rs_create_resource_list 119 * 120 * PARAMETERS: aml_buffer - Pointer to the resource byte stream 121 * output_buffer - Pointer to the user's buffer 122 * 123 * RETURN: Status: AE_OK if okay, else a valid acpi_status code 124 * If output_buffer is not large enough, output_buffer_length 125 * indicates how large output_buffer should be, else it 126 * indicates how may u8 elements of output_buffer are valid. 127 * 128 * DESCRIPTION: Takes the byte stream returned from a _CRS, _PRS control method 129 * execution and parses the stream to create a linked list 130 * of device resources. 131 * 132 ******************************************************************************/ 133 134acpi_status 135acpi_rs_create_resource_list(union acpi_operand_object *aml_buffer, 136 struct acpi_buffer * output_buffer) 137{ 138 139 acpi_status status; 140 u8 *aml_start; 141 acpi_size list_size_needed = 0; 142 u32 aml_buffer_length; 143 void *resource; 144 145 ACPI_FUNCTION_TRACE(rs_create_resource_list); 146 147 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "AmlBuffer = %p\n", aml_buffer)); 148 149 /* Params already validated, so we don't re-validate here */ 150 151 aml_buffer_length = aml_buffer->buffer.length; 152 aml_start = aml_buffer->buffer.pointer; 153 154 /* 155 * Pass the aml_buffer into a module that can calculate 156 * the buffer size needed for the linked list 157 */ 158 status = acpi_rs_get_list_length(aml_start, aml_buffer_length, 159 &list_size_needed); 160 161 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Status=%X ListSizeNeeded=%X\n", 162 status, (u32) list_size_needed)); 163 if (ACPI_FAILURE(status)) { 164 return_ACPI_STATUS(status); 165 } 166 167 /* Validate/Allocate/Clear caller buffer */ 168 169 status = acpi_ut_initialize_buffer(output_buffer, list_size_needed); 170 if (ACPI_FAILURE(status)) { 171 return_ACPI_STATUS(status); 172 } 173 174 /* Do the conversion */ 175 176 resource = output_buffer->pointer; 177 status = acpi_ut_walk_aml_resources(aml_start, aml_buffer_length, 178 acpi_rs_convert_aml_to_resources, 179 &resource); 180 if (ACPI_FAILURE(status)) { 181 return_ACPI_STATUS(status); 182 } 183 184 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "OutputBuffer %p Length %X\n", 185 output_buffer->pointer, (u32) output_buffer->length)); 186 return_ACPI_STATUS(AE_OK); 187} 188 189/******************************************************************************* 190 * 191 * FUNCTION: acpi_rs_create_pci_routing_table 192 * 193 * PARAMETERS: package_object - Pointer to a union acpi_operand_object 194 * package 195 * output_buffer - Pointer to the user's buffer 196 * 197 * RETURN: Status AE_OK if okay, else a valid acpi_status code. 198 * If the output_buffer is too small, the error will be 199 * AE_BUFFER_OVERFLOW and output_buffer->Length will point 200 * to the size buffer needed. 201 * 202 * DESCRIPTION: Takes the union acpi_operand_object package and creates a 203 * linked list of PCI interrupt descriptions 204 * 205 * NOTE: It is the caller's responsibility to ensure that the start of the 206 * output buffer is aligned properly (if necessary). 207 * 208 ******************************************************************************/ 209 210acpi_status 211acpi_rs_create_pci_routing_table(union acpi_operand_object *package_object, 212 struct acpi_buffer *output_buffer) 213{ 214 u8 *buffer; 215 union acpi_operand_object **top_object_list; 216 union acpi_operand_object **sub_object_list; 217 union acpi_operand_object *obj_desc; 218 acpi_size buffer_size_needed = 0; 219 u32 number_of_elements; 220 u32 index; 221 struct acpi_pci_routing_table *user_prt; 222 struct acpi_namespace_node *node; 223 acpi_status status; 224 struct acpi_buffer path_buffer; 225 226 ACPI_FUNCTION_TRACE(rs_create_pci_routing_table); 227 228 /* Params already validated, so we don't re-validate here */ 229 230 /* Get the required buffer length */ 231 232 status = acpi_rs_get_pci_routing_table_length(package_object, 233 &buffer_size_needed); 234 if (ACPI_FAILURE(status)) { 235 return_ACPI_STATUS(status); 236 } 237 238 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "BufferSizeNeeded = %X\n", 239 (u32) buffer_size_needed)); 240 241 /* Validate/Allocate/Clear caller buffer */ 242 243 status = acpi_ut_initialize_buffer(output_buffer, buffer_size_needed); 244 if (ACPI_FAILURE(status)) { 245 return_ACPI_STATUS(status); 246 } 247 248 /* 249 * Loop through the ACPI_INTERNAL_OBJECTS - Each object should be a 250 * package that in turn contains an u64 Address, a u8 Pin, 251 * a Name, and a u8 source_index. 252 */ 253 top_object_list = package_object->package.elements; 254 number_of_elements = package_object->package.count; 255 buffer = output_buffer->pointer; 256 user_prt = ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer); 257 258 for (index = 0; index < number_of_elements; index++) { 259 260 /* 261 * Point user_prt past this current structure 262 * 263 * NOTE: On the first iteration, user_prt->Length will 264 * be zero because we cleared the return buffer earlier 265 */ 266 buffer += user_prt->length; 267 user_prt = ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer); 268 269 /* 270 * Fill in the Length field with the information we have at this point. 271 * The minus four is to subtract the size of the u8 Source[4] member 272 * because it is added below. 273 */ 274 user_prt->length = (sizeof(struct acpi_pci_routing_table) - 4); 275 276 /* Each element of the top-level package must also be a package */ 277 278 if ((*top_object_list)->common.type != ACPI_TYPE_PACKAGE) { 279 ACPI_ERROR((AE_INFO, 280 "(PRT[%u]) Need sub-package, found %s", 281 index, 282 acpi_ut_get_object_type_name 283 (*top_object_list))); 284 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 285 } 286 287 /* Each sub-package must be of length 4 */ 288 289 if ((*top_object_list)->package.count != 4) { 290 ACPI_ERROR((AE_INFO, 291 "(PRT[%u]) Need package of length 4, found length %u", 292 index, (*top_object_list)->package.count)); 293 return_ACPI_STATUS(AE_AML_PACKAGE_LIMIT); 294 } 295 296 /* 297 * Dereference the sub-package. 298 * The sub_object_list will now point to an array of the four IRQ 299 * elements: [Address, Pin, Source, source_index] 300 */ 301 sub_object_list = (*top_object_list)->package.elements; 302 303 /* 1) First subobject: Dereference the PRT.Address */ 304 305 obj_desc = sub_object_list[0]; 306 if (obj_desc->common.type != ACPI_TYPE_INTEGER) { 307 ACPI_ERROR((AE_INFO, 308 "(PRT[%u].Address) Need Integer, found %s", 309 index, 310 acpi_ut_get_object_type_name(obj_desc))); 311 return_ACPI_STATUS(AE_BAD_DATA); 312 } 313 314 user_prt->address = obj_desc->integer.value; 315 316 /* 2) Second subobject: Dereference the PRT.Pin */ 317 318 obj_desc = sub_object_list[1]; 319 if (obj_desc->common.type != ACPI_TYPE_INTEGER) { 320 ACPI_ERROR((AE_INFO, 321 "(PRT[%u].Pin) Need Integer, found %s", 322 index, 323 acpi_ut_get_object_type_name(obj_desc))); 324 return_ACPI_STATUS(AE_BAD_DATA); 325 } 326 327 user_prt->pin = (u32) obj_desc->integer.value; 328 329 /* 330 * If the BIOS has erroneously reversed the _PRT source_name (index 2) 331 * and the source_index (index 3), fix it. _PRT is important enough to 332 * workaround this BIOS error. This also provides compatibility with 333 * other ACPI implementations. 334 */ 335 obj_desc = sub_object_list[3]; 336 if (!obj_desc || (obj_desc->common.type != ACPI_TYPE_INTEGER)) { 337 sub_object_list[3] = sub_object_list[2]; 338 sub_object_list[2] = obj_desc; 339 340 ACPI_WARNING((AE_INFO, 341 "(PRT[%X].Source) SourceName and SourceIndex are reversed, fixed", 342 index)); 343 } 344 345 /* 346 * 3) Third subobject: Dereference the PRT.source_name 347 * The name may be unresolved (slack mode), so allow a null object 348 */ 349 obj_desc = sub_object_list[2]; 350 if (obj_desc) { 351 switch (obj_desc->common.type) { 352 case ACPI_TYPE_LOCAL_REFERENCE: 353 354 if (obj_desc->reference.class != 355 ACPI_REFCLASS_NAME) { 356 ACPI_ERROR((AE_INFO, 357 "(PRT[%u].Source) Need name, found Reference Class 0x%X", 358 index, 359 obj_desc->reference.class)); 360 return_ACPI_STATUS(AE_BAD_DATA); 361 } 362 363 node = obj_desc->reference.node; 364 365 /* Use *remaining* length of the buffer as max for pathname */ 366 367 path_buffer.length = output_buffer->length - 368 (u32) ((u8 *) user_prt->source - 369 (u8 *) output_buffer->pointer); 370 path_buffer.pointer = user_prt->source; 371 372 status = 373 acpi_ns_handle_to_pathname((acpi_handle) 374 node, 375 &path_buffer); 376 377 /* +1 to include null terminator */ 378 379 user_prt->length += 380 (u32) ACPI_STRLEN(user_prt->source) + 1; 381 break; 382 383 case ACPI_TYPE_STRING: 384 385 ACPI_STRCPY(user_prt->source, 386 obj_desc->string.pointer); 387 388 /* 389 * Add to the Length field the length of the string 390 * (add 1 for terminator) 391 */ 392 user_prt->length += obj_desc->string.length + 1; 393 break; 394 395 case ACPI_TYPE_INTEGER: 396 /* 397 * If this is a number, then the Source Name is NULL, since the 398 * entire buffer was zeroed out, we can leave this alone. 399 * 400 * Add to the Length field the length of the u32 NULL 401 */ 402 user_prt->length += sizeof(u32); 403 break; 404 405 default: 406 407 ACPI_ERROR((AE_INFO, 408 "(PRT[%u].Source) Need Ref/String/Integer, found %s", 409 index, 410 acpi_ut_get_object_type_name 411 (obj_desc))); 412 return_ACPI_STATUS(AE_BAD_DATA); 413 } 414 } 415 416 /* Now align the current length */ 417 418 user_prt->length = 419 (u32) ACPI_ROUND_UP_TO_64BIT(user_prt->length); 420 421 /* 4) Fourth subobject: Dereference the PRT.source_index */ 422 423 obj_desc = sub_object_list[3]; 424 if (obj_desc->common.type != ACPI_TYPE_INTEGER) { 425 ACPI_ERROR((AE_INFO, 426 "(PRT[%u].SourceIndex) Need Integer, found %s", 427 index, 428 acpi_ut_get_object_type_name(obj_desc))); 429 return_ACPI_STATUS(AE_BAD_DATA); 430 } 431 432 user_prt->source_index = (u32) obj_desc->integer.value; 433 434 /* Point to the next union acpi_operand_object in the top level package */ 435 436 top_object_list++; 437 } 438 439 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "OutputBuffer %p Length %X\n", 440 output_buffer->pointer, (u32) output_buffer->length)); 441 return_ACPI_STATUS(AE_OK); 442} 443 444/******************************************************************************* 445 * 446 * FUNCTION: acpi_rs_create_aml_resources 447 * 448 * PARAMETERS: linked_list_buffer - Pointer to the resource linked list 449 * output_buffer - Pointer to the user's buffer 450 * 451 * RETURN: Status AE_OK if okay, else a valid acpi_status code. 452 * If the output_buffer is too small, the error will be 453 * AE_BUFFER_OVERFLOW and output_buffer->Length will point 454 * to the size buffer needed. 455 * 456 * DESCRIPTION: Takes the linked list of device resources and 457 * creates a bytestream to be used as input for the 458 * _SRS control method. 459 * 460 ******************************************************************************/ 461 462acpi_status 463acpi_rs_create_aml_resources(struct acpi_resource *linked_list_buffer, 464 struct acpi_buffer *output_buffer) 465{ 466 acpi_status status; 467 acpi_size aml_size_needed = 0; 468 469 ACPI_FUNCTION_TRACE(rs_create_aml_resources); 470 471 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "LinkedListBuffer = %p\n", 472 linked_list_buffer)); 473 474 /* 475 * Params already validated, so we don't re-validate here 476 * 477 * Pass the linked_list_buffer into a module that calculates 478 * the buffer size needed for the byte stream. 479 */ 480 status = acpi_rs_get_aml_length(linked_list_buffer, &aml_size_needed); 481 482 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "AmlSizeNeeded=%X, %s\n", 483 (u32) aml_size_needed, 484 acpi_format_exception(status))); 485 if (ACPI_FAILURE(status)) { 486 return_ACPI_STATUS(status); 487 } 488 489 /* Validate/Allocate/Clear caller buffer */ 490 491 status = acpi_ut_initialize_buffer(output_buffer, aml_size_needed); 492 if (ACPI_FAILURE(status)) { 493 return_ACPI_STATUS(status); 494 } 495 496 /* Do the conversion */ 497 498 status = 499 acpi_rs_convert_resources_to_aml(linked_list_buffer, 500 aml_size_needed, 501 output_buffer->pointer); 502 if (ACPI_FAILURE(status)) { 503 return_ACPI_STATUS(status); 504 } 505 506 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "OutputBuffer %p Length %X\n", 507 output_buffer->pointer, (u32) output_buffer->length)); 508 return_ACPI_STATUS(AE_OK); 509} 510