1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2009 Nathan Whitehorn 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. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 #include <sys/param.h> 32 #include <sys/bus.h> 33 #include <sys/eventhandler.h> 34 #include <sys/systm.h> 35 #include <sys/module.h> 36 #include <sys/conf.h> 37 #include <sys/cpu.h> 38 #include <sys/clock.h> 39 #include <sys/ctype.h> 40 #include <sys/kernel.h> 41 #include <sys/kthread.h> 42 #include <sys/lock.h> 43 #include <sys/mutex.h> 44 #include <sys/reboot.h> 45 #include <sys/rman.h> 46 #include <sys/sysctl.h> 47 #include <sys/unistd.h> 48 49 #include <machine/bus.h> 50 #include <machine/intr_machdep.h> 51 #include <machine/md_var.h> 52 53 #include <dev/iicbus/iicbus.h> 54 #include <dev/iicbus/iiconf.h> 55 #include <dev/led/led.h> 56 #include <dev/ofw/openfirm.h> 57 #include <dev/ofw/ofw_bus.h> 58 #include <dev/ofw/ofw_bus_subr.h> 59 #include <powerpc/powermac/macgpiovar.h> 60 #include <powerpc/powermac/powermac_thermal.h> 61 62 #include "clock_if.h" 63 #include "iicbus_if.h" 64 65 struct smu_cmd { 66 volatile uint8_t cmd; 67 uint8_t len; 68 uint8_t data[254]; 69 70 STAILQ_ENTRY(smu_cmd) cmd_q; 71 }; 72 73 STAILQ_HEAD(smu_cmdq, smu_cmd); 74 75 struct smu_fan { 76 struct pmac_fan fan; 77 device_t dev; 78 cell_t reg; 79 80 enum { 81 SMU_FAN_RPM, 82 SMU_FAN_PWM 83 } type; 84 int setpoint; 85 int old_style; 86 int rpm; 87 }; 88 89 /* We can read the PWM and the RPM from a PWM controlled fan. 90 * Offer both values via sysctl. 91 */ 92 enum { 93 SMU_PWM_SYSCTL_PWM = 1 << 8, 94 SMU_PWM_SYSCTL_RPM = 2 << 8 95 }; 96 97 struct smu_sensor { 98 struct pmac_therm therm; 99 device_t dev; 100 101 cell_t reg; 102 enum { 103 SMU_CURRENT_SENSOR, 104 SMU_VOLTAGE_SENSOR, 105 SMU_POWER_SENSOR, 106 SMU_TEMP_SENSOR 107 } type; 108 }; 109 110 struct smu_softc { 111 device_t sc_dev; 112 struct mtx sc_mtx; 113 114 struct resource *sc_memr; 115 int sc_memrid; 116 int sc_u3; 117 118 bus_dma_tag_t sc_dmatag; 119 bus_space_tag_t sc_bt; 120 bus_space_handle_t sc_mailbox; 121 122 struct smu_cmd *sc_cmd, *sc_cur_cmd; 123 bus_addr_t sc_cmd_phys; 124 bus_dmamap_t sc_cmd_dmamap; 125 struct smu_cmdq sc_cmdq; 126 127 struct smu_fan *sc_fans; 128 int sc_nfans; 129 int old_style_fans; 130 struct smu_sensor *sc_sensors; 131 int sc_nsensors; 132 133 int sc_doorbellirqid; 134 struct resource *sc_doorbellirq; 135 void *sc_doorbellirqcookie; 136 137 struct proc *sc_fanmgt_proc; 138 time_t sc_lastuserchange; 139 140 /* Calibration data */ 141 uint16_t sc_cpu_diode_scale; 142 int16_t sc_cpu_diode_offset; 143 144 uint16_t sc_cpu_volt_scale; 145 int16_t sc_cpu_volt_offset; 146 uint16_t sc_cpu_curr_scale; 147 int16_t sc_cpu_curr_offset; 148 149 uint16_t sc_slots_pow_scale; 150 int16_t sc_slots_pow_offset; 151 152 struct cdev *sc_leddev; 153 }; 154 155 /* regular bus attachment functions */ 156 157 static int smu_probe(device_t); 158 static int smu_attach(device_t); 159 static const struct ofw_bus_devinfo * 160 smu_get_devinfo(device_t bus, device_t dev); 161 162 /* cpufreq notification hooks */ 163 164 static void smu_cpufreq_pre_change(device_t, const struct cf_level *level); 165 static void smu_cpufreq_post_change(device_t, const struct cf_level *level); 166 167 /* clock interface */ 168 static int smu_gettime(device_t dev, struct timespec *ts); 169 static int smu_settime(device_t dev, struct timespec *ts); 170 171 /* utility functions */ 172 static int smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait); 173 static int smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, 174 size_t len); 175 static void smu_attach_i2c(device_t dev, phandle_t i2croot); 176 static void smu_attach_fans(device_t dev, phandle_t fanroot); 177 static void smu_attach_sensors(device_t dev, phandle_t sensroot); 178 static void smu_set_sleepled(void *xdev, int onoff); 179 static int smu_server_mode(SYSCTL_HANDLER_ARGS); 180 static void smu_doorbell_intr(void *xdev); 181 static void smu_shutdown(void *xdev, int howto); 182 183 /* where to find the doorbell GPIO */ 184 185 static device_t smu_doorbell = NULL; 186 187 static device_method_t smu_methods[] = { 188 /* Device interface */ 189 DEVMETHOD(device_probe, smu_probe), 190 DEVMETHOD(device_attach, smu_attach), 191 192 /* Clock interface */ 193 DEVMETHOD(clock_gettime, smu_gettime), 194 DEVMETHOD(clock_settime, smu_settime), 195 196 /* ofw_bus interface */ 197 DEVMETHOD(bus_child_pnpinfo, ofw_bus_gen_child_pnpinfo), 198 DEVMETHOD(ofw_bus_get_devinfo, smu_get_devinfo), 199 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 200 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 201 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 202 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 203 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 204 205 { 0, 0 }, 206 }; 207 208 static driver_t smu_driver = { 209 "smu", 210 smu_methods, 211 sizeof(struct smu_softc) 212 }; 213 214 DRIVER_MODULE(smu, ofwbus, smu_driver, 0, 0); 215 static MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information"); 216 217 #define SMU_MAILBOX 0x8000860c 218 #define SMU_FANMGT_INTERVAL 1000 /* ms */ 219 220 /* Command types */ 221 #define SMU_ADC 0xd8 222 #define SMU_FAN 0x4a 223 #define SMU_RPM_STATUS 0x01 224 #define SMU_RPM_SETPOINT 0x02 225 #define SMU_PWM_STATUS 0x11 226 #define SMU_PWM_SETPOINT 0x12 227 #define SMU_I2C 0x9a 228 #define SMU_I2C_SIMPLE 0x00 229 #define SMU_I2C_NORMAL 0x01 230 #define SMU_I2C_COMBINED 0x02 231 #define SMU_MISC 0xee 232 #define SMU_MISC_GET_DATA 0x02 233 #define SMU_MISC_LED_CTRL 0x04 234 #define SMU_POWER 0xaa 235 #define SMU_POWER_EVENTS 0x8f 236 #define SMU_PWR_GET_POWERUP 0x00 237 #define SMU_PWR_SET_POWERUP 0x01 238 #define SMU_PWR_CLR_POWERUP 0x02 239 #define SMU_RTC 0x8e 240 #define SMU_RTC_GET 0x81 241 #define SMU_RTC_SET 0x80 242 243 /* Power event types */ 244 #define SMU_WAKEUP_KEYPRESS 0x01 245 #define SMU_WAKEUP_AC_INSERT 0x02 246 #define SMU_WAKEUP_AC_CHANGE 0x04 247 #define SMU_WAKEUP_RING 0x10 248 249 /* Data blocks */ 250 #define SMU_CPUTEMP_CAL 0x18 251 #define SMU_CPUVOLT_CAL 0x21 252 #define SMU_SLOTPW_CAL 0x78 253 254 /* Partitions */ 255 #define SMU_PARTITION 0x3e 256 #define SMU_PARTITION_LATEST 0x01 257 #define SMU_PARTITION_BASE 0x02 258 #define SMU_PARTITION_UPDATE 0x03 259 260 static int 261 smu_probe(device_t dev) 262 { 263 const char *name = ofw_bus_get_name(dev); 264 265 if (strcmp(name, "smu") != 0) 266 return (ENXIO); 267 268 device_set_desc(dev, "Apple System Management Unit"); 269 return (0); 270 } 271 272 static void 273 smu_phys_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error) 274 { 275 struct smu_softc *sc = xsc; 276 277 sc->sc_cmd_phys = segs[0].ds_addr; 278 } 279 280 static int 281 smu_attach(device_t dev) 282 { 283 struct smu_softc *sc; 284 phandle_t node, child; 285 uint8_t data[12]; 286 287 sc = device_get_softc(dev); 288 289 mtx_init(&sc->sc_mtx, "smu", NULL, MTX_DEF); 290 sc->sc_cur_cmd = NULL; 291 sc->sc_doorbellirqid = -1; 292 293 sc->sc_u3 = 0; 294 if (OF_finddevice("/u3") != -1) 295 sc->sc_u3 = 1; 296 297 /* 298 * Map the mailbox area. This should be determined from firmware, 299 * but I have not found a simple way to do that. 300 */ 301 bus_dma_tag_create(NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT, 302 BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL, 303 NULL, &(sc->sc_dmatag)); 304 sc->sc_bt = &bs_le_tag; 305 bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox); 306 307 /* 308 * Allocate the command buffer. This can be anywhere in the low 4 GB 309 * of memory. 310 */ 311 bus_dmamem_alloc(sc->sc_dmatag, (void **)&sc->sc_cmd, BUS_DMA_WAITOK | 312 BUS_DMA_ZERO, &sc->sc_cmd_dmamap); 313 bus_dmamap_load(sc->sc_dmatag, sc->sc_cmd_dmamap, 314 sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0); 315 STAILQ_INIT(&sc->sc_cmdq); 316 317 /* 318 * Set up handlers to change CPU voltage when CPU frequency is changed. 319 */ 320 EVENTHANDLER_REGISTER(cpufreq_pre_change, smu_cpufreq_pre_change, dev, 321 EVENTHANDLER_PRI_ANY); 322 EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change, dev, 323 EVENTHANDLER_PRI_ANY); 324 325 node = ofw_bus_get_node(dev); 326 327 /* Some SMUs have RPM and PWM controlled fans which do not sit 328 * under the same node. So we have to attach them separately. 329 */ 330 smu_attach_fans(dev, node); 331 332 /* 333 * Now detect and attach the other child devices. 334 */ 335 for (child = OF_child(node); child != 0; child = OF_peer(child)) { 336 char name[32]; 337 memset(name, 0, sizeof(name)); 338 OF_getprop(child, "name", name, sizeof(name)); 339 340 if (strncmp(name, "sensors", 8) == 0) 341 smu_attach_sensors(dev, child); 342 343 if (strncmp(name, "smu-i2c-control", 15) == 0) 344 smu_attach_i2c(dev, child); 345 } 346 347 /* Some SMUs have the I2C children directly under the bus. */ 348 smu_attach_i2c(dev, node); 349 350 /* 351 * Collect calibration constants. 352 */ 353 smu_get_datablock(dev, SMU_CPUTEMP_CAL, data, sizeof(data)); 354 sc->sc_cpu_diode_scale = (data[4] << 8) + data[5]; 355 sc->sc_cpu_diode_offset = (data[6] << 8) + data[7]; 356 357 smu_get_datablock(dev, SMU_CPUVOLT_CAL, data, sizeof(data)); 358 sc->sc_cpu_volt_scale = (data[4] << 8) + data[5]; 359 sc->sc_cpu_volt_offset = (data[6] << 8) + data[7]; 360 sc->sc_cpu_curr_scale = (data[8] << 8) + data[9]; 361 sc->sc_cpu_curr_offset = (data[10] << 8) + data[11]; 362 363 smu_get_datablock(dev, SMU_SLOTPW_CAL, data, sizeof(data)); 364 sc->sc_slots_pow_scale = (data[4] << 8) + data[5]; 365 sc->sc_slots_pow_offset = (data[6] << 8) + data[7]; 366 367 /* 368 * Set up LED interface 369 */ 370 sc->sc_leddev = led_create(smu_set_sleepled, dev, "sleepled"); 371 372 /* 373 * Reset on power loss behavior 374 */ 375 376 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 377 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 378 "server_mode", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, dev, 379 0, smu_server_mode, "I", "Enable reboot after power failure"); 380 381 /* 382 * Set up doorbell interrupt. 383 */ 384 sc->sc_doorbellirqid = 0; 385 sc->sc_doorbellirq = bus_alloc_resource_any(smu_doorbell, SYS_RES_IRQ, 386 &sc->sc_doorbellirqid, RF_ACTIVE); 387 bus_setup_intr(smu_doorbell, sc->sc_doorbellirq, 388 INTR_TYPE_MISC | INTR_MPSAFE, NULL, smu_doorbell_intr, dev, 389 &sc->sc_doorbellirqcookie); 390 powerpc_config_intr(rman_get_start(sc->sc_doorbellirq), 391 INTR_TRIGGER_EDGE, INTR_POLARITY_LOW); 392 393 /* 394 * Connect RTC interface. 395 */ 396 clock_register(dev, 1000); 397 398 /* 399 * Learn about shutdown events 400 */ 401 EVENTHANDLER_REGISTER(shutdown_final, smu_shutdown, dev, 402 SHUTDOWN_PRI_LAST); 403 404 return (bus_generic_attach(dev)); 405 } 406 407 static const struct ofw_bus_devinfo * 408 smu_get_devinfo(device_t bus, device_t dev) 409 { 410 411 return (device_get_ivars(dev)); 412 } 413 414 static void 415 smu_send_cmd(device_t dev, struct smu_cmd *cmd) 416 { 417 struct smu_softc *sc; 418 419 sc = device_get_softc(dev); 420 421 mtx_assert(&sc->sc_mtx, MA_OWNED); 422 423 if (sc->sc_u3) 424 powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */ 425 426 sc->sc_cur_cmd = cmd; 427 428 /* Copy the command to the mailbox */ 429 sc->sc_cmd->cmd = cmd->cmd; 430 sc->sc_cmd->len = cmd->len; 431 memcpy(sc->sc_cmd->data, cmd->data, sizeof(cmd->data)); 432 bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_PREWRITE); 433 bus_space_write_4(sc->sc_bt, sc->sc_mailbox, 0, sc->sc_cmd_phys); 434 435 /* Flush the cacheline it is in -- SMU bypasses the cache */ 436 __asm __volatile("sync; dcbf 0,%0; sync" :: "r"(sc->sc_cmd): "memory"); 437 438 /* Ring SMU doorbell */ 439 macgpio_write(smu_doorbell, GPIO_DDR_OUTPUT); 440 } 441 442 static void 443 smu_doorbell_intr(void *xdev) 444 { 445 device_t smu; 446 struct smu_softc *sc; 447 int doorbell_ack; 448 449 smu = xdev; 450 doorbell_ack = macgpio_read(smu_doorbell); 451 sc = device_get_softc(smu); 452 453 if (doorbell_ack != (GPIO_DDR_OUTPUT | GPIO_LEVEL_RO | GPIO_DATA)) 454 return; 455 456 mtx_lock(&sc->sc_mtx); 457 458 if (sc->sc_cur_cmd == NULL) /* spurious */ 459 goto done; 460 461 /* Check result. First invalidate the cache again... */ 462 __asm __volatile("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory"); 463 464 bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_POSTREAD); 465 466 sc->sc_cur_cmd->cmd = sc->sc_cmd->cmd; 467 sc->sc_cur_cmd->len = sc->sc_cmd->len; 468 memcpy(sc->sc_cur_cmd->data, sc->sc_cmd->data, 469 sizeof(sc->sc_cmd->data)); 470 wakeup(sc->sc_cur_cmd); 471 sc->sc_cur_cmd = NULL; 472 if (sc->sc_u3) 473 powerpc_pow_enabled = 1; 474 475 done: 476 /* Queue next command if one is pending */ 477 if (STAILQ_FIRST(&sc->sc_cmdq) != NULL) { 478 sc->sc_cur_cmd = STAILQ_FIRST(&sc->sc_cmdq); 479 STAILQ_REMOVE_HEAD(&sc->sc_cmdq, cmd_q); 480 smu_send_cmd(smu, sc->sc_cur_cmd); 481 } 482 483 mtx_unlock(&sc->sc_mtx); 484 } 485 486 static int 487 smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait) 488 { 489 struct smu_softc *sc; 490 uint8_t cmd_code; 491 int error; 492 493 sc = device_get_softc(dev); 494 cmd_code = cmd->cmd; 495 496 mtx_lock(&sc->sc_mtx); 497 if (sc->sc_cur_cmd != NULL) { 498 STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q); 499 } else 500 smu_send_cmd(dev, cmd); 501 mtx_unlock(&sc->sc_mtx); 502 503 if (!wait) 504 return (0); 505 506 if (sc->sc_doorbellirqid < 0) { 507 /* Poll if the IRQ has not been set up yet */ 508 do { 509 DELAY(50); 510 smu_doorbell_intr(dev); 511 } while (sc->sc_cur_cmd != NULL); 512 } else { 513 /* smu_doorbell_intr will wake us when the command is ACK'ed */ 514 error = tsleep(cmd, 0, "smu", 800 * hz / 1000); 515 if (error != 0) 516 smu_doorbell_intr(dev); /* One last chance */ 517 518 if (error != 0) { 519 mtx_lock(&sc->sc_mtx); 520 if (cmd->cmd == cmd_code) { /* Never processed */ 521 /* Abort this command if we timed out */ 522 if (sc->sc_cur_cmd == cmd) 523 sc->sc_cur_cmd = NULL; 524 else 525 STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd, 526 cmd_q); 527 mtx_unlock(&sc->sc_mtx); 528 return (error); 529 } 530 error = 0; 531 mtx_unlock(&sc->sc_mtx); 532 } 533 } 534 535 /* SMU acks the command by inverting the command bits */ 536 if (cmd->cmd == ((~cmd_code) & 0xff)) 537 error = 0; 538 else 539 error = EIO; 540 541 return (error); 542 } 543 544 static int 545 smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, size_t len) 546 { 547 struct smu_cmd cmd; 548 uint8_t addr[4]; 549 550 cmd.cmd = SMU_PARTITION; 551 cmd.len = 2; 552 cmd.data[0] = SMU_PARTITION_LATEST; 553 cmd.data[1] = id; 554 555 smu_run_cmd(dev, &cmd, 1); 556 557 addr[0] = addr[1] = 0; 558 addr[2] = cmd.data[0]; 559 addr[3] = cmd.data[1]; 560 561 cmd.cmd = SMU_MISC; 562 cmd.len = 7; 563 cmd.data[0] = SMU_MISC_GET_DATA; 564 cmd.data[1] = sizeof(addr); 565 memcpy(&cmd.data[2], addr, sizeof(addr)); 566 cmd.data[6] = len; 567 568 smu_run_cmd(dev, &cmd, 1); 569 memcpy(buf, cmd.data, len); 570 return (0); 571 } 572 573 static void 574 smu_slew_cpu_voltage(device_t dev, int to) 575 { 576 struct smu_cmd cmd; 577 578 cmd.cmd = SMU_POWER; 579 cmd.len = 8; 580 cmd.data[0] = 'V'; 581 cmd.data[1] = 'S'; 582 cmd.data[2] = 'L'; 583 cmd.data[3] = 'E'; 584 cmd.data[4] = 'W'; 585 cmd.data[5] = 0xff; 586 cmd.data[6] = 1; 587 cmd.data[7] = to; 588 589 smu_run_cmd(dev, &cmd, 1); 590 } 591 592 static void 593 smu_cpufreq_pre_change(device_t dev, const struct cf_level *level) 594 { 595 /* 596 * Make sure the CPU voltage is raised before we raise 597 * the clock. 598 */ 599 600 if (level->rel_set[0].freq == 10000 /* max */) 601 smu_slew_cpu_voltage(dev, 0); 602 } 603 604 static void 605 smu_cpufreq_post_change(device_t dev, const struct cf_level *level) 606 { 607 /* We are safe to reduce CPU voltage after a downward transition */ 608 609 if (level->rel_set[0].freq < 10000 /* max */) 610 smu_slew_cpu_voltage(dev, 1); /* XXX: 1/4 voltage for 970MP? */ 611 } 612 613 /* Routines for probing the SMU doorbell GPIO */ 614 static int doorbell_probe(device_t dev); 615 static int doorbell_attach(device_t dev); 616 617 static device_method_t doorbell_methods[] = { 618 /* Device interface */ 619 DEVMETHOD(device_probe, doorbell_probe), 620 DEVMETHOD(device_attach, doorbell_attach), 621 { 0, 0 }, 622 }; 623 624 static driver_t doorbell_driver = { 625 "smudoorbell", 626 doorbell_methods, 627 0 628 }; 629 630 EARLY_DRIVER_MODULE(smudoorbell, macgpio, doorbell_driver, 0, 0, 631 BUS_PASS_SUPPORTDEV); 632 633 static int 634 doorbell_probe(device_t dev) 635 { 636 const char *name = ofw_bus_get_name(dev); 637 638 if (strcmp(name, "smu-doorbell") != 0) 639 return (ENXIO); 640 641 device_set_desc(dev, "SMU Doorbell GPIO"); 642 device_quiet(dev); 643 return (0); 644 } 645 646 static int 647 doorbell_attach(device_t dev) 648 { 649 smu_doorbell = dev; 650 return (0); 651 } 652 653 /* 654 * Sensor and fan management 655 */ 656 657 static int 658 smu_fan_check_old_style(struct smu_fan *fan) 659 { 660 device_t smu = fan->dev; 661 struct smu_softc *sc = device_get_softc(smu); 662 struct smu_cmd cmd; 663 int error; 664 665 if (sc->old_style_fans != -1) 666 return (sc->old_style_fans); 667 668 /* 669 * Apple has two fan control mechanisms. We can't distinguish 670 * them except by seeing if the new one fails. If the new one 671 * fails, use the old one. 672 */ 673 674 cmd.cmd = SMU_FAN; 675 cmd.len = 2; 676 cmd.data[0] = 0x31; 677 cmd.data[1] = fan->reg; 678 679 do { 680 error = smu_run_cmd(smu, &cmd, 1); 681 } while (error == EWOULDBLOCK); 682 683 sc->old_style_fans = (error != 0); 684 685 return (sc->old_style_fans); 686 } 687 688 static int 689 smu_fan_set_rpm(struct smu_fan *fan, int rpm) 690 { 691 device_t smu = fan->dev; 692 struct smu_cmd cmd; 693 int error; 694 695 cmd.cmd = SMU_FAN; 696 error = EIO; 697 698 /* Clamp to allowed range */ 699 rpm = max(fan->fan.min_rpm, rpm); 700 rpm = min(fan->fan.max_rpm, rpm); 701 702 smu_fan_check_old_style(fan); 703 704 if (!fan->old_style) { 705 cmd.len = 4; 706 cmd.data[0] = 0x30; 707 cmd.data[1] = fan->reg; 708 cmd.data[2] = (rpm >> 8) & 0xff; 709 cmd.data[3] = rpm & 0xff; 710 711 error = smu_run_cmd(smu, &cmd, 1); 712 if (error && error != EWOULDBLOCK) 713 fan->old_style = 1; 714 } else { 715 cmd.len = 14; 716 cmd.data[0] = 0x00; /* RPM fan. */ 717 cmd.data[1] = 1 << fan->reg; 718 cmd.data[2 + 2*fan->reg] = (rpm >> 8) & 0xff; 719 cmd.data[3 + 2*fan->reg] = rpm & 0xff; 720 error = smu_run_cmd(smu, &cmd, 1); 721 } 722 723 if (error == 0) 724 fan->setpoint = rpm; 725 726 return (error); 727 } 728 729 static int 730 smu_fan_read_rpm(struct smu_fan *fan) 731 { 732 device_t smu = fan->dev; 733 struct smu_cmd cmd; 734 int rpm, error; 735 736 smu_fan_check_old_style(fan); 737 738 if (!fan->old_style) { 739 cmd.cmd = SMU_FAN; 740 cmd.len = 2; 741 cmd.data[0] = 0x31; 742 cmd.data[1] = fan->reg; 743 744 error = smu_run_cmd(smu, &cmd, 1); 745 if (error && error != EWOULDBLOCK) 746 fan->old_style = 1; 747 748 rpm = (cmd.data[0] << 8) | cmd.data[1]; 749 } 750 751 if (fan->old_style) { 752 cmd.cmd = SMU_FAN; 753 cmd.len = 1; 754 cmd.data[0] = SMU_RPM_STATUS; 755 756 error = smu_run_cmd(smu, &cmd, 1); 757 if (error) 758 return (error); 759 760 rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2]; 761 } 762 763 return (rpm); 764 } 765 static int 766 smu_fan_set_pwm(struct smu_fan *fan, int pwm) 767 { 768 device_t smu = fan->dev; 769 struct smu_cmd cmd; 770 int error; 771 772 cmd.cmd = SMU_FAN; 773 error = EIO; 774 775 /* Clamp to allowed range */ 776 pwm = max(fan->fan.min_rpm, pwm); 777 pwm = min(fan->fan.max_rpm, pwm); 778 779 /* 780 * Apple has two fan control mechanisms. We can't distinguish 781 * them except by seeing if the new one fails. If the new one 782 * fails, use the old one. 783 */ 784 785 if (!fan->old_style) { 786 cmd.len = 4; 787 cmd.data[0] = 0x30; 788 cmd.data[1] = fan->reg; 789 cmd.data[2] = (pwm >> 8) & 0xff; 790 cmd.data[3] = pwm & 0xff; 791 792 error = smu_run_cmd(smu, &cmd, 1); 793 if (error && error != EWOULDBLOCK) 794 fan->old_style = 1; 795 } 796 797 if (fan->old_style) { 798 cmd.len = 14; 799 cmd.data[0] = 0x10; /* PWM fan. */ 800 cmd.data[1] = 1 << fan->reg; 801 cmd.data[2 + 2*fan->reg] = (pwm >> 8) & 0xff; 802 cmd.data[3 + 2*fan->reg] = pwm & 0xff; 803 error = smu_run_cmd(smu, &cmd, 1); 804 } 805 806 if (error == 0) 807 fan->setpoint = pwm; 808 809 return (error); 810 } 811 812 static int 813 smu_fan_read_pwm(struct smu_fan *fan, int *pwm, int *rpm) 814 { 815 device_t smu = fan->dev; 816 struct smu_cmd cmd; 817 int error; 818 819 if (!fan->old_style) { 820 cmd.cmd = SMU_FAN; 821 cmd.len = 2; 822 cmd.data[0] = 0x31; 823 cmd.data[1] = fan->reg; 824 825 error = smu_run_cmd(smu, &cmd, 1); 826 if (error && error != EWOULDBLOCK) 827 fan->old_style = 1; 828 829 *rpm = (cmd.data[0] << 8) | cmd.data[1]; 830 } 831 832 if (fan->old_style) { 833 cmd.cmd = SMU_FAN; 834 cmd.len = 1; 835 cmd.data[0] = SMU_PWM_STATUS; 836 837 error = smu_run_cmd(smu, &cmd, 1); 838 if (error) 839 return (error); 840 841 *rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2]; 842 } 843 if (fan->old_style) { 844 cmd.cmd = SMU_FAN; 845 cmd.len = 14; 846 cmd.data[0] = SMU_PWM_SETPOINT; 847 cmd.data[1] = 1 << fan->reg; 848 849 error = smu_run_cmd(smu, &cmd, 1); 850 if (error) 851 return (error); 852 853 *pwm = cmd.data[fan->reg*2+2]; 854 } 855 return (0); 856 } 857 858 static int 859 smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS) 860 { 861 device_t smu; 862 struct smu_softc *sc; 863 struct smu_fan *fan; 864 int pwm = 0, rpm, error = 0; 865 866 smu = arg1; 867 sc = device_get_softc(smu); 868 fan = &sc->sc_fans[arg2 & 0xff]; 869 870 if (fan->type == SMU_FAN_RPM) { 871 rpm = smu_fan_read_rpm(fan); 872 if (rpm < 0) 873 return (rpm); 874 875 error = sysctl_handle_int(oidp, &rpm, 0, req); 876 } else { 877 error = smu_fan_read_pwm(fan, &pwm, &rpm); 878 if (error < 0) 879 return (EIO); 880 881 switch (arg2 & 0xff00) { 882 case SMU_PWM_SYSCTL_PWM: 883 error = sysctl_handle_int(oidp, &pwm, 0, req); 884 break; 885 case SMU_PWM_SYSCTL_RPM: 886 error = sysctl_handle_int(oidp, &rpm, 0, req); 887 break; 888 default: 889 /* This should never happen */ 890 return (EINVAL); 891 } 892 } 893 /* We can only read the RPM from a PWM controlled fan, so return. */ 894 if ((arg2 & 0xff00) == SMU_PWM_SYSCTL_RPM) 895 return (0); 896 897 if (error || !req->newptr) 898 return (error); 899 900 sc->sc_lastuserchange = time_uptime; 901 902 if (fan->type == SMU_FAN_RPM) 903 return (smu_fan_set_rpm(fan, rpm)); 904 else 905 return (smu_fan_set_pwm(fan, pwm)); 906 } 907 908 static void 909 smu_fill_fan_prop(device_t dev, phandle_t child, int id) 910 { 911 struct smu_fan *fan; 912 struct smu_softc *sc; 913 char type[32]; 914 915 sc = device_get_softc(dev); 916 fan = &sc->sc_fans[id]; 917 918 OF_getprop(child, "device_type", type, sizeof(type)); 919 /* We have either RPM or PWM controlled fans. */ 920 if (strcmp(type, "fan-rpm-control") == 0) 921 fan->type = SMU_FAN_RPM; 922 else 923 fan->type = SMU_FAN_PWM; 924 925 fan->dev = dev; 926 fan->old_style = 0; 927 OF_getprop(child, "reg", &fan->reg, 928 sizeof(cell_t)); 929 OF_getprop(child, "min-value", &fan->fan.min_rpm, 930 sizeof(int)); 931 OF_getprop(child, "max-value", &fan->fan.max_rpm, 932 sizeof(int)); 933 OF_getprop(child, "zone", &fan->fan.zone, 934 sizeof(int)); 935 936 if (OF_getprop(child, "unmanaged-value", 937 &fan->fan.default_rpm, 938 sizeof(int)) != sizeof(int)) 939 fan->fan.default_rpm = fan->fan.max_rpm; 940 941 OF_getprop(child, "location", fan->fan.name, 942 sizeof(fan->fan.name)); 943 944 if (fan->type == SMU_FAN_RPM) 945 fan->setpoint = smu_fan_read_rpm(fan); 946 else 947 smu_fan_read_pwm(fan, &fan->setpoint, &fan->rpm); 948 } 949 950 /* On the first call count the number of fans. In the second call, 951 * after allocating the fan struct, fill the properties of the fans. 952 */ 953 static int 954 smu_count_fans(device_t dev) 955 { 956 struct smu_softc *sc; 957 phandle_t child, node, root; 958 int nfans = 0; 959 960 node = ofw_bus_get_node(dev); 961 sc = device_get_softc(dev); 962 963 /* First find the fanroots and count the number of fans. */ 964 for (root = OF_child(node); root != 0; root = OF_peer(root)) { 965 char name[32]; 966 memset(name, 0, sizeof(name)); 967 OF_getprop(root, "name", name, sizeof(name)); 968 if (strncmp(name, "rpm-fans", 9) == 0 || 969 strncmp(name, "pwm-fans", 9) == 0 || 970 strncmp(name, "fans", 5) == 0) 971 for (child = OF_child(root); child != 0; 972 child = OF_peer(child)) { 973 nfans++; 974 /* When allocated, fill the fan properties. */ 975 if (sc->sc_fans != NULL) { 976 smu_fill_fan_prop(dev, child, 977 nfans - 1); 978 } 979 } 980 } 981 if (nfans == 0) { 982 device_printf(dev, "WARNING: No fans detected!\n"); 983 return (0); 984 } 985 return (nfans); 986 } 987 988 static void 989 smu_attach_fans(device_t dev, phandle_t fanroot) 990 { 991 struct smu_fan *fan; 992 struct smu_softc *sc; 993 struct sysctl_oid *oid, *fanroot_oid; 994 struct sysctl_ctx_list *ctx; 995 char sysctl_name[32]; 996 int i, j; 997 998 sc = device_get_softc(dev); 999 1000 /* Get the number of fans. */ 1001 sc->sc_nfans = smu_count_fans(dev); 1002 if (sc->sc_nfans == 0) 1003 return; 1004 1005 /* Now we're able to allocate memory for the fans struct. */ 1006 sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU, 1007 M_WAITOK | M_ZERO); 1008 1009 /* Now fill in the properties. */ 1010 smu_count_fans(dev); 1011 1012 /* Register fans with pmac_thermal */ 1013 for (i = 0; i < sc->sc_nfans; i++) 1014 pmac_thermal_fan_register(&sc->sc_fans[i].fan); 1015 1016 ctx = device_get_sysctl_ctx(dev); 1017 fanroot_oid = SYSCTL_ADD_NODE(ctx, 1018 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans", 1019 CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "SMU Fan Information"); 1020 1021 /* Add sysctls */ 1022 for (i = 0; i < sc->sc_nfans; i++) { 1023 fan = &sc->sc_fans[i]; 1024 for (j = 0; j < strlen(fan->fan.name); j++) { 1025 sysctl_name[j] = tolower(fan->fan.name[j]); 1026 if (isspace(sysctl_name[j])) 1027 sysctl_name[j] = '_'; 1028 } 1029 sysctl_name[j] = 0; 1030 if (fan->type == SMU_FAN_RPM) { 1031 oid = SYSCTL_ADD_NODE(ctx, 1032 SYSCTL_CHILDREN(fanroot_oid), OID_AUTO, 1033 sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 1034 "Fan Information"); 1035 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1036 "minrpm", CTLFLAG_RD, 1037 &fan->fan.min_rpm, 0, 1038 "Minimum allowed RPM"); 1039 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1040 "maxrpm", CTLFLAG_RD, 1041 &fan->fan.max_rpm, 0, 1042 "Maximum allowed RPM"); 1043 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1044 "rpm",CTLTYPE_INT | CTLFLAG_RW | 1045 CTLFLAG_MPSAFE, dev, i, 1046 smu_fanrpm_sysctl, "I", "Fan RPM"); 1047 1048 fan->fan.read = (int (*)(struct pmac_fan *))smu_fan_read_rpm; 1049 fan->fan.set = (int (*)(struct pmac_fan *, int))smu_fan_set_rpm; 1050 1051 } else { 1052 oid = SYSCTL_ADD_NODE(ctx, 1053 SYSCTL_CHILDREN(fanroot_oid), OID_AUTO, 1054 sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 1055 "Fan Information"); 1056 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1057 "minpwm", CTLFLAG_RD, 1058 &fan->fan.min_rpm, 0, 1059 "Minimum allowed PWM in %"); 1060 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1061 "maxpwm", CTLFLAG_RD, 1062 &fan->fan.max_rpm, 0, 1063 "Maximum allowed PWM in %"); 1064 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1065 "pwm",CTLTYPE_INT | CTLFLAG_RW | 1066 CTLFLAG_MPSAFE, dev, 1067 SMU_PWM_SYSCTL_PWM | i, 1068 smu_fanrpm_sysctl, "I", "Fan PWM in %"); 1069 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 1070 "rpm",CTLTYPE_INT | CTLFLAG_RD | 1071 CTLFLAG_MPSAFE, dev, 1072 SMU_PWM_SYSCTL_RPM | i, 1073 smu_fanrpm_sysctl, "I", "Fan RPM"); 1074 fan->fan.read = NULL; 1075 fan->fan.set = (int (*)(struct pmac_fan *, int))smu_fan_set_pwm; 1076 } 1077 if (bootverbose) 1078 device_printf(dev, "Fan: %s type: %d\n", 1079 fan->fan.name, fan->type); 1080 } 1081 } 1082 1083 static int 1084 smu_sensor_read(struct smu_sensor *sens) 1085 { 1086 device_t smu = sens->dev; 1087 struct smu_cmd cmd; 1088 struct smu_softc *sc; 1089 int64_t value; 1090 int error; 1091 1092 cmd.cmd = SMU_ADC; 1093 cmd.len = 1; 1094 cmd.data[0] = sens->reg; 1095 error = 0; 1096 1097 error = smu_run_cmd(smu, &cmd, 1); 1098 if (error != 0) 1099 return (-1); 1100 1101 sc = device_get_softc(smu); 1102 value = (cmd.data[0] << 8) | cmd.data[1]; 1103 1104 switch (sens->type) { 1105 case SMU_TEMP_SENSOR: 1106 value *= sc->sc_cpu_diode_scale; 1107 value >>= 3; 1108 value += ((int64_t)sc->sc_cpu_diode_offset) << 9; 1109 value <<= 1; 1110 1111 /* Convert from 16.16 fixed point degC into integer 0.1 K. */ 1112 value = 10*(value >> 16) + ((10*(value & 0xffff)) >> 16) + 2731; 1113 break; 1114 case SMU_VOLTAGE_SENSOR: 1115 value *= sc->sc_cpu_volt_scale; 1116 value += sc->sc_cpu_volt_offset; 1117 value <<= 4; 1118 1119 /* Convert from 16.16 fixed point V into mV. */ 1120 value *= 15625; 1121 value /= 1024; 1122 value /= 1000; 1123 break; 1124 case SMU_CURRENT_SENSOR: 1125 value *= sc->sc_cpu_curr_scale; 1126 value += sc->sc_cpu_curr_offset; 1127 value <<= 4; 1128 1129 /* Convert from 16.16 fixed point A into mA. */ 1130 value *= 15625; 1131 value /= 1024; 1132 value /= 1000; 1133 break; 1134 case SMU_POWER_SENSOR: 1135 value *= sc->sc_slots_pow_scale; 1136 value += sc->sc_slots_pow_offset; 1137 value <<= 4; 1138 1139 /* Convert from 16.16 fixed point W into mW. */ 1140 value *= 15625; 1141 value /= 1024; 1142 value /= 1000; 1143 break; 1144 } 1145 1146 return (value); 1147 } 1148 1149 static int 1150 smu_sensor_sysctl(SYSCTL_HANDLER_ARGS) 1151 { 1152 device_t smu; 1153 struct smu_softc *sc; 1154 struct smu_sensor *sens; 1155 int value, error; 1156 1157 smu = arg1; 1158 sc = device_get_softc(smu); 1159 sens = &sc->sc_sensors[arg2]; 1160 1161 value = smu_sensor_read(sens); 1162 if (value < 0) 1163 return (EBUSY); 1164 1165 error = sysctl_handle_int(oidp, &value, 0, req); 1166 1167 return (error); 1168 } 1169 1170 static void 1171 smu_attach_sensors(device_t dev, phandle_t sensroot) 1172 { 1173 struct smu_sensor *sens; 1174 struct smu_softc *sc; 1175 struct sysctl_oid *sensroot_oid; 1176 struct sysctl_ctx_list *ctx; 1177 phandle_t child; 1178 char type[32]; 1179 int i; 1180 1181 sc = device_get_softc(dev); 1182 sc->sc_nsensors = 0; 1183 1184 for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) 1185 sc->sc_nsensors++; 1186 1187 if (sc->sc_nsensors == 0) { 1188 device_printf(dev, "WARNING: No sensors detected!\n"); 1189 return; 1190 } 1191 1192 sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct smu_sensor), 1193 M_SMU, M_WAITOK | M_ZERO); 1194 1195 sens = sc->sc_sensors; 1196 sc->sc_nsensors = 0; 1197 1198 ctx = device_get_sysctl_ctx(dev); 1199 sensroot_oid = SYSCTL_ADD_NODE(ctx, 1200 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors", 1201 CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "SMU Sensor Information"); 1202 1203 for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) { 1204 char sysctl_name[40], sysctl_desc[40]; 1205 const char *units; 1206 1207 sens->dev = dev; 1208 OF_getprop(child, "device_type", type, sizeof(type)); 1209 1210 if (strcmp(type, "current-sensor") == 0) { 1211 sens->type = SMU_CURRENT_SENSOR; 1212 units = "mA"; 1213 } else if (strcmp(type, "temp-sensor") == 0) { 1214 sens->type = SMU_TEMP_SENSOR; 1215 units = "C"; 1216 } else if (strcmp(type, "voltage-sensor") == 0) { 1217 sens->type = SMU_VOLTAGE_SENSOR; 1218 units = "mV"; 1219 } else if (strcmp(type, "power-sensor") == 0) { 1220 sens->type = SMU_POWER_SENSOR; 1221 units = "mW"; 1222 } else { 1223 continue; 1224 } 1225 1226 OF_getprop(child, "reg", &sens->reg, sizeof(cell_t)); 1227 OF_getprop(child, "zone", &sens->therm.zone, sizeof(int)); 1228 OF_getprop(child, "location", sens->therm.name, 1229 sizeof(sens->therm.name)); 1230 1231 for (i = 0; i < strlen(sens->therm.name); i++) { 1232 sysctl_name[i] = tolower(sens->therm.name[i]); 1233 if (isspace(sysctl_name[i])) 1234 sysctl_name[i] = '_'; 1235 } 1236 sysctl_name[i] = 0; 1237 1238 sprintf(sysctl_desc,"%s (%s)", sens->therm.name, units); 1239 1240 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO, 1241 sysctl_name, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, 1242 dev, sc->sc_nsensors, smu_sensor_sysctl, 1243 (sens->type == SMU_TEMP_SENSOR) ? "IK" : "I", sysctl_desc); 1244 1245 if (sens->type == SMU_TEMP_SENSOR) { 1246 /* Make up some numbers */ 1247 sens->therm.target_temp = 500 + 2731; /* 50 C */ 1248 sens->therm.max_temp = 900 + 2731; /* 90 C */ 1249 1250 sens->therm.read = 1251 (int (*)(struct pmac_therm *))smu_sensor_read; 1252 pmac_thermal_sensor_register(&sens->therm); 1253 } 1254 1255 sens++; 1256 sc->sc_nsensors++; 1257 } 1258 } 1259 1260 static void 1261 smu_set_sleepled(void *xdev, int onoff) 1262 { 1263 static struct smu_cmd cmd; 1264 device_t smu = xdev; 1265 1266 cmd.cmd = SMU_MISC; 1267 cmd.len = 3; 1268 cmd.data[0] = SMU_MISC_LED_CTRL; 1269 cmd.data[1] = 0; 1270 cmd.data[2] = onoff; 1271 1272 smu_run_cmd(smu, &cmd, 0); 1273 } 1274 1275 static int 1276 smu_server_mode(SYSCTL_HANDLER_ARGS) 1277 { 1278 struct smu_cmd cmd; 1279 u_int server_mode; 1280 device_t smu = arg1; 1281 int error; 1282 1283 cmd.cmd = SMU_POWER_EVENTS; 1284 cmd.len = 1; 1285 cmd.data[0] = SMU_PWR_GET_POWERUP; 1286 1287 error = smu_run_cmd(smu, &cmd, 1); 1288 1289 if (error) 1290 return (error); 1291 1292 server_mode = (cmd.data[1] & SMU_WAKEUP_AC_INSERT) ? 1 : 0; 1293 1294 error = sysctl_handle_int(oidp, &server_mode, 0, req); 1295 1296 if (error || !req->newptr) 1297 return (error); 1298 1299 if (server_mode == 1) 1300 cmd.data[0] = SMU_PWR_SET_POWERUP; 1301 else if (server_mode == 0) 1302 cmd.data[0] = SMU_PWR_CLR_POWERUP; 1303 else 1304 return (EINVAL); 1305 1306 cmd.len = 3; 1307 cmd.data[1] = 0; 1308 cmd.data[2] = SMU_WAKEUP_AC_INSERT; 1309 1310 return (smu_run_cmd(smu, &cmd, 1)); 1311 } 1312 1313 static void 1314 smu_shutdown(void *xdev, int howto) 1315 { 1316 device_t smu = xdev; 1317 struct smu_cmd cmd; 1318 1319 cmd.cmd = SMU_POWER; 1320 if ((howto & RB_POWEROFF) != 0) 1321 strcpy(cmd.data, "SHUTDOWN"); 1322 else if ((howto & RB_HALT) == 0) 1323 strcpy(cmd.data, "RESTART"); 1324 else 1325 return; 1326 1327 cmd.len = strlen(cmd.data); 1328 1329 smu_run_cmd(smu, &cmd, 1); 1330 1331 for (;;); 1332 } 1333 1334 static int 1335 smu_gettime(device_t dev, struct timespec *ts) 1336 { 1337 struct smu_cmd cmd; 1338 struct clocktime ct; 1339 1340 cmd.cmd = SMU_RTC; 1341 cmd.len = 1; 1342 cmd.data[0] = SMU_RTC_GET; 1343 1344 if (smu_run_cmd(dev, &cmd, 1) != 0) 1345 return (ENXIO); 1346 1347 ct.nsec = 0; 1348 ct.sec = bcd2bin(cmd.data[0]); 1349 ct.min = bcd2bin(cmd.data[1]); 1350 ct.hour = bcd2bin(cmd.data[2]); 1351 ct.dow = bcd2bin(cmd.data[3]); 1352 ct.day = bcd2bin(cmd.data[4]); 1353 ct.mon = bcd2bin(cmd.data[5]); 1354 ct.year = bcd2bin(cmd.data[6]) + 2000; 1355 1356 return (clock_ct_to_ts(&ct, ts)); 1357 } 1358 1359 static int 1360 smu_settime(device_t dev, struct timespec *ts) 1361 { 1362 static struct smu_cmd cmd; 1363 struct clocktime ct; 1364 1365 cmd.cmd = SMU_RTC; 1366 cmd.len = 8; 1367 cmd.data[0] = SMU_RTC_SET; 1368 1369 clock_ts_to_ct(ts, &ct); 1370 1371 cmd.data[1] = bin2bcd(ct.sec); 1372 cmd.data[2] = bin2bcd(ct.min); 1373 cmd.data[3] = bin2bcd(ct.hour); 1374 cmd.data[4] = bin2bcd(ct.dow); 1375 cmd.data[5] = bin2bcd(ct.day); 1376 cmd.data[6] = bin2bcd(ct.mon); 1377 cmd.data[7] = bin2bcd(ct.year - 2000); 1378 1379 return (smu_run_cmd(dev, &cmd, 0)); 1380 } 1381 1382 /* SMU I2C Interface */ 1383 1384 static int smuiic_probe(device_t dev); 1385 static int smuiic_attach(device_t dev); 1386 static int smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs); 1387 static phandle_t smuiic_get_node(device_t bus, device_t dev); 1388 1389 static device_method_t smuiic_methods[] = { 1390 /* device interface */ 1391 DEVMETHOD(device_probe, smuiic_probe), 1392 DEVMETHOD(device_attach, smuiic_attach), 1393 1394 /* iicbus interface */ 1395 DEVMETHOD(iicbus_callback, iicbus_null_callback), 1396 DEVMETHOD(iicbus_transfer, smuiic_transfer), 1397 1398 /* ofw_bus interface */ 1399 DEVMETHOD(ofw_bus_get_node, smuiic_get_node), 1400 { 0, 0 } 1401 }; 1402 1403 struct smuiic_softc { 1404 struct mtx sc_mtx; 1405 volatile int sc_iic_inuse; 1406 int sc_busno; 1407 }; 1408 1409 static driver_t smuiic_driver = { 1410 "iichb", 1411 smuiic_methods, 1412 sizeof(struct smuiic_softc) 1413 }; 1414 1415 DRIVER_MODULE(smuiic, smu, smuiic_driver, 0, 0); 1416 1417 static void 1418 smu_attach_i2c(device_t smu, phandle_t i2croot) 1419 { 1420 phandle_t child; 1421 device_t cdev; 1422 struct ofw_bus_devinfo *dinfo; 1423 char name[32]; 1424 1425 for (child = OF_child(i2croot); child != 0; child = OF_peer(child)) { 1426 if (OF_getprop(child, "name", name, sizeof(name)) <= 0) 1427 continue; 1428 1429 if (strcmp(name, "i2c-bus") != 0 && strcmp(name, "i2c") != 0) 1430 continue; 1431 1432 dinfo = malloc(sizeof(struct ofw_bus_devinfo), M_SMU, 1433 M_WAITOK | M_ZERO); 1434 if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) { 1435 free(dinfo, M_SMU); 1436 continue; 1437 } 1438 1439 cdev = device_add_child(smu, NULL, -1); 1440 if (cdev == NULL) { 1441 device_printf(smu, "<%s>: device_add_child failed\n", 1442 dinfo->obd_name); 1443 ofw_bus_gen_destroy_devinfo(dinfo); 1444 free(dinfo, M_SMU); 1445 continue; 1446 } 1447 device_set_ivars(cdev, dinfo); 1448 } 1449 } 1450 1451 static int 1452 smuiic_probe(device_t dev) 1453 { 1454 const char *name; 1455 1456 name = ofw_bus_get_name(dev); 1457 if (name == NULL) 1458 return (ENXIO); 1459 1460 if (strcmp(name, "i2c-bus") == 0 || strcmp(name, "i2c") == 0) { 1461 device_set_desc(dev, "SMU I2C controller"); 1462 return (0); 1463 } 1464 1465 return (ENXIO); 1466 } 1467 1468 static int 1469 smuiic_attach(device_t dev) 1470 { 1471 struct smuiic_softc *sc = device_get_softc(dev); 1472 mtx_init(&sc->sc_mtx, "smuiic", NULL, MTX_DEF); 1473 sc->sc_iic_inuse = 0; 1474 1475 /* Get our bus number */ 1476 OF_getprop(ofw_bus_get_node(dev), "reg", &sc->sc_busno, 1477 sizeof(sc->sc_busno)); 1478 1479 /* Add the IIC bus layer */ 1480 device_add_child(dev, "iicbus", -1); 1481 1482 return (bus_generic_attach(dev)); 1483 } 1484 1485 static int 1486 smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 1487 { 1488 struct smuiic_softc *sc = device_get_softc(dev); 1489 struct smu_cmd cmd; 1490 int i, j, error; 1491 1492 mtx_lock(&sc->sc_mtx); 1493 while (sc->sc_iic_inuse) 1494 mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 100); 1495 1496 sc->sc_iic_inuse = 1; 1497 error = 0; 1498 1499 for (i = 0; i < nmsgs; i++) { 1500 cmd.cmd = SMU_I2C; 1501 cmd.data[0] = sc->sc_busno; 1502 if (msgs[i].flags & IIC_M_NOSTOP) 1503 cmd.data[1] = SMU_I2C_COMBINED; 1504 else 1505 cmd.data[1] = SMU_I2C_SIMPLE; 1506 1507 cmd.data[2] = msgs[i].slave; 1508 if (msgs[i].flags & IIC_M_RD) 1509 cmd.data[2] |= 1; 1510 1511 if (msgs[i].flags & IIC_M_NOSTOP) { 1512 KASSERT(msgs[i].len < 4, 1513 ("oversize I2C combined message")); 1514 1515 cmd.data[3] = min(msgs[i].len, 3); 1516 memcpy(&cmd.data[4], msgs[i].buf, min(msgs[i].len, 3)); 1517 i++; /* Advance to next part of message */ 1518 } else { 1519 cmd.data[3] = 0; 1520 memset(&cmd.data[4], 0, 3); 1521 } 1522 1523 cmd.data[7] = msgs[i].slave; 1524 if (msgs[i].flags & IIC_M_RD) 1525 cmd.data[7] |= 1; 1526 1527 cmd.data[8] = msgs[i].len; 1528 if (msgs[i].flags & IIC_M_RD) { 1529 memset(&cmd.data[9], 0xff, msgs[i].len); 1530 cmd.len = 9; 1531 } else { 1532 memcpy(&cmd.data[9], msgs[i].buf, msgs[i].len); 1533 cmd.len = 9 + msgs[i].len; 1534 } 1535 1536 mtx_unlock(&sc->sc_mtx); 1537 smu_run_cmd(device_get_parent(dev), &cmd, 1); 1538 mtx_lock(&sc->sc_mtx); 1539 1540 for (j = 0; j < 10; j++) { 1541 cmd.cmd = SMU_I2C; 1542 cmd.len = 1; 1543 cmd.data[0] = 0; 1544 memset(&cmd.data[1], 0xff, msgs[i].len); 1545 1546 mtx_unlock(&sc->sc_mtx); 1547 smu_run_cmd(device_get_parent(dev), &cmd, 1); 1548 mtx_lock(&sc->sc_mtx); 1549 1550 if (!(cmd.data[0] & 0x80)) 1551 break; 1552 1553 mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 10); 1554 } 1555 1556 if (cmd.data[0] & 0x80) { 1557 error = EIO; 1558 msgs[i].len = 0; 1559 goto exit; 1560 } 1561 memcpy(msgs[i].buf, &cmd.data[1], msgs[i].len); 1562 msgs[i].len = cmd.len - 1; 1563 } 1564 1565 exit: 1566 sc->sc_iic_inuse = 0; 1567 mtx_unlock(&sc->sc_mtx); 1568 wakeup(sc); 1569 return (error); 1570 } 1571 1572 static phandle_t 1573 smuiic_get_node(device_t bus, device_t dev) 1574 { 1575 1576 return (ofw_bus_get_node(bus)); 1577 } 1578