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