projects / GitHub / LineageOS / android_kernel_samsung_universal7580.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'wimax-2.6.35.y' of git://git.kernel.org/pub/scm/linux/kernel/git/inaky...
[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / scsi / bfa / bfa_ioim.c
1 /*
2 * Copyright (c) 2005-2009 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 <bfa.h>
19 #include <cs/bfa_debug.h>
20 #include <bfa_cb_ioim_macros.h>
21
22 BFA_TRC_FILE(HAL, IOIM);
23
24 /*
25 * forward declarations.
26 */
27 static bfa_boolean_t bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
28 static bfa_boolean_t bfa_ioim_sge_setup(struct bfa_ioim_s *ioim);
29 static void bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim);
30 static bfa_boolean_t bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
31 static void bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
32 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
33 static void __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete);
34 static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
35 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
36 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
37
38 /**
39 * bfa_ioim_sm
40 */
41
42 /**
43 * IO state machine events
44 */
45 enum bfa_ioim_event {
46 BFA_IOIM_SM_START = 1, /* io start request from host */
47 BFA_IOIM_SM_COMP_GOOD = 2, /* io good comp, resource free */
48 BFA_IOIM_SM_COMP = 3, /* io comp, resource is free */
49 BFA_IOIM_SM_COMP_UTAG = 4, /* io comp, resource is free */
50 BFA_IOIM_SM_DONE = 5, /* io comp, resource not free */
51 BFA_IOIM_SM_FREE = 6, /* io resource is freed */
52 BFA_IOIM_SM_ABORT = 7, /* abort request from scsi stack */
53 BFA_IOIM_SM_ABORT_COMP = 8, /* abort from f/w */
54 BFA_IOIM_SM_ABORT_DONE = 9, /* abort completion from f/w */
55 BFA_IOIM_SM_QRESUME = 10, /* CQ space available to queue IO */
56 BFA_IOIM_SM_SGALLOCED = 11, /* SG page allocation successful */
57 BFA_IOIM_SM_SQRETRY = 12, /* sequence recovery retry */
58 BFA_IOIM_SM_HCB = 13, /* bfa callback complete */
59 BFA_IOIM_SM_CLEANUP = 14, /* IO cleanup from itnim */
60 BFA_IOIM_SM_TMSTART = 15, /* IO cleanup from tskim */
61 BFA_IOIM_SM_TMDONE = 16, /* IO cleanup from tskim */
62 BFA_IOIM_SM_HWFAIL = 17, /* IOC h/w failure event */
63 BFA_IOIM_SM_IOTOV = 18, /* ITN offline TOV */
64 };
65
66 /*
67 * forward declaration of IO state machine
68 */
69 static void bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim,
70 enum bfa_ioim_event event);
71 static void bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim,
72 enum bfa_ioim_event event);
73 static void bfa_ioim_sm_active(struct bfa_ioim_s *ioim,
74 enum bfa_ioim_event event);
75 static void bfa_ioim_sm_abort(struct bfa_ioim_s *ioim,
76 enum bfa_ioim_event event);
77 static void bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim,
78 enum bfa_ioim_event event);
79 static void bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim,
80 enum bfa_ioim_event event);
81 static void bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim,
82 enum bfa_ioim_event event);
83 static void bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim,
84 enum bfa_ioim_event event);
85 static void bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim,
86 enum bfa_ioim_event event);
87 static void bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim,
88 enum bfa_ioim_event event);
89 static void bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
90 enum bfa_ioim_event event);
91
92 /**
93 * IO is not started (unallocated).
94 */
95 static void
96 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
97 {
98 bfa_trc_fp(ioim->bfa, ioim->iotag);
99 bfa_trc_fp(ioim->bfa, event);
100
101 switch (event) {
102 case BFA_IOIM_SM_START:
103 if (!bfa_itnim_is_online(ioim->itnim)) {
104 if (!bfa_itnim_hold_io(ioim->itnim)) {
105 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
106 list_del(&ioim->qe);
107 list_add_tail(&ioim->qe,
108 &ioim->fcpim->ioim_comp_q);
109 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
110 __bfa_cb_ioim_pathtov, ioim);
111 } else {
112 list_del(&ioim->qe);
113 list_add_tail(&ioim->qe,
114 &ioim->itnim->pending_q);
115 }
116 break;
117 }
118
119 if (ioim->nsges > BFI_SGE_INLINE) {
120 if (!bfa_ioim_sge_setup(ioim)) {
121 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
122 return;
123 }
124 }
125
126 if (!bfa_ioim_send_ioreq(ioim)) {
127 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
128 break;
129 }
130
131 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
132 break;
133
134 case BFA_IOIM_SM_IOTOV:
135 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
136 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
137 __bfa_cb_ioim_pathtov, ioim);
138 break;
139
140 case BFA_IOIM_SM_ABORT:
141 /**
142 * IO in pending queue can get abort requests. Complete abort
143 * requests immediately.
144 */
145 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
146 bfa_assert(bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
147 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
148 ioim);
149 break;
150
151 default:
152 bfa_sm_fault(ioim->bfa, event);
153 }
154 }
155
156 /**
157 * IO is waiting for SG pages.
158 */
159 static void
160 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
161 {
162 bfa_trc(ioim->bfa, ioim->iotag);
163 bfa_trc(ioim->bfa, event);
164
165 switch (event) {
166 case BFA_IOIM_SM_SGALLOCED:
167 if (!bfa_ioim_send_ioreq(ioim)) {
168 bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
169 break;
170 }
171 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
172 break;
173
174 case BFA_IOIM_SM_CLEANUP:
175 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
176 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
177 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
178 ioim);
179 bfa_ioim_notify_cleanup(ioim);
180 break;
181
182 case BFA_IOIM_SM_ABORT:
183 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
184 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
185 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
186 ioim);
187 break;
188
189 case BFA_IOIM_SM_HWFAIL:
190 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
191 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
192 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
193 ioim);
194 break;
195
196 default:
197 bfa_sm_fault(ioim->bfa, event);
198 }
199 }
200
201 /**
202 * IO is active.
203 */
204 static void
205 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
206 {
207 bfa_trc_fp(ioim->bfa, ioim->iotag);
208 bfa_trc_fp(ioim->bfa, event);
209
210 switch (event) {
211 case BFA_IOIM_SM_COMP_GOOD:
212 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
213 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
214 __bfa_cb_ioim_good_comp, ioim);
215 break;
216
217 case BFA_IOIM_SM_COMP:
218 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
219 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
220 ioim);
221 break;
222
223 case BFA_IOIM_SM_DONE:
224 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
225 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
226 ioim);
227 break;
228
229 case BFA_IOIM_SM_ABORT:
230 ioim->iosp->abort_explicit = BFA_TRUE;
231 ioim->io_cbfn = __bfa_cb_ioim_abort;
232
233 if (bfa_ioim_send_abort(ioim))
234 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
235 else {
236 bfa_sm_set_state(ioim, bfa_ioim_sm_abort_qfull);
237 bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
238 &ioim->iosp->reqq_wait);
239 }
240 break;
241
242 case BFA_IOIM_SM_CLEANUP:
243 ioim->iosp->abort_explicit = BFA_FALSE;
244 ioim->io_cbfn = __bfa_cb_ioim_failed;
245
246 if (bfa_ioim_send_abort(ioim))
247 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
248 else {
249 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
250 bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
251 &ioim->iosp->reqq_wait);
252 }
253 break;
254
255 case BFA_IOIM_SM_HWFAIL:
256 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
257 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
258 ioim);
259 break;
260
261 default:
262 bfa_sm_fault(ioim->bfa, event);
263 }
264 }
265
266 /**
267 * IO is being aborted, waiting for completion from firmware.
268 */
269 static void
270 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
271 {
272 bfa_trc(ioim->bfa, ioim->iotag);
273 bfa_trc(ioim->bfa, event);
274
275 switch (event) {
276 case BFA_IOIM_SM_COMP_GOOD:
277 case BFA_IOIM_SM_COMP:
278 case BFA_IOIM_SM_DONE:
279 case BFA_IOIM_SM_FREE:
280 break;
281
282 case BFA_IOIM_SM_ABORT_DONE:
283 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
284 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
285 ioim);
286 break;
287
288 case BFA_IOIM_SM_ABORT_COMP:
289 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
290 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
291 ioim);
292 break;
293
294 case BFA_IOIM_SM_COMP_UTAG:
295 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
296 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
297 ioim);
298 break;
299
300 case BFA_IOIM_SM_CLEANUP:
301 bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
302 ioim->iosp->abort_explicit = BFA_FALSE;
303
304 if (bfa_ioim_send_abort(ioim))
305 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
306 else {
307 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
308 bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
309 &ioim->iosp->reqq_wait);
310 }
311 break;
312
313 case BFA_IOIM_SM_HWFAIL:
314 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
315 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
316 ioim);
317 break;
318
319 default:
320 bfa_sm_fault(ioim->bfa, event);
321 }
322 }
323
324 /**
325 * IO is being cleaned up (implicit abort), waiting for completion from
326 * firmware.
327 */
328 static void
329 bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
330 {
331 bfa_trc(ioim->bfa, ioim->iotag);
332 bfa_trc(ioim->bfa, event);
333
334 switch (event) {
335 case BFA_IOIM_SM_COMP_GOOD:
336 case BFA_IOIM_SM_COMP:
337 case BFA_IOIM_SM_DONE:
338 case BFA_IOIM_SM_FREE:
339 break;
340
341 case BFA_IOIM_SM_ABORT:
342 /**
343 * IO is already being aborted implicitly
344 */
345 ioim->io_cbfn = __bfa_cb_ioim_abort;
346 break;
347
348 case BFA_IOIM_SM_ABORT_DONE:
349 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
350 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
351 bfa_ioim_notify_cleanup(ioim);
352 break;
353
354 case BFA_IOIM_SM_ABORT_COMP:
355 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
356 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
357 bfa_ioim_notify_cleanup(ioim);
358 break;
359
360 case BFA_IOIM_SM_COMP_UTAG:
361 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
362 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
363 bfa_ioim_notify_cleanup(ioim);
364 break;
365
366 case BFA_IOIM_SM_HWFAIL:
367 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
368 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
369 ioim);
370 break;
371
372 case BFA_IOIM_SM_CLEANUP:
373 /**
374 * IO can be in cleanup state already due to TM command. 2nd cleanup
375 * request comes from ITN offline event.
376 */
377 break;
378
379 default:
380 bfa_sm_fault(ioim->bfa, event);
381 }
382 }
383
384 /**
385 * IO is waiting for room in request CQ
386 */
387 static void
388 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
389 {
390 bfa_trc(ioim->bfa, ioim->iotag);
391 bfa_trc(ioim->bfa, event);
392
393 switch (event) {
394 case BFA_IOIM_SM_QRESUME:
395 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
396 bfa_ioim_send_ioreq(ioim);
397 break;
398
399 case BFA_IOIM_SM_ABORT:
400 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
401 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
402 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
403 ioim);
404 break;
405
406 case BFA_IOIM_SM_CLEANUP:
407 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
408 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
409 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
410 ioim);
411 bfa_ioim_notify_cleanup(ioim);
412 break;
413
414 case BFA_IOIM_SM_HWFAIL:
415 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
416 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
417 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
418 ioim);
419 break;
420
421 default:
422 bfa_sm_fault(ioim->bfa, event);
423 }
424 }
425
426 /**
427 * Active IO is being aborted, waiting for room in request CQ.
428 */
429 static void
430 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
431 {
432 bfa_trc(ioim->bfa, ioim->iotag);
433 bfa_trc(ioim->bfa, event);
434
435 switch (event) {
436 case BFA_IOIM_SM_QRESUME:
437 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
438 bfa_ioim_send_abort(ioim);
439 break;
440
441 case BFA_IOIM_SM_CLEANUP:
442 bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
443 ioim->iosp->abort_explicit = BFA_FALSE;
444 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
445 break;
446
447 case BFA_IOIM_SM_COMP_GOOD:
448 case BFA_IOIM_SM_COMP:
449 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
450 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
451 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
452 ioim);
453 break;
454
455 case BFA_IOIM_SM_DONE:
456 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
457 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
458 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
459 ioim);
460 break;
461
462 case BFA_IOIM_SM_HWFAIL:
463 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
464 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
465 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
466 ioim);
467 break;
468
469 default:
470 bfa_sm_fault(ioim->bfa, event);
471 }
472 }
473
474 /**
475 * Active IO is being cleaned up, waiting for room in request CQ.
476 */
477 static void
478 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
479 {
480 bfa_trc(ioim->bfa, ioim->iotag);
481 bfa_trc(ioim->bfa, event);
482
483 switch (event) {
484 case BFA_IOIM_SM_QRESUME:
485 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
486 bfa_ioim_send_abort(ioim);
487 break;
488
489 case BFA_IOIM_SM_ABORT:
490 /**
491 * IO is alraedy being cleaned up implicitly
492 */
493 ioim->io_cbfn = __bfa_cb_ioim_abort;
494 break;
495
496 case BFA_IOIM_SM_COMP_GOOD:
497 case BFA_IOIM_SM_COMP:
498 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
499 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
500 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
501 bfa_ioim_notify_cleanup(ioim);
502 break;
503
504 case BFA_IOIM_SM_DONE:
505 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
506 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
507 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
508 bfa_ioim_notify_cleanup(ioim);
509 break;
510
511 case BFA_IOIM_SM_HWFAIL:
512 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
513 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
514 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
515 ioim);
516 break;
517
518 default:
519 bfa_sm_fault(ioim->bfa, event);
520 }
521 }
522
523 /**
524 * IO bfa callback is pending.
525 */
526 static void
527 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
528 {
529 bfa_trc_fp(ioim->bfa, ioim->iotag);
530 bfa_trc_fp(ioim->bfa, event);
531
532 switch (event) {
533 case BFA_IOIM_SM_HCB:
534 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
535 bfa_ioim_free(ioim);
536 bfa_cb_ioim_resfree(ioim->bfa->bfad);
537 break;
538
539 case BFA_IOIM_SM_CLEANUP:
540 bfa_ioim_notify_cleanup(ioim);
541 break;
542
543 case BFA_IOIM_SM_HWFAIL:
544 break;
545
546 default:
547 bfa_sm_fault(ioim->bfa, event);
548 }
549 }
550
551 /**
552 * IO bfa callback is pending. IO resource cannot be freed.
553 */
554 static void
555 bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
556 {
557 bfa_trc(ioim->bfa, ioim->iotag);
558 bfa_trc(ioim->bfa, event);
559
560 switch (event) {
561 case BFA_IOIM_SM_HCB:
562 bfa_sm_set_state(ioim, bfa_ioim_sm_resfree);
563 list_del(&ioim->qe);
564 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_resfree_q);
565 break;
566
567 case BFA_IOIM_SM_FREE:
568 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
569 break;
570
571 case BFA_IOIM_SM_CLEANUP:
572 bfa_ioim_notify_cleanup(ioim);
573 break;
574
575 case BFA_IOIM_SM_HWFAIL:
576 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
577 break;
578
579 default:
580 bfa_sm_fault(ioim->bfa, event);
581 }
582 }
583
584 /**
585 * IO is completed, waiting resource free from firmware.
586 */
587 static void
588 bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
589 {
590 bfa_trc(ioim->bfa, ioim->iotag);
591 bfa_trc(ioim->bfa, event);
592
593 switch (event) {
594 case BFA_IOIM_SM_FREE:
595 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
596 bfa_ioim_free(ioim);
597 bfa_cb_ioim_resfree(ioim->bfa->bfad);
598 break;
599
600 case BFA_IOIM_SM_CLEANUP:
601 bfa_ioim_notify_cleanup(ioim);
602 break;
603
604 case BFA_IOIM_SM_HWFAIL:
605 break;
606
607 default:
608 bfa_sm_fault(ioim->bfa, event);
609 }
610 }
611
612
613
614 /**
615 * bfa_ioim_private
616 */
617
618 static void
619 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
620 {
621 struct bfa_ioim_s *ioim = cbarg;
622
623 if (!complete) {
624 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
625 return;
626 }
627
628 bfa_cb_ioim_good_comp(ioim->bfa->bfad, ioim->dio);
629 }
630
631 static void
632 __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
633 {
634 struct bfa_ioim_s *ioim = cbarg;
635 struct bfi_ioim_rsp_s *m;
636 u8 *snsinfo = NULL;
637 u8 sns_len = 0;
638 s32 residue = 0;
639
640 if (!complete) {
641 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
642 return;
643 }
644
645 m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
646 if (m->io_status == BFI_IOIM_STS_OK) {
647 /**
648 * setup sense information, if present
649 */
650 if (m->scsi_status == SCSI_STATUS_CHECK_CONDITION
651 && m->sns_len) {
652 sns_len = m->sns_len;
653 snsinfo = ioim->iosp->snsinfo;
654 }
655
656 /**
657 * setup residue value correctly for normal completions
658 */
659 if (m->resid_flags == FCP_RESID_UNDER)
660 residue = bfa_os_ntohl(m->residue);
661 if (m->resid_flags == FCP_RESID_OVER) {
662 residue = bfa_os_ntohl(m->residue);
663 residue = -residue;
664 }
665 }
666
667 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, m->io_status,
668 m->scsi_status, sns_len, snsinfo, residue);
669 }
670
671 static void
672 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
673 {
674 struct bfa_ioim_s *ioim = cbarg;
675
676 if (!complete) {
677 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
678 return;
679 }
680
681 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
682 0, 0, NULL, 0);
683 }
684
685 static void
686 __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
687 {
688 struct bfa_ioim_s *ioim = cbarg;
689
690 if (!complete) {
691 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
692 return;
693 }
694
695 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
696 0, 0, NULL, 0);
697 }
698
699 static void
700 __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
701 {
702 struct bfa_ioim_s *ioim = cbarg;
703
704 if (!complete) {
705 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
706 return;
707 }
708
709 bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
710 }
711
712 static void
713 bfa_ioim_sgpg_alloced(void *cbarg)
714 {
715 struct bfa_ioim_s *ioim = cbarg;
716
717 ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
718 list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
719 bfa_ioim_sgpg_setup(ioim);
720 bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
721 }
722
723 /**
724 * Send I/O request to firmware.
725 */
726 static bfa_boolean_t
727 bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
728 {
729 struct bfa_itnim_s *itnim = ioim->itnim;
730 struct bfi_ioim_req_s *m;
731 static struct fcp_cmnd_s cmnd_z0 = { 0 };
732 struct bfi_sge_s *sge;
733 u32 pgdlen = 0;
734 u64 addr;
735 struct scatterlist *sg;
736 struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
737
738 /**
739 * check for room in queue to send request now
740 */
741 m = bfa_reqq_next(ioim->bfa, itnim->reqq);
742 if (!m) {
743 bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
744 &ioim->iosp->reqq_wait);
745 return BFA_FALSE;
746 }
747
748 /**
749 * build i/o request message next
750 */
751 m->io_tag = bfa_os_htons(ioim->iotag);
752 m->rport_hdl = ioim->itnim->rport->fw_handle;
753 m->io_timeout = bfa_cb_ioim_get_timeout(ioim->dio);
754
755 /**
756 * build inline IO SG element here
757 */
758 sge = &m->sges[0];
759 if (ioim->nsges) {
760 sg = (struct scatterlist *)scsi_sglist(cmnd);
761 addr = bfa_os_sgaddr(sg_dma_address(sg));
762 sge->sga = *(union bfi_addr_u *) &addr;
763 pgdlen = sg_dma_len(sg);
764 sge->sg_len = pgdlen;
765 sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
766 BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
767 bfa_sge_to_be(sge);
768 sge++;
769 }
770
771 if (ioim->nsges > BFI_SGE_INLINE) {
772 sge->sga = ioim->sgpg->sgpg_pa;
773 } else {
774 sge->sga.a32.addr_lo = 0;
775 sge->sga.a32.addr_hi = 0;
776 }
777 sge->sg_len = pgdlen;
778 sge->flags = BFI_SGE_PGDLEN;
779 bfa_sge_to_be(sge);
780
781 /**
782 * set up I/O command parameters
783 */
784 bfa_os_assign(m->cmnd, cmnd_z0);
785 m->cmnd.lun = bfa_cb_ioim_get_lun(ioim->dio);
786 m->cmnd.iodir = bfa_cb_ioim_get_iodir(ioim->dio);
787 bfa_os_assign(m->cmnd.cdb,
788 *(struct scsi_cdb_s *)bfa_cb_ioim_get_cdb(ioim->dio));
789 m->cmnd.fcp_dl = bfa_os_htonl(bfa_cb_ioim_get_size(ioim->dio));
790
791 /**
792 * set up I/O message header
793 */
794 switch (m->cmnd.iodir) {
795 case FCP_IODIR_READ:
796 bfi_h2i_set(m->mh, BFI_MC_IOIM_READ, 0, bfa_lpuid(ioim->bfa));
797 bfa_stats(itnim, input_reqs);
798 break;
799 case FCP_IODIR_WRITE:
800 bfi_h2i_set(m->mh, BFI_MC_IOIM_WRITE, 0, bfa_lpuid(ioim->bfa));
801 bfa_stats(itnim, output_reqs);
802 break;
803 case FCP_IODIR_RW:
804 bfa_stats(itnim, input_reqs);
805 bfa_stats(itnim, output_reqs);
806 default:
807 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
808 }
809 if (itnim->seq_rec ||
810 (bfa_cb_ioim_get_size(ioim->dio) & (sizeof(u32) - 1)))
811 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
812
813 #ifdef IOIM_ADVANCED
814 m->cmnd.crn = bfa_cb_ioim_get_crn(ioim->dio);
815 m->cmnd.priority = bfa_cb_ioim_get_priority(ioim->dio);
816 m->cmnd.taskattr = bfa_cb_ioim_get_taskattr(ioim->dio);
817
818 /**
819 * Handle large CDB (>16 bytes).
820 */
821 m->cmnd.addl_cdb_len = (bfa_cb_ioim_get_cdblen(ioim->dio) -
822 FCP_CMND_CDB_LEN) / sizeof(u32);
823 if (m->cmnd.addl_cdb_len) {
824 bfa_os_memcpy(&m->cmnd.cdb + 1, (struct scsi_cdb_s *)
825 bfa_cb_ioim_get_cdb(ioim->dio) + 1,
826 m->cmnd.addl_cdb_len * sizeof(u32));
827 fcp_cmnd_fcpdl(&m->cmnd) =
828 bfa_os_htonl(bfa_cb_ioim_get_size(ioim->dio));
829 }
830 #endif
831
832 /**
833 * queue I/O message to firmware
834 */
835 bfa_reqq_produce(ioim->bfa, itnim->reqq);
836 return BFA_TRUE;
837 }
838
839 /**
840 * Setup any additional SG pages needed.Inline SG element is setup
841 * at queuing time.
842 */
843 static bfa_boolean_t
844 bfa_ioim_sge_setup(struct bfa_ioim_s *ioim)
845 {
846 u16 nsgpgs;
847
848 bfa_assert(ioim->nsges > BFI_SGE_INLINE);
849
850 /**
851 * allocate SG pages needed
852 */
853 nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
854 if (!nsgpgs)
855 return BFA_TRUE;
856
857 if (bfa_sgpg_malloc(ioim->bfa, &ioim->sgpg_q, nsgpgs)
858 != BFA_STATUS_OK) {
859 bfa_sgpg_wait(ioim->bfa, &ioim->iosp->sgpg_wqe, nsgpgs);
860 return BFA_FALSE;
861 }
862
863 ioim->nsgpgs = nsgpgs;
864 bfa_ioim_sgpg_setup(ioim);
865
866 return BFA_TRUE;
867 }
868
869 static void
870 bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim)
871 {
872 int sgeid, nsges, i;
873 struct bfi_sge_s *sge;
874 struct bfa_sgpg_s *sgpg;
875 u32 pgcumsz;
876 u64 addr;
877 struct scatterlist *sg;
878 struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
879
880 sgeid = BFI_SGE_INLINE;
881 ioim->sgpg = sgpg = bfa_q_first(&ioim->sgpg_q);
882
883 sg = scsi_sglist(cmnd);
884 sg = sg_next(sg);
885
886 do {
887 sge = sgpg->sgpg->sges;
888 nsges = ioim->nsges - sgeid;
889 if (nsges > BFI_SGPG_DATA_SGES)
890 nsges = BFI_SGPG_DATA_SGES;
891
892 pgcumsz = 0;
893 for (i = 0; i < nsges; i++, sge++, sgeid++, sg = sg_next(sg)) {
894 addr = bfa_os_sgaddr(sg_dma_address(sg));
895 sge->sga = *(union bfi_addr_u *) &addr;
896 sge->sg_len = sg_dma_len(sg);
897 pgcumsz += sge->sg_len;
898
899 /**
900 * set flags
901 */
902 if (i < (nsges - 1))
903 sge->flags = BFI_SGE_DATA;
904 else if (sgeid < (ioim->nsges - 1))
905 sge->flags = BFI_SGE_DATA_CPL;
906 else
907 sge->flags = BFI_SGE_DATA_LAST;
908 }
909
910 sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
911
912 /**
913 * set the link element of each page
914 */
915 if (sgeid == ioim->nsges) {
916 sge->flags = BFI_SGE_PGDLEN;
917 sge->sga.a32.addr_lo = 0;
918 sge->sga.a32.addr_hi = 0;
919 } else {
920 sge->flags = BFI_SGE_LINK;
921 sge->sga = sgpg->sgpg_pa;
922 }
923 sge->sg_len = pgcumsz;
924 } while (sgeid < ioim->nsges);
925 }
926
927 /**
928 * Send I/O abort request to firmware.
929 */
930 static bfa_boolean_t
931 bfa_ioim_send_abort(struct bfa_ioim_s *ioim)
932 {
933 struct bfa_itnim_s *itnim = ioim->itnim;
934 struct bfi_ioim_abort_req_s *m;
935 enum bfi_ioim_h2i msgop;
936
937 /**
938 * check for room in queue to send request now
939 */
940 m = bfa_reqq_next(ioim->bfa, itnim->reqq);
941 if (!m)
942 return BFA_FALSE;
943
944 /**
945 * build i/o request message next
946 */
947 if (ioim->iosp->abort_explicit)
948 msgop = BFI_IOIM_H2I_IOABORT_REQ;
949 else
950 msgop = BFI_IOIM_H2I_IOCLEANUP_REQ;
951
952 bfi_h2i_set(m->mh, BFI_MC_IOIM, msgop, bfa_lpuid(ioim->bfa));
953 m->io_tag = bfa_os_htons(ioim->iotag);
954 m->abort_tag = ++ioim->abort_tag;
955
956 /**
957 * queue I/O message to firmware
958 */
959 bfa_reqq_produce(ioim->bfa, itnim->reqq);
960 return BFA_TRUE;
961 }
962
963 /**
964 * Call to resume any I/O requests waiting for room in request queue.
965 */
966 static void
967 bfa_ioim_qresume(void *cbarg)
968 {
969 struct bfa_ioim_s *ioim = cbarg;
970
971 bfa_fcpim_stats(ioim->fcpim, qresumes);
972 bfa_sm_send_event(ioim, BFA_IOIM_SM_QRESUME);
973 }
974
975
976 static void
977 bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
978 {
979 /**
980 * Move IO from itnim queue to fcpim global queue since itnim will be
981 * freed.
982 */
983 list_del(&ioim->qe);
984 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
985
986 if (!ioim->iosp->tskim) {
987 if (ioim->fcpim->delay_comp && ioim->itnim->iotov_active) {
988 bfa_cb_dequeue(&ioim->hcb_qe);
989 list_del(&ioim->qe);
990 list_add_tail(&ioim->qe, &ioim->itnim->delay_comp_q);
991 }
992 bfa_itnim_iodone(ioim->itnim);
993 } else
994 bfa_tskim_iodone(ioim->iosp->tskim);
995 }
996
997 /**
998 * or after the link comes back.
999 */
1000 void
1001 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
1002 {
1003 /**
1004 * If path tov timer expired, failback with PATHTOV status - these
1005 * IO requests are not normally retried by IO stack.
1006 *
1007 * Otherwise device cameback online and fail it with normal failed
1008 * status so that IO stack retries these failed IO requests.
1009 */
1010 if (iotov)
1011 ioim->io_cbfn = __bfa_cb_ioim_pathtov;
1012 else
1013 ioim->io_cbfn = __bfa_cb_ioim_failed;
1014
1015 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1016
1017 /**
1018 * Move IO to fcpim global queue since itnim will be
1019 * freed.
1020 */
1021 list_del(&ioim->qe);
1022 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
1023 }
1024
1025
1026
1027 /**
1028 * bfa_ioim_friend
1029 */
1030
1031 /**
1032 * Memory allocation and initialization.
1033 */
1034 void
1035 bfa_ioim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
1036 {
1037 struct bfa_ioim_s *ioim;
1038 struct bfa_ioim_sp_s *iosp;
1039 u16 i;
1040 u8 *snsinfo;
1041 u32 snsbufsz;
1042
1043 /**
1044 * claim memory first
1045 */
1046 ioim = (struct bfa_ioim_s *) bfa_meminfo_kva(minfo);
1047 fcpim->ioim_arr = ioim;
1048 bfa_meminfo_kva(minfo) = (u8 *) (ioim + fcpim->num_ioim_reqs);
1049
1050 iosp = (struct bfa_ioim_sp_s *) bfa_meminfo_kva(minfo);
1051 fcpim->ioim_sp_arr = iosp;
1052 bfa_meminfo_kva(minfo) = (u8 *) (iosp + fcpim->num_ioim_reqs);
1053
1054 /**
1055 * Claim DMA memory for per IO sense data.
1056 */
1057 snsbufsz = fcpim->num_ioim_reqs * BFI_IOIM_SNSLEN;
1058 fcpim->snsbase.pa = bfa_meminfo_dma_phys(minfo);
1059 bfa_meminfo_dma_phys(minfo) += snsbufsz;
1060
1061 fcpim->snsbase.kva = bfa_meminfo_dma_virt(minfo);
1062 bfa_meminfo_dma_virt(minfo) += snsbufsz;
1063 snsinfo = fcpim->snsbase.kva;
1064 bfa_iocfc_set_snsbase(fcpim->bfa, fcpim->snsbase.pa);
1065
1066 /**
1067 * Initialize ioim free queues
1068 */
1069 INIT_LIST_HEAD(&fcpim->ioim_free_q);
1070 INIT_LIST_HEAD(&fcpim->ioim_resfree_q);
1071 INIT_LIST_HEAD(&fcpim->ioim_comp_q);
1072
1073 for (i = 0; i < fcpim->num_ioim_reqs;
1074 i++, ioim++, iosp++, snsinfo += BFI_IOIM_SNSLEN) {
1075 /*
1076 * initialize IOIM
1077 */
1078 bfa_os_memset(ioim, 0, sizeof(struct bfa_ioim_s));
1079 ioim->iotag = i;
1080 ioim->bfa = fcpim->bfa;
1081 ioim->fcpim = fcpim;
1082 ioim->iosp = iosp;
1083 iosp->snsinfo = snsinfo;
1084 INIT_LIST_HEAD(&ioim->sgpg_q);
1085 bfa_reqq_winit(&ioim->iosp->reqq_wait,
1086 bfa_ioim_qresume, ioim);
1087 bfa_sgpg_winit(&ioim->iosp->sgpg_wqe,
1088 bfa_ioim_sgpg_alloced, ioim);
1089 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
1090
1091 list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
1092 }
1093 }
1094
1095 /**
1096 * Driver detach time call.
1097 */
1098 void
1099 bfa_ioim_detach(struct bfa_fcpim_mod_s *fcpim)
1100 {
1101 }
1102
1103 void
1104 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1105 {
1106 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1107 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
1108 struct bfa_ioim_s *ioim;
1109 u16 iotag;
1110 enum bfa_ioim_event evt = BFA_IOIM_SM_COMP;
1111
1112 iotag = bfa_os_ntohs(rsp->io_tag);
1113
1114 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
1115 bfa_assert(ioim->iotag == iotag);
1116
1117 bfa_trc(ioim->bfa, ioim->iotag);
1118 bfa_trc(ioim->bfa, rsp->io_status);
1119 bfa_trc(ioim->bfa, rsp->reuse_io_tag);
1120
1121 if (bfa_sm_cmp_state(ioim, bfa_ioim_sm_active))
1122 bfa_os_assign(ioim->iosp->comp_rspmsg, *m);
1123
1124 switch (rsp->io_status) {
1125 case BFI_IOIM_STS_OK:
1126 bfa_fcpim_stats(fcpim, iocomp_ok);
1127 if (rsp->reuse_io_tag == 0)
1128 evt = BFA_IOIM_SM_DONE;
1129 else
1130 evt = BFA_IOIM_SM_COMP;
1131 break;
1132
1133 case BFI_IOIM_STS_TIMEDOUT:
1134 case BFI_IOIM_STS_ABORTED:
1135 rsp->io_status = BFI_IOIM_STS_ABORTED;
1136 bfa_fcpim_stats(fcpim, iocomp_aborted);
1137 if (rsp->reuse_io_tag == 0)
1138 evt = BFA_IOIM_SM_DONE;
1139 else
1140 evt = BFA_IOIM_SM_COMP;
1141 break;
1142
1143 case BFI_IOIM_STS_PROTO_ERR:
1144 bfa_fcpim_stats(fcpim, iocom_proto_err);
1145 bfa_assert(rsp->reuse_io_tag);
1146 evt = BFA_IOIM_SM_COMP;
1147 break;
1148
1149 case BFI_IOIM_STS_SQER_NEEDED:
1150 bfa_fcpim_stats(fcpim, iocom_sqer_needed);
1151 bfa_assert(rsp->reuse_io_tag == 0);
1152 evt = BFA_IOIM_SM_SQRETRY;
1153 break;
1154
1155 case BFI_IOIM_STS_RES_FREE:
1156 bfa_fcpim_stats(fcpim, iocom_res_free);
1157 evt = BFA_IOIM_SM_FREE;
1158 break;
1159
1160 case BFI_IOIM_STS_HOST_ABORTED:
1161 bfa_fcpim_stats(fcpim, iocom_hostabrts);
1162 if (rsp->abort_tag != ioim->abort_tag) {
1163 bfa_trc(ioim->bfa, rsp->abort_tag);
1164 bfa_trc(ioim->bfa, ioim->abort_tag);
1165 return;
1166 }
1167
1168 if (rsp->reuse_io_tag)
1169 evt = BFA_IOIM_SM_ABORT_COMP;
1170 else
1171 evt = BFA_IOIM_SM_ABORT_DONE;
1172 break;
1173
1174 case BFI_IOIM_STS_UTAG:
1175 bfa_fcpim_stats(fcpim, iocom_utags);
1176 evt = BFA_IOIM_SM_COMP_UTAG;
1177 break;
1178
1179 default:
1180 bfa_assert(0);
1181 }
1182
1183 bfa_sm_send_event(ioim, evt);
1184 }
1185
1186 void
1187 bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1188 {
1189 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1190 struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
1191 struct bfa_ioim_s *ioim;
1192 u16 iotag;
1193
1194 iotag = bfa_os_ntohs(rsp->io_tag);
1195
1196 ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
1197 bfa_assert(ioim->iotag == iotag);
1198
1199 bfa_trc_fp(ioim->bfa, ioim->iotag);
1200 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
1201 }
1202
1203 /**
1204 * Called by itnim to clean up IO while going offline.
1205 */
1206 void
1207 bfa_ioim_cleanup(struct bfa_ioim_s *ioim)
1208 {
1209 bfa_trc(ioim->bfa, ioim->iotag);
1210 bfa_fcpim_stats(ioim->fcpim, io_cleanups);
1211
1212 ioim->iosp->tskim = NULL;
1213 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
1214 }
1215
1216 void
1217 bfa_ioim_cleanup_tm(struct bfa_ioim_s *ioim, struct bfa_tskim_s *tskim)
1218 {
1219 bfa_trc(ioim->bfa, ioim->iotag);
1220 bfa_fcpim_stats(ioim->fcpim, io_tmaborts);
1221
1222 ioim->iosp->tskim = tskim;
1223 bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
1224 }
1225
1226 /**
1227 * IOC failure handling.
1228 */
1229 void
1230 bfa_ioim_iocdisable(struct bfa_ioim_s *ioim)
1231 {
1232 bfa_sm_send_event(ioim, BFA_IOIM_SM_HWFAIL);
1233 }
1234
1235 /**
1236 * IO offline TOV popped. Fail the pending IO.
1237 */
1238 void
1239 bfa_ioim_tov(struct bfa_ioim_s *ioim)
1240 {
1241 bfa_sm_send_event(ioim, BFA_IOIM_SM_IOTOV);
1242 }
1243
1244
1245
1246 /**
1247 * bfa_ioim_api
1248 */
1249
1250 /**
1251 * Allocate IOIM resource for initiator mode I/O request.
1252 */
1253 struct bfa_ioim_s *
1254 bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
1255 struct bfa_itnim_s *itnim, u16 nsges)
1256 {
1257 struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1258 struct bfa_ioim_s *ioim;
1259
1260 /**
1261 * alocate IOIM resource
1262 */
1263 bfa_q_deq(&fcpim->ioim_free_q, &ioim);
1264 if (!ioim) {
1265 bfa_fcpim_stats(fcpim, no_iotags);
1266 return NULL;
1267 }
1268
1269 ioim->dio = dio;
1270 ioim->itnim = itnim;
1271 ioim->nsges = nsges;
1272 ioim->nsgpgs = 0;
1273
1274 bfa_stats(fcpim, total_ios);
1275 bfa_stats(itnim, ios);
1276 fcpim->ios_active++;
1277
1278 list_add_tail(&ioim->qe, &itnim->io_q);
1279 bfa_trc_fp(ioim->bfa, ioim->iotag);
1280
1281 return ioim;
1282 }
1283
1284 void
1285 bfa_ioim_free(struct bfa_ioim_s *ioim)
1286 {
1287 struct bfa_fcpim_mod_s *fcpim = ioim->fcpim;
1288
1289 bfa_trc_fp(ioim->bfa, ioim->iotag);
1290 bfa_assert_fp(bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit));
1291
1292 bfa_assert_fp(list_empty(&ioim->sgpg_q)
1293 || (ioim->nsges > BFI_SGE_INLINE));
1294
1295 if (ioim->nsgpgs > 0)
1296 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
1297
1298 bfa_stats(ioim->itnim, io_comps);
1299 fcpim->ios_active--;
1300
1301 list_del(&ioim->qe);
1302 list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
1303 }
1304
1305 void
1306 bfa_ioim_start(struct bfa_ioim_s *ioim)
1307 {
1308 bfa_trc_fp(ioim->bfa, ioim->iotag);
1309 bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
1310 }
1311
1312 /**
1313 * Driver I/O abort request.
1314 */
1315 void
1316 bfa_ioim_abort(struct bfa_ioim_s *ioim)
1317 {
1318 bfa_trc(ioim->bfa, ioim->iotag);
1319 bfa_fcpim_stats(ioim->fcpim, io_aborts);
1320 bfa_sm_send_event(ioim, BFA_IOIM_SM_ABORT);
1321 }
1322
1323