[SCSI] libfc: Formatting cleanups across libfc

This patch makes a variety of cleanup changes to all libfc files.

This patch adds kernel-doc headers to all functions lacking them
and attempts to better format existing headers. It also add kernel-doc
headers to structures.

This patch ensures that the current naming conventions for local ports,
remote ports and remote port private data is upheld in the following
manner.

struct               instance (i.e. variable name)
--------------------------------------------------
fc_lport                      lport
fc_rport                      rport
fc_rport_libfc_priv           rpriv
fc_rport_priv                 rdata

I also renamed dns_rp and ptp_rp to dns_rdata and ptp_rdata
respectively.

I used emacs 'indent-region' and 'tabify' on all libfc files
to correct spacing alignments.

I feel sorry for anyone attempting to review this patch.

Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>

1 files changed, 379 insertions, 288 deletions

diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 98279fe0d0c7..970b54f653b7 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -67,10 +67,16 @@ struct kmem_cache *scsi_pkt_cachep;
 #define CMD_SCSI_STATUS(Cmnd)       ((Cmnd)->SCp.Status)
 #define CMD_RESID_LEN(Cmnd)         ((Cmnd)->SCp.buffers_residual)
 
+/**
+ * struct fc_fcp_internal - FCP layer internal data
+ * @scsi_pkt_pool:  Memory pool to draw FCP packets from
+ * @scsi_pkt_queue: Current FCP packets
+ * @throttled:      The FCP packet queue is throttled
+ */
 struct fc_fcp_internal {
-        mempool_t       *scsi_pkt_pool;
+        mempool_t        *scsi_pkt_pool;
         struct list_head scsi_pkt_queue;
-        u8              throttled;
+        u8               throttled;
 };
 
 #define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
@@ -84,9 +90,9 @@ static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
 static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
-static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp);
+static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_timeout_error(struct fc_fcp_pkt *);
-static void fc_fcp_timeout(unsigned long data);
+static void fc_fcp_timeout(unsigned long);
 static void fc_fcp_rec(struct fc_fcp_pkt *);
 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
@@ -125,23 +131,22 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
 #define FC_FCP_DFLT_QUEUE_DEPTH 32
 
 /**
- * fc_fcp_pkt_alloc - allocation routine for scsi_pkt packet
- * @lp:         fc lport struct
- * @gfp:        gfp flags for allocation
+ * fc_fcp_pkt_alloc() - Allocate a fcp_pkt
+ * @lport: The local port that the FCP packet is for
+ * @gfp:   GFP flags for allocation
  *
- * This is used by upper layer scsi driver.
- * Return Value : scsi_pkt structure or null on allocation failure.
- * Context      : call from process context. no locking required.
+ * Return value: fcp_pkt structure or null on allocation failure.
+ * Context:      Can be called from process context, no lock is required.
  */
-static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
+static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lport, gfp_t gfp)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         struct fc_fcp_pkt *fsp;
 
         fsp = mempool_alloc(si->scsi_pkt_pool, gfp);
         if (fsp) {
                 memset(fsp, 0, sizeof(*fsp));
-                fsp->lp = lp;
+                fsp->lp = lport;
                 atomic_set(&fsp->ref_cnt, 1);
                 init_timer(&fsp->timer);
                 INIT_LIST_HEAD(&fsp->list);
@@ -151,12 +156,11 @@ static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
 }
 
 /**
- * fc_fcp_pkt_release() - release hold on scsi_pkt packet
- * @fsp:        fcp packet struct
+ * fc_fcp_pkt_release() - Release hold on a fcp_pkt
+ * @fsp: The FCP packet to be released
  *
- * This is used by upper layer scsi driver.
- * Context      : call from process  and interrupt context.
- *                no locking required
+ * Context: Can be called from process or interrupt context,
+ *          no lock is required.
  */
 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
 {
@@ -167,20 +171,25 @@ static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
         }
 }
 
+/**
+ * fc_fcp_pkt_hold() - Hold a fcp_pkt
+ * @fsp: The FCP packet to be held
+ */
 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
 {
         atomic_inc(&fsp->ref_cnt);
 }
 
 /**
- * fc_fcp_pkt_destory() - release hold on scsi_pkt packet
- * @seq:                exchange sequence
- * @fsp:        fcp packet struct
+ * fc_fcp_pkt_destory() - Release hold on a fcp_pkt
+ * @seq: The sequence that the FCP packet is on (required by destructor API)
+ * @fsp: The FCP packet to be released
+ *
+ * This routine is called by a destructor callback in the exch_seq_send()
+ * routine of the libfc Transport Template. The 'struct fc_seq' is a required
+ * argument even though it is not used by this routine.
  *
- * Release hold on scsi_pkt packet set to keep scsi_pkt
- * till EM layer exch resource is not freed.
- * Context      : called from from EM layer.
- *                no locking required
+ * Context: No locking required.
  */
 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
 {
@@ -188,10 +197,10 @@ static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
 }
 
 /**
- * fc_fcp_lock_pkt() - lock a packet and get a ref to it.
- * @fsp:        fcp packet
+ * fc_fcp_lock_pkt() - Lock a fcp_pkt and increase its reference count
+ * @fsp: The FCP packet to be locked and incremented
  *
- * We should only return error if we return a command to scsi-ml before
+ * We should only return error if we return a command to SCSI-ml before
  * getting a response. This can happen in cases where we send a abort, but
  * do not wait for the response and the abort and command can be passing
  * each other on the wire/network-layer.
@@ -216,18 +225,33 @@ static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
         return 0;
 }
 
+/**
+ * fc_fcp_unlock_pkt() - Release a fcp_pkt's lock and decrement its
+ *                       reference count
+ * @fsp: The FCP packet to be unlocked and decremented
+ */
 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
 {
         spin_unlock_bh(&fsp->scsi_pkt_lock);
         fc_fcp_pkt_release(fsp);
 }
 
+/**
+ * fc_fcp_timer_set() - Start a timer for a fcp_pkt
+ * @fsp:   The FCP packet to start a timer for
+ * @delay: The timeout period for the timer
+ */
 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
 {
         if (!(fsp->state & FC_SRB_COMPL))
                 mod_timer(&fsp->timer, jiffies + delay);
 }
 
+/**
+ * fc_fcp_send_abort() - Send an abort for exchanges associated with a
+ *                       fcp_pkt
+ * @fsp: The FCP packet to abort exchanges on
+ */
 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
 {
         if (!fsp->seq_ptr)
@@ -237,9 +261,14 @@ static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
         return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
 }
 
-/*
- * Retry command.
- * An abort isn't needed.
+/**
+ * fc_fcp_retry_cmd() - Retry a fcp_pkt
+ * @fsp: The FCP packet to be retried
+ *
+ * Sets the status code to be FC_ERROR and then calls
+ * fc_fcp_complete_locked() which in turn calls fc_io_compl().
+ * fc_io_compl() will notify the SCSI-ml that the I/O is done.
+ * The SCSI-ml will retry the command.
  */
 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
 {
@@ -254,43 +283,35 @@ static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
         fc_fcp_complete_locked(fsp);
 }
 
-/*
- * fc_fcp_ddp_setup - calls to LLD's ddp_setup to set up DDP
- * transfer for a read I/O indicated by the fc_fcp_pkt.
- * @fsp: ptr to the fc_fcp_pkt
- *
- * This is called in exch_seq_send() when we have a newly allocated
- * exchange with a valid exchange id to setup ddp.
- *
- * returns: none
+/**
+ * fc_fcp_ddp_setup() - Calls a LLD's ddp_setup routine to set up DDP context
+ * @fsp: The FCP packet that will manage the DDP frames
+ * @xid: The XID that will be used for the DDP exchange
  */
 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
 
         if (!fsp)
                 return;
 
-        lp = fsp->lp;
+        lport = fsp->lp;
         if ((fsp->req_flags & FC_SRB_READ) &&
-            (lp->lro_enabled) && (lp->tt.ddp_setup)) {
-                if (lp->tt.ddp_setup(lp, xid, scsi_sglist(fsp->cmd),
-                                     scsi_sg_count(fsp->cmd)))
+            (lport->lro_enabled) && (lport->tt.ddp_setup)) {
+                if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
+                                        scsi_sg_count(fsp->cmd)))
                         fsp->xfer_ddp = xid;
         }
 }
 
-/*
- * fc_fcp_ddp_done - calls to LLD's ddp_done to release any
- * DDP related resources for this I/O if it is initialized
- * as a ddp transfer
- * @fsp: ptr to the fc_fcp_pkt
- *
- * returns: none
+/**
+ * fc_fcp_ddp_done() - Calls a LLD's ddp_done routine to release any
+ *                     DDP related resources for a fcp_pkt
+ * @fsp: The FCP packet that DDP had been used on
  */
 static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
 
         if (!fsp)
                 return;
@@ -298,22 +319,22 @@ static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
         if (fsp->xfer_ddp == FC_XID_UNKNOWN)
                 return;
 
-        lp = fsp->lp;
-        if (lp->tt.ddp_done) {
-                fsp->xfer_len = lp->tt.ddp_done(lp, fsp->xfer_ddp);
+        lport = fsp->lp;
+        if (lport->tt.ddp_done) {
+                fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
                 fsp->xfer_ddp = FC_XID_UNKNOWN;
         }
 }
 
-
-/*
- * Receive SCSI data from target.
- * Called after receiving solicited data.
+/**
+ * fc_fcp_recv_data() - Handler for receiving SCSI-FCP data from a target
+ * @fsp: The FCP packet the data is on
+ * @fp:  The data frame
  */
 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         struct scsi_cmnd *sc = fsp->cmd;
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fcoe_dev_stats *stats;
         struct fc_frame_header *fh;
         size_t start_offset;
@@ -363,13 +384,13 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 
                 if (~crc != le32_to_cpu(fr_crc(fp))) {
 crc_err:
-                        stats = fc_lport_get_stats(lp);
+                        stats = fc_lport_get_stats(lport);
                         stats->ErrorFrames++;
                         /* FIXME - per cpu count, not total count! */
                         if (stats->InvalidCRCCount++ < 5)
                                 printk(KERN_WARNING "libfc: CRC error on data "
                                        "frame for port (%6x)\n",
-                                       fc_host_port_id(lp->host));
+                                       fc_host_port_id(lport->host));
                         /*
                          * Assume the frame is total garbage.
                          * We may have copied it over the good part
@@ -397,18 +418,17 @@ crc_err:
 }
 
 /**
- * fc_fcp_send_data() -  Send SCSI data to target.
- * @fsp: ptr to fc_fcp_pkt
- * @sp: ptr to this sequence
- * @offset: starting offset for this data request
- * @seq_blen: the burst length for this data request
+ * fc_fcp_send_data() - Send SCSI data to a target
+ * @fsp:      The FCP packet the data is on
+ * @sp:       The sequence the data is to be sent on
+ * @offset:   The starting offset for this data request
+ * @seq_blen: The burst length for this data request
  *
  * Called after receiving a Transfer Ready data descriptor.
- * if LLD is capable of seq offload then send down seq_blen
- * size of data in single frame, otherwise send multiple FC
- * frames of max FC frame payload supported by target port.
- *
- * Returns : 0 for success.
+ * If the LLD is capable of sequence offload then send down the
+ * seq_blen ammount of data in single frame, otherwise send
+ * multiple frames of the maximum frame payload supported by
+ * the target port.
  */
 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                             size_t offset, size_t seq_blen)
@@ -417,7 +437,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         struct scsi_cmnd *sc;
         struct scatterlist *sg;
         struct fc_frame *fp = NULL;
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         size_t remaining;
         size_t t_blen;
         size_t tlen;
@@ -426,7 +446,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         int error;
         void *data = NULL;
         void *page_addr;
-        int using_sg = lp->sg_supp;
+        int using_sg = lport->sg_supp;
         u32 f_ctl;
 
         WARN_ON(seq_blen <= 0);
@@ -448,10 +468,10 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
          * to max FC frame payload previously set in fsp->max_payload.
          */
         t_blen = fsp->max_payload;
-        if (lp->seq_offload) {
-                t_blen = min(seq_blen, (size_t)lp->lso_max);
+        if (lport->seq_offload) {
+                t_blen = min(seq_blen, (size_t)lport->lso_max);
                 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
-                           fsp, seq_blen, lp->lso_max, t_blen);
+                           fsp, seq_blen, lport->lso_max, t_blen);
         }
 
         WARN_ON(t_blen < FC_MIN_MAX_PAYLOAD);
@@ -463,7 +483,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         remaining = seq_blen;
         fh_parm_offset = frame_offset = offset;
         tlen = 0;
-        seq = lp->tt.seq_start_next(seq);
+        seq = lport->tt.seq_start_next(seq);
         f_ctl = FC_FC_REL_OFF;
         WARN_ON(!seq);
 
@@ -486,11 +506,11 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                         if (tlen % 4)
                                 using_sg = 0;
                         if (using_sg) {
-                                fp = _fc_frame_alloc(lp, 0);
+                                fp = _fc_frame_alloc(lport, 0);
                                 if (!fp)
                                         return -ENOMEM;
                         } else {
-                                fp = fc_frame_alloc(lp, tlen);
+                                fp = fc_frame_alloc(lport, tlen);
                                 if (!fp)
                                         return -ENOMEM;
 
@@ -550,7 +570,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                 /*
                  * send fragment using for a sequence.
                  */
-                error = lp->tt.seq_send(lp, seq, fp);
+                error = lport->tt.seq_send(lport, seq, fp);
                 if (error) {
                         WARN_ON(1);             /* send error should be rare */
                         fc_fcp_retry_cmd(fsp);
@@ -562,6 +582,11 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         return 0;
 }
 
+/**
+ * fc_fcp_abts_resp() - Send an ABTS response
+ * @fsp: The FCP packet that is being aborted
+ * @fp:  The response frame
+ */
 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         int ba_done = 1;
@@ -598,8 +623,8 @@ static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 }
 
 /**
- * fc_fcp_reduce_can_queue() - drop can_queue
- * @lp: lport to drop queueing for
+ * fc_fcp_reduce_can_queue() - Reduce the can_queue value for a local port
+ * @lport: The local port to reduce can_queue on
  *
  * If we are getting memory allocation failures, then we may
  * be trying to execute too many commands. We let the running
@@ -607,37 +632,36 @@ static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
  * can_queue. Eventually we will hit the point where we run
  * on all reserved structs.
  */
-static void fc_fcp_reduce_can_queue(struct fc_lport *lp)
+static void fc_fcp_reduce_can_queue(struct fc_lport *lport)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         unsigned long flags;
         int can_queue;
 
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        spin_lock_irqsave(lport->host->host_lock, flags);
         if (si->throttled)
                 goto done;
         si->throttled = 1;
 
-        can_queue = lp->host->can_queue;
+        can_queue = lport->host->can_queue;
         can_queue >>= 1;
         if (!can_queue)
                 can_queue = 1;
-        lp->host->can_queue = can_queue;
-        shost_printk(KERN_ERR, lp->host, "libfc: Could not allocate frame.\n"
+        lport->host->can_queue = can_queue;
+        shost_printk(KERN_ERR, lport->host, "libfc: Could not allocate frame.\n"
                      "Reducing can_queue to %d.\n", can_queue);
 done:
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
 /**
- * fc_fcp_recv() - Reveive FCP frames
+ * fc_fcp_recv() - Reveive an FCP frame
  * @seq: The sequence the frame is on
- * @fp: The FC frame
+ * @fp:  The received frame
  * @arg: The related FCP packet
  *
- * Return   : None
- * Context  : called from Soft IRQ context
- *            can not called holding list lock
+ * Context: Called from Soft IRQ context. Can not be called
+ *          holding the FCP packet list lock.
  */
 static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -710,6 +734,11 @@ errout:
                 fc_fcp_reduce_can_queue(lport);
 }
 
+/**
+ * fc_fcp_resp() - Handler for FCP responses
+ * @fsp: The FCP packet the response is for
+ * @fp:  The response frame
+ */
 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         struct fc_frame_header *fh;
@@ -823,15 +852,16 @@ err:
 }
 
 /**
- * fc_fcp_complete_locked() - complete processing of a fcp packet
- * @fsp:        fcp packet
+ * fc_fcp_complete_locked() - Complete processing of a fcp_pkt with the
+ *                            fcp_pkt lock held
+ * @fsp: The FCP packet to be completed
  *
  * This function may sleep if a timer is pending. The packet lock must be
  * held, and the host lock must not be held.
  */
 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fc_seq *seq;
         struct fc_exch *ep;
         u32 f_ctl;
@@ -862,7 +892,7 @@ static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
                         struct fc_frame *conf_frame;
                         struct fc_seq *csp;
 
-                        csp = lp->tt.seq_start_next(seq);
+                        csp = lport->tt.seq_start_next(seq);
                         conf_frame = fc_frame_alloc(fsp->lp, 0);
                         if (conf_frame) {
                                 f_ctl = FC_FC_SEQ_INIT;
@@ -871,43 +901,48 @@ static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
                                 fc_fill_fc_hdr(conf_frame, FC_RCTL_DD_SOL_CTL,
                                                ep->did, ep->sid,
                                                FC_TYPE_FCP, f_ctl, 0);
-                                lp->tt.seq_send(lp, csp, conf_frame);
+                                lport->tt.seq_send(lport, csp, conf_frame);
                         }
                 }
-                lp->tt.exch_done(seq);
+                lport->tt.exch_done(seq);
         }
         fc_io_compl(fsp);
 }
 
+/**
+ * fc_fcp_cleanup_cmd() - Cancel the active exchange on a fcp_pkt
+ * @fsp:   The FCP packet whose exchanges should be canceled
+ * @error: The reason for the cancellation
+ */
 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
 
         if (fsp->seq_ptr) {
-                lp->tt.exch_done(fsp->seq_ptr);
+                lport->tt.exch_done(fsp->seq_ptr);
                 fsp->seq_ptr = NULL;
         }
         fsp->status_code = error;
 }
 
 /**
- * fc_fcp_cleanup_each_cmd() - Cleanup active commads
- * @lp:         logical port
- * @id:         target id
- * @lun:        lun
- * @error:      fsp status code
+ * fc_fcp_cleanup_each_cmd() - Cancel all exchanges on a local port
+ * @lport: The local port whose exchanges should be canceled
+ * @id:    The target's ID
+ * @lun:   The LUN
+ * @error: The reason for cancellation
  *
  * If lun or id is -1, they are ignored.
  */
-static void fc_fcp_cleanup_each_cmd(struct fc_lport *lp, unsigned int id,
+static void fc_fcp_cleanup_each_cmd(struct fc_lport *lport, unsigned int id,
                                     unsigned int lun, int error)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         struct fc_fcp_pkt *fsp;
         struct scsi_cmnd *sc_cmd;
         unsigned long flags;
 
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        spin_lock_irqsave(lport->host->host_lock, flags);
 restart:
         list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
                 sc_cmd = fsp->cmd;
@@ -918,7 +953,7 @@ restart:
                         continue;
 
                 fc_fcp_pkt_hold(fsp);
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(lport->host->host_lock, flags);
 
                 if (!fc_fcp_lock_pkt(fsp)) {
                         fc_fcp_cleanup_cmd(fsp, error);
@@ -927,35 +962,36 @@ restart:
                 }
 
                 fc_fcp_pkt_release(fsp);
-                spin_lock_irqsave(lp->host->host_lock, flags);
+                spin_lock_irqsave(lport->host->host_lock, flags);
                 /*
                  * while we dropped the lock multiple pkts could
                  * have been released, so we have to start over.
                  */
                 goto restart;
         }
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
-static void fc_fcp_abort_io(struct fc_lport *lp)
+/**
+ * fc_fcp_abort_io() - Abort all FCP-SCSI exchanges on a local port
+ * @lport: The local port whose exchanges are to be aborted
+ */
+static void fc_fcp_abort_io(struct fc_lport *lport)
 {
-        fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_HRD_ERROR);
+        fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_HRD_ERROR);
 }
 
 /**
- * fc_fcp_pkt_send() - send a fcp packet to the lower level.
- * @lp:         fc lport
- * @fsp:        fc packet.
+ * fc_fcp_pkt_send() - Send a fcp_pkt
+ * @lport: The local port to send the FCP packet on
+ * @fsp:   The FCP packet to send
  *
- * This is called by upper layer protocol.
- * Return   : zero for success and -1 for failure
- * Context  : called from queuecommand which can be called from process
- *            or scsi soft irq.
- * Locks    : called with the host lock and irqs disabled.
+ * Return:  Zero for success and -1 for failure
+ * Locks:   Called with the host lock and irqs disabled.
  */
-static int fc_fcp_pkt_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
+static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         int rc;
 
         fsp->cmd->SCp.ptr = (char *)fsp;
@@ -967,16 +1003,22 @@ static int fc_fcp_pkt_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
         memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
         list_add_tail(&fsp->list, &si->scsi_pkt_queue);
 
-        spin_unlock_irq(lp->host->host_lock);
-        rc = lp->tt.fcp_cmd_send(lp, fsp, fc_fcp_recv);
-        spin_lock_irq(lp->host->host_lock);
+        spin_unlock_irq(lport->host->host_lock);
+        rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
+        spin_lock_irq(lport->host->host_lock);
         if (rc)
                 list_del(&fsp->list);
 
         return rc;
 }
 
-static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
+/**
+ * fc_fcp_cmd_send() - Send a FCP command
+ * @lport: The local port to send the command on
+ * @fsp:   The FCP packet the command is on
+ * @resp:  The handler for the response
+ */
+static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
                            void (*resp)(struct fc_seq *,
                                         struct fc_frame *fp,
                                         void *arg))
@@ -984,14 +1026,14 @@ static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         struct fc_frame *fp;
         struct fc_seq *seq;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         const size_t len = sizeof(fsp->cdb_cmd);
         int rc = 0;
 
         if (fc_fcp_lock_pkt(fsp))
                 return 0;
 
-        fp = fc_frame_alloc(lp, sizeof(fsp->cdb_cmd));
+        fp = fc_frame_alloc(lport, sizeof(fsp->cdb_cmd));
         if (!fp) {
                 rc = -1;
                 goto unlock;
@@ -1001,13 +1043,14 @@ static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         fr_fsp(fp) = fsp;
         rport = fsp->rport;
         fsp->max_payload = rport->maxframe_size;
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
 
         fc_fill_fc_hdr(fp, FC_RCTL_DD_UNSOL_CMD, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_FCP,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
-        seq = lp->tt.exch_seq_send(lp, fp, resp, fc_fcp_pkt_destroy, fsp, 0);
+        seq = lport->tt.exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy,
+                                      fsp, 0);
         if (!seq) {
                 rc = -1;
                 goto unlock;
@@ -1025,8 +1068,10 @@ unlock:
         return rc;
 }
 
-/*
- * transport error handler
+/**
+ * fc_fcp_error() - Handler for FCP layer errors
+ * @fsp: The FCP packet the error is on
+ * @fp:  The frame that has errored
  */
 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
@@ -1051,9 +1096,11 @@ unlock:
         fc_fcp_unlock_pkt(fsp);
 }
 
-/*
- * Scsi abort handler- calls to send an abort
- * and then wait for abort completion
+/**
+ * fc_fcp_pkt_abort() - Abort a fcp_pkt
+ * @fsp:   The FCP packet to abort on
+ *
+ * Called to send an abort and then wait for abort completion
  */
 static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
 {
@@ -1082,14 +1129,15 @@ static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
         return rc;
 }
 
-/*
- * Retry LUN reset after resource allocation failed.
+/**
+ * fc_lun_reset_send() - Send LUN reset command
+ * @data: The FCP packet that identifies the LUN to be reset
  */
 static void fc_lun_reset_send(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
-        struct fc_lport *lp = fsp->lp;
-        if (lp->tt.fcp_cmd_send(lp, fsp, fc_tm_done)) {
+        struct fc_lport *lport = fsp->lp;
+        if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
                 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
                         return;
                 if (fc_fcp_lock_pkt(fsp))
@@ -1100,11 +1148,15 @@ static void fc_lun_reset_send(unsigned long data)
         }
 }
 
-/*
- * Scsi device reset handler- send a LUN RESET to the device
- * and wait for reset reply
+/**
+ * fc_lun_reset() - Send a LUN RESET command to a device
+ *                  and wait for the reply
+ * @lport: The local port to sent the comand on
+ * @fsp:   The FCP packet that identifies the LUN to be reset
+ * @id:    The SCSI command ID
+ * @lun:   The LUN ID to be reset
  */
-static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
+static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
                         unsigned int id, unsigned int lun)
 {
         int rc;
@@ -1132,14 +1184,14 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
 
         spin_lock_bh(&fsp->scsi_pkt_lock);
         if (fsp->seq_ptr) {
-                lp->tt.exch_done(fsp->seq_ptr);
+                lport->tt.exch_done(fsp->seq_ptr);
                 fsp->seq_ptr = NULL;
         }
         fsp->wait_for_comp = 0;
         spin_unlock_bh(&fsp->scsi_pkt_lock);
 
         if (!rc) {
-                FC_SCSI_DBG(lp, "lun reset failed\n");
+                FC_SCSI_DBG(lport, "lun reset failed\n");
                 return FAILED;
         }
 
@@ -1147,13 +1199,16 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         if (fsp->cdb_status != FCP_TMF_CMPL)
                 return FAILED;
 
-        FC_SCSI_DBG(lp, "lun reset to lun %u completed\n", lun);
-        fc_fcp_cleanup_each_cmd(lp, id, lun, FC_CMD_ABORTED);
+        FC_SCSI_DBG(lport, "lun reset to lun %u completed\n", lun);
+        fc_fcp_cleanup_each_cmd(lport, id, lun, FC_CMD_ABORTED);
         return SUCCESS;
 }
 
-/*
- * Task Managment response handler
+/**
+ * fc_tm_done() - Task Managment response handler
+ * @seq: The sequence that the response is on
+ * @fp:  The response frame
+ * @arg: The FCP packet the response is for
  */
 static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1190,34 +1245,31 @@ static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         fc_fcp_unlock_pkt(fsp);
 }
 
-static void fc_fcp_cleanup(struct fc_lport *lp)
+/**
+ * fc_fcp_cleanup() - Cleanup all FCP exchanges on a local port
+ * @lport: The local port to be cleaned up
+ */
+static void fc_fcp_cleanup(struct fc_lport *lport)
 {
-        fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_ERROR);
+        fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_ERROR);
 }
 
-/*
- * fc_fcp_timeout: called by OS timer function.
- *
- * The timer has been inactivated and must be reactivated if desired
- * using fc_fcp_timer_set().
- *
- * Algorithm:
- *
- * If REC is supported, just issue it, and return.  The REC exchange will
- * complete or time out, and recovery can continue at that point.
- *
- * Otherwise, if the response has been received without all the data,
- * it has been ER_TIMEOUT since the response was received.
+/**
+ * fc_fcp_timeout() - Handler for fcp_pkt timeouts
+ * @data: The FCP packet that has timed out
  *
- * If the response has not been received,
- * we see if data was received recently.  If it has been, we continue waiting,
- * otherwise, we abort the command.
+ * If REC is supported then just issue it and return. The REC exchange will
+ * complete or time out and recovery can continue at that point. Otherwise,
+ * if the response has been received without all the data it has been
+ * ER_TIMEOUT since the response was received. If the response has not been
+ * received we see if data was received recently. If it has been then we
+ * continue waiting, otherwise, we abort the command.
  */
 static void fc_fcp_timeout(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
         struct fc_rport *rport = fsp->rport;
-        struct fc_rport_libfc_priv *rp = rport->dd_data;
+        struct fc_rport_libfc_priv *rpriv = rport->dd_data;
 
         if (fc_fcp_lock_pkt(fsp))
                 return;
@@ -1227,7 +1279,7 @@ static void fc_fcp_timeout(unsigned long data)
 
         fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
 
-        if (rp->flags & FC_RP_FLAGS_REC_SUPPORTED)
+        if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
                 fc_fcp_rec(fsp);
         else if (time_after_eq(fsp->last_pkt_time + (FC_SCSI_ER_TIMEOUT / 2),
                                jiffies))
@@ -1241,35 +1293,37 @@ unlock:
         fc_fcp_unlock_pkt(fsp);
 }
 
-/*
- * Send a REC ELS request
+/**
+ * fc_fcp_rec() - Send a REC ELS request
+ * @fsp: The FCP packet to send the REC request on
  */
 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_frame *fp;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
 
-        lp = fsp->lp;
+        lport = fsp->lp;
         rport = fsp->rport;
-        rp = rport->dd_data;
-        if (!fsp->seq_ptr || rp->rp_state != RPORT_ST_READY) {
+        rpriv = rport->dd_data;
+        if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
                 fsp->status_code = FC_HRD_ERROR;
                 fsp->io_status = 0;
                 fc_fcp_complete_locked(fsp);
                 return;
         }
-        fp = fc_frame_alloc(lp, sizeof(struct fc_els_rec));
+        fp = fc_frame_alloc(lport, sizeof(struct fc_els_rec));
         if (!fp)
                 goto retry;
 
         fr_seq(fp) = fsp->seq_ptr;
         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_ELS,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_ELS,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
-        if (lp->tt.elsct_send(lp, rport->port_id, fp, ELS_REC, fc_fcp_rec_resp,
-                              fsp, jiffies_to_msecs(FC_SCSI_REC_TOV))) {
+        if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
+                                 fc_fcp_rec_resp, fsp,
+                                 jiffies_to_msecs(FC_SCSI_REC_TOV))) {
                 fc_fcp_pkt_hold(fsp);           /* hold while REC outstanding */
                 return;
         }
@@ -1280,12 +1334,16 @@ retry:
                 fc_timeout_error(fsp);
 }
 
-/*
- * Receive handler for REC ELS frame
- * if it is a reject then let the scsi layer to handle
- * the timeout. if it is a LS_ACC then if the io was not completed
- * then set the timeout and return otherwise complete the exchange
- * and tell the scsi layer to restart the I/O.
+/**
+ * fc_fcp_rec_resp() - Handler for REC ELS responses
+ * @seq: The sequence the response is on
+ * @fp:  The response frame
+ * @arg: The FCP packet the response is on
+ *
+ * If the response is a reject then the scsi layer will handle
+ * the timeout. If the response is a LS_ACC then if the I/O was not completed
+ * set the timeout and return. If the I/O was completed then complete the
+ * exchange and tell the SCSI layer.
  */
 static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1297,7 +1355,7 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         u32 offset;
         enum dma_data_direction data_dir;
         enum fc_rctl r_ctl;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
 
         if (IS_ERR(fp)) {
                 fc_fcp_rec_error(fsp, fp);
@@ -1320,13 +1378,13 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                         /* fall through */
                 case ELS_RJT_UNSUP:
                         FC_FCP_DBG(fsp, "device does not support REC\n");
-                        rp = fsp->rport->dd_data;
+                        rpriv = fsp->rport->dd_data;
                         /*
                          * if we do not spport RECs or got some bogus
                          * reason then resetup timer so we check for
                          * making progress.
                          */
-                        rp->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
+                        rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
                         fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
                         break;
                 case ELS_RJT_LOGIC:
@@ -1423,8 +1481,10 @@ out:
         fc_frame_free(fp);
 }
 
-/*
- * Handle error response or timeout for REC exchange.
+/**
+ * fc_fcp_rec_error() - Handler for REC errors
+ * @fsp: The FCP packet the error is on
+ * @fp:  The REC frame
  */
 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
@@ -1463,10 +1523,9 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding REC */
 }
 
-/*
- * Time out error routine:
- * abort's the I/O close the exchange and
- * send completion notification to scsi layer
+/**
+ * fc_timeout_error() - Handler for fcp_pkt timeouts
+ * @fsp: The FCP packt that has timed out
  */
 static void fc_timeout_error(struct fc_fcp_pkt *fsp)
 {
@@ -1480,16 +1539,18 @@ static void fc_timeout_error(struct fc_fcp_pkt *fsp)
         fc_fcp_send_abort(fsp);
 }
 
-/*
- * Sequence retransmission request.
+/**
+ * fc_fcp_srr() - Send a SRR request (Sequence Retransmission Request)
+ * @fsp:   The FCP packet the SRR is to be sent on
+ * @r_ctl: The R_CTL field for the SRR request
  * This is called after receiving status but insufficient data, or
  * when expecting status but the request has timed out.
  */
 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
         struct fc_seq *seq;
         struct fcp_srr *srr;
@@ -1497,12 +1558,13 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         u8 cdb_op;
 
         rport = fsp->rport;
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
         cdb_op = fsp->cdb_cmd.fc_cdb[0];
 
-        if (!(rp->flags & FC_RP_FLAGS_RETRY) || rp->rp_state != RPORT_ST_READY)
+        if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
+            rpriv->rp_state != RPORT_ST_READY)
                 goto retry;                     /* shouldn't happen */
-        fp = fc_frame_alloc(lp, sizeof(*srr));
+        fp = fc_frame_alloc(lport, sizeof(*srr));
         if (!fp)
                 goto retry;
 
@@ -1515,11 +1577,11 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         srr->srr_rel_off = htonl(offset);
 
         fc_fill_fc_hdr(fp, FC_RCTL_ELS4_REQ, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_FCP,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
-        seq = lp->tt.exch_seq_send(lp, fp, fc_fcp_srr_resp, NULL,
-                                   fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
+        seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp, NULL,
+                                      fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
         if (!seq)
                 goto retry;
 
@@ -1533,8 +1595,11 @@ retry:
         fc_fcp_retry_cmd(fsp);
 }
 
-/*
- * Handle response from SRR.
+/**
+ * fc_fcp_srr_resp() - Handler for SRR response
+ * @seq: The sequence the SRR is on
+ * @fp:  The SRR frame
+ * @arg: The FCP packet the SRR is on
  */
 static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1580,6 +1645,11 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
 }
 
+/**
+ * fc_fcp_srr_error() - Handler for SRR errors
+ * @fsp: The FCP packet that the SRR error is on
+ * @fp:  The SRR frame
+ */
 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         if (fc_fcp_lock_pkt(fsp))
@@ -1604,31 +1674,36 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
 }
 
-static inline int fc_fcp_lport_queue_ready(struct fc_lport *lp)
+/**
+ * fc_fcp_lport_queue_ready() - Determine if the lport and it's queue is ready
+ * @lport: The local port to be checked
+ */
+static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
 {
         /* lock ? */
-        return (lp->state == LPORT_ST_READY) && lp->link_up && !lp->qfull;
+        return (lport->state == LPORT_ST_READY) &&
+                lport->link_up && !lport->qfull;
 }
 
 /**
- * fc_queuecommand - The queuecommand function of the scsi template
- * @cmd:        struct scsi_cmnd to be executed
- * @done:       Callback function to be called when cmd is completed
+ * fc_queuecommand() - The queuecommand function of the SCSI template
+ * @cmd:   The scsi_cmnd to be executed
+ * @done:  The callback function to be called when the scsi_cmnd is complete
  *
- * this is the i/o strategy routine, called by the scsi layer
- * this routine is called with holding the host_lock.
+ * This is the i/o strategy routine, called by the SCSI layer. This routine
+ * is called with the host_lock held.
  */
 int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
         struct fc_fcp_pkt *fsp;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         int rval;
         int rc = 0;
         struct fcoe_dev_stats *stats;
 
-        lp = shost_priv(sc_cmd->device->host);
+        lport = shost_priv(sc_cmd->device->host);
 
         rval = fc_remote_port_chkready(rport);
         if (rval) {
@@ -1647,14 +1722,14 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
                 goto out;
         }
 
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
 
-        if (!fc_fcp_lport_queue_ready(lp)) {
+        if (!fc_fcp_lport_queue_ready(lport)) {
                 rc = SCSI_MLQUEUE_HOST_BUSY;
                 goto out;
         }
 
-        fsp = fc_fcp_pkt_alloc(lp, GFP_ATOMIC);
+        fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
         if (fsp == NULL) {
                 rc = SCSI_MLQUEUE_HOST_BUSY;
                 goto out;
@@ -1664,7 +1739,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
          * build the libfc request pkt
          */
         fsp->cmd = sc_cmd;      /* save the cmd */
-        fsp->lp = lp;           /* save the softc ptr */
+        fsp->lp = lport;        /* save the softc ptr */
         fsp->rport = rport;     /* set the remote port ptr */
         fsp->xfer_ddp = FC_XID_UNKNOWN;
         sc_cmd->scsi_done = done;
@@ -1678,7 +1753,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
         /*
          * setup the data direction
          */
-        stats = fc_lport_get_stats(lp);
+        stats = fc_lport_get_stats(lport);
         if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
                 fsp->req_flags = FC_SRB_READ;
                 stats->InputRequests++;
@@ -1692,7 +1767,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
                 stats->ControlRequests++;
         }
 
-        fsp->tgt_flags = rp->flags;
+        fsp->tgt_flags = rpriv->flags;
 
         init_timer(&fsp->timer);
         fsp->timer.data = (unsigned long)fsp;
@@ -1702,7 +1777,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
          * if we get -1 return then put the request in the pending
          * queue.
          */
-        rval = fc_fcp_pkt_send(lp, fsp);
+        rval = fc_fcp_pkt_send(lport, fsp);
         if (rval != 0) {
                 fsp->state = FC_SRB_FREE;
                 fc_fcp_pkt_release(fsp);
@@ -1714,18 +1789,17 @@ out:
 EXPORT_SYMBOL(fc_queuecommand);
 
 /**
- * fc_io_compl() -  Handle responses for completed commands
- * @fsp:        scsi packet
- *
- * Translates a error to a Linux SCSI error.
+ * fc_io_compl() - Handle responses for completed commands
+ * @fsp: The FCP packet that is complete
  *
+ * Translates fcp_pkt errors to a Linux SCSI errors.
  * The fcp packet lock must be held when calling.
  */
 static void fc_io_compl(struct fc_fcp_pkt *fsp)
 {
         struct fc_fcp_internal *si;
         struct scsi_cmnd *sc_cmd;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         unsigned long flags;
 
         /* release outstanding ddp context */
@@ -1738,11 +1812,11 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                 spin_lock_bh(&fsp->scsi_pkt_lock);
         }
 
-        lp = fsp->lp;
-        si = fc_get_scsi_internal(lp);
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        lport = fsp->lp;
+        si = fc_get_scsi_internal(lport);
+        spin_lock_irqsave(lport->host->host_lock, flags);
         if (!fsp->cmd) {
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(lport->host->host_lock, flags);
                 return;
         }
 
@@ -1759,7 +1833,7 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
         fsp->cmd = NULL;
 
         if (!sc_cmd->SCp.ptr) {
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(lport->host->host_lock, flags);
                 return;
         }
 
@@ -1826,7 +1900,7 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
         list_del(&fsp->list);
         sc_cmd->SCp.ptr = NULL;
         sc_cmd->scsi_done(sc_cmd);
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 
         /* release ref from initial allocation in queue command */
         fc_fcp_pkt_release(fsp);
@@ -1834,35 +1908,34 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
 
 /**
  * fc_eh_abort() - Abort a command
- * @sc_cmd:     scsi command to abort
+ * @sc_cmd: The SCSI command to abort
  *
- * From scsi host template.
- * send ABTS to the target device  and wait for the response
- * sc_cmd is the pointer to the command to be aborted.
+ * From SCSI host template.
+ * Send an ABTS to the target device and wait for the response.
  */
 int fc_eh_abort(struct scsi_cmnd *sc_cmd)
 {
         struct fc_fcp_pkt *fsp;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         int rc = FAILED;
         unsigned long flags;
 
-        lp = shost_priv(sc_cmd->device->host);
-        if (lp->state != LPORT_ST_READY)
+        lport = shost_priv(sc_cmd->device->host);
+        if (lport->state != LPORT_ST_READY)
                 return rc;
-        else if (!lp->link_up)
+        else if (!lport->link_up)
                 return rc;
 
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        spin_lock_irqsave(lport->host->host_lock, flags);
         fsp = CMD_SP(sc_cmd);
         if (!fsp) {
                 /* command completed while scsi eh was setting up */
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(lport->host->host_lock, flags);
                 return SUCCESS;
         }
         /* grab a ref so the fsp and sc_cmd cannot be relased from under us */
         fc_fcp_pkt_hold(fsp);
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 
         if (fc_fcp_lock_pkt(fsp)) {
                 /* completed while we were waiting for timer to be deleted */
@@ -1880,34 +1953,32 @@ release_pkt:
 EXPORT_SYMBOL(fc_eh_abort);
 
 /**
- * fc_eh_device_reset() Reset a single LUN
- * @sc_cmd:     scsi command
+ * fc_eh_device_reset() - Reset a single LUN
+ * @sc_cmd: The SCSI command which identifies the device whose
+ *          LUN is to be reset
  *
- * Set from scsi host template to send tm cmd to the target and wait for the
- * response.
+ * Set from SCSI host template.
  */
 int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_fcp_pkt *fsp;
         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
         int rc = FAILED;
-        struct fc_rport_libfc_priv *rp;
         int rval;
 
         rval = fc_remote_port_chkready(rport);
         if (rval)
                 goto out;
 
-        rp = rport->dd_data;
-        lp = shost_priv(sc_cmd->device->host);
+        lport = shost_priv(sc_cmd->device->host);
 
-        if (lp->state != LPORT_ST_READY)
+        if (lport->state != LPORT_ST_READY)
                 return rc;
 
-        FC_SCSI_DBG(lp, "Resetting rport (%6x)\n", rport->port_id);
+        FC_SCSI_DBG(lport, "Resetting rport (%6x)\n", rport->port_id);
 
-        fsp = fc_fcp_pkt_alloc(lp, GFP_NOIO);
+        fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
         if (fsp == NULL) {
                 printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
                 sc_cmd->result = DID_NO_CONNECT << 16;
@@ -1919,13 +1990,13 @@ int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
          * the sc passed in is not setup for execution like when sent
          * through the queuecommand callout.
          */
-        fsp->lp = lp;           /* save the softc ptr */
+        fsp->lp = lport;        /* save the softc ptr */
         fsp->rport = rport;     /* set the remote port ptr */
 
         /*
          * flush outstanding commands
          */
-        rc = fc_lun_reset(lp, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
+        rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
         fsp->state = FC_SRB_FREE;
         fc_fcp_pkt_release(fsp);
 
@@ -1935,38 +2006,39 @@ out:
 EXPORT_SYMBOL(fc_eh_device_reset);
 
 /**
- * fc_eh_host_reset() - The reset function will reset the ports on the host.
- * @sc_cmd:     scsi command
+ * fc_eh_host_reset() - Reset a Scsi_Host.
+ * @sc_cmd: The SCSI command that identifies the SCSI host to be reset
  */
 int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
 {
         struct Scsi_Host *shost = sc_cmd->device->host;
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
         unsigned long wait_tmo;
 
-        FC_SCSI_DBG(lp, "Resetting host\n");
+        FC_SCSI_DBG(lport, "Resetting host\n");
 
-        lp->tt.lport_reset(lp);
+        lport->tt.lport_reset(lport);
         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
-        while (!fc_fcp_lport_queue_ready(lp) && time_before(jiffies, wait_tmo))
+        while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
+                                                               wait_tmo))
                 msleep(1000);
 
-        if (fc_fcp_lport_queue_ready(lp)) {
+        if (fc_fcp_lport_queue_ready(lport)) {
                 shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
-                             "on port (%6x)\n", fc_host_port_id(lp->host));
+                             "on port (%6x)\n", fc_host_port_id(lport->host));
                 return SUCCESS;
         } else {
                 shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
                              "port (%6x) is not ready.\n",
-                             fc_host_port_id(lp->host));
+                             fc_host_port_id(lport->host));
                 return FAILED;
         }
 }
 EXPORT_SYMBOL(fc_eh_host_reset);
 
 /**
- * fc_slave_alloc() - configure queue depth
- * @sdev:       scsi device
+ * fc_slave_alloc() - Configure the queue depth of a Scsi_Host
+ * @sdev: The SCSI device that identifies the SCSI host
  *
  * Configures queue depth based on host's cmd_per_len. If not set
  * then we use the libfc default.
@@ -1988,6 +2060,12 @@ int fc_slave_alloc(struct scsi_device *sdev)
 }
 EXPORT_SYMBOL(fc_slave_alloc);
 
+/**
+ * fc_change_queue_depth() - Change a device's queue depth
+ * @sdev:   The SCSI device whose queue depth is to change
+ * @qdepth: The new queue depth
+ * @reason: The resason for the change
+ */
 int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
         switch (reason) {
@@ -2007,6 +2085,11 @@ int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 }
 EXPORT_SYMBOL(fc_change_queue_depth);
 
+/**
+ * fc_change_queue_type() - Change a device's queue type
+ * @sdev:     The SCSI device whose queue depth is to change
+ * @tag_type: Identifier for queue type
+ */
 int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
 {
         if (sdev->tagged_supported) {
@@ -2022,17 +2105,21 @@ int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
 }
 EXPORT_SYMBOL(fc_change_queue_type);
 
-void fc_fcp_destroy(struct fc_lport *lp)
+/**
+ * fc_fcp_destory() - Tear down the FCP layer for a given local port
+ * @lport: The local port that no longer needs the FCP layer
+ */
+void fc_fcp_destroy(struct fc_lport *lport)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
 
         if (!list_empty(&si->scsi_pkt_queue))
                 printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
-                       "port (%6x)\n", fc_host_port_id(lp->host));
+                       "port (%6x)\n", fc_host_port_id(lport->host));
 
         mempool_destroy(si->scsi_pkt_pool);
         kfree(si);
-        lp->scsi_priv = NULL;
+        lport->scsi_priv = NULL;
 }
 EXPORT_SYMBOL(fc_fcp_destroy);
 
@@ -2058,24 +2145,28 @@ void fc_destroy_fcp()
                 kmem_cache_destroy(scsi_pkt_cachep);
 }
 
-int fc_fcp_init(struct fc_lport *lp)
+/**
+ * fc_fcp_init() - Initialize the FCP layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
+int fc_fcp_init(struct fc_lport *lport)
 {
         int rc;
         struct fc_fcp_internal *si;
 
-        if (!lp->tt.fcp_cmd_send)
-                lp->tt.fcp_cmd_send = fc_fcp_cmd_send;
+        if (!lport->tt.fcp_cmd_send)
+                lport->tt.fcp_cmd_send = fc_fcp_cmd_send;
 
-        if (!lp->tt.fcp_cleanup)
-                lp->tt.fcp_cleanup = fc_fcp_cleanup;
+        if (!lport->tt.fcp_cleanup)
+                lport->tt.fcp_cleanup = fc_fcp_cleanup;
 
-        if (!lp->tt.fcp_abort_io)
-                lp->tt.fcp_abort_io = fc_fcp_abort_io;
+        if (!lport->tt.fcp_abort_io)
+                lport->tt.fcp_abort_io = fc_fcp_abort_io;
 
         si = kzalloc(sizeof(struct fc_fcp_internal), GFP_KERNEL);
         if (!si)
                 return -ENOMEM;
-        lp->scsi_priv = si;
+        lport->scsi_priv = si;
         INIT_LIST_HEAD(&si->scsi_pkt_queue);
 
         si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);