sys/platform/pc32/acpica5/acpi_pstate_machdep.c

   1 /*
   2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Sepherosa Ziehau <sepherosa@gmail.com>
   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  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/globaldata.h>
  38
  39 #include <machine/md_var.h>
  40 #include <machine/cpufunc.h>
  41 #include <machine/cpufreq.h>
  42
  43 #include "acpi.h"
  44 #include "acpi_cpu_pstate.h"
  45
  46 #define AMD_APMI_HWPSTATE               0x80
  47
  48 #define AMD_MSR_PSTATE_CSR_MASK         0x7ULL
  49 #define AMD1X_MSR_PSTATE_CTL            0xc0010062
  50 #define AMD1X_MSR_PSTATE_ST             0xc0010063
  51
  52 #define AMD_MSR_PSTATE_EN               0x8000000000000000ULL
  53
  54 #define AMD10_MSR_PSTATE_START          0xc0010064
  55 #define AMD10_MSR_PSTATE_COUNT          5
  56
  57 #define AMD0F_PST_CTL_FID(cval)         (((cval) >> 0)  & 0x3f)
  58 #define AMD0F_PST_CTL_VID(cval)         (((cval) >> 6)  & 0x1f)
  59 #define AMD0F_PST_CTL_VST(cval)         (((cval) >> 11) & 0x7f)
  60 #define AMD0F_PST_CTL_MVS(cval)         (((cval) >> 18) & 0x3)
  61 #define AMD0F_PST_CTL_PLLTIME(cval)     (((cval) >> 20) & 0x7f)
  62 #define AMD0F_PST_CTL_RVO(cval)         (((cval) >> 28) & 0x3)
  63 #define AMD0F_PST_CTL_IRT(cval)         (((cval) >> 30) & 0x3)
  64
  65 #define AMD0F_PST_ST_FID(sval)          (((sval) >> 0) & 0x3f)
  66 #define AMD0F_PST_ST_VID(sval)          (((sval) >> 6) & 0x3f)
  67
  68 static const struct acpi_pst_md *
  69                 acpi_pst_amd_probe(void);
  70 static int      acpi_pst_amd_check_csr(const struct acpi_pst_res *,
  71                     const struct acpi_pst_res *);
  72 static int      acpi_pst_amd1x_check_pstates(const struct acpi_pstate *, int,
  73                     uint32_t, uint32_t);
  74 static int      acpi_pst_amd10_check_pstates(const struct acpi_pstate *, int);
  75 static int      acpi_pst_amd0f_check_pstates(const struct acpi_pstate *, int);
  76 static int      acpi_pst_amd1x_set_pstate(const struct acpi_pst_res *,
  77                     const struct acpi_pst_res *, const struct acpi_pstate *);
  78 static int      acpi_pst_amd0f_set_pstate(const struct acpi_pst_res *,
  79                     const struct acpi_pst_res *, const struct acpi_pstate *);
  80 static const struct acpi_pstate *
  81                 acpi_pst_amd1x_get_pstate(const struct acpi_pst_res *,
  82                     const struct acpi_pstate *, int);
  83 static const struct acpi_pstate *
  84                 acpi_pst_amd0f_get_pstate(const struct acpi_pst_res *,
  85                     const struct acpi_pstate *, int);
  86
  87 static const struct acpi_pst_md acpi_pst_amd10 = {
  88         .pmd_check_csr          = acpi_pst_amd_check_csr,
  89         .pmd_check_pstates      = acpi_pst_amd10_check_pstates,
  90         .pmd_set_pstate         = acpi_pst_amd1x_set_pstate,
  91         .pmd_get_pstate         = acpi_pst_amd1x_get_pstate
  92 };
  93
  94 static const struct acpi_pst_md acpi_pst_amd0f = {
  95         .pmd_check_csr          = acpi_pst_amd_check_csr,
  96         .pmd_check_pstates      = acpi_pst_amd0f_check_pstates,
  97         .pmd_set_pstate         = acpi_pst_amd0f_set_pstate,
  98         .pmd_get_pstate         = acpi_pst_amd0f_get_pstate
  99 };
 100
 101 const struct acpi_pst_md *
 102 acpi_pst_md_probe(void)
 103 {
 104         if (strcmp(cpu_vendor, "AuthenticAMD") == 0)
 105                 return acpi_pst_amd_probe();
 106         return NULL;
 107 }
 108
 109 static const struct acpi_pst_md *
 110 acpi_pst_amd_probe(void)
 111 {
 112         uint32_t regs[4], ext_family;
 113
 114         if ((cpu_id & 0x00000f00) != 0x00000f00)
 115                 return NULL;
 116
 117         /* Check whether APMI exists */
 118         do_cpuid(0x80000000, regs);
 119         if (regs[0] < 0x80000007)
 120                 return NULL;
 121
 122         /* Fetch APMI */
 123         do_cpuid(0x80000007, regs);
 124
 125         ext_family = cpu_id & 0x0ff00000;
 126         switch (ext_family) {
 127         case 0x00000000:        /* Family 0fh */
 128                 if ((regs[3] & 0x06) == 0x06)
 129                         return &acpi_pst_amd0f;
 130                 break;
 131
 132         case 0x00100000:        /* Family 10h */
 133                 if (regs[3] & 0x80)
 134                         return &acpi_pst_amd10;
 135                 break;
 136
 137         default:
 138                 break;
 139         }
 140         return NULL;
 141 }
 142
 143 static int
 144 acpi_pst_amd_check_csr(const struct acpi_pst_res *ctrl,
 145                        const struct acpi_pst_res *status)
 146 {
 147         if (ctrl->pr_gas.SpaceId != ACPI_ADR_SPACE_FIXED_HARDWARE) {
 148                 kprintf("cpu%d: Invalid P-State control register\n", mycpuid);
 149                 return EINVAL;
 150         }
 151         if (status->pr_gas.SpaceId != ACPI_ADR_SPACE_FIXED_HARDWARE) {
 152                 kprintf("cpu%d: Invalid P-State status register\n", mycpuid);
 153                 return EINVAL;
 154         }
 155         return 0;
 156 }
 157
 158 static int
 159 acpi_pst_amd1x_check_pstates(const struct acpi_pstate *pstates, int npstates,
 160                              uint32_t msr_start, uint32_t msr_end)
 161 {
 162         int i;
 163
 164         /*
 165          * Make sure that related MSR P-State registers are enabled.
 166          *
 167          * NOTE:
 168          * We don't check status register value here;
 169          * it will not be used.
 170          */
 171         for (i = 0; i < npstates; ++i) {
 172                 uint64_t pstate;
 173                 uint32_t msr;
 174
 175                 msr = msr_start +
 176                       (pstates[i].st_cval & AMD_MSR_PSTATE_CSR_MASK);
 177                 if (msr >= msr_end) {
 178                         kprintf("cpu%d: MSR P-State register %#08x "
 179                                 "does not exist\n", mycpuid, msr);
 180                         return EINVAL;
 181                 }
 182
 183                 pstate = rdmsr(msr);
 184                 if ((pstate & AMD_MSR_PSTATE_EN) == 0) {
 185                         kprintf("cpu%d: MSR P-State register %#08x "
 186                                 "is not enabled\n", mycpuid, msr);
 187                         return EINVAL;
 188                 }
 189         }
 190         return 0;
 191 }
 192
 193 static int
 194 acpi_pst_amd10_check_pstates(const struct acpi_pstate *pstates, int npstates)
 195 {
 196         /* Only P0-P4 are supported */
 197         if (npstates > AMD10_MSR_PSTATE_COUNT) {
 198                 kprintf("cpu%d: only P0-P4 is allowed\n", mycpuid);
 199                 return EINVAL;
 200         }
 201
 202         return acpi_pst_amd1x_check_pstates(pstates, npstates,
 203                         AMD10_MSR_PSTATE_START,
 204                         AMD10_MSR_PSTATE_START + AMD10_MSR_PSTATE_COUNT);
 205 }
 206
 207 static int
 208 acpi_pst_amd1x_set_pstate(const struct acpi_pst_res *ctrl __unused,
 209                           const struct acpi_pst_res *status __unused,
 210                           const struct acpi_pstate *pstate)
 211 {
 212         uint64_t cval;
 213
 214         cval = pstate->st_cval & AMD_MSR_PSTATE_CSR_MASK;
 215         wrmsr(AMD1X_MSR_PSTATE_CTL, cval);
 216
 217         /*
 218          * Don't check AMD1X_MSR_PSTATE_ST here, since it is
 219          * affected by various P-State limits.
 220          *
 221          * For details:
 222          * AMD Family 10h Processor BKDG Rev 3.20 (#31116)
 223          * 2.4.2.4 P-state Transition Behavior
 224          */
 225
 226         return 0;
 227 }
 228
 229 static const struct acpi_pstate *
 230 acpi_pst_amd1x_get_pstate(const struct acpi_pst_res *status __unused,
 231                           const struct acpi_pstate *pstates, int npstates)
 232 {
 233         uint64_t sval;
 234         int i;
 235
 236         sval = rdmsr(AMD1X_MSR_PSTATE_ST) & AMD_MSR_PSTATE_CSR_MASK;
 237         for (i = 0; i < npstates; ++i) {
 238                 if ((pstates[i].st_sval & AMD_MSR_PSTATE_CSR_MASK) == sval)
 239                         return &pstates[i];
 240         }
 241         return NULL;
 242 }
 243
 244 static int
 245 acpi_pst_amd0f_check_pstates(const struct acpi_pstate *pstates, int npstates)
 246 {
 247         struct amd0f_fidvid fv_max, fv_min;
 248         int i;
 249
 250         amd0f_fidvid_limit(&fv_min, &fv_max);
 251
 252         for (i = 0; i < npstates; ++i) {
 253                 const struct acpi_pstate *p = &pstates[i];
 254                 uint32_t fid, vid, mvs, rvo;
 255                 int mvs_mv, rvo_mv;
 256
 257                 fid = AMD0F_PST_CTL_FID(p->st_cval);
 258                 vid = AMD0F_PST_CTL_VID(p->st_cval);
 259
 260                 if (fid > fv_max.fid || fid < fv_min.fid) {
 261                         kprintf("cpu%d: Invalid FID %#x [%#x, %#x]\n",
 262                                 mycpuid, fid, fv_min.fid, fv_max.fid);
 263                         return EINVAL;
 264                 }
 265                 if (vid < fv_max.vid || vid > fv_min.vid) {
 266                         kprintf("cpu%d: Invalid VID %#x [%#x, %#x]\n",
 267                                 mycpuid, vid, fv_max.vid, fv_min.fid);
 268                         return EINVAL;
 269                 }
 270
 271                 mvs = AMD0F_PST_CTL_MVS(p->st_cval);
 272                 rvo = AMD0F_PST_CTL_RVO(p->st_cval);
 273
 274                 /* Only 0 is allowed, i.e. 25mV stepping */
 275                 if (mvs != 0) {
 276                         kprintf("cpu%d: Invalid MVS %#x\n", mycpuid, mvs);
 277                         return EINVAL;
 278                 }
 279
 280                 /* -> mV */
 281                 mvs_mv = 25 * (1 << mvs);
 282                 rvo_mv = 25 * rvo;
 283                 if (rvo_mv % mvs_mv != 0) {
 284                         kprintf("cpu%d: Invalid MVS/RVO (%#x/%#x)\n",
 285                                 mycpuid, mvs, rvo);
 286                         return EINVAL;
 287                 }
 288         }
 289         return 0;
 290 }
 291
 292 static int
 293 acpi_pst_amd0f_set_pstate(const struct acpi_pst_res *ctrl __unused,
 294                           const struct acpi_pst_res *status __unused,
 295                           const struct acpi_pstate *pstate)
 296 {
 297         struct amd0f_fidvid fv;
 298         struct amd0f_xsit xsit;
 299
 300         fv.fid = AMD0F_PST_CTL_FID(pstate->st_cval);
 301         fv.vid = AMD0F_PST_CTL_VID(pstate->st_cval);
 302
 303         xsit.rvo = AMD0F_PST_CTL_RVO(pstate->st_cval);
 304         xsit.mvs = AMD0F_PST_CTL_MVS(pstate->st_cval);
 305         xsit.vst = AMD0F_PST_CTL_VST(pstate->st_cval);
 306         xsit.pll_time = AMD0F_PST_CTL_PLLTIME(pstate->st_cval);
 307         xsit.irt = AMD0F_PST_CTL_IRT(pstate->st_cval);
 308
 309         return amd0f_set_fidvid(&fv, &xsit);
 310 }
 311
 312 static const struct acpi_pstate *
 313 acpi_pst_amd0f_get_pstate(const struct acpi_pst_res *status __unused,
 314                           const struct acpi_pstate *pstates, int npstates)
 315 {
 316         struct amd0f_fidvid fv;
 317         int error, i;
 318
 319         error = amd0f_get_fidvid(&fv);
 320         if (error)
 321                 return NULL;
 322
 323         for (i = 0; i < npstates; ++i) {
 324                 const struct acpi_pstate *p = &pstates[i];
 325
 326                 if (fv.fid == AMD0F_PST_ST_FID(p->st_sval) &&
 327                     fv.vid == AMD0F_PST_ST_VID(p->st_sval))
 328                         return p;
 329         }
 330         return NULL;
 331 }