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