?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 's5p/for-next'
[linux-2.6/next.git] / drivers / scsi / bfa / bfa_fcpim.c
blobe07bd4745d8ba5b968ded24e81785096c1535b84
1 /*
2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include "bfad_drv.h"
19 #include "bfa_modules.h"
20
21 BFA_TRC_FILE(HAL, FCPIM);
22
23 /*
24 * BFA ITNIM Related definitions
25 */
26 static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
27 static bfa_boolean_t bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim);
28 static bfa_boolean_t bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim);
29 static void bfa_ioim_lm_init(struct bfa_s *bfa);
30
31 #define BFA_ITNIM_FROM_TAG(_fcpim, _tag) \
32 (((_fcpim)->itnim_arr + ((_tag) & ((_fcpim)->num_itnims - 1))))
33
34 #define bfa_fcpim_additn(__itnim) \
35 list_add_tail(&(__itnim)->qe, &(__itnim)->fcpim->itnim_q)
36 #define bfa_fcpim_delitn(__itnim) do { \
37 WARN_ON(!bfa_q_is_on_q(&(__itnim)->fcpim->itnim_q, __itnim)); \
38 bfa_itnim_update_del_itn_stats(__itnim); \
39 list_del(&(__itnim)->qe); \
40 WARN_ON(!list_empty(&(__itnim)->io_q)); \
41 WARN_ON(!list_empty(&(__itnim)->io_cleanup_q)); \
42 WARN_ON(!list_empty(&(__itnim)->pending_q)); \
43 } while (0)
44
45 #define bfa_itnim_online_cb(__itnim) do { \
46 if ((__itnim)->bfa->fcs) \
47 bfa_cb_itnim_online((__itnim)->ditn); \
48 else { \
49 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
50 __bfa_cb_itnim_online, (__itnim)); \
51 } \
52 } while (0)
53
54 #define bfa_itnim_offline_cb(__itnim) do { \
55 if ((__itnim)->bfa->fcs) \
56 bfa_cb_itnim_offline((__itnim)->ditn); \
57 else { \
58 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
59 __bfa_cb_itnim_offline, (__itnim)); \
60 } \
61 } while (0)
62
63 #define bfa_ioim_rp_wwn(__ioim) \
64 (((struct bfa_fcs_rport_s *) \
65 (__ioim)->itnim->rport->rport_drv)->pwwn)
66
67 #define bfa_ioim_lp_wwn(__ioim) \
68 ((BFA_LPS_FROM_TAG(BFA_LPS_MOD((__ioim)->bfa), \
69 (__ioim)->itnim->rport->rport_info.lp_tag))->pwwn) \
70
71 #define bfa_itnim_sler_cb(__itnim) do { \
72 if ((__itnim)->bfa->fcs) \
73 bfa_cb_itnim_sler((__itnim)->ditn); \
74 else { \
75 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
76 __bfa_cb_itnim_sler, (__itnim)); \
77 } \
78 } while (0)
79
80 enum bfa_ioim_lm_status {
81 BFA_IOIM_LM_PRESENT = 1,
82 BFA_IOIM_LM_LUN_NOT_SUP = 2,
83 BFA_IOIM_LM_RPL_DATA_CHANGED = 3,
84 BFA_IOIM_LM_LUN_NOT_RDY = 4,
85 };
86
87 enum bfa_ioim_lm_ua_status {
88 BFA_IOIM_LM_UA_RESET = 0,
89 BFA_IOIM_LM_UA_SET = 1,
90 };
91
92 /*
93 * itnim state machine event
94 */
95 enum bfa_itnim_event {
96 BFA_ITNIM_SM_CREATE = 1, /* itnim is created */
97 BFA_ITNIM_SM_ONLINE = 2, /* itnim is online */
98 BFA_ITNIM_SM_OFFLINE = 3, /* itnim is offline */
99 BFA_ITNIM_SM_FWRSP = 4, /* firmware response */
100 BFA_ITNIM_SM_DELETE = 5, /* deleting an existing itnim */
101 BFA_ITNIM_SM_CLEANUP = 6, /* IO cleanup completion */
102 BFA_ITNIM_SM_SLER = 7, /* second level error recovery */
103 BFA_ITNIM_SM_HWFAIL = 8, /* IOC h/w failure event */
104 BFA_ITNIM_SM_QRESUME = 9, /* queue space available */
105 };
106
107 /*
108 * BFA IOIM related definitions
109 */
110 #define bfa_ioim_move_to_comp_q(__ioim) do { \
111 list_del(&(__ioim)->qe); \
112 list_add_tail(&(__ioim)->qe, &(__ioim)->fcpim->ioim_comp_q); \
113 } while (0)
114
115
116 #define bfa_ioim_cb_profile_comp(__fcpim, __ioim) do { \
117 if ((__fcpim)->profile_comp) \
118 (__fcpim)->profile_comp(__ioim); \
119 } while (0)
120
121 #define bfa_ioim_cb_profile_start(__fcpim, __ioim) do { \
122 if ((__fcpim)->profile_start) \
123 (__fcpim)->profile_start(__ioim); \
124 } while (0)
125
126 /*
127 * IO state machine events
128 */
129 enum bfa_ioim_event {
130 BFA_IOIM_SM_START = 1, /* io start request from host */
131 BFA_IOIM_SM_COMP_GOOD = 2, /* io good comp, resource free */
132 BFA_IOIM_SM_COMP = 3, /* io comp, resource is free */
133 BFA_IOIM_SM_COMP_UTAG = 4, /* io comp, resource is free */
134 BFA_IOIM_SM_DONE = 5, /* io comp, resource not free */
135 BFA_IOIM_SM_FREE = 6, /* io resource is freed */
136 BFA_IOIM_SM_ABORT = 7, /* abort request from scsi stack */
137 BFA_IOIM_SM_ABORT_COMP = 8, /* abort from f/w */
138 BFA_IOIM_SM_ABORT_DONE = 9, /* abort completion from f/w */
139 BFA_IOIM_SM_QRESUME = 10, /* CQ space available to queue IO */
140 BFA_IOIM_SM_SGALLOCED = 11, /* SG page allocation successful */
141 BFA_IOIM_SM_SQRETRY = 12, /* sequence recovery retry */
142 BFA_IOIM_SM_HCB = 13, /* bfa callback complete */
143 BFA_IOIM_SM_CLEANUP = 14, /* IO cleanup from itnim */
144 BFA_IOIM_SM_TMSTART = 15, /* IO cleanup from tskim */
145 BFA_IOIM_SM_TMDONE = 16, /* IO cleanup from tskim */
146 BFA_IOIM_SM_HWFAIL = 17, /* IOC h/w failure event */
147 BFA_IOIM_SM_IOTOV = 18, /* ITN offline TOV */
148 BFA_IOIM_SM_LM_LUN_NOT_SUP = 19,/* lunmask lun not supported */
149 BFA_IOIM_SM_LM_RPL_DC = 20, /* lunmask report-lun data changed */
150 BFA_IOIM_SM_LM_LUN_NOT_RDY = 21,/* lunmask lun not ready */
151 };
152
153
154 /*
155 * BFA TSKIM related definitions
156 */
157
158 /*
159 * task management completion handling
160 */
161 #define bfa_tskim_qcomp(__tskim, __cbfn) do { \
162 bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, __cbfn, (__tskim));\
163 bfa_tskim_notify_comp(__tskim); \
164 } while (0)
165
166 #define bfa_tskim_notify_comp(__tskim) do { \
167 if ((__tskim)->notify) \
168 bfa_itnim_tskdone((__tskim)->itnim); \
169 } while (0)
170
171
172 enum bfa_tskim_event {
173 BFA_TSKIM_SM_START = 1, /* TM command start */
174 BFA_TSKIM_SM_DONE = 2, /* TM completion */
175 BFA_TSKIM_SM_QRESUME = 3, /* resume after qfull */
176 BFA_TSKIM_SM_HWFAIL = 5, /* IOC h/w failure event */
177 BFA_TSKIM_SM_HCB = 6, /* BFA callback completion */
178 BFA_TSKIM_SM_IOS_DONE = 7, /* IO and sub TM completions */
179 BFA_TSKIM_SM_CLEANUP = 8, /* TM cleanup on ITN offline */
180 BFA_TSKIM_SM_CLEANUP_DONE = 9, /* TM abort completion */
181 };
182
183 /*
184 * forward declaration for BFA ITNIM functions
185 */
186 static void bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim);
187 static bfa_boolean_t bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim);
188 static bfa_boolean_t bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim);
189 static void bfa_itnim_cleanp_comp(void *itnim_cbarg);
190 static void bfa_itnim_cleanup(struct bfa_itnim_s *itnim);
191 static void __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete);
192 static void __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete);
193 static void __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete);
194 static void bfa_itnim_iotov_online(struct bfa_itnim_s *itnim);
195 static void bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim);
196 static void bfa_itnim_iotov(void *itnim_arg);
197 static void bfa_itnim_iotov_start(struct bfa_itnim_s *itnim);
198 static void bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim);
199 static void bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim);
200
201 /*
202 * forward declaration of ITNIM state machine
203 */
204 static void bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim,
205 enum bfa_itnim_event event);
206 static void bfa_itnim_sm_created(struct bfa_itnim_s *itnim,
207 enum bfa_itnim_event event);
208 static void bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim,
209 enum bfa_itnim_event event);
210 static void bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
211 enum bfa_itnim_event event);
212 static void bfa_itnim_sm_online(struct bfa_itnim_s *itnim,
213 enum bfa_itnim_event event);
214 static void bfa_itnim_sm_sler(struct bfa_itnim_s *itnim,
215 enum bfa_itnim_event event);
216 static void bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
217 enum bfa_itnim_event event);
218 static void bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
219 enum bfa_itnim_event event);
220 static void bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim,
221 enum bfa_itnim_event event);
222 static void bfa_itnim_sm_offline(struct bfa_itnim_s *itnim,
223 enum bfa_itnim_event event);
224 static void bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
225 enum bfa_itnim_event event);
226 static void bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim,
227 enum bfa_itnim_event event);
228 static void bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
229 enum bfa_itnim_event event);
230 static void bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
231 enum bfa_itnim_event event);
232 static void bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
233 enum bfa_itnim_event event);
234
235 /*
236 * forward declaration for BFA IOIM functions
237 */
238 static bfa_boolean_t bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
239 static bfa_boolean_t bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim);
240 static bfa_boolean_t bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
241 static void bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
242 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
243 static void __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete);
244 static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
245 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
246 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
247 static bfa_boolean_t bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
248 static void __bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete);
249 static void __bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete);
250 static void __bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete);
251
252 /*
253 * forward declaration of BFA IO state machine
254 */
255 static void bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim,
256 enum bfa_ioim_event event);
257 static void bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim,
258 enum bfa_ioim_event event);
259 static void bfa_ioim_sm_active(struct bfa_ioim_s *ioim,
260 enum bfa_ioim_event event);
261 static void bfa_ioim_sm_abort(struct bfa_ioim_s *ioim,
262 enum bfa_ioim_event event);
263 static void bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim,
264 enum bfa_ioim_event event);
265 static void bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim,
266 enum bfa_ioim_event event);
267 static void bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim,
268 enum bfa_ioim_event event);
269 static void bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim,
270 enum bfa_ioim_event event);
271 static void bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim,
272 enum bfa_ioim_event event);
273 static void bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim,
274 enum bfa_ioim_event event);
275 static void bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
276 enum bfa_ioim_event event);
277 static void bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim,
278 enum bfa_ioim_event event);
279 /*
280 * forward declaration for BFA TSKIM functions
281 */
282 static void __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete);
283 static void __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete);
284 static bfa_boolean_t bfa_tskim_match_scope(struct bfa_tskim_s *tskim,
285 struct scsi_lun lun);
286 static void bfa_tskim_gather_ios(struct bfa_tskim_s *tskim);
287 static void bfa_tskim_cleanp_comp(void *tskim_cbarg);
288 static void bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim);
289 static bfa_boolean_t bfa_tskim_send(struct bfa_tskim_s *tskim);
290 static bfa_boolean_t bfa_tskim_send_abort(struct bfa_tskim_s *tskim);
291 static void bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim);
292
293 /*
294 * forward declaration of BFA TSKIM state machine
295 */
296 static void bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim,
297 enum bfa_tskim_event event);
298 static void bfa_tskim_sm_active(struct bfa_tskim_s *tskim,
299 enum bfa_tskim_event event);
300 static void bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim,
301 enum bfa_tskim_event event);
302 static void bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim,
303 enum bfa_tskim_event event);
304 static void bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim,
305 enum bfa_tskim_event event);
306 static void bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
307 enum bfa_tskim_event event);
308 static void bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim,
309 enum bfa_tskim_event event);
310 /*
311 * BFA FCP Initiator Mode module
312 */
313
314 /*
315 * Compute and return memory needed by FCP(im) module.
316 */
317 static void
318 bfa_fcpim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len)
319 {
320 bfa_itnim_meminfo(cfg, km_len);
321
322 /*
323 * IO memory
324 */
325 *km_len += cfg->fwcfg.num_ioim_reqs *
326 (sizeof(struct bfa_ioim_s) + sizeof(struct bfa_ioim_sp_s));
327
328 /*
329 * task management command memory
330 */
331 if (cfg->fwcfg.num_tskim_reqs < BFA_TSKIM_MIN)
332 cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN;
333 *km_len += cfg->fwcfg.num_tskim_reqs * sizeof(struct bfa_tskim_s);
334 }
335
336
337 static void
338 bfa_fcpim_attach(struct bfa_fcp_mod_s *fcp, void *bfad,
339 struct bfa_iocfc_cfg_s *cfg, struct bfa_pcidev_s *pcidev)
340 {
341 struct bfa_fcpim_s *fcpim = &fcp->fcpim;
342 struct bfa_s *bfa = fcp->bfa;
343
344 bfa_trc(bfa, cfg->drvcfg.path_tov);
345 bfa_trc(bfa, cfg->fwcfg.num_rports);
346 bfa_trc(bfa, cfg->fwcfg.num_ioim_reqs);
347 bfa_trc(bfa, cfg->fwcfg.num_tskim_reqs);
348
349 fcpim->fcp = fcp;
350 fcpim->bfa = bfa;
351 fcpim->num_itnims = cfg->fwcfg.num_rports;
352 fcpim->num_tskim_reqs = cfg->fwcfg.num_tskim_reqs;
353 fcpim->path_tov = cfg->drvcfg.path_tov;
354 fcpim->delay_comp = cfg->drvcfg.delay_comp;
355 fcpim->profile_comp = NULL;
356 fcpim->profile_start = NULL;
357
358 bfa_itnim_attach(fcpim);
359 bfa_tskim_attach(fcpim);
360 bfa_ioim_attach(fcpim);
361 }
362
363 static void
364 bfa_fcpim_iocdisable(struct bfa_fcp_mod_s *fcp)
365 {
366 struct bfa_fcpim_s *fcpim = &fcp->fcpim;
367 struct bfa_itnim_s *itnim;
368 struct list_head *qe, *qen;
369
370 /* Enqueue unused ioim resources to free_q */
371 list_splice_tail_init(&fcpim->tskim_unused_q, &fcpim->tskim_free_q);
372
373 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
374 itnim = (struct bfa_itnim_s *) qe;
375 bfa_itnim_iocdisable(itnim);
376 }
377 }
378
379 void
380 bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov)
381 {
382 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
383
384 fcpim->path_tov = path_tov * 1000;
385 if (fcpim->path_tov > BFA_FCPIM_PATHTOV_MAX)
386 fcpim->path_tov = BFA_FCPIM_PATHTOV_MAX;
387 }
388
389 u16
390 bfa_fcpim_path_tov_get(struct bfa_s *bfa)
391 {
392 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
393
394 return fcpim->path_tov / 1000;
395 }
396
397 #define bfa_fcpim_add_iostats(__l, __r, __stats) \
398 (__l->__stats += __r->__stats)
399
400 void
401 bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
402 struct bfa_itnim_iostats_s *rstats)
403 {
404 bfa_fcpim_add_iostats(lstats, rstats, total_ios);
405 bfa_fcpim_add_iostats(lstats, rstats, qresumes);
406 bfa_fcpim_add_iostats(lstats, rstats, no_iotags);
407 bfa_fcpim_add_iostats(lstats, rstats, io_aborts);
408 bfa_fcpim_add_iostats(lstats, rstats, no_tskims);
409 bfa_fcpim_add_iostats(lstats, rstats, iocomp_ok);
410 bfa_fcpim_add_iostats(lstats, rstats, iocomp_underrun);
411 bfa_fcpim_add_iostats(lstats, rstats, iocomp_overrun);
412 bfa_fcpim_add_iostats(lstats, rstats, iocomp_aborted);
413 bfa_fcpim_add_iostats(lstats, rstats, iocomp_timedout);
414 bfa_fcpim_add_iostats(lstats, rstats, iocom_nexus_abort);
415 bfa_fcpim_add_iostats(lstats, rstats, iocom_proto_err);
416 bfa_fcpim_add_iostats(lstats, rstats, iocom_dif_err);
417 bfa_fcpim_add_iostats(lstats, rstats, iocom_sqer_needed);
418 bfa_fcpim_add_iostats(lstats, rstats, iocom_res_free);
419 bfa_fcpim_add_iostats(lstats, rstats, iocom_hostabrts);
420 bfa_fcpim_add_iostats(lstats, rstats, iocom_utags);
421 bfa_fcpim_add_iostats(lstats, rstats, io_cleanups);
422 bfa_fcpim_add_iostats(lstats, rstats, io_tmaborts);
423 bfa_fcpim_add_iostats(lstats, rstats, onlines);
424 bfa_fcpim_add_iostats(lstats, rstats, offlines);
425 bfa_fcpim_add_iostats(lstats, rstats, creates);
426 bfa_fcpim_add_iostats(lstats, rstats, deletes);
427 bfa_fcpim_add_iostats(lstats, rstats, create_comps);
428 bfa_fcpim_add_iostats(lstats, rstats, delete_comps);
429 bfa_fcpim_add_iostats(lstats, rstats, sler_events);
430 bfa_fcpim_add_iostats(lstats, rstats, fw_create);
431 bfa_fcpim_add_iostats(lstats, rstats, fw_delete);
432 bfa_fcpim_add_iostats(lstats, rstats, ioc_disabled);
433 bfa_fcpim_add_iostats(lstats, rstats, cleanup_comps);
434 bfa_fcpim_add_iostats(lstats, rstats, tm_cmnds);
435 bfa_fcpim_add_iostats(lstats, rstats, tm_fw_rsps);
436 bfa_fcpim_add_iostats(lstats, rstats, tm_success);
437 bfa_fcpim_add_iostats(lstats, rstats, tm_failures);
438 bfa_fcpim_add_iostats(lstats, rstats, tm_io_comps);
439 bfa_fcpim_add_iostats(lstats, rstats, tm_qresumes);
440 bfa_fcpim_add_iostats(lstats, rstats, tm_iocdowns);
441 bfa_fcpim_add_iostats(lstats, rstats, tm_cleanups);
442 bfa_fcpim_add_iostats(lstats, rstats, tm_cleanup_comps);
443 bfa_fcpim_add_iostats(lstats, rstats, io_comps);
444 bfa_fcpim_add_iostats(lstats, rstats, input_reqs);
445 bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
446 bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
447 bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
448 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_across_sg);
449 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_sup);
450 bfa_fcpim_add_iostats(lstats, rstats, lm_rpl_data_changed);
451 bfa_fcpim_add_iostats(lstats, rstats, lm_wire_residue_changed);
452 bfa_fcpim_add_iostats(lstats, rstats, lm_small_buf_addresidue);
453 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_rdy);
454 }
455
456 bfa_status_t
457 bfa_fcpim_port_iostats(struct bfa_s *bfa,
458 struct bfa_itnim_iostats_s *stats, u8 lp_tag)
459 {
460 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
461 struct list_head *qe, *qen;
462 struct bfa_itnim_s *itnim;
463
464 /* accumulate IO stats from itnim */
465 memset(stats, 0, sizeof(struct bfa_itnim_iostats_s));
466 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
467 itnim = (struct bfa_itnim_s *) qe;
468 if (itnim->rport->rport_info.lp_tag != lp_tag)
469 continue;
470 bfa_fcpim_add_stats(stats, &(itnim->stats));
471 }
472 return BFA_STATUS_OK;
473 }
474
475 void
476 bfa_ioim_profile_comp(struct bfa_ioim_s *ioim)
477 {
478 struct bfa_itnim_latency_s *io_lat =
479 &(ioim->itnim->ioprofile.io_latency);
480 u32 val, idx;
481
482 val = (u32)(jiffies - ioim->start_time);
483 idx = bfa_ioim_get_index(scsi_bufflen((struct scsi_cmnd *)ioim->dio));
484 bfa_itnim_ioprofile_update(ioim->itnim, idx);
485
486 io_lat->count[idx]++;
487 io_lat->min[idx] = (io_lat->min[idx] < val) ? io_lat->min[idx] : val;
488 io_lat->max[idx] = (io_lat->max[idx] > val) ? io_lat->max[idx] : val;
489 io_lat->avg[idx] += val;
490 }
491
492 void
493 bfa_ioim_profile_start(struct bfa_ioim_s *ioim)
494 {
495 ioim->start_time = jiffies;
496 }
497
498 bfa_status_t
499 bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time)
500 {
501 struct bfa_itnim_s *itnim;
502 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
503 struct list_head *qe, *qen;
504
505 /* accumulate IO stats from itnim */
506 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
507 itnim = (struct bfa_itnim_s *) qe;
508 bfa_itnim_clear_stats(itnim);
509 }
510 fcpim->io_profile = BFA_TRUE;
511 fcpim->io_profile_start_time = time;
512 fcpim->profile_comp = bfa_ioim_profile_comp;
513 fcpim->profile_start = bfa_ioim_profile_start;
514 return BFA_STATUS_OK;
515 }
516
517 bfa_status_t
518 bfa_fcpim_profile_off(struct bfa_s *bfa)
519 {
520 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
521 fcpim->io_profile = BFA_FALSE;
522 fcpim->io_profile_start_time = 0;
523 fcpim->profile_comp = NULL;
524 fcpim->profile_start = NULL;
525 return BFA_STATUS_OK;
526 }
527
528 u16
529 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
530 {
531 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
532
533 return fcpim->q_depth;
534 }
535
536 /*
537 * BFA ITNIM module state machine functions
538 */
539
540 /*
541 * Beginning/unallocated state - no events expected.
542 */
543 static void
544 bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
545 {
546 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
547 bfa_trc(itnim->bfa, event);
548
549 switch (event) {
550 case BFA_ITNIM_SM_CREATE:
551 bfa_sm_set_state(itnim, bfa_itnim_sm_created);
552 itnim->is_online = BFA_FALSE;
553 bfa_fcpim_additn(itnim);
554 break;
555
556 default:
557 bfa_sm_fault(itnim->bfa, event);
558 }
559 }
560
561 /*
562 * Beginning state, only online event expected.
563 */
564 static void
565 bfa_itnim_sm_created(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
566 {
567 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
568 bfa_trc(itnim->bfa, event);
569
570 switch (event) {
571 case BFA_ITNIM_SM_ONLINE:
572 if (bfa_itnim_send_fwcreate(itnim))
573 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
574 else
575 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
576 break;
577
578 case BFA_ITNIM_SM_DELETE:
579 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
580 bfa_fcpim_delitn(itnim);
581 break;
582
583 case BFA_ITNIM_SM_HWFAIL:
584 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
585 break;
586
587 default:
588 bfa_sm_fault(itnim->bfa, event);
589 }
590 }
591
592 /*
593 * Waiting for itnim create response from firmware.
594 */
595 static void
596 bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
597 {
598 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
599 bfa_trc(itnim->bfa, event);
600
601 switch (event) {
602 case BFA_ITNIM_SM_FWRSP:
603 bfa_sm_set_state(itnim, bfa_itnim_sm_online);
604 itnim->is_online = BFA_TRUE;
605 bfa_itnim_iotov_online(itnim);
606 bfa_itnim_online_cb(itnim);
607 break;
608
609 case BFA_ITNIM_SM_DELETE:
610 bfa_sm_set_state(itnim, bfa_itnim_sm_delete_pending);
611 break;
612
613 case BFA_ITNIM_SM_OFFLINE:
614 if (bfa_itnim_send_fwdelete(itnim))
615 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
616 else
617 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
618 break;
619
620 case BFA_ITNIM_SM_HWFAIL:
621 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
622 break;
623
624 default:
625 bfa_sm_fault(itnim->bfa, event);
626 }
627 }
628
629 static void
630 bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
631 enum bfa_itnim_event event)
632 {
633 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
634 bfa_trc(itnim->bfa, event);
635
636 switch (event) {
637 case BFA_ITNIM_SM_QRESUME:
638 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
639 bfa_itnim_send_fwcreate(itnim);
640 break;
641
642 case BFA_ITNIM_SM_DELETE:
643 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
644 bfa_reqq_wcancel(&itnim->reqq_wait);
645 bfa_fcpim_delitn(itnim);
646 break;
647
648 case BFA_ITNIM_SM_OFFLINE:
649 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
650 bfa_reqq_wcancel(&itnim->reqq_wait);
651 bfa_itnim_offline_cb(itnim);
652 break;
653
654 case BFA_ITNIM_SM_HWFAIL:
655 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
656 bfa_reqq_wcancel(&itnim->reqq_wait);
657 break;
658
659 default:
660 bfa_sm_fault(itnim->bfa, event);
661 }
662 }
663
664 /*
665 * Waiting for itnim create response from firmware, a delete is pending.
666 */
667 static void
668 bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
669 enum bfa_itnim_event event)
670 {
671 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
672 bfa_trc(itnim->bfa, event);
673
674 switch (event) {
675 case BFA_ITNIM_SM_FWRSP:
676 if (bfa_itnim_send_fwdelete(itnim))
677 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
678 else
679 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
680 break;
681
682 case BFA_ITNIM_SM_HWFAIL:
683 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
684 bfa_fcpim_delitn(itnim);
685 break;
686
687 default:
688 bfa_sm_fault(itnim->bfa, event);
689 }
690 }
691
692 /*
693 * Online state - normal parking state.
694 */
695 static void
696 bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
697 {
698 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
699 bfa_trc(itnim->bfa, event);
700
701 switch (event) {
702 case BFA_ITNIM_SM_OFFLINE:
703 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
704 itnim->is_online = BFA_FALSE;
705 bfa_itnim_iotov_start(itnim);
706 bfa_itnim_cleanup(itnim);
707 break;
708
709 case BFA_ITNIM_SM_DELETE:
710 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
711 itnim->is_online = BFA_FALSE;
712 bfa_itnim_cleanup(itnim);
713 break;
714
715 case BFA_ITNIM_SM_SLER:
716 bfa_sm_set_state(itnim, bfa_itnim_sm_sler);
717 itnim->is_online = BFA_FALSE;
718 bfa_itnim_iotov_start(itnim);
719 bfa_itnim_sler_cb(itnim);
720 break;
721
722 case BFA_ITNIM_SM_HWFAIL:
723 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
724 itnim->is_online = BFA_FALSE;
725 bfa_itnim_iotov_start(itnim);
726 bfa_itnim_iocdisable_cleanup(itnim);
727 break;
728
729 default:
730 bfa_sm_fault(itnim->bfa, event);
731 }
732 }
733
734 /*
735 * Second level error recovery need.
736 */
737 static void
738 bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
739 {
740 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
741 bfa_trc(itnim->bfa, event);
742
743 switch (event) {
744 case BFA_ITNIM_SM_OFFLINE:
745 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
746 bfa_itnim_cleanup(itnim);
747 break;
748
749 case BFA_ITNIM_SM_DELETE:
750 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
751 bfa_itnim_cleanup(itnim);
752 bfa_itnim_iotov_delete(itnim);
753 break;
754
755 case BFA_ITNIM_SM_HWFAIL:
756 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
757 bfa_itnim_iocdisable_cleanup(itnim);
758 break;
759
760 default:
761 bfa_sm_fault(itnim->bfa, event);
762 }
763 }
764
765 /*
766 * Going offline. Waiting for active IO cleanup.
767 */
768 static void
769 bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
770 enum bfa_itnim_event event)
771 {
772 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
773 bfa_trc(itnim->bfa, event);
774
775 switch (event) {
776 case BFA_ITNIM_SM_CLEANUP:
777 if (bfa_itnim_send_fwdelete(itnim))
778 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
779 else
780 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
781 break;
782
783 case BFA_ITNIM_SM_DELETE:
784 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
785 bfa_itnim_iotov_delete(itnim);
786 break;
787
788 case BFA_ITNIM_SM_HWFAIL:
789 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
790 bfa_itnim_iocdisable_cleanup(itnim);
791 bfa_itnim_offline_cb(itnim);
792 break;
793
794 case BFA_ITNIM_SM_SLER:
795 break;
796
797 default:
798 bfa_sm_fault(itnim->bfa, event);
799 }
800 }
801
802 /*
803 * Deleting itnim. Waiting for active IO cleanup.
804 */
805 static void
806 bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
807 enum bfa_itnim_event event)
808 {
809 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
810 bfa_trc(itnim->bfa, event);
811
812 switch (event) {
813 case BFA_ITNIM_SM_CLEANUP:
814 if (bfa_itnim_send_fwdelete(itnim))
815 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
816 else
817 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
818 break;
819
820 case BFA_ITNIM_SM_HWFAIL:
821 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
822 bfa_itnim_iocdisable_cleanup(itnim);
823 break;
824
825 default:
826 bfa_sm_fault(itnim->bfa, event);
827 }
828 }
829
830 /*
831 * Rport offline. Fimrware itnim is being deleted - awaiting f/w response.
832 */
833 static void
834 bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
835 {
836 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
837 bfa_trc(itnim->bfa, event);
838
839 switch (event) {
840 case BFA_ITNIM_SM_FWRSP:
841 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
842 bfa_itnim_offline_cb(itnim);
843 break;
844
845 case BFA_ITNIM_SM_DELETE:
846 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
847 break;
848
849 case BFA_ITNIM_SM_HWFAIL:
850 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
851 bfa_itnim_offline_cb(itnim);
852 break;
853
854 default:
855 bfa_sm_fault(itnim->bfa, event);
856 }
857 }
858
859 static void
860 bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
861 enum bfa_itnim_event event)
862 {
863 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
864 bfa_trc(itnim->bfa, event);
865
866 switch (event) {
867 case BFA_ITNIM_SM_QRESUME:
868 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
869 bfa_itnim_send_fwdelete(itnim);
870 break;
871
872 case BFA_ITNIM_SM_DELETE:
873 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
874 break;
875
876 case BFA_ITNIM_SM_HWFAIL:
877 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
878 bfa_reqq_wcancel(&itnim->reqq_wait);
879 bfa_itnim_offline_cb(itnim);
880 break;
881
882 default:
883 bfa_sm_fault(itnim->bfa, event);
884 }
885 }
886
887 /*
888 * Offline state.
889 */
890 static void
891 bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
892 {
893 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
894 bfa_trc(itnim->bfa, event);
895
896 switch (event) {
897 case BFA_ITNIM_SM_DELETE:
898 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
899 bfa_itnim_iotov_delete(itnim);
900 bfa_fcpim_delitn(itnim);
901 break;
902
903 case BFA_ITNIM_SM_ONLINE:
904 if (bfa_itnim_send_fwcreate(itnim))
905 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
906 else
907 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
908 break;
909
910 case BFA_ITNIM_SM_HWFAIL:
911 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
912 break;
913
914 default:
915 bfa_sm_fault(itnim->bfa, event);
916 }
917 }
918
919 static void
920 bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
921 enum bfa_itnim_event event)
922 {
923 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
924 bfa_trc(itnim->bfa, event);
925
926 switch (event) {
927 case BFA_ITNIM_SM_DELETE:
928 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
929 bfa_itnim_iotov_delete(itnim);
930 bfa_fcpim_delitn(itnim);
931 break;
932
933 case BFA_ITNIM_SM_OFFLINE:
934 bfa_itnim_offline_cb(itnim);
935 break;
936
937 case BFA_ITNIM_SM_ONLINE:
938 if (bfa_itnim_send_fwcreate(itnim))
939 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
940 else
941 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
942 break;
943
944 case BFA_ITNIM_SM_HWFAIL:
945 break;
946
947 default:
948 bfa_sm_fault(itnim->bfa, event);
949 }
950 }
951
952 /*
953 * Itnim is deleted, waiting for firmware response to delete.
954 */
955 static void
956 bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
957 {
958 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
959 bfa_trc(itnim->bfa, event);
960
961 switch (event) {
962 case BFA_ITNIM_SM_FWRSP:
963 case BFA_ITNIM_SM_HWFAIL:
964 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
965 bfa_fcpim_delitn(itnim);
966 break;
967
968 default:
969 bfa_sm_fault(itnim->bfa, event);
970 }
971 }
972
973 static void
974 bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
975 enum bfa_itnim_event event)
976 {
977 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
978 bfa_trc(itnim->bfa, event);
979
980 switch (event) {
981 case BFA_ITNIM_SM_QRESUME:
982 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
983 bfa_itnim_send_fwdelete(itnim);
984 break;
985
986 case BFA_ITNIM_SM_HWFAIL:
987 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
988 bfa_reqq_wcancel(&itnim->reqq_wait);
989 bfa_fcpim_delitn(itnim);
990 break;
991
992 default:
993 bfa_sm_fault(itnim->bfa, event);
994 }
995 }
996
997 /*
998 * Initiate cleanup of all IOs on an IOC failure.
999 */
1000 static void
1001 bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim)
1002 {
1003 struct bfa_tskim_s *tskim;
1004 struct bfa_ioim_s *ioim;
1005 struct list_head *qe, *qen;
1006
1007 list_for_each_safe(qe, qen, &itnim->tsk_q) {
1008 tskim = (struct bfa_tskim_s *) qe;
1009 bfa_tskim_iocdisable(tskim);
1010 }
1011
1012 list_for_each_safe(qe, qen, &itnim->io_q) {
1013 ioim = (struct bfa_ioim_s *) qe;
1014 bfa_ioim_iocdisable(ioim);
1015 }
1016
1017 /*
1018 * For IO request in pending queue, we pretend an early timeout.
1019 */
1020 list_for_each_safe(qe, qen, &itnim->pending_q) {
1021 ioim = (struct bfa_ioim_s *) qe;
1022 bfa_ioim_tov(ioim);
1023 }
1024
1025 list_for_each_safe(qe, qen, &itnim->io_cleanup_q) {
1026 ioim = (struct bfa_ioim_s *) qe;
1027 bfa_ioim_iocdisable(ioim);
1028 }
1029 }
1030
1031 /*
1032 * IO cleanup completion
1033 */
1034 static void
1035 bfa_itnim_cleanp_comp(void *itnim_cbarg)
1036 {
1037 struct bfa_itnim_s *itnim = itnim_cbarg;
1038
1039 bfa_stats(itnim, cleanup_comps);
1040 bfa_sm_send_event(itnim, BFA_ITNIM_SM_CLEANUP);
1041 }
1042
1043 /*
1044 * Initiate cleanup of all IOs.
1045 */
1046 static void
1047 bfa_itnim_cleanup(struct bfa_itnim_s *itnim)
1048 {
1049 struct bfa_ioim_s *ioim;
1050 struct bfa_tskim_s *tskim;
1051 struct list_head *qe, *qen;
1052
1053 bfa_wc_init(&itnim->wc, bfa_itnim_cleanp_comp, itnim);
1054
1055 list_for_each_safe(qe, qen, &itnim->io_q) {
1056 ioim = (struct bfa_ioim_s *) qe;
1057
1058 /*
1059 * Move IO to a cleanup queue from active queue so that a later
1060 * TM will not pickup this IO.
1061 */
1062 list_del(&ioim->qe);
1063 list_add_tail(&ioim->qe, &itnim->io_cleanup_q);
1064
1065 bfa_wc_up(&itnim->wc);
1066 bfa_ioim_cleanup(ioim);
1067 }
1068
1069 list_for_each_safe(qe, qen, &itnim->tsk_q) {
1070 tskim = (struct bfa_tskim_s *) qe;
1071 bfa_wc_up(&itnim->wc);
1072 bfa_tskim_cleanup(tskim);
1073 }
1074
1075 bfa_wc_wait(&itnim->wc);
1076 }
1077
1078 static void
1079 __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete)
1080 {
1081 struct bfa_itnim_s *itnim = cbarg;
1082
1083 if (complete)
1084 bfa_cb_itnim_online(itnim->ditn);
1085 }
1086
1087 static void
1088 __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete)
1089 {
1090 struct bfa_itnim_s *itnim = cbarg;
1091
1092 if (complete)
1093 bfa_cb_itnim_offline(itnim->ditn);
1094 }
1095
1096 static void
1097 __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete)
1098 {
1099 struct bfa_itnim_s *itnim = cbarg;
1100
1101 if (complete)
1102 bfa_cb_itnim_sler(itnim->ditn);
1103 }
1104
1105 /*
1106 * Call to resume any I/O requests waiting for room in request queue.
1107 */
1108 static void
1109 bfa_itnim_qresume(void *cbarg)
1110 {
1111 struct bfa_itnim_s *itnim = cbarg;
1112
1113 bfa_sm_send_event(itnim, BFA_ITNIM_SM_QRESUME);
1114 }
1115
1116 /*
1117 * bfa_itnim_public
1118 */
1119
1120 void
1121 bfa_itnim_iodone(struct bfa_itnim_s *itnim)
1122 {
1123 bfa_wc_down(&itnim->wc);
1124 }
1125
1126 void
1127 bfa_itnim_tskdone(struct bfa_itnim_s *itnim)
1128 {
1129 bfa_wc_down(&itnim->wc);
1130 }
1131
1132 void
1133 bfa_itnim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len)
1134 {
1135 /*
1136 * ITN memory
1137 */
1138 *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_itnim_s);
1139 }
1140
1141 void
1142 bfa_itnim_attach(struct bfa_fcpim_s *fcpim)
1143 {
1144 struct bfa_s *bfa = fcpim->bfa;
1145 struct bfa_fcp_mod_s *fcp = fcpim->fcp;
1146 struct bfa_itnim_s *itnim;
1147 int i, j;
1148
1149 INIT_LIST_HEAD(&fcpim->itnim_q);
1150
1151 itnim = (struct bfa_itnim_s *) bfa_mem_kva_curp(fcp);
1152 fcpim->itnim_arr = itnim;
1153
1154 for (i = 0; i < fcpim->num_itnims; i++, itnim++) {
1155 memset(itnim, 0, sizeof(struct bfa_itnim_s));
1156 itnim->bfa = bfa;
1157 itnim->fcpim = fcpim;
1158 itnim->reqq = BFA_REQQ_QOS_LO;
1159 itnim->rport = BFA_RPORT_FROM_TAG(bfa, i);
1160 itnim->iotov_active = BFA_FALSE;
1161 bfa_reqq_winit(&itnim->reqq_wait, bfa_itnim_qresume, itnim);
1162
1163 INIT_LIST_HEAD(&itnim->io_q);
1164 INIT_LIST_HEAD(&itnim->io_cleanup_q);
1165 INIT_LIST_HEAD(&itnim->pending_q);
1166 INIT_LIST_HEAD(&itnim->tsk_q);
1167 INIT_LIST_HEAD(&itnim->delay_comp_q);
1168 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1169 itnim->ioprofile.io_latency.min[j] = ~0;
1170 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
1171 }
1172
1173 bfa_mem_kva_curp(fcp) = (u8 *) itnim;
1174 }
1175
1176 void
1177 bfa_itnim_iocdisable(struct bfa_itnim_s *itnim)
1178 {
1179 bfa_stats(itnim, ioc_disabled);
1180 bfa_sm_send_event(itnim, BFA_ITNIM_SM_HWFAIL);
1181 }
1182
1183 static bfa_boolean_t
1184 bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim)
1185 {
1186 struct bfi_itn_create_req_s *m;
1187
1188 itnim->msg_no++;
1189
1190 /*
1191 * check for room in queue to send request now
1192 */
1193 m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1194 if (!m) {
1195 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1196 return BFA_FALSE;
1197 }
1198
1199 bfi_h2i_set(m->mh, BFI_MC_ITN, BFI_ITN_H2I_CREATE_REQ,
1200 bfa_fn_lpu(itnim->bfa));
1201 m->fw_handle = itnim->rport->fw_handle;
1202 m->class = FC_CLASS_3;
1203 m->seq_rec = itnim->seq_rec;
1204 m->msg_no = itnim->msg_no;
1205 bfa_stats(itnim, fw_create);
1206
1207 /*
1208 * queue I/O message to firmware
1209 */
1210 bfa_reqq_produce(itnim->bfa, itnim->reqq, m->mh);
1211 return BFA_TRUE;
1212 }
1213
1214 static bfa_boolean_t
1215 bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim)
1216 {
1217 struct bfi_itn_delete_req_s *m;
1218
1219 /*
1220 * check for room in queue to send request now
1221 */
1222 m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1223 if (!m) {
1224 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1225 return BFA_FALSE;
1226 }
1227
1228 bfi_h2i_set(m->mh, BFI_MC_ITN, BFI_ITN_H2I_DELETE_REQ,
1229 bfa_fn_lpu(itnim->bfa));
1230 m->fw_handle = itnim->rport->fw_handle;
1231 bfa_stats(itnim, fw_delete);
1232
1233 /*
1234 * queue I/O message to firmware
1235 */
1236 bfa_reqq_produce(itnim->bfa, itnim->reqq, m->mh);
1237 return BFA_TRUE;
1238 }
1239
1240 /*
1241 * Cleanup all pending failed inflight requests.
1242 */
1243 static void
1244 bfa_itnim_delayed_comp(struct bfa_itnim_s *itnim, bfa_boolean_t iotov)
1245 {
1246 struct bfa_ioim_s *ioim;
1247 struct list_head *qe, *qen;
1248
1249 list_for_each_safe(qe, qen, &itnim->delay_comp_q) {
1250 ioim = (struct bfa_ioim_s *)qe;
1251 bfa_ioim_delayed_comp(ioim, iotov);
1252 }
1253 }
1254
1255 /*
1256 * Start all pending IO requests.
1257 */
1258 static void
1259 bfa_itnim_iotov_online(struct bfa_itnim_s *itnim)
1260 {
1261 struct bfa_ioim_s *ioim;
1262
1263 bfa_itnim_iotov_stop(itnim);
1264
1265 /*
1266 * Abort all inflight IO requests in the queue
1267 */
1268 bfa_itnim_delayed_comp(itnim, BFA_FALSE);
1269
1270 /*
1271 * Start all pending IO requests.
1272 */
1273 while (!list_empty(&itnim->pending_q)) {
1274 bfa_q_deq(&itnim->pending_q, &ioim);
1275 list_add_tail(&ioim->qe, &itnim->io_q);
1276 bfa_ioim_start(ioim);
1277 }
1278 }
1279
1280 /*
1281 * Fail all pending IO requests
1282 */
1283 static void
1284 bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim)
1285 {
1286 struct bfa_ioim_s *ioim;
1287
1288 /*
1289 * Fail all inflight IO requests in the queue
1290 */
1291 bfa_itnim_delayed_comp(itnim, BFA_TRUE);
1292
1293 /*
1294 * Fail any pending IO requests.
1295 */
1296 while (!list_empty(&itnim->pending_q)) {
1297 bfa_q_deq(&itnim->pending_q, &ioim);
1298 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
1299 bfa_ioim_tov(ioim);
1300 }
1301 }
1302
1303 /*
1304 * IO TOV timer callback. Fail any pending IO requests.
1305 */
1306 static void
1307 bfa_itnim_iotov(void *itnim_arg)
1308 {
1309 struct bfa_itnim_s *itnim = itnim_arg;
1310
1311 itnim->iotov_active = BFA_FALSE;
1312
1313 bfa_cb_itnim_tov_begin(itnim->ditn);
1314 bfa_itnim_iotov_cleanup(itnim);
1315 bfa_cb_itnim_tov(itnim->ditn);
1316 }
1317
1318 /*
1319 * Start IO TOV timer for failing back pending IO requests in offline state.
1320 */
1321 static void
1322 bfa_itnim_iotov_start(struct bfa_itnim_s *itnim)
1323 {
1324 if (itnim->fcpim->path_tov > 0) {
1325
1326 itnim->iotov_active = BFA_TRUE;
1327 WARN_ON(!bfa_itnim_hold_io(itnim));
1328 bfa_timer_start(itnim->bfa, &itnim->timer,
1329 bfa_itnim_iotov, itnim, itnim->fcpim->path_tov);
1330 }
1331 }
1332
1333 /*
1334 * Stop IO TOV timer.
1335 */
1336 static void
1337 bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim)
1338 {
1339 if (itnim->iotov_active) {
1340 itnim->iotov_active = BFA_FALSE;
1341 bfa_timer_stop(&itnim->timer);
1342 }
1343 }
1344
1345 /*
1346 * Stop IO TOV timer.
1347 */
1348 static void
1349 bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim)
1350 {
1351 bfa_boolean_t pathtov_active = BFA_FALSE;
1352
1353 if (itnim->iotov_active)
1354 pathtov_active = BFA_TRUE;
1355
1356 bfa_itnim_iotov_stop(itnim);
1357 if (pathtov_active)
1358 bfa_cb_itnim_tov_begin(itnim->ditn);
1359 bfa_itnim_iotov_cleanup(itnim);
1360 if (pathtov_active)
1361 bfa_cb_itnim_tov(itnim->ditn);
1362 }
1363
1364 static void
1365 bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim)
1366 {
1367 struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
1368 fcpim->del_itn_stats.del_itn_iocomp_aborted +=
1369 itnim->stats.iocomp_aborted;
1370 fcpim->del_itn_stats.del_itn_iocomp_timedout +=
1371 itnim->stats.iocomp_timedout;
1372 fcpim->del_itn_stats.del_itn_iocom_sqer_needed +=
1373 itnim->stats.iocom_sqer_needed;
1374 fcpim->del_itn_stats.del_itn_iocom_res_free +=
1375 itnim->stats.iocom_res_free;
1376 fcpim->del_itn_stats.del_itn_iocom_hostabrts +=
1377 itnim->stats.iocom_hostabrts;
1378 fcpim->del_itn_stats.del_itn_total_ios += itnim->stats.total_ios;
1379 fcpim->del_itn_stats.del_io_iocdowns += itnim->stats.io_iocdowns;
1380 fcpim->del_itn_stats.del_tm_iocdowns += itnim->stats.tm_iocdowns;
1381 }
1382
1383 /*
1384 * bfa_itnim_public
1385 */
1386
1387 /*
1388 * Itnim interrupt processing.
1389 */
1390 void
1391 bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1392 {
1393 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
1394 union bfi_itn_i2h_msg_u msg;
1395 struct bfa_itnim_s *itnim;
1396
1397 bfa_trc(bfa, m->mhdr.msg_id);
1398
1399 msg.msg = m;
1400
1401 switch (m->mhdr.msg_id) {
1402 case BFI_ITN_I2H_CREATE_RSP:
1403 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1404 msg.create_rsp->bfa_handle);
1405 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
1406 bfa_stats(itnim, create_comps);
1407 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1408 break;
1409
1410 case BFI_ITN_I2H_DELETE_RSP:
1411 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1412 msg.delete_rsp->bfa_handle);
1413 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
1414 bfa_stats(itnim, delete_comps);
1415 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1416 break;
1417
1418 case BFI_ITN_I2H_SLER_EVENT:
1419 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1420 msg.sler_event->bfa_handle);
1421 bfa_stats(itnim, sler_events);
1422 bfa_sm_send_event(itnim, BFA_ITNIM_SM_SLER);
1423 break;
1424
1425 default:
1426 bfa_trc(bfa, m->mhdr.msg_id);
1427 WARN_ON(1);
1428 }
1429 }
1430
1431 /*
1432 * bfa_itnim_api
1433 */
1434
1435 struct bfa_itnim_s *
1436 bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
1437 {
1438 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
1439 struct bfa_itnim_s *itnim;
1440
1441 bfa_itn_create(bfa, rport, bfa_itnim_isr);
1442
1443 itnim = BFA_ITNIM_FROM_TAG(fcpim, rport->rport_tag);
1444 WARN_ON(itnim->rport != rport);
1445
1446 itnim->ditn = ditn;
1447
1448 bfa_stats(itnim, creates);
1449 bfa_sm_send_event(itnim, BFA_ITNIM_SM_CREATE);
1450
1451 return itnim;
1452 }
1453
1454 void
1455 bfa_itnim_delete(struct bfa_itnim_s *itnim)
1456 {
1457 bfa_stats(itnim, deletes);
1458 bfa_sm_send_event(itnim, BFA_ITNIM_SM_DELETE);
1459 }
1460
1461 void
1462 bfa_itnim_online(struct bfa_itnim_s *itnim, bfa_boolean_t seq_rec)
1463 {
1464 itnim->seq_rec = seq_rec;
1465 bfa_stats(itnim, onlines);
1466 bfa_sm_send_event(itnim, BFA_ITNIM_SM_ONLINE);
1467 }
1468
1469 void
1470 bfa_itnim_offline(struct bfa_itnim_s *itnim)
1471 {
1472 bfa_stats(itnim, offlines);
1473 bfa_sm_send_event(itnim, BFA_ITNIM_SM_OFFLINE);
1474 }
1475
1476 /*
1477 * Return true if itnim is considered offline for holding off IO request.
1478 * IO is not held if itnim is being deleted.
1479 */
1480 bfa_boolean_t
1481 bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
1482 {
1483 return itnim->fcpim->path_tov && itnim->iotov_active &&
1484 (bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwcreate) ||
1485 bfa_sm_cmp_state(itnim, bfa_itnim_sm_sler) ||
1486 bfa_sm_cmp_state(itnim, bfa_itnim_sm_cleanup_offline) ||
1487 bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwdelete) ||
1488 bfa_sm_cmp_state(itnim, bfa_itnim_sm_offline) ||
1489 bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable));
1490 }
1491
1492 #define bfa_io_lat_clock_res_div HZ
1493 #define bfa_io_lat_clock_res_mul 1000
1494 bfa_status_t
1495 bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
1496 struct bfa_itnim_ioprofile_s *ioprofile)
1497 {
1498 struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
1499 if (!fcpim->io_profile)
1500 return BFA_STATUS_IOPROFILE_OFF;
1501
1502 itnim->ioprofile.index = BFA_IOBUCKET_MAX;
1503 itnim->ioprofile.io_profile_start_time =
1504 bfa_io_profile_start_time(itnim->bfa);
1505 itnim->ioprofile.clock_res_mul = bfa_io_lat_clock_res_mul;
1506 itnim->ioprofile.clock_res_div = bfa_io_lat_clock_res_div;
1507 *ioprofile = itnim->ioprofile;
1508
1509 return BFA_STATUS_OK;
1510 }
1511
1512 void
1513 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
1514 {
1515 int j;
1516 memset(&itnim->stats, 0, sizeof(itnim->stats));
1517 memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile));
1518 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1519 itnim->ioprofile.io_latency.min[j] = ~0;
1520 }
1521
1522 /*
1523 * BFA IO module state machine functions
1524 */
1525
1526 /*
1527 * IO is not started (unallocated).
1528 */
1529 static void
1530 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1531 {
1532 switch (event) {
1533 case BFA_IOIM_SM_START:
1534 if (!bfa_itnim_is_online(ioim->itnim)) {
1535 if (!bfa_itnim_hold_io(ioim->itnim)) {
1536 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1537 list_del(&ioim->qe);
1538 list_add_tail(&ioim->qe,
1539 &ioim->fcpim->ioim_comp_q);
1540 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1541 __bfa_cb_ioim_pathtov, ioim);
1542 } else {
1543 list_del(&ioim->qe);
1544 list_add_tail(&ioim->qe,
1545 &ioim->itnim->pending_q);
1546 }
1547 break;
1548 }
1549
1550 if (ioim->nsges > BFI_SGE_INLINE) {
1551 if (!bfa_ioim_sgpg_alloc(ioim)) {
1552 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
1553 return;
1554 }
1555 }
1556
1557 if (!bfa_ioim_send_ioreq(ioim)) {
1558 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1559 break;
1560 }
1561
1562 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1563 break;
1564
1565 case BFA_IOIM_SM_IOTOV:
1566 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1567 bfa_ioim_move_to_comp_q(ioim);
1568 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1569 __bfa_cb_ioim_pathtov, ioim);
1570 break;
1571
1572 case BFA_IOIM_SM_ABORT:
1573 /*
1574 * IO in pending queue can get abort requests. Complete abort
1575 * requests immediately.
1576 */
1577 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1578 WARN_ON(!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
1579 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1580 __bfa_cb_ioim_abort, ioim);
1581 break;
1582
1583 case BFA_IOIM_SM_LM_LUN_NOT_SUP:
1584 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1585 bfa_ioim_move_to_comp_q(ioim);
1586 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1587 __bfa_cb_ioim_lm_lun_not_sup, ioim);
1588 break;
1589
1590 case BFA_IOIM_SM_LM_RPL_DC:
1591 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1592 bfa_ioim_move_to_comp_q(ioim);
1593 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1594 __bfa_cb_ioim_lm_rpl_dc, ioim);
1595 break;
1596
1597 case BFA_IOIM_SM_LM_LUN_NOT_RDY:
1598 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1599 bfa_ioim_move_to_comp_q(ioim);
1600 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1601 __bfa_cb_ioim_lm_lun_not_rdy, ioim);
1602 break;
1603
1604 default:
1605 bfa_sm_fault(ioim->bfa, event);
1606 }
1607 }
1608
1609 /*
1610 * IO is waiting for SG pages.
1611 */
1612 static void
1613 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1614 {
1615 bfa_trc(ioim->bfa, ioim->iotag);
1616 bfa_trc(ioim->bfa, event);
1617
1618 switch (event) {
1619 case BFA_IOIM_SM_SGALLOCED:
1620 if (!bfa_ioim_send_ioreq(ioim)) {
1621 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1622 break;
1623 }
1624 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1625 break;
1626
1627 case BFA_IOIM_SM_CLEANUP:
1628 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1629 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1630 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1631 ioim);
1632 bfa_ioim_notify_cleanup(ioim);
1633 break;
1634
1635 case BFA_IOIM_SM_ABORT:
1636 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1637 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1638 bfa_ioim_move_to_comp_q(ioim);
1639 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1640 ioim);
1641 break;
1642
1643 case BFA_IOIM_SM_HWFAIL:
1644 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1645 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1646 bfa_ioim_move_to_comp_q(ioim);
1647 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1648 ioim);
1649 break;
1650
1651 default:
1652 bfa_sm_fault(ioim->bfa, event);
1653 }
1654 }
1655
1656 /*
1657 * IO is active.
1658 */
1659 static void
1660 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1661 {
1662 switch (event) {
1663 case BFA_IOIM_SM_COMP_GOOD:
1664 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1665 bfa_ioim_move_to_comp_q(ioim);
1666 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1667 __bfa_cb_ioim_good_comp, ioim);
1668 break;
1669
1670 case BFA_IOIM_SM_COMP:
1671 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1672 bfa_ioim_move_to_comp_q(ioim);
1673 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1674 ioim);
1675 break;
1676
1677 case BFA_IOIM_SM_DONE:
1678 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1679 bfa_ioim_move_to_comp_q(ioim);
1680 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1681 ioim);
1682 break;
1683
1684 case BFA_IOIM_SM_ABORT:
1685 ioim->iosp->abort_explicit = BFA_TRUE;
1686 ioim->io_cbfn = __bfa_cb_ioim_abort;
1687
1688 if (bfa_ioim_send_abort(ioim))
1689 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1690 else {
1691 bfa_sm_set_state(ioim, bfa_ioim_sm_abort_qfull);
1692 bfa_stats(ioim->itnim, qwait);
1693 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1694 &ioim->iosp->reqq_wait);
1695 }
1696 break;
1697
1698 case BFA_IOIM_SM_CLEANUP:
1699 ioim->iosp->abort_explicit = BFA_FALSE;
1700 ioim->io_cbfn = __bfa_cb_ioim_failed;
1701
1702 if (bfa_ioim_send_abort(ioim))
1703 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1704 else {
1705 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1706 bfa_stats(ioim->itnim, qwait);
1707 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1708 &ioim->iosp->reqq_wait);
1709 }
1710 break;
1711
1712 case BFA_IOIM_SM_HWFAIL:
1713 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1714 bfa_ioim_move_to_comp_q(ioim);
1715 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1716 ioim);
1717 break;
1718
1719 case BFA_IOIM_SM_SQRETRY:
1720 if (bfa_ioim_maxretry_reached(ioim)) {
1721 /* max retry reached, free IO */
1722 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1723 bfa_ioim_move_to_comp_q(ioim);
1724 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1725 __bfa_cb_ioim_failed, ioim);
1726 break;
1727 }
1728 /* waiting for IO tag resource free */
1729 bfa_sm_set_state(ioim, bfa_ioim_sm_cmnd_retry);
1730 break;
1731
1732 default:
1733 bfa_sm_fault(ioim->bfa, event);
1734 }
1735 }
1736
1737 /*
1738 * IO is retried with new tag.
1739 */
1740 static void
1741 bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1742 {
1743 switch (event) {
1744 case BFA_IOIM_SM_FREE:
1745 /* abts and rrq done. Now retry the IO with new tag */
1746 bfa_ioim_update_iotag(ioim);
1747 if (!bfa_ioim_send_ioreq(ioim)) {
1748 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1749 break;
1750 }
1751 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1752 break;
1753
1754 case BFA_IOIM_SM_CLEANUP:
1755 ioim->iosp->abort_explicit = BFA_FALSE;
1756 ioim->io_cbfn = __bfa_cb_ioim_failed;
1757
1758 if (bfa_ioim_send_abort(ioim))
1759 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1760 else {
1761 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1762 bfa_stats(ioim->itnim, qwait);
1763 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1764 &ioim->iosp->reqq_wait);
1765 }
1766 break;
1767
1768 case BFA_IOIM_SM_HWFAIL:
1769 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1770 bfa_ioim_move_to_comp_q(ioim);
1771 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1772 __bfa_cb_ioim_failed, ioim);
1773 break;
1774
1775 case BFA_IOIM_SM_ABORT:
1776 /* in this state IO abort is done.
1777 * Waiting for IO tag resource free.
1778 */
1779 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1780 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1781 ioim);
1782 break;
1783
1784 default:
1785 bfa_sm_fault(ioim->bfa, event);
1786 }
1787 }
1788
1789 /*
1790 * IO is being aborted, waiting for completion from firmware.
1791 */
1792 static void
1793 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1794 {
1795 bfa_trc(ioim->bfa, ioim->iotag);
1796 bfa_trc(ioim->bfa, event);
1797
1798 switch (event) {
1799 case BFA_IOIM_SM_COMP_GOOD:
1800 case BFA_IOIM_SM_COMP:
1801 case BFA_IOIM_SM_DONE:
1802 case BFA_IOIM_SM_FREE:
1803 break;
1804
1805 case BFA_IOIM_SM_ABORT_DONE:
1806 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1807 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1808 ioim);
1809 break;
1810
1811 case BFA_IOIM_SM_ABORT_COMP:
1812 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1813 bfa_ioim_move_to_comp_q(ioim);
1814 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1815 ioim);
1816 break;
1817
1818 case BFA_IOIM_SM_COMP_UTAG:
1819 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1820 bfa_ioim_move_to_comp_q(ioim);
1821 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1822 ioim);
1823 break;
1824
1825 case BFA_IOIM_SM_CLEANUP:
1826 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1827 ioim->iosp->abort_explicit = BFA_FALSE;
1828
1829 if (bfa_ioim_send_abort(ioim))
1830 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1831 else {
1832 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1833 bfa_stats(ioim->itnim, qwait);
1834 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1835 &ioim->iosp->reqq_wait);
1836 }
1837 break;
1838
1839 case BFA_IOIM_SM_HWFAIL:
1840 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1841 bfa_ioim_move_to_comp_q(ioim);
1842 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1843 ioim);
1844 break;
1845
1846 default:
1847 bfa_sm_fault(ioim->bfa, event);
1848 }
1849 }
1850
1851 /*
1852 * IO is being cleaned up (implicit abort), waiting for completion from
1853 * firmware.
1854 */
1855 static void
1856 bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1857 {
1858 bfa_trc(ioim->bfa, ioim->iotag);
1859 bfa_trc(ioim->bfa, event);
1860
1861 switch (event) {
1862 case BFA_IOIM_SM_COMP_GOOD:
1863 case BFA_IOIM_SM_COMP:
1864 case BFA_IOIM_SM_DONE:
1865 case BFA_IOIM_SM_FREE:
1866 break;
1867
1868 case BFA_IOIM_SM_ABORT:
1869 /*
1870 * IO is already being aborted implicitly
1871 */
1872 ioim->io_cbfn = __bfa_cb_ioim_abort;
1873 break;
1874
1875 case BFA_IOIM_SM_ABORT_DONE:
1876 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1877 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1878 bfa_ioim_notify_cleanup(ioim);
1879 break;
1880
1881 case BFA_IOIM_SM_ABORT_COMP:
1882 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1883 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1884 bfa_ioim_notify_cleanup(ioim);
1885 break;
1886
1887 case BFA_IOIM_SM_COMP_UTAG:
1888 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1889 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1890 bfa_ioim_notify_cleanup(ioim);
1891 break;
1892
1893 case BFA_IOIM_SM_HWFAIL:
1894 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1895 bfa_ioim_move_to_comp_q(ioim);
1896 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1897 ioim);
1898 break;
1899
1900 case BFA_IOIM_SM_CLEANUP:
1901 /*
1902 * IO can be in cleanup state already due to TM command.
1903 * 2nd cleanup request comes from ITN offline event.
1904 */
1905 break;
1906
1907 default:
1908 bfa_sm_fault(ioim->bfa, event);
1909 }
1910 }
1911
1912 /*
1913 * IO is waiting for room in request CQ
1914 */
1915 static void
1916 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1917 {
1918 bfa_trc(ioim->bfa, ioim->iotag);
1919 bfa_trc(ioim->bfa, event);
1920
1921 switch (event) {
1922 case BFA_IOIM_SM_QRESUME:
1923 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1924 bfa_ioim_send_ioreq(ioim);
1925 break;
1926
1927 case BFA_IOIM_SM_ABORT:
1928 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1929 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1930 bfa_ioim_move_to_comp_q(ioim);
1931 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1932 ioim);
1933 break;
1934
1935 case BFA_IOIM_SM_CLEANUP:
1936 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1937 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1938 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1939 ioim);
1940 bfa_ioim_notify_cleanup(ioim);
1941 break;
1942
1943 case BFA_IOIM_SM_HWFAIL:
1944 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1945 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1946 bfa_ioim_move_to_comp_q(ioim);
1947 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1948 ioim);
1949 break;
1950
1951 default:
1952 bfa_sm_fault(ioim->bfa, event);
1953 }
1954 }
1955
1956 /*
1957 * Active IO is being aborted, waiting for room in request CQ.
1958 */
1959 static void
1960 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1961 {
1962 bfa_trc(ioim->bfa, ioim->iotag);
1963 bfa_trc(ioim->bfa, event);
1964
1965 switch (event) {
1966 case BFA_IOIM_SM_QRESUME:
1967 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1968 bfa_ioim_send_abort(ioim);
1969 break;
1970
1971 case BFA_IOIM_SM_CLEANUP:
1972 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1973 ioim->iosp->abort_explicit = BFA_FALSE;
1974 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1975 break;
1976
1977 case BFA_IOIM_SM_COMP_GOOD:
1978 case BFA_IOIM_SM_COMP:
1979 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1980 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1981 bfa_ioim_move_to_comp_q(ioim);
1982 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1983 ioim);
1984 break;
1985
1986 case BFA_IOIM_SM_DONE:
1987 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1988 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1989 bfa_ioim_move_to_comp_q(ioim);
1990 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1991 ioim);
1992 break;
1993
1994 case BFA_IOIM_SM_HWFAIL:
1995 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1996 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1997 bfa_ioim_move_to_comp_q(ioim);
1998 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1999 ioim);
2000 break;
2001
2002 default:
2003 bfa_sm_fault(ioim->bfa, event);
2004 }
2005 }
2006
2007 /*
2008 * Active IO is being cleaned up, waiting for room in request CQ.
2009 */
2010 static void
2011 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2012 {
2013 bfa_trc(ioim->bfa, ioim->iotag);
2014 bfa_trc(ioim->bfa, event);
2015
2016 switch (event) {
2017 case BFA_IOIM_SM_QRESUME:
2018 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
2019 bfa_ioim_send_abort(ioim);
2020 break;
2021
2022 case BFA_IOIM_SM_ABORT:
2023 /*
2024 * IO is already being cleaned up implicitly
2025 */
2026 ioim->io_cbfn = __bfa_cb_ioim_abort;
2027 break;
2028
2029 case BFA_IOIM_SM_COMP_GOOD:
2030 case BFA_IOIM_SM_COMP:
2031 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2032 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
2033 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
2034 bfa_ioim_notify_cleanup(ioim);
2035 break;
2036
2037 case BFA_IOIM_SM_DONE:
2038 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
2039 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
2040 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
2041 bfa_ioim_notify_cleanup(ioim);
2042 break;
2043
2044 case BFA_IOIM_SM_HWFAIL:
2045 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2046 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
2047 bfa_ioim_move_to_comp_q(ioim);
2048 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
2049 ioim);
2050 break;
2051
2052 default:
2053 bfa_sm_fault(ioim->bfa, event);
2054 }
2055 }
2056
2057 /*
2058 * IO bfa callback is pending.
2059 */
2060 static void
2061 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2062 {
2063 switch (event) {
2064 case BFA_IOIM_SM_HCB:
2065 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2066 bfa_ioim_free(ioim);
2067 break;
2068
2069 case BFA_IOIM_SM_CLEANUP:
2070 bfa_ioim_notify_cleanup(ioim);
2071 break;
2072
2073 case BFA_IOIM_SM_HWFAIL:
2074 break;
2075
2076 default:
2077 bfa_sm_fault(ioim->bfa, event);
2078 }
2079 }
2080
2081 /*
2082 * IO bfa callback is pending. IO resource cannot be freed.
2083 */
2084 static void
2085 bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2086 {
2087 bfa_trc(ioim->bfa, ioim->iotag);
2088 bfa_trc(ioim->bfa, event);
2089
2090 switch (event) {
2091 case BFA_IOIM_SM_HCB:
2092 bfa_sm_set_state(ioim, bfa_ioim_sm_resfree);
2093 list_del(&ioim->qe);
2094 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_resfree_q);
2095 break;
2096
2097 case BFA_IOIM_SM_FREE:
2098 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2099 break;
2100
2101 case BFA_IOIM_SM_CLEANUP:
2102 bfa_ioim_notify_cleanup(ioim);
2103 break;
2104
2105 case BFA_IOIM_SM_HWFAIL:
2106 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2107 break;
2108
2109 default:
2110 bfa_sm_fault(ioim->bfa, event);
2111 }
2112 }
2113
2114 /*
2115 * IO is completed, waiting resource free from firmware.
2116 */
2117 static void
2118 bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2119 {
2120 bfa_trc(ioim->bfa, ioim->iotag);
2121 bfa_trc(ioim->bfa, event);
2122
2123 switch (event) {
2124 case BFA_IOIM_SM_FREE:
2125 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2126 bfa_ioim_free(ioim);
2127 break;
2128
2129 case BFA_IOIM_SM_CLEANUP:
2130 bfa_ioim_notify_cleanup(ioim);
2131 break;
2132
2133 case BFA_IOIM_SM_HWFAIL:
2134 break;
2135
2136 default:
2137 bfa_sm_fault(ioim->bfa, event);
2138 }
2139 }
2140
2141 /*
2142 * This is called from bfa_fcpim_start after the bfa_init() with flash read
2143 * is complete by driver. now invalidate the stale content of lun mask
2144 * like unit attention, rp tag and lp tag.
2145 */
2146 static void
2147 bfa_ioim_lm_init(struct bfa_s *bfa)
2148 {
2149 struct bfa_lun_mask_s *lunm_list;
2150 int i;
2151
2152 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2153 return;
2154
2155 lunm_list = bfa_get_lun_mask_list(bfa);
2156 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2157 lunm_list[i].ua = BFA_IOIM_LM_UA_RESET;
2158 lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
2159 lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
2160 }
2161 }
2162
2163 /*
2164 * Validate LUN for LUN masking
2165 */
2166 static enum bfa_ioim_lm_status
2167 bfa_ioim_lm_check(struct bfa_ioim_s *ioim, struct bfa_lps_s *lps,
2168 struct bfa_rport_s *rp, struct scsi_lun lun)
2169 {
2170 u8 i;
2171 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2172 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2173 struct scsi_cdb_s *cdb = (struct scsi_cdb_s *)cmnd->cmnd;
2174
2175 if ((cdb->scsi_cdb[0] == REPORT_LUNS) &&
2176 (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
2177 ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
2178 return BFA_IOIM_LM_PRESENT;
2179 }
2180
2181 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2182
2183 if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2184 continue;
2185
2186 if ((scsilun_to_int((struct scsi_lun *)&lun_list[i].lun) ==
2187 scsilun_to_int((struct scsi_lun *)&lun))
2188 && (rp->rport_tag == lun_list[i].rp_tag)
2189 && ((u8)ioim->itnim->rport->rport_info.lp_tag ==
2190 lun_list[i].lp_tag)) {
2191 bfa_trc(ioim->bfa, lun_list[i].rp_tag);
2192 bfa_trc(ioim->bfa, lun_list[i].lp_tag);
2193 bfa_trc(ioim->bfa, scsilun_to_int(
2194 (struct scsi_lun *)&lun_list[i].lun));
2195
2196 if ((lun_list[i].ua == BFA_IOIM_LM_UA_SET) &&
2197 ((cdb->scsi_cdb[0] != INQUIRY) ||
2198 (cdb->scsi_cdb[0] != REPORT_LUNS))) {
2199 lun_list[i].ua = BFA_IOIM_LM_UA_RESET;
2200 return BFA_IOIM_LM_RPL_DATA_CHANGED;
2201 }
2202
2203 if (cdb->scsi_cdb[0] == REPORT_LUNS)
2204 ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
2205
2206 return BFA_IOIM_LM_PRESENT;
2207 }
2208 }
2209
2210 if ((cdb->scsi_cdb[0] == INQUIRY) &&
2211 (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
2212 ioim->proc_rsp_data = bfa_ioim_lm_proc_inq_data;
2213 return BFA_IOIM_LM_PRESENT;
2214 }
2215
2216 if (cdb->scsi_cdb[0] == TEST_UNIT_READY)
2217 return BFA_IOIM_LM_LUN_NOT_RDY;
2218
2219 return BFA_IOIM_LM_LUN_NOT_SUP;
2220 }
2221
2222 static bfa_boolean_t
2223 bfa_ioim_lm_proc_rsp_data_dummy(struct bfa_ioim_s *ioim)
2224 {
2225 return BFA_TRUE;
2226 }
2227
2228 static void
2229 bfa_ioim_lm_fetch_lun(struct bfa_ioim_s *ioim, u8 *rl_data, int offset,
2230 int buf_lun_cnt)
2231 {
2232 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2233 struct scsi_lun *lun_data = (struct scsi_lun *)(rl_data + offset);
2234 struct scsi_lun lun;
2235 int i, j;
2236
2237 bfa_trc(ioim->bfa, buf_lun_cnt);
2238 for (j = 0; j < buf_lun_cnt; j++) {
2239 lun = *((struct scsi_lun *)(lun_data + j));
2240 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2241 if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2242 continue;
2243 if ((lun_list[i].rp_wwn == bfa_ioim_rp_wwn(ioim)) &&
2244 (lun_list[i].lp_wwn == bfa_ioim_lp_wwn(ioim)) &&
2245 (scsilun_to_int((struct scsi_lun *)&lun_list[i].lun)
2246 == scsilun_to_int((struct scsi_lun *)&lun))) {
2247 lun_list[i].state = BFA_IOIM_LUN_MASK_FETCHED;
2248 break;
2249 }
2250 } /* next lun in mask DB */
2251 } /* next lun in buf */
2252 }
2253
2254 static int
2255 bfa_ioim_lm_update_lun_sg(struct bfa_ioim_s *ioim, u32 *pgdlen,
2256 struct scsi_report_luns_data_s *rl)
2257 {
2258 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2259 struct scatterlist *sg = scsi_sglist(cmnd);
2260 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2261 struct scsi_lun *prev_rl_data = NULL, *base_rl_data;
2262 int i, j, sgeid, lun_fetched_cnt = 0, prev_sg_len = 0, base_count;
2263 int lun_across_sg_bytes, bytes_from_next_buf;
2264 u64 last_lun, temp_last_lun;
2265
2266 /* fetch luns from the first sg element */
2267 bfa_ioim_lm_fetch_lun(ioim, (u8 *)(rl->lun), 0,
2268 (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1);
2269
2270 /* fetch luns from multiple sg elements */
2271 scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), sgeid) {
2272 if (sgeid == 0) {
2273 prev_sg_len = sg_dma_len(sg);
2274 prev_rl_data = (struct scsi_lun *)
2275 phys_to_virt(sg_dma_address(sg));
2276 continue;
2277 }
2278
2279 /* if the buf is having more data */
2280 lun_across_sg_bytes = prev_sg_len % sizeof(struct scsi_lun);
2281 if (lun_across_sg_bytes) {
2282 bfa_trc(ioim->bfa, lun_across_sg_bytes);
2283 bfa_stats(ioim->itnim, lm_lun_across_sg);
2284 bytes_from_next_buf = sizeof(struct scsi_lun) -
2285 lun_across_sg_bytes;
2286
2287 /* from next buf take higher bytes */
2288 temp_last_lun = *((u64 *)
2289 phys_to_virt(sg_dma_address(sg)));
2290 last_lun |= temp_last_lun >>
2291 (lun_across_sg_bytes * BITS_PER_BYTE);
2292
2293 /* from prev buf take higher bytes */
2294 temp_last_lun = *((u64 *)(prev_rl_data +
2295 (prev_sg_len - lun_across_sg_bytes)));
2296 temp_last_lun >>= bytes_from_next_buf * BITS_PER_BYTE;
2297 last_lun = last_lun | (temp_last_lun <<
2298 (bytes_from_next_buf * BITS_PER_BYTE));
2299
2300 bfa_ioim_lm_fetch_lun(ioim, (u8 *)&last_lun, 0, 1);
2301 } else
2302 bytes_from_next_buf = 0;
2303
2304 *pgdlen += sg_dma_len(sg);
2305 prev_sg_len = sg_dma_len(sg);
2306 prev_rl_data = (struct scsi_lun *)
2307 phys_to_virt(sg_dma_address(sg));
2308 bfa_ioim_lm_fetch_lun(ioim, (u8 *)prev_rl_data,
2309 bytes_from_next_buf,
2310 sg_dma_len(sg) / sizeof(struct scsi_lun));
2311 }
2312
2313 /* update the report luns data - based on fetched luns */
2314 sg = scsi_sglist(cmnd);
2315 base_rl_data = (struct scsi_lun *)rl->lun;
2316 base_count = (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1;
2317 for (i = 0, j = 0; i < MAX_LUN_MASK_CFG; i++) {
2318 if (lun_list[i].state == BFA_IOIM_LUN_MASK_FETCHED) {
2319 base_rl_data[j] = lun_list[i].lun;
2320 lun_list[i].state = BFA_IOIM_LUN_MASK_ACTIVE;
2321 j++;
2322 lun_fetched_cnt++;
2323 }
2324
2325 if (j > base_count) {
2326 j = 0;
2327 sg = sg_next(sg);
2328 base_rl_data = (struct scsi_lun *)
2329 phys_to_virt(sg_dma_address(sg));
2330 base_count = sg_dma_len(sg) / sizeof(struct scsi_lun);
2331 }
2332 }
2333
2334 bfa_trc(ioim->bfa, lun_fetched_cnt);
2335 return lun_fetched_cnt;
2336 }
2337
2338 static bfa_boolean_t
2339 bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim)
2340 {
2341 struct scsi_inquiry_data_s *inq;
2342 struct scatterlist *sg = scsi_sglist((struct scsi_cmnd *)ioim->dio);
2343
2344 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2345 inq = (struct scsi_inquiry_data_s *)phys_to_virt(sg_dma_address(sg));
2346
2347 bfa_trc(ioim->bfa, inq->device_type);
2348 inq->peripheral_qual = SCSI_INQ_PQ_NOT_CON;
2349 return 0;
2350 }
2351
2352 static bfa_boolean_t
2353 bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim)
2354 {
2355 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2356 struct scatterlist *sg = scsi_sglist(cmnd);
2357 struct bfi_ioim_rsp_s *m;
2358 struct scsi_report_luns_data_s *rl = NULL;
2359 int lun_count = 0, lun_fetched_cnt = 0;
2360 u32 residue, pgdlen = 0;
2361
2362 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2363 if (bfa_get_lun_mask_status(ioim->bfa) != BFA_LUNMASK_ENABLED)
2364 return BFA_TRUE;
2365
2366 m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
2367 if (m->scsi_status == SCSI_STATUS_CHECK_CONDITION)
2368 return BFA_TRUE;
2369
2370 pgdlen = sg_dma_len(sg);
2371 bfa_trc(ioim->bfa, pgdlen);
2372 rl = (struct scsi_report_luns_data_s *)phys_to_virt(sg_dma_address(sg));
2373 lun_count = cpu_to_be32(rl->lun_list_length) / sizeof(struct scsi_lun);
2374 lun_fetched_cnt = bfa_ioim_lm_update_lun_sg(ioim, &pgdlen, rl);
2375
2376 if (lun_count == lun_fetched_cnt)
2377 return BFA_TRUE;
2378
2379 bfa_trc(ioim->bfa, lun_count);
2380 bfa_trc(ioim->bfa, lun_fetched_cnt);
2381 bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
2382
2383 if (be32_to_cpu(rl->lun_list_length) <= pgdlen)
2384 rl->lun_list_length = be32_to_cpu(lun_fetched_cnt) *
2385 sizeof(struct scsi_lun);
2386 else
2387 bfa_stats(ioim->itnim, lm_small_buf_addresidue);
2388
2389 bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
2390 bfa_trc(ioim->bfa, be32_to_cpu(m->residue));
2391
2392 residue = be32_to_cpu(m->residue);
2393 residue += (lun_count - lun_fetched_cnt) * sizeof(struct scsi_lun);
2394 bfa_stats(ioim->itnim, lm_wire_residue_changed);
2395 m->residue = be32_to_cpu(residue);
2396 bfa_trc(ioim->bfa, ioim->nsges);
2397 return BFA_FALSE;
2398 }
2399
2400 static void
2401 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
2402 {
2403 struct bfa_ioim_s *ioim = cbarg;
2404
2405 if (!complete) {
2406 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2407 return;
2408 }
2409
2410 bfa_cb_ioim_good_comp(ioim->bfa->bfad, ioim->dio);
2411 }
2412
2413 static void
2414 __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
2415 {
2416 struct bfa_ioim_s *ioim = cbarg;
2417 struct bfi_ioim_rsp_s *m;
2418 u8 *snsinfo = NULL;
2419 u8 sns_len = 0;
2420 s32 residue = 0;
2421
2422 if (!complete) {
2423 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2424 return;
2425 }
2426
2427 m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
2428 if (m->io_status == BFI_IOIM_STS_OK) {
2429 /*
2430 * setup sense information, if present
2431 */
2432 if ((m->scsi_status == SCSI_STATUS_CHECK_CONDITION) &&
2433 m->sns_len) {
2434 sns_len = m->sns_len;
2435 snsinfo = BFA_SNSINFO_FROM_TAG(ioim->fcpim->fcp,
2436 ioim->iotag);
2437 }
2438
2439 /*
2440 * setup residue value correctly for normal completions
2441 */
2442 if (m->resid_flags == FCP_RESID_UNDER) {
2443 residue = be32_to_cpu(m->residue);
2444 bfa_stats(ioim->itnim, iocomp_underrun);
2445 }
2446 if (m->resid_flags == FCP_RESID_OVER) {
2447 residue = be32_to_cpu(m->residue);
2448 residue = -residue;
2449 bfa_stats(ioim->itnim, iocomp_overrun);
2450 }
2451 }
2452
2453 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, m->io_status,
2454 m->scsi_status, sns_len, snsinfo, residue);
2455 }
2456
2457 static void
2458 __bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete)
2459 {
2460 struct bfa_ioim_s *ioim = cbarg;
2461 int sns_len = 0xD;
2462 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2463 struct scsi_sense_s *snsinfo;
2464
2465 if (!complete) {
2466 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2467 return;
2468 }
2469
2470 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
2471 ioim->fcpim->fcp, ioim->iotag);
2472 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2473 snsinfo->add_sense_length = 0xa;
2474 snsinfo->asc = SCSI_ASC_LUN_NOT_SUPPORTED;
2475 snsinfo->sense_key = ILLEGAL_REQUEST;
2476 bfa_trc(ioim->bfa, residue);
2477 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2478 SCSI_STATUS_CHECK_CONDITION, sns_len,
2479 (u8 *)snsinfo, residue);
2480 }
2481
2482 static void
2483 __bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete)
2484 {
2485 struct bfa_ioim_s *ioim = cbarg;
2486 int sns_len = 0xD;
2487 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2488 struct scsi_sense_s *snsinfo;
2489
2490 if (!complete) {
2491 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2492 return;
2493 }
2494
2495 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(ioim->fcpim->fcp,
2496 ioim->iotag);
2497 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2498 snsinfo->sense_key = SCSI_MP_IEC_UNIT_ATTN;
2499 snsinfo->asc = SCSI_ASC_TOCC;
2500 snsinfo->add_sense_length = 0x6;
2501 snsinfo->ascq = SCSI_ASCQ_RL_DATA_CHANGED;
2502 bfa_trc(ioim->bfa, residue);
2503 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2504 SCSI_STATUS_CHECK_CONDITION, sns_len,
2505 (u8 *)snsinfo, residue);
2506 }
2507
2508 static void
2509 __bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete)
2510 {
2511 struct bfa_ioim_s *ioim = cbarg;
2512 int sns_len = 0xD;
2513 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2514 struct scsi_sense_s *snsinfo;
2515
2516 if (!complete) {
2517 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2518 return;
2519 }
2520
2521 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
2522 ioim->fcpim->fcp, ioim->iotag);
2523 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2524 snsinfo->add_sense_length = 0xa;
2525 snsinfo->sense_key = NOT_READY;
2526 snsinfo->asc = SCSI_ASC_LUN_NOT_READY;
2527 snsinfo->ascq = SCSI_ASCQ_MAN_INTR_REQ;
2528 bfa_trc(ioim->bfa, residue);
2529 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2530 SCSI_STATUS_CHECK_CONDITION, sns_len,
2531 (u8 *)snsinfo, residue);
2532 }
2533
2534 void
2535 bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn, wwn_t rp_wwn,
2536 u16 rp_tag, u8 lp_tag)
2537 {
2538 struct bfa_lun_mask_s *lun_list;
2539 u8 i;
2540
2541 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2542 return;
2543
2544 lun_list = bfa_get_lun_mask_list(bfa);
2545 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2546 if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
2547 if ((lun_list[i].lp_wwn == lp_wwn) &&
2548 (lun_list[i].rp_wwn == rp_wwn)) {
2549 lun_list[i].rp_tag = rp_tag;
2550 lun_list[i].lp_tag = lp_tag;
2551 }
2552 }
2553 }
2554 }
2555
2556 /*
2557 * set UA for all active luns in LM DB
2558 */
2559 static void
2560 bfa_ioim_lm_set_ua(struct bfa_s *bfa)
2561 {
2562 struct bfa_lun_mask_s *lunm_list;
2563 int i;
2564
2565 lunm_list = bfa_get_lun_mask_list(bfa);
2566 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2567 if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2568 continue;
2569 lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2570 }
2571 }
2572
2573 bfa_status_t
2574 bfa_fcpim_lunmask_update(struct bfa_s *bfa, u32 update)
2575 {
2576 struct bfa_lunmask_cfg_s *lun_mask;
2577
2578 bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2579 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2580 return BFA_STATUS_FAILED;
2581
2582 if (bfa_get_lun_mask_status(bfa) == update)
2583 return BFA_STATUS_NO_CHANGE;
2584
2585 lun_mask = bfa_get_lun_mask(bfa);
2586 lun_mask->status = update;
2587
2588 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED)
2589 bfa_ioim_lm_set_ua(bfa);
2590
2591 return bfa_dconf_update(bfa);
2592 }
2593
2594 bfa_status_t
2595 bfa_fcpim_lunmask_clear(struct bfa_s *bfa)
2596 {
2597 int i;
2598 struct bfa_lun_mask_s *lunm_list;
2599
2600 bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2601 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2602 return BFA_STATUS_FAILED;
2603
2604 lunm_list = bfa_get_lun_mask_list(bfa);
2605 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2606 if (lunm_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
2607 if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID)
2608 bfa_rport_unset_lunmask(bfa,
2609 BFA_RPORT_FROM_TAG(bfa, lunm_list[i].rp_tag));
2610 }
2611 }
2612
2613 memset(lunm_list, 0, sizeof(struct bfa_lun_mask_s) * MAX_LUN_MASK_CFG);
2614 return bfa_dconf_update(bfa);
2615 }
2616
2617 bfa_status_t
2618 bfa_fcpim_lunmask_query(struct bfa_s *bfa, void *buf)
2619 {
2620 struct bfa_lunmask_cfg_s *lun_mask;
2621
2622 bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2623 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2624 return BFA_STATUS_FAILED;
2625
2626 lun_mask = bfa_get_lun_mask(bfa);
2627 memcpy(buf, lun_mask, sizeof(struct bfa_lunmask_cfg_s));
2628 return BFA_STATUS_OK;
2629 }
2630
2631 bfa_status_t
2632 bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2633 wwn_t rpwwn, struct scsi_lun lun)
2634 {
2635 struct bfa_lun_mask_s *lunm_list;
2636 struct bfa_rport_s *rp = NULL;
2637 int i, free_index = MAX_LUN_MASK_CFG + 1;
2638 struct bfa_fcs_lport_s *port = NULL;
2639 struct bfa_fcs_rport_s *rp_fcs;
2640
2641 bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2642 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2643 return BFA_STATUS_FAILED;
2644
2645 port = bfa_fcs_lookup_port(&((struct bfad_s *)bfa->bfad)->bfa_fcs,
2646 vf_id, *pwwn);
2647 if (port) {
2648 *pwwn = port->port_cfg.pwwn;
2649 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
2650 rp = rp_fcs->bfa_rport;
2651 }
2652
2653 lunm_list = bfa_get_lun_mask_list(bfa);
2654 /* if entry exists */
2655 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2656 if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2657 free_index = i;
2658 if ((lunm_list[i].lp_wwn == *pwwn) &&
2659 (lunm_list[i].rp_wwn == rpwwn) &&
2660 (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
2661 scsilun_to_int((struct scsi_lun *)&lun)))
2662 return BFA_STATUS_ENTRY_EXISTS;
2663 }
2664
2665 if (free_index > MAX_LUN_MASK_CFG)
2666 return BFA_STATUS_MAX_ENTRY_REACHED;
2667
2668 if (rp) {
2669 lunm_list[free_index].lp_tag = bfa_lps_get_tag_from_pid(bfa,
2670 rp->rport_info.local_pid);
2671 lunm_list[free_index].rp_tag = rp->rport_tag;
2672 } else {
2673 lunm_list[free_index].lp_tag = BFA_LP_TAG_INVALID;
2674 lunm_list[free_index].rp_tag = BFA_RPORT_TAG_INVALID;
2675 }
2676
2677 lunm_list[free_index].lp_wwn = *pwwn;
2678 lunm_list[free_index].rp_wwn = rpwwn;
2679 lunm_list[free_index].lun = lun;
2680 lunm_list[free_index].state = BFA_IOIM_LUN_MASK_ACTIVE;
2681
2682 /* set for all luns in this rp */
2683 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2684 if ((lunm_list[i].lp_wwn == *pwwn) &&
2685 (lunm_list[i].rp_wwn == rpwwn))
2686 lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2687 }
2688
2689 return bfa_dconf_update(bfa);
2690 }
2691
2692 bfa_status_t
2693 bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2694 wwn_t rpwwn, struct scsi_lun lun)
2695 {
2696 struct bfa_lun_mask_s *lunm_list;
2697 struct bfa_rport_s *rp = NULL;
2698 struct bfa_fcs_lport_s *port = NULL;
2699 struct bfa_fcs_rport_s *rp_fcs;
2700 int i;
2701
2702 /* in min cfg lunm_list could be NULL but no commands should run. */
2703 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2704 return BFA_STATUS_FAILED;
2705
2706 bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2707 bfa_trc(bfa, *pwwn);
2708 bfa_trc(bfa, rpwwn);
2709 bfa_trc(bfa, scsilun_to_int((struct scsi_lun *)&lun));
2710
2711 if (*pwwn == 0) {
2712 port = bfa_fcs_lookup_port(
2713 &((struct bfad_s *)bfa->bfad)->bfa_fcs,
2714 vf_id, *pwwn);
2715 if (port) {
2716 *pwwn = port->port_cfg.pwwn;
2717 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
2718 rp = rp_fcs->bfa_rport;
2719 }
2720 }
2721
2722 lunm_list = bfa_get_lun_mask_list(bfa);
2723 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2724 if ((lunm_list[i].lp_wwn == *pwwn) &&
2725 (lunm_list[i].rp_wwn == rpwwn) &&
2726 (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
2727 scsilun_to_int((struct scsi_lun *)&lun))) {
2728 lunm_list[i].lp_wwn = 0;
2729 lunm_list[i].rp_wwn = 0;
2730 int_to_scsilun(0, &lunm_list[i].lun);
2731 lunm_list[i].state = BFA_IOIM_LUN_MASK_INACTIVE;
2732 if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID) {
2733 lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
2734 lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
2735 }
2736 return bfa_dconf_update(bfa);
2737 }
2738 }
2739
2740 /* set for all luns in this rp */
2741 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2742 if ((lunm_list[i].lp_wwn == *pwwn) &&
2743 (lunm_list[i].rp_wwn == rpwwn))
2744 lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2745 }
2746
2747 return BFA_STATUS_ENTRY_NOT_EXISTS;
2748 }
2749
2750 static void
2751 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
2752 {
2753 struct bfa_ioim_s *ioim = cbarg;
2754
2755 if (!complete) {
2756 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2757 return;
2758 }
2759
2760 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2761 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
2762 0, 0, NULL, 0);
2763 }
2764
2765 static void
2766 __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
2767 {
2768 struct bfa_ioim_s *ioim = cbarg;
2769
2770 bfa_stats(ioim->itnim, path_tov_expired);
2771 if (!complete) {
2772 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2773 return;
2774 }
2775
2776 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2777 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
2778 0, 0, NULL, 0);
2779 }
2780
2781 static void
2782 __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
2783 {
2784 struct bfa_ioim_s *ioim = cbarg;
2785
2786 if (!complete) {
2787 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2788 return;
2789 }
2790
2791 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2792 bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
2793 }
2794
2795 static void
2796 bfa_ioim_sgpg_alloced(void *cbarg)
2797 {
2798 struct bfa_ioim_s *ioim = cbarg;
2799
2800 ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2801 list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
2802 ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2803 bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
2804 }
2805
2806 /*
2807 * Send I/O request to firmware.
2808 */
2809 static bfa_boolean_t
2810 bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
2811 {
2812 struct bfa_itnim_s *itnim = ioim->itnim;
2813 struct bfi_ioim_req_s *m;
2814 static struct fcp_cmnd_s cmnd_z0 = { { { 0 } } };
2815 struct bfi_sge_s *sge, *sgpge;
2816 u32 pgdlen = 0;
2817 u32 fcp_dl;
2818 u64 addr;
2819 struct scatterlist *sg;
2820 struct bfa_sgpg_s *sgpg;
2821 struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
2822 u32 i, sge_id, pgcumsz;
2823 enum dma_data_direction dmadir;
2824
2825 /*
2826 * check for room in queue to send request now
2827 */
2828 m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2829 if (!m) {
2830 bfa_stats(ioim->itnim, qwait);
2831 bfa_reqq_wait(ioim->bfa, ioim->reqq,
2832 &ioim->iosp->reqq_wait);
2833 return BFA_FALSE;
2834 }
2835
2836 /*
2837 * build i/o request message next
2838 */
2839 m->io_tag = cpu_to_be16(ioim->iotag);
2840 m->rport_hdl = ioim->itnim->rport->fw_handle;
2841 m->io_timeout = 0;
2842
2843 sge = &m->sges[0];
2844 sgpg = ioim->sgpg;
2845 sge_id = 0;
2846 sgpge = NULL;
2847 pgcumsz = 0;
2848 scsi_for_each_sg(cmnd, sg, ioim->nsges, i) {
2849 if (i == 0) {
2850 /* build inline IO SG element */
2851 addr = bfa_sgaddr_le(sg_dma_address(sg));
2852 sge->sga = *(union bfi_addr_u *) &addr;
2853 pgdlen = sg_dma_len(sg);
2854 sge->sg_len = pgdlen;
2855 sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
2856 BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
2857 bfa_sge_to_be(sge);
2858 sge++;
2859 } else {
2860 if (sge_id == 0)
2861 sgpge = sgpg->sgpg->sges;
2862
2863 addr = bfa_sgaddr_le(sg_dma_address(sg));
2864 sgpge->sga = *(union bfi_addr_u *) &addr;
2865 sgpge->sg_len = sg_dma_len(sg);
2866 pgcumsz += sgpge->sg_len;
2867
2868 /* set flags */
2869 if (i < (ioim->nsges - 1) &&
2870 sge_id < (BFI_SGPG_DATA_SGES - 1))
2871 sgpge->flags = BFI_SGE_DATA;
2872 else if (i < (ioim->nsges - 1))
2873 sgpge->flags = BFI_SGE_DATA_CPL;
2874 else
2875 sgpge->flags = BFI_SGE_DATA_LAST;
2876
2877 bfa_sge_to_le(sgpge);
2878
2879 sgpge++;
2880 if (i == (ioim->nsges - 1)) {
2881 sgpge->flags = BFI_SGE_PGDLEN;
2882 sgpge->sga.a32.addr_lo = 0;
2883 sgpge->sga.a32.addr_hi = 0;
2884 sgpge->sg_len = pgcumsz;
2885 bfa_sge_to_le(sgpge);
2886 } else if (++sge_id == BFI_SGPG_DATA_SGES) {
2887 sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
2888 sgpge->flags = BFI_SGE_LINK;
2889 sgpge->sga = sgpg->sgpg_pa;
2890 sgpge->sg_len = pgcumsz;
2891 bfa_sge_to_le(sgpge);
2892 sge_id = 0;
2893 pgcumsz = 0;
2894 }
2895 }
2896 }
2897
2898 if (ioim->nsges > BFI_SGE_INLINE) {
2899 sge->sga = ioim->sgpg->sgpg_pa;
2900 } else {
2901 sge->sga.a32.addr_lo = 0;
2902 sge->sga.a32.addr_hi = 0;
2903 }
2904 sge->sg_len = pgdlen;
2905 sge->flags = BFI_SGE_PGDLEN;
2906 bfa_sge_to_be(sge);
2907
2908 /*
2909 * set up I/O command parameters
2910 */
2911 m->cmnd = cmnd_z0;
2912 int_to_scsilun(cmnd->device->lun, &m->cmnd.lun);
2913 dmadir = cmnd->sc_data_direction;
2914 if (dmadir == DMA_TO_DEVICE)
2915 m->cmnd.iodir = FCP_IODIR_WRITE;
2916 else if (dmadir == DMA_FROM_DEVICE)
2917 m->cmnd.iodir = FCP_IODIR_READ;
2918 else
2919 m->cmnd.iodir = FCP_IODIR_NONE;
2920
2921 m->cmnd.cdb = *(struct scsi_cdb_s *) cmnd->cmnd;
2922 fcp_dl = scsi_bufflen(cmnd);
2923 m->cmnd.fcp_dl = cpu_to_be32(fcp_dl);
2924
2925 /*
2926 * set up I/O message header
2927 */
2928 switch (m->cmnd.iodir) {
2929 case FCP_IODIR_READ:
2930 bfi_h2i_set(m->mh, BFI_MC_IOIM_READ, 0, bfa_fn_lpu(ioim->bfa));
2931 bfa_stats(itnim, input_reqs);
2932 ioim->itnim->stats.rd_throughput += fcp_dl;
2933 break;
2934 case FCP_IODIR_WRITE:
2935 bfi_h2i_set(m->mh, BFI_MC_IOIM_WRITE, 0, bfa_fn_lpu(ioim->bfa));
2936 bfa_stats(itnim, output_reqs);
2937 ioim->itnim->stats.wr_throughput += fcp_dl;
2938 break;
2939 case FCP_IODIR_RW:
2940 bfa_stats(itnim, input_reqs);
2941 bfa_stats(itnim, output_reqs);
2942 default:
2943 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_fn_lpu(ioim->bfa));
2944 }
2945 if (itnim->seq_rec ||
2946 (scsi_bufflen(cmnd) & (sizeof(u32) - 1)))
2947 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_fn_lpu(ioim->bfa));
2948
2949 /*
2950 * queue I/O message to firmware
2951 */
2952 bfa_reqq_produce(ioim->bfa, ioim->reqq, m->mh);
2953 return BFA_TRUE;
2954 }
2955
2956 /*
2957 * Setup any additional SG pages needed.Inline SG element is setup
2958 * at queuing time.
2959 */
2960 static bfa_boolean_t
2961 bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim)
2962 {
2963 u16 nsgpgs;
2964
2965 WARN_ON(ioim->nsges <= BFI_SGE_INLINE);
2966
2967 /*
2968 * allocate SG pages needed
2969 */
2970 nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2971 if (!nsgpgs)
2972 return BFA_TRUE;
2973
2974 if (bfa_sgpg_malloc(ioim->bfa, &ioim->sgpg_q, nsgpgs)
2975 != BFA_STATUS_OK) {
2976 bfa_sgpg_wait(ioim->bfa, &ioim->iosp->sgpg_wqe, nsgpgs);
2977 return BFA_FALSE;
2978 }
2979
2980 ioim->nsgpgs = nsgpgs;
2981 ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2982
2983 return BFA_TRUE;
2984 }
2985
2986 /*
2987 * Send I/O abort request to firmware.
2988 */
2989 static bfa_boolean_t
2990 bfa_ioim_send_abort(struct bfa_ioim_s *ioim)
2991 {
2992 struct bfi_ioim_abort_req_s *m;
2993 enum bfi_ioim_h2i msgop;
2994
2995 /*
2996 * check for room in queue to send request now
2997 */
2998 m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2999 if (!m)
3000 return BFA_FALSE;
3001
3002 /*
3003 * build i/o request message next
3004 */
3005 if (ioim->iosp->abort_explicit)
3006 msgop = BFI_IOIM_H2I_IOABORT_REQ;
3007 else
3008 msgop = BFI_IOIM_H2I_IOCLEANUP_REQ;
3009
3010 bfi_h2i_set(m->mh, BFI_MC_IOIM, msgop, bfa_fn_lpu(ioim->bfa));
3011 m->io_tag = cpu_to_be16(ioim->iotag);
3012 m->abort_tag = ++ioim->abort_tag;
3013
3014 /*
3015 * queue I/O message to firmware
3016 */
3017 bfa_reqq_produce(ioim->bfa, ioim->reqq, m->mh);
3018 return BFA_TRUE;
3019 }
3020
3021 /*
3022 * Call to resume any I/O requests waiting for room in request queue.
3023 */
3024 static void
3025 bfa_ioim_qresume(void *cbarg)
3026 {
3027 struct bfa_ioim_s *ioim = cbarg;
3028
3029 bfa_stats(ioim->itnim, qresumes);
3030 bfa_sm_send_event(ioim, BFA_IOIM_SM_QRESUME);
3031 }
3032
3033
3034 static void
3035 bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
3036 {
3037 /*
3038 * Move IO from itnim queue to fcpim global queue since itnim will be
3039 * freed.
3040 */
3041 list_del(&ioim->qe);
3042 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
3043
3044 if (!ioim->iosp->tskim) {
3045 if (ioim->fcpim->delay_comp && ioim->itnim->iotov_active) {
3046 bfa_cb_dequeue(&ioim->hcb_qe);
3047 list_del(&ioim->qe);
3048 list_add_tail(&ioim->qe, &ioim->itnim->delay_comp_q);
3049 }
3050 bfa_itnim_iodone(ioim->itnim);
3051 } else
3052 bfa_wc_down(&ioim->iosp->tskim->wc);
3053 }
3054
3055 static bfa_boolean_t
3056 bfa_ioim_is_abortable(struct bfa_ioim_s *ioim)
3057 {
3058 if ((bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit) &&
3059 (!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim))) ||
3060 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort)) ||
3061 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort_qfull)) ||
3062 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb)) ||
3063 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb_free)) ||
3064 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_resfree)))
3065 return BFA_FALSE;
3066
3067 return BFA_TRUE;
3068 }
3069
3070 void
3071 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
3072 {
3073 /*
3074 * If path tov timer expired, failback with PATHTOV status - these
3075 * IO requests are not normally retried by IO stack.
3076 *
3077 * Otherwise device cameback online and fail it with normal failed
3078 * status so that IO stack retries these failed IO requests.
3079 */
3080 if (iotov)
3081 ioim->io_cbfn = __bfa_cb_ioim_pathtov;
3082 else {
3083 ioim->io_cbfn = __bfa_cb_ioim_failed;
3084 bfa_stats(ioim->itnim, iocom_nexus_abort);
3085 }
3086 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
3087
3088 /*
3089 * Move IO to fcpim global queue since itnim will be
3090 * freed.
3091 */
3092 list_del(&ioim->qe);
3093 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
3094 }
3095
3096
3097 /*
3098 * Memory allocation and initialization.
3099 */
3100 void
3101 bfa_ioim_attach(struct bfa_fcpim_s *fcpim)
3102 {
3103 struct bfa_ioim_s *ioim;
3104 struct bfa_fcp_mod_s *fcp = fcpim->fcp;
3105 struct bfa_ioim_sp_s *iosp;
3106 u16 i;
3107
3108 /*
3109 * claim memory first
3110 */
3111 ioim = (struct bfa_ioim_s *) bfa_mem_kva_curp(fcp);
3112 fcpim->ioim_arr = ioim;
3113 bfa_mem_kva_curp(fcp) = (u8 *) (ioim + fcpim->fcp->num_ioim_reqs);
3114
3115 iosp = (struct bfa_ioim_sp_s *) bfa_mem_kva_curp(fcp);
3116 fcpim->ioim_sp_arr = iosp;
3117 bfa_mem_kva_curp(fcp) = (u8 *) (iosp + fcpim->fcp->num_ioim_reqs);
3118
3119 /*
3120 * Initialize ioim free queues
3121 */
3122 INIT_LIST_HEAD(&fcpim->ioim_resfree_q);
3123 INIT_LIST_HEAD(&fcpim->ioim_comp_q);
3124
3125 for (i = 0; i < fcpim->fcp->num_ioim_reqs;
3126 i++, ioim++, iosp++) {
3127 /*
3128 * initialize IOIM
3129 */
3130 memset(ioim, 0, sizeof(struct bfa_ioim_s));
3131 ioim->iotag = i;
3132 ioim->bfa = fcpim->bfa;
3133 ioim->fcpim = fcpim;
3134 ioim->iosp = iosp;
3135 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
3136 INIT_LIST_HEAD(&ioim->sgpg_q);
3137 bfa_reqq_winit(&ioim->iosp->reqq_wait,
3138 bfa_ioim_qresume, ioim);
3139 bfa_sgpg_winit(&ioim->iosp->sgpg_wqe,
3140 bfa_ioim_sgpg_alloced, ioim);
3141 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
3142 }
3143 }
3144
3145 void
3146 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3147 {
3148 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3149 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
3150 struct bfa_ioim_s *ioim;
3151 u16 iotag;
3152 enum bfa_ioim_event evt = BFA_IOIM_SM_COMP;
3153
3154 iotag = be16_to_cpu(rsp->io_tag);
3155
3156 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
3157 WARN_ON(ioim->iotag != iotag);
3158
3159 bfa_trc(ioim->bfa, ioim->iotag);
3160 bfa_trc(ioim->bfa, rsp->io_status);
3161 bfa_trc(ioim->bfa, rsp->reuse_io_tag);
3162
3163 if (bfa_sm_cmp_state(ioim, bfa_ioim_sm_active))
3164 ioim->iosp->comp_rspmsg = *m;
3165
3166 switch (rsp->io_status) {
3167 case BFI_IOIM_STS_OK:
3168 bfa_stats(ioim->itnim, iocomp_ok);
3169 if (rsp->reuse_io_tag == 0)
3170 evt = BFA_IOIM_SM_DONE;
3171 else
3172 evt = BFA_IOIM_SM_COMP;
3173 ioim->proc_rsp_data(ioim);
3174 break;
3175
3176 case BFI_IOIM_STS_TIMEDOUT:
3177 bfa_stats(ioim->itnim, iocomp_timedout);
3178 case BFI_IOIM_STS_ABORTED:
3179 rsp->io_status = BFI_IOIM_STS_ABORTED;
3180 bfa_stats(ioim->itnim, iocomp_aborted);
3181 if (rsp->reuse_io_tag == 0)
3182 evt = BFA_IOIM_SM_DONE;
3183 else
3184 evt = BFA_IOIM_SM_COMP;
3185 break;
3186
3187 case BFI_IOIM_STS_PROTO_ERR:
3188 bfa_stats(ioim->itnim, iocom_proto_err);
3189 WARN_ON(!rsp->reuse_io_tag);
3190 evt = BFA_IOIM_SM_COMP;
3191 break;
3192
3193 case BFI_IOIM_STS_SQER_NEEDED:
3194 bfa_stats(ioim->itnim, iocom_sqer_needed);
3195 WARN_ON(rsp->reuse_io_tag != 0);
3196 evt = BFA_IOIM_SM_SQRETRY;
3197 break;
3198
3199 case BFI_IOIM_STS_RES_FREE:
3200 bfa_stats(ioim->itnim, iocom_res_free);
3201 evt = BFA_IOIM_SM_FREE;
3202 break;
3203
3204 case BFI_IOIM_STS_HOST_ABORTED:
3205 bfa_stats(ioim->itnim, iocom_hostabrts);
3206 if (rsp->abort_tag != ioim->abort_tag) {
3207 bfa_trc(ioim->bfa, rsp->abort_tag);
3208 bfa_trc(ioim->bfa, ioim->abort_tag);
3209 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
3210 return;
3211 }
3212
3213 if (rsp->reuse_io_tag)
3214 evt = BFA_IOIM_SM_ABORT_COMP;
3215 else
3216 evt = BFA_IOIM_SM_ABORT_DONE;
3217 break;
3218
3219 case BFI_IOIM_STS_UTAG:
3220 bfa_stats(ioim->itnim, iocom_utags);
3221 evt = BFA_IOIM_SM_COMP_UTAG;
3222 break;
3223
3224 default:
3225 WARN_ON(1);
3226 }
3227
3228 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
3229 bfa_sm_send_event(ioim, evt);
3230 }
3231
3232 void
3233 bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3234 {
3235 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3236 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
3237 struct bfa_ioim_s *ioim;
3238 u16 iotag;
3239
3240 iotag = be16_to_cpu(rsp->io_tag);
3241
3242 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
3243 WARN_ON(BFA_IOIM_TAG_2_ID(ioim->iotag) != iotag);
3244
3245 bfa_ioim_cb_profile_comp(fcpim, ioim);
3246
3247 if (bfa_get_lun_mask_status(bfa) != BFA_LUNMASK_ENABLED) {
3248 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
3249 return;
3250 }
3251
3252 if (ioim->proc_rsp_data(ioim) == BFA_TRUE)
3253 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
3254 else
3255 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP);
3256 }
3257
3258 /*
3259 * Called by itnim to clean up IO while going offline.
3260 */
3261 void
3262 bfa_ioim_cleanup(struct bfa_ioim_s *ioim)
3263 {
3264 bfa_trc(ioim->bfa, ioim->iotag);
3265 bfa_stats(ioim->itnim, io_cleanups);
3266
3267 ioim->iosp->tskim = NULL;
3268 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
3269 }
3270
3271 void
3272 bfa_ioim_cleanup_tm(struct bfa_ioim_s *ioim, struct bfa_tskim_s *tskim)
3273 {
3274 bfa_trc(ioim->bfa, ioim->iotag);
3275 bfa_stats(ioim->itnim, io_tmaborts);
3276
3277 ioim->iosp->tskim = tskim;
3278 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
3279 }
3280
3281 /*
3282 * IOC failure handling.
3283 */
3284 void
3285 bfa_ioim_iocdisable(struct bfa_ioim_s *ioim)
3286 {
3287 bfa_trc(ioim->bfa, ioim->iotag);
3288 bfa_stats(ioim->itnim, io_iocdowns);
3289 bfa_sm_send_event(ioim, BFA_IOIM_SM_HWFAIL);
3290 }
3291
3292 /*
3293 * IO offline TOV popped. Fail the pending IO.
3294 */
3295 void
3296 bfa_ioim_tov(struct bfa_ioim_s *ioim)
3297 {
3298 bfa_trc(ioim->bfa, ioim->iotag);
3299 bfa_sm_send_event(ioim, BFA_IOIM_SM_IOTOV);
3300 }
3301
3302
3303 /*
3304 * Allocate IOIM resource for initiator mode I/O request.
3305 */
3306 struct bfa_ioim_s *
3307 bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
3308 struct bfa_itnim_s *itnim, u16 nsges)
3309 {
3310 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3311 struct bfa_ioim_s *ioim;
3312 struct bfa_iotag_s *iotag = NULL;
3313
3314 /*
3315 * alocate IOIM resource
3316 */
3317 bfa_q_deq(&fcpim->fcp->iotag_ioim_free_q, &iotag);
3318 if (!iotag) {
3319 bfa_stats(itnim, no_iotags);
3320 return NULL;
3321 }
3322
3323 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag->tag);
3324
3325 ioim->dio = dio;
3326 ioim->itnim = itnim;
3327 ioim->nsges = nsges;
3328 ioim->nsgpgs = 0;
3329
3330 bfa_stats(itnim, total_ios);
3331 fcpim->ios_active++;
3332
3333 list_add_tail(&ioim->qe, &itnim->io_q);
3334
3335 return ioim;
3336 }
3337
3338 void
3339 bfa_ioim_free(struct bfa_ioim_s *ioim)
3340 {
3341 struct bfa_fcpim_s *fcpim = ioim->fcpim;
3342 struct bfa_iotag_s *iotag;
3343
3344 if (ioim->nsgpgs > 0)
3345 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
3346
3347 bfa_stats(ioim->itnim, io_comps);
3348 fcpim->ios_active--;
3349
3350 ioim->iotag &= BFA_IOIM_IOTAG_MASK;
3351
3352 WARN_ON(!(ioim->iotag <
3353 (fcpim->fcp->num_ioim_reqs + fcpim->fcp->num_fwtio_reqs)));
3354 iotag = BFA_IOTAG_FROM_TAG(fcpim->fcp, ioim->iotag);
3355
3356 if (ioim->iotag < fcpim->fcp->num_ioim_reqs)
3357 list_add_tail(&iotag->qe, &fcpim->fcp->iotag_ioim_free_q);
3358 else
3359 list_add_tail(&iotag->qe, &fcpim->fcp->iotag_tio_free_q);
3360
3361 list_del(&ioim->qe);
3362 }
3363
3364 void
3365 bfa_ioim_start(struct bfa_ioim_s *ioim)
3366 {
3367 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
3368 struct bfa_lps_s *lps;
3369 enum bfa_ioim_lm_status status;
3370 struct scsi_lun scsilun;
3371
3372 if (bfa_get_lun_mask_status(ioim->bfa) == BFA_LUNMASK_ENABLED) {
3373 lps = BFA_IOIM_TO_LPS(ioim);
3374 int_to_scsilun(cmnd->device->lun, &scsilun);
3375 status = bfa_ioim_lm_check(ioim, lps,
3376 ioim->itnim->rport, scsilun);
3377 if (status == BFA_IOIM_LM_LUN_NOT_RDY) {
3378 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_RDY);
3379 bfa_stats(ioim->itnim, lm_lun_not_rdy);
3380 return;
3381 }
3382
3383 if (status == BFA_IOIM_LM_LUN_NOT_SUP) {
3384 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_SUP);
3385 bfa_stats(ioim->itnim, lm_lun_not_sup);
3386 return;
3387 }
3388
3389 if (status == BFA_IOIM_LM_RPL_DATA_CHANGED) {
3390 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_RPL_DC);
3391 bfa_stats(ioim->itnim, lm_rpl_data_changed);
3392 return;
3393 }
3394 }
3395
3396 bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
3397
3398 /*
3399 * Obtain the queue over which this request has to be issued
3400 */
3401 ioim->reqq = bfa_fcpim_ioredirect_enabled(ioim->bfa) ?
3402 BFA_FALSE : bfa_itnim_get_reqq(ioim);
3403
3404 bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
3405 }
3406
3407 /*
3408 * Driver I/O abort request.
3409 */
3410 bfa_status_t
3411 bfa_ioim_abort(struct bfa_ioim_s *ioim)
3412 {
3413
3414 bfa_trc(ioim->bfa, ioim->iotag);
3415
3416 if (!bfa_ioim_is_abortable(ioim))
3417 return BFA_STATUS_FAILED;
3418
3419 bfa_stats(ioim->itnim, io_aborts);
3420 bfa_sm_send_event(ioim, BFA_IOIM_SM_ABORT);
3421
3422 return BFA_STATUS_OK;
3423 }
3424
3425 /*
3426 * BFA TSKIM state machine functions
3427 */
3428
3429 /*
3430 * Task management command beginning state.
3431 */
3432 static void
3433 bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3434 {
3435 bfa_trc(tskim->bfa, event);
3436
3437 switch (event) {
3438 case BFA_TSKIM_SM_START:
3439 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
3440 bfa_tskim_gather_ios(tskim);
3441
3442 /*
3443 * If device is offline, do not send TM on wire. Just cleanup
3444 * any pending IO requests and complete TM request.
3445 */
3446 if (!bfa_itnim_is_online(tskim->itnim)) {
3447 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3448 tskim->tsk_status = BFI_TSKIM_STS_OK;
3449 bfa_tskim_cleanup_ios(tskim);
3450 return;
3451 }
3452
3453 if (!bfa_tskim_send(tskim)) {
3454 bfa_sm_set_state(tskim, bfa_tskim_sm_qfull);
3455 bfa_stats(tskim->itnim, tm_qwait);
3456 bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
3457 &tskim->reqq_wait);
3458 }
3459 break;
3460
3461 default:
3462 bfa_sm_fault(tskim->bfa, event);
3463 }
3464 }
3465
3466 /*
3467 * TM command is active, awaiting completion from firmware to
3468 * cleanup IO requests in TM scope.
3469 */
3470 static void
3471 bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3472 {
3473 bfa_trc(tskim->bfa, event);
3474
3475 switch (event) {
3476 case BFA_TSKIM_SM_DONE:
3477 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3478 bfa_tskim_cleanup_ios(tskim);
3479 break;
3480
3481 case BFA_TSKIM_SM_CLEANUP:
3482 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
3483 if (!bfa_tskim_send_abort(tskim)) {
3484 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup_qfull);
3485 bfa_stats(tskim->itnim, tm_qwait);
3486 bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
3487 &tskim->reqq_wait);
3488 }
3489 break;
3490
3491 case BFA_TSKIM_SM_HWFAIL:
3492 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3493 bfa_tskim_iocdisable_ios(tskim);
3494 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3495 break;
3496
3497 default:
3498 bfa_sm_fault(tskim->bfa, event);
3499 }
3500 }
3501
3502 /*
3503 * An active TM is being cleaned up since ITN is offline. Awaiting cleanup
3504 * completion event from firmware.
3505 */
3506 static void
3507 bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3508 {
3509 bfa_trc(tskim->bfa, event);
3510
3511 switch (event) {
3512 case BFA_TSKIM_SM_DONE:
3513 /*
3514 * Ignore and wait for ABORT completion from firmware.
3515 */
3516 break;
3517
3518 case BFA_TSKIM_SM_CLEANUP_DONE:
3519 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3520 bfa_tskim_cleanup_ios(tskim);
3521 break;
3522
3523 case BFA_TSKIM_SM_HWFAIL:
3524 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3525 bfa_tskim_iocdisable_ios(tskim);
3526 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3527 break;
3528
3529 default:
3530 bfa_sm_fault(tskim->bfa, event);
3531 }
3532 }
3533
3534 static void
3535 bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3536 {
3537 bfa_trc(tskim->bfa, event);
3538
3539 switch (event) {
3540 case BFA_TSKIM_SM_IOS_DONE:
3541 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3542 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_done);
3543 break;
3544
3545 case BFA_TSKIM_SM_CLEANUP:
3546 /*
3547 * Ignore, TM command completed on wire.
3548 * Notify TM conmpletion on IO cleanup completion.
3549 */
3550 break;
3551
3552 case BFA_TSKIM_SM_HWFAIL:
3553 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3554 bfa_tskim_iocdisable_ios(tskim);
3555 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3556 break;
3557
3558 default:
3559 bfa_sm_fault(tskim->bfa, event);
3560 }
3561 }
3562
3563 /*
3564 * Task management command is waiting for room in request CQ
3565 */
3566 static void
3567 bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3568 {
3569 bfa_trc(tskim->bfa, event);
3570
3571 switch (event) {
3572 case BFA_TSKIM_SM_QRESUME:
3573 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
3574 bfa_tskim_send(tskim);
3575 break;
3576
3577 case BFA_TSKIM_SM_CLEANUP:
3578 /*
3579 * No need to send TM on wire since ITN is offline.
3580 */
3581 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3582 bfa_reqq_wcancel(&tskim->reqq_wait);
3583 bfa_tskim_cleanup_ios(tskim);
3584 break;
3585
3586 case BFA_TSKIM_SM_HWFAIL:
3587 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3588 bfa_reqq_wcancel(&tskim->reqq_wait);
3589 bfa_tskim_iocdisable_ios(tskim);
3590 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3591 break;
3592
3593 default:
3594 bfa_sm_fault(tskim->bfa, event);
3595 }
3596 }
3597
3598 /*
3599 * Task management command is active, awaiting for room in request CQ
3600 * to send clean up request.
3601 */
3602 static void
3603 bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
3604 enum bfa_tskim_event event)
3605 {
3606 bfa_trc(tskim->bfa, event);
3607
3608 switch (event) {
3609 case BFA_TSKIM_SM_DONE:
3610 bfa_reqq_wcancel(&tskim->reqq_wait);
3611 /*
3612 * Fall through !!!
3613 */
3614 case BFA_TSKIM_SM_QRESUME:
3615 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
3616 bfa_tskim_send_abort(tskim);
3617 break;
3618
3619 case BFA_TSKIM_SM_HWFAIL:
3620 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3621 bfa_reqq_wcancel(&tskim->reqq_wait);
3622 bfa_tskim_iocdisable_ios(tskim);
3623 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3624 break;
3625
3626 default:
3627 bfa_sm_fault(tskim->bfa, event);
3628 }
3629 }
3630
3631 /*
3632 * BFA callback is pending
3633 */
3634 static void
3635 bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3636 {
3637 bfa_trc(tskim->bfa, event);
3638
3639 switch (event) {
3640 case BFA_TSKIM_SM_HCB:
3641 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
3642 bfa_tskim_free(tskim);
3643 break;
3644
3645 case BFA_TSKIM_SM_CLEANUP:
3646 bfa_tskim_notify_comp(tskim);
3647 break;
3648
3649 case BFA_TSKIM_SM_HWFAIL:
3650 break;
3651
3652 default:
3653 bfa_sm_fault(tskim->bfa, event);
3654 }
3655 }
3656
3657 static void
3658 __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete)
3659 {
3660 struct bfa_tskim_s *tskim = cbarg;
3661
3662 if (!complete) {
3663 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
3664 return;
3665 }
3666
3667 bfa_stats(tskim->itnim, tm_success);
3668 bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk, tskim->tsk_status);
3669 }
3670
3671 static void
3672 __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete)
3673 {
3674 struct bfa_tskim_s *tskim = cbarg;
3675
3676 if (!complete) {
3677 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
3678 return;
3679 }
3680
3681 bfa_stats(tskim->itnim, tm_failures);
3682 bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk,
3683 BFI_TSKIM_STS_FAILED);
3684 }
3685
3686 static bfa_boolean_t
3687 bfa_tskim_match_scope(struct bfa_tskim_s *tskim, struct scsi_lun lun)
3688 {
3689 switch (tskim->tm_cmnd) {
3690 case FCP_TM_TARGET_RESET:
3691 return BFA_TRUE;
3692
3693 case FCP_TM_ABORT_TASK_SET:
3694 case FCP_TM_CLEAR_TASK_SET:
3695 case FCP_TM_LUN_RESET:
3696 case FCP_TM_CLEAR_ACA:
3697 return !memcmp(&tskim->lun, &lun, sizeof(lun));
3698
3699 default:
3700 WARN_ON(1);
3701 }
3702
3703 return BFA_FALSE;
3704 }
3705
3706 /*
3707 * Gather affected IO requests and task management commands.
3708 */
3709 static void
3710 bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
3711 {
3712 struct bfa_itnim_s *itnim = tskim->itnim;
3713 struct bfa_ioim_s *ioim;
3714 struct list_head *qe, *qen;
3715 struct scsi_cmnd *cmnd;
3716 struct scsi_lun scsilun;
3717
3718 INIT_LIST_HEAD(&tskim->io_q);
3719
3720 /*
3721 * Gather any active IO requests first.
3722 */
3723 list_for_each_safe(qe, qen, &itnim->io_q) {
3724 ioim = (struct bfa_ioim_s *) qe;
3725 cmnd = (struct scsi_cmnd *) ioim->dio;
3726 int_to_scsilun(cmnd->device->lun, &scsilun);
3727 if (bfa_tskim_match_scope(tskim, scsilun)) {
3728 list_del(&ioim->qe);
3729 list_add_tail(&ioim->qe, &tskim->io_q);
3730 }
3731 }
3732
3733 /*
3734 * Failback any pending IO requests immediately.
3735 */
3736 list_for_each_safe(qe, qen, &itnim->pending_q) {
3737 ioim = (struct bfa_ioim_s *) qe;
3738 cmnd = (struct scsi_cmnd *) ioim->dio;
3739 int_to_scsilun(cmnd->device->lun, &scsilun);
3740 if (bfa_tskim_match_scope(tskim, scsilun)) {
3741 list_del(&ioim->qe);
3742 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
3743 bfa_ioim_tov(ioim);
3744 }
3745 }
3746 }
3747
3748 /*
3749 * IO cleanup completion
3750 */
3751 static void
3752 bfa_tskim_cleanp_comp(void *tskim_cbarg)
3753 {
3754 struct bfa_tskim_s *tskim = tskim_cbarg;
3755
3756 bfa_stats(tskim->itnim, tm_io_comps);
3757 bfa_sm_send_event(tskim, BFA_TSKIM_SM_IOS_DONE);
3758 }
3759
3760 /*
3761 * Gather affected IO requests and task management commands.
3762 */
3763 static void
3764 bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim)
3765 {
3766 struct bfa_ioim_s *ioim;
3767 struct list_head *qe, *qen;
3768
3769 bfa_wc_init(&tskim->wc, bfa_tskim_cleanp_comp, tskim);
3770
3771 list_for_each_safe(qe, qen, &tskim->io_q) {
3772 ioim = (struct bfa_ioim_s *) qe;
3773 bfa_wc_up(&tskim->wc);
3774 bfa_ioim_cleanup_tm(ioim, tskim);
3775 }
3776
3777 bfa_wc_wait(&tskim->wc);
3778 }
3779
3780 /*
3781 * Send task management request to firmware.
3782 */
3783 static bfa_boolean_t
3784 bfa_tskim_send(struct bfa_tskim_s *tskim)
3785 {
3786 struct bfa_itnim_s *itnim = tskim->itnim;
3787 struct bfi_tskim_req_s *m;
3788
3789 /*
3790 * check for room in queue to send request now
3791 */
3792 m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3793 if (!m)
3794 return BFA_FALSE;
3795
3796 /*
3797 * build i/o request message next
3798 */
3799 bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_TM_REQ,
3800 bfa_fn_lpu(tskim->bfa));
3801
3802 m->tsk_tag = cpu_to_be16(tskim->tsk_tag);
3803 m->itn_fhdl = tskim->itnim->rport->fw_handle;
3804 m->t_secs = tskim->tsecs;
3805 m->lun = tskim->lun;
3806 m->tm_flags = tskim->tm_cmnd;
3807
3808 /*
3809 * queue I/O message to firmware
3810 */
3811 bfa_reqq_produce(tskim->bfa, itnim->reqq, m->mh);
3812 return BFA_TRUE;
3813 }
3814
3815 /*
3816 * Send abort request to cleanup an active TM to firmware.
3817 */
3818 static bfa_boolean_t
3819 bfa_tskim_send_abort(struct bfa_tskim_s *tskim)
3820 {
3821 struct bfa_itnim_s *itnim = tskim->itnim;
3822 struct bfi_tskim_abortreq_s *m;
3823
3824 /*
3825 * check for room in queue to send request now
3826 */
3827 m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3828 if (!m)
3829 return BFA_FALSE;
3830
3831 /*
3832 * build i/o request message next
3833 */
3834 bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_ABORT_REQ,
3835 bfa_fn_lpu(tskim->bfa));
3836
3837 m->tsk_tag = cpu_to_be16(tskim->tsk_tag);
3838
3839 /*
3840 * queue I/O message to firmware
3841 */
3842 bfa_reqq_produce(tskim->bfa, itnim->reqq, m->mh);
3843 return BFA_TRUE;
3844 }
3845
3846 /*
3847 * Call to resume task management cmnd waiting for room in request queue.
3848 */
3849 static void
3850 bfa_tskim_qresume(void *cbarg)
3851 {
3852 struct bfa_tskim_s *tskim = cbarg;
3853
3854 bfa_stats(tskim->itnim, tm_qresumes);
3855 bfa_sm_send_event(tskim, BFA_TSKIM_SM_QRESUME);
3856 }
3857
3858 /*
3859 * Cleanup IOs associated with a task mangement command on IOC failures.
3860 */
3861 static void
3862 bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim)
3863 {
3864 struct bfa_ioim_s *ioim;
3865 struct list_head *qe, *qen;
3866
3867 list_for_each_safe(qe, qen, &tskim->io_q) {
3868 ioim = (struct bfa_ioim_s *) qe;
3869 bfa_ioim_iocdisable(ioim);
3870 }
3871 }
3872
3873 /*
3874 * Notification on completions from related ioim.
3875 */
3876 void
3877 bfa_tskim_iodone(struct bfa_tskim_s *tskim)
3878 {
3879 bfa_wc_down(&tskim->wc);
3880 }
3881
3882 /*
3883 * Handle IOC h/w failure notification from itnim.
3884 */
3885 void
3886 bfa_tskim_iocdisable(struct bfa_tskim_s *tskim)
3887 {
3888 tskim->notify = BFA_FALSE;
3889 bfa_stats(tskim->itnim, tm_iocdowns);
3890 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HWFAIL);
3891 }
3892
3893 /*
3894 * Cleanup TM command and associated IOs as part of ITNIM offline.
3895 */
3896 void
3897 bfa_tskim_cleanup(struct bfa_tskim_s *tskim)
3898 {
3899 tskim->notify = BFA_TRUE;
3900 bfa_stats(tskim->itnim, tm_cleanups);
3901 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP);
3902 }
3903
3904 /*
3905 * Memory allocation and initialization.
3906 */
3907 void
3908 bfa_tskim_attach(struct bfa_fcpim_s *fcpim)
3909 {
3910 struct bfa_tskim_s *tskim;
3911 struct bfa_fcp_mod_s *fcp = fcpim->fcp;
3912 u16 i;
3913
3914 INIT_LIST_HEAD(&fcpim->tskim_free_q);
3915 INIT_LIST_HEAD(&fcpim->tskim_unused_q);
3916
3917 tskim = (struct bfa_tskim_s *) bfa_mem_kva_curp(fcp);
3918 fcpim->tskim_arr = tskim;
3919
3920 for (i = 0; i < fcpim->num_tskim_reqs; i++, tskim++) {
3921 /*
3922 * initialize TSKIM
3923 */
3924 memset(tskim, 0, sizeof(struct bfa_tskim_s));
3925 tskim->tsk_tag = i;
3926 tskim->bfa = fcpim->bfa;
3927 tskim->fcpim = fcpim;
3928 tskim->notify = BFA_FALSE;
3929 bfa_reqq_winit(&tskim->reqq_wait, bfa_tskim_qresume,
3930 tskim);
3931 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
3932
3933 list_add_tail(&tskim->qe, &fcpim->tskim_free_q);
3934 }
3935
3936 bfa_mem_kva_curp(fcp) = (u8 *) tskim;
3937 }
3938
3939 void
3940 bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3941 {
3942 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3943 struct bfi_tskim_rsp_s *rsp = (struct bfi_tskim_rsp_s *) m;
3944 struct bfa_tskim_s *tskim;
3945 u16 tsk_tag = be16_to_cpu(rsp->tsk_tag);
3946
3947 tskim = BFA_TSKIM_FROM_TAG(fcpim, tsk_tag);
3948 WARN_ON(tskim->tsk_tag != tsk_tag);
3949
3950 tskim->tsk_status = rsp->tsk_status;
3951
3952 /*
3953 * Firmware sends BFI_TSKIM_STS_ABORTED status for abort
3954 * requests. All other statuses are for normal completions.
3955 */
3956 if (rsp->tsk_status == BFI_TSKIM_STS_ABORTED) {
3957 bfa_stats(tskim->itnim, tm_cleanup_comps);
3958 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP_DONE);
3959 } else {
3960 bfa_stats(tskim->itnim, tm_fw_rsps);
3961 bfa_sm_send_event(tskim, BFA_TSKIM_SM_DONE);
3962 }
3963 }
3964
3965
3966 struct bfa_tskim_s *
3967 bfa_tskim_alloc(struct bfa_s *bfa, struct bfad_tskim_s *dtsk)
3968 {
3969 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3970 struct bfa_tskim_s *tskim;
3971
3972 bfa_q_deq(&fcpim->tskim_free_q, &tskim);
3973
3974 if (tskim)
3975 tskim->dtsk = dtsk;
3976
3977 return tskim;
3978 }
3979
3980 void
3981 bfa_tskim_free(struct bfa_tskim_s *tskim)
3982 {
3983 WARN_ON(!bfa_q_is_on_q_func(&tskim->itnim->tsk_q, &tskim->qe));
3984 list_del(&tskim->qe);
3985 list_add_tail(&tskim->qe, &tskim->fcpim->tskim_free_q);
3986 }
3987
3988 /*
3989 * Start a task management command.
3990 *
3991 * @param[in] tskim BFA task management command instance
3992 * @param[in] itnim i-t nexus for the task management command
3993 * @param[in] lun lun, if applicable
3994 * @param[in] tm_cmnd Task management command code.
3995 * @param[in] t_secs Timeout in seconds
3996 *
3997 * @return None.
3998 */
3999 void
4000 bfa_tskim_start(struct bfa_tskim_s *tskim, struct bfa_itnim_s *itnim,
4001 struct scsi_lun lun,
4002 enum fcp_tm_cmnd tm_cmnd, u8 tsecs)
4003 {
4004 tskim->itnim = itnim;
4005 tskim->lun = lun;
4006 tskim->tm_cmnd = tm_cmnd;
4007 tskim->tsecs = tsecs;
4008 tskim->notify = BFA_FALSE;
4009 bfa_stats(itnim, tm_cmnds);
4010
4011 list_add_tail(&tskim->qe, &itnim->tsk_q);
4012 bfa_sm_send_event(tskim, BFA_TSKIM_SM_START);
4013 }
4014
4015 void
4016 bfa_tskim_res_recfg(struct bfa_s *bfa, u16 num_tskim_fw)
4017 {
4018 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
4019 struct list_head *qe;
4020 int i;
4021
4022 for (i = 0; i < (fcpim->num_tskim_reqs - num_tskim_fw); i++) {
4023 bfa_q_deq_tail(&fcpim->tskim_free_q, &qe);
4024 list_add_tail(qe, &fcpim->tskim_unused_q);
4025 }
4026 }
4027
4028 /* BFA FCP module - parent module for fcpim */
4029
4030 BFA_MODULE(fcp);
4031
4032 static void
4033 bfa_fcp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
4034 struct bfa_s *bfa)
4035 {
4036 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4037 struct bfa_mem_kva_s *fcp_kva = BFA_MEM_FCP_KVA(bfa);
4038 struct bfa_mem_dma_s *seg_ptr;
4039 u16 nsegs, idx, per_seg_ios, num_io_req;
4040 u32 km_len = 0;
4041
4042 /*
4043 * ZERO for num_ioim_reqs and num_fwtio_reqs is allowed config value.
4044 * So if the values are non zero, adjust them appropriately.
4045 */
4046 if (cfg->fwcfg.num_ioim_reqs &&
4047 cfg->fwcfg.num_ioim_reqs < BFA_IOIM_MIN)
4048 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN;
4049 else if (cfg->fwcfg.num_ioim_reqs > BFA_IOIM_MAX)
4050 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MAX;
4051
4052 if (cfg->fwcfg.num_fwtio_reqs > BFA_FWTIO_MAX)
4053 cfg->fwcfg.num_fwtio_reqs = BFA_FWTIO_MAX;
4054
4055 num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
4056 if (num_io_req > BFA_IO_MAX) {
4057 if (cfg->fwcfg.num_ioim_reqs && cfg->fwcfg.num_fwtio_reqs) {
4058 cfg->fwcfg.num_ioim_reqs = BFA_IO_MAX/2;
4059 cfg->fwcfg.num_fwtio_reqs = BFA_IO_MAX/2;
4060 } else if (cfg->fwcfg.num_fwtio_reqs)
4061 cfg->fwcfg.num_fwtio_reqs = BFA_FWTIO_MAX;
4062 else
4063 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MAX;
4064 }
4065
4066 bfa_fcpim_meminfo(cfg, &km_len);
4067
4068 num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
4069 km_len += num_io_req * sizeof(struct bfa_iotag_s);
4070 km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_itn_s);
4071
4072 /* dma memory */
4073 nsegs = BFI_MEM_DMA_NSEGS(num_io_req, BFI_IOIM_SNSLEN);
4074 per_seg_ios = BFI_MEM_NREQS_SEG(BFI_IOIM_SNSLEN);
4075
4076 bfa_mem_dma_seg_iter(fcp, seg_ptr, nsegs, idx) {
4077 if (num_io_req >= per_seg_ios) {
4078 num_io_req -= per_seg_ios;
4079 bfa_mem_dma_setup(minfo, seg_ptr,
4080 per_seg_ios * BFI_IOIM_SNSLEN);
4081 } else
4082 bfa_mem_dma_setup(minfo, seg_ptr,
4083 num_io_req * BFI_IOIM_SNSLEN);
4084 }
4085
4086 /* kva memory */
4087 bfa_mem_kva_setup(minfo, fcp_kva, km_len);
4088 }
4089
4090 static void
4091 bfa_fcp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4092 struct bfa_pcidev_s *pcidev)
4093 {
4094 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4095 struct bfa_mem_dma_s *seg_ptr;
4096 u16 idx, nsegs, num_io_req;
4097
4098 fcp->num_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
4099 fcp->num_fwtio_reqs = cfg->fwcfg.num_fwtio_reqs;
4100 fcp->num_itns = cfg->fwcfg.num_rports;
4101 fcp->bfa = bfa;
4102
4103 /*
4104 * Setup the pool of snsbase addr's, that is passed to fw as
4105 * part of bfi_iocfc_cfg_s.
4106 */
4107 num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
4108 nsegs = BFI_MEM_DMA_NSEGS(num_io_req, BFI_IOIM_SNSLEN);
4109
4110 bfa_mem_dma_seg_iter(fcp, seg_ptr, nsegs, idx) {
4111
4112 if (!bfa_mem_dma_virt(seg_ptr))
4113 break;
4114
4115 fcp->snsbase[idx].pa = bfa_mem_dma_phys(seg_ptr);
4116 fcp->snsbase[idx].kva = bfa_mem_dma_virt(seg_ptr);
4117 bfa_iocfc_set_snsbase(bfa, idx, fcp->snsbase[idx].pa);
4118 }
4119
4120 bfa_fcpim_attach(fcp, bfad, cfg, pcidev);
4121
4122 bfa_iotag_attach(fcp);
4123
4124 fcp->itn_arr = (struct bfa_itn_s *) bfa_mem_kva_curp(fcp);
4125 bfa_mem_kva_curp(fcp) = (u8 *)fcp->itn_arr +
4126 (fcp->num_itns * sizeof(struct bfa_itn_s));
4127 memset(fcp->itn_arr, 0,
4128 (fcp->num_itns * sizeof(struct bfa_itn_s)));
4129 }
4130
4131 static void
4132 bfa_fcp_detach(struct bfa_s *bfa)
4133 {
4134 }
4135
4136 static void
4137 bfa_fcp_start(struct bfa_s *bfa)
4138 {
4139 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4140
4141 /*
4142 * bfa_init() with flash read is complete. now invalidate the stale
4143 * content of lun mask like unit attention, rp tag and lp tag.
4144 */
4145 bfa_ioim_lm_init(fcp->bfa);
4146 }
4147
4148 static void
4149 bfa_fcp_stop(struct bfa_s *bfa)
4150 {
4151 }
4152
4153 static void
4154 bfa_fcp_iocdisable(struct bfa_s *bfa)
4155 {
4156 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4157
4158 /* Enqueue unused ioim resources to free_q */
4159 list_splice_tail_init(&fcp->iotag_unused_q, &fcp->iotag_ioim_free_q);
4160
4161 bfa_fcpim_iocdisable(fcp);
4162 }
4163
4164 void
4165 bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw)
4166 {
4167 struct bfa_fcp_mod_s *mod = BFA_FCP_MOD(bfa);
4168 struct list_head *qe;
4169 int i;
4170
4171 for (i = 0; i < (mod->num_ioim_reqs - num_ioim_fw); i++) {
4172 bfa_q_deq_tail(&mod->iotag_ioim_free_q, &qe);
4173 list_add_tail(qe, &mod->iotag_unused_q);
4174 }
4175 }
4176
4177 void
4178 bfa_itn_create(struct bfa_s *bfa, struct bfa_rport_s *rport,
4179 void (*isr)(struct bfa_s *bfa, struct bfi_msg_s *m))
4180 {
4181 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4182 struct bfa_itn_s *itn;
4183
4184 itn = BFA_ITN_FROM_TAG(fcp, rport->rport_tag);
4185 itn->isr = isr;
4186 }
4187
4188 /*
4189 * Itn interrupt processing.
4190 */
4191 void
4192 bfa_itn_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4193 {
4194 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
4195 union bfi_itn_i2h_msg_u msg;
4196 struct bfa_itn_s *itn;
4197
4198 msg.msg = m;
4199 itn = BFA_ITN_FROM_TAG(fcp, msg.create_rsp->bfa_handle);
4200
4201 if (itn->isr)
4202 itn->isr(bfa, m);
4203 else
4204 WARN_ON(1);
4205 }
4206
4207 void
4208 bfa_iotag_attach(struct bfa_fcp_mod_s *fcp)
4209 {
4210 struct bfa_iotag_s *iotag;
4211 u16 num_io_req, i;
4212
4213 iotag = (struct bfa_iotag_s *) bfa_mem_kva_curp(fcp);
4214 fcp->iotag_arr = iotag;
4215
4216 INIT_LIST_HEAD(&fcp->iotag_ioim_free_q);
4217 INIT_LIST_HEAD(&fcp->iotag_tio_free_q);
4218 INIT_LIST_HEAD(&fcp->iotag_unused_q);
4219
4220 num_io_req = fcp->num_ioim_reqs + fcp->num_fwtio_reqs;
4221 for (i = 0; i < num_io_req; i++, iotag++) {
4222 memset(iotag, 0, sizeof(struct bfa_iotag_s));
4223 iotag->tag = i;
4224 if (i < fcp->num_ioim_reqs)
4225 list_add_tail(&iotag->qe, &fcp->iotag_ioim_free_q);
4226 else
4227 list_add_tail(&iotag->qe, &fcp->iotag_tio_free_q);
4228 }
4229
4230 bfa_mem_kva_curp(fcp) = (u8 *) iotag;
4231 }
linux-next