1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright (c) 2009-2010, Intel Corporation. 27 * All rights reserved. 28 */ 29 30 /* 31 * There are three types of container objects defined in the ACPI Spec as below. 32 * PNP0A05: Generic Container Device 33 * A device whose settings are totally controlled by its ACPI resource 34 * information, and otherwise needs no device or bus-specific driver support. 35 * This was originally known as Generic ISA Bus Device. 36 * This ID should only be used for containers that do not produce resources 37 * for consumption by child devices. Any system resources claimed by a PNP0A05 38 * device's _CRS object must be consumed by the container itself. 39 * PNP0A06: Generic Container Device 40 * This device behaves exactly the same as the PNP0A05 device. 41 * This was originally known as Extended I/O Bus. 42 * This ID should only be used for containers that do not produce resources 43 * for consumption by child devices. Any system resources claimed by a PNP0A06 44 * device's _CRS object must be consumed by the container itself. 45 * ACPI0004: Module Device. 46 * This device is a container object that acts as a bus node in a namespace. 47 * A Module Device without any of the _CRS, _PRS and _SRS methods behaves 48 * the same way as the Generic Container Devices (PNP0A05 or PNP0A06). 49 * If the Module Device contains a _CRS method, only the resources 50 * described in the _CRS are available for consumption by its child devices. 51 * Also, the Module Device can support _PRS and _SRS methods if _CRS is 52 * supported. 53 */ 54 55 #include <sys/types.h> 56 #include <sys/atomic.h> 57 #include <sys/note.h> 58 #include <sys/sunddi.h> 59 #include <sys/sunndi.h> 60 #include <sys/acpi/acpi.h> 61 #include <sys/acpica.h> 62 #include <sys/acpidev.h> 63 #include <sys/acpidev_dr.h> 64 #include <sys/acpidev_impl.h> 65 66 static ACPI_STATUS acpidev_container_probe(acpidev_walk_info_t *infop); 67 static acpidev_filter_result_t acpidev_container_filter( 68 acpidev_walk_info_t *infop, char *devname, int maxlen); 69 static ACPI_STATUS acpidev_container_init(acpidev_walk_info_t *infop); 70 static acpidev_filter_result_t acpidev_container_filter_func( 71 acpidev_walk_info_t *infop, ACPI_HANDLE hdl, acpidev_filter_rule_t *rulep, 72 char *devname, int devnamelen); 73 74 /* 75 * Default class driver for ACPI container objects. 76 */ 77 acpidev_class_t acpidev_class_container = { 78 0, /* adc_refcnt */ 79 ACPIDEV_CLASS_REV1, /* adc_version */ 80 ACPIDEV_CLASS_ID_CONTAINER, /* adc_class_id */ 81 "ACPI Container", /* adc_class_name */ 82 ACPIDEV_TYPE_CONTAINER, /* adc_dev_type */ 83 NULL, /* adc_private */ 84 NULL, /* adc_pre_probe */ 85 NULL, /* adc_post_probe */ 86 acpidev_container_probe, /* adc_probe */ 87 acpidev_container_filter, /* adc_filter */ 88 acpidev_container_init, /* adc_init */ 89 NULL, /* adc_fini */ 90 }; 91 92 static char *acpidev_container_device_ids[] = { 93 ACPIDEV_HID_MODULE, 94 ACPIDEV_HID_CONTAINER1, 95 ACPIDEV_HID_CONTAINER2, 96 }; 97 98 static char *acpidev_container_uid_formats[] = { 99 "CPUSCK%x", 100 }; 101 102 /* Filter rule table for container objects. */ 103 static acpidev_filter_rule_t acpidev_container_filters[] = { 104 { /* Ignore all container objects under ACPI root object */ 105 NULL, 106 0, 107 ACPIDEV_FILTER_SKIP, 108 NULL, 109 1, 110 1, 111 NULL, 112 NULL, 113 }, 114 { /* Create node and scan child for all other container objects */ 115 acpidev_container_filter_func, 116 0, 117 ACPIDEV_FILTER_DEFAULT, 118 &acpidev_class_list_device, 119 2, 120 INT_MAX, 121 NULL, 122 ACPIDEV_NODE_NAME_CONTAINER, 123 } 124 }; 125 126 static ACPI_STATUS 127 acpidev_container_probe(acpidev_walk_info_t *infop) 128 { 129 ACPI_STATUS rc = AE_OK; 130 int flags; 131 132 ASSERT(infop != NULL); 133 ASSERT(infop->awi_hdl != NULL); 134 ASSERT(infop->awi_info != NULL); 135 136 if (infop->awi_info->Type != ACPI_TYPE_DEVICE || 137 acpidev_match_device_id(infop->awi_info, 138 ACPIDEV_ARRAY_PARAM(acpidev_container_device_ids)) == 0) { 139 return (AE_OK); 140 } 141 142 flags = ACPIDEV_PROCESS_FLAG_SCAN; 143 switch (infop->awi_op_type) { 144 case ACPIDEV_OP_BOOT_PROBE: 145 if (acpica_get_devcfg_feature(ACPI_DEVCFG_CONTAINER)) { 146 flags |= ACPIDEV_PROCESS_FLAG_CREATE; 147 acpidev_dr_check(infop); 148 } 149 break; 150 151 case ACPIDEV_OP_BOOT_REPROBE: 152 break; 153 154 case ACPIDEV_OP_HOTPLUG_PROBE: 155 if (acpica_get_devcfg_feature(ACPI_DEVCFG_CONTAINER)) { 156 flags |= ACPIDEV_PROCESS_FLAG_CREATE | 157 ACPIDEV_PROCESS_FLAG_SYNCSTATUS | 158 ACPIDEV_PROCESS_FLAG_HOLDBRANCH; 159 } 160 break; 161 162 default: 163 ACPIDEV_DEBUG(CE_WARN, "!acpidev: unknown operation type %u in " 164 "acpidev_container_probe().", infop->awi_op_type); 165 rc = AE_BAD_PARAMETER; 166 break; 167 } 168 169 if (rc == AE_OK) { 170 rc = acpidev_process_object(infop, flags); 171 } 172 if (ACPI_FAILURE(rc) && rc != AE_NOT_EXIST && rc != AE_ALREADY_EXISTS) { 173 cmn_err(CE_WARN, 174 "!acpidev: failed to process container object %s.", 175 infop->awi_name); 176 } else { 177 rc = AE_OK; 178 } 179 180 return (rc); 181 } 182 183 static ACPI_STATUS 184 acpidev_container_search_dev(ACPI_HANDLE hdl, UINT32 lvl, void *ctx, 185 void **retval) 186 { 187 _NOTE(ARGUNUSED(hdl, retval)); 188 189 int *fp = (int *)ctx; 190 191 *fp = lvl; 192 193 return (AE_CTRL_TERMINATE); 194 } 195 196 static acpidev_filter_result_t 197 acpidev_container_filter_func(acpidev_walk_info_t *infop, ACPI_HANDLE hdl, 198 acpidev_filter_rule_t *rulep, char *devname, int devnamelen) 199 { 200 ACPI_BUFFER buf; 201 void *retval; 202 int proc_lvl, cpu_lvl, module_lvl; 203 acpidev_filter_result_t res; 204 static char *cpu_hids[] = { 205 ACPIDEV_HID_CPU, 206 }; 207 static char *module_hids[] = { 208 ACPIDEV_HID_MODULE, 209 }; 210 211 res = acpidev_filter_default(infop, hdl, rulep, devname, devnamelen); 212 /* Return if we don't need to generate a device name. */ 213 if (devname == NULL || res == ACPIDEV_FILTER_FAILED || 214 res == ACPIDEV_FILTER_SKIP) { 215 return (res); 216 } 217 218 /* Try to figure out the most specific device name for the object. */ 219 retval = NULL; 220 proc_lvl = INT_MAX; 221 cpu_lvl = INT_MAX; 222 module_lvl = INT_MAX; 223 224 /* Search for ACPI Processor object. */ 225 (void) AcpiWalkNamespace(ACPI_TYPE_PROCESSOR, hdl, 2, 226 acpidev_container_search_dev, NULL, &proc_lvl, &retval); 227 228 /* Search for CPU Device object. */ 229 (void) acpidev_get_device_by_id(hdl, ACPIDEV_ARRAY_PARAM(cpu_hids), 2, 230 B_FALSE, acpidev_container_search_dev, &cpu_lvl, &retval); 231 232 /* Search for Module Device object. */ 233 (void) acpidev_get_device_by_id(hdl, ACPIDEV_ARRAY_PARAM(module_hids), 234 2, B_FALSE, acpidev_container_search_dev, &module_lvl, &retval); 235 236 buf.Pointer = devname; 237 buf.Length = devnamelen; 238 if (cpu_lvl > proc_lvl) { 239 cpu_lvl = proc_lvl; 240 } 241 if (cpu_lvl == 1) { 242 /* CPU as child, most likely a physical CPU. */ 243 (void) strlcpy(devname, ACPIDEV_NODE_NAME_MODULE_CPU, 244 devnamelen); 245 } else if (cpu_lvl == 2 && module_lvl == 1) { 246 /* CPU as grandchild, most likely a system board. */ 247 (void) strlcpy(devname, ACPIDEV_NODE_NAME_MODULE_SBD, 248 devnamelen); 249 } else if (ACPI_FAILURE(AcpiGetName(infop->awi_hdl, 250 ACPI_SINGLE_NAME, &buf))) { 251 /* 252 * Failed to get ACPI object name; use ACPI object name 253 * as the default name. 254 */ 255 (void) strlcpy(devname, ACPIDEV_NODE_NAME_CONTAINER, 256 devnamelen); 257 } 258 259 return (res); 260 } 261 262 static acpidev_filter_result_t 263 acpidev_container_filter(acpidev_walk_info_t *infop, char *devname, int maxlen) 264 { 265 acpidev_filter_result_t res; 266 267 ASSERT(infop != NULL); 268 if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE || 269 infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE || 270 infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) { 271 res = acpidev_filter_device(infop, infop->awi_hdl, 272 ACPIDEV_ARRAY_PARAM(acpidev_container_filters), 273 devname, maxlen); 274 } else { 275 res = ACPIDEV_FILTER_FAILED; 276 } 277 278 return (res); 279 } 280 281 static ACPI_STATUS 282 acpidev_container_init(acpidev_walk_info_t *infop) 283 { 284 static char *compatible[] = { 285 ACPIDEV_TYPE_CONTAINER, 286 ACPIDEV_HID_VIRTNEX, 287 ACPIDEV_TYPE_VIRTNEX, 288 }; 289 290 ASSERT(infop != NULL); 291 ASSERT(infop->awi_hdl != NULL); 292 ASSERT(infop->awi_dip != NULL); 293 294 if (ACPI_FAILURE(acpidev_set_compatible(infop, 295 ACPIDEV_ARRAY_PARAM(compatible)))) { 296 return (AE_ERROR); 297 } 298 if (ACPI_FAILURE(acpidev_set_unitaddr(infop, 299 ACPIDEV_ARRAY_PARAM(acpidev_container_uid_formats), NULL))) { 300 return (AE_ERROR); 301 } 302 303 return (AE_OK); 304 } 305