sys/powerpc/powermac/smu.c

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