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