1 /* 2 * Copyright 2013 Red Hat Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: Ben Skeggs 23 */ 24 #include "priv.h" 25 26 #include <subdev/bios.h> 27 #include <subdev/bios/vmap.h> 28 #include <subdev/bios/volt.h> 29 #include <subdev/therm.h> 30 31 int 32 nvkm_volt_get(struct nvkm_volt *volt) 33 { 34 int ret, i; 35 36 if (volt->func->volt_get) 37 return volt->func->volt_get(volt); 38 39 ret = volt->func->vid_get(volt); 40 if (ret >= 0) { 41 for (i = 0; i < volt->vid_nr; i++) { 42 if (volt->vid[i].vid == ret) 43 return volt->vid[i].uv; 44 } 45 ret = -EINVAL; 46 } 47 return ret; 48 } 49 50 static int 51 nvkm_volt_set(struct nvkm_volt *volt, u32 uv) 52 { 53 struct nvkm_subdev *subdev = &volt->subdev; 54 int i, ret = -EINVAL, best_err = volt->max_uv, best = -1; 55 56 if (volt->func->volt_set) 57 return volt->func->volt_set(volt, uv); 58 59 for (i = 0; i < volt->vid_nr; i++) { 60 int err = volt->vid[i].uv - uv; 61 if (err < 0 || err > best_err) 62 continue; 63 64 best_err = err; 65 best = i; 66 if (best_err == 0) 67 break; 68 } 69 70 if (best == -1) { 71 nvkm_error(subdev, "couldn't set %iuv\n", uv); 72 return ret; 73 } 74 75 ret = volt->func->vid_set(volt, volt->vid[best].vid); 76 nvkm_debug(subdev, "set req %duv to %duv: %d\n", uv, 77 volt->vid[best].uv, ret); 78 return ret; 79 } 80 81 int 82 nvkm_volt_map_min(struct nvkm_volt *volt, u8 id) 83 { 84 struct nvkm_bios *bios = volt->subdev.device->bios; 85 struct nvbios_vmap_entry info; 86 u8 ver, len; 87 u32 vmap; 88 89 vmap = nvbios_vmap_entry_parse(bios, id, &ver, &len, &info); 90 if (vmap) { 91 if (info.link != 0xff) { 92 int ret = nvkm_volt_map_min(volt, info.link); 93 if (ret < 0) 94 return ret; 95 info.min += ret; 96 } 97 return info.min; 98 } 99 100 return id ? id * 10000 : -ENODEV; 101 } 102 103 int 104 nvkm_volt_map(struct nvkm_volt *volt, u8 id, u8 temp) 105 { 106 struct nvkm_bios *bios = volt->subdev.device->bios; 107 struct nvbios_vmap_entry info; 108 u8 ver, len; 109 u32 vmap; 110 111 vmap = nvbios_vmap_entry_parse(bios, id, &ver, &len, &info); 112 if (vmap) { 113 s64 result; 114 115 if (volt->speedo < 0) 116 return volt->speedo; 117 118 if (ver == 0x10 || (ver == 0x20 && info.mode == 0)) { 119 result = div64_s64((s64)info.arg[0], 10); 120 result += div64_s64((s64)info.arg[1] * volt->speedo, 10); 121 result += div64_s64((s64)info.arg[2] * volt->speedo * volt->speedo, 100000); 122 } else if (ver == 0x20) { 123 switch (info.mode) { 124 /* 0x0 handled above! */ 125 case 0x1: 126 result = ((s64)info.arg[0] * 15625) >> 18; 127 result += ((s64)info.arg[1] * volt->speedo * 15625) >> 18; 128 result += ((s64)info.arg[2] * temp * 15625) >> 10; 129 result += ((s64)info.arg[3] * volt->speedo * temp * 15625) >> 18; 130 result += ((s64)info.arg[4] * volt->speedo * volt->speedo * 15625) >> 30; 131 result += ((s64)info.arg[5] * temp * temp * 15625) >> 18; 132 break; 133 case 0x3: 134 result = (info.min + info.max) / 2; 135 break; 136 case 0x2: 137 default: 138 result = info.min; 139 break; 140 } 141 } else { 142 return -ENODEV; 143 } 144 145 result = min(max(result, (s64)info.min), (s64)info.max); 146 147 if (info.link != 0xff) { 148 int ret = nvkm_volt_map(volt, info.link, temp); 149 if (ret < 0) 150 return ret; 151 result += ret; 152 } 153 return result; 154 } 155 156 return id ? id * 10000 : -ENODEV; 157 } 158 159 int 160 nvkm_volt_set_id(struct nvkm_volt *volt, u8 id, u8 min_id, u8 temp, 161 int condition) 162 { 163 int ret; 164 165 if (volt->func->set_id) 166 return volt->func->set_id(volt, id, condition); 167 168 ret = nvkm_volt_map(volt, id, temp); 169 if (ret >= 0) { 170 int prev = nvkm_volt_get(volt); 171 if (!condition || prev < 0 || 172 (condition < 0 && ret < prev) || 173 (condition > 0 && ret > prev)) { 174 int min = nvkm_volt_map(volt, min_id, temp); 175 if (min >= 0) 176 ret = max(min, ret); 177 ret = nvkm_volt_set(volt, ret); 178 } else { 179 ret = 0; 180 } 181 } 182 return ret; 183 } 184 185 static void 186 nvkm_volt_parse_bios(struct nvkm_bios *bios, struct nvkm_volt *volt) 187 { 188 struct nvkm_subdev *subdev = &bios->subdev; 189 struct nvbios_volt_entry ivid; 190 struct nvbios_volt info; 191 u8 ver, hdr, cnt, len; 192 u32 data; 193 int i; 194 195 data = nvbios_volt_parse(bios, &ver, &hdr, &cnt, &len, &info); 196 if (data && info.vidmask && info.base && info.step && info.ranged) { 197 nvkm_debug(subdev, "found ranged based VIDs\n"); 198 volt->min_uv = info.min; 199 volt->max_uv = info.max; 200 for (i = 0; i < info.vidmask + 1; i++) { 201 if (info.base >= info.min && 202 info.base <= info.max) { 203 volt->vid[volt->vid_nr].uv = info.base; 204 volt->vid[volt->vid_nr].vid = i; 205 volt->vid_nr++; 206 } 207 info.base += info.step; 208 } 209 volt->vid_mask = info.vidmask; 210 } else if (data && info.vidmask && !info.ranged) { 211 nvkm_debug(subdev, "found entry based VIDs\n"); 212 volt->min_uv = 0xffffffff; 213 volt->max_uv = 0; 214 for (i = 0; i < cnt; i++) { 215 data = nvbios_volt_entry_parse(bios, i, &ver, &hdr, 216 &ivid); 217 if (data) { 218 volt->vid[volt->vid_nr].uv = ivid.voltage; 219 volt->vid[volt->vid_nr].vid = ivid.vid; 220 volt->vid_nr++; 221 volt->min_uv = min(volt->min_uv, ivid.voltage); 222 volt->max_uv = max(volt->max_uv, ivid.voltage); 223 } 224 } 225 volt->vid_mask = info.vidmask; 226 } else if (data && info.type == NVBIOS_VOLT_PWM) { 227 volt->min_uv = info.base; 228 volt->max_uv = info.base + info.pwm_range; 229 } 230 } 231 232 static int 233 nvkm_volt_speedo_read(struct nvkm_volt *volt) 234 { 235 if (volt->func->speedo_read) 236 return volt->func->speedo_read(volt); 237 return -EINVAL; 238 } 239 240 static int 241 nvkm_volt_init(struct nvkm_subdev *subdev) 242 { 243 struct nvkm_volt *volt = nvkm_volt(subdev); 244 int ret = nvkm_volt_get(volt); 245 if (ret < 0) { 246 if (ret != -ENODEV) 247 nvkm_debug(subdev, "current voltage unknown\n"); 248 return 0; 249 } 250 nvkm_debug(subdev, "current voltage: %duv\n", ret); 251 return 0; 252 } 253 254 static int 255 nvkm_volt_oneinit(struct nvkm_subdev *subdev) 256 { 257 struct nvkm_volt *volt = nvkm_volt(subdev); 258 259 volt->speedo = nvkm_volt_speedo_read(volt); 260 if (volt->speedo > 0) 261 nvkm_debug(&volt->subdev, "speedo %x\n", volt->speedo); 262 263 if (volt->func->oneinit) 264 return volt->func->oneinit(volt); 265 266 return 0; 267 } 268 269 static void * 270 nvkm_volt_dtor(struct nvkm_subdev *subdev) 271 { 272 return nvkm_volt(subdev); 273 } 274 275 static const struct nvkm_subdev_func 276 nvkm_volt = { 277 .dtor = nvkm_volt_dtor, 278 .init = nvkm_volt_init, 279 .oneinit = nvkm_volt_oneinit, 280 }; 281 282 void 283 nvkm_volt_ctor(const struct nvkm_volt_func *func, struct nvkm_device *device, 284 enum nvkm_subdev_type type, int inst, struct nvkm_volt *volt) 285 { 286 struct nvkm_bios *bios = device->bios; 287 int i; 288 289 nvkm_subdev_ctor(&nvkm_volt, device, type, inst, &volt->subdev); 290 volt->func = func; 291 292 /* Assuming the non-bios device should build the voltage table later */ 293 if (bios) { 294 u8 ver, hdr, cnt, len; 295 struct nvbios_vmap vmap; 296 297 nvkm_volt_parse_bios(bios, volt); 298 nvkm_debug(&volt->subdev, "min: %iuv max: %iuv\n", 299 volt->min_uv, volt->max_uv); 300 301 if (nvbios_vmap_parse(bios, &ver, &hdr, &cnt, &len, &vmap)) { 302 volt->max0_id = vmap.max0; 303 volt->max1_id = vmap.max1; 304 volt->max2_id = vmap.max2; 305 } else { 306 volt->max0_id = 0xff; 307 volt->max1_id = 0xff; 308 volt->max2_id = 0xff; 309 } 310 } 311 312 if (volt->vid_nr) { 313 for (i = 0; i < volt->vid_nr; i++) { 314 nvkm_debug(&volt->subdev, "VID %02x: %duv\n", 315 volt->vid[i].vid, volt->vid[i].uv); 316 } 317 } 318 } 319 320 int 321 nvkm_volt_new_(const struct nvkm_volt_func *func, struct nvkm_device *device, 322 enum nvkm_subdev_type type, int inst, struct nvkm_volt **pvolt) 323 { 324 if (!(*pvolt = kzalloc(sizeof(**pvolt), GFP_KERNEL))) 325 return -ENOMEM; 326 nvkm_volt_ctor(func, device, type, inst, *pvolt); 327 return 0; 328 } 329