diff --git a/drivers/net/wireless/intel/iwlwifi/fw/pnvm.c b/drivers/net/wireless/intel/iwlwifi/fw/pnvm.c
index 2cd07d2690e0..267a1efd2364 100644
--- a/drivers/net/wireless/intel/iwlwifi/fw/pnvm.c
+++ b/drivers/net/wireless/intel/iwlwifi/fw/pnvm.c
@@ -33,132 +33,132 @@ static bool iwl_pnvm_complete_fn(struct iwl_notif_wait_data *notif_wait,
  static int iwl_pnvm_handle_section(struct iwl_trans *trans, const u8 *data,
  				   size_t len)
  {
-	struct iwl_ucode_tlv *tlv;
+	const struct iwl_ucode_tlv *tlv;
  	u32 sha1 = 0;
  	u16 mac_type = 0, rf_id = 0;
  	u8 *pnvm_data = NULL, *tmp;
  	u32 size = 0;
  	int ret;

  	IWL_DEBUG_FW(trans, "Handling PNVM section\n");

  	while (len >= sizeof(*tlv)) {
  		u32 tlv_len, tlv_type;

  		len -= sizeof(*tlv);
-		tlv = (void *)data;
+		tlv = (const void *)data;

  		tlv_len = le32_to_cpu(tlv->length);
  		tlv_type = le32_to_cpu(tlv->type);

  		if (len < tlv_len) {
  			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
  				len, tlv_len);
  			ret = -EINVAL;
  			goto out;
  		}

  		data += sizeof(*tlv);

  		switch (tlv_type) {
  		case IWL_UCODE_TLV_PNVM_VERSION:
  			if (tlv_len < sizeof(__le32)) {
  				IWL_DEBUG_FW(trans,
  					     "Invalid size for IWL_UCODE_TLV_PNVM_VERSION (expected %zd, got %d)\n",
  					     sizeof(__le32), tlv_len);
  				break;
  			}

-			sha1 = le32_to_cpup((__le32 *)data);
+			sha1 = le32_to_cpup((const __le32 *)data);

  			IWL_DEBUG_FW(trans,
  				     "Got IWL_UCODE_TLV_PNVM_VERSION %0x\n",
  				     sha1);
  			break;
  		case IWL_UCODE_TLV_HW_TYPE:
  			if (tlv_len < 2 * sizeof(__le16)) {
  				IWL_DEBUG_FW(trans,
  					     "Invalid size for IWL_UCODE_TLV_HW_TYPE (expected %zd, got %d)\n",
  					     2 * sizeof(__le16), tlv_len);
  				break;
  			}

-			mac_type = le16_to_cpup((__le16 *)data);
-			rf_id = le16_to_cpup((__le16 *)(data + sizeof(__le16)));
+			mac_type = le16_to_cpup((const __le16 *)data);
+			rf_id = le16_to_cpup((const __le16 *)(data + sizeof(__le16)));

  			IWL_DEBUG_FW(trans,
  				     "Got IWL_UCODE_TLV_HW_TYPE mac_type 0x%0x rf_id 0x%0x\n",
  				     mac_type, rf_id);

  			if (mac_type != CSR_HW_REV_TYPE(trans->hw_rev) ||
  			    rf_id != CSR_HW_RFID_TYPE(trans->hw_rf_id)) {
  				IWL_DEBUG_FW(trans,
  					     "HW mismatch, skipping PNVM section, mac_type 0x%0x, rf_id 0x%0x.\n",
  					     CSR_HW_REV_TYPE(trans->hw_rev), trans->hw_rf_id);
  				ret = -ENOENT;
  				goto out;
  			}

  			break;
  		case IWL_UCODE_TLV_SEC_RT: {
-			struct iwl_pnvm_section *section = (void *)data;
+			const struct iwl_pnvm_section *section = (const void *)data;
  			u32 data_len = tlv_len - sizeof(*section);

  			IWL_DEBUG_FW(trans,
  				     "Got IWL_UCODE_TLV_SEC_RT len %d\n",
  				     tlv_len);

  			/* TODO: remove, this is a deprecated separator */
-			if (le32_to_cpup((__le32 *)data) == 0xddddeeee) {
+			if (le32_to_cpup((const __le32 *)data) == 0xddddeeee) {
  				IWL_DEBUG_FW(trans, "Ignoring separator.\n");
  				break;
  			}

  			IWL_DEBUG_FW(trans, "Adding data (size %d)\n",
  				     data_len);

  			tmp = krealloc(pnvm_data, size + data_len, GFP_KERNEL);
  			if (!tmp) {
  				IWL_DEBUG_FW(trans,
  					     "Couldn't allocate (more) pnvm_data\n");

  				ret = -ENOMEM;
  				goto out;
  			}

  			pnvm_data = tmp;

  			memcpy(pnvm_data + size, section->data, data_len);

  			size += data_len;

  			break;
  		}
  		case IWL_UCODE_TLV_PNVM_SKU:
  			IWL_DEBUG_FW(trans,
  				     "New PNVM section started, stop parsing.\n");
  			goto done;
  		default:
  			IWL_DEBUG_FW(trans, "Found TLV 0x%0x, len %d\n",
  				     tlv_type, tlv_len);
  			break;
  		}

  		len -= ALIGN(tlv_len, 4);
  		data += ALIGN(tlv_len, 4);
  	}

  done:
  	if (!size) {
  		IWL_DEBUG_FW(trans, "Empty PNVM, skipping.\n");
  		ret = -ENOENT;
  		goto out;
  	}

  	IWL_INFO(trans, "loaded PNVM version 0x%0x\n", sha1);

  	ret = iwl_trans_set_pnvm(trans, pnvm_data, size);
  out:
  	kfree(pnvm_data);
  	return ret;
  }
@@ -166,71 +166,71 @@ static int iwl_pnvm_handle_section(struct iwl_trans *trans, const u8 *data,
  static int iwl_pnvm_parse(struct iwl_trans *trans, const u8 *data,
  			  size_t len)
  {
-	struct iwl_ucode_tlv *tlv;
+	const struct iwl_ucode_tlv *tlv;

  	IWL_DEBUG_FW(trans, "Parsing PNVM file\n");

  	while (len >= sizeof(*tlv)) {
  		u32 tlv_len, tlv_type;

  		len -= sizeof(*tlv);
-		tlv = (void *)data;
+		tlv = (const void *)data;

  		tlv_len = le32_to_cpu(tlv->length);
  		tlv_type = le32_to_cpu(tlv->type);

  		if (len < tlv_len) {
  			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
  				len, tlv_len);
  			return -EINVAL;
  		}

  		if (tlv_type == IWL_UCODE_TLV_PNVM_SKU) {
-			struct iwl_sku_id *sku_id =
-				(void *)(data + sizeof(*tlv));
+			const struct iwl_sku_id *sku_id =
+				(const void *)(data + sizeof(*tlv));

  			IWL_DEBUG_FW(trans,
  				     "Got IWL_UCODE_TLV_PNVM_SKU len %d\n",
  				     tlv_len);
  			IWL_DEBUG_FW(trans, "sku_id 0x%0x 0x%0x 0x%0x\n",
  				     le32_to_cpu(sku_id->data[0]),
  				     le32_to_cpu(sku_id->data[1]),
  				     le32_to_cpu(sku_id->data[2]));

  			data += sizeof(*tlv) + ALIGN(tlv_len, 4);
  			len -= ALIGN(tlv_len, 4);

  			if (trans->sku_id[0] == le32_to_cpu(sku_id->data[0]) &&
  			    trans->sku_id[1] == le32_to_cpu(sku_id->data[1]) &&
  			    trans->sku_id[2] == le32_to_cpu(sku_id->data[2])) {
  				int ret;

  				ret = iwl_pnvm_handle_section(trans, data, len);
  				if (!ret)
  					return 0;
  			} else {
  				IWL_DEBUG_FW(trans, "SKU ID didn't match!\n");
  			}
  		} else {
  			data += sizeof(*tlv) + ALIGN(tlv_len, 4);
  			len -= ALIGN(tlv_len, 4);
  		}
  	}

  	return -ENOENT;
  }

  /*
   * This is known to be broken on v4.19 and to work on v5.4.  Until we
   * figure out why this is the case and how to make it work, simply
   * disable the feature in old kernels.
   */
  #if defined(CONFIG_EFI)

  #define IWL_EFI_VAR_GUID EFI_GUID(0x92daaf2f, 0xc02b, 0x455b,	\
  				  0xb2, 0xec, 0xf5, 0xa3,	\
  				  0x59, 0x4f, 0x4a, 0xea)

  #define IWL_UEFI_OEM_PNVM_NAME	L"UefiCnvWlanOemSignedPnvm"

  #define IWL_HARDCODED_PNVM_SIZE 4096
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c b/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
index 579bc81cc0ae..187de7262f09 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c
@@ -398,25 +398,25 @@ void iwl_dbg_tlv_free(struct iwl_trans *trans)
  static int iwl_dbg_tlv_parse_bin(struct iwl_trans *trans, const u8 *data,
  				 size_t len)
  {
  	const struct iwl_ucode_tlv *tlv;
  	u32 tlv_len;

  	while (len >= sizeof(*tlv)) {
  		len -= sizeof(*tlv);
-		tlv = (void *)data;
+		tlv = (const void *)data;

  		tlv_len = le32_to_cpu(tlv->length);

  		if (len < tlv_len) {
  			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
  				len, tlv_len);
  			return -EINVAL;
  		}
  		len -= ALIGN(tlv_len, 4);
  		data += sizeof(*tlv) + ALIGN(tlv_len, 4);

  		iwl_dbg_tlv_alloc(trans, tlv, true);
  	}

  	return 0;
  }
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-drv.c b/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
index eb168dc535d4..79939f257c65 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
@@ -236,25 +236,25 @@ struct iwl_tlv_calib_data {
  struct iwl_firmware_pieces {
  	struct fw_img_parsing img[IWL_UCODE_TYPE_MAX];

  	u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
  	u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;

  	/* FW debug data parsed for driver usage */
  	bool dbg_dest_tlv_init;
-	u8 *dbg_dest_ver;
+	const u8 *dbg_dest_ver;
  	union {
-		struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
-		struct iwl_fw_dbg_dest_tlv_v1 *dbg_dest_tlv_v1;
+		const struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
+		const struct iwl_fw_dbg_dest_tlv_v1 *dbg_dest_tlv_v1;
  	};
-	struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX];
+	const struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX];
  	size_t dbg_conf_tlv_len[FW_DBG_CONF_MAX];
-	struct iwl_fw_dbg_trigger_tlv *dbg_trigger_tlv[FW_DBG_TRIGGER_MAX];
+	const struct iwl_fw_dbg_trigger_tlv *dbg_trigger_tlv[FW_DBG_TRIGGER_MAX];
  	size_t dbg_trigger_tlv_len[FW_DBG_TRIGGER_MAX];
  	struct iwl_fw_dbg_mem_seg_tlv *dbg_mem_tlv;
  	size_t n_mem_tlv;
  };

  /*
   * These functions are just to extract uCode section data from the pieces
   * structure.
   */
@@ -325,76 +325,77 @@ static void set_sec_offset(struct iwl_firmware_pieces *pieces,
  static int iwl_store_cscheme(struct iwl_fw *fw, const u8 *data, const u32 len)
  {
  	int i, j;
-	struct iwl_fw_cscheme_list *l = (struct iwl_fw_cscheme_list *)data;
-	struct iwl_fw_cipher_scheme *fwcs;
+	const struct iwl_fw_cscheme_list *l =
+		(const struct iwl_fw_cscheme_list *)data;
+	const struct iwl_fw_cipher_scheme *fwcs;

  	if (len < sizeof(*l) ||
  	    len < sizeof(l->size) + l->size * sizeof(l->cs[0]))
  		return -EINVAL;

  	for (i = 0, j = 0; i < IWL_UCODE_MAX_CS && i < l->size; i++) {
  		fwcs = &l->cs[j];

  		/* we skip schemes with zero cipher suite selector */
  		if (!fwcs->cipher)
  			continue;

  		fw->cs[j++] = *fwcs;
  	}

  	return 0;
  }

  /*
   * Gets uCode section from tlv.
   */
  static int iwl_store_ucode_sec(struct iwl_firmware_pieces *pieces,
  			       const void *data, enum iwl_ucode_type type,
  			       int size)
  {
  	struct fw_img_parsing *img;
  	struct fw_sec *sec;
-	struct fw_sec_parsing *sec_parse;
+	const struct fw_sec_parsing *sec_parse;
  	size_t alloc_size;

  	if (WARN_ON(!pieces || !data || type >= IWL_UCODE_TYPE_MAX))
  		return -1;

-	sec_parse = (struct fw_sec_parsing *)data;
+	sec_parse = (const struct fw_sec_parsing *)data;

  	img = &pieces->img[type];

  	alloc_size = sizeof(*img->sec) * (img->sec_counter + 1);
  	sec = krealloc(img->sec, alloc_size, GFP_KERNEL);
  	if (!sec)
  		return -ENOMEM;
  	img->sec = sec;

  	sec = &img->sec[img->sec_counter];

  	sec->offset = le32_to_cpu(sec_parse->offset);
  	sec->data = sec_parse->data;
  	sec->size = size - sizeof(sec_parse->offset);

  	++img->sec_counter;

  	return 0;
  }

  static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data)
  {
-	struct iwl_tlv_calib_data *def_calib =
-					(struct iwl_tlv_calib_data *)data;
+	const struct iwl_tlv_calib_data *def_calib =
+					(const struct iwl_tlv_calib_data *)data;
  	u32 ucode_type = le32_to_cpu(def_calib->ucode_type);
  	if (ucode_type >= IWL_UCODE_TYPE_MAX) {
  		IWL_ERR(drv, "Wrong ucode_type %u for default calibration.\n",
  			ucode_type);
  		return -EINVAL;
  	}
  	drv->fw.default_calib[ucode_type].flow_trigger =
  		def_calib->calib.flow_trigger;
  	drv->fw.default_calib[ucode_type].event_trigger =
  		def_calib->calib.event_trigger;

  	return 0;
  }
@@ -402,20 +403,20 @@ static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data)
  static void iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data,
  				    struct iwl_ucode_capabilities *capa)
  {
-	const struct iwl_ucode_api *ucode_api = (void *)data;
+	const struct iwl_ucode_api *ucode_api = (const void *)data;
  	u32 api_index = le32_to_cpu(ucode_api->api_index);
  	u32 api_flags = le32_to_cpu(ucode_api->api_flags);
  	int i;

  	if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_API, 32)) {
  		IWL_WARN(drv,
  			 "api flags index %d larger than supported by driver\n",
  			 api_index);
  		return;
  	}

  	for (i = 0; i < 32; i++) {
  		if (api_flags & BIT(i))
  			__set_bit(i + 32 * api_index, capa->_api);
  	}
  }
@@ -423,20 +424,20 @@ static void iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data,
  static void iwl_set_ucode_capabilities(struct iwl_drv *drv, const u8 *data,
  				       struct iwl_ucode_capabilities *capa)
  {
-	const struct iwl_ucode_capa *ucode_capa = (void *)data;
+	const struct iwl_ucode_capa *ucode_capa = (const void *)data;
  	u32 api_index = le32_to_cpu(ucode_capa->api_index);
  	u32 api_flags = le32_to_cpu(ucode_capa->api_capa);
  	int i;

  	if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_CAPA, 32)) {
  		IWL_WARN(drv,
  			 "capa flags index %d larger than supported by driver\n",
  			 api_index);
  		return;
  	}

  	for (i = 0; i < 32; i++) {
  		if (api_flags & BIT(i))
  			__set_bit(i + 32 * api_index, capa->_capa);
  	}
  }
@@ -454,100 +455,100 @@ static const char *iwl_reduced_fw_name(struct iwl_drv *drv)
  static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
  				    const struct firmware *ucode_raw,
  				    struct iwl_firmware_pieces *pieces)
  {
-	struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
+	const struct iwl_ucode_header *ucode = (const void *)ucode_raw->data;
  	u32 api_ver, hdr_size, build;
  	char buildstr[25];
  	const u8 *src;

  	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
  	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);

  	switch (api_ver) {
  	default:
  		hdr_size = 28;
  		if (ucode_raw->size < hdr_size) {
  			IWL_ERR(drv, "File size too small!\n");
  			return -EINVAL;
  		}
  		build = le32_to_cpu(ucode->u.v2.build);
  		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
  			     le32_to_cpu(ucode->u.v2.inst_size));
  		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
  			     le32_to_cpu(ucode->u.v2.data_size));
  		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
  			     le32_to_cpu(ucode->u.v2.init_size));
  		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
  			     le32_to_cpu(ucode->u.v2.init_data_size));
  		src = ucode->u.v2.data;
  		break;
  	case 0:
  	case 1:
  	case 2:
  		hdr_size = 24;
  		if (ucode_raw->size < hdr_size) {
  			IWL_ERR(drv, "File size too small!\n");
  			return -EINVAL;
  		}
  		build = 0;
  		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
  			     le32_to_cpu(ucode->u.v1.inst_size));
  		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
  			     le32_to_cpu(ucode->u.v1.data_size));
  		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
  			     le32_to_cpu(ucode->u.v1.init_size));
  		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
  			     le32_to_cpu(ucode->u.v1.init_data_size));
  		src = ucode->u.v1.data;
  		break;
  	}

  	if (build)
  		sprintf(buildstr, " build %u", build);
  	else
  		buildstr[0] = '\0';

  	snprintf(drv->fw.fw_version,
  		 sizeof(drv->fw.fw_version),
  		 "%u.%u.%u.%u%s %s",
  		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
  		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
  		 IWL_UCODE_API(drv->fw.ucode_ver),
  		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
  		 buildstr, iwl_reduced_fw_name(drv));

  	/* Verify size of file vs. image size info in file's header */

  	if (ucode_raw->size != hdr_size +
  	    get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) +
  	    get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) +
  	    get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) +
  	    get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)) {

  		IWL_ERR(drv,
  			"uCode file size %d does not match expected size\n",
  			(int)ucode_raw->size);
  		return -EINVAL;
  	}


  	set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, src);
  	src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST);
  	set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
  		       IWLAGN_RTC_INST_LOWER_BOUND);
  	set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, src);
  	src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA);
  	set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
  		       IWLAGN_RTC_DATA_LOWER_BOUND);
  	set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, src);
  	src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST);
  	set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
  		       IWLAGN_RTC_INST_LOWER_BOUND);
  	set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, src);
  	src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA);
  	set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
  		       IWLAGN_RTC_DATA_LOWER_BOUND);
  	return 0;
  }

  #define FW_ADDR_CACHE_CONTROL 0xC0000000
@@ -555,633 +556,634 @@ static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
  static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
  				const struct firmware *ucode_raw,
  				struct iwl_firmware_pieces *pieces,
  				struct iwl_ucode_capabilities *capa,
  				bool *usniffer_images)
  {
-	struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
+	const struct iwl_tlv_ucode_header *ucode = (const void *)ucode_raw->data;
  	const struct iwl_ucode_tlv *tlv;
  	size_t len = ucode_raw->size;
  	const u8 *data;
  	u32 tlv_len;
  	u32 usniffer_img;
  	enum iwl_ucode_tlv_type tlv_type;
  	const u8 *tlv_data;
  	char buildstr[25];
  	u32 build, paging_mem_size;
  	int num_of_cpus;
  	bool usniffer_req = false;

  	if (len < sizeof(*ucode)) {
  		IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
  		return -EINVAL;
  	}

  	if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
  		IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
  			le32_to_cpu(ucode->magic));
  		return -EINVAL;
  	}

  	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
  	memcpy(drv->fw.human_readable, ucode->human_readable,
  	       sizeof(drv->fw.human_readable));
  	build = le32_to_cpu(ucode->build);

  	if (build)
  		sprintf(buildstr, " build %u", build);
  	else
  		buildstr[0] = '\0';

  	snprintf(drv->fw.fw_version,
  		 sizeof(drv->fw.fw_version),
  		 "%u.%u.%u.%u%s %s",
  		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
  		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
  		 IWL_UCODE_API(drv->fw.ucode_ver),
  		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
  		 buildstr, iwl_reduced_fw_name(drv));

  	data = ucode->data;

  	len -= sizeof(*ucode);

  	while (len >= sizeof(*tlv)) {
  		len -= sizeof(*tlv);
-		tlv = (void *)data;
+		tlv = (const void *)data;

  		tlv_len = le32_to_cpu(tlv->length);
  		tlv_type = le32_to_cpu(tlv->type);
  		tlv_data = tlv->data;

  		if (len < tlv_len) {
  			IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
  				len, tlv_len);
  			return -EINVAL;
  		}
  		len -= ALIGN(tlv_len, 4);
  		data += sizeof(*tlv) + ALIGN(tlv_len, 4);

  		switch (tlv_type) {
  		case IWL_UCODE_TLV_INST:
  			set_sec_data(pieces, IWL_UCODE_REGULAR,
  				     IWL_UCODE_SECTION_INST, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_REGULAR,
  				     IWL_UCODE_SECTION_INST, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_REGULAR,
  				       IWL_UCODE_SECTION_INST,
  				       IWLAGN_RTC_INST_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_DATA:
  			set_sec_data(pieces, IWL_UCODE_REGULAR,
  				     IWL_UCODE_SECTION_DATA, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_REGULAR,
  				     IWL_UCODE_SECTION_DATA, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_REGULAR,
  				       IWL_UCODE_SECTION_DATA,
  				       IWLAGN_RTC_DATA_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_INIT:
  			set_sec_data(pieces, IWL_UCODE_INIT,
  				     IWL_UCODE_SECTION_INST, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_INIT,
  				     IWL_UCODE_SECTION_INST, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_INIT,
  				       IWL_UCODE_SECTION_INST,
  				       IWLAGN_RTC_INST_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_INIT_DATA:
  			set_sec_data(pieces, IWL_UCODE_INIT,
  				     IWL_UCODE_SECTION_DATA, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_INIT,
  				     IWL_UCODE_SECTION_DATA, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_INIT,
  				       IWL_UCODE_SECTION_DATA,
  				       IWLAGN_RTC_DATA_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_BOOT:
  			IWL_ERR(drv, "Found unexpected BOOT ucode\n");
  			break;
  		case IWL_UCODE_TLV_PROBE_MAX_LEN:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			capa->max_probe_length =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_PAN:
  			if (tlv_len)
  				goto invalid_tlv_len;
  			capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
  			break;
  		case IWL_UCODE_TLV_FLAGS:
  			/* must be at least one u32 */
  			if (tlv_len < sizeof(u32))
  				goto invalid_tlv_len;
  			/* and a proper number of u32s */
  			if (tlv_len % sizeof(u32))
  				goto invalid_tlv_len;
  			/*
  			 * This driver only reads the first u32 as
  			 * right now no more features are defined,
  			 * if that changes then either the driver
  			 * will not work with the new firmware, or
  			 * it'll not take advantage of new features.
  			 */
-			capa->flags = le32_to_cpup((__le32 *)tlv_data);
+			capa->flags = le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_API_CHANGES_SET:
  			if (tlv_len != sizeof(struct iwl_ucode_api))
  				goto invalid_tlv_len;
  			iwl_set_ucode_api_flags(drv, tlv_data, capa);
  			break;
  		case IWL_UCODE_TLV_ENABLED_CAPABILITIES:
  			if (tlv_len != sizeof(struct iwl_ucode_capa))
  				goto invalid_tlv_len;
  			iwl_set_ucode_capabilities(drv, tlv_data, capa);
  			break;
  		case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->init_evtlog_ptr =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->init_evtlog_size =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->init_errlog_ptr =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->inst_evtlog_ptr =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->inst_evtlog_size =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			pieces->inst_errlog_ptr =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
  			if (tlv_len)
  				goto invalid_tlv_len;
  			drv->fw.enhance_sensitivity_table = true;
  			break;
  		case IWL_UCODE_TLV_WOWLAN_INST:
  			set_sec_data(pieces, IWL_UCODE_WOWLAN,
  				     IWL_UCODE_SECTION_INST, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_WOWLAN,
  				     IWL_UCODE_SECTION_INST, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_WOWLAN,
  				       IWL_UCODE_SECTION_INST,
  				       IWLAGN_RTC_INST_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_WOWLAN_DATA:
  			set_sec_data(pieces, IWL_UCODE_WOWLAN,
  				     IWL_UCODE_SECTION_DATA, tlv_data);
  			set_sec_size(pieces, IWL_UCODE_WOWLAN,
  				     IWL_UCODE_SECTION_DATA, tlv_len);
  			set_sec_offset(pieces, IWL_UCODE_WOWLAN,
  				       IWL_UCODE_SECTION_DATA,
  				       IWLAGN_RTC_DATA_LOWER_BOUND);
  			break;
  		case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			capa->standard_phy_calibration_size =
-					le32_to_cpup((__le32 *)tlv_data);
+					le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_SEC_RT:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_SEC_INIT:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_SEC_WOWLAN:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_DEF_CALIB:
  			if (tlv_len != sizeof(struct iwl_tlv_calib_data))
  				goto invalid_tlv_len;
  			if (iwl_set_default_calib(drv, tlv_data))
  				goto tlv_error;
  			break;
  		case IWL_UCODE_TLV_PHY_SKU:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
-			drv->fw.phy_config = le32_to_cpup((__le32 *)tlv_data);
+			drv->fw.phy_config = le32_to_cpup((const __le32 *)tlv_data);
  			drv->fw.valid_tx_ant = (drv->fw.phy_config &
  						FW_PHY_CFG_TX_CHAIN) >>
  						FW_PHY_CFG_TX_CHAIN_POS;
  			drv->fw.valid_rx_ant = (drv->fw.phy_config &
  						FW_PHY_CFG_RX_CHAIN) >>
  						FW_PHY_CFG_RX_CHAIN_POS;
  			break;
  		case IWL_UCODE_TLV_SECURE_SEC_RT:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_SECURE_SEC_INIT:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_SECURE_SEC_WOWLAN:
  			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
  					    tlv_len);
  			drv->fw.type = IWL_FW_MVM;
  			break;
  		case IWL_UCODE_TLV_NUM_OF_CPU:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			num_of_cpus =
-				le32_to_cpup((__le32 *)tlv_data);
+				le32_to_cpup((const __le32 *)tlv_data);

  			if (num_of_cpus == 2) {
  				drv->fw.img[IWL_UCODE_REGULAR].is_dual_cpus =
  					true;
  				drv->fw.img[IWL_UCODE_INIT].is_dual_cpus =
  					true;
  				drv->fw.img[IWL_UCODE_WOWLAN].is_dual_cpus =
  					true;
  			} else if ((num_of_cpus > 2) || (num_of_cpus < 1)) {
  				IWL_ERR(drv, "Driver support upto 2 CPUs\n");
  				return -EINVAL;
  			}
  			break;
  		case IWL_UCODE_TLV_CSCHEME:
  			if (iwl_store_cscheme(&drv->fw, tlv_data, tlv_len))
  				goto invalid_tlv_len;
  			break;
  		case IWL_UCODE_TLV_N_SCAN_CHANNELS:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
  			capa->n_scan_channels =
-				le32_to_cpup((__le32 *)tlv_data);
+				le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_FW_VERSION: {
-			__le32 *ptr = (void *)tlv_data;
+			const __le32 *ptr = (const __le32 *)tlv_data;
  			u32 major, minor;
  			u8 local_comp;

  			if (tlv_len != sizeof(u32) * 3)
  				goto invalid_tlv_len;

  			major = le32_to_cpup(ptr++);
  			minor = le32_to_cpup(ptr++);
  			local_comp = le32_to_cpup(ptr);

  			if (major >= 35)
  				snprintf(drv->fw.fw_version,
  					 sizeof(drv->fw.fw_version),
  					"%u.%08x.%u %s", major, minor,
  					local_comp, iwl_reduced_fw_name(drv));
  			else
  				snprintf(drv->fw.fw_version,
  					 sizeof(drv->fw.fw_version),
  					"%u.%u.%u %s", major, minor,
  					local_comp, iwl_reduced_fw_name(drv));
  			break;
  			}
  		case IWL_UCODE_TLV_FW_DBG_DEST: {
-			struct iwl_fw_dbg_dest_tlv *dest = NULL;
-			struct iwl_fw_dbg_dest_tlv_v1 *dest_v1 = NULL;
+			const struct iwl_fw_dbg_dest_tlv *dest = NULL;
+			const struct iwl_fw_dbg_dest_tlv_v1 *dest_v1 = NULL;
  			u8 mon_mode;

-			pieces->dbg_dest_ver = (u8 *)tlv_data;
+			pieces->dbg_dest_ver = (const u8 *)tlv_data;
  			if (*pieces->dbg_dest_ver == 1) {
-				dest = (void *)tlv_data;
+				dest = (const void *)tlv_data;
  			} else if (*pieces->dbg_dest_ver == 0) {
-				dest_v1 = (void *)tlv_data;
+				dest_v1 = (const void *)tlv_data;
  			} else {
  				IWL_ERR(drv,
  					"The version is %d, and it is invalid\n",
  					*pieces->dbg_dest_ver);
  				break;
  			}

  			if (pieces->dbg_dest_tlv_init) {
  				IWL_ERR(drv,
  					"dbg destination ignored, already exists\n");
  				break;
  			}

  			pieces->dbg_dest_tlv_init = true;

  			if (dest_v1) {
  				pieces->dbg_dest_tlv_v1 = dest_v1;
  				mon_mode = dest_v1->monitor_mode;
  			} else {
  				pieces->dbg_dest_tlv = dest;
  				mon_mode = dest->monitor_mode;
  			}

  			IWL_INFO(drv, "Found debug destination: %s\n",
  				 get_fw_dbg_mode_string(mon_mode));

  			drv->fw.dbg.n_dest_reg = (dest_v1) ?
  				tlv_len -
  				offsetof(struct iwl_fw_dbg_dest_tlv_v1,
  					 reg_ops) :
  				tlv_len -
  				offsetof(struct iwl_fw_dbg_dest_tlv,
  					 reg_ops);

  			drv->fw.dbg.n_dest_reg /=
  				sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]);

  			break;
  			}
  		case IWL_UCODE_TLV_FW_DBG_CONF: {
-			struct iwl_fw_dbg_conf_tlv *conf = (void *)tlv_data;
+			const struct iwl_fw_dbg_conf_tlv *conf =
+				(const void *)tlv_data;

  			if (!pieces->dbg_dest_tlv_init) {
  				IWL_ERR(drv,
  					"Ignore dbg config %d - no destination configured\n",
  					conf->id);
  				break;
  			}

  			if (conf->id >= ARRAY_SIZE(drv->fw.dbg.conf_tlv)) {
  				IWL_ERR(drv,
  					"Skip unknown configuration: %d\n",
  					conf->id);
  				break;
  			}

  			if (pieces->dbg_conf_tlv[conf->id]) {
  				IWL_ERR(drv,
  					"Ignore duplicate dbg config %d\n",
  					conf->id);
  				break;
  			}

  			if (conf->usniffer)
  				usniffer_req = true;

  			IWL_INFO(drv, "Found debug configuration: %d\n",
  				 conf->id);

  			pieces->dbg_conf_tlv[conf->id] = conf;
  			pieces->dbg_conf_tlv_len[conf->id] = tlv_len;
  			break;
  			}
  		case IWL_UCODE_TLV_FW_DBG_TRIGGER: {
-			struct iwl_fw_dbg_trigger_tlv *trigger =
-				(void *)tlv_data;
+			const struct iwl_fw_dbg_trigger_tlv *trigger =
+				(const void *)tlv_data;
  			u32 trigger_id = le32_to_cpu(trigger->id);

  			if (trigger_id >= ARRAY_SIZE(drv->fw.dbg.trigger_tlv)) {
  				IWL_ERR(drv,
  					"Skip unknown trigger: %u\n",
  					trigger->id);
  				break;
  			}

  			if (pieces->dbg_trigger_tlv[trigger_id]) {
  				IWL_ERR(drv,
  					"Ignore duplicate dbg trigger %u\n",
  					trigger->id);
  				break;
  			}

  			IWL_INFO(drv, "Found debug trigger: %u\n", trigger->id);

  			pieces->dbg_trigger_tlv[trigger_id] = trigger;
  			pieces->dbg_trigger_tlv_len[trigger_id] = tlv_len;
  			break;
  			}
  		case IWL_UCODE_TLV_FW_DBG_DUMP_LST: {
  			if (tlv_len != sizeof(u32)) {
  				IWL_ERR(drv,
  					"dbg lst mask size incorrect, skip\n");
  				break;
  			}

  			drv->fw.dbg.dump_mask =
-				le32_to_cpup((__le32 *)tlv_data);
+				le32_to_cpup((const __le32 *)tlv_data);
  			break;
  			}
  		case IWL_UCODE_TLV_SEC_RT_USNIFFER:
  			*usniffer_images = true;
  			iwl_store_ucode_sec(pieces, tlv_data,
  					    IWL_UCODE_REGULAR_USNIFFER,
  					    tlv_len);
  			break;
  		case IWL_UCODE_TLV_PAGING:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
-			paging_mem_size = le32_to_cpup((__le32 *)tlv_data);
+			paging_mem_size = le32_to_cpup((const __le32 *)tlv_data);

  			IWL_DEBUG_FW(drv,
  				     "Paging: paging enabled (size = %u bytes)\n",
  				     paging_mem_size);

  			if (paging_mem_size > MAX_PAGING_IMAGE_SIZE) {
  				IWL_ERR(drv,
  					"Paging: driver supports up to %lu bytes for paging image\n",
  					MAX_PAGING_IMAGE_SIZE);
  				return -EINVAL;
  			}

  			if (paging_mem_size & (FW_PAGING_SIZE - 1)) {
  				IWL_ERR(drv,
  					"Paging: image isn't multiple %lu\n",
  					FW_PAGING_SIZE);
  				return -EINVAL;
  			}

  			drv->fw.img[IWL_UCODE_REGULAR].paging_mem_size =
  				paging_mem_size;
  			usniffer_img = IWL_UCODE_REGULAR_USNIFFER;
  			drv->fw.img[usniffer_img].paging_mem_size =
  				paging_mem_size;
  			break;
  		case IWL_UCODE_TLV_FW_GSCAN_CAPA:
  			/* ignored */
  			break;
  		case IWL_UCODE_TLV_FW_MEM_SEG: {
-			struct iwl_fw_dbg_mem_seg_tlv *dbg_mem =
-				(void *)tlv_data;
+			const struct iwl_fw_dbg_mem_seg_tlv *dbg_mem =
+				(const void *)tlv_data;
  			size_t size;
  			struct iwl_fw_dbg_mem_seg_tlv *n;

  			if (tlv_len != (sizeof(*dbg_mem)))
  				goto invalid_tlv_len;

  			IWL_DEBUG_INFO(drv, "Found debug memory segment: %u\n",
  				       dbg_mem->data_type);

  			size = sizeof(*pieces->dbg_mem_tlv) *
  			       (pieces->n_mem_tlv + 1);
  			n = krealloc(pieces->dbg_mem_tlv, size, GFP_KERNEL);
  			if (!n)
  				return -ENOMEM;
  			pieces->dbg_mem_tlv = n;
  			pieces->dbg_mem_tlv[pieces->n_mem_tlv] = *dbg_mem;
  			pieces->n_mem_tlv++;
  			break;
  			}
  		case IWL_UCODE_TLV_IML: {
  			drv->fw.iml_len = tlv_len;
  			drv->fw.iml = kmemdup(tlv_data, tlv_len, GFP_KERNEL);
  			if (!drv->fw.iml)
  				return -ENOMEM;
  			break;
  			}
  		case IWL_UCODE_TLV_FW_RECOVERY_INFO: {
-			struct {
+			const struct {
  				__le32 buf_addr;
  				__le32 buf_size;
-			} *recov_info = (void *)tlv_data;
+			} *recov_info = (const void *)tlv_data;

  			if (tlv_len != sizeof(*recov_info))
  				goto invalid_tlv_len;
  			capa->error_log_addr =
  				le32_to_cpu(recov_info->buf_addr);
  			capa->error_log_size =
  				le32_to_cpu(recov_info->buf_size);
  			}
  			break;
  		case IWL_UCODE_TLV_FW_FSEQ_VERSION: {
-			struct {
+			const struct {
  				u8 version[32];
  				u8 sha1[20];
-			} *fseq_ver = (void *)tlv_data;
+			} *fseq_ver = (const void *)tlv_data;

  			if (tlv_len != sizeof(*fseq_ver))
  				goto invalid_tlv_len;
  			IWL_INFO(drv, "TLV_FW_FSEQ_VERSION: %s\n",
  				 fseq_ver->version);
  			}
  			break;
  		case IWL_UCODE_TLV_FW_NUM_STATIONS:
  			if (tlv_len != sizeof(u32))
  				goto invalid_tlv_len;
-			if (le32_to_cpup((__le32 *)tlv_data) >
+			if (le32_to_cpup((const __le32 *)tlv_data) >
  			    IWL_MVM_STATION_COUNT_MAX) {
  				IWL_ERR(drv,
  					"%d is an invalid number of station\n",
-					le32_to_cpup((__le32 *)tlv_data));
+					le32_to_cpup((const __le32 *)tlv_data));
  				goto tlv_error;
  			}
  			capa->num_stations =
-				le32_to_cpup((__le32 *)tlv_data);
+				le32_to_cpup((const __le32 *)tlv_data);
  			break;
  		case IWL_UCODE_TLV_UMAC_DEBUG_ADDRS: {
-			struct iwl_umac_debug_addrs *dbg_ptrs =
-				(void *)tlv_data;
+			const struct iwl_umac_debug_addrs *dbg_ptrs =
+				(const void *)tlv_data;

  			if (tlv_len != sizeof(*dbg_ptrs))
  				goto invalid_tlv_len;
  			if (drv->trans->trans_cfg->device_family <
  			    IWL_DEVICE_FAMILY_22000)
  				break;
  			drv->trans->dbg.umac_error_event_table =
  				le32_to_cpu(dbg_ptrs->error_info_addr) &
  				~FW_ADDR_CACHE_CONTROL;
  			drv->trans->dbg.error_event_table_tlv_status |=
  				IWL_ERROR_EVENT_TABLE_UMAC;
  			break;
  			}
  		case IWL_UCODE_TLV_LMAC_DEBUG_ADDRS: {
-			struct iwl_lmac_debug_addrs *dbg_ptrs =
-				(void *)tlv_data;
+			const struct iwl_lmac_debug_addrs *dbg_ptrs =
+				(const void *)tlv_data;

  			if (tlv_len != sizeof(*dbg_ptrs))
  				goto invalid_tlv_len;
  			if (drv->trans->trans_cfg->device_family <
  			    IWL_DEVICE_FAMILY_22000)
  				break;
  			drv->trans->dbg.lmac_error_event_table[0] =
  				le32_to_cpu(dbg_ptrs->error_event_table_ptr) &
  				~FW_ADDR_CACHE_CONTROL;
  			drv->trans->dbg.error_event_table_tlv_status |=
  				IWL_ERROR_EVENT_TABLE_LMAC1;
  			break;
  			}
  		case IWL_UCODE_TLV_TYPE_DEBUG_INFO:
  		case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
  		case IWL_UCODE_TLV_TYPE_HCMD:
  		case IWL_UCODE_TLV_TYPE_REGIONS:
  		case IWL_UCODE_TLV_TYPE_TRIGGERS:
  			if (iwlwifi_mod_params.enable_ini)
  				iwl_dbg_tlv_alloc(drv->trans, tlv, false);
  			break;
  		case IWL_UCODE_TLV_CMD_VERSIONS:
  			if (tlv_len % sizeof(struct iwl_fw_cmd_version)) {
  				IWL_ERR(drv,
  					"Invalid length for command versions: %u\n",
  					tlv_len);
  				tlv_len /= sizeof(struct iwl_fw_cmd_version);
  				tlv_len *= sizeof(struct iwl_fw_cmd_version);
  			}
  			if (WARN_ON(capa->cmd_versions))
  				return -EINVAL;
  			capa->cmd_versions = kmemdup(tlv_data, tlv_len,
  						     GFP_KERNEL);
  			if (!capa->cmd_versions)
  				return -ENOMEM;
  			capa->n_cmd_versions =
  				tlv_len / sizeof(struct iwl_fw_cmd_version);
  			break;
  		case IWL_UCODE_TLV_PHY_INTEGRATION_VERSION:
  			if (drv->fw.phy_integration_ver) {
  				IWL_ERR(drv,
  					"phy integration str ignored, already exists\n");
  				break;
  			}

  			drv->fw.phy_integration_ver =
  				kmemdup(tlv_data, tlv_len, GFP_KERNEL);
  			if (!drv->fw.phy_integration_ver)
  				return -ENOMEM;
  			drv->fw.phy_integration_ver_len = tlv_len;
  			break;
  		default:
  			IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
  			break;
  		}
  	}

  	if (!fw_has_capa(capa, IWL_UCODE_TLV_CAPA_USNIFFER_UNIFIED) &&
  	    usniffer_req && !*usniffer_images) {
  		IWL_ERR(drv,
  			"user selected to work with usniffer but usniffer image isn't available in ucode package\n");
  		return -EINVAL;
  	}

  	if (len) {
  		IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
  		iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
  		return -EINVAL;
  	}

  	return 0;

   invalid_tlv_len:
  	IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
   tlv_error:
  	iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);

  	return -EINVAL;
  }
@@ -1298,312 +1300,312 @@ static void _iwl_op_mode_stop(struct iwl_drv *drv)
  /*
   * iwl_req_fw_callback - callback when firmware was loaded
   *
   * If loaded successfully, copies the firmware into buffers
   * for the card to fetch (via DMA).
   */
  static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
  {
  	struct iwl_drv *drv = context;
  	struct iwl_fw *fw = &drv->fw;
-	struct iwl_ucode_header *ucode;
+	const struct iwl_ucode_header *ucode;
  	struct iwlwifi_opmode_table *op;
  	int err;
  	struct iwl_firmware_pieces *pieces;
  	const unsigned int api_max = drv->trans->cfg->ucode_api_max;
  	const unsigned int api_min = drv->trans->cfg->ucode_api_min;
  	size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX];
  	u32 api_ver;
  	int i;
  	bool load_module = false;
  	bool usniffer_images = false;

  	fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH;
  	fw->ucode_capa.standard_phy_calibration_size =
  			IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
  	fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS;
  	fw->ucode_capa.num_stations = IWL_MVM_STATION_COUNT_MAX;
  	/* dump all fw memory areas by default */
  	fw->dbg.dump_mask = 0xffffffff;

  	pieces = kzalloc(sizeof(*pieces), GFP_KERNEL);
  	if (!pieces)
  		goto out_free_fw;

  	if (!ucode_raw)
  		goto try_again;

  	IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
  			  drv->firmware_name, ucode_raw->size);

  	/* Make sure that we got at least the API version number */
  	if (ucode_raw->size < 4) {
  		IWL_ERR(drv, "File size way too small!\n");
  		goto try_again;
  	}

  	/* Data from ucode file:  header followed by uCode images */
-	ucode = (struct iwl_ucode_header *)ucode_raw->data;
+	ucode = (const struct iwl_ucode_header *)ucode_raw->data;

  	if (ucode->ver)
  		err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces);
  	else
  		err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces,
  					     &fw->ucode_capa, &usniffer_images);

  	if (err)
  		goto try_again;

  	if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION))
  		api_ver = drv->fw.ucode_ver;
  	else
  		api_ver = IWL_UCODE_API(drv->fw.ucode_ver);

  	/*
  	 * api_ver should match the api version forming part of the
  	 * firmware filename ... but we don't check for that and only rely
  	 * on the API version read from firmware header from here on forward
  	 */
  	if (api_ver < api_min || api_ver > api_max) {
  		IWL_ERR(drv,
  			"Driver unable to support your firmware API. "
  			"Driver supports v%u, firmware is v%u.\n",
  			api_max, api_ver);
  		goto try_again;
  	}

  	/*
  	 * In mvm uCode there is no difference between data and instructions
  	 * sections.
  	 */
  	if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces,
  							 drv->trans->cfg))
  		goto try_again;

  	/* Allocate ucode buffers for card's bus-master loading ... */

  	/* Runtime instructions and 2 copies of data:
  	 * 1) unmodified from disk
  	 * 2) backup cache for save/restore during power-downs
  	 */
  	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
  		if (iwl_alloc_ucode(drv, pieces, i))
  			goto out_free_fw;

  	if (pieces->dbg_dest_tlv_init) {
  		size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) +
  			sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
  			drv->fw.dbg.n_dest_reg;

  		drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);

  		if (!drv->fw.dbg.dest_tlv)
  			goto out_free_fw;

  		if (*pieces->dbg_dest_ver == 0) {
  			memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1,
  			       dbg_dest_size);
  		} else {
  			struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv =
  				drv->fw.dbg.dest_tlv;

  			dest_tlv->version = pieces->dbg_dest_tlv->version;
  			dest_tlv->monitor_mode =
  				pieces->dbg_dest_tlv->monitor_mode;
  			dest_tlv->size_power =
  				pieces->dbg_dest_tlv->size_power;
  			dest_tlv->wrap_count =
  				pieces->dbg_dest_tlv->wrap_count;
  			dest_tlv->write_ptr_reg =
  				pieces->dbg_dest_tlv->write_ptr_reg;
  			dest_tlv->base_shift =
  				pieces->dbg_dest_tlv->base_shift;
  			memcpy(dest_tlv->reg_ops,
  			       pieces->dbg_dest_tlv->reg_ops,
  			       sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
  			       drv->fw.dbg.n_dest_reg);

  			/* In version 1 of the destination tlv, which is
  			 * relevant for internal buffer exclusively,
  			 * the base address is part of given with the length
  			 * of the buffer, and the size shift is give instead of
  			 * end shift. We now store these values in base_reg,
  			 * and end shift, and when dumping the data we'll
  			 * manipulate it for extracting both the length and
  			 * base address */
  			dest_tlv->base_reg = pieces->dbg_dest_tlv->cfg_reg;
  			dest_tlv->end_shift =
  				pieces->dbg_dest_tlv->size_shift;
  		}
  	}

  	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) {
  		if (pieces->dbg_conf_tlv[i]) {
  			drv->fw.dbg.conf_tlv[i] =
  				kmemdup(pieces->dbg_conf_tlv[i],
  					pieces->dbg_conf_tlv_len[i],
  					GFP_KERNEL);
  			if (!drv->fw.dbg.conf_tlv[i])
  				goto out_free_fw;
  		}
  	}

  	memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz));

  	trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] =
  		sizeof(struct iwl_fw_dbg_trigger_missed_bcon);
  	trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] = 0;
  	trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] =
  		sizeof(struct iwl_fw_dbg_trigger_cmd);
  	trigger_tlv_sz[FW_DBG_TRIGGER_MLME] =
  		sizeof(struct iwl_fw_dbg_trigger_mlme);
  	trigger_tlv_sz[FW_DBG_TRIGGER_STATS] =
  		sizeof(struct iwl_fw_dbg_trigger_stats);
  	trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] =
  		sizeof(struct iwl_fw_dbg_trigger_low_rssi);
  	trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] =
  		sizeof(struct iwl_fw_dbg_trigger_txq_timer);
  	trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] =
  		sizeof(struct iwl_fw_dbg_trigger_time_event);
  	trigger_tlv_sz[FW_DBG_TRIGGER_BA] =
  		sizeof(struct iwl_fw_dbg_trigger_ba);
  	trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] =
  		sizeof(struct iwl_fw_dbg_trigger_tdls);

  	for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) {
  		if (pieces->dbg_trigger_tlv[i]) {
  			/*
  			 * If the trigger isn't long enough, WARN and exit.
  			 * Someone is trying to debug something and he won't
  			 * be able to catch the bug he is trying to chase.
  			 * We'd better be noisy to be sure he knows what's
  			 * going on.
  			 */
  			if (WARN_ON(pieces->dbg_trigger_tlv_len[i] <
  				    (trigger_tlv_sz[i] +
  				     sizeof(struct iwl_fw_dbg_trigger_tlv))))
  				goto out_free_fw;
  			drv->fw.dbg.trigger_tlv_len[i] =
  				pieces->dbg_trigger_tlv_len[i];
  			drv->fw.dbg.trigger_tlv[i] =
  				kmemdup(pieces->dbg_trigger_tlv[i],
  					drv->fw.dbg.trigger_tlv_len[i],
  					GFP_KERNEL);
  			if (!drv->fw.dbg.trigger_tlv[i])
  				goto out_free_fw;
  		}
  	}

  	/* Now that we can no longer fail, copy information */

  	drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv;
  	pieces->dbg_mem_tlv = NULL;
  	drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv;

  	/*
  	 * The (size - 16) / 12 formula is based on the information recorded
  	 * for each event, which is of mode 1 (including timestamp) for all
  	 * new microcodes that include this information.
  	 */
  	fw->init_evtlog_ptr = pieces->init_evtlog_ptr;
  	if (pieces->init_evtlog_size)
  		fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12;
  	else
  		fw->init_evtlog_size =
  			drv->trans->trans_cfg->base_params->max_event_log_size;
  	fw->init_errlog_ptr = pieces->init_errlog_ptr;
  	fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr;
  	if (pieces->inst_evtlog_size)
  		fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12;
  	else
  		fw->inst_evtlog_size =
  			drv->trans->trans_cfg->base_params->max_event_log_size;
  	fw->inst_errlog_ptr = pieces->inst_errlog_ptr;

  	/*
  	 * figure out the offset of chain noise reset and gain commands
  	 * base on the size of standard phy calibration commands table size
  	 */
  	if (fw->ucode_capa.standard_phy_calibration_size >
  	    IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
  		fw->ucode_capa.standard_phy_calibration_size =
  			IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;

  	/* We have our copies now, allow OS release its copies */
  	release_firmware(ucode_raw);

  	mutex_lock(&iwlwifi_opmode_table_mtx);
  	switch (fw->type) {
  	case IWL_FW_DVM:
  		op = &iwlwifi_opmode_table[DVM_OP_MODE];
  		break;
  	default:
  		WARN(1, "Invalid fw type %d\n", fw->type);
  		fallthrough;
  	case IWL_FW_MVM:
  		op = &iwlwifi_opmode_table[MVM_OP_MODE];
  		break;
  	}

  	IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
  		 drv->fw.fw_version, op->name);

  	iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans);

  	/* add this device to the list of devices using this op_mode */
  	list_add_tail(&drv->list, &op->drv);

  	if (op->ops) {
  		drv->op_mode = _iwl_op_mode_start(drv, op);

  		if (!drv->op_mode) {
  			mutex_unlock(&iwlwifi_opmode_table_mtx);
  			goto out_unbind;
  		}
  	} else {
  		load_module = true;
  	}
  	mutex_unlock(&iwlwifi_opmode_table_mtx);

  	/*
  	 * Complete the firmware request last so that
  	 * a driver unbind (stop) doesn't run while we
  	 * are doing the start() above.
  	 */
  	complete(&drv->request_firmware_complete);

  	/*
  	 * Load the module last so we don't block anything
  	 * else from proceeding if the module fails to load
  	 * or hangs loading.
  	 */
  	if (load_module) {
  		request_module("%s", op->name);
  #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR
  		if (err)
  			IWL_ERR(drv,
  				"failed to load module %s (error %d), is dynamic loading enabled?\n",
  				op->name, err);
  #endif
  	}
  	goto free;

   try_again:
  	/* try next, if any */
  	release_firmware(ucode_raw);
  	if (iwl_request_firmware(drv, false))
  		goto out_unbind;
  	goto free;

   out_free_fw:
  	release_firmware(ucode_raw);
   out_unbind:
  	complete(&drv->request_firmware_complete);
  	device_release_driver(drv->trans->dev);
   free:
  	if (pieces) {
  		for (i = 0; i < ARRAY_SIZE(pieces->img); i++)
  			kfree(pieces->img[i].sec);
  		kfree(pieces->dbg_mem_tlv);
  		kfree(pieces);
  	}
  }
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c b/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
index af684f80b0cc..776d524024c4 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
@@ -348,99 +348,99 @@ static enum nl80211_band iwl_nl80211_band_from_channel_idx(int ch_idx)
  static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
  				struct iwl_nvm_data *data,
  				const void * const nvm_ch_flags,
  				u32 sbands_flags, bool v4)
  {
  	int ch_idx;
  	int n_channels = 0;
  	struct ieee80211_channel *channel;
  	u32 ch_flags;
  	int num_of_ch;
  	const u16 *nvm_chan;

  	if (cfg->uhb_supported) {
  		num_of_ch = IWL_NVM_NUM_CHANNELS_UHB;
  		nvm_chan = iwl_uhb_nvm_channels;
  	} else if (cfg->nvm_type == IWL_NVM_EXT) {
  		num_of_ch = IWL_NVM_NUM_CHANNELS_EXT;
  		nvm_chan = iwl_ext_nvm_channels;
  	} else {
  		num_of_ch = IWL_NVM_NUM_CHANNELS;
  		nvm_chan = iwl_nvm_channels;
  	}

  	for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
  		enum nl80211_band band =
  			iwl_nl80211_band_from_channel_idx(ch_idx);

  		if (v4)
  			ch_flags =
-				__le32_to_cpup((__le32 *)nvm_ch_flags + ch_idx);
+				__le32_to_cpup((const __le32 *)nvm_ch_flags + ch_idx);
  		else
  			ch_flags =
-				__le16_to_cpup((__le16 *)nvm_ch_flags + ch_idx);
+				__le16_to_cpup((const __le16 *)nvm_ch_flags + ch_idx);

  		if (band == NL80211_BAND_5GHZ &&
  		    !data->sku_cap_band_52ghz_enable)
  			continue;

  		/* workaround to disable wide channels in 5GHz */
  		if ((sbands_flags & IWL_NVM_SBANDS_FLAGS_NO_WIDE_IN_5GHZ) &&
  		    band == NL80211_BAND_5GHZ) {
  			ch_flags &= ~(NVM_CHANNEL_40MHZ |
  				     NVM_CHANNEL_80MHZ |
  				     NVM_CHANNEL_160MHZ);
  		}

  		if (ch_flags & NVM_CHANNEL_160MHZ)
  			data->vht160_supported = true;

  		if (!(sbands_flags & IWL_NVM_SBANDS_FLAGS_LAR) &&
  		    !(ch_flags & NVM_CHANNEL_VALID)) {
  			/*
  			 * Channels might become valid later if lar is
  			 * supported, hence we still want to add them to
  			 * the list of supported channels to cfg80211.
  			 */
  			iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM,
  						    nvm_chan[ch_idx], ch_flags);
  			continue;
  		}

  		channel = &data->channels[n_channels];
  		n_channels++;

  		channel->hw_value = nvm_chan[ch_idx];
  		channel->band = band;
  		channel->center_freq =
  			ieee80211_channel_to_frequency(
  				channel->hw_value, channel->band);

  		/* Initialize regulatory-based run-time data */

  		/*
  		 * Default value - highest tx power value.  max_power
  		 * is not used in mvm, and is used for backwards compatibility
  		 */
  		channel->max_power = IWL_DEFAULT_MAX_TX_POWER;

  		/* don't put limitations in case we're using LAR */
  		if (!(sbands_flags & IWL_NVM_SBANDS_FLAGS_LAR))
  			channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
  							       ch_idx, band,
  							       ch_flags, cfg);
  		else
  			channel->flags = 0;

  		/* TODO: Don't put limitations on UHB devices as we still don't
  		 * have NVM for them
  		 */
  		if (cfg->uhb_supported)
  			channel->flags = 0;
  		iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM,
  					    channel->hw_value, ch_flags);
  		IWL_DEBUG_EEPROM(dev, "Ch. %d: %ddBm\n",
  				 channel->hw_value, channel->max_power);
  	}

  	return n_channels;
  }
@@ -854,39 +854,39 @@ static void iwl_init_sbands(struct iwl_trans *trans,
  static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
  		       const __le16 *phy_sku)
  {
  	if (cfg->nvm_type != IWL_NVM_EXT)
  		return le16_to_cpup(nvm_sw + SKU);

-	return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
+	return le32_to_cpup((const __le32 *)(phy_sku + SKU_FAMILY_8000));
  }

  static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
  {
  	if (cfg->nvm_type != IWL_NVM_EXT)
  		return le16_to_cpup(nvm_sw + NVM_VERSION);
  	else
-		return le32_to_cpup((__le32 *)(nvm_sw +
+		return le32_to_cpup((const __le32 *)(nvm_sw +
  					       NVM_VERSION_EXT_NVM));
  }

  static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
  			     const __le16 *phy_sku)
  {
  	if (cfg->nvm_type != IWL_NVM_EXT)
  		return le16_to_cpup(nvm_sw + RADIO_CFG);

-	return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_EXT_NVM));
+	return le32_to_cpup((const __le32 *)(phy_sku + RADIO_CFG_FAMILY_EXT_NVM));

  }

  static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
  {
  	int n_hw_addr;

  	if (cfg->nvm_type != IWL_NVM_EXT)
  		return le16_to_cpup(nvm_sw + N_HW_ADDRS);

-	n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
+	n_hw_addr = le32_to_cpup((const __le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));

  	return n_hw_addr & N_HW_ADDR_MASK;
  }
@@ -1382,176 +1382,176 @@ IWL_EXPORT_SYMBOL(iwl_nvm_fixups);
  /*
   * Reads external NVM from a file into mvm->nvm_sections
   *
   * HOW TO CREATE THE NVM FILE FORMAT:
   * ------------------------------
   * 1. create hex file, format:
   *      3800 -> header
   *      0000 -> header
   *      5a40 -> data
   *
   *   rev - 6 bit (word1)
   *   len - 10 bit (word1)
   *   id - 4 bit (word2)
   *   rsv - 12 bit (word2)
   *
   * 2. flip 8bits with 8 bits per line to get the right NVM file format
   *
   * 3. create binary file from the hex file
   *
   * 4. save as "iNVM_xxx.bin" under /lib/firmware
   */
  int iwl_read_external_nvm(struct iwl_trans *trans,
  			  const char *nvm_file_name,
  			  struct iwl_nvm_section *nvm_sections)
  {
  	int ret, section_size;
  	u16 section_id;
  	const struct firmware *fw_entry;
  	const struct {
  		__le16 word1;
  		__le16 word2;
  		u8 data[];
  	} *file_sec;
  	const u8 *eof;
  	u8 *temp;
  	int max_section_size;
  	const __le32 *dword_buff;

  #define NVM_WORD1_LEN(x) (8 * (x & 0x03FF))
  #define NVM_WORD2_ID(x) (x >> 12)
  #define EXT_NVM_WORD2_LEN(x) (2 * (((x) & 0xFF) << 8 | (x) >> 8))
  #define EXT_NVM_WORD1_ID(x) ((x) >> 4)
  #define NVM_HEADER_0	(0x2A504C54)
  #define NVM_HEADER_1	(0x4E564D2A)
  #define NVM_HEADER_SIZE	(4 * sizeof(u32))

  	IWL_DEBUG_EEPROM(trans->dev, "Read from external NVM\n");

  	/* Maximal size depends on NVM version */
  	if (trans->cfg->nvm_type != IWL_NVM_EXT)
  		max_section_size = IWL_MAX_NVM_SECTION_SIZE;
  	else
  		max_section_size = IWL_MAX_EXT_NVM_SECTION_SIZE;

  	/*
  	 * Obtain NVM image via request_firmware. Since we already used
  	 * request_firmware_nowait() for the firmware binary load and only
  	 * get here after that we assume the NVM request can be satisfied
  	 * synchronously.
  	 */
  	ret = request_firmware(&fw_entry, nvm_file_name, trans->dev);
  	if (ret) {
  		IWL_ERR(trans, "ERROR: %s isn't available %d\n",
  			nvm_file_name, ret);
  		return ret;
  	}

  	IWL_INFO(trans, "Loaded NVM file %s (%zu bytes)\n",
  		 nvm_file_name, fw_entry->size);

  	if (fw_entry->size > MAX_NVM_FILE_LEN) {
  		IWL_ERR(trans, "NVM file too large\n");
  		ret = -EINVAL;
  		goto out;
  	}

  	eof = fw_entry->data + fw_entry->size;
-	dword_buff = (__le32 *)fw_entry->data;
+	dword_buff = (const __le32 *)fw_entry->data;

  	/* some NVM file will contain a header.
  	 * The header is identified by 2 dwords header as follow:
  	 * dword[0] = 0x2A504C54
  	 * dword[1] = 0x4E564D2A
  	 *
  	 * This header must be skipped when providing the NVM data to the FW.
  	 */
  	if (fw_entry->size > NVM_HEADER_SIZE &&
  	    dword_buff[0] == cpu_to_le32(NVM_HEADER_0) &&
  	    dword_buff[1] == cpu_to_le32(NVM_HEADER_1)) {
-		file_sec = (void *)(fw_entry->data + NVM_HEADER_SIZE);
+		file_sec = (const void *)(fw_entry->data + NVM_HEADER_SIZE);
  		IWL_INFO(trans, "NVM Version %08X\n", le32_to_cpu(dword_buff[2]));
  		IWL_INFO(trans, "NVM Manufacturing date %08X\n",
  			 le32_to_cpu(dword_buff[3]));

  		/* nvm file validation, dword_buff[2] holds the file version */
  		if (trans->trans_cfg->device_family == IWL_DEVICE_FAMILY_8000 &&
  		    CSR_HW_REV_STEP(trans->hw_rev) == SILICON_C_STEP &&
  		    le32_to_cpu(dword_buff[2]) < 0xE4A) {
  			ret = -EFAULT;
  			goto out;
  		}
  	} else {
-		file_sec = (void *)fw_entry->data;
+		file_sec = (const void *)fw_entry->data;
  	}

  	while (true) {
  		if (file_sec->data > eof) {
  			IWL_ERR(trans,
  				"ERROR - NVM file too short for section header\n");
  			ret = -EINVAL;
  			break;
  		}

  		/* check for EOF marker */
  		if (!file_sec->word1 && !file_sec->word2) {
  			ret = 0;
  			break;
  		}

  		if (trans->cfg->nvm_type != IWL_NVM_EXT) {
  			section_size =
  				2 * NVM_WORD1_LEN(le16_to_cpu(file_sec->word1));
  			section_id = NVM_WORD2_ID(le16_to_cpu(file_sec->word2));
  		} else {
  			section_size = 2 * EXT_NVM_WORD2_LEN(
  						le16_to_cpu(file_sec->word2));
  			section_id = EXT_NVM_WORD1_ID(
  						le16_to_cpu(file_sec->word1));
  		}

  		if (section_size > max_section_size) {
  			IWL_ERR(trans, "ERROR - section too large (%d)\n",
  				section_size);
  			ret = -EINVAL;
  			break;
  		}

  		if (!section_size) {
  			IWL_ERR(trans, "ERROR - section empty\n");
  			ret = -EINVAL;
  			break;
  		}

  		if (file_sec->data + section_size > eof) {
  			IWL_ERR(trans,
  				"ERROR - NVM file too short for section (%d bytes)\n",
  				section_size);
  			ret = -EINVAL;
  			break;
  		}

  		if (WARN(section_id >= NVM_MAX_NUM_SECTIONS,
  			 "Invalid NVM section ID %d\n", section_id)) {
  			ret = -EINVAL;
  			break;
  		}

  		temp = kmemdup(file_sec->data, section_size, GFP_KERNEL);
  		if (!temp) {
  			ret = -ENOMEM;
  			break;
  		}

  		iwl_nvm_fixups(trans->hw_id, section_id, temp, section_size);

  		kfree(nvm_sections[section_id].data);
  		nvm_sections[section_id].data = temp;
  		nvm_sections[section_id].length = section_size;

  		/* advance to the next section */
-		file_sec = (void *)(file_sec->data + section_size);
+		file_sec = (const void *)(file_sec->data + section_size);
  	}
  out:
  	release_firmware(fw_entry);
  	return ret;
  }
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
index 60e0db4a5e20..3d2ce95b0421 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-trans.c
@@ -182,18 +182,18 @@ IWL_EXPORT_SYMBOL(iwl_trans_send_cmd);
  /* Comparator for struct iwl_hcmd_names.
   * Used in the binary search over a list of host commands.
   *
   * @key: command_id that we're looking for.
   * @elt: struct iwl_hcmd_names candidate for match.
   *
   * @return 0 iff equal.
   */
  static int iwl_hcmd_names_cmp(const void *key, const void *elt)
  {
  	const struct iwl_hcmd_names *name = elt;
-	u8 cmd1 = *(u8 *)key;
+	const u8 *cmd1 = key;
  	u8 cmd2 = name->cmd_id;

-	return (cmd1 - cmd2);
+	return (*cmd1 - cmd2);
  }

  const char *iwl_get_cmd_string(struct iwl_trans *trans, u32 id)
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
index 1ad621d13ad3..ace6f2c76747 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
@@ -597,59 +597,60 @@ static int iwl_mvm_get_ctrl_vif_queue(struct iwl_mvm *mvm,
  static void iwl_mvm_probe_resp_set_noa(struct iwl_mvm *mvm,
  				       struct sk_buff *skb)
  {
  	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  	struct iwl_mvm_vif *mvmvif =
  		iwl_mvm_vif_from_mac80211(info->control.vif);
  	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
  	int base_len = (u8 *)mgmt->u.probe_resp.variable - (u8 *)mgmt;
  	struct iwl_probe_resp_data *resp_data;
-	u8 *ie, *pos;
+	const u8 *ie;
+	u8 *pos;
  	u8 match[] = {
  		(WLAN_OUI_WFA >> 16) & 0xff,
  		(WLAN_OUI_WFA >> 8) & 0xff,
  		WLAN_OUI_WFA & 0xff,
  		WLAN_OUI_TYPE_WFA_P2P,
  	};

  	rcu_read_lock();

  	resp_data = rcu_dereference(mvmvif->probe_resp_data);
  	if (!resp_data)
  		goto out;

  	if (!resp_data->notif.noa_active)
  		goto out;

-	ie = (u8 *)cfg80211_find_ie_match(WLAN_EID_VENDOR_SPECIFIC,
+	ie = cfg80211_find_ie_match(WLAN_EID_VENDOR_SPECIFIC,
  					  mgmt->u.probe_resp.variable,
  					  skb->len - base_len,
  					  match, 4, 2);
  	if (!ie) {
  		IWL_DEBUG_TX(mvm, "probe resp doesn't have P2P IE\n");
  		goto out;
  	}

  	if (skb_tailroom(skb) < resp_data->noa_len) {
  		if (pskb_expand_head(skb, 0, resp_data->noa_len, GFP_ATOMIC)) {
  			IWL_ERR(mvm,
  				"Failed to reallocate probe resp\n");
  			goto out;
  		}
  	}

  	pos = skb_put(skb, resp_data->noa_len);

  	*pos++ = WLAN_EID_VENDOR_SPECIFIC;
  	/* Set length of IE body (not including ID and length itself) */
  	*pos++ = resp_data->noa_len - 2;
  	*pos++ = (WLAN_OUI_WFA >> 16) & 0xff;
  	*pos++ = (WLAN_OUI_WFA >> 8) & 0xff;
  	*pos++ = WLAN_OUI_WFA & 0xff;
  	*pos++ = WLAN_OUI_TYPE_WFA_P2P;

  	memcpy(pos, &resp_data->notif.noa_attr,
  	       resp_data->noa_len - sizeof(struct ieee80211_vendor_ie));

  out:
  	rcu_read_unlock();
  }
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
index 1bf4c37fe960..a8025c78f80b 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
@@ -665,56 +665,56 @@ static int iwl_pcie_load_firmware_chunk(struct iwl_trans *trans,
  static int iwl_pcie_load_section(struct iwl_trans *trans, u8 section_num,
  			    const struct fw_desc *section)
  {
  	u8 *v_addr;
  	dma_addr_t p_addr;
  	u32 offset, chunk_sz = min_t(u32, FH_MEM_TB_MAX_LENGTH, section->len);
  	int ret = 0;

  	IWL_DEBUG_FW(trans, "[%d] uCode section being loaded...\n",
  		     section_num);

  	v_addr = dma_alloc_coherent(trans->dev, chunk_sz, &p_addr,
  				    GFP_KERNEL | __GFP_NOWARN);
  	if (!v_addr) {
  		IWL_DEBUG_INFO(trans, "Falling back to small chunks of DMA\n");
  		chunk_sz = PAGE_SIZE;
  		v_addr = dma_alloc_coherent(trans->dev, chunk_sz,
  					    &p_addr, GFP_KERNEL);
  		if (!v_addr)
  			return -ENOMEM;
  	}

  	for (offset = 0; offset < section->len; offset += chunk_sz) {
  		u32 copy_size, dst_addr;
  		bool extended_addr = false;

  		copy_size = min_t(u32, chunk_sz, section->len - offset);
  		dst_addr = section->offset + offset;

  		if (dst_addr >= IWL_FW_MEM_EXTENDED_START &&
  		    dst_addr <= IWL_FW_MEM_EXTENDED_END)
  			extended_addr = true;

  		if (extended_addr)
  			iwl_set_bits_prph(trans, LMPM_CHICK,
  					  LMPM_CHICK_EXTENDED_ADDR_SPACE);

-		memcpy(v_addr, (u8 *)section->data + offset, copy_size);
+		memcpy(v_addr, (const u8 *)section->data + offset, copy_size);
  		ret = iwl_pcie_load_firmware_chunk(trans, dst_addr, p_addr,
  						   copy_size);

  		if (extended_addr)
  			iwl_clear_bits_prph(trans, LMPM_CHICK,
  					    LMPM_CHICK_EXTENDED_ADDR_SPACE);

  		if (ret) {
  			IWL_ERR(trans,
  				"Could not load the [%d] uCode section\n",
  				section_num);
  			break;
  		}
  	}

  	dma_free_coherent(trans->dev, chunk_sz, v_addr, p_addr);
  	return ret;
  }
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/tx.c b/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
index 9073a7e551dc..6e02c8b294ac 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/tx.c
@@ -867,47 +867,47 @@ void iwl_trans_pcie_txq_set_shared_mode(struct iwl_trans *trans, u32 txq_id,
  void iwl_trans_pcie_txq_disable(struct iwl_trans *trans, int txq_id,
  				bool configure_scd)
  {
  	struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
  	u32 stts_addr = trans_pcie->scd_base_addr +
  			SCD_TX_STTS_QUEUE_OFFSET(txq_id);
  	static const u32 zero_val[4] = {};

  	trans->txqs.txq[txq_id]->frozen_expiry_remainder = 0;
  	trans->txqs.txq[txq_id]->frozen = false;

  	/*
  	 * Upon HW Rfkill - we stop the device, and then stop the queues
  	 * in the op_mode. Just for the sake of the simplicity of the op_mode,
  	 * allow the op_mode to call txq_disable after it already called
  	 * stop_device.
  	 */
  	if (!test_and_clear_bit(txq_id, trans->txqs.queue_used)) {
  		WARN_ONCE(test_bit(STATUS_DEVICE_ENABLED, &trans->status),
  			  "queue %d not used", txq_id);
  		return;
  	}

  	if (configure_scd) {
  		iwl_scd_txq_set_inactive(trans, txq_id);

-		iwl_trans_write_mem(trans, stts_addr, (void *)zero_val,
+		iwl_trans_write_mem(trans, stts_addr, zero_val,
  				    ARRAY_SIZE(zero_val));
  	}

  	iwl_pcie_txq_unmap(trans, txq_id);
  	trans->txqs.txq[txq_id]->ampdu = false;

  	IWL_DEBUG_TX_QUEUES(trans, "Deactivate queue %d\n", txq_id);
  }

  /*************** HOST COMMAND QUEUE FUNCTIONS   *****/

  /*
   * iwl_pcie_enqueue_hcmd - enqueue a uCode command
   * @priv: device private data point
   * @cmd: a pointer to the ucode command structure
   *
   * The function returns < 0 values to indicate the operation
   * failed. On success, it returns the index (>= 0) of command in the
   * command queue.
   */
