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 /* 27 * ppm driver subroutines 28 */ 29 30 #include <sys/open.h> 31 #include <sys/file.h> 32 #include <sys/conf.h> 33 #include <sys/epm.h> 34 #include <sys/sunldi.h> 35 #include <sys/ppmvar.h> 36 #include <sys/ppmio.h> 37 #include <sys/promif.h> 38 #include <sys/ddi_impldefs.h> 39 #include <sys/ddi.h> 40 #include <sys/sunddi.h> 41 /* 42 * Append address to the device path, if it is set. Routine 43 * ddi_pathname does not look for device address if the node is in 44 * DS_INITIALIZED state. 45 */ 46 #define PPM_GET_PATHNAME(dip, path) \ 47 (void) ddi_pathname((dip), (path)); \ 48 if ((i_ddi_node_state((dip)) < DS_INITIALIZED) && \ 49 (ddi_get_name_addr((dip)) != NULL)) { \ 50 (void) strcat((path), "@"); \ 51 (void) strcat((path), ddi_get_name_addr((dip)));\ 52 } 53 54 int ppm_parse_dc(char **, ppm_dc_t *); 55 int ppm_match_devs(char *, ppm_db_t *); 56 ppm_db_t *ppm_parse_pattern(struct ppm_db **, char *); 57 int ppm_count_char(char *, char); 58 int ppm_stoi(char *, uint_t *); 59 int ppm_convert(char *, uint_t *); 60 void ppm_prop_free(struct ppm_cdata **); 61 62 /* 63 * lookup string property from configuration file ppm.conf 64 */ 65 static int 66 ppm_get_confdata(struct ppm_cdata **cdp, dev_info_t *dip) 67 { 68 #ifdef DEBUG 69 char *str = "ppm_get_confdata"; 70 #endif 71 struct ppm_cdata *cinfo; 72 int err; 73 74 for (; (cinfo = *cdp) != NULL; cdp++) { 75 err = ddi_prop_lookup_string_array( 76 DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 77 cinfo->name, &cinfo->strings, &cinfo->cnt); 78 if (err != DDI_PROP_SUCCESS) { 79 PPMD(D_ERROR, ("%s: no %s found, err(%d)\n", 80 str, cinfo->name, err)) 81 break; 82 } 83 } 84 return (err); 85 } 86 87 void 88 ppm_prop_free(struct ppm_cdata **cdp) 89 { 90 if (cdp) { 91 for (; *cdp; cdp++) { 92 if ((*cdp)->name) { 93 kmem_free((*cdp)->name, 94 strlen((*cdp)->name) + 1); 95 (*cdp)->name = NULL; 96 } 97 if ((*cdp)->strings) { 98 ddi_prop_free((*cdp)->strings); 99 (*cdp)->strings = NULL; 100 } 101 } 102 } 103 } 104 105 106 /* 107 * free ddi prop strings. Under error condition, free ppm_db_t lists as well. 108 */ 109 static int 110 ppm_attach_err(struct ppm_cdata **cdp, int err) 111 { 112 ppm_domain_t *domp; 113 ppm_db_t *db, *tmp; 114 115 ppm_prop_free(cdp); 116 if (err != DDI_SUCCESS) { 117 for (domp = ppm_domain_p; domp; domp = domp->next) { 118 for (db = domp->conflist; (tmp = db) != NULL; ) { 119 db = db->next; 120 kmem_free(tmp->name, strlen(tmp->name) + 1); 121 kmem_free(tmp, sizeof (*tmp)); 122 } 123 domp->conflist = NULL; 124 } 125 err = DDI_FAILURE; 126 } 127 128 return (err); 129 } 130 131 132 ppm_domain_t * 133 ppm_lookup_domain(char *dname) 134 { 135 ppm_domain_t *domp; 136 137 for (domp = ppm_domain_p; domp; domp = domp->next) { 138 if (strcmp(dname, domp->name) == 0) 139 break; 140 } 141 return (domp); 142 } 143 144 145 /* 146 * for the purpose of optimizing we search for identical dc->path 147 * that has been opened per previous visit here. If search results 148 * in a hit, copy the device handle, else open the device. 149 */ 150 ppm_dc_t * 151 ppm_lookup_hndl(int model, ppm_dc_t *key_dc) 152 { 153 #ifdef DEBUG 154 char *str = "ppm_lookup_hndl"; 155 #endif 156 char *key_path = key_dc->path; 157 ppm_domain_t *domp; 158 ppm_dc_t *dc; 159 160 /* search domain by domain.model */ 161 for (domp = ppm_domain_p; domp; domp = domp->next) { 162 if (domp->model == model) 163 break; 164 } 165 166 /* lookup hndl from same domain model */ 167 if (domp && PPM_DOMAIN_UP(domp)) { 168 for (dc = domp->dc; dc; dc = dc->next) { 169 if ((strcmp(dc->path, key_path) == 0) && 170 (dc->lh != NULL)) { 171 PPMD(D_PPMDC, ("%s: Hit(dc_path:%s) from SAME " 172 "domain %s.\n", str, key_path, domp->name)) 173 key_dc->lh = dc->lh; 174 return (key_dc); 175 } 176 } 177 } 178 179 /* otherwise, check other domains */ 180 for (domp = ppm_domain_p; 181 domp && (domp->model != model); domp = domp->next) { 182 if (PPM_DOMAIN_UP(domp)) { 183 for (dc = domp->dc; dc; dc = dc->next) { 184 if ((strcmp(dc->path, key_path) == 0) && 185 (dc->lh != NULL)) { 186 PPMD(D_PPMDC, ("%s: Hit(dc_path:%s) " 187 "from domain %s\n", 188 str, key_path, domp->name)) 189 key_dc->lh = dc->lh; 190 return (key_dc); 191 } 192 } 193 } 194 } 195 196 PPMD(D_PPMDC, ("%s: Miss(dc_path:%s)\n", str, key_path)) 197 return (NULL); 198 } 199 200 201 #define PPM_DOMAIN_PROP "ppm-domains" 202 #define PPM_DEV_PROP_SUFFIX "-devices" 203 #define PPM_MODEL_PROP_SUFFIX "-model" 204 #define PPM_PROPNAME_PROP_SUFFIX "-propname" 205 #define PPM_CTRL_PROP_SUFFIX "-control" 206 207 struct ppm_domit ppm_domit_data[] = { 208 { "SX", PPMD_SX, 0, PPMD_ON }, 209 { "CPU", PPMD_CPU, PPMD_LOCK_ALL, PPMD_ON }, 210 { "FET", PPMD_FET, PPMD_LOCK_ONE, PPMD_ON }, 211 { "PCI", PPMD_PCI, PPMD_LOCK_ONE, PPMD_ON }, 212 { "PCI_PROP", PPMD_PCI_PROP, PPMD_LOCK_ONE, PPMD_ON }, 213 { "LED", PPMD_LED, 0, PPMD_ON }, 214 { "PCIE", PPMD_PCIE, PPMD_LOCK_ONE, PPMD_ON }, 215 { NULL } 216 }; 217 218 /* 219 * store up platform dependent information provided by ppm.conf file 220 * into private data base 221 */ 222 int 223 ppm_create_db(dev_info_t *dip) 224 { 225 #ifdef DEBUG 226 char *str = "ppm_create_db"; 227 #endif 228 ppm_domain_t *domp; 229 ppm_db_t *db; 230 ppm_dc_t *dc; 231 struct ppm_cdata domdata; /* hold "ppm-domains" property */ 232 struct ppm_cdata modeldata; /* hold "domain_xy-model" property */ 233 struct ppm_cdata propnamedata; /* hold "domain_xy-propname" property */ 234 struct ppm_cdata devdata; /* hold "domain_xy-devices" property */ 235 struct ppm_cdata dcdata; /* hold "domain_xy-control" property */ 236 struct ppm_cdata *cdata[2]; 237 char **dom_namep, **model_namep, **dev_namep, **dc_namep; 238 struct ppm_domit *domit_p; 239 int err; 240 241 /* 242 * get "ppm-domains" property 243 */ 244 bzero(&domdata, sizeof (domdata)); 245 domdata.name = kmem_zalloc(strlen(PPM_DOMAIN_PROP) + 1, KM_SLEEP); 246 (void) strcpy(domdata.name, PPM_DOMAIN_PROP); 247 cdata[0] = &domdata; 248 cdata[1] = NULL; 249 if (err = ppm_get_confdata(cdata, dip)) { 250 PPMD(D_CREATEDB, ("%s: failed to get prop \"%s\"!\n", 251 str, PPM_DOMAIN_PROP)) 252 return (ppm_attach_err(cdata, err)); 253 } 254 255 for (dom_namep = domdata.strings; *dom_namep; dom_namep++) { 256 domp = kmem_zalloc(sizeof (*domp), KM_SLEEP); 257 domp->name = kmem_zalloc(strlen(*dom_namep) + 1, KM_SLEEP); 258 (void) strcpy(domp->name, *dom_namep); 259 mutex_init(&domp->lock, NULL, MUTEX_DRIVER, NULL); 260 if (ppm_domain_p == NULL) 261 ppm_domain_p = domp; 262 else { 263 domp->next = ppm_domain_p; 264 ppm_domain_p = domp; 265 } 266 } 267 ppm_prop_free(cdata); 268 269 /* 270 * more per domain property strings in ppm.conf file tell us 271 * what the nature of domain, how to performe domain control, etc. 272 * Even the property names of those per domain properties are 273 * formed consisting its domain name string. 274 * Here we walk through our domain list, and fullfill the details. 275 */ 276 for (domp = ppm_domain_p; domp; domp = domp->next) { 277 size_t plen; 278 279 /* 280 * get "domain_xy-model" property 281 */ 282 bzero(&modeldata, sizeof (modeldata)); 283 plen = strlen(domp->name) + strlen(PPM_MODEL_PROP_SUFFIX) + 1; 284 modeldata.name = kmem_zalloc(plen, KM_SLEEP); 285 (void) sprintf(modeldata.name, "%s%s", 286 domp->name, PPM_MODEL_PROP_SUFFIX); 287 288 cdata[0] = &modeldata; 289 cdata[1] = NULL; 290 if (err = ppm_get_confdata(cdata, dip)) { 291 PPMD(D_CREATEDB, ("%s: Can't read property %s!\n", 292 str, modeldata.name)) 293 return (ppm_attach_err(cdata, err)); 294 } 295 296 model_namep = modeldata.strings; 297 for (domit_p = ppm_domit_data; domit_p->name; domit_p++) { 298 if (strcmp(domit_p->name, *model_namep) == 0) { 299 domp->model = domit_p->model; 300 domp->dflags = domit_p->dflags; 301 domp->status = domit_p->status; 302 break; 303 } 304 } 305 ASSERT(domit_p); 306 307 ppm_prop_free(cdata); 308 309 310 /* get "domain_xy-propname" property */ 311 bzero(&propnamedata, sizeof (propnamedata)); 312 plen = strlen(domp->name) + 313 strlen(PPM_PROPNAME_PROP_SUFFIX) + 1; 314 propnamedata.name = kmem_zalloc(plen, KM_SLEEP); 315 (void) sprintf(propnamedata.name, "%s%s", 316 domp->name, PPM_PROPNAME_PROP_SUFFIX); 317 318 cdata[0] = &propnamedata; 319 cdata[1] = NULL; 320 if (ppm_get_confdata(cdata, dip) == DDI_PROP_SUCCESS) { 321 domp->propname = kmem_zalloc( 322 (strlen(*propnamedata.strings) + 1), KM_SLEEP); 323 (void) strcpy(domp->propname, *propnamedata.strings); 324 PPMD(D_CREATEDB, ("%s: %s has property name: %s\n", 325 str, domp->name, domp->propname)) 326 } 327 ppm_prop_free(cdata); 328 329 330 /* get "domain_xy-devices" property */ 331 bzero(&devdata, sizeof (devdata)); 332 plen = strlen(domp->name) + strlen(PPM_DEV_PROP_SUFFIX) + 1; 333 devdata.name = kmem_zalloc(plen, KM_SLEEP); 334 (void) sprintf(devdata.name, "%s%s", 335 domp->name, PPM_DEV_PROP_SUFFIX); 336 337 cdata[0] = &devdata; 338 cdata[1] = NULL; 339 if (err = ppm_get_confdata(cdata, dip)) { 340 PPMD(D_CREATEDB, ("%s: Can't read property %s!\n", 341 str, devdata.name)) 342 return (ppm_attach_err(cdata, err)); 343 } 344 345 for (dev_namep = devdata.strings; *dev_namep; dev_namep++) { 346 if (!ppm_parse_pattern(&db, *dev_namep)) 347 return (ppm_attach_err(cdata, err)); 348 db->next = domp->conflist; 349 domp->conflist = db; 350 PPMD(D_CREATEDB, ("%s: %s add pattern: %s \n", 351 str, devdata.name, db->name)) 352 } 353 PPMD(D_CREATEDB, ("\n")) 354 ppm_prop_free(cdata); 355 356 357 /* get "domain_xy-control" property */ 358 bzero(&dcdata, sizeof (dcdata)); 359 plen = strlen(domp->name) + strlen(PPM_CTRL_PROP_SUFFIX) + 1; 360 dcdata.name = kmem_zalloc(plen, KM_SLEEP); 361 (void) sprintf(dcdata.name, "%s%s", 362 domp->name, PPM_CTRL_PROP_SUFFIX); 363 364 cdata[0] = &dcdata; 365 cdata[1] = NULL; 366 if (ppm_get_confdata(cdata, dip) == DDI_PROP_SUCCESS) { 367 for (dc_namep = dcdata.strings; *dc_namep; 368 dc_namep++) { 369 dc = kmem_zalloc(sizeof (*dc), KM_SLEEP); 370 dc->next = domp->dc; 371 domp->dc = dc; 372 err = ppm_parse_dc(dc_namep, domp->dc); 373 if (err != DDI_SUCCESS) 374 return (ppm_attach_err(cdata, err)); 375 } 376 } 377 ppm_prop_free(cdata); 378 #ifdef DEBUG 379 dc = domp->dc; 380 while (dc) { 381 ppm_print_dc(dc); 382 dc = dc->next; 383 } 384 #endif 385 } 386 387 return (DDI_SUCCESS); 388 } 389 390 391 /* 392 * scan conf devices within each domain for a matching device name 393 */ 394 ppm_domain_t * 395 ppm_lookup_dev(dev_info_t *dip) 396 { 397 char path[MAXNAMELEN]; 398 ppm_domain_t *domp; 399 ppm_db_t *dbp; 400 #ifdef __x86 401 char *devtype = NULL; 402 #endif /* __x86 */ 403 404 PPM_GET_PATHNAME(dip, path); 405 for (domp = ppm_domain_p; domp; domp = domp->next) { 406 if (PPM_DOMAIN_UP(domp)) { 407 for (dbp = domp->conflist; dbp; dbp = dbp->next) { 408 /* 409 * allow claiming root without knowing 410 * its full name 411 */ 412 if (dip == ddi_root_node() && 413 strcmp(dbp->name, "/") == 0) 414 return (domp); 415 416 #ifdef __x86 417 /* 418 * Special rule to catch all CPU devices on x86. 419 */ 420 if (domp->model == PPMD_CPU && 421 strcmp(dbp->name, "/") == 0 && 422 ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 423 DDI_PROP_DONTPASS, "device_type", 424 &devtype) == DDI_SUCCESS) { 425 if (strcmp(devtype, "cpu") == 0) { 426 ddi_prop_free(devtype); 427 return (domp); 428 } else { 429 ddi_prop_free(devtype); 430 } 431 } 432 #endif /* __x86 */ 433 434 if (ppm_match_devs(path, dbp) == 0) 435 return (domp); 436 } 437 } 438 } 439 440 return (NULL); 441 } 442 443 444 /* 445 * check ppm.conf file domain device pathname syntax, if correct, 446 * create device match pattern. 447 * return 1 for good, -1 for bad. 448 */ 449 ppm_db_t * 450 ppm_parse_pattern(struct ppm_db **dbpp, char *dev_path) 451 { 452 char path[MAXNAMELEN]; 453 int wccnt, i; 454 int wcpos[2]; 455 int pos; 456 char *cp; 457 ppm_db_t *dbp; 458 459 (void) strcpy(path, dev_path); 460 if ((wccnt = ppm_count_char(path, '*')) > 2) 461 return (NULL); 462 463 for (i = 0, cp = path, pos = 0; i < wccnt; i++, cp++, pos++) { 464 for (; *cp; cp++, pos++) 465 if (*cp == '*') 466 break; 467 wcpos[i] = pos; 468 PPMD(D_CREATEDB, (" wildcard #%d, pos %d\n", 469 (i + 1), wcpos[i])) 470 } 471 472 #ifdef DEBUG 473 /* first '*', if exists, don't go beyond the string */ 474 if (wccnt > 0) 475 ASSERT(wcpos[0] < strlen(path)); 476 477 /* second '*', if exists, better be the last character */ 478 if (wccnt == 2) 479 ASSERT(wcpos[1] == (strlen(path) - 1)); 480 #endif 481 482 /* 483 * first '*', if followed by any char, must be immediately 484 * followed by '@' and the rest better be bound by 485 * ['0-9', 'a-f', A-F'] until ended '0' or second '*''0'. 486 */ 487 if ((wccnt > 0) && (wcpos[0] < (strlen(path) - 1))) { 488 cp = path + wcpos[0] + 1; 489 if (*cp != '@') 490 return (NULL); 491 492 if (!(((*(++cp) > '0') && (*cp < '9')) || 493 ((*cp > 'a') && (*cp < 'f')) || 494 ((*cp > 'A') && (*cp < 'F')))) 495 return (NULL); 496 } 497 498 dbp = kmem_zalloc(sizeof (struct ppm_db), KM_SLEEP); 499 dbp->name = kmem_zalloc((strlen(path) + 1), KM_SLEEP); 500 (void) strcpy(dbp->name, path); 501 dbp->wccnt = wccnt; 502 dbp->wcpos[0] = (wccnt > 0) ? wcpos[0] : -1; 503 dbp->wcpos[1] = (wccnt == 2) ? wcpos[1] : -1; 504 505 return (*dbpp = dbp); 506 } 507 508 509 /* 510 * match given device "path" to domain device pathname 511 * pattern dbp->name that contains one or two '*' character(s). 512 * Matching policy: 513 * 1). If one wildcard terminates match pattern, need exact match 514 * up to (but exclude) the wildcard; 515 * 2). If one wildcard does not terminate match pattern, it is to 516 * match driver name (terminates with '@') and must be followed 517 * by exact match of rest of pattern; 518 * 3). If two wildcards, first is to match driver name as in 2), 519 * second is to match fcnid (terminates with '/' or '\0') and 520 * must the last char of pattern. 521 * 522 * return 0 if match, and 523 * non 0 if mismatch 524 */ 525 int 526 ppm_match_devs(char *dev_path, ppm_db_t *dbp) 527 { 528 char path[MAXNAMELEN]; 529 char *cp; /* points into "path", real device pathname */ 530 char *np; /* points into "dbp->name", the pattern */ 531 int len; 532 533 if (dbp->wccnt == 0) 534 return (strcmp(dev_path, dbp->name)); 535 536 (void) strcpy(path, dev_path); 537 538 /* match upto the first '*' regardless */ 539 if (strncmp(path, dbp->name, dbp->wcpos[0]) != 0) 540 return (-1); 541 542 543 /* "<exact match>*" */ 544 if (dbp->name[dbp->wcpos[0] + 1] == 0) { 545 cp = path + dbp->wcpos[0]; 546 while (*cp && (*cp++ != '/')) 547 ; 548 return ((*cp == 0) ? 0 : -1); 549 } 550 551 552 /* locate '@' */ 553 cp = path + dbp->wcpos[0] + 1; 554 while (*cp && *cp != '@') 555 cp++; 556 557 np = dbp->name + dbp->wcpos[0] + 1; 558 559 /* if one wildcard, match the rest in the pattern */ 560 if (dbp->wccnt == 1) 561 return ((strcmp(cp, np) == 0) ? 0 : (-1)); 562 563 564 /* must have exact match after first wildcard up to second */ 565 ASSERT(dbp->wccnt == 2); 566 len = dbp->wcpos[1] - dbp->wcpos[0] - 1; 567 if (strncmp(cp, np, len) != 0) 568 return (-1); 569 570 /* second wildcard match terminates with '/' or '\0' */ 571 /* but only termination with '\0' is a successful match */ 572 cp += len; 573 while (*cp && (*cp != '/')) 574 cp++; 575 return ((*cp == 0) ? 0 : -1); 576 } 577 578 579 /* 580 * By claiming a device, ppm gets involved in its power change 581 * process: handles additional issues prior and/or post its 582 * power(9e) call. 583 * 584 * If 'dip' is a PCI device, this is the time to ask its parent 585 * what PCI bus speed it is running. 586 * 587 * returns 1 (claimed), 0 (not claimed) 588 */ 589 int 590 ppm_claim_dev(dev_info_t *dip) 591 { 592 ppm_domain_t *domp; 593 dev_info_t *pdip; 594 uint_t pciclk; 595 int claimed = -1; 596 597 domp = ppm_lookup_dev(dip); 598 if (!domp) 599 claimed = 0; 600 601 if (domp && PPMD_IS_PCI(domp->model) && 602 ! (domp->dflags & (PPMD_PCI33MHZ | PPMD_PCI66MHZ))) { 603 pdip = ddi_get_parent(dip); 604 ASSERT(pdip); 605 pciclk = ddi_prop_get_int(DDI_DEV_T_ANY, pdip, 606 DDI_PROP_DONTPASS, "clock-frequency", -1); 607 608 switch (pciclk) { 609 case 33000000: 610 domp->dflags |= PPMD_PCI33MHZ; 611 claimed = 1; 612 break; 613 case 66000000: 614 domp->dflags |= PPMD_PCI66MHZ; 615 claimed = 1; 616 break; 617 default: 618 claimed = 0; 619 break; 620 } 621 } 622 623 if (domp && (claimed == -1)) 624 claimed = 1; 625 626 #ifdef DEBUG 627 if (claimed) { 628 char path[MAXNAMELEN]; 629 PPMD(D_CLAIMDEV, ("ppm_claim_dev: %s into domain %s\n", 630 ddi_pathname(dip, path), domp->name)) 631 } 632 633 #endif 634 635 return (claimed); 636 } 637 638 /* 639 * add a device to the list of domain's owned devices (if it is not already 640 * on the list). 641 */ 642 ppm_owned_t * 643 ppm_add_owned(dev_info_t *dip, ppm_domain_t *domp) 644 { 645 char path[MAXNAMELEN]; 646 ppm_owned_t *owned, *new_owned; 647 648 ASSERT(MUTEX_HELD(&domp->lock)); 649 PPM_GET_PATHNAME(dip, path); 650 for (owned = domp->owned; owned; owned = owned->next) 651 if (strcmp(path, owned->path) == 0) 652 return (owned); 653 654 new_owned = kmem_zalloc(sizeof (*new_owned), KM_SLEEP); 655 new_owned->path = kmem_zalloc(strlen(path) + 1, KM_SLEEP); 656 (void) strcpy(new_owned->path, path); 657 new_owned->next = domp->owned; 658 domp->owned = new_owned; 659 660 return (domp->owned); 661 } 662 663 /* 664 * create/init a new ppm device and link into the domain 665 */ 666 ppm_dev_t * 667 ppm_add_dev(dev_info_t *dip, ppm_domain_t *domp) 668 { 669 char path[MAXNAMELEN]; 670 ppm_dev_t *new = NULL; 671 int cmpt; 672 ppm_owned_t *owned; 673 674 ASSERT(MUTEX_HELD(&domp->lock)); 675 (void) ddi_pathname(dip, path); 676 /* 677 * For devs which have exported "pm-components" we want to create 678 * a data structure for each component. When a driver chooses not 679 * to export the prop we treat its device as having a single 680 * component and build a structure for it anyway. All other ppm 681 * logic will act as if this device were always up and can thus 682 * make correct decisions about it in relation to other devices 683 * in its domain. 684 */ 685 for (cmpt = PM_GET_PM_INFO(dip) ? PM_NUMCMPTS(dip) : 1; cmpt--; ) { 686 new = kmem_zalloc(sizeof (*new), KM_SLEEP); 687 new->path = kmem_zalloc(strlen(path) + 1, KM_SLEEP); 688 (void) strcpy(new->path, path); 689 new->domp = domp; 690 new->dip = dip; 691 new->cmpt = cmpt; 692 ppm_dev_init(new); 693 new->next = domp->devlist; 694 domp->devlist = new; 695 PPMD(D_ADDDEV, 696 ("ppm_add_dev: %s to domain %s: ppm_dev(0x%p)\n", 697 new->path, domp->name, (void *)new)) 698 } 699 700 ASSERT(new != NULL); 701 /* 702 * devi_pm_ppm_private should be set only after all 703 * ppm_dev s related to all components have been 704 * initialized and domain's pwr_cnt is incremented 705 * for each of them. 706 */ 707 PPM_SET_PRIVATE(dip, new); 708 709 /* remember this device forever */ 710 owned = ppm_add_owned(dip, domp); 711 712 /* 713 * Initializing flag is set for devices which have gone through 714 * PPM_PMR_INIT_CHILD ctlop. By this point, these devices have 715 * been added to ppm structures and could participate in pm 716 * decision making, so clear the initializing flag. 717 */ 718 if (owned->initializing) { 719 owned->initializing = 0; 720 PPMD(D_ADDDEV, ("ppm_add_dev: cleared initializing flag " 721 "for %s@%s\n", PM_NAME(dip), 722 (PM_ADDR(dip) == NULL) ? "" : PM_ADDR(dip))) 723 } 724 725 return (new); 726 } 727 728 729 /* 730 * returns an existing or newly created ppm device reference 731 */ 732 ppm_dev_t * 733 ppm_get_dev(dev_info_t *dip, ppm_domain_t *domp) 734 { 735 ppm_dev_t *pdp; 736 737 mutex_enter(&domp->lock); 738 pdp = PPM_GET_PRIVATE(dip); 739 if (pdp == NULL) 740 pdp = ppm_add_dev(dip, domp); 741 mutex_exit(&domp->lock); 742 743 return (pdp); 744 } 745 746 747 /* 748 * scan a domain's device list and remove those with .dip 749 * matching the arg *dip; we need to scan the entire list 750 * for the case of devices with multiple components 751 */ 752 void 753 ppm_rem_dev(dev_info_t *dip) 754 { 755 ppm_dev_t *pdp, **devpp; 756 ppm_domain_t *domp; 757 758 pdp = PPM_GET_PRIVATE(dip); 759 ASSERT(pdp); 760 domp = pdp->domp; 761 ASSERT(domp); 762 763 mutex_enter(&domp->lock); 764 for (devpp = &domp->devlist; (pdp = *devpp) != NULL; ) { 765 if (pdp->dip != dip) { 766 devpp = &pdp->next; 767 continue; 768 } 769 770 PPMD(D_REMDEV, ("ppm_rem_dev: path \"%s\", ppm_dev 0x%p\n", 771 pdp->path, (void *)pdp)) 772 773 PPM_SET_PRIVATE(dip, NULL); 774 *devpp = pdp->next; 775 ppm_dev_fini(pdp); 776 kmem_free(pdp->path, strlen(pdp->path) + 1); 777 kmem_free(pdp, sizeof (*pdp)); 778 } 779 mutex_exit(&domp->lock); 780 } 781 782 /* 783 * prepare kernel ioctl calls: 784 */ 785 void 786 ppm_init_cb(dev_info_t *dip) 787 { 788 char *str = "ppm_init_cb"; 789 ppm_domain_t *domp; 790 ppm_dc_t *dc; 791 792 for (domp = ppm_domain_p; domp != NULL; domp = domp->next) { 793 for (dc = domp->dc; dc; dc = dc->next) { 794 /* 795 * Warning: This code is rather confusing. 796 * 797 * It intends to ensure that ppm_init_lyr() is only 798 * called ONCE for a device that may be associated 799 * with more than one domain control. 800 * So, what it does is first to check to see if 801 * there is a handle, and then if not it goes on 802 * to call the init_lyr() routine. 803 * 804 * The non-obvious thing is that the ppm_init_lyr() 805 * routine, in addition to opening the device 806 * associated with the dc (domain control) in 807 * question, has the side-effect of creating the 808 * handle for that dc as well. 809 */ 810 if (ppm_lookup_hndl(domp->model, dc) != NULL) 811 continue; 812 813 if (ppm_init_lyr(dc, dip) != DDI_SUCCESS) { 814 domp->dflags |= PPMD_OFFLINE; 815 cmn_err(CE_WARN, "%s: ppm domain %s will " 816 "be offline.", str, domp->name); 817 break; 818 } 819 } 820 } 821 } 822 823 824 /* 825 * ppm_init_lyr - initializing layered ioctl 826 * Return: 827 * DDI_SUCCESS - succeeded 828 * DDI_FAILURE - failed 829 * 830 */ 831 int 832 ppm_init_lyr(ppm_dc_t *dc, dev_info_t *dip) 833 { 834 char *str = "ppm_init_lyr"; 835 int err = 0; 836 ldi_ident_t li; 837 838 ASSERT(dc && dc->path); 839 840 if (err = ldi_ident_from_dip(dip, &li)) { 841 cmn_err(CE_WARN, "%s: get ldi identifier " 842 "failed (err=%d)", str, err); 843 } 844 845 err = ldi_open_by_name(dc->path, FWRITE|FREAD, kcred, &(dc->lh), li); 846 847 (void) ldi_ident_release(li); 848 849 if (err != 0) { 850 cmn_err(CE_WARN, "Failed to open device(%s), rv(%d)", 851 dc->path, err); 852 return (err); 853 } 854 855 return (DDI_SUCCESS); 856 } 857 858 /* 859 * lock, unlock, or trylock for one power mutex 860 */ 861 void 862 ppm_lock_one(ppm_dev_t *ppmd, power_req_t *reqp, int *iresp) 863 { 864 switch (reqp->request_type) { 865 case PMR_PPM_LOCK_POWER: 866 pm_lock_power_single(ppmd->dip, 867 reqp->req.ppm_lock_power_req.circp); 868 break; 869 870 case PMR_PPM_UNLOCK_POWER: 871 pm_unlock_power_single(ppmd->dip, 872 reqp->req.ppm_unlock_power_req.circ); 873 break; 874 875 case PMR_PPM_TRY_LOCK_POWER: 876 *iresp = pm_try_locking_power_single(ppmd->dip, 877 reqp->req.ppm_lock_power_req.circp); 878 break; 879 } 880 } 881 882 883 /* 884 * lock, unlock, or trylock for all power mutexes within a domain 885 */ 886 void 887 ppm_lock_all(ppm_domain_t *domp, power_req_t *reqp, int *iresp) 888 { 889 /* 890 * To simplify the implementation we let all the devices 891 * in the domain be represented by a single device (dip). 892 * We use the first device in the domain's devlist. This 893 * is safe because we return with the domain lock held 894 * which prevents the list from changing. 895 */ 896 if (reqp->request_type == PMR_PPM_LOCK_POWER) { 897 if (!MUTEX_HELD(&domp->lock)) 898 mutex_enter(&domp->lock); 899 domp->refcnt++; 900 ASSERT(domp->devlist != NULL); 901 pm_lock_power_single(domp->devlist->dip, 902 reqp->req.ppm_lock_power_req.circp); 903 /* domain lock remains held */ 904 return; 905 } else if (reqp->request_type == PMR_PPM_UNLOCK_POWER) { 906 ASSERT(MUTEX_HELD(&domp->lock)); 907 ASSERT(domp->devlist != NULL); 908 pm_unlock_power_single(domp->devlist->dip, 909 reqp->req.ppm_unlock_power_req.circ); 910 if (--domp->refcnt == 0) 911 mutex_exit(&domp->lock); 912 return; 913 } 914 915 ASSERT(reqp->request_type == PMR_PPM_TRY_LOCK_POWER); 916 if (!MUTEX_HELD(&domp->lock)) 917 if (!mutex_tryenter(&domp->lock)) { 918 *iresp = 0; 919 return; 920 } 921 *iresp = pm_try_locking_power_single(domp->devlist->dip, 922 reqp->req.ppm_lock_power_req.circp); 923 if (*iresp) 924 domp->refcnt++; 925 else 926 mutex_exit(&domp->lock); 927 } 928 929 930 /* 931 * return FALSE: if any detached device during its previous life exported 932 * the "no-involuntary-power-cycles" property and detached with its 933 * power level not at its lowest, or there is a device in the process 934 * of being installed/attached; if a PCI domain has devices that have not 935 * exported a property that it can tolerate clock off while bus is not 936 * quiescent; if a 66mhz PCI domain has devices that do not support stopping 937 * clock at D3; either one would count as a power holder. 938 * return TRUE: otherwise. 939 */ 940 boolean_t 941 ppm_none_else_holds_power(ppm_domain_t *domp) 942 { 943 ppm_dev_t *ppmd; 944 ppm_owned_t *owned; 945 int i = 0; 946 947 if (PPMD_IS_PCI(domp->model)) { 948 for (ppmd = domp->devlist; ppmd; ppmd = ppmd->next) { 949 if ((domp->model == PPMD_PCI_PROP) && 950 !(ppmd->flags & PPMDEV_PCI_PROP_CLKPM)) 951 return (B_FALSE); 952 if ((domp->dflags & PPMD_PCI66MHZ) && 953 !(ppmd->flags & PPMDEV_PCI66_D2)) 954 return (B_FALSE); 955 } 956 } 957 958 for (owned = domp->owned; owned; owned = owned->next) 959 if (pm_noinvol_detached(owned->path) || owned->initializing) 960 i++; 961 return (i == 0); 962 } 963 964 965 /* 966 * return the number of char 'c' occurrences in string s 967 */ 968 int 969 ppm_count_char(char *s, char c) 970 { 971 int i = 0; 972 char *cp = s; 973 974 while (*cp) { 975 if (*cp == c) 976 i++; 977 cp++; 978 } 979 980 return (i); 981 } 982 983 984 /* 985 * extract and convert a substring from input string "ss" in form of 986 * "name=value" into an hex or decimal integer 987 */ 988 #define X_BASE 16 989 #define D_BASE 10 990 int 991 ppm_stoi(char *ss, uint_t *val) 992 { 993 char *cp; 994 int hex_ = 0, base = D_BASE; 995 int digit; 996 997 if ((cp = strchr(ss, '=')) == NULL) 998 return (*val = (uint_t)-1); 999 1000 cp++; 1001 if ((*cp == '0') && (*++cp == 'x')) { 1002 hex_++; 1003 cp++; 1004 base = X_BASE; 1005 } 1006 1007 for (digit = 0; *cp; cp++) { 1008 if (hex_ && ((*cp >= 'A') && (*cp <= 'F'))) 1009 digit = (digit * base) + ((*cp - 'A') + D_BASE); 1010 else if (hex_ && ((*cp >= 'a') && (*cp <= 'f'))) 1011 digit = (digit * base) + ((*cp - 'a') + D_BASE); 1012 else 1013 digit = (digit * base) + (*cp - '0'); 1014 } 1015 1016 return (*val = digit); 1017 } 1018 1019 /* 1020 * ppm_convert - convert a #define symbol to its integer value, 1021 * only the #defines for ppm_dc.cmd and ppm_dc.method fields in 1022 * ppmvar.h file are recognized. 1023 */ 1024 struct ppm_confdefs { 1025 char *sym; 1026 int val; 1027 } ppm_confdefs_table[] = { 1028 { "ENTER_S3", PPMDC_ENTER_S3 }, 1029 { "EXIT_S3", PPMDC_EXIT_S3 }, 1030 { "CPU_NEXT", PPMDC_CPU_NEXT }, 1031 { "PRE_CHNG", PPMDC_PRE_CHNG }, 1032 { "CPU_GO", PPMDC_CPU_GO }, 1033 { "POST_CHNG", PPMDC_POST_CHNG }, 1034 { "FET_ON", PPMDC_FET_ON }, 1035 { "FET_OFF", PPMDC_FET_OFF }, 1036 { "CLK_OFF", PPMDC_CLK_OFF }, 1037 { "CLK_ON", PPMDC_CLK_ON }, 1038 { "LED_ON", PPMDC_LED_ON }, 1039 { "LED_OFF", PPMDC_LED_OFF }, 1040 { "KIO", PPMDC_KIO }, 1041 { "VCORE", PPMDC_VCORE }, 1042 #ifdef sun4u 1043 { "I2CKIO", PPMDC_I2CKIO }, 1044 #endif 1045 { "CPUSPEEDKIO", PPMDC_CPUSPEEDKIO }, 1046 { "PRE_PWR_OFF", PPMDC_PRE_PWR_OFF }, 1047 { "PRE_PWR_ON", PPMDC_PRE_PWR_ON }, 1048 { "POST_PWR_ON", PPMDC_POST_PWR_ON }, 1049 { "PWR_OFF", PPMDC_PWR_OFF }, 1050 { "PWR_ON", PPMDC_PWR_ON }, 1051 { "RESET_OFF", PPMDC_RESET_OFF }, 1052 { "RESET_ON", PPMDC_RESET_ON }, 1053 { NULL } 1054 }; 1055 1056 1057 /* 1058 * convert a #define'd symbol to its integer value where 1059 * input "symbol" is expected to be in form of "SYMBOL=value" 1060 */ 1061 int 1062 ppm_convert(char *symbol, uint_t *val) 1063 { 1064 char *s; 1065 struct ppm_confdefs *pcfp; 1066 1067 if ((s = strchr(symbol, '=')) == NULL) { 1068 cmn_err(CE_WARN, "ppm_convert: token \"%s\" syntax error in " 1069 "ppm.conf file", symbol); 1070 return (*val = (uint_t)-1); 1071 } 1072 s++; 1073 1074 for (pcfp = ppm_confdefs_table; (pcfp->sym != NULL); pcfp++) { 1075 if (strcmp(s, pcfp->sym) == 0) 1076 return (*val = pcfp->val); 1077 } 1078 1079 cmn_err(CE_WARN, "ppm_convert: Unrecognizable token \"%s\" " 1080 "in ppm.conf file", symbol); 1081 return (*val = (uint_t)-1); 1082 } 1083 1084 1085 /* 1086 * parse a domain control property string into data structure struct ppm_dc 1087 */ 1088 int 1089 ppm_parse_dc(char **dc_namep, ppm_dc_t *dc) 1090 { 1091 char *str = "ppm_parse_dc"; 1092 char *line; 1093 char *f, *b; 1094 char **dclist; /* list of ppm_dc_t fields */ 1095 int count; /* the # of '=' indicates the # of items */ 1096 size_t len; /* length of line being parsed */ 1097 boolean_t done; 1098 int i; 1099 int err; 1100 1101 len = strlen(*dc_namep); 1102 line = kmem_alloc(len + 1, KM_SLEEP); 1103 (void) strcpy(line, *dc_namep); 1104 1105 count = ppm_count_char(line, '='); 1106 ASSERT((count - ppm_count_char(line, ' ')) == 1); 1107 1108 dclist = (char **) 1109 kmem_zalloc((sizeof (char *) * (count + 1)), KM_SLEEP); 1110 for (i = 0, f = b = line, done = B_FALSE; !done; i++, f = ++b) { 1111 while (*b != ' ' && *b != 0) 1112 b++; 1113 if (*b == 0) 1114 done = B_TRUE; 1115 else 1116 *b = 0; 1117 dclist[i] = f; 1118 } 1119 1120 for (i = 0; i < count; i++) { 1121 if (strstr(dclist[i], "cmd=")) { 1122 err = ppm_convert(dclist[i], &dc->cmd); 1123 if (err == -1) 1124 return (err); 1125 continue; 1126 } 1127 if ((f = strstr(dclist[i], "path=")) != NULL) { 1128 f += strlen("path="); 1129 dc->path = kmem_zalloc((strlen(f) + 1), KM_SLEEP); 1130 (void) strcpy(dc->path, f); 1131 continue; 1132 } 1133 if (strstr(dclist[i], "method=")) { 1134 err = ppm_convert(dclist[i], &dc->method); 1135 if (err == -1) 1136 return (err); 1137 continue; 1138 } 1139 if (strstr(dclist[i], "iowr=")) { 1140 (void) ppm_stoi(dclist[i], &dc->m_un.kio.iowr); 1141 continue; 1142 } 1143 if (strstr(dclist[i], "iord=")) { 1144 (void) ppm_stoi(dclist[i], &dc->m_un.kio.iord); 1145 continue; 1146 } 1147 if (strstr(dclist[i], "val=")) { 1148 (void) ppm_stoi(dclist[i], &dc->m_un.kio.val); 1149 continue; 1150 } 1151 if (strstr(dclist[i], "speeds=")) { 1152 ASSERT(dc->method == PPMDC_CPUSPEEDKIO); 1153 (void) ppm_stoi(dclist[i], &dc->m_un.cpu.speeds); 1154 continue; 1155 } 1156 #ifdef sun4u 1157 if (strstr(dclist[i], "mask=")) { 1158 (void) ppm_stoi(dclist[i], &dc->m_un.i2c.mask); 1159 continue; 1160 } 1161 #endif 1162 /* This must be before the if statement for delay */ 1163 if (strstr(dclist[i], "post_delay=")) { 1164 #ifdef sun4u 1165 ASSERT(dc->method == PPMDC_KIO || 1166 dc->method == PPMDC_I2CKIO); 1167 #else 1168 ASSERT(dc->method == PPMDC_KIO); 1169 #endif 1170 /* 1171 * all delays are uint_t type instead of clock_t. 1172 * If the delay is too long, it might get truncated. 1173 * But, we don't expect delay to be too long. 1174 */ 1175 switch (dc->method) { 1176 case PPMDC_KIO: 1177 (void) ppm_stoi(dclist[i], 1178 &dc->m_un.kio.post_delay); 1179 break; 1180 1181 #ifdef sun4u 1182 case PPMDC_I2CKIO: 1183 (void) ppm_stoi(dclist[i], 1184 &dc->m_un.i2c.post_delay); 1185 break; 1186 #endif 1187 1188 default: 1189 break; 1190 } 1191 continue; 1192 } 1193 if (strstr(dclist[i], "delay=")) { 1194 #ifdef sun4u 1195 ASSERT(dc->method == PPMDC_VCORE || 1196 dc->method == PPMDC_KIO || 1197 dc->method == PPMDC_I2CKIO); 1198 #else 1199 ASSERT(dc->method == PPMDC_VCORE || 1200 dc->method == PPMDC_KIO); 1201 #endif 1202 1203 /* 1204 * all delays are uint_t type instead of clock_t. 1205 * If the delay is too long, it might get truncated. 1206 * But, we don't expect delay to be too long. 1207 */ 1208 1209 switch (dc->method) { 1210 case PPMDC_KIO: 1211 (void) ppm_stoi(dclist[i], &dc->m_un.kio.delay); 1212 break; 1213 1214 #ifdef sun4u 1215 case PPMDC_I2CKIO: 1216 (void) ppm_stoi(dclist[i], &dc->m_un.i2c.delay); 1217 break; 1218 #endif 1219 1220 case PPMDC_VCORE: 1221 (void) ppm_stoi(dclist[i], &dc->m_un.cpu.delay); 1222 break; 1223 1224 default: 1225 break; 1226 } 1227 continue; 1228 } 1229 1230 /* we encounted unrecognized field, flag error */ 1231 cmn_err(CE_WARN, "%s: Unrecognized token \"%s\" in ppm.conf " 1232 "file!", str, dclist[i]); 1233 return (-1); 1234 } 1235 1236 kmem_free(dclist, sizeof (char *) * (count + 1)); 1237 kmem_free(line, len + 1); 1238 1239 return (DDI_SUCCESS); 1240 } 1241 1242 1243 /* 1244 * search for domain control handle for a claimed device coupled with a 1245 * domain control command. NULL device may indicate LED domain. 1246 */ 1247 ppm_dc_t * 1248 ppm_lookup_dc(ppm_domain_t *domp, int cmd) 1249 { 1250 #ifdef DEBUG 1251 char *str = "ppm_lookup_dc"; 1252 #endif 1253 ppm_dc_t *dc; 1254 1255 /* 1256 * For convenience, we accept 'domp' as NULL for searching 1257 * LED domain control operation. 1258 */ 1259 if ((cmd == PPMDC_LED_OFF) || (cmd == PPMDC_LED_ON)) { 1260 for (domp = ppm_domain_p; domp; domp = domp->next) 1261 if (domp->model == PPMD_LED) 1262 break; 1263 if (!domp || !domp->dc || !domp->dc->lh || !domp->dc->next) { 1264 PPMD(D_LED, ("\tinsufficient led domain control " 1265 "information.\n")) 1266 return (NULL); 1267 } 1268 if (cmd == domp->dc->cmd) 1269 return (domp->dc); 1270 else 1271 return (domp->dc->next); 1272 } 1273 1274 1275 /* 1276 * for the rest of ppm domains, lookup ppm_dc starting from domp 1277 */ 1278 ASSERT(domp != NULL); 1279 switch (cmd) { 1280 case PPMDC_CPU_NEXT: 1281 case PPMDC_PRE_CHNG: 1282 case PPMDC_CPU_GO: 1283 case PPMDC_POST_CHNG: 1284 case PPMDC_FET_OFF: 1285 case PPMDC_FET_ON: 1286 case PPMDC_CLK_OFF: 1287 case PPMDC_CLK_ON: 1288 case PPMDC_PRE_PWR_OFF: 1289 case PPMDC_PRE_PWR_ON: 1290 case PPMDC_POST_PWR_ON: 1291 case PPMDC_PWR_OFF: 1292 case PPMDC_PWR_ON: 1293 case PPMDC_RESET_OFF: 1294 case PPMDC_RESET_ON: 1295 case PPMDC_ENTER_S3: 1296 case PPMDC_EXIT_S3: 1297 break; 1298 default: 1299 PPMD(D_PPMDC, ("%s: cmd(%d) unrecognized\n", str, cmd)) 1300 return (NULL); 1301 } 1302 1303 for (dc = domp->dc; dc; dc = dc->next) { 1304 if (dc->cmd == cmd) { 1305 return (dc); 1306 } 1307 } 1308 1309 return (NULL); 1310 } 1311 1312 #include <sys/esunddi.h> 1313 1314 ppm_domain_t * 1315 ppm_get_domain_by_dev(const char *p) 1316 { 1317 dev_info_t *dip; 1318 ppm_domain_t *domp; 1319 ppm_dev_t *pdev; 1320 boolean_t found = B_FALSE; 1321 1322 if ((dip = e_ddi_hold_devi_by_path((char *)p, 0)) == NULL) 1323 return (NULL); 1324 1325 for (domp = ppm_domain_p; domp; domp = domp->next) { 1326 for (pdev = domp->devlist; pdev; pdev = pdev->next) { 1327 if (pdev->dip == dip) { 1328 found = B_TRUE; 1329 break; 1330 } 1331 } 1332 if (found) 1333 break; 1334 } 1335 ddi_release_devi(dip); 1336 return (domp); 1337 } 1338 1339 1340 #ifdef DEBUG 1341 #define FLINTSTR(flags, sym) { flags, sym, #sym } 1342 #define PMR_UNKNOWN -1 1343 /* 1344 * convert a ctlop integer to a char string. this helps printing 1345 * meaningful info when cltops are received from the pm framework. 1346 * since some ctlops are so frequent, we use mask to limit output: 1347 * a valid string is returned when ctlop is found and when 1348 * (cmd.flags & mask) is true; otherwise NULL is returned. 1349 */ 1350 char * 1351 ppm_get_ctlstr(int ctlop, uint_t mask) 1352 { 1353 struct ctlop_cmd { 1354 uint_t flags; 1355 int ctlop; 1356 char *str; 1357 }; 1358 1359 struct ctlop_cmd *ccp; 1360 static struct ctlop_cmd cmds[] = { 1361 FLINTSTR(D_SETPWR, PMR_SET_POWER), 1362 FLINTSTR(D_CTLOPS2, PMR_SUSPEND), 1363 FLINTSTR(D_CTLOPS2, PMR_RESUME), 1364 FLINTSTR(D_CTLOPS2, PMR_PRE_SET_POWER), 1365 FLINTSTR(D_CTLOPS2, PMR_POST_SET_POWER), 1366 FLINTSTR(D_CTLOPS2, PMR_PPM_SET_POWER), 1367 FLINTSTR(0, PMR_PPM_ATTACH), 1368 FLINTSTR(0, PMR_PPM_DETACH), 1369 FLINTSTR(D_CTLOPS1, PMR_PPM_POWER_CHANGE_NOTIFY), 1370 FLINTSTR(D_CTLOPS1, PMR_REPORT_PMCAP), 1371 FLINTSTR(D_CTLOPS1, PMR_CHANGED_POWER), 1372 FLINTSTR(D_CTLOPS2, PMR_PPM_INIT_CHILD), 1373 FLINTSTR(D_CTLOPS2, PMR_PPM_UNINIT_CHILD), 1374 FLINTSTR(D_CTLOPS2, PMR_PPM_PRE_PROBE), 1375 FLINTSTR(D_CTLOPS2, PMR_PPM_POST_PROBE), 1376 FLINTSTR(D_CTLOPS2, PMR_PPM_PRE_ATTACH), 1377 FLINTSTR(D_CTLOPS2, PMR_PPM_POST_ATTACH), 1378 FLINTSTR(D_CTLOPS2, PMR_PPM_PRE_DETACH), 1379 FLINTSTR(D_CTLOPS2, PMR_PPM_POST_DETACH), 1380 FLINTSTR(D_CTLOPS1, PMR_PPM_UNMANAGE), 1381 FLINTSTR(D_CTLOPS2, PMR_PPM_PRE_RESUME), 1382 FLINTSTR(D_CTLOPS1, PMR_PPM_ALL_LOWEST), 1383 FLINTSTR(D_LOCKS, PMR_PPM_LOCK_POWER), 1384 FLINTSTR(D_LOCKS, PMR_PPM_UNLOCK_POWER), 1385 FLINTSTR(D_LOCKS, PMR_PPM_TRY_LOCK_POWER), 1386 FLINTSTR(D_LOCKS, PMR_PPM_POWER_LOCK_OWNER), 1387 FLINTSTR(D_CTLOPS1 | D_CTLOPS2, PMR_PPM_ENTER_SX), 1388 FLINTSTR(D_CTLOPS1 | D_CTLOPS2, PMR_UNKNOWN), 1389 }; 1390 1391 for (ccp = cmds; ccp->ctlop != PMR_UNKNOWN; ccp++) 1392 if (ctlop == ccp->ctlop) 1393 break; 1394 1395 if (ccp->flags & mask) 1396 return (ccp->str); 1397 return (NULL); 1398 } 1399 1400 void 1401 ppm_print_dc(ppm_dc_t *dc) 1402 { 1403 ppm_dc_t *d = dc; 1404 1405 PPMD(D_PPMDC, ("\nAdds ppm_dc: path(%s),\n cmd(%x), " 1406 "method(%x), ", d->path, d->cmd, d->method)) 1407 if (d->method == PPMDC_KIO) { 1408 PPMD(D_PPMDC, ("kio.iowr(%x), kio.val(0x%X)", 1409 d->m_un.kio.iowr, d->m_un.kio.val)) 1410 #ifdef sun4u 1411 } else if (d->method == PPMDC_I2CKIO) { 1412 PPMD(D_PPMDC, ("i2c.iowr(%x), i2c.val(0x%X), " 1413 "i2c.mask(0x%X)", d->m_un.i2c.iowr, 1414 d->m_un.i2c.val, d->m_un.i2c.mask)) 1415 #endif 1416 } else if (d->method == PPMDC_VCORE) { 1417 PPMD(D_PPMDC, ("cpu: .iord(%x), .iowr(%x), .val(0x%X), " 1418 ".delay(0x%x)", 1419 d->m_un.cpu.iord, d->m_un.cpu.iowr, d->m_un.cpu.val, 1420 d->m_un.cpu.delay)) 1421 } else if (d->method == PPMDC_CPUSPEEDKIO) { 1422 PPMD(D_PPMDC, ("cpu.iowr(%x), cpu.speeds(0x%X)", 1423 d->m_un.cpu.iowr, d->m_un.cpu.speeds)) 1424 } 1425 PPMD(D_PPMDC, ("\n")) 1426 } 1427 #endif /* DEBUG */