* @IWL_FW_INI_ALLOCATION_ID_SDFX: for SDFX module
  * @IWL_FW_INI_ALLOCATION_ID_FW_DUMP: used for crash and runtime dumps
  * @IWL_FW_INI_ALLOCATION_ID_USER_DEFINED: for future user scenarios
+ * @IWL_FW_INI_ALLOCATION_NUM: number of allocation ids
 */
 enum iwl_fw_ini_allocation_id {
        IWL_FW_INI_ALLOCATION_INVALID,
        IWL_FW_INI_ALLOCATION_ID_SDFX,
        IWL_FW_INI_ALLOCATION_ID_FW_DUMP,
        IWL_FW_INI_ALLOCATION_ID_USER_DEFINED,
+       IWL_FW_INI_ALLOCATION_NUM,
 }; /* FW_DEBUG_TLV_ALLOCATION_ID_E_VER_1 */
 
 /**
 
 }
 
 static void iwl_fw_dbg_buffer_apply(struct iwl_fw_runtime *fwrt,
-                                   struct iwl_fw_ini_allocation_data *alloc,
+                                   struct iwl_fw_ini_allocation_tlv *alloc,
                                    enum iwl_fw_ini_apply_point pnt)
 {
        struct iwl_trans *trans = fwrt->trans;
                .len[0] = sizeof(ldbg_cmd),
        };
        int block_idx = trans->dbg.num_blocks;
-       u32 buf_location = le32_to_cpu(alloc->tlv.buffer_location);
+       u32 buf_location = le32_to_cpu(alloc->buffer_location);
+       u32 alloc_id = le32_to_cpu(alloc->allocation_id);
+
+       if (alloc_id <= IWL_FW_INI_ALLOCATION_INVALID ||
+           alloc_id >= IWL_FW_INI_ALLOCATION_NUM) {
+               IWL_ERR(fwrt, "WRT: Invalid allocation id %d\n", alloc_id);
+               return;
+       }
 
        if (fwrt->trans->dbg.ini_dest == IWL_FW_INI_LOCATION_INVALID)
                fwrt->trans->dbg.ini_dest = buf_location;
        if (buf_location != IWL_FW_INI_LOCATION_DRAM_PATH)
                return;
 
-       if (!alloc->is_alloc) {
-               iwl_fw_dbg_buffer_allocation(fwrt,
-                                            le32_to_cpu(alloc->tlv.size));
+       if (!(BIT(alloc_id) & fwrt->trans->dbg.is_alloc)) {
+               iwl_fw_dbg_buffer_allocation(fwrt, le32_to_cpu(alloc->size));
                if (block_idx == trans->dbg.num_blocks)
                        return;
-               alloc->is_alloc = 1;
+               fwrt->trans->dbg.is_alloc |= BIT(alloc_id);
        }
 
        /* First block is assigned via registers / context info */
        cmd->num_frags = cpu_to_le32(1);
        cmd->fragments[0].address =
                cpu_to_le64(trans->dbg.fw_mon[block_idx].physical);
-       cmd->fragments[0].size = alloc->tlv.size;
-       cmd->allocation_id = alloc->tlv.allocation_id;
-       cmd->buffer_location = alloc->tlv.buffer_location;
+       cmd->fragments[0].size = alloc->size;
+       cmd->allocation_id = alloc->allocation_id;
+       cmd->buffer_location = alloc->buffer_location;
 
        iwl_trans_send_cmd(trans, &hcmd);
 }
                case IWL_UCODE_TLV_TYPE_DEBUG_INFO:
                        iwl_fw_dbg_info_apply(fwrt, ini_tlv, ext, pnt);
                        break;
-               case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION: {
-                       struct iwl_fw_ini_allocation_data *buf_alloc = ini_tlv;
-
+               case IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION:
                        if (pnt != IWL_FW_INI_APPLY_EARLY) {
                                IWL_ERR(fwrt,
                                        "WRT: ext=%d. Invalid apply point %d for buffer allocation\n",
                                        ext, pnt);
                                goto next;
                        }
-
                        iwl_fw_dbg_buffer_apply(fwrt, ini_tlv, pnt);
-                       iter += sizeof(buf_alloc->is_alloc);
                        break;
-               }
                case IWL_UCODE_TLV_TYPE_HCMD:
                        if (pnt < IWL_FW_INI_APPLY_AFTER_ALIVE) {
                                IWL_ERR(fwrt,
 
        else
                data = &trans->dbg.apply_points[apply_point];
 
-       /* add room for is_alloc field in &iwl_fw_ini_allocation_data struct */
-       if (le32_to_cpu(tlv->type) == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
-               struct iwl_fw_ini_allocation_data *buf_alloc =
-                       (void *)tlv->data;
-
-               offset_size += sizeof(buf_alloc->is_alloc);
-       }
-
        /*
         * Make sure we still have room to copy this TLV. Offset points to the
         * location the last copy ended.
                if (WARN_ON(apply >= IWL_FW_INI_APPLY_NUM))
                        continue;
 
-               /* add room for is_alloc field in &iwl_fw_ini_allocation_data
-                * struct
-                */
-               if (tlv_type == IWL_UCODE_TLV_TYPE_BUFFER_ALLOCATION) {
-                       struct iwl_fw_ini_allocation_data *buf_alloc =
-                               (void *)tlv->data;
-
-                       size[apply] += sizeof(buf_alloc->is_alloc);
-               }
-
                size[apply] += sizeof(*tlv) + tlv_len;
        }
 
 
  * @ini_valid: indicates if debug ini mode is on
  * @num_blocks: number of blocks in fw_mon
  * @fw_mon: address of the buffers for firmware monitor
+ * @is_alloc: bit i is set if buffer i was allocated
  * @hw_error: equals true if hw error interrupt was received from the FW
  * @ini_dest: debug monitor destination uses &enum iwl_fw_ini_buffer_location
  */
        struct iwl_apply_point_data apply_points_ext[IWL_FW_INI_APPLY_NUM];
 
        int num_blocks;
-       struct iwl_dram_data fw_mon[IWL_FW_INI_APPLY_NUM];
+       struct iwl_dram_data fw_mon[IWL_FW_INI_ALLOCATION_NUM];
+       u32 is_alloc;
 
        bool hw_error;
        enum iwl_fw_ini_buffer_location ini_dest;