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