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#include <linux/percpu.h>
26
27#include <scsi/scsi_transport.h>
28#include <scsi/scsi_transport_fc.h>
29#include <scsi/scsi_bsg_fc.h>
30
31#include <scsi/fc/fc_fcp.h>
32#include <scsi/fc/fc_ns.h>
33#include <scsi/fc/fc_ms.h>
34#include <scsi/fc/fc_els.h>
35#include <scsi/fc/fc_gs.h>
36
37#include <scsi/fc_frame.h>
38
39#define	FC_FC4_PROV_SIZE	(FC_TYPE_FCP + 1)	/* size of tables */
40
41/*
42 * libfc error codes
43 */
44#define	FC_NO_ERR	0	/* no error */
45#define	FC_EX_TIMEOUT	1	/* Exchange timeout */
46#define	FC_EX_CLOSED	2	/* Exchange closed */
47
48/**
49 * enum fc_lport_state - Local port states
50 * @LPORT_ST_DISABLED: Disabled
51 * @LPORT_ST_FLOGI:    Fabric login (FLOGI) sent
52 * @LPORT_ST_DNS:      Waiting for name server remote port to become ready
53 * @LPORT_ST_RPN_ID:   Register port name by ID (RPN_ID) sent
54 * @LPORT_ST_RFT_ID:   Register Fibre Channel types by ID (RFT_ID) sent
55 * @LPORT_ST_RFF_ID:   Register FC-4 Features by ID (RFF_ID) sent
56 * @LPORT_ST_FDMI:     Waiting for mgmt server rport to become ready
57 * @LPORT_ST_RHBA:
58 * @LPORT_ST_SCR:      State Change Register (SCR) sent
59 * @LPORT_ST_READY:    Ready for use
60 * @LPORT_ST_LOGO:     Local port logout (LOGO) sent
61 * @LPORT_ST_RESET:    Local port reset
62 */
63enum fc_lport_state {
64	LPORT_ST_DISABLED = 0,
65	LPORT_ST_FLOGI,
66	LPORT_ST_DNS,
67	LPORT_ST_RNN_ID,
68	LPORT_ST_RSNN_NN,
69	LPORT_ST_RSPN_ID,
70	LPORT_ST_RFT_ID,
71	LPORT_ST_RFF_ID,
72	LPORT_ST_FDMI,
73	LPORT_ST_RHBA,
74	LPORT_ST_RPA,
75	LPORT_ST_DHBA,
76	LPORT_ST_DPRT,
77	LPORT_ST_SCR,
78	LPORT_ST_READY,
79	LPORT_ST_LOGO,
80	LPORT_ST_RESET
81};
82
83enum fc_disc_event {
84	DISC_EV_NONE = 0,
85	DISC_EV_SUCCESS,
86	DISC_EV_FAILED
87};
88
89/**
90 * enum fc_rport_state - Remote port states
91 * @RPORT_ST_INIT:    Initialized
92 * @RPORT_ST_FLOGI:   Waiting for FLOGI completion for point-to-multipoint
93 * @RPORT_ST_PLOGI_WAIT:   Waiting for peer to login for point-to-multipoint
94 * @RPORT_ST_PLOGI:   Waiting for PLOGI completion
95 * @RPORT_ST_PRLI:    Waiting for PRLI completion
96 * @RPORT_ST_RTV:     Waiting for RTV completion
97 * @RPORT_ST_READY:   Ready for use
98 * @RPORT_ST_ADISC:   Discover Address sent
99 * @RPORT_ST_DELETE:  Remote port being deleted
100*/
101enum fc_rport_state {
102	RPORT_ST_INIT,
103	RPORT_ST_FLOGI,
104	RPORT_ST_PLOGI_WAIT,
105	RPORT_ST_PLOGI,
106	RPORT_ST_PRLI,
107	RPORT_ST_RTV,
108	RPORT_ST_READY,
109	RPORT_ST_ADISC,
110	RPORT_ST_DELETE,
111};
112
113/**
114 * struct fc_disc_port - temporary discovery port to hold rport identifiers
115 * @lp:         Fibre Channel host port instance
116 * @peers:      Node for list management during discovery and RSCN processing
117 * @rport_work: Work struct for starting the rport state machine
118 * @port_id:    Port ID of the discovered port
119 */
120struct fc_disc_port {
121	struct fc_lport    *lp;
122	struct list_head   peers;
123	struct work_struct rport_work;
124	u32                port_id;
125};
126
127/**
128 * enum fc_rport_event - Remote port events
129 * @RPORT_EV_NONE:   No event
130 * @RPORT_EV_READY:  Remote port is ready for use
131 * @RPORT_EV_FAILED: State machine failed, remote port is not ready
132 * @RPORT_EV_STOP:   Remote port has been stopped
133 * @RPORT_EV_LOGO:   Remote port logout (LOGO) sent
134 */
135enum fc_rport_event {
136	RPORT_EV_NONE = 0,
137	RPORT_EV_READY,
138	RPORT_EV_FAILED,
139	RPORT_EV_STOP,
140	RPORT_EV_LOGO
141};
142
143struct fc_rport_priv;
144
145/**
146 * struct fc_rport_operations - Operations for a remote port
147 * @event_callback: Function to be called for remote port events
148 */
149struct fc_rport_operations {
150	void (*event_callback)(struct fc_lport *, struct fc_rport_priv *,
151			       enum fc_rport_event);
152};
153
154/**
155 * struct fc_rport_libfc_priv - libfc internal information about a remote port
156 * @local_port: The associated local port
157 * @rp_state:   Indicates READY for I/O or DELETE when blocked
158 * @flags:      REC and RETRY supported flags
159 * @e_d_tov:    Error detect timeout value (in msec)
160 * @r_a_tov:    Resource allocation timeout value (in msec)
161 */
162struct fc_rport_libfc_priv {
163	struct fc_lport		   *local_port;
164	enum fc_rport_state        rp_state;
165	u16			   flags;
166	#define FC_RP_FLAGS_REC_SUPPORTED	(1 << 0)
167	#define FC_RP_FLAGS_RETRY		(1 << 1)
168	#define FC_RP_STARTED			(1 << 2)
169	#define FC_RP_FLAGS_CONF_REQ		(1 << 3)
170	unsigned int	           e_d_tov;
171	unsigned int	           r_a_tov;
172};
173
174/**
175 * struct fc_rport_priv - libfc remote port and discovery info
176 * @local_port:     The associated local port
177 * @rport:          The FC transport remote port
178 * @kref:           Reference counter
179 * @rp_state:       Enumeration that tracks progress of PLOGI, PRLI,
180 *                  and RTV exchanges
181 * @ids:            The remote port identifiers and roles
182 * @flags:          STARTED, REC and RETRY_SUPPORTED flags
183 * @max_seq:        Maximum number of concurrent sequences
184 * @disc_id:        The discovery identifier
185 * @maxframe_size:  The maximum frame size
186 * @retries:        The retry count for the current state
187 * @major_retries:  The retry count for the entire PLOGI/PRLI state machine
188 * @e_d_tov:        Error detect timeout value (in msec)
189 * @r_a_tov:        Resource allocation timeout value (in msec)
190 * @rp_mutex:       The mutex that protects the remote port
191 * @retry_work:     Handle for retries
192 * @event_callback: Callback when READY, FAILED or LOGO states complete
193 * @prli_count:     Count of open PRLI sessions in providers
194 * @rcu:	    Structure used for freeing in an RCU-safe manner
195 */
196struct fc_rport_priv {
197	struct fc_lport		    *local_port;
198	struct fc_rport		    *rport;
199	struct kref		    kref;
200	enum fc_rport_state         rp_state;
201	struct fc_rport_identifiers ids;
202	u16			    flags;
203	u16		            max_seq;
204	u16			    disc_id;
205	u16			    maxframe_size;
206	unsigned int	            retries;
207	unsigned int	            major_retries;
208	unsigned int	            e_d_tov;
209	unsigned int	            r_a_tov;
210	struct mutex                rp_mutex;
211	struct delayed_work	    retry_work;
212	enum fc_rport_event         event;
213	struct fc_rport_operations  *ops;
214	struct list_head            peers;
215	struct work_struct          event_work;
216	u32			    supported_classes;
217	u16                         prli_count;
218	struct rcu_head		    rcu;
219	u16			    sp_features;
220	u8			    spp_type;
221	void			    (*lld_event_callback)(struct fc_lport *,
222						      struct fc_rport_priv *,
223						      enum fc_rport_event);
224};
225
226/**
227 * struct fc_stats - fc stats structure
228 * @SecondsSinceLastReset: Seconds since the last reset
229 * @TxFrames:              Number of transmitted frames
230 * @TxWords:               Number of transmitted words
231 * @RxFrames:              Number of received frames
232 * @RxWords:               Number of received words
233 * @ErrorFrames:           Number of received error frames
234 * @DumpedFrames:          Number of dumped frames
235 * @FcpPktAllocFails:      Number of fcp packet allocation failures
236 * @FcpPktAborts:          Number of fcp packet aborts
237 * @FcpFrameAllocFails:    Number of fcp frame allocation failures
238 * @LinkFailureCount:      Number of link failures
239 * @LossOfSignalCount:     Number for signal losses
240 * @InvalidTxWordCount:    Number of invalid transmitted words
241 * @InvalidCRCCount:       Number of invalid CRCs
242 * @InputRequests:         Number of input requests
243 * @OutputRequests:        Number of output requests
244 * @ControlRequests:       Number of control requests
245 * @InputBytes:            Number of received bytes
246 * @OutputBytes:           Number of transmitted bytes
247 * @VLinkFailureCount:     Number of virtual link failures
248 * @MissDiscAdvCount:      Number of missing FIP discovery advertisement
249 */
250struct fc_stats {
251	u64		SecondsSinceLastReset;
252	u64		TxFrames;
253	u64		TxWords;
254	u64		RxFrames;
255	u64		RxWords;
256	u64		ErrorFrames;
257	u64		DumpedFrames;
258	u64		FcpPktAllocFails;
259	u64		FcpPktAborts;
260	u64		FcpFrameAllocFails;
261	u64		LinkFailureCount;
262	u64		LossOfSignalCount;
263	u64		InvalidTxWordCount;
264	u64		InvalidCRCCount;
265	u64		InputRequests;
266	u64		OutputRequests;
267	u64		ControlRequests;
268	u64		InputBytes;
269	u64		OutputBytes;
270	u64		VLinkFailureCount;
271	u64		MissDiscAdvCount;
272};
273
274/**
275 * struct fc_seq_els_data - ELS data used for passing ELS specific responses
276 * @reason: The reason for rejection
277 * @explan: The explanation of the rejection
278 *
279 * Mainly used by the exchange manager layer.
280 */
281struct fc_seq_els_data {
282	enum fc_els_rjt_reason reason;
283	enum fc_els_rjt_explan explan;
284};
285
286/**
287 * struct fc_fcp_pkt - FCP request structure (one for each scsi_cmnd request)
288 * @lp:              The associated local port
289 * @state:           The state of the I/O
290 * @ref_cnt:         Reference count
291 * @scsi_pkt_lock:   Lock to protect the SCSI packet (must be taken before the
292 *                   host_lock if both are to be held at the same time)
293 * @cmd:             The SCSI command (set and clear with the host_lock held)
294 * @list:            Tracks queued commands (accessed with the host_lock held)
295 * @timer:           The command timer
296 * @tm_done:         Completion indicator
297 * @wait_for_comp:   Indicator to wait for completion of the I/O (in jiffies)
298 * @data_len:        The length of the data
299 * @cdb_cmd:         The CDB command
300 * @xfer_len:        The transfer length
301 * @xfer_ddp:        Indicates if this transfer used DDP (XID of the exchange
302 *                   will be set here if DDP was setup)
303 * @xfer_contig_end: The offset into the buffer if the buffer is contiguous
304 *                   (Tx and Rx)
305 * @max_payload:     The maximum payload size (in bytes)
306 * @io_status:       SCSI result (upper 24 bits)
307 * @cdb_status:      CDB status
308 * @status_code:     FCP I/O status
309 * @scsi_comp_flags: Completion flags (bit 3 Underrun bit 2: overrun)
310 * @req_flags:       Request flags (bit 0: read bit:1 write)
311 * @scsi_resid:      SCSI residule length
312 * @rport:           The remote port that the SCSI command is targeted at
313 * @seq_ptr:         The sequence that will carry the SCSI command
314 * @recov_retry:     Number of recovery retries
315 * @recov_seq:       The sequence for REC or SRR
316 */
317struct fc_fcp_pkt {
318	spinlock_t	  scsi_pkt_lock;
319	atomic_t	  ref_cnt;
320
321	/* SCSI command and data transfer information */
322	u32		  data_len;
323
324	/* SCSI I/O related information */
325	struct scsi_cmnd  *cmd;
326	struct list_head  list;
327
328	/* Housekeeping information */
329	struct fc_lport   *lp;
330	u8		  state;
331
332	/* SCSI/FCP return status */
333	u8		  cdb_status;
334	u8		  status_code;
335	u8		  scsi_comp_flags;
336	u32		  io_status;
337	u32		  req_flags;
338	u32		  scsi_resid;
339
340	/* Transport related veriables */
341	size_t		  xfer_len;
342	struct fcp_cmnd   cdb_cmd;
343	u32		  xfer_contig_end;
344	u16		  max_payload;
345	u16		  xfer_ddp;
346
347	/* Associated structures */
348	struct fc_rport	  *rport;
349	struct fc_seq	  *seq_ptr;
350
351	/* Timeout/error related information */
352	struct timer_list timer;
353	int	          wait_for_comp;
354	u32		  recov_retry;
355	struct fc_seq	  *recov_seq;
356	struct completion tm_done;
357} ____cacheline_aligned_in_smp;
358
359/*
360 * Structure and function definitions for managing Fibre Channel Exchanges
361 * and Sequences
362 *
363 * fc_exch holds state for one exchange and links to its active sequence.
364 *
365 * fc_seq holds the state for an individual sequence.
366 */
367
368struct fc_exch_mgr;
369struct fc_exch_mgr_anchor;
370extern u16 fc_cpu_mask;	/* cpu mask for possible cpus */
371
372/**
373 * struct fc_seq - FC sequence
374 * @id:       The sequence ID
375 * @ssb_stat: Status flags for the sequence status block (SSB)
376 * @cnt:      Number of frames sent so far
377 * @rec_data: FC-4 value for REC
378 */
379struct fc_seq {
380	u8  id;
381	u16 ssb_stat;
382	u16 cnt;
383	u32 rec_data;
384};
385
386#define FC_EX_DONE		(1 << 0) /* ep is completed */
387#define FC_EX_RST_CLEANUP	(1 << 1) /* reset is forcing completion */
388
389/**
390 * struct fc_exch - Fibre Channel Exchange
391 * @em:           Exchange manager
392 * @pool:         Exchange pool
393 * @state:        The exchange's state
394 * @xid:          The exchange ID
395 * @ex_list:      Handle used by the EM to track free exchanges
396 * @ex_lock:      Lock that protects the exchange
397 * @ex_refcnt:    Reference count
398 * @timeout_work: Handle for timeout handler
399 * @lp:           The local port that this exchange is on
400 * @oxid:         Originator's exchange ID
401 * @rxid:         Responder's exchange ID
402 * @oid:          Originator's FCID
403 * @sid:          Source FCID
404 * @did:          Destination FCID
405 * @esb_stat:     ESB exchange status
406 * @r_a_tov:      Resouce allocation time out value (in msecs)
407 * @seq_id:       The next sequence ID to use
408 * @encaps:       encapsulation information for lower-level driver
409 * @f_ctl:        F_CTL flags for the sequence
410 * @fh_type:      The frame type
411 * @class:        The class of service
412 * @seq:          The sequence in use on this exchange
413 * @resp_active:  Number of tasks that are concurrently executing @resp().
414 * @resp_task:    If @resp_active > 0, either the task executing @resp(), the
415 *                task that has been interrupted to execute the soft-IRQ
416 *                executing @resp() or NULL if more than one task is executing
417 *                @resp concurrently.
418 * @resp_wq:      Waitqueue for the tasks waiting on @resp_active.
419 * @resp:         Callback for responses on this exchange
420 * @destructor:   Called when destroying the exchange
421 * @arg:          Passed as a void pointer to the resp() callback
422 *
423 * Locking notes: The ex_lock protects following items:
424 *	state, esb_stat, f_ctl, seq.ssb_stat
425 *	seq_id
426 *	sequence allocation
427 */
428struct fc_exch {
429	spinlock_t	    ex_lock;
430	atomic_t	    ex_refcnt;
431	enum fc_class	    class;
432	struct fc_exch_mgr  *em;
433	struct fc_exch_pool *pool;
434	struct list_head    ex_list;
435	struct fc_lport	    *lp;
436	u32		    esb_stat;
437	u8		    state;
438	u8		    fh_type;
439	u8		    seq_id;
440	u8		    encaps;
441	u16		    xid;
442	u16		    oxid;
443	u16		    rxid;
444	u32		    oid;
445	u32		    sid;
446	u32		    did;
447	u32		    r_a_tov;
448	u32		    f_ctl;
449	struct fc_seq       seq;
450	int		    resp_active;
451	struct task_struct  *resp_task;
452	wait_queue_head_t   resp_wq;
453	void		    (*resp)(struct fc_seq *, struct fc_frame *, void *);
454	void		    *arg;
455	void		    (*destructor)(struct fc_seq *, void *);
456	struct delayed_work timeout_work;
457} ____cacheline_aligned_in_smp;
458#define	fc_seq_exch(sp) container_of(sp, struct fc_exch, seq)
459
460
461struct libfc_function_template {
462	/*
463	 * Interface to send a FC frame
464	 *
465	 * STATUS: REQUIRED
466	 */
467	int (*frame_send)(struct fc_lport *, struct fc_frame *);
468
469	/*
470	 * Interface to send ELS/CT frames
471	 *
472	 * STATUS: OPTIONAL
473	 */
474	struct fc_seq *(*elsct_send)(struct fc_lport *, u32 did,
475				     struct fc_frame *, unsigned int op,
476				     void (*resp)(struct fc_seq *,
477					     struct fc_frame *, void *arg),
478				     void *arg, u32 timer_msec);
479
480	/*
481	 * Send the FC frame payload using a new exchange and sequence.
482	 *
483	 * The exchange response handler is set in this routine to resp()
484	 * function pointer. It can be called in two scenarios: if a timeout
485	 * occurs or if a response frame is received for the exchange. The
486	 * fc_frame pointer in response handler will also indicate timeout
487	 * as error using IS_ERR related macros.
488	 *
489	 * The exchange destructor handler is also set in this routine.
490	 * The destructor handler is invoked by EM layer when exchange
491	 * is about to free, this can be used by caller to free its
492	 * resources along with exchange free.
493	 *
494	 * The arg is passed back to resp and destructor handler.
495	 *
496	 * The timeout value (in msec) for an exchange is set if non zero
497	 * timer_msec argument is specified. The timer is canceled when
498	 * it fires or when the exchange is done. The exchange timeout handler
499	 * is registered by EM layer.
500	 *
501	 * STATUS: OPTIONAL
502	 */
503	struct fc_seq *(*exch_seq_send)(struct fc_lport *, struct fc_frame *,
504					void (*resp)(struct fc_seq *,
505						     struct fc_frame *,
506						     void *),
507					void (*destructor)(struct fc_seq *,
508							   void *),
509					void *, unsigned int timer_msec);
510
511	/*
512	 * Sets up the DDP context for a given exchange id on the given
513	 * scatterlist if LLD supports DDP for large receive.
514	 *
515	 * STATUS: OPTIONAL
516	 */
517	int (*ddp_setup)(struct fc_lport *, u16, struct scatterlist *,
518			 unsigned int);
519	/*
520	 * Completes the DDP transfer and returns the length of data DDPed
521	 * for the given exchange id.
522	 *
523	 * STATUS: OPTIONAL
524	 */
525	int (*ddp_done)(struct fc_lport *, u16);
526	/*
527	 * Sets up the DDP context for a given exchange id on the given
528	 * scatterlist if LLD supports DDP for target.
529	 *
530	 * STATUS: OPTIONAL
531	 */
532	int (*ddp_target)(struct fc_lport *, u16, struct scatterlist *,
533			  unsigned int);
534	/*
535	 * Allow LLD to fill its own Link Error Status Block
536	 *
537	 * STATUS: OPTIONAL
538	 */
539	void (*get_lesb)(struct fc_lport *, struct fc_els_lesb *lesb);
540	/*
541	 * Send a frame using an existing sequence and exchange.
542	 *
543	 * STATUS: OPTIONAL
544	 */
545	int (*seq_send)(struct fc_lport *, struct fc_seq *,
546			struct fc_frame *);
547
548	/*
549	 * Send an ELS response using information from the received frame.
550	 *
551	 * STATUS: OPTIONAL
552	 */
553	void (*seq_els_rsp_send)(struct fc_frame *, enum fc_els_cmd,
554				 struct fc_seq_els_data *);
555
556	/*
557	 * Abort an exchange and sequence. Generally called because of a
558	 * exchange timeout or an abort from the upper layer.
559	 *
560	 * A timer_msec can be specified for abort timeout, if non-zero
561	 * timer_msec value is specified then exchange resp handler
562	 * will be called with timeout error if no response to abort.
563	 *
564	 * STATUS: OPTIONAL
565	 */
566	int (*seq_exch_abort)(const struct fc_seq *,
567			      unsigned int timer_msec);
568
569	/*
570	 * Indicate that an exchange/sequence tuple is complete and the memory
571	 * allocated for the related objects may be freed.
572	 *
573	 * STATUS: OPTIONAL
574	 */
575	void (*exch_done)(struct fc_seq *);
576
577	/*
578	 * Start a new sequence on the same exchange/sequence tuple.
579	 *
580	 * STATUS: OPTIONAL
581	 */
582	struct fc_seq *(*seq_start_next)(struct fc_seq *);
583
584	/*
585	 * Set a response handler for the exchange of the sequence.
586	 *
587	 * STATUS: OPTIONAL
588	 */
589	void (*seq_set_resp)(struct fc_seq *sp,
590			     void (*resp)(struct fc_seq *, struct fc_frame *,
591					  void *),
592			     void *arg);
593
594	/*
595	 * Assign a sequence for an incoming request frame.
596	 *
597	 * STATUS: OPTIONAL
598	 */
599	struct fc_seq *(*seq_assign)(struct fc_lport *, struct fc_frame *);
600
601	/*
602	 * Release the reference on the sequence returned by seq_assign().
603	 *
604	 * STATUS: OPTIONAL
605	 */
606	void (*seq_release)(struct fc_seq *);
607
608	/*
609	 * Reset an exchange manager, completing all sequences and exchanges.
610	 * If s_id is non-zero, reset only exchanges originating from that FID.
611	 * If d_id is non-zero, reset only exchanges sending to that FID.
612	 *
613	 * STATUS: OPTIONAL
614	 */
615	void (*exch_mgr_reset)(struct fc_lport *, u32 s_id, u32 d_id);
616
617	/*
618	 * Flush the rport work queue. Generally used before shutdown.
619	 *
620	 * STATUS: OPTIONAL
621	 */
622	void (*rport_flush_queue)(void);
623
624	/*
625	 * Receive a frame for a local port.
626	 *
627	 * STATUS: OPTIONAL
628	 */
629	void (*lport_recv)(struct fc_lport *, struct fc_frame *);
630
631	/*
632	 * Reset the local port.
633	 *
634	 * STATUS: OPTIONAL
635	 */
636	int (*lport_reset)(struct fc_lport *);
637
638	/*
639	 * Set the local port FC_ID.
640	 *
641	 * This may be provided by the LLD to allow it to be
642	 * notified when the local port is assigned a FC-ID.
643	 *
644	 * The frame, if non-NULL, is the incoming frame with the
645	 * FLOGI LS_ACC or FLOGI, and may contain the granted MAC
646	 * address for the LLD.  The frame pointer may be NULL if
647	 * no MAC is associated with this assignment (LOGO or PLOGI).
648	 *
649	 * If FC_ID is non-zero, r_a_tov and e_d_tov must be valid.
650	 *
651	 * Note: this is called with the local port mutex held.
652	 *
653	 * STATUS: OPTIONAL
654	 */
655	void (*lport_set_port_id)(struct fc_lport *, u32 port_id,
656				  struct fc_frame *);
657
658	/*
659	 * Create a remote port with a given port ID
660	 *
661	 * STATUS: OPTIONAL
662	 */
663	struct fc_rport_priv *(*rport_create)(struct fc_lport *, u32);
664
665	/*
666	 * Initiates the RP state machine. It is called from the LP module.
667	 * This function will issue the following commands to the N_Port
668	 * identified by the FC ID provided.
669	 *
670	 * - PLOGI
671	 * - PRLI
672	 * - RTV
673	 *
674	 * STATUS: OPTIONAL
675	 */
676	int (*rport_login)(struct fc_rport_priv *);
677
678	/*
679	 * Logoff, and remove the rport from the transport if
680	 * it had been added. This will send a LOGO to the target.
681	 *
682	 * STATUS: OPTIONAL
683	 */
684	int (*rport_logoff)(struct fc_rport_priv *);
685
686	/*
687	 * Receive a request from a remote port.
688	 *
689	 * STATUS: OPTIONAL
690	 */
691	void (*rport_recv_req)(struct fc_lport *, struct fc_frame *);
692
693	/*
694	 * lookup an rport by it's port ID.
695	 *
696	 * STATUS: OPTIONAL
697	 */
698	struct fc_rport_priv *(*rport_lookup)(const struct fc_lport *, u32);
699
700	/*
701	 * Destroy an rport after final kref_put().
702	 * The argument is a pointer to the kref inside the fc_rport_priv.
703	 */
704	void (*rport_destroy)(struct kref *);
705
706	/*
707	 * Callback routine after the remote port is logged in
708	 *
709	 * STATUS: OPTIONAL
710	 */
711	void (*rport_event_callback)(struct fc_lport *,
712				     struct fc_rport_priv *,
713				     enum fc_rport_event);
714
715	/*
716	 * Send a fcp cmd from fsp pkt.
717	 * Called with the SCSI host lock unlocked and irqs disabled.
718	 *
719	 * The resp handler is called when FCP_RSP received.
720	 *
721	 * STATUS: OPTIONAL
722	 */
723	int (*fcp_cmd_send)(struct fc_lport *, struct fc_fcp_pkt *,
724			    void (*resp)(struct fc_seq *, struct fc_frame *,
725					 void *));
726
727	/*
728	 * Cleanup the FCP layer, used during link down and reset
729	 *
730	 * STATUS: OPTIONAL
731	 */
732	void (*fcp_cleanup)(struct fc_lport *);
733
734	/*
735	 * Abort all I/O on a local port
736	 *
737	 * STATUS: OPTIONAL
738	 */
739	void (*fcp_abort_io)(struct fc_lport *);
740
741	/*
742	 * Receive a request for the discovery layer.
743	 *
744	 * STATUS: OPTIONAL
745	 */
746	void (*disc_recv_req)(struct fc_lport *, struct fc_frame *);
747
748	/*
749	 * Start discovery for a local port.
750	 *
751	 * STATUS: OPTIONAL
752	 */
753	void (*disc_start)(void (*disc_callback)(struct fc_lport *,
754						 enum fc_disc_event),
755			   struct fc_lport *);
756
757	/*
758	 * Stop discovery for a given lport. This will remove
759	 * all discovered rports
760	 *
761	 * STATUS: OPTIONAL
762	 */
763	void (*disc_stop) (struct fc_lport *);
764
765	/*
766	 * Stop discovery for a given lport. This will block
767	 * until all discovered rports are deleted from the
768	 * FC transport class
769	 *
770	 * STATUS: OPTIONAL
771	 */
772	void (*disc_stop_final) (struct fc_lport *);
773};
774
775/**
776 * struct fc_disc - Discovery context
777 * @retry_count:   Number of retries
778 * @pending:       1 if discovery is pending, 0 if not
779 * @requested:     1 if discovery has been requested, 0 if not
780 * @seq_count:     Number of sequences used for discovery
781 * @buf_len:       Length of the discovery buffer
782 * @disc_id:       Discovery ID
783 * @rports:        List of discovered remote ports
784 * @priv:          Private pointer for use by discovery code
785 * @disc_mutex:    Mutex that protects the discovery context
786 * @partial_buf:   Partial name buffer (if names are returned
787 *                 in multiple frames)
788 * @disc_work:     handle for delayed work context
789 * @disc_callback: Callback routine called when discovery completes
790 */
791struct fc_disc {
792	unsigned char         retry_count;
793	unsigned char         pending;
794	unsigned char         requested;
795	unsigned short        seq_count;
796	unsigned char         buf_len;
797	u16                   disc_id;
798
799	struct list_head      rports;
800	void		      *priv;
801	struct mutex	      disc_mutex;
802	struct fc_gpn_ft_resp partial_buf;
803	struct delayed_work   disc_work;
804
805	void (*disc_callback)(struct fc_lport *,
806			      enum fc_disc_event);
807};
808
809/*
810 * Local port notifier and events.
811 */
812extern struct blocking_notifier_head fc_lport_notifier_head;
813enum fc_lport_event {
814	FC_LPORT_EV_ADD,
815	FC_LPORT_EV_DEL,
816};
817
818/**
819 * struct fc_lport - Local port
820 * @host:                  The SCSI host associated with a local port
821 * @ema_list:              Exchange manager anchor list
822 * @dns_rdata:             The directory server remote port
823 * @ms_rdata:		   The management server remote port
824 * @ptp_rdata:             Point to point remote port
825 * @scsi_priv:             FCP layer internal data
826 * @disc:                  Discovery context
827 * @vports:                Child vports if N_Port
828 * @vport:                 Parent vport if VN_Port
829 * @tt:                    Libfc function template
830 * @link_up:               Link state (1 = link up, 0 = link down)
831 * @qfull:                 Queue state (1 queue is full, 0 queue is not full)
832 * @state:                 Identifies the state
833 * @boot_time:             Timestamp indicating when the local port came online
834 * @host_stats:            SCSI host statistics
835 * @stats:                 FC local port stats (TODO separate libfc LLD stats)
836 * @retry_count:           Number of retries in the current state
837 * @port_id:               FC Port ID
838 * @wwpn:                  World Wide Port Name
839 * @wwnn:                  World Wide Node Name
840 * @service_params:        Common service parameters
841 * @e_d_tov:               Error detection timeout value
842 * @r_a_tov:               Resouce allocation timeout value
843 * @rnid_gen:              RNID information
844 * @sg_supp:               Indicates if scatter gather is supported
845 * @seq_offload:           Indicates if sequence offload is supported
846 * @crc_offload:           Indicates if CRC offload is supported
847 * @lro_enabled:           Indicates if large receive offload is supported
848 * @does_npiv:             Supports multiple vports
849 * @npiv_enabled:          Switch/fabric allows NPIV
850 * @mfs:                   The maximum Fibre Channel payload size
851 * @max_retry_count:       The maximum retry attempts
852 * @max_rport_retry_count: The maximum remote port retry attempts
853 * @rport_priv_size:       Size needed by driver after struct fc_rport_priv
854 * @lro_xid:               The maximum XID for LRO
855 * @lso_max:               The maximum large offload send size
856 * @fcts:                  FC-4 type mask
857 * @lp_mutex:              Mutex to protect the local port
858 * @list:                  Linkage on list of vport peers
859 * @retry_work:            Handle to local port for delayed retry context
860 * @prov:		   Pointers available for use by passive FC-4 providers
861 * @lport_list:            Linkage on module-wide list of local ports
862 */
863struct fc_lport {
864	/* Associations */
865	struct Scsi_Host	       *host;
866	struct list_head	       ema_list;
867	struct fc_rport_priv	       *dns_rdata;
868	struct fc_rport_priv	       *ms_rdata;
869	struct fc_rport_priv	       *ptp_rdata;
870	void			       *scsi_priv;
871	struct fc_disc                 disc;
872
873	/* Virtual port information */
874	struct list_head	       vports;
875	struct fc_vport		       *vport;
876
877	/* Operational Information */
878	struct libfc_function_template tt;
879	u8			       link_up;
880	u8			       qfull;
881	enum fc_lport_state	       state;
882	unsigned long		       boot_time;
883	struct fc_host_statistics      host_stats;
884	struct fc_stats	__percpu       *stats;
885	u8			       retry_count;
886
887	/* Fabric information */
888	u32                            port_id;
889	u64			       wwpn;
890	u64			       wwnn;
891	unsigned int		       service_params;
892	unsigned int		       e_d_tov;
893	unsigned int		       r_a_tov;
894	struct fc_els_rnid_gen	       rnid_gen;
895
896	/* Capabilities */
897	u32			       sg_supp:1;
898	u32			       seq_offload:1;
899	u32			       crc_offload:1;
900	u32			       lro_enabled:1;
901	u32			       does_npiv:1;
902	u32			       npiv_enabled:1;
903	u32			       point_to_multipoint:1;
904	u32			       fdmi_enabled:1;
905	u32			       mfs;
906	u8			       max_retry_count;
907	u8			       max_rport_retry_count;
908	u16			       rport_priv_size;
909	u16			       link_speed;
910	u16			       link_supported_speeds;
911	u16			       lro_xid;
912	unsigned int		       lso_max;
913	struct fc_ns_fts	       fcts;
914
915	/* Miscellaneous */
916	struct mutex                   lp_mutex;
917	struct list_head               list;
918	struct delayed_work	       retry_work;
919	void			       *prov[FC_FC4_PROV_SIZE];
920	struct list_head               lport_list;
921};
922
923/**
924 * struct fc4_prov - FC-4 provider registration
925 * @prli:               Handler for incoming PRLI
926 * @prlo:               Handler for session reset
927 * @recv:		Handler for incoming request
928 * @module:		Pointer to module.  May be NULL.
929 */
930struct fc4_prov {
931	int (*prli)(struct fc_rport_priv *, u32 spp_len,
932		    const struct fc_els_spp *spp_in,
933		    struct fc_els_spp *spp_out);
934	void (*prlo)(struct fc_rport_priv *);
935	void (*recv)(struct fc_lport *, struct fc_frame *);
936	struct module *module;
937};
938
939/*
940 * Register FC-4 provider with libfc.
941 */
942int fc_fc4_register_provider(enum fc_fh_type type, struct fc4_prov *);
943void fc_fc4_deregister_provider(enum fc_fh_type type, struct fc4_prov *);
944
945/*
946 * FC_LPORT HELPER FUNCTIONS
947 *****************************/
948
949/**
950 * fc_lport_test_ready() - Determine if a local port is in the READY state
951 * @lport: The local port to test
952 */
953static inline int fc_lport_test_ready(struct fc_lport *lport)
954{
955	return lport->state == LPORT_ST_READY;
956}
957
958/**
959 * fc_set_wwnn() - Set the World Wide Node Name of a local port
960 * @lport: The local port whose WWNN is to be set
961 * @wwnn:  The new WWNN
962 */
963static inline void fc_set_wwnn(struct fc_lport *lport, u64 wwnn)
964{
965	lport->wwnn = wwnn;
966}
967
968/**
969 * fc_set_wwpn() - Set the World Wide Port Name of a local port
970 * @lport: The local port whose WWPN is to be set
971 * @wwnn:  The new WWPN
972 */
973static inline void fc_set_wwpn(struct fc_lport *lport, u64 wwnn)
974{
975	lport->wwpn = wwnn;
976}
977
978/**
979 * fc_lport_state_enter() - Change a local port's state
980 * @lport: The local port whose state is to change
981 * @state: The new state
982 */
983static inline void fc_lport_state_enter(struct fc_lport *lport,
984					enum fc_lport_state state)
985{
986	if (state != lport->state)
987		lport->retry_count = 0;
988	lport->state = state;
989}
990
991/**
992 * fc_lport_init_stats() - Allocate per-CPU statistics for a local port
993 * @lport: The local port whose statistics are to be initialized
994 */
995static inline int fc_lport_init_stats(struct fc_lport *lport)
996{
997	lport->stats = alloc_percpu(struct fc_stats);
998	if (!lport->stats)
999		return -ENOMEM;
1000	return 0;
1001}
1002
1003/**
1004 * fc_lport_free_stats() - Free memory for a local port's statistics
1005 * @lport: The local port whose statistics are to be freed
1006 */
1007static inline void fc_lport_free_stats(struct fc_lport *lport)
1008{
1009	free_percpu(lport->stats);
1010}
1011
1012/**
1013 * lport_priv() - Return the private data from a local port
1014 * @lport: The local port whose private data is to be retreived
1015 */
1016static inline void *lport_priv(const struct fc_lport *lport)
1017{
1018	return (void *)(lport + 1);
1019}
1020
1021/**
1022 * libfc_host_alloc() - Allocate a Scsi_Host with room for a local port and
1023 *                      LLD private data
1024 * @sht:       The SCSI host template
1025 * @priv_size: Size of private data
1026 *
1027 * Returns: libfc lport
1028 */
1029static inline struct fc_lport *
1030libfc_host_alloc(struct scsi_host_template *sht, int priv_size)
1031{
1032	struct fc_lport *lport;
1033	struct Scsi_Host *shost;
1034
1035	shost = scsi_host_alloc(sht, sizeof(*lport) + priv_size);
1036	if (!shost)
1037		return NULL;
1038	lport = shost_priv(shost);
1039	lport->host = shost;
1040	INIT_LIST_HEAD(&lport->ema_list);
1041	INIT_LIST_HEAD(&lport->vports);
1042	return lport;
1043}
1044
1045/*
1046 * FC_FCP HELPER FUNCTIONS
1047 *****************************/
1048static inline bool fc_fcp_is_read(const struct fc_fcp_pkt *fsp)
1049{
1050	if (fsp && fsp->cmd)
1051		return fsp->cmd->sc_data_direction == DMA_FROM_DEVICE;
1052	return false;
1053}
1054
1055/*
1056 * LOCAL PORT LAYER
1057 *****************************/
1058int fc_lport_init(struct fc_lport *);
1059int fc_lport_destroy(struct fc_lport *);
1060int fc_fabric_logoff(struct fc_lport *);
1061int fc_fabric_login(struct fc_lport *);
1062void __fc_linkup(struct fc_lport *);
1063void fc_linkup(struct fc_lport *);
1064void __fc_linkdown(struct fc_lport *);
1065void fc_linkdown(struct fc_lport *);
1066void fc_vport_setlink(struct fc_lport *);
1067void fc_vports_linkchange(struct fc_lport *);
1068int fc_lport_config(struct fc_lport *);
1069int fc_lport_reset(struct fc_lport *);
1070int fc_set_mfs(struct fc_lport *, u32 mfs);
1071struct fc_lport *libfc_vport_create(struct fc_vport *, int privsize);
1072struct fc_lport *fc_vport_id_lookup(struct fc_lport *, u32 port_id);
1073int fc_lport_bsg_request(struct fc_bsg_job *);
1074void fc_lport_set_local_id(struct fc_lport *, u32 port_id);
1075void fc_lport_iterate(void (*func)(struct fc_lport *, void *), void *);
1076
1077/*
1078 * REMOTE PORT LAYER
1079 *****************************/
1080int fc_rport_init(struct fc_lport *);
1081void fc_rport_terminate_io(struct fc_rport *);
1082
1083/*
1084 * DISCOVERY LAYER
1085 *****************************/
1086void fc_disc_init(struct fc_lport *);
1087void fc_disc_config(struct fc_lport *, void *);
1088
1089static inline struct fc_lport *fc_disc_lport(struct fc_disc *disc)
1090{
1091	return container_of(disc, struct fc_lport, disc);
1092}
1093
1094/*
1095 * FCP LAYER
1096 *****************************/
1097int fc_fcp_init(struct fc_lport *);
1098void fc_fcp_destroy(struct fc_lport *);
1099
1100/*
1101 * SCSI INTERACTION LAYER
1102 *****************************/
1103int fc_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
1104int fc_eh_abort(struct scsi_cmnd *);
1105int fc_eh_device_reset(struct scsi_cmnd *);
1106int fc_eh_host_reset(struct scsi_cmnd *);
1107int fc_slave_alloc(struct scsi_device *);
1108
1109/*
1110 * ELS/CT interface
1111 *****************************/
1112int fc_elsct_init(struct fc_lport *);
1113struct fc_seq *fc_elsct_send(struct fc_lport *, u32 did,
1114				    struct fc_frame *,
1115				    unsigned int op,
1116				    void (*resp)(struct fc_seq *,
1117						 struct fc_frame *,
1118						 void *arg),
1119				    void *arg, u32 timer_msec);
1120void fc_lport_flogi_resp(struct fc_seq *, struct fc_frame *, void *);
1121void fc_lport_logo_resp(struct fc_seq *, struct fc_frame *, void *);
1122void fc_fill_reply_hdr(struct fc_frame *, const struct fc_frame *,
1123		       enum fc_rctl, u32 parm_offset);
1124void fc_fill_hdr(struct fc_frame *, const struct fc_frame *,
1125		 enum fc_rctl, u32 f_ctl, u16 seq_cnt, u32 parm_offset);
1126
1127
1128/*
1129 * EXCHANGE MANAGER LAYER
1130 *****************************/
1131int fc_exch_init(struct fc_lport *);
1132void fc_exch_update_stats(struct fc_lport *lport);
1133struct fc_exch_mgr_anchor *fc_exch_mgr_add(struct fc_lport *,
1134					   struct fc_exch_mgr *,
1135					   bool (*match)(struct fc_frame *));
1136void fc_exch_mgr_del(struct fc_exch_mgr_anchor *);
1137int fc_exch_mgr_list_clone(struct fc_lport *src, struct fc_lport *dst);
1138struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *, enum fc_class class,
1139				      u16 min_xid, u16 max_xid,
1140				      bool (*match)(struct fc_frame *));
1141void fc_exch_mgr_free(struct fc_lport *);
1142void fc_exch_recv(struct fc_lport *, struct fc_frame *);
1143void fc_exch_mgr_reset(struct fc_lport *, u32 s_id, u32 d_id);
1144
1145/*
1146 * Functions for fc_functions_template
1147 */
1148void fc_get_host_speed(struct Scsi_Host *);
1149void fc_get_host_port_state(struct Scsi_Host *);
1150void fc_set_rport_loss_tmo(struct fc_rport *, u32 timeout);
1151struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *);
1152
1153#endif /* _LIBFC_H_ */
1154