if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
                IWL_ERR(trans, "Start IWL Error Log Dump:\n");
                IWL_ERR(trans, "Status: 0x%08lX, count: %d\n",
-                       priv->shrd->status, table.valid);
+                       priv->status, table.valid);
        }
 
        trace_iwlwifi_dev_ucode_error(trans->dev, table.error_id, table.tsf_low,
        /* Set the FW error flag -- cleared on iwl_down */
        set_bit(STATUS_FW_ERROR, &priv->status);
 
-       /* Cancel currently queued command. */
-       clear_bit(STATUS_HCMD_ACTIVE, &priv->shrd->status);
-
        iwl_abort_notification_waits(&priv->notif_wait);
 
        /* Keep the restart process from trying to send host
 
        int pos = 0;
        const size_t bufsz = sizeof(buf);
 
-       pos += scnprintf(buf + pos, bufsz - pos, "STATUS_HCMD_ACTIVE:\t %d\n",
-               test_bit(STATUS_HCMD_ACTIVE, &priv->shrd->status));
        pos += scnprintf(buf + pos, bufsz - pos, "STATUS_RF_KILL_HW:\t %d\n",
                test_bit(STATUS_RF_KILL_HW, &priv->status));
        pos += scnprintf(buf + pos, bufsz - pos, "STATUS_CT_KILL:\t\t %d\n",
 
                        APMS_CLK_VAL_MRB_FUNC_MODE) ||
             (iwl_read_prph(trans, APMG_PS_CTRL_REG) &
                        APMG_PS_CTRL_VAL_RESET_REQ))) {
-               clear_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status);
+               struct iwl_trans_pcie *trans_pcie;
+
+               trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
+               clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
                iwl_op_mode_wimax_active(trans->op_mode);
                wake_up(&trans->wait_command_queue);
                return;
 
        iwl_hcmd_queue_reclaim(trans, txq_id, index);
 
        if (!(meta->flags & CMD_ASYNC)) {
-               if (!test_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status)) {
+               if (!test_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status)) {
                        IWL_WARN(trans,
                                 "HCMD_ACTIVE already clear for command %s\n",
                                 get_cmd_string(cmd->hdr.cmd));
                }
-               clear_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status);
+               clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
                IWL_DEBUG_INFO(trans, "Clearing HCMD_ACTIVE for command %s\n",
                               get_cmd_string(cmd->hdr.cmd));
                wake_up(&trans->wait_command_queue);
                        get_cmd_string(cmd->id));
 
        if (WARN_ON(test_and_set_bit(STATUS_HCMD_ACTIVE,
-                                    &trans->shrd->status))) {
+                                    &trans_pcie->status))) {
                IWL_ERR(trans, "Command %s: a command is already active!\n",
                        get_cmd_string(cmd->id));
                return -EIO;
        cmd_idx = iwl_enqueue_hcmd(trans, cmd);
        if (cmd_idx < 0) {
                ret = cmd_idx;
-               clear_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status);
+               clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
                IWL_ERR(trans,
                        "Error sending %s: enqueue_hcmd failed: %d\n",
                          get_cmd_string(cmd->id), ret);
        }
 
        ret = wait_event_timeout(trans->wait_command_queue,
-                       !test_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status),
+                       !test_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status),
                        HOST_COMPLETE_TIMEOUT);
        if (!ret) {
-               if (test_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status)) {
+               if (test_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status)) {
                        struct iwl_tx_queue *txq =
                                &trans_pcie->txq[trans_pcie->cmd_queue];
                        struct iwl_queue *q = &txq->q;
                                "Current CMD queue read_ptr %d write_ptr %d\n",
                                q->read_ptr, q->write_ptr);
 
-                       clear_bit(STATUS_HCMD_ACTIVE, &trans->shrd->status);
+                       clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
                        IWL_DEBUG_INFO(trans, "Clearing HCMD_ACTIVE for command"
                                 "%s\n", get_cmd_string(cmd->id));
                        ret = -ETIMEDOUT;
 
 
        /* stop and reset the on-board processor */
        iwl_write32(trans, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
+
+       /* clear all status bits */
+       clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
+       clear_bit(STATUS_INT_ENABLED, &trans_pcie->status);
+       clear_bit(STATUS_DEVICE_ENABLED, &trans_pcie->status);
+       clear_bit(STATUS_POWER_PMI, &trans_pcie->status);
 }
 
 static void iwl_trans_pcie_wowlan_suspend(struct iwl_trans *trans)