drivers/acpi/tables/tbxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbxface - Public interfaces to the ACPI subsystem
   4  *                         ACPI table oriented interfaces
   5  *              $Revision: 32 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "acnamesp.h"
  30 #include "acinterp.h"
  31 #include "actables.h"
  32
  33
  34 #define _COMPONENT          TABLE_MANAGER
  35          MODULE_NAME         ("tbxface")
  36
  37
  38 /*******************************************************************************
  39  *
  40  * FUNCTION:    Acpi_load_tables
  41  *
  42  * PARAMETERS:  None
  43  *
  44  * RETURN:      Status
  45  *
  46  * DESCRIPTION: This function is called to load the ACPI tables from the
  47  *              provided RSDT
  48  *
  49  ******************************************************************************/
  50
  51 ACPI_STATUS
  52 acpi_load_tables (
  53         ACPI_PHYSICAL_ADDRESS   rsdp_physical_address)
  54 {
  55         ACPI_STATUS             status = AE_OK;
  56         u32                     number_of_tables = 0;
  57
  58
  59         /* Map and validate the RSDP */
  60
  61         status = acpi_tb_verify_rsdp (rsdp_physical_address);
  62         if (ACPI_FAILURE (status)) {
  63                 REPORT_ERROR (("Acpi_load_tables: RSDP Failed validation: %s\n",
  64                                   acpi_cm_format_exception (status)));
  65                 goto error_exit;
  66         }
  67
  68         /* Get the RSDT via the RSDP */
  69
  70         status = acpi_tb_get_table_rsdt (&number_of_tables);
  71         if (ACPI_FAILURE (status)) {
  72                 REPORT_ERROR (("Acpi_load_tables: Could not load RSDT: %s\n",
  73                                   acpi_cm_format_exception (status)));
  74                 goto error_exit;
  75         }
  76
  77         /* Now get the rest of the tables */
  78
  79         status = acpi_tb_get_all_tables (number_of_tables, NULL);
  80         if (ACPI_FAILURE (status)) {
  81                 REPORT_ERROR (("Acpi_load_tables: Error getting required tables (DSDT/FADT/FACS): %s\n",
  82                                   acpi_cm_format_exception (status)));
  83                 goto error_exit;
  84         }
  85
  86
  87         /* Load the namespace from the tables */
  88
  89         status = acpi_ns_load_namespace ();
  90         if (ACPI_FAILURE (status)) {
  91                 REPORT_ERROR (("Acpi_load_tables: Could not load namespace: %s\n",
  92                                   acpi_cm_format_exception (status)));
  93                 goto error_exit;
  94         }
  95
  96         return (AE_OK);
  97
  98
  99 error_exit:
 100         REPORT_ERROR (("Acpi_load_tables: Could not load tables: %s\n",
 101                           acpi_cm_format_exception (status)));
 102
 103         return (status);
 104 }
 105
 106
 107 /*******************************************************************************
 108  *
 109  * FUNCTION:    Acpi_load_table
 110  *
 111  * PARAMETERS:  Table_ptr       - pointer to a buffer containing the entire
 112  *                                table to be loaded
 113  *
 114  * RETURN:      Status
 115  *
 116  * DESCRIPTION: This function is called to load a table from the caller's
 117  *              buffer.  The buffer must contain an entire ACPI Table including
 118  *              a valid header.  The header fields will be verified, and if it
 119  *              is determined that the table is invalid, the call will fail.
 120  *
 121  *              If the call fails an appropriate status will be returned.
 122  *
 123  ******************************************************************************/
 124
 125 ACPI_STATUS
 126 acpi_load_table (
 127         ACPI_TABLE_HEADER       *table_ptr)
 128 {
 129         ACPI_STATUS             status;
 130         ACPI_TABLE_DESC         table_info;
 131
 132
 133         if (!table_ptr) {
 134                 return (AE_BAD_PARAMETER);
 135         }
 136
 137         /* Copy the table to a local buffer */
 138
 139         status = acpi_tb_get_table (0, table_ptr, &table_info);
 140         if (ACPI_FAILURE (status)) {
 141                 return (status);
 142         }
 143
 144         /* Install the new table into the local data structures */
 145
 146         status = acpi_tb_install_table (NULL, &table_info);
 147         if (ACPI_FAILURE (status)) {
 148                 /* Free table allocated by Acpi_tb_get_table */
 149
 150                 acpi_tb_delete_single_table (&table_info);
 151                 return (status);
 152         }
 153
 154
 155         status = acpi_ns_load_table (table_info.installed_desc, acpi_gbl_root_node);
 156         if (ACPI_FAILURE (status)) {
 157                 /* Uninstall table and free the buffer */
 158
 159                 acpi_tb_uninstall_table (table_info.installed_desc);
 160                 return (status);
 161         }
 162
 163
 164         return (status);
 165 }
 166
 167
 168 /*******************************************************************************
 169  *
 170  * FUNCTION:    Acpi_unload_table
 171  *
 172  * PARAMETERS:  Table_type    - Type of table to be unloaded
 173  *
 174  * RETURN:      Status
 175  *
 176  * DESCRIPTION: This routine is used to force the unload of a table
 177  *
 178  ******************************************************************************/
 179
 180 ACPI_STATUS
 181 acpi_unload_table (
 182         ACPI_TABLE_TYPE         table_type)
 183 {
 184         ACPI_TABLE_DESC         *list_head;
 185
 186
 187         /* Parameter validation */
 188
 189         if (table_type > ACPI_TABLE_MAX) {
 190                 return (AE_BAD_PARAMETER);
 191         }
 192
 193
 194         /* Find all tables of the requested type */
 195
 196         list_head = &acpi_gbl_acpi_tables[table_type];
 197         do
 198         {
 199                 /*
 200                  * Delete all namespace entries owned by this table.  Note that these
 201                  * entries can appear anywhere in the namespace by virtue of the AML
 202                  * "Scope" operator.  Thus, we need to track ownership by an ID, not
 203                  * simply a position within the hierarchy
 204                  */
 205
 206                 acpi_ns_delete_namespace_by_owner (list_head->table_id);
 207
 208                 /* Delete (or unmap) the actual table */
 209
 210                 acpi_tb_delete_acpi_table (table_type);
 211
 212         } while (list_head != &acpi_gbl_acpi_tables[table_type]);
 213
 214         return (AE_OK);
 215 }
 216
 217
 218 /*******************************************************************************
 219  *
 220  * FUNCTION:    Acpi_get_table_header
 221  *
 222  * PARAMETERS:  Table_type      - one of the defined table types
 223  *              Instance        - the non zero instance of the table, allows
 224  *                                support for multiple tables of the same type
 225  *                                see Acpi_gbl_Acpi_table_flag
 226  *              Out_table_header - pointer to the ACPI_TABLE_HEADER if successful
 227  *
 228  * DESCRIPTION: This function is called to get an ACPI table header.  The caller
 229  *              supplies an pointer to a data area sufficient to contain an ACPI
 230  *              ACPI_TABLE_HEADER structure.
 231  *
 232  *              The header contains a length field that can be used to determine
 233  *              the size of the buffer needed to contain the entire table.  This
 234  *              function is not valid for the RSD PTR table since it does not
 235  *              have a standard header and is fixed length.
 236  *
 237  *              If the operation fails for any reason an appropriate status will
 238  *              be returned and the contents of Out_table_header are undefined.
 239  *
 240  ******************************************************************************/
 241
 242 ACPI_STATUS
 243 acpi_get_table_header (
 244         ACPI_TABLE_TYPE         table_type,
 245         u32                     instance,
 246         ACPI_TABLE_HEADER       *out_table_header)
 247 {
 248         ACPI_TABLE_HEADER       *tbl_ptr;
 249         ACPI_STATUS             status;
 250
 251
 252         if ((instance == 0)                 ||
 253                 (table_type == ACPI_TABLE_RSDP) ||
 254                 (!out_table_header))
 255         {
 256                 return (AE_BAD_PARAMETER);
 257         }
 258
 259         /* Check the table type and instance */
 260
 261         if ((table_type > ACPI_TABLE_MAX)   ||
 262                 (IS_SINGLE_TABLE (acpi_gbl_acpi_table_data[table_type].flags) &&
 263                  instance > 1))
 264         {
 265                 return (AE_BAD_PARAMETER);
 266         }
 267
 268
 269         /* Get a pointer to the entire table */
 270
 271         status = acpi_tb_get_table_ptr (table_type, instance, &tbl_ptr);
 272         if (ACPI_FAILURE (status)) {
 273                 return (status);
 274         }
 275
 276         /*
 277          * The function will return a NULL pointer if the table is not loaded
 278          */
 279         if (tbl_ptr == NULL) {
 280                 return (AE_NOT_EXIST);
 281         }
 282
 283         /*
 284          * Copy the header to the caller's buffer
 285          */
 286         MEMCPY ((void *) out_table_header, (void *) tbl_ptr,
 287                          sizeof (ACPI_TABLE_HEADER));
 288
 289         return (status);
 290 }
 291
 292
 293 /*******************************************************************************
 294  *
 295  * FUNCTION:    Acpi_get_table
 296  *
 297  * PARAMETERS:  Table_type      - one of the defined table types
 298  *              Instance        - the non zero instance of the table, allows
 299  *                                support for multiple tables of the same type
 300  *                                see Acpi_gbl_Acpi_table_flag
 301  *              Ret_buffer      - pointer to a structure containing a buffer to
 302  *                                receive the table
 303  *
 304  * RETURN:      Status
 305  *
 306  * DESCRIPTION: This function is called to get an ACPI table.  The caller
 307  *              supplies an Out_buffer large enough to contain the entire ACPI
 308  *              table.  The caller should call the Acpi_get_table_header function
 309  *              first to determine the buffer size needed.  Upon completion
 310  *              the Out_buffer->Length field will indicate the number of bytes
 311  *              copied into the Out_buffer->Buf_ptr buffer. This table will be
 312  *              a complete table including the header.
 313  *
 314  *              If the operation fails an appropriate status will be returned
 315  *              and the contents of Out_buffer are undefined.
 316  *
 317  ******************************************************************************/
 318
 319 ACPI_STATUS
 320 acpi_get_table (
 321         ACPI_TABLE_TYPE         table_type,
 322         u32                     instance,
 323         ACPI_BUFFER             *ret_buffer)
 324 {
 325         ACPI_TABLE_HEADER       *tbl_ptr;
 326         ACPI_STATUS             status;
 327         u32                     ret_buf_len;
 328
 329
 330         /*
 331          *  If we have a buffer, we must have a length too
 332          */
 333         if ((instance == 0)                 ||
 334                 (!ret_buffer)                   ||
 335                 ((!ret_buffer->pointer) && (ret_buffer->length)))
 336         {
 337                 return (AE_BAD_PARAMETER);
 338         }
 339
 340         /* Check the table type and instance */
 341
 342         if ((table_type > ACPI_TABLE_MAX)   ||
 343                 (IS_SINGLE_TABLE (acpi_gbl_acpi_table_data[table_type].flags) &&
 344                  instance > 1))
 345         {
 346                 return (AE_BAD_PARAMETER);
 347         }
 348
 349
 350         /* Get a pointer to the entire table */
 351
 352         status = acpi_tb_get_table_ptr (table_type, instance, &tbl_ptr);
 353         if (ACPI_FAILURE (status)) {
 354                 return (status);
 355         }
 356
 357         /*
 358          * Acpi_tb_get_table_ptr will return a NULL pointer if the
 359          *  table is not loaded.
 360          */
 361         if (tbl_ptr == NULL) {
 362                 return (AE_NOT_EXIST);
 363         }
 364
 365         /*
 366          * Got a table ptr, assume it's ok and copy it to the user's buffer
 367          */
 368         if (table_type == ACPI_TABLE_RSDP) {
 369                 /*
 370                  *  RSD PTR is the only "table" without a header
 371                  */
 372                 ret_buf_len = sizeof (RSDP_DESCRIPTOR);
 373         }
 374         else {
 375                 ret_buf_len = tbl_ptr->length;
 376         }
 377
 378         /*
 379          * Verify we have space in the caller's buffer for the table
 380          */
 381         if (ret_buffer->length < ret_buf_len) {
 382                 ret_buffer->length = ret_buf_len;
 383                 return (AE_BUFFER_OVERFLOW);
 384         }
 385
 386         ret_buffer->length = ret_buf_len;
 387
 388         MEMCPY ((void *) ret_buffer->pointer, (void *) tbl_ptr, ret_buf_len);
 389
 390         return (AE_OK);
 391 }
 392