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_INI_TLV_GROUP))
 130                         continue;
 131
 132                 hdr = (void *)&tlv->data[0];
 133                 apply = le32_to_cpu(hdr->apply_point);
 134
 135                 IWL_DEBUG_FW(trans, "Read TLV %x, apply point %d\n",
 136                              le32_to_cpu(tlv->type), apply);
 137
 138                 if (WARN_ON(apply >= IWL_FW_INI_APPLY_NUM))
 139                         continue;
 140
 141                 /* add room for is_alloc field in &iwl_fw_ini_allocation_data
 142                  * struct
 143                  */
 144                 if (tlv_type == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
 145                         struct iwl_fw_ini_allocation_data *buf_alloc =
 146                                 (void *)tlv->data;
 147
 148                         size[apply] += sizeof(buf_alloc->is_alloc);
 149                 }
 150
 151                 size[apply] += sizeof(*tlv) + tlv_len;
 152         }
 153
 154         for (i = 0; i < ARRAY_SIZE(size); i++) {
 155                 void *mem;
 156
 157                 if (!size[i])
 158                         continue;
 159
 160                 mem = kzalloc(size[i], GFP_KERNEL);
 161
 162                 if (!mem) {
 163                         IWL_ERR(trans, "No memory for apply point %d\n", i);
 164                         return;
 165                 }
 166
 167                 if (ext) {
 168                         trans->apply_points_ext[i].data = mem;
 169                         trans->apply_points_ext[i].size = size[i];
 170                 } else {
 171                         trans->apply_points[i].data = mem;
 172                         trans->apply_points[i].size = size[i];
 173                 }
 174
 175                 trans->ini_valid = true;
 176         }
 177 }
 178
 179 void iwl_fw_dbg_free(struct iwl_trans *trans)
 180 {
 181         int i;
 182
 183         for (i = 0; i < ARRAY_SIZE(trans->apply_points); i++) {
 184                 kfree(trans->apply_points[i].data);
 185                 trans->apply_points[i].size = 0;
 186                 trans->apply_points[i].offset = 0;
 187
 188                 kfree(trans->apply_points_ext[i].data);
 189                 trans->apply_points_ext[i].size = 0;
 190                 trans->apply_points_ext[i].offset = 0;
 191         }
 192 }
 193
 194 static int iwl_parse_fw_dbg_tlv(struct iwl_trans *trans, const u8 *data,
 195                                 size_t len)
 196 {
 197         struct iwl_ucode_tlv *tlv;
 198         enum iwl_ucode_tlv_type tlv_type;
 199         u32 tlv_len;
 200
 201         while (len >= sizeof(*tlv)) {
 202                 len -= sizeof(*tlv);
 203                 tlv = (void *)data;
 204
 205                 tlv_len = le32_to_cpu(tlv->length);
 206                 tlv_type = le32_to_cpu(tlv->type);
 207
 208                 if (len < tlv_len) {
 209                         IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
 210                                 len, tlv_len);
 211                         return -EINVAL;
 212                 }
 213                 len -= ALIGN(tlv_len, 4);
 214                 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
 215
 216                 switch (tlv_type) {
 217                 case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
 218                 case IWL_UCODE_TLV_TYPE_HCMD:
 219                 case IWL_UCODE_TLV_TYPE_REGIONS:
 220                 case IWL_UCODE_TLV_TYPE_TRIGGERS:
 221                 case IWL_UCODE_TLV_TYPE_DEBUG_FLOW:
 222                         iwl_fw_dbg_copy_tlv(trans, tlv, true);
 223                         break;
 224                 default:
 225                         WARN_ONCE(1, "Invalid TLV %x\n", tlv_type);
 226                         break;
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 void iwl_load_fw_dbg_tlv(struct device *dev, struct iwl_trans *trans)
 234 {
 235         const struct firmware *fw;
 236         int res;
 237
 238         if (trans->external_ini_loaded || !iwlwifi_mod_params.enable_ini)
 239                 return;
 240
 241         res = request_firmware(&fw, "iwl-dbg-tlv.ini", dev);
 242         if (res)
 243                 return;
 244
 245         iwl_alloc_dbg_tlv(trans, fw->size, fw->data, true);
 246         iwl_parse_fw_dbg_tlv(trans, fw->data, fw->size);
 247
 248         trans->external_ini_loaded = true;
 249         release_firmware(fw);
 250 }