1 /*
2  * This file is part of the Chelsio FCoE driver for Linux.
3  *
4  * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34 
35 #ifndef __CSIO_SCSI_H__
36 #define __CSIO_SCSI_H__
37 
38 #include <linux/spinlock_types.h>
39 #include <linux/completion.h>
40 #include <scsi/scsi.h>
41 #include <scsi/scsi_cmnd.h>
42 #include <scsi/scsi_device.h>
43 #include <scsi/scsi_host.h>
44 #include <scsi/scsi_eh.h>
45 #include <scsi/scsi_tcq.h>
46 #include <scsi/fc/fc_fcp.h>
47 
48 #include "csio_defs.h"
49 #include "csio_wr.h"
50 
51 extern struct scsi_host_template csio_fcoe_shost_template;
52 extern struct scsi_host_template csio_fcoe_shost_vport_template;
53 
54 extern int csio_scsi_eqsize;
55 extern int csio_scsi_iqlen;
56 extern int csio_scsi_ioreqs;
57 extern uint32_t csio_max_scan_tmo;
58 extern uint32_t csio_delta_scan_tmo;
59 extern int csio_lun_qdepth;
60 
61 /*
62  **************************** NOTE *******************************
63  * How do we calculate MAX FCoE SCSI SGEs? Here is the math:
64  * Max Egress WR size = 512 bytes
65  * One SCSI egress WR has the following fixed no of bytes:
66  *      48 (sizeof(struct fw_scsi_write[read]_wr)) - FW WR
67  *    + 32 (sizeof(struct fc_fcp_cmnd)) - Immediate FCP_CMD
68  *    ------
69  *      80
70  *    ------
71  * That leaves us with 512 - 96 = 432 bytes for data SGE. Using
72  * struct ulptx_sgl header for the SGE consumes:
73  *	- 4 bytes for cmnd_sge.
74  *	- 12 bytes for the first SGL.
75  * That leaves us with 416 bytes for the remaining SGE pairs. Which is
76  * is 416 / 24 (size(struct ulptx_sge_pair)) = 17 SGE pairs,
77  * or 34 SGEs. Adding the first SGE fetches us 35 SGEs.
78  */
79 #define CSIO_SCSI_MAX_SGE		35
80 #define CSIO_SCSI_ABRT_TMO_MS		60000
81 #define CSIO_SCSI_LUNRST_TMO_MS		60000
82 #define CSIO_SCSI_TM_POLL_MS		2000	/* should be less than
83 						 * all TM timeouts.
84 						 */
85 #define CSIO_SCSI_IQ_WRSZ		128
86 #define CSIO_SCSI_IQSIZE		(csio_scsi_iqlen * CSIO_SCSI_IQ_WRSZ)
87 
88 #define	CSIO_MAX_SNS_LEN		128
89 #define	CSIO_SCSI_RSP_LEN	(FCP_RESP_WITH_EXT + 4 + CSIO_MAX_SNS_LEN)
90 
91 /* Reference to scsi_cmnd */
92 #define csio_scsi_cmnd(req)		((req)->scratch1)
93 
94 struct csio_scsi_stats {
95 	uint64_t		n_tot_success;	/* Total number of good I/Os */
96 	uint32_t		n_rn_nr_error;	/* No. of remote-node-not-
97 						 * ready errors
98 						 */
99 	uint32_t		n_hw_nr_error;	/* No. of hw-module-not-
100 						 * ready errors
101 						 */
102 	uint32_t		n_dmamap_error;	/* No. of DMA map erros */
103 	uint32_t		n_unsupp_sge_error; /* No. of too-many-SGes
104 						     * errors.
105 						     */
106 	uint32_t		n_no_req_error;	/* No. of Out-of-ioreqs error */
107 	uint32_t		n_busy_error;	/* No. of -EBUSY errors */
108 	uint32_t		n_hosterror;	/* No. of FW_HOSTERROR I/O */
109 	uint32_t		n_rsperror;	/* No. of response errors */
110 	uint32_t		n_autosense;	/* No. of auto sense replies */
111 	uint32_t		n_ovflerror;	/* No. of overflow errors */
112 	uint32_t		n_unflerror;	/* No. of underflow errors */
113 	uint32_t		n_rdev_nr_error;/* No. of rdev not
114 						 * ready errors
115 						 */
116 	uint32_t		n_rdev_lost_error;/* No. of rdev lost errors */
117 	uint32_t		n_rdev_logo_error;/* No. of rdev logo errors */
118 	uint32_t		n_link_down_error;/* No. of link down errors */
119 	uint32_t		n_no_xchg_error; /* No. no exchange error */
120 	uint32_t		n_unknown_error;/* No. of unhandled errors */
121 	uint32_t		n_aborted;	/* No. of aborted I/Os */
122 	uint32_t		n_abrt_timedout; /* No. of abort timedouts */
123 	uint32_t		n_abrt_fail;	/* No. of abort failures */
124 	uint32_t		n_abrt_dups;	/* No. of duplicate aborts */
125 	uint32_t		n_abrt_race_comp; /* No. of aborts that raced
126 						   * with completions.
127 						   */
128 	uint32_t		n_abrt_busy_error;/* No. of abort failures
129 						   * due to -EBUSY.
130 						   */
131 	uint32_t		n_closed;	/* No. of closed I/Os */
132 	uint32_t		n_cls_busy_error; /* No. of close failures
133 						   * due to -EBUSY.
134 						   */
135 	uint32_t		n_active;	/* No. of IOs in active_q */
136 	uint32_t		n_tm_active;	/* No. of TMs in active_q */
137 	uint32_t		n_wcbfn;	/* No. of I/Os in worker
138 						 * cbfn q
139 						 */
140 	uint32_t		n_free_ioreq;	/* No. of freelist entries */
141 	uint32_t		n_free_ddp;	/* No. of DDP freelist */
142 	uint32_t		n_unaligned;	/* No. of Unaligned SGls */
143 	uint32_t		n_inval_cplop;	/* No. invalid CPL op's in IQ */
144 	uint32_t		n_inval_scsiop;	/* No. invalid scsi op's in IQ*/
145 };
146 
147 struct csio_scsim {
148 	struct csio_hw		*hw;		/* Pointer to HW moduel */
149 	uint8_t			max_sge;	/* Max SGE */
150 	uint8_t			proto_cmd_len;	/* Proto specific SCSI
151 						 * cmd length
152 						 */
153 	uint16_t		proto_rsp_len;	/* Proto specific SCSI
154 						 * response length
155 						 */
156 	spinlock_t		freelist_lock;	/* Lock for ioreq freelist */
157 	struct list_head	active_q;	/* Outstanding SCSI I/Os */
158 	struct list_head	ioreq_freelist;	/* Free list of ioreq's */
159 	struct list_head	ddp_freelist;	/* DDP descriptor freelist */
160 	struct csio_scsi_stats	stats;		/* This module's statistics */
161 };
162 
163 /* State machine defines */
164 enum csio_scsi_ev {
165 	CSIO_SCSIE_START_IO = 1,		/* Start a regular SCSI IO */
166 	CSIO_SCSIE_START_TM,			/* Start a TM IO */
167 	CSIO_SCSIE_COMPLETED,			/* IO Completed */
168 	CSIO_SCSIE_ABORT,			/* Abort IO */
169 	CSIO_SCSIE_ABORTED,			/* IO Aborted */
170 	CSIO_SCSIE_CLOSE,			/* Close exchange */
171 	CSIO_SCSIE_CLOSED,			/* Exchange closed */
172 	CSIO_SCSIE_DRVCLEANUP,			/* Driver wants to manually
173 						 * cleanup this I/O.
174 						 */
175 };
176 
177 enum csio_scsi_lev {
178 	CSIO_LEV_ALL = 1,
179 	CSIO_LEV_LNODE,
180 	CSIO_LEV_RNODE,
181 	CSIO_LEV_LUN,
182 };
183 
184 struct csio_scsi_level_data {
185 	enum csio_scsi_lev	level;
186 	struct csio_rnode	*rnode;
187 	struct csio_lnode	*lnode;
188 	uint64_t		oslun;
189 };
190 
191 static inline struct csio_ioreq *
192 csio_get_scsi_ioreq(struct csio_scsim *scm)
193 {
194 	struct csio_sm *req;
195 
196 	if (likely(!list_empty(&scm->ioreq_freelist))) {
197 		req = list_first_entry(&scm->ioreq_freelist,
198 				       struct csio_sm, sm_list);
199 		list_del_init(&req->sm_list);
200 		CSIO_DEC_STATS(scm, n_free_ioreq);
201 		return (struct csio_ioreq *)req;
202 	} else
203 		return NULL;
204 }
205 
206 static inline void
207 csio_put_scsi_ioreq(struct csio_scsim *scm, struct csio_ioreq *ioreq)
208 {
209 	list_add_tail(&ioreq->sm.sm_list, &scm->ioreq_freelist);
210 	CSIO_INC_STATS(scm, n_free_ioreq);
211 }
212 
213 static inline void
214 csio_put_scsi_ioreq_list(struct csio_scsim *scm, struct list_head *reqlist,
215 			 int n)
216 {
217 	list_splice_init(reqlist, &scm->ioreq_freelist);
218 	scm->stats.n_free_ioreq += n;
219 }
220 
221 static inline struct csio_dma_buf *
222 csio_get_scsi_ddp(struct csio_scsim *scm)
223 {
224 	struct csio_dma_buf *ddp;
225 
226 	if (likely(!list_empty(&scm->ddp_freelist))) {
227 		ddp = list_first_entry(&scm->ddp_freelist,
228 				       struct csio_dma_buf, list);
229 		list_del_init(&ddp->list);
230 		CSIO_DEC_STATS(scm, n_free_ddp);
231 		return ddp;
232 	} else
233 		return NULL;
234 }
235 
236 static inline void
237 csio_put_scsi_ddp(struct csio_scsim *scm, struct csio_dma_buf *ddp)
238 {
239 	list_add_tail(&ddp->list, &scm->ddp_freelist);
240 	CSIO_INC_STATS(scm, n_free_ddp);
241 }
242 
243 static inline void
244 csio_put_scsi_ddp_list(struct csio_scsim *scm, struct list_head *reqlist,
245 			 int n)
246 {
247 	list_splice_tail_init(reqlist, &scm->ddp_freelist);
248 	scm->stats.n_free_ddp += n;
249 }
250 
251 static inline void
252 csio_scsi_completed(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
253 {
254 	csio_post_event(&ioreq->sm, CSIO_SCSIE_COMPLETED);
255 	if (csio_list_deleted(&ioreq->sm.sm_list))
256 		list_add_tail(&ioreq->sm.sm_list, cbfn_q);
257 }
258 
259 static inline void
260 csio_scsi_aborted(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
261 {
262 	csio_post_event(&ioreq->sm, CSIO_SCSIE_ABORTED);
263 	list_add_tail(&ioreq->sm.sm_list, cbfn_q);
264 }
265 
266 static inline void
267 csio_scsi_closed(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
268 {
269 	csio_post_event(&ioreq->sm, CSIO_SCSIE_CLOSED);
270 	list_add_tail(&ioreq->sm.sm_list, cbfn_q);
271 }
272 
273 static inline void
274 csio_scsi_drvcleanup(struct csio_ioreq *ioreq)
275 {
276 	csio_post_event(&ioreq->sm, CSIO_SCSIE_DRVCLEANUP);
277 }
278 
279 /*
280  * csio_scsi_start_io - Kick starts the IO SM.
281  * @req: io request SM.
282  *
283  * needs to be called with lock held.
284  */
285 static inline int
286 csio_scsi_start_io(struct csio_ioreq *ioreq)
287 {
288 	csio_post_event(&ioreq->sm, CSIO_SCSIE_START_IO);
289 	return ioreq->drv_status;
290 }
291 
292 /*
293  * csio_scsi_start_tm - Kicks off the Task management IO SM.
294  * @req: io request SM.
295  *
296  * needs to be called with lock held.
297  */
298 static inline int
299 csio_scsi_start_tm(struct csio_ioreq *ioreq)
300 {
301 	csio_post_event(&ioreq->sm, CSIO_SCSIE_START_TM);
302 	return ioreq->drv_status;
303 }
304 
305 /*
306  * csio_scsi_abort - Abort an IO request
307  * @req: io request SM.
308  *
309  * needs to be called with lock held.
310  */
311 static inline int
312 csio_scsi_abort(struct csio_ioreq *ioreq)
313 {
314 	csio_post_event(&ioreq->sm, CSIO_SCSIE_ABORT);
315 	return ioreq->drv_status;
316 }
317 
318 /*
319  * csio_scsi_close - Close an IO request
320  * @req: io request SM.
321  *
322  * needs to be called with lock held.
323  */
324 static inline int
325 csio_scsi_close(struct csio_ioreq *ioreq)
326 {
327 	csio_post_event(&ioreq->sm, CSIO_SCSIE_CLOSE);
328 	return ioreq->drv_status;
329 }
330 
331 void csio_scsi_cleanup_io_q(struct csio_scsim *, struct list_head *);
332 int csio_scsim_cleanup_io(struct csio_scsim *, bool abort);
333 int csio_scsim_cleanup_io_lnode(struct csio_scsim *,
334 					  struct csio_lnode *);
335 struct csio_ioreq *csio_scsi_cmpl_handler(struct csio_hw *, void *, uint32_t,
336 					  struct csio_fl_dma_buf *,
337 					  void *, uint8_t **);
338 int csio_scsi_qconfig(struct csio_hw *);
339 int csio_scsim_init(struct csio_scsim *, struct csio_hw *);
340 void csio_scsim_exit(struct csio_scsim *);
341 
342 #endif /* __CSIO_SCSI_H__ */
343