drivers/net/wireless/intel/iwlwifi/mvm/tt.c

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