sys/powerpc/powermac/smu.c

   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 }