1 /******************************************************************************* 2 * 3 * Module Name: rsmem24 - Memory resource descriptors 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acresrc.h" 47 48 #define _COMPONENT ACPI_RESOURCES 49 ACPI_MODULE_NAME("rsmemory") 50 51 /******************************************************************************* 52 * 53 * acpi_rs_convert_memory24 54 * 55 ******************************************************************************/ 56 struct acpi_rsconvert_info acpi_rs_convert_memory24[4] = { 57 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY24, 58 ACPI_RS_SIZE(struct acpi_resource_memory24), 59 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory24)}, 60 61 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY24, 62 sizeof(struct aml_resource_memory24), 63 0}, 64 65 /* Read/Write bit */ 66 67 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory24.write_protect), 68 AML_OFFSET(memory24.flags), 69 0}, 70 /* 71 * These fields are contiguous in both the source and destination: 72 * Minimum Base Address 73 * Maximum Base Address 74 * Address Base Alignment 75 * Range Length 76 */ 77 {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.memory24.minimum), 78 AML_OFFSET(memory24.minimum), 79 4} 80 }; 81 82 /******************************************************************************* 83 * 84 * acpi_rs_convert_memory32 85 * 86 ******************************************************************************/ 87 88 struct acpi_rsconvert_info acpi_rs_convert_memory32[4] = { 89 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY32, 90 ACPI_RS_SIZE(struct acpi_resource_memory32), 91 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory32)}, 92 93 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY32, 94 sizeof(struct aml_resource_memory32), 95 0}, 96 97 /* Read/Write bit */ 98 99 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory32.write_protect), 100 AML_OFFSET(memory32.flags), 101 0}, 102 /* 103 * These fields are contiguous in both the source and destination: 104 * Minimum Base Address 105 * Maximum Base Address 106 * Address Base Alignment 107 * Range Length 108 */ 109 {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.memory32.minimum), 110 AML_OFFSET(memory32.minimum), 111 4} 112 }; 113 114 /******************************************************************************* 115 * 116 * acpi_rs_convert_fixed_memory32 117 * 118 ******************************************************************************/ 119 120 struct acpi_rsconvert_info acpi_rs_convert_fixed_memory32[4] = { 121 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_MEMORY32, 122 ACPI_RS_SIZE(struct acpi_resource_fixed_memory32), 123 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_memory32)}, 124 125 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_MEMORY32, 126 sizeof(struct aml_resource_fixed_memory32), 127 0}, 128 129 /* Read/Write bit */ 130 131 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.fixed_memory32.write_protect), 132 AML_OFFSET(fixed_memory32.flags), 133 0}, 134 /* 135 * These fields are contiguous in both the source and destination: 136 * Base Address 137 * Range Length 138 */ 139 {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.fixed_memory32.address), 140 AML_OFFSET(fixed_memory32.address), 141 2} 142 }; 143 144 /******************************************************************************* 145 * 146 * acpi_rs_get_vendor_small 147 * 148 ******************************************************************************/ 149 150 struct acpi_rsconvert_info acpi_rs_get_vendor_small[3] = { 151 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR, 152 ACPI_RS_SIZE(struct acpi_resource_vendor), 153 ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_small)}, 154 155 /* Length of the vendor data (byte count) */ 156 157 {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length), 158 0, 159 sizeof(u8)}, 160 161 /* Vendor data */ 162 163 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]), 164 sizeof(struct aml_resource_small_header), 165 0} 166 }; 167 168 /******************************************************************************* 169 * 170 * acpi_rs_get_vendor_large 171 * 172 ******************************************************************************/ 173 174 struct acpi_rsconvert_info acpi_rs_get_vendor_large[3] = { 175 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR, 176 ACPI_RS_SIZE(struct acpi_resource_vendor), 177 ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_large)}, 178 179 /* Length of the vendor data (byte count) */ 180 181 {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length), 182 0, 183 sizeof(u8)}, 184 185 /* Vendor data */ 186 187 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]), 188 sizeof(struct aml_resource_large_header), 189 0} 190 }; 191 192 /******************************************************************************* 193 * 194 * acpi_rs_set_vendor 195 * 196 ******************************************************************************/ 197 198 struct acpi_rsconvert_info acpi_rs_set_vendor[7] = { 199 /* Default is a small vendor descriptor */ 200 201 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_SMALL, 202 sizeof(struct aml_resource_small_header), 203 ACPI_RSC_TABLE_SIZE(acpi_rs_set_vendor)}, 204 205 /* Get the length and copy the data */ 206 207 {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length), 208 0, 209 0}, 210 211 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]), 212 sizeof(struct aml_resource_small_header), 213 0}, 214 215 /* 216 * All done if the Vendor byte length is 7 or less, meaning that it will 217 * fit within a small descriptor 218 */ 219 {ACPI_RSC_EXIT_LE, 0, 0, 7}, 220 221 /* Must create a large vendor descriptor */ 222 223 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_LARGE, 224 sizeof(struct aml_resource_large_header), 225 0}, 226 227 {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length), 228 0, 229 0}, 230 231 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]), 232 sizeof(struct aml_resource_large_header), 233 0} 234 }; 235