drivers/acpi/tables/tbconvrt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbconvrt - ACPI Table conversion utilities
   4  *              $Revision: 15 $
   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 #include "actbl.h"
  31
  32
  33 #define _COMPONENT          TABLE_MANAGER
  34          MODULE_NAME         ("tbconvrt")
  35
  36
  37 /*
  38  * Build a GAS structure from earlier ACPI table entries (V1.0 and 0.71 extensions)
  39  *
  40  * 1) Address space
  41  * 2) Length in bytes -- convert to length in bits
  42  * 3) Bit offset is zero
  43  * 4) Reserved field is zero
  44  * 5) Expand address to 64 bits
  45  */
  46 #define ASL_BUILD_GAS_FROM_ENTRY(a,b,c,d)   {a.address_space_id = (u8) d;\
  47                            a.register_bit_width = (u8) MUL_8 (b);\
  48                            a.register_bit_offset = 0;\
  49                            a.reserved = 0;\
  50                            a.address = (UINT64) c;}
  51
  52
  53 /* ACPI V1.0 entries -- address space is always I/O */
  54
  55 #define ASL_BUILD_GAS_FROM_V1_ENTRY(a,b,c)  ASL_BUILD_GAS_FROM_ENTRY(a,b,c,ADDRESS_SPACE_SYSTEM_IO)
  56
  57
  58 /*******************************************************************************
  59  *
  60  * FUNCTION:    Acpi_tb_convert_to_xsdt
  61  *
  62  * PARAMETERS:
  63  *
  64  * RETURN:
  65  *
  66  * DESCRIPTION:
  67  *
  68  ******************************************************************************/
  69
  70 ACPI_STATUS
  71 acpi_tb_convert_to_xsdt (
  72         ACPI_TABLE_DESC         *table_info,
  73         u32                     *number_of_tables)
  74 {
  75         u32                     table_size;
  76         u32                     pointer_size;
  77         u32                     i;
  78         XSDT_DESCRIPTOR         *new_table;
  79
  80
  81 #ifndef _IA64
  82
  83         if (acpi_gbl_RSDP->revision < 2) {
  84                 pointer_size = sizeof (u32);
  85         }
  86
  87         else
  88 #endif
  89         {
  90                 pointer_size = sizeof (UINT64);
  91         }
  92
  93         /*
  94          * Determine the number of tables pointed to by the RSDT/XSDT.
  95          * This is defined by the ACPI Specification to be the number of
  96          * pointers contained within the RSDT/XSDT.  The size of the pointers
  97          * is architecture-dependent.
  98          */
  99
 100         table_size = table_info->pointer->length;
 101         *number_of_tables = (table_size -
 102                            sizeof (ACPI_TABLE_HEADER)) / pointer_size;
 103
 104         /* Compute size of the converted XSDT */
 105
 106         table_size = (*number_of_tables * sizeof (UINT64)) + sizeof (ACPI_TABLE_HEADER);
 107
 108
 109         /* Allocate an XSDT */
 110
 111         new_table = acpi_cm_callocate (table_size);
 112         if (!new_table) {
 113                 return (AE_NO_MEMORY);
 114         }
 115
 116         /* Copy the header and set the length */
 117
 118         MEMCPY (new_table, table_info->pointer, sizeof (ACPI_TABLE_HEADER));
 119         new_table->header.length = table_size;
 120
 121         /* Copy the table pointers */
 122
 123         for (i = 0; i < *number_of_tables; i++) {
 124                 if (acpi_gbl_RSDP->revision < 2) {
 125 #ifdef _IA64
 126                         new_table->table_offset_entry[i] =
 127                                 ((RSDT_DESCRIPTOR_REV071 *) table_info->pointer)->table_offset_entry[i];
 128 #else
 129                         new_table->table_offset_entry[i] =
 130                                 ((RSDT_DESCRIPTOR_REV1 *) table_info->pointer)->table_offset_entry[i];
 131 #endif
 132                 }
 133                 else {
 134                         new_table->table_offset_entry[i] =
 135                                 ((XSDT_DESCRIPTOR *) table_info->pointer)->table_offset_entry[i];
 136                 }
 137         }
 138
 139
 140         /* Delete the original table (either mapped or in a buffer) */
 141
 142         acpi_tb_delete_single_table (table_info);
 143
 144
 145         /* Point the table descriptor to the new table */
 146
 147         table_info->pointer     = (ACPI_TABLE_HEADER *) new_table;
 148         table_info->base_pointer = (ACPI_TABLE_HEADER *) new_table;
 149         table_info->length      = table_size;
 150         table_info->allocation  = ACPI_MEM_ALLOCATED;
 151
 152         return (AE_OK);
 153 }
 154
 155
 156 /*******************************************************************************
 157  *
 158  * FUNCTION:    Acpi_tb_convert_table_fadt
 159  *
 160  * PARAMETERS:
 161  *
 162  * RETURN:
 163  *
 164  * DESCRIPTION:
 165  *    Converts BIOS supplied 1.0 and 0.71 ACPI FADT to an intermediate
 166  *    ACPI 2.0 FADT. If the BIOS supplied a 2.0 FADT then it is simply
 167  *    copied to the intermediate FADT.  The ACPI CA software uses this
 168  *    intermediate FADT. Thus a significant amount of special #ifdef
 169  *    type codeing is saved. This intermediate FADT will need to be
 170  *    freed at some point.
 171  *
 172  ******************************************************************************/
 173
 174 ACPI_STATUS
 175 acpi_tb_convert_table_fadt (void)
 176 {
 177
 178 #ifdef _IA64
 179         FADT_DESCRIPTOR_REV071 *FADT71;
 180         u8                      pm1_address_space;
 181         u8                      pm2_address_space;
 182         u8                      pm_timer_address_space;
 183         u8                      gpe0address_space;
 184         u8                      gpe1_address_space;
 185 #else
 186         FADT_DESCRIPTOR_REV1   *FADT1;
 187 #endif
 188
 189         FADT_DESCRIPTOR_REV2   *FADT2;
 190         ACPI_TABLE_DESC        *table_desc;
 191
 192
 193         /* Acpi_gbl_FADT is valid */
 194         /* Allocate and zero the 2.0 buffer */
 195
 196         FADT2 = acpi_cm_callocate (sizeof (FADT_DESCRIPTOR_REV2));
 197         if (FADT2 == NULL) {
 198                 return (AE_NO_MEMORY);
 199         }
 200
 201
 202         /* The ACPI FADT revision number is FADT2_REVISION_ID=3 */
 203         /* So, if the current table revision is less than 3 it is type 1.0 or 0.71 */
 204
 205         if (acpi_gbl_FADT->header.revision >= FADT2_REVISION_ID) {
 206                 /* We have an ACPI 2.0 FADT but we must copy it to our local buffer */
 207
 208                 *FADT2 = *((FADT_DESCRIPTOR_REV2*) acpi_gbl_FADT);
 209
 210         }
 211
 212         else {
 213
 214 #ifdef _IA64
 215                 /*
 216                  * For the 64-bit case only, a revision ID less than V2.0 means the
 217                  * tables are the 0.71 extensions
 218                  */
 219
 220                 /* The BIOS stored FADT should agree with Revision 0.71 */
 221
 222                 FADT71 = (FADT_DESCRIPTOR_REV071 *) acpi_gbl_FADT;
 223
 224                 /* Copy the table header*/
 225
 226                 FADT2->header       = FADT71->header;
 227
 228                 /* Copy the common fields */
 229
 230                 FADT2->sci_int      = FADT71->sci_int;
 231                 FADT2->acpi_enable  = FADT71->acpi_enable;
 232                 FADT2->acpi_disable = FADT71->acpi_disable;
 233                 FADT2->S4_bios_req  = FADT71->S4_bios_req;
 234                 FADT2->plvl2_lat    = FADT71->plvl2_lat;
 235                 FADT2->plvl3_lat    = FADT71->plvl3_lat;
 236                 FADT2->day_alrm     = FADT71->day_alrm;
 237                 FADT2->mon_alrm     = FADT71->mon_alrm;
 238                 FADT2->century      = FADT71->century;
 239                 FADT2->gpe1_base    = FADT71->gpe1_base;
 240
 241                 /*
 242                  * We still use the block length registers even though
 243                  * the GAS structure should obsolete them.  This is because
 244                  * these registers are byte lengths versus the GAS which
 245                  * contains a bit width
 246                  */
 247                 FADT2->pm1_evt_len  = FADT71->pm1_evt_len;
 248                 FADT2->pm1_cnt_len  = FADT71->pm1_cnt_len;
 249                 FADT2->pm2_cnt_len  = FADT71->pm2_cnt_len;
 250                 FADT2->pm_tm_len    = FADT71->pm_tm_len;
 251                 FADT2->gpe0blk_len  = FADT71->gpe0blk_len;
 252                 FADT2->gpe1_blk_len = FADT71->gpe1_blk_len;
 253                 FADT2->gpe1_base    = FADT71->gpe1_base;
 254
 255                 /* Copy the existing 0.71 flags to 2.0. The other bits are zero.*/
 256
 257                 FADT2->wb_invd      = FADT71->flush_cash;
 258                 FADT2->proc_c1      = FADT71->proc_c1;
 259                 FADT2->plvl2_up     = FADT71->plvl2_up;
 260                 FADT2->pwr_button   = FADT71->pwr_button;
 261                 FADT2->sleep_button = FADT71->sleep_button;
 262                 FADT2->fixed_rTC    = FADT71->fixed_rTC;
 263                 FADT2->rtcs4        = FADT71->rtcs4;
 264                 FADT2->tmr_val_ext  = FADT71->tmr_val_ext;
 265                 FADT2->dock_cap     = FADT71->dock_cap;
 266
 267
 268                 /* We should not use these next two addresses */
 269                 /* Since our buffer is pre-zeroed nothing to do for */
 270                 /* the next three data items in the structure */
 271                 /* FADT2->Firmware_ctrl = 0; */
 272                 /* FADT2->Dsdt = 0; */
 273
 274                 /* System Interrupt Model isn't used in ACPI 2.0*/
 275                 /* FADT2->Reserved1 = 0; */
 276
 277                 /* This field is set by the OEM to convey the preferred */
 278                 /* power management profile to OSPM. It doesn't have any*/
 279                 /* 0.71 equivalence.  Since we don't know what kind of  */
 280                 /* 64-bit system this is, we will pick unspecified.     */
 281
 282                 FADT2->prefer_PM_profile = PM_UNSPECIFIED;
 283
 284
 285                 /* Port address of SMI command port */
 286                 /* We shouldn't use this port because IA64 doesn't */
 287                 /* have or use SMI.  It has PMI. */
 288
 289                 FADT2->smi_cmd      = (u32)(FADT71->smi_cmd & 0xFFFFFFFF);
 290
 291
 292                 /* processor performance state control*/
 293                 /* The value OSPM writes to the SMI_CMD register to assume */
 294                 /* processor performance state control responsibility. */
 295                 /* There isn't any equivalence in 0.71 */
 296                 /* Again this should be meaningless for IA64 */
 297                 /* FADT2->Pstate_cnt = 0; */
 298
 299                 /* The 32-bit Power management and GPE registers are */
 300                 /* not valid in IA-64 and we are not going to use them */
 301                 /* so leaving them pre-zeroed. */
 302
 303                 /* Support for the _CST object and C States change notification.*/
 304                 /* This data item hasn't any 0.71 equivalence so leaving it zero.*/
 305                 /* FADT2->Cst_cnt = 0; */
 306
 307                 /* number of flush strides that need to be read */
 308                 /* No 0.71 equivalence. Leave pre-zeroed. */
 309                 /* FADT2->Flush_size = 0; */
 310
 311                 /* Processor's memory cache line width, in bytes */
 312                 /* No 0.71 equivalence. Leave pre-zeroed. */
 313                 /* FADT2->Flush_stride = 0; */
 314
 315                 /* Processor’s duty cycle index in processor's P_CNT reg*/
 316                 /* No 0.71 equivalence. Leave pre-zeroed. */
 317                 /* FADT2->Duty_offset = 0; */
 318
 319                 /* Processor’s duty cycle value bit width in P_CNT register.*/
 320                 /* No 0.71 equivalence. Leave pre-zeroed. */
 321                 /* FADT2->Duty_width = 0; */
 322
 323
 324                 /* Since there isn't any equivalence in 0.71 */
 325                 /* and since Big_sur had to support legacy */
 326
 327                 FADT2->iapc_boot_arch = BAF_LEGACY_DEVICES;
 328
 329                 /* Copy to ACPI 2.0 64-BIT Extended Addresses */
 330
 331                 FADT2->Xfirmware_ctrl = FADT71->firmware_ctrl;
 332                 FADT2->Xdsdt         = FADT71->dsdt;
 333
 334
 335                 /* Extract the address space IDs */
 336
 337                 pm1_address_space   = (u8)((FADT71->address_space & PM1_BLK_ADDRESS_SPACE)    >> 1);
 338                 pm2_address_space   = (u8)((FADT71->address_space & PM2_CNT_BLK_ADDRESS_SPACE) >> 2);
 339                 pm_timer_address_space = (u8)((FADT71->address_space & PM_TMR_BLK_ADDRESS_SPACE) >> 3);
 340                 gpe0address_space   = (u8)((FADT71->address_space & GPE0_BLK_ADDRESS_SPACE)   >> 4);
 341                 gpe1_address_space  = (u8)((FADT71->address_space & GPE1_BLK_ADDRESS_SPACE)   >> 5);
 342
 343                 /*
 344                  * Convert the 0.71 (non-GAS style) Block addresses to V2.0 GAS structures,
 345                  * in this order:
 346                  *
 347                  * PM 1_a Events
 348                  * PM 1_b Events
 349                  * PM 1_a Control
 350                  * PM 1_b Control
 351                  * PM 2 Control
 352                  * PM Timer Control
 353                  * GPE Block 0
 354                  * GPE Block 1
 355                  */
 356
 357                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm1a_evt_blk, FADT71->pm1_evt_len, FADT71->pm1a_evt_blk, pm1_address_space);
 358                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm1b_evt_blk, FADT71->pm1_evt_len, FADT71->pm1b_evt_blk, pm1_address_space);
 359                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm1a_cnt_blk, FADT71->pm1_cnt_len, FADT71->pm1a_cnt_blk, pm1_address_space);
 360                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm1b_cnt_blk, FADT71->pm1_cnt_len, FADT71->pm1b_cnt_blk, pm1_address_space);
 361                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm2_cnt_blk, FADT71->pm2_cnt_len, FADT71->pm2_cnt_blk, pm2_address_space);
 362                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xpm_tmr_blk, FADT71->pm_tm_len,  FADT71->pm_tmr_blk, pm_timer_address_space);
 363                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xgpe0blk,    FADT71->gpe0blk_len, FADT71->gpe0blk,   gpe0address_space);
 364                 ASL_BUILD_GAS_FROM_ENTRY (FADT2->Xgpe1_blk,   FADT71->gpe1_blk_len, FADT71->gpe1_blk, gpe1_address_space);
 365
 366 #else
 367
 368                 /* ACPI 1.0 FACS */
 369
 370
 371                 /* The BIOS stored FADT should agree with Revision 1.0 */
 372
 373                 FADT1 = (FADT_DESCRIPTOR_REV1*) acpi_gbl_FADT;
 374
 375                 /*
 376                  * Copy the table header and the common part of the tables
 377                  * The 2.0 table is an extension of the 1.0 table, so the
 378                  * entire 1.0 table can be copied first, then expand some
 379                  * fields to 64 bits.
 380                  */
 381
 382                 MEMCPY (FADT2, FADT1, sizeof (FADT_DESCRIPTOR_REV1));
 383
 384
 385                 /* Convert table pointers to 64-bit fields */
 386
 387                 FADT2->Xfirmware_ctrl = (UINT64) FADT1->firmware_ctrl;
 388                 FADT2->Xdsdt         = (UINT64) FADT1->dsdt;
 389
 390                 /* System Interrupt Model isn't used in ACPI 2.0*/
 391                 /* FADT2->Reserved1 = 0; */
 392
 393                 /* This field is set by the OEM to convey the preferred */
 394                 /* power management profile to OSPM. It doesn't have any*/
 395                 /* 1.0 equivalence.  Since we don't know what kind of   */
 396                 /* 32-bit system this is, we will pick unspecified.     */
 397
 398                 FADT2->prefer_PM_profile = PM_UNSPECIFIED;
 399
 400
 401                 /* Processor Performance State Control. This is the value  */
 402                 /* OSPM writes to the SMI_CMD register to assume processor */
 403                 /* performance state control responsibility. There isn't   */
 404                 /* any equivalence in 1.0.  So leave it zeroed.            */
 405
 406                 FADT2->pstate_cnt = 0;
 407
 408
 409                 /* Support for the _CST object and C States change notification.*/
 410                 /* This data item hasn't any 1.0 equivalence so leaving it zero.*/
 411
 412                 FADT2->cst_cnt = 0;
 413
 414
 415                 /* Since there isn't any equivalence in 1.0 and since it   */
 416                 /* is highly likely that a 1.0 system has legacy  support. */
 417
 418                 FADT2->iapc_boot_arch = BAF_LEGACY_DEVICES;
 419
 420
 421                 /*
 422                  * Convert the V1.0 Block addresses to V2.0 GAS structures
 423                  * in this order:
 424                  *
 425                  * PM 1_a Events
 426                  * PM 1_b Events
 427                  * PM 1_a Control
 428                  * PM 1_b Control
 429                  * PM 2 Control
 430                  * PM Timer Control
 431                  * GPE Block 0
 432                  * GPE Block 1
 433                  */
 434
 435                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm1a_evt_blk, FADT1->pm1_evt_len, FADT1->pm1a_evt_blk);
 436                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm1b_evt_blk, FADT1->pm1_evt_len, FADT1->pm1b_evt_blk);
 437                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm1a_cnt_blk, FADT1->pm1_cnt_len, FADT1->pm1a_cnt_blk);
 438                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm1b_cnt_blk, FADT1->pm1_cnt_len, FADT1->pm1b_cnt_blk);
 439                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm2_cnt_blk, FADT1->pm2_cnt_len, FADT1->pm2_cnt_blk);
 440                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xpm_tmr_blk, FADT1->pm_tm_len,  FADT1->pm_tmr_blk);
 441                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xgpe0blk,    FADT1->gpe0blk_len, FADT1->gpe0blk);
 442                 ASL_BUILD_GAS_FROM_V1_ENTRY (FADT2->Xgpe1_blk,   FADT1->gpe1_blk_len, FADT1->gpe1_blk);
 443 #endif
 444         }
 445
 446
 447         /*
 448          * Global FADT pointer will point to the common V2.0 FADT
 449          */
 450         acpi_gbl_FADT = FADT2;
 451
 452
 453         /* Free the original table */
 454
 455         table_desc = &acpi_gbl_acpi_tables[ACPI_TABLE_FADT];
 456         acpi_tb_delete_single_table (table_desc);
 457
 458
 459         /* Install the new table */
 460
 461         table_desc->pointer = (ACPI_TABLE_HEADER *) acpi_gbl_FADT;
 462         table_desc->base_pointer = acpi_gbl_FADT;
 463         table_desc->allocation = ACPI_MEM_ALLOCATED;
 464         table_desc->length = sizeof (FADT_DESCRIPTOR_REV2);
 465
 466
 467         /* Dump the FADT Header */
 468
 469         /* Dump the entire FADT */
 470
 471
 472         return (AE_OK);
 473 }
 474
 475
 476 /*******************************************************************************
 477  *
 478  * FUNCTION:    Acpi_tb_convert_table_facs
 479  *
 480  * PARAMETERS:
 481  *
 482  * RETURN:
 483  *
 484  * DESCRIPTION:
 485  *
 486  ******************************************************************************/
 487
 488 ACPI_STATUS
 489 acpi_tb_build_common_facs (
 490         ACPI_TABLE_DESC         *table_info)
 491 {
 492         ACPI_COMMON_FACS        *common_facs;
 493
 494 #ifdef _IA64
 495         FACS_DESCRIPTOR_REV071  *FACS71;
 496 #else
 497         FACS_DESCRIPTOR_REV1    *FACS1;
 498 #endif
 499
 500         FACS_DESCRIPTOR_REV2    *FACS2;
 501
 502
 503         /* Allocate a common FACS */
 504
 505         common_facs = acpi_cm_callocate (sizeof (ACPI_COMMON_FACS));
 506         if (!common_facs) {
 507                 return (AE_NO_MEMORY);
 508         }
 509
 510
 511         /* Copy fields to the new FACS */
 512
 513         if (acpi_gbl_RSDP->revision < 2) {
 514 #ifdef _IA64
 515                 /* 0.71 FACS */
 516
 517                 FACS71 = (FACS_DESCRIPTOR_REV071 *) acpi_gbl_FACS;
 518
 519                 common_facs->global_lock = (u32 *) &(FACS71->global_lock);
 520                 common_facs->firmware_waking_vector = &FACS71->firmware_waking_vector;
 521                 common_facs->vector_width = 64;
 522 #else
 523                 /* ACPI 1.0 FACS */
 524
 525                 FACS1 = (FACS_DESCRIPTOR_REV1 *) acpi_gbl_FACS;
 526
 527                 common_facs->global_lock = &(FACS1->global_lock);
 528                 common_facs->firmware_waking_vector = (UINT64 *) &FACS1->firmware_waking_vector;
 529                 common_facs->vector_width = 32;
 530
 531 #endif
 532         }
 533
 534         else {
 535                 /* ACPI 2.0 FACS */
 536
 537                 FACS2 = (FACS_DESCRIPTOR_REV2 *) acpi_gbl_FACS;
 538
 539                 common_facs->global_lock = &(FACS2->global_lock);
 540                 common_facs->firmware_waking_vector = &FACS2->Xfirmware_waking_vector;
 541                 common_facs->vector_width = 64;
 542         }
 543
 544
 545         /* Set the global FACS pointer to point to the common FACS */
 546
 547
 548         acpi_gbl_FACS = common_facs;
 549
 550         return  (AE_OK);
 551 }
 552
 553