1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * processor_throttling.c - Throttling submodule of the ACPI processor driver
   4 *
   5 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   6 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   7 *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
   8 *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
   9 *  			- Added processor hotplug support
  10 */
  11
  12#include <linux/kernel.h>
  13#include <linux/module.h>
  14#include <linux/slab.h>
  15#include <linux/init.h>
  16#include <linux/sched.h>
  17#include <linux/cpufreq.h>
  18#include <linux/acpi.h>
  19#include <acpi/processor.h>
  20#include <asm/io.h>
  21#include <linux/uaccess.h>
  22
  23#define PREFIX "ACPI: "
  24
  25#define ACPI_PROCESSOR_CLASS            "processor"
  26#define _COMPONENT              ACPI_PROCESSOR_COMPONENT
  27ACPI_MODULE_NAME("processor_throttling");
  28
  29/* ignore_tpc:
  30 *  0 -> acpi processor driver doesn't ignore _TPC values
  31 *  1 -> acpi processor driver ignores _TPC values
  32 */
  33static int ignore_tpc;
  34module_param(ignore_tpc, int, 0644);
  35MODULE_PARM_DESC(ignore_tpc, "Disable broken BIOS _TPC throttling support");
  36
  37struct throttling_tstate {
  38	unsigned int cpu;		/* cpu nr */
  39	int target_state;		/* target T-state */
  40};
  41
  42struct acpi_processor_throttling_arg {
  43	struct acpi_processor *pr;
  44	int target_state;
  45	bool force;
  46};
  47
  48#define THROTTLING_PRECHANGE       (1)
  49#define THROTTLING_POSTCHANGE      (2)
  50
  51static int acpi_processor_get_throttling(struct acpi_processor *pr);
  52static int __acpi_processor_set_throttling(struct acpi_processor *pr,
  53					   int state, bool force, bool direct);
  54
  55static int acpi_processor_update_tsd_coord(void)
  56{
  57	int count, count_target;
  58	int retval = 0;
  59	unsigned int i, j;
  60	cpumask_var_t covered_cpus;
  61	struct acpi_processor *pr, *match_pr;
  62	struct acpi_tsd_package *pdomain, *match_pdomain;
  63	struct acpi_processor_throttling *pthrottling, *match_pthrottling;
  64
  65	if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
  66		return -ENOMEM;
  67
  68	/*
  69	 * Now that we have _TSD data from all CPUs, lets setup T-state
  70	 * coordination between all CPUs.
  71	 */
  72	for_each_possible_cpu(i) {
  73		pr = per_cpu(processors, i);
  74		if (!pr)
  75			continue;
  76
  77		/* Basic validity check for domain info */
  78		pthrottling = &(pr->throttling);
  79
  80		/*
  81		 * If tsd package for one cpu is invalid, the coordination
  82		 * among all CPUs is thought as invalid.
  83		 * Maybe it is ugly.
  84		 */
  85		if (!pthrottling->tsd_valid_flag) {
  86			retval = -EINVAL;
  87			break;
  88		}
  89	}
  90	if (retval)
  91		goto err_ret;
  92
  93	for_each_possible_cpu(i) {
  94		pr = per_cpu(processors, i);
  95		if (!pr)
  96			continue;
  97
  98		if (cpumask_test_cpu(i, covered_cpus))
  99			continue;
 100		pthrottling = &pr->throttling;
 101
 102		pdomain = &(pthrottling->domain_info);
 103		cpumask_set_cpu(i, pthrottling->shared_cpu_map);
 104		cpumask_set_cpu(i, covered_cpus);
 105		/*
 106		 * If the number of processor in the TSD domain is 1, it is
 107		 * unnecessary to parse the coordination for this CPU.
 108		 */
 109		if (pdomain->num_processors <= 1)
 110			continue;
 111
 112		/* Validate the Domain info */
 113		count_target = pdomain->num_processors;
 114		count = 1;
 115
 116		for_each_possible_cpu(j) {
 117			if (i == j)
 118				continue;
 119
 120			match_pr = per_cpu(processors, j);
 121			if (!match_pr)
 122				continue;
 123
 124			match_pthrottling = &(match_pr->throttling);
 125			match_pdomain = &(match_pthrottling->domain_info);
 126			if (match_pdomain->domain != pdomain->domain)
 127				continue;
 128
 129			/* Here i and j are in the same domain.
 130			 * If two TSD packages have the same domain, they
 131			 * should have the same num_porcessors and
 132			 * coordination type. Otherwise it will be regarded
 133			 * as illegal.
 134			 */
 135			if (match_pdomain->num_processors != count_target) {
 136				retval = -EINVAL;
 137				goto err_ret;
 138			}
 139
 140			if (pdomain->coord_type != match_pdomain->coord_type) {
 141				retval = -EINVAL;
 142				goto err_ret;
 143			}
 144
 145			cpumask_set_cpu(j, covered_cpus);
 146			cpumask_set_cpu(j, pthrottling->shared_cpu_map);
 147			count++;
 148		}
 149		for_each_possible_cpu(j) {
 150			if (i == j)
 151				continue;
 152
 153			match_pr = per_cpu(processors, j);
 154			if (!match_pr)
 155				continue;
 156
 157			match_pthrottling = &(match_pr->throttling);
 158			match_pdomain = &(match_pthrottling->domain_info);
 159			if (match_pdomain->domain != pdomain->domain)
 160				continue;
 161
 162			/*
 163			 * If some CPUS have the same domain, they
 164			 * will have the same shared_cpu_map.
 165			 */
 166			cpumask_copy(match_pthrottling->shared_cpu_map,
 167				     pthrottling->shared_cpu_map);
 168		}
 169	}
 170
 171err_ret:
 172	free_cpumask_var(covered_cpus);
 173
 174	for_each_possible_cpu(i) {
 175		pr = per_cpu(processors, i);
 176		if (!pr)
 177			continue;
 178
 179		/*
 180		 * Assume no coordination on any error parsing domain info.
 181		 * The coordination type will be forced as SW_ALL.
 182		 */
 183		if (retval) {
 184			pthrottling = &(pr->throttling);
 185			cpumask_clear(pthrottling->shared_cpu_map);
 186			cpumask_set_cpu(i, pthrottling->shared_cpu_map);
 187			pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
 188		}
 189	}
 190
 191	return retval;
 192}
 193
 194/*
 195 * Update the T-state coordination after the _TSD
 196 * data for all cpus is obtained.
 197 */
 198void acpi_processor_throttling_init(void)
 199{
 200	if (acpi_processor_update_tsd_coord()) {
 201		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 202			"Assume no T-state coordination\n"));
 203	}
 204
 205	return;
 206}
 207
 208static int acpi_processor_throttling_notifier(unsigned long event, void *data)
 209{
 210	struct throttling_tstate *p_tstate = data;
 211	struct acpi_processor *pr;
 212	unsigned int cpu ;
 213	int target_state;
 214	struct acpi_processor_limit *p_limit;
 215	struct acpi_processor_throttling *p_throttling;
 216
 217	cpu = p_tstate->cpu;
 218	pr = per_cpu(processors, cpu);
 219	if (!pr) {
 220		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid pr pointer\n"));
 221		return 0;
 222	}
 223	if (!pr->flags.throttling) {
 224		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Throttling control is "
 225				"unsupported on CPU %d\n", cpu));
 226		return 0;
 227	}
 228	target_state = p_tstate->target_state;
 229	p_throttling = &(pr->throttling);
 230	switch (event) {
 231	case THROTTLING_PRECHANGE:
 232		/*
 233		 * Prechange event is used to choose one proper t-state,
 234		 * which meets the limits of thermal, user and _TPC.
 235		 */
 236		p_limit = &pr->limit;
 237		if (p_limit->thermal.tx > target_state)
 238			target_state = p_limit->thermal.tx;
 239		if (p_limit->user.tx > target_state)
 240			target_state = p_limit->user.tx;
 241		if (pr->throttling_platform_limit > target_state)
 242			target_state = pr->throttling_platform_limit;
 243		if (target_state >= p_throttling->state_count) {
 244			printk(KERN_WARNING
 245				"Exceed the limit of T-state \n");
 246			target_state = p_throttling->state_count - 1;
 247		}
 248		p_tstate->target_state = target_state;
 249		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PreChange Event:"
 250				"target T-state of CPU %d is T%d\n",
 251				cpu, target_state));
 252		break;
 253	case THROTTLING_POSTCHANGE:
 254		/*
 255		 * Postchange event is only used to update the
 256		 * T-state flag of acpi_processor_throttling.
 257		 */
 258		p_throttling->state = target_state;
 259		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PostChange Event:"
 260				"CPU %d is switched to T%d\n",
 261				cpu, target_state));
 262		break;
 263	default:
 264		printk(KERN_WARNING
 265			"Unsupported Throttling notifier event\n");
 266		break;
 267	}
 268
 269	return 0;
 270}
 271
 272/*
 273 * _TPC - Throttling Present Capabilities
 274 */
 275static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
 276{
 277	acpi_status status = 0;
 278	unsigned long long tpc = 0;
 279
 280	if (!pr)
 281		return -EINVAL;
 282
 283	if (ignore_tpc)
 284		goto end;
 285
 286	status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
 287	if (ACPI_FAILURE(status)) {
 288		if (status != AE_NOT_FOUND) {
 289			ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
 290		}
 291		return -ENODEV;
 292	}
 293
 294end:
 295	pr->throttling_platform_limit = (int)tpc;
 296	return 0;
 297}
 298
 299int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
 300{
 301	int result = 0;
 302	int throttling_limit;
 303	int current_state;
 304	struct acpi_processor_limit *limit;
 305	int target_state;
 306
 307	if (ignore_tpc)
 308		return 0;
 309
 310	result = acpi_processor_get_platform_limit(pr);
 311	if (result) {
 312		/* Throttling Limit is unsupported */
 313		return result;
 314	}
 315
 316	throttling_limit = pr->throttling_platform_limit;
 317	if (throttling_limit >= pr->throttling.state_count) {
 318		/* Uncorrect Throttling Limit */
 319		return -EINVAL;
 320	}
 321
 322	current_state = pr->throttling.state;
 323	if (current_state > throttling_limit) {
 324		/*
 325		 * The current state can meet the requirement of
 326		 * _TPC limit. But it is reasonable that OSPM changes
 327		 * t-states from high to low for better performance.
 328		 * Of course the limit condition of thermal
 329		 * and user should be considered.
 330		 */
 331		limit = &pr->limit;
 332		target_state = throttling_limit;
 333		if (limit->thermal.tx > target_state)
 334			target_state = limit->thermal.tx;
 335		if (limit->user.tx > target_state)
 336			target_state = limit->user.tx;
 337	} else if (current_state == throttling_limit) {
 338		/*
 339		 * Unnecessary to change the throttling state
 340		 */
 341		return 0;
 342	} else {
 343		/*
 344		 * If the current state is lower than the limit of _TPC, it
 345		 * will be forced to switch to the throttling state defined
 346		 * by throttling_platfor_limit.
 347		 * Because the previous state meets with the limit condition
 348		 * of thermal and user, it is unnecessary to check it again.
 349		 */
 350		target_state = throttling_limit;
 351	}
 352	return acpi_processor_set_throttling(pr, target_state, false);
 353}
 354
 355/*
 356 * This function is used to reevaluate whether the T-state is valid
 357 * after one CPU is onlined/offlined.
 358 * It is noted that it won't reevaluate the following properties for
 359 * the T-state.
 360 *	1. Control method.
 361 *	2. the number of supported T-state
 362 *	3. TSD domain
 363 */
 364void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
 365					bool is_dead)
 366{
 367	int result = 0;
 368
 369	if (is_dead) {
 370		/* When one CPU is offline, the T-state throttling
 371		 * will be invalidated.
 372		 */
 373		pr->flags.throttling = 0;
 374		return;
 375	}
 376	/* the following is to recheck whether the T-state is valid for
 377	 * the online CPU
 378	 */
 379	if (!pr->throttling.state_count) {
 380		/* If the number of T-state is invalid, it is
 381		 * invalidated.
 382		 */
 383		pr->flags.throttling = 0;
 384		return;
 385	}
 386	pr->flags.throttling = 1;
 387
 388	/* Disable throttling (if enabled).  We'll let subsequent
 389	 * policy (e.g.thermal) decide to lower performance if it
 390	 * so chooses, but for now we'll crank up the speed.
 391	 */
 392
 393	result = acpi_processor_get_throttling(pr);
 394	if (result)
 395		goto end;
 396
 397	if (pr->throttling.state) {
 398		result = acpi_processor_set_throttling(pr, 0, false);
 399		if (result)
 400			goto end;
 401	}
 402
 403end:
 404	if (result)
 405		pr->flags.throttling = 0;
 406}
 407/*
 408 * _PTC - Processor Throttling Control (and status) register location
 409 */
 410static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
 411{
 412	int result = 0;
 413	acpi_status status = 0;
 414	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 415	union acpi_object *ptc = NULL;
 416	union acpi_object obj = { 0 };
 417	struct acpi_processor_throttling *throttling;
 418
 419	status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
 420	if (ACPI_FAILURE(status)) {
 421		if (status != AE_NOT_FOUND) {
 422			ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
 423		}
 424		return -ENODEV;
 425	}
 426
 427	ptc = (union acpi_object *)buffer.pointer;
 428	if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE)
 429	    || (ptc->package.count != 2)) {
 430		printk(KERN_ERR PREFIX "Invalid _PTC data\n");
 431		result = -EFAULT;
 432		goto end;
 433	}
 434
 435	/*
 436	 * control_register
 437	 */
 438
 439	obj = ptc->package.elements[0];
 440
 441	if ((obj.type != ACPI_TYPE_BUFFER)
 442	    || (obj.buffer.length < sizeof(struct acpi_ptc_register))
 443	    || (obj.buffer.pointer == NULL)) {
 444		printk(KERN_ERR PREFIX
 445		       "Invalid _PTC data (control_register)\n");
 446		result = -EFAULT;
 447		goto end;
 448	}
 449	memcpy(&pr->throttling.control_register, obj.buffer.pointer,
 450	       sizeof(struct acpi_ptc_register));
 451
 452	/*
 453	 * status_register
 454	 */
 455
 456	obj = ptc->package.elements[1];
 457
 458	if ((obj.type != ACPI_TYPE_BUFFER)
 459	    || (obj.buffer.length < sizeof(struct acpi_ptc_register))
 460	    || (obj.buffer.pointer == NULL)) {
 461		printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n");
 462		result = -EFAULT;
 463		goto end;
 464	}
 465
 466	memcpy(&pr->throttling.status_register, obj.buffer.pointer,
 467	       sizeof(struct acpi_ptc_register));
 468
 469	throttling = &pr->throttling;
 470
 471	if ((throttling->control_register.bit_width +
 472		throttling->control_register.bit_offset) > 32) {
 473		printk(KERN_ERR PREFIX "Invalid _PTC control register\n");
 474		result = -EFAULT;
 475		goto end;
 476	}
 477
 478	if ((throttling->status_register.bit_width +
 479		throttling->status_register.bit_offset) > 32) {
 480		printk(KERN_ERR PREFIX "Invalid _PTC status register\n");
 481		result = -EFAULT;
 482		goto end;
 483	}
 484
 485      end:
 486	kfree(buffer.pointer);
 487
 488	return result;
 489}
 490
 491/*
 492 * _TSS - Throttling Supported States
 493 */
 494static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
 495{
 496	int result = 0;
 497	acpi_status status = AE_OK;
 498	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 499	struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
 500	struct acpi_buffer state = { 0, NULL };
 501	union acpi_object *tss = NULL;
 502	int i;
 503
 504	status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
 505	if (ACPI_FAILURE(status)) {
 506		if (status != AE_NOT_FOUND) {
 507			ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
 508		}
 509		return -ENODEV;
 510	}
 511
 512	tss = buffer.pointer;
 513	if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
 514		printk(KERN_ERR PREFIX "Invalid _TSS data\n");
 515		result = -EFAULT;
 516		goto end;
 517	}
 518
 519	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
 520			  tss->package.count));
 521
 522	pr->throttling.state_count = tss->package.count;
 523	pr->throttling.states_tss =
 524	    kmalloc_array(tss->package.count,
 525			  sizeof(struct acpi_processor_tx_tss),
 526			  GFP_KERNEL);
 527	if (!pr->throttling.states_tss) {
 528		result = -ENOMEM;
 529		goto end;
 530	}
 531
 532	for (i = 0; i < pr->throttling.state_count; i++) {
 533
 534		struct acpi_processor_tx_tss *tx =
 535		    (struct acpi_processor_tx_tss *)&(pr->throttling.
 536						      states_tss[i]);
 537
 538		state.length = sizeof(struct acpi_processor_tx_tss);
 539		state.pointer = tx;
 540
 541		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
 542
 543		status = acpi_extract_package(&(tss->package.elements[i]),
 544					      &format, &state);
 545		if (ACPI_FAILURE(status)) {
 546			ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data"));
 547			result = -EFAULT;
 548			kfree(pr->throttling.states_tss);
 549			goto end;
 550		}
 551
 552		if (!tx->freqpercentage) {
 553			printk(KERN_ERR PREFIX
 554			       "Invalid _TSS data: freq is zero\n");
 555			result = -EFAULT;
 556			kfree(pr->throttling.states_tss);
 557			goto end;
 558		}
 559	}
 560
 561      end:
 562	kfree(buffer.pointer);
 563
 564	return result;
 565}
 566
 567/*
 568 * _TSD - T-State Dependencies
 569 */
 570static int acpi_processor_get_tsd(struct acpi_processor *pr)
 571{
 572	int result = 0;
 573	acpi_status status = AE_OK;
 574	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 575	struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
 576	struct acpi_buffer state = { 0, NULL };
 577	union acpi_object *tsd = NULL;
 578	struct acpi_tsd_package *pdomain;
 579	struct acpi_processor_throttling *pthrottling;
 580
 581	pthrottling = &pr->throttling;
 582	pthrottling->tsd_valid_flag = 0;
 583
 584	status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
 585	if (ACPI_FAILURE(status)) {
 586		if (status != AE_NOT_FOUND) {
 587			ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD"));
 588		}
 589		return -ENODEV;
 590	}
 591
 592	tsd = buffer.pointer;
 593	if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
 594		printk(KERN_ERR PREFIX "Invalid _TSD data\n");
 595		result = -EFAULT;
 596		goto end;
 597	}
 598
 599	if (tsd->package.count != 1) {
 600		printk(KERN_ERR PREFIX "Invalid _TSD data\n");
 601		result = -EFAULT;
 602		goto end;
 603	}
 604
 605	pdomain = &(pr->throttling.domain_info);
 606
 607	state.length = sizeof(struct acpi_tsd_package);
 608	state.pointer = pdomain;
 609
 610	status = acpi_extract_package(&(tsd->package.elements[0]),
 611				      &format, &state);
 612	if (ACPI_FAILURE(status)) {
 613		printk(KERN_ERR PREFIX "Invalid _TSD data\n");
 614		result = -EFAULT;
 615		goto end;
 616	}
 617
 618	if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
 619		printk(KERN_ERR PREFIX "Unknown _TSD:num_entries\n");
 620		result = -EFAULT;
 621		goto end;
 622	}
 623
 624	if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
 625		printk(KERN_ERR PREFIX "Unknown _TSD:revision\n");
 626		result = -EFAULT;
 627		goto end;
 628	}
 629
 630	pthrottling = &pr->throttling;
 631	pthrottling->tsd_valid_flag = 1;
 632	pthrottling->shared_type = pdomain->coord_type;
 633	cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
 634	/*
 635	 * If the coordination type is not defined in ACPI spec,
 636	 * the tsd_valid_flag will be clear and coordination type
 637	 * will be forecd as DOMAIN_COORD_TYPE_SW_ALL.
 638	 */
 639	if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
 640		pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
 641		pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
 642		pthrottling->tsd_valid_flag = 0;
 643		pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
 644	}
 645
 646      end:
 647	kfree(buffer.pointer);
 648	return result;
 649}
 650
 651/* --------------------------------------------------------------------------
 652                              Throttling Control
 653   -------------------------------------------------------------------------- */
 654static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
 655{
 656	int state = 0;
 657	u32 value = 0;
 658	u32 duty_mask = 0;
 659	u32 duty_value = 0;
 660
 661	if (!pr)
 662		return -EINVAL;
 663
 664	if (!pr->flags.throttling)
 665		return -ENODEV;
 666
 667	/*
 668	 * We don't care about error returns - we just try to mark
 669	 * these reserved so that nobody else is confused into thinking
 670	 * that this region might be unused..
 671	 *
 672	 * (In particular, allocating the IO range for Cardbus)
 673	 */
 674	request_region(pr->throttling.address, 6, "ACPI CPU throttle");
 675
 676	pr->throttling.state = 0;
 677
 678	duty_mask = pr->throttling.state_count - 1;
 679
 680	duty_mask <<= pr->throttling.duty_offset;
 681
 682	local_irq_disable();
 683
 684	value = inl(pr->throttling.address);
 685
 686	/*
 687	 * Compute the current throttling state when throttling is enabled
 688	 * (bit 4 is on).
 689	 */
 690	if (value & 0x10) {
 691		duty_value = value & duty_mask;
 692		duty_value >>= pr->throttling.duty_offset;
 693
 694		if (duty_value)
 695			state = pr->throttling.state_count - duty_value;
 696	}
 697
 698	pr->throttling.state = state;
 699
 700	local_irq_enable();
 701
 702	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 703			  "Throttling state is T%d (%d%% throttling applied)\n",
 704			  state, pr->throttling.states[state].performance));
 705
 706	return 0;
 707}
 708
 709#ifdef CONFIG_X86
 710static int acpi_throttling_rdmsr(u64 *value)
 711{
 712	u64 msr_high, msr_low;
 713	u64 msr = 0;
 714	int ret = -1;
 715
 716	if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
 717		!this_cpu_has(X86_FEATURE_ACPI)) {
 718		printk(KERN_ERR PREFIX
 719			"HARDWARE addr space,NOT supported yet\n");
 720	} else {
 721		msr_low = 0;
 722		msr_high = 0;
 723		rdmsr_safe(MSR_IA32_THERM_CONTROL,
 724			(u32 *)&msr_low , (u32 *) &msr_high);
 725		msr = (msr_high << 32) | msr_low;
 726		*value = (u64) msr;
 727		ret = 0;
 728	}
 729	return ret;
 730}
 731
 732static int acpi_throttling_wrmsr(u64 value)
 733{
 734	int ret = -1;
 735	u64 msr;
 736
 737	if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
 738		!this_cpu_has(X86_FEATURE_ACPI)) {
 739		printk(KERN_ERR PREFIX
 740			"HARDWARE addr space,NOT supported yet\n");
 741	} else {
 742		msr = value;
 743		wrmsr_safe(MSR_IA32_THERM_CONTROL,
 744			msr & 0xffffffff, msr >> 32);
 745		ret = 0;
 746	}
 747	return ret;
 748}
 749#else
 750static int acpi_throttling_rdmsr(u64 *value)
 751{
 752	printk(KERN_ERR PREFIX
 753		"HARDWARE addr space,NOT supported yet\n");
 754	return -1;
 755}
 756
 757static int acpi_throttling_wrmsr(u64 value)
 758{
 759	printk(KERN_ERR PREFIX
 760		"HARDWARE addr space,NOT supported yet\n");
 761	return -1;
 762}
 763#endif
 764
 765static int acpi_read_throttling_status(struct acpi_processor *pr,
 766					u64 *value)
 767{
 768	u32 bit_width, bit_offset;
 769	u32 ptc_value;
 770	u64 ptc_mask;
 771	struct acpi_processor_throttling *throttling;
 772	int ret = -1;
 773
 774	throttling = &pr->throttling;
 775	switch (throttling->status_register.space_id) {
 776	case ACPI_ADR_SPACE_SYSTEM_IO:
 777		bit_width = throttling->status_register.bit_width;
 778		bit_offset = throttling->status_register.bit_offset;
 779
 780		acpi_os_read_port((acpi_io_address) throttling->status_register.
 781				  address, &ptc_value,
 782				  (u32) (bit_width + bit_offset));
 783		ptc_mask = (1 << bit_width) - 1;
 784		*value = (u64) ((ptc_value >> bit_offset) & ptc_mask);
 785		ret = 0;
 786		break;
 787	case ACPI_ADR_SPACE_FIXED_HARDWARE:
 788		ret = acpi_throttling_rdmsr(value);
 789		break;
 790	default:
 791		printk(KERN_ERR PREFIX "Unknown addr space %d\n",
 792		       (u32) (throttling->status_register.space_id));
 793	}
 794	return ret;
 795}
 796
 797static int acpi_write_throttling_state(struct acpi_processor *pr,
 798				u64 value)
 799{
 800	u32 bit_width, bit_offset;
 801	u64 ptc_value;
 802	u64 ptc_mask;
 803	struct acpi_processor_throttling *throttling;
 804	int ret = -1;
 805
 806	throttling = &pr->throttling;
 807	switch (throttling->control_register.space_id) {
 808	case ACPI_ADR_SPACE_SYSTEM_IO:
 809		bit_width = throttling->control_register.bit_width;
 810		bit_offset = throttling->control_register.bit_offset;
 811		ptc_mask = (1 << bit_width) - 1;
 812		ptc_value = value & ptc_mask;
 813
 814		acpi_os_write_port((acpi_io_address) throttling->
 815					control_register.address,
 816					(u32) (ptc_value << bit_offset),
 817					(u32) (bit_width + bit_offset));
 818		ret = 0;
 819		break;
 820	case ACPI_ADR_SPACE_FIXED_HARDWARE:
 821		ret = acpi_throttling_wrmsr(value);
 822		break;
 823	default:
 824		printk(KERN_ERR PREFIX "Unknown addr space %d\n",
 825		       (u32) (throttling->control_register.space_id));
 826	}
 827	return ret;
 828}
 829
 830static int acpi_get_throttling_state(struct acpi_processor *pr,
 831				u64 value)
 832{
 833	int i;
 834
 835	for (i = 0; i < pr->throttling.state_count; i++) {
 836		struct acpi_processor_tx_tss *tx =
 837		    (struct acpi_processor_tx_tss *)&(pr->throttling.
 838						      states_tss[i]);
 839		if (tx->control == value)
 840			return i;
 841	}
 842	return -1;
 843}
 844
 845static int acpi_get_throttling_value(struct acpi_processor *pr,
 846			int state, u64 *value)
 847{
 848	int ret = -1;
 849
 850	if (state >= 0 && state <= pr->throttling.state_count) {
 851		struct acpi_processor_tx_tss *tx =
 852		    (struct acpi_processor_tx_tss *)&(pr->throttling.
 853						      states_tss[state]);
 854		*value = tx->control;
 855		ret = 0;
 856	}
 857	return ret;
 858}
 859
 860static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
 861{
 862	int state = 0;
 863	int ret;
 864	u64 value;
 865
 866	if (!pr)
 867		return -EINVAL;
 868
 869	if (!pr->flags.throttling)
 870		return -ENODEV;
 871
 872	pr->throttling.state = 0;
 873
 874	value = 0;
 875	ret = acpi_read_throttling_status(pr, &value);
 876	if (ret >= 0) {
 877		state = acpi_get_throttling_state(pr, value);
 878		if (state == -1) {
 879			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 880				"Invalid throttling state, reset\n"));
 881			state = 0;
 882			ret = __acpi_processor_set_throttling(pr, state, true,
 883							      true);
 884			if (ret)
 885				return ret;
 886		}
 887		pr->throttling.state = state;
 888	}
 889
 890	return 0;
 891}
 892
 893static long __acpi_processor_get_throttling(void *data)
 894{
 895	struct acpi_processor *pr = data;
 896
 897	return pr->throttling.acpi_processor_get_throttling(pr);
 898}
 899
 
 
 
 
 
 
 
 900static int acpi_processor_get_throttling(struct acpi_processor *pr)
 901{
 902	if (!pr)
 903		return -EINVAL;
 904
 905	if (!pr->flags.throttling)
 906		return -ENODEV;
 907
 908	/*
 909	 * This is either called from the CPU hotplug callback of
 910	 * processor_driver or via the ACPI probe function. In the latter
 911	 * case the CPU is not guaranteed to be online. Both call sites are
 912	 * protected against CPU hotplug.
 913	 */
 914	if (!cpu_online(pr->id))
 915		return -ENODEV;
 916
 917	return call_on_cpu(pr->id, __acpi_processor_get_throttling, pr, false);
 918}
 919
 920static int acpi_processor_get_fadt_info(struct acpi_processor *pr)
 921{
 922	int i, step;
 923
 924	if (!pr->throttling.address) {
 925		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
 926		return -EINVAL;
 927	} else if (!pr->throttling.duty_width) {
 928		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
 929		return -EINVAL;
 930	}
 931	/* TBD: Support duty_cycle values that span bit 4. */
 932	else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
 933		printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
 934		return -EINVAL;
 935	}
 936
 937	pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
 938
 939	/*
 940	 * Compute state values. Note that throttling displays a linear power
 941	 * performance relationship (at 50% performance the CPU will consume
 942	 * 50% power).  Values are in 1/10th of a percent to preserve accuracy.
 943	 */
 944
 945	step = (1000 / pr->throttling.state_count);
 946
 947	for (i = 0; i < pr->throttling.state_count; i++) {
 948		pr->throttling.states[i].performance = 1000 - step * i;
 949		pr->throttling.states[i].power = 1000 - step * i;
 950	}
 951	return 0;
 952}
 953
 954static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
 955					      int state, bool force)
 956{
 957	u32 value = 0;
 958	u32 duty_mask = 0;
 959	u32 duty_value = 0;
 960
 961	if (!pr)
 962		return -EINVAL;
 963
 964	if ((state < 0) || (state > (pr->throttling.state_count - 1)))
 965		return -EINVAL;
 966
 967	if (!pr->flags.throttling)
 968		return -ENODEV;
 969
 970	if (!force && (state == pr->throttling.state))
 971		return 0;
 972
 973	if (state < pr->throttling_platform_limit)
 974		return -EPERM;
 975	/*
 976	 * Calculate the duty_value and duty_mask.
 977	 */
 978	if (state) {
 979		duty_value = pr->throttling.state_count - state;
 980
 981		duty_value <<= pr->throttling.duty_offset;
 982
 983		/* Used to clear all duty_value bits */
 984		duty_mask = pr->throttling.state_count - 1;
 985
 986		duty_mask <<= acpi_gbl_FADT.duty_offset;
 987		duty_mask = ~duty_mask;
 988	}
 989
 990	local_irq_disable();
 991
 992	/*
 993	 * Disable throttling by writing a 0 to bit 4.  Note that we must
 994	 * turn it off before you can change the duty_value.
 995	 */
 996	value = inl(pr->throttling.address);
 997	if (value & 0x10) {
 998		value &= 0xFFFFFFEF;
 999		outl(value, pr->throttling.address);
1000	}
1001
1002	/*
1003	 * Write the new duty_value and then enable throttling.  Note
1004	 * that a state value of 0 leaves throttling disabled.
1005	 */
1006	if (state) {
1007		value &= duty_mask;
1008		value |= duty_value;
1009		outl(value, pr->throttling.address);
1010
1011		value |= 0x00000010;
1012		outl(value, pr->throttling.address);
1013	}
1014
1015	pr->throttling.state = state;
1016
1017	local_irq_enable();
1018
1019	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1020			  "Throttling state set to T%d (%d%%)\n", state,
1021			  (pr->throttling.states[state].performance ? pr->
1022			   throttling.states[state].performance / 10 : 0)));
1023
1024	return 0;
1025}
1026
1027static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
1028					     int state, bool force)
1029{
1030	int ret;
1031	u64 value;
1032
1033	if (!pr)
1034		return -EINVAL;
1035
1036	if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1037		return -EINVAL;
1038
1039	if (!pr->flags.throttling)
1040		return -ENODEV;
1041
1042	if (!force && (state == pr->throttling.state))
1043		return 0;
1044
1045	if (state < pr->throttling_platform_limit)
1046		return -EPERM;
1047
1048	value = 0;
1049	ret = acpi_get_throttling_value(pr, state, &value);
1050	if (ret >= 0) {
1051		acpi_write_throttling_state(pr, value);
1052		pr->throttling.state = state;
1053	}
1054
1055	return 0;
1056}
1057
1058static long acpi_processor_throttling_fn(void *data)
1059{
1060	struct acpi_processor_throttling_arg *arg = data;
1061	struct acpi_processor *pr = arg->pr;
1062
1063	return pr->throttling.acpi_processor_set_throttling(pr,
1064			arg->target_state, arg->force);
1065}
1066
1067static int __acpi_processor_set_throttling(struct acpi_processor *pr,
1068					   int state, bool force, bool direct)
1069{
1070	int ret = 0;
1071	unsigned int i;
1072	struct acpi_processor *match_pr;
1073	struct acpi_processor_throttling *p_throttling;
1074	struct acpi_processor_throttling_arg arg;
1075	struct throttling_tstate t_state;
1076
1077	if (!pr)
1078		return -EINVAL;
1079
1080	if (!pr->flags.throttling)
1081		return -ENODEV;
1082
1083	if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1084		return -EINVAL;
1085
1086	if (cpu_is_offline(pr->id)) {
1087		/*
1088		 * the cpu pointed by pr->id is offline. Unnecessary to change
1089		 * the throttling state any more.
1090		 */
1091		return -ENODEV;
1092	}
1093
1094	t_state.target_state = state;
1095	p_throttling = &(pr->throttling);
1096
1097	/*
1098	 * The throttling notifier will be called for every
1099	 * affected cpu in order to get one proper T-state.
1100	 * The notifier event is THROTTLING_PRECHANGE.
1101	 */
1102	for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1103		t_state.cpu = i;
1104		acpi_processor_throttling_notifier(THROTTLING_PRECHANGE,
1105							&t_state);
1106	}
1107	/*
1108	 * The function of acpi_processor_set_throttling will be called
1109	 * to switch T-state. If the coordination type is SW_ALL or HW_ALL,
1110	 * it is necessary to call it for every affected cpu. Otherwise
1111	 * it can be called only for the cpu pointed by pr.
1112	 */
1113	if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
1114		arg.pr = pr;
1115		arg.target_state = state;
1116		arg.force = force;
1117		ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, &arg,
1118				  direct);
1119	} else {
1120		/*
1121		 * When the T-state coordination is SW_ALL or HW_ALL,
1122		 * it is necessary to set T-state for every affected
1123		 * cpus.
1124		 */
1125		for_each_cpu_and(i, cpu_online_mask,
1126		    p_throttling->shared_cpu_map) {
1127			match_pr = per_cpu(processors, i);
1128			/*
1129			 * If the pointer is invalid, we will report the
1130			 * error message and continue.
1131			 */
1132			if (!match_pr) {
1133				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1134					"Invalid Pointer for CPU %d\n", i));
1135				continue;
1136			}
1137			/*
1138			 * If the throttling control is unsupported on CPU i,
1139			 * we will report the error message and continue.
1140			 */
1141			if (!match_pr->flags.throttling) {
1142				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1143					"Throttling Control is unsupported "
1144					"on CPU %d\n", i));
1145				continue;
1146			}
1147
1148			arg.pr = match_pr;
1149			arg.target_state = state;
1150			arg.force = force;
1151			ret = call_on_cpu(pr->id, acpi_processor_throttling_fn,
1152					  &arg, direct);
1153		}
1154	}
1155	/*
1156	 * After the set_throttling is called, the
1157	 * throttling notifier is called for every
1158	 * affected cpu to update the T-states.
1159	 * The notifier event is THROTTLING_POSTCHANGE
1160	 */
1161	for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1162		t_state.cpu = i;
1163		acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE,
1164							&t_state);
1165	}
1166
1167	return ret;
1168}
1169
1170int acpi_processor_set_throttling(struct acpi_processor *pr, int state,
1171				  bool force)
1172{
1173	return __acpi_processor_set_throttling(pr, state, force, false);
1174}
1175
1176int acpi_processor_get_throttling_info(struct acpi_processor *pr)
1177{
1178	int result = 0;
1179	struct acpi_processor_throttling *pthrottling;
1180
1181	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1182			  "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
1183			  pr->throttling.address,
1184			  pr->throttling.duty_offset,
1185			  pr->throttling.duty_width));
1186
1187	/*
1188	 * Evaluate _PTC, _TSS and _TPC
1189	 * They must all be present or none of them can be used.
1190	 */
1191	if (acpi_processor_get_throttling_control(pr) ||
1192		acpi_processor_get_throttling_states(pr) ||
1193		acpi_processor_get_platform_limit(pr))
1194	{
1195		pr->throttling.acpi_processor_get_throttling =
1196		    &acpi_processor_get_throttling_fadt;
1197		pr->throttling.acpi_processor_set_throttling =
1198		    &acpi_processor_set_throttling_fadt;
1199		if (acpi_processor_get_fadt_info(pr))
1200			return 0;
1201	} else {
1202		pr->throttling.acpi_processor_get_throttling =
1203		    &acpi_processor_get_throttling_ptc;
1204		pr->throttling.acpi_processor_set_throttling =
1205		    &acpi_processor_set_throttling_ptc;
1206	}
1207
1208	/*
1209	 * If TSD package for one CPU can't be parsed successfully, it means
1210	 * that this CPU will have no coordination with other CPUs.
1211	 */
1212	if (acpi_processor_get_tsd(pr)) {
1213		pthrottling = &pr->throttling;
1214		pthrottling->tsd_valid_flag = 0;
1215		cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
1216		pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
1217	}
1218
1219	/*
1220	 * PIIX4 Errata: We don't support throttling on the original PIIX4.
1221	 * This shouldn't be an issue as few (if any) mobile systems ever
1222	 * used this part.
1223	 */
1224	if (errata.piix4.throttle) {
1225		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1226				  "Throttling not supported on PIIX4 A- or B-step\n"));
1227		return 0;
1228	}
1229
1230	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
1231			  pr->throttling.state_count));
1232
1233	pr->flags.throttling = 1;
1234
1235	/*
1236	 * Disable throttling (if enabled).  We'll let subsequent policy (e.g.
1237	 * thermal) decide to lower performance if it so chooses, but for now
1238	 * we'll crank up the speed.
1239	 */
1240
1241	result = acpi_processor_get_throttling(pr);
1242	if (result)
1243		goto end;
1244
1245	if (pr->throttling.state) {
1246		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1247				  "Disabling throttling (was T%d)\n",
1248				  pr->throttling.state));
1249		result = acpi_processor_set_throttling(pr, 0, false);
1250		if (result)
1251			goto end;
1252	}
1253
1254      end:
1255	if (result)
1256		pr->flags.throttling = 0;
1257
1258	return result;
1259}
1260