?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Blackfin: bf548-ezkit/bf561-ezkit: update nor flash layout
[zen-stable.git] / drivers / scsi / bfa / bfa_fcpim.c
blobc0353cdca92956f6d3d82070f9cd7f0ce1556f63
1 /*
2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include "bfad_drv.h"
19 #include "bfa_modules.h"
20
21 BFA_TRC_FILE(HAL, FCPIM);
22 BFA_MODULE(fcpim);
23
24 /*
25 * BFA ITNIM Related definitions
26 */
27 static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
28
29 #define BFA_ITNIM_FROM_TAG(_fcpim, _tag) \
30 (((_fcpim)->itnim_arr + ((_tag) & ((_fcpim)->num_itnims - 1))))
31
32 #define bfa_fcpim_additn(__itnim) \
33 list_add_tail(&(__itnim)->qe, &(__itnim)->fcpim->itnim_q)
34 #define bfa_fcpim_delitn(__itnim) do { \
35 WARN_ON(!bfa_q_is_on_q(&(__itnim)->fcpim->itnim_q, __itnim)); \
36 bfa_itnim_update_del_itn_stats(__itnim); \
37 list_del(&(__itnim)->qe); \
38 WARN_ON(!list_empty(&(__itnim)->io_q)); \
39 WARN_ON(!list_empty(&(__itnim)->io_cleanup_q)); \
40 WARN_ON(!list_empty(&(__itnim)->pending_q)); \
41 } while (0)
42
43 #define bfa_itnim_online_cb(__itnim) do { \
44 if ((__itnim)->bfa->fcs) \
45 bfa_cb_itnim_online((__itnim)->ditn); \
46 else { \
47 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
48 __bfa_cb_itnim_online, (__itnim)); \
49 } \
50 } while (0)
51
52 #define bfa_itnim_offline_cb(__itnim) do { \
53 if ((__itnim)->bfa->fcs) \
54 bfa_cb_itnim_offline((__itnim)->ditn); \
55 else { \
56 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
57 __bfa_cb_itnim_offline, (__itnim)); \
58 } \
59 } while (0)
60
61 #define bfa_itnim_sler_cb(__itnim) do { \
62 if ((__itnim)->bfa->fcs) \
63 bfa_cb_itnim_sler((__itnim)->ditn); \
64 else { \
65 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe, \
66 __bfa_cb_itnim_sler, (__itnim)); \
67 } \
68 } while (0)
69
70 /*
71 * itnim state machine event
72 */
73 enum bfa_itnim_event {
74 BFA_ITNIM_SM_CREATE = 1, /* itnim is created */
75 BFA_ITNIM_SM_ONLINE = 2, /* itnim is online */
76 BFA_ITNIM_SM_OFFLINE = 3, /* itnim is offline */
77 BFA_ITNIM_SM_FWRSP = 4, /* firmware response */
78 BFA_ITNIM_SM_DELETE = 5, /* deleting an existing itnim */
79 BFA_ITNIM_SM_CLEANUP = 6, /* IO cleanup completion */
80 BFA_ITNIM_SM_SLER = 7, /* second level error recovery */
81 BFA_ITNIM_SM_HWFAIL = 8, /* IOC h/w failure event */
82 BFA_ITNIM_SM_QRESUME = 9, /* queue space available */
83 };
84
85 /*
86 * BFA IOIM related definitions
87 */
88 #define bfa_ioim_move_to_comp_q(__ioim) do { \
89 list_del(&(__ioim)->qe); \
90 list_add_tail(&(__ioim)->qe, &(__ioim)->fcpim->ioim_comp_q); \
91 } while (0)
92
93
94 #define bfa_ioim_cb_profile_comp(__fcpim, __ioim) do { \
95 if ((__fcpim)->profile_comp) \
96 (__fcpim)->profile_comp(__ioim); \
97 } while (0)
98
99 #define bfa_ioim_cb_profile_start(__fcpim, __ioim) do { \
100 if ((__fcpim)->profile_start) \
101 (__fcpim)->profile_start(__ioim); \
102 } while (0)
103
104 /*
105 * IO state machine events
106 */
107 enum bfa_ioim_event {
108 BFA_IOIM_SM_START = 1, /* io start request from host */
109 BFA_IOIM_SM_COMP_GOOD = 2, /* io good comp, resource free */
110 BFA_IOIM_SM_COMP = 3, /* io comp, resource is free */
111 BFA_IOIM_SM_COMP_UTAG = 4, /* io comp, resource is free */
112 BFA_IOIM_SM_DONE = 5, /* io comp, resource not free */
113 BFA_IOIM_SM_FREE = 6, /* io resource is freed */
114 BFA_IOIM_SM_ABORT = 7, /* abort request from scsi stack */
115 BFA_IOIM_SM_ABORT_COMP = 8, /* abort from f/w */
116 BFA_IOIM_SM_ABORT_DONE = 9, /* abort completion from f/w */
117 BFA_IOIM_SM_QRESUME = 10, /* CQ space available to queue IO */
118 BFA_IOIM_SM_SGALLOCED = 11, /* SG page allocation successful */
119 BFA_IOIM_SM_SQRETRY = 12, /* sequence recovery retry */
120 BFA_IOIM_SM_HCB = 13, /* bfa callback complete */
121 BFA_IOIM_SM_CLEANUP = 14, /* IO cleanup from itnim */
122 BFA_IOIM_SM_TMSTART = 15, /* IO cleanup from tskim */
123 BFA_IOIM_SM_TMDONE = 16, /* IO cleanup from tskim */
124 BFA_IOIM_SM_HWFAIL = 17, /* IOC h/w failure event */
125 BFA_IOIM_SM_IOTOV = 18, /* ITN offline TOV */
126 };
127
128
129 /*
130 * BFA TSKIM related definitions
131 */
132
133 /*
134 * task management completion handling
135 */
136 #define bfa_tskim_qcomp(__tskim, __cbfn) do { \
137 bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, __cbfn, (__tskim));\
138 bfa_tskim_notify_comp(__tskim); \
139 } while (0)
140
141 #define bfa_tskim_notify_comp(__tskim) do { \
142 if ((__tskim)->notify) \
143 bfa_itnim_tskdone((__tskim)->itnim); \
144 } while (0)
145
146
147 enum bfa_tskim_event {
148 BFA_TSKIM_SM_START = 1, /* TM command start */
149 BFA_TSKIM_SM_DONE = 2, /* TM completion */
150 BFA_TSKIM_SM_QRESUME = 3, /* resume after qfull */
151 BFA_TSKIM_SM_HWFAIL = 5, /* IOC h/w failure event */
152 BFA_TSKIM_SM_HCB = 6, /* BFA callback completion */
153 BFA_TSKIM_SM_IOS_DONE = 7, /* IO and sub TM completions */
154 BFA_TSKIM_SM_CLEANUP = 8, /* TM cleanup on ITN offline */
155 BFA_TSKIM_SM_CLEANUP_DONE = 9, /* TM abort completion */
156 };
157
158 /*
159 * forward declaration for BFA ITNIM functions
160 */
161 static void bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim);
162 static bfa_boolean_t bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim);
163 static bfa_boolean_t bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim);
164 static void bfa_itnim_cleanp_comp(void *itnim_cbarg);
165 static void bfa_itnim_cleanup(struct bfa_itnim_s *itnim);
166 static void __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete);
167 static void __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete);
168 static void __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete);
169 static void bfa_itnim_iotov_online(struct bfa_itnim_s *itnim);
170 static void bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim);
171 static void bfa_itnim_iotov(void *itnim_arg);
172 static void bfa_itnim_iotov_start(struct bfa_itnim_s *itnim);
173 static void bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim);
174 static void bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim);
175
176 /*
177 * forward declaration of ITNIM state machine
178 */
179 static void bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim,
180 enum bfa_itnim_event event);
181 static void bfa_itnim_sm_created(struct bfa_itnim_s *itnim,
182 enum bfa_itnim_event event);
183 static void bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim,
184 enum bfa_itnim_event event);
185 static void bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
186 enum bfa_itnim_event event);
187 static void bfa_itnim_sm_online(struct bfa_itnim_s *itnim,
188 enum bfa_itnim_event event);
189 static void bfa_itnim_sm_sler(struct bfa_itnim_s *itnim,
190 enum bfa_itnim_event event);
191 static void bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
192 enum bfa_itnim_event event);
193 static void bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
194 enum bfa_itnim_event event);
195 static void bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim,
196 enum bfa_itnim_event event);
197 static void bfa_itnim_sm_offline(struct bfa_itnim_s *itnim,
198 enum bfa_itnim_event event);
199 static void bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
200 enum bfa_itnim_event event);
201 static void bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim,
202 enum bfa_itnim_event event);
203 static void bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
204 enum bfa_itnim_event event);
205 static void bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
206 enum bfa_itnim_event event);
207 static void bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
208 enum bfa_itnim_event event);
209
210 /*
211 * forward declaration for BFA IOIM functions
212 */
213 static bfa_boolean_t bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
214 static bfa_boolean_t bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim);
215 static bfa_boolean_t bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
216 static void bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
217 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
218 static void __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete);
219 static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
220 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
221 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
222 static bfa_boolean_t bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
223
224 /*
225 * forward declaration of BFA IO state machine
226 */
227 static void bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim,
228 enum bfa_ioim_event event);
229 static void bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim,
230 enum bfa_ioim_event event);
231 static void bfa_ioim_sm_active(struct bfa_ioim_s *ioim,
232 enum bfa_ioim_event event);
233 static void bfa_ioim_sm_abort(struct bfa_ioim_s *ioim,
234 enum bfa_ioim_event event);
235 static void bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim,
236 enum bfa_ioim_event event);
237 static void bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim,
238 enum bfa_ioim_event event);
239 static void bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim,
240 enum bfa_ioim_event event);
241 static void bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim,
242 enum bfa_ioim_event event);
243 static void bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim,
244 enum bfa_ioim_event event);
245 static void bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim,
246 enum bfa_ioim_event event);
247 static void bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
248 enum bfa_ioim_event event);
249 static void bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim,
250 enum bfa_ioim_event event);
251 /*
252 * forward declaration for BFA TSKIM functions
253 */
254 static void __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete);
255 static void __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete);
256 static bfa_boolean_t bfa_tskim_match_scope(struct bfa_tskim_s *tskim,
257 struct scsi_lun lun);
258 static void bfa_tskim_gather_ios(struct bfa_tskim_s *tskim);
259 static void bfa_tskim_cleanp_comp(void *tskim_cbarg);
260 static void bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim);
261 static bfa_boolean_t bfa_tskim_send(struct bfa_tskim_s *tskim);
262 static bfa_boolean_t bfa_tskim_send_abort(struct bfa_tskim_s *tskim);
263 static void bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim);
264
265 /*
266 * forward declaration of BFA TSKIM state machine
267 */
268 static void bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim,
269 enum bfa_tskim_event event);
270 static void bfa_tskim_sm_active(struct bfa_tskim_s *tskim,
271 enum bfa_tskim_event event);
272 static void bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim,
273 enum bfa_tskim_event event);
274 static void bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim,
275 enum bfa_tskim_event event);
276 static void bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim,
277 enum bfa_tskim_event event);
278 static void bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
279 enum bfa_tskim_event event);
280 static void bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim,
281 enum bfa_tskim_event event);
282 /*
283 * BFA FCP Initiator Mode module
284 */
285
286 /*
287 * Compute and return memory needed by FCP(im) module.
288 */
289 static void
290 bfa_fcpim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
291 u32 *dm_len)
292 {
293 bfa_itnim_meminfo(cfg, km_len, dm_len);
294
295 /*
296 * IO memory
297 */
298 if (cfg->fwcfg.num_ioim_reqs < BFA_IOIM_MIN)
299 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN;
300 else if (cfg->fwcfg.num_ioim_reqs > BFA_IOIM_MAX)
301 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MAX;
302
303 *km_len += cfg->fwcfg.num_ioim_reqs *
304 (sizeof(struct bfa_ioim_s) + sizeof(struct bfa_ioim_sp_s));
305
306 *dm_len += cfg->fwcfg.num_ioim_reqs * BFI_IOIM_SNSLEN;
307
308 /*
309 * task management command memory
310 */
311 if (cfg->fwcfg.num_tskim_reqs < BFA_TSKIM_MIN)
312 cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN;
313 *km_len += cfg->fwcfg.num_tskim_reqs * sizeof(struct bfa_tskim_s);
314 }
315
316
317 static void
318 bfa_fcpim_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
319 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
320 {
321 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
322
323 bfa_trc(bfa, cfg->drvcfg.path_tov);
324 bfa_trc(bfa, cfg->fwcfg.num_rports);
325 bfa_trc(bfa, cfg->fwcfg.num_ioim_reqs);
326 bfa_trc(bfa, cfg->fwcfg.num_tskim_reqs);
327
328 fcpim->bfa = bfa;
329 fcpim->num_itnims = cfg->fwcfg.num_rports;
330 fcpim->num_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
331 fcpim->num_tskim_reqs = cfg->fwcfg.num_tskim_reqs;
332 fcpim->path_tov = cfg->drvcfg.path_tov;
333 fcpim->delay_comp = cfg->drvcfg.delay_comp;
334 fcpim->profile_comp = NULL;
335 fcpim->profile_start = NULL;
336
337 bfa_itnim_attach(fcpim, meminfo);
338 bfa_tskim_attach(fcpim, meminfo);
339 bfa_ioim_attach(fcpim, meminfo);
340 }
341
342 static void
343 bfa_fcpim_detach(struct bfa_s *bfa)
344 {
345 }
346
347 static void
348 bfa_fcpim_start(struct bfa_s *bfa)
349 {
350 }
351
352 static void
353 bfa_fcpim_stop(struct bfa_s *bfa)
354 {
355 }
356
357 static void
358 bfa_fcpim_iocdisable(struct bfa_s *bfa)
359 {
360 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
361 struct bfa_itnim_s *itnim;
362 struct list_head *qe, *qen;
363
364 list_for_each_safe(qe, qen, &fcpim->itnim_q) {
365 itnim = (struct bfa_itnim_s *) qe;
366 bfa_itnim_iocdisable(itnim);
367 }
368 }
369
370 void
371 bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov)
372 {
373 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
374
375 fcpim->path_tov = path_tov * 1000;
376 if (fcpim->path_tov > BFA_FCPIM_PATHTOV_MAX)
377 fcpim->path_tov = BFA_FCPIM_PATHTOV_MAX;
378 }
379
380 u16
381 bfa_fcpim_path_tov_get(struct bfa_s *bfa)
382 {
383 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
384
385 return fcpim->path_tov / 1000;
386 }
387
388 u16
389 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
390 {
391 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
392
393 return fcpim->q_depth;
394 }
395
396 /*
397 * BFA ITNIM module state machine functions
398 */
399
400 /*
401 * Beginning/unallocated state - no events expected.
402 */
403 static void
404 bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
405 {
406 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
407 bfa_trc(itnim->bfa, event);
408
409 switch (event) {
410 case BFA_ITNIM_SM_CREATE:
411 bfa_sm_set_state(itnim, bfa_itnim_sm_created);
412 itnim->is_online = BFA_FALSE;
413 bfa_fcpim_additn(itnim);
414 break;
415
416 default:
417 bfa_sm_fault(itnim->bfa, event);
418 }
419 }
420
421 /*
422 * Beginning state, only online event expected.
423 */
424 static void
425 bfa_itnim_sm_created(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
426 {
427 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
428 bfa_trc(itnim->bfa, event);
429
430 switch (event) {
431 case BFA_ITNIM_SM_ONLINE:
432 if (bfa_itnim_send_fwcreate(itnim))
433 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
434 else
435 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
436 break;
437
438 case BFA_ITNIM_SM_DELETE:
439 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
440 bfa_fcpim_delitn(itnim);
441 break;
442
443 case BFA_ITNIM_SM_HWFAIL:
444 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
445 break;
446
447 default:
448 bfa_sm_fault(itnim->bfa, event);
449 }
450 }
451
452 /*
453 * Waiting for itnim create response from firmware.
454 */
455 static void
456 bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
457 {
458 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
459 bfa_trc(itnim->bfa, event);
460
461 switch (event) {
462 case BFA_ITNIM_SM_FWRSP:
463 bfa_sm_set_state(itnim, bfa_itnim_sm_online);
464 itnim->is_online = BFA_TRUE;
465 bfa_itnim_iotov_online(itnim);
466 bfa_itnim_online_cb(itnim);
467 break;
468
469 case BFA_ITNIM_SM_DELETE:
470 bfa_sm_set_state(itnim, bfa_itnim_sm_delete_pending);
471 break;
472
473 case BFA_ITNIM_SM_OFFLINE:
474 if (bfa_itnim_send_fwdelete(itnim))
475 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
476 else
477 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
478 break;
479
480 case BFA_ITNIM_SM_HWFAIL:
481 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
482 break;
483
484 default:
485 bfa_sm_fault(itnim->bfa, event);
486 }
487 }
488
489 static void
490 bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
491 enum bfa_itnim_event event)
492 {
493 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
494 bfa_trc(itnim->bfa, event);
495
496 switch (event) {
497 case BFA_ITNIM_SM_QRESUME:
498 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
499 bfa_itnim_send_fwcreate(itnim);
500 break;
501
502 case BFA_ITNIM_SM_DELETE:
503 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
504 bfa_reqq_wcancel(&itnim->reqq_wait);
505 bfa_fcpim_delitn(itnim);
506 break;
507
508 case BFA_ITNIM_SM_OFFLINE:
509 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
510 bfa_reqq_wcancel(&itnim->reqq_wait);
511 bfa_itnim_offline_cb(itnim);
512 break;
513
514 case BFA_ITNIM_SM_HWFAIL:
515 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
516 bfa_reqq_wcancel(&itnim->reqq_wait);
517 break;
518
519 default:
520 bfa_sm_fault(itnim->bfa, event);
521 }
522 }
523
524 /*
525 * Waiting for itnim create response from firmware, a delete is pending.
526 */
527 static void
528 bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
529 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_FWRSP:
536 if (bfa_itnim_send_fwdelete(itnim))
537 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
538 else
539 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
540 break;
541
542 case BFA_ITNIM_SM_HWFAIL:
543 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
544 bfa_fcpim_delitn(itnim);
545 break;
546
547 default:
548 bfa_sm_fault(itnim->bfa, event);
549 }
550 }
551
552 /*
553 * Online state - normal parking state.
554 */
555 static void
556 bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
557 {
558 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
559 bfa_trc(itnim->bfa, event);
560
561 switch (event) {
562 case BFA_ITNIM_SM_OFFLINE:
563 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
564 itnim->is_online = BFA_FALSE;
565 bfa_itnim_iotov_start(itnim);
566 bfa_itnim_cleanup(itnim);
567 break;
568
569 case BFA_ITNIM_SM_DELETE:
570 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
571 itnim->is_online = BFA_FALSE;
572 bfa_itnim_cleanup(itnim);
573 break;
574
575 case BFA_ITNIM_SM_SLER:
576 bfa_sm_set_state(itnim, bfa_itnim_sm_sler);
577 itnim->is_online = BFA_FALSE;
578 bfa_itnim_iotov_start(itnim);
579 bfa_itnim_sler_cb(itnim);
580 break;
581
582 case BFA_ITNIM_SM_HWFAIL:
583 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
584 itnim->is_online = BFA_FALSE;
585 bfa_itnim_iotov_start(itnim);
586 bfa_itnim_iocdisable_cleanup(itnim);
587 break;
588
589 default:
590 bfa_sm_fault(itnim->bfa, event);
591 }
592 }
593
594 /*
595 * Second level error recovery need.
596 */
597 static void
598 bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
599 {
600 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
601 bfa_trc(itnim->bfa, event);
602
603 switch (event) {
604 case BFA_ITNIM_SM_OFFLINE:
605 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
606 bfa_itnim_cleanup(itnim);
607 break;
608
609 case BFA_ITNIM_SM_DELETE:
610 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
611 bfa_itnim_cleanup(itnim);
612 bfa_itnim_iotov_delete(itnim);
613 break;
614
615 case BFA_ITNIM_SM_HWFAIL:
616 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
617 bfa_itnim_iocdisable_cleanup(itnim);
618 break;
619
620 default:
621 bfa_sm_fault(itnim->bfa, event);
622 }
623 }
624
625 /*
626 * Going offline. Waiting for active IO cleanup.
627 */
628 static void
629 bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
630 enum bfa_itnim_event event)
631 {
632 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
633 bfa_trc(itnim->bfa, event);
634
635 switch (event) {
636 case BFA_ITNIM_SM_CLEANUP:
637 if (bfa_itnim_send_fwdelete(itnim))
638 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
639 else
640 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
641 break;
642
643 case BFA_ITNIM_SM_DELETE:
644 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
645 bfa_itnim_iotov_delete(itnim);
646 break;
647
648 case BFA_ITNIM_SM_HWFAIL:
649 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
650 bfa_itnim_iocdisable_cleanup(itnim);
651 bfa_itnim_offline_cb(itnim);
652 break;
653
654 case BFA_ITNIM_SM_SLER:
655 break;
656
657 default:
658 bfa_sm_fault(itnim->bfa, event);
659 }
660 }
661
662 /*
663 * Deleting itnim. Waiting for active IO cleanup.
664 */
665 static void
666 bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
667 enum bfa_itnim_event event)
668 {
669 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
670 bfa_trc(itnim->bfa, event);
671
672 switch (event) {
673 case BFA_ITNIM_SM_CLEANUP:
674 if (bfa_itnim_send_fwdelete(itnim))
675 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
676 else
677 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
678 break;
679
680 case BFA_ITNIM_SM_HWFAIL:
681 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
682 bfa_itnim_iocdisable_cleanup(itnim);
683 break;
684
685 default:
686 bfa_sm_fault(itnim->bfa, event);
687 }
688 }
689
690 /*
691 * Rport offline. Fimrware itnim is being deleted - awaiting f/w response.
692 */
693 static void
694 bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
695 {
696 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
697 bfa_trc(itnim->bfa, event);
698
699 switch (event) {
700 case BFA_ITNIM_SM_FWRSP:
701 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
702 bfa_itnim_offline_cb(itnim);
703 break;
704
705 case BFA_ITNIM_SM_DELETE:
706 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
707 break;
708
709 case BFA_ITNIM_SM_HWFAIL:
710 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
711 bfa_itnim_offline_cb(itnim);
712 break;
713
714 default:
715 bfa_sm_fault(itnim->bfa, event);
716 }
717 }
718
719 static void
720 bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
721 enum bfa_itnim_event event)
722 {
723 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
724 bfa_trc(itnim->bfa, event);
725
726 switch (event) {
727 case BFA_ITNIM_SM_QRESUME:
728 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
729 bfa_itnim_send_fwdelete(itnim);
730 break;
731
732 case BFA_ITNIM_SM_DELETE:
733 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
734 break;
735
736 case BFA_ITNIM_SM_HWFAIL:
737 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
738 bfa_reqq_wcancel(&itnim->reqq_wait);
739 bfa_itnim_offline_cb(itnim);
740 break;
741
742 default:
743 bfa_sm_fault(itnim->bfa, event);
744 }
745 }
746
747 /*
748 * Offline state.
749 */
750 static void
751 bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
752 {
753 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
754 bfa_trc(itnim->bfa, event);
755
756 switch (event) {
757 case BFA_ITNIM_SM_DELETE:
758 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
759 bfa_itnim_iotov_delete(itnim);
760 bfa_fcpim_delitn(itnim);
761 break;
762
763 case BFA_ITNIM_SM_ONLINE:
764 if (bfa_itnim_send_fwcreate(itnim))
765 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
766 else
767 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
768 break;
769
770 case BFA_ITNIM_SM_HWFAIL:
771 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
772 break;
773
774 default:
775 bfa_sm_fault(itnim->bfa, event);
776 }
777 }
778
779 static void
780 bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
781 enum bfa_itnim_event event)
782 {
783 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
784 bfa_trc(itnim->bfa, event);
785
786 switch (event) {
787 case BFA_ITNIM_SM_DELETE:
788 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
789 bfa_itnim_iotov_delete(itnim);
790 bfa_fcpim_delitn(itnim);
791 break;
792
793 case BFA_ITNIM_SM_OFFLINE:
794 bfa_itnim_offline_cb(itnim);
795 break;
796
797 case BFA_ITNIM_SM_ONLINE:
798 if (bfa_itnim_send_fwcreate(itnim))
799 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
800 else
801 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
802 break;
803
804 case BFA_ITNIM_SM_HWFAIL:
805 break;
806
807 default:
808 bfa_sm_fault(itnim->bfa, event);
809 }
810 }
811
812 /*
813 * Itnim is deleted, waiting for firmware response to delete.
814 */
815 static void
816 bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
817 {
818 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
819 bfa_trc(itnim->bfa, event);
820
821 switch (event) {
822 case BFA_ITNIM_SM_FWRSP:
823 case BFA_ITNIM_SM_HWFAIL:
824 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
825 bfa_fcpim_delitn(itnim);
826 break;
827
828 default:
829 bfa_sm_fault(itnim->bfa, event);
830 }
831 }
832
833 static void
834 bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
835 enum bfa_itnim_event event)
836 {
837 bfa_trc(itnim->bfa, itnim->rport->rport_tag);
838 bfa_trc(itnim->bfa, event);
839
840 switch (event) {
841 case BFA_ITNIM_SM_QRESUME:
842 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
843 bfa_itnim_send_fwdelete(itnim);
844 break;
845
846 case BFA_ITNIM_SM_HWFAIL:
847 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
848 bfa_reqq_wcancel(&itnim->reqq_wait);
849 bfa_fcpim_delitn(itnim);
850 break;
851
852 default:
853 bfa_sm_fault(itnim->bfa, event);
854 }
855 }
856
857 /*
858 * Initiate cleanup of all IOs on an IOC failure.
859 */
860 static void
861 bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim)
862 {
863 struct bfa_tskim_s *tskim;
864 struct bfa_ioim_s *ioim;
865 struct list_head *qe, *qen;
866
867 list_for_each_safe(qe, qen, &itnim->tsk_q) {
868 tskim = (struct bfa_tskim_s *) qe;
869 bfa_tskim_iocdisable(tskim);
870 }
871
872 list_for_each_safe(qe, qen, &itnim->io_q) {
873 ioim = (struct bfa_ioim_s *) qe;
874 bfa_ioim_iocdisable(ioim);
875 }
876
877 /*
878 * For IO request in pending queue, we pretend an early timeout.
879 */
880 list_for_each_safe(qe, qen, &itnim->pending_q) {
881 ioim = (struct bfa_ioim_s *) qe;
882 bfa_ioim_tov(ioim);
883 }
884
885 list_for_each_safe(qe, qen, &itnim->io_cleanup_q) {
886 ioim = (struct bfa_ioim_s *) qe;
887 bfa_ioim_iocdisable(ioim);
888 }
889 }
890
891 /*
892 * IO cleanup completion
893 */
894 static void
895 bfa_itnim_cleanp_comp(void *itnim_cbarg)
896 {
897 struct bfa_itnim_s *itnim = itnim_cbarg;
898
899 bfa_stats(itnim, cleanup_comps);
900 bfa_sm_send_event(itnim, BFA_ITNIM_SM_CLEANUP);
901 }
902
903 /*
904 * Initiate cleanup of all IOs.
905 */
906 static void
907 bfa_itnim_cleanup(struct bfa_itnim_s *itnim)
908 {
909 struct bfa_ioim_s *ioim;
910 struct bfa_tskim_s *tskim;
911 struct list_head *qe, *qen;
912
913 bfa_wc_init(&itnim->wc, bfa_itnim_cleanp_comp, itnim);
914
915 list_for_each_safe(qe, qen, &itnim->io_q) {
916 ioim = (struct bfa_ioim_s *) qe;
917
918 /*
919 * Move IO to a cleanup queue from active queue so that a later
920 * TM will not pickup this IO.
921 */
922 list_del(&ioim->qe);
923 list_add_tail(&ioim->qe, &itnim->io_cleanup_q);
924
925 bfa_wc_up(&itnim->wc);
926 bfa_ioim_cleanup(ioim);
927 }
928
929 list_for_each_safe(qe, qen, &itnim->tsk_q) {
930 tskim = (struct bfa_tskim_s *) qe;
931 bfa_wc_up(&itnim->wc);
932 bfa_tskim_cleanup(tskim);
933 }
934
935 bfa_wc_wait(&itnim->wc);
936 }
937
938 static void
939 __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete)
940 {
941 struct bfa_itnim_s *itnim = cbarg;
942
943 if (complete)
944 bfa_cb_itnim_online(itnim->ditn);
945 }
946
947 static void
948 __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete)
949 {
950 struct bfa_itnim_s *itnim = cbarg;
951
952 if (complete)
953 bfa_cb_itnim_offline(itnim->ditn);
954 }
955
956 static void
957 __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete)
958 {
959 struct bfa_itnim_s *itnim = cbarg;
960
961 if (complete)
962 bfa_cb_itnim_sler(itnim->ditn);
963 }
964
965 /*
966 * Call to resume any I/O requests waiting for room in request queue.
967 */
968 static void
969 bfa_itnim_qresume(void *cbarg)
970 {
971 struct bfa_itnim_s *itnim = cbarg;
972
973 bfa_sm_send_event(itnim, BFA_ITNIM_SM_QRESUME);
974 }
975
976 /*
977 * bfa_itnim_public
978 */
979
980 void
981 bfa_itnim_iodone(struct bfa_itnim_s *itnim)
982 {
983 bfa_wc_down(&itnim->wc);
984 }
985
986 void
987 bfa_itnim_tskdone(struct bfa_itnim_s *itnim)
988 {
989 bfa_wc_down(&itnim->wc);
990 }
991
992 void
993 bfa_itnim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
994 u32 *dm_len)
995 {
996 /*
997 * ITN memory
998 */
999 *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_itnim_s);
1000 }
1001
1002 void
1003 bfa_itnim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
1004 {
1005 struct bfa_s *bfa = fcpim->bfa;
1006 struct bfa_itnim_s *itnim;
1007 int i, j;
1008
1009 INIT_LIST_HEAD(&fcpim->itnim_q);
1010
1011 itnim = (struct bfa_itnim_s *) bfa_meminfo_kva(minfo);
1012 fcpim->itnim_arr = itnim;
1013
1014 for (i = 0; i < fcpim->num_itnims; i++, itnim++) {
1015 memset(itnim, 0, sizeof(struct bfa_itnim_s));
1016 itnim->bfa = bfa;
1017 itnim->fcpim = fcpim;
1018 itnim->reqq = BFA_REQQ_QOS_LO;
1019 itnim->rport = BFA_RPORT_FROM_TAG(bfa, i);
1020 itnim->iotov_active = BFA_FALSE;
1021 bfa_reqq_winit(&itnim->reqq_wait, bfa_itnim_qresume, itnim);
1022
1023 INIT_LIST_HEAD(&itnim->io_q);
1024 INIT_LIST_HEAD(&itnim->io_cleanup_q);
1025 INIT_LIST_HEAD(&itnim->pending_q);
1026 INIT_LIST_HEAD(&itnim->tsk_q);
1027 INIT_LIST_HEAD(&itnim->delay_comp_q);
1028 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1029 itnim->ioprofile.io_latency.min[j] = ~0;
1030 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
1031 }
1032
1033 bfa_meminfo_kva(minfo) = (u8 *) itnim;
1034 }
1035
1036 void
1037 bfa_itnim_iocdisable(struct bfa_itnim_s *itnim)
1038 {
1039 bfa_stats(itnim, ioc_disabled);
1040 bfa_sm_send_event(itnim, BFA_ITNIM_SM_HWFAIL);
1041 }
1042
1043 static bfa_boolean_t
1044 bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim)
1045 {
1046 struct bfi_itnim_create_req_s *m;
1047
1048 itnim->msg_no++;
1049
1050 /*
1051 * check for room in queue to send request now
1052 */
1053 m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1054 if (!m) {
1055 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1056 return BFA_FALSE;
1057 }
1058
1059 bfi_h2i_set(m->mh, BFI_MC_ITNIM, BFI_ITNIM_H2I_CREATE_REQ,
1060 bfa_lpuid(itnim->bfa));
1061 m->fw_handle = itnim->rport->fw_handle;
1062 m->class = FC_CLASS_3;
1063 m->seq_rec = itnim->seq_rec;
1064 m->msg_no = itnim->msg_no;
1065 bfa_stats(itnim, fw_create);
1066
1067 /*
1068 * queue I/O message to firmware
1069 */
1070 bfa_reqq_produce(itnim->bfa, itnim->reqq);
1071 return BFA_TRUE;
1072 }
1073
1074 static bfa_boolean_t
1075 bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim)
1076 {
1077 struct bfi_itnim_delete_req_s *m;
1078
1079 /*
1080 * check for room in queue to send request now
1081 */
1082 m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1083 if (!m) {
1084 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1085 return BFA_FALSE;
1086 }
1087
1088 bfi_h2i_set(m->mh, BFI_MC_ITNIM, BFI_ITNIM_H2I_DELETE_REQ,
1089 bfa_lpuid(itnim->bfa));
1090 m->fw_handle = itnim->rport->fw_handle;
1091 bfa_stats(itnim, fw_delete);
1092
1093 /*
1094 * queue I/O message to firmware
1095 */
1096 bfa_reqq_produce(itnim->bfa, itnim->reqq);
1097 return BFA_TRUE;
1098 }
1099
1100 /*
1101 * Cleanup all pending failed inflight requests.
1102 */
1103 static void
1104 bfa_itnim_delayed_comp(struct bfa_itnim_s *itnim, bfa_boolean_t iotov)
1105 {
1106 struct bfa_ioim_s *ioim;
1107 struct list_head *qe, *qen;
1108
1109 list_for_each_safe(qe, qen, &itnim->delay_comp_q) {
1110 ioim = (struct bfa_ioim_s *)qe;
1111 bfa_ioim_delayed_comp(ioim, iotov);
1112 }
1113 }
1114
1115 /*
1116 * Start all pending IO requests.
1117 */
1118 static void
1119 bfa_itnim_iotov_online(struct bfa_itnim_s *itnim)
1120 {
1121 struct bfa_ioim_s *ioim;
1122
1123 bfa_itnim_iotov_stop(itnim);
1124
1125 /*
1126 * Abort all inflight IO requests in the queue
1127 */
1128 bfa_itnim_delayed_comp(itnim, BFA_FALSE);
1129
1130 /*
1131 * Start all pending IO requests.
1132 */
1133 while (!list_empty(&itnim->pending_q)) {
1134 bfa_q_deq(&itnim->pending_q, &ioim);
1135 list_add_tail(&ioim->qe, &itnim->io_q);
1136 bfa_ioim_start(ioim);
1137 }
1138 }
1139
1140 /*
1141 * Fail all pending IO requests
1142 */
1143 static void
1144 bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim)
1145 {
1146 struct bfa_ioim_s *ioim;
1147
1148 /*
1149 * Fail all inflight IO requests in the queue
1150 */
1151 bfa_itnim_delayed_comp(itnim, BFA_TRUE);
1152
1153 /*
1154 * Fail any pending IO requests.
1155 */
1156 while (!list_empty(&itnim->pending_q)) {
1157 bfa_q_deq(&itnim->pending_q, &ioim);
1158 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
1159 bfa_ioim_tov(ioim);
1160 }
1161 }
1162
1163 /*
1164 * IO TOV timer callback. Fail any pending IO requests.
1165 */
1166 static void
1167 bfa_itnim_iotov(void *itnim_arg)
1168 {
1169 struct bfa_itnim_s *itnim = itnim_arg;
1170
1171 itnim->iotov_active = BFA_FALSE;
1172
1173 bfa_cb_itnim_tov_begin(itnim->ditn);
1174 bfa_itnim_iotov_cleanup(itnim);
1175 bfa_cb_itnim_tov(itnim->ditn);
1176 }
1177
1178 /*
1179 * Start IO TOV timer for failing back pending IO requests in offline state.
1180 */
1181 static void
1182 bfa_itnim_iotov_start(struct bfa_itnim_s *itnim)
1183 {
1184 if (itnim->fcpim->path_tov > 0) {
1185
1186 itnim->iotov_active = BFA_TRUE;
1187 WARN_ON(!bfa_itnim_hold_io(itnim));
1188 bfa_timer_start(itnim->bfa, &itnim->timer,
1189 bfa_itnim_iotov, itnim, itnim->fcpim->path_tov);
1190 }
1191 }
1192
1193 /*
1194 * Stop IO TOV timer.
1195 */
1196 static void
1197 bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim)
1198 {
1199 if (itnim->iotov_active) {
1200 itnim->iotov_active = BFA_FALSE;
1201 bfa_timer_stop(&itnim->timer);
1202 }
1203 }
1204
1205 /*
1206 * Stop IO TOV timer.
1207 */
1208 static void
1209 bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim)
1210 {
1211 bfa_boolean_t pathtov_active = BFA_FALSE;
1212
1213 if (itnim->iotov_active)
1214 pathtov_active = BFA_TRUE;
1215
1216 bfa_itnim_iotov_stop(itnim);
1217 if (pathtov_active)
1218 bfa_cb_itnim_tov_begin(itnim->ditn);
1219 bfa_itnim_iotov_cleanup(itnim);
1220 if (pathtov_active)
1221 bfa_cb_itnim_tov(itnim->ditn);
1222 }
1223
1224 static void
1225 bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim)
1226 {
1227 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(itnim->bfa);
1228 fcpim->del_itn_stats.del_itn_iocomp_aborted +=
1229 itnim->stats.iocomp_aborted;
1230 fcpim->del_itn_stats.del_itn_iocomp_timedout +=
1231 itnim->stats.iocomp_timedout;
1232 fcpim->del_itn_stats.del_itn_iocom_sqer_needed +=
1233 itnim->stats.iocom_sqer_needed;
1234 fcpim->del_itn_stats.del_itn_iocom_res_free +=
1235 itnim->stats.iocom_res_free;
1236 fcpim->del_itn_stats.del_itn_iocom_hostabrts +=
1237 itnim->stats.iocom_hostabrts;
1238 fcpim->del_itn_stats.del_itn_total_ios += itnim->stats.total_ios;
1239 fcpim->del_itn_stats.del_io_iocdowns += itnim->stats.io_iocdowns;
1240 fcpim->del_itn_stats.del_tm_iocdowns += itnim->stats.tm_iocdowns;
1241 }
1242
1243 /*
1244 * bfa_itnim_public
1245 */
1246
1247 /*
1248 * Itnim interrupt processing.
1249 */
1250 void
1251 bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1252 {
1253 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1254 union bfi_itnim_i2h_msg_u msg;
1255 struct bfa_itnim_s *itnim;
1256
1257 bfa_trc(bfa, m->mhdr.msg_id);
1258
1259 msg.msg = m;
1260
1261 switch (m->mhdr.msg_id) {
1262 case BFI_ITNIM_I2H_CREATE_RSP:
1263 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1264 msg.create_rsp->bfa_handle);
1265 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
1266 bfa_stats(itnim, create_comps);
1267 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1268 break;
1269
1270 case BFI_ITNIM_I2H_DELETE_RSP:
1271 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1272 msg.delete_rsp->bfa_handle);
1273 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
1274 bfa_stats(itnim, delete_comps);
1275 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1276 break;
1277
1278 case BFI_ITNIM_I2H_SLER_EVENT:
1279 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1280 msg.sler_event->bfa_handle);
1281 bfa_stats(itnim, sler_events);
1282 bfa_sm_send_event(itnim, BFA_ITNIM_SM_SLER);
1283 break;
1284
1285 default:
1286 bfa_trc(bfa, m->mhdr.msg_id);
1287 WARN_ON(1);
1288 }
1289 }
1290
1291 /*
1292 * bfa_itnim_api
1293 */
1294
1295 struct bfa_itnim_s *
1296 bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
1297 {
1298 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1299 struct bfa_itnim_s *itnim;
1300
1301 itnim = BFA_ITNIM_FROM_TAG(fcpim, rport->rport_tag);
1302 WARN_ON(itnim->rport != rport);
1303
1304 itnim->ditn = ditn;
1305
1306 bfa_stats(itnim, creates);
1307 bfa_sm_send_event(itnim, BFA_ITNIM_SM_CREATE);
1308
1309 return itnim;
1310 }
1311
1312 void
1313 bfa_itnim_delete(struct bfa_itnim_s *itnim)
1314 {
1315 bfa_stats(itnim, deletes);
1316 bfa_sm_send_event(itnim, BFA_ITNIM_SM_DELETE);
1317 }
1318
1319 void
1320 bfa_itnim_online(struct bfa_itnim_s *itnim, bfa_boolean_t seq_rec)
1321 {
1322 itnim->seq_rec = seq_rec;
1323 bfa_stats(itnim, onlines);
1324 bfa_sm_send_event(itnim, BFA_ITNIM_SM_ONLINE);
1325 }
1326
1327 void
1328 bfa_itnim_offline(struct bfa_itnim_s *itnim)
1329 {
1330 bfa_stats(itnim, offlines);
1331 bfa_sm_send_event(itnim, BFA_ITNIM_SM_OFFLINE);
1332 }
1333
1334 /*
1335 * Return true if itnim is considered offline for holding off IO request.
1336 * IO is not held if itnim is being deleted.
1337 */
1338 bfa_boolean_t
1339 bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
1340 {
1341 return itnim->fcpim->path_tov && itnim->iotov_active &&
1342 (bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwcreate) ||
1343 bfa_sm_cmp_state(itnim, bfa_itnim_sm_sler) ||
1344 bfa_sm_cmp_state(itnim, bfa_itnim_sm_cleanup_offline) ||
1345 bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwdelete) ||
1346 bfa_sm_cmp_state(itnim, bfa_itnim_sm_offline) ||
1347 bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable));
1348 }
1349
1350 void
1351 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
1352 {
1353 int j;
1354 memset(&itnim->stats, 0, sizeof(itnim->stats));
1355 memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile));
1356 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1357 itnim->ioprofile.io_latency.min[j] = ~0;
1358 }
1359
1360 /*
1361 * BFA IO module state machine functions
1362 */
1363
1364 /*
1365 * IO is not started (unallocated).
1366 */
1367 static void
1368 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1369 {
1370 switch (event) {
1371 case BFA_IOIM_SM_START:
1372 if (!bfa_itnim_is_online(ioim->itnim)) {
1373 if (!bfa_itnim_hold_io(ioim->itnim)) {
1374 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1375 list_del(&ioim->qe);
1376 list_add_tail(&ioim->qe,
1377 &ioim->fcpim->ioim_comp_q);
1378 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1379 __bfa_cb_ioim_pathtov, ioim);
1380 } else {
1381 list_del(&ioim->qe);
1382 list_add_tail(&ioim->qe,
1383 &ioim->itnim->pending_q);
1384 }
1385 break;
1386 }
1387
1388 if (ioim->nsges > BFI_SGE_INLINE) {
1389 if (!bfa_ioim_sgpg_alloc(ioim)) {
1390 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
1391 return;
1392 }
1393 }
1394
1395 if (!bfa_ioim_send_ioreq(ioim)) {
1396 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1397 break;
1398 }
1399
1400 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1401 break;
1402
1403 case BFA_IOIM_SM_IOTOV:
1404 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1405 bfa_ioim_move_to_comp_q(ioim);
1406 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1407 __bfa_cb_ioim_pathtov, ioim);
1408 break;
1409
1410 case BFA_IOIM_SM_ABORT:
1411 /*
1412 * IO in pending queue can get abort requests. Complete abort
1413 * requests immediately.
1414 */
1415 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1416 WARN_ON(!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
1417 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1418 __bfa_cb_ioim_abort, ioim);
1419 break;
1420
1421 default:
1422 bfa_sm_fault(ioim->bfa, event);
1423 }
1424 }
1425
1426 /*
1427 * IO is waiting for SG pages.
1428 */
1429 static void
1430 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1431 {
1432 bfa_trc(ioim->bfa, ioim->iotag);
1433 bfa_trc(ioim->bfa, event);
1434
1435 switch (event) {
1436 case BFA_IOIM_SM_SGALLOCED:
1437 if (!bfa_ioim_send_ioreq(ioim)) {
1438 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1439 break;
1440 }
1441 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1442 break;
1443
1444 case BFA_IOIM_SM_CLEANUP:
1445 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1446 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1447 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1448 ioim);
1449 bfa_ioim_notify_cleanup(ioim);
1450 break;
1451
1452 case BFA_IOIM_SM_ABORT:
1453 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1454 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1455 bfa_ioim_move_to_comp_q(ioim);
1456 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1457 ioim);
1458 break;
1459
1460 case BFA_IOIM_SM_HWFAIL:
1461 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1462 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1463 bfa_ioim_move_to_comp_q(ioim);
1464 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1465 ioim);
1466 break;
1467
1468 default:
1469 bfa_sm_fault(ioim->bfa, event);
1470 }
1471 }
1472
1473 /*
1474 * IO is active.
1475 */
1476 static void
1477 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1478 {
1479 switch (event) {
1480 case BFA_IOIM_SM_COMP_GOOD:
1481 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1482 bfa_ioim_move_to_comp_q(ioim);
1483 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1484 __bfa_cb_ioim_good_comp, ioim);
1485 break;
1486
1487 case BFA_IOIM_SM_COMP:
1488 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1489 bfa_ioim_move_to_comp_q(ioim);
1490 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1491 ioim);
1492 break;
1493
1494 case BFA_IOIM_SM_DONE:
1495 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1496 bfa_ioim_move_to_comp_q(ioim);
1497 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1498 ioim);
1499 break;
1500
1501 case BFA_IOIM_SM_ABORT:
1502 ioim->iosp->abort_explicit = BFA_TRUE;
1503 ioim->io_cbfn = __bfa_cb_ioim_abort;
1504
1505 if (bfa_ioim_send_abort(ioim))
1506 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1507 else {
1508 bfa_sm_set_state(ioim, bfa_ioim_sm_abort_qfull);
1509 bfa_stats(ioim->itnim, qwait);
1510 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1511 &ioim->iosp->reqq_wait);
1512 }
1513 break;
1514
1515 case BFA_IOIM_SM_CLEANUP:
1516 ioim->iosp->abort_explicit = BFA_FALSE;
1517 ioim->io_cbfn = __bfa_cb_ioim_failed;
1518
1519 if (bfa_ioim_send_abort(ioim))
1520 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1521 else {
1522 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1523 bfa_stats(ioim->itnim, qwait);
1524 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1525 &ioim->iosp->reqq_wait);
1526 }
1527 break;
1528
1529 case BFA_IOIM_SM_HWFAIL:
1530 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1531 bfa_ioim_move_to_comp_q(ioim);
1532 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1533 ioim);
1534 break;
1535
1536 case BFA_IOIM_SM_SQRETRY:
1537 if (bfa_ioim_maxretry_reached(ioim)) {
1538 /* max retry reached, free IO */
1539 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1540 bfa_ioim_move_to_comp_q(ioim);
1541 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1542 __bfa_cb_ioim_failed, ioim);
1543 break;
1544 }
1545 /* waiting for IO tag resource free */
1546 bfa_sm_set_state(ioim, bfa_ioim_sm_cmnd_retry);
1547 break;
1548
1549 default:
1550 bfa_sm_fault(ioim->bfa, event);
1551 }
1552 }
1553
1554 /*
1555 * IO is retried with new tag.
1556 */
1557 static void
1558 bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1559 {
1560 switch (event) {
1561 case BFA_IOIM_SM_FREE:
1562 /* abts and rrq done. Now retry the IO with new tag */
1563 bfa_ioim_update_iotag(ioim);
1564 if (!bfa_ioim_send_ioreq(ioim)) {
1565 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1566 break;
1567 }
1568 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1569 break;
1570
1571 case BFA_IOIM_SM_CLEANUP:
1572 ioim->iosp->abort_explicit = BFA_FALSE;
1573 ioim->io_cbfn = __bfa_cb_ioim_failed;
1574
1575 if (bfa_ioim_send_abort(ioim))
1576 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1577 else {
1578 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1579 bfa_stats(ioim->itnim, qwait);
1580 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1581 &ioim->iosp->reqq_wait);
1582 }
1583 break;
1584
1585 case BFA_IOIM_SM_HWFAIL:
1586 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1587 bfa_ioim_move_to_comp_q(ioim);
1588 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1589 __bfa_cb_ioim_failed, ioim);
1590 break;
1591
1592 case BFA_IOIM_SM_ABORT:
1593 /* in this state IO abort is done.
1594 * Waiting for IO tag resource free.
1595 */
1596 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1597 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1598 ioim);
1599 break;
1600
1601 default:
1602 bfa_sm_fault(ioim->bfa, event);
1603 }
1604 }
1605
1606 /*
1607 * IO is being aborted, waiting for completion from firmware.
1608 */
1609 static void
1610 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1611 {
1612 bfa_trc(ioim->bfa, ioim->iotag);
1613 bfa_trc(ioim->bfa, event);
1614
1615 switch (event) {
1616 case BFA_IOIM_SM_COMP_GOOD:
1617 case BFA_IOIM_SM_COMP:
1618 case BFA_IOIM_SM_DONE:
1619 case BFA_IOIM_SM_FREE:
1620 break;
1621
1622 case BFA_IOIM_SM_ABORT_DONE:
1623 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1624 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1625 ioim);
1626 break;
1627
1628 case BFA_IOIM_SM_ABORT_COMP:
1629 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1630 bfa_ioim_move_to_comp_q(ioim);
1631 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1632 ioim);
1633 break;
1634
1635 case BFA_IOIM_SM_COMP_UTAG:
1636 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1637 bfa_ioim_move_to_comp_q(ioim);
1638 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1639 ioim);
1640 break;
1641
1642 case BFA_IOIM_SM_CLEANUP:
1643 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1644 ioim->iosp->abort_explicit = BFA_FALSE;
1645
1646 if (bfa_ioim_send_abort(ioim))
1647 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1648 else {
1649 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1650 bfa_stats(ioim->itnim, qwait);
1651 bfa_reqq_wait(ioim->bfa, ioim->reqq,
1652 &ioim->iosp->reqq_wait);
1653 }
1654 break;
1655
1656 case BFA_IOIM_SM_HWFAIL:
1657 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1658 bfa_ioim_move_to_comp_q(ioim);
1659 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1660 ioim);
1661 break;
1662
1663 default:
1664 bfa_sm_fault(ioim->bfa, event);
1665 }
1666 }
1667
1668 /*
1669 * IO is being cleaned up (implicit abort), waiting for completion from
1670 * firmware.
1671 */
1672 static void
1673 bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1674 {
1675 bfa_trc(ioim->bfa, ioim->iotag);
1676 bfa_trc(ioim->bfa, event);
1677
1678 switch (event) {
1679 case BFA_IOIM_SM_COMP_GOOD:
1680 case BFA_IOIM_SM_COMP:
1681 case BFA_IOIM_SM_DONE:
1682 case BFA_IOIM_SM_FREE:
1683 break;
1684
1685 case BFA_IOIM_SM_ABORT:
1686 /*
1687 * IO is already being aborted implicitly
1688 */
1689 ioim->io_cbfn = __bfa_cb_ioim_abort;
1690 break;
1691
1692 case BFA_IOIM_SM_ABORT_DONE:
1693 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1694 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1695 bfa_ioim_notify_cleanup(ioim);
1696 break;
1697
1698 case BFA_IOIM_SM_ABORT_COMP:
1699 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1700 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1701 bfa_ioim_notify_cleanup(ioim);
1702 break;
1703
1704 case BFA_IOIM_SM_COMP_UTAG:
1705 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1706 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1707 bfa_ioim_notify_cleanup(ioim);
1708 break;
1709
1710 case BFA_IOIM_SM_HWFAIL:
1711 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1712 bfa_ioim_move_to_comp_q(ioim);
1713 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1714 ioim);
1715 break;
1716
1717 case BFA_IOIM_SM_CLEANUP:
1718 /*
1719 * IO can be in cleanup state already due to TM command.
1720 * 2nd cleanup request comes from ITN offline event.
1721 */
1722 break;
1723
1724 default:
1725 bfa_sm_fault(ioim->bfa, event);
1726 }
1727 }
1728
1729 /*
1730 * IO is waiting for room in request CQ
1731 */
1732 static void
1733 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1734 {
1735 bfa_trc(ioim->bfa, ioim->iotag);
1736 bfa_trc(ioim->bfa, event);
1737
1738 switch (event) {
1739 case BFA_IOIM_SM_QRESUME:
1740 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1741 bfa_ioim_send_ioreq(ioim);
1742 break;
1743
1744 case BFA_IOIM_SM_ABORT:
1745 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1746 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1747 bfa_ioim_move_to_comp_q(ioim);
1748 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1749 ioim);
1750 break;
1751
1752 case BFA_IOIM_SM_CLEANUP:
1753 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1754 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1755 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1756 ioim);
1757 bfa_ioim_notify_cleanup(ioim);
1758 break;
1759
1760 case BFA_IOIM_SM_HWFAIL:
1761 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1762 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1763 bfa_ioim_move_to_comp_q(ioim);
1764 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1765 ioim);
1766 break;
1767
1768 default:
1769 bfa_sm_fault(ioim->bfa, event);
1770 }
1771 }
1772
1773 /*
1774 * Active IO is being aborted, waiting for room in request CQ.
1775 */
1776 static void
1777 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1778 {
1779 bfa_trc(ioim->bfa, ioim->iotag);
1780 bfa_trc(ioim->bfa, event);
1781
1782 switch (event) {
1783 case BFA_IOIM_SM_QRESUME:
1784 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1785 bfa_ioim_send_abort(ioim);
1786 break;
1787
1788 case BFA_IOIM_SM_CLEANUP:
1789 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1790 ioim->iosp->abort_explicit = BFA_FALSE;
1791 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1792 break;
1793
1794 case BFA_IOIM_SM_COMP_GOOD:
1795 case BFA_IOIM_SM_COMP:
1796 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1797 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1798 bfa_ioim_move_to_comp_q(ioim);
1799 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1800 ioim);
1801 break;
1802
1803 case BFA_IOIM_SM_DONE:
1804 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1805 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1806 bfa_ioim_move_to_comp_q(ioim);
1807 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1808 ioim);
1809 break;
1810
1811 case BFA_IOIM_SM_HWFAIL:
1812 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1813 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1814 bfa_ioim_move_to_comp_q(ioim);
1815 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1816 ioim);
1817 break;
1818
1819 default:
1820 bfa_sm_fault(ioim->bfa, event);
1821 }
1822 }
1823
1824 /*
1825 * Active IO is being cleaned up, waiting for room in request CQ.
1826 */
1827 static void
1828 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1829 {
1830 bfa_trc(ioim->bfa, ioim->iotag);
1831 bfa_trc(ioim->bfa, event);
1832
1833 switch (event) {
1834 case BFA_IOIM_SM_QRESUME:
1835 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1836 bfa_ioim_send_abort(ioim);
1837 break;
1838
1839 case BFA_IOIM_SM_ABORT:
1840 /*
1841 * IO is already being cleaned up implicitly
1842 */
1843 ioim->io_cbfn = __bfa_cb_ioim_abort;
1844 break;
1845
1846 case BFA_IOIM_SM_COMP_GOOD:
1847 case BFA_IOIM_SM_COMP:
1848 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1849 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1850 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1851 bfa_ioim_notify_cleanup(ioim);
1852 break;
1853
1854 case BFA_IOIM_SM_DONE:
1855 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1856 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1857 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1858 bfa_ioim_notify_cleanup(ioim);
1859 break;
1860
1861 case BFA_IOIM_SM_HWFAIL:
1862 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1863 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1864 bfa_ioim_move_to_comp_q(ioim);
1865 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1866 ioim);
1867 break;
1868
1869 default:
1870 bfa_sm_fault(ioim->bfa, event);
1871 }
1872 }
1873
1874 /*
1875 * IO bfa callback is pending.
1876 */
1877 static void
1878 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1879 {
1880 switch (event) {
1881 case BFA_IOIM_SM_HCB:
1882 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
1883 bfa_ioim_free(ioim);
1884 break;
1885
1886 case BFA_IOIM_SM_CLEANUP:
1887 bfa_ioim_notify_cleanup(ioim);
1888 break;
1889
1890 case BFA_IOIM_SM_HWFAIL:
1891 break;
1892
1893 default:
1894 bfa_sm_fault(ioim->bfa, event);
1895 }
1896 }
1897
1898 /*
1899 * IO bfa callback is pending. IO resource cannot be freed.
1900 */
1901 static void
1902 bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1903 {
1904 bfa_trc(ioim->bfa, ioim->iotag);
1905 bfa_trc(ioim->bfa, event);
1906
1907 switch (event) {
1908 case BFA_IOIM_SM_HCB:
1909 bfa_sm_set_state(ioim, bfa_ioim_sm_resfree);
1910 list_del(&ioim->qe);
1911 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_resfree_q);
1912 break;
1913
1914 case BFA_IOIM_SM_FREE:
1915 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1916 break;
1917
1918 case BFA_IOIM_SM_CLEANUP:
1919 bfa_ioim_notify_cleanup(ioim);
1920 break;
1921
1922 case BFA_IOIM_SM_HWFAIL:
1923 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1924 break;
1925
1926 default:
1927 bfa_sm_fault(ioim->bfa, event);
1928 }
1929 }
1930
1931 /*
1932 * IO is completed, waiting resource free from firmware.
1933 */
1934 static void
1935 bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1936 {
1937 bfa_trc(ioim->bfa, ioim->iotag);
1938 bfa_trc(ioim->bfa, event);
1939
1940 switch (event) {
1941 case BFA_IOIM_SM_FREE:
1942 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
1943 bfa_ioim_free(ioim);
1944 break;
1945
1946 case BFA_IOIM_SM_CLEANUP:
1947 bfa_ioim_notify_cleanup(ioim);
1948 break;
1949
1950 case BFA_IOIM_SM_HWFAIL:
1951 break;
1952
1953 default:
1954 bfa_sm_fault(ioim->bfa, event);
1955 }
1956 }
1957
1958
1959 static void
1960 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
1961 {
1962 struct bfa_ioim_s *ioim = cbarg;
1963
1964 if (!complete) {
1965 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
1966 return;
1967 }
1968
1969 bfa_cb_ioim_good_comp(ioim->bfa->bfad, ioim->dio);
1970 }
1971
1972 static void
1973 __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
1974 {
1975 struct bfa_ioim_s *ioim = cbarg;
1976 struct bfi_ioim_rsp_s *m;
1977 u8 *snsinfo = NULL;
1978 u8 sns_len = 0;
1979 s32 residue = 0;
1980
1981 if (!complete) {
1982 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
1983 return;
1984 }
1985
1986 m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
1987 if (m->io_status == BFI_IOIM_STS_OK) {
1988 /*
1989 * setup sense information, if present
1990 */
1991 if ((m->scsi_status == SCSI_STATUS_CHECK_CONDITION) &&
1992 m->sns_len) {
1993 sns_len = m->sns_len;
1994 snsinfo = ioim->iosp->snsinfo;
1995 }
1996
1997 /*
1998 * setup residue value correctly for normal completions
1999 */
2000 if (m->resid_flags == FCP_RESID_UNDER) {
2001 residue = be32_to_cpu(m->residue);
2002 bfa_stats(ioim->itnim, iocomp_underrun);
2003 }
2004 if (m->resid_flags == FCP_RESID_OVER) {
2005 residue = be32_to_cpu(m->residue);
2006 residue = -residue;
2007 bfa_stats(ioim->itnim, iocomp_overrun);
2008 }
2009 }
2010
2011 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, m->io_status,
2012 m->scsi_status, sns_len, snsinfo, residue);
2013 }
2014
2015 static void
2016 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
2017 {
2018 struct bfa_ioim_s *ioim = cbarg;
2019
2020 if (!complete) {
2021 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2022 return;
2023 }
2024
2025 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
2026 0, 0, NULL, 0);
2027 }
2028
2029 static void
2030 __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
2031 {
2032 struct bfa_ioim_s *ioim = cbarg;
2033
2034 bfa_stats(ioim->itnim, path_tov_expired);
2035 if (!complete) {
2036 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2037 return;
2038 }
2039
2040 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
2041 0, 0, NULL, 0);
2042 }
2043
2044 static void
2045 __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
2046 {
2047 struct bfa_ioim_s *ioim = cbarg;
2048
2049 if (!complete) {
2050 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2051 return;
2052 }
2053
2054 bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
2055 }
2056
2057 static void
2058 bfa_ioim_sgpg_alloced(void *cbarg)
2059 {
2060 struct bfa_ioim_s *ioim = cbarg;
2061
2062 ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2063 list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
2064 ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2065 bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
2066 }
2067
2068 /*
2069 * Send I/O request to firmware.
2070 */
2071 static bfa_boolean_t
2072 bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
2073 {
2074 struct bfa_itnim_s *itnim = ioim->itnim;
2075 struct bfi_ioim_req_s *m;
2076 static struct fcp_cmnd_s cmnd_z0 = { { { 0 } } };
2077 struct bfi_sge_s *sge, *sgpge;
2078 u32 pgdlen = 0;
2079 u32 fcp_dl;
2080 u64 addr;
2081 struct scatterlist *sg;
2082 struct bfa_sgpg_s *sgpg;
2083 struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
2084 u32 i, sge_id, pgcumsz;
2085 enum dma_data_direction dmadir;
2086
2087 /*
2088 * check for room in queue to send request now
2089 */
2090 m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2091 if (!m) {
2092 bfa_stats(ioim->itnim, qwait);
2093 bfa_reqq_wait(ioim->bfa, ioim->reqq,
2094 &ioim->iosp->reqq_wait);
2095 return BFA_FALSE;
2096 }
2097
2098 /*
2099 * build i/o request message next
2100 */
2101 m->io_tag = cpu_to_be16(ioim->iotag);
2102 m->rport_hdl = ioim->itnim->rport->fw_handle;
2103 m->io_timeout = 0;
2104
2105 sge = &m->sges[0];
2106 sgpg = ioim->sgpg;
2107 sge_id = 0;
2108 sgpge = NULL;
2109 pgcumsz = 0;
2110 scsi_for_each_sg(cmnd, sg, ioim->nsges, i) {
2111 if (i == 0) {
2112 /* build inline IO SG element */
2113 addr = bfa_sgaddr_le(sg_dma_address(sg));
2114 sge->sga = *(union bfi_addr_u *) &addr;
2115 pgdlen = sg_dma_len(sg);
2116 sge->sg_len = pgdlen;
2117 sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
2118 BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
2119 bfa_sge_to_be(sge);
2120 sge++;
2121 } else {
2122 if (sge_id == 0)
2123 sgpge = sgpg->sgpg->sges;
2124
2125 addr = bfa_sgaddr_le(sg_dma_address(sg));
2126 sgpge->sga = *(union bfi_addr_u *) &addr;
2127 sgpge->sg_len = sg_dma_len(sg);
2128 pgcumsz += sgpge->sg_len;
2129
2130 /* set flags */
2131 if (i < (ioim->nsges - 1) &&
2132 sge_id < (BFI_SGPG_DATA_SGES - 1))
2133 sgpge->flags = BFI_SGE_DATA;
2134 else if (i < (ioim->nsges - 1))
2135 sgpge->flags = BFI_SGE_DATA_CPL;
2136 else
2137 sgpge->flags = BFI_SGE_DATA_LAST;
2138
2139 bfa_sge_to_le(sgpge);
2140
2141 sgpge++;
2142 if (i == (ioim->nsges - 1)) {
2143 sgpge->flags = BFI_SGE_PGDLEN;
2144 sgpge->sga.a32.addr_lo = 0;
2145 sgpge->sga.a32.addr_hi = 0;
2146 sgpge->sg_len = pgcumsz;
2147 bfa_sge_to_le(sgpge);
2148 } else if (++sge_id == BFI_SGPG_DATA_SGES) {
2149 sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
2150 sgpge->flags = BFI_SGE_LINK;
2151 sgpge->sga = sgpg->sgpg_pa;
2152 sgpge->sg_len = pgcumsz;
2153 bfa_sge_to_le(sgpge);
2154 sge_id = 0;
2155 pgcumsz = 0;
2156 }
2157 }
2158 }
2159
2160 if (ioim->nsges > BFI_SGE_INLINE) {
2161 sge->sga = ioim->sgpg->sgpg_pa;
2162 } else {
2163 sge->sga.a32.addr_lo = 0;
2164 sge->sga.a32.addr_hi = 0;
2165 }
2166 sge->sg_len = pgdlen;
2167 sge->flags = BFI_SGE_PGDLEN;
2168 bfa_sge_to_be(sge);
2169
2170 /*
2171 * set up I/O command parameters
2172 */
2173 m->cmnd = cmnd_z0;
2174 int_to_scsilun(cmnd->device->lun, &m->cmnd.lun);
2175 dmadir = cmnd->sc_data_direction;
2176 if (dmadir == DMA_TO_DEVICE)
2177 m->cmnd.iodir = FCP_IODIR_WRITE;
2178 else if (dmadir == DMA_FROM_DEVICE)
2179 m->cmnd.iodir = FCP_IODIR_READ;
2180 else
2181 m->cmnd.iodir = FCP_IODIR_NONE;
2182
2183 m->cmnd.cdb = *(struct scsi_cdb_s *) cmnd->cmnd;
2184 fcp_dl = scsi_bufflen(cmnd);
2185 m->cmnd.fcp_dl = cpu_to_be32(fcp_dl);
2186
2187 /*
2188 * set up I/O message header
2189 */
2190 switch (m->cmnd.iodir) {
2191 case FCP_IODIR_READ:
2192 bfi_h2i_set(m->mh, BFI_MC_IOIM_READ, 0, bfa_lpuid(ioim->bfa));
2193 bfa_stats(itnim, input_reqs);
2194 ioim->itnim->stats.rd_throughput += fcp_dl;
2195 break;
2196 case FCP_IODIR_WRITE:
2197 bfi_h2i_set(m->mh, BFI_MC_IOIM_WRITE, 0, bfa_lpuid(ioim->bfa));
2198 bfa_stats(itnim, output_reqs);
2199 ioim->itnim->stats.wr_throughput += fcp_dl;
2200 break;
2201 case FCP_IODIR_RW:
2202 bfa_stats(itnim, input_reqs);
2203 bfa_stats(itnim, output_reqs);
2204 default:
2205 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
2206 }
2207 if (itnim->seq_rec ||
2208 (scsi_bufflen(cmnd) & (sizeof(u32) - 1)))
2209 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
2210
2211 /*
2212 * queue I/O message to firmware
2213 */
2214 bfa_reqq_produce(ioim->bfa, ioim->reqq);
2215 return BFA_TRUE;
2216 }
2217
2218 /*
2219 * Setup any additional SG pages needed.Inline SG element is setup
2220 * at queuing time.
2221 */
2222 static bfa_boolean_t
2223 bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim)
2224 {
2225 u16 nsgpgs;
2226
2227 WARN_ON(ioim->nsges <= BFI_SGE_INLINE);
2228
2229 /*
2230 * allocate SG pages needed
2231 */
2232 nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2233 if (!nsgpgs)
2234 return BFA_TRUE;
2235
2236 if (bfa_sgpg_malloc(ioim->bfa, &ioim->sgpg_q, nsgpgs)
2237 != BFA_STATUS_OK) {
2238 bfa_sgpg_wait(ioim->bfa, &ioim->iosp->sgpg_wqe, nsgpgs);
2239 return BFA_FALSE;
2240 }
2241
2242 ioim->nsgpgs = nsgpgs;
2243 ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2244
2245 return BFA_TRUE;
2246 }
2247
2248 /*
2249 * Send I/O abort request to firmware.
2250 */
2251 static bfa_boolean_t
2252 bfa_ioim_send_abort(struct bfa_ioim_s *ioim)
2253 {
2254 struct bfi_ioim_abort_req_s *m;
2255 enum bfi_ioim_h2i msgop;
2256
2257 /*
2258 * check for room in queue to send request now
2259 */
2260 m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2261 if (!m)
2262 return BFA_FALSE;
2263
2264 /*
2265 * build i/o request message next
2266 */
2267 if (ioim->iosp->abort_explicit)
2268 msgop = BFI_IOIM_H2I_IOABORT_REQ;
2269 else
2270 msgop = BFI_IOIM_H2I_IOCLEANUP_REQ;
2271
2272 bfi_h2i_set(m->mh, BFI_MC_IOIM, msgop, bfa_lpuid(ioim->bfa));
2273 m->io_tag = cpu_to_be16(ioim->iotag);
2274 m->abort_tag = ++ioim->abort_tag;
2275
2276 /*
2277 * queue I/O message to firmware
2278 */
2279 bfa_reqq_produce(ioim->bfa, ioim->reqq);
2280 return BFA_TRUE;
2281 }
2282
2283 /*
2284 * Call to resume any I/O requests waiting for room in request queue.
2285 */
2286 static void
2287 bfa_ioim_qresume(void *cbarg)
2288 {
2289 struct bfa_ioim_s *ioim = cbarg;
2290
2291 bfa_stats(ioim->itnim, qresumes);
2292 bfa_sm_send_event(ioim, BFA_IOIM_SM_QRESUME);
2293 }
2294
2295
2296 static void
2297 bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
2298 {
2299 /*
2300 * Move IO from itnim queue to fcpim global queue since itnim will be
2301 * freed.
2302 */
2303 list_del(&ioim->qe);
2304 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
2305
2306 if (!ioim->iosp->tskim) {
2307 if (ioim->fcpim->delay_comp && ioim->itnim->iotov_active) {
2308 bfa_cb_dequeue(&ioim->hcb_qe);
2309 list_del(&ioim->qe);
2310 list_add_tail(&ioim->qe, &ioim->itnim->delay_comp_q);
2311 }
2312 bfa_itnim_iodone(ioim->itnim);
2313 } else
2314 bfa_wc_down(&ioim->iosp->tskim->wc);
2315 }
2316
2317 static bfa_boolean_t
2318 bfa_ioim_is_abortable(struct bfa_ioim_s *ioim)
2319 {
2320 if ((bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit) &&
2321 (!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim))) ||
2322 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort)) ||
2323 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort_qfull)) ||
2324 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb)) ||
2325 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb_free)) ||
2326 (bfa_sm_cmp_state(ioim, bfa_ioim_sm_resfree)))
2327 return BFA_FALSE;
2328
2329 return BFA_TRUE;
2330 }
2331
2332 void
2333 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
2334 {
2335 /*
2336 * If path tov timer expired, failback with PATHTOV status - these
2337 * IO requests are not normally retried by IO stack.
2338 *
2339 * Otherwise device cameback online and fail it with normal failed
2340 * status so that IO stack retries these failed IO requests.
2341 */
2342 if (iotov)
2343 ioim->io_cbfn = __bfa_cb_ioim_pathtov;
2344 else {
2345 ioim->io_cbfn = __bfa_cb_ioim_failed;
2346 bfa_stats(ioim->itnim, iocom_nexus_abort);
2347 }
2348 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
2349
2350 /*
2351 * Move IO to fcpim global queue since itnim will be
2352 * freed.
2353 */
2354 list_del(&ioim->qe);
2355 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
2356 }
2357
2358
2359 /*
2360 * Memory allocation and initialization.
2361 */
2362 void
2363 bfa_ioim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
2364 {
2365 struct bfa_ioim_s *ioim;
2366 struct bfa_ioim_sp_s *iosp;
2367 u16 i;
2368 u8 *snsinfo;
2369 u32 snsbufsz;
2370
2371 /*
2372 * claim memory first
2373 */
2374 ioim = (struct bfa_ioim_s *) bfa_meminfo_kva(minfo);
2375 fcpim->ioim_arr = ioim;
2376 bfa_meminfo_kva(minfo) = (u8 *) (ioim + fcpim->num_ioim_reqs);
2377
2378 iosp = (struct bfa_ioim_sp_s *) bfa_meminfo_kva(minfo);
2379 fcpim->ioim_sp_arr = iosp;
2380 bfa_meminfo_kva(minfo) = (u8 *) (iosp + fcpim->num_ioim_reqs);
2381
2382 /*
2383 * Claim DMA memory for per IO sense data.
2384 */
2385 snsbufsz = fcpim->num_ioim_reqs * BFI_IOIM_SNSLEN;
2386 fcpim->snsbase.pa = bfa_meminfo_dma_phys(minfo);
2387 bfa_meminfo_dma_phys(minfo) += snsbufsz;
2388
2389 fcpim->snsbase.kva = bfa_meminfo_dma_virt(minfo);
2390 bfa_meminfo_dma_virt(minfo) += snsbufsz;
2391 snsinfo = fcpim->snsbase.kva;
2392 bfa_iocfc_set_snsbase(fcpim->bfa, fcpim->snsbase.pa);
2393
2394 /*
2395 * Initialize ioim free queues
2396 */
2397 INIT_LIST_HEAD(&fcpim->ioim_free_q);
2398 INIT_LIST_HEAD(&fcpim->ioim_resfree_q);
2399 INIT_LIST_HEAD(&fcpim->ioim_comp_q);
2400
2401 for (i = 0; i < fcpim->num_ioim_reqs;
2402 i++, ioim++, iosp++, snsinfo += BFI_IOIM_SNSLEN) {
2403 /*
2404 * initialize IOIM
2405 */
2406 memset(ioim, 0, sizeof(struct bfa_ioim_s));
2407 ioim->iotag = i;
2408 ioim->bfa = fcpim->bfa;
2409 ioim->fcpim = fcpim;
2410 ioim->iosp = iosp;
2411 iosp->snsinfo = snsinfo;
2412 INIT_LIST_HEAD(&ioim->sgpg_q);
2413 bfa_reqq_winit(&ioim->iosp->reqq_wait,
2414 bfa_ioim_qresume, ioim);
2415 bfa_sgpg_winit(&ioim->iosp->sgpg_wqe,
2416 bfa_ioim_sgpg_alloced, ioim);
2417 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2418
2419 list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
2420 }
2421 }
2422
2423 void
2424 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2425 {
2426 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
2427 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
2428 struct bfa_ioim_s *ioim;
2429 u16 iotag;
2430 enum bfa_ioim_event evt = BFA_IOIM_SM_COMP;
2431
2432 iotag = be16_to_cpu(rsp->io_tag);
2433
2434 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
2435 WARN_ON(ioim->iotag != iotag);
2436
2437 bfa_trc(ioim->bfa, ioim->iotag);
2438 bfa_trc(ioim->bfa, rsp->io_status);
2439 bfa_trc(ioim->bfa, rsp->reuse_io_tag);
2440
2441 if (bfa_sm_cmp_state(ioim, bfa_ioim_sm_active))
2442 ioim->iosp->comp_rspmsg = *m;
2443
2444 switch (rsp->io_status) {
2445 case BFI_IOIM_STS_OK:
2446 bfa_stats(ioim->itnim, iocomp_ok);
2447 if (rsp->reuse_io_tag == 0)
2448 evt = BFA_IOIM_SM_DONE;
2449 else
2450 evt = BFA_IOIM_SM_COMP;
2451 break;
2452
2453 case BFI_IOIM_STS_TIMEDOUT:
2454 bfa_stats(ioim->itnim, iocomp_timedout);
2455 case BFI_IOIM_STS_ABORTED:
2456 rsp->io_status = BFI_IOIM_STS_ABORTED;
2457 bfa_stats(ioim->itnim, iocomp_aborted);
2458 if (rsp->reuse_io_tag == 0)
2459 evt = BFA_IOIM_SM_DONE;
2460 else
2461 evt = BFA_IOIM_SM_COMP;
2462 break;
2463
2464 case BFI_IOIM_STS_PROTO_ERR:
2465 bfa_stats(ioim->itnim, iocom_proto_err);
2466 WARN_ON(!rsp->reuse_io_tag);
2467 evt = BFA_IOIM_SM_COMP;
2468 break;
2469
2470 case BFI_IOIM_STS_SQER_NEEDED:
2471 bfa_stats(ioim->itnim, iocom_sqer_needed);
2472 WARN_ON(rsp->reuse_io_tag != 0);
2473 evt = BFA_IOIM_SM_SQRETRY;
2474 break;
2475
2476 case BFI_IOIM_STS_RES_FREE:
2477 bfa_stats(ioim->itnim, iocom_res_free);
2478 evt = BFA_IOIM_SM_FREE;
2479 break;
2480
2481 case BFI_IOIM_STS_HOST_ABORTED:
2482 bfa_stats(ioim->itnim, iocom_hostabrts);
2483 if (rsp->abort_tag != ioim->abort_tag) {
2484 bfa_trc(ioim->bfa, rsp->abort_tag);
2485 bfa_trc(ioim->bfa, ioim->abort_tag);
2486 return;
2487 }
2488
2489 if (rsp->reuse_io_tag)
2490 evt = BFA_IOIM_SM_ABORT_COMP;
2491 else
2492 evt = BFA_IOIM_SM_ABORT_DONE;
2493 break;
2494
2495 case BFI_IOIM_STS_UTAG:
2496 bfa_stats(ioim->itnim, iocom_utags);
2497 evt = BFA_IOIM_SM_COMP_UTAG;
2498 break;
2499
2500 default:
2501 WARN_ON(1);
2502 }
2503
2504 bfa_sm_send_event(ioim, evt);
2505 }
2506
2507 void
2508 bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2509 {
2510 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
2511 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
2512 struct bfa_ioim_s *ioim;
2513 u16 iotag;
2514
2515 iotag = be16_to_cpu(rsp->io_tag);
2516
2517 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
2518 WARN_ON(BFA_IOIM_TAG_2_ID(ioim->iotag) != iotag);
2519
2520 bfa_ioim_cb_profile_comp(fcpim, ioim);
2521 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
2522 }
2523
2524 /*
2525 * Called by itnim to clean up IO while going offline.
2526 */
2527 void
2528 bfa_ioim_cleanup(struct bfa_ioim_s *ioim)
2529 {
2530 bfa_trc(ioim->bfa, ioim->iotag);
2531 bfa_stats(ioim->itnim, io_cleanups);
2532
2533 ioim->iosp->tskim = NULL;
2534 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
2535 }
2536
2537 void
2538 bfa_ioim_cleanup_tm(struct bfa_ioim_s *ioim, struct bfa_tskim_s *tskim)
2539 {
2540 bfa_trc(ioim->bfa, ioim->iotag);
2541 bfa_stats(ioim->itnim, io_tmaborts);
2542
2543 ioim->iosp->tskim = tskim;
2544 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
2545 }
2546
2547 /*
2548 * IOC failure handling.
2549 */
2550 void
2551 bfa_ioim_iocdisable(struct bfa_ioim_s *ioim)
2552 {
2553 bfa_trc(ioim->bfa, ioim->iotag);
2554 bfa_stats(ioim->itnim, io_iocdowns);
2555 bfa_sm_send_event(ioim, BFA_IOIM_SM_HWFAIL);
2556 }
2557
2558 /*
2559 * IO offline TOV popped. Fail the pending IO.
2560 */
2561 void
2562 bfa_ioim_tov(struct bfa_ioim_s *ioim)
2563 {
2564 bfa_trc(ioim->bfa, ioim->iotag);
2565 bfa_sm_send_event(ioim, BFA_IOIM_SM_IOTOV);
2566 }
2567
2568
2569 /*
2570 * Allocate IOIM resource for initiator mode I/O request.
2571 */
2572 struct bfa_ioim_s *
2573 bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
2574 struct bfa_itnim_s *itnim, u16 nsges)
2575 {
2576 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
2577 struct bfa_ioim_s *ioim;
2578
2579 /*
2580 * alocate IOIM resource
2581 */
2582 bfa_q_deq(&fcpim->ioim_free_q, &ioim);
2583 if (!ioim) {
2584 bfa_stats(itnim, no_iotags);
2585 return NULL;
2586 }
2587
2588 ioim->dio = dio;
2589 ioim->itnim = itnim;
2590 ioim->nsges = nsges;
2591 ioim->nsgpgs = 0;
2592
2593 bfa_stats(itnim, total_ios);
2594 fcpim->ios_active++;
2595
2596 list_add_tail(&ioim->qe, &itnim->io_q);
2597
2598 return ioim;
2599 }
2600
2601 void
2602 bfa_ioim_free(struct bfa_ioim_s *ioim)
2603 {
2604 struct bfa_fcpim_mod_s *fcpim = ioim->fcpim;
2605
2606 if (ioim->nsgpgs > 0)
2607 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
2608
2609 bfa_stats(ioim->itnim, io_comps);
2610 fcpim->ios_active--;
2611
2612 ioim->iotag &= BFA_IOIM_IOTAG_MASK;
2613 list_del(&ioim->qe);
2614 list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
2615 }
2616
2617 void
2618 bfa_ioim_start(struct bfa_ioim_s *ioim)
2619 {
2620 bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
2621
2622 /*
2623 * Obtain the queue over which this request has to be issued
2624 */
2625 ioim->reqq = bfa_fcpim_ioredirect_enabled(ioim->bfa) ?
2626 BFA_FALSE : bfa_itnim_get_reqq(ioim);
2627
2628 bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
2629 }
2630
2631 /*
2632 * Driver I/O abort request.
2633 */
2634 bfa_status_t
2635 bfa_ioim_abort(struct bfa_ioim_s *ioim)
2636 {
2637
2638 bfa_trc(ioim->bfa, ioim->iotag);
2639
2640 if (!bfa_ioim_is_abortable(ioim))
2641 return BFA_STATUS_FAILED;
2642
2643 bfa_stats(ioim->itnim, io_aborts);
2644 bfa_sm_send_event(ioim, BFA_IOIM_SM_ABORT);
2645
2646 return BFA_STATUS_OK;
2647 }
2648
2649 /*
2650 * BFA TSKIM state machine functions
2651 */
2652
2653 /*
2654 * Task management command beginning state.
2655 */
2656 static void
2657 bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2658 {
2659 bfa_trc(tskim->bfa, event);
2660
2661 switch (event) {
2662 case BFA_TSKIM_SM_START:
2663 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
2664 bfa_tskim_gather_ios(tskim);
2665
2666 /*
2667 * If device is offline, do not send TM on wire. Just cleanup
2668 * any pending IO requests and complete TM request.
2669 */
2670 if (!bfa_itnim_is_online(tskim->itnim)) {
2671 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
2672 tskim->tsk_status = BFI_TSKIM_STS_OK;
2673 bfa_tskim_cleanup_ios(tskim);
2674 return;
2675 }
2676
2677 if (!bfa_tskim_send(tskim)) {
2678 bfa_sm_set_state(tskim, bfa_tskim_sm_qfull);
2679 bfa_stats(tskim->itnim, tm_qwait);
2680 bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
2681 &tskim->reqq_wait);
2682 }
2683 break;
2684
2685 default:
2686 bfa_sm_fault(tskim->bfa, event);
2687 }
2688 }
2689
2690 /*
2691 * TM command is active, awaiting completion from firmware to
2692 * cleanup IO requests in TM scope.
2693 */
2694 static void
2695 bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2696 {
2697 bfa_trc(tskim->bfa, event);
2698
2699 switch (event) {
2700 case BFA_TSKIM_SM_DONE:
2701 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
2702 bfa_tskim_cleanup_ios(tskim);
2703 break;
2704
2705 case BFA_TSKIM_SM_CLEANUP:
2706 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
2707 if (!bfa_tskim_send_abort(tskim)) {
2708 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup_qfull);
2709 bfa_stats(tskim->itnim, tm_qwait);
2710 bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
2711 &tskim->reqq_wait);
2712 }
2713 break;
2714
2715 case BFA_TSKIM_SM_HWFAIL:
2716 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2717 bfa_tskim_iocdisable_ios(tskim);
2718 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
2719 break;
2720
2721 default:
2722 bfa_sm_fault(tskim->bfa, event);
2723 }
2724 }
2725
2726 /*
2727 * An active TM is being cleaned up since ITN is offline. Awaiting cleanup
2728 * completion event from firmware.
2729 */
2730 static void
2731 bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2732 {
2733 bfa_trc(tskim->bfa, event);
2734
2735 switch (event) {
2736 case BFA_TSKIM_SM_DONE:
2737 /*
2738 * Ignore and wait for ABORT completion from firmware.
2739 */
2740 break;
2741
2742 case BFA_TSKIM_SM_CLEANUP_DONE:
2743 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
2744 bfa_tskim_cleanup_ios(tskim);
2745 break;
2746
2747 case BFA_TSKIM_SM_HWFAIL:
2748 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2749 bfa_tskim_iocdisable_ios(tskim);
2750 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
2751 break;
2752
2753 default:
2754 bfa_sm_fault(tskim->bfa, event);
2755 }
2756 }
2757
2758 static void
2759 bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2760 {
2761 bfa_trc(tskim->bfa, event);
2762
2763 switch (event) {
2764 case BFA_TSKIM_SM_IOS_DONE:
2765 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2766 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_done);
2767 break;
2768
2769 case BFA_TSKIM_SM_CLEANUP:
2770 /*
2771 * Ignore, TM command completed on wire.
2772 * Notify TM conmpletion on IO cleanup completion.
2773 */
2774 break;
2775
2776 case BFA_TSKIM_SM_HWFAIL:
2777 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2778 bfa_tskim_iocdisable_ios(tskim);
2779 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
2780 break;
2781
2782 default:
2783 bfa_sm_fault(tskim->bfa, event);
2784 }
2785 }
2786
2787 /*
2788 * Task management command is waiting for room in request CQ
2789 */
2790 static void
2791 bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2792 {
2793 bfa_trc(tskim->bfa, event);
2794
2795 switch (event) {
2796 case BFA_TSKIM_SM_QRESUME:
2797 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
2798 bfa_tskim_send(tskim);
2799 break;
2800
2801 case BFA_TSKIM_SM_CLEANUP:
2802 /*
2803 * No need to send TM on wire since ITN is offline.
2804 */
2805 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
2806 bfa_reqq_wcancel(&tskim->reqq_wait);
2807 bfa_tskim_cleanup_ios(tskim);
2808 break;
2809
2810 case BFA_TSKIM_SM_HWFAIL:
2811 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2812 bfa_reqq_wcancel(&tskim->reqq_wait);
2813 bfa_tskim_iocdisable_ios(tskim);
2814 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
2815 break;
2816
2817 default:
2818 bfa_sm_fault(tskim->bfa, event);
2819 }
2820 }
2821
2822 /*
2823 * Task management command is active, awaiting for room in request CQ
2824 * to send clean up request.
2825 */
2826 static void
2827 bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
2828 enum bfa_tskim_event event)
2829 {
2830 bfa_trc(tskim->bfa, event);
2831
2832 switch (event) {
2833 case BFA_TSKIM_SM_DONE:
2834 bfa_reqq_wcancel(&tskim->reqq_wait);
2835 /*
2836 * Fall through !!!
2837 */
2838 case BFA_TSKIM_SM_QRESUME:
2839 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
2840 bfa_tskim_send_abort(tskim);
2841 break;
2842
2843 case BFA_TSKIM_SM_HWFAIL:
2844 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
2845 bfa_reqq_wcancel(&tskim->reqq_wait);
2846 bfa_tskim_iocdisable_ios(tskim);
2847 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
2848 break;
2849
2850 default:
2851 bfa_sm_fault(tskim->bfa, event);
2852 }
2853 }
2854
2855 /*
2856 * BFA callback is pending
2857 */
2858 static void
2859 bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
2860 {
2861 bfa_trc(tskim->bfa, event);
2862
2863 switch (event) {
2864 case BFA_TSKIM_SM_HCB:
2865 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
2866 bfa_tskim_free(tskim);
2867 break;
2868
2869 case BFA_TSKIM_SM_CLEANUP:
2870 bfa_tskim_notify_comp(tskim);
2871 break;
2872
2873 case BFA_TSKIM_SM_HWFAIL:
2874 break;
2875
2876 default:
2877 bfa_sm_fault(tskim->bfa, event);
2878 }
2879 }
2880
2881 static void
2882 __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete)
2883 {
2884 struct bfa_tskim_s *tskim = cbarg;
2885
2886 if (!complete) {
2887 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
2888 return;
2889 }
2890
2891 bfa_stats(tskim->itnim, tm_success);
2892 bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk, tskim->tsk_status);
2893 }
2894
2895 static void
2896 __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete)
2897 {
2898 struct bfa_tskim_s *tskim = cbarg;
2899
2900 if (!complete) {
2901 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
2902 return;
2903 }
2904
2905 bfa_stats(tskim->itnim, tm_failures);
2906 bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk,
2907 BFI_TSKIM_STS_FAILED);
2908 }
2909
2910 static bfa_boolean_t
2911 bfa_tskim_match_scope(struct bfa_tskim_s *tskim, struct scsi_lun lun)
2912 {
2913 switch (tskim->tm_cmnd) {
2914 case FCP_TM_TARGET_RESET:
2915 return BFA_TRUE;
2916
2917 case FCP_TM_ABORT_TASK_SET:
2918 case FCP_TM_CLEAR_TASK_SET:
2919 case FCP_TM_LUN_RESET:
2920 case FCP_TM_CLEAR_ACA:
2921 return !memcmp(&tskim->lun, &lun, sizeof(lun));
2922
2923 default:
2924 WARN_ON(1);
2925 }
2926
2927 return BFA_FALSE;
2928 }
2929
2930 /*
2931 * Gather affected IO requests and task management commands.
2932 */
2933 static void
2934 bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
2935 {
2936 struct bfa_itnim_s *itnim = tskim->itnim;
2937 struct bfa_ioim_s *ioim;
2938 struct list_head *qe, *qen;
2939 struct scsi_cmnd *cmnd;
2940 struct scsi_lun scsilun;
2941
2942 INIT_LIST_HEAD(&tskim->io_q);
2943
2944 /*
2945 * Gather any active IO requests first.
2946 */
2947 list_for_each_safe(qe, qen, &itnim->io_q) {
2948 ioim = (struct bfa_ioim_s *) qe;
2949 cmnd = (struct scsi_cmnd *) ioim->dio;
2950 int_to_scsilun(cmnd->device->lun, &scsilun);
2951 if (bfa_tskim_match_scope(tskim, scsilun)) {
2952 list_del(&ioim->qe);
2953 list_add_tail(&ioim->qe, &tskim->io_q);
2954 }
2955 }
2956
2957 /*
2958 * Failback any pending IO requests immediately.
2959 */
2960 list_for_each_safe(qe, qen, &itnim->pending_q) {
2961 ioim = (struct bfa_ioim_s *) qe;
2962 cmnd = (struct scsi_cmnd *) ioim->dio;
2963 int_to_scsilun(cmnd->device->lun, &scsilun);
2964 if (bfa_tskim_match_scope(tskim, scsilun)) {
2965 list_del(&ioim->qe);
2966 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
2967 bfa_ioim_tov(ioim);
2968 }
2969 }
2970 }
2971
2972 /*
2973 * IO cleanup completion
2974 */
2975 static void
2976 bfa_tskim_cleanp_comp(void *tskim_cbarg)
2977 {
2978 struct bfa_tskim_s *tskim = tskim_cbarg;
2979
2980 bfa_stats(tskim->itnim, tm_io_comps);
2981 bfa_sm_send_event(tskim, BFA_TSKIM_SM_IOS_DONE);
2982 }
2983
2984 /*
2985 * Gather affected IO requests and task management commands.
2986 */
2987 static void
2988 bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim)
2989 {
2990 struct bfa_ioim_s *ioim;
2991 struct list_head *qe, *qen;
2992
2993 bfa_wc_init(&tskim->wc, bfa_tskim_cleanp_comp, tskim);
2994
2995 list_for_each_safe(qe, qen, &tskim->io_q) {
2996 ioim = (struct bfa_ioim_s *) qe;
2997 bfa_wc_up(&tskim->wc);
2998 bfa_ioim_cleanup_tm(ioim, tskim);
2999 }
3000
3001 bfa_wc_wait(&tskim->wc);
3002 }
3003
3004 /*
3005 * Send task management request to firmware.
3006 */
3007 static bfa_boolean_t
3008 bfa_tskim_send(struct bfa_tskim_s *tskim)
3009 {
3010 struct bfa_itnim_s *itnim = tskim->itnim;
3011 struct bfi_tskim_req_s *m;
3012
3013 /*
3014 * check for room in queue to send request now
3015 */
3016 m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3017 if (!m)
3018 return BFA_FALSE;
3019
3020 /*
3021 * build i/o request message next
3022 */
3023 bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_TM_REQ,
3024 bfa_lpuid(tskim->bfa));
3025
3026 m->tsk_tag = cpu_to_be16(tskim->tsk_tag);
3027 m->itn_fhdl = tskim->itnim->rport->fw_handle;
3028 m->t_secs = tskim->tsecs;
3029 m->lun = tskim->lun;
3030 m->tm_flags = tskim->tm_cmnd;
3031
3032 /*
3033 * queue I/O message to firmware
3034 */
3035 bfa_reqq_produce(tskim->bfa, itnim->reqq);
3036 return BFA_TRUE;
3037 }
3038
3039 /*
3040 * Send abort request to cleanup an active TM to firmware.
3041 */
3042 static bfa_boolean_t
3043 bfa_tskim_send_abort(struct bfa_tskim_s *tskim)
3044 {
3045 struct bfa_itnim_s *itnim = tskim->itnim;
3046 struct bfi_tskim_abortreq_s *m;
3047
3048 /*
3049 * check for room in queue to send request now
3050 */
3051 m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3052 if (!m)
3053 return BFA_FALSE;
3054
3055 /*
3056 * build i/o request message next
3057 */
3058 bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_ABORT_REQ,
3059 bfa_lpuid(tskim->bfa));
3060
3061 m->tsk_tag = cpu_to_be16(tskim->tsk_tag);
3062
3063 /*
3064 * queue I/O message to firmware
3065 */
3066 bfa_reqq_produce(tskim->bfa, itnim->reqq);
3067 return BFA_TRUE;
3068 }
3069
3070 /*
3071 * Call to resume task management cmnd waiting for room in request queue.
3072 */
3073 static void
3074 bfa_tskim_qresume(void *cbarg)
3075 {
3076 struct bfa_tskim_s *tskim = cbarg;
3077
3078 bfa_stats(tskim->itnim, tm_qresumes);
3079 bfa_sm_send_event(tskim, BFA_TSKIM_SM_QRESUME);
3080 }
3081
3082 /*
3083 * Cleanup IOs associated with a task mangement command on IOC failures.
3084 */
3085 static void
3086 bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim)
3087 {
3088 struct bfa_ioim_s *ioim;
3089 struct list_head *qe, *qen;
3090
3091 list_for_each_safe(qe, qen, &tskim->io_q) {
3092 ioim = (struct bfa_ioim_s *) qe;
3093 bfa_ioim_iocdisable(ioim);
3094 }
3095 }
3096
3097 /*
3098 * Notification on completions from related ioim.
3099 */
3100 void
3101 bfa_tskim_iodone(struct bfa_tskim_s *tskim)
3102 {
3103 bfa_wc_down(&tskim->wc);
3104 }
3105
3106 /*
3107 * Handle IOC h/w failure notification from itnim.
3108 */
3109 void
3110 bfa_tskim_iocdisable(struct bfa_tskim_s *tskim)
3111 {
3112 tskim->notify = BFA_FALSE;
3113 bfa_stats(tskim->itnim, tm_iocdowns);
3114 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HWFAIL);
3115 }
3116
3117 /*
3118 * Cleanup TM command and associated IOs as part of ITNIM offline.
3119 */
3120 void
3121 bfa_tskim_cleanup(struct bfa_tskim_s *tskim)
3122 {
3123 tskim->notify = BFA_TRUE;
3124 bfa_stats(tskim->itnim, tm_cleanups);
3125 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP);
3126 }
3127
3128 /*
3129 * Memory allocation and initialization.
3130 */
3131 void
3132 bfa_tskim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
3133 {
3134 struct bfa_tskim_s *tskim;
3135 u16 i;
3136
3137 INIT_LIST_HEAD(&fcpim->tskim_free_q);
3138
3139 tskim = (struct bfa_tskim_s *) bfa_meminfo_kva(minfo);
3140 fcpim->tskim_arr = tskim;
3141
3142 for (i = 0; i < fcpim->num_tskim_reqs; i++, tskim++) {
3143 /*
3144 * initialize TSKIM
3145 */
3146 memset(tskim, 0, sizeof(struct bfa_tskim_s));
3147 tskim->tsk_tag = i;
3148 tskim->bfa = fcpim->bfa;
3149 tskim->fcpim = fcpim;
3150 tskim->notify = BFA_FALSE;
3151 bfa_reqq_winit(&tskim->reqq_wait, bfa_tskim_qresume,
3152 tskim);
3153 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
3154
3155 list_add_tail(&tskim->qe, &fcpim->tskim_free_q);
3156 }
3157
3158 bfa_meminfo_kva(minfo) = (u8 *) tskim;
3159 }
3160
3161 void
3162 bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3163 {
3164 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
3165 struct bfi_tskim_rsp_s *rsp = (struct bfi_tskim_rsp_s *) m;
3166 struct bfa_tskim_s *tskim;
3167 u16 tsk_tag = be16_to_cpu(rsp->tsk_tag);
3168
3169 tskim = BFA_TSKIM_FROM_TAG(fcpim, tsk_tag);
3170 WARN_ON(tskim->tsk_tag != tsk_tag);
3171
3172 tskim->tsk_status = rsp->tsk_status;
3173
3174 /*
3175 * Firmware sends BFI_TSKIM_STS_ABORTED status for abort
3176 * requests. All other statuses are for normal completions.
3177 */
3178 if (rsp->tsk_status == BFI_TSKIM_STS_ABORTED) {
3179 bfa_stats(tskim->itnim, tm_cleanup_comps);
3180 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP_DONE);
3181 } else {
3182 bfa_stats(tskim->itnim, tm_fw_rsps);
3183 bfa_sm_send_event(tskim, BFA_TSKIM_SM_DONE);
3184 }
3185 }
3186
3187
3188 struct bfa_tskim_s *
3189 bfa_tskim_alloc(struct bfa_s *bfa, struct bfad_tskim_s *dtsk)
3190 {
3191 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
3192 struct bfa_tskim_s *tskim;
3193
3194 bfa_q_deq(&fcpim->tskim_free_q, &tskim);
3195
3196 if (tskim)
3197 tskim->dtsk = dtsk;
3198
3199 return tskim;
3200 }
3201
3202 void
3203 bfa_tskim_free(struct bfa_tskim_s *tskim)
3204 {
3205 WARN_ON(!bfa_q_is_on_q_func(&tskim->itnim->tsk_q, &tskim->qe));
3206 list_del(&tskim->qe);
3207 list_add_tail(&tskim->qe, &tskim->fcpim->tskim_free_q);
3208 }
3209
3210 /*
3211 * Start a task management command.
3212 *
3213 * @param[in] tskim BFA task management command instance
3214 * @param[in] itnim i-t nexus for the task management command
3215 * @param[in] lun lun, if applicable
3216 * @param[in] tm_cmnd Task management command code.
3217 * @param[in] t_secs Timeout in seconds
3218 *
3219 * @return None.
3220 */
3221 void
3222 bfa_tskim_start(struct bfa_tskim_s *tskim, struct bfa_itnim_s *itnim,
3223 struct scsi_lun lun,
3224 enum fcp_tm_cmnd tm_cmnd, u8 tsecs)
3225 {
3226 tskim->itnim = itnim;
3227 tskim->lun = lun;
3228 tskim->tm_cmnd = tm_cmnd;
3229 tskim->tsecs = tsecs;
3230 tskim->notify = BFA_FALSE;
3231 bfa_stats(itnim, tm_cmnds);
3232
3233 list_add_tail(&tskim->qe, &itnim->tsk_q);
3234 bfa_sm_send_event(tskim, BFA_TSKIM_SM_START);
3235 }