1 /****************************************************************************** 2 * 3 * Module Name: hwvalid - I/O request validation 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 #define __HWVALID_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 49 #define _COMPONENT ACPI_HARDWARE 50 ACPI_MODULE_NAME ("hwvalid") 51 52 /* Local prototypes */ 53 54 static ACPI_STATUS 55 AcpiHwValidateIoRequest ( 56 ACPI_IO_ADDRESS Address, 57 UINT32 BitWidth); 58 59 60 /* 61 * Protected I/O ports. Some ports are always illegal, and some are 62 * conditionally illegal. This table must remain ordered by port address. 63 * 64 * The table is used to implement the Microsoft port access rules that 65 * first appeared in Windows XP. Some ports are always illegal, and some 66 * ports are only illegal if the BIOS calls _OSI with a WinXP string or 67 * later (meaning that the BIOS itelf is post-XP.) 68 * 69 * This provides ACPICA with the desired port protections and 70 * Microsoft compatibility. 71 * 72 * Description of port entries: 73 * DMA: DMA controller 74 * PIC0: Programmable Interrupt Controller (8259A) 75 * PIT1: System Timer 1 76 * PIT2: System Timer 2 failsafe 77 * RTC: Real-time clock 78 * CMOS: Extended CMOS 79 * DMA1: DMA 1 page registers 80 * DMA1L: DMA 1 Ch 0 low page 81 * DMA2: DMA 2 page registers 82 * DMA2L: DMA 2 low page refresh 83 * ARBC: Arbitration control 84 * SETUP: Reserved system board setup 85 * POS: POS channel select 86 * PIC1: Cascaded PIC 87 * IDMA: ISA DMA 88 * ELCR: PIC edge/level registers 89 * PCI: PCI configuration space 90 */ 91 static const ACPI_PORT_INFO AcpiProtectedPorts[] = 92 { 93 {"DMA", 0x0000, 0x000F, ACPI_OSI_WIN_XP}, 94 {"PIC0", 0x0020, 0x0021, ACPI_ALWAYS_ILLEGAL}, 95 {"PIT1", 0x0040, 0x0043, ACPI_OSI_WIN_XP}, 96 {"PIT2", 0x0048, 0x004B, ACPI_OSI_WIN_XP}, 97 {"RTC", 0x0070, 0x0071, ACPI_OSI_WIN_XP}, 98 {"CMOS", 0x0074, 0x0076, ACPI_OSI_WIN_XP}, 99 {"DMA1", 0x0081, 0x0083, ACPI_OSI_WIN_XP}, 100 {"DMA1L", 0x0087, 0x0087, ACPI_OSI_WIN_XP}, 101 {"DMA2", 0x0089, 0x008B, ACPI_OSI_WIN_XP}, 102 {"DMA2L", 0x008F, 0x008F, ACPI_OSI_WIN_XP}, 103 {"ARBC", 0x0090, 0x0091, ACPI_OSI_WIN_XP}, 104 {"SETUP", 0x0093, 0x0094, ACPI_OSI_WIN_XP}, 105 {"POS", 0x0096, 0x0097, ACPI_OSI_WIN_XP}, 106 {"PIC1", 0x00A0, 0x00A1, ACPI_ALWAYS_ILLEGAL}, 107 {"IDMA", 0x00C0, 0x00DF, ACPI_OSI_WIN_XP}, 108 {"ELCR", 0x04D0, 0x04D1, ACPI_ALWAYS_ILLEGAL}, 109 {"PCI", 0x0CF8, 0x0CFF, ACPI_OSI_WIN_XP} 110 }; 111 112 #define ACPI_PORT_INFO_ENTRIES ACPI_ARRAY_LENGTH (AcpiProtectedPorts) 113 114 115 /****************************************************************************** 116 * 117 * FUNCTION: AcpiHwValidateIoRequest 118 * 119 * PARAMETERS: Address Address of I/O port/register 120 * BitWidth Number of bits (8,16,32) 121 * 122 * RETURN: Status 123 * 124 * DESCRIPTION: Validates an I/O request (address/length). Certain ports are 125 * always illegal and some ports are only illegal depending on 126 * the requests the BIOS AML code makes to the predefined 127 * _OSI method. 128 * 129 ******************************************************************************/ 130 131 static ACPI_STATUS 132 AcpiHwValidateIoRequest ( 133 ACPI_IO_ADDRESS Address, 134 UINT32 BitWidth) 135 { 136 UINT32 i; 137 UINT32 ByteWidth; 138 ACPI_IO_ADDRESS LastAddress; 139 const ACPI_PORT_INFO *PortInfo; 140 141 142 ACPI_FUNCTION_TRACE (HwValidateIoRequest); 143 144 145 /* Supported widths are 8/16/32 */ 146 147 if ((BitWidth != 8) && 148 (BitWidth != 16) && 149 (BitWidth != 32)) 150 { 151 ACPI_ERROR ((AE_INFO, 152 "Bad BitWidth parameter: %8.8X", BitWidth)); 153 return (AE_BAD_PARAMETER); 154 } 155 156 PortInfo = AcpiProtectedPorts; 157 ByteWidth = ACPI_DIV_8 (BitWidth); 158 LastAddress = Address + ByteWidth - 1; 159 160 ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Address %p LastAddress %p Length %X", 161 ACPI_CAST_PTR (void, Address), ACPI_CAST_PTR (void, LastAddress), 162 ByteWidth)); 163 164 /* Maximum 16-bit address in I/O space */ 165 166 if (LastAddress > ACPI_UINT16_MAX) 167 { 168 ACPI_ERROR ((AE_INFO, 169 "Illegal I/O port address/length above 64K: %p/0x%X", 170 ACPI_CAST_PTR (void, Address), ByteWidth)); 171 return_ACPI_STATUS (AE_LIMIT); 172 } 173 174 /* Exit if requested address is not within the protected port table */ 175 176 if (Address > AcpiProtectedPorts[ACPI_PORT_INFO_ENTRIES - 1].End) 177 { 178 return_ACPI_STATUS (AE_OK); 179 } 180 181 /* Check request against the list of protected I/O ports */ 182 183 for (i = 0; i < ACPI_PORT_INFO_ENTRIES; i++, PortInfo++) 184 { 185 /* 186 * Check if the requested address range will write to a reserved 187 * port. Four cases to consider: 188 * 189 * 1) Address range is contained completely in the port address range 190 * 2) Address range overlaps port range at the port range start 191 * 3) Address range overlaps port range at the port range end 192 * 4) Address range completely encompasses the port range 193 */ 194 if ((Address <= PortInfo->End) && (LastAddress >= PortInfo->Start)) 195 { 196 /* Port illegality may depend on the _OSI calls made by the BIOS */ 197 198 if (AcpiGbl_OsiData >= PortInfo->OsiDependency) 199 { 200 ACPI_DEBUG_PRINT ((ACPI_DB_IO, 201 "Denied AML access to port 0x%p/%X (%s 0x%.4X-0x%.4X)", 202 ACPI_CAST_PTR (void, Address), ByteWidth, PortInfo->Name, 203 PortInfo->Start, PortInfo->End)); 204 205 return_ACPI_STATUS (AE_AML_ILLEGAL_ADDRESS); 206 } 207 } 208 209 /* Finished if address range ends before the end of this port */ 210 211 if (LastAddress <= PortInfo->End) 212 { 213 break; 214 } 215 } 216 217 return_ACPI_STATUS (AE_OK); 218 } 219 220 221 /****************************************************************************** 222 * 223 * FUNCTION: AcpiHwReadPort 224 * 225 * PARAMETERS: Address Address of I/O port/register to read 226 * Value Where value is placed 227 * Width Number of bits 228 * 229 * RETURN: Status and value read from port 230 * 231 * DESCRIPTION: Read data from an I/O port or register. This is a front-end 232 * to AcpiOsReadPort that performs validation on both the port 233 * address and the length. 234 * 235 *****************************************************************************/ 236 237 ACPI_STATUS 238 AcpiHwReadPort ( 239 ACPI_IO_ADDRESS Address, 240 UINT32 *Value, 241 UINT32 Width) 242 { 243 ACPI_STATUS Status; 244 UINT32 OneByte; 245 UINT32 i; 246 247 248 /* Truncate address to 16 bits if requested */ 249 250 if (AcpiGbl_TruncateIoAddresses) 251 { 252 Address &= ACPI_UINT16_MAX; 253 } 254 255 /* Validate the entire request and perform the I/O */ 256 257 Status = AcpiHwValidateIoRequest (Address, Width); 258 if (ACPI_SUCCESS (Status)) 259 { 260 Status = AcpiOsReadPort (Address, Value, Width); 261 return (Status); 262 } 263 264 if (Status != AE_AML_ILLEGAL_ADDRESS) 265 { 266 return (Status); 267 } 268 269 /* 270 * There has been a protection violation within the request. Fall 271 * back to byte granularity port I/O and ignore the failing bytes. 272 * This provides Windows compatibility. 273 */ 274 for (i = 0, *Value = 0; i < Width; i += 8) 275 { 276 /* Validate and read one byte */ 277 278 if (AcpiHwValidateIoRequest (Address, 8) == AE_OK) 279 { 280 Status = AcpiOsReadPort (Address, &OneByte, 8); 281 if (ACPI_FAILURE (Status)) 282 { 283 return (Status); 284 } 285 286 *Value |= (OneByte << i); 287 } 288 289 Address++; 290 } 291 292 return (AE_OK); 293 } 294 295 296 /****************************************************************************** 297 * 298 * FUNCTION: AcpiHwWritePort 299 * 300 * PARAMETERS: Address Address of I/O port/register to write 301 * Value Value to write 302 * Width Number of bits 303 * 304 * RETURN: Status 305 * 306 * DESCRIPTION: Write data to an I/O port or register. This is a front-end 307 * to AcpiOsWritePort that performs validation on both the port 308 * address and the length. 309 * 310 *****************************************************************************/ 311 312 ACPI_STATUS 313 AcpiHwWritePort ( 314 ACPI_IO_ADDRESS Address, 315 UINT32 Value, 316 UINT32 Width) 317 { 318 ACPI_STATUS Status; 319 UINT32 i; 320 321 322 /* Truncate address to 16 bits if requested */ 323 324 if (AcpiGbl_TruncateIoAddresses) 325 { 326 Address &= ACPI_UINT16_MAX; 327 } 328 329 /* Validate the entire request and perform the I/O */ 330 331 Status = AcpiHwValidateIoRequest (Address, Width); 332 if (ACPI_SUCCESS (Status)) 333 { 334 Status = AcpiOsWritePort (Address, Value, Width); 335 return (Status); 336 } 337 338 if (Status != AE_AML_ILLEGAL_ADDRESS) 339 { 340 return (Status); 341 } 342 343 /* 344 * There has been a protection violation within the request. Fall 345 * back to byte granularity port I/O and ignore the failing bytes. 346 * This provides Windows compatibility. 347 */ 348 for (i = 0; i < Width; i += 8) 349 { 350 /* Validate and write one byte */ 351 352 if (AcpiHwValidateIoRequest (Address, 8) == AE_OK) 353 { 354 Status = AcpiOsWritePort (Address, (Value >> i) & 0xFF, 8); 355 if (ACPI_FAILURE (Status)) 356 { 357 return (Status); 358 } 359 } 360 361 Address++; 362 } 363 364 return (AE_OK); 365 } 366