u32 smem_len = fwrt->fw->dbg.n_mem_tlv ? 0 : fwrt->trans->cfg->smem_len;
        u32 sram2_len = fwrt->fw->dbg.n_mem_tlv ?
                                0 : fwrt->trans->cfg->dccm2_len;
-       bool monitor_dump_only = false;
        int i;
 
-       if (fwrt->dump.trig &&
-           fwrt->dump.trig->mode & IWL_FW_DBG_TRIGGER_MONITOR_ONLY)
-               monitor_dump_only = true;
-
        /* SRAM - include stack CCM if driver knows the values for it */
        if (!fwrt->trans->cfg->dccm_offset || !fwrt->trans->cfg->dccm_len) {
                const struct fw_img *img;
        }
 
        /* If we only want a monitor dump, reset the file length */
-       if (monitor_dump_only) {
+       if (fwrt->dump.monitor_only) {
                file_len = sizeof(*dump_file) + sizeof(*dump_data) * 2 +
                           sizeof(*dump_info) + sizeof(*dump_smem_cfg);
        }
        }
 
        /* In case we only want monitor dump, skip to dump trasport data */
-       if (monitor_dump_only)
+       if (fwrt->dump.monitor_only)
                goto out;
 
        if (fwrt->fw->dbg.dump_mask & BIT(IWL_FW_ERROR_DUMP_MEM)) {
        }
 
        fw_error_dump->trans_ptr = iwl_trans_dump_data(fwrt->trans,
-                                                      fwrt->dump.trig);
+                                                      fwrt->dump.monitor_only);
        file_len = le32_to_cpu(dump_file->file_len);
        fw_error_dump->fwrt_len = file_len;
        if (fw_error_dump->trans_ptr) {
 IWL_EXPORT_SYMBOL(iwl_fw_alive_error_dump);
 
 int iwl_fw_dbg_collect_desc(struct iwl_fw_runtime *fwrt,
-                           const struct iwl_fw_dump_desc *desc, void *trigger,
+                           const struct iwl_fw_dump_desc *desc,
+                           bool monitor_only,
                            unsigned int delay)
 {
        /*
                 le32_to_cpu(desc->trig_desc.type));
 
        fwrt->dump.desc = desc;
-       fwrt->dump.trig = trigger;
+       fwrt->dump.monitor_only = monitor_only;
 
        schedule_delayed_work(&fwrt->dump.wk, delay);
 
 {
        struct iwl_fw_dump_desc *desc;
        unsigned int delay = 0;
+       bool monitor_only = false;
 
        if (trigger) {
                u16 occurrences = le16_to_cpu(trigger->occurrences) - 1;
 
                trigger->occurrences = cpu_to_le16(occurrences);
                delay = le16_to_cpu(trigger->trig_dis_ms);
+               monitor_only = trigger->mode & IWL_FW_DBG_TRIGGER_MONITOR_ONLY;
        }
 
        desc = kzalloc(sizeof(*desc) + len, GFP_ATOMIC);
        desc->trig_desc.type = cpu_to_le32(trig);
        memcpy(desc->trig_desc.data, str, len);
 
-       return iwl_fw_dbg_collect_desc(fwrt, desc, trigger, delay);
+       return iwl_fw_dbg_collect_desc(fwrt, desc, monitor_only, delay);
 }
 IWL_EXPORT_SYMBOL(iwl_fw_dbg_collect);
 
 
        if (fwrt->dump.desc != &iwl_dump_desc_assert)
                kfree(fwrt->dump.desc);
        fwrt->dump.desc = NULL;
-       fwrt->dump.trig = NULL;
 }
 
 void iwl_fw_error_dump(struct iwl_fw_runtime *fwrt);
 int iwl_fw_dbg_collect_desc(struct iwl_fw_runtime *fwrt,
                            const struct iwl_fw_dump_desc *desc,
-                           void *trigger, unsigned int delay);
+                           bool monitor_only, unsigned int delay);
 int iwl_fw_dbg_collect(struct iwl_fw_runtime *fwrt,
                       enum iwl_fw_dbg_trigger trig,
                       const char *str, size_t len,
 
        void (*resume)(struct iwl_trans *trans);
 
        struct iwl_trans_dump_data *(*dump_data)(struct iwl_trans *trans,
-                                                const struct iwl_fw_dbg_trigger_tlv
-                                                *trigger);
+                                                bool monitor_only);
 };
 
 /**
 }
 
 static inline struct iwl_trans_dump_data *
-iwl_trans_dump_data(struct iwl_trans *trans,
-                   const struct iwl_fw_dbg_trigger_tlv *trigger)
+iwl_trans_dump_data(struct iwl_trans *trans, bool monitor_only)
 {
        if (!trans->ops->dump_data)
                return NULL;
-       return trans->ops->dump_data(trans, trigger);
+       return trans->ops->dump_data(trans, monitor_only);
 }
 
 static inline struct iwl_device_cmd *
 
 
 static struct iwl_trans_dump_data
 *iwl_trans_pcie_dump_data(struct iwl_trans *trans,
-                         const struct iwl_fw_dbg_trigger_tlv *trigger)
+                         bool monitor_only)
 {
        struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
        struct iwl_fw_error_dump_data *data;
        /* FW monitor */
        monitor_len = iwl_trans_get_fw_monitor_len(trans, &len);
 
-       if (trigger && (trigger->mode & IWL_FW_DBG_TRIGGER_MONITOR_ONLY)) {
+       if (monitor_only) {
                if (!(trans->dbg_dump_mask &
                      BIT(IWL_FW_ERROR_DUMP_FW_MONITOR)))
                        return NULL;