1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2018 Justin Hibbits 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 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/module.h> 37 38 #include <dev/ofw/openfirm.h> 39 40 #include "cpufreq_if.h" 41 42 static int pstate_ids[256]; 43 static int pstate_freqs[256]; 44 static int npstates; 45 46 static void parse_pstates(void) 47 { 48 phandle_t node; 49 50 node = OF_finddevice("/ibm,opal/power-mgt"); 51 52 /* If this fails, npstates will remain 0, and any attachment will bail. */ 53 if (node == -1) 54 return; 55 56 npstates = OF_getencprop(node, "ibm,pstate-ids", pstate_ids, 57 sizeof(pstate_ids)); 58 if (npstates < 0) { 59 npstates = 0; 60 return; 61 } 62 63 if (OF_getencprop(node, "ibm,pstate-frequencies-mhz", pstate_freqs, 64 sizeof(pstate_freqs)) != npstates) { 65 npstates = 0; 66 return; 67 } 68 npstates /= sizeof(cell_t); 69 70 } 71 72 /* Make this a sysinit so it runs before the cpufreq driver attaches. */ 73 SYSINIT(parse_pstates, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, parse_pstates, NULL); 74 75 #define PMCR_UPPERPS_MASK 0xff00000000000000UL 76 #define PMCR_UPPERPS_SHIFT 56 77 #define PMCR_LOWERPS_MASK 0x00ff000000000000UL 78 #define PMCR_LOWERPS_SHIFT 48 79 #define PMCR_VERSION_MASK 0x0000000f 80 #define PMCR_VERSION_1 1 81 82 struct pmcr_softc { 83 device_t dev; 84 }; 85 86 static void pmcr_identify(driver_t *driver, device_t parent); 87 static int pmcr_probe(device_t dev); 88 static int pmcr_attach(device_t dev); 89 static int pmcr_settings(device_t dev, struct cf_setting *sets, int *count); 90 static int pmcr_set(device_t dev, const struct cf_setting *set); 91 static int pmcr_get(device_t dev, struct cf_setting *set); 92 static int pmcr_type(device_t dev, int *type); 93 94 static device_method_t pmcr_methods[] = { 95 /* Device interface */ 96 DEVMETHOD(device_identify, pmcr_identify), 97 DEVMETHOD(device_probe, pmcr_probe), 98 DEVMETHOD(device_attach, pmcr_attach), 99 100 /* cpufreq interface */ 101 DEVMETHOD(cpufreq_drv_set, pmcr_set), 102 DEVMETHOD(cpufreq_drv_get, pmcr_get), 103 DEVMETHOD(cpufreq_drv_type, pmcr_type), 104 DEVMETHOD(cpufreq_drv_settings, pmcr_settings), 105 106 {0, 0} 107 }; 108 109 static driver_t pmcr_driver = { 110 "pmcr", 111 pmcr_methods, 112 sizeof(struct pmcr_softc) 113 }; 114 115 static devclass_t pmcr_devclass; 116 DRIVER_MODULE(pmcr, cpu, pmcr_driver, pmcr_devclass, 0, 0); 117 118 static void 119 pmcr_identify(driver_t *driver, device_t parent) 120 { 121 122 /* Make sure we're not being doubly invoked. */ 123 if (device_find_child(parent, "pmcr", -1) != NULL) 124 return; 125 126 /* 127 * We attach a child for every CPU since settings need to 128 * be performed on every CPU in the SMP case. 129 */ 130 if (BUS_ADD_CHILD(parent, 10, "pmcr", -1) == NULL) 131 device_printf(parent, "add pmcr child failed\n"); 132 } 133 134 static int 135 pmcr_probe(device_t dev) 136 { 137 if (resource_disabled("pmcr", 0)) 138 return (ENXIO); 139 140 if (npstates == 0) 141 return (ENXIO); 142 143 device_set_desc(dev, "Power Management Control Register"); 144 return (0); 145 } 146 147 static int 148 pmcr_attach(device_t dev) 149 { 150 struct pmcr_softc *sc; 151 152 sc = device_get_softc(dev); 153 sc->dev = dev; 154 155 cpufreq_register(dev); 156 return (0); 157 } 158 159 static int 160 pmcr_settings(device_t dev, struct cf_setting *sets, int *count) 161 { 162 struct pmcr_softc *sc; 163 int i; 164 165 sc = device_get_softc(dev); 166 if (sets == NULL || count == NULL) 167 return (EINVAL); 168 if (*count < npstates) 169 return (E2BIG); 170 171 /* Return a list of valid settings for this driver. */ 172 memset(sets, CPUFREQ_VAL_UNKNOWN, sizeof(*sets) * npstates); 173 174 for (i = 0; i < npstates; i++) { 175 sets[i].freq = pstate_freqs[i]; 176 sets[i].spec[0] = pstate_ids[i]; 177 sets[i].spec[1] = i; 178 sets[i].dev = dev; 179 } 180 *count = npstates; 181 182 return (0); 183 } 184 185 static int 186 pmcr_set(device_t dev, const struct cf_setting *set) 187 { 188 register_t pmcr; 189 190 if (set == NULL) 191 return (EINVAL); 192 193 if (set->spec[1] < 0 || set->spec[1] >= npstates) 194 return (EINVAL); 195 196 pmcr = ((long)set->spec[0] << PMCR_LOWERPS_SHIFT) & PMCR_LOWERPS_MASK; 197 pmcr |= ((long)set->spec[0] << PMCR_UPPERPS_SHIFT) & PMCR_UPPERPS_MASK; 198 pmcr |= PMCR_VERSION_1; 199 200 mtspr(SPR_PMCR, pmcr); 201 powerpc_sync(); isync(); 202 203 return (0); 204 } 205 206 static int 207 pmcr_get(device_t dev, struct cf_setting *set) 208 { 209 struct pmcr_softc *sc; 210 register_t pmcr; 211 int i, pstate; 212 213 if (set == NULL) 214 return (EINVAL); 215 sc = device_get_softc(dev); 216 217 memset(set, CPUFREQ_VAL_UNKNOWN, sizeof(*set)); 218 219 pmcr = mfspr(SPR_PMCR); 220 221 pstate = (pmcr & PMCR_LOWERPS_MASK) >> PMCR_LOWERPS_SHIFT; 222 223 for (i = 0; i < npstates && pstate_ids[i] != pstate; i++) 224 ; 225 226 if (i == npstates) 227 return (EINVAL); 228 229 set->spec[0] = pstate; 230 set->spec[1] = i; 231 set->freq = pstate_freqs[i]; 232 233 set->dev = dev; 234 235 return (0); 236 } 237 238 static int 239 pmcr_type(device_t dev, int *type) 240 { 241 242 if (type == NULL) 243 return (EINVAL); 244 245 *type = CPUFREQ_TYPE_ABSOLUTE; 246 return (0); 247 } 248 249