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