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