struct fsf_status_read_buffer *sr_buf;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
        zfcp_fsf_req_free(req);
        zfcp_dbf_hba_fsf_unsol("fail", adapter->dbf, NULL);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
        unsigned long old_req_id = (unsigned long) scmnd->host_scribble;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
        req = zfcp_fsf_req_create(qdio, FSF_QTCB_ABORT_FCP_CMND,
        zfcp_fsf_req_free(req);
        req = NULL;
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return req;
 }
 
        struct zfcp_fsf_req *req;
        int ret = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
 failed_send:
        zfcp_fsf_req_free(req);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return ret;
 }
 
        struct zfcp_qdio *qdio = adapter->qdio;
        int ret = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
 failed_send:
        zfcp_fsf_req_free(req);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return ret;
 }
 
        struct zfcp_qdio *qdio = erp_action->adapter->qdio;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req = NULL;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out_unlock;
 
 
        zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
        retval = zfcp_fsf_req_send(req);
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        if (!retval)
                wait_for_completion(&req->completion);
 
        return retval;
 
 out_unlock:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
                return -EOPNOTSUPP;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
                return -EOPNOTSUPP;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out_unlock;
 
        req->handler = zfcp_fsf_exchange_port_data_handler;
        zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
        retval = zfcp_fsf_req_send(req);
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
 
        if (!retval)
                wait_for_completion(&req->completion);
        return retval;
 
 out_unlock:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                put_device(&port->dev);
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
        if (retval)
                zfcp_fsf_req_free(req);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
        if (retval)
                zfcp_fsf_req_free(req);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
        struct zfcp_fsf_req *req;
        int retval = -EIO;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
                erp_action->fsf_req_id = 0;
        }
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return retval;
 }
 
                       ZFCP_STATUS_COMMON_UNBLOCKED)))
                return NULL;
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
        zfcp_fsf_req_free(req);
        req = NULL;
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return req;
 }
 
                return ERR_PTR(-EINVAL);
        }
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (zfcp_qdio_sbal_get(qdio))
                goto out;
 
        zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
        retval = zfcp_fsf_req_send(req);
 out:
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
 
        if (!retval) {
                wait_for_completion(&req->completion);
 
        unsigned long long now, span;
        int used;
 
-       spin_lock(&qdio->stat_lock);
        now = get_clock_monotonic();
        span = (now - qdio->req_q_time) >> 12;
        used = QDIO_MAX_BUFFERS_PER_Q - atomic_read(&qdio->req_q_free);
        qdio->req_q_util += used * span;
        qdio->req_q_time = now;
-       spin_unlock(&qdio->stat_lock);
 }
 
 static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
        /* cleanup all SBALs being program-owned now */
        zfcp_qdio_zero_sbals(qdio->req_q, idx, count);
 
+       spin_lock_irq(&qdio->stat_lock);
        zfcp_qdio_account(qdio);
+       spin_unlock_irq(&qdio->stat_lock);
        atomic_add(count, &qdio->req_q_free);
        wake_up(&qdio->req_q_wq);
 }
 
 static int zfcp_qdio_sbal_check(struct zfcp_qdio *qdio)
 {
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        if (atomic_read(&qdio->req_q_free) ||
            !(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
                return 1;
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        return 0;
 }
 
 {
        long ret;
 
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
        ret = wait_event_interruptible_timeout(qdio->req_q_wq,
                               zfcp_qdio_sbal_check(qdio), 5 * HZ);
 
                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1", NULL);
        }
 
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        return -EIO;
 }
 
        int retval;
        u8 sbal_number = q_req->sbal_number;
 
+       spin_lock(&qdio->stat_lock);
        zfcp_qdio_account(qdio);
+       spin_unlock(&qdio->stat_lock);
 
        retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0,
                         q_req->sbal_first, sbal_number);
                return;
 
        /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
-       spin_lock_bh(&qdio->req_q_lock);
+       spin_lock_irq(&qdio->req_q_lock);
        atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
-       spin_unlock_bh(&qdio->req_q_lock);
+       spin_unlock_irq(&qdio->req_q_lock);
 
        wake_up(&qdio->req_q_wq);