drivers/acpi/tables/tbtable.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbtable - ACPI tables: FACP, FACS, and RSDP utilities
   4  *              $Revision: 24 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000 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  */
  25
  26
  27 #include "acpi.h"
  28 #include "achware.h"
  29 #include "actables.h"
  30
  31
  32 #define _COMPONENT          TABLE_MANAGER
  33          MODULE_NAME         ("tbtable")
  34
  35
  36 /*******************************************************************************
  37  *
  38  * FUNCTION:    Acpi_tb_get_table_rsdt
  39  *
  40  * PARAMETERS:  Number_of_tables    - Where the table count is placed
  41  *
  42  * RETURN:      Status
  43  *
  44  * DESCRIPTION: Load and validate the RSDP (ptr) and RSDT (table)
  45  *
  46  ******************************************************************************/
  47
  48 ACPI_STATUS
  49 acpi_tb_get_table_rsdt (
  50         u32                     *number_of_tables)
  51 {
  52         ACPI_STATUS             status = AE_OK;
  53         ACPI_TABLE_DESC         table_info;
  54
  55
  56         /* Get the RSDP */
  57
  58         status = acpi_tb_find_rsdp (&table_info);
  59         if (ACPI_FAILURE (status)) {
  60                 REPORT_WARNING ("RSDP structure not found");
  61                 return (AE_NO_ACPI_TABLES);
  62         }
  63
  64         /* Save the table pointers and allocation info */
  65
  66         status = acpi_tb_init_table_descriptor (ACPI_TABLE_RSDP, &table_info);
  67         if (ACPI_FAILURE (status)) {
  68                 return (status);
  69         }
  70
  71         acpi_gbl_RSDP = (ROOT_SYSTEM_DESCRIPTOR_POINTER *) table_info.pointer;
  72
  73
  74         /*
  75          * RSDP structure was found;  Now get the RSDT
  76          */
  77
  78         status = acpi_tb_get_table ((void *) acpi_gbl_RSDP->rsdt_physical_address, NULL,
  79                          &table_info);
  80         if (ACPI_FAILURE (status)) {
  81                 if (status == AE_BAD_SIGNATURE) {
  82                         /* Invalid RSDT signature */
  83
  84                         REPORT_ERROR ("Invalid signature where RSDP indicates RSDT should be located");
  85
  86                 }
  87                 REPORT_ERROR ("Unable to locate RSDT");
  88
  89                 return (status);
  90         }
  91
  92
  93         /* Always delete the RSDP mapping */
  94
  95         acpi_tb_delete_acpi_table (ACPI_TABLE_RSDP);
  96
  97         /* Save the table pointers and allocation info */
  98
  99         status = acpi_tb_init_table_descriptor (ACPI_TABLE_RSDT, &table_info);
 100         if (ACPI_FAILURE (status)) {
 101                 return (status);
 102         }
 103
 104         acpi_gbl_RSDT = (ROOT_SYSTEM_DESCRIPTION_TABLE *) table_info.pointer;
 105
 106
 107         /* Valid RSDT signature, verify the checksum */
 108
 109         status = acpi_tb_verify_table_checksum ((ACPI_TABLE_HEADER *) acpi_gbl_RSDT);
 110
 111         /*
 112          * Determine the number of tables pointed to by the RSDT.
 113          * This is defined by the ACPI Specification to be the number of
 114          * pointers contained within the RSDT.  The size of the pointers
 115          * is architecture-dependent.
 116          */
 117
 118         *number_of_tables = ((acpi_gbl_RSDT->header.length -
 119                            sizeof (ACPI_TABLE_HEADER)) / sizeof (void *));
 120
 121
 122         return (status);
 123 }
 124
 125
 126 /*******************************************************************************
 127  *
 128  * FUNCTION:    Acpi_tb_scan_memory_for_rsdp
 129  *
 130  * PARAMETERS:  Start_address       - Starting pointer for search
 131  *              Length              - Maximum length to search
 132  *
 133  * RETURN:      Pointer to the RSDP if found, otherwise NULL.
 134  *
 135  * DESCRIPTION: Search a block of memory for the RSDP signature
 136  *
 137  ******************************************************************************/
 138
 139 u8 *
 140 acpi_tb_scan_memory_for_rsdp (
 141         u8                      *start_address,
 142         u32                     length)
 143 {
 144         u32                     offset;
 145         u8                      *mem_rover;
 146
 147
 148         /* Search from given start addr for the requested length  */
 149
 150         for (offset = 0, mem_rover = start_address;
 151                  offset < length;
 152                  offset += RSDP_SCAN_STEP, mem_rover += RSDP_SCAN_STEP)
 153         {
 154
 155                 /* The signature and checksum must both be correct */
 156
 157                 if (STRNCMP ((NATIVE_CHAR *) mem_rover, RSDP_SIG, sizeof (RSDP_SIG)-1) == 0 &&
 158                         acpi_tb_checksum (mem_rover,
 159                                 sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER)) == 0)
 160                 {
 161                         /* If so, we have found the RSDP */
 162
 163                         return (mem_rover);
 164                 }
 165         }
 166
 167         /* Searched entire block, no RSDP was found */
 168
 169         return (NULL);
 170 }
 171
 172
 173 /*******************************************************************************
 174  *
 175  * FUNCTION:    Acpi_tb_find_rsdp
 176  *
 177  * PARAMETERS:  *Buffer_ptr             - If == NULL, read data from buffer
 178  *                                        rather than searching memory
 179  *              *Table_info             - Where the table info is returned
 180  *
 181  * RETURN:      Status
 182  *
 183  * DESCRIPTION: Search lower 1_mbyte of memory for the root system descriptor
 184  *              pointer structure.  If it is found, set *RSDP to point to it.
 185  *
 186  *              NOTE: The RSDP must be either in the first 1_k of the Extended
 187  *              BIOS Data Area or between E0000 and FFFFF (ACPI 1.0 section
 188  *              5.2.2; assertion #421).
 189  *
 190  ******************************************************************************/
 191
 192 ACPI_STATUS
 193 acpi_tb_find_rsdp (
 194         ACPI_TABLE_DESC         *table_info)
 195 {
 196         u8                      *table_ptr;
 197         u8                      *mem_rover;
 198         ACPI_STATUS             status = AE_OK;
 199
 200         if (acpi_gbl_acpi_init_data.RSDP_physical_address) {
 201                 /*
 202                  *  RSDP address was supplied as part of the initialization data
 203                  */
 204
 205                 status = acpi_os_map_memory(acpi_gbl_acpi_init_data.RSDP_physical_address,
 206                                  sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER),
 207                                  (void **)&table_ptr);
 208
 209                 if (ACPI_FAILURE (status)) {
 210                         return (status);
 211                 }
 212
 213                 if (!table_ptr) {
 214                         return (AE_NO_MEMORY);
 215                 }
 216
 217                 /*
 218                  *  The signature and checksum must both be correct
 219                  */
 220
 221                 if (STRNCMP ((NATIVE_CHAR *) table_ptr, RSDP_SIG, sizeof (RSDP_SIG)-1) != 0) {
 222                         /* Nope, BAD Signature */
 223                         acpi_os_unmap_memory (table_ptr, sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER));
 224                         return (AE_BAD_SIGNATURE);
 225                 }
 226
 227                 /* The signature and checksum must both be correct */
 228
 229                 if (acpi_tb_checksum (table_ptr,
 230                                 sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER)) != 0)
 231                 {
 232                         /* Nope, BAD Checksum */
 233                         acpi_os_unmap_memory (table_ptr, sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER));
 234                         return (AE_BAD_CHECKSUM);
 235                 }
 236
 237                 /* RSDP supplied is OK */
 238                 /* If so, we have found the RSDP */
 239
 240                 table_info->pointer     = (ACPI_TABLE_HEADER *) table_ptr;
 241                 table_info->length      = sizeof (ROOT_SYSTEM_DESCRIPTOR_POINTER);
 242                 table_info->allocation  = ACPI_MEM_MAPPED;
 243                 table_info->base_pointer = table_ptr;
 244
 245                 return (AE_OK);
 246         }
 247
 248         /*
 249          * Search memory for RSDP.  First map low physical memory.
 250          */
 251
 252         status = acpi_os_map_memory (LO_RSDP_WINDOW_BASE, LO_RSDP_WINDOW_SIZE,
 253                           (void **)&table_ptr);
 254
 255         if (ACPI_FAILURE (status)) {
 256                 return (status);
 257         }
 258
 259         /*
 260          * 1) Search EBDA (low memory) paragraphs
 261          */
 262
 263         if (NULL != (mem_rover = acpi_tb_scan_memory_for_rsdp (table_ptr,
 264                           LO_RSDP_WINDOW_SIZE)))
 265         {
 266                 /* Found it, return pointer and don't delete the mapping */
 267
 268                 table_info->pointer     = (ACPI_TABLE_HEADER *) mem_rover;
 269                 table_info->length      = LO_RSDP_WINDOW_SIZE;
 270                 table_info->allocation  = ACPI_MEM_MAPPED;
 271                 table_info->base_pointer = table_ptr;
 272
 273                 return (AE_OK);
 274         }
 275
 276         /* This mapping is no longer needed */
 277
 278         acpi_os_unmap_memory (table_ptr, LO_RSDP_WINDOW_SIZE);
 279
 280
 281         /*
 282          * 2) Search upper memory: 16-byte boundaries in E0000h-F0000h
 283          */
 284
 285         status = acpi_os_map_memory (HI_RSDP_WINDOW_BASE, HI_RSDP_WINDOW_SIZE,
 286                           (void **)&table_ptr);
 287
 288         if (ACPI_FAILURE (status)) {
 289                 return (status);
 290         }
 291
 292         if (NULL != (mem_rover = acpi_tb_scan_memory_for_rsdp (table_ptr,
 293                           HI_RSDP_WINDOW_SIZE)))
 294         {
 295                 /* Found it, return pointer and don't delete the mapping */
 296
 297                 table_info->pointer     = (ACPI_TABLE_HEADER *) mem_rover;
 298                 table_info->length      = HI_RSDP_WINDOW_SIZE;
 299                 table_info->allocation  = ACPI_MEM_MAPPED;
 300                 table_info->base_pointer = table_ptr;
 301
 302                 return (AE_OK);
 303         }
 304
 305         /* This mapping is no longer needed */
 306
 307         acpi_os_unmap_memory (table_ptr, HI_RSDP_WINDOW_SIZE);
 308
 309
 310         /* RSDP signature was not found */
 311
 312         return (AE_NOT_FOUND);
 313 }
 314
 315
 316 /******************************************************************************
 317  *
 318  * FUNCTION:    Acpi_tb_get_table_facs
 319  *
 320  * PARAMETERS:  *Buffer_ptr             - If Buffer_ptr is valid, read data from
 321  *                                          buffer rather than searching memory
 322  *              *Table_info             - Where the table info is returned
 323  *
 324  * RETURN:      Status
 325  *
 326  * DESCRIPTION: Returns a pointer to the FACS as defined in FACP.  This
 327  *              function assumes the global variable FACP has been
 328  *              correctly initialized.  The value of FACP->Firmware_ctrl
 329  *              into a far pointer which is returned.
 330  *
 331  *****************************************************************************/
 332
 333 ACPI_STATUS
 334 acpi_tb_get_table_facs (
 335         ACPI_TABLE_HEADER       *buffer_ptr,
 336         ACPI_TABLE_DESC         *table_info)
 337 {
 338         void                    *table_ptr = NULL;
 339         u32                     size;
 340         u8                      allocation;
 341         ACPI_STATUS             status = AE_OK;
 342
 343
 344         /* Must have a valid FACP pointer */
 345
 346         if (!acpi_gbl_FACP) {
 347                 return (AE_NO_ACPI_TABLES);
 348         }
 349
 350         size = sizeof (FIRMWARE_ACPI_CONTROL_STRUCTURE);
 351         if (buffer_ptr) {
 352                 /*
 353                  * Getting table from a file -- allocate a buffer and
 354                  * read the table.
 355                  */
 356                 table_ptr = acpi_cm_allocate (size);
 357                 if(!table_ptr) {
 358                         return (AE_NO_MEMORY);
 359                 }
 360
 361                 MEMCPY (table_ptr, buffer_ptr, size);
 362
 363                 /* Save allocation type */
 364
 365                 allocation = ACPI_MEM_ALLOCATED;
 366         }
 367
 368         else {
 369                 /* Just map the physical memory to our address space */
 370
 371                 status = acpi_tb_map_acpi_table ((void *) acpi_gbl_FACP->firmware_ctrl,
 372                                    &size, &table_ptr);
 373                 if (ACPI_FAILURE(status)) {
 374                         return (status);
 375                 }
 376
 377                 /* Save allocation type */
 378
 379                 allocation = ACPI_MEM_MAPPED;
 380         }
 381
 382
 383         /* Return values */
 384
 385         table_info->pointer     = table_ptr;
 386         table_info->length      = size;
 387         table_info->allocation  = allocation;
 388         table_info->base_pointer = table_ptr;
 389
 390         return (status);
 391 }
 392