tree-wide: fix typos "ammount" -> "amount"
[linux-2.6.git] / drivers / scsi / libfc / fc_fcp.c
1 /*
2  * Copyright(c) 2007 Intel Corporation. All rights reserved.
3  * Copyright(c) 2008 Red Hat, Inc.  All rights reserved.
4  * Copyright(c) 2008 Mike Christie
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along with
16  * this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Maintained at www.Open-FCoE.org
20  */
21
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/kernel.h>
25 #include <linux/types.h>
26 #include <linux/spinlock.h>
27 #include <linux/scatterlist.h>
28 #include <linux/err.h>
29 #include <linux/crc32.h>
30
31 #include <scsi/scsi_tcq.h>
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_host.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_cmnd.h>
36
37 #include <scsi/fc/fc_fc2.h>
38
39 #include <scsi/libfc.h>
40 #include <scsi/fc_encode.h>
41
42 #include "fc_libfc.h"
43
44 struct kmem_cache *scsi_pkt_cachep;
45
46 /* SRB state definitions */
47 #define FC_SRB_FREE             0               /* cmd is free */
48 #define FC_SRB_CMD_SENT         (1 << 0)        /* cmd has been sent */
49 #define FC_SRB_RCV_STATUS       (1 << 1)        /* response has arrived */
50 #define FC_SRB_ABORT_PENDING    (1 << 2)        /* cmd abort sent to device */
51 #define FC_SRB_ABORTED          (1 << 3)        /* abort acknowleged */
52 #define FC_SRB_DISCONTIG        (1 << 4)        /* non-sequential data recvd */
53 #define FC_SRB_COMPL            (1 << 5)        /* fc_io_compl has been run */
54 #define FC_SRB_FCP_PROCESSING_TMO (1 << 6)      /* timer function processing */
55
56 #define FC_SRB_READ             (1 << 1)
57 #define FC_SRB_WRITE            (1 << 0)
58
59 /*
60  * The SCp.ptr should be tested and set under the host lock. NULL indicates
61  * that the command has been retruned to the scsi layer.
62  */
63 #define CMD_SP(Cmnd)                ((struct fc_fcp_pkt *)(Cmnd)->SCp.ptr)
64 #define CMD_ENTRY_STATUS(Cmnd)      ((Cmnd)->SCp.have_data_in)
65 #define CMD_COMPL_STATUS(Cmnd)      ((Cmnd)->SCp.this_residual)
66 #define CMD_SCSI_STATUS(Cmnd)       ((Cmnd)->SCp.Status)
67 #define CMD_RESID_LEN(Cmnd)         ((Cmnd)->SCp.buffers_residual)
68
69 /**
70  * struct fc_fcp_internal - FCP layer internal data
71  * @scsi_pkt_pool: Memory pool to draw FCP packets from
72  * @scsi_queue_lock: Protects the scsi_pkt_queue
73  * @scsi_pkt_queue: Current FCP packets
74  * @last_can_queue_ramp_down_time: ramp down time
75  * @last_can_queue_ramp_up_time: ramp up time
76  * @max_can_queue: max can_queue size
77  */
78 struct fc_fcp_internal {
79         mempool_t               *scsi_pkt_pool;
80         spinlock_t              scsi_queue_lock;
81         struct list_head        scsi_pkt_queue;
82         unsigned long           last_can_queue_ramp_down_time;
83         unsigned long           last_can_queue_ramp_up_time;
84         int                     max_can_queue;
85 };
86
87 #define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
88
89 /*
90  * function prototypes
91  * FC scsi I/O related functions
92  */
93 static void fc_fcp_recv_data(struct fc_fcp_pkt *, struct fc_frame *);
94 static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
95 static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
96 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
97 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
98 static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
99 static void fc_timeout_error(struct fc_fcp_pkt *);
100 static void fc_fcp_timeout(unsigned long);
101 static void fc_fcp_rec(struct fc_fcp_pkt *);
102 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
103 static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
104 static void fc_io_compl(struct fc_fcp_pkt *);
105
106 static void fc_fcp_srr(struct fc_fcp_pkt *, enum fc_rctl, u32);
107 static void fc_fcp_srr_resp(struct fc_seq *, struct fc_frame *, void *);
108 static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
109
110 /*
111  * command status codes
112  */
113 #define FC_COMPLETE             0
114 #define FC_CMD_ABORTED          1
115 #define FC_CMD_RESET            2
116 #define FC_CMD_PLOGO            3
117 #define FC_SNS_RCV              4
118 #define FC_TRANS_ERR            5
119 #define FC_DATA_OVRRUN          6
120 #define FC_DATA_UNDRUN          7
121 #define FC_ERROR                8
122 #define FC_HRD_ERROR            9
123 #define FC_CMD_TIME_OUT         10
124
125 /*
126  * Error recovery timeout values.
127  */
128 #define FC_SCSI_ER_TIMEOUT      (10 * HZ)
129 #define FC_SCSI_TM_TOV          (10 * HZ)
130 #define FC_SCSI_REC_TOV         (2 * HZ)
131 #define FC_HOST_RESET_TIMEOUT   (30 * HZ)
132 #define FC_CAN_QUEUE_PERIOD     (60 * HZ)
133
134 #define FC_MAX_ERROR_CNT        5
135 #define FC_MAX_RECOV_RETRY      3
136
137 #define FC_FCP_DFLT_QUEUE_DEPTH 32
138
139 /**
140  * fc_fcp_pkt_alloc() - Allocate a fcp_pkt
141  * @lport: The local port that the FCP packet is for
142  * @gfp:   GFP flags for allocation
143  *
144  * Return value: fcp_pkt structure or null on allocation failure.
145  * Context:      Can be called from process context, no lock is required.
146  */
147 static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lport, gfp_t gfp)
148 {
149         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
150         struct fc_fcp_pkt *fsp;
151
152         fsp = mempool_alloc(si->scsi_pkt_pool, gfp);
153         if (fsp) {
154                 memset(fsp, 0, sizeof(*fsp));
155                 fsp->lp = lport;
156                 atomic_set(&fsp->ref_cnt, 1);
157                 init_timer(&fsp->timer);
158                 INIT_LIST_HEAD(&fsp->list);
159                 spin_lock_init(&fsp->scsi_pkt_lock);
160         }
161         return fsp;
162 }
163
164 /**
165  * fc_fcp_pkt_release() - Release hold on a fcp_pkt
166  * @fsp: The FCP packet to be released
167  *
168  * Context: Can be called from process or interrupt context,
169  *          no lock is required.
170  */
171 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
172 {
173         if (atomic_dec_and_test(&fsp->ref_cnt)) {
174                 struct fc_fcp_internal *si = fc_get_scsi_internal(fsp->lp);
175
176                 mempool_free(fsp, si->scsi_pkt_pool);
177         }
178 }
179
180 /**
181  * fc_fcp_pkt_hold() - Hold a fcp_pkt
182  * @fsp: The FCP packet to be held
183  */
184 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
185 {
186         atomic_inc(&fsp->ref_cnt);
187 }
188
189 /**
190  * fc_fcp_pkt_destory() - Release hold on a fcp_pkt
191  * @seq: The sequence that the FCP packet is on (required by destructor API)
192  * @fsp: The FCP packet to be released
193  *
194  * This routine is called by a destructor callback in the exch_seq_send()
195  * routine of the libfc Transport Template. The 'struct fc_seq' is a required
196  * argument even though it is not used by this routine.
197  *
198  * Context: No locking required.
199  */
200 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
201 {
202         fc_fcp_pkt_release(fsp);
203 }
204
205 /**
206  * fc_fcp_lock_pkt() - Lock a fcp_pkt and increase its reference count
207  * @fsp: The FCP packet to be locked and incremented
208  *
209  * We should only return error if we return a command to SCSI-ml before
210  * getting a response. This can happen in cases where we send a abort, but
211  * do not wait for the response and the abort and command can be passing
212  * each other on the wire/network-layer.
213  *
214  * Note: this function locks the packet and gets a reference to allow
215  * callers to call the completion function while the lock is held and
216  * not have to worry about the packets refcount.
217  *
218  * TODO: Maybe we should just have callers grab/release the lock and
219  * have a function that they call to verify the fsp and grab a ref if
220  * needed.
221  */
222 static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
223 {
224         spin_lock_bh(&fsp->scsi_pkt_lock);
225         if (fsp->state & FC_SRB_COMPL) {
226                 spin_unlock_bh(&fsp->scsi_pkt_lock);
227                 return -EPERM;
228         }
229
230         fc_fcp_pkt_hold(fsp);
231         return 0;
232 }
233
234 /**
235  * fc_fcp_unlock_pkt() - Release a fcp_pkt's lock and decrement its
236  *                       reference count
237  * @fsp: The FCP packet to be unlocked and decremented
238  */
239 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
240 {
241         spin_unlock_bh(&fsp->scsi_pkt_lock);
242         fc_fcp_pkt_release(fsp);
243 }
244
245 /**
246  * fc_fcp_timer_set() - Start a timer for a fcp_pkt
247  * @fsp:   The FCP packet to start a timer for
248  * @delay: The timeout period for the timer
249  */
250 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
251 {
252         if (!(fsp->state & FC_SRB_COMPL))
253                 mod_timer(&fsp->timer, jiffies + delay);
254 }
255
256 /**
257  * fc_fcp_send_abort() - Send an abort for exchanges associated with a
258  *                       fcp_pkt
259  * @fsp: The FCP packet to abort exchanges on
260  */
261 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
262 {
263         if (!fsp->seq_ptr)
264                 return -EINVAL;
265
266         fsp->state |= FC_SRB_ABORT_PENDING;
267         return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
268 }
269
270 /**
271  * fc_fcp_retry_cmd() - Retry a fcp_pkt
272  * @fsp: The FCP packet to be retried
273  *
274  * Sets the status code to be FC_ERROR and then calls
275  * fc_fcp_complete_locked() which in turn calls fc_io_compl().
276  * fc_io_compl() will notify the SCSI-ml that the I/O is done.
277  * The SCSI-ml will retry the command.
278  */
279 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
280 {
281         if (fsp->seq_ptr) {
282                 fsp->lp->tt.exch_done(fsp->seq_ptr);
283                 fsp->seq_ptr = NULL;
284         }
285
286         fsp->state &= ~FC_SRB_ABORT_PENDING;
287         fsp->io_status = 0;
288         fsp->status_code = FC_ERROR;
289         fc_fcp_complete_locked(fsp);
290 }
291
292 /**
293  * fc_fcp_ddp_setup() - Calls a LLD's ddp_setup routine to set up DDP context
294  * @fsp: The FCP packet that will manage the DDP frames
295  * @xid: The XID that will be used for the DDP exchange
296  */
297 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
298 {
299         struct fc_lport *lport;
300
301         if (!fsp)
302                 return;
303
304         lport = fsp->lp;
305         if ((fsp->req_flags & FC_SRB_READ) &&
306             (lport->lro_enabled) && (lport->tt.ddp_setup)) {
307                 if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
308                                         scsi_sg_count(fsp->cmd)))
309                         fsp->xfer_ddp = xid;
310         }
311 }
312
313 /**
314  * fc_fcp_ddp_done() - Calls a LLD's ddp_done routine to release any
315  *                     DDP related resources for a fcp_pkt
316  * @fsp: The FCP packet that DDP had been used on
317  */
318 static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
319 {
320         struct fc_lport *lport;
321
322         if (!fsp)
323                 return;
324
325         if (fsp->xfer_ddp == FC_XID_UNKNOWN)
326                 return;
327
328         lport = fsp->lp;
329         if (lport->tt.ddp_done) {
330                 fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
331                 fsp->xfer_ddp = FC_XID_UNKNOWN;
332         }
333 }
334
335 /**
336  * fc_fcp_can_queue_ramp_up() - increases can_queue
337  * @lport: lport to ramp up can_queue
338  *
339  * Locking notes: Called with Scsi_Host lock held
340  */
341 static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
342 {
343         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
344         int can_queue;
345
346         if (si->last_can_queue_ramp_up_time &&
347             (time_before(jiffies, si->last_can_queue_ramp_up_time +
348                          FC_CAN_QUEUE_PERIOD)))
349                 return;
350
351         if (time_before(jiffies, si->last_can_queue_ramp_down_time +
352                         FC_CAN_QUEUE_PERIOD))
353                 return;
354
355         si->last_can_queue_ramp_up_time = jiffies;
356
357         can_queue = lport->host->can_queue << 1;
358         if (can_queue >= si->max_can_queue) {
359                 can_queue = si->max_can_queue;
360                 si->last_can_queue_ramp_down_time = 0;
361         }
362         lport->host->can_queue = can_queue;
363         shost_printk(KERN_ERR, lport->host, "libfc: increased "
364                      "can_queue to %d.\n", can_queue);
365 }
366
367 /**
368  * fc_fcp_can_queue_ramp_down() - reduces can_queue
369  * @lport: lport to reduce can_queue
370  *
371  * If we are getting memory allocation failures, then we may
372  * be trying to execute too many commands. We let the running
373  * commands complete or timeout, then try again with a reduced
374  * can_queue. Eventually we will hit the point where we run
375  * on all reserved structs.
376  *
377  * Locking notes: Called with Scsi_Host lock held
378  */
379 static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
380 {
381         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
382         int can_queue;
383
384         if (si->last_can_queue_ramp_down_time &&
385             (time_before(jiffies, si->last_can_queue_ramp_down_time +
386                          FC_CAN_QUEUE_PERIOD)))
387                 return;
388
389         si->last_can_queue_ramp_down_time = jiffies;
390
391         can_queue = lport->host->can_queue;
392         can_queue >>= 1;
393         if (!can_queue)
394                 can_queue = 1;
395         lport->host->can_queue = can_queue;
396         shost_printk(KERN_ERR, lport->host, "libfc: Could not allocate frame.\n"
397                      "Reducing can_queue to %d.\n", can_queue);
398 }
399
400 /*
401  * fc_fcp_frame_alloc() -  Allocates fc_frame structure and buffer.
402  * @lport:      fc lport struct
403  * @len:        payload length
404  *
405  * Allocates fc_frame structure and buffer but if fails to allocate
406  * then reduce can_queue.
407  */
408 static inline struct fc_frame *fc_fcp_frame_alloc(struct fc_lport *lport,
409                                                   size_t len)
410 {
411         struct fc_frame *fp;
412         unsigned long flags;
413
414         fp = fc_frame_alloc(lport, len);
415         if (likely(fp))
416                 return fp;
417
418         /* error case */
419         spin_lock_irqsave(lport->host->host_lock, flags);
420         fc_fcp_can_queue_ramp_down(lport);
421         spin_unlock_irqrestore(lport->host->host_lock, flags);
422         return NULL;
423 }
424
425 /**
426  * fc_fcp_recv_data() - Handler for receiving SCSI-FCP data from a target
427  * @fsp: The FCP packet the data is on
428  * @fp:  The data frame
429  */
430 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
431 {
432         struct scsi_cmnd *sc = fsp->cmd;
433         struct fc_lport *lport = fsp->lp;
434         struct fcoe_dev_stats *stats;
435         struct fc_frame_header *fh;
436         size_t start_offset;
437         size_t offset;
438         u32 crc;
439         u32 copy_len = 0;
440         size_t len;
441         void *buf;
442         struct scatterlist *sg;
443         u32 nents;
444
445         fh = fc_frame_header_get(fp);
446         offset = ntohl(fh->fh_parm_offset);
447         start_offset = offset;
448         len = fr_len(fp) - sizeof(*fh);
449         buf = fc_frame_payload_get(fp, 0);
450
451         /* if this I/O is ddped, update xfer len */
452         fc_fcp_ddp_done(fsp);
453
454         if (offset + len > fsp->data_len) {
455                 /* this should never happen */
456                 if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
457                     fc_frame_crc_check(fp))
458                         goto crc_err;
459                 FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
460                            "data_len %x\n", len, offset, fsp->data_len);
461                 fc_fcp_retry_cmd(fsp);
462                 return;
463         }
464         if (offset != fsp->xfer_len)
465                 fsp->state |= FC_SRB_DISCONTIG;
466
467         sg = scsi_sglist(sc);
468         nents = scsi_sg_count(sc);
469
470         if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
471                 copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
472                                                     &offset, KM_SOFTIRQ0, NULL);
473         } else {
474                 crc = crc32(~0, (u8 *) fh, sizeof(*fh));
475                 copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
476                                                     &offset, KM_SOFTIRQ0, &crc);
477                 buf = fc_frame_payload_get(fp, 0);
478                 if (len % 4)
479                         crc = crc32(crc, buf + len, 4 - (len % 4));
480
481                 if (~crc != le32_to_cpu(fr_crc(fp))) {
482 crc_err:
483                         stats = fc_lport_get_stats(lport);
484                         stats->ErrorFrames++;
485                         /* FIXME - per cpu count, not total count! */
486                         if (stats->InvalidCRCCount++ < 5)
487                                 printk(KERN_WARNING "libfc: CRC error on data "
488                                        "frame for port (%6x)\n",
489                                        fc_host_port_id(lport->host));
490                         /*
491                          * Assume the frame is total garbage.
492                          * We may have copied it over the good part
493                          * of the buffer.
494                          * If so, we need to retry the entire operation.
495                          * Otherwise, ignore it.
496                          */
497                         if (fsp->state & FC_SRB_DISCONTIG)
498                                 fc_fcp_retry_cmd(fsp);
499                         return;
500                 }
501         }
502
503         if (fsp->xfer_contig_end == start_offset)
504                 fsp->xfer_contig_end += copy_len;
505         fsp->xfer_len += copy_len;
506
507         /*
508          * In the very rare event that this data arrived after the response
509          * and completes the transfer, call the completion handler.
510          */
511         if (unlikely(fsp->state & FC_SRB_RCV_STATUS) &&
512             fsp->xfer_len == fsp->data_len - fsp->scsi_resid)
513                 fc_fcp_complete_locked(fsp);
514 }
515
516 /**
517  * fc_fcp_send_data() - Send SCSI data to a target
518  * @fsp:      The FCP packet the data is on
519  * @sp:       The sequence the data is to be sent on
520  * @offset:   The starting offset for this data request
521  * @seq_blen: The burst length for this data request
522  *
523  * Called after receiving a Transfer Ready data descriptor.
524  * If the LLD is capable of sequence offload then send down the
525  * seq_blen amount of data in single frame, otherwise send
526  * multiple frames of the maximum frame payload supported by
527  * the target port.
528  */
529 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
530                             size_t offset, size_t seq_blen)
531 {
532         struct fc_exch *ep;
533         struct scsi_cmnd *sc;
534         struct scatterlist *sg;
535         struct fc_frame *fp = NULL;
536         struct fc_lport *lport = fsp->lp;
537         struct page *page;
538         size_t remaining;
539         size_t t_blen;
540         size_t tlen;
541         size_t sg_bytes;
542         size_t frame_offset, fh_parm_offset;
543         size_t off;
544         int error;
545         void *data = NULL;
546         void *page_addr;
547         int using_sg = lport->sg_supp;
548         u32 f_ctl;
549
550         WARN_ON(seq_blen <= 0);
551         if (unlikely(offset + seq_blen > fsp->data_len)) {
552                 /* this should never happen */
553                 FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
554                            "offset %zx\n", seq_blen, offset);
555                 fc_fcp_send_abort(fsp);
556                 return 0;
557         } else if (offset != fsp->xfer_len) {
558                 /* Out of Order Data Request - no problem, but unexpected. */
559                 FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
560                            "seq_blen %zx offset %zx\n", seq_blen, offset);
561         }
562
563         /*
564          * if LLD is capable of seq_offload then set transport
565          * burst length (t_blen) to seq_blen, otherwise set t_blen
566          * to max FC frame payload previously set in fsp->max_payload.
567          */
568         t_blen = fsp->max_payload;
569         if (lport->seq_offload) {
570                 t_blen = min(seq_blen, (size_t)lport->lso_max);
571                 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
572                            fsp, seq_blen, lport->lso_max, t_blen);
573         }
574
575         WARN_ON(t_blen < FC_MIN_MAX_PAYLOAD);
576         if (t_blen > 512)
577                 t_blen &= ~(512 - 1);   /* round down to block size */
578         WARN_ON(t_blen < FC_MIN_MAX_PAYLOAD);   /* won't go below 256 */
579         sc = fsp->cmd;
580
581         remaining = seq_blen;
582         fh_parm_offset = frame_offset = offset;
583         tlen = 0;
584         seq = lport->tt.seq_start_next(seq);
585         f_ctl = FC_FC_REL_OFF;
586         WARN_ON(!seq);
587
588         sg = scsi_sglist(sc);
589
590         while (remaining > 0 && sg) {
591                 if (offset >= sg->length) {
592                         offset -= sg->length;
593                         sg = sg_next(sg);
594                         continue;
595                 }
596                 if (!fp) {
597                         tlen = min(t_blen, remaining);
598
599                         /*
600                          * TODO.  Temporary workaround.  fc_seq_send() can't
601                          * handle odd lengths in non-linear skbs.
602                          * This will be the final fragment only.
603                          */
604                         if (tlen % 4)
605                                 using_sg = 0;
606                         fp = fc_frame_alloc(lport, using_sg ? 0 : tlen);
607                         if (!fp)
608                                 return -ENOMEM;
609
610                         data = fc_frame_header_get(fp) + 1;
611                         fh_parm_offset = frame_offset;
612                         fr_max_payload(fp) = fsp->max_payload;
613                 }
614
615                 off = offset + sg->offset;
616                 sg_bytes = min(tlen, sg->length - offset);
617                 sg_bytes = min(sg_bytes,
618                                (size_t) (PAGE_SIZE - (off & ~PAGE_MASK)));
619                 page = sg_page(sg) + (off >> PAGE_SHIFT);
620                 if (using_sg) {
621                         get_page(page);
622                         skb_fill_page_desc(fp_skb(fp),
623                                            skb_shinfo(fp_skb(fp))->nr_frags,
624                                            page, off & ~PAGE_MASK, sg_bytes);
625                         fp_skb(fp)->data_len += sg_bytes;
626                         fr_len(fp) += sg_bytes;
627                         fp_skb(fp)->truesize += PAGE_SIZE;
628                 } else {
629                         /*
630                          * The scatterlist item may be bigger than PAGE_SIZE,
631                          * but we must not cross pages inside the kmap.
632                          */
633                         page_addr = kmap_atomic(page, KM_SOFTIRQ0);
634                         memcpy(data, (char *)page_addr + (off & ~PAGE_MASK),
635                                sg_bytes);
636                         kunmap_atomic(page_addr, KM_SOFTIRQ0);
637                         data += sg_bytes;
638                 }
639                 offset += sg_bytes;
640                 frame_offset += sg_bytes;
641                 tlen -= sg_bytes;
642                 remaining -= sg_bytes;
643
644                 if ((skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN) &&
645                     (tlen))
646                         continue;
647
648                 /*
649                  * Send sequence with transfer sequence initiative in case
650                  * this is last FCP frame of the sequence.
651                  */
652                 if (remaining == 0)
653                         f_ctl |= FC_FC_SEQ_INIT | FC_FC_END_SEQ;
654
655                 ep = fc_seq_exch(seq);
656                 fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
657                                FC_TYPE_FCP, f_ctl, fh_parm_offset);
658
659                 /*
660                  * send fragment using for a sequence.
661                  */
662                 error = lport->tt.seq_send(lport, seq, fp);
663                 if (error) {
664                         WARN_ON(1);             /* send error should be rare */
665                         fc_fcp_retry_cmd(fsp);
666                         return 0;
667                 }
668                 fp = NULL;
669         }
670         fsp->xfer_len += seq_blen;      /* premature count? */
671         return 0;
672 }
673
674 /**
675  * fc_fcp_abts_resp() - Send an ABTS response
676  * @fsp: The FCP packet that is being aborted
677  * @fp:  The response frame
678  */
679 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
680 {
681         int ba_done = 1;
682         struct fc_ba_rjt *brp;
683         struct fc_frame_header *fh;
684
685         fh = fc_frame_header_get(fp);
686         switch (fh->fh_r_ctl) {
687         case FC_RCTL_BA_ACC:
688                 break;
689         case FC_RCTL_BA_RJT:
690                 brp = fc_frame_payload_get(fp, sizeof(*brp));
691                 if (brp && brp->br_reason == FC_BA_RJT_LOG_ERR)
692                         break;
693                 /* fall thru */
694         default:
695                 /*
696                  * we will let the command timeout
697                  * and scsi-ml recover in this case,
698                  * therefore cleared the ba_done flag.
699                  */
700                 ba_done = 0;
701         }
702
703         if (ba_done) {
704                 fsp->state |= FC_SRB_ABORTED;
705                 fsp->state &= ~FC_SRB_ABORT_PENDING;
706
707                 if (fsp->wait_for_comp)
708                         complete(&fsp->tm_done);
709                 else
710                         fc_fcp_complete_locked(fsp);
711         }
712 }
713
714 /**
715  * fc_fcp_recv() - Reveive an FCP frame
716  * @seq: The sequence the frame is on
717  * @fp:  The received frame
718  * @arg: The related FCP packet
719  *
720  * Context: Called from Soft IRQ context. Can not be called
721  *          holding the FCP packet list lock.
722  */
723 static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
724 {
725         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
726         struct fc_lport *lport = fsp->lp;
727         struct fc_frame_header *fh;
728         struct fcp_txrdy *dd;
729         u8 r_ctl;
730         int rc = 0;
731
732         if (IS_ERR(fp)) {
733                 fc_fcp_error(fsp, fp);
734                 return;
735         }
736
737         fh = fc_frame_header_get(fp);
738         r_ctl = fh->fh_r_ctl;
739
740         if (!(lport->state & LPORT_ST_READY))
741                 goto out;
742         if (fc_fcp_lock_pkt(fsp))
743                 goto out;
744         fsp->last_pkt_time = jiffies;
745
746         if (fh->fh_type == FC_TYPE_BLS) {
747                 fc_fcp_abts_resp(fsp, fp);
748                 goto unlock;
749         }
750
751         if (fsp->state & (FC_SRB_ABORTED | FC_SRB_ABORT_PENDING))
752                 goto unlock;
753
754         if (r_ctl == FC_RCTL_DD_DATA_DESC) {
755                 /*
756                  * received XFER RDY from the target
757                  * need to send data to the target
758                  */
759                 WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
760                 dd = fc_frame_payload_get(fp, sizeof(*dd));
761                 WARN_ON(!dd);
762
763                 rc = fc_fcp_send_data(fsp, seq,
764                                       (size_t) ntohl(dd->ft_data_ro),
765                                       (size_t) ntohl(dd->ft_burst_len));
766                 if (!rc)
767                         seq->rec_data = fsp->xfer_len;
768         } else if (r_ctl == FC_RCTL_DD_SOL_DATA) {
769                 /*
770                  * received a DATA frame
771                  * next we will copy the data to the system buffer
772                  */
773                 WARN_ON(fr_len(fp) < sizeof(*fh));      /* len may be 0 */
774                 fc_fcp_recv_data(fsp, fp);
775                 seq->rec_data = fsp->xfer_contig_end;
776         } else if (r_ctl == FC_RCTL_DD_CMD_STATUS) {
777                 WARN_ON(fr_flags(fp) & FCPHF_CRC_UNCHECKED);
778
779                 fc_fcp_resp(fsp, fp);
780         } else {
781                 FC_FCP_DBG(fsp, "unexpected frame.  r_ctl %x\n", r_ctl);
782         }
783 unlock:
784         fc_fcp_unlock_pkt(fsp);
785 out:
786         fc_frame_free(fp);
787 }
788
789 /**
790  * fc_fcp_resp() - Handler for FCP responses
791  * @fsp: The FCP packet the response is for
792  * @fp:  The response frame
793  */
794 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
795 {
796         struct fc_frame_header *fh;
797         struct fcp_resp *fc_rp;
798         struct fcp_resp_ext *rp_ex;
799         struct fcp_resp_rsp_info *fc_rp_info;
800         u32 plen;
801         u32 expected_len;
802         u32 respl = 0;
803         u32 snsl = 0;
804         u8 flags = 0;
805
806         plen = fr_len(fp);
807         fh = (struct fc_frame_header *)fr_hdr(fp);
808         if (unlikely(plen < sizeof(*fh) + sizeof(*fc_rp)))
809                 goto len_err;
810         plen -= sizeof(*fh);
811         fc_rp = (struct fcp_resp *)(fh + 1);
812         fsp->cdb_status = fc_rp->fr_status;
813         flags = fc_rp->fr_flags;
814         fsp->scsi_comp_flags = flags;
815         expected_len = fsp->data_len;
816
817         /* if ddp, update xfer len */
818         fc_fcp_ddp_done(fsp);
819
820         if (unlikely((flags & ~FCP_CONF_REQ) || fc_rp->fr_status)) {
821                 rp_ex = (void *)(fc_rp + 1);
822                 if (flags & (FCP_RSP_LEN_VAL | FCP_SNS_LEN_VAL)) {
823                         if (plen < sizeof(*fc_rp) + sizeof(*rp_ex))
824                                 goto len_err;
825                         fc_rp_info = (struct fcp_resp_rsp_info *)(rp_ex + 1);
826                         if (flags & FCP_RSP_LEN_VAL) {
827                                 respl = ntohl(rp_ex->fr_rsp_len);
828                                 if (respl != sizeof(*fc_rp_info))
829                                         goto len_err;
830                                 if (fsp->wait_for_comp) {
831                                         /* Abuse cdb_status for rsp code */
832                                         fsp->cdb_status = fc_rp_info->rsp_code;
833                                         complete(&fsp->tm_done);
834                                         /*
835                                          * tmfs will not have any scsi cmd so
836                                          * exit here
837                                          */
838                                         return;
839                                 } else
840                                         goto err;
841                         }
842                         if (flags & FCP_SNS_LEN_VAL) {
843                                 snsl = ntohl(rp_ex->fr_sns_len);
844                                 if (snsl > SCSI_SENSE_BUFFERSIZE)
845                                         snsl = SCSI_SENSE_BUFFERSIZE;
846                                 memcpy(fsp->cmd->sense_buffer,
847                                        (char *)fc_rp_info + respl, snsl);
848                         }
849                 }
850                 if (flags & (FCP_RESID_UNDER | FCP_RESID_OVER)) {
851                         if (plen < sizeof(*fc_rp) + sizeof(rp_ex->fr_resid))
852                                 goto len_err;
853                         if (flags & FCP_RESID_UNDER) {
854                                 fsp->scsi_resid = ntohl(rp_ex->fr_resid);
855                                 /*
856                                  * The cmnd->underflow is the minimum number of
857                                  * bytes that must be transfered for this
858                                  * command.  Provided a sense condition is not
859                                  * present, make sure the actual amount
860                                  * transferred is at least the underflow value
861                                  * or fail.
862                                  */
863                                 if (!(flags & FCP_SNS_LEN_VAL) &&
864                                     (fc_rp->fr_status == 0) &&
865                                     (scsi_bufflen(fsp->cmd) -
866                                      fsp->scsi_resid) < fsp->cmd->underflow)
867                                         goto err;
868                                 expected_len -= fsp->scsi_resid;
869                         } else {
870                                 fsp->status_code = FC_ERROR;
871                         }
872                 }
873         }
874         fsp->state |= FC_SRB_RCV_STATUS;
875
876         /*
877          * Check for missing or extra data frames.
878          */
879         if (unlikely(fsp->xfer_len != expected_len)) {
880                 if (fsp->xfer_len < expected_len) {
881                         /*
882                          * Some data may be queued locally,
883                          * Wait a at least one jiffy to see if it is delivered.
884                          * If this expires without data, we may do SRR.
885                          */
886                         fc_fcp_timer_set(fsp, 2);
887                         return;
888                 }
889                 fsp->status_code = FC_DATA_OVRRUN;
890                 FC_FCP_DBG(fsp, "tgt %6x xfer len %zx greater than expected, "
891                            "len %x, data len %x\n",
892                            fsp->rport->port_id,
893                            fsp->xfer_len, expected_len, fsp->data_len);
894         }
895         fc_fcp_complete_locked(fsp);
896         return;
897
898 len_err:
899         FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
900                    "snsl %u\n", flags, fr_len(fp), respl, snsl);
901 err:
902         fsp->status_code = FC_ERROR;
903         fc_fcp_complete_locked(fsp);
904 }
905
906 /**
907  * fc_fcp_complete_locked() - Complete processing of a fcp_pkt with the
908  *                            fcp_pkt lock held
909  * @fsp: The FCP packet to be completed
910  *
911  * This function may sleep if a timer is pending. The packet lock must be
912  * held, and the host lock must not be held.
913  */
914 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
915 {
916         struct fc_lport *lport = fsp->lp;
917         struct fc_seq *seq;
918         struct fc_exch *ep;
919         u32 f_ctl;
920
921         if (fsp->state & FC_SRB_ABORT_PENDING)
922                 return;
923
924         if (fsp->state & FC_SRB_ABORTED) {
925                 if (!fsp->status_code)
926                         fsp->status_code = FC_CMD_ABORTED;
927         } else {
928                 /*
929                  * Test for transport underrun, independent of response
930                  * underrun status.
931                  */
932                 if (fsp->xfer_len < fsp->data_len && !fsp->io_status &&
933                     (!(fsp->scsi_comp_flags & FCP_RESID_UNDER) ||
934                      fsp->xfer_len < fsp->data_len - fsp->scsi_resid)) {
935                         fsp->status_code = FC_DATA_UNDRUN;
936                         fsp->io_status = 0;
937                 }
938         }
939
940         seq = fsp->seq_ptr;
941         if (seq) {
942                 fsp->seq_ptr = NULL;
943                 if (unlikely(fsp->scsi_comp_flags & FCP_CONF_REQ)) {
944                         struct fc_frame *conf_frame;
945                         struct fc_seq *csp;
946
947                         csp = lport->tt.seq_start_next(seq);
948                         conf_frame = fc_fcp_frame_alloc(fsp->lp, 0);
949                         if (conf_frame) {
950                                 f_ctl = FC_FC_SEQ_INIT;
951                                 f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
952                                 ep = fc_seq_exch(seq);
953                                 fc_fill_fc_hdr(conf_frame, FC_RCTL_DD_SOL_CTL,
954                                                ep->did, ep->sid,
955                                                FC_TYPE_FCP, f_ctl, 0);
956                                 lport->tt.seq_send(lport, csp, conf_frame);
957                         }
958                 }
959                 lport->tt.exch_done(seq);
960         }
961         fc_io_compl(fsp);
962 }
963
964 /**
965  * fc_fcp_cleanup_cmd() - Cancel the active exchange on a fcp_pkt
966  * @fsp:   The FCP packet whose exchanges should be canceled
967  * @error: The reason for the cancellation
968  */
969 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
970 {
971         struct fc_lport *lport = fsp->lp;
972
973         if (fsp->seq_ptr) {
974                 lport->tt.exch_done(fsp->seq_ptr);
975                 fsp->seq_ptr = NULL;
976         }
977         fsp->status_code = error;
978 }
979
980 /**
981  * fc_fcp_cleanup_each_cmd() - Cancel all exchanges on a local port
982  * @lport: The local port whose exchanges should be canceled
983  * @id:    The target's ID
984  * @lun:   The LUN
985  * @error: The reason for cancellation
986  *
987  * If lun or id is -1, they are ignored.
988  */
989 static void fc_fcp_cleanup_each_cmd(struct fc_lport *lport, unsigned int id,
990                                     unsigned int lun, int error)
991 {
992         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
993         struct fc_fcp_pkt *fsp;
994         struct scsi_cmnd *sc_cmd;
995         unsigned long flags;
996
997         spin_lock_irqsave(&si->scsi_queue_lock, flags);
998 restart:
999         list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
1000                 sc_cmd = fsp->cmd;
1001                 if (id != -1 && scmd_id(sc_cmd) != id)
1002                         continue;
1003
1004                 if (lun != -1 && sc_cmd->device->lun != lun)
1005                         continue;
1006
1007                 fc_fcp_pkt_hold(fsp);
1008                 spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1009
1010                 if (!fc_fcp_lock_pkt(fsp)) {
1011                         fc_fcp_cleanup_cmd(fsp, error);
1012                         fc_io_compl(fsp);
1013                         fc_fcp_unlock_pkt(fsp);
1014                 }
1015
1016                 fc_fcp_pkt_release(fsp);
1017                 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1018                 /*
1019                  * while we dropped the lock multiple pkts could
1020                  * have been released, so we have to start over.
1021                  */
1022                 goto restart;
1023         }
1024         spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1025 }
1026
1027 /**
1028  * fc_fcp_abort_io() - Abort all FCP-SCSI exchanges on a local port
1029  * @lport: The local port whose exchanges are to be aborted
1030  */
1031 static void fc_fcp_abort_io(struct fc_lport *lport)
1032 {
1033         fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_HRD_ERROR);
1034 }
1035
1036 /**
1037  * fc_fcp_pkt_send() - Send a fcp_pkt
1038  * @lport: The local port to send the FCP packet on
1039  * @fsp:   The FCP packet to send
1040  *
1041  * Return:  Zero for success and -1 for failure
1042  * Locks:   Called without locks held
1043  */
1044 static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
1045 {
1046         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
1047         unsigned long flags;
1048         int rc;
1049
1050         fsp->cmd->SCp.ptr = (char *)fsp;
1051         fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1052         fsp->cdb_cmd.fc_flags = fsp->req_flags & ~FCP_CFL_LEN_MASK;
1053
1054         int_to_scsilun(fsp->cmd->device->lun,
1055                        (struct scsi_lun *)fsp->cdb_cmd.fc_lun);
1056         memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
1057
1058         spin_lock_irqsave(&si->scsi_queue_lock, flags);
1059         list_add_tail(&fsp->list, &si->scsi_pkt_queue);
1060         spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1061         rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
1062         if (unlikely(rc)) {
1063                 spin_lock_irqsave(&si->scsi_queue_lock, flags);
1064                 list_del(&fsp->list);
1065                 spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1066         }
1067
1068         return rc;
1069 }
1070
1071 /**
1072  * fc_fcp_cmd_send() - Send a FCP command
1073  * @lport: The local port to send the command on
1074  * @fsp:   The FCP packet the command is on
1075  * @resp:  The handler for the response
1076  */
1077 static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1078                            void (*resp)(struct fc_seq *,
1079                                         struct fc_frame *fp,
1080                                         void *arg))
1081 {
1082         struct fc_frame *fp;
1083         struct fc_seq *seq;
1084         struct fc_rport *rport;
1085         struct fc_rport_libfc_priv *rpriv;
1086         const size_t len = sizeof(fsp->cdb_cmd);
1087         int rc = 0;
1088
1089         if (fc_fcp_lock_pkt(fsp))
1090                 return 0;
1091
1092         fp = fc_fcp_frame_alloc(lport, sizeof(fsp->cdb_cmd));
1093         if (!fp) {
1094                 rc = -1;
1095                 goto unlock;
1096         }
1097
1098         memcpy(fc_frame_payload_get(fp, len), &fsp->cdb_cmd, len);
1099         fr_fsp(fp) = fsp;
1100         rport = fsp->rport;
1101         fsp->max_payload = rport->maxframe_size;
1102         rpriv = rport->dd_data;
1103
1104         fc_fill_fc_hdr(fp, FC_RCTL_DD_UNSOL_CMD, rport->port_id,
1105                        fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
1106                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
1107
1108         seq = lport->tt.exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy,
1109                                       fsp, 0);
1110         if (!seq) {
1111                 rc = -1;
1112                 goto unlock;
1113         }
1114         fsp->last_pkt_time = jiffies;
1115         fsp->seq_ptr = seq;
1116         fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
1117
1118         setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
1119         fc_fcp_timer_set(fsp,
1120                          (fsp->tgt_flags & FC_RP_FLAGS_REC_SUPPORTED) ?
1121                          FC_SCSI_REC_TOV : FC_SCSI_ER_TIMEOUT);
1122 unlock:
1123         fc_fcp_unlock_pkt(fsp);
1124         return rc;
1125 }
1126
1127 /**
1128  * fc_fcp_error() - Handler for FCP layer errors
1129  * @fsp: The FCP packet the error is on
1130  * @fp:  The frame that has errored
1131  */
1132 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1133 {
1134         int error = PTR_ERR(fp);
1135
1136         if (fc_fcp_lock_pkt(fsp))
1137                 return;
1138
1139         if (error == -FC_EX_CLOSED) {
1140                 fc_fcp_retry_cmd(fsp);
1141                 goto unlock;
1142         }
1143
1144         /*
1145          * clear abort pending, because the lower layer
1146          * decided to force completion.
1147          */
1148         fsp->state &= ~FC_SRB_ABORT_PENDING;
1149         fsp->status_code = FC_CMD_PLOGO;
1150         fc_fcp_complete_locked(fsp);
1151 unlock:
1152         fc_fcp_unlock_pkt(fsp);
1153 }
1154
1155 /**
1156  * fc_fcp_pkt_abort() - Abort a fcp_pkt
1157  * @fsp:   The FCP packet to abort on
1158  *
1159  * Called to send an abort and then wait for abort completion
1160  */
1161 static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
1162 {
1163         int rc = FAILED;
1164
1165         if (fc_fcp_send_abort(fsp))
1166                 return FAILED;
1167
1168         init_completion(&fsp->tm_done);
1169         fsp->wait_for_comp = 1;
1170
1171         spin_unlock_bh(&fsp->scsi_pkt_lock);
1172         rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
1173         spin_lock_bh(&fsp->scsi_pkt_lock);
1174         fsp->wait_for_comp = 0;
1175
1176         if (!rc) {
1177                 FC_FCP_DBG(fsp, "target abort cmd  failed\n");
1178                 rc = FAILED;
1179         } else if (fsp->state & FC_SRB_ABORTED) {
1180                 FC_FCP_DBG(fsp, "target abort cmd  passed\n");
1181                 rc = SUCCESS;
1182                 fc_fcp_complete_locked(fsp);
1183         }
1184
1185         return rc;
1186 }
1187
1188 /**
1189  * fc_lun_reset_send() - Send LUN reset command
1190  * @data: The FCP packet that identifies the LUN to be reset
1191  */
1192 static void fc_lun_reset_send(unsigned long data)
1193 {
1194         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1195         struct fc_lport *lport = fsp->lp;
1196         if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
1197                 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
1198                         return;
1199                 if (fc_fcp_lock_pkt(fsp))
1200                         return;
1201                 setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
1202                 fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
1203                 fc_fcp_unlock_pkt(fsp);
1204         }
1205 }
1206
1207 /**
1208  * fc_lun_reset() - Send a LUN RESET command to a device
1209  *                  and wait for the reply
1210  * @lport: The local port to sent the comand on
1211  * @fsp:   The FCP packet that identifies the LUN to be reset
1212  * @id:    The SCSI command ID
1213  * @lun:   The LUN ID to be reset
1214  */
1215 static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
1216                         unsigned int id, unsigned int lun)
1217 {
1218         int rc;
1219
1220         fsp->cdb_cmd.fc_dl = htonl(fsp->data_len);
1221         fsp->cdb_cmd.fc_tm_flags = FCP_TMF_LUN_RESET;
1222         int_to_scsilun(lun, (struct scsi_lun *)fsp->cdb_cmd.fc_lun);
1223
1224         fsp->wait_for_comp = 1;
1225         init_completion(&fsp->tm_done);
1226
1227         fc_lun_reset_send((unsigned long)fsp);
1228
1229         /*
1230          * wait for completion of reset
1231          * after that make sure all commands are terminated
1232          */
1233         rc = wait_for_completion_timeout(&fsp->tm_done, FC_SCSI_TM_TOV);
1234
1235         spin_lock_bh(&fsp->scsi_pkt_lock);
1236         fsp->state |= FC_SRB_COMPL;
1237         spin_unlock_bh(&fsp->scsi_pkt_lock);
1238
1239         del_timer_sync(&fsp->timer);
1240
1241         spin_lock_bh(&fsp->scsi_pkt_lock);
1242         if (fsp->seq_ptr) {
1243                 lport->tt.exch_done(fsp->seq_ptr);
1244                 fsp->seq_ptr = NULL;
1245         }
1246         fsp->wait_for_comp = 0;
1247         spin_unlock_bh(&fsp->scsi_pkt_lock);
1248
1249         if (!rc) {
1250                 FC_SCSI_DBG(lport, "lun reset failed\n");
1251                 return FAILED;
1252         }
1253
1254         /* cdb_status holds the tmf's rsp code */
1255         if (fsp->cdb_status != FCP_TMF_CMPL)
1256                 return FAILED;
1257
1258         FC_SCSI_DBG(lport, "lun reset to lun %u completed\n", lun);
1259         fc_fcp_cleanup_each_cmd(lport, id, lun, FC_CMD_ABORTED);
1260         return SUCCESS;
1261 }
1262
1263 /**
1264  * fc_tm_done() - Task Managment response handler
1265  * @seq: The sequence that the response is on
1266  * @fp:  The response frame
1267  * @arg: The FCP packet the response is for
1268  */
1269 static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1270 {
1271         struct fc_fcp_pkt *fsp = arg;
1272         struct fc_frame_header *fh;
1273
1274         if (IS_ERR(fp)) {
1275                 /*
1276                  * If there is an error just let it timeout or wait
1277                  * for TMF to be aborted if it timedout.
1278                  *
1279                  * scsi-eh will escalate for when either happens.
1280                  */
1281                 return;
1282         }
1283
1284         if (fc_fcp_lock_pkt(fsp))
1285                 return;
1286
1287         /*
1288          * raced with eh timeout handler.
1289          */
1290         if (!fsp->seq_ptr || !fsp->wait_for_comp) {
1291                 spin_unlock_bh(&fsp->scsi_pkt_lock);
1292                 return;
1293         }
1294
1295         fh = fc_frame_header_get(fp);
1296         if (fh->fh_type != FC_TYPE_BLS)
1297                 fc_fcp_resp(fsp, fp);
1298         fsp->seq_ptr = NULL;
1299         fsp->lp->tt.exch_done(seq);
1300         fc_frame_free(fp);
1301         fc_fcp_unlock_pkt(fsp);
1302 }
1303
1304 /**
1305  * fc_fcp_cleanup() - Cleanup all FCP exchanges on a local port
1306  * @lport: The local port to be cleaned up
1307  */
1308 static void fc_fcp_cleanup(struct fc_lport *lport)
1309 {
1310         fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_ERROR);
1311 }
1312
1313 /**
1314  * fc_fcp_timeout() - Handler for fcp_pkt timeouts
1315  * @data: The FCP packet that has timed out
1316  *
1317  * If REC is supported then just issue it and return. The REC exchange will
1318  * complete or time out and recovery can continue at that point. Otherwise,
1319  * if the response has been received without all the data it has been
1320  * ER_TIMEOUT since the response was received. If the response has not been
1321  * received we see if data was received recently. If it has been then we
1322  * continue waiting, otherwise, we abort the command.
1323  */
1324 static void fc_fcp_timeout(unsigned long data)
1325 {
1326         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
1327         struct fc_rport *rport = fsp->rport;
1328         struct fc_rport_libfc_priv *rpriv = rport->dd_data;
1329
1330         if (fc_fcp_lock_pkt(fsp))
1331                 return;
1332
1333         if (fsp->cdb_cmd.fc_tm_flags)
1334                 goto unlock;
1335
1336         fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
1337
1338         if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
1339                 fc_fcp_rec(fsp);
1340         else if (time_after_eq(fsp->last_pkt_time + (FC_SCSI_ER_TIMEOUT / 2),
1341                                jiffies))
1342                 fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
1343         else if (fsp->state & FC_SRB_RCV_STATUS)
1344                 fc_fcp_complete_locked(fsp);
1345         else
1346                 fc_timeout_error(fsp);
1347         fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
1348 unlock:
1349         fc_fcp_unlock_pkt(fsp);
1350 }
1351
1352 /**
1353  * fc_fcp_rec() - Send a REC ELS request
1354  * @fsp: The FCP packet to send the REC request on
1355  */
1356 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
1357 {
1358         struct fc_lport *lport;
1359         struct fc_frame *fp;
1360         struct fc_rport *rport;
1361         struct fc_rport_libfc_priv *rpriv;
1362
1363         lport = fsp->lp;
1364         rport = fsp->rport;
1365         rpriv = rport->dd_data;
1366         if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
1367                 fsp->status_code = FC_HRD_ERROR;
1368                 fsp->io_status = 0;
1369                 fc_fcp_complete_locked(fsp);
1370                 return;
1371         }
1372         fp = fc_fcp_frame_alloc(lport, sizeof(struct fc_els_rec));
1373         if (!fp)
1374                 goto retry;
1375
1376         fr_seq(fp) = fsp->seq_ptr;
1377         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, rport->port_id,
1378                        fc_host_port_id(rpriv->local_port->host), FC_TYPE_ELS,
1379                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
1380         if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
1381                                  fc_fcp_rec_resp, fsp,
1382                                  jiffies_to_msecs(FC_SCSI_REC_TOV))) {
1383                 fc_fcp_pkt_hold(fsp);           /* hold while REC outstanding */
1384                 return;
1385         }
1386 retry:
1387         if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1388                 fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
1389         else
1390                 fc_timeout_error(fsp);
1391 }
1392
1393 /**
1394  * fc_fcp_rec_resp() - Handler for REC ELS responses
1395  * @seq: The sequence the response is on
1396  * @fp:  The response frame
1397  * @arg: The FCP packet the response is on
1398  *
1399  * If the response is a reject then the scsi layer will handle
1400  * the timeout. If the response is a LS_ACC then if the I/O was not completed
1401  * set the timeout and return. If the I/O was completed then complete the
1402  * exchange and tell the SCSI layer.
1403  */
1404 static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1405 {
1406         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)arg;
1407         struct fc_els_rec_acc *recp;
1408         struct fc_els_ls_rjt *rjt;
1409         u32 e_stat;
1410         u8 opcode;
1411         u32 offset;
1412         enum dma_data_direction data_dir;
1413         enum fc_rctl r_ctl;
1414         struct fc_rport_libfc_priv *rpriv;
1415
1416         if (IS_ERR(fp)) {
1417                 fc_fcp_rec_error(fsp, fp);
1418                 return;
1419         }
1420
1421         if (fc_fcp_lock_pkt(fsp))
1422                 goto out;
1423
1424         fsp->recov_retry = 0;
1425         opcode = fc_frame_payload_op(fp);
1426         if (opcode == ELS_LS_RJT) {
1427                 rjt = fc_frame_payload_get(fp, sizeof(*rjt));
1428                 switch (rjt->er_reason) {
1429                 default:
1430                         FC_FCP_DBG(fsp, "device %x unexpected REC reject "
1431                                    "reason %d expl %d\n",
1432                                    fsp->rport->port_id, rjt->er_reason,
1433                                    rjt->er_explan);
1434                         /* fall through */
1435                 case ELS_RJT_UNSUP:
1436                         FC_FCP_DBG(fsp, "device does not support REC\n");
1437                         rpriv = fsp->rport->dd_data;
1438                         /*
1439                          * if we do not spport RECs or got some bogus
1440                          * reason then resetup timer so we check for
1441                          * making progress.
1442                          */
1443                         rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
1444                         fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
1445                         break;
1446                 case ELS_RJT_LOGIC:
1447                 case ELS_RJT_UNAB:
1448                         /*
1449                          * If no data transfer, the command frame got dropped
1450                          * so we just retry.  If data was transferred, we
1451                          * lost the response but the target has no record,
1452                          * so we abort and retry.
1453                          */
1454                         if (rjt->er_explan == ELS_EXPL_OXID_RXID &&
1455                             fsp->xfer_len == 0) {
1456                                 fc_fcp_retry_cmd(fsp);
1457                                 break;
1458                         }
1459                         fc_timeout_error(fsp);
1460                         break;
1461                 }
1462         } else if (opcode == ELS_LS_ACC) {
1463                 if (fsp->state & FC_SRB_ABORTED)
1464                         goto unlock_out;
1465
1466                 data_dir = fsp->cmd->sc_data_direction;
1467                 recp = fc_frame_payload_get(fp, sizeof(*recp));
1468                 offset = ntohl(recp->reca_fc4value);
1469                 e_stat = ntohl(recp->reca_e_stat);
1470
1471                 if (e_stat & ESB_ST_COMPLETE) {
1472
1473                         /*
1474                          * The exchange is complete.
1475                          *
1476                          * For output, we must've lost the response.
1477                          * For input, all data must've been sent.
1478                          * We lost may have lost the response
1479                          * (and a confirmation was requested) and maybe
1480                          * some data.
1481                          *
1482                          * If all data received, send SRR
1483                          * asking for response.  If partial data received,
1484                          * or gaps, SRR requests data at start of gap.
1485                          * Recovery via SRR relies on in-order-delivery.
1486                          */
1487                         if (data_dir == DMA_TO_DEVICE) {
1488                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
1489                         } else if (fsp->xfer_contig_end == offset) {
1490                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
1491                         } else {
1492                                 offset = fsp->xfer_contig_end;
1493                                 r_ctl = FC_RCTL_DD_SOL_DATA;
1494                         }
1495                         fc_fcp_srr(fsp, r_ctl, offset);
1496                 } else if (e_stat & ESB_ST_SEQ_INIT) {
1497
1498                         /*
1499                          * The remote port has the initiative, so just
1500                          * keep waiting for it to complete.
1501                          */
1502                         fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
1503                 } else {
1504
1505                         /*
1506                          * The exchange is incomplete, we have seq. initiative.
1507                          * Lost response with requested confirmation,
1508                          * lost confirmation, lost transfer ready or
1509                          * lost write data.
1510                          *
1511                          * For output, if not all data was received, ask
1512                          * for transfer ready to be repeated.
1513                          *
1514                          * If we received or sent all the data, send SRR to
1515                          * request response.
1516                          *
1517                          * If we lost a response, we may have lost some read
1518                          * data as well.
1519                          */
1520                         r_ctl = FC_RCTL_DD_SOL_DATA;
1521                         if (data_dir == DMA_TO_DEVICE) {
1522                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
1523                                 if (offset < fsp->data_len)
1524                                         r_ctl = FC_RCTL_DD_DATA_DESC;
1525                         } else if (offset == fsp->xfer_contig_end) {
1526                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
1527                         } else if (fsp->xfer_contig_end < offset) {
1528                                 offset = fsp->xfer_contig_end;
1529                         }
1530                         fc_fcp_srr(fsp, r_ctl, offset);
1531                 }
1532         }
1533 unlock_out:
1534         fc_fcp_unlock_pkt(fsp);
1535 out:
1536         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding REC */
1537         fc_frame_free(fp);
1538 }
1539
1540 /**
1541  * fc_fcp_rec_error() - Handler for REC errors
1542  * @fsp: The FCP packet the error is on
1543  * @fp:  The REC frame
1544  */
1545 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1546 {
1547         int error = PTR_ERR(fp);
1548
1549         if (fc_fcp_lock_pkt(fsp))
1550                 goto out;
1551
1552         switch (error) {
1553         case -FC_EX_CLOSED:
1554                 fc_fcp_retry_cmd(fsp);
1555                 break;
1556
1557         default:
1558                 FC_FCP_DBG(fsp, "REC %p fid %x error unexpected error %d\n",
1559                            fsp, fsp->rport->port_id, error);
1560                 fsp->status_code = FC_CMD_PLOGO;
1561                 /* fall through */
1562
1563         case -FC_EX_TIMEOUT:
1564                 /*
1565                  * Assume REC or LS_ACC was lost.
1566                  * The exchange manager will have aborted REC, so retry.
1567                  */
1568                 FC_FCP_DBG(fsp, "REC fid %x error error %d retry %d/%d\n",
1569                            fsp->rport->port_id, error, fsp->recov_retry,
1570                            FC_MAX_RECOV_RETRY);
1571                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1572                         fc_fcp_rec(fsp);
1573                 else
1574                         fc_timeout_error(fsp);
1575                 break;
1576         }
1577         fc_fcp_unlock_pkt(fsp);
1578 out:
1579         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding REC */
1580 }
1581
1582 /**
1583  * fc_timeout_error() - Handler for fcp_pkt timeouts
1584  * @fsp: The FCP packt that has timed out
1585  */
1586 static void fc_timeout_error(struct fc_fcp_pkt *fsp)
1587 {
1588         fsp->status_code = FC_CMD_TIME_OUT;
1589         fsp->cdb_status = 0;
1590         fsp->io_status = 0;
1591         /*
1592          * if this fails then we let the scsi command timer fire and
1593          * scsi-ml escalate.
1594          */
1595         fc_fcp_send_abort(fsp);
1596 }
1597
1598 /**
1599  * fc_fcp_srr() - Send a SRR request (Sequence Retransmission Request)
1600  * @fsp:   The FCP packet the SRR is to be sent on
1601  * @r_ctl: The R_CTL field for the SRR request
1602  * This is called after receiving status but insufficient data, or
1603  * when expecting status but the request has timed out.
1604  */
1605 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
1606 {
1607         struct fc_lport *lport = fsp->lp;
1608         struct fc_rport *rport;
1609         struct fc_rport_libfc_priv *rpriv;
1610         struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
1611         struct fc_seq *seq;
1612         struct fcp_srr *srr;
1613         struct fc_frame *fp;
1614         u8 cdb_op;
1615
1616         rport = fsp->rport;
1617         rpriv = rport->dd_data;
1618         cdb_op = fsp->cdb_cmd.fc_cdb[0];
1619
1620         if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
1621             rpriv->rp_state != RPORT_ST_READY)
1622                 goto retry;                     /* shouldn't happen */
1623         fp = fc_fcp_frame_alloc(lport, sizeof(*srr));
1624         if (!fp)
1625                 goto retry;
1626
1627         srr = fc_frame_payload_get(fp, sizeof(*srr));
1628         memset(srr, 0, sizeof(*srr));
1629         srr->srr_op = ELS_SRR;
1630         srr->srr_ox_id = htons(ep->oxid);
1631         srr->srr_rx_id = htons(ep->rxid);
1632         srr->srr_r_ctl = r_ctl;
1633         srr->srr_rel_off = htonl(offset);
1634
1635         fc_fill_fc_hdr(fp, FC_RCTL_ELS4_REQ, rport->port_id,
1636                        fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
1637                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
1638
1639         seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp, NULL,
1640                                       fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
1641         if (!seq)
1642                 goto retry;
1643
1644         fsp->recov_seq = seq;
1645         fsp->xfer_len = offset;
1646         fsp->xfer_contig_end = offset;
1647         fsp->state &= ~FC_SRB_RCV_STATUS;
1648         fc_fcp_pkt_hold(fsp);           /* hold for outstanding SRR */
1649         return;
1650 retry:
1651         fc_fcp_retry_cmd(fsp);
1652 }
1653
1654 /**
1655  * fc_fcp_srr_resp() - Handler for SRR response
1656  * @seq: The sequence the SRR is on
1657  * @fp:  The SRR frame
1658  * @arg: The FCP packet the SRR is on
1659  */
1660 static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
1661 {
1662         struct fc_fcp_pkt *fsp = arg;
1663         struct fc_frame_header *fh;
1664
1665         if (IS_ERR(fp)) {
1666                 fc_fcp_srr_error(fsp, fp);
1667                 return;
1668         }
1669
1670         if (fc_fcp_lock_pkt(fsp))
1671                 goto out;
1672
1673         fh = fc_frame_header_get(fp);
1674         /*
1675          * BUG? fc_fcp_srr_error calls exch_done which would release
1676          * the ep. But if fc_fcp_srr_error had got -FC_EX_TIMEOUT,
1677          * then fc_exch_timeout would be sending an abort. The exch_done
1678          * call by fc_fcp_srr_error would prevent fc_exch.c from seeing
1679          * an abort response though.
1680          */
1681         if (fh->fh_type == FC_TYPE_BLS) {
1682                 fc_fcp_unlock_pkt(fsp);
1683                 return;
1684         }
1685
1686         fsp->recov_seq = NULL;
1687         switch (fc_frame_payload_op(fp)) {
1688         case ELS_LS_ACC:
1689                 fsp->recov_retry = 0;
1690                 fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
1691                 break;
1692         case ELS_LS_RJT:
1693         default:
1694                 fc_timeout_error(fsp);
1695                 break;
1696         }
1697         fc_fcp_unlock_pkt(fsp);
1698         fsp->lp->tt.exch_done(seq);
1699 out:
1700         fc_frame_free(fp);
1701         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
1702 }
1703
1704 /**
1705  * fc_fcp_srr_error() - Handler for SRR errors
1706  * @fsp: The FCP packet that the SRR error is on
1707  * @fp:  The SRR frame
1708  */
1709 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
1710 {
1711         if (fc_fcp_lock_pkt(fsp))
1712                 goto out;
1713         fsp->lp->tt.exch_done(fsp->recov_seq);
1714         fsp->recov_seq = NULL;
1715         switch (PTR_ERR(fp)) {
1716         case -FC_EX_TIMEOUT:
1717                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
1718                         fc_fcp_rec(fsp);
1719                 else
1720                         fc_timeout_error(fsp);
1721                 break;
1722         case -FC_EX_CLOSED:                     /* e.g., link failure */
1723                 /* fall through */
1724         default:
1725                 fc_fcp_retry_cmd(fsp);
1726                 break;
1727         }
1728         fc_fcp_unlock_pkt(fsp);
1729 out:
1730         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
1731 }
1732
1733 /**
1734  * fc_fcp_lport_queue_ready() - Determine if the lport and it's queue is ready
1735  * @lport: The local port to be checked
1736  */
1737 static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
1738 {
1739         /* lock ? */
1740         return (lport->state == LPORT_ST_READY) &&
1741                 lport->link_up && !lport->qfull;
1742 }
1743
1744 /**
1745  * fc_queuecommand() - The queuecommand function of the SCSI template
1746  * @cmd:   The scsi_cmnd to be executed
1747  * @done:  The callback function to be called when the scsi_cmnd is complete
1748  *
1749  * This is the i/o strategy routine, called by the SCSI layer. This routine
1750  * is called with the host_lock held.
1751  */
1752 int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
1753 {
1754         struct fc_lport *lport;
1755         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
1756         struct fc_fcp_pkt *fsp;
1757         struct fc_rport_libfc_priv *rpriv;
1758         int rval;
1759         int rc = 0;
1760         struct fcoe_dev_stats *stats;
1761
1762         lport = shost_priv(sc_cmd->device->host);
1763         spin_unlock_irq(lport->host->host_lock);
1764
1765         rval = fc_remote_port_chkready(rport);
1766         if (rval) {
1767                 sc_cmd->result = rval;
1768                 done(sc_cmd);
1769                 goto out;
1770         }
1771
1772         if (!*(struct fc_remote_port **)rport->dd_data) {
1773                 /*
1774                  * rport is transitioning from blocked/deleted to
1775                  * online
1776                  */
1777                 sc_cmd->result = DID_IMM_RETRY << 16;
1778                 done(sc_cmd);
1779                 goto out;
1780         }
1781
1782         rpriv = rport->dd_data;
1783
1784         if (!fc_fcp_lport_queue_ready(lport)) {
1785                 if (lport->qfull)
1786                         fc_fcp_can_queue_ramp_down(lport);
1787                 rc = SCSI_MLQUEUE_HOST_BUSY;
1788                 goto out;
1789         }
1790
1791         fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
1792         if (fsp == NULL) {
1793                 rc = SCSI_MLQUEUE_HOST_BUSY;
1794                 goto out;
1795         }
1796
1797         /*
1798          * build the libfc request pkt
1799          */
1800         fsp->cmd = sc_cmd;      /* save the cmd */
1801         fsp->lp = lport;        /* save the softc ptr */
1802         fsp->rport = rport;     /* set the remote port ptr */
1803         fsp->xfer_ddp = FC_XID_UNKNOWN;
1804         sc_cmd->scsi_done = done;
1805
1806         /*
1807          * set up the transfer length
1808          */
1809         fsp->data_len = scsi_bufflen(sc_cmd);
1810         fsp->xfer_len = 0;
1811
1812         /*
1813          * setup the data direction
1814          */
1815         stats = fc_lport_get_stats(lport);
1816         if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
1817                 fsp->req_flags = FC_SRB_READ;
1818                 stats->InputRequests++;
1819                 stats->InputMegabytes = fsp->data_len;
1820         } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
1821                 fsp->req_flags = FC_SRB_WRITE;
1822                 stats->OutputRequests++;
1823                 stats->OutputMegabytes = fsp->data_len;
1824         } else {
1825                 fsp->req_flags = 0;
1826                 stats->ControlRequests++;
1827         }
1828
1829         fsp->tgt_flags = rpriv->flags;
1830
1831         init_timer(&fsp->timer);
1832         fsp->timer.data = (unsigned long)fsp;
1833
1834         /*
1835          * send it to the lower layer
1836          * if we get -1 return then put the request in the pending
1837          * queue.
1838          */
1839         rval = fc_fcp_pkt_send(lport, fsp);
1840         if (rval != 0) {
1841                 fsp->state = FC_SRB_FREE;
1842                 fc_fcp_pkt_release(fsp);
1843                 rc = SCSI_MLQUEUE_HOST_BUSY;
1844         }
1845 out:
1846         spin_lock_irq(lport->host->host_lock);
1847         return rc;
1848 }
1849 EXPORT_SYMBOL(fc_queuecommand);
1850
1851 /**
1852  * fc_io_compl() - Handle responses for completed commands
1853  * @fsp: The FCP packet that is complete
1854  *
1855  * Translates fcp_pkt errors to a Linux SCSI errors.
1856  * The fcp packet lock must be held when calling.
1857  */
1858 static void fc_io_compl(struct fc_fcp_pkt *fsp)
1859 {
1860         struct fc_fcp_internal *si;
1861         struct scsi_cmnd *sc_cmd;
1862         struct fc_lport *lport;
1863         unsigned long flags;
1864
1865         /* release outstanding ddp context */
1866         fc_fcp_ddp_done(fsp);
1867
1868         fsp->state |= FC_SRB_COMPL;
1869         if (!(fsp->state & FC_SRB_FCP_PROCESSING_TMO)) {
1870                 spin_unlock_bh(&fsp->scsi_pkt_lock);
1871                 del_timer_sync(&fsp->timer);
1872                 spin_lock_bh(&fsp->scsi_pkt_lock);
1873         }
1874
1875         lport = fsp->lp;
1876         si = fc_get_scsi_internal(lport);
1877         if (!fsp->cmd)
1878                 return;
1879
1880         /*
1881          * if can_queue ramp down is done then try can_queue ramp up
1882          * since commands are completing now.
1883          */
1884         if (si->last_can_queue_ramp_down_time)
1885                 fc_fcp_can_queue_ramp_up(lport);
1886
1887         sc_cmd = fsp->cmd;
1888         fsp->cmd = NULL;
1889
1890         if (!sc_cmd->SCp.ptr)
1891                 return;
1892
1893         CMD_SCSI_STATUS(sc_cmd) = fsp->cdb_status;
1894         switch (fsp->status_code) {
1895         case FC_COMPLETE:
1896                 if (fsp->cdb_status == 0) {
1897                         /*
1898                          * good I/O status
1899                          */
1900                         sc_cmd->result = DID_OK << 16;
1901                         if (fsp->scsi_resid)
1902                                 CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1903                 } else {
1904                         /*
1905                          * transport level I/O was ok but scsi
1906                          * has non zero status
1907                          */
1908                         sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
1909                 }
1910                 break;
1911         case FC_ERROR:
1912                 sc_cmd->result = DID_ERROR << 16;
1913                 break;
1914         case FC_DATA_UNDRUN:
1915                 if ((fsp->cdb_status == 0) && !(fsp->req_flags & FC_SRB_READ)) {
1916                         /*
1917                          * scsi status is good but transport level
1918                          * underrun.
1919                          */
1920                         sc_cmd->result = (fsp->state & FC_SRB_RCV_STATUS ?
1921                                           DID_OK : DID_ERROR) << 16;
1922                 } else {
1923                         /*
1924                          * scsi got underrun, this is an error
1925                          */
1926                         CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
1927                         sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1928                 }
1929                 break;
1930         case FC_DATA_OVRRUN:
1931                 /*
1932                  * overrun is an error
1933                  */
1934                 sc_cmd->result = (DID_ERROR << 16) | fsp->cdb_status;
1935                 break;
1936         case FC_CMD_ABORTED:
1937                 sc_cmd->result = (DID_ERROR << 16) | fsp->io_status;
1938                 break;
1939         case FC_CMD_TIME_OUT:
1940                 sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
1941                 break;
1942         case FC_CMD_RESET:
1943                 sc_cmd->result = (DID_RESET << 16);
1944                 break;
1945         case FC_HRD_ERROR:
1946                 sc_cmd->result = (DID_NO_CONNECT << 16);
1947                 break;
1948         default:
1949                 sc_cmd->result = (DID_ERROR << 16);
1950                 break;
1951         }
1952
1953         spin_lock_irqsave(&si->scsi_queue_lock, flags);
1954         list_del(&fsp->list);
1955         spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
1956         sc_cmd->SCp.ptr = NULL;
1957         sc_cmd->scsi_done(sc_cmd);
1958
1959         /* release ref from initial allocation in queue command */
1960         fc_fcp_pkt_release(fsp);
1961 }
1962
1963 /**
1964  * fc_eh_abort() - Abort a command
1965  * @sc_cmd: The SCSI command to abort
1966  *
1967  * From SCSI host template.
1968  * Send an ABTS to the target device and wait for the response.
1969  */
1970 int fc_eh_abort(struct scsi_cmnd *sc_cmd)
1971 {
1972         struct fc_fcp_pkt *fsp;
1973         struct fc_lport *lport;
1974         int rc = FAILED;
1975         unsigned long flags;
1976
1977         lport = shost_priv(sc_cmd->device->host);
1978         if (lport->state != LPORT_ST_READY)
1979                 return rc;
1980         else if (!lport->link_up)
1981                 return rc;
1982
1983         spin_lock_irqsave(lport->host->host_lock, flags);
1984         fsp = CMD_SP(sc_cmd);
1985         if (!fsp) {
1986                 /* command completed while scsi eh was setting up */
1987                 spin_unlock_irqrestore(lport->host->host_lock, flags);
1988                 return SUCCESS;
1989         }
1990         /* grab a ref so the fsp and sc_cmd cannot be relased from under us */
1991         fc_fcp_pkt_hold(fsp);
1992         spin_unlock_irqrestore(lport->host->host_lock, flags);
1993
1994         if (fc_fcp_lock_pkt(fsp)) {
1995                 /* completed while we were waiting for timer to be deleted */
1996                 rc = SUCCESS;
1997                 goto release_pkt;
1998         }
1999
2000         rc = fc_fcp_pkt_abort(fsp);
2001         fc_fcp_unlock_pkt(fsp);
2002
2003 release_pkt:
2004         fc_fcp_pkt_release(fsp);
2005         return rc;
2006 }
2007 EXPORT_SYMBOL(fc_eh_abort);
2008
2009 /**
2010  * fc_eh_device_reset() - Reset a single LUN
2011  * @sc_cmd: The SCSI command which identifies the device whose
2012  *          LUN is to be reset
2013  *
2014  * Set from SCSI host template.
2015  */
2016 int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
2017 {
2018         struct fc_lport *lport;
2019         struct fc_fcp_pkt *fsp;
2020         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
2021         int rc = FAILED;
2022         int rval;
2023
2024         rval = fc_remote_port_chkready(rport);
2025         if (rval)
2026                 goto out;
2027
2028         lport = shost_priv(sc_cmd->device->host);
2029
2030         if (lport->state != LPORT_ST_READY)
2031                 return rc;
2032
2033         FC_SCSI_DBG(lport, "Resetting rport (%6x)\n", rport->port_id);
2034
2035         fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
2036         if (fsp == NULL) {
2037                 printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
2038                 goto out;
2039         }
2040
2041         /*
2042          * Build the libfc request pkt. Do not set the scsi cmnd, because
2043          * the sc passed in is not setup for execution like when sent
2044          * through the queuecommand callout.
2045          */
2046         fsp->lp = lport;        /* save the softc ptr */
2047         fsp->rport = rport;     /* set the remote port ptr */
2048
2049         /*
2050          * flush outstanding commands
2051          */
2052         rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
2053         fsp->state = FC_SRB_FREE;
2054         fc_fcp_pkt_release(fsp);
2055
2056 out:
2057         return rc;
2058 }
2059 EXPORT_SYMBOL(fc_eh_device_reset);
2060
2061 /**
2062  * fc_eh_host_reset() - Reset a Scsi_Host.
2063  * @sc_cmd: The SCSI command that identifies the SCSI host to be reset
2064  */
2065 int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
2066 {
2067         struct Scsi_Host *shost = sc_cmd->device->host;
2068         struct fc_lport *lport = shost_priv(shost);
2069         unsigned long wait_tmo;
2070
2071         FC_SCSI_DBG(lport, "Resetting host\n");
2072
2073         lport->tt.lport_reset(lport);
2074         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
2075         while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
2076                                                                wait_tmo))
2077                 msleep(1000);
2078
2079         if (fc_fcp_lport_queue_ready(lport)) {
2080                 shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
2081                              "on port (%6x)\n", fc_host_port_id(lport->host));
2082                 return SUCCESS;
2083         } else {
2084                 shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
2085                              "port (%6x) is not ready.\n",
2086                              fc_host_port_id(lport->host));
2087                 return FAILED;
2088         }
2089 }
2090 EXPORT_SYMBOL(fc_eh_host_reset);
2091
2092 /**
2093  * fc_slave_alloc() - Configure the queue depth of a Scsi_Host
2094  * @sdev: The SCSI device that identifies the SCSI host
2095  *
2096  * Configures queue depth based on host's cmd_per_len. If not set
2097  * then we use the libfc default.
2098  */
2099 int fc_slave_alloc(struct scsi_device *sdev)
2100 {
2101         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2102
2103         if (!rport || fc_remote_port_chkready(rport))
2104                 return -ENXIO;
2105
2106         if (sdev->tagged_supported)
2107                 scsi_activate_tcq(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
2108         else
2109                 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2110                                         FC_FCP_DFLT_QUEUE_DEPTH);
2111
2112         return 0;
2113 }
2114 EXPORT_SYMBOL(fc_slave_alloc);
2115
2116 /**
2117  * fc_change_queue_depth() - Change a device's queue depth
2118  * @sdev:   The SCSI device whose queue depth is to change
2119  * @qdepth: The new queue depth
2120  * @reason: The resason for the change
2121  */
2122 int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
2123 {
2124         switch (reason) {
2125         case SCSI_QDEPTH_DEFAULT:
2126                 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
2127                 break;
2128         case SCSI_QDEPTH_QFULL:
2129                 scsi_track_queue_full(sdev, qdepth);
2130                 break;
2131         case SCSI_QDEPTH_RAMP_UP:
2132                 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
2133                 break;
2134         default:
2135                 return -EOPNOTSUPP;
2136         }
2137         return sdev->queue_depth;
2138 }
2139 EXPORT_SYMBOL(fc_change_queue_depth);
2140
2141 /**
2142  * fc_change_queue_type() - Change a device's queue type
2143  * @sdev:     The SCSI device whose queue depth is to change
2144  * @tag_type: Identifier for queue type
2145  */
2146 int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
2147 {
2148         if (sdev->tagged_supported) {
2149                 scsi_set_tag_type(sdev, tag_type);
2150                 if (tag_type)
2151                         scsi_activate_tcq(sdev, sdev->queue_depth);
2152                 else
2153                         scsi_deactivate_tcq(sdev, sdev->queue_depth);
2154         } else
2155                 tag_type = 0;
2156
2157         return tag_type;
2158 }
2159 EXPORT_SYMBOL(fc_change_queue_type);
2160
2161 /**
2162  * fc_fcp_destory() - Tear down the FCP layer for a given local port
2163  * @lport: The local port that no longer needs the FCP layer
2164  */
2165 void fc_fcp_destroy(struct fc_lport *lport)
2166 {
2167         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
2168
2169         if (!list_empty(&si->scsi_pkt_queue))
2170                 printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
2171                        "port (%6x)\n", fc_host_port_id(lport->host));
2172
2173         mempool_destroy(si->scsi_pkt_pool);
2174         kfree(si);
2175         lport->scsi_priv = NULL;
2176 }
2177 EXPORT_SYMBOL(fc_fcp_destroy);
2178
2179 int fc_setup_fcp()
2180 {
2181         int rc = 0;
2182
2183         scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
2184                                             sizeof(struct fc_fcp_pkt),
2185                                             0, SLAB_HWCACHE_ALIGN, NULL);
2186         if (!scsi_pkt_cachep) {
2187                 printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
2188                        "module load failed!");
2189                 rc = -ENOMEM;
2190         }
2191
2192         return rc;
2193 }
2194
2195 void fc_destroy_fcp()
2196 {
2197         if (scsi_pkt_cachep)
2198                 kmem_cache_destroy(scsi_pkt_cachep);
2199 }
2200
2201 /**
2202  * fc_fcp_init() - Initialize the FCP layer for a local port
2203  * @lport: The local port to initialize the exchange layer for
2204  */
2205 int fc_fcp_init(struct fc_lport *lport)
2206 {
2207         int rc;
2208         struct fc_fcp_internal *si;
2209
2210         if (!lport->tt.fcp_cmd_send)
2211                 lport->tt.fcp_cmd_send = fc_fcp_cmd_send;
2212
2213         if (!lport->tt.fcp_cleanup)
2214                 lport->tt.fcp_cleanup = fc_fcp_cleanup;
2215
2216         if (!lport->tt.fcp_abort_io)
2217                 lport->tt.fcp_abort_io = fc_fcp_abort_io;
2218
2219         si = kzalloc(sizeof(struct fc_fcp_internal), GFP_KERNEL);
2220         if (!si)
2221                 return -ENOMEM;
2222         lport->scsi_priv = si;
2223         si->max_can_queue = lport->host->can_queue;
2224         INIT_LIST_HEAD(&si->scsi_pkt_queue);
2225         spin_lock_init(&si->scsi_queue_lock);
2226
2227         si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);
2228         if (!si->scsi_pkt_pool) {
2229                 rc = -ENOMEM;
2230                 goto free_internal;
2231         }
2232         return 0;
2233
2234 free_internal:
2235         kfree(si);
2236         return rc;
2237 }
2238 EXPORT_SYMBOL(fc_fcp_init);