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 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 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 (WARN_ONCE(apply_point >= IWL_FW_INI_APPLY_NUM,
  77                       "Invalid apply point id %d\n", apply_point))
  78                 return;
  79
  80         if (ext)
  81                 data = &trans->apply_points_ext[apply_point];
  82         else
  83                 data = &trans->apply_points[apply_point];
  84
  85         /* add room for is_alloc field in &iwl_fw_ini_allocation_data struct */
  86         if (le32_to_cpu(tlv->type) == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
  87                 struct iwl_fw_ini_allocation_data *buf_alloc =
  88                         (void *)tlv->data;
  89
  90                 offset_size += sizeof(buf_alloc->is_alloc);
  91         }
  92
  93         /*
  94          * Make sure we still have room to copy this TLV. Offset points to the
  95          * location the last copy ended.
  96          */
  97         if (WARN_ONCE(data->offset + offset_size > data->size,
  98                       "Not enough memory for apply point %d\n",
  99                       apply_point))
 100                 return;
 101
 102         memcpy(data->data + data->offset, (void *)tlv, copy_size);
 103         data->offset += offset_size;
 104 }
 105
 106 void iwl_alloc_dbg_tlv(struct iwl_trans *trans, size_t len, const u8 *data,
 107                        bool ext)
 108 {
 109         struct iwl_ucode_tlv *tlv;
 110         u32 size[IWL_FW_INI_APPLY_NUM] = {0};
 111         int i;
 112
 113         while (len >= sizeof(*tlv)) {
 114                 u32 tlv_len, tlv_type, apply;
 115                 struct iwl_fw_ini_header *hdr;
 116
 117                 len -= sizeof(*tlv);
 118                 tlv = (void *)data;
 119
 120                 tlv_len = le32_to_cpu(tlv->length);
 121                 tlv_type = le32_to_cpu(tlv->type);
 122
 123                 if (len < tlv_len)
 124                         return;
 125
 126                 len -= ALIGN(tlv_len, 4);
 127                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 128
 129                 if (tlv_type < IWL_UCODE_TLV_DEBUG_BASE ||
 130                     tlv_type > IWL_UCODE_TLV_DEBUG_MAX)
 131                         continue;
 132
 133                 hdr = (void *)&tlv->data[0];
 134                 apply = le32_to_cpu(hdr->apply_point);
 135
 136                 IWL_DEBUG_FW(trans, "Read TLV %x, apply point %d\n",
 137                              le32_to_cpu(tlv->type), apply);
 138
 139                 if (WARN_ON(apply >= IWL_FW_INI_APPLY_NUM))
 140                         continue;
 141
 142                 /* add room for is_alloc field in &iwl_fw_ini_allocation_data
 143                  * struct
 144                  */
 145                 if (tlv_type == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
 146                         struct iwl_fw_ini_allocation_data *buf_alloc =
 147                                 (void *)tlv->data;
 148
 149                         size[apply] += sizeof(buf_alloc->is_alloc);
 150                 }
 151
 152                 size[apply] += sizeof(*tlv) + tlv_len;
 153         }
 154
 155         for (i = 0; i < ARRAY_SIZE(size); i++) {
 156                 void *mem;
 157
 158                 if (!size[i])
 159                         continue;
 160
 161                 mem = kzalloc(size[i], GFP_KERNEL);
 162
 163                 if (!mem) {
 164                         IWL_ERR(trans, "No memory for apply point %d\n", i);
 165                         return;
 166                 }
 167
 168                 if (ext) {
 169                         trans->apply_points_ext[i].data = mem;
 170                         trans->apply_points_ext[i].size = size[i];
 171                 } else {
 172                         trans->apply_points[i].data = mem;
 173                         trans->apply_points[i].size = size[i];
 174                 }
 175
 176                 trans->ini_valid = true;
 177         }
 178 }
 179
 180 void iwl_fw_dbg_free(struct iwl_trans *trans)
 181 {
 182         int i;
 183
 184         for (i = 0; i < ARRAY_SIZE(trans->apply_points); i++) {
 185                 kfree(trans->apply_points[i].data);
 186                 trans->apply_points[i].size = 0;
 187                 trans->apply_points[i].offset = 0;
 188
 189                 kfree(trans->apply_points_ext[i].data);
 190                 trans->apply_points_ext[i].size = 0;
 191                 trans->apply_points_ext[i].offset = 0;
 192         }
 193 }
 194
 195 static int iwl_parse_fw_dbg_tlv(struct iwl_trans *trans, const u8 *data,
 196                                 size_t len)
 197 {
 198         struct iwl_ucode_tlv *tlv;
 199         enum iwl_ucode_tlv_type tlv_type;
 200         u32 tlv_len;
 201
 202         while (len >= sizeof(*tlv)) {
 203                 len -= sizeof(*tlv);
 204                 tlv = (void *)data;
 205
 206                 tlv_len = le32_to_cpu(tlv->length);
 207                 tlv_type = le32_to_cpu(tlv->type);
 208
 209                 if (len < tlv_len) {
 210                         IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
 211                                 len, tlv_len);
 212                         return -EINVAL;
 213                 }
 214                 len -= ALIGN(tlv_len, 4);
 215                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 216
 217                 switch (tlv_type) {
 218                 case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
 219                 case IWL_UCODE_TLV_TYPE_HCMD:
 220                 case IWL_UCODE_TLV_TYPE_REGIONS:
 221                 case IWL_UCODE_TLV_TYPE_TRIGGERS:
 222                 case IWL_UCODE_TLV_TYPE_DEBUG_FLOW:
 223                         iwl_fw_dbg_copy_tlv(trans, tlv, true);
 224                         break;
 225                 default:
 226                         WARN_ONCE(1, "Invalid TLV %x\n", tlv_type);
 227                         break;
 228                 }
 229         }
 230
 231         return 0;
 232 }
 233
 234 void iwl_load_fw_dbg_tlv(struct device *dev, struct iwl_trans *trans)
 235 {
 236         const struct firmware *fw;
 237         int res;
 238
 239         if (trans->external_ini_loaded || !iwlwifi_mod_params.enable_ini)
 240                 return;
 241
 242         res = request_firmware(&fw, "iwl-dbg-tlv.ini", dev);
 243         if (res)
 244                 return;
 245
 246         iwl_alloc_dbg_tlv(trans, fw->size, fw->data, true);
 247         iwl_parse_fw_dbg_tlv(trans, fw->data, fw->size);
 248
 249         trans->external_ini_loaded = true;
 250         release_firmware(fw);
 251 }