[SCSI] libfc, fcoe: fixed locking issues with lport->lp_mutex around lport->link_status
[linux-2.6.git] / include / scsi / libfc.h
1 /*
2  * Copyright(c) 2007 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
16  *
17  * Maintained at www.Open-FCoE.org
18  */
19
20 #ifndef _LIBFC_H_
21 #define _LIBFC_H_
22
23 #include <linux/timer.h>
24 #include <linux/if.h>
25
26 #include <scsi/scsi_transport.h>
27 #include <scsi/scsi_transport_fc.h>
28
29 #include <scsi/fc/fc_fcp.h>
30 #include <scsi/fc/fc_ns.h>
31 #include <scsi/fc/fc_els.h>
32 #include <scsi/fc/fc_gs.h>
33
34 #include <scsi/fc_frame.h>
35
36 #define LIBFC_DEBUG
37
38 #ifdef LIBFC_DEBUG
39 /* Log messages */
40 #define FC_DBG(fmt, args...)                                            \
41         do {                                                            \
42                 printk(KERN_INFO "%s " fmt, __func__, ##args);          \
43         } while (0)
44 #else
45 #define FC_DBG(fmt, args...)
46 #endif
47
48 /*
49  * libfc error codes
50  */
51 #define FC_NO_ERR       0       /* no error */
52 #define FC_EX_TIMEOUT   1       /* Exchange timeout */
53 #define FC_EX_CLOSED    2       /* Exchange closed */
54
55 /* some helpful macros */
56
57 #define ntohll(x) be64_to_cpu(x)
58 #define htonll(x) cpu_to_be64(x)
59
60 #define ntoh24(p) (((p)[0] << 16) | ((p)[1] << 8) | ((p)[2]))
61
62 #define hton24(p, v)    do {                    \
63                 p[0] = (((v) >> 16) & 0xFF);    \
64                 p[1] = (((v) >> 8) & 0xFF);     \
65                 p[2] = ((v) & 0xFF);            \
66         } while (0)
67
68 /*
69  * FC HBA status
70  */
71 enum fc_lport_state {
72         LPORT_ST_NONE = 0,
73         LPORT_ST_FLOGI,
74         LPORT_ST_DNS,
75         LPORT_ST_RPN_ID,
76         LPORT_ST_RFT_ID,
77         LPORT_ST_SCR,
78         LPORT_ST_READY,
79         LPORT_ST_LOGO,
80         LPORT_ST_RESET
81 };
82
83 enum fc_disc_event {
84         DISC_EV_NONE = 0,
85         DISC_EV_SUCCESS,
86         DISC_EV_FAILED
87 };
88
89 enum fc_rport_state {
90         RPORT_ST_NONE = 0,
91         RPORT_ST_INIT,          /* initialized */
92         RPORT_ST_PLOGI,         /* waiting for PLOGI completion */
93         RPORT_ST_PRLI,          /* waiting for PRLI completion */
94         RPORT_ST_RTV,           /* waiting for RTV completion */
95         RPORT_ST_READY,         /* ready for use */
96         RPORT_ST_LOGO,          /* port logout sent */
97 };
98
99 enum fc_rport_trans_state {
100         FC_PORTSTATE_ROGUE,
101         FC_PORTSTATE_REAL,
102 };
103
104 /**
105  * struct fc_disc_port - temporary discovery port to hold rport identifiers
106  * @lp: Fibre Channel host port instance
107  * @peers: node for list management during discovery and RSCN processing
108  * @ids: identifiers structure to pass to fc_remote_port_add()
109  * @rport_work: work struct for starting the rport state machine
110  */
111 struct fc_disc_port {
112         struct fc_lport             *lp;
113         struct list_head            peers;
114         struct fc_rport_identifiers ids;
115         struct work_struct          rport_work;
116 };
117
118 enum fc_rport_event {
119         RPORT_EV_NONE = 0,
120         RPORT_EV_CREATED,
121         RPORT_EV_FAILED,
122         RPORT_EV_STOP,
123         RPORT_EV_LOGO
124 };
125
126 struct fc_rport_operations {
127         void (*event_callback)(struct fc_lport *, struct fc_rport *,
128                                enum fc_rport_event);
129 };
130
131 /**
132  * struct fc_rport_libfc_priv - libfc internal information about a remote port
133  * @local_port: Fibre Channel host port instance
134  * @rp_state: state tracks progress of PLOGI, PRLI, and RTV exchanges
135  * @flags: REC and RETRY supported flags
136  * @max_seq: maximum number of concurrent sequences
137  * @retries: retry count in current state
138  * @e_d_tov: error detect timeout value (in msec)
139  * @r_a_tov: resource allocation timeout value (in msec)
140  * @rp_mutex: mutex protects rport
141  * @retry_work:
142  * @event_callback: Callback for rport READY, FAILED or LOGO
143  */
144 struct fc_rport_libfc_priv {
145         struct fc_lport            *local_port;
146         enum fc_rport_state        rp_state;
147         u16                        flags;
148         #define FC_RP_FLAGS_REC_SUPPORTED       (1 << 0)
149         #define FC_RP_FLAGS_RETRY               (1 << 1)
150         u16                        max_seq;
151         unsigned int               retries;
152         unsigned int               e_d_tov;
153         unsigned int               r_a_tov;
154         enum fc_rport_trans_state  trans_state;
155         struct mutex               rp_mutex;
156         struct delayed_work        retry_work;
157         enum fc_rport_event        event;
158         struct fc_rport_operations *ops;
159         struct list_head           peers;
160         struct work_struct         event_work;
161 };
162
163 #define PRIV_TO_RPORT(x)                                                \
164         (struct fc_rport *)((void *)x - sizeof(struct fc_rport));
165 #define RPORT_TO_PRIV(x)                                                \
166         (struct fc_rport_libfc_priv *)((void *)x + sizeof(struct fc_rport));
167
168 struct fc_rport *fc_rport_rogue_create(struct fc_disc_port *);
169
170 static inline void fc_rport_set_name(struct fc_rport *rport, u64 wwpn, u64 wwnn)
171 {
172         rport->node_name = wwnn;
173         rport->port_name = wwpn;
174 }
175
176 /*
177  * fcoe stats structure
178  */
179 struct fcoe_dev_stats {
180         u64             SecondsSinceLastReset;
181         u64             TxFrames;
182         u64             TxWords;
183         u64             RxFrames;
184         u64             RxWords;
185         u64             ErrorFrames;
186         u64             DumpedFrames;
187         u64             LinkFailureCount;
188         u64             LossOfSignalCount;
189         u64             InvalidTxWordCount;
190         u64             InvalidCRCCount;
191         u64             InputRequests;
192         u64             OutputRequests;
193         u64             ControlRequests;
194         u64             InputMegabytes;
195         u64             OutputMegabytes;
196 };
197
198 /*
199  * els data is used for passing ELS respone specific
200  * data to send ELS response mainly using infomation
201  * in exchange and sequence in EM layer.
202  */
203 struct fc_seq_els_data {
204         struct fc_frame *fp;
205         enum fc_els_rjt_reason reason;
206         enum fc_els_rjt_explan explan;
207 };
208
209 /*
210  * FCP request structure, one for each scsi cmd request
211  */
212 struct fc_fcp_pkt {
213         /*
214          * housekeeping stuff
215          */
216         struct fc_lport *lp;    /* handle to hba struct */
217         u16             state;          /* scsi_pkt state state */
218         u16             tgt_flags;      /* target flags  */
219         atomic_t        ref_cnt;        /* fcp pkt ref count */
220         spinlock_t      scsi_pkt_lock;  /* Must be taken before the host lock
221                                          * if both are held at the same time */
222         /*
223          * SCSI I/O related stuff
224          */
225         struct scsi_cmnd *cmd;          /* scsi command pointer. set/clear
226                                          * under host lock */
227         struct list_head list;          /* tracks queued commands. access under
228                                          * host lock */
229         /*
230          * timeout related stuff
231          */
232         struct timer_list timer;        /* command timer */
233         struct completion tm_done;
234         int     wait_for_comp;
235         unsigned long   start_time;     /* start jiffie */
236         unsigned long   end_time;       /* end jiffie */
237         unsigned long   last_pkt_time;   /* jiffies of last frame received */
238
239         /*
240          * scsi cmd and data transfer information
241          */
242         u32             data_len;
243         /*
244          * transport related veriables
245          */
246         struct fcp_cmnd cdb_cmd;
247         size_t          xfer_len;
248         u32             xfer_contig_end; /* offset of end of contiguous xfer */
249         u16             max_payload;    /* max payload size in bytes */
250
251         /*
252          * scsi/fcp return status
253          */
254         u32             io_status;      /* SCSI result upper 24 bits */
255         u8              cdb_status;
256         u8              status_code;    /* FCP I/O status */
257         /* bit 3 Underrun bit 2: overrun */
258         u8              scsi_comp_flags;
259         u32             req_flags;      /* bit 0: read bit:1 write */
260         u32             scsi_resid;     /* residule length */
261
262         struct fc_rport *rport;         /* remote port pointer */
263         struct fc_seq   *seq_ptr;       /* current sequence pointer */
264         /*
265          * Error Processing
266          */
267         u8              recov_retry;    /* count of recovery retries */
268         struct fc_seq   *recov_seq;     /* sequence for REC or SRR */
269 };
270
271 /*
272  * Structure and function definitions for managing Fibre Channel Exchanges
273  * and Sequences
274  *
275  * fc_exch holds state for one exchange and links to its active sequence.
276  *
277  * fc_seq holds the state for an individual sequence.
278  */
279
280 struct fc_exch_mgr;
281
282 /*
283  * Sequence.
284  */
285 struct fc_seq {
286         u8      id;             /* seq ID */
287         u16     ssb_stat;       /* status flags for sequence status block */
288         u16     cnt;            /* frames sent so far on sequence */
289         u32     rec_data;       /* FC-4 value for REC */
290 };
291
292 #define FC_EX_DONE              (1 << 0) /* ep is completed */
293 #define FC_EX_RST_CLEANUP       (1 << 1) /* reset is forcing completion */
294
295 /*
296  * Exchange.
297  *
298  * Locking notes: The ex_lock protects following items:
299  *      state, esb_stat, f_ctl, seq.ssb_stat
300  *      seq_id
301  *      sequence allocation
302  */
303 struct fc_exch {
304         struct fc_exch_mgr *em;         /* exchange manager */
305         u32             state;          /* internal driver state */
306         u16             xid;            /* our exchange ID */
307         struct list_head        ex_list;        /* free or busy list linkage */
308         spinlock_t      ex_lock;        /* lock covering exchange state */
309         atomic_t        ex_refcnt;      /* reference counter */
310         struct delayed_work timeout_work; /* timer for upper level protocols */
311         struct fc_lport *lp;            /* fc device instance */
312         u16             oxid;           /* originator's exchange ID */
313         u16             rxid;           /* responder's exchange ID */
314         u32             oid;            /* originator's FCID */
315         u32             sid;            /* source FCID */
316         u32             did;            /* destination FCID */
317         u32             esb_stat;       /* exchange status for ESB */
318         u32             r_a_tov;        /* r_a_tov from rport (msec) */
319         u8              seq_id;         /* next sequence ID to use */
320         u32             f_ctl;          /* F_CTL flags for sequences */
321         u8              fh_type;        /* frame type */
322         enum fc_class   class;          /* class of service */
323         struct fc_seq   seq;            /* single sequence */
324         /*
325          * Handler for responses to this current exchange.
326          */
327         void            (*resp)(struct fc_seq *, struct fc_frame *, void *);
328         void            (*destructor)(struct fc_seq *, void *);
329         /*
330          * arg is passed as void pointer to exchange
331          * resp and destructor handlers
332          */
333         void            *arg;
334 };
335 #define fc_seq_exch(sp) container_of(sp, struct fc_exch, seq)
336
337 struct libfc_function_template {
338
339         /**
340          * Mandatory Fields
341          *
342          * These handlers must be implemented by the LLD.
343          */
344
345         /*
346          * Interface to send a FC frame
347          */
348         int (*frame_send)(struct fc_lport *lp, struct fc_frame *fp);
349
350         /**
351          * Optional Fields
352          *
353          * The LLD may choose to implement any of the following handlers.
354          * If LLD doesn't specify hander and leaves its pointer NULL then
355          * the default libfc function will be used for that handler.
356          */
357
358         /**
359          * ELS/CT interfaces
360          */
361
362         /*
363          * elsct_send - sends ELS/CT frame
364          */
365         struct fc_seq *(*elsct_send)(struct fc_lport *lport,
366                                      struct fc_rport *rport,
367                                      struct fc_frame *fp,
368                                      unsigned int op,
369                                      void (*resp)(struct fc_seq *,
370                                              struct fc_frame *fp,
371                                              void *arg),
372                                      void *arg, u32 timer_msec);
373         /**
374          * Exhance Manager interfaces
375          */
376
377         /*
378          * Send the FC frame payload using a new exchange and sequence.
379          *
380          * The frame pointer with some of the header's fields must be
381          * filled before calling exch_seq_send(), those fields are,
382          *
383          * - routing control
384          * - FC port did
385          * - FC port sid
386          * - FC header type
387          * - frame control
388          * - parameter or relative offset
389          *
390          * The exchange response handler is set in this routine to resp()
391          * function pointer. It can be called in two scenarios: if a timeout
392          * occurs or if a response frame is received for the exchange. The
393          * fc_frame pointer in response handler will also indicate timeout
394          * as error using IS_ERR related macros.
395          *
396          * The exchange destructor handler is also set in this routine.
397          * The destructor handler is invoked by EM layer when exchange
398          * is about to free, this can be used by caller to free its
399          * resources along with exchange free.
400          *
401          * The arg is passed back to resp and destructor handler.
402          *
403          * The timeout value (in msec) for an exchange is set if non zero
404          * timer_msec argument is specified. The timer is canceled when
405          * it fires or when the exchange is done. The exchange timeout handler
406          * is registered by EM layer.
407          */
408         struct fc_seq *(*exch_seq_send)(struct fc_lport *lp,
409                                         struct fc_frame *fp,
410                                         void (*resp)(struct fc_seq *sp,
411                                                      struct fc_frame *fp,
412                                                      void *arg),
413                                         void (*destructor)(struct fc_seq *sp,
414                                                            void *arg),
415                                         void *arg, unsigned int timer_msec);
416
417         /*
418          * send a frame using existing sequence and exchange.
419          */
420         int (*seq_send)(struct fc_lport *lp, struct fc_seq *sp,
421                         struct fc_frame *fp);
422
423         /*
424          * Send ELS response using mainly infomation
425          * in exchange and sequence in EM layer.
426          */
427         void (*seq_els_rsp_send)(struct fc_seq *sp, enum fc_els_cmd els_cmd,
428                                  struct fc_seq_els_data *els_data);
429
430         /*
431          * Abort an exchange and sequence. Generally called because of a
432          * exchange timeout or an abort from the upper layer.
433          *
434          * A timer_msec can be specified for abort timeout, if non-zero
435          * timer_msec value is specified then exchange resp handler
436          * will be called with timeout error if no response to abort.
437          */
438         int (*seq_exch_abort)(const struct fc_seq *req_sp,
439                               unsigned int timer_msec);
440
441         /*
442          * Indicate that an exchange/sequence tuple is complete and the memory
443          * allocated for the related objects may be freed.
444          */
445         void (*exch_done)(struct fc_seq *sp);
446
447         /*
448          * Assigns a EM and a free XID for an new exchange and then
449          * allocates a new exchange and sequence pair.
450          * The fp can be used to determine free XID.
451          */
452         struct fc_exch *(*exch_get)(struct fc_lport *lp, struct fc_frame *fp);
453
454         /*
455          * Release previously assigned XID by exch_get API.
456          * The LLD may implement this if XID is assigned by LLD
457          * in exch_get().
458          */
459         void (*exch_put)(struct fc_lport *lp, struct fc_exch_mgr *mp,
460                          u16 ex_id);
461
462         /*
463          * Start a new sequence on the same exchange/sequence tuple.
464          */
465         struct fc_seq *(*seq_start_next)(struct fc_seq *sp);
466
467         /*
468          * Reset an exchange manager, completing all sequences and exchanges.
469          * If s_id is non-zero, reset only exchanges originating from that FID.
470          * If d_id is non-zero, reset only exchanges sending to that FID.
471          */
472         void (*exch_mgr_reset)(struct fc_lport *,
473                                u32 s_id, u32 d_id);
474
475         void (*rport_flush_queue)(void);
476         /**
477          * Local Port interfaces
478          */
479
480         /*
481          * Receive a frame to a local port.
482          */
483         void (*lport_recv)(struct fc_lport *lp, struct fc_seq *sp,
484                            struct fc_frame *fp);
485
486         int (*lport_reset)(struct fc_lport *);
487
488         /**
489          * Remote Port interfaces
490          */
491
492         /*
493          * Initiates the RP state machine. It is called from the LP module.
494          * This function will issue the following commands to the N_Port
495          * identified by the FC ID provided.
496          *
497          * - PLOGI
498          * - PRLI
499          * - RTV
500          */
501         int (*rport_login)(struct fc_rport *rport);
502
503         /*
504          * Logoff, and remove the rport from the transport if
505          * it had been added. This will send a LOGO to the target.
506          */
507         int (*rport_logoff)(struct fc_rport *rport);
508
509         /*
510          * Recieve a request from a remote port.
511          */
512         void (*rport_recv_req)(struct fc_seq *, struct fc_frame *,
513                                struct fc_rport *);
514
515         struct fc_rport *(*rport_lookup)(const struct fc_lport *, u32);
516
517         /**
518          * FCP interfaces
519          */
520
521         /*
522          * Send a fcp cmd from fsp pkt.
523          * Called with the SCSI host lock unlocked and irqs disabled.
524          *
525          * The resp handler is called when FCP_RSP received.
526          *
527          */
528         int (*fcp_cmd_send)(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
529                             void (*resp)(struct fc_seq *, struct fc_frame *fp,
530                                          void *arg));
531
532         /*
533          * Used at least durring linkdown and reset
534          */
535         void (*fcp_cleanup)(struct fc_lport *lp);
536
537         /*
538          * Abort all I/O on a local port
539          */
540         void (*fcp_abort_io)(struct fc_lport *lp);
541
542         /**
543          * Discovery interfaces
544          */
545
546         void (*disc_recv_req)(struct fc_seq *,
547                               struct fc_frame *, struct fc_lport *);
548
549         /*
550          * Start discovery for a local port.
551          */
552         void (*disc_start)(void (*disc_callback)(struct fc_lport *,
553                                                  enum fc_disc_event),
554                            struct fc_lport *);
555
556         /*
557          * Stop discovery for a given lport. This will remove
558          * all discovered rports
559          */
560         void (*disc_stop) (struct fc_lport *);
561
562         /*
563          * Stop discovery for a given lport. This will block
564          * until all discovered rports are deleted from the
565          * FC transport class
566          */
567         void (*disc_stop_final) (struct fc_lport *);
568 };
569
570 /* information used by the discovery layer */
571 struct fc_disc {
572         unsigned char           retry_count;
573         unsigned char           delay;
574         unsigned char           pending;
575         unsigned char           requested;
576         unsigned short          seq_count;
577         unsigned char           buf_len;
578         enum fc_disc_event      event;
579
580         void (*disc_callback)(struct fc_lport *,
581                               enum fc_disc_event);
582
583         struct list_head         rports;
584         struct fc_lport         *lport;
585         struct mutex            disc_mutex;
586         struct fc_gpn_ft_resp   partial_buf;    /* partial name buffer */
587         struct delayed_work     disc_work;
588 };
589
590 struct fc_lport {
591         struct list_head list;
592
593         /* Associations */
594         struct Scsi_Host        *host;
595         struct fc_exch_mgr      *emp;
596         struct fc_rport         *dns_rp;
597         struct fc_rport         *ptp_rp;
598         void                    *scsi_priv;
599         struct fc_disc          disc;
600
601         /* Operational Information */
602         struct libfc_function_template tt;
603         u8                      link_up;
604         u8                      qfull;
605         enum fc_lport_state     state;
606         unsigned long           boot_time;
607
608         struct fc_host_statistics host_stats;
609         struct fcoe_dev_stats   *dev_stats[NR_CPUS];
610         u64                     wwpn;
611         u64                     wwnn;
612         u8                      retry_count;
613
614         /* Capabilities */
615         u32                     sg_supp:1;      /* scatter gather supported */
616         u32                     seq_offload:1;  /* seq offload supported */
617         u32                     crc_offload:1;  /* crc offload supported */
618         u32                     lro_enabled:1;  /* large receive offload */
619         u32                     mfs;            /* max FC payload size */
620         unsigned int            service_params;
621         unsigned int            e_d_tov;
622         unsigned int            r_a_tov;
623         u8                      max_retry_count;
624         u16                     link_speed;
625         u16                     link_supported_speeds;
626         u16                     lro_xid;        /* max xid for fcoe lro */
627         struct fc_ns_fts        fcts;           /* FC-4 type masks */
628         struct fc_els_rnid_gen  rnid_gen;       /* RNID information */
629
630         /* Semaphores */
631         struct mutex lp_mutex;
632
633         /* Miscellaneous */
634         struct delayed_work     retry_work;
635         struct delayed_work     disc_work;
636 };
637
638 /**
639  * FC_LPORT HELPER FUNCTIONS
640  *****************************/
641 static inline void *lport_priv(const struct fc_lport *lp)
642 {
643         return (void *)(lp + 1);
644 }
645
646 static inline int fc_lport_test_ready(struct fc_lport *lp)
647 {
648         return lp->state == LPORT_ST_READY;
649 }
650
651 static inline void fc_set_wwnn(struct fc_lport *lp, u64 wwnn)
652 {
653         lp->wwnn = wwnn;
654 }
655
656 static inline void fc_set_wwpn(struct fc_lport *lp, u64 wwnn)
657 {
658         lp->wwpn = wwnn;
659 }
660
661 static inline void fc_lport_state_enter(struct fc_lport *lp,
662                                         enum fc_lport_state state)
663 {
664         if (state != lp->state)
665                 lp->retry_count = 0;
666         lp->state = state;
667 }
668
669
670 /**
671  * LOCAL PORT LAYER
672  *****************************/
673 int fc_lport_init(struct fc_lport *lp);
674
675 /*
676  * Destroy the specified local port by finding and freeing all
677  * fc_rports associated with it and then by freeing the fc_lport
678  * itself.
679  */
680 int fc_lport_destroy(struct fc_lport *lp);
681
682 /*
683  * Logout the specified local port from the fabric
684  */
685 int fc_fabric_logoff(struct fc_lport *lp);
686
687 /*
688  * Initiate the LP state machine. This handler will use fc_host_attr
689  * to store the FLOGI service parameters, so fc_host_attr must be
690  * initialized before calling this handler.
691  */
692 int fc_fabric_login(struct fc_lport *lp);
693
694 /*
695  * The link is up for the given local port.
696  */
697 void fc_linkup(struct fc_lport *);
698
699 /*
700  * Link is down for the given local port.
701  */
702 void fc_linkdown(struct fc_lport *);
703
704 /*
705  * Configure the local port.
706  */
707 int fc_lport_config(struct fc_lport *);
708
709 /*
710  * Reset the local port.
711  */
712 int fc_lport_reset(struct fc_lport *);
713
714 /*
715  * Set the mfs or reset
716  */
717 int fc_set_mfs(struct fc_lport *lp, u32 mfs);
718
719
720 /**
721  * REMOTE PORT LAYER
722  *****************************/
723 int fc_rport_init(struct fc_lport *lp);
724 void fc_rport_terminate_io(struct fc_rport *rp);
725
726 /**
727  * DISCOVERY LAYER
728  *****************************/
729 int fc_disc_init(struct fc_lport *lp);
730
731
732 /**
733  * SCSI LAYER
734  *****************************/
735 /*
736  * Initialize the SCSI block of libfc
737  */
738 int fc_fcp_init(struct fc_lport *);
739
740 /*
741  * This section provides an API which allows direct interaction
742  * with the SCSI-ml. Each of these functions satisfies a function
743  * pointer defined in Scsi_Host and therefore is always called
744  * directly from the SCSI-ml.
745  */
746 int fc_queuecommand(struct scsi_cmnd *sc_cmd,
747                     void (*done)(struct scsi_cmnd *));
748
749 /*
750  * complete processing of a fcp packet
751  *
752  * This function may sleep if a fsp timer is pending.
753  * The host lock must not be held by caller.
754  */
755 void fc_fcp_complete(struct fc_fcp_pkt *fsp);
756
757 /*
758  * Send an ABTS frame to the target device. The sc_cmd argument
759  * is a pointer to the SCSI command to be aborted.
760  */
761 int fc_eh_abort(struct scsi_cmnd *sc_cmd);
762
763 /*
764  * Reset a LUN by sending send the tm cmd to the target.
765  */
766 int fc_eh_device_reset(struct scsi_cmnd *sc_cmd);
767
768 /*
769  * Reset the host adapter.
770  */
771 int fc_eh_host_reset(struct scsi_cmnd *sc_cmd);
772
773 /*
774  * Check rport status.
775  */
776 int fc_slave_alloc(struct scsi_device *sdev);
777
778 /*
779  * Adjust the queue depth.
780  */
781 int fc_change_queue_depth(struct scsi_device *sdev, int qdepth);
782
783 /*
784  * Change the tag type.
785  */
786 int fc_change_queue_type(struct scsi_device *sdev, int tag_type);
787
788 /*
789  * Free memory pools used by the FCP layer.
790  */
791 void fc_fcp_destroy(struct fc_lport *);
792
793 /**
794  * ELS/CT interface
795  *****************************/
796 /*
797  * Initializes ELS/CT interface
798  */
799 int fc_elsct_init(struct fc_lport *lp);
800
801
802 /**
803  * EXCHANGE MANAGER LAYER
804  *****************************/
805 /*
806  * Initializes Exchange Manager related
807  * function pointers in struct libfc_function_template.
808  */
809 int fc_exch_init(struct fc_lport *lp);
810
811 /*
812  * Allocates an Exchange Manager (EM).
813  *
814  * The EM manages exchanges for their allocation and
815  * free, also allows exchange lookup for received
816  * frame.
817  *
818  * The class is used for initializing FC class of
819  * allocated exchange from EM.
820  *
821  * The min_xid and max_xid will limit new
822  * exchange ID (XID) within this range for
823  * a new exchange.
824  * The LLD may choose to have multiple EMs,
825  * e.g. one EM instance per CPU receive thread in LLD.
826  * The LLD can use exch_get() of struct libfc_function_template
827  * to specify XID for a new exchange within
828  * a specified EM instance.
829  *
830  * The em_idx to uniquely identify an EM instance.
831  */
832 struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
833                                       enum fc_class class,
834                                       u16 min_xid,
835                                       u16 max_xid);
836
837 /*
838  * Free an exchange manager.
839  */
840 void fc_exch_mgr_free(struct fc_exch_mgr *mp);
841
842 /*
843  * Receive a frame on specified local port and exchange manager.
844  */
845 void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
846                   struct fc_frame *fp);
847
848 /*
849  * This function is for exch_seq_send function pointer in
850  * struct libfc_function_template, see comment block on
851  * exch_seq_send for description of this function.
852  */
853 struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
854                                 struct fc_frame *fp,
855                                 void (*resp)(struct fc_seq *sp,
856                                              struct fc_frame *fp,
857                                              void *arg),
858                                 void (*destructor)(struct fc_seq *sp,
859                                                    void *arg),
860                                 void *arg, u32 timer_msec);
861
862 /*
863  * send a frame using existing sequence and exchange.
864  */
865 int fc_seq_send(struct fc_lport *lp, struct fc_seq *sp, struct fc_frame *fp);
866
867 /*
868  * Send ELS response using mainly infomation
869  * in exchange and sequence in EM layer.
870  */
871 void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
872                          struct fc_seq_els_data *els_data);
873
874 /*
875  * This function is for seq_exch_abort function pointer in
876  * struct libfc_function_template, see comment block on
877  * seq_exch_abort for description of this function.
878  */
879 int fc_seq_exch_abort(const struct fc_seq *req_sp, unsigned int timer_msec);
880
881 /*
882  * Indicate that an exchange/sequence tuple is complete and the memory
883  * allocated for the related objects may be freed.
884  */
885 void fc_exch_done(struct fc_seq *sp);
886
887 /*
888  * Assigns a EM and XID for a frame and then allocates
889  * a new exchange and sequence pair.
890  * The fp can be used to determine free XID.
891  */
892 struct fc_exch *fc_exch_get(struct fc_lport *lp, struct fc_frame *fp);
893
894 /*
895  * Allocate a new exchange and sequence pair.
896  * if ex_id is zero then next free exchange id
897  * from specified exchange manger mp will be assigned.
898  */
899 struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp,
900                               struct fc_frame *fp, u16 ex_id);
901 /*
902  * Start a new sequence on the same exchange as the supplied sequence.
903  */
904 struct fc_seq *fc_seq_start_next(struct fc_seq *sp);
905
906 /*
907  * Reset an exchange manager, completing all sequences and exchanges.
908  * If s_id is non-zero, reset only exchanges originating from that FID.
909  * If d_id is non-zero, reset only exchanges sending to that FID.
910  */
911 void fc_exch_mgr_reset(struct fc_lport *, u32 s_id, u32 d_id);
912
913 /*
914  * Functions for fc_functions_template
915  */
916 void fc_get_host_speed(struct Scsi_Host *shost);
917 void fc_get_host_port_type(struct Scsi_Host *shost);
918 void fc_get_host_port_state(struct Scsi_Host *shost);
919 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout);
920 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *);
921
922 /*
923  * module setup functions.
924  */
925 int fc_setup_exch_mgr(void);
926 void fc_destroy_exch_mgr(void);
927 int fc_setup_rport(void);
928 void fc_destroy_rport(void);
929
930 #endif /* _LIBFC_H_ */