sys/arm/broadcom/bcm2835/bcm2835_cpufreq.c

   1 /*-
   2  * Copyright (C) 2013-2015 Daisuke Aoyama <aoyama@peach.ne.jp>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/bus.h>
  34 #include <sys/cpu.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39 #include <sys/mutex.h>
  40 #include <sys/sema.h>
  41 #include <sys/sysctl.h>
  42
  43 #include <machine/bus.h>
  44 #include <machine/cpu.h>
  45 #include <machine/intr.h>
  46
  47 #include <arm/broadcom/bcm2835/bcm2835_mbox.h>
  48 #include <arm/broadcom/bcm2835/bcm2835_mbox_prop.h>
  49 #include <arm/broadcom/bcm2835/bcm2835_vcbus.h>
  50
  51 #include "cpufreq_if.h"
  52 #include "mbox_if.h"
  53
  54 #ifdef DEBUG
  55 #define DPRINTF(fmt, ...) do {                  \
  56         printf("%s:%u: ", __func__, __LINE__);  \
  57         printf(fmt, ##__VA_ARGS__);             \
  58 } while (0)
  59 #else
  60 #define DPRINTF(fmt, ...)
  61 #endif
  62
  63 #define HZ2MHZ(freq) ((freq) / (1000 * 1000))
  64 #define MHZ2HZ(freq) ((freq) * (1000 * 1000))
  65
  66 #ifdef SOC_BCM2836
  67 #define OFFSET2MVOLT(val) (((val) / 1000))
  68 #define MVOLT2OFFSET(val) (((val) * 1000))
  69 #define DEFAULT_ARM_FREQUENCY    600
  70 #define DEFAULT_LOWEST_FREQ      600
  71 #else
  72 #define OFFSET2MVOLT(val) (1200 + ((val) * 25))
  73 #define MVOLT2OFFSET(val) (((val) - 1200) / 25)
  74 #define DEFAULT_ARM_FREQUENCY    700
  75 #define DEFAULT_LOWEST_FREQ      300
  76 #endif
  77 #define DEFAULT_CORE_FREQUENCY   250
  78 #define DEFAULT_SDRAM_FREQUENCY  400
  79 #define TRANSITION_LATENCY      1000
  80 #define MIN_OVER_VOLTAGE         -16
  81 #define MAX_OVER_VOLTAGE           6
  82 #define MSG_ERROR         -999999999
  83 #define MHZSTEP                  100
  84 #define HZSTEP     (MHZ2HZ(MHZSTEP))
  85 #define TZ_ZEROC                2732
  86
  87 #define VC_LOCK(sc) do {                        \
  88                 sema_wait(&vc_sema);            \
  89         } while (0)
  90 #define VC_UNLOCK(sc) do {                      \
  91                 sema_post(&vc_sema);            \
  92         } while (0)
  93
  94 /* ARM->VC mailbox property semaphore */
  95 static struct sema vc_sema;
  96
  97 static struct sysctl_ctx_list bcm2835_sysctl_ctx;
  98
  99 struct bcm2835_cpufreq_softc {
 100         device_t        dev;
 101         int             arm_max_freq;
 102         int             arm_min_freq;
 103         int             core_max_freq;
 104         int             core_min_freq;
 105         int             sdram_max_freq;
 106         int             sdram_min_freq;
 107         int             max_voltage_core;
 108         int             min_voltage_core;
 109
 110         /* the values written in mbox */
 111         int             voltage_core;
 112         int             voltage_sdram;
 113         int             voltage_sdram_c;
 114         int             voltage_sdram_i;
 115         int             voltage_sdram_p;
 116         int             turbo_mode;
 117
 118         /* initial hook for waiting mbox intr */
 119         struct intr_config_hook init_hook;
 120 };
 121
 122 static int cpufreq_verbose = 0;
 123 TUNABLE_INT("hw.bcm2835.cpufreq.verbose", &cpufreq_verbose);
 124 static int cpufreq_lowest_freq = DEFAULT_LOWEST_FREQ;
 125 TUNABLE_INT("hw.bcm2835.cpufreq.lowest_freq", &cpufreq_lowest_freq);
 126
 127 #ifdef PROP_DEBUG
 128 static void
 129 bcm2835_dump(const void *data, int len)
 130 {
 131         const uint8_t *p = (const uint8_t*)data;
 132         int i;
 133
 134         printf("dump @ %p:\n", data);
 135         for (i = 0; i < len; i++) {
 136                 printf("%2.2x ", p[i]);
 137                 if ((i % 4) == 3)
 138                         printf(" ");
 139                 if ((i % 16) == 15)
 140                         printf("\n");
 141         }
 142         printf("\n");
 143 }
 144 #endif
 145
 146 static int
 147 bcm2835_cpufreq_get_clock_rate(struct bcm2835_cpufreq_softc *sc,
 148     uint32_t clock_id)
 149 {
 150         struct msg_get_clock_rate msg;
 151         int rate;
 152         int err;
 153
 154         /*
 155          * Get clock rate
 156          *   Tag: 0x00030002
 157          *   Request:
 158          *     Length: 4
 159          *     Value:
 160          *       u32: clock id
 161          *   Response:
 162          *     Length: 8
 163          *     Value:
 164          *       u32: clock id
 165          *       u32: rate (in Hz)
 166          */
 167
 168         /* setup single tag buffer */
 169         memset(&msg, 0, sizeof(msg));
 170         msg.hdr.buf_size = sizeof(msg);
 171         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 172         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_CLOCK_RATE;
 173         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 174         msg.tag_hdr.val_len = sizeof(msg.body.req);
 175         msg.body.req.clock_id = clock_id;
 176         msg.end_tag = 0;
 177
 178         /* call mailbox property */
 179         err = bcm2835_mbox_property(&msg, sizeof(msg));
 180         if (err) {
 181                 device_printf(sc->dev, "can't get clock rate (id=%u)\n",
 182                     clock_id);
 183                 return (MSG_ERROR);
 184         }
 185
 186         /* result (Hz) */
 187         rate = (int)msg.body.resp.rate_hz;
 188         DPRINTF("clock = %d(Hz)\n", rate);
 189         return (rate);
 190 }
 191
 192 static int
 193 bcm2835_cpufreq_get_max_clock_rate(struct bcm2835_cpufreq_softc *sc,
 194     uint32_t clock_id)
 195 {
 196         struct msg_get_max_clock_rate msg;
 197         int rate;
 198         int err;
 199
 200         /*
 201          * Get max clock rate
 202          *   Tag: 0x00030004
 203          *   Request:
 204          *     Length: 4
 205          *     Value:
 206          *       u32: clock id
 207          *   Response:
 208          *     Length: 8
 209          *     Value:
 210          *       u32: clock id
 211          *       u32: rate (in Hz)
 212          */
 213
 214         /* setup single tag buffer */
 215         memset(&msg, 0, sizeof(msg));
 216         msg.hdr.buf_size = sizeof(msg);
 217         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 218         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_MAX_CLOCK_RATE;
 219         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 220         msg.tag_hdr.val_len = sizeof(msg.body.req);
 221         msg.body.req.clock_id = clock_id;
 222         msg.end_tag = 0;
 223
 224         /* call mailbox property */
 225         err = bcm2835_mbox_property(&msg, sizeof(msg));
 226         if (err) {
 227                 device_printf(sc->dev, "can't get max clock rate (id=%u)\n",
 228                     clock_id);
 229                 return (MSG_ERROR);
 230         }
 231
 232         /* result (Hz) */
 233         rate = (int)msg.body.resp.rate_hz;
 234         DPRINTF("clock = %d(Hz)\n", rate);
 235         return (rate);
 236 }
 237
 238 static int
 239 bcm2835_cpufreq_get_min_clock_rate(struct bcm2835_cpufreq_softc *sc,
 240     uint32_t clock_id)
 241 {
 242         struct msg_get_min_clock_rate msg;
 243         int rate;
 244         int err;
 245
 246         /*
 247          * Get min clock rate
 248          *   Tag: 0x00030007
 249          *   Request:
 250          *     Length: 4
 251          *     Value:
 252          *       u32: clock id
 253          *   Response:
 254          *     Length: 8
 255          *     Value:
 256          *       u32: clock id
 257          *       u32: rate (in Hz)
 258          */
 259
 260         /* setup single tag buffer */
 261         memset(&msg, 0, sizeof(msg));
 262         msg.hdr.buf_size = sizeof(msg);
 263         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 264         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_MIN_CLOCK_RATE;
 265         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 266         msg.tag_hdr.val_len = sizeof(msg.body.req);
 267         msg.body.req.clock_id = clock_id;
 268         msg.end_tag = 0;
 269
 270         /* call mailbox property */
 271         err = bcm2835_mbox_property(&msg, sizeof(msg));
 272         if (err) {
 273                 device_printf(sc->dev, "can't get min clock rate (id=%u)\n",
 274                     clock_id);
 275                 return (MSG_ERROR);
 276         }
 277
 278         /* result (Hz) */
 279         rate = (int)msg.body.resp.rate_hz;
 280         DPRINTF("clock = %d(Hz)\n", rate);
 281         return (rate);
 282 }
 283
 284 static int
 285 bcm2835_cpufreq_set_clock_rate(struct bcm2835_cpufreq_softc *sc,
 286     uint32_t clock_id, uint32_t rate_hz)
 287 {
 288         struct msg_set_clock_rate msg;
 289         int rate;
 290         int err;
 291
 292         /*
 293          * Set clock rate
 294          *   Tag: 0x00038002
 295          *   Request:
 296          *     Length: 8
 297          *     Value:
 298          *       u32: clock id
 299          *       u32: rate (in Hz)
 300          *   Response:
 301          *     Length: 8
 302          *     Value:
 303          *       u32: clock id
 304          *       u32: rate (in Hz)
 305          */
 306
 307         /* setup single tag buffer */
 308         memset(&msg, 0, sizeof(msg));
 309         msg.hdr.buf_size = sizeof(msg);
 310         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 311         msg.tag_hdr.tag = BCM2835_MBOX_TAG_SET_CLOCK_RATE;
 312         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 313         msg.tag_hdr.val_len = sizeof(msg.body.req);
 314         msg.body.req.clock_id = clock_id;
 315         msg.body.req.rate_hz = rate_hz;
 316         msg.end_tag = 0;
 317
 318         /* call mailbox property */
 319         err = bcm2835_mbox_property(&msg, sizeof(msg));
 320         if (err) {
 321                 device_printf(sc->dev, "can't set clock rate (id=%u)\n",
 322                     clock_id);
 323                 return (MSG_ERROR);
 324         }
 325
 326         /* workaround for core clock */
 327         if (clock_id == BCM2835_MBOX_CLOCK_ID_CORE) {
 328                 /* for safety (may change voltage without changing clock) */
 329                 DELAY(TRANSITION_LATENCY);
 330
 331                 /*
 332                  * XXX: the core clock is unable to change at once,
 333                  * to change certainly, write it twice now.
 334                  */
 335
 336                 /* setup single tag buffer */
 337                 memset(&msg, 0, sizeof(msg));
 338                 msg.hdr.buf_size = sizeof(msg);
 339                 msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 340                 msg.tag_hdr.tag = BCM2835_MBOX_TAG_SET_CLOCK_RATE;
 341                 msg.tag_hdr.val_buf_size = sizeof(msg.body);
 342                 msg.tag_hdr.val_len = sizeof(msg.body.req);
 343                 msg.body.req.clock_id = clock_id;
 344                 msg.body.req.rate_hz = rate_hz;
 345                 msg.end_tag = 0;
 346
 347                 /* call mailbox property */
 348                 err = bcm2835_mbox_property(&msg, sizeof(msg));
 349                 if (err) {
 350                         device_printf(sc->dev,
 351                             "can't set clock rate (id=%u)\n", clock_id);
 352                         return (MSG_ERROR);
 353                 }
 354         }
 355
 356         /* result (Hz) */
 357         rate = (int)msg.body.resp.rate_hz;
 358         DPRINTF("clock = %d(Hz)\n", rate);
 359         return (rate);
 360 }
 361
 362 static int
 363 bcm2835_cpufreq_get_turbo(struct bcm2835_cpufreq_softc *sc)
 364 {
 365         struct msg_get_turbo msg;
 366         int level;
 367         int err;
 368
 369         /*
 370          * Get turbo
 371          *   Tag: 0x00030009
 372          *   Request:
 373          *     Length: 4
 374          *     Value:
 375          *       u32: id
 376          *   Response:
 377          *     Length: 8
 378          *     Value:
 379          *       u32: id
 380          *       u32: level
 381          */
 382
 383         /* setup single tag buffer */
 384         memset(&msg, 0, sizeof(msg));
 385         msg.hdr.buf_size = sizeof(msg);
 386         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 387         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_TURBO;
 388         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 389         msg.tag_hdr.val_len = sizeof(msg.body.req);
 390         msg.body.req.id = 0;
 391         msg.end_tag = 0;
 392
 393         /* call mailbox property */
 394         err = bcm2835_mbox_property(&msg, sizeof(msg));
 395         if (err) {
 396                 device_printf(sc->dev, "can't get turbo\n");
 397                 return (MSG_ERROR);
 398         }
 399
 400         /* result 0=non-turbo, 1=turbo */
 401         level = (int)msg.body.resp.level;
 402         DPRINTF("level = %d\n", level);
 403         return (level);
 404 }
 405
 406 static int
 407 bcm2835_cpufreq_set_turbo(struct bcm2835_cpufreq_softc *sc, uint32_t level)
 408 {
 409         struct msg_set_turbo msg;
 410         int value;
 411         int err;
 412
 413         /*
 414          * Set turbo
 415          *   Tag: 0x00038009
 416          *   Request:
 417          *     Length: 8
 418          *     Value:
 419          *       u32: id
 420          *       u32: level
 421          *   Response:
 422          *     Length: 8
 423          *     Value:
 424          *       u32: id
 425          *       u32: level
 426          */
 427
 428         /* replace unknown value to OFF */
 429         if (level != BCM2835_MBOX_TURBO_ON && level != BCM2835_MBOX_TURBO_OFF)
 430                 level = BCM2835_MBOX_TURBO_OFF;
 431
 432         /* setup single tag buffer */
 433         memset(&msg, 0, sizeof(msg));
 434         msg.hdr.buf_size = sizeof(msg);
 435         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 436         msg.tag_hdr.tag = BCM2835_MBOX_TAG_SET_TURBO;
 437         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 438         msg.tag_hdr.val_len = sizeof(msg.body.req);
 439         msg.body.req.id = 0;
 440         msg.body.req.level = level;
 441         msg.end_tag = 0;
 442
 443         /* call mailbox property */
 444         err = bcm2835_mbox_property(&msg, sizeof(msg));
 445         if (err) {
 446                 device_printf(sc->dev, "can't set turbo\n");
 447                 return (MSG_ERROR);
 448         }
 449
 450         /* result 0=non-turbo, 1=turbo */
 451         value = (int)msg.body.resp.level;
 452         DPRINTF("level = %d\n", value);
 453         return (value);
 454 }
 455
 456 static int
 457 bcm2835_cpufreq_get_voltage(struct bcm2835_cpufreq_softc *sc,
 458     uint32_t voltage_id)
 459 {
 460         struct msg_get_voltage msg;
 461         int value;
 462         int err;
 463
 464         /*
 465          * Get voltage
 466          *   Tag: 0x00030003
 467          *   Request:
 468          *     Length: 4
 469          *     Value:
 470          *       u32: voltage id
 471          *   Response:
 472          *     Length: 8
 473          *     Value:
 474          *       u32: voltage id
 475          *       u32: value (offset from 1.2V in units of 0.025V)
 476          */
 477
 478         /* setup single tag buffer */
 479         memset(&msg, 0, sizeof(msg));
 480         msg.hdr.buf_size = sizeof(msg);
 481         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 482         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_VOLTAGE;
 483         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 484         msg.tag_hdr.val_len = sizeof(msg.body.req);
 485         msg.body.req.voltage_id = voltage_id;
 486         msg.end_tag = 0;
 487
 488         /* call mailbox property */
 489         err = bcm2835_mbox_property(&msg, sizeof(msg));
 490         if (err) {
 491                 device_printf(sc->dev, "can't get voltage\n");
 492                 return (MSG_ERROR);
 493         }
 494
 495         /* result (offset from 1.2V) */
 496         value = (int)msg.body.resp.value;
 497         DPRINTF("value = %d\n", value);
 498         return (value);
 499 }
 500
 501 static int
 502 bcm2835_cpufreq_get_max_voltage(struct bcm2835_cpufreq_softc *sc,
 503     uint32_t voltage_id)
 504 {
 505         struct msg_get_max_voltage msg;
 506         int value;
 507         int err;
 508
 509         /*
 510          * Get voltage
 511          *   Tag: 0x00030005
 512          *   Request:
 513          *     Length: 4
 514          *     Value:
 515          *       u32: voltage id
 516          *   Response:
 517          *     Length: 8
 518          *     Value:
 519          *       u32: voltage id
 520          *       u32: value (offset from 1.2V in units of 0.025V)
 521          */
 522
 523         /* setup single tag buffer */
 524         memset(&msg, 0, sizeof(msg));
 525         msg.hdr.buf_size = sizeof(msg);
 526         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 527         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_MAX_VOLTAGE;
 528         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 529         msg.tag_hdr.val_len = sizeof(msg.body.req);
 530         msg.body.req.voltage_id = voltage_id;
 531         msg.end_tag = 0;
 532
 533         /* call mailbox property */
 534         err = bcm2835_mbox_property(&msg, sizeof(msg));
 535         if (err) {
 536                 device_printf(sc->dev, "can't get max voltage\n");
 537                 return (MSG_ERROR);
 538         }
 539
 540         /* result (offset from 1.2V) */
 541         value = (int)msg.body.resp.value;
 542         DPRINTF("value = %d\n", value);
 543         return (value);
 544 }
 545 static int
 546 bcm2835_cpufreq_get_min_voltage(struct bcm2835_cpufreq_softc *sc,
 547     uint32_t voltage_id)
 548 {
 549         struct msg_get_min_voltage msg;
 550         int value;
 551         int err;
 552
 553         /*
 554          * Get voltage
 555          *   Tag: 0x00030008
 556          *   Request:
 557          *     Length: 4
 558          *     Value:
 559          *       u32: voltage id
 560          *   Response:
 561          *     Length: 8
 562          *     Value:
 563          *       u32: voltage id
 564          *       u32: value (offset from 1.2V in units of 0.025V)
 565          */
 566
 567         /* setup single tag buffer */
 568         memset(&msg, 0, sizeof(msg));
 569         msg.hdr.buf_size = sizeof(msg);
 570         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 571         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_MIN_VOLTAGE;
 572         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 573         msg.tag_hdr.val_len = sizeof(msg.body.req);
 574         msg.body.req.voltage_id = voltage_id;
 575         msg.end_tag = 0;
 576
 577         /* call mailbox property */
 578         err = bcm2835_mbox_property(&msg, sizeof(msg));
 579         if (err) {
 580                 device_printf(sc->dev, "can't get min voltage\n");
 581                 return (MSG_ERROR);
 582         }
 583
 584         /* result (offset from 1.2V) */
 585         value = (int)msg.body.resp.value;
 586         DPRINTF("value = %d\n", value);
 587         return (value);
 588 }
 589
 590 static int
 591 bcm2835_cpufreq_set_voltage(struct bcm2835_cpufreq_softc *sc,
 592     uint32_t voltage_id, int32_t value)
 593 {
 594         struct msg_set_voltage msg;
 595         int err;
 596
 597         /*
 598          * Set voltage
 599          *   Tag: 0x00038003
 600          *   Request:
 601          *     Length: 4
 602          *     Value:
 603          *       u32: voltage id
 604          *       u32: value (offset from 1.2V in units of 0.025V)
 605          *   Response:
 606          *     Length: 8
 607          *     Value:
 608          *       u32: voltage id
 609          *       u32: value (offset from 1.2V in units of 0.025V)
 610          */
 611
 612         /*
 613          * over_voltage:
 614          * 0 (1.2 V). Values above 6 are only allowed when force_turbo or
 615          * current_limit_override are specified (which set the warranty bit).
 616          */
 617         if (value > MAX_OVER_VOLTAGE || value < MIN_OVER_VOLTAGE) {
 618                 /* currently not supported */
 619                 device_printf(sc->dev, "not supported voltage: %d\n", value);
 620                 return (MSG_ERROR);
 621         }
 622
 623         /* setup single tag buffer */
 624         memset(&msg, 0, sizeof(msg));
 625         msg.hdr.buf_size = sizeof(msg);
 626         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 627         msg.tag_hdr.tag = BCM2835_MBOX_TAG_SET_VOLTAGE;
 628         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 629         msg.tag_hdr.val_len = sizeof(msg.body.req);
 630         msg.body.req.voltage_id = voltage_id;
 631         msg.body.req.value = (uint32_t)value;
 632         msg.end_tag = 0;
 633
 634         /* call mailbox property */
 635         err = bcm2835_mbox_property(&msg, sizeof(msg));
 636         if (err) {
 637                 device_printf(sc->dev, "can't set voltage\n");
 638                 return (MSG_ERROR);
 639         }
 640
 641         /* result (offset from 1.2V) */
 642         value = (int)msg.body.resp.value;
 643         DPRINTF("value = %d\n", value);
 644         return (value);
 645 }
 646
 647 static int
 648 bcm2835_cpufreq_get_temperature(struct bcm2835_cpufreq_softc *sc)
 649 {
 650         struct msg_get_temperature msg;
 651         int value;
 652         int err;
 653
 654         /*
 655          * Get temperature
 656          *   Tag: 0x00030006
 657          *   Request:
 658          *     Length: 4
 659          *     Value:
 660          *       u32: temperature id
 661          *   Response:
 662          *     Length: 8
 663          *     Value:
 664          *       u32: temperature id
 665          *       u32: value
 666          */
 667
 668         /* setup single tag buffer */
 669         memset(&msg, 0, sizeof(msg));
 670         msg.hdr.buf_size = sizeof(msg);
 671         msg.hdr.code = BCM2835_MBOX_CODE_REQ;
 672         msg.tag_hdr.tag = BCM2835_MBOX_TAG_GET_TEMPERATURE;
 673         msg.tag_hdr.val_buf_size = sizeof(msg.body);
 674         msg.tag_hdr.val_len = sizeof(msg.body.req);
 675         msg.body.req.temperature_id = 0;
 676         msg.end_tag = 0;
 677
 678         /* call mailbox property */
 679         err = bcm2835_mbox_property(&msg, sizeof(msg));
 680         if (err) {
 681                 device_printf(sc->dev, "can't get temperature\n");
 682                 return (MSG_ERROR);
 683         }
 684
 685         /* result (temperature of degree C) */
 686         value = (int)msg.body.resp.value;
 687         DPRINTF("value = %d\n", value);
 688         return (value);
 689 }
 690
 691
 692
 693 static int
 694 sysctl_bcm2835_cpufreq_arm_freq(SYSCTL_HANDLER_ARGS)
 695 {
 696         struct bcm2835_cpufreq_softc *sc = arg1;
 697         int val;
 698         int err;
 699
 700         /* get realtime value */
 701         VC_LOCK(sc);
 702         val = bcm2835_cpufreq_get_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_ARM);
 703         VC_UNLOCK(sc);
 704         if (val == MSG_ERROR)
 705                 return (EIO);
 706
 707         err = sysctl_handle_int(oidp, &val, 0, req);
 708         if (err || !req->newptr) /* error || read request */
 709                 return (err);
 710
 711         /* write request */
 712         VC_LOCK(sc);
 713         err = bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_ARM,
 714             val);
 715         VC_UNLOCK(sc);
 716         if (err == MSG_ERROR) {
 717                 device_printf(sc->dev, "set clock arm_freq error\n");
 718                 return (EIO);
 719         }
 720         DELAY(TRANSITION_LATENCY);
 721
 722         return (0);
 723 }
 724
 725 static int
 726 sysctl_bcm2835_cpufreq_core_freq(SYSCTL_HANDLER_ARGS)
 727 {
 728         struct bcm2835_cpufreq_softc *sc = arg1;
 729         int val;
 730         int err;
 731
 732         /* get realtime value */
 733         VC_LOCK(sc);
 734         val = bcm2835_cpufreq_get_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_CORE);
 735         VC_UNLOCK(sc);
 736         if (val == MSG_ERROR)
 737                 return (EIO);
 738
 739         err = sysctl_handle_int(oidp, &val, 0, req);
 740         if (err || !req->newptr) /* error || read request */
 741                 return (err);
 742
 743         /* write request */
 744         VC_LOCK(sc);
 745         err = bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_CORE,
 746             val);
 747         if (err == MSG_ERROR) {
 748                 VC_UNLOCK(sc);
 749                 device_printf(sc->dev, "set clock core_freq error\n");
 750                 return (EIO);
 751         }
 752         VC_UNLOCK(sc);
 753         DELAY(TRANSITION_LATENCY);
 754
 755         return (0);
 756 }
 757
 758 static int
 759 sysctl_bcm2835_cpufreq_sdram_freq(SYSCTL_HANDLER_ARGS)
 760 {
 761         struct bcm2835_cpufreq_softc *sc = arg1;
 762         int val;
 763         int err;
 764
 765         /* get realtime value */
 766         VC_LOCK(sc);
 767         val = bcm2835_cpufreq_get_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_SDRAM);
 768         VC_UNLOCK(sc);
 769         if (val == MSG_ERROR)
 770                 return (EIO);
 771
 772         err = sysctl_handle_int(oidp, &val, 0, req);
 773         if (err || !req->newptr) /* error || read request */
 774                 return (err);
 775
 776         /* write request */
 777         VC_LOCK(sc);
 778         err = bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_SDRAM,
 779             val);
 780         VC_UNLOCK(sc);
 781         if (err == MSG_ERROR) {
 782                 device_printf(sc->dev, "set clock sdram_freq error\n");
 783                 return (EIO);
 784         }
 785         DELAY(TRANSITION_LATENCY);
 786
 787         return (0);
 788 }
 789
 790 static int
 791 sysctl_bcm2835_cpufreq_turbo(SYSCTL_HANDLER_ARGS)
 792 {
 793         struct bcm2835_cpufreq_softc *sc = arg1;
 794         int val;
 795         int err;
 796
 797         /* get realtime value */
 798         VC_LOCK(sc);
 799         val = bcm2835_cpufreq_get_turbo(sc);
 800         VC_UNLOCK(sc);
 801         if (val == MSG_ERROR)
 802                 return (EIO);
 803
 804         err = sysctl_handle_int(oidp, &val, 0, req);
 805         if (err || !req->newptr) /* error || read request */
 806                 return (err);
 807
 808         /* write request */
 809         if (val > 0)
 810                 sc->turbo_mode = BCM2835_MBOX_TURBO_ON;
 811         else
 812                 sc->turbo_mode = BCM2835_MBOX_TURBO_OFF;
 813
 814         VC_LOCK(sc);
 815         err = bcm2835_cpufreq_set_turbo(sc, sc->turbo_mode);
 816         VC_UNLOCK(sc);
 817         if (err == MSG_ERROR) {
 818                 device_printf(sc->dev, "set turbo error\n");
 819                 return (EIO);
 820         }
 821         DELAY(TRANSITION_LATENCY);
 822
 823         return (0);
 824 }
 825
 826 static int
 827 sysctl_bcm2835_cpufreq_voltage_core(SYSCTL_HANDLER_ARGS)
 828 {
 829         struct bcm2835_cpufreq_softc *sc = arg1;
 830         int val;
 831         int err;
 832
 833         /* get realtime value */
 834         VC_LOCK(sc);
 835         val = bcm2835_cpufreq_get_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_CORE);
 836         VC_UNLOCK(sc);
 837         if (val == MSG_ERROR)
 838                 return (EIO);
 839
 840         err = sysctl_handle_int(oidp, &val, 0, req);
 841         if (err || !req->newptr) /* error || read request */
 842                 return (err);
 843
 844         /* write request */
 845         if (val > MAX_OVER_VOLTAGE || val < MIN_OVER_VOLTAGE)
 846                 return (EINVAL);
 847         sc->voltage_core = val;
 848
 849         VC_LOCK(sc);
 850         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_CORE,
 851             sc->voltage_core);
 852         VC_UNLOCK(sc);
 853         if (err == MSG_ERROR) {
 854                 device_printf(sc->dev, "set voltage core error\n");
 855                 return (EIO);
 856         }
 857         DELAY(TRANSITION_LATENCY);
 858
 859         return (0);
 860 }
 861
 862 static int
 863 sysctl_bcm2835_cpufreq_voltage_sdram_c(SYSCTL_HANDLER_ARGS)
 864 {
 865         struct bcm2835_cpufreq_softc *sc = arg1;
 866         int val;
 867         int err;
 868
 869         /* get realtime value */
 870         VC_LOCK(sc);
 871         val = bcm2835_cpufreq_get_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_C);
 872         VC_UNLOCK(sc);
 873         if (val == MSG_ERROR)
 874                 return (EIO);
 875
 876         err = sysctl_handle_int(oidp, &val, 0, req);
 877         if (err || !req->newptr) /* error || read request */
 878                 return (err);
 879
 880         /* write request */
 881         if (val > MAX_OVER_VOLTAGE || val < MIN_OVER_VOLTAGE)
 882                 return (EINVAL);
 883         sc->voltage_sdram_c = val;
 884
 885         VC_LOCK(sc);
 886         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_C,
 887            sc->voltage_sdram_c);
 888         VC_UNLOCK(sc);
 889         if (err == MSG_ERROR) {
 890                 device_printf(sc->dev, "set voltage sdram_c error\n");
 891                 return (EIO);
 892         }
 893         DELAY(TRANSITION_LATENCY);
 894
 895         return (0);
 896 }
 897
 898 static int
 899 sysctl_bcm2835_cpufreq_voltage_sdram_i(SYSCTL_HANDLER_ARGS)
 900 {
 901         struct bcm2835_cpufreq_softc *sc = arg1;
 902         int val;
 903         int err;
 904
 905         /* get realtime value */
 906         VC_LOCK(sc);
 907         val = bcm2835_cpufreq_get_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_I);
 908         VC_UNLOCK(sc);
 909         if (val == MSG_ERROR)
 910                 return (EIO);
 911
 912         err = sysctl_handle_int(oidp, &val, 0, req);
 913         if (err || !req->newptr) /* error || read request */
 914                 return (err);
 915
 916         /* write request */
 917         if (val > MAX_OVER_VOLTAGE || val < MIN_OVER_VOLTAGE)
 918                 return (EINVAL);
 919         sc->voltage_sdram_i = val;
 920
 921         VC_LOCK(sc);
 922         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_I,
 923             sc->voltage_sdram_i);
 924         VC_UNLOCK(sc);
 925         if (err == MSG_ERROR) {
 926                 device_printf(sc->dev, "set voltage sdram_i error\n");
 927                 return (EIO);
 928         }
 929         DELAY(TRANSITION_LATENCY);
 930
 931         return (0);
 932 }
 933
 934 static int
 935 sysctl_bcm2835_cpufreq_voltage_sdram_p(SYSCTL_HANDLER_ARGS)
 936 {
 937         struct bcm2835_cpufreq_softc *sc = arg1;
 938         int val;
 939         int err;
 940
 941         /* get realtime value */
 942         VC_LOCK(sc);
 943         val = bcm2835_cpufreq_get_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_P);
 944         VC_UNLOCK(sc);
 945         if (val == MSG_ERROR)
 946                 return (EIO);
 947
 948         err = sysctl_handle_int(oidp, &val, 0, req);
 949         if (err || !req->newptr) /* error || read request */
 950                 return (err);
 951
 952         /* write request */
 953         if (val > MAX_OVER_VOLTAGE || val < MIN_OVER_VOLTAGE)
 954                 return (EINVAL);
 955         sc->voltage_sdram_p = val;
 956
 957         VC_LOCK(sc);
 958         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_P,
 959             sc->voltage_sdram_p);
 960         VC_UNLOCK(sc);
 961         if (err == MSG_ERROR) {
 962                 device_printf(sc->dev, "set voltage sdram_p error\n");
 963                 return (EIO);
 964         }
 965         DELAY(TRANSITION_LATENCY);
 966
 967         return (0);
 968 }
 969
 970 static int
 971 sysctl_bcm2835_cpufreq_voltage_sdram(SYSCTL_HANDLER_ARGS)
 972 {
 973         struct bcm2835_cpufreq_softc *sc = arg1;
 974         int val;
 975         int err;
 976
 977         /* multiple write only */
 978         if (!req->newptr)
 979                 return (EINVAL);
 980         val = 0;
 981         err = sysctl_handle_int(oidp, &val, 0, req);
 982         if (err)
 983                 return (err);
 984
 985         /* write request */
 986         if (val > MAX_OVER_VOLTAGE || val < MIN_OVER_VOLTAGE)
 987                 return (EINVAL);
 988         sc->voltage_sdram = val;
 989
 990         VC_LOCK(sc);
 991         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_C,
 992             val);
 993         if (err == MSG_ERROR) {
 994                 VC_UNLOCK(sc);
 995                 device_printf(sc->dev, "set voltage sdram_c error\n");
 996                 return (EIO);
 997         }
 998         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_I,
 999             val);
1000         if (err == MSG_ERROR) {
1001                 VC_UNLOCK(sc);
1002                 device_printf(sc->dev, "set voltage sdram_i error\n");
1003                 return (EIO);
1004         }
1005         err = bcm2835_cpufreq_set_voltage(sc, BCM2835_MBOX_VOLTAGE_ID_SDRAM_P,
1006             val);
1007         if (err == MSG_ERROR) {
1008                 VC_UNLOCK(sc);
1009                 device_printf(sc->dev, "set voltage sdram_p error\n");
1010                 return (EIO);
1011         }
1012         VC_UNLOCK(sc);
1013         DELAY(TRANSITION_LATENCY);
1014
1015         return (0);
1016 }
1017
1018 static int
1019 sysctl_bcm2835_cpufreq_temperature(SYSCTL_HANDLER_ARGS)
1020 {
1021         struct bcm2835_cpufreq_softc *sc = arg1;
1022         int val;
1023         int err;
1024
1025         /* get realtime value */
1026         VC_LOCK(sc);
1027         val = bcm2835_cpufreq_get_temperature(sc);
1028         VC_UNLOCK(sc);
1029         if (val == MSG_ERROR)
1030                 return (EIO);
1031
1032         err = sysctl_handle_int(oidp, &val, 0, req);
1033         if (err || !req->newptr) /* error || read request */
1034                 return (err);
1035
1036         /* write request */
1037         return (EINVAL);
1038 }
1039
1040 static int
1041 sysctl_bcm2835_devcpu_temperature(SYSCTL_HANDLER_ARGS)
1042 {
1043         struct bcm2835_cpufreq_softc *sc = arg1;
1044         int val;
1045         int err;
1046
1047         /* get realtime value */
1048         VC_LOCK(sc);
1049         val = bcm2835_cpufreq_get_temperature(sc);
1050         VC_UNLOCK(sc);
1051         if (val == MSG_ERROR)
1052                 return (EIO);
1053
1054         /* 1/1000 celsius (raw) to 1/10 kelvin */
1055         val = val / 100 + TZ_ZEROC;
1056
1057         err = sysctl_handle_int(oidp, &val, 0, req);
1058         if (err || !req->newptr) /* error || read request */
1059                 return (err);
1060
1061         /* write request */
1062         return (EINVAL);
1063 }
1064
1065
1066 static void
1067 bcm2835_cpufreq_init(void *arg)
1068 {
1069         struct bcm2835_cpufreq_softc *sc = arg;
1070         struct sysctl_ctx_list *ctx;
1071         device_t cpu;
1072         int arm_freq, core_freq, sdram_freq;
1073         int arm_max_freq, arm_min_freq, core_max_freq, core_min_freq;
1074         int sdram_max_freq, sdram_min_freq;
1075         int voltage_core, voltage_sdram_c, voltage_sdram_i, voltage_sdram_p;
1076         int max_voltage_core, min_voltage_core;
1077         int max_voltage_sdram_c, min_voltage_sdram_c;
1078         int max_voltage_sdram_i, min_voltage_sdram_i;
1079         int max_voltage_sdram_p, min_voltage_sdram_p;
1080         int turbo, temperature;
1081
1082         VC_LOCK(sc);
1083
1084         /* current clock */
1085         arm_freq = bcm2835_cpufreq_get_clock_rate(sc,
1086             BCM2835_MBOX_CLOCK_ID_ARM);
1087         core_freq = bcm2835_cpufreq_get_clock_rate(sc,
1088             BCM2835_MBOX_CLOCK_ID_CORE);
1089         sdram_freq = bcm2835_cpufreq_get_clock_rate(sc,
1090             BCM2835_MBOX_CLOCK_ID_SDRAM);
1091
1092         /* max/min clock */
1093         arm_max_freq = bcm2835_cpufreq_get_max_clock_rate(sc,
1094             BCM2835_MBOX_CLOCK_ID_ARM);
1095         arm_min_freq = bcm2835_cpufreq_get_min_clock_rate(sc,
1096             BCM2835_MBOX_CLOCK_ID_ARM);
1097         core_max_freq = bcm2835_cpufreq_get_max_clock_rate(sc,
1098             BCM2835_MBOX_CLOCK_ID_CORE);
1099         core_min_freq = bcm2835_cpufreq_get_min_clock_rate(sc,
1100             BCM2835_MBOX_CLOCK_ID_CORE);
1101         sdram_max_freq = bcm2835_cpufreq_get_max_clock_rate(sc,
1102             BCM2835_MBOX_CLOCK_ID_SDRAM);
1103         sdram_min_freq = bcm2835_cpufreq_get_min_clock_rate(sc,
1104             BCM2835_MBOX_CLOCK_ID_SDRAM);
1105
1106         /* turbo mode */
1107         turbo = bcm2835_cpufreq_get_turbo(sc);
1108         if (turbo > 0)
1109                 sc->turbo_mode = BCM2835_MBOX_TURBO_ON;
1110         else
1111                 sc->turbo_mode = BCM2835_MBOX_TURBO_OFF;
1112
1113         /* voltage */
1114         voltage_core = bcm2835_cpufreq_get_voltage(sc,
1115             BCM2835_MBOX_VOLTAGE_ID_CORE);
1116         voltage_sdram_c = bcm2835_cpufreq_get_voltage(sc,
1117             BCM2835_MBOX_VOLTAGE_ID_SDRAM_C);
1118         voltage_sdram_i = bcm2835_cpufreq_get_voltage(sc,
1119             BCM2835_MBOX_VOLTAGE_ID_SDRAM_I);
1120         voltage_sdram_p = bcm2835_cpufreq_get_voltage(sc,
1121             BCM2835_MBOX_VOLTAGE_ID_SDRAM_P);
1122
1123         /* current values (offset from 1.2V) */
1124         sc->voltage_core = voltage_core;
1125         sc->voltage_sdram = voltage_sdram_c;
1126         sc->voltage_sdram_c = voltage_sdram_c;
1127         sc->voltage_sdram_i = voltage_sdram_i;
1128         sc->voltage_sdram_p = voltage_sdram_p;
1129
1130         /* max/min voltage */
1131         max_voltage_core = bcm2835_cpufreq_get_max_voltage(sc,
1132             BCM2835_MBOX_VOLTAGE_ID_CORE);
1133         min_voltage_core = bcm2835_cpufreq_get_min_voltage(sc,
1134             BCM2835_MBOX_VOLTAGE_ID_CORE);
1135         max_voltage_sdram_c = bcm2835_cpufreq_get_max_voltage(sc,
1136             BCM2835_MBOX_VOLTAGE_ID_SDRAM_C);
1137         max_voltage_sdram_i = bcm2835_cpufreq_get_max_voltage(sc,
1138             BCM2835_MBOX_VOLTAGE_ID_SDRAM_I);
1139         max_voltage_sdram_p = bcm2835_cpufreq_get_max_voltage(sc,
1140             BCM2835_MBOX_VOLTAGE_ID_SDRAM_P);
1141         min_voltage_sdram_c = bcm2835_cpufreq_get_min_voltage(sc,
1142             BCM2835_MBOX_VOLTAGE_ID_SDRAM_C);
1143         min_voltage_sdram_i = bcm2835_cpufreq_get_min_voltage(sc,
1144             BCM2835_MBOX_VOLTAGE_ID_SDRAM_I);
1145         min_voltage_sdram_p = bcm2835_cpufreq_get_min_voltage(sc,
1146             BCM2835_MBOX_VOLTAGE_ID_SDRAM_P);
1147
1148         /* temperature */
1149         temperature = bcm2835_cpufreq_get_temperature(sc);
1150
1151         /* show result */
1152         if (cpufreq_verbose || bootverbose) {
1153                 device_printf(sc->dev, "Boot settings:\n");
1154                 device_printf(sc->dev,
1155                     "current ARM %dMHz, Core %dMHz, SDRAM %dMHz, Turbo %s\n",
1156                     HZ2MHZ(arm_freq), HZ2MHZ(core_freq), HZ2MHZ(sdram_freq),
1157                     (sc->turbo_mode == BCM2835_MBOX_TURBO_ON) ? "ON" : "OFF");
1158
1159                 device_printf(sc->dev,
1160                     "max/min ARM %d/%dMHz, Core %d/%dMHz, SDRAM %d/%dMHz\n",
1161                     HZ2MHZ(arm_max_freq), HZ2MHZ(arm_min_freq),
1162                     HZ2MHZ(core_max_freq), HZ2MHZ(core_min_freq),
1163                     HZ2MHZ(sdram_max_freq), HZ2MHZ(sdram_min_freq));
1164
1165                 device_printf(sc->dev,
1166                     "current Core %dmV, SDRAM_C %dmV, SDRAM_I %dmV, "
1167                     "SDRAM_P %dmV\n",
1168                     OFFSET2MVOLT(voltage_core), OFFSET2MVOLT(voltage_sdram_c),
1169                     OFFSET2MVOLT(voltage_sdram_i),
1170                     OFFSET2MVOLT(voltage_sdram_p));
1171
1172                 device_printf(sc->dev,
1173                     "max/min Core %d/%dmV, SDRAM_C %d/%dmV, SDRAM_I %d/%dmV, "
1174                     "SDRAM_P %d/%dmV\n",
1175                     OFFSET2MVOLT(max_voltage_core),
1176                     OFFSET2MVOLT(min_voltage_core),
1177                     OFFSET2MVOLT(max_voltage_sdram_c),
1178                     OFFSET2MVOLT(min_voltage_sdram_c),
1179                     OFFSET2MVOLT(max_voltage_sdram_i),
1180                     OFFSET2MVOLT(min_voltage_sdram_i),
1181                     OFFSET2MVOLT(max_voltage_sdram_p),
1182                     OFFSET2MVOLT(min_voltage_sdram_p));
1183
1184                 device_printf(sc->dev,
1185                     "Temperature %d.%dC\n", (temperature / 1000),
1186                     (temperature % 1000) / 100);
1187         } else { /* !cpufreq_verbose && !bootverbose */
1188                 device_printf(sc->dev,
1189                     "ARM %dMHz, Core %dMHz, SDRAM %dMHz, Turbo %s\n",
1190                     HZ2MHZ(arm_freq), HZ2MHZ(core_freq), HZ2MHZ(sdram_freq),
1191                     (sc->turbo_mode == BCM2835_MBOX_TURBO_ON) ? "ON" : "OFF");
1192         }
1193
1194         /* keep in softc (MHz/mV) */
1195         sc->arm_max_freq = HZ2MHZ(arm_max_freq);
1196         sc->arm_min_freq = HZ2MHZ(arm_min_freq);
1197         sc->core_max_freq = HZ2MHZ(core_max_freq);
1198         sc->core_min_freq = HZ2MHZ(core_min_freq);
1199         sc->sdram_max_freq = HZ2MHZ(sdram_max_freq);
1200         sc->sdram_min_freq = HZ2MHZ(sdram_min_freq);
1201         sc->max_voltage_core = OFFSET2MVOLT(max_voltage_core);
1202         sc->min_voltage_core = OFFSET2MVOLT(min_voltage_core);
1203
1204         /* if turbo is on, set to max values */
1205         if (sc->turbo_mode == BCM2835_MBOX_TURBO_ON) {
1206                 bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_ARM,
1207                     arm_max_freq);
1208                 DELAY(TRANSITION_LATENCY);
1209                 bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_CORE,
1210                     core_max_freq);
1211                 DELAY(TRANSITION_LATENCY);
1212                 bcm2835_cpufreq_set_clock_rate(sc,
1213                     BCM2835_MBOX_CLOCK_ID_SDRAM, sdram_max_freq);
1214                 DELAY(TRANSITION_LATENCY);
1215         } else {
1216                 bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_ARM,
1217                     arm_min_freq);
1218                 DELAY(TRANSITION_LATENCY);
1219                 bcm2835_cpufreq_set_clock_rate(sc, BCM2835_MBOX_CLOCK_ID_CORE,
1220                     core_min_freq);
1221                 DELAY(TRANSITION_LATENCY);
1222                 bcm2835_cpufreq_set_clock_rate(sc,
1223                     BCM2835_MBOX_CLOCK_ID_SDRAM, sdram_min_freq);
1224                 DELAY(TRANSITION_LATENCY);
1225         }
1226
1227         VC_UNLOCK(sc);
1228
1229         /* add human readable temperature to dev.cpu node */
1230         cpu = device_get_parent(sc->dev);
1231         if (cpu != NULL) {
1232                 ctx = device_get_sysctl_ctx(cpu);
1233                 SYSCTL_ADD_PROC(ctx,
1234                     SYSCTL_CHILDREN(device_get_sysctl_tree(cpu)), OID_AUTO,
1235                     "temperature", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
1236                     sysctl_bcm2835_devcpu_temperature, "IK",
1237                     "Current SoC temperature");
1238         }
1239
1240         /* release this hook (continue boot) */
1241         config_intrhook_disestablish(&sc->init_hook);
1242 }
1243
1244 static void
1245 bcm2835_cpufreq_identify(driver_t *driver, device_t parent)
1246 {
1247
1248         DPRINTF("driver=%p, parent=%p\n", driver, parent);
1249         if (device_find_child(parent, "bcm2835_cpufreq", -1) != NULL)
1250                 return;
1251         if (BUS_ADD_CHILD(parent, 0, "bcm2835_cpufreq", -1) == NULL)
1252                 device_printf(parent, "add child failed\n");
1253 }
1254
1255 static int
1256 bcm2835_cpufreq_probe(device_t dev)
1257 {
1258
1259         if (device_get_unit(dev) != 0)
1260                 return (ENXIO);
1261         device_set_desc(dev, "CPU Frequency Control");
1262
1263         return (0);
1264 }
1265
1266 static int
1267 bcm2835_cpufreq_attach(device_t dev)
1268 {
1269         struct bcm2835_cpufreq_softc *sc;
1270         struct sysctl_oid *oid;
1271
1272         /* set self dev */
1273         sc = device_get_softc(dev);
1274         sc->dev = dev;
1275
1276         /* initial values */
1277         sc->arm_max_freq = -1;
1278         sc->arm_min_freq = -1;
1279         sc->core_max_freq = -1;
1280         sc->core_min_freq = -1;
1281         sc->sdram_max_freq = -1;
1282         sc->sdram_min_freq = -1;
1283         sc->max_voltage_core = 0;
1284         sc->min_voltage_core = 0;
1285
1286         /* setup sysctl at first device */
1287         if (device_get_unit(dev) == 0) {
1288                 sysctl_ctx_init(&bcm2835_sysctl_ctx);
1289                 /* create node for hw.cpufreq */
1290                 oid = SYSCTL_ADD_NODE(&bcm2835_sysctl_ctx,
1291                     SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, "cpufreq",
1292                     CTLFLAG_RD, NULL, "");
1293
1294                 /* Frequency (Hz) */
1295                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1296                     OID_AUTO, "arm_freq", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1297                     sysctl_bcm2835_cpufreq_arm_freq, "IU",
1298                     "ARM frequency (Hz)");
1299                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1300                     OID_AUTO, "core_freq", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1301                     sysctl_bcm2835_cpufreq_core_freq, "IU",
1302                     "Core frequency (Hz)");
1303                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1304                     OID_AUTO, "sdram_freq", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1305                     sysctl_bcm2835_cpufreq_sdram_freq, "IU",
1306                     "SDRAM frequency (Hz)");
1307
1308                 /* Turbo state */
1309                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1310                     OID_AUTO, "turbo", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1311                     sysctl_bcm2835_cpufreq_turbo, "IU",
1312                     "Disables dynamic clocking");
1313
1314                 /* Voltage (offset from 1.2V in units of 0.025V) */
1315                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1316                     OID_AUTO, "voltage_core", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
1317                     sysctl_bcm2835_cpufreq_voltage_core, "I",
1318                     "ARM/GPU core voltage"
1319                     "(offset from 1.2V in units of 0.025V)");
1320                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1321                     OID_AUTO, "voltage_sdram", CTLTYPE_INT | CTLFLAG_WR, sc,
1322                     0, sysctl_bcm2835_cpufreq_voltage_sdram, "I",
1323                     "SDRAM voltage (offset from 1.2V in units of 0.025V)");
1324
1325                 /* Voltage individual SDRAM */
1326                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1327                     OID_AUTO, "voltage_sdram_c", CTLTYPE_INT | CTLFLAG_RW, sc,
1328                     0, sysctl_bcm2835_cpufreq_voltage_sdram_c, "I",
1329                     "SDRAM controller voltage"
1330                     "(offset from 1.2V in units of 0.025V)");
1331                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1332                     OID_AUTO, "voltage_sdram_i", CTLTYPE_INT | CTLFLAG_RW, sc,
1333                     0, sysctl_bcm2835_cpufreq_voltage_sdram_i, "I",
1334                     "SDRAM I/O voltage (offset from 1.2V in units of 0.025V)");
1335                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1336                     OID_AUTO, "voltage_sdram_p", CTLTYPE_INT | CTLFLAG_RW, sc,
1337                     0, sysctl_bcm2835_cpufreq_voltage_sdram_p, "I",
1338                     "SDRAM phy voltage (offset from 1.2V in units of 0.025V)");
1339
1340                 /* Temperature */
1341                 SYSCTL_ADD_PROC(&bcm2835_sysctl_ctx, SYSCTL_CHILDREN(oid),
1342                     OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
1343                     sysctl_bcm2835_cpufreq_temperature, "I",
1344                     "SoC temperature (thousandths of a degree C)");
1345         }
1346
1347         /* ARM->VC lock */
1348         sema_init(&vc_sema, 1, "vcsema");
1349
1350         /* register callback for using mbox when interrupts are enabled */
1351         sc->init_hook.ich_func = bcm2835_cpufreq_init;
1352         sc->init_hook.ich_arg = sc;
1353
1354         if (config_intrhook_establish(&sc->init_hook) != 0) {
1355                 device_printf(dev, "config_intrhook_establish failed\n");
1356                 return (ENOMEM);
1357         }
1358
1359         /* this device is controlled by cpufreq(4) */
1360         cpufreq_register(dev);
1361
1362         return (0);
1363 }
1364
1365 static int
1366 bcm2835_cpufreq_detach(device_t dev)
1367 {
1368         struct bcm2835_cpufreq_softc *sc;
1369
1370         sc = device_get_softc(dev);
1371
1372         sema_destroy(&vc_sema);
1373
1374         return (cpufreq_unregister(dev));
1375 }
1376
1377 static int
1378 bcm2835_cpufreq_set(device_t dev, const struct cf_setting *cf)
1379 {
1380         struct bcm2835_cpufreq_softc *sc;
1381         uint32_t rate_hz, rem;
1382         int cur_freq, resp_freq, arm_freq, min_freq, core_freq;
1383
1384         if (cf == NULL || cf->freq < 0)
1385                 return (EINVAL);
1386
1387         sc = device_get_softc(dev);
1388
1389         /* setting clock (Hz) */
1390         rate_hz = (uint32_t)MHZ2HZ(cf->freq);
1391         rem = rate_hz % HZSTEP;
1392         rate_hz -= rem;
1393         if (rate_hz == 0)
1394                 return (EINVAL);
1395
1396         /* adjust min freq */
1397         min_freq = sc->arm_min_freq;
1398         if (sc->turbo_mode != BCM2835_MBOX_TURBO_ON)
1399                 if (min_freq > cpufreq_lowest_freq)
1400                         min_freq = cpufreq_lowest_freq;
1401
1402         if (rate_hz < MHZ2HZ(min_freq) || rate_hz > MHZ2HZ(sc->arm_max_freq))
1403                 return (EINVAL);
1404
1405         /* set new value and verify it */
1406         VC_LOCK(sc);
1407         cur_freq = bcm2835_cpufreq_get_clock_rate(sc,
1408             BCM2835_MBOX_CLOCK_ID_ARM);
1409         resp_freq = bcm2835_cpufreq_set_clock_rate(sc,
1410             BCM2835_MBOX_CLOCK_ID_ARM, rate_hz);
1411         DELAY(TRANSITION_LATENCY);
1412         arm_freq = bcm2835_cpufreq_get_clock_rate(sc,
1413             BCM2835_MBOX_CLOCK_ID_ARM);
1414
1415         /*
1416          * if non-turbo and lower than or equal min_freq,
1417          * clock down core and sdram to default first.
1418          */
1419         if (sc->turbo_mode != BCM2835_MBOX_TURBO_ON) {
1420                 core_freq = bcm2835_cpufreq_get_clock_rate(sc,
1421                     BCM2835_MBOX_CLOCK_ID_CORE);
1422                 if (rate_hz > MHZ2HZ(sc->arm_min_freq)) {
1423                         bcm2835_cpufreq_set_clock_rate(sc,
1424                             BCM2835_MBOX_CLOCK_ID_CORE,
1425                             MHZ2HZ(sc->core_max_freq));
1426                         DELAY(TRANSITION_LATENCY);
1427                         bcm2835_cpufreq_set_clock_rate(sc,
1428                             BCM2835_MBOX_CLOCK_ID_SDRAM,
1429                             MHZ2HZ(sc->sdram_max_freq));
1430                         DELAY(TRANSITION_LATENCY);
1431                 } else {
1432                         if (sc->core_min_freq < DEFAULT_CORE_FREQUENCY &&
1433                             core_freq > DEFAULT_CORE_FREQUENCY) {
1434                                 /* first, down to 250, then down to min */
1435                                 DELAY(TRANSITION_LATENCY);
1436                                 bcm2835_cpufreq_set_clock_rate(sc,
1437                                     BCM2835_MBOX_CLOCK_ID_CORE,
1438                                     MHZ2HZ(DEFAULT_CORE_FREQUENCY));
1439                                 DELAY(TRANSITION_LATENCY);
1440                                 /* reset core voltage */
1441                                 bcm2835_cpufreq_set_voltage(sc,
1442                                     BCM2835_MBOX_VOLTAGE_ID_CORE, 0);
1443                                 DELAY(TRANSITION_LATENCY);
1444                         }
1445                         bcm2835_cpufreq_set_clock_rate(sc,
1446                             BCM2835_MBOX_CLOCK_ID_CORE,
1447                             MHZ2HZ(sc->core_min_freq));
1448                         DELAY(TRANSITION_LATENCY);
1449                         bcm2835_cpufreq_set_clock_rate(sc,
1450                             BCM2835_MBOX_CLOCK_ID_SDRAM,
1451                             MHZ2HZ(sc->sdram_min_freq));
1452                         DELAY(TRANSITION_LATENCY);
1453                 }
1454         }
1455
1456         VC_UNLOCK(sc);
1457
1458         if (resp_freq < 0 || arm_freq < 0 || resp_freq != arm_freq) {
1459                 device_printf(dev, "wrong freq\n");
1460                 return (EIO);
1461         }
1462         DPRINTF("cpufreq: %d -> %d\n", cur_freq, arm_freq);
1463
1464         return (0);
1465 }
1466
1467 static int
1468 bcm2835_cpufreq_get(device_t dev, struct cf_setting *cf)
1469 {
1470         struct bcm2835_cpufreq_softc *sc;
1471         int arm_freq;
1472
1473         if (cf == NULL)
1474                 return (EINVAL);
1475
1476         sc = device_get_softc(dev);
1477         memset(cf, CPUFREQ_VAL_UNKNOWN, sizeof(*cf));
1478         cf->dev = NULL;
1479
1480         /* get cuurent value */
1481         VC_LOCK(sc);
1482         arm_freq = bcm2835_cpufreq_get_clock_rate(sc,
1483             BCM2835_MBOX_CLOCK_ID_ARM);
1484         VC_UNLOCK(sc);
1485         if (arm_freq < 0) {
1486                 device_printf(dev, "can't get clock\n");
1487                 return (EINVAL);
1488         }
1489
1490         /* CPU clock in MHz or 100ths of a percent. */
1491         cf->freq = HZ2MHZ(arm_freq);
1492         /* Voltage in mV. */
1493         cf->volts = CPUFREQ_VAL_UNKNOWN;
1494         /* Power consumed in mW. */
1495         cf->power = CPUFREQ_VAL_UNKNOWN;
1496         /* Transition latency in us. */
1497         cf->lat = TRANSITION_LATENCY;
1498         /* Driver providing this setting. */
1499         cf->dev = dev;
1500
1501         return (0);
1502 }
1503
1504 static int
1505 bcm2835_cpufreq_make_freq_list(device_t dev, struct cf_setting *sets,
1506     int *count)
1507 {
1508         struct bcm2835_cpufreq_softc *sc;
1509         int freq, min_freq, volts, rem;
1510         int idx;
1511
1512         sc = device_get_softc(dev);
1513         freq = sc->arm_max_freq;
1514         min_freq = sc->arm_min_freq;
1515
1516         /* adjust head freq to STEP */
1517         rem = freq % MHZSTEP;
1518         freq -= rem;
1519         if (freq < min_freq)
1520                 freq = min_freq;
1521
1522         /* if non-turbo, add extra low freq */
1523         if (sc->turbo_mode != BCM2835_MBOX_TURBO_ON)
1524                 if (min_freq > cpufreq_lowest_freq)
1525                         min_freq = cpufreq_lowest_freq;
1526
1527 #ifdef SOC_BCM2836
1528         /* XXX RPi2 have only 900/600MHz */
1529         idx = 0;
1530         volts = sc->min_voltage_core;
1531         sets[idx].freq = freq;
1532         sets[idx].volts = volts;
1533         sets[idx].lat = TRANSITION_LATENCY;
1534         sets[idx].dev = dev;
1535         idx++;
1536         if (freq != min_freq) {
1537                 sets[idx].freq = min_freq;
1538                 sets[idx].volts = volts;
1539                 sets[idx].lat = TRANSITION_LATENCY;
1540                 sets[idx].dev = dev;
1541                 idx++;
1542         }
1543 #else
1544         /* from freq to min_freq */
1545         for (idx = 0; idx < *count && freq >= min_freq; idx++) {
1546                 if (freq > sc->arm_min_freq)
1547                         volts = sc->max_voltage_core;
1548                 else
1549                         volts = sc->min_voltage_core;
1550                 sets[idx].freq = freq;
1551                 sets[idx].volts = volts;
1552                 sets[idx].lat = TRANSITION_LATENCY;
1553                 sets[idx].dev = dev;
1554                 freq -= MHZSTEP;
1555         }
1556 #endif
1557         *count = idx;
1558
1559         return (0);
1560 }
1561
1562 static int
1563 bcm2835_cpufreq_settings(device_t dev, struct cf_setting *sets, int *count)
1564 {
1565         struct bcm2835_cpufreq_softc *sc;
1566
1567         if (sets == NULL || count == NULL)
1568                 return (EINVAL);
1569
1570         sc = device_get_softc(dev);
1571         if (sc->arm_min_freq < 0 || sc->arm_max_freq < 0) {
1572                 printf("device is not configured\n");
1573                 return (EINVAL);
1574         }
1575
1576         /* fill data with unknown value */
1577         memset(sets, CPUFREQ_VAL_UNKNOWN, sizeof(*sets) * (*count));
1578         /* create new array up to count */
1579         bcm2835_cpufreq_make_freq_list(dev, sets, count);
1580
1581         return (0);
1582 }
1583
1584 static int
1585 bcm2835_cpufreq_type(device_t dev, int *type)
1586 {
1587
1588         if (type == NULL)
1589                 return (EINVAL);
1590         *type = CPUFREQ_TYPE_ABSOLUTE;
1591
1592         return (0);
1593 }
1594
1595 static device_method_t bcm2835_cpufreq_methods[] = {
1596         /* Device interface */
1597         DEVMETHOD(device_identify,      bcm2835_cpufreq_identify),
1598         DEVMETHOD(device_probe,         bcm2835_cpufreq_probe),
1599         DEVMETHOD(device_attach,        bcm2835_cpufreq_attach),
1600         DEVMETHOD(device_detach,        bcm2835_cpufreq_detach),
1601
1602         /* cpufreq interface */
1603         DEVMETHOD(cpufreq_drv_set,      bcm2835_cpufreq_set),
1604         DEVMETHOD(cpufreq_drv_get,      bcm2835_cpufreq_get),
1605         DEVMETHOD(cpufreq_drv_settings, bcm2835_cpufreq_settings),
1606         DEVMETHOD(cpufreq_drv_type,     bcm2835_cpufreq_type),
1607
1608         DEVMETHOD_END
1609 };
1610
1611 static devclass_t bcm2835_cpufreq_devclass;
1612 static driver_t bcm2835_cpufreq_driver = {
1613         "bcm2835_cpufreq",
1614         bcm2835_cpufreq_methods,
1615         sizeof(struct bcm2835_cpufreq_softc),
1616 };
1617
1618 DRIVER_MODULE(bcm2835_cpufreq, cpu, bcm2835_cpufreq_driver,
1619     bcm2835_cpufreq_devclass, 0, 0);