Merge branch 'acpi-processor' · tjh.dev/kernel@2b0181a

+15 -13

drivers/acpi/acpi_processor.c

··· 50 50 { 51 51 u8 value1 = 0; 52 52 u8 value2 = 0; 53 + struct pci_dev *ide_dev = NULL, *isa_dev = NULL; 53 54 54 55 55 56 if (!dev) ··· 108 107 * each IDE controller's DMA status to make sure we catch all 109 108 * DMA activity. 110 109 */ 111 - dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 110 + ide_dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 112 111 PCI_DEVICE_ID_INTEL_82371AB, 113 112 PCI_ANY_ID, PCI_ANY_ID, NULL); 114 - if (dev) { 115 - errata.piix4.bmisx = pci_resource_start(dev, 4); 116 - pci_dev_put(dev); 113 + if (ide_dev) { 114 + errata.piix4.bmisx = pci_resource_start(ide_dev, 4); 115 + pci_dev_put(ide_dev); 117 116 } 118 117 119 118 /* ··· 125 124 * disable C3 support if this is enabled, as some legacy 126 125 * devices won't operate well if fast DMA is disabled. 127 126 */ 128 - dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 127 + isa_dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 129 128 PCI_DEVICE_ID_INTEL_82371AB_0, 130 129 PCI_ANY_ID, PCI_ANY_ID, NULL); 131 - if (dev) { 132 - pci_read_config_byte(dev, 0x76, &value1); 133 - pci_read_config_byte(dev, 0x77, &value2); 130 + if (isa_dev) { 131 + pci_read_config_byte(isa_dev, 0x76, &value1); 132 + pci_read_config_byte(isa_dev, 0x77, &value2); 134 133 if ((value1 & 0x80) || (value2 & 0x80)) 135 134 errata.piix4.fdma = 1; 136 - pci_dev_put(dev); 135 + pci_dev_put(isa_dev); 137 136 } 138 137 139 138 break; 140 139 } 141 140 142 - if (errata.piix4.bmisx) 143 - dev_dbg(&dev->dev, "Bus master activity detection (BM-IDE) erratum enabled\n"); 144 - if (errata.piix4.fdma) 145 - dev_dbg(&dev->dev, "Type-F DMA livelock erratum (C3 disabled)\n"); 141 + if (ide_dev) 142 + dev_dbg(&ide_dev->dev, "Bus master activity detection (BM-IDE) erratum enabled\n"); 143 + 144 + if (isa_dev) 145 + dev_dbg(&isa_dev->dev, "Type-F DMA livelock erratum (C3 disabled)\n"); 146 146 147 147 return 0; 148 148 }

+10 -3

drivers/acpi/processor_driver.c

··· 166 166 if (result && !IS_ENABLED(CONFIG_ACPI_CPU_FREQ_PSS)) 167 167 dev_dbg(&device->dev, "CPPC data invalid or not present\n"); 168 168 169 - if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver) 170 - acpi_processor_power_init(pr); 169 + acpi_processor_power_init(pr); 171 170 172 171 acpi_pss_perf_init(pr); 173 172 ··· 258 259 acpi_processor_ignore_ppc_init(); 259 260 } 260 261 262 + acpi_processor_register_idle_driver(); 263 + 261 264 result = driver_register(&acpi_processor_driver); 262 265 if (result < 0) 263 - return result; 266 + goto unregister_idle_drv; 264 267 265 268 result = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, 266 269 "acpi/cpu-drv:online", ··· 284 283 acpi_idle_rescan_dead_smt_siblings(); 285 284 286 285 return 0; 286 + 287 287 err: 288 288 driver_unregister(&acpi_processor_driver); 289 + 290 + unregister_idle_drv: 291 + acpi_processor_unregister_idle_driver(); 292 + 289 293 return result; 290 294 } 291 295 ··· 308 302 cpuhp_remove_state_nocalls(hp_online); 309 303 cpuhp_remove_state_nocalls(CPUHP_ACPI_CPUDRV_DEAD); 310 304 driver_unregister(&acpi_processor_driver); 305 + acpi_processor_unregister_idle_driver(); 311 306 } 312 307 313 308 module_init(acpi_processor_driver_init);

+95 -67

drivers/acpi/processor_idle.c

··· 51 51 52 52 static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device); 53 53 54 - struct cpuidle_driver acpi_idle_driver = { 54 + static struct cpuidle_driver acpi_idle_driver = { 55 55 .name = "acpi_idle", 56 56 .owner = THIS_MODULE, 57 57 }; ··· 946 946 lpi_state->entry_method = ACPI_CSTATE_INTEGER; 947 947 lpi_state->address = obj->integer.value; 948 948 } else { 949 + pr_debug("Entry method of state-%d is invalid, disable it.\n", 950 + state_idx); 949 951 continue; 950 952 } 951 953 ··· 1180 1178 return -EINVAL; 1181 1179 } 1182 1180 1183 - static int acpi_processor_setup_lpi_states(struct acpi_processor *pr) 1181 + static void acpi_processor_setup_lpi_states(struct acpi_processor *pr) 1184 1182 { 1185 1183 int i; 1186 1184 struct acpi_lpi_state *lpi; ··· 1188 1186 struct cpuidle_driver *drv = &acpi_idle_driver; 1189 1187 1190 1188 if (!pr->flags.has_lpi) 1191 - return -EOPNOTSUPP; 1189 + return; 1192 1190 1193 1191 for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { 1194 1192 lpi = &pr->power.lpi_states[i]; ··· 1206 1204 } 1207 1205 1208 1206 drv->state_count = i; 1209 - 1210 - return 0; 1211 1207 } 1212 1208 1213 1209 /** ··· 1214 1214 * 1215 1215 * @pr: the ACPI processor 1216 1216 */ 1217 - static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 1217 + static void acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 1218 1218 { 1219 1219 int i; 1220 1220 struct cpuidle_driver *drv = &acpi_idle_driver; 1221 1221 1222 1222 if (!pr->flags.power_setup_done || !pr->flags.power) 1223 - return -EINVAL; 1223 + return; 1224 1224 1225 1225 drv->safe_state_index = -1; 1226 1226 for (i = ACPI_IDLE_STATE_START; i < CPUIDLE_STATE_MAX; i++) { ··· 1228 1228 drv->states[i].desc[0] = '\0'; 1229 1229 } 1230 1230 1231 - if (pr->flags.has_lpi) 1232 - return acpi_processor_setup_lpi_states(pr); 1231 + if (pr->flags.has_lpi) { 1232 + acpi_processor_setup_lpi_states(pr); 1233 + return; 1234 + } 1233 1235 1234 1236 acpi_processor_setup_cstates(pr); 1235 - return 0; 1236 1237 } 1237 1238 1238 1239 /** 1239 - * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE 1240 + * acpi_processor_setup_cpuidle_dev - configures CPUIDLE 1240 1241 * device i.e. per-cpu data 1241 1242 * 1242 1243 * @pr: the ACPI processor 1243 1244 * @dev : the cpuidle device 1244 1245 */ 1245 - static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr, 1246 - struct cpuidle_device *dev) 1246 + static void acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr, 1247 + struct cpuidle_device *dev) 1247 1248 { 1248 1249 if (!pr->flags.power_setup_done || !pr->flags.power || !dev) 1249 - return -EINVAL; 1250 + return; 1250 1251 1251 1252 dev->cpu = pr->id; 1252 - if (pr->flags.has_lpi) 1253 - return acpi_processor_ffh_lpi_probe(pr->id); 1254 - 1255 - acpi_processor_setup_cpuidle_cx(pr, dev); 1256 - return 0; 1253 + if (!pr->flags.has_lpi) 1254 + acpi_processor_setup_cpuidle_cx(pr, dev); 1257 1255 } 1258 1256 1259 1257 static int acpi_processor_get_power_info(struct acpi_processor *pr) ··· 1260 1262 1261 1263 ret = acpi_processor_get_lpi_info(pr); 1262 1264 if (ret) 1263 - ret = acpi_processor_get_cstate_info(pr); 1265 + return acpi_processor_get_cstate_info(pr); 1266 + 1267 + if (pr->flags.has_lpi) { 1268 + ret = acpi_processor_ffh_lpi_probe(pr->id); 1269 + if (ret) 1270 + pr_err("CPU%u: Invalid FFH LPI data\n", pr->id); 1271 + } 1264 1272 1265 1273 return ret; 1266 1274 } ··· 1351 1347 return 0; 1352 1348 } 1353 1349 1354 - static int acpi_processor_registered; 1355 - 1356 - int acpi_processor_power_init(struct acpi_processor *pr) 1350 + void acpi_processor_register_idle_driver(void) 1357 1351 { 1358 - int retval; 1352 + struct acpi_processor *pr; 1353 + int ret = -ENODEV; 1354 + int cpu; 1355 + 1356 + /* 1357 + * ACPI idle driver is used by all possible CPUs. 1358 + * Use the processor power info of one in them to set up idle states. 1359 + * Note that the existing idle handler will be used on platforms that 1360 + * only support C1. 1361 + */ 1362 + for_each_possible_cpu(cpu) { 1363 + pr = per_cpu(processors, cpu); 1364 + if (!pr) 1365 + continue; 1366 + 1367 + acpi_processor_cstate_first_run_checks(); 1368 + ret = acpi_processor_get_power_info(pr); 1369 + if (!ret) { 1370 + pr->flags.power_setup_done = 1; 1371 + acpi_processor_setup_cpuidle_states(pr); 1372 + break; 1373 + } 1374 + } 1375 + 1376 + if (ret) { 1377 + pr_debug("No ACPI power information from any CPUs.\n"); 1378 + return; 1379 + } 1380 + 1381 + ret = cpuidle_register_driver(&acpi_idle_driver); 1382 + if (ret) { 1383 + pr_debug("register %s failed.\n", acpi_idle_driver.name); 1384 + return; 1385 + } 1386 + pr_debug("%s registered with cpuidle.\n", acpi_idle_driver.name); 1387 + } 1388 + 1389 + void acpi_processor_unregister_idle_driver(void) 1390 + { 1391 + cpuidle_unregister_driver(&acpi_idle_driver); 1392 + } 1393 + 1394 + void acpi_processor_power_init(struct acpi_processor *pr) 1395 + { 1359 1396 struct cpuidle_device *dev; 1360 1397 1398 + /* 1399 + * The code below only works if the current cpuidle driver is the ACPI 1400 + * idle driver. 1401 + */ 1402 + if (cpuidle_get_driver() != &acpi_idle_driver) 1403 + return; 1404 + 1361 1405 if (disabled_by_idle_boot_param()) 1362 - return 0; 1406 + return; 1363 1407 1364 1408 acpi_processor_cstate_first_run_checks(); 1365 1409 1366 1410 if (!acpi_processor_get_power_info(pr)) 1367 1411 pr->flags.power_setup_done = 1; 1368 1412 1413 + if (!pr->flags.power) 1414 + return; 1415 + 1416 + dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1417 + if (!dev) 1418 + return; 1419 + 1420 + per_cpu(acpi_cpuidle_device, pr->id) = dev; 1421 + 1422 + acpi_processor_setup_cpuidle_dev(pr, dev); 1423 + 1369 1424 /* 1370 - * Install the idle handler if processor power management is supported. 1371 - * Note that we use previously set idle handler will be used on 1372 - * platforms that only support C1. 1425 + * Register a cpuidle device for this CPU. The cpuidle driver using 1426 + * this device is expected to be registered. 1373 1427 */ 1374 - if (pr->flags.power) { 1375 - /* Register acpi_idle_driver if not already registered */ 1376 - if (!acpi_processor_registered) { 1377 - acpi_processor_setup_cpuidle_states(pr); 1378 - retval = cpuidle_register_driver(&acpi_idle_driver); 1379 - if (retval) 1380 - return retval; 1381 - pr_debug("%s registered with cpuidle\n", 1382 - acpi_idle_driver.name); 1383 - } 1384 - 1385 - dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1386 - if (!dev) 1387 - return -ENOMEM; 1388 - per_cpu(acpi_cpuidle_device, pr->id) = dev; 1389 - 1390 - acpi_processor_setup_cpuidle_dev(pr, dev); 1391 - 1392 - /* Register per-cpu cpuidle_device. Cpuidle driver 1393 - * must already be registered before registering device 1394 - */ 1395 - retval = cpuidle_register_device(dev); 1396 - if (retval) { 1397 - if (acpi_processor_registered == 0) 1398 - cpuidle_unregister_driver(&acpi_idle_driver); 1399 - 1400 - per_cpu(acpi_cpuidle_device, pr->id) = NULL; 1401 - kfree(dev); 1402 - return retval; 1403 - } 1404 - acpi_processor_registered++; 1428 + if (cpuidle_register_device(dev)) { 1429 + per_cpu(acpi_cpuidle_device, pr->id) = NULL; 1430 + kfree(dev); 1405 1431 } 1406 - return 0; 1407 1432 } 1408 1433 1409 - int acpi_processor_power_exit(struct acpi_processor *pr) 1434 + void acpi_processor_power_exit(struct acpi_processor *pr) 1410 1435 { 1411 1436 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 1412 1437 1413 1438 if (disabled_by_idle_boot_param()) 1414 - return 0; 1439 + return; 1415 1440 1416 1441 if (pr->flags.power) { 1417 1442 cpuidle_unregister_device(dev); 1418 - acpi_processor_registered--; 1419 - if (acpi_processor_registered == 0) 1420 - cpuidle_unregister_driver(&acpi_idle_driver); 1421 - 1422 1443 kfree(dev); 1423 1444 } 1424 1445 1425 1446 pr->flags.power_setup_done = 0; 1426 - return 0; 1427 1447 } 1428 1448 1429 1449 MODULE_IMPORT_NS("ACPI_PROCESSOR_IDLE");

+6 -28

include/acpi/processor.h

··· 417 417 #endif /* CONFIG_ACPI_CPU_FREQ_PSS */ 418 418 419 419 /* in processor_idle.c */ 420 - extern struct cpuidle_driver acpi_idle_driver; 421 420 #ifdef CONFIG_ACPI_PROCESSOR_IDLE 422 - int acpi_processor_power_init(struct acpi_processor *pr); 423 - int acpi_processor_power_exit(struct acpi_processor *pr); 421 + void acpi_processor_power_init(struct acpi_processor *pr); 422 + void acpi_processor_power_exit(struct acpi_processor *pr); 424 423 int acpi_processor_power_state_has_changed(struct acpi_processor *pr); 425 424 int acpi_processor_hotplug(struct acpi_processor *pr); 426 - #else 427 - static inline int acpi_processor_power_init(struct acpi_processor *pr) 428 - { 429 - return -ENODEV; 430 - } 431 - 432 - static inline int acpi_processor_power_exit(struct acpi_processor *pr) 433 - { 434 - return -ENODEV; 435 - } 436 - 437 - static inline int acpi_processor_power_state_has_changed(struct acpi_processor *pr) 438 - { 439 - return -ENODEV; 440 - } 441 - 442 - static inline int acpi_processor_hotplug(struct acpi_processor *pr) 443 - { 444 - return -ENODEV; 445 - } 425 + void acpi_processor_register_idle_driver(void); 426 + void acpi_processor_unregister_idle_driver(void); 427 + int acpi_processor_ffh_lpi_probe(unsigned int cpu); 428 + int acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi); 446 429 #endif /* CONFIG_ACPI_PROCESSOR_IDLE */ 447 430 448 431 /* in processor_thermal.c */ ··· 447 464 return; 448 465 } 449 466 #endif /* CONFIG_CPU_FREQ */ 450 - 451 - #ifdef CONFIG_ACPI_PROCESSOR_IDLE 452 - extern int acpi_processor_ffh_lpi_probe(unsigned int cpu); 453 - extern int acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi); 454 - #endif 455 467 456 468 void acpi_processor_init_invariance_cppc(void); 457 469

Configure Feed

Configure Feed