开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
dswload.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

dswload.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * Module Name: dswload - Dispatcher namespace load callbacks
  4.  *              $Revision: 50 $
  5.  *
  6.  *****************************************************************************/
  8. /*
  9.  *  Copyright (C) 2000, 2001 R. Byron Moore
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24.  */
  27. #include "acpi.h"
  28. #include "acparser.h"
  29. #include "amlcode.h"
  30. #include "acdispat.h"
  31. #include "acinterp.h"
  32. #include "acnamesp.h"
  33. #include "acevents.h"
  36. #define _COMPONENT          ACPI_DISPATCHER
  37.  MODULE_NAME         ("dswload")
  40. /*******************************************************************************
  41.  *
  42.  * FUNCTION:    Acpi_ds_init_callbacks
  43.  *
  44.  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  45.  *              Pass_number     - 1, 2, or 3
  46.  *
  47.  * RETURN:      Status
  48.  *
  49.  * DESCRIPTION: Init walk state callbacks
  50.  *
  51.  ******************************************************************************/
  53. acpi_status
  54. acpi_ds_init_callbacks (
  55. acpi_walk_state         *walk_state,
  56. u32                     pass_number)
  57. {
  59. switch (pass_number) {
  60. case 1:
  61. walk_state->parse_flags       = ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE;
  62. walk_state->descending_callback = acpi_ds_load1_begin_op;
  63. walk_state->ascending_callback = acpi_ds_load1_end_op;
  64. break;
  66. case 2:
  67. walk_state->parse_flags       = ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE;
  68. walk_state->descending_callback = acpi_ds_load2_begin_op;
  69. walk_state->ascending_callback = acpi_ds_load2_end_op;
  70. break;
  72. case 3:
  73. walk_state->parse_flags      |= ACPI_PARSE_EXECUTE  | ACPI_PARSE_DELETE_TREE;
  74. walk_state->descending_callback = acpi_ds_exec_begin_op;
  75. walk_state->ascending_callback = acpi_ds_exec_end_op;
  76. break;
  78. default:
  79. return (AE_BAD_PARAMETER);
  80. break;
  81. }
  83. return (AE_OK);
  84. }
  87. /*******************************************************************************
  88.  *
  89.  * FUNCTION:    Acpi_ds_load1_begin_op
  90.  *
  91.  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  92.  *              Op              - Op that has been just been reached in the
  93.  *                                walk;  Arguments have not been evaluated yet.
  94.  *
  95.  * RETURN:      Status
  96.  *
  97.  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
  98.  *
  99.  ******************************************************************************/
  101. acpi_status
  102. acpi_ds_load1_begin_op (
  103. acpi_walk_state         *walk_state,
  104. acpi_parse_object       **out_op)
  105. {
  106. acpi_parse_object       *op;
  107. acpi_namespace_node     *node;
  108. acpi_status             status;
  109. acpi_object_type8       data_type;
  110. NATIVE_CHAR             *path;
  113. PROC_NAME ("Ds_load1_begin_op");
  115. op = walk_state->op;
  116. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%pn", op, walk_state));
  119. /* We are only interested in opcodes that have an associated name */
  121. if (walk_state->op) {
  122.    if (!(walk_state->op_info->flags & AML_NAMED)) {
  123. *out_op = op;
  124. return (AE_OK);
  125. }
  127. /* Check if this object has already been installed in the namespace */
  129. if (op->node) {
  130. *out_op = op;
  131. return (AE_OK);
  132. }
  133. }
  135. path = acpi_ps_get_next_namestring (&walk_state->parser_state);
  137. /* Map the raw opcode into an internal object type */
  139. data_type = acpi_ds_map_named_opcode_to_data_type (walk_state->opcode);
  142. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  143. "State=%p Op=%p Type=%xn", walk_state, op, data_type));
  146. if (walk_state->opcode == AML_SCOPE_OP) {
  147. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  148. "State=%p Op=%p Type=%xn", walk_state, op, data_type));
  149. }
  151. /*
  152.  * Enter the named type into the internal namespace.  We enter the name
  153.  * as we go downward in the parse tree.  Any necessary subobjects that involve
  154.  * arguments to the opcode must be created as we go back up the parse tree later.
  155.  */
  156. status = acpi_ns_lookup (walk_state->scope_info, path, data_type,
  157.   IMODE_LOAD_PASS1, NS_NO_UPSEARCH, walk_state, &(node));
  159. if (ACPI_FAILURE (status)) {
  160. return (status);
  161. }
  163. if (!op) {
  164. /* Create a new op */
  166. op = acpi_ps_alloc_op (walk_state->opcode);
  167. if (!op) {
  168. return (AE_NO_MEMORY);
  169. }
  170. }
  172. /* Initialize */
  174. ((acpi_parse2_object *)op)->name = node->name;
  176. /*
  177.  * Put the Node in the "op" object that the parser uses, so we
  178.  * can get it again quickly when this scope is closed
  179.  */
  180. op->node = node;
  181. acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state->parser_state), op);
  183. *out_op = op;
  184. return (status);
  185. }
  188. /*******************************************************************************
  189.  *
  190.  * FUNCTION:    Acpi_ds_load1_end_op
  191.  *
  192.  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  193.  *              Op              - Op that has been just been completed in the
  194.  *                                walk;  Arguments have now been evaluated.
  195.  *
  196.  * RETURN:      Status
  197.  *
  198.  * DESCRIPTION: Ascending callback used during the loading of the namespace,
  199.  *              both control methods and everything else.
  200.  *
  201.  ******************************************************************************/
  203. acpi_status
  204. acpi_ds_load1_end_op (
  205. acpi_walk_state         *walk_state)
  206. {
  207. acpi_parse_object       *op;
  208. acpi_object_type8       data_type;
  211. PROC_NAME ("Ds_load1_end_op");
  213. op = walk_state->op;
  214. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%pn", op, walk_state));
  217. /* We are only interested in opcodes that have an associated name */
  219. if (!(walk_state->op_info->flags & AML_NAMED)) {
  220. return (AE_OK);
  221. }
  223. /* Get the type to determine if we should pop the scope */
  225. data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
  227. if (op->opcode == AML_NAME_OP) {
  228. /* For Name opcode, check the argument */
  230. if (op->value.arg) {
  231. data_type = acpi_ds_map_opcode_to_data_type (
  232.   (op->value.arg)->opcode, NULL);
  233. ((acpi_namespace_node *)op->node)->type =
  234.   (u8) data_type;
  235. }
  236. }
  238. /* Pop the scope stack */
  240. if (acpi_ns_opens_scope (data_type)) {
  241. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %pn",
  242. acpi_ut_get_type_name (data_type), op));
  244. acpi_ds_scope_stack_pop (walk_state);
  245. }
  247. return (AE_OK);
  248. }
  251. /*******************************************************************************
  252.  *
  253.  * FUNCTION:    Acpi_ds_load2_begin_op
  254.  *
  255.  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  256.  *              Op              - Op that has been just been reached in the
  257.  *                                walk;  Arguments have not been evaluated yet.
  258.  *
  259.  * RETURN:      Status
  260.  *
  261.  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
  262.  *
  263.  ******************************************************************************/
  265. acpi_status
  266. acpi_ds_load2_begin_op (
  267. acpi_walk_state         *walk_state,
  268. acpi_parse_object       **out_op)
  269. {
  270. acpi_parse_object       *op;
  271. acpi_namespace_node     *node;
  272. acpi_status             status;
  273. acpi_object_type8       data_type;
  274. NATIVE_CHAR             *buffer_ptr;
  275. void                    *original = NULL;
  278. PROC_NAME ("Ds_load2_begin_op");
  280. op = walk_state->op;
  281. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%pn", op, walk_state));
  284. if (op) {
  285. /* We only care about Namespace opcodes here */
  287. if (!(walk_state->op_info->flags & AML_NSOPCODE) &&
  288. walk_state->opcode != AML_INT_NAMEPATH_OP) {
  289. return (AE_OK);
  290. }
  292. /* TBD: [Restructure] Temp! same code as in psparse */
  294. if (!(walk_state->op_info->flags & AML_NAMED)) {
  295. return (AE_OK);
  296. }
  298. /*
  299.  * Get the name we are going to enter or lookup in the namespace
  300.  */
  301. if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
  302. /* For Namepath op, get the path string */
  304. buffer_ptr = op->value.string;
  305. if (!buffer_ptr) {
  306. /* No name, just exit */
  308. return (AE_OK);
  309. }
  310. }
  311. else {
  312. /* Get name from the op */
  314. buffer_ptr = (NATIVE_CHAR *) &((acpi_parse2_object *)op)->name;
  315. }
  316. }
  317. else {
  318. buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
  319. }
  322. /* Map the raw opcode into an internal object type */
  324. data_type = acpi_ds_map_named_opcode_to_data_type (walk_state->opcode);
  326. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  327. "State=%p Op=%p Type=%xn", walk_state, op, data_type));
  330. if (walk_state->opcode == AML_FIELD_OP         ||
  331. walk_state->opcode == AML_BANK_FIELD_OP    ||
  332. walk_state->opcode == AML_INDEX_FIELD_OP) {
  333. node = NULL;
  334. status = AE_OK;
  335. }
  337. else if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
  338. /*
  339.  * The Name_path is an object reference to an existing object. Don't enter the
  340.  * name into the namespace, but look it up for use later
  341.  */
  342. status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
  343.   IMODE_EXECUTE, NS_SEARCH_PARENT, walk_state, &(node));
  344. }
  346. else {
  347. if (op && op->node) {
  348. original = op->node;
  349. node = op->node;
  351. if (acpi_ns_opens_scope (data_type)) {
  352. status = acpi_ds_scope_stack_push (node, data_type, walk_state);
  353. if (ACPI_FAILURE (status)) {
  354. return (status);
  355. }
  357. }
  358. return (AE_OK);
  359. }
  361. /*
  362.  * Enter the named type into the internal namespace.  We enter the name
  363.  * as we go downward in the parse tree.  Any necessary subobjects that involve
  364.  * arguments to the opcode must be created as we go back up the parse tree later.
  365.  */
  366. status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
  367.   IMODE_EXECUTE, NS_NO_UPSEARCH, walk_state, &(node));
  368. }
  370. if (ACPI_SUCCESS (status)) {
  371. if (!op) {
  372. /* Create a new op */
  374. op = acpi_ps_alloc_op (walk_state->opcode);
  375. if (!op) {
  376. return (AE_NO_MEMORY);
  377. }
  379. /* Initialize */
  381. ((acpi_parse2_object *)op)->name = node->name;
  382. *out_op = op;
  383. }
  385. /*
  386.  * Put the Node in the "op" object that the parser uses, so we
  387.  * can get it again quickly when this scope is closed
  388.  */
  389. op->node = node;
  391. if (original) {
  392. ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "old %p new %pn", original, node));
  394. if (original != node) {
  395. ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
  396. "Lookup match error: old %p new %pn", original, node));
  397. }
  398. }
  399. }
  401. return (status);
  402. }
  405. /*******************************************************************************
  406.  *
  407.  * FUNCTION:    Acpi_ds_load2_end_op
  408.  *
  409.  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  410.  *              Op              - Op that has been just been completed in the
  411.  *                                walk;  Arguments have now been evaluated.
  412.  *
  413.  * RETURN:      Status
  414.  *
  415.  * DESCRIPTION: Ascending callback used during the loading of the namespace,
  416.  *              both control methods and everything else.
  417.  *
  418.  ******************************************************************************/
  420. acpi_status
  421. acpi_ds_load2_end_op (
  422. acpi_walk_state         *walk_state)
  423. {
  424. acpi_parse_object       *op;
  425. acpi_status             status = AE_OK;
  426. acpi_object_type8       data_type;
  427. acpi_namespace_node     *node;
  428. acpi_parse_object       *arg;
  429. acpi_namespace_node     *new_node;
  430. u32                     i;
  433. PROC_NAME ("Ds_load2_end_op");
  435. op = walk_state->op;
  436. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%pn", op, walk_state));
  439. /* Only interested in opcodes that have namespace objects */
  441. if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
  442. return (AE_OK);
  443. }
  445. if (op->opcode == AML_SCOPE_OP) {
  446. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  447. "Ending scope Op=%p State=%pn", op, walk_state));
  449. if (((acpi_parse2_object *)op)->name == -1) {
  450. ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unnamed scope! Op=%p State=%pn",
  451. op, walk_state));
  452. return (AE_OK);
  453. }
  454. }
  457. data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
  459. /*
  460.  * Get the Node/name from the earlier lookup
  461.  * (It was saved in the *op structure)
  462.  */
  463. node = op->node;
  465. /*
  466.  * Put the Node on the object stack (Contains the ACPI Name of
  467.  * this object)
  468.  */
  469. walk_state->operands[0] = (void *) node;
  470. walk_state->num_operands = 1;
  472. /* Pop the scope stack */
  474. if (acpi_ns_opens_scope (data_type)) {
  476. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %pn",
  477. acpi_ut_get_type_name (data_type), op));
  478. acpi_ds_scope_stack_pop (walk_state);
  479. }
  481. /*
  482.  * Named operations are as follows:
  483.  *
  484.  * AML_ALIAS
  485.  * AML_BANKFIELD
  486.  * AML_CREATEBITFIELD
  487.  * AML_CREATEBYTEFIELD
  488.  * AML_CREATEDWORDFIELD
  489.  * AML_CREATEFIELD
  490.  * AML_CREATEQWORDFIELD
  491.  * AML_CREATEWORDFIELD
  492.  * AML_DATA_REGION
  493.  * AML_DEVICE
  494.  * AML_EVENT
  495.  * AML_FIELD
  496.  * AML_INDEXFIELD
  497.  * AML_METHOD
  498.  * AML_METHODCALL
  499.  * AML_MUTEX
  500.  * AML_NAME
  501.  * AML_NAMEDFIELD
  502.  * AML_OPREGION
  503.  * AML_POWERRES
  504.  * AML_PROCESSOR
  505.  * AML_SCOPE
  506.  * AML_THERMALZONE
  507.  */
  509. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  510. "Create-Load [%s] State=%p Op=%p Named_obj=%pn",
  511. acpi_ps_get_opcode_name (op->opcode), walk_state, op, node));
  513. /* Decode the opcode */
  515. arg = op->value.arg;
  517. switch (walk_state->op_info->type) {
  518. case AML_TYPE_CREATE_FIELD:
  520. /*
  521.  * Create the field object, but the field buffer and index must
  522.  * be evaluated later during the execution phase
  523.  */
  524. status = acpi_ds_create_buffer_field (op, walk_state);
  525. break;
  528.  case AML_TYPE_NAMED_FIELD:
  530. arg = op->value.arg;
  531. switch (op->opcode) {
  532. case AML_INDEX_FIELD_OP:
  534. status = acpi_ds_create_index_field (op, (acpi_handle) arg->node,
  535.    walk_state);
  536. break;
  539. case AML_BANK_FIELD_OP:
  541. status = acpi_ds_create_bank_field (op, arg->node, walk_state);
  542. break;
  545. case AML_FIELD_OP:
  547. status = acpi_ds_create_field (op, arg->node, walk_state);
  548. break;
  549. }
  550. break;
  553.  case AML_TYPE_NAMED_SIMPLE:
  555. status = acpi_ds_create_operands (walk_state, arg);
  556. if (ACPI_FAILURE (status)) {
  557. goto cleanup;
  558. }
  560. switch (op->opcode) {
  561. case AML_PROCESSOR_OP:
  563. status = acpi_ex_create_processor (walk_state);
  564. break;
  567. case AML_POWER_RES_OP:
  569. status = acpi_ex_create_power_resource (walk_state);
  570. break;
  573. case AML_MUTEX_OP:
  575. status = acpi_ex_create_mutex (walk_state);
  576. break;
  579. case AML_EVENT_OP:
  581. status = acpi_ex_create_event (walk_state);
  582. break;
  585. case AML_DATA_REGION_OP:
  587. status = acpi_ex_create_table_region (walk_state);
  588. break;
  590. case AML_ALIAS_OP:
  592. status = acpi_ex_create_alias (walk_state);
  593. break;
  595. default:
  596. /* Unknown opcode */
  598. status = AE_OK;
  599. goto cleanup;
  600. break;
  601. }
  603. /* Delete operands */
  605. for (i = 1; i < walk_state->num_operands; i++) {
  606. acpi_ut_remove_reference (walk_state->operands[i]);
  607. walk_state->operands[i] = NULL;
  608. }
  610. break;
  613. case AML_TYPE_NAMED_COMPLEX:
  615. switch (op->opcode) {
  616. case AML_METHOD_OP:
  617. /*
  618.  * Method_op Pkg_length Names_string Method_flags Term_list
  619.  */
  620. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  621. "LOADING-Method: State=%p Op=%p Named_obj=%pn",
  622. walk_state, op, node));
  624. if (!node->object) {
  625. status = acpi_ds_create_operands (walk_state, arg);
  626. if (ACPI_FAILURE (status)) {
  627. goto cleanup;
  628. }
  630. status = acpi_ex_create_method (((acpi_parse2_object *) op)->data,
  631.    ((acpi_parse2_object *) op)->length,
  632.    walk_state);
  633. }
  634. break;
  637. case AML_REGION_OP:
  638. /*
  639.  * The Op_region is not fully parsed at this time. Only valid argument is the Space_id.
  640.  * (We must save the address of the AML of the address and length operands)
  641.  */
  642. status = acpi_ex_create_region (((acpi_parse2_object *) op)->data,
  643.   ((acpi_parse2_object *) op)->length,
  644.  (ACPI_ADR_SPACE_TYPE) arg->value.integer, walk_state);
  645. break;
  648. case AML_NAME_OP:
  650. status = acpi_ds_create_node (walk_state, node, op);
  651. break;
  652. }
  653. break;
  656. case AML_CLASS_INTERNAL:
  658. /* case AML_INT_NAMEPATH_OP: */
  659. break;
  662. case AML_CLASS_METHOD_CALL:
  664. ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
  665. "RESOLVING-Method_call: State=%p Op=%p Named_obj=%pn",
  666. walk_state, op, node));
  668. /*
  669.  * Lookup the method name and save the Node
  670.  */
  671. status = acpi_ns_lookup (walk_state->scope_info, arg->value.string,
  672.   ACPI_TYPE_ANY, IMODE_LOAD_PASS2,
  673.   NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
  674.   walk_state, &(new_node));
  675. if (ACPI_SUCCESS (status)) {
  676. /* TBD: has name already been resolved by here ??*/
  678. /* TBD: [Restructure] Make sure that what we found is indeed a method! */
  679. /* We didn't search for a method on purpose, to see if the name would resolve! */
  681. /* We could put the returned object (Node) on the object stack for later, but
  682.  * for now, we will put it in the "op" object that the parser uses, so we
  683.  * can get it again at the end of this scope
  684.  */
  685. op->node = new_node;
  686. }
  688. break;
  691. default:
  692. break;
  693. }
  696. cleanup:
  698. /* Remove the Node pushed at the very beginning */
  700. walk_state->operands[0] = NULL;
  701. walk_state->num_operands = 0;
  702. return (status);
  703. }