1 /*
2  * Copyright 2012 The Nouveau community
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: Martin Peres
23  */
24 #include "priv.h"
25 
26 #include <core/option.h>
27 #include <subdev/pmu.h>
28 
29 int
30 nvkm_therm_temp_get(struct nvkm_therm *therm)
31 {
32 	if (therm->func->temp_get)
33 		return therm->func->temp_get(therm);
34 	return -ENODEV;
35 }
36 
37 static int
38 nvkm_therm_update_trip(struct nvkm_therm *therm)
39 {
40 	struct nvbios_therm_trip_point *trip = therm->fan->bios.trip,
41 				       *cur_trip = NULL,
42 				       *last_trip = therm->last_trip;
43 	u8  temp = therm->func->temp_get(therm);
44 	u16 duty, i;
45 
46 	/* look for the trip point corresponding to the current temperature */
47 	cur_trip = NULL;
48 	for (i = 0; i < therm->fan->bios.nr_fan_trip; i++) {
49 		if (temp >= trip[i].temp)
50 			cur_trip = &trip[i];
51 	}
52 
53 	/* account for the hysteresis cycle */
54 	if (last_trip && temp <= (last_trip->temp) &&
55 	    temp > (last_trip->temp - last_trip->hysteresis))
56 		cur_trip = last_trip;
57 
58 	if (cur_trip) {
59 		duty = cur_trip->fan_duty;
60 		therm->last_trip = cur_trip;
61 	} else {
62 		duty = 0;
63 		therm->last_trip = NULL;
64 	}
65 
66 	return duty;
67 }
68 
69 static int
70 nvkm_therm_compute_linear_duty(struct nvkm_therm *therm, u8 linear_min_temp,
71                                u8 linear_max_temp)
72 {
73 	u8  temp = therm->func->temp_get(therm);
74 	u16 duty;
75 
76 	/* handle the non-linear part first */
77 	if (temp < linear_min_temp)
78 		return therm->fan->bios.min_duty;
79 	else if (temp > linear_max_temp)
80 		return therm->fan->bios.max_duty;
81 
82 	/* we are in the linear zone */
83 	duty  = (temp - linear_min_temp);
84 	duty *= (therm->fan->bios.max_duty - therm->fan->bios.min_duty);
85 	duty /= (linear_max_temp - linear_min_temp);
86 	duty += therm->fan->bios.min_duty;
87 	return duty;
88 }
89 
90 static int
91 nvkm_therm_update_linear(struct nvkm_therm *therm)
92 {
93 	u8  min = therm->fan->bios.linear_min_temp;
94 	u8  max = therm->fan->bios.linear_max_temp;
95 	return nvkm_therm_compute_linear_duty(therm, min, max);
96 }
97 
98 static int
99 nvkm_therm_update_linear_fallback(struct nvkm_therm *therm)
100 {
101 	u8 max = therm->bios_sensor.thrs_fan_boost.temp;
102 	return nvkm_therm_compute_linear_duty(therm, 30, max);
103 }
104 
105 static void
106 nvkm_therm_update(struct nvkm_therm *therm, int mode)
107 {
108 	struct nvkm_subdev *subdev = &therm->subdev;
109 	struct nvkm_timer *tmr = subdev->device->timer;
110 	unsigned long flags;
111 	bool immd = true;
112 	bool poll = true;
113 	int duty = -1;
114 
115 	spin_lock_irqsave(&therm->lock, flags);
116 	if (mode < 0)
117 		mode = therm->mode;
118 	therm->mode = mode;
119 
120 	switch (mode) {
121 	case NVKM_THERM_CTRL_MANUAL:
122 		nvkm_timer_alarm(tmr, 0, &therm->alarm);
123 		duty = nvkm_therm_fan_get(therm);
124 		if (duty < 0)
125 			duty = 100;
126 		poll = false;
127 		break;
128 	case NVKM_THERM_CTRL_AUTO:
129 		switch(therm->fan->bios.fan_mode) {
130 		case NVBIOS_THERM_FAN_TRIP:
131 			duty = nvkm_therm_update_trip(therm);
132 			break;
133 		case NVBIOS_THERM_FAN_LINEAR:
134 			duty = nvkm_therm_update_linear(therm);
135 			break;
136 		case NVBIOS_THERM_FAN_OTHER:
137 			if (therm->cstate) {
138 				duty = therm->cstate;
139 				poll = false;
140 			} else {
141 				duty = nvkm_therm_update_linear_fallback(therm);
142 			}
143 			break;
144 		}
145 		immd = false;
146 		break;
147 	case NVKM_THERM_CTRL_NONE:
148 	default:
149 		nvkm_timer_alarm(tmr, 0, &therm->alarm);
150 		poll = false;
151 	}
152 
153 	if (poll)
154 		nvkm_timer_alarm(tmr, 1000000000ULL, &therm->alarm);
155 	spin_unlock_irqrestore(&therm->lock, flags);
156 
157 	if (duty >= 0) {
158 		nvkm_debug(subdev, "FAN target request: %d%%\n", duty);
159 		nvkm_therm_fan_set(therm, immd, duty);
160 	}
161 }
162 
163 int
164 nvkm_therm_cstate(struct nvkm_therm *therm, int fan, int dir)
165 {
166 	struct nvkm_subdev *subdev = &therm->subdev;
167 	if (!dir || (dir < 0 && fan < therm->cstate) ||
168 		    (dir > 0 && fan > therm->cstate)) {
169 		nvkm_debug(subdev, "default fan speed -> %d%%\n", fan);
170 		therm->cstate = fan;
171 		nvkm_therm_update(therm, -1);
172 	}
173 	return 0;
174 }
175 
176 static void
177 nvkm_therm_alarm(struct nvkm_alarm *alarm)
178 {
179 	struct nvkm_therm *therm =
180 	       container_of(alarm, struct nvkm_therm, alarm);
181 	nvkm_therm_update(therm, -1);
182 }
183 
184 int
185 nvkm_therm_fan_mode(struct nvkm_therm *therm, int mode)
186 {
187 	struct nvkm_subdev *subdev = &therm->subdev;
188 	struct nvkm_device *device = subdev->device;
189 	static const char *name[] = {
190 		"disabled",
191 		"manual",
192 		"automatic"
193 	};
194 
195 	/* The default PPWR ucode on fermi interferes with fan management */
196 	if ((mode >= ARRAY_SIZE(name)) ||
197 	    (mode != NVKM_THERM_CTRL_NONE && nvkm_pmu_fan_controlled(device)))
198 		return -EINVAL;
199 
200 	/* do not allow automatic fan management if the thermal sensor is
201 	 * not available */
202 	if (mode == NVKM_THERM_CTRL_AUTO &&
203 	    therm->func->temp_get(therm) < 0)
204 		return -EINVAL;
205 
206 	if (therm->mode == mode)
207 		return 0;
208 
209 	nvkm_debug(subdev, "fan management: %s\n", name[mode]);
210 	nvkm_therm_update(therm, mode);
211 	return 0;
212 }
213 
214 int
215 nvkm_therm_attr_get(struct nvkm_therm *therm, enum nvkm_therm_attr_type type)
216 {
217 	switch (type) {
218 	case NVKM_THERM_ATTR_FAN_MIN_DUTY:
219 		return therm->fan->bios.min_duty;
220 	case NVKM_THERM_ATTR_FAN_MAX_DUTY:
221 		return therm->fan->bios.max_duty;
222 	case NVKM_THERM_ATTR_FAN_MODE:
223 		return therm->mode;
224 	case NVKM_THERM_ATTR_THRS_FAN_BOOST:
225 		return therm->bios_sensor.thrs_fan_boost.temp;
226 	case NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST:
227 		return therm->bios_sensor.thrs_fan_boost.hysteresis;
228 	case NVKM_THERM_ATTR_THRS_DOWN_CLK:
229 		return therm->bios_sensor.thrs_down_clock.temp;
230 	case NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST:
231 		return therm->bios_sensor.thrs_down_clock.hysteresis;
232 	case NVKM_THERM_ATTR_THRS_CRITICAL:
233 		return therm->bios_sensor.thrs_critical.temp;
234 	case NVKM_THERM_ATTR_THRS_CRITICAL_HYST:
235 		return therm->bios_sensor.thrs_critical.hysteresis;
236 	case NVKM_THERM_ATTR_THRS_SHUTDOWN:
237 		return therm->bios_sensor.thrs_shutdown.temp;
238 	case NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST:
239 		return therm->bios_sensor.thrs_shutdown.hysteresis;
240 	}
241 
242 	return -EINVAL;
243 }
244 
245 int
246 nvkm_therm_attr_set(struct nvkm_therm *therm,
247 		    enum nvkm_therm_attr_type type, int value)
248 {
249 	switch (type) {
250 	case NVKM_THERM_ATTR_FAN_MIN_DUTY:
251 		if (value < 0)
252 			value = 0;
253 		if (value > therm->fan->bios.max_duty)
254 			value = therm->fan->bios.max_duty;
255 		therm->fan->bios.min_duty = value;
256 		return 0;
257 	case NVKM_THERM_ATTR_FAN_MAX_DUTY:
258 		if (value < 0)
259 			value = 0;
260 		if (value < therm->fan->bios.min_duty)
261 			value = therm->fan->bios.min_duty;
262 		therm->fan->bios.max_duty = value;
263 		return 0;
264 	case NVKM_THERM_ATTR_FAN_MODE:
265 		return nvkm_therm_fan_mode(therm, value);
266 	case NVKM_THERM_ATTR_THRS_FAN_BOOST:
267 		therm->bios_sensor.thrs_fan_boost.temp = value;
268 		therm->func->program_alarms(therm);
269 		return 0;
270 	case NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST:
271 		therm->bios_sensor.thrs_fan_boost.hysteresis = value;
272 		therm->func->program_alarms(therm);
273 		return 0;
274 	case NVKM_THERM_ATTR_THRS_DOWN_CLK:
275 		therm->bios_sensor.thrs_down_clock.temp = value;
276 		therm->func->program_alarms(therm);
277 		return 0;
278 	case NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST:
279 		therm->bios_sensor.thrs_down_clock.hysteresis = value;
280 		therm->func->program_alarms(therm);
281 		return 0;
282 	case NVKM_THERM_ATTR_THRS_CRITICAL:
283 		therm->bios_sensor.thrs_critical.temp = value;
284 		therm->func->program_alarms(therm);
285 		return 0;
286 	case NVKM_THERM_ATTR_THRS_CRITICAL_HYST:
287 		therm->bios_sensor.thrs_critical.hysteresis = value;
288 		therm->func->program_alarms(therm);
289 		return 0;
290 	case NVKM_THERM_ATTR_THRS_SHUTDOWN:
291 		therm->bios_sensor.thrs_shutdown.temp = value;
292 		therm->func->program_alarms(therm);
293 		return 0;
294 	case NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST:
295 		therm->bios_sensor.thrs_shutdown.hysteresis = value;
296 		therm->func->program_alarms(therm);
297 		return 0;
298 	}
299 
300 	return -EINVAL;
301 }
302 
303 void
304 nvkm_therm_clkgate_enable(struct nvkm_therm *therm)
305 {
306 	if (!therm || !therm->func->clkgate_enable || !therm->clkgating_enabled)
307 		return;
308 
309 	nvkm_debug(&therm->subdev,
310 		   "Enabling clockgating\n");
311 	therm->func->clkgate_enable(therm);
312 }
313 
314 void
315 nvkm_therm_clkgate_fini(struct nvkm_therm *therm, bool suspend)
316 {
317 	if (!therm || !therm->func->clkgate_fini || !therm->clkgating_enabled)
318 		return;
319 
320 	nvkm_debug(&therm->subdev,
321 		   "Preparing clockgating for %s\n",
322 		   suspend ? "suspend" : "fini");
323 	therm->func->clkgate_fini(therm, suspend);
324 }
325 
326 static void
327 nvkm_therm_clkgate_oneinit(struct nvkm_therm *therm)
328 {
329 	if (!therm->func->clkgate_enable || !therm->clkgating_enabled)
330 		return;
331 
332 	nvkm_info(&therm->subdev, "Clockgating enabled\n");
333 }
334 
335 static void
336 nvkm_therm_intr(struct nvkm_subdev *subdev)
337 {
338 	struct nvkm_therm *therm = nvkm_therm(subdev);
339 	if (therm->func->intr)
340 		therm->func->intr(therm);
341 }
342 
343 static int
344 nvkm_therm_fini(struct nvkm_subdev *subdev, bool suspend)
345 {
346 	struct nvkm_therm *therm = nvkm_therm(subdev);
347 
348 	if (therm->func->fini)
349 		therm->func->fini(therm);
350 
351 	nvkm_therm_fan_fini(therm, suspend);
352 	nvkm_therm_sensor_fini(therm, suspend);
353 
354 	if (suspend) {
355 		therm->suspend = therm->mode;
356 		therm->mode = NVKM_THERM_CTRL_NONE;
357 	}
358 
359 	return 0;
360 }
361 
362 static int
363 nvkm_therm_oneinit(struct nvkm_subdev *subdev)
364 {
365 	struct nvkm_therm *therm = nvkm_therm(subdev);
366 	nvkm_therm_sensor_ctor(therm);
367 	nvkm_therm_ic_ctor(therm);
368 	nvkm_therm_fan_ctor(therm);
369 	nvkm_therm_fan_mode(therm, NVKM_THERM_CTRL_AUTO);
370 	nvkm_therm_sensor_preinit(therm);
371 	nvkm_therm_clkgate_oneinit(therm);
372 	return 0;
373 }
374 
375 static int
376 nvkm_therm_init(struct nvkm_subdev *subdev)
377 {
378 	struct nvkm_therm *therm = nvkm_therm(subdev);
379 
380 	if (therm->func->init)
381 		therm->func->init(therm);
382 
383 	if (therm->suspend >= 0) {
384 		/* restore the pwm value only when on manual or auto mode */
385 		if (therm->suspend > 0)
386 			nvkm_therm_fan_set(therm, true, therm->fan->percent);
387 
388 		nvkm_therm_fan_mode(therm, therm->suspend);
389 	}
390 
391 	nvkm_therm_sensor_init(therm);
392 	nvkm_therm_fan_init(therm);
393 	return 0;
394 }
395 
396 void
397 nvkm_therm_clkgate_init(struct nvkm_therm *therm,
398 			const struct nvkm_therm_clkgate_pack *p)
399 {
400 	if (!therm || !therm->func->clkgate_init || !therm->clkgating_enabled)
401 		return;
402 
403 	therm->func->clkgate_init(therm, p);
404 }
405 
406 static void *
407 nvkm_therm_dtor(struct nvkm_subdev *subdev)
408 {
409 	struct nvkm_therm *therm = nvkm_therm(subdev);
410 	kfree(therm->fan);
411 	return therm;
412 }
413 
414 static const struct nvkm_subdev_func
415 nvkm_therm = {
416 	.dtor = nvkm_therm_dtor,
417 	.oneinit = nvkm_therm_oneinit,
418 	.init = nvkm_therm_init,
419 	.fini = nvkm_therm_fini,
420 	.intr = nvkm_therm_intr,
421 };
422 
423 void
424 nvkm_therm_ctor(struct nvkm_therm *therm, struct nvkm_device *device,
425 		int index, const struct nvkm_therm_func *func)
426 {
427 	nvkm_subdev_ctor(&nvkm_therm, device, index, &therm->subdev);
428 	therm->func = func;
429 
430 	nvkm_alarm_init(&therm->alarm, nvkm_therm_alarm);
431 	spin_lock_init(&therm->lock);
432 	spin_lock_init(&therm->sensor.alarm_program_lock);
433 
434 	therm->fan_get = nvkm_therm_fan_user_get;
435 	therm->fan_set = nvkm_therm_fan_user_set;
436 	therm->attr_get = nvkm_therm_attr_get;
437 	therm->attr_set = nvkm_therm_attr_set;
438 	therm->mode = therm->suspend = -1; /* undefined */
439 
440 	therm->clkgating_enabled = nvkm_boolopt(device->cfgopt,
441 						"NvPmEnableGating", false);
442 }
443 
444 int
445 nvkm_therm_new_(const struct nvkm_therm_func *func, struct nvkm_device *device,
446 		int index, struct nvkm_therm **ptherm)
447 {
448 	struct nvkm_therm *therm;
449 
450 	if (!(therm = *ptherm = kzalloc(sizeof(*therm), GFP_KERNEL)))
451 		return -ENOMEM;
452 
453 	nvkm_therm_ctor(therm, device, index, func);
454 	return 0;
455 }
456