1 /******************************************************************************
2  *
3  * This file is provided under a dual BSD/GPLv2 license.  When using or
4  * redistributing this file, you may do so under either license.
5  *
6  * GPL LICENSE SUMMARY
7  *
8  * Copyright(c) 2013 - 2014, 2019 Intel Corporation. All rights reserved.
9  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
10  * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
11  * Copyright(c) 2019 - 2020 Intel Corporation
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of version 2 of the GNU General Public License as
15  * published by the Free Software Foundation.
16  *
17  * This program is distributed in the hope that it will be useful, but
18  * WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * General Public License for more details.
21  *
22  * The full GNU General Public License is included in this distribution
23  * in the file called COPYING.
24  *
25  * Contact Information:
26  *  Intel Linux Wireless <linuxwifi@intel.com>
27  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
28  *
29  * BSD LICENSE
30  *
31  * Copyright(c) 2012 - 2014, 2019 Intel Corporation. All rights reserved.
32  * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
33  * Copyright(c) 2015 - 2016 Intel Deutschland GmbH
34  * Copyright(c) 2019 - 2020 Intel Corporation
35  * All rights reserved.
36  *
37  * Redistribution and use in source and binary forms, with or without
38  * modification, are permitted provided that the following conditions
39  * are met:
40  *
41  *  * Redistributions of source code must retain the above copyright
42  *    notice, this list of conditions and the following disclaimer.
43  *  * Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in
45  *    the documentation and/or other materials provided with the
46  *    distribution.
47  *  * Neither the name Intel Corporation nor the names of its
48  *    contributors may be used to endorse or promote products derived
49  *    from this software without specific prior written permission.
50  *
51  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
52  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
53  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
54  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
55  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
56  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
57  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
61  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62  *
63  *****************************************************************************/
64 
65 #include <linux/sort.h>
66 
67 #include "mvm.h"
68 
69 #define IWL_MVM_TEMP_NOTIF_WAIT_TIMEOUT	HZ
70 
71 void iwl_mvm_enter_ctkill(struct iwl_mvm *mvm)
72 {
73 	struct iwl_mvm_tt_mgmt *tt = &mvm->thermal_throttle;
74 	u32 duration = tt->params.ct_kill_duration;
75 
76 	if (test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status))
77 		return;
78 
79 	IWL_ERR(mvm, "Enter CT Kill\n");
80 	iwl_mvm_set_hw_ctkill_state(mvm, true);
81 
82 	if (!iwl_mvm_is_tt_in_fw(mvm)) {
83 		tt->throttle = false;
84 		tt->dynamic_smps = false;
85 	}
86 
87 	/* Don't schedule an exit work if we're in test mode, since
88 	 * the temperature will not change unless we manually set it
89 	 * again (or disable testing).
90 	 */
91 	if (!mvm->temperature_test)
92 		schedule_delayed_work(&tt->ct_kill_exit,
93 				      round_jiffies_relative(duration * HZ));
94 }
95 
96 static void iwl_mvm_exit_ctkill(struct iwl_mvm *mvm)
97 {
98 	if (!test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status))
99 		return;
100 
101 	IWL_ERR(mvm, "Exit CT Kill\n");
102 	iwl_mvm_set_hw_ctkill_state(mvm, false);
103 }
104 
105 void iwl_mvm_tt_temp_changed(struct iwl_mvm *mvm, u32 temp)
106 {
107 	/* ignore the notification if we are in test mode */
108 	if (mvm->temperature_test)
109 		return;
110 
111 	if (mvm->temperature == temp)
112 		return;
113 
114 	mvm->temperature = temp;
115 	iwl_mvm_tt_handler(mvm);
116 }
117 
118 static int iwl_mvm_temp_notif_parse(struct iwl_mvm *mvm,
119 				    struct iwl_rx_packet *pkt)
120 {
121 	struct iwl_dts_measurement_notif_v1 *notif_v1;
122 	int len = iwl_rx_packet_payload_len(pkt);
123 	int temp;
124 
125 	/* we can use notif_v1 only, because v2 only adds an additional
126 	 * parameter, which is not used in this function.
127 	*/
128 	if (WARN_ON_ONCE(len < sizeof(*notif_v1))) {
129 		IWL_ERR(mvm, "Invalid DTS_MEASUREMENT_NOTIFICATION\n");
130 		return -EINVAL;
131 	}
132 
133 	notif_v1 = (void *)pkt->data;
134 
135 	temp = le32_to_cpu(notif_v1->temp);
136 
137 	/* shouldn't be negative, but since it's s32, make sure it isn't */
138 	if (WARN_ON_ONCE(temp < 0))
139 		temp = 0;
140 
141 	IWL_DEBUG_TEMP(mvm, "DTS_MEASUREMENT_NOTIFICATION - %d\n", temp);
142 
143 	return temp;
144 }
145 
146 static bool iwl_mvm_temp_notif_wait(struct iwl_notif_wait_data *notif_wait,
147 				    struct iwl_rx_packet *pkt, void *data)
148 {
149 	struct iwl_mvm *mvm =
150 		container_of(notif_wait, struct iwl_mvm, notif_wait);
151 	int *temp = data;
152 	int ret;
153 
154 	ret = iwl_mvm_temp_notif_parse(mvm, pkt);
155 	if (ret < 0)
156 		return true;
157 
158 	*temp = ret;
159 
160 	return true;
161 }
162 
163 void iwl_mvm_temp_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
164 {
165 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
166 	struct iwl_dts_measurement_notif_v2 *notif_v2;
167 	int len = iwl_rx_packet_payload_len(pkt);
168 	int temp;
169 	u32 ths_crossed;
170 
171 	/* the notification is handled synchronously in ctkill, so skip here */
172 	if (test_bit(IWL_MVM_STATUS_HW_CTKILL, &mvm->status))
173 		return;
174 
175 	temp = iwl_mvm_temp_notif_parse(mvm, pkt);
176 
177 	if (!iwl_mvm_is_tt_in_fw(mvm)) {
178 		if (temp >= 0)
179 			iwl_mvm_tt_temp_changed(mvm, temp);
180 		return;
181 	}
182 
183 	if (WARN_ON_ONCE(len < sizeof(*notif_v2))) {
184 		IWL_ERR(mvm, "Invalid DTS_MEASUREMENT_NOTIFICATION\n");
185 		return;
186 	}
187 
188 	notif_v2 = (void *)pkt->data;
189 	ths_crossed = le32_to_cpu(notif_v2->threshold_idx);
190 
191 	/* 0xFF in ths_crossed means the notification is not related
192 	 * to a trip, so we can ignore it here.
193 	 */
194 	if (ths_crossed == 0xFF)
195 		return;
196 
197 	IWL_DEBUG_TEMP(mvm, "Temp = %d Threshold crossed = %d\n",
198 		       temp, ths_crossed);
199 
200 #ifdef CONFIG_THERMAL
201 	if (WARN_ON(ths_crossed >= IWL_MAX_DTS_TRIPS))
202 		return;
203 
204 	if (mvm->tz_device.tzone) {
205 		struct iwl_mvm_thermal_device *tz_dev = &mvm->tz_device;
206 
207 		thermal_notify_framework(tz_dev->tzone,
208 					 tz_dev->fw_trips_index[ths_crossed]);
209 	}
210 #endif /* CONFIG_THERMAL */
211 }
212 
213 void iwl_mvm_ct_kill_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
214 {
215 	struct iwl_rx_packet *pkt = rxb_addr(rxb);
216 	struct ct_kill_notif *notif;
217 	int len = iwl_rx_packet_payload_len(pkt);
218 
219 	if (WARN_ON_ONCE(len != sizeof(*notif))) {
220 		IWL_ERR(mvm, "Invalid CT_KILL_NOTIFICATION\n");
221 		return;
222 	}
223 
224 	notif = (struct ct_kill_notif *)pkt->data;
225 	IWL_DEBUG_TEMP(mvm, "CT Kill notification temperature = %d\n",
226 		       notif->temperature);
227 
228 	iwl_mvm_enter_ctkill(mvm);
229 }
230 
231 /*
232  * send the DTS_MEASUREMENT_TRIGGER command with or without waiting for a
233  * response. If we get a response then the measurement is stored in 'temp'
234  */
235 static int iwl_mvm_send_temp_cmd(struct iwl_mvm *mvm, bool response, s32 *temp)
236 {
237 	struct iwl_host_cmd cmd = {};
238 	struct iwl_dts_measurement_cmd dts_cmd = {
239 		.flags = cpu_to_le32(DTS_TRIGGER_CMD_FLAGS_TEMP),
240 	};
241 	struct iwl_ext_dts_measurement_cmd ext_cmd = {
242 		.control_mode = cpu_to_le32(DTS_DIRECT_WITHOUT_MEASURE),
243 	};
244 	struct iwl_dts_measurement_resp *resp;
245 	void *cmd_ptr;
246 	int ret;
247 	u32 cmd_flags = 0;
248 	u16 len;
249 
250 	/* Check which command format is used (regular/extended) */
251 	if (fw_has_capa(&mvm->fw->ucode_capa,
252 			IWL_UCODE_TLV_CAPA_EXTENDED_DTS_MEASURE)) {
253 		len = sizeof(ext_cmd);
254 		cmd_ptr = &ext_cmd;
255 	} else {
256 		len = sizeof(dts_cmd);
257 		cmd_ptr = &dts_cmd;
258 	}
259 	/* The command version where we get a response is zero length */
260 	if (response) {
261 		cmd_flags = CMD_WANT_SKB;
262 		len = 0;
263 	}
264 
265 	cmd.id =  WIDE_ID(PHY_OPS_GROUP, CMD_DTS_MEASUREMENT_TRIGGER_WIDE);
266 	cmd.len[0] = len;
267 	cmd.flags = cmd_flags;
268 	cmd.data[0] = cmd_ptr;
269 
270 	IWL_DEBUG_TEMP(mvm,
271 		       "Sending temperature measurement command - %s response\n",
272 		       response ? "with" : "without");
273 	ret = iwl_mvm_send_cmd(mvm, &cmd);
274 
275 	if (ret) {
276 		IWL_ERR(mvm,
277 			"Failed to send the temperature measurement command (err=%d)\n",
278 			ret);
279 		return ret;
280 	}
281 
282 	if (response) {
283 		resp = (void *)cmd.resp_pkt->data;
284 		*temp = le32_to_cpu(resp->temp);
285 		IWL_DEBUG_TEMP(mvm,
286 			       "Got temperature measurement response: temp=%d\n",
287 			       *temp);
288 		iwl_free_resp(&cmd);
289 	}
290 
291 	return ret;
292 }
293 
294 int iwl_mvm_get_temp(struct iwl_mvm *mvm, s32 *temp)
295 {
296 	struct iwl_notification_wait wait_temp_notif;
297 	static u16 temp_notif[] = { WIDE_ID(PHY_OPS_GROUP,
298 					    DTS_MEASUREMENT_NOTIF_WIDE) };
299 	int ret;
300 	u8 cmd_ver;
301 
302 	/*
303 	 * If command version is 1 we send the command and immediately get
304 	 * a response. For older versions we send the command and wait for a
305 	 * notification (no command TLV for previous versions).
306 	 */
307 	cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, PHY_OPS_GROUP,
308 					CMD_DTS_MEASUREMENT_TRIGGER_WIDE,
309 					IWL_FW_CMD_VER_UNKNOWN);
310 	if (cmd_ver == 1)
311 		return iwl_mvm_send_temp_cmd(mvm, true, temp);
312 
313 	lockdep_assert_held(&mvm->mutex);
314 
315 	iwl_init_notification_wait(&mvm->notif_wait, &wait_temp_notif,
316 				   temp_notif, ARRAY_SIZE(temp_notif),
317 				   iwl_mvm_temp_notif_wait, temp);
318 
319 	ret = iwl_mvm_send_temp_cmd(mvm, false, temp);
320 	if (ret) {
321 		iwl_remove_notification(&mvm->notif_wait, &wait_temp_notif);
322 		return ret;
323 	}
324 
325 	ret = iwl_wait_notification(&mvm->notif_wait, &wait_temp_notif,
326 				    IWL_MVM_TEMP_NOTIF_WAIT_TIMEOUT);
327 	if (ret)
328 		IWL_ERR(mvm, "Getting the temperature timed out\n");
329 
330 	return ret;
331 }
332 
333 static void check_exit_ctkill(struct work_struct *work)
334 {
335 	struct iwl_mvm_tt_mgmt *tt;
336 	struct iwl_mvm *mvm;
337 	u32 duration;
338 	s32 temp;
339 	int ret;
340 
341 	tt = container_of(work, struct iwl_mvm_tt_mgmt, ct_kill_exit.work);
342 	mvm = container_of(tt, struct iwl_mvm, thermal_throttle);
343 
344 	if (iwl_mvm_is_tt_in_fw(mvm)) {
345 		iwl_mvm_exit_ctkill(mvm);
346 
347 		return;
348 	}
349 
350 	duration = tt->params.ct_kill_duration;
351 
352 	flush_work(&mvm->roc_done_wk);
353 
354 	mutex_lock(&mvm->mutex);
355 
356 	if (__iwl_mvm_mac_start(mvm))
357 		goto reschedule;
358 
359 	ret = iwl_mvm_get_temp(mvm, &temp);
360 
361 	__iwl_mvm_mac_stop(mvm);
362 
363 	if (ret)
364 		goto reschedule;
365 
366 	IWL_DEBUG_TEMP(mvm, "NIC temperature: %d\n", temp);
367 
368 	if (temp <= tt->params.ct_kill_exit) {
369 		mutex_unlock(&mvm->mutex);
370 		iwl_mvm_exit_ctkill(mvm);
371 		return;
372 	}
373 
374 reschedule:
375 	mutex_unlock(&mvm->mutex);
376 	schedule_delayed_work(&mvm->thermal_throttle.ct_kill_exit,
377 			      round_jiffies(duration * HZ));
378 }
379 
380 static void iwl_mvm_tt_smps_iterator(void *_data, u8 *mac,
381 				     struct ieee80211_vif *vif)
382 {
383 	struct iwl_mvm *mvm = _data;
384 	enum ieee80211_smps_mode smps_mode;
385 
386 	lockdep_assert_held(&mvm->mutex);
387 
388 	if (mvm->thermal_throttle.dynamic_smps)
389 		smps_mode = IEEE80211_SMPS_DYNAMIC;
390 	else
391 		smps_mode = IEEE80211_SMPS_AUTOMATIC;
392 
393 	if (vif->type != NL80211_IFTYPE_STATION)
394 		return;
395 
396 	iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT, smps_mode);
397 }
398 
399 static void iwl_mvm_tt_tx_protection(struct iwl_mvm *mvm, bool enable)
400 {
401 	struct iwl_mvm_sta *mvmsta;
402 	int i, err;
403 
404 	for (i = 0; i < mvm->fw->ucode_capa.num_stations; i++) {
405 		mvmsta = iwl_mvm_sta_from_staid_protected(mvm, i);
406 		if (!mvmsta)
407 			continue;
408 
409 		if (enable == mvmsta->tt_tx_protection)
410 			continue;
411 		err = iwl_mvm_tx_protection(mvm, mvmsta, enable);
412 		if (err) {
413 			IWL_ERR(mvm, "Failed to %s Tx protection\n",
414 				enable ? "enable" : "disable");
415 		} else {
416 			IWL_DEBUG_TEMP(mvm, "%s Tx protection\n",
417 				       enable ? "Enable" : "Disable");
418 			mvmsta->tt_tx_protection = enable;
419 		}
420 	}
421 }
422 
423 void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff)
424 {
425 	struct iwl_host_cmd cmd = {
426 		.id = REPLY_THERMAL_MNG_BACKOFF,
427 		.len = { sizeof(u32), },
428 		.data = { &backoff, },
429 	};
430 
431 	backoff = max(backoff, mvm->thermal_throttle.min_backoff);
432 
433 	if (iwl_mvm_send_cmd(mvm, &cmd) == 0) {
434 		IWL_DEBUG_TEMP(mvm, "Set Thermal Tx backoff to: %u\n",
435 			       backoff);
436 		mvm->thermal_throttle.tx_backoff = backoff;
437 	} else {
438 		IWL_ERR(mvm, "Failed to change Thermal Tx backoff\n");
439 	}
440 }
441 
442 void iwl_mvm_tt_handler(struct iwl_mvm *mvm)
443 {
444 	struct iwl_tt_params *params = &mvm->thermal_throttle.params;
445 	struct iwl_mvm_tt_mgmt *tt = &mvm->thermal_throttle;
446 	s32 temperature = mvm->temperature;
447 	bool throttle_enable = false;
448 	int i;
449 	u32 tx_backoff;
450 
451 	IWL_DEBUG_TEMP(mvm, "NIC temperature: %d\n", mvm->temperature);
452 
453 	if (params->support_ct_kill && temperature >= params->ct_kill_entry) {
454 		iwl_mvm_enter_ctkill(mvm);
455 		return;
456 	}
457 
458 	if (params->support_ct_kill &&
459 	    temperature <= params->ct_kill_exit) {
460 		iwl_mvm_exit_ctkill(mvm);
461 		return;
462 	}
463 
464 	if (params->support_dynamic_smps) {
465 		if (!tt->dynamic_smps &&
466 		    temperature >= params->dynamic_smps_entry) {
467 			IWL_DEBUG_TEMP(mvm, "Enable dynamic SMPS\n");
468 			tt->dynamic_smps = true;
469 			ieee80211_iterate_active_interfaces_atomic(
470 					mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
471 					iwl_mvm_tt_smps_iterator, mvm);
472 			throttle_enable = true;
473 		} else if (tt->dynamic_smps &&
474 			   temperature <= params->dynamic_smps_exit) {
475 			IWL_DEBUG_TEMP(mvm, "Disable dynamic SMPS\n");
476 			tt->dynamic_smps = false;
477 			ieee80211_iterate_active_interfaces_atomic(
478 					mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
479 					iwl_mvm_tt_smps_iterator, mvm);
480 		}
481 	}
482 
483 	if (params->support_tx_protection) {
484 		if (temperature >= params->tx_protection_entry) {
485 			iwl_mvm_tt_tx_protection(mvm, true);
486 			throttle_enable = true;
487 		} else if (temperature <= params->tx_protection_exit) {
488 			iwl_mvm_tt_tx_protection(mvm, false);
489 		}
490 	}
491 
492 	if (params->support_tx_backoff) {
493 		tx_backoff = tt->min_backoff;
494 		for (i = 0; i < TT_TX_BACKOFF_SIZE; i++) {
495 			if (temperature < params->tx_backoff[i].temperature)
496 				break;
497 			tx_backoff = max(tt->min_backoff,
498 					 params->tx_backoff[i].backoff);
499 		}
500 		if (tx_backoff != tt->min_backoff)
501 			throttle_enable = true;
502 		if (tt->tx_backoff != tx_backoff)
503 			iwl_mvm_tt_tx_backoff(mvm, tx_backoff);
504 	}
505 
506 	if (!tt->throttle && throttle_enable) {
507 		IWL_WARN(mvm,
508 			 "Due to high temperature thermal throttling initiated\n");
509 		tt->throttle = true;
510 	} else if (tt->throttle && !tt->dynamic_smps &&
511 		   tt->tx_backoff == tt->min_backoff &&
512 		   temperature <= params->tx_protection_exit) {
513 		IWL_WARN(mvm,
514 			 "Temperature is back to normal thermal throttling stopped\n");
515 		tt->throttle = false;
516 	}
517 }
518 
519 static const struct iwl_tt_params iwl_mvm_default_tt_params = {
520 	.ct_kill_entry = 118,
521 	.ct_kill_exit = 96,
522 	.ct_kill_duration = 5,
523 	.dynamic_smps_entry = 114,
524 	.dynamic_smps_exit = 110,
525 	.tx_protection_entry = 114,
526 	.tx_protection_exit = 108,
527 	.tx_backoff = {
528 		{.temperature = 112, .backoff = 200},
529 		{.temperature = 113, .backoff = 600},
530 		{.temperature = 114, .backoff = 1200},
531 		{.temperature = 115, .backoff = 2000},
532 		{.temperature = 116, .backoff = 4000},
533 		{.temperature = 117, .backoff = 10000},
534 	},
535 	.support_ct_kill = true,
536 	.support_dynamic_smps = true,
537 	.support_tx_protection = true,
538 	.support_tx_backoff = true,
539 };
540 
541 /* budget in mWatt */
542 static const u32 iwl_mvm_cdev_budgets[] = {
543 	2400,	/* cooling state 0 */
544 	2000,	/* cooling state 1 */
545 	1800,	/* cooling state 2 */
546 	1600,	/* cooling state 3 */
547 	1400,	/* cooling state 4 */
548 	1200,	/* cooling state 5 */
549 	1000,	/* cooling state 6 */
550 	900,	/* cooling state 7 */
551 	800,	/* cooling state 8 */
552 	700,	/* cooling state 9 */
553 	650,	/* cooling state 10 */
554 	600,	/* cooling state 11 */
555 	550,	/* cooling state 12 */
556 	500,	/* cooling state 13 */
557 	450,	/* cooling state 14 */
558 	400,	/* cooling state 15 */
559 	350,	/* cooling state 16 */
560 	300,	/* cooling state 17 */
561 	250,	/* cooling state 18 */
562 	200,	/* cooling state 19 */
563 	150,	/* cooling state 20 */
564 };
565 
566 int iwl_mvm_ctdp_command(struct iwl_mvm *mvm, u32 op, u32 state)
567 {
568 	struct iwl_mvm_ctdp_cmd cmd = {
569 		.operation = cpu_to_le32(op),
570 		.budget = cpu_to_le32(iwl_mvm_cdev_budgets[state]),
571 		.window_size = 0,
572 	};
573 	int ret;
574 	u32 status;
575 
576 	lockdep_assert_held(&mvm->mutex);
577 
578 	status = 0;
579 	ret = iwl_mvm_send_cmd_pdu_status(mvm, WIDE_ID(PHY_OPS_GROUP,
580 						       CTDP_CONFIG_CMD),
581 					  sizeof(cmd), &cmd, &status);
582 
583 	if (ret) {
584 		IWL_ERR(mvm, "cTDP command failed (err=%d)\n", ret);
585 		return ret;
586 	}
587 
588 	switch (op) {
589 	case CTDP_CMD_OPERATION_START:
590 #ifdef CONFIG_THERMAL
591 		mvm->cooling_dev.cur_state = state;
592 #endif /* CONFIG_THERMAL */
593 		break;
594 	case CTDP_CMD_OPERATION_REPORT:
595 		IWL_DEBUG_TEMP(mvm, "cTDP avg energy in mWatt = %d\n", status);
596 		/* when the function is called with CTDP_CMD_OPERATION_REPORT
597 		 * option the function should return the average budget value
598 		 * that is received from the FW.
599 		 * The budget can't be less or equal to 0, so it's possible
600 		 * to distinguish between error values and budgets.
601 		 */
602 		return status;
603 	case CTDP_CMD_OPERATION_STOP:
604 		IWL_DEBUG_TEMP(mvm, "cTDP stopped successfully\n");
605 		break;
606 	}
607 
608 	return 0;
609 }
610 
611 #ifdef CONFIG_THERMAL
612 static int compare_temps(const void *a, const void *b)
613 {
614 	return ((s16)le16_to_cpu(*(__le16 *)a) -
615 		(s16)le16_to_cpu(*(__le16 *)b));
616 }
617 #endif
618 
619 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm)
620 {
621 	struct temp_report_ths_cmd cmd = {0};
622 	int ret;
623 #ifdef CONFIG_THERMAL
624 	int i, j, idx = 0;
625 
626 	lockdep_assert_held(&mvm->mutex);
627 
628 	if (!mvm->tz_device.tzone)
629 		goto send;
630 
631 	/* The driver holds array of temperature trips that are unsorted
632 	 * and uncompressed, the FW should get it compressed and sorted
633 	 */
634 
635 	/* compress temp_trips to cmd array, remove uninitialized values*/
636 	for (i = 0; i < IWL_MAX_DTS_TRIPS; i++) {
637 		if (mvm->tz_device.temp_trips[i] != S16_MIN) {
638 			cmd.thresholds[idx++] =
639 				cpu_to_le16(mvm->tz_device.temp_trips[i]);
640 		}
641 	}
642 	cmd.num_temps = cpu_to_le32(idx);
643 
644 	if (!idx)
645 		goto send;
646 
647 	/*sort cmd array*/
648 	sort(cmd.thresholds, idx, sizeof(s16), compare_temps, NULL);
649 
650 	/* we should save the indexes of trips because we sort
651 	 * and compress the orginal array
652 	 */
653 	for (i = 0; i < idx; i++) {
654 		for (j = 0; j < IWL_MAX_DTS_TRIPS; j++) {
655 			if (le16_to_cpu(cmd.thresholds[i]) ==
656 				mvm->tz_device.temp_trips[j])
657 				mvm->tz_device.fw_trips_index[i] = j;
658 		}
659 	}
660 
661 send:
662 #endif
663 	ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP,
664 						TEMP_REPORTING_THRESHOLDS_CMD),
665 				   0, sizeof(cmd), &cmd);
666 	if (ret)
667 		IWL_ERR(mvm, "TEMP_REPORT_THS_CMD command failed (err=%d)\n",
668 			ret);
669 
670 	return ret;
671 }
672 
673 #ifdef CONFIG_THERMAL
674 static int iwl_mvm_tzone_get_temp(struct thermal_zone_device *device,
675 				  int *temperature)
676 {
677 	struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata;
678 	int ret;
679 	int temp;
680 
681 	mutex_lock(&mvm->mutex);
682 
683 	if (!iwl_mvm_firmware_running(mvm) ||
684 	    mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) {
685 		ret = -ENODATA;
686 		goto out;
687 	}
688 
689 	ret = iwl_mvm_get_temp(mvm, &temp);
690 	if (ret)
691 		goto out;
692 
693 	*temperature = temp * 1000;
694 
695 out:
696 	mutex_unlock(&mvm->mutex);
697 	return ret;
698 }
699 
700 static int iwl_mvm_tzone_get_trip_temp(struct thermal_zone_device *device,
701 				       int trip, int *temp)
702 {
703 	struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata;
704 
705 	if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS)
706 		return -EINVAL;
707 
708 	*temp = mvm->tz_device.temp_trips[trip] * 1000;
709 
710 	return 0;
711 }
712 
713 static int iwl_mvm_tzone_get_trip_type(struct thermal_zone_device *device,
714 				       int trip, enum thermal_trip_type *type)
715 {
716 	if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS)
717 		return -EINVAL;
718 
719 	*type = THERMAL_TRIP_PASSIVE;
720 
721 	return 0;
722 }
723 
724 static int iwl_mvm_tzone_set_trip_temp(struct thermal_zone_device *device,
725 				       int trip, int temp)
726 {
727 	struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata;
728 	struct iwl_mvm_thermal_device *tzone;
729 	int i, ret;
730 	s16 temperature;
731 
732 	mutex_lock(&mvm->mutex);
733 
734 	if (!iwl_mvm_firmware_running(mvm) ||
735 	    mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) {
736 		ret = -EIO;
737 		goto out;
738 	}
739 
740 	if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS) {
741 		ret = -EINVAL;
742 		goto out;
743 	}
744 
745 	if ((temp / 1000) > S16_MAX) {
746 		ret = -EINVAL;
747 		goto out;
748 	}
749 
750 	temperature = (s16)(temp / 1000);
751 	tzone = &mvm->tz_device;
752 
753 	if (!tzone) {
754 		ret = -EIO;
755 		goto out;
756 	}
757 
758 	/* no updates*/
759 	if (tzone->temp_trips[trip] == temperature) {
760 		ret = 0;
761 		goto out;
762 	}
763 
764 	/* already existing temperature */
765 	for (i = 0; i < IWL_MAX_DTS_TRIPS; i++) {
766 		if (tzone->temp_trips[i] == temperature) {
767 			ret = -EINVAL;
768 			goto out;
769 		}
770 	}
771 
772 	tzone->temp_trips[trip] = temperature;
773 
774 	ret = iwl_mvm_send_temp_report_ths_cmd(mvm);
775 out:
776 	mutex_unlock(&mvm->mutex);
777 	return ret;
778 }
779 
780 static  struct thermal_zone_device_ops tzone_ops = {
781 	.get_temp = iwl_mvm_tzone_get_temp,
782 	.get_trip_temp = iwl_mvm_tzone_get_trip_temp,
783 	.get_trip_type = iwl_mvm_tzone_get_trip_type,
784 	.set_trip_temp = iwl_mvm_tzone_set_trip_temp,
785 };
786 
787 /* make all trips writable */
788 #define IWL_WRITABLE_TRIPS_MSK (BIT(IWL_MAX_DTS_TRIPS) - 1)
789 
790 static void iwl_mvm_thermal_zone_register(struct iwl_mvm *mvm)
791 {
792 	int i, ret;
793 	char name[16];
794 	static atomic_t counter = ATOMIC_INIT(0);
795 
796 	if (!iwl_mvm_is_tt_in_fw(mvm)) {
797 		mvm->tz_device.tzone = NULL;
798 
799 		return;
800 	}
801 
802 	BUILD_BUG_ON(ARRAY_SIZE(name) >= THERMAL_NAME_LENGTH);
803 
804 	sprintf(name, "iwlwifi_%u", atomic_inc_return(&counter) & 0xFF);
805 	mvm->tz_device.tzone = thermal_zone_device_register(name,
806 							IWL_MAX_DTS_TRIPS,
807 							IWL_WRITABLE_TRIPS_MSK,
808 							mvm, &tzone_ops,
809 							NULL, 0, 0);
810 	if (IS_ERR(mvm->tz_device.tzone)) {
811 		IWL_DEBUG_TEMP(mvm,
812 			       "Failed to register to thermal zone (err = %ld)\n",
813 			       PTR_ERR(mvm->tz_device.tzone));
814 		mvm->tz_device.tzone = NULL;
815 		return;
816 	}
817 
818 	ret = thermal_zone_device_enable(mvm->tz_device.tzone);
819 	if (ret) {
820 		IWL_DEBUG_TEMP(mvm, "Failed to enable thermal zone\n");
821 		thermal_zone_device_unregister(mvm->tz_device.tzone);
822 		return;
823 	}
824 
825 	/* 0 is a valid temperature,
826 	 * so initialize the array with S16_MIN which invalid temperature
827 	 */
828 	for (i = 0 ; i < IWL_MAX_DTS_TRIPS; i++)
829 		mvm->tz_device.temp_trips[i] = S16_MIN;
830 }
831 
832 static int iwl_mvm_tcool_get_max_state(struct thermal_cooling_device *cdev,
833 				       unsigned long *state)
834 {
835 	*state = ARRAY_SIZE(iwl_mvm_cdev_budgets) - 1;
836 
837 	return 0;
838 }
839 
840 static int iwl_mvm_tcool_get_cur_state(struct thermal_cooling_device *cdev,
841 				       unsigned long *state)
842 {
843 	struct iwl_mvm *mvm = (struct iwl_mvm *)(cdev->devdata);
844 
845 	*state = mvm->cooling_dev.cur_state;
846 
847 	return 0;
848 }
849 
850 static int iwl_mvm_tcool_set_cur_state(struct thermal_cooling_device *cdev,
851 				       unsigned long new_state)
852 {
853 	struct iwl_mvm *mvm = (struct iwl_mvm *)(cdev->devdata);
854 	int ret;
855 
856 	mutex_lock(&mvm->mutex);
857 
858 	if (!iwl_mvm_firmware_running(mvm) ||
859 	    mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) {
860 		ret = -EIO;
861 		goto unlock;
862 	}
863 
864 	if (new_state >= ARRAY_SIZE(iwl_mvm_cdev_budgets)) {
865 		ret = -EINVAL;
866 		goto unlock;
867 	}
868 
869 	ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START,
870 				   new_state);
871 
872 unlock:
873 	mutex_unlock(&mvm->mutex);
874 	return ret;
875 }
876 
877 static const struct thermal_cooling_device_ops tcooling_ops = {
878 	.get_max_state = iwl_mvm_tcool_get_max_state,
879 	.get_cur_state = iwl_mvm_tcool_get_cur_state,
880 	.set_cur_state = iwl_mvm_tcool_set_cur_state,
881 };
882 
883 static void iwl_mvm_cooling_device_register(struct iwl_mvm *mvm)
884 {
885 	char name[] = "iwlwifi";
886 
887 	if (!iwl_mvm_is_ctdp_supported(mvm))
888 		return;
889 
890 	BUILD_BUG_ON(ARRAY_SIZE(name) >= THERMAL_NAME_LENGTH);
891 
892 	mvm->cooling_dev.cdev =
893 		thermal_cooling_device_register(name,
894 						mvm,
895 						&tcooling_ops);
896 
897 	if (IS_ERR(mvm->cooling_dev.cdev)) {
898 		IWL_DEBUG_TEMP(mvm,
899 			       "Failed to register to cooling device (err = %ld)\n",
900 			       PTR_ERR(mvm->cooling_dev.cdev));
901 		mvm->cooling_dev.cdev = NULL;
902 		return;
903 	}
904 }
905 
906 static void iwl_mvm_thermal_zone_unregister(struct iwl_mvm *mvm)
907 {
908 	if (!iwl_mvm_is_tt_in_fw(mvm) || !mvm->tz_device.tzone)
909 		return;
910 
911 	IWL_DEBUG_TEMP(mvm, "Thermal zone device unregister\n");
912 	if (mvm->tz_device.tzone) {
913 		thermal_zone_device_unregister(mvm->tz_device.tzone);
914 		mvm->tz_device.tzone = NULL;
915 	}
916 }
917 
918 static void iwl_mvm_cooling_device_unregister(struct iwl_mvm *mvm)
919 {
920 	if (!iwl_mvm_is_ctdp_supported(mvm) || !mvm->cooling_dev.cdev)
921 		return;
922 
923 	IWL_DEBUG_TEMP(mvm, "Cooling device unregister\n");
924 	if (mvm->cooling_dev.cdev) {
925 		thermal_cooling_device_unregister(mvm->cooling_dev.cdev);
926 		mvm->cooling_dev.cdev = NULL;
927 	}
928 }
929 #endif /* CONFIG_THERMAL */
930 
931 void iwl_mvm_thermal_initialize(struct iwl_mvm *mvm, u32 min_backoff)
932 {
933 	struct iwl_mvm_tt_mgmt *tt = &mvm->thermal_throttle;
934 
935 	IWL_DEBUG_TEMP(mvm, "Initialize Thermal Throttling\n");
936 
937 	if (mvm->cfg->thermal_params)
938 		tt->params = *mvm->cfg->thermal_params;
939 	else
940 		tt->params = iwl_mvm_default_tt_params;
941 
942 	tt->throttle = false;
943 	tt->dynamic_smps = false;
944 	tt->min_backoff = min_backoff;
945 	INIT_DELAYED_WORK(&tt->ct_kill_exit, check_exit_ctkill);
946 
947 #ifdef CONFIG_THERMAL
948 	iwl_mvm_cooling_device_register(mvm);
949 	iwl_mvm_thermal_zone_register(mvm);
950 #endif
951 	mvm->init_status |= IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE;
952 }
953 
954 void iwl_mvm_thermal_exit(struct iwl_mvm *mvm)
955 {
956 	if (!(mvm->init_status & IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE))
957 		return;
958 
959 	cancel_delayed_work_sync(&mvm->thermal_throttle.ct_kill_exit);
960 	IWL_DEBUG_TEMP(mvm, "Exit Thermal Throttling\n");
961 
962 #ifdef CONFIG_THERMAL
963 	iwl_mvm_cooling_device_unregister(mvm);
964 	iwl_mvm_thermal_zone_unregister(mvm);
965 #endif
966 	mvm->init_status &= ~IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE;
967 }
968