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