acpi_tz.c revision 1.24
1 /* $NetBSD: acpi_tz.c,v 1.24 2007/10/07 23:14:53 xtraeme Exp $ */ 2 3 /* 4 * Copyright (c) 2003 Jared D. McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 /* 29 * ACPI Thermal Zone driver 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: acpi_tz.c,v 1.24 2007/10/07 23:14:53 xtraeme Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/errno.h> 39 #include <sys/ioctl.h> 40 #include <sys/syslog.h> 41 #include <sys/device.h> 42 #include <sys/callout.h> 43 #include <sys/proc.h> 44 #include <sys/mutex.h> 45 #include <dev/sysmon/sysmonvar.h> 46 47 #include <dev/acpi/acpica.h> 48 #include <dev/acpi/acpireg.h> 49 #include <dev/acpi/acpivar.h> 50 51 /* flags */ 52 #define ATZ_F_VERBOSE 0x01 /* show events to console */ 53 #define ATZ_F_CRITICAL 0x02 /* zone critical */ 54 #define ATZ_F_HOT 0x04 /* zone hot */ 55 #define ATZ_F_PASSIVE 0x08 /* zone passive cooling */ 56 #define ATZ_F_PASSIVEONLY 0x10 /* zone is passive cooling only */ 57 58 /* no active cooling level */ 59 #define ATZ_ACTIVE_NONE -1 60 61 /* constants */ 62 #define ATZ_TZP_RATE 300 /* default if no _TZP CM present (30 secs) */ 63 #define ATZ_NLEVELS 10 /* number of cooling levels, from ACPI spec */ 64 #define ATZ_ZEROC 2732 /* 0C in tenths degrees Kelvin */ 65 #define ATZ_TMP_INVALID 0xffffffff /* invalid temperature */ 66 #define ATZ_ZONE_EXPIRE 9000 /* zone info refetch interval (15min) */ 67 68 /* sensor indexes */ 69 #define ATZ_SENSOR_TEMP 0 /* thermal zone temperature */ 70 #define ATZ_NUMSENSORS 1 /* number of sensors */ 71 72 static int acpitz_match(struct device *, struct cfdata *, void *); 73 static void acpitz_attach(struct device *, struct device *, void *); 74 75 /* 76 * ACPI Temperature Zone information. Note all temperatures are reported 77 * in tenths of degrees Kelvin 78 */ 79 struct acpitz_zone { 80 /* Active cooling temperature threshold */ 81 UINT32 ac[ATZ_NLEVELS]; 82 /* Package of references to all active cooling devices for a level */ 83 ACPI_BUFFER al[ATZ_NLEVELS]; 84 /* Critical temperature threshold for system shutdown */ 85 UINT32 crt; 86 /* Critical temperature threshold for S4 sleep */ 87 UINT32 hot; 88 /* Package of references to processor objects for passive cooling */ 89 ACPI_BUFFER psl; 90 /* Passive cooling temperature threshold */ 91 UINT32 psv; 92 /* Thermal constants for use in passive cooling formulas */ 93 UINT32 tc1, tc2; 94 /* Current temperature of the thermal zone */ 95 UINT32 tmp; 96 /* Thermal sampling period for passive cooling, in tenths of seconds */ 97 UINT32 tsp; 98 /* Package of references to devices in this TZ (optional) */ 99 ACPI_BUFFER tzd; 100 /* Recommended TZ polling frequency, in tenths of seconds */ 101 UINT32 tzp; 102 }; 103 104 struct acpitz_softc { 105 struct device sc_dev; 106 struct acpi_devnode *sc_devnode; 107 struct acpitz_zone sc_zone; 108 struct callout sc_callout; 109 struct envsys_data sc_data[ATZ_NUMSENSORS]; 110 struct sysmon_envsys sc_sysmon; 111 kmutex_t sc_mtx; 112 int sc_active; /* active cooling level */ 113 int sc_flags; 114 int sc_rate; /* tz poll rate */ 115 int sc_zone_expire; 116 }; 117 118 static void acpitz_get_status(void *); 119 static void acpitz_get_zone(void *, int); 120 static void acpitz_get_zone_quiet(void *); 121 static char* acpitz_celcius_string(int); 122 static void acpitz_print_status(struct acpitz_softc *); 123 static void acpitz_power_off(struct acpitz_softc *); 124 static void acpitz_power_zone(struct acpitz_softc *, int, int); 125 static void acpitz_sane_temp(UINT32 *tmp); 126 static ACPI_STATUS 127 acpitz_switch_cooler(ACPI_OBJECT *, void *); 128 static void acpitz_notify_handler(ACPI_HANDLE, UINT32, void *); 129 static int acpitz_get_integer(struct acpitz_softc *, const char *, UINT32 *); 130 static void acpitz_tick(void *); 131 static void acpitz_init_envsys(struct acpitz_softc *); 132 133 CFATTACH_DECL(acpitz, sizeof(struct acpitz_softc), acpitz_match, 134 acpitz_attach, NULL, NULL); 135 136 /* 137 * acpitz_match: autoconf(9) match routine 138 */ 139 static int 140 acpitz_match(struct device *parent, struct cfdata *match, void *aux) 141 { 142 struct acpi_attach_args *aa = aux; 143 144 if (aa->aa_node->ad_type != ACPI_TYPE_THERMAL) 145 return 0; 146 147 return 1; 148 } 149 150 /* 151 * acpitz_attach: autoconf(9) attach routine 152 */ 153 static void 154 acpitz_attach(struct device *parent, struct device *self, void *aux) 155 { 156 struct acpitz_softc *sc = (struct acpitz_softc *)self; 157 struct acpi_attach_args *aa = aux; 158 ACPI_STATUS rv; 159 ACPI_INTEGER v; 160 161 mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_NONE); 162 163 #if 0 164 sc->sc_flags = ATZ_F_VERBOSE; 165 #endif 166 sc->sc_devnode = aa->aa_node; 167 168 aprint_naive(": ACPI Thermal Zone\n"); 169 aprint_normal(": ACPI Thermal Zone\n"); 170 171 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, "_TZP", &v); 172 if (ACPI_FAILURE(rv)) { 173 aprint_verbose("%s: unable to get polling interval; using default of", 174 sc->sc_dev.dv_xname); 175 sc->sc_zone.tzp = ATZ_TZP_RATE; 176 } else { 177 sc->sc_zone.tzp = v; 178 aprint_verbose("%s: polling interval is", sc->sc_dev.dv_xname); 179 } 180 aprint_verbose(" %d.%ds\n", sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10); 181 182 /* XXX a value of 0 means "polling is not necessary" */ 183 if (sc->sc_zone.tzp == 0) 184 sc->sc_zone.tzp = ATZ_TZP_RATE; 185 186 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 187 188 acpitz_get_zone(sc, 1); 189 acpitz_get_status(sc); 190 191 rv = AcpiInstallNotifyHandler(sc->sc_devnode->ad_handle, 192 ACPI_SYSTEM_NOTIFY, acpitz_notify_handler, sc); 193 if (ACPI_FAILURE(rv)) { 194 aprint_error("%s: unable to install SYSTEM NOTIFY handler: %s\n", 195 sc->sc_dev.dv_xname, AcpiFormatException(rv)); 196 return; 197 } 198 199 callout_init(&sc->sc_callout, 0); 200 callout_reset(&sc->sc_callout, sc->sc_zone.tzp * hz / 10, 201 acpitz_tick, sc); 202 203 acpitz_init_envsys(sc); 204 } 205 206 static void 207 acpitz_get_zone_quiet(void *opaque) 208 { 209 acpitz_get_zone(opaque, 0); 210 } 211 212 static void 213 acpitz_get_status(void *opaque) 214 { 215 struct acpitz_softc *sc = opaque; 216 UINT32 tmp, active; 217 int i, flags; 218 219 sc->sc_zone_expire--; 220 if (sc->sc_zone_expire <= 0) { 221 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 222 if (sc->sc_flags & ATZ_F_VERBOSE) 223 printf("%s: force refetch zone\n", sc->sc_dev.dv_xname); 224 acpitz_get_zone(sc, 0); 225 } 226 227 if (acpitz_get_integer(sc, "_TMP", &tmp)) { 228 printf("%s: failed to evaluate _TMP\n", sc->sc_dev.dv_xname); 229 return; 230 } 231 sc->sc_zone.tmp = tmp; 232 /* XXX sanity check for tmp here? */ 233 234 /* 235 * The temperature unit for envsys(4) is microKelvin, so convert to 236 * that from ACPI's microKelvin. Also, the ACPI specification assumes 237 * that K = C + 273.2 rather than the nominal 273.15 used by envsys(4), 238 * so we correct for that too. 239 */ 240 sc->sc_data[ATZ_SENSOR_TEMP].value_cur = 241 sc->sc_zone.tmp * 100000 - 50000; 242 sc->sc_data[ATZ_SENSOR_TEMP].state = ENVSYS_SVALID; 243 244 if (sc->sc_flags & ATZ_F_VERBOSE) 245 acpitz_print_status(sc); 246 247 if (sc->sc_flags & ATZ_F_PASSIVEONLY) { 248 /* Passive Cooling: XXX not yet */ 249 250 } else { 251 /* Active Cooling */ 252 253 /* temperature threshold: _AC0 > ... > _AC9 */ 254 active = ATZ_ACTIVE_NONE; 255 for (i = ATZ_NLEVELS - 1; i >= 0; i--) { 256 if (sc->sc_zone.ac[i] == ATZ_TMP_INVALID) 257 continue; 258 259 /* we want to keep highest cooling mode in 'active' */ 260 if (sc->sc_zone.ac[i] <= tmp) 261 active = i; 262 } 263 264 flags = sc->sc_flags & ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 265 if (sc->sc_zone.psv != ATZ_TMP_INVALID && 266 tmp >= sc->sc_zone.psv) 267 flags |= ATZ_F_PASSIVE; 268 if (sc->sc_zone.hot != ATZ_TMP_INVALID && 269 tmp >= sc->sc_zone.hot) 270 flags |= ATZ_F_HOT; 271 if (sc->sc_zone.crt != ATZ_TMP_INVALID && 272 tmp >= sc->sc_zone.crt) 273 flags |= ATZ_F_CRITICAL; 274 275 if (flags != sc->sc_flags) { 276 int changed = (sc->sc_flags ^ flags) & flags; 277 sc->sc_flags = flags; 278 if (changed & ATZ_F_CRITICAL) { 279 sc->sc_data[ATZ_SENSOR_TEMP].state = 280 ENVSYS_SCRITICAL; 281 printf("%s: zone went critical at temp %sC\n", 282 sc->sc_dev.dv_xname, 283 acpitz_celcius_string(tmp)); 284 } else if (changed & ATZ_F_HOT) { 285 sc->sc_data[ATZ_SENSOR_TEMP].state = 286 ENVSYS_SWARNOVER; 287 printf("%s: zone went hot at temp %sC\n", 288 sc->sc_dev.dv_xname, 289 acpitz_celcius_string(tmp)); 290 } 291 } 292 293 /* power on fans */ 294 if (sc->sc_active != active) { 295 if (sc->sc_active != ATZ_ACTIVE_NONE) 296 acpitz_power_zone(sc, sc->sc_active, 0); 297 298 if (active != ATZ_ACTIVE_NONE) { 299 if (sc->sc_flags & ATZ_F_VERBOSE) 300 printf("%s: active cooling level %u\n", 301 sc->sc_dev.dv_xname, active); 302 acpitz_power_zone(sc, active, 1); 303 } 304 305 sc->sc_active = active; 306 } 307 } 308 309 return; 310 } 311 312 static char * 313 acpitz_celcius_string(int dk) 314 { 315 static char buf[10]; 316 317 snprintf(buf, sizeof(buf), "%d.%d", (dk - ATZ_ZEROC) / 10, 318 (dk - ATZ_ZEROC) % 10); 319 320 return buf; 321 } 322 323 static void 324 acpitz_print_status(struct acpitz_softc *sc) 325 { 326 327 printf("%s: zone temperature is now %sC\n", sc->sc_dev.dv_xname, 328 acpitz_celcius_string(sc->sc_zone.tmp)); 329 330 return; 331 } 332 333 static ACPI_STATUS 334 acpitz_switch_cooler(ACPI_OBJECT *obj, void *arg) 335 { 336 ACPI_HANDLE cooler; 337 ACPI_STATUS rv; 338 int pwr_state, flag; 339 340 flag = *(int *)arg; 341 342 if (flag) 343 pwr_state = ACPI_STATE_D0; 344 else 345 pwr_state = ACPI_STATE_D3; 346 347 switch(obj->Type) { 348 case ACPI_TYPE_ANY: 349 cooler = obj->Reference.Handle; 350 break; 351 case ACPI_TYPE_STRING: 352 rv = AcpiGetHandle(NULL, obj->String.Pointer, &cooler); 353 if (ACPI_FAILURE(rv)) { 354 printf("failed to get handler from %s\n", 355 obj->String.Pointer); 356 return rv; 357 } 358 break; 359 default: 360 printf("unknown power type: %d\n", obj->Type); 361 return AE_OK; 362 } 363 364 rv = acpi_pwr_switch_consumer(cooler, pwr_state); 365 if (rv != AE_BAD_PARAMETER && ACPI_FAILURE(rv)) { 366 printf("failed to change state for %s: %s\n", 367 acpi_name(obj->Reference.Handle), 368 AcpiFormatException(rv)); 369 } 370 371 return AE_OK; 372 } 373 374 /* 375 * acpitz_power_zone: 376 * power on or off the i:th part of the zone zone 377 */ 378 static void 379 acpitz_power_zone(struct acpitz_softc *sc, int i, int on) 380 { 381 KASSERT(i >= 0 && i < ATZ_NLEVELS); 382 383 acpi_foreach_package_object(sc->sc_zone.al[i].Pointer, 384 acpitz_switch_cooler, &on); 385 } 386 387 388 /* 389 * acpitz_power_off: 390 * power off parts of the zone 391 */ 392 static void 393 acpitz_power_off(struct acpitz_softc *sc) 394 { 395 int i; 396 397 for (i = 0 ; i < ATZ_NLEVELS; i++) { 398 if (sc->sc_zone.al[i].Pointer == NULL) 399 continue; 400 acpitz_power_zone(sc, i, 0); 401 } 402 sc->sc_active = ATZ_ACTIVE_NONE; 403 sc->sc_flags &= ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 404 } 405 406 static void 407 acpitz_get_zone(void *opaque, int verbose) 408 { 409 struct acpitz_softc *sc = opaque; 410 ACPI_STATUS rv; 411 char buf[8]; 412 int i, valid_levels; 413 static int first = 1; 414 415 if (!first) { 416 acpitz_power_off(sc); 417 418 for (i = 0; i < ATZ_NLEVELS; i++) { 419 if (sc->sc_zone.al[i].Pointer != NULL) 420 AcpiOsFree(sc->sc_zone.al[i].Pointer); 421 sc->sc_zone.al[i].Pointer = NULL; 422 } 423 } 424 425 valid_levels = 0; 426 427 for (i = 0; i < ATZ_NLEVELS; i++) { 428 ACPI_OBJECT *obj; 429 430 snprintf(buf, sizeof(buf), "_AC%d", i); 431 if (acpitz_get_integer(sc, buf, &sc->sc_zone.ac[i])) 432 continue; 433 434 snprintf(buf, sizeof(buf), "_AL%d", i); 435 rv = acpi_eval_struct(sc->sc_devnode->ad_handle, buf, 436 &sc->sc_zone.al[i]); 437 if (ACPI_FAILURE(rv)) { 438 sc->sc_zone.al[i].Pointer = NULL; 439 continue; 440 } 441 442 obj = sc->sc_zone.al[i].Pointer; 443 if (obj != NULL) { 444 if (obj->Type != ACPI_TYPE_PACKAGE) { 445 printf("%s: ac%d not package\n", 446 sc->sc_dev.dv_xname, i); 447 AcpiOsFree(obj); 448 sc->sc_zone.al[i].Pointer = NULL; 449 continue; 450 } 451 } 452 453 if (first) 454 printf("%s: active cooling level %d: %sC\n", 455 sc->sc_dev.dv_xname, i, 456 acpitz_celcius_string(sc->sc_zone.ac[i])); 457 458 valid_levels++; 459 } 460 461 if (valid_levels == 0) { 462 sc->sc_flags |= ATZ_F_PASSIVEONLY; 463 if (first) 464 printf("%s: passive cooling mode only\n", 465 sc->sc_dev.dv_xname); 466 } 467 468 acpitz_get_integer(sc, "_TMP", &sc->sc_zone.tmp); 469 acpitz_get_integer(sc, "_CRT", &sc->sc_zone.crt); 470 acpitz_get_integer(sc, "_HOT", &sc->sc_zone.hot); 471 sc->sc_zone.psl.Length = ACPI_ALLOCATE_BUFFER; 472 sc->sc_zone.psl.Pointer = NULL; 473 AcpiEvaluateObject(sc, "_PSL", NULL, &sc->sc_zone.psl); 474 acpitz_get_integer(sc, "_PSV", &sc->sc_zone.psv); 475 acpitz_get_integer(sc, "_TC1", &sc->sc_zone.tc1); 476 acpitz_get_integer(sc, "_TC2", &sc->sc_zone.tc2); 477 478 acpitz_sane_temp(&sc->sc_zone.tmp); 479 acpitz_sane_temp(&sc->sc_zone.crt); 480 acpitz_sane_temp(&sc->sc_zone.hot); 481 acpitz_sane_temp(&sc->sc_zone.psv); 482 483 if (verbose) { 484 printf("%s:", sc->sc_dev.dv_xname); 485 if (sc->sc_zone.crt != ATZ_TMP_INVALID) 486 printf(" critical %sC", 487 acpitz_celcius_string(sc->sc_zone.crt)); 488 if (sc->sc_zone.hot != ATZ_TMP_INVALID) 489 printf(" hot %sC", 490 acpitz_celcius_string(sc->sc_zone.hot)); 491 if (sc->sc_zone.psv != ATZ_TMP_INVALID) 492 printf(" passive %sC", 493 acpitz_celcius_string(sc->sc_zone.tmp)); 494 printf("\n"); 495 } 496 497 for (i = 0; i < ATZ_NLEVELS; i++) 498 acpitz_sane_temp(&sc->sc_zone.ac[i]); 499 500 acpitz_power_off(sc); 501 first = 0; 502 } 503 504 505 static void 506 acpitz_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque) 507 { 508 struct acpitz_softc *sc = opaque; 509 ACPI_OSD_EXEC_CALLBACK func = NULL; 510 const char *name; 511 int rv; 512 513 switch (notify) { 514 case ACPI_NOTIFY_ThermalZoneStatusChanged: 515 func = acpitz_get_status; 516 name = "status check"; 517 break; 518 case ACPI_NOTIFY_ThermalZoneTripPointsChanged: 519 case ACPI_NOTIFY_DeviceListsChanged: 520 func = acpitz_get_zone_quiet; 521 name = "get zone"; 522 break; 523 default: 524 printf("%s: received unhandled notify message 0x%x\n", 525 sc->sc_dev.dv_xname, notify); 526 return; 527 } 528 529 KASSERT(func != NULL); 530 531 rv = AcpiOsQueueForExecution(OSD_PRIORITY_LO, func, sc); 532 if (rv != AE_OK) 533 printf("%s: unable to queue %s\n", sc->sc_dev.dv_xname, name); 534 535 return; 536 } 537 538 static void 539 acpitz_sane_temp(UINT32 *tmp) 540 { 541 /* Sane temperatures are beteen 0 and 150 C */ 542 if (*tmp < ATZ_ZEROC || *tmp > ATZ_ZEROC + 1500) 543 *tmp = ATZ_TMP_INVALID; 544 } 545 546 static int 547 acpitz_get_integer(struct acpitz_softc *sc, const char *cm, UINT32 *val) 548 { 549 ACPI_STATUS rv; 550 ACPI_INTEGER tmp; 551 552 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, cm, &tmp); 553 if (ACPI_FAILURE(rv)) { 554 #ifdef ACPI_DEBUG 555 printf("%s: failed to evaluate %s: %s\n", sc->sc_dev.dv_xname, 556 cm, AcpiFormatException(rv)); 557 #endif 558 *val = ATZ_TMP_INVALID; 559 return 1; 560 } 561 562 *val = tmp; 563 564 return 0; 565 } 566 567 static void 568 acpitz_tick(void *opaque) 569 { 570 struct acpitz_softc *sc = opaque; 571 572 callout_reset(&sc->sc_callout, sc->sc_zone.tzp * hz / 10, 573 acpitz_tick, opaque); 574 AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpitz_get_status, sc); 575 576 return; 577 } 578 579 static void 580 acpitz_init_envsys(struct acpitz_softc *sc) 581 { 582 int i; 583 584 for (i = 0; i < ATZ_NUMSENSORS; i++) { 585 sc->sc_data[i].sensor = i; 586 sc->sc_data[i].state = ENVSYS_SVALID; 587 sc->sc_data[i].monitor = true; 588 sc->sc_data[i].flags = 589 (ENVSYS_FMONCRITICAL|ENVSYS_FMONWARNOVER); 590 } 591 #define INITDATA(index, unit, string) \ 592 sc->sc_data[index].units = unit; \ 593 snprintf(sc->sc_data[index].desc, sizeof(sc->sc_data[index].desc), \ 594 "%s %s", sc->sc_dev.dv_xname, string); 595 596 INITDATA(ATZ_SENSOR_TEMP, ENVSYS_STEMP, "temperature"); 597 598 /* hook into sysmon */ 599 sc->sc_sysmon.sme_sensor_data = sc->sc_data; 600 sc->sc_sysmon.sme_name = sc->sc_dev.dv_xname; 601 sc->sc_sysmon.sme_cookie = sc; 602 sc->sc_sysmon.sme_nsensors = ATZ_NUMSENSORS; 603 sc->sc_sysmon.sme_flags = SME_DISABLE_GTREDATA; 604 605 if (sysmon_envsys_register(&sc->sc_sysmon)) 606 printf("%s: unable to register with sysmon\n", 607 sc->sc_dev.dv_xname); 608 } 609
Indexes created Tue Sep 30 11:09:46 GMT 2025