drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.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) 2018 - 2019 Intel Corporation
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of version 2 of the GNU General Public License as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.
  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) 2018 - 2019 Intel Corporation
  32  * All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions
  36  * are met:
  37  *
  38  *  * Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  *  * Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in
  42  *    the documentation and/or other materials provided with the
  43  *    distribution.
  44  *  * Neither the name Intel Corporation nor the names of its
  45  *    contributors may be used to endorse or promote products derived
  46  *    from this software without specific prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  49  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  50  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  51  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  52  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  53  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  54  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  55  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  56  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  57  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  58  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  59  *
  60  *****************************************************************************/
  61
  62 #include <linux/firmware.h>
  63 #include "iwl-trans.h"
  64 #include "iwl-dbg-tlv.h"
  65
  66 void iwl_fw_dbg_copy_tlv(struct iwl_trans *trans, struct iwl_ucode_tlv *tlv,
  67                          bool ext)
  68 {
  69         struct iwl_apply_point_data *data;
  70         struct iwl_fw_ini_header *header = (void *)&tlv->data[0];
  71         u32 apply_point = le32_to_cpu(header->apply_point);
  72
  73         int copy_size = le32_to_cpu(tlv->length) + sizeof(*tlv);
  74         int offset_size = copy_size;
  75
  76         if (le32_to_cpu(header->tlv_version) != 1)
  77                 return;
  78
  79         if (WARN_ONCE(apply_point >= IWL_FW_INI_APPLY_NUM,
  80                       "Invalid apply point id %d\n", apply_point))
  81                 return;
  82
  83         if (ext)
  84                 data = &trans->dbg.apply_points_ext[apply_point];
  85         else
  86                 data = &trans->dbg.apply_points[apply_point];
  87
  88         /* add room for is_alloc field in &iwl_fw_ini_allocation_data struct */
  89         if (le32_to_cpu(tlv->type) == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
  90                 struct iwl_fw_ini_allocation_data *buf_alloc =
  91                         (void *)tlv->data;
  92
  93                 offset_size += sizeof(buf_alloc->is_alloc);
  94         }
  95
  96         /*
  97          * Make sure we still have room to copy this TLV. Offset points to the
  98          * location the last copy ended.
  99          */
 100         if (WARN_ONCE(data->offset + offset_size > data->size,
 101                       "Not enough memory for apply point %d\n",
 102                       apply_point))
 103                 return;
 104
 105         memcpy(data->data + data->offset, (void *)tlv, copy_size);
 106         data->offset += offset_size;
 107 }
 108
 109 void iwl_alloc_dbg_tlv(struct iwl_trans *trans, size_t len, const u8 *data,
 110                        bool ext)
 111 {
 112         struct iwl_ucode_tlv *tlv;
 113         u32 size[IWL_FW_INI_APPLY_NUM] = {0};
 114         int i;
 115
 116         while (len >= sizeof(*tlv)) {
 117                 u32 tlv_len, tlv_type, apply;
 118                 struct iwl_fw_ini_header *hdr;
 119
 120                 len -= sizeof(*tlv);
 121                 tlv = (void *)data;
 122
 123                 tlv_len = le32_to_cpu(tlv->length);
 124                 tlv_type = le32_to_cpu(tlv->type);
 125
 126                 if (len < tlv_len)
 127                         return;
 128
 129                 len -= ALIGN(tlv_len, 4);
 130                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 131
 132                 if (tlv_type < IWL_UCODE_TLV_DEBUG_BASE ||
 133                     tlv_type > IWL_UCODE_TLV_DEBUG_MAX)
 134                         continue;
 135
 136                 hdr = (void *)&tlv->data[0];
 137                 apply = le32_to_cpu(hdr->apply_point);
 138
 139                 if (le32_to_cpu(hdr->tlv_version) != 1)
 140                         continue;
 141
 142                 IWL_DEBUG_FW(trans, "WRT: read TLV 0x%x, apply point %d\n",
 143                              le32_to_cpu(tlv->type), apply);
 144
 145                 if (WARN_ON(apply >= IWL_FW_INI_APPLY_NUM))
 146                         continue;
 147
 148                 /* add room for is_alloc field in &iwl_fw_ini_allocation_data
 149                  * struct
 150                  */
 151                 if (tlv_type == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
 152                         struct iwl_fw_ini_allocation_data *buf_alloc =
 153                                 (void *)tlv->data;
 154
 155                         size[apply] += sizeof(buf_alloc->is_alloc);
 156                 }
 157
 158                 size[apply] += sizeof(*tlv) + tlv_len;
 159         }
 160
 161         for (i = 0; i < ARRAY_SIZE(size); i++) {
 162                 void *mem;
 163
 164                 if (!size[i])
 165                         continue;
 166
 167                 mem = kzalloc(size[i], GFP_KERNEL);
 168
 169                 if (!mem) {
 170                         IWL_ERR(trans, "No memory for apply point %d\n", i);
 171                         return;
 172                 }
 173
 174                 if (ext) {
 175                         trans->dbg.apply_points_ext[i].data = mem;
 176                         trans->dbg.apply_points_ext[i].size = size[i];
 177                 } else {
 178                         trans->dbg.apply_points[i].data = mem;
 179                         trans->dbg.apply_points[i].size = size[i];
 180                 }
 181
 182                 trans->dbg.ini_valid = true;
 183         }
 184 }
 185
 186 void iwl_fw_dbg_free(struct iwl_trans *trans)
 187 {
 188         int i;
 189
 190         for (i = 0; i < ARRAY_SIZE(trans->dbg.apply_points); i++) {
 191                 kfree(trans->dbg.apply_points[i].data);
 192                 trans->dbg.apply_points[i].size = 0;
 193                 trans->dbg.apply_points[i].offset = 0;
 194
 195                 kfree(trans->dbg.apply_points_ext[i].data);
 196                 trans->dbg.apply_points_ext[i].size = 0;
 197                 trans->dbg.apply_points_ext[i].offset = 0;
 198         }
 199 }
 200
 201 static int iwl_parse_fw_dbg_tlv(struct iwl_trans *trans, const u8 *data,
 202                                 size_t len)
 203 {
 204         struct iwl_ucode_tlv *tlv;
 205         enum iwl_ucode_tlv_type tlv_type;
 206         u32 tlv_len;
 207
 208         while (len >= sizeof(*tlv)) {
 209                 len -= sizeof(*tlv);
 210                 tlv = (void *)data;
 211
 212                 tlv_len = le32_to_cpu(tlv->length);
 213                 tlv_type = le32_to_cpu(tlv->type);
 214
 215                 if (len < tlv_len) {
 216                         IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
 217                                 len, tlv_len);
 218                         return -EINVAL;
 219                 }
 220                 len -= ALIGN(tlv_len, 4);
 221                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 222
 223                 switch (tlv_type) {
 224                 case IWL_UCODE_TLV_TYPE_DEBUG_INFO:
 225                 case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
 226                 case IWL_UCODE_TLV_TYPE_HCMD:
 227                 case IWL_UCODE_TLV_TYPE_REGIONS:
 228                 case IWL_UCODE_TLV_TYPE_TRIGGERS:
 229                 case IWL_UCODE_TLV_TYPE_DEBUG_FLOW:
 230                         iwl_fw_dbg_copy_tlv(trans, tlv, true);
 231                         break;
 232                 default:
 233                         WARN_ONCE(1, "Invalid TLV %x\n", tlv_type);
 234                         break;
 235                 }
 236         }
 237
 238         return 0;
 239 }
 240
 241 void iwl_load_fw_dbg_tlv(struct device *dev, struct iwl_trans *trans)
 242 {
 243         const struct firmware *fw;
 244         int res;
 245
 246         if (trans->dbg.external_ini_loaded || !iwlwifi_mod_params.enable_ini)
 247                 return;
 248
 249         res = request_firmware(&fw, "iwl-dbg-tlv.ini", dev);
 250         if (res)
 251                 return;
 252
 253         iwl_alloc_dbg_tlv(trans, fw->size, fw->data, true);
 254         iwl_parse_fw_dbg_tlv(trans, fw->data, fw->size);
 255
 256         trans->dbg.external_ini_loaded = true;
 257         release_firmware(fw);
 258 }