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