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 static int iwl_mvm_get_temp_cmd(struct iwl_mvm *mvm) 232 { 233 struct iwl_dts_measurement_cmd cmd = { 234 .flags = cpu_to_le32(DTS_TRIGGER_CMD_FLAGS_TEMP), 235 }; 236 struct iwl_ext_dts_measurement_cmd extcmd = { 237 .control_mode = cpu_to_le32(DTS_DIRECT_WITHOUT_MEASURE), 238 }; 239 u32 cmdid; 240 241 cmdid = iwl_cmd_id(CMD_DTS_MEASUREMENT_TRIGGER_WIDE, 242 PHY_OPS_GROUP, 0); 243 244 if (!fw_has_capa(&mvm->fw->ucode_capa, 245 IWL_UCODE_TLV_CAPA_EXTENDED_DTS_MEASURE)) 246 return iwl_mvm_send_cmd_pdu(mvm, cmdid, 0, sizeof(cmd), &cmd); 247 248 return iwl_mvm_send_cmd_pdu(mvm, cmdid, 0, sizeof(extcmd), &extcmd); 249 } 250 251 int iwl_mvm_get_temp(struct iwl_mvm *mvm, s32 *temp) 252 { 253 struct iwl_notification_wait wait_temp_notif; 254 static u16 temp_notif[] = { WIDE_ID(PHY_OPS_GROUP, 255 DTS_MEASUREMENT_NOTIF_WIDE) }; 256 int ret; 257 258 lockdep_assert_held(&mvm->mutex); 259 260 iwl_init_notification_wait(&mvm->notif_wait, &wait_temp_notif, 261 temp_notif, ARRAY_SIZE(temp_notif), 262 iwl_mvm_temp_notif_wait, temp); 263 264 ret = iwl_mvm_get_temp_cmd(mvm); 265 if (ret) { 266 IWL_ERR(mvm, "Failed to get the temperature (err=%d)\n", ret); 267 iwl_remove_notification(&mvm->notif_wait, &wait_temp_notif); 268 return ret; 269 } 270 271 ret = iwl_wait_notification(&mvm->notif_wait, &wait_temp_notif, 272 IWL_MVM_TEMP_NOTIF_WAIT_TIMEOUT); 273 if (ret) 274 IWL_ERR(mvm, "Getting the temperature timed out\n"); 275 276 return ret; 277 } 278 279 static void check_exit_ctkill(struct work_struct *work) 280 { 281 struct iwl_mvm_tt_mgmt *tt; 282 struct iwl_mvm *mvm; 283 u32 duration; 284 s32 temp; 285 int ret; 286 287 tt = container_of(work, struct iwl_mvm_tt_mgmt, ct_kill_exit.work); 288 mvm = container_of(tt, struct iwl_mvm, thermal_throttle); 289 290 if (iwl_mvm_is_tt_in_fw(mvm)) { 291 iwl_mvm_exit_ctkill(mvm); 292 293 return; 294 } 295 296 duration = tt->params.ct_kill_duration; 297 298 mutex_lock(&mvm->mutex); 299 300 if (__iwl_mvm_mac_start(mvm)) 301 goto reschedule; 302 303 ret = iwl_mvm_get_temp(mvm, &temp); 304 305 __iwl_mvm_mac_stop(mvm); 306 307 if (ret) 308 goto reschedule; 309 310 IWL_DEBUG_TEMP(mvm, "NIC temperature: %d\n", temp); 311 312 if (temp <= tt->params.ct_kill_exit) { 313 mutex_unlock(&mvm->mutex); 314 iwl_mvm_exit_ctkill(mvm); 315 return; 316 } 317 318 reschedule: 319 mutex_unlock(&mvm->mutex); 320 schedule_delayed_work(&mvm->thermal_throttle.ct_kill_exit, 321 round_jiffies(duration * HZ)); 322 } 323 324 static void iwl_mvm_tt_smps_iterator(void *_data, u8 *mac, 325 struct ieee80211_vif *vif) 326 { 327 struct iwl_mvm *mvm = _data; 328 enum ieee80211_smps_mode smps_mode; 329 330 lockdep_assert_held(&mvm->mutex); 331 332 if (mvm->thermal_throttle.dynamic_smps) 333 smps_mode = IEEE80211_SMPS_DYNAMIC; 334 else 335 smps_mode = IEEE80211_SMPS_AUTOMATIC; 336 337 if (vif->type != NL80211_IFTYPE_STATION) 338 return; 339 340 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT, smps_mode); 341 } 342 343 static void iwl_mvm_tt_tx_protection(struct iwl_mvm *mvm, bool enable) 344 { 345 struct iwl_mvm_sta *mvmsta; 346 int i, err; 347 348 for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) { 349 mvmsta = iwl_mvm_sta_from_staid_protected(mvm, i); 350 if (!mvmsta) 351 continue; 352 353 if (enable == mvmsta->tt_tx_protection) 354 continue; 355 err = iwl_mvm_tx_protection(mvm, mvmsta, enable); 356 if (err) { 357 IWL_ERR(mvm, "Failed to %s Tx protection\n", 358 enable ? "enable" : "disable"); 359 } else { 360 IWL_DEBUG_TEMP(mvm, "%s Tx protection\n", 361 enable ? "Enable" : "Disable"); 362 mvmsta->tt_tx_protection = enable; 363 } 364 } 365 } 366 367 void iwl_mvm_tt_tx_backoff(struct iwl_mvm *mvm, u32 backoff) 368 { 369 struct iwl_host_cmd cmd = { 370 .id = REPLY_THERMAL_MNG_BACKOFF, 371 .len = { sizeof(u32), }, 372 .data = { &backoff, }, 373 }; 374 375 backoff = max(backoff, mvm->thermal_throttle.min_backoff); 376 377 if (iwl_mvm_send_cmd(mvm, &cmd) == 0) { 378 IWL_DEBUG_TEMP(mvm, "Set Thermal Tx backoff to: %u\n", 379 backoff); 380 mvm->thermal_throttle.tx_backoff = backoff; 381 } else { 382 IWL_ERR(mvm, "Failed to change Thermal Tx backoff\n"); 383 } 384 } 385 386 void iwl_mvm_tt_handler(struct iwl_mvm *mvm) 387 { 388 struct iwl_tt_params *params = &mvm->thermal_throttle.params; 389 struct iwl_mvm_tt_mgmt *tt = &mvm->thermal_throttle; 390 s32 temperature = mvm->temperature; 391 bool throttle_enable = false; 392 int i; 393 u32 tx_backoff; 394 395 IWL_DEBUG_TEMP(mvm, "NIC temperature: %d\n", mvm->temperature); 396 397 if (params->support_ct_kill && temperature >= params->ct_kill_entry) { 398 iwl_mvm_enter_ctkill(mvm); 399 return; 400 } 401 402 if (params->support_ct_kill && 403 temperature <= params->ct_kill_exit) { 404 iwl_mvm_exit_ctkill(mvm); 405 return; 406 } 407 408 if (params->support_dynamic_smps) { 409 if (!tt->dynamic_smps && 410 temperature >= params->dynamic_smps_entry) { 411 IWL_DEBUG_TEMP(mvm, "Enable dynamic SMPS\n"); 412 tt->dynamic_smps = true; 413 ieee80211_iterate_active_interfaces_atomic( 414 mvm->hw, IEEE80211_IFACE_ITER_NORMAL, 415 iwl_mvm_tt_smps_iterator, mvm); 416 throttle_enable = true; 417 } else if (tt->dynamic_smps && 418 temperature <= params->dynamic_smps_exit) { 419 IWL_DEBUG_TEMP(mvm, "Disable dynamic SMPS\n"); 420 tt->dynamic_smps = false; 421 ieee80211_iterate_active_interfaces_atomic( 422 mvm->hw, IEEE80211_IFACE_ITER_NORMAL, 423 iwl_mvm_tt_smps_iterator, mvm); 424 } 425 } 426 427 if (params->support_tx_protection) { 428 if (temperature >= params->tx_protection_entry) { 429 iwl_mvm_tt_tx_protection(mvm, true); 430 throttle_enable = true; 431 } else if (temperature <= params->tx_protection_exit) { 432 iwl_mvm_tt_tx_protection(mvm, false); 433 } 434 } 435 436 if (params->support_tx_backoff) { 437 tx_backoff = tt->min_backoff; 438 for (i = 0; i < TT_TX_BACKOFF_SIZE; i++) { 439 if (temperature < params->tx_backoff[i].temperature) 440 break; 441 tx_backoff = max(tt->min_backoff, 442 params->tx_backoff[i].backoff); 443 } 444 if (tx_backoff != tt->min_backoff) 445 throttle_enable = true; 446 if (tt->tx_backoff != tx_backoff) 447 iwl_mvm_tt_tx_backoff(mvm, tx_backoff); 448 } 449 450 if (!tt->throttle && throttle_enable) { 451 IWL_WARN(mvm, 452 "Due to high temperature thermal throttling initiated\n"); 453 tt->throttle = true; 454 } else if (tt->throttle && !tt->dynamic_smps && 455 tt->tx_backoff == tt->min_backoff && 456 temperature <= params->tx_protection_exit) { 457 IWL_WARN(mvm, 458 "Temperature is back to normal thermal throttling stopped\n"); 459 tt->throttle = false; 460 } 461 } 462 463 static const struct iwl_tt_params iwl_mvm_default_tt_params = { 464 .ct_kill_entry = 118, 465 .ct_kill_exit = 96, 466 .ct_kill_duration = 5, 467 .dynamic_smps_entry = 114, 468 .dynamic_smps_exit = 110, 469 .tx_protection_entry = 114, 470 .tx_protection_exit = 108, 471 .tx_backoff = { 472 {.temperature = 112, .backoff = 200}, 473 {.temperature = 113, .backoff = 600}, 474 {.temperature = 114, .backoff = 1200}, 475 {.temperature = 115, .backoff = 2000}, 476 {.temperature = 116, .backoff = 4000}, 477 {.temperature = 117, .backoff = 10000}, 478 }, 479 .support_ct_kill = true, 480 .support_dynamic_smps = true, 481 .support_tx_protection = true, 482 .support_tx_backoff = true, 483 }; 484 485 /* budget in mWatt */ 486 static const u32 iwl_mvm_cdev_budgets[] = { 487 2400, /* cooling state 0 */ 488 2000, /* cooling state 1 */ 489 1800, /* cooling state 2 */ 490 1600, /* cooling state 3 */ 491 1400, /* cooling state 4 */ 492 1200, /* cooling state 5 */ 493 1000, /* cooling state 6 */ 494 900, /* cooling state 7 */ 495 800, /* cooling state 8 */ 496 700, /* cooling state 9 */ 497 650, /* cooling state 10 */ 498 600, /* cooling state 11 */ 499 550, /* cooling state 12 */ 500 500, /* cooling state 13 */ 501 450, /* cooling state 14 */ 502 400, /* cooling state 15 */ 503 350, /* cooling state 16 */ 504 300, /* cooling state 17 */ 505 250, /* cooling state 18 */ 506 200, /* cooling state 19 */ 507 150, /* cooling state 20 */ 508 }; 509 510 int iwl_mvm_ctdp_command(struct iwl_mvm *mvm, u32 op, u32 state) 511 { 512 struct iwl_mvm_ctdp_cmd cmd = { 513 .operation = cpu_to_le32(op), 514 .budget = cpu_to_le32(iwl_mvm_cdev_budgets[state]), 515 .window_size = 0, 516 }; 517 int ret; 518 u32 status; 519 520 lockdep_assert_held(&mvm->mutex); 521 522 status = 0; 523 ret = iwl_mvm_send_cmd_pdu_status(mvm, WIDE_ID(PHY_OPS_GROUP, 524 CTDP_CONFIG_CMD), 525 sizeof(cmd), &cmd, &status); 526 527 if (ret) { 528 IWL_ERR(mvm, "cTDP command failed (err=%d)\n", ret); 529 return ret; 530 } 531 532 switch (op) { 533 case CTDP_CMD_OPERATION_START: 534 #ifdef CONFIG_THERMAL 535 mvm->cooling_dev.cur_state = state; 536 #endif /* CONFIG_THERMAL */ 537 break; 538 case CTDP_CMD_OPERATION_REPORT: 539 IWL_DEBUG_TEMP(mvm, "cTDP avg energy in mWatt = %d\n", status); 540 /* when the function is called with CTDP_CMD_OPERATION_REPORT 541 * option the function should return the average budget value 542 * that is received from the FW. 543 * The budget can't be less or equal to 0, so it's possible 544 * to distinguish between error values and budgets. 545 */ 546 return status; 547 case CTDP_CMD_OPERATION_STOP: 548 IWL_DEBUG_TEMP(mvm, "cTDP stopped successfully\n"); 549 break; 550 } 551 552 return 0; 553 } 554 555 #ifdef CONFIG_THERMAL 556 static int compare_temps(const void *a, const void *b) 557 { 558 return ((s16)le16_to_cpu(*(__le16 *)a) - 559 (s16)le16_to_cpu(*(__le16 *)b)); 560 } 561 #endif 562 563 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm) 564 { 565 struct temp_report_ths_cmd cmd = {0}; 566 int ret; 567 #ifdef CONFIG_THERMAL 568 int i, j, idx = 0; 569 570 lockdep_assert_held(&mvm->mutex); 571 572 if (!mvm->tz_device.tzone) 573 goto send; 574 575 /* The driver holds array of temperature trips that are unsorted 576 * and uncompressed, the FW should get it compressed and sorted 577 */ 578 579 /* compress temp_trips to cmd array, remove uninitialized values*/ 580 for (i = 0; i < IWL_MAX_DTS_TRIPS; i++) { 581 if (mvm->tz_device.temp_trips[i] != S16_MIN) { 582 cmd.thresholds[idx++] = 583 cpu_to_le16(mvm->tz_device.temp_trips[i]); 584 } 585 } 586 cmd.num_temps = cpu_to_le32(idx); 587 588 if (!idx) 589 goto send; 590 591 /*sort cmd array*/ 592 sort(cmd.thresholds, idx, sizeof(s16), compare_temps, NULL); 593 594 /* we should save the indexes of trips because we sort 595 * and compress the orginal array 596 */ 597 for (i = 0; i < idx; i++) { 598 for (j = 0; j < IWL_MAX_DTS_TRIPS; j++) { 599 if (le16_to_cpu(cmd.thresholds[i]) == 600 mvm->tz_device.temp_trips[j]) 601 mvm->tz_device.fw_trips_index[i] = j; 602 } 603 } 604 605 send: 606 #endif 607 ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP, 608 TEMP_REPORTING_THRESHOLDS_CMD), 609 0, sizeof(cmd), &cmd); 610 if (ret) 611 IWL_ERR(mvm, "TEMP_REPORT_THS_CMD command failed (err=%d)\n", 612 ret); 613 614 return ret; 615 } 616 617 #ifdef CONFIG_THERMAL 618 static int iwl_mvm_tzone_get_temp(struct thermal_zone_device *device, 619 int *temperature) 620 { 621 struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata; 622 int ret; 623 int temp; 624 625 mutex_lock(&mvm->mutex); 626 627 if (!iwl_mvm_firmware_running(mvm) || 628 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) { 629 ret = -ENODATA; 630 goto out; 631 } 632 633 ret = iwl_mvm_get_temp(mvm, &temp); 634 if (ret) 635 goto out; 636 637 *temperature = temp * 1000; 638 639 out: 640 mutex_unlock(&mvm->mutex); 641 return ret; 642 } 643 644 static int iwl_mvm_tzone_get_trip_temp(struct thermal_zone_device *device, 645 int trip, int *temp) 646 { 647 struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata; 648 649 if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS) 650 return -EINVAL; 651 652 *temp = mvm->tz_device.temp_trips[trip] * 1000; 653 654 return 0; 655 } 656 657 static int iwl_mvm_tzone_get_trip_type(struct thermal_zone_device *device, 658 int trip, enum thermal_trip_type *type) 659 { 660 if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS) 661 return -EINVAL; 662 663 *type = THERMAL_TRIP_PASSIVE; 664 665 return 0; 666 } 667 668 static int iwl_mvm_tzone_set_trip_temp(struct thermal_zone_device *device, 669 int trip, int temp) 670 { 671 struct iwl_mvm *mvm = (struct iwl_mvm *)device->devdata; 672 struct iwl_mvm_thermal_device *tzone; 673 int i, ret; 674 s16 temperature; 675 676 mutex_lock(&mvm->mutex); 677 678 if (!iwl_mvm_firmware_running(mvm) || 679 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) { 680 ret = -EIO; 681 goto out; 682 } 683 684 if (trip < 0 || trip >= IWL_MAX_DTS_TRIPS) { 685 ret = -EINVAL; 686 goto out; 687 } 688 689 if ((temp / 1000) > S16_MAX) { 690 ret = -EINVAL; 691 goto out; 692 } 693 694 temperature = (s16)(temp / 1000); 695 tzone = &mvm->tz_device; 696 697 if (!tzone) { 698 ret = -EIO; 699 goto out; 700 } 701 702 /* no updates*/ 703 if (tzone->temp_trips[trip] == temperature) { 704 ret = 0; 705 goto out; 706 } 707 708 /* already existing temperature */ 709 for (i = 0; i < IWL_MAX_DTS_TRIPS; i++) { 710 if (tzone->temp_trips[i] == temperature) { 711 ret = -EINVAL; 712 goto out; 713 } 714 } 715 716 tzone->temp_trips[trip] = temperature; 717 718 ret = iwl_mvm_send_temp_report_ths_cmd(mvm); 719 out: 720 mutex_unlock(&mvm->mutex); 721 return ret; 722 } 723 724 static struct thermal_zone_device_ops tzone_ops = { 725 .get_temp = iwl_mvm_tzone_get_temp, 726 .get_trip_temp = iwl_mvm_tzone_get_trip_temp, 727 .get_trip_type = iwl_mvm_tzone_get_trip_type, 728 .set_trip_temp = iwl_mvm_tzone_set_trip_temp, 729 }; 730 731 /* make all trips writable */ 732 #define IWL_WRITABLE_TRIPS_MSK (BIT(IWL_MAX_DTS_TRIPS) - 1) 733 734 static void iwl_mvm_thermal_zone_register(struct iwl_mvm *mvm) 735 { 736 int i; 737 char name[16]; 738 static atomic_t counter = ATOMIC_INIT(0); 739 740 if (!iwl_mvm_is_tt_in_fw(mvm)) { 741 mvm->tz_device.tzone = NULL; 742 743 return; 744 } 745 746 BUILD_BUG_ON(ARRAY_SIZE(name) >= THERMAL_NAME_LENGTH); 747 748 sprintf(name, "iwlwifi_%u", atomic_inc_return(&counter) & 0xFF); 749 mvm->tz_device.tzone = thermal_zone_device_register(name, 750 IWL_MAX_DTS_TRIPS, 751 IWL_WRITABLE_TRIPS_MSK, 752 mvm, &tzone_ops, 753 NULL, 0, 0); 754 if (IS_ERR(mvm->tz_device.tzone)) { 755 IWL_DEBUG_TEMP(mvm, 756 "Failed to register to thermal zone (err = %ld)\n", 757 PTR_ERR(mvm->tz_device.tzone)); 758 mvm->tz_device.tzone = NULL; 759 return; 760 } 761 762 /* 0 is a valid temperature, 763 * so initialize the array with S16_MIN which invalid temperature 764 */ 765 for (i = 0 ; i < IWL_MAX_DTS_TRIPS; i++) 766 mvm->tz_device.temp_trips[i] = S16_MIN; 767 } 768 769 static int iwl_mvm_tcool_get_max_state(struct thermal_cooling_device *cdev, 770 unsigned long *state) 771 { 772 *state = ARRAY_SIZE(iwl_mvm_cdev_budgets) - 1; 773 774 return 0; 775 } 776 777 static int iwl_mvm_tcool_get_cur_state(struct thermal_cooling_device *cdev, 778 unsigned long *state) 779 { 780 struct iwl_mvm *mvm = (struct iwl_mvm *)(cdev->devdata); 781 782 *state = mvm->cooling_dev.cur_state; 783 784 return 0; 785 } 786 787 static int iwl_mvm_tcool_set_cur_state(struct thermal_cooling_device *cdev, 788 unsigned long new_state) 789 { 790 struct iwl_mvm *mvm = (struct iwl_mvm *)(cdev->devdata); 791 int ret; 792 793 mutex_lock(&mvm->mutex); 794 795 if (!iwl_mvm_firmware_running(mvm) || 796 mvm->fwrt.cur_fw_img != IWL_UCODE_REGULAR) { 797 ret = -EIO; 798 goto unlock; 799 } 800 801 if (new_state >= ARRAY_SIZE(iwl_mvm_cdev_budgets)) { 802 ret = -EINVAL; 803 goto unlock; 804 } 805 806 ret = iwl_mvm_ctdp_command(mvm, CTDP_CMD_OPERATION_START, 807 new_state); 808 809 unlock: 810 mutex_unlock(&mvm->mutex); 811 return ret; 812 } 813 814 static const struct thermal_cooling_device_ops tcooling_ops = { 815 .get_max_state = iwl_mvm_tcool_get_max_state, 816 .get_cur_state = iwl_mvm_tcool_get_cur_state, 817 .set_cur_state = iwl_mvm_tcool_set_cur_state, 818 }; 819 820 static void iwl_mvm_cooling_device_register(struct iwl_mvm *mvm) 821 { 822 char name[] = "iwlwifi"; 823 824 if (!iwl_mvm_is_ctdp_supported(mvm)) 825 return; 826 827 BUILD_BUG_ON(ARRAY_SIZE(name) >= THERMAL_NAME_LENGTH); 828 829 mvm->cooling_dev.cdev = 830 thermal_cooling_device_register(name, 831 mvm, 832 &tcooling_ops); 833 834 if (IS_ERR(mvm->cooling_dev.cdev)) { 835 IWL_DEBUG_TEMP(mvm, 836 "Failed to register to cooling device (err = %ld)\n", 837 PTR_ERR(mvm->cooling_dev.cdev)); 838 mvm->cooling_dev.cdev = NULL; 839 return; 840 } 841 } 842 843 static void iwl_mvm_thermal_zone_unregister(struct iwl_mvm *mvm) 844 { 845 if (!iwl_mvm_is_tt_in_fw(mvm) || !mvm->tz_device.tzone) 846 return; 847 848 IWL_DEBUG_TEMP(mvm, "Thermal zone device unregister\n"); 849 if (mvm->tz_device.tzone) { 850 thermal_zone_device_unregister(mvm->tz_device.tzone); 851 mvm->tz_device.tzone = NULL; 852 } 853 } 854 855 static void iwl_mvm_cooling_device_unregister(struct iwl_mvm *mvm) 856 { 857 if (!iwl_mvm_is_ctdp_supported(mvm) || !mvm->cooling_dev.cdev) 858 return; 859 860 IWL_DEBUG_TEMP(mvm, "Cooling device unregister\n"); 861 if (mvm->cooling_dev.cdev) { 862 thermal_cooling_device_unregister(mvm->cooling_dev.cdev); 863 mvm->cooling_dev.cdev = NULL; 864 } 865 } 866 #endif /* CONFIG_THERMAL */ 867 868 void iwl_mvm_thermal_initialize(struct iwl_mvm *mvm, u32 min_backoff) 869 { 870 struct iwl_mvm_tt_mgmt *tt = &mvm->thermal_throttle; 871 872 IWL_DEBUG_TEMP(mvm, "Initialize Thermal Throttling\n"); 873 874 if (mvm->cfg->thermal_params) 875 tt->params = *mvm->cfg->thermal_params; 876 else 877 tt->params = iwl_mvm_default_tt_params; 878 879 tt->throttle = false; 880 tt->dynamic_smps = false; 881 tt->min_backoff = min_backoff; 882 INIT_DELAYED_WORK(&tt->ct_kill_exit, check_exit_ctkill); 883 884 #ifdef CONFIG_THERMAL 885 iwl_mvm_cooling_device_register(mvm); 886 iwl_mvm_thermal_zone_register(mvm); 887 #endif 888 mvm->init_status |= IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE; 889 } 890 891 void iwl_mvm_thermal_exit(struct iwl_mvm *mvm) 892 { 893 if (!(mvm->init_status & IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE)) 894 return; 895 896 cancel_delayed_work_sync(&mvm->thermal_throttle.ct_kill_exit); 897 IWL_DEBUG_TEMP(mvm, "Exit Thermal Throttling\n"); 898 899 #ifdef CONFIG_THERMAL 900 iwl_mvm_cooling_device_unregister(mvm); 901 iwl_mvm_thermal_zone_unregister(mvm); 902 #endif 903 mvm->init_status &= ~IWL_MVM_INIT_STATUS_THERMAL_INIT_COMPLETE; 904 } 905