base.c 14.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * Copyright 2013 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs
 */

#include <core/option.h>

27
#include <subdev/clk.h>
28 29 30 31 32 33 34 35 36 37 38 39 40
#include <subdev/therm.h>
#include <subdev/volt.h>
#include <subdev/fb.h>

#include <subdev/bios.h>
#include <subdev/bios/boost.h>
#include <subdev/bios/cstep.h>
#include <subdev/bios/perf.h>

/******************************************************************************
 * misc
 *****************************************************************************/
static u32
41
nouveau_clk_adjust(struct nouveau_clk *clk, bool adjust,
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
		     u8 pstate, u8 domain, u32 input)
{
	struct nouveau_bios *bios = nouveau_bios(clk);
	struct nvbios_boostE boostE;
	u8  ver, hdr, cnt, len;
	u16 data;

	data = nvbios_boostEm(bios, pstate, &ver, &hdr, &cnt, &len, &boostE);
	if (data) {
		struct nvbios_boostS boostS;
		u8  idx = 0, sver, shdr;
		u16 subd;

		input = max(boostE.min, input);
		input = min(boostE.max, input);
		do {
			sver = ver;
			shdr = hdr;
			subd = nvbios_boostSp(bios, idx++, data, &sver, &shdr,
					      cnt, len, &boostS);
			if (subd && boostS.domain == domain) {
				if (adjust)
					input = input * boostS.percent / 100;
				input = max(boostS.min, input);
				input = min(boostS.max, input);
				break;
			}
		} while (subd);
	}

	return input;
}

/******************************************************************************
 * C-States
 *****************************************************************************/
static int
79
nouveau_cstate_prog(struct nouveau_clk *clk,
80 81 82 83 84 85 86 87 88 89 90 91 92
		    struct nouveau_pstate *pstate, int cstatei)
{
	struct nouveau_therm *ptherm = nouveau_therm(clk);
	struct nouveau_volt *volt = nouveau_volt(clk);
	struct nouveau_cstate *cstate;
	int ret;

	if (!list_empty(&pstate->list)) {
		cstate = list_entry(pstate->list.prev, typeof(*cstate), head);
	} else {
		cstate = &pstate->base;
	}

93 94 95 96 97 98
	if (ptherm) {
		ret = nouveau_therm_cstate(ptherm, pstate->fanspeed, +1);
		if (ret && ret != -ENODEV) {
			nv_error(clk, "failed to raise fan speed: %d\n", ret);
			return ret;
		}
99 100
	}

101 102 103 104 105 106
	if (volt) {
		ret = volt->set_id(volt, cstate->voltage, +1);
		if (ret && ret != -ENODEV) {
			nv_error(clk, "failed to raise voltage: %d\n", ret);
			return ret;
		}
107 108 109 110 111 112 113 114
	}

	ret = clk->calc(clk, cstate);
	if (ret == 0) {
		ret = clk->prog(clk);
		clk->tidy(clk);
	}

115 116 117 118 119
	if (volt) {
		ret = volt->set_id(volt, cstate->voltage, -1);
		if (ret && ret != -ENODEV)
			nv_error(clk, "failed to lower voltage: %d\n", ret);
	}
120

121 122 123 124 125
	if (ptherm) {
		ret = nouveau_therm_cstate(ptherm, pstate->fanspeed, -1);
		if (ret && ret != -ENODEV)
			nv_error(clk, "failed to lower fan speed: %d\n", ret);
	}
126 127 128 129 130 131 132 133 134 135 136 137

	return 0;
}

static void
nouveau_cstate_del(struct nouveau_cstate *cstate)
{
	list_del(&cstate->head);
	kfree(cstate);
}

static int
138
nouveau_cstate_new(struct nouveau_clk *clk, int idx,
139 140 141
		   struct nouveau_pstate *pstate)
{
	struct nouveau_bios *bios = nouveau_bios(clk);
142
	struct nouveau_domain *domain = clk->domains;
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
	struct nouveau_cstate *cstate = NULL;
	struct nvbios_cstepX cstepX;
	u8  ver, hdr;
	u16 data;

	data = nvbios_cstepXp(bios, idx, &ver, &hdr, &cstepX);
	if (!data)
		return -ENOENT;

	cstate = kzalloc(sizeof(*cstate), GFP_KERNEL);
	if (!cstate)
		return -ENOMEM;

	*cstate = pstate->base;
	cstate->voltage = cstepX.voltage;

	while (domain && domain->name != nv_clk_src_max) {
		if (domain->flags & NVKM_CLK_DOM_FLAG_CORE) {
161
			u32 freq = nouveau_clk_adjust(clk, true,
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
							pstate->pstate,
							domain->bios,
							cstepX.freq);
			cstate->domain[domain->name] = freq;
		}
		domain++;
	}

	list_add(&cstate->head, &pstate->list);
	return 0;
}

/******************************************************************************
 * P-States
 *****************************************************************************/
static int
178
nouveau_pstate_prog(struct nouveau_clk *clk, int pstatei)
179 180 181 182 183 184 185 186 187 188 189 190 191 192
{
	struct nouveau_fb *pfb = nouveau_fb(clk);
	struct nouveau_pstate *pstate;
	int ret, idx = 0;

	list_for_each_entry(pstate, &clk->states, head) {
		if (idx++ == pstatei)
			break;
	}

	nv_debug(clk, "setting performance state %d\n", pstatei);
	clk->pstate = pstatei;

	if (pfb->ram->calc) {
193 194 195 196 197 198
		int khz = pstate->base.domain[nv_clk_src_mem];
		do {
			ret = pfb->ram->calc(pfb, khz);
			if (ret == 0)
				ret = pfb->ram->prog(pfb);
		} while (ret > 0);
199 200 201 202 203 204
		pfb->ram->tidy(pfb);
	}

	return nouveau_cstate_prog(clk, pstate, 0);
}

205 206
static void
nouveau_pstate_work(struct work_struct *work)
207
{
208
	struct nouveau_clk *clk = container_of(work, typeof(*clk), work);
209 210 211 212
	int pstate;

	if (!atomic_xchg(&clk->waiting, 0))
		return;
213
	clk->pwrsrc = power_supply_is_system_supplied();
214

215 216 217
	nv_trace(clk, "P %d PWR %d U(AC) %d U(DC) %d A %d T %d D %d\n",
		 clk->pstate, clk->pwrsrc, clk->ustate_ac, clk->ustate_dc,
		 clk->astate, clk->tstate, clk->dstate);
218

219 220 221
	pstate = clk->pwrsrc ? clk->ustate_ac : clk->ustate_dc;
	if (clk->state_nr && pstate != -1) {
		pstate = (pstate < 0) ? clk->astate : pstate;
222 223 224 225 226 227 228
		pstate = min(pstate, clk->state_nr - 1 - clk->tstate);
		pstate = max(pstate, clk->dstate);
	} else {
		pstate = clk->pstate = -1;
	}

	nv_trace(clk, "-> %d\n", pstate);
229 230 231 232 233 234 235 236 237
	if (pstate != clk->pstate) {
		int ret = nouveau_pstate_prog(clk, pstate);
		if (ret) {
			nv_error(clk, "error setting pstate %d: %d\n",
				 pstate, ret);
		}
	}

	wake_up_all(&clk->wait);
238
	nvkm_notify_get(&clk->pwrsrc_ntfy);
239 240 241
}

static int
242
nouveau_pstate_calc(struct nouveau_clk *clk, bool wait)
243 244 245 246 247 248
{
	atomic_set(&clk->waiting, 1);
	schedule_work(&clk->work);
	if (wait)
		wait_event(clk->wait, !atomic_read(&clk->waiting));
	return 0;
249 250 251
}

static void
252
nouveau_pstate_info(struct nouveau_clk *clk, struct nouveau_pstate *pstate)
253
{
254
	struct nouveau_domain *clock = clk->domains - 1;
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	struct nouveau_cstate *cstate;
	char info[3][32] = { "", "", "" };
	char name[4] = "--";
	int i = -1;

	if (pstate->pstate != 0xff)
		snprintf(name, sizeof(name), "%02x", pstate->pstate);

	while ((++clock)->name != nv_clk_src_max) {
		u32 lo = pstate->base.domain[clock->name];
		u32 hi = lo;
		if (hi == 0)
			continue;

		nv_debug(clk, "%02x: %10d KHz\n", clock->name, lo);
		list_for_each_entry(cstate, &pstate->list, head) {
			u32 freq = cstate->domain[clock->name];
			lo = min(lo, freq);
			hi = max(hi, freq);
			nv_debug(clk, "%10d KHz\n", freq);
		}

		if (clock->mname && ++i < ARRAY_SIZE(info)) {
			lo /= clock->mdiv;
			hi /= clock->mdiv;
			if (lo == hi) {
				snprintf(info[i], sizeof(info[i]), "%s %d MHz",
					 clock->mname, lo);
			} else {
				snprintf(info[i], sizeof(info[i]),
					 "%s %d-%d MHz", clock->mname, lo, hi);
			}
		}
	}

	nv_info(clk, "%s: %s %s %s\n", name, info[0], info[1], info[2]);
}

static void
nouveau_pstate_del(struct nouveau_pstate *pstate)
{
	struct nouveau_cstate *cstate, *temp;

	list_for_each_entry_safe(cstate, temp, &pstate->list, head) {
		nouveau_cstate_del(cstate);
	}

	list_del(&pstate->head);
	kfree(pstate);
}

static int
307
nouveau_pstate_new(struct nouveau_clk *clk, int idx)
308 309
{
	struct nouveau_bios *bios = nouveau_bios(clk);
310
	struct nouveau_domain *domain = clk->domains - 1;
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
	struct nouveau_pstate *pstate;
	struct nouveau_cstate *cstate;
	struct nvbios_cstepE cstepE;
	struct nvbios_perfE perfE;
	u8  ver, hdr, cnt, len;
	u16 data;

	data = nvbios_perfEp(bios, idx, &ver, &hdr, &cnt, &len, &perfE);
	if (!data)
		return -EINVAL;
	if (perfE.pstate == 0xff)
		return 0;

	pstate = kzalloc(sizeof(*pstate), GFP_KERNEL);
	cstate = &pstate->base;
	if (!pstate)
		return -ENOMEM;

	INIT_LIST_HEAD(&pstate->list);

	pstate->pstate = perfE.pstate;
	pstate->fanspeed = perfE.fanspeed;
	cstate->voltage = perfE.voltage;
	cstate->domain[nv_clk_src_core] = perfE.core;
	cstate->domain[nv_clk_src_shader] = perfE.shader;
	cstate->domain[nv_clk_src_mem] = perfE.memory;
	cstate->domain[nv_clk_src_vdec] = perfE.vdec;
	cstate->domain[nv_clk_src_dom6] = perfE.disp;

	while (ver >= 0x40 && (++domain)->name != nv_clk_src_max) {
		struct nvbios_perfS perfS;
		u8  sver = ver, shdr = hdr;
		u32 perfSe = nvbios_perfSp(bios, data, domain->bios,
					  &sver, &shdr, cnt, len, &perfS);
		if (perfSe == 0 || sver != 0x40)
			continue;

		if (domain->flags & NVKM_CLK_DOM_FLAG_CORE) {
349
			perfS.v40.freq = nouveau_clk_adjust(clk, false,
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
							      pstate->pstate,
							      domain->bios,
							      perfS.v40.freq);
		}

		cstate->domain[domain->name] = perfS.v40.freq;
	}

	data = nvbios_cstepEm(bios, pstate->pstate, &ver, &hdr, &cstepE);
	if (data) {
		int idx = cstepE.index;
		do {
			nouveau_cstate_new(clk, idx, pstate);
		} while(idx--);
	}

	nouveau_pstate_info(clk, pstate);
	list_add_tail(&pstate->head, &clk->states);
	clk->state_nr++;
	return 0;
}

/******************************************************************************
 * Adjustment triggers
 *****************************************************************************/
static int
376
nouveau_clk_ustate_update(struct nouveau_clk *clk, int req)
377 378 379 380
{
	struct nouveau_pstate *pstate;
	int i = 0;

381 382
	if (!clk->allow_reclock)
		return -ENOSYS;
383 384 385 386 387 388 389 390 391 392 393 394 395

	if (req != -1 && req != -2) {
		list_for_each_entry(pstate, &clk->states, head) {
			if (pstate->pstate == req)
				break;
			i++;
		}

		if (pstate->pstate != req)
			return -EINVAL;
		req = i;
	}

396 397 398 399
	return req + 2;
}

static int
400
nouveau_clk_nstate(struct nouveau_clk *clk, const char *mode, int arglen)
401 402 403
{
	int ret = 1;

404 405 406
	if (clk->allow_reclock && !strncasecmpz(mode, "auto", arglen))
		return -2;

407 408 409 410 411 412
	if (strncasecmpz(mode, "disabled", arglen)) {
		char save = mode[arglen];
		long v;

		((char *)mode)[arglen] = '\0';
		if (!kstrtol(mode, 0, &v)) {
413
			ret = nouveau_clk_ustate_update(clk, v);
414 415 416 417 418 419 420
			if (ret < 0)
				ret = 1;
		}
		((char *)mode)[arglen] = save;
	}

	return ret - 2;
421 422 423
}

int
424
nouveau_clk_ustate(struct nouveau_clk *clk, int req, int pwr)
425
{
426
	int ret = nouveau_clk_ustate_update(clk, req);
427 428 429 430 431 432
	if (ret >= 0) {
		if (ret -= 2, pwr) clk->ustate_ac = ret;
		else		   clk->ustate_dc = ret;
		return nouveau_pstate_calc(clk, true);
	}
	return ret;
433 434 435
}

int
436
nouveau_clk_astate(struct nouveau_clk *clk, int req, int rel, bool wait)
437 438 439 440 441
{
	if (!rel) clk->astate  = req;
	if ( rel) clk->astate += rel;
	clk->astate = min(clk->astate, clk->state_nr - 1);
	clk->astate = max(clk->astate, 0);
442
	return nouveau_pstate_calc(clk, wait);
443 444 445
}

int
446
nouveau_clk_tstate(struct nouveau_clk *clk, int req, int rel)
447 448 449 450 451
{
	if (!rel) clk->tstate  = req;
	if ( rel) clk->tstate += rel;
	clk->tstate = min(clk->tstate, 0);
	clk->tstate = max(clk->tstate, -(clk->state_nr - 1));
452
	return nouveau_pstate_calc(clk, true);
453 454 455
}

int
456
nouveau_clk_dstate(struct nouveau_clk *clk, int req, int rel)
457 458 459 460 461
{
	if (!rel) clk->dstate  = req;
	if ( rel) clk->dstate += rel;
	clk->dstate = min(clk->dstate, clk->state_nr - 1);
	clk->dstate = max(clk->dstate, 0);
462
	return nouveau_pstate_calc(clk, true);
463 464
}

465
static int
466
nouveau_clk_pwrsrc(struct nvkm_notify *notify)
467
{
468
	struct nouveau_clk *clk =
469
		container_of(notify, typeof(*clk), pwrsrc_ntfy);
470
	nouveau_pstate_calc(clk, false);
471
	return NVKM_NOTIFY_DROP;
472 473
}

474 475 476
/******************************************************************************
 * subdev base class implementation
 *****************************************************************************/
477 478

int
479
_nouveau_clk_fini(struct nouveau_object *object, bool suspend)
480
{
481
	struct nouveau_clk *clk = (void *)object;
482
	nvkm_notify_put(&clk->pwrsrc_ntfy);
483 484 485
	return nouveau_subdev_fini(&clk->base, suspend);
}

486
int
487
_nouveau_clk_init(struct nouveau_object *object)
488
{
489 490
	struct nouveau_clk *clk = (void *)object;
	struct nouveau_domain *clock = clk->domains;
491 492
	int ret;

493 494 495 496
	ret = nouveau_subdev_init(&clk->base);
	if (ret)
		return ret;

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
	memset(&clk->bstate, 0x00, sizeof(clk->bstate));
	INIT_LIST_HEAD(&clk->bstate.list);
	clk->bstate.pstate = 0xff;

	while (clock->name != nv_clk_src_max) {
		ret = clk->read(clk, clock->name);
		if (ret < 0) {
			nv_error(clk, "%02x freq unknown\n", clock->name);
			return ret;
		}
		clk->bstate.base.domain[clock->name] = ret;
		clock++;
	}

	nouveau_pstate_info(clk, &clk->bstate);

	clk->astate = clk->state_nr - 1;
	clk->tstate = 0;
	clk->dstate = 0;
	clk->pstate = -1;
517
	nouveau_pstate_calc(clk, true);
518 519 520 521
	return 0;
}

void
522
_nouveau_clk_dtor(struct nouveau_object *object)
523
{
524
	struct nouveau_clk *clk = (void *)object;
525 526
	struct nouveau_pstate *pstate, *temp;

527
	nvkm_notify_fini(&clk->pwrsrc_ntfy);
528

529 530 531 532 533 534 535 536
	list_for_each_entry_safe(pstate, temp, &clk->states, head) {
		nouveau_pstate_del(pstate);
	}

	nouveau_subdev_destroy(&clk->base);
}

int
537
nouveau_clk_create_(struct nouveau_object *parent,
538 539
		      struct nouveau_object *engine,
		      struct nouveau_oclass *oclass,
540
		      struct nouveau_domain *clocks,
541
		      struct nouveau_pstate *pstates, int nb_pstates,
542
		      bool allow_reclock,
543 544 545
		      int length, void **object)
{
	struct nouveau_device *device = nv_device(parent);
546
	struct nouveau_clk *clk;
547 548 549 550 551 552 553 554 555 556 557
	int ret, idx, arglen;
	const char *mode;

	ret = nouveau_subdev_create_(parent, engine, oclass, 0, "CLK",
				     "clock", length, object);
	clk = *object;
	if (ret)
		return ret;

	INIT_LIST_HEAD(&clk->states);
	clk->domains = clocks;
558 559
	clk->ustate_ac = -1;
	clk->ustate_dc = -1;
560

561 562 563 564
	INIT_WORK(&clk->work, nouveau_pstate_work);
	init_waitqueue_head(&clk->wait);
	atomic_set(&clk->waiting, 0);

565 566 567 568 569 570 571 572 573 574 575
	/* If no pstates are provided, try and fetch them from the BIOS */
	if (!pstates) {
		idx = 0;
		do {
			ret = nouveau_pstate_new(clk, idx++);
		} while (ret == 0);
	} else {
		for (idx = 0; idx < nb_pstates; idx++)
			list_add_tail(&pstates[idx].head, &clk->states);
		clk->state_nr = nb_pstates;
	}
576

577 578
	clk->allow_reclock = allow_reclock;

579
	ret = nvkm_notify_init(NULL, &device->event, nouveau_clk_pwrsrc, true,
580
			       NULL, 0, 0, &clk->pwrsrc_ntfy);
581 582 583
	if (ret)
		return ret;

584 585
	mode = nouveau_stropt(device->cfgopt, "NvClkMode", &arglen);
	if (mode) {
586 587
		clk->ustate_ac = nouveau_clk_nstate(clk, mode, arglen);
		clk->ustate_dc = nouveau_clk_nstate(clk, mode, arglen);
588 589
	}

590 591
	mode = nouveau_stropt(device->cfgopt, "NvClkModeAC", &arglen);
	if (mode)
592
		clk->ustate_ac = nouveau_clk_nstate(clk, mode, arglen);
593 594 595

	mode = nouveau_stropt(device->cfgopt, "NvClkModeDC", &arglen);
	if (mode)
596
		clk->ustate_dc = nouveau_clk_nstate(clk, mode, arglen);
597 598


599 600
	return 0;
}