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