struct zfcp_dbf *dbf = req->adapter->dbf;
        struct fsf_status_read_buffer *srb = req->data;
        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
+       static int const level = 2;
        unsigned long flags;
 
+       if (unlikely(!debug_level_enabled(dbf->hba, level)))
+               return;
+
        spin_lock_irqsave(&dbf->hba_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
                zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len,
                                  "fsf_uss", req->req_id);
 log:
-       debug_event(dbf->hba, 2, rec, sizeof(*rec));
+       debug_event(dbf->hba, level, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
        struct zfcp_dbf *dbf = req->adapter->dbf;
        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
        struct fsf_status_read_buffer *sr_buf = req->data;
+       static int const level = 1;
        unsigned long flags;
 
+       if (unlikely(!debug_level_enabled(dbf->hba, level)))
+               return;
+
        spin_lock_irqsave(&dbf->hba_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
        memcpy(&rec->u.be, &sr_buf->payload.bit_error,
               sizeof(struct fsf_bit_error_payload));
 
-       debug_event(dbf->hba, 1, rec, sizeof(*rec));
+       debug_event(dbf->hba, level, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
        struct zfcp_dbf *dbf = adapter->dbf;
        struct zfcp_dbf_pay *payload = &dbf->pay_buf;
        unsigned long flags;
+       static int const level = 1;
        u16 length;
 
+       if (unlikely(!debug_level_enabled(dbf->pay, level)))
+               return;
+
        if (!pl)
                return;
 
 
        while (payload->counter < scount && (char *)pl[payload->counter]) {
                memcpy(payload->data, (char *)pl[payload->counter], length);
-               debug_event(dbf->pay, 1, payload, zfcp_dbf_plen(length));
+               debug_event(dbf->pay, level, payload, zfcp_dbf_plen(length));
                payload->counter++;
        }
 
 {
        struct zfcp_dbf *dbf = adapter->dbf;
        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
+       static int const level = 1;
        unsigned long flags;
 
+       if (unlikely(!debug_level_enabled(dbf->hba, level)))
+               return;
+
        spin_lock_irqsave(&dbf->hba_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
        rec->id = ZFCP_DBF_HBA_BASIC;
 
-       debug_event(dbf->hba, 1, rec, sizeof(*rec));
+       debug_event(dbf->hba, level, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
 {
        struct zfcp_dbf *dbf = adapter->dbf;
        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
+       static int const level = 1;
        struct list_head *entry;
        unsigned long flags;
 
+       if (unlikely(!debug_level_enabled(dbf->rec, level)))
+               return;
+
        spin_lock_irqsave(&dbf->rec_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
        rec->u.trig.want = want;
        rec->u.trig.need = need;
 
-       debug_event(dbf->rec, 1, rec, sizeof(*rec));
+       debug_event(dbf->rec, level, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
        unsigned long flags;
 
+       if (!debug_level_enabled(dbf->rec, level))
+               return;
+
        spin_lock_irqsave(&dbf->rec_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
 {
        struct zfcp_dbf *dbf = wka_port->adapter->dbf;
        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
+       static int const level = 1;
        unsigned long flags;
 
+       if (unlikely(!debug_level_enabled(dbf->rec, level)))
+               return;
+
        spin_lock_irqsave(&dbf->rec_lock, flags);
        memset(rec, 0, sizeof(*rec));
 
        rec->u.run.rec_action = ~0;
        rec->u.run.rec_count = ~0;
 
-       debug_event(dbf->rec, 1, rec, sizeof(*rec));
+       debug_event(dbf->rec, level, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
+#define ZFCP_DBF_SAN_LEVEL 1
+
 static inline
 void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf,
                  char *paytag, struct scatterlist *sg, u8 id, u16 len,
                                      (u16)(sg->length - offset));
                        /* cap_len <= pay_sum < cap_len+ZFCP_DBF_PAY_MAX_REC */
                        memcpy(payload->data, sg_virt(sg) + offset, pay_len);
-                       debug_event(dbf->pay, 1, payload,
+                       debug_event(dbf->pay, ZFCP_DBF_SAN_LEVEL, payload,
                                    zfcp_dbf_plen(pay_len));
                        payload->counter++;
                        offset += pay_len;
        spin_unlock(&dbf->pay_lock);
 
 out:
-       debug_event(dbf->san, 1, rec, sizeof(*rec));
+       debug_event(dbf->san, ZFCP_DBF_SAN_LEVEL, rec, sizeof(*rec));
        spin_unlock_irqrestore(&dbf->san_lock, flags);
 }
 
        struct zfcp_fsf_ct_els *ct_els = fsf->data;
        u16 length;
 
+       if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
+               return;
+
        length = (u16)zfcp_qdio_real_bytes(ct_els->req);
        zfcp_dbf_san(tag, dbf, "san_req", ct_els->req, ZFCP_DBF_SAN_REQ,
                     length, fsf->req_id, d_id, length);
        struct zfcp_fsf_ct_els *ct_els = fsf->data;
        u16 length;
 
+       if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
+               return;
+
        length = (u16)zfcp_qdio_real_bytes(ct_els->resp);
        zfcp_dbf_san(tag, dbf, "san_res", ct_els->resp, ZFCP_DBF_SAN_RES,
                     length, fsf->req_id, ct_els->d_id,
        u16 length;
        struct scatterlist sg;
 
+       if (unlikely(!debug_level_enabled(dbf->san, ZFCP_DBF_SAN_LEVEL)))
+               return;
+
        length = (u16)(srb->length -
                        offsetof(struct fsf_status_read_buffer, payload));
        sg_init_one(&sg, srb->payload.data, length);