aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/bfa
diff options
context:
space:
mode:
authorJonathan Herman <hermanjl@cs.unc.edu>2013-01-17 16:15:55 -0500
committerJonathan Herman <hermanjl@cs.unc.edu>2013-01-17 16:15:55 -0500
commit8dea78da5cee153b8af9c07a2745f6c55057fe12 (patch)
treea8f4d49d63b1ecc92f2fddceba0655b2472c5bd9 /drivers/scsi/bfa
parent406089d01562f1e2bf9f089fd7637009ebaad589 (diff)
Patched in Tegra support.
Diffstat (limited to 'drivers/scsi/bfa')
-rw-r--r--drivers/scsi/bfa/bfa.h9
-rw-r--r--drivers/scsi/bfa/bfa_core.c799
-rw-r--r--drivers/scsi/bfa/bfa_cs.h4
-rw-r--r--drivers/scsi/bfa/bfa_defs.h65
-rw-r--r--drivers/scsi/bfa/bfa_defs_fcs.h18
-rw-r--r--drivers/scsi/bfa/bfa_defs_svc.h563
-rw-r--r--drivers/scsi/bfa/bfa_fc.h170
-rw-r--r--drivers/scsi/bfa/bfa_fcbuild.c25
-rw-r--r--drivers/scsi/bfa/bfa_fcbuild.h2
-rw-r--r--drivers/scsi/bfa/bfa_fcpim.c551
-rw-r--r--drivers/scsi/bfa/bfa_fcpim.h20
-rw-r--r--drivers/scsi/bfa/bfa_fcs.c240
-rw-r--r--drivers/scsi/bfa/bfa_fcs.h88
-rw-r--r--drivers/scsi/bfa/bfa_fcs_fcpim.c129
-rw-r--r--drivers/scsi/bfa/bfa_fcs_lport.c815
-rw-r--r--drivers/scsi/bfa/bfa_fcs_rport.c753
-rw-r--r--drivers/scsi/bfa/bfa_ioc.c708
-rw-r--r--drivers/scsi/bfa/bfa_ioc.h84
-rw-r--r--drivers/scsi/bfa/bfa_ioc_ct.c253
-rw-r--r--drivers/scsi/bfa/bfa_modules.h2
-rw-r--r--drivers/scsi/bfa/bfa_port.c32
-rw-r--r--drivers/scsi/bfa/bfa_port.h3
-rw-r--r--drivers/scsi/bfa/bfa_svc.c896
-rw-r--r--drivers/scsi/bfa/bfa_svc.h62
-rw-r--r--drivers/scsi/bfa/bfad.c265
-rw-r--r--drivers/scsi/bfa/bfad_attr.c132
-rw-r--r--drivers/scsi/bfa/bfad_bsg.c512
-rw-r--r--drivers/scsi/bfa/bfad_bsg.h67
-rw-r--r--drivers/scsi/bfa/bfad_debugfs.c6
-rw-r--r--drivers/scsi/bfa/bfad_drv.h8
-rw-r--r--drivers/scsi/bfa/bfad_im.c81
-rw-r--r--drivers/scsi/bfa/bfad_im.h28
-rw-r--r--drivers/scsi/bfa/bfi.h72
-rw-r--r--drivers/scsi/bfa/bfi_ms.h31
-rw-r--r--drivers/scsi/bfa/bfi_reg.h9
35 files changed, 1906 insertions, 5596 deletions
diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index 4ad7e368bbc..a796de93505 100644
--- a/drivers/scsi/bfa/bfa.h
+++ b/drivers/scsi/bfa/bfa.h
@@ -225,9 +225,9 @@ struct bfa_faa_args_s {
225}; 225};
226 226
227struct bfa_iocfc_s { 227struct bfa_iocfc_s {
228 bfa_fsm_t fsm;
229 struct bfa_s *bfa; 228 struct bfa_s *bfa;
230 struct bfa_iocfc_cfg_s cfg; 229 struct bfa_iocfc_cfg_s cfg;
230 int action;
231 u32 req_cq_pi[BFI_IOC_MAX_CQS]; 231 u32 req_cq_pi[BFI_IOC_MAX_CQS];
232 u32 rsp_cq_ci[BFI_IOC_MAX_CQS]; 232 u32 rsp_cq_ci[BFI_IOC_MAX_CQS];
233 u8 hw_qid[BFI_IOC_MAX_CQS]; 233 u8 hw_qid[BFI_IOC_MAX_CQS];
@@ -236,9 +236,7 @@ struct bfa_iocfc_s {
236 struct bfa_cb_qe_s dis_hcb_qe; 236 struct bfa_cb_qe_s dis_hcb_qe;
237 struct bfa_cb_qe_s en_hcb_qe; 237 struct bfa_cb_qe_s en_hcb_qe;
238 struct bfa_cb_qe_s stats_hcb_qe; 238 struct bfa_cb_qe_s stats_hcb_qe;
239 bfa_boolean_t submod_enabled; 239 bfa_boolean_t cfgdone;
240 bfa_boolean_t cb_reqd; /* Driver call back reqd */
241 bfa_status_t op_status; /* Status of bfa iocfc op */
242 240
243 struct bfa_dma_s cfg_info; 241 struct bfa_dma_s cfg_info;
244 struct bfi_iocfc_cfg_s *cfginfo; 242 struct bfi_iocfc_cfg_s *cfginfo;
@@ -343,6 +341,8 @@ void bfa_hwct_msix_getvecs(struct bfa_s *bfa, u32 *vecmap, u32 *nvecs,
343void bfa_hwct_msix_get_rme_range(struct bfa_s *bfa, u32 *start, 341void bfa_hwct_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
344 u32 *end); 342 u32 *end);
345void bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns); 343void bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns);
344wwn_t bfa_iocfc_get_pwwn(struct bfa_s *bfa);
345wwn_t bfa_iocfc_get_nwwn(struct bfa_s *bfa);
346int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa, 346int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa,
347 struct bfi_pbc_vport_s *pbc_vport); 347 struct bfi_pbc_vport_s *pbc_vport);
348 348
@@ -428,6 +428,7 @@ bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
428 428
429void bfa_iocfc_enable(struct bfa_s *bfa); 429void bfa_iocfc_enable(struct bfa_s *bfa);
430void bfa_iocfc_disable(struct bfa_s *bfa); 430void bfa_iocfc_disable(struct bfa_s *bfa);
431void bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status);
431#define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout) \ 432#define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout) \
432 bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout) 433 bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout)
433 434
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 342d7d9c099..4bd546bcc24 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -165,16 +165,6 @@ bfa_com_phy_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
165 bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg); 165 bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg);
166} 166}
167 167
168static void
169bfa_com_fru_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
170{
171 struct bfa_fru_s *fru = BFA_FRU(bfa);
172 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
173
174 bfa_fru_attach(fru, &bfa->ioc, bfa, bfa->trcmod, mincfg);
175 bfa_fru_memclaim(fru, fru_dma->kva_curp, fru_dma->dma_curp, mincfg);
176}
177
178/* 168/*
179 * BFA IOC FC related definitions 169 * BFA IOC FC related definitions
180 */ 170 */
@@ -210,484 +200,13 @@ enum {
210#define DEF_CFG_NUM_SBOOT_LUNS 16 200#define DEF_CFG_NUM_SBOOT_LUNS 16
211 201
212/* 202/*
213 * IOCFC state machine definitions/declarations
214 */
215bfa_fsm_state_decl(bfa_iocfc, stopped, struct bfa_iocfc_s, enum iocfc_event);
216bfa_fsm_state_decl(bfa_iocfc, initing, struct bfa_iocfc_s, enum iocfc_event);
217bfa_fsm_state_decl(bfa_iocfc, dconf_read, struct bfa_iocfc_s, enum iocfc_event);
218bfa_fsm_state_decl(bfa_iocfc, init_cfg_wait,
219 struct bfa_iocfc_s, enum iocfc_event);
220bfa_fsm_state_decl(bfa_iocfc, init_cfg_done,
221 struct bfa_iocfc_s, enum iocfc_event);
222bfa_fsm_state_decl(bfa_iocfc, operational,
223 struct bfa_iocfc_s, enum iocfc_event);
224bfa_fsm_state_decl(bfa_iocfc, dconf_write,
225 struct bfa_iocfc_s, enum iocfc_event);
226bfa_fsm_state_decl(bfa_iocfc, stopping, struct bfa_iocfc_s, enum iocfc_event);
227bfa_fsm_state_decl(bfa_iocfc, enabling, struct bfa_iocfc_s, enum iocfc_event);
228bfa_fsm_state_decl(bfa_iocfc, cfg_wait, struct bfa_iocfc_s, enum iocfc_event);
229bfa_fsm_state_decl(bfa_iocfc, disabling, struct bfa_iocfc_s, enum iocfc_event);
230bfa_fsm_state_decl(bfa_iocfc, disabled, struct bfa_iocfc_s, enum iocfc_event);
231bfa_fsm_state_decl(bfa_iocfc, failed, struct bfa_iocfc_s, enum iocfc_event);
232bfa_fsm_state_decl(bfa_iocfc, init_failed,
233 struct bfa_iocfc_s, enum iocfc_event);
234
235/*
236 * forward declaration for IOC FC functions 203 * forward declaration for IOC FC functions
237 */ 204 */
238static void bfa_iocfc_start_submod(struct bfa_s *bfa);
239static void bfa_iocfc_disable_submod(struct bfa_s *bfa);
240static void bfa_iocfc_send_cfg(void *bfa_arg);
241static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status); 205static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status);
242static void bfa_iocfc_disable_cbfn(void *bfa_arg); 206static void bfa_iocfc_disable_cbfn(void *bfa_arg);
243static void bfa_iocfc_hbfail_cbfn(void *bfa_arg); 207static void bfa_iocfc_hbfail_cbfn(void *bfa_arg);
244static void bfa_iocfc_reset_cbfn(void *bfa_arg); 208static void bfa_iocfc_reset_cbfn(void *bfa_arg);
245static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn; 209static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
246static void bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete);
247static void bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl);
248static void bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl);
249static void bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl);
250
251static void
252bfa_iocfc_sm_stopped_entry(struct bfa_iocfc_s *iocfc)
253{
254}
255
256static void
257bfa_iocfc_sm_stopped(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
258{
259 bfa_trc(iocfc->bfa, event);
260
261 switch (event) {
262 case IOCFC_E_INIT:
263 case IOCFC_E_ENABLE:
264 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_initing);
265 break;
266 default:
267 bfa_sm_fault(iocfc->bfa, event);
268 break;
269 }
270}
271
272static void
273bfa_iocfc_sm_initing_entry(struct bfa_iocfc_s *iocfc)
274{
275 bfa_ioc_enable(&iocfc->bfa->ioc);
276}
277
278static void
279bfa_iocfc_sm_initing(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
280{
281 bfa_trc(iocfc->bfa, event);
282
283 switch (event) {
284 case IOCFC_E_IOC_ENABLED:
285 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
286 break;
287
288 case IOCFC_E_DISABLE:
289 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
290 break;
291
292 case IOCFC_E_STOP:
293 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
294 break;
295
296 case IOCFC_E_IOC_FAILED:
297 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
298 break;
299 default:
300 bfa_sm_fault(iocfc->bfa, event);
301 break;
302 }
303}
304
305static void
306bfa_iocfc_sm_dconf_read_entry(struct bfa_iocfc_s *iocfc)
307{
308 bfa_dconf_modinit(iocfc->bfa);
309}
310
311static void
312bfa_iocfc_sm_dconf_read(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
313{
314 bfa_trc(iocfc->bfa, event);
315
316 switch (event) {
317 case IOCFC_E_DCONF_DONE:
318 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_wait);
319 break;
320
321 case IOCFC_E_DISABLE:
322 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
323 break;
324
325 case IOCFC_E_STOP:
326 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
327 break;
328
329 case IOCFC_E_IOC_FAILED:
330 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
331 break;
332 default:
333 bfa_sm_fault(iocfc->bfa, event);
334 break;
335 }
336}
337
338static void
339bfa_iocfc_sm_init_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
340{
341 bfa_iocfc_send_cfg(iocfc->bfa);
342}
343
344static void
345bfa_iocfc_sm_init_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
346{
347 bfa_trc(iocfc->bfa, event);
348
349 switch (event) {
350 case IOCFC_E_CFG_DONE:
351 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_done);
352 break;
353
354 case IOCFC_E_DISABLE:
355 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
356 break;
357
358 case IOCFC_E_STOP:
359 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
360 break;
361
362 case IOCFC_E_IOC_FAILED:
363 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
364 break;
365 default:
366 bfa_sm_fault(iocfc->bfa, event);
367 break;
368 }
369}
370
371static void
372bfa_iocfc_sm_init_cfg_done_entry(struct bfa_iocfc_s *iocfc)
373{
374 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
375 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
376 bfa_iocfc_init_cb, iocfc->bfa);
377}
378
379static void
380bfa_iocfc_sm_init_cfg_done(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
381{
382 bfa_trc(iocfc->bfa, event);
383
384 switch (event) {
385 case IOCFC_E_START:
386 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
387 break;
388 case IOCFC_E_STOP:
389 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
390 break;
391 case IOCFC_E_DISABLE:
392 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
393 break;
394 case IOCFC_E_IOC_FAILED:
395 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
396 break;
397 default:
398 bfa_sm_fault(iocfc->bfa, event);
399 break;
400 }
401}
402
403static void
404bfa_iocfc_sm_operational_entry(struct bfa_iocfc_s *iocfc)
405{
406 bfa_fcport_init(iocfc->bfa);
407 bfa_iocfc_start_submod(iocfc->bfa);
408}
409
410static void
411bfa_iocfc_sm_operational(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
412{
413 bfa_trc(iocfc->bfa, event);
414
415 switch (event) {
416 case IOCFC_E_STOP:
417 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
418 break;
419 case IOCFC_E_DISABLE:
420 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
421 break;
422 case IOCFC_E_IOC_FAILED:
423 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
424 break;
425 default:
426 bfa_sm_fault(iocfc->bfa, event);
427 break;
428 }
429}
430
431static void
432bfa_iocfc_sm_dconf_write_entry(struct bfa_iocfc_s *iocfc)
433{
434 bfa_dconf_modexit(iocfc->bfa);
435}
436
437static void
438bfa_iocfc_sm_dconf_write(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
439{
440 bfa_trc(iocfc->bfa, event);
441
442 switch (event) {
443 case IOCFC_E_DCONF_DONE:
444 case IOCFC_E_IOC_FAILED:
445 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
446 break;
447 default:
448 bfa_sm_fault(iocfc->bfa, event);
449 break;
450 }
451}
452
453static void
454bfa_iocfc_sm_stopping_entry(struct bfa_iocfc_s *iocfc)
455{
456 bfa_ioc_disable(&iocfc->bfa->ioc);
457}
458
459static void
460bfa_iocfc_sm_stopping(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
461{
462 bfa_trc(iocfc->bfa, event);
463
464 switch (event) {
465 case IOCFC_E_IOC_DISABLED:
466 bfa_isr_disable(iocfc->bfa);
467 bfa_iocfc_disable_submod(iocfc->bfa);
468 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
469 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
470 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.stop_hcb_qe,
471 bfa_iocfc_stop_cb, iocfc->bfa);
472 break;
473
474 case IOCFC_E_IOC_ENABLED:
475 case IOCFC_E_DCONF_DONE:
476 case IOCFC_E_CFG_DONE:
477 break;
478
479 default:
480 bfa_sm_fault(iocfc->bfa, event);
481 break;
482 }
483}
484
485static void
486bfa_iocfc_sm_enabling_entry(struct bfa_iocfc_s *iocfc)
487{
488 bfa_ioc_enable(&iocfc->bfa->ioc);
489}
490
491static void
492bfa_iocfc_sm_enabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
493{
494 bfa_trc(iocfc->bfa, event);
495
496 switch (event) {
497 case IOCFC_E_IOC_ENABLED:
498 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
499 break;
500
501 case IOCFC_E_DISABLE:
502 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
503 break;
504
505 case IOCFC_E_STOP:
506 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
507 break;
508
509 case IOCFC_E_IOC_FAILED:
510 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
511
512 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
513 break;
514
515 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
516 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
517 bfa_iocfc_enable_cb, iocfc->bfa);
518 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
519 break;
520 default:
521 bfa_sm_fault(iocfc->bfa, event);
522 break;
523 }
524}
525
526static void
527bfa_iocfc_sm_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
528{
529 bfa_iocfc_send_cfg(iocfc->bfa);
530}
531
532static void
533bfa_iocfc_sm_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
534{
535 bfa_trc(iocfc->bfa, event);
536
537 switch (event) {
538 case IOCFC_E_CFG_DONE:
539 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
540 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
541 break;
542
543 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
544 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
545 bfa_iocfc_enable_cb, iocfc->bfa);
546 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
547 break;
548 case IOCFC_E_DISABLE:
549 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
550 break;
551
552 case IOCFC_E_STOP:
553 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
554 break;
555 case IOCFC_E_IOC_FAILED:
556 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
557 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
558 break;
559
560 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
561 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
562 bfa_iocfc_enable_cb, iocfc->bfa);
563 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
564 break;
565 default:
566 bfa_sm_fault(iocfc->bfa, event);
567 break;
568 }
569}
570
571static void
572bfa_iocfc_sm_disabling_entry(struct bfa_iocfc_s *iocfc)
573{
574 bfa_ioc_disable(&iocfc->bfa->ioc);
575}
576
577static void
578bfa_iocfc_sm_disabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
579{
580 bfa_trc(iocfc->bfa, event);
581
582 switch (event) {
583 case IOCFC_E_IOC_DISABLED:
584 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabled);
585 break;
586 case IOCFC_E_IOC_ENABLED:
587 case IOCFC_E_DCONF_DONE:
588 case IOCFC_E_CFG_DONE:
589 break;
590 default:
591 bfa_sm_fault(iocfc->bfa, event);
592 break;
593 }
594}
595
596static void
597bfa_iocfc_sm_disabled_entry(struct bfa_iocfc_s *iocfc)
598{
599 bfa_isr_disable(iocfc->bfa);
600 bfa_iocfc_disable_submod(iocfc->bfa);
601 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
602 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
603 bfa_iocfc_disable_cb, iocfc->bfa);
604}
605
606static void
607bfa_iocfc_sm_disabled(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
608{
609 bfa_trc(iocfc->bfa, event);
610
611 switch (event) {
612 case IOCFC_E_STOP:
613 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
614 break;
615 case IOCFC_E_ENABLE:
616 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_enabling);
617 break;
618 default:
619 bfa_sm_fault(iocfc->bfa, event);
620 break;
621 }
622}
623
624static void
625bfa_iocfc_sm_failed_entry(struct bfa_iocfc_s *iocfc)
626{
627 bfa_isr_disable(iocfc->bfa);
628 bfa_iocfc_disable_submod(iocfc->bfa);
629}
630
631static void
632bfa_iocfc_sm_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
633{
634 bfa_trc(iocfc->bfa, event);
635
636 switch (event) {
637 case IOCFC_E_STOP:
638 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
639 break;
640 case IOCFC_E_DISABLE:
641 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
642 break;
643 case IOCFC_E_IOC_ENABLED:
644 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
645 break;
646 case IOCFC_E_IOC_FAILED:
647 break;
648 default:
649 bfa_sm_fault(iocfc->bfa, event);
650 break;
651 }
652}
653
654static void
655bfa_iocfc_sm_init_failed_entry(struct bfa_iocfc_s *iocfc)
656{
657 bfa_isr_disable(iocfc->bfa);
658 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
659 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
660 bfa_iocfc_init_cb, iocfc->bfa);
661}
662
663static void
664bfa_iocfc_sm_init_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
665{
666 bfa_trc(iocfc->bfa, event);
667
668 switch (event) {
669 case IOCFC_E_STOP:
670 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
671 break;
672 case IOCFC_E_DISABLE:
673 bfa_ioc_disable(&iocfc->bfa->ioc);
674 break;
675 case IOCFC_E_IOC_ENABLED:
676 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
677 break;
678 case IOCFC_E_IOC_DISABLED:
679 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
680 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
681 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
682 bfa_iocfc_disable_cb, iocfc->bfa);
683 break;
684 case IOCFC_E_IOC_FAILED:
685 break;
686 default:
687 bfa_sm_fault(iocfc->bfa, event);
688 break;
689 }
690}
691 210
692/* 211/*
693 * BFA Interrupt handling functions 212 * BFA Interrupt handling functions
@@ -712,19 +231,16 @@ bfa_reqq_resume(struct bfa_s *bfa, int qid)
712 } 231 }
713} 232}
714 233
715bfa_boolean_t 234static inline void
716bfa_isr_rspq(struct bfa_s *bfa, int qid) 235bfa_isr_rspq(struct bfa_s *bfa, int qid)
717{ 236{
718 struct bfi_msg_s *m; 237 struct bfi_msg_s *m;
719 u32 pi, ci; 238 u32 pi, ci;
720 struct list_head *waitq; 239 struct list_head *waitq;
721 bfa_boolean_t ret;
722 240
723 ci = bfa_rspq_ci(bfa, qid); 241 ci = bfa_rspq_ci(bfa, qid);
724 pi = bfa_rspq_pi(bfa, qid); 242 pi = bfa_rspq_pi(bfa, qid);
725 243
726 ret = (ci != pi);
727
728 while (ci != pi) { 244 while (ci != pi) {
729 m = bfa_rspq_elem(bfa, qid, ci); 245 m = bfa_rspq_elem(bfa, qid, ci);
730 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX); 246 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX);
@@ -744,8 +260,6 @@ bfa_isr_rspq(struct bfa_s *bfa, int qid)
744 waitq = bfa_reqq(bfa, qid); 260 waitq = bfa_reqq(bfa, qid);
745 if (!list_empty(waitq)) 261 if (!list_empty(waitq))
746 bfa_reqq_resume(bfa, qid); 262 bfa_reqq_resume(bfa, qid);
747
748 return ret;
749} 263}
750 264
751static inline void 265static inline void
@@ -806,7 +320,6 @@ bfa_intx(struct bfa_s *bfa)
806{ 320{
807 u32 intr, qintr; 321 u32 intr, qintr;
808 int queue; 322 int queue;
809 bfa_boolean_t rspq_comp = BFA_FALSE;
810 323
811 intr = readl(bfa->iocfc.bfa_regs.intr_status); 324 intr = readl(bfa->iocfc.bfa_regs.intr_status);
812 325
@@ -819,12 +332,11 @@ bfa_intx(struct bfa_s *bfa)
819 */ 332 */
820 if (bfa->queue_process) { 333 if (bfa->queue_process) {
821 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 334 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
822 if (bfa_isr_rspq(bfa, queue)) 335 bfa_isr_rspq(bfa, queue);
823 rspq_comp = BFA_TRUE;
824 } 336 }
825 337
826 if (!intr) 338 if (!intr)
827 return (qintr | rspq_comp) ? BFA_TRUE : BFA_FALSE; 339 return BFA_TRUE;
828 340
829 /* 341 /*
830 * CPE completion queue interrupt 342 * CPE completion queue interrupt
@@ -838,8 +350,7 @@ bfa_intx(struct bfa_s *bfa)
838 if (!intr) 350 if (!intr)
839 return BFA_TRUE; 351 return BFA_TRUE;
840 352
841 if (bfa->intr_enabled) 353 bfa_msix_lpu_err(bfa, intr);
842 bfa_msix_lpu_err(bfa, intr);
843 354
844 return BFA_TRUE; 355 return BFA_TRUE;
845} 356}
@@ -848,37 +359,30 @@ void
848bfa_isr_enable(struct bfa_s *bfa) 359bfa_isr_enable(struct bfa_s *bfa)
849{ 360{
850 u32 umsk; 361 u32 umsk;
851 int port_id = bfa_ioc_portid(&bfa->ioc); 362 int pci_func = bfa_ioc_pcifn(&bfa->ioc);
852 363
853 bfa_trc(bfa, bfa_ioc_pcifn(&bfa->ioc)); 364 bfa_trc(bfa, pci_func);
854 bfa_trc(bfa, port_id);
855 365
856 bfa_msix_ctrl_install(bfa); 366 bfa_msix_ctrl_install(bfa);
857 367
858 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) { 368 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) {
859 umsk = __HFN_INT_ERR_MASK_CT2; 369 umsk = __HFN_INT_ERR_MASK_CT2;
860 umsk |= port_id == 0 ? 370 umsk |= pci_func == 0 ?
861 __HFN_INT_FN0_MASK_CT2 : __HFN_INT_FN1_MASK_CT2; 371 __HFN_INT_FN0_MASK_CT2 : __HFN_INT_FN1_MASK_CT2;
862 } else { 372 } else {
863 umsk = __HFN_INT_ERR_MASK; 373 umsk = __HFN_INT_ERR_MASK;
864 umsk |= port_id == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK; 374 umsk |= pci_func == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK;
865 } 375 }
866 376
867 writel(umsk, bfa->iocfc.bfa_regs.intr_status); 377 writel(umsk, bfa->iocfc.bfa_regs.intr_status);
868 writel(~umsk, bfa->iocfc.bfa_regs.intr_mask); 378 writel(~umsk, bfa->iocfc.bfa_regs.intr_mask);
869 bfa->iocfc.intr_mask = ~umsk; 379 bfa->iocfc.intr_mask = ~umsk;
870 bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0); 380 bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0);
871
872 /*
873 * Set the flag indicating successful enabling of interrupts
874 */
875 bfa->intr_enabled = BFA_TRUE;
876} 381}
877 382
878void 383void
879bfa_isr_disable(struct bfa_s *bfa) 384bfa_isr_disable(struct bfa_s *bfa)
880{ 385{
881 bfa->intr_enabled = BFA_FALSE;
882 bfa_isr_mode_set(bfa, BFA_FALSE); 386 bfa_isr_mode_set(bfa, BFA_FALSE);
883 writel(-1L, bfa->iocfc.bfa_regs.intr_mask); 387 writel(-1L, bfa->iocfc.bfa_regs.intr_mask);
884 bfa_msix_uninstall(bfa); 388 bfa_msix_uninstall(bfa);
@@ -994,8 +498,7 @@ bfa_iocfc_send_cfg(void *bfa_arg)
994 cfg_info->single_msix_vec = 1; 498 cfg_info->single_msix_vec = 1;
995 cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG; 499 cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG;
996 cfg_info->num_cqs = cfg->fwcfg.num_cqs; 500 cfg_info->num_cqs = cfg->fwcfg.num_cqs;
997 cfg_info->num_ioim_reqs = cpu_to_be16(bfa_fcpim_get_throttle_cfg(bfa, 501 cfg_info->num_ioim_reqs = cpu_to_be16(cfg->fwcfg.num_ioim_reqs);
998 cfg->fwcfg.num_ioim_reqs));
999 cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs); 502 cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs);
1000 503
1001 bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa); 504 bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa);
@@ -1022,9 +525,11 @@ bfa_iocfc_send_cfg(void *bfa_arg)
1022 * Enable interrupt coalescing if it is driver init path 525 * Enable interrupt coalescing if it is driver init path
1023 * and not ioc disable/enable path. 526 * and not ioc disable/enable path.
1024 */ 527 */
1025 if (bfa_fsm_cmp_state(iocfc, bfa_iocfc_sm_init_cfg_wait)) 528 if (!iocfc->cfgdone)
1026 cfg_info->intr_attr.coalesce = BFA_TRUE; 529 cfg_info->intr_attr.coalesce = BFA_TRUE;
1027 530
531 iocfc->cfgdone = BFA_FALSE;
532
1028 /* 533 /*
1029 * dma map IOC configuration itself 534 * dma map IOC configuration itself
1030 */ 535 */
@@ -1044,6 +549,8 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1044 549
1045 bfa->bfad = bfad; 550 bfa->bfad = bfad;
1046 iocfc->bfa = bfa; 551 iocfc->bfa = bfa;
552 iocfc->action = BFA_IOCFC_ACT_NONE;
553
1047 iocfc->cfg = *cfg; 554 iocfc->cfg = *cfg;
1048 555
1049 /* 556 /*
@@ -1094,7 +601,7 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
1094{ 601{
1095 u8 *dm_kva = NULL; 602 u8 *dm_kva = NULL;
1096 u64 dm_pa = 0; 603 u64 dm_pa = 0;
1097 int i, per_reqq_sz, per_rspq_sz; 604 int i, per_reqq_sz, per_rspq_sz, dbgsz;
1098 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 605 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1099 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa); 606 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa);
1100 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa); 607 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa);
@@ -1155,8 +662,11 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
1155 BFA_CACHELINE_SZ); 662 BFA_CACHELINE_SZ);
1156 663
1157 /* Claim IOCFC kva memory */ 664 /* Claim IOCFC kva memory */
1158 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc)); 665 dbgsz = (bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
1159 bfa_mem_kva_curp(iocfc) += BFA_DBG_FWTRC_LEN; 666 if (dbgsz > 0) {
667 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc));
668 bfa_mem_kva_curp(iocfc) += dbgsz;
669 }
1160} 670}
1161 671
1162/* 672/*
@@ -1173,8 +683,6 @@ bfa_iocfc_start_submod(struct bfa_s *bfa)
1173 683
1174 for (i = 0; hal_mods[i]; i++) 684 for (i = 0; hal_mods[i]; i++)
1175 hal_mods[i]->start(bfa); 685 hal_mods[i]->start(bfa);
1176
1177 bfa->iocfc.submod_enabled = BFA_TRUE;
1178} 686}
1179 687
1180/* 688/*
@@ -1185,13 +693,8 @@ bfa_iocfc_disable_submod(struct bfa_s *bfa)
1185{ 693{
1186 int i; 694 int i;
1187 695
1188 if (bfa->iocfc.submod_enabled == BFA_FALSE)
1189 return;
1190
1191 for (i = 0; hal_mods[i]; i++) 696 for (i = 0; hal_mods[i]; i++)
1192 hal_mods[i]->iocdisable(bfa); 697 hal_mods[i]->iocdisable(bfa);
1193
1194 bfa->iocfc.submod_enabled = BFA_FALSE;
1195} 698}
1196 699
1197static void 700static void
@@ -1199,8 +702,15 @@ bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
1199{ 702{
1200 struct bfa_s *bfa = bfa_arg; 703 struct bfa_s *bfa = bfa_arg;
1201 704
1202 if (complete) 705 if (complete) {
1203 bfa_cb_init(bfa->bfad, bfa->iocfc.op_status); 706 if (bfa->iocfc.cfgdone && BFA_DCONF_MOD(bfa)->flashdone)
707 bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
708 else
709 bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
710 } else {
711 if (bfa->iocfc.cfgdone)
712 bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
713 }
1204} 714}
1205 715
1206static void 716static void
@@ -1211,6 +721,8 @@ bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
1211 721
1212 if (compl) 722 if (compl)
1213 complete(&bfad->comp); 723 complete(&bfad->comp);
724 else
725 bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
1214} 726}
1215 727
1216static void 728static void
@@ -1257,14 +769,10 @@ bfa_iocfc_qreg(struct bfa_s *bfa, struct bfi_iocfc_qreg_s *qreg)
1257static void 769static void
1258bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg) 770bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg)
1259{ 771{
1260 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1261 struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo;
1262
1263 bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs); 772 bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs);
1264 bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs); 773 bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs);
1265 bfa_rport_res_recfg(bfa, fwcfg->num_rports); 774 bfa_rport_res_recfg(bfa, fwcfg->num_rports);
1266 bfa_fcp_res_recfg(bfa, cpu_to_be16(cfg_info->num_ioim_reqs), 775 bfa_fcp_res_recfg(bfa, fwcfg->num_ioim_reqs);
1267 fwcfg->num_ioim_reqs);
1268 bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs); 776 bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs);
1269} 777}
1270 778
@@ -1286,6 +794,8 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
1286 fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs); 794 fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs);
1287 fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports); 795 fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports);
1288 796
797 iocfc->cfgdone = BFA_TRUE;
798
1289 /* 799 /*
1290 * configure queue register offsets as learnt from firmware 800 * configure queue register offsets as learnt from firmware
1291 */ 801 */
@@ -1301,13 +811,22 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
1301 */ 811 */
1302 bfa_msix_queue_install(bfa); 812 bfa_msix_queue_install(bfa);
1303 813
1304 if (bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn != 0) { 814 /*
1305 bfa->ioc.attr->pwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn; 815 * Configuration is complete - initialize/start submodules
1306 bfa->ioc.attr->nwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_nwwn; 816 */
1307 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE); 817 bfa_fcport_init(bfa);
818
819 if (iocfc->action == BFA_IOCFC_ACT_INIT) {
820 if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
821 bfa_cb_queue(bfa, &iocfc->init_hcb_qe,
822 bfa_iocfc_init_cb, bfa);
823 } else {
824 if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
825 bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
826 bfa_iocfc_enable_cb, bfa);
827 bfa_iocfc_start_submod(bfa);
1308 } 828 }
1309} 829}
1310
1311void 830void
1312bfa_iocfc_reset_queues(struct bfa_s *bfa) 831bfa_iocfc_reset_queues(struct bfa_s *bfa)
1313{ 832{
@@ -1321,23 +840,6 @@ bfa_iocfc_reset_queues(struct bfa_s *bfa)
1321 } 840 }
1322} 841}
1323 842
1324/*
1325 * Process FAA pwwn msg from fw.
1326 */
1327static void
1328bfa_iocfc_process_faa_addr(struct bfa_s *bfa, struct bfi_faa_addr_msg_s *msg)
1329{
1330 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1331 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1332
1333 cfgrsp->pbc_cfg.pbc_pwwn = msg->pwwn;
1334 cfgrsp->pbc_cfg.pbc_nwwn = msg->nwwn;
1335
1336 bfa->ioc.attr->pwwn = msg->pwwn;
1337 bfa->ioc.attr->nwwn = msg->nwwn;
1338 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE);
1339}
1340
1341/* Fabric Assigned Address specific functions */ 843/* Fabric Assigned Address specific functions */
1342 844
1343/* 845/*
@@ -1353,13 +855,84 @@ bfa_faa_validate_request(struct bfa_s *bfa)
1353 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type)) 855 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type))
1354 return BFA_STATUS_FEATURE_NOT_SUPPORTED; 856 return BFA_STATUS_FEATURE_NOT_SUPPORTED;
1355 } else { 857 } else {
1356 return BFA_STATUS_IOC_NON_OP; 858 if (!bfa_ioc_is_acq_addr(&bfa->ioc))
859 return BFA_STATUS_IOC_NON_OP;
1357 } 860 }
1358 861
1359 return BFA_STATUS_OK; 862 return BFA_STATUS_OK;
1360} 863}
1361 864
1362bfa_status_t 865bfa_status_t
866bfa_faa_enable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn, void *cbarg)
867{
868 struct bfi_faa_en_dis_s faa_enable_req;
869 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
870 bfa_status_t status;
871
872 iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
873 iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
874
875 status = bfa_faa_validate_request(bfa);
876 if (status != BFA_STATUS_OK)
877 return status;
878
879 if (iocfc->faa_args.busy == BFA_TRUE)
880 return BFA_STATUS_DEVBUSY;
881
882 if (iocfc->faa_args.faa_state == BFA_FAA_ENABLED)
883 return BFA_STATUS_FAA_ENABLED;
884
885 if (bfa_fcport_is_trunk_enabled(bfa))
886 return BFA_STATUS_ERROR_TRUNK_ENABLED;
887
888 bfa_fcport_cfg_faa(bfa, BFA_FAA_ENABLED);
889 iocfc->faa_args.busy = BFA_TRUE;
890
891 memset(&faa_enable_req, 0, sizeof(struct bfi_faa_en_dis_s));
892 bfi_h2i_set(faa_enable_req.mh, BFI_MC_IOCFC,
893 BFI_IOCFC_H2I_FAA_ENABLE_REQ, bfa_fn_lpu(bfa));
894
895 bfa_ioc_mbox_send(&bfa->ioc, &faa_enable_req,
896 sizeof(struct bfi_faa_en_dis_s));
897
898 return BFA_STATUS_OK;
899}
900
901bfa_status_t
902bfa_faa_disable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn,
903 void *cbarg)
904{
905 struct bfi_faa_en_dis_s faa_disable_req;
906 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
907 bfa_status_t status;
908
909 iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
910 iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
911
912 status = bfa_faa_validate_request(bfa);
913 if (status != BFA_STATUS_OK)
914 return status;
915
916 if (iocfc->faa_args.busy == BFA_TRUE)
917 return BFA_STATUS_DEVBUSY;
918
919 if (iocfc->faa_args.faa_state == BFA_FAA_DISABLED)
920 return BFA_STATUS_FAA_DISABLED;
921
922 bfa_fcport_cfg_faa(bfa, BFA_FAA_DISABLED);
923 iocfc->faa_args.busy = BFA_TRUE;
924
925 memset(&faa_disable_req, 0, sizeof(struct bfi_faa_en_dis_s));
926 bfi_h2i_set(faa_disable_req.mh, BFI_MC_IOCFC,
927 BFI_IOCFC_H2I_FAA_DISABLE_REQ, bfa_fn_lpu(bfa));
928
929 bfa_ioc_mbox_send(&bfa->ioc, &faa_disable_req,
930 sizeof(struct bfi_faa_en_dis_s));
931
932 return BFA_STATUS_OK;
933}
934
935bfa_status_t
1363bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr, 936bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
1364 bfa_cb_iocfc_t cbfn, void *cbarg) 937 bfa_cb_iocfc_t cbfn, void *cbarg)
1365{ 938{
@@ -1390,6 +963,38 @@ bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
1390} 963}
1391 964
1392/* 965/*
966 * FAA enable response
967 */
968static void
969bfa_faa_enable_reply(struct bfa_iocfc_s *iocfc,
970 struct bfi_faa_en_dis_rsp_s *rsp)
971{
972 void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
973 bfa_status_t status = rsp->status;
974
975 WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
976
977 iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
978 iocfc->faa_args.busy = BFA_FALSE;
979}
980
981/*
982 * FAA disable response
983 */
984static void
985bfa_faa_disable_reply(struct bfa_iocfc_s *iocfc,
986 struct bfi_faa_en_dis_rsp_s *rsp)
987{
988 void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
989 bfa_status_t status = rsp->status;
990
991 WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
992
993 iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
994 iocfc->faa_args.busy = BFA_FALSE;
995}
996
997/*
1393 * FAA query response 998 * FAA query response
1394 */ 999 */
1395static void 1000static void
@@ -1418,10 +1023,25 @@ bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
1418{ 1023{
1419 struct bfa_s *bfa = bfa_arg; 1024 struct bfa_s *bfa = bfa_arg;
1420 1025
1421 if (status == BFA_STATUS_OK) 1026 if (status == BFA_STATUS_FAA_ACQ_ADDR) {
1422 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_ENABLED); 1027 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1423 else 1028 bfa_iocfc_init_cb, bfa);
1424 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1029 return;
1030 }
1031
1032 if (status != BFA_STATUS_OK) {
1033 bfa_isr_disable(bfa);
1034 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
1035 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1036 bfa_iocfc_init_cb, bfa);
1037 else if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
1038 bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
1039 bfa_iocfc_enable_cb, bfa);
1040 return;
1041 }
1042
1043 bfa_iocfc_send_cfg(bfa);
1044 bfa_dconf_modinit(bfa);
1425} 1045}
1426 1046
1427/* 1047/*
@@ -1432,7 +1052,17 @@ bfa_iocfc_disable_cbfn(void *bfa_arg)
1432{ 1052{
1433 struct bfa_s *bfa = bfa_arg; 1053 struct bfa_s *bfa = bfa_arg;
1434 1054
1435 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_DISABLED); 1055 bfa_isr_disable(bfa);
1056 bfa_iocfc_disable_submod(bfa);
1057
1058 if (bfa->iocfc.action == BFA_IOCFC_ACT_STOP)
1059 bfa_cb_queue(bfa, &bfa->iocfc.stop_hcb_qe, bfa_iocfc_stop_cb,
1060 bfa);
1061 else {
1062 WARN_ON(bfa->iocfc.action != BFA_IOCFC_ACT_DISABLE);
1063 bfa_cb_queue(bfa, &bfa->iocfc.dis_hcb_qe, bfa_iocfc_disable_cb,
1064 bfa);
1065 }
1436} 1066}
1437 1067
1438/* 1068/*
@@ -1444,7 +1074,13 @@ bfa_iocfc_hbfail_cbfn(void *bfa_arg)
1444 struct bfa_s *bfa = bfa_arg; 1074 struct bfa_s *bfa = bfa_arg;
1445 1075
1446 bfa->queue_process = BFA_FALSE; 1076 bfa->queue_process = BFA_FALSE;
1447 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1077
1078 bfa_isr_disable(bfa);
1079 bfa_iocfc_disable_submod(bfa);
1080
1081 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
1082 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe, bfa_iocfc_init_cb,
1083 bfa);
1448} 1084}
1449 1085
1450/* 1086/*
@@ -1459,6 +1095,7 @@ bfa_iocfc_reset_cbfn(void *bfa_arg)
1459 bfa_isr_enable(bfa); 1095 bfa_isr_enable(bfa);
1460} 1096}
1461 1097
1098
1462/* 1099/*
1463 * Query IOC memory requirement information. 1100 * Query IOC memory requirement information.
1464 */ 1101 */
@@ -1502,7 +1139,8 @@ bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1502 bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len); 1139 bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len);
1503 1140
1504 /* kva memory setup for IOCFC */ 1141 /* kva memory setup for IOCFC */
1505 bfa_mem_kva_setup(meminfo, iocfc_kva, BFA_DBG_FWTRC_LEN); 1142 bfa_mem_kva_setup(meminfo, iocfc_kva,
1143 ((bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0));
1506} 1144}
1507 1145
1508/* 1146/*
@@ -1533,12 +1171,6 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1533 INIT_LIST_HEAD(&bfa->comp_q); 1171 INIT_LIST_HEAD(&bfa->comp_q);
1534 for (i = 0; i < BFI_IOC_MAX_CQS; i++) 1172 for (i = 0; i < BFI_IOC_MAX_CQS; i++)
1535 INIT_LIST_HEAD(&bfa->reqq_waitq[i]); 1173 INIT_LIST_HEAD(&bfa->reqq_waitq[i]);
1536
1537 bfa->iocfc.cb_reqd = BFA_FALSE;
1538 bfa->iocfc.op_status = BFA_STATUS_OK;
1539 bfa->iocfc.submod_enabled = BFA_FALSE;
1540
1541 bfa_fsm_set_state(&bfa->iocfc, bfa_iocfc_sm_stopped);
1542} 1174}
1543 1175
1544/* 1176/*
@@ -1547,7 +1179,8 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1547void 1179void
1548bfa_iocfc_init(struct bfa_s *bfa) 1180bfa_iocfc_init(struct bfa_s *bfa)
1549{ 1181{
1550 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_INIT); 1182 bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
1183 bfa_ioc_enable(&bfa->ioc);
1551} 1184}
1552 1185
1553/* 1186/*
@@ -1557,7 +1190,8 @@ bfa_iocfc_init(struct bfa_s *bfa)
1557void 1190void
1558bfa_iocfc_start(struct bfa_s *bfa) 1191bfa_iocfc_start(struct bfa_s *bfa)
1559{ 1192{
1560 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_START); 1193 if (bfa->iocfc.cfgdone)
1194 bfa_iocfc_start_submod(bfa);
1561} 1195}
1562 1196
1563/* 1197/*
@@ -1567,8 +1201,12 @@ bfa_iocfc_start(struct bfa_s *bfa)
1567void 1201void
1568bfa_iocfc_stop(struct bfa_s *bfa) 1202bfa_iocfc_stop(struct bfa_s *bfa)
1569{ 1203{
1204 bfa->iocfc.action = BFA_IOCFC_ACT_STOP;
1205
1570 bfa->queue_process = BFA_FALSE; 1206 bfa->queue_process = BFA_FALSE;
1571 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_STOP); 1207 bfa_dconf_modexit(bfa);
1208 if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
1209 bfa_ioc_disable(&bfa->ioc);
1572} 1210}
1573 1211
1574void 1212void
@@ -1588,9 +1226,13 @@ bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
1588 case BFI_IOCFC_I2H_UPDATEQ_RSP: 1226 case BFI_IOCFC_I2H_UPDATEQ_RSP:
1589 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK); 1227 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
1590 break; 1228 break;
1591 case BFI_IOCFC_I2H_ADDR_MSG: 1229 case BFI_IOCFC_I2H_FAA_ENABLE_RSP:
1592 bfa_iocfc_process_faa_addr(bfa, 1230 bfa_faa_enable_reply(iocfc,
1593 (struct bfi_faa_addr_msg_s *)msg); 1231 (struct bfi_faa_en_dis_rsp_s *)msg);
1232 break;
1233 case BFI_IOCFC_I2H_FAA_DISABLE_RSP:
1234 bfa_faa_disable_reply(iocfc,
1235 (struct bfi_faa_en_dis_rsp_s *)msg);
1594 break; 1236 break;
1595 case BFI_IOCFC_I2H_FAA_QUERY_RSP: 1237 case BFI_IOCFC_I2H_FAA_QUERY_RSP:
1596 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg); 1238 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg);
@@ -1664,8 +1306,8 @@ bfa_iocfc_enable(struct bfa_s *bfa)
1664{ 1306{
1665 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1307 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
1666 "IOC Enable"); 1308 "IOC Enable");
1667 bfa->iocfc.cb_reqd = BFA_TRUE; 1309 bfa->iocfc.action = BFA_IOCFC_ACT_ENABLE;
1668 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_ENABLE); 1310 bfa_ioc_enable(&bfa->ioc);
1669} 1311}
1670 1312
1671void 1313void
@@ -1673,16 +1315,17 @@ bfa_iocfc_disable(struct bfa_s *bfa)
1673{ 1315{
1674 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1316 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
1675 "IOC Disable"); 1317 "IOC Disable");
1318 bfa->iocfc.action = BFA_IOCFC_ACT_DISABLE;
1676 1319
1677 bfa->queue_process = BFA_FALSE; 1320 bfa->queue_process = BFA_FALSE;
1678 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DISABLE); 1321 bfa_ioc_disable(&bfa->ioc);
1679} 1322}
1680 1323
1324
1681bfa_boolean_t 1325bfa_boolean_t
1682bfa_iocfc_is_operational(struct bfa_s *bfa) 1326bfa_iocfc_is_operational(struct bfa_s *bfa)
1683{ 1327{
1684 return bfa_ioc_is_operational(&bfa->ioc) && 1328 return bfa_ioc_is_operational(&bfa->ioc) && bfa->iocfc.cfgdone;
1685 bfa_fsm_cmp_state(&bfa->iocfc, bfa_iocfc_sm_operational);
1686} 1329}
1687 1330
1688/* 1331/*
@@ -1762,7 +1405,6 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1762 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa); 1405 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa);
1763 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa); 1406 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa);
1764 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa); 1407 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa);
1765 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
1766 1408
1767 WARN_ON((cfg == NULL) || (meminfo == NULL)); 1409 WARN_ON((cfg == NULL) || (meminfo == NULL));
1768 1410
@@ -1787,8 +1429,6 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1787 bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo()); 1429 bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo());
1788 bfa_mem_dma_setup(meminfo, phy_dma, 1430 bfa_mem_dma_setup(meminfo, phy_dma,
1789 bfa_phy_meminfo(cfg->drvcfg.min_cfg)); 1431 bfa_phy_meminfo(cfg->drvcfg.min_cfg));
1790 bfa_mem_dma_setup(meminfo, fru_dma,
1791 bfa_fru_meminfo(cfg->drvcfg.min_cfg));
1792} 1432}
1793 1433
1794/* 1434/*
@@ -1861,7 +1501,6 @@ bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1861 bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg); 1501 bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg);
1862 bfa_com_diag_attach(bfa); 1502 bfa_com_diag_attach(bfa);
1863 bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg); 1503 bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg);
1864 bfa_com_fru_attach(bfa, cfg->drvcfg.min_cfg);
1865} 1504}
1866 1505
1867/* 1506/*
@@ -1928,6 +1567,16 @@ bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
1928 } 1567 }
1929} 1568}
1930 1569
1570void
1571bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status)
1572{
1573 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT) {
1574 if (bfa->iocfc.cfgdone == BFA_TRUE)
1575 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1576 bfa_iocfc_init_cb, bfa);
1577 }
1578}
1579
1931/* 1580/*
1932 * Return the list of PCI vendor/device id lists supported by this 1581 * Return the list of PCI vendor/device id lists supported by this
1933 * BFA instance. 1582 * BFA instance.
diff --git a/drivers/scsi/bfa/bfa_cs.h b/drivers/scsi/bfa/bfa_cs.h
index 91a8aa394db..12bfeed268e 100644
--- a/drivers/scsi/bfa/bfa_cs.h
+++ b/drivers/scsi/bfa/bfa_cs.h
@@ -168,7 +168,7 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
168/* 168/*
169 * bfa_q_deq - dequeue an element from head of the queue 169 * bfa_q_deq - dequeue an element from head of the queue
170 */ 170 */
171#define bfa_q_deq(_q, _qe) do { \ 171#define bfa_q_deq(_q, _qe) { \
172 if (!list_empty(_q)) { \ 172 if (!list_empty(_q)) { \
173 (*((struct list_head **) (_qe))) = bfa_q_next(_q); \ 173 (*((struct list_head **) (_qe))) = bfa_q_next(_q); \
174 bfa_q_prev(bfa_q_next(*((struct list_head **) _qe))) = \ 174 bfa_q_prev(bfa_q_next(*((struct list_head **) _qe))) = \
@@ -177,7 +177,7 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
177 } else { \ 177 } else { \
178 *((struct list_head **) (_qe)) = (struct list_head *) NULL;\ 178 *((struct list_head **) (_qe)) = (struct list_head *) NULL;\
179 } \ 179 } \
180} while (0) 180}
181 181
182/* 182/*
183 * bfa_q_deq_tail - dequeue an element from tail of the queue 183 * bfa_q_deq_tail - dequeue an element from tail of the queue
diff --git a/drivers/scsi/bfa/bfa_defs.h b/drivers/scsi/bfa/bfa_defs.h
index 0efdf312b42..7b3d235d20b 100644
--- a/drivers/scsi/bfa/bfa_defs.h
+++ b/drivers/scsi/bfa/bfa_defs.h
@@ -159,13 +159,10 @@ enum bfa_status {
159 BFA_STATUS_BEACON_ON = 72, /* Port Beacon already on */ 159 BFA_STATUS_BEACON_ON = 72, /* Port Beacon already on */
160 BFA_STATUS_ENOFSAVE = 78, /* No saved firmware trace */ 160 BFA_STATUS_ENOFSAVE = 78, /* No saved firmware trace */
161 BFA_STATUS_IOC_DISABLED = 82, /* IOC is already disabled */ 161 BFA_STATUS_IOC_DISABLED = 82, /* IOC is already disabled */
162 BFA_STATUS_ERROR_TRL_ENABLED = 87, /* TRL is enabled */
163 BFA_STATUS_ERROR_QOS_ENABLED = 88, /* QoS is enabled */
164 BFA_STATUS_NO_SFP_DEV = 89, /* No SFP device check or replace SFP */ 162 BFA_STATUS_NO_SFP_DEV = 89, /* No SFP device check or replace SFP */
165 BFA_STATUS_MEMTEST_FAILED = 90, /* Memory test failed contact support */ 163 BFA_STATUS_MEMTEST_FAILED = 90, /* Memory test failed contact support */
166 BFA_STATUS_LEDTEST_OP = 109, /* LED test is operating */ 164 BFA_STATUS_LEDTEST_OP = 109, /* LED test is operating */
167 BFA_STATUS_INVALID_MAC = 134, /* Invalid MAC address */ 165 BFA_STATUS_INVALID_MAC = 134, /* Invalid MAC address */
168 BFA_STATUS_CMD_NOTSUPP_CNA = 146, /* Command not supported for CNA */
169 BFA_STATUS_PBC = 154, /* Operation not allowed for pre-boot 166 BFA_STATUS_PBC = 154, /* Operation not allowed for pre-boot
170 * configuration */ 167 * configuration */
171 BFA_STATUS_BAD_FWCFG = 156, /* Bad firmware configuration */ 168 BFA_STATUS_BAD_FWCFG = 156, /* Bad firmware configuration */
@@ -187,17 +184,6 @@ enum bfa_status {
187 BFA_STATUS_FAA_ACQ_ADDR = 200, /* Acquiring addr */ 184 BFA_STATUS_FAA_ACQ_ADDR = 200, /* Acquiring addr */
188 BFA_STATUS_ERROR_TRUNK_ENABLED = 203, /* Trunk enabled on adapter */ 185 BFA_STATUS_ERROR_TRUNK_ENABLED = 203, /* Trunk enabled on adapter */
189 BFA_STATUS_MAX_ENTRY_REACHED = 212, /* MAX entry reached */ 186 BFA_STATUS_MAX_ENTRY_REACHED = 212, /* MAX entry reached */
190 BFA_STATUS_TOPOLOGY_LOOP = 230, /* Topology is set to Loop */
191 BFA_STATUS_LOOP_UNSUPP_MEZZ = 231, /* Loop topology is not supported
192 * on mezz cards */
193 BFA_STATUS_INVALID_BW = 233, /* Invalid bandwidth value */
194 BFA_STATUS_QOS_BW_INVALID = 234, /* Invalid QOS bandwidth
195 * configuration */
196 BFA_STATUS_DPORT_ENABLED = 235, /* D-port mode is already enabled */
197 BFA_STATUS_DPORT_DISABLED = 236, /* D-port mode is already disabled */
198 BFA_STATUS_CMD_NOTSUPP_MEZZ = 239, /* Cmd not supported for MEZZ card */
199 BFA_STATUS_FRU_NOT_PRESENT = 240, /* fru module not present */
200 BFA_STATUS_DPORT_ERR = 245, /* D-port mode is enabled */
201 BFA_STATUS_MAX_VAL /* Unknown error code */ 187 BFA_STATUS_MAX_VAL /* Unknown error code */
202}; 188};
203#define bfa_status_t enum bfa_status 189#define bfa_status_t enum bfa_status
@@ -263,10 +249,6 @@ struct bfa_adapter_attr_s {
263 249
264 u8 is_mezz; 250 u8 is_mezz;
265 u8 trunk_capable; 251 u8 trunk_capable;
266 u8 mfg_day; /* manufacturing day */
267 u8 mfg_month; /* manufacturing month */
268 u16 mfg_year; /* manufacturing year */
269 u16 rsvd;
270}; 252};
271 253
272/* 254/*
@@ -517,17 +499,6 @@ struct bfa_ioc_aen_data_s {
517}; 499};
518 500
519/* 501/*
520 * D-port states
521 *
522*/
523enum bfa_dport_state {
524 BFA_DPORT_ST_DISABLED = 0, /* D-port is Disabled */
525 BFA_DPORT_ST_DISABLING = 1, /* D-port is Disabling */
526 BFA_DPORT_ST_ENABLING = 2, /* D-port is Enabling */
527 BFA_DPORT_ST_ENABLED = 3, /* D-port is Enabled */
528};
529
530/*
531 * ---------------------- mfg definitions ------------ 502 * ---------------------- mfg definitions ------------
532 */ 503 */
533 504
@@ -751,8 +722,7 @@ struct bfa_ablk_cfg_pf_s {
751 u8 rsvd[1]; 722 u8 rsvd[1];
752 u16 num_qpairs; 723 u16 num_qpairs;
753 u16 num_vectors; 724 u16 num_vectors;
754 u16 bw_min; 725 u32 bw;
755 u16 bw_max;
756}; 726};
757 727
758struct bfa_ablk_cfg_port_s { 728struct bfa_ablk_cfg_port_s {
@@ -919,40 +889,11 @@ struct sfp_diag_ext_s {
919 u8 ext_status_ctl[2]; 889 u8 ext_status_ctl[2];
920}; 890};
921 891
922/*
923 * Diagnostic: Data Fields -- Address A2h
924 * General Use Fields: User Writable Table - Features's Control Registers
925 * Total 32 bytes
926 */
927struct sfp_usr_eeprom_s {
928 u8 rsvd1[2]; /* 128-129 */
929 u8 ewrap; /* 130 */
930 u8 rsvd2[2]; /* */
931 u8 owrap; /* 133 */
932 u8 rsvd3[2]; /* */
933 u8 prbs; /* 136: PRBS 7 generator */
934 u8 rsvd4[2]; /* */
935 u8 tx_eqz_16; /* 139: TX Equalizer (16xFC) */
936 u8 tx_eqz_8; /* 140: TX Equalizer (8xFC) */
937 u8 rsvd5[2]; /* */
938 u8 rx_emp_16; /* 143: RX Emphasis (16xFC) */
939 u8 rx_emp_8; /* 144: RX Emphasis (8xFC) */
940 u8 rsvd6[2]; /* */
941 u8 tx_eye_adj; /* 147: TX eye Threshold Adjust */
942 u8 rsvd7[3]; /* */
943 u8 tx_eye_qctl; /* 151: TX eye Quality Control */
944 u8 tx_eye_qres; /* 152: TX eye Quality Result */
945 u8 rsvd8[2]; /* */
946 u8 poh[3]; /* 155-157: Power On Hours */
947 u8 rsvd9[2]; /* */
948};
949
950struct sfp_mem_s { 892struct sfp_mem_s {
951 struct sfp_srlid_base_s srlid_base; 893 struct sfp_srlid_base_s srlid_base;
952 struct sfp_srlid_ext_s srlid_ext; 894 struct sfp_srlid_ext_s srlid_ext;
953 struct sfp_diag_base_s diag_base; 895 struct sfp_diag_base_s diag_base;
954 struct sfp_diag_ext_s diag_ext; 896 struct sfp_diag_ext_s diag_ext;
955 struct sfp_usr_eeprom_s usr_eeprom;
956}; 897};
957 898
958/* 899/*
@@ -961,7 +902,7 @@ struct sfp_mem_s {
961union sfp_xcvr_e10g_code_u { 902union sfp_xcvr_e10g_code_u {
962 u8 b; 903 u8 b;
963 struct { 904 struct {
964#ifdef __BIG_ENDIAN 905#ifdef __BIGENDIAN
965 u8 e10g_unall:1; /* 10G Ethernet compliance */ 906 u8 e10g_unall:1; /* 10G Ethernet compliance */
966 u8 e10g_lrm:1; 907 u8 e10g_lrm:1;
967 u8 e10g_lr:1; 908 u8 e10g_lr:1;
@@ -1041,7 +982,7 @@ union sfp_xcvr_fc2_code_u {
1041union sfp_xcvr_fc3_code_u { 982union sfp_xcvr_fc3_code_u {
1042 u8 b; 983 u8 b;
1043 struct { 984 struct {
1044#ifdef __BIG_ENDIAN 985#ifdef __BIGENDIAN
1045 u8 rsv4:1; 986 u8 rsv4:1;
1046 u8 mb800:1; /* 800 Mbytes/sec */ 987 u8 mb800:1; /* 800 Mbytes/sec */
1047 u8 mb1600:1; /* 1600 Mbytes/sec */ 988 u8 mb1600:1; /* 1600 Mbytes/sec */
diff --git a/drivers/scsi/bfa/bfa_defs_fcs.h b/drivers/scsi/bfa/bfa_defs_fcs.h
index 06f0a163ca3..3bbc583f65c 100644
--- a/drivers/scsi/bfa/bfa_defs_fcs.h
+++ b/drivers/scsi/bfa/bfa_defs_fcs.h
@@ -93,7 +93,6 @@ struct bfa_lport_cfg_s {
93 wwn_t pwwn; /* port wwn */ 93 wwn_t pwwn; /* port wwn */
94 wwn_t nwwn; /* node wwn */ 94 wwn_t nwwn; /* node wwn */
95 struct bfa_lport_symname_s sym_name; /* vm port symbolic name */ 95 struct bfa_lport_symname_s sym_name; /* vm port symbolic name */
96 struct bfa_lport_symname_s node_sym_name; /* Node symbolic name */
97 enum bfa_lport_role roles; /* FCS port roles */ 96 enum bfa_lport_role roles; /* FCS port roles */
98 u32 rsvd; 97 u32 rsvd;
99 bfa_boolean_t preboot_vp; /* vport created from PBC */ 98 bfa_boolean_t preboot_vp; /* vport created from PBC */
@@ -193,18 +192,6 @@ struct bfa_lport_stats_s {
193 u32 ns_gidft_unknown_rsp; 192 u32 ns_gidft_unknown_rsp;
194 u32 ns_gidft_alloc_wait; 193 u32 ns_gidft_alloc_wait;
195 194
196 u32 ns_rnnid_sent;
197 u32 ns_rnnid_accepts;
198 u32 ns_rnnid_rsp_err;
199 u32 ns_rnnid_rejects;
200 u32 ns_rnnid_alloc_wait;
201
202 u32 ns_rsnn_nn_sent;
203 u32 ns_rsnn_nn_accepts;
204 u32 ns_rsnn_nn_rsp_err;
205 u32 ns_rsnn_nn_rejects;
206 u32 ns_rsnn_nn_alloc_wait;
207
208 /* 195 /*
209 * Mgmt Server stats 196 * Mgmt Server stats
210 */ 197 */
@@ -423,11 +410,6 @@ struct bfa_rport_remote_link_stats_s {
423 u32 icc; /* Invalid CRC Count */ 410 u32 icc; /* Invalid CRC Count */
424}; 411};
425 412
426struct bfa_rport_qualifier_s {
427 wwn_t pwwn; /* Port WWN */
428 u32 pid; /* port ID */
429 u32 rsvd;
430};
431 413
432#define BFA_MAX_IO_INDEX 7 414#define BFA_MAX_IO_INDEX 7
433#define BFA_NO_IO_INDEX 9 415#define BFA_NO_IO_INDEX 9
diff --git a/drivers/scsi/bfa/bfa_defs_svc.h b/drivers/scsi/bfa/bfa_defs_svc.h
index ec03c8cd8da..863c6ba7d5e 100644
--- a/drivers/scsi/bfa/bfa_defs_svc.h
+++ b/drivers/scsi/bfa/bfa_defs_svc.h
@@ -34,42 +34,42 @@
34struct bfa_iocfc_intr_attr_s { 34struct bfa_iocfc_intr_attr_s {
35 u8 coalesce; /* enable/disable coalescing */ 35 u8 coalesce; /* enable/disable coalescing */
36 u8 rsvd[3]; 36 u8 rsvd[3];
37 __be16 latency; /* latency in microseconds */ 37 __be16 latency; /* latency in microseconds */
38 __be16 delay; /* delay in microseconds */ 38 __be16 delay; /* delay in microseconds */
39}; 39};
40 40
41/* 41/*
42 * IOC firmware configuraton 42 * IOC firmware configuraton
43 */ 43 */
44struct bfa_iocfc_fwcfg_s { 44struct bfa_iocfc_fwcfg_s {
45 u16 num_fabrics; /* number of fabrics */ 45 u16 num_fabrics; /* number of fabrics */
46 u16 num_lports; /* number of local lports */ 46 u16 num_lports; /* number of local lports */
47 u16 num_rports; /* number of remote ports */ 47 u16 num_rports; /* number of remote ports */
48 u16 num_ioim_reqs; /* number of IO reqs */ 48 u16 num_ioim_reqs; /* number of IO reqs */
49 u16 num_tskim_reqs; /* task management requests */ 49 u16 num_tskim_reqs; /* task management requests */
50 u16 num_fwtio_reqs; /* number of TM IO reqs in FW */ 50 u16 num_fwtio_reqs; /* number of TM IO reqs in FW */
51 u16 num_fcxp_reqs; /* unassisted FC exchanges */ 51 u16 num_fcxp_reqs; /* unassisted FC exchanges */
52 u16 num_uf_bufs; /* unsolicited recv buffers */ 52 u16 num_uf_bufs; /* unsolicited recv buffers */
53 u8 num_cqs; 53 u8 num_cqs;
54 u8 fw_tick_res; /* FW clock resolution in ms */ 54 u8 fw_tick_res; /* FW clock resolution in ms */
55 u8 rsvd[6]; 55 u8 rsvd[2];
56}; 56};
57#pragma pack() 57#pragma pack()
58 58
59struct bfa_iocfc_drvcfg_s { 59struct bfa_iocfc_drvcfg_s {
60 u16 num_reqq_elems; /* number of req queue elements */ 60 u16 num_reqq_elems; /* number of req queue elements */
61 u16 num_rspq_elems; /* number of rsp queue elements */ 61 u16 num_rspq_elems; /* number of rsp queue elements */
62 u16 num_sgpgs; /* number of total SG pages */ 62 u16 num_sgpgs; /* number of total SG pages */
63 u16 num_sboot_tgts; /* number of SAN boot targets */ 63 u16 num_sboot_tgts; /* number of SAN boot targets */
64 u16 num_sboot_luns; /* number of SAN boot luns */ 64 u16 num_sboot_luns; /* number of SAN boot luns */
65 u16 ioc_recover; /* IOC recovery mode */ 65 u16 ioc_recover; /* IOC recovery mode */
66 u16 min_cfg; /* minimum configuration */ 66 u16 min_cfg; /* minimum configuration */
67 u16 path_tov; /* device path timeout */ 67 u16 path_tov; /* device path timeout */
68 u16 num_tio_reqs; /* number of TM IO reqs */ 68 u16 num_tio_reqs; /*!< number of TM IO reqs */
69 u8 port_mode; 69 u8 port_mode;
70 u8 rsvd_a; 70 u8 rsvd_a;
71 bfa_boolean_t delay_comp; /* delay completion of failed 71 bfa_boolean_t delay_comp; /* delay completion of
72 * inflight IOs */ 72 failed inflight IOs */
73 u16 num_ttsk_reqs; /* TM task management requests */ 73 u16 num_ttsk_reqs; /* TM task management requests */
74 u32 rsvd; 74 u32 rsvd;
75}; 75};
@@ -101,8 +101,8 @@ struct bfa_fw_ioim_stats_s {
101 u32 fw_frm_drop; /* f/w drop the frame */ 101 u32 fw_frm_drop; /* f/w drop the frame */
102 102
103 u32 rec_timeout; /* FW rec timed out */ 103 u32 rec_timeout; /* FW rec timed out */
104 u32 error_rec; /* FW sending rec on 104 u32 error_rec; /* FW sending rec on
105 * an error condition*/ 105 * an error condition*/
106 u32 wait_for_si; /* FW wait for SI */ 106 u32 wait_for_si; /* FW wait for SI */
107 u32 rec_rsp_inval; /* REC rsp invalid */ 107 u32 rec_rsp_inval; /* REC rsp invalid */
108 u32 seqr_io_abort; /* target does not know cmd so abort */ 108 u32 seqr_io_abort; /* target does not know cmd so abort */
@@ -124,9 +124,9 @@ struct bfa_fw_ioim_stats_s {
124 u32 unexp_fcp_rsp; /* fcp response in wrong state */ 124 u32 unexp_fcp_rsp; /* fcp response in wrong state */
125 125
126 u32 fcp_rsp_under_run; /* fcp rsp IO underrun */ 126 u32 fcp_rsp_under_run; /* fcp rsp IO underrun */
127 u32 fcp_rsp_under_run_wr; /* fcp rsp IO underrun for write */ 127 u32 fcp_rsp_under_run_wr; /* fcp rsp IO underrun for write */
128 u32 fcp_rsp_under_run_err; /* fcp rsp IO underrun error */ 128 u32 fcp_rsp_under_run_err; /* fcp rsp IO underrun error */
129 u32 fcp_rsp_resid_inval; /* invalid residue */ 129 u32 fcp_rsp_resid_inval; /* invalid residue */
130 u32 fcp_rsp_over_run; /* fcp rsp IO overrun */ 130 u32 fcp_rsp_over_run; /* fcp rsp IO overrun */
131 u32 fcp_rsp_over_run_err; /* fcp rsp IO overrun error */ 131 u32 fcp_rsp_over_run_err; /* fcp rsp IO overrun error */
132 u32 fcp_rsp_proto_err; /* protocol error in fcp rsp */ 132 u32 fcp_rsp_proto_err; /* protocol error in fcp rsp */
@@ -142,20 +142,21 @@ struct bfa_fw_ioim_stats_s {
142 u32 ioh_hit_class2_event; /* IOH hit class2 */ 142 u32 ioh_hit_class2_event; /* IOH hit class2 */
143 u32 ioh_miss_other_event; /* IOH miss other */ 143 u32 ioh_miss_other_event; /* IOH miss other */
144 u32 ioh_seq_cnt_err_event; /* IOH seq cnt error */ 144 u32 ioh_seq_cnt_err_event; /* IOH seq cnt error */
145 u32 ioh_len_err_event; /* IOH len error - fcp_dl != 145 u32 ioh_len_err_event; /* IOH len error - fcp_dl !=
146 * bytes xfered */ 146 * bytes xfered */
147 u32 ioh_seq_len_err_event; /* IOH seq len error */ 147 u32 ioh_seq_len_err_event; /* IOH seq len error */
148 u32 ioh_data_oor_event; /* Data out of range */ 148 u32 ioh_data_oor_event; /* Data out of range */
149 u32 ioh_ro_ooo_event; /* Relative offset out of range */ 149 u32 ioh_ro_ooo_event; /* Relative offset out of range */
150 u32 ioh_cpu_owned_event; /* IOH hit -iost owned by f/w */ 150 u32 ioh_cpu_owned_event; /* IOH hit -iost owned by f/w */
151 u32 ioh_unexp_frame_event; /* unexpected frame received 151 u32 ioh_unexp_frame_event; /* unexpected frame received
152 * count */ 152 * count */
153 u32 ioh_err_int; /* IOH error int during data-phase 153 u32 ioh_err_int; /* IOH error int during data-phase
154 * for scsi write */ 154 * for scsi write
155 */
155}; 156};
156 157
157struct bfa_fw_tio_stats_s { 158struct bfa_fw_tio_stats_s {
158 u32 tio_conf_proc; /* TIO CONF processed */ 159 u32 tio_conf_proc; /* TIO CONF processed */
159 u32 tio_conf_drop; /* TIO CONF dropped */ 160 u32 tio_conf_drop; /* TIO CONF dropped */
160 u32 tio_cleanup_req; /* TIO cleanup requested */ 161 u32 tio_cleanup_req; /* TIO cleanup requested */
161 u32 tio_cleanup_comp; /* TIO cleanup completed */ 162 u32 tio_cleanup_comp; /* TIO cleanup completed */
@@ -163,36 +164,34 @@ struct bfa_fw_tio_stats_s {
163 u32 tio_abort_rsp_comp; /* TIO abort rsp completed */ 164 u32 tio_abort_rsp_comp; /* TIO abort rsp completed */
164 u32 tio_abts_req; /* TIO ABTS requested */ 165 u32 tio_abts_req; /* TIO ABTS requested */
165 u32 tio_abts_ack; /* TIO ABTS ack-ed */ 166 u32 tio_abts_ack; /* TIO ABTS ack-ed */
166 u32 tio_abts_ack_nocomp;/* TIO ABTS ack-ed but not completed */ 167 u32 tio_abts_ack_nocomp; /* TIO ABTS ack-ed but not completed */
167 u32 tio_abts_tmo; /* TIO ABTS timeout */ 168 u32 tio_abts_tmo; /* TIO ABTS timeout */
168 u32 tio_snsdata_dma; /* TIO sense data DMA */ 169 u32 tio_snsdata_dma; /* TIO sense data DMA */
169 u32 tio_rxwchan_wait; /* TIO waiting for RX wait channel */ 170 u32 tio_rxwchan_wait; /* TIO waiting for RX wait channel */
170 u32 tio_rxwchan_avail; /* TIO RX wait channel available */ 171 u32 tio_rxwchan_avail; /* TIO RX wait channel available */
171 u32 tio_hit_bls; /* TIO IOH BLS event */ 172 u32 tio_hit_bls; /* TIO IOH BLS event */
172 u32 tio_uf_recv; /* TIO received UF */ 173 u32 tio_uf_recv; /* TIO received UF */
173 u32 tio_rd_invalid_sm; /* TIO read reqst in wrong state machine */ 174 u32 tio_rd_invalid_sm; /* TIO read reqst in wrong state machine */
174 u32 tio_wr_invalid_sm; /* TIO write reqst in wrong state machine */ 175 u32 tio_wr_invalid_sm;/* TIO write reqst in wrong state machine */
175 176
176 u32 ds_rxwchan_wait; /* DS waiting for RX wait channel */ 177 u32 ds_rxwchan_wait; /* DS waiting for RX wait channel */
177 u32 ds_rxwchan_avail; /* DS RX wait channel available */ 178 u32 ds_rxwchan_avail; /* DS RX wait channel available */
178 u32 ds_unaligned_rd; /* DS unaligned read */ 179 u32 ds_unaligned_rd; /* DS unaligned read */
179 u32 ds_rdcomp_invalid_sm; /* DS read completed in wrong state 180 u32 ds_rdcomp_invalid_sm; /* DS read completed in wrong state machine */
180 * machine */ 181 u32 ds_wrcomp_invalid_sm; /* DS write completed in wrong state machine */
181 u32 ds_wrcomp_invalid_sm; /* DS write completed in wrong state
182 * machine */
183 u32 ds_flush_req; /* DS flush requested */ 182 u32 ds_flush_req; /* DS flush requested */
184 u32 ds_flush_comp; /* DS flush completed */ 183 u32 ds_flush_comp; /* DS flush completed */
185 u32 ds_xfrdy_exp; /* DS XFER_RDY expired */ 184 u32 ds_xfrdy_exp; /* DS XFER_RDY expired */
186 u32 ds_seq_cnt_err; /* DS seq cnt error */ 185 u32 ds_seq_cnt_err; /* DS seq cnt error */
187 u32 ds_seq_len_err; /* DS seq len error */ 186 u32 ds_seq_len_err; /* DS seq len error */
188 u32 ds_data_oor; /* DS data out of order */ 187 u32 ds_data_oor; /* DS data out of order */
189 u32 ds_hit_bls; /* DS hit BLS */ 188 u32 ds_hit_bls; /* DS hit BLS */
190 u32 ds_edtov_timer_exp; /* DS edtov expired */ 189 u32 ds_edtov_timer_exp; /* DS edtov expired */
191 u32 ds_cpu_owned; /* DS cpu owned */ 190 u32 ds_cpu_owned; /* DS cpu owned */
192 u32 ds_hit_class2; /* DS hit class2 */ 191 u32 ds_hit_class2; /* DS hit class2 */
193 u32 ds_length_err; /* DS length error */ 192 u32 ds_length_err; /* DS length error */
194 u32 ds_ro_ooo_err; /* DS relative offset out-of-order error */ 193 u32 ds_ro_ooo_err; /* DS relative offset out-of-order error */
195 u32 ds_rectov_timer_exp;/* DS rectov expired */ 194 u32 ds_rectov_timer_exp; /* DS rectov expired */
196 u32 ds_unexp_fr_err; /* DS unexp frame error */ 195 u32 ds_unexp_fr_err; /* DS unexp frame error */
197}; 196};
198 197
@@ -209,156 +208,119 @@ struct bfa_fw_io_stats_s {
209 */ 208 */
210 209
211struct bfa_fw_port_fpg_stats_s { 210struct bfa_fw_port_fpg_stats_s {
212 u32 intr_evt; 211 u32 intr_evt;
213 u32 intr; 212 u32 intr;
214 u32 intr_excess; 213 u32 intr_excess;
215 u32 intr_cause0; 214 u32 intr_cause0;
216 u32 intr_other; 215 u32 intr_other;
217 u32 intr_other_ign; 216 u32 intr_other_ign;
218 u32 sig_lost; 217 u32 sig_lost;
219 u32 sig_regained; 218 u32 sig_regained;
220 u32 sync_lost; 219 u32 sync_lost;
221 u32 sync_to; 220 u32 sync_to;
222 u32 sync_regained; 221 u32 sync_regained;
223 u32 div2_overflow; 222 u32 div2_overflow;
224 u32 div2_underflow; 223 u32 div2_underflow;
225 u32 efifo_overflow; 224 u32 efifo_overflow;
226 u32 efifo_underflow; 225 u32 efifo_underflow;
227 u32 idle_rx; 226 u32 idle_rx;
228 u32 lrr_rx; 227 u32 lrr_rx;
229 u32 lr_rx; 228 u32 lr_rx;
230 u32 ols_rx; 229 u32 ols_rx;
231 u32 nos_rx; 230 u32 nos_rx;
232 u32 lip_rx; 231 u32 lip_rx;
233 u32 arbf0_rx; 232 u32 arbf0_rx;
234 u32 arb_rx; 233 u32 arb_rx;
235 u32 mrk_rx; 234 u32 mrk_rx;
236 u32 const_mrk_rx; 235 u32 const_mrk_rx;
237 u32 prim_unknown; 236 u32 prim_unknown;
238}; 237};
239 238
240 239
241struct bfa_fw_port_lksm_stats_s { 240struct bfa_fw_port_lksm_stats_s {
242 u32 hwsm_success; /* hwsm state machine success */ 241 u32 hwsm_success; /* hwsm state machine success */
243 u32 hwsm_fails; /* hwsm fails */ 242 u32 hwsm_fails; /* hwsm fails */
244 u32 hwsm_wdtov; /* hwsm timed out */ 243 u32 hwsm_wdtov; /* hwsm timed out */
245 u32 swsm_success; /* swsm success */ 244 u32 swsm_success; /* swsm success */
246 u32 swsm_fails; /* swsm fails */ 245 u32 swsm_fails; /* swsm fails */
247 u32 swsm_wdtov; /* swsm timed out */ 246 u32 swsm_wdtov; /* swsm timed out */
248 u32 busybufs; /* link init failed due to busybuf */ 247 u32 busybufs; /* link init failed due to busybuf */
249 u32 buf_waits; /* bufwait state entries */ 248 u32 buf_waits; /* bufwait state entries */
250 u32 link_fails; /* link failures */ 249 u32 link_fails; /* link failures */
251 u32 psp_errors; /* primitive sequence protocol errors */ 250 u32 psp_errors; /* primitive sequence protocol errors */
252 u32 lr_unexp; /* No. of times LR rx-ed unexpectedly */ 251 u32 lr_unexp; /* No. of times LR rx-ed unexpectedly */
253 u32 lrr_unexp; /* No. of times LRR rx-ed unexpectedly */ 252 u32 lrr_unexp; /* No. of times LRR rx-ed unexpectedly */
254 u32 lr_tx; /* No. of times LR tx started */ 253 u32 lr_tx; /* No. of times LR tx started */
255 u32 lrr_tx; /* No. of times LRR tx started */ 254 u32 lrr_tx; /* No. of times LRR tx started */
256 u32 ols_tx; /* No. of times OLS tx started */ 255 u32 ols_tx; /* No. of times OLS tx started */
257 u32 nos_tx; /* No. of times NOS tx started */ 256 u32 nos_tx; /* No. of times NOS tx started */
258 u32 hwsm_lrr_rx; /* No. of times LRR rx-ed by HWSM */ 257 u32 hwsm_lrr_rx; /* No. of times LRR rx-ed by HWSM */
259 u32 hwsm_lr_rx; /* No. of times LR rx-ed by HWSM */ 258 u32 hwsm_lr_rx; /* No. of times LR rx-ed by HWSM */
260 u32 bbsc_lr; /* LKSM LR tx for credit recovery */ 259 u32 bbsc_lr; /* LKSM LR tx for credit recovery */
261 u32 rsvd;
262}; 260};
263 261
264struct bfa_fw_port_snsm_stats_s { 262struct bfa_fw_port_snsm_stats_s {
265 u32 hwsm_success; /* Successful hwsm terminations */ 263 u32 hwsm_success; /* Successful hwsm terminations */
266 u32 hwsm_fails; /* hwsm fail count */ 264 u32 hwsm_fails; /* hwsm fail count */
267 u32 hwsm_wdtov; /* hwsm timed out */ 265 u32 hwsm_wdtov; /* hwsm timed out */
268 u32 swsm_success; /* swsm success */ 266 u32 swsm_success; /* swsm success */
269 u32 swsm_wdtov; /* swsm timed out */ 267 u32 swsm_wdtov; /* swsm timed out */
270 u32 error_resets; /* error resets initiated by upsm */ 268 u32 error_resets; /* error resets initiated by upsm */
271 u32 sync_lost; /* Sync loss count */ 269 u32 sync_lost; /* Sync loss count */
272 u32 sig_lost; /* Signal loss count */ 270 u32 sig_lost; /* Signal loss count */
273 u32 asn8g_attempts; /* SNSM HWSM at 8Gbps attempts */ 271 u32 asn8g_attempts; /* SNSM HWSM at 8Gbps attempts */
274 u32 adapt_success; /* SNSM adaptation success */
275 u32 adapt_fails; /* SNSM adaptation failures */
276 u32 adapt_ign_fails; /* SNSM adaptation failures ignored */
277}; 272};
278 273
279struct bfa_fw_port_physm_stats_s { 274struct bfa_fw_port_physm_stats_s {
280 u32 module_inserts; /* Module insert count */ 275 u32 module_inserts; /* Module insert count */
281 u32 module_xtracts; /* Module extracts count */ 276 u32 module_xtracts; /* Module extracts count */
282 u32 module_invalids; /* Invalid module inserted count */ 277 u32 module_invalids; /* Invalid module inserted count */
283 u32 module_read_ign; /* Module validation status ignored */ 278 u32 module_read_ign; /* Module validation status ignored */
284 u32 laser_faults; /* Laser fault count */ 279 u32 laser_faults; /* Laser fault count */
285 u32 rsvd; 280 u32 rsvd;
286}; 281};
287 282
288struct bfa_fw_fip_stats_s { 283struct bfa_fw_fip_stats_s {
289 u32 vlan_req; /* vlan discovery requests */ 284 u32 vlan_req; /* vlan discovery requests */
290 u32 vlan_notify; /* vlan notifications */ 285 u32 vlan_notify; /* vlan notifications */
291 u32 vlan_err; /* vlan response error */ 286 u32 vlan_err; /* vlan response error */
292 u32 vlan_timeouts; /* vlan disvoery timeouts */ 287 u32 vlan_timeouts; /* vlan disvoery timeouts */
293 u32 vlan_invalids; /* invalid vlan in discovery advert. */ 288 u32 vlan_invalids; /* invalid vlan in discovery advert. */
294 u32 disc_req; /* Discovery solicit requests */ 289 u32 disc_req; /* Discovery solicit requests */
295 u32 disc_rsp; /* Discovery solicit response */ 290 u32 disc_rsp; /* Discovery solicit response */
296 u32 disc_err; /* Discovery advt. parse errors */ 291 u32 disc_err; /* Discovery advt. parse errors */
297 u32 disc_unsol; /* Discovery unsolicited */ 292 u32 disc_unsol; /* Discovery unsolicited */
298 u32 disc_timeouts; /* Discovery timeouts */ 293 u32 disc_timeouts; /* Discovery timeouts */
299 u32 disc_fcf_unavail; /* Discovery FCF Not Avail. */ 294 u32 disc_fcf_unavail; /* Discovery FCF Not Avail. */
300 u32 linksvc_unsupp; /* Unsupported link service req */ 295 u32 linksvc_unsupp; /* Unsupported link service req */
301 u32 linksvc_err; /* Parse error in link service req */ 296 u32 linksvc_err; /* Parse error in link service req */
302 u32 logo_req; /* FIP logos received */ 297 u32 logo_req; /* FIP logos received */
303 u32 clrvlink_req; /* Clear virtual link req */ 298 u32 clrvlink_req; /* Clear virtual link req */
304 u32 op_unsupp; /* Unsupported FIP operation */ 299 u32 op_unsupp; /* Unsupported FIP operation */
305 u32 untagged; /* Untagged frames (ignored) */ 300 u32 untagged; /* Untagged frames (ignored) */
306 u32 invalid_version; /* Invalid FIP version */ 301 u32 invalid_version; /* Invalid FIP version */
307}; 302};
308 303
309struct bfa_fw_lps_stats_s { 304struct bfa_fw_lps_stats_s {
310 u32 mac_invalids; /* Invalid mac assigned */ 305 u32 mac_invalids; /* Invalid mac assigned */
311 u32 rsvd; 306 u32 rsvd;
312}; 307};
313 308
314struct bfa_fw_fcoe_stats_s { 309struct bfa_fw_fcoe_stats_s {
315 u32 cee_linkups; /* CEE link up count */ 310 u32 cee_linkups; /* CEE link up count */
316 u32 cee_linkdns; /* CEE link down count */ 311 u32 cee_linkdns; /* CEE link down count */
317 u32 fip_linkups; /* FIP link up count */ 312 u32 fip_linkups; /* FIP link up count */
318 u32 fip_linkdns; /* FIP link up count */ 313 u32 fip_linkdns; /* FIP link up count */
319 u32 fip_fails; /* FIP fail count */ 314 u32 fip_fails; /* FIP fail count */
320 u32 mac_invalids; /* Invalid mac assigned */ 315 u32 mac_invalids; /* Invalid mac assigned */
321}; 316};
322 317
323/* 318/*
324 * IOC firmware FCoE port stats 319 * IOC firmware FCoE port stats
325 */ 320 */
326struct bfa_fw_fcoe_port_stats_s { 321struct bfa_fw_fcoe_port_stats_s {
327 struct bfa_fw_fcoe_stats_s fcoe_stats; 322 struct bfa_fw_fcoe_stats_s fcoe_stats;
328 struct bfa_fw_fip_stats_s fip_stats; 323 struct bfa_fw_fip_stats_s fip_stats;
329};
330
331/**
332 * @brief LPSM statistics
333 */
334struct bfa_fw_lpsm_stats_s {
335 u32 cls_rx; /* LPSM cls_rx */
336 u32 cls_tx; /* LPSM cls_tx */
337 u32 arbf0_rx; /* LPSM abrf0 rcvd */
338 u32 arbf0_tx; /* LPSM abrf0 xmit */
339 u32 init_rx; /* LPSM loop init start */
340 u32 unexp_hwst; /* LPSM unknown hw state */
341 u32 unexp_frame; /* LPSM unknown_frame */
342 u32 unexp_prim; /* LPSM unexpected primitive */
343 u32 prev_alpa_unavail; /* LPSM prev alpa unavailable */
344 u32 alpa_unavail; /* LPSM alpa not available */
345 u32 lip_rx; /* LPSM lip rcvd */
346 u32 lip_f7f7_rx; /* LPSM lip f7f7 rcvd */
347 u32 lip_f8_rx; /* LPSM lip f8 rcvd */
348 u32 lip_f8f7_rx; /* LPSM lip f8f7 rcvd */
349 u32 lip_other_rx; /* LPSM lip other rcvd */
350 u32 lip_tx; /* LPSM lip xmit */
351 u32 retry_tov; /* LPSM retry TOV */
352 u32 lip_tov; /* LPSM LIP wait TOV */
353 u32 idle_tov; /* LPSM idle wait TOV */
354 u32 arbf0_tov; /* LPSM arbfo wait TOV */
355 u32 stop_loop_tov; /* LPSM stop loop wait TOV */
356 u32 lixa_tov; /* LPSM lisa wait TOV */
357 u32 lixx_tov; /* LPSM lilp/lirp wait TOV */
358 u32 cls_tov; /* LPSM cls wait TOV */
359 u32 sler; /* LPSM SLER recvd */
360 u32 failed; /* LPSM failed */
361 u32 success; /* LPSM online */
362}; 324};
363 325
364/* 326/*
@@ -367,15 +329,14 @@ struct bfa_fw_lpsm_stats_s {
367struct bfa_fw_fc_uport_stats_s { 329struct bfa_fw_fc_uport_stats_s {
368 struct bfa_fw_port_snsm_stats_s snsm_stats; 330 struct bfa_fw_port_snsm_stats_s snsm_stats;
369 struct bfa_fw_port_lksm_stats_s lksm_stats; 331 struct bfa_fw_port_lksm_stats_s lksm_stats;
370 struct bfa_fw_lpsm_stats_s lpsm_stats;
371}; 332};
372 333
373/* 334/*
374 * IOC firmware FC port stats 335 * IOC firmware FC port stats
375 */ 336 */
376union bfa_fw_fc_port_stats_s { 337union bfa_fw_fc_port_stats_s {
377 struct bfa_fw_fc_uport_stats_s fc_stats; 338 struct bfa_fw_fc_uport_stats_s fc_stats;
378 struct bfa_fw_fcoe_port_stats_s fcoe_stats; 339 struct bfa_fw_fcoe_port_stats_s fcoe_stats;
379}; 340};
380 341
381/* 342/*
@@ -395,30 +356,35 @@ struct bfa_fw_fcxchg_stats_s {
395 u32 ua_state_inv; 356 u32 ua_state_inv;
396}; 357};
397 358
359struct bfa_fw_lpsm_stats_s {
360 u32 cls_rx;
361 u32 cls_tx;
362};
363
398/* 364/*
399 * Trunk statistics 365 * Trunk statistics
400 */ 366 */
401struct bfa_fw_trunk_stats_s { 367struct bfa_fw_trunk_stats_s {
402 u32 emt_recvd; /* Trunk EMT received */ 368 u32 emt_recvd; /* Trunk EMT received */
403 u32 emt_accepted; /* Trunk EMT Accepted */ 369 u32 emt_accepted; /* Trunk EMT Accepted */
404 u32 emt_rejected; /* Trunk EMT rejected */ 370 u32 emt_rejected; /* Trunk EMT rejected */
405 u32 etp_recvd; /* Trunk ETP received */ 371 u32 etp_recvd; /* Trunk ETP received */
406 u32 etp_accepted; /* Trunk ETP Accepted */ 372 u32 etp_accepted; /* Trunk ETP Accepted */
407 u32 etp_rejected; /* Trunk ETP rejected */ 373 u32 etp_rejected; /* Trunk ETP rejected */
408 u32 lr_recvd; /* Trunk LR received */ 374 u32 lr_recvd; /* Trunk LR received */
409 u32 rsvd; /* padding for 64 bit alignment */ 375 u32 rsvd; /* padding for 64 bit alignment */
410}; 376};
411 377
412struct bfa_fw_advsm_stats_s { 378struct bfa_fw_advsm_stats_s {
413 u32 flogi_sent; /* Flogi sent */ 379 u32 flogi_sent; /* Flogi sent */
414 u32 flogi_acc_recvd; /* Flogi Acc received */ 380 u32 flogi_acc_recvd; /* Flogi Acc received */
415 u32 flogi_rjt_recvd; /* Flogi rejects received */ 381 u32 flogi_rjt_recvd; /* Flogi rejects received */
416 u32 flogi_retries; /* Flogi retries */ 382 u32 flogi_retries; /* Flogi retries */
417 383
418 u32 elp_recvd; /* ELP received */ 384 u32 elp_recvd; /* ELP received */
419 u32 elp_accepted; /* ELP Accepted */ 385 u32 elp_accepted; /* ELP Accepted */
420 u32 elp_rejected; /* ELP rejected */ 386 u32 elp_rejected; /* ELP rejected */
421 u32 elp_dropped; /* ELP dropped */ 387 u32 elp_dropped; /* ELP dropped */
422}; 388};
423 389
424/* 390/*
@@ -487,6 +453,7 @@ struct bfa_fw_stats_s {
487 struct bfa_fw_io_stats_s io_stats; 453 struct bfa_fw_io_stats_s io_stats;
488 struct bfa_fw_port_stats_s port_stats; 454 struct bfa_fw_port_stats_s port_stats;
489 struct bfa_fw_fcxchg_stats_s fcxchg_stats; 455 struct bfa_fw_fcxchg_stats_s fcxchg_stats;
456 struct bfa_fw_lpsm_stats_s lpsm_stats;
490 struct bfa_fw_lps_stats_s lps_stats; 457 struct bfa_fw_lps_stats_s lps_stats;
491 struct bfa_fw_trunk_stats_s trunk_stats; 458 struct bfa_fw_trunk_stats_s trunk_stats;
492 struct bfa_fw_advsm_stats_s advsm_stats; 459 struct bfa_fw_advsm_stats_s advsm_stats;
@@ -526,23 +493,13 @@ enum bfa_qos_bw_alloc {
526 BFA_QOS_BW_LOW = 10, /* bandwidth allocation for Low */ 493 BFA_QOS_BW_LOW = 10, /* bandwidth allocation for Low */
527}; 494};
528#pragma pack(1) 495#pragma pack(1)
529
530struct bfa_qos_bw_s {
531 u8 qos_bw_set;
532 u8 high;
533 u8 med;
534 u8 low;
535};
536
537/* 496/*
538 * QoS attribute returned in QoS Query 497 * QoS attribute returned in QoS Query
539 */ 498 */
540struct bfa_qos_attr_s { 499struct bfa_qos_attr_s {
541 u8 state; /* QoS current state */ 500 u8 state; /* QoS current state */
542 u8 rsvd1[3]; 501 u8 rsvd[3];
543 u32 total_bb_cr; /* Total BB Credits */ 502 u32 total_bb_cr; /* Total BB Credits */
544 struct bfa_qos_bw_s qos_bw; /* QOS bw cfg */
545 struct bfa_qos_bw_s qos_bw_op; /* QOS bw operational */
546}; 503};
547 504
548/* 505/*
@@ -564,7 +521,7 @@ struct bfa_qos_vc_attr_s {
564 u16 total_vc_count; /* Total VC Count */ 521 u16 total_vc_count; /* Total VC Count */
565 u16 shared_credit; 522 u16 shared_credit;
566 u32 elp_opmode_flags; 523 u32 elp_opmode_flags;
567 struct bfa_qos_vc_info_s vc_info[BFA_QOS_MAX_VC]; /* as many as 524 struct bfa_qos_vc_info_s vc_info[BFA_QOS_MAX_VC]; /* as many as
568 * total_vc_count */ 525 * total_vc_count */
569}; 526};
570 527
@@ -574,16 +531,16 @@ struct bfa_qos_vc_attr_s {
574struct bfa_qos_stats_s { 531struct bfa_qos_stats_s {
575 u32 flogi_sent; /* QoS Flogi sent */ 532 u32 flogi_sent; /* QoS Flogi sent */
576 u32 flogi_acc_recvd; /* QoS Flogi Acc received */ 533 u32 flogi_acc_recvd; /* QoS Flogi Acc received */
577 u32 flogi_rjt_recvd; /* QoS Flogi rejects received */ 534 u32 flogi_rjt_recvd; /* QoS Flogi rejects received */
578 u32 flogi_retries; /* QoS Flogi retries */ 535 u32 flogi_retries; /* QoS Flogi retries */
579 536
580 u32 elp_recvd; /* QoS ELP received */ 537 u32 elp_recvd; /* QoS ELP received */
581 u32 elp_accepted; /* QoS ELP Accepted */ 538 u32 elp_accepted; /* QoS ELP Accepted */
582 u32 elp_rejected; /* QoS ELP rejected */ 539 u32 elp_rejected; /* QoS ELP rejected */
583 u32 elp_dropped; /* QoS ELP dropped */ 540 u32 elp_dropped; /* QoS ELP dropped */
584 541
585 u32 qos_rscn_recvd; /* QoS RSCN received */ 542 u32 qos_rscn_recvd; /* QoS RSCN received */
586 u32 rsvd; /* padding for 64 bit alignment */ 543 u32 rsvd; /* padding for 64 bit alignment */
587}; 544};
588 545
589/* 546/*
@@ -591,9 +548,9 @@ struct bfa_qos_stats_s {
591 */ 548 */
592struct bfa_fcoe_stats_s { 549struct bfa_fcoe_stats_s {
593 u64 secs_reset; /* Seconds since stats reset */ 550 u64 secs_reset; /* Seconds since stats reset */
594 u64 cee_linkups; /* CEE link up */ 551 u64 cee_linkups; /* CEE link up */
595 u64 cee_linkdns; /* CEE link down */ 552 u64 cee_linkdns; /* CEE link down */
596 u64 fip_linkups; /* FIP link up */ 553 u64 fip_linkups; /* FIP link up */
597 u64 fip_linkdns; /* FIP link down */ 554 u64 fip_linkdns; /* FIP link down */
598 u64 fip_fails; /* FIP failures */ 555 u64 fip_fails; /* FIP failures */
599 u64 mac_invalids; /* Invalid mac assignments */ 556 u64 mac_invalids; /* Invalid mac assignments */
@@ -603,38 +560,38 @@ struct bfa_fcoe_stats_s {
603 u64 vlan_timeouts; /* Vlan request timeouts */ 560 u64 vlan_timeouts; /* Vlan request timeouts */
604 u64 vlan_invalids; /* Vlan invalids */ 561 u64 vlan_invalids; /* Vlan invalids */
605 u64 disc_req; /* Discovery requests */ 562 u64 disc_req; /* Discovery requests */
606 u64 disc_rsp; /* Discovery responses */ 563 u64 disc_rsp; /* Discovery responses */
607 u64 disc_err; /* Discovery error frames */ 564 u64 disc_err; /* Discovery error frames */
608 u64 disc_unsol; /* Discovery unsolicited */ 565 u64 disc_unsol; /* Discovery unsolicited */
609 u64 disc_timeouts; /* Discovery timeouts */ 566 u64 disc_timeouts; /* Discovery timeouts */
610 u64 disc_fcf_unavail; /* Discovery FCF not avail */ 567 u64 disc_fcf_unavail; /* Discovery FCF not avail */
611 u64 linksvc_unsupp; /* FIP link service req unsupp */ 568 u64 linksvc_unsupp; /* FIP link service req unsupp. */
612 u64 linksvc_err; /* FIP link service req errors */ 569 u64 linksvc_err; /* FIP link service req errors */
613 u64 logo_req; /* FIP logos received */ 570 u64 logo_req; /* FIP logos received */
614 u64 clrvlink_req; /* Clear virtual link requests */ 571 u64 clrvlink_req; /* Clear virtual link requests */
615 u64 op_unsupp; /* FIP operation unsupp. */ 572 u64 op_unsupp; /* FIP operation unsupp. */
616 u64 untagged; /* FIP untagged frames */ 573 u64 untagged; /* FIP untagged frames */
617 u64 txf_ucast; /* Tx FCoE unicast frames */ 574 u64 txf_ucast; /* Tx FCoE unicast frames */
618 u64 txf_ucast_vlan; /* Tx FCoE unicast vlan frames */ 575 u64 txf_ucast_vlan; /* Tx FCoE unicast vlan frames */
619 u64 txf_ucast_octets; /* Tx FCoE unicast octets */ 576 u64 txf_ucast_octets; /* Tx FCoE unicast octets */
620 u64 txf_mcast; /* Tx FCoE multicast frames */ 577 u64 txf_mcast; /* Tx FCoE multicast frames */
621 u64 txf_mcast_vlan; /* Tx FCoE multicast vlan frames */ 578 u64 txf_mcast_vlan; /* Tx FCoE multicast vlan frames */
622 u64 txf_mcast_octets; /* Tx FCoE multicast octets */ 579 u64 txf_mcast_octets; /* Tx FCoE multicast octets */
623 u64 txf_bcast; /* Tx FCoE broadcast frames */ 580 u64 txf_bcast; /* Tx FCoE broadcast frames */
624 u64 txf_bcast_vlan; /* Tx FCoE broadcast vlan frames */ 581 u64 txf_bcast_vlan; /* Tx FCoE broadcast vlan frames */
625 u64 txf_bcast_octets; /* Tx FCoE broadcast octets */ 582 u64 txf_bcast_octets; /* Tx FCoE broadcast octets */
626 u64 txf_timeout; /* Tx timeouts */ 583 u64 txf_timeout; /* Tx timeouts */
627 u64 txf_parity_errors; /* Transmit parity err */ 584 u64 txf_parity_errors; /* Transmit parity err */
628 u64 txf_fid_parity_errors; /* Transmit FID parity err */ 585 u64 txf_fid_parity_errors; /* Transmit FID parity err */
629 u64 rxf_ucast_octets; /* Rx FCoE unicast octets */ 586 u64 rxf_ucast_octets; /* Rx FCoE unicast octets */
630 u64 rxf_ucast; /* Rx FCoE unicast frames */ 587 u64 rxf_ucast; /* Rx FCoE unicast frames */
631 u64 rxf_ucast_vlan; /* Rx FCoE unicast vlan frames */ 588 u64 rxf_ucast_vlan; /* Rx FCoE unicast vlan frames */
632 u64 rxf_mcast_octets; /* Rx FCoE multicast octets */ 589 u64 rxf_mcast_octets; /* Rx FCoE multicast octets */
633 u64 rxf_mcast; /* Rx FCoE multicast frames */ 590 u64 rxf_mcast; /* Rx FCoE multicast frames */
634 u64 rxf_mcast_vlan; /* Rx FCoE multicast vlan frames */ 591 u64 rxf_mcast_vlan; /* Rx FCoE multicast vlan frames */
635 u64 rxf_bcast_octets; /* Rx FCoE broadcast octets */ 592 u64 rxf_bcast_octets; /* Rx FCoE broadcast octets */
636 u64 rxf_bcast; /* Rx FCoE broadcast frames */ 593 u64 rxf_bcast; /* Rx FCoE broadcast frames */
637 u64 rxf_bcast_vlan; /* Rx FCoE broadcast vlan frames */ 594 u64 rxf_bcast_vlan; /* Rx FCoE broadcast vlan frames */
638}; 595};
639 596
640/* 597/*
@@ -715,7 +672,12 @@ struct bfa_itnim_iostats_s {
715 u32 tm_iocdowns; /* TM cleaned-up due to IOC down */ 672 u32 tm_iocdowns; /* TM cleaned-up due to IOC down */
716 u32 tm_cleanups; /* TM cleanup requests */ 673 u32 tm_cleanups; /* TM cleanup requests */
717 u32 tm_cleanup_comps; /* TM cleanup completions */ 674 u32 tm_cleanup_comps; /* TM cleanup completions */
718 u32 rsvd[6]; 675 u32 lm_lun_across_sg; /* LM lun is across sg data buf */
676 u32 lm_lun_not_sup; /* LM lun not supported */
677 u32 lm_rpl_data_changed; /* LM report-lun data changed */
678 u32 lm_wire_residue_changed; /* LM report-lun rsp residue changed */
679 u32 lm_small_buf_addresidue; /* LM buf smaller than reported cnt */
680 u32 lm_lun_not_rdy; /* LM lun not ready */
719}; 681};
720 682
721/* Modify char* port_stt[] in bfal_port.c if a new state was added */ 683/* Modify char* port_stt[] in bfal_port.c if a new state was added */
@@ -734,8 +696,7 @@ enum bfa_port_states {
734 BFA_PORT_ST_FWMISMATCH = 12, 696 BFA_PORT_ST_FWMISMATCH = 12,
735 BFA_PORT_ST_PREBOOT_DISABLED = 13, 697 BFA_PORT_ST_PREBOOT_DISABLED = 13,
736 BFA_PORT_ST_TOGGLING_QWAIT = 14, 698 BFA_PORT_ST_TOGGLING_QWAIT = 14,
737 BFA_PORT_ST_FAA_MISCONFIG = 15, 699 BFA_PORT_ST_ACQ_ADDR = 15,
738 BFA_PORT_ST_DPORT = 16,
739 BFA_PORT_ST_MAX_STATE, 700 BFA_PORT_ST_MAX_STATE,
740}; 701};
741 702
@@ -757,11 +718,9 @@ enum bfa_port_type {
757 */ 718 */
758enum bfa_port_topology { 719enum bfa_port_topology {
759 BFA_PORT_TOPOLOGY_NONE = 0, /* No valid topology */ 720 BFA_PORT_TOPOLOGY_NONE = 0, /* No valid topology */
760 BFA_PORT_TOPOLOGY_P2P_OLD_VER = 1, /* P2P def for older ver */ 721 BFA_PORT_TOPOLOGY_P2P = 1, /* P2P only */
761 BFA_PORT_TOPOLOGY_LOOP = 2, /* LOOP topology */ 722 BFA_PORT_TOPOLOGY_LOOP = 2, /* LOOP topology */
762 BFA_PORT_TOPOLOGY_AUTO_OLD_VER = 3, /* auto def for older ver */ 723 BFA_PORT_TOPOLOGY_AUTO = 3, /* auto topology selection */
763 BFA_PORT_TOPOLOGY_AUTO = 4, /* auto topology selection */
764 BFA_PORT_TOPOLOGY_P2P = 5, /* P2P only */
765}; 724};
766 725
767/* 726/*
@@ -805,7 +764,6 @@ enum bfa_port_linkstate_rsn {
805 BFA_PORT_LINKSTATE_RSN_LOCAL_FAULT = 9, 764 BFA_PORT_LINKSTATE_RSN_LOCAL_FAULT = 9,
806 BFA_PORT_LINKSTATE_RSN_REMOTE_FAULT = 10, 765 BFA_PORT_LINKSTATE_RSN_REMOTE_FAULT = 10,
807 BFA_PORT_LINKSTATE_RSN_TIMEOUT = 11, 766 BFA_PORT_LINKSTATE_RSN_TIMEOUT = 11,
808 BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG = 12,
809 767
810 768
811 769
@@ -879,19 +837,6 @@ struct bfa_lunmask_cfg_s {
879 struct bfa_lun_mask_s lun_list[MAX_LUN_MASK_CFG]; 837 struct bfa_lun_mask_s lun_list[MAX_LUN_MASK_CFG];
880}; 838};
881 839
882struct bfa_throttle_cfg_s {
883 u16 is_valid;
884 u16 value;
885 u32 rsvd;
886};
887
888struct bfa_defs_fcpim_throttle_s {
889 u16 max_value;
890 u16 cur_value;
891 u16 cfg_value;
892 u16 rsvd;
893};
894
895/* 840/*
896 * Physical port configuration 841 * Physical port configuration
897 */ 842 */
@@ -907,13 +852,12 @@ struct bfa_port_cfg_s {
907 u8 tx_bbcredit; /* transmit buffer credits */ 852 u8 tx_bbcredit; /* transmit buffer credits */
908 u8 ratelimit; /* ratelimit enabled or not */ 853 u8 ratelimit; /* ratelimit enabled or not */
909 u8 trl_def_speed; /* ratelimit default speed */ 854 u8 trl_def_speed; /* ratelimit default speed */
910 u8 bb_scn; /* BB_SCN value from FLOGI Exchg */ 855 u8 bb_scn; /* BB_SCN value from FLOGI Exchg */
911 u8 bb_scn_state; /* Config state of BB_SCN */ 856 u8 bb_scn_state; /* Config state of BB_SCN */
912 u8 faa_state; /* FAA enabled/disabled */ 857 u8 faa_state; /* FAA enabled/disabled */
913 u8 rsvd1; 858 u8 rsvd[1];
914 u16 path_tov; /* device path timeout */ 859 u16 path_tov; /* device path timeout */
915 u16 q_depth; /* SCSI Queue depth */ 860 u16 q_depth; /* SCSI Queue depth */
916 struct bfa_qos_bw_s qos_bw; /* QOS bandwidth */
917}; 861};
918#pragma pack() 862#pragma pack()
919 863
@@ -924,21 +868,20 @@ struct bfa_port_attr_s {
924 /* 868 /*
925 * Static fields 869 * Static fields
926 */ 870 */
927 wwn_t nwwn; /* node wwn */ 871 wwn_t nwwn; /* node wwn */
928 wwn_t pwwn; /* port wwn */ 872 wwn_t pwwn; /* port wwn */
929 wwn_t factorynwwn; /* factory node wwn */ 873 wwn_t factorynwwn; /* factory node wwn */
930 wwn_t factorypwwn; /* factory port wwn */ 874 wwn_t factorypwwn; /* factory port wwn */
931 enum fc_cos cos_supported; /* supported class of 875 enum fc_cos cos_supported; /* supported class of services */
932 * services */ 876 u32 rsvd;
933 u32 rsvd;
934 struct fc_symname_s port_symname; /* port symbolic name */ 877 struct fc_symname_s port_symname; /* port symbolic name */
935 enum bfa_port_speed speed_supported; /* supported speeds */ 878 enum bfa_port_speed speed_supported; /* supported speeds */
936 bfa_boolean_t pbind_enabled; 879 bfa_boolean_t pbind_enabled;
937 880
938 /* 881 /*
939 * Configured values 882 * Configured values
940 */ 883 */
941 struct bfa_port_cfg_s pport_cfg; /* pport cfg */ 884 struct bfa_port_cfg_s pport_cfg; /* pport cfg */
942 885
943 /* 886 /*
944 * Dynamic field - info from BFA 887 * Dynamic field - info from BFA
@@ -947,69 +890,68 @@ struct bfa_port_attr_s {
947 enum bfa_port_speed speed; /* current speed */ 890 enum bfa_port_speed speed; /* current speed */
948 enum bfa_port_topology topology; /* current topology */ 891 enum bfa_port_topology topology; /* current topology */
949 bfa_boolean_t beacon; /* current beacon status */ 892 bfa_boolean_t beacon; /* current beacon status */
950 bfa_boolean_t link_e2e_beacon; /* link beacon is on */ 893 bfa_boolean_t link_e2e_beacon; /* link beacon is on */
951 bfa_boolean_t bbsc_op_status; /* fc credit recovery oper 894 bfa_boolean_t bbsc_op_status; /* fc credit recovery oper state */
952 * state */
953 895
954 /* 896 /*
955 * Dynamic field - info from FCS 897 * Dynamic field - info from FCS
956 */ 898 */
957 u32 pid; /* port ID */ 899 u32 pid; /* port ID */
958 enum bfa_port_type port_type; /* current topology */ 900 enum bfa_port_type port_type; /* current topology */
959 u32 loopback; /* external loopback */ 901 u32 loopback; /* external loopback */
960 u32 authfail; /* auth fail state */ 902 u32 authfail; /* auth fail state */
961 903
962 /* FCoE specific */ 904 /* FCoE specific */
963 u16 fcoe_vlan; 905 u16 fcoe_vlan;
964 u8 rsvd1[6]; 906 u8 rsvd1[2];
965}; 907};
966 908
967/* 909/*
968 * Port FCP mappings. 910 * Port FCP mappings.
969 */ 911 */
970struct bfa_port_fcpmap_s { 912struct bfa_port_fcpmap_s {
971 char osdevname[256]; 913 char osdevname[256];
972 u32 bus; 914 u32 bus;
973 u32 target; 915 u32 target;
974 u32 oslun; 916 u32 oslun;
975 u32 fcid; 917 u32 fcid;
976 wwn_t nwwn; 918 wwn_t nwwn;
977 wwn_t pwwn; 919 wwn_t pwwn;
978 u64 fcplun; 920 u64 fcplun;
979 char luid[256]; 921 char luid[256];
980}; 922};
981 923
982/* 924/*
983 * Port RNID info. 925 * Port RNID info.
984 */ 926 */
985struct bfa_port_rnid_s { 927struct bfa_port_rnid_s {
986 wwn_t wwn; 928 wwn_t wwn;
987 u32 unittype; 929 u32 unittype;
988 u32 portid; 930 u32 portid;
989 u32 attached_nodes_num; 931 u32 attached_nodes_num;
990 u16 ip_version; 932 u16 ip_version;
991 u16 udp_port; 933 u16 udp_port;
992 u8 ipaddr[16]; 934 u8 ipaddr[16];
993 u16 rsvd; 935 u16 rsvd;
994 u16 topologydiscoveryflags; 936 u16 topologydiscoveryflags;
995}; 937};
996 938
997#pragma pack(1) 939#pragma pack(1)
998struct bfa_fcport_fcf_s { 940struct bfa_fcport_fcf_s {
999 wwn_t name; /* FCF name */ 941 wwn_t name; /* FCF name */
1000 wwn_t fabric_name; /* Fabric Name */ 942 wwn_t fabric_name; /* Fabric Name */
1001 u8 fipenabled; /* FIP enabled or not */ 943 u8 fipenabled; /* FIP enabled or not */
1002 u8 fipfailed; /* FIP failed or not */ 944 u8 fipfailed; /* FIP failed or not */
1003 u8 resv[2]; 945 u8 resv[2];
1004 u8 pri; /* FCF priority */ 946 u8 pri; /* FCF priority */
1005 u8 version; /* FIP version used */ 947 u8 version; /* FIP version used */
1006 u8 available; /* Available for login */ 948 u8 available; /* Available for login */
1007 u8 fka_disabled; /* FKA is disabled */ 949 u8 fka_disabled; /* FKA is disabled */
1008 u8 maxsz_verified; /* FCoE max size verified */ 950 u8 maxsz_verified; /* FCoE max size verified */
1009 u8 fc_map[3]; /* FC map */ 951 u8 fc_map[3]; /* FC map */
1010 __be16 vlan; /* FCoE vlan tag/priority */ 952 __be16 vlan; /* FCoE vlan tag/priority */
1011 u32 fka_adv_per; /* FIP ka advert. period */ 953 u32 fka_adv_per; /* FIP ka advert. period */
1012 mac_t mac; /* FCF mac */ 954 mac_t mac; /* FCF mac */
1013}; 955};
1014 956
1015/* 957/*
@@ -1031,13 +973,6 @@ struct bfa_trunk_vc_attr_s {
1031 u16 vc_credits[8]; 973 u16 vc_credits[8];
1032}; 974};
1033 975
1034struct bfa_fcport_loop_info_s {
1035 u8 myalpa; /* alpa claimed */
1036 u8 alpabm_val; /* alpa bitmap valid or not (1 or 0) */
1037 u8 resvd[6];
1038 struct fc_alpabm_s alpabm; /* alpa bitmap */
1039};
1040
1041/* 976/*
1042 * Link state information 977 * Link state information
1043 */ 978 */
@@ -1046,20 +981,15 @@ struct bfa_port_link_s {
1046 u8 linkstate_rsn; /* bfa_port_linkstate_rsn_t */ 981 u8 linkstate_rsn; /* bfa_port_linkstate_rsn_t */
1047 u8 topology; /* P2P/LOOP bfa_port_topology */ 982 u8 topology; /* P2P/LOOP bfa_port_topology */
1048 u8 speed; /* Link speed (1/2/4/8 G) */ 983 u8 speed; /* Link speed (1/2/4/8 G) */
1049 u32 linkstate_opt; /* Linkstate optional data (debug) */ 984 u32 linkstate_opt; /* Linkstate optional data (debug) */
1050 u8 trunked; /* Trunked or not (1 or 0) */ 985 u8 trunked; /* Trunked or not (1 or 0) */
1051 u8 resvd[7]; 986 u8 resvd[3];
1052 struct bfa_qos_attr_s qos_attr; /* QoS Attributes */ 987 struct bfa_qos_attr_s qos_attr; /* QoS Attributes */
1053 union { 988 union {
1054 struct bfa_fcport_loop_info_s loop_info; 989 struct bfa_qos_vc_attr_s qos_vc_attr; /* VC info from ELP */
1055 union { 990 struct bfa_trunk_vc_attr_s trunk_vc_attr;
1056 struct bfa_qos_vc_attr_s qos_vc_attr; 991 struct bfa_fcport_fcf_s fcf; /* FCF information (for FCoE) */
1057 /* VC info from ELP */ 992 } vc_fcf;
1058 struct bfa_trunk_vc_attr_s trunk_vc_attr;
1059 struct bfa_fcport_fcf_s fcf;
1060 /* FCF information (for FCoE) */
1061 } vc_fcf;
1062 } attr;
1063}; 993};
1064#pragma pack() 994#pragma pack()
1065 995
@@ -1105,7 +1035,7 @@ struct bfa_rport_hal_stats_s {
1105 u32 sm_fwc_del; /* fw create: delete events */ 1035 u32 sm_fwc_del; /* fw create: delete events */
1106 u32 sm_fwc_off; /* fw create: offline events */ 1036 u32 sm_fwc_off; /* fw create: offline events */
1107 u32 sm_fwc_hwf; /* fw create: IOC down */ 1037 u32 sm_fwc_hwf; /* fw create: IOC down */
1108 u32 sm_fwc_unexp; /* fw create: exception events*/ 1038 u32 sm_fwc_unexp; /* fw create: exception events*/
1109 u32 sm_on_off; /* online: offline events */ 1039 u32 sm_on_off; /* online: offline events */
1110 u32 sm_on_del; /* online: delete events */ 1040 u32 sm_on_del; /* online: delete events */
1111 u32 sm_on_hwf; /* online: IOC down events */ 1041 u32 sm_on_hwf; /* online: IOC down events */
@@ -1113,25 +1043,25 @@ struct bfa_rport_hal_stats_s {
1113 u32 sm_fwd_rsp; /* fw delete: fw responses */ 1043 u32 sm_fwd_rsp; /* fw delete: fw responses */
1114 u32 sm_fwd_del; /* fw delete: delete events */ 1044 u32 sm_fwd_del; /* fw delete: delete events */
1115 u32 sm_fwd_hwf; /* fw delete: IOC down events */ 1045 u32 sm_fwd_hwf; /* fw delete: IOC down events */
1116 u32 sm_fwd_unexp; /* fw delete: exception events*/ 1046 u32 sm_fwd_unexp; /* fw delete: exception events*/
1117 u32 sm_off_del; /* offline: delete events */ 1047 u32 sm_off_del; /* offline: delete events */
1118 u32 sm_off_on; /* offline: online events */ 1048 u32 sm_off_on; /* offline: online events */
1119 u32 sm_off_hwf; /* offline: IOC down events */ 1049 u32 sm_off_hwf; /* offline: IOC down events */
1120 u32 sm_off_unexp; /* offline: exception events */ 1050 u32 sm_off_unexp; /* offline: exception events */
1121 u32 sm_del_fwrsp; /* delete: fw responses */ 1051 u32 sm_del_fwrsp; /* delete: fw responses */
1122 u32 sm_del_hwf; /* delete: IOC down events */ 1052 u32 sm_del_hwf; /* delete: IOC down events */
1123 u32 sm_del_unexp; /* delete: exception events */ 1053 u32 sm_del_unexp; /* delete: exception events */
1124 u32 sm_delp_fwrsp; /* delete pend: fw responses */ 1054 u32 sm_delp_fwrsp; /* delete pend: fw responses */
1125 u32 sm_delp_hwf; /* delete pend: IOC downs */ 1055 u32 sm_delp_hwf; /* delete pend: IOC downs */
1126 u32 sm_delp_unexp; /* delete pend: exceptions */ 1056 u32 sm_delp_unexp; /* delete pend: exceptions */
1127 u32 sm_offp_fwrsp; /* off-pending: fw responses */ 1057 u32 sm_offp_fwrsp; /* off-pending: fw responses */
1128 u32 sm_offp_del; /* off-pending: deletes */ 1058 u32 sm_offp_del; /* off-pending: deletes */
1129 u32 sm_offp_hwf; /* off-pending: IOC downs */ 1059 u32 sm_offp_hwf; /* off-pending: IOC downs */
1130 u32 sm_offp_unexp; /* off-pending: exceptions */ 1060 u32 sm_offp_unexp; /* off-pending: exceptions */
1131 u32 sm_iocd_off; /* IOC down: offline events */ 1061 u32 sm_iocd_off; /* IOC down: offline events */
1132 u32 sm_iocd_del; /* IOC down: delete events */ 1062 u32 sm_iocd_del; /* IOC down: delete events */
1133 u32 sm_iocd_on; /* IOC down: online events */ 1063 u32 sm_iocd_on; /* IOC down: online events */
1134 u32 sm_iocd_unexp; /* IOC down: exceptions */ 1064 u32 sm_iocd_unexp; /* IOC down: exceptions */
1135 u32 rsvd; 1065 u32 rsvd;
1136}; 1066};
1137#pragma pack(1) 1067#pragma pack(1)
@@ -1139,9 +1069,9 @@ struct bfa_rport_hal_stats_s {
1139 * Rport's QoS attributes 1069 * Rport's QoS attributes
1140 */ 1070 */
1141struct bfa_rport_qos_attr_s { 1071struct bfa_rport_qos_attr_s {
1142 u8 qos_priority; /* rport's QoS priority */ 1072 u8 qos_priority; /* rport's QoS priority */
1143 u8 rsvd[3]; 1073 u8 rsvd[3];
1144 u32 qos_flow_id; /* QoS flow Id */ 1074 u32 qos_flow_id; /* QoS flow Id */
1145}; 1075};
1146#pragma pack() 1076#pragma pack()
1147 1077
@@ -1184,9 +1114,6 @@ struct bfa_port_fc_stats_s {
1184 u64 tx_frames; /* Tx frames */ 1114 u64 tx_frames; /* Tx frames */
1185 u64 tx_words; /* Tx words */ 1115 u64 tx_words; /* Tx words */
1186 u64 tx_lip; /* Tx LIP */ 1116 u64 tx_lip; /* Tx LIP */
1187 u64 tx_lip_f7f7; /* Tx LIP_F7F7 */
1188 u64 tx_lip_f8f7; /* Tx LIP_F8F7 */
1189 u64 tx_arbf0; /* Tx ARB F0 */
1190 u64 tx_nos; /* Tx NOS */ 1117 u64 tx_nos; /* Tx NOS */
1191 u64 tx_ols; /* Tx OLS */ 1118 u64 tx_ols; /* Tx OLS */
1192 u64 tx_lr; /* Tx LR */ 1119 u64 tx_lr; /* Tx LR */
@@ -1194,9 +1121,6 @@ struct bfa_port_fc_stats_s {
1194 u64 rx_frames; /* Rx frames */ 1121 u64 rx_frames; /* Rx frames */
1195 u64 rx_words; /* Rx words */ 1122 u64 rx_words; /* Rx words */
1196 u64 lip_count; /* Rx LIP */ 1123 u64 lip_count; /* Rx LIP */
1197 u64 rx_lip_f7f7; /* Rx LIP_F7F7 */
1198 u64 rx_lip_f8f7; /* Rx LIP_F8F7 */
1199 u64 rx_arbf0; /* Rx ARB F0 */
1200 u64 nos_count; /* Rx NOS */ 1124 u64 nos_count; /* Rx NOS */
1201 u64 ols_count; /* Rx OLS */ 1125 u64 ols_count; /* Rx OLS */
1202 u64 lr_count; /* Rx LR */ 1126 u64 lr_count; /* Rx LR */
@@ -1218,7 +1142,6 @@ struct bfa_port_fc_stats_s {
1218 u64 bbsc_frames_lost; /* Credit Recovery-Frames Lost */ 1142 u64 bbsc_frames_lost; /* Credit Recovery-Frames Lost */
1219 u64 bbsc_credits_lost; /* Credit Recovery-Credits Lost */ 1143 u64 bbsc_credits_lost; /* Credit Recovery-Credits Lost */
1220 u64 bbsc_link_resets; /* Credit Recovery-Link Resets */ 1144 u64 bbsc_link_resets; /* Credit Recovery-Link Resets */
1221 u64 loop_timeouts; /* Loop timeouts */
1222}; 1145};
1223 1146
1224/* 1147/*
diff --git a/drivers/scsi/bfa/bfa_fc.h b/drivers/scsi/bfa/bfa_fc.h
index bea821b9803..50b6a1c8619 100644
--- a/drivers/scsi/bfa/bfa_fc.h
+++ b/drivers/scsi/bfa/bfa_fc.h
@@ -24,7 +24,6 @@ typedef u64 wwn_t;
24 24
25#define WWN_NULL (0) 25#define WWN_NULL (0)
26#define FC_SYMNAME_MAX 256 /* max name server symbolic name size */ 26#define FC_SYMNAME_MAX 256 /* max name server symbolic name size */
27#define FC_ALPA_MAX 128
28 27
29#pragma pack(1) 28#pragma pack(1)
30 29
@@ -57,6 +56,161 @@ struct scsi_cdb_s {
57 56
58#define SCSI_MAX_ALLOC_LEN 0xFF /* maximum allocarion length */ 57#define SCSI_MAX_ALLOC_LEN 0xFF /* maximum allocarion length */
59 58
59#define SCSI_SENSE_CUR_ERR 0x70
60#define SCSI_SENSE_DEF_ERR 0x71
61
62/*
63 * SCSI additional sense codes
64 */
65#define SCSI_ASC_LUN_NOT_READY 0x04
66#define SCSI_ASC_LUN_NOT_SUPPORTED 0x25
67#define SCSI_ASC_TOCC 0x3F
68
69/*
70 * SCSI additional sense code qualifiers
71 */
72#define SCSI_ASCQ_MAN_INTR_REQ 0x03 /* manual intervention req */
73#define SCSI_ASCQ_RL_DATA_CHANGED 0x0E /* report luns data changed */
74
75/*
76 * Methods of reporting informational exceptions
77 */
78#define SCSI_MP_IEC_UNIT_ATTN 0x2 /* generate unit attention */
79
80struct scsi_report_luns_data_s {
81 u32 lun_list_length; /* length of LUN list length */
82 u32 reserved;
83 struct scsi_lun lun[1]; /* first LUN in lun list */
84};
85
86struct scsi_inquiry_vendor_s {
87 u8 vendor_id[8];
88};
89
90struct scsi_inquiry_prodid_s {
91 u8 product_id[16];
92};
93
94struct scsi_inquiry_prodrev_s {
95 u8 product_rev[4];
96};
97
98struct scsi_inquiry_data_s {
99#ifdef __BIG_ENDIAN
100 u8 peripheral_qual:3; /* peripheral qualifier */
101 u8 device_type:5; /* peripheral device type */
102 u8 rmb:1; /* removable medium bit */
103 u8 device_type_mod:7; /* device type modifier */
104 u8 version;
105 u8 aenc:1; /* async evt notification capability */
106 u8 trm_iop:1; /* terminate I/O process */
107 u8 norm_aca:1; /* normal ACA supported */
108 u8 hi_support:1; /* SCSI-3: supports REPORT LUNS */
109 u8 rsp_data_format:4;
110 u8 additional_len;
111 u8 sccs:1;
112 u8 reserved1:7;
113 u8 reserved2:1;
114 u8 enc_serv:1; /* enclosure service component */
115 u8 reserved3:1;
116 u8 multi_port:1; /* multi-port device */
117 u8 m_chngr:1; /* device in medium transport element */
118 u8 ack_req_q:1; /* SIP specific bit */
119 u8 addr32:1; /* SIP specific bit */
120 u8 addr16:1; /* SIP specific bit */
121 u8 rel_adr:1; /* relative address */
122 u8 w_bus32:1;
123 u8 w_bus16:1;
124 u8 synchronous:1;
125 u8 linked_commands:1;
126 u8 trans_dis:1;
127 u8 cmd_queue:1; /* command queueing supported */
128 u8 soft_reset:1; /* soft reset alternative (VS) */
129#else
130 u8 device_type:5; /* peripheral device type */
131 u8 peripheral_qual:3; /* peripheral qualifier */
132 u8 device_type_mod:7; /* device type modifier */
133 u8 rmb:1; /* removable medium bit */
134 u8 version;
135 u8 rsp_data_format:4;
136 u8 hi_support:1; /* SCSI-3: supports REPORT LUNS */
137 u8 norm_aca:1; /* normal ACA supported */
138 u8 terminate_iop:1;/* terminate I/O process */
139 u8 aenc:1; /* async evt notification capability */
140 u8 additional_len;
141 u8 reserved1:7;
142 u8 sccs:1;
143 u8 addr16:1; /* SIP specific bit */
144 u8 addr32:1; /* SIP specific bit */
145 u8 ack_req_q:1; /* SIP specific bit */
146 u8 m_chngr:1; /* device in medium transport element */
147 u8 multi_port:1; /* multi-port device */
148 u8 reserved3:1; /* TBD - Vendor Specific */
149 u8 enc_serv:1; /* enclosure service component */
150 u8 reserved2:1;
151 u8 soft_seset:1; /* soft reset alternative (VS) */
152 u8 cmd_queue:1; /* command queueing supported */
153 u8 trans_dis:1;
154 u8 linked_commands:1;
155 u8 synchronous:1;
156 u8 w_bus16:1;
157 u8 w_bus32:1;
158 u8 rel_adr:1; /* relative address */
159#endif
160 struct scsi_inquiry_vendor_s vendor_id;
161 struct scsi_inquiry_prodid_s product_id;
162 struct scsi_inquiry_prodrev_s product_rev;
163 u8 vendor_specific[20];
164 u8 reserved4[40];
165};
166
167/*
168 * SCSI sense data format
169 */
170struct scsi_sense_s {
171#ifdef __BIG_ENDIAN
172 u8 valid:1;
173 u8 rsp_code:7;
174#else
175 u8 rsp_code:7;
176 u8 valid:1;
177#endif
178 u8 seg_num;
179#ifdef __BIG_ENDIAN
180 u8 file_mark:1;
181 u8 eom:1; /* end of media */
182 u8 ili:1; /* incorrect length indicator */
183 u8 reserved:1;
184 u8 sense_key:4;
185#else
186 u8 sense_key:4;
187 u8 reserved:1;
188 u8 ili:1; /* incorrect length indicator */
189 u8 eom:1; /* end of media */
190 u8 file_mark:1;
191#endif
192 u8 information[4]; /* device-type or cmd specific info */
193 u8 add_sense_length; /* additional sense length */
194 u8 command_info[4];/* command specific information */
195 u8 asc; /* additional sense code */
196 u8 ascq; /* additional sense code qualifier */
197 u8 fru_code; /* field replaceable unit code */
198#ifdef __BIG_ENDIAN
199 u8 sksv:1; /* sense key specific valid */
200 u8 c_d:1; /* command/data bit */
201 u8 res1:2;
202 u8 bpv:1; /* bit pointer valid */
203 u8 bpointer:3; /* bit pointer */
204#else
205 u8 bpointer:3; /* bit pointer */
206 u8 bpv:1; /* bit pointer valid */
207 u8 res1:2;
208 u8 c_d:1; /* command/data bit */
209 u8 sksv:1; /* sense key specific valid */
210#endif
211 u8 fpointer[2]; /* field pointer */
212};
213
60/* 214/*
61 * Fibre Channel Header Structure (FCHS) definition 215 * Fibre Channel Header Structure (FCHS) definition
62 */ 216 */
@@ -1016,10 +1170,6 @@ struct fc_symname_s {
1016 u8 symname[FC_SYMNAME_MAX]; 1170 u8 symname[FC_SYMNAME_MAX];
1017}; 1171};
1018 1172
1019struct fc_alpabm_s {
1020 u8 alpa_bm[FC_ALPA_MAX / 8];
1021};
1022
1023/* 1173/*
1024 * protocol default timeout values 1174 * protocol default timeout values
1025 */ 1175 */
@@ -1284,7 +1434,6 @@ enum {
1284 GS_GSPN_ID = 0x0118, /* Get symbolic PN on ID */ 1434 GS_GSPN_ID = 0x0118, /* Get symbolic PN on ID */
1285 GS_RFT_ID = 0x0217, /* Register fc4type on ID */ 1435 GS_RFT_ID = 0x0217, /* Register fc4type on ID */
1286 GS_RSPN_ID = 0x0218, /* Register symbolic PN on ID */ 1436 GS_RSPN_ID = 0x0218, /* Register symbolic PN on ID */
1287 GS_RSNN_NN = 0x0239, /* Register symbolic NN on NN */
1288 GS_RPN_ID = 0x0212, /* Register port name */ 1437 GS_RPN_ID = 0x0212, /* Register port name */
1289 GS_RNN_ID = 0x0213, /* Register node name */ 1438 GS_RNN_ID = 0x0213, /* Register node name */
1290 GS_RCS_ID = 0x0214, /* Register class of service */ 1439 GS_RCS_ID = 0x0214, /* Register class of service */
@@ -1363,15 +1512,6 @@ struct fcgs_rspnid_req_s {
1363}; 1512};
1364 1513
1365/* 1514/*
1366 * RSNN_NN
1367 */
1368struct fcgs_rsnn_nn_req_s {
1369 wwn_t node_name; /* Node name */
1370 u8 snn_len; /* symbolic node name length */
1371 u8 snn[256]; /* symbolic node name */
1372};
1373
1374/*
1375 * RPN_ID 1515 * RPN_ID
1376 */ 1516 */
1377struct fcgs_rpnid_req_s { 1517struct fcgs_rpnid_req_s {
diff --git a/drivers/scsi/bfa/bfa_fcbuild.c b/drivers/scsi/bfa/bfa_fcbuild.c
index dce787f6cca..17b59b8b564 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.c
+++ b/drivers/scsi/bfa/bfa_fcbuild.c
@@ -228,10 +228,6 @@ fc_plogi_x_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
228 228
229 memcpy(plogi, &plogi_tmpl, sizeof(struct fc_logi_s)); 229 memcpy(plogi, &plogi_tmpl, sizeof(struct fc_logi_s));
230 230
231 /* For FC AL bb_cr is 0 and altbbcred is 1 */
232 if (!bb_cr)
233 plogi->csp.altbbcred = 1;
234
235 plogi->els_cmd.els_code = els_code; 231 plogi->els_cmd.els_code = els_code;
236 if (els_code == FC_ELS_PLOGI) 232 if (els_code == FC_ELS_PLOGI)
237 fc_els_req_build(fchs, d_id, s_id, ox_id); 233 fc_els_req_build(fchs, d_id, s_id, ox_id);
@@ -1256,27 +1252,6 @@ fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
1256} 1252}
1257 1253
1258u16 1254u16
1259fc_rsnn_nn_build(struct fchs_s *fchs, void *pyld, u32 s_id,
1260 wwn_t node_name, u8 *name)
1261{
1262 struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
1263 struct fcgs_rsnn_nn_req_s *rsnn_nn =
1264 (struct fcgs_rsnn_nn_req_s *) (cthdr + 1);
1265 u32 d_id = bfa_hton3b(FC_NAME_SERVER);
1266
1267 fc_gs_fchdr_build(fchs, d_id, s_id, 0);
1268 fc_gs_cthdr_build(cthdr, s_id, GS_RSNN_NN);
1269
1270 memset(rsnn_nn, 0, sizeof(struct fcgs_rsnn_nn_req_s));
1271
1272 rsnn_nn->node_name = node_name;
1273 rsnn_nn->snn_len = (u8) strlen((char *)name);
1274 strncpy((char *)rsnn_nn->snn, (char *)name, rsnn_nn->snn_len);
1275
1276 return sizeof(struct fcgs_rsnn_nn_req_s) + sizeof(struct ct_hdr_s);
1277}
1278
1279u16
1280fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type) 1255fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type)
1281{ 1256{
1282 1257
diff --git a/drivers/scsi/bfa/bfa_fcbuild.h b/drivers/scsi/bfa/bfa_fcbuild.h
index 03c753d1e54..42cd9d4da69 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.h
+++ b/drivers/scsi/bfa/bfa_fcbuild.h
@@ -166,8 +166,6 @@ enum fc_parse_status fc_rrq_rsp_parse(struct fchs_s *buf, int len);
166 166
167u16 fc_rspnid_build(struct fchs_s *fchs, void *pld, u32 s_id, 167u16 fc_rspnid_build(struct fchs_s *fchs, void *pld, u32 s_id,
168 u16 ox_id, u8 *name); 168 u16 ox_id, u8 *name);
169u16 fc_rsnn_nn_build(struct fchs_s *fchs, void *pld, u32 s_id,
170 wwn_t node_name, u8 *name);
171 169
172u16 fc_rftid_build(struct fchs_s *fchs, void *pld, u32 s_id, 170u16 fc_rftid_build(struct fchs_s *fchs, void *pld, u32 s_id,
173 u16 ox_id, enum bfa_lport_role role); 171 u16 ox_id, enum bfa_lport_role role);
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index 27b56096235..e07bd4745d8 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -24,6 +24,8 @@ BFA_TRC_FILE(HAL, FCPIM);
24 * BFA ITNIM Related definitions 24 * BFA ITNIM Related definitions
25 */ 25 */
26static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim); 26static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
27static bfa_boolean_t bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim);
28static bfa_boolean_t bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim);
27static void bfa_ioim_lm_init(struct bfa_s *bfa); 29static void bfa_ioim_lm_init(struct bfa_s *bfa);
28 30
29#define BFA_ITNIM_FROM_TAG(_fcpim, _tag) \ 31#define BFA_ITNIM_FROM_TAG(_fcpim, _tag) \
@@ -58,6 +60,14 @@ static void bfa_ioim_lm_init(struct bfa_s *bfa);
58 } \ 60 } \
59} while (0) 61} while (0)
60 62
63#define bfa_ioim_rp_wwn(__ioim) \
64 (((struct bfa_fcs_rport_s *) \
65 (__ioim)->itnim->rport->rport_drv)->pwwn)
66
67#define bfa_ioim_lp_wwn(__ioim) \
68 ((BFA_LPS_FROM_TAG(BFA_LPS_MOD((__ioim)->bfa), \
69 (__ioim)->itnim->rport->rport_info.lp_tag))->pwwn) \
70
61#define bfa_itnim_sler_cb(__itnim) do { \ 71#define bfa_itnim_sler_cb(__itnim) do { \
62 if ((__itnim)->bfa->fcs) \ 72 if ((__itnim)->bfa->fcs) \
63 bfa_cb_itnim_sler((__itnim)->ditn); \ 73 bfa_cb_itnim_sler((__itnim)->ditn); \
@@ -67,6 +77,13 @@ static void bfa_ioim_lm_init(struct bfa_s *bfa);
67 } \ 77 } \
68} while (0) 78} while (0)
69 79
80enum bfa_ioim_lm_status {
81 BFA_IOIM_LM_PRESENT = 1,
82 BFA_IOIM_LM_LUN_NOT_SUP = 2,
83 BFA_IOIM_LM_RPL_DATA_CHANGED = 3,
84 BFA_IOIM_LM_LUN_NOT_RDY = 4,
85};
86
70enum bfa_ioim_lm_ua_status { 87enum bfa_ioim_lm_ua_status {
71 BFA_IOIM_LM_UA_RESET = 0, 88 BFA_IOIM_LM_UA_RESET = 0,
72 BFA_IOIM_LM_UA_SET = 1, 89 BFA_IOIM_LM_UA_SET = 1,
@@ -128,6 +145,9 @@ enum bfa_ioim_event {
128 BFA_IOIM_SM_TMDONE = 16, /* IO cleanup from tskim */ 145 BFA_IOIM_SM_TMDONE = 16, /* IO cleanup from tskim */
129 BFA_IOIM_SM_HWFAIL = 17, /* IOC h/w failure event */ 146 BFA_IOIM_SM_HWFAIL = 17, /* IOC h/w failure event */
130 BFA_IOIM_SM_IOTOV = 18, /* ITN offline TOV */ 147 BFA_IOIM_SM_IOTOV = 18, /* ITN offline TOV */
148 BFA_IOIM_SM_LM_LUN_NOT_SUP = 19,/* lunmask lun not supported */
149 BFA_IOIM_SM_LM_RPL_DC = 20, /* lunmask report-lun data changed */
150 BFA_IOIM_SM_LM_LUN_NOT_RDY = 21,/* lunmask lun not ready */
131}; 151};
132 152
133 153
@@ -158,7 +178,6 @@ enum bfa_tskim_event {
158 BFA_TSKIM_SM_IOS_DONE = 7, /* IO and sub TM completions */ 178 BFA_TSKIM_SM_IOS_DONE = 7, /* IO and sub TM completions */
159 BFA_TSKIM_SM_CLEANUP = 8, /* TM cleanup on ITN offline */ 179 BFA_TSKIM_SM_CLEANUP = 8, /* TM cleanup on ITN offline */
160 BFA_TSKIM_SM_CLEANUP_DONE = 9, /* TM abort completion */ 180 BFA_TSKIM_SM_CLEANUP_DONE = 9, /* TM abort completion */
161 BFA_TSKIM_SM_UTAG = 10, /* TM completion unknown tag */
162}; 181};
163 182
164/* 183/*
@@ -226,6 +245,9 @@ static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
226static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete); 245static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
227static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete); 246static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
228static bfa_boolean_t bfa_ioim_is_abortable(struct bfa_ioim_s *ioim); 247static bfa_boolean_t bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
248static void __bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete);
249static void __bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete);
250static void __bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete);
229 251
230/* 252/*
231 * forward declaration of BFA IO state machine 253 * forward declaration of BFA IO state machine
@@ -423,6 +445,12 @@ bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
423 bfa_fcpim_add_iostats(lstats, rstats, output_reqs); 445 bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
424 bfa_fcpim_add_iostats(lstats, rstats, rd_throughput); 446 bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
425 bfa_fcpim_add_iostats(lstats, rstats, wr_throughput); 447 bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
448 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_across_sg);
449 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_sup);
450 bfa_fcpim_add_iostats(lstats, rstats, lm_rpl_data_changed);
451 bfa_fcpim_add_iostats(lstats, rstats, lm_wire_residue_changed);
452 bfa_fcpim_add_iostats(lstats, rstats, lm_small_buf_addresidue);
453 bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_rdy);
426} 454}
427 455
428bfa_status_t 456bfa_status_t
@@ -1467,13 +1495,7 @@ bfa_status_t
1467bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim, 1495bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
1468 struct bfa_itnim_ioprofile_s *ioprofile) 1496 struct bfa_itnim_ioprofile_s *ioprofile)
1469{ 1497{
1470 struct bfa_fcpim_s *fcpim; 1498 struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
1471
1472 if (!itnim)
1473 return BFA_STATUS_NO_FCPIM_NEXUS;
1474
1475 fcpim = BFA_FCPIM(itnim->bfa);
1476
1477 if (!fcpim->io_profile) 1499 if (!fcpim->io_profile)
1478 return BFA_STATUS_IOPROFILE_OFF; 1500 return BFA_STATUS_IOPROFILE_OFF;
1479 1501
@@ -1491,10 +1513,6 @@ void
1491bfa_itnim_clear_stats(struct bfa_itnim_s *itnim) 1513bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
1492{ 1514{
1493 int j; 1515 int j;
1494
1495 if (!itnim)
1496 return;
1497
1498 memset(&itnim->stats, 0, sizeof(itnim->stats)); 1516 memset(&itnim->stats, 0, sizeof(itnim->stats));
1499 memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile)); 1517 memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile));
1500 for (j = 0; j < BFA_IOBUCKET_MAX; j++) 1518 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
@@ -1562,6 +1580,27 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1562 __bfa_cb_ioim_abort, ioim); 1580 __bfa_cb_ioim_abort, ioim);
1563 break; 1581 break;
1564 1582
1583 case BFA_IOIM_SM_LM_LUN_NOT_SUP:
1584 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1585 bfa_ioim_move_to_comp_q(ioim);
1586 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1587 __bfa_cb_ioim_lm_lun_not_sup, ioim);
1588 break;
1589
1590 case BFA_IOIM_SM_LM_RPL_DC:
1591 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1592 bfa_ioim_move_to_comp_q(ioim);
1593 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1594 __bfa_cb_ioim_lm_rpl_dc, ioim);
1595 break;
1596
1597 case BFA_IOIM_SM_LM_LUN_NOT_RDY:
1598 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1599 bfa_ioim_move_to_comp_q(ioim);
1600 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1601 __bfa_cb_ioim_lm_lun_not_rdy, ioim);
1602 break;
1603
1565 default: 1604 default:
1566 bfa_sm_fault(ioim->bfa, event); 1605 bfa_sm_fault(ioim->bfa, event);
1567 } 1606 }
@@ -2121,6 +2160,243 @@ bfa_ioim_lm_init(struct bfa_s *bfa)
2121 } 2160 }
2122} 2161}
2123 2162
2163/*
2164 * Validate LUN for LUN masking
2165 */
2166static enum bfa_ioim_lm_status
2167bfa_ioim_lm_check(struct bfa_ioim_s *ioim, struct bfa_lps_s *lps,
2168 struct bfa_rport_s *rp, struct scsi_lun lun)
2169{
2170 u8 i;
2171 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2172 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2173 struct scsi_cdb_s *cdb = (struct scsi_cdb_s *)cmnd->cmnd;
2174
2175 if ((cdb->scsi_cdb[0] == REPORT_LUNS) &&
2176 (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
2177 ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
2178 return BFA_IOIM_LM_PRESENT;
2179 }
2180
2181 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2182
2183 if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2184 continue;
2185
2186 if ((scsilun_to_int((struct scsi_lun *)&lun_list[i].lun) ==
2187 scsilun_to_int((struct scsi_lun *)&lun))
2188 && (rp->rport_tag == lun_list[i].rp_tag)
2189 && ((u8)ioim->itnim->rport->rport_info.lp_tag ==
2190 lun_list[i].lp_tag)) {
2191 bfa_trc(ioim->bfa, lun_list[i].rp_tag);
2192 bfa_trc(ioim->bfa, lun_list[i].lp_tag);
2193 bfa_trc(ioim->bfa, scsilun_to_int(
2194 (struct scsi_lun *)&lun_list[i].lun));
2195
2196 if ((lun_list[i].ua == BFA_IOIM_LM_UA_SET) &&
2197 ((cdb->scsi_cdb[0] != INQUIRY) ||
2198 (cdb->scsi_cdb[0] != REPORT_LUNS))) {
2199 lun_list[i].ua = BFA_IOIM_LM_UA_RESET;
2200 return BFA_IOIM_LM_RPL_DATA_CHANGED;
2201 }
2202
2203 if (cdb->scsi_cdb[0] == REPORT_LUNS)
2204 ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
2205
2206 return BFA_IOIM_LM_PRESENT;
2207 }
2208 }
2209
2210 if ((cdb->scsi_cdb[0] == INQUIRY) &&
2211 (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
2212 ioim->proc_rsp_data = bfa_ioim_lm_proc_inq_data;
2213 return BFA_IOIM_LM_PRESENT;
2214 }
2215
2216 if (cdb->scsi_cdb[0] == TEST_UNIT_READY)
2217 return BFA_IOIM_LM_LUN_NOT_RDY;
2218
2219 return BFA_IOIM_LM_LUN_NOT_SUP;
2220}
2221
2222static bfa_boolean_t
2223bfa_ioim_lm_proc_rsp_data_dummy(struct bfa_ioim_s *ioim)
2224{
2225 return BFA_TRUE;
2226}
2227
2228static void
2229bfa_ioim_lm_fetch_lun(struct bfa_ioim_s *ioim, u8 *rl_data, int offset,
2230 int buf_lun_cnt)
2231{
2232 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2233 struct scsi_lun *lun_data = (struct scsi_lun *)(rl_data + offset);
2234 struct scsi_lun lun;
2235 int i, j;
2236
2237 bfa_trc(ioim->bfa, buf_lun_cnt);
2238 for (j = 0; j < buf_lun_cnt; j++) {
2239 lun = *((struct scsi_lun *)(lun_data + j));
2240 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2241 if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2242 continue;
2243 if ((lun_list[i].rp_wwn == bfa_ioim_rp_wwn(ioim)) &&
2244 (lun_list[i].lp_wwn == bfa_ioim_lp_wwn(ioim)) &&
2245 (scsilun_to_int((struct scsi_lun *)&lun_list[i].lun)
2246 == scsilun_to_int((struct scsi_lun *)&lun))) {
2247 lun_list[i].state = BFA_IOIM_LUN_MASK_FETCHED;
2248 break;
2249 }
2250 } /* next lun in mask DB */
2251 } /* next lun in buf */
2252}
2253
2254static int
2255bfa_ioim_lm_update_lun_sg(struct bfa_ioim_s *ioim, u32 *pgdlen,
2256 struct scsi_report_luns_data_s *rl)
2257{
2258 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2259 struct scatterlist *sg = scsi_sglist(cmnd);
2260 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
2261 struct scsi_lun *prev_rl_data = NULL, *base_rl_data;
2262 int i, j, sgeid, lun_fetched_cnt = 0, prev_sg_len = 0, base_count;
2263 int lun_across_sg_bytes, bytes_from_next_buf;
2264 u64 last_lun, temp_last_lun;
2265
2266 /* fetch luns from the first sg element */
2267 bfa_ioim_lm_fetch_lun(ioim, (u8 *)(rl->lun), 0,
2268 (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1);
2269
2270 /* fetch luns from multiple sg elements */
2271 scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), sgeid) {
2272 if (sgeid == 0) {
2273 prev_sg_len = sg_dma_len(sg);
2274 prev_rl_data = (struct scsi_lun *)
2275 phys_to_virt(sg_dma_address(sg));
2276 continue;
2277 }
2278
2279 /* if the buf is having more data */
2280 lun_across_sg_bytes = prev_sg_len % sizeof(struct scsi_lun);
2281 if (lun_across_sg_bytes) {
2282 bfa_trc(ioim->bfa, lun_across_sg_bytes);
2283 bfa_stats(ioim->itnim, lm_lun_across_sg);
2284 bytes_from_next_buf = sizeof(struct scsi_lun) -
2285 lun_across_sg_bytes;
2286
2287 /* from next buf take higher bytes */
2288 temp_last_lun = *((u64 *)
2289 phys_to_virt(sg_dma_address(sg)));
2290 last_lun |= temp_last_lun >>
2291 (lun_across_sg_bytes * BITS_PER_BYTE);
2292
2293 /* from prev buf take higher bytes */
2294 temp_last_lun = *((u64 *)(prev_rl_data +
2295 (prev_sg_len - lun_across_sg_bytes)));
2296 temp_last_lun >>= bytes_from_next_buf * BITS_PER_BYTE;
2297 last_lun = last_lun | (temp_last_lun <<
2298 (bytes_from_next_buf * BITS_PER_BYTE));
2299
2300 bfa_ioim_lm_fetch_lun(ioim, (u8 *)&last_lun, 0, 1);
2301 } else
2302 bytes_from_next_buf = 0;
2303
2304 *pgdlen += sg_dma_len(sg);
2305 prev_sg_len = sg_dma_len(sg);
2306 prev_rl_data = (struct scsi_lun *)
2307 phys_to_virt(sg_dma_address(sg));
2308 bfa_ioim_lm_fetch_lun(ioim, (u8 *)prev_rl_data,
2309 bytes_from_next_buf,
2310 sg_dma_len(sg) / sizeof(struct scsi_lun));
2311 }
2312
2313 /* update the report luns data - based on fetched luns */
2314 sg = scsi_sglist(cmnd);
2315 base_rl_data = (struct scsi_lun *)rl->lun;
2316 base_count = (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1;
2317 for (i = 0, j = 0; i < MAX_LUN_MASK_CFG; i++) {
2318 if (lun_list[i].state == BFA_IOIM_LUN_MASK_FETCHED) {
2319 base_rl_data[j] = lun_list[i].lun;
2320 lun_list[i].state = BFA_IOIM_LUN_MASK_ACTIVE;
2321 j++;
2322 lun_fetched_cnt++;
2323 }
2324
2325 if (j > base_count) {
2326 j = 0;
2327 sg = sg_next(sg);
2328 base_rl_data = (struct scsi_lun *)
2329 phys_to_virt(sg_dma_address(sg));
2330 base_count = sg_dma_len(sg) / sizeof(struct scsi_lun);
2331 }
2332 }
2333
2334 bfa_trc(ioim->bfa, lun_fetched_cnt);
2335 return lun_fetched_cnt;
2336}
2337
2338static bfa_boolean_t
2339bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim)
2340{
2341 struct scsi_inquiry_data_s *inq;
2342 struct scatterlist *sg = scsi_sglist((struct scsi_cmnd *)ioim->dio);
2343
2344 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2345 inq = (struct scsi_inquiry_data_s *)phys_to_virt(sg_dma_address(sg));
2346
2347 bfa_trc(ioim->bfa, inq->device_type);
2348 inq->peripheral_qual = SCSI_INQ_PQ_NOT_CON;
2349 return 0;
2350}
2351
2352static bfa_boolean_t
2353bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim)
2354{
2355 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
2356 struct scatterlist *sg = scsi_sglist(cmnd);
2357 struct bfi_ioim_rsp_s *m;
2358 struct scsi_report_luns_data_s *rl = NULL;
2359 int lun_count = 0, lun_fetched_cnt = 0;
2360 u32 residue, pgdlen = 0;
2361
2362 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2363 if (bfa_get_lun_mask_status(ioim->bfa) != BFA_LUNMASK_ENABLED)
2364 return BFA_TRUE;
2365
2366 m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
2367 if (m->scsi_status == SCSI_STATUS_CHECK_CONDITION)
2368 return BFA_TRUE;
2369
2370 pgdlen = sg_dma_len(sg);
2371 bfa_trc(ioim->bfa, pgdlen);
2372 rl = (struct scsi_report_luns_data_s *)phys_to_virt(sg_dma_address(sg));
2373 lun_count = cpu_to_be32(rl->lun_list_length) / sizeof(struct scsi_lun);
2374 lun_fetched_cnt = bfa_ioim_lm_update_lun_sg(ioim, &pgdlen, rl);
2375
2376 if (lun_count == lun_fetched_cnt)
2377 return BFA_TRUE;
2378
2379 bfa_trc(ioim->bfa, lun_count);
2380 bfa_trc(ioim->bfa, lun_fetched_cnt);
2381 bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
2382
2383 if (be32_to_cpu(rl->lun_list_length) <= pgdlen)
2384 rl->lun_list_length = be32_to_cpu(lun_fetched_cnt) *
2385 sizeof(struct scsi_lun);
2386 else
2387 bfa_stats(ioim->itnim, lm_small_buf_addresidue);
2388
2389 bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
2390 bfa_trc(ioim->bfa, be32_to_cpu(m->residue));
2391
2392 residue = be32_to_cpu(m->residue);
2393 residue += (lun_count - lun_fetched_cnt) * sizeof(struct scsi_lun);
2394 bfa_stats(ioim->itnim, lm_wire_residue_changed);
2395 m->residue = be32_to_cpu(residue);
2396 bfa_trc(ioim->bfa, ioim->nsges);
2397 return BFA_FALSE;
2398}
2399
2124static void 2400static void
2125__bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete) 2401__bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
2126{ 2402{
@@ -2178,6 +2454,83 @@ __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
2178 m->scsi_status, sns_len, snsinfo, residue); 2454 m->scsi_status, sns_len, snsinfo, residue);
2179} 2455}
2180 2456
2457static void
2458__bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete)
2459{
2460 struct bfa_ioim_s *ioim = cbarg;
2461 int sns_len = 0xD;
2462 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2463 struct scsi_sense_s *snsinfo;
2464
2465 if (!complete) {
2466 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2467 return;
2468 }
2469
2470 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
2471 ioim->fcpim->fcp, ioim->iotag);
2472 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2473 snsinfo->add_sense_length = 0xa;
2474 snsinfo->asc = SCSI_ASC_LUN_NOT_SUPPORTED;
2475 snsinfo->sense_key = ILLEGAL_REQUEST;
2476 bfa_trc(ioim->bfa, residue);
2477 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2478 SCSI_STATUS_CHECK_CONDITION, sns_len,
2479 (u8 *)snsinfo, residue);
2480}
2481
2482static void
2483__bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete)
2484{
2485 struct bfa_ioim_s *ioim = cbarg;
2486 int sns_len = 0xD;
2487 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2488 struct scsi_sense_s *snsinfo;
2489
2490 if (!complete) {
2491 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2492 return;
2493 }
2494
2495 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(ioim->fcpim->fcp,
2496 ioim->iotag);
2497 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2498 snsinfo->sense_key = SCSI_MP_IEC_UNIT_ATTN;
2499 snsinfo->asc = SCSI_ASC_TOCC;
2500 snsinfo->add_sense_length = 0x6;
2501 snsinfo->ascq = SCSI_ASCQ_RL_DATA_CHANGED;
2502 bfa_trc(ioim->bfa, residue);
2503 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2504 SCSI_STATUS_CHECK_CONDITION, sns_len,
2505 (u8 *)snsinfo, residue);
2506}
2507
2508static void
2509__bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete)
2510{
2511 struct bfa_ioim_s *ioim = cbarg;
2512 int sns_len = 0xD;
2513 u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
2514 struct scsi_sense_s *snsinfo;
2515
2516 if (!complete) {
2517 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2518 return;
2519 }
2520
2521 snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
2522 ioim->fcpim->fcp, ioim->iotag);
2523 snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
2524 snsinfo->add_sense_length = 0xa;
2525 snsinfo->sense_key = NOT_READY;
2526 snsinfo->asc = SCSI_ASC_LUN_NOT_READY;
2527 snsinfo->ascq = SCSI_ASCQ_MAN_INTR_REQ;
2528 bfa_trc(ioim->bfa, residue);
2529 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
2530 SCSI_STATUS_CHECK_CONDITION, sns_len,
2531 (u8 *)snsinfo, residue);
2532}
2533
2181void 2534void
2182bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn, wwn_t rp_wwn, 2535bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn, wwn_t rp_wwn,
2183 u16 rp_tag, u8 lp_tag) 2536 u16 rp_tag, u8 lp_tag)
@@ -2294,8 +2647,7 @@ bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2294 if (port) { 2647 if (port) {
2295 *pwwn = port->port_cfg.pwwn; 2648 *pwwn = port->port_cfg.pwwn;
2296 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn); 2649 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
2297 if (rp_fcs) 2650 rp = rp_fcs->bfa_rport;
2298 rp = rp_fcs->bfa_rport;
2299 } 2651 }
2300 2652
2301 lunm_list = bfa_get_lun_mask_list(bfa); 2653 lunm_list = bfa_get_lun_mask_list(bfa);
@@ -2363,8 +2715,7 @@ bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2363 if (port) { 2715 if (port) {
2364 *pwwn = port->port_cfg.pwwn; 2716 *pwwn = port->port_cfg.pwwn;
2365 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn); 2717 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
2366 if (rp_fcs) 2718 rp = rp_fcs->bfa_rport;
2367 rp = rp_fcs->bfa_rport;
2368 } 2719 }
2369 } 2720 }
2370 2721
@@ -2406,6 +2757,7 @@ __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
2406 return; 2757 return;
2407 } 2758 }
2408 2759
2760 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2409 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED, 2761 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
2410 0, 0, NULL, 0); 2762 0, 0, NULL, 0);
2411} 2763}
@@ -2421,6 +2773,7 @@ __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
2421 return; 2773 return;
2422 } 2774 }
2423 2775
2776 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2424 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV, 2777 bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
2425 0, 0, NULL, 0); 2778 0, 0, NULL, 0);
2426} 2779}
@@ -2435,6 +2788,7 @@ __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
2435 return; 2788 return;
2436 } 2789 }
2437 2790
2791 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2438 bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio); 2792 bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
2439} 2793}
2440 2794
@@ -2778,6 +3132,7 @@ bfa_ioim_attach(struct bfa_fcpim_s *fcpim)
2778 ioim->bfa = fcpim->bfa; 3132 ioim->bfa = fcpim->bfa;
2779 ioim->fcpim = fcpim; 3133 ioim->fcpim = fcpim;
2780 ioim->iosp = iosp; 3134 ioim->iosp = iosp;
3135 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2781 INIT_LIST_HEAD(&ioim->sgpg_q); 3136 INIT_LIST_HEAD(&ioim->sgpg_q);
2782 bfa_reqq_winit(&ioim->iosp->reqq_wait, 3137 bfa_reqq_winit(&ioim->iosp->reqq_wait,
2783 bfa_ioim_qresume, ioim); 3138 bfa_ioim_qresume, ioim);
@@ -2815,6 +3170,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2815 evt = BFA_IOIM_SM_DONE; 3170 evt = BFA_IOIM_SM_DONE;
2816 else 3171 else
2817 evt = BFA_IOIM_SM_COMP; 3172 evt = BFA_IOIM_SM_COMP;
3173 ioim->proc_rsp_data(ioim);
2818 break; 3174 break;
2819 3175
2820 case BFI_IOIM_STS_TIMEDOUT: 3176 case BFI_IOIM_STS_TIMEDOUT:
@@ -2850,6 +3206,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2850 if (rsp->abort_tag != ioim->abort_tag) { 3206 if (rsp->abort_tag != ioim->abort_tag) {
2851 bfa_trc(ioim->bfa, rsp->abort_tag); 3207 bfa_trc(ioim->bfa, rsp->abort_tag);
2852 bfa_trc(ioim->bfa, ioim->abort_tag); 3208 bfa_trc(ioim->bfa, ioim->abort_tag);
3209 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2853 return; 3210 return;
2854 } 3211 }
2855 3212
@@ -2868,6 +3225,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2868 WARN_ON(1); 3225 WARN_ON(1);
2869 } 3226 }
2870 3227
3228 ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
2871 bfa_sm_send_event(ioim, evt); 3229 bfa_sm_send_event(ioim, evt);
2872} 3230}
2873 3231
@@ -2886,7 +3244,15 @@ bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2886 3244
2887 bfa_ioim_cb_profile_comp(fcpim, ioim); 3245 bfa_ioim_cb_profile_comp(fcpim, ioim);
2888 3246
2889 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD); 3247 if (bfa_get_lun_mask_status(bfa) != BFA_LUNMASK_ENABLED) {
3248 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
3249 return;
3250 }
3251
3252 if (ioim->proc_rsp_data(ioim) == BFA_TRUE)
3253 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
3254 else
3255 bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP);
2890} 3256}
2891 3257
2892/* 3258/*
@@ -2998,6 +3364,35 @@ bfa_ioim_free(struct bfa_ioim_s *ioim)
2998void 3364void
2999bfa_ioim_start(struct bfa_ioim_s *ioim) 3365bfa_ioim_start(struct bfa_ioim_s *ioim)
3000{ 3366{
3367 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
3368 struct bfa_lps_s *lps;
3369 enum bfa_ioim_lm_status status;
3370 struct scsi_lun scsilun;
3371
3372 if (bfa_get_lun_mask_status(ioim->bfa) == BFA_LUNMASK_ENABLED) {
3373 lps = BFA_IOIM_TO_LPS(ioim);
3374 int_to_scsilun(cmnd->device->lun, &scsilun);
3375 status = bfa_ioim_lm_check(ioim, lps,
3376 ioim->itnim->rport, scsilun);
3377 if (status == BFA_IOIM_LM_LUN_NOT_RDY) {
3378 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_RDY);
3379 bfa_stats(ioim->itnim, lm_lun_not_rdy);
3380 return;
3381 }
3382
3383 if (status == BFA_IOIM_LM_LUN_NOT_SUP) {
3384 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_SUP);
3385 bfa_stats(ioim->itnim, lm_lun_not_sup);
3386 return;
3387 }
3388
3389 if (status == BFA_IOIM_LM_RPL_DATA_CHANGED) {
3390 bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_RPL_DC);
3391 bfa_stats(ioim->itnim, lm_rpl_data_changed);
3392 return;
3393 }
3394 }
3395
3001 bfa_ioim_cb_profile_start(ioim->fcpim, ioim); 3396 bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
3002 3397
3003 /* 3398 /*
@@ -3037,7 +3432,7 @@ bfa_ioim_abort(struct bfa_ioim_s *ioim)
3037static void 3432static void
3038bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3433bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3039{ 3434{
3040 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3435 bfa_trc(tskim->bfa, event);
3041 3436
3042 switch (event) { 3437 switch (event) {
3043 case BFA_TSKIM_SM_START: 3438 case BFA_TSKIM_SM_START:
@@ -3075,7 +3470,7 @@ bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3075static void 3470static void
3076bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3471bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3077{ 3472{
3078 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3473 bfa_trc(tskim->bfa, event);
3079 3474
3080 switch (event) { 3475 switch (event) {
3081 case BFA_TSKIM_SM_DONE: 3476 case BFA_TSKIM_SM_DONE:
@@ -3111,7 +3506,7 @@ bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3111static void 3506static void
3112bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3507bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3113{ 3508{
3114 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3509 bfa_trc(tskim->bfa, event);
3115 3510
3116 switch (event) { 3511 switch (event) {
3117 case BFA_TSKIM_SM_DONE: 3512 case BFA_TSKIM_SM_DONE:
@@ -3120,7 +3515,6 @@ bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3120 */ 3515 */
3121 break; 3516 break;
3122 3517
3123 case BFA_TSKIM_SM_UTAG:
3124 case BFA_TSKIM_SM_CLEANUP_DONE: 3518 case BFA_TSKIM_SM_CLEANUP_DONE:
3125 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup); 3519 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3126 bfa_tskim_cleanup_ios(tskim); 3520 bfa_tskim_cleanup_ios(tskim);
@@ -3140,7 +3534,7 @@ bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3140static void 3534static void
3141bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3535bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3142{ 3536{
3143 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3537 bfa_trc(tskim->bfa, event);
3144 3538
3145 switch (event) { 3539 switch (event) {
3146 case BFA_TSKIM_SM_IOS_DONE: 3540 case BFA_TSKIM_SM_IOS_DONE:
@@ -3172,7 +3566,7 @@ bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3172static void 3566static void
3173bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3567bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3174{ 3568{
3175 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3569 bfa_trc(tskim->bfa, event);
3176 3570
3177 switch (event) { 3571 switch (event) {
3178 case BFA_TSKIM_SM_QRESUME: 3572 case BFA_TSKIM_SM_QRESUME:
@@ -3209,7 +3603,7 @@ static void
3209bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim, 3603bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
3210 enum bfa_tskim_event event) 3604 enum bfa_tskim_event event)
3211{ 3605{
3212 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3606 bfa_trc(tskim->bfa, event);
3213 3607
3214 switch (event) { 3608 switch (event) {
3215 case BFA_TSKIM_SM_DONE: 3609 case BFA_TSKIM_SM_DONE:
@@ -3240,7 +3634,7 @@ bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
3240static void 3634static void
3241bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 3635bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3242{ 3636{
3243 bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event); 3637 bfa_trc(tskim->bfa, event);
3244 3638
3245 switch (event) { 3639 switch (event) {
3246 case BFA_TSKIM_SM_HCB: 3640 case BFA_TSKIM_SM_HCB:
@@ -3562,8 +3956,6 @@ bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3562 if (rsp->tsk_status == BFI_TSKIM_STS_ABORTED) { 3956 if (rsp->tsk_status == BFI_TSKIM_STS_ABORTED) {
3563 bfa_stats(tskim->itnim, tm_cleanup_comps); 3957 bfa_stats(tskim->itnim, tm_cleanup_comps);
3564 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP_DONE); 3958 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP_DONE);
3565 } else if (rsp->tsk_status == BFI_TSKIM_STS_UTAG) {
3566 bfa_sm_send_event(tskim, BFA_TSKIM_SM_UTAG);
3567 } else { 3959 } else {
3568 bfa_stats(tskim->itnim, tm_fw_rsps); 3960 bfa_stats(tskim->itnim, tm_fw_rsps);
3569 bfa_sm_send_event(tskim, BFA_TSKIM_SM_DONE); 3961 bfa_sm_send_event(tskim, BFA_TSKIM_SM_DONE);
@@ -3703,7 +4095,6 @@ bfa_fcp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3703 struct bfa_mem_dma_s *seg_ptr; 4095 struct bfa_mem_dma_s *seg_ptr;
3704 u16 idx, nsegs, num_io_req; 4096 u16 idx, nsegs, num_io_req;
3705 4097
3706 fcp->max_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
3707 fcp->num_ioim_reqs = cfg->fwcfg.num_ioim_reqs; 4098 fcp->num_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
3708 fcp->num_fwtio_reqs = cfg->fwcfg.num_fwtio_reqs; 4099 fcp->num_fwtio_reqs = cfg->fwcfg.num_fwtio_reqs;
3709 fcp->num_itns = cfg->fwcfg.num_rports; 4100 fcp->num_itns = cfg->fwcfg.num_rports;
@@ -3726,7 +4117,6 @@ bfa_fcp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3726 bfa_iocfc_set_snsbase(bfa, idx, fcp->snsbase[idx].pa); 4117 bfa_iocfc_set_snsbase(bfa, idx, fcp->snsbase[idx].pa);
3727 } 4118 }
3728 4119
3729 fcp->throttle_update_required = 1;
3730 bfa_fcpim_attach(fcp, bfad, cfg, pcidev); 4120 bfa_fcpim_attach(fcp, bfad, cfg, pcidev);
3731 4121
3732 bfa_iotag_attach(fcp); 4122 bfa_iotag_attach(fcp);
@@ -3765,33 +4155,23 @@ bfa_fcp_iocdisable(struct bfa_s *bfa)
3765{ 4155{
3766 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa); 4156 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3767 4157
4158 /* Enqueue unused ioim resources to free_q */
4159 list_splice_tail_init(&fcp->iotag_unused_q, &fcp->iotag_ioim_free_q);
4160
3768 bfa_fcpim_iocdisable(fcp); 4161 bfa_fcpim_iocdisable(fcp);
3769} 4162}
3770 4163
3771void 4164void
3772bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw, u16 max_ioim_fw) 4165bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw)
3773{ 4166{
3774 struct bfa_fcp_mod_s *mod = BFA_FCP_MOD(bfa); 4167 struct bfa_fcp_mod_s *mod = BFA_FCP_MOD(bfa);
3775 struct list_head *qe; 4168 struct list_head *qe;
3776 int i; 4169 int i;
3777 4170
3778 /* Update io throttle value only once during driver load time */
3779 if (!mod->throttle_update_required)
3780 return;
3781
3782 for (i = 0; i < (mod->num_ioim_reqs - num_ioim_fw); i++) { 4171 for (i = 0; i < (mod->num_ioim_reqs - num_ioim_fw); i++) {
3783 bfa_q_deq_tail(&mod->iotag_ioim_free_q, &qe); 4172 bfa_q_deq_tail(&mod->iotag_ioim_free_q, &qe);
3784 list_add_tail(qe, &mod->iotag_unused_q); 4173 list_add_tail(qe, &mod->iotag_unused_q);
3785 } 4174 }
3786
3787 if (mod->num_ioim_reqs != num_ioim_fw) {
3788 bfa_trc(bfa, mod->num_ioim_reqs);
3789 bfa_trc(bfa, num_ioim_fw);
3790 }
3791
3792 mod->max_ioim_reqs = max_ioim_fw;
3793 mod->num_ioim_reqs = num_ioim_fw;
3794 mod->throttle_update_required = 0;
3795} 4175}
3796 4176
3797void 4177void
@@ -3849,88 +4229,3 @@ bfa_iotag_attach(struct bfa_fcp_mod_s *fcp)
3849 4229
3850 bfa_mem_kva_curp(fcp) = (u8 *) iotag; 4230 bfa_mem_kva_curp(fcp) = (u8 *) iotag;
3851} 4231}
3852
3853
3854/**
3855 * To send config req, first try to use throttle value from flash
3856 * If 0, then use driver parameter
3857 * We need to use min(flash_val, drv_val) because
3858 * memory allocation was done based on this cfg'd value
3859 */
3860u16
3861bfa_fcpim_get_throttle_cfg(struct bfa_s *bfa, u16 drv_cfg_param)
3862{
3863 u16 tmp;
3864 struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3865
3866 /*
3867 * If throttle value from flash is already in effect after driver is
3868 * loaded then until next load, always return current value instead
3869 * of actual flash value
3870 */
3871 if (!fcp->throttle_update_required)
3872 return (u16)fcp->num_ioim_reqs;
3873
3874 tmp = bfa_dconf_read_data_valid(bfa) ? bfa_fcpim_read_throttle(bfa) : 0;
3875 if (!tmp || (tmp > drv_cfg_param))
3876 tmp = drv_cfg_param;
3877
3878 return tmp;
3879}
3880
3881bfa_status_t
3882bfa_fcpim_write_throttle(struct bfa_s *bfa, u16 value)
3883{
3884 if (!bfa_dconf_get_min_cfg(bfa)) {
3885 BFA_DCONF_MOD(bfa)->dconf->throttle_cfg.value = value;
3886 BFA_DCONF_MOD(bfa)->dconf->throttle_cfg.is_valid = 1;
3887 return BFA_STATUS_OK;
3888 }
3889
3890 return BFA_STATUS_FAILED;
3891}
3892
3893u16
3894bfa_fcpim_read_throttle(struct bfa_s *bfa)
3895{
3896 struct bfa_throttle_cfg_s *throttle_cfg =
3897 &(BFA_DCONF_MOD(bfa)->dconf->throttle_cfg);
3898
3899 return ((!bfa_dconf_get_min_cfg(bfa)) ?
3900 ((throttle_cfg->is_valid == 1) ? (throttle_cfg->value) : 0) : 0);
3901}
3902
3903bfa_status_t
3904bfa_fcpim_throttle_set(struct bfa_s *bfa, u16 value)
3905{
3906 /* in min cfg no commands should run. */
3907 if ((bfa_dconf_get_min_cfg(bfa) == BFA_TRUE) ||
3908 (!bfa_dconf_read_data_valid(bfa)))
3909 return BFA_STATUS_FAILED;
3910
3911 bfa_fcpim_write_throttle(bfa, value);
3912
3913 return bfa_dconf_update(bfa);
3914}
3915
3916bfa_status_t
3917bfa_fcpim_throttle_get(struct bfa_s *bfa, void *buf)
3918{
3919 struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3920 struct bfa_defs_fcpim_throttle_s throttle;
3921
3922 if ((bfa_dconf_get_min_cfg(bfa) == BFA_TRUE) ||
3923 (!bfa_dconf_read_data_valid(bfa)))
3924 return BFA_STATUS_FAILED;
3925
3926 memset(&throttle, 0, sizeof(struct bfa_defs_fcpim_throttle_s));
3927
3928 throttle.cur_value = (u16)(fcpim->fcp->num_ioim_reqs);
3929 throttle.cfg_value = bfa_fcpim_read_throttle(bfa);
3930 if (!throttle.cfg_value)
3931 throttle.cfg_value = throttle.cur_value;
3932 throttle.max_value = (u16)(fcpim->fcp->max_ioim_reqs);
3933 memcpy(buf, &throttle, sizeof(struct bfa_defs_fcpim_throttle_s));
3934
3935 return BFA_STATUS_OK;
3936}
diff --git a/drivers/scsi/bfa/bfa_fcpim.h b/drivers/scsi/bfa/bfa_fcpim.h
index e693af6e593..1080bcb81cb 100644
--- a/drivers/scsi/bfa/bfa_fcpim.h
+++ b/drivers/scsi/bfa/bfa_fcpim.h
@@ -42,7 +42,7 @@ void bfa_itn_create(struct bfa_s *bfa, struct bfa_rport_s *rport,
42 void (*isr)(struct bfa_s *bfa, struct bfi_msg_s *m)); 42 void (*isr)(struct bfa_s *bfa, struct bfi_msg_s *m));
43void bfa_itn_isr(struct bfa_s *bfa, struct bfi_msg_s *m); 43void bfa_itn_isr(struct bfa_s *bfa, struct bfi_msg_s *m);
44void bfa_iotag_attach(struct bfa_fcp_mod_s *fcp); 44void bfa_iotag_attach(struct bfa_fcp_mod_s *fcp);
45void bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw, u16 max_ioim_fw); 45void bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw);
46 46
47#define BFA_FCP_MOD(_hal) (&(_hal)->modules.fcp_mod) 47#define BFA_FCP_MOD(_hal) (&(_hal)->modules.fcp_mod)
48#define BFA_MEM_FCP_KVA(__bfa) (&(BFA_FCP_MOD(__bfa)->kva_seg)) 48#define BFA_MEM_FCP_KVA(__bfa) (&(BFA_FCP_MOD(__bfa)->kva_seg))
@@ -51,9 +51,7 @@ void bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw, u16 max_ioim_fw);
51#define BFA_ITN_FROM_TAG(_fcp, _tag) \ 51#define BFA_ITN_FROM_TAG(_fcp, _tag) \
52 ((_fcp)->itn_arr + ((_tag) & ((_fcp)->num_itns - 1))) 52 ((_fcp)->itn_arr + ((_tag) & ((_fcp)->num_itns - 1)))
53#define BFA_SNSINFO_FROM_TAG(_fcp, _tag) \ 53#define BFA_SNSINFO_FROM_TAG(_fcp, _tag) \
54 bfa_mem_get_dmabuf_kva(_fcp, (_tag & BFA_IOIM_IOTAG_MASK), \ 54 bfa_mem_get_dmabuf_kva(_fcp, _tag, BFI_IOIM_SNSLEN)
55 BFI_IOIM_SNSLEN)
56
57 55
58#define BFA_ITNIM_MIN 32 56#define BFA_ITNIM_MIN 32
59#define BFA_ITNIM_MAX 1024 57#define BFA_ITNIM_MAX 1024
@@ -112,6 +110,7 @@ struct bfad_ioim_s;
112struct bfad_tskim_s; 110struct bfad_tskim_s;
113 111
114typedef void (*bfa_fcpim_profile_t) (struct bfa_ioim_s *ioim); 112typedef void (*bfa_fcpim_profile_t) (struct bfa_ioim_s *ioim);
113typedef bfa_boolean_t (*bfa_ioim_lm_proc_rsp_data_t) (struct bfa_ioim_s *ioim);
115 114
116struct bfa_fcpim_s { 115struct bfa_fcpim_s {
117 struct bfa_s *bfa; 116 struct bfa_s *bfa;
@@ -125,6 +124,7 @@ struct bfa_fcpim_s {
125 u32 path_tov; 124 u32 path_tov;
126 u16 q_depth; 125 u16 q_depth;
127 u8 reqq; /* Request queue to be used */ 126 u8 reqq; /* Request queue to be used */
127 u8 lun_masking_pending;
128 struct list_head itnim_q; /* queue of active itnim */ 128 struct list_head itnim_q; /* queue of active itnim */
129 struct list_head ioim_resfree_q; /* IOs waiting for f/w */ 129 struct list_head ioim_resfree_q; /* IOs waiting for f/w */
130 struct list_head ioim_comp_q; /* IO global comp Q */ 130 struct list_head ioim_comp_q; /* IO global comp Q */
@@ -150,7 +150,6 @@ struct bfa_fcp_mod_s {
150 struct list_head iotag_unused_q; /* unused IO resources*/ 150 struct list_head iotag_unused_q; /* unused IO resources*/
151 struct bfa_iotag_s *iotag_arr; 151 struct bfa_iotag_s *iotag_arr;
152 struct bfa_itn_s *itn_arr; 152 struct bfa_itn_s *itn_arr;
153 int max_ioim_reqs;
154 int num_ioim_reqs; 153 int num_ioim_reqs;
155 int num_fwtio_reqs; 154 int num_fwtio_reqs;
156 int num_itns; 155 int num_itns;
@@ -158,7 +157,6 @@ struct bfa_fcp_mod_s {
158 struct bfa_fcpim_s fcpim; 157 struct bfa_fcpim_s fcpim;
159 struct bfa_mem_dma_s dma_seg[BFA_FCP_DMA_SEGS]; 158 struct bfa_mem_dma_s dma_seg[BFA_FCP_DMA_SEGS];
160 struct bfa_mem_kva_s kva_seg; 159 struct bfa_mem_kva_s kva_seg;
161 int throttle_update_required;
162}; 160};
163 161
164/* 162/*
@@ -183,6 +181,7 @@ struct bfa_ioim_s {
183 u8 reqq; /* Request queue for I/O */ 181 u8 reqq; /* Request queue for I/O */
184 u8 mode; /* IO is passthrough or not */ 182 u8 mode; /* IO is passthrough or not */
185 u64 start_time; /* IO's Profile start val */ 183 u64 start_time; /* IO's Profile start val */
184 bfa_ioim_lm_proc_rsp_data_t proc_rsp_data; /* RSP data adjust */
186}; 185};
187 186
188struct bfa_ioim_sp_s { 187struct bfa_ioim_sp_s {
@@ -262,6 +261,10 @@ struct bfa_itnim_s {
262 (__ioim)->iotag |= k << BFA_IOIM_RETRY_TAG_OFFSET; \ 261 (__ioim)->iotag |= k << BFA_IOIM_RETRY_TAG_OFFSET; \
263} while (0) 262} while (0)
264 263
264#define BFA_IOIM_TO_LPS(__ioim) \
265 BFA_LPS_FROM_TAG(BFA_LPS_MOD(__ioim->bfa), \
266 __ioim->itnim->rport->rport_info.lp_tag)
267
265static inline bfa_boolean_t 268static inline bfa_boolean_t
266bfa_ioim_maxretry_reached(struct bfa_ioim_s *ioim) 269bfa_ioim_maxretry_reached(struct bfa_ioim_s *ioim)
267{ 270{
@@ -420,10 +423,5 @@ bfa_status_t bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id,
420bfa_status_t bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id, 423bfa_status_t bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id,
421 wwn_t *pwwn, wwn_t rpwwn, struct scsi_lun lun); 424 wwn_t *pwwn, wwn_t rpwwn, struct scsi_lun lun);
422bfa_status_t bfa_fcpim_lunmask_clear(struct bfa_s *bfa); 425bfa_status_t bfa_fcpim_lunmask_clear(struct bfa_s *bfa);
423u16 bfa_fcpim_read_throttle(struct bfa_s *bfa);
424bfa_status_t bfa_fcpim_write_throttle(struct bfa_s *bfa, u16 value);
425bfa_status_t bfa_fcpim_throttle_set(struct bfa_s *bfa, u16 value);
426bfa_status_t bfa_fcpim_throttle_get(struct bfa_s *bfa, void *buf);
427u16 bfa_fcpim_get_throttle_cfg(struct bfa_s *bfa, u16 drv_cfg_param);
428 426
429#endif /* __BFA_FCPIM_H__ */ 427#endif /* __BFA_FCPIM_H__ */
diff --git a/drivers/scsi/bfa/bfa_fcs.c b/drivers/scsi/bfa/bfa_fcs.c
index d428808fb37..eaac57e1dde 100644
--- a/drivers/scsi/bfa/bfa_fcs.c
+++ b/drivers/scsi/bfa/bfa_fcs.c
@@ -76,7 +76,6 @@ bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
76 fcs->bfa = bfa; 76 fcs->bfa = bfa;
77 fcs->bfad = bfad; 77 fcs->bfad = bfad;
78 fcs->min_cfg = min_cfg; 78 fcs->min_cfg = min_cfg;
79 fcs->num_rport_logins = 0;
80 79
81 bfa->fcs = BFA_TRUE; 80 bfa->fcs = BFA_TRUE;
82 fcbuild_init(); 81 fcbuild_init();
@@ -120,18 +119,6 @@ bfa_fcs_update_cfg(struct bfa_fcs_s *fcs)
120} 119}
121 120
122/* 121/*
123 * Stop FCS operations.
124 */
125void
126bfa_fcs_stop(struct bfa_fcs_s *fcs)
127{
128 bfa_wc_init(&fcs->wc, bfa_fcs_exit_comp, fcs);
129 bfa_wc_up(&fcs->wc);
130 bfa_fcs_fabric_modstop(fcs);
131 bfa_wc_wait(&fcs->wc);
132}
133
134/*
135 * fcs pbc vport initialization 122 * fcs pbc vport initialization
136 */ 123 */
137void 124void
@@ -166,7 +153,6 @@ bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
166 fcs->driver_info = *driver_info; 153 fcs->driver_info = *driver_info;
167 154
168 bfa_fcs_fabric_psymb_init(&fcs->fabric); 155 bfa_fcs_fabric_psymb_init(&fcs->fabric);
169 bfa_fcs_fabric_nsymb_init(&fcs->fabric);
170} 156}
171 157
172/* 158/*
@@ -227,8 +213,6 @@ static void bfa_fcs_fabric_notify_offline(struct bfa_fcs_fabric_s *fabric);
227static void bfa_fcs_fabric_delay(void *cbarg); 213static void bfa_fcs_fabric_delay(void *cbarg);
228static void bfa_fcs_fabric_delete(struct bfa_fcs_fabric_s *fabric); 214static void bfa_fcs_fabric_delete(struct bfa_fcs_fabric_s *fabric);
229static void bfa_fcs_fabric_delete_comp(void *cbarg); 215static void bfa_fcs_fabric_delete_comp(void *cbarg);
230static void bfa_fcs_fabric_stop(struct bfa_fcs_fabric_s *fabric);
231static void bfa_fcs_fabric_stop_comp(void *cbarg);
232static void bfa_fcs_fabric_process_uf(struct bfa_fcs_fabric_s *fabric, 216static void bfa_fcs_fabric_process_uf(struct bfa_fcs_fabric_s *fabric,
233 struct fchs_s *fchs, u16 len); 217 struct fchs_s *fchs, u16 len);
234static void bfa_fcs_fabric_process_flogi(struct bfa_fcs_fabric_s *fabric, 218static void bfa_fcs_fabric_process_flogi(struct bfa_fcs_fabric_s *fabric,
@@ -266,10 +250,6 @@ static void bfa_fcs_fabric_sm_isolated(struct bfa_fcs_fabric_s *fabric,
266 enum bfa_fcs_fabric_event event); 250 enum bfa_fcs_fabric_event event);
267static void bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric, 251static void bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric,
268 enum bfa_fcs_fabric_event event); 252 enum bfa_fcs_fabric_event event);
269static void bfa_fcs_fabric_sm_stopping(struct bfa_fcs_fabric_s *fabric,
270 enum bfa_fcs_fabric_event event);
271static void bfa_fcs_fabric_sm_cleanup(struct bfa_fcs_fabric_s *fabric,
272 enum bfa_fcs_fabric_event event);
273/* 253/*
274 * Beginning state before fabric creation. 254 * Beginning state before fabric creation.
275 */ 255 */
@@ -303,30 +283,16 @@ static void
303bfa_fcs_fabric_sm_created(struct bfa_fcs_fabric_s *fabric, 283bfa_fcs_fabric_sm_created(struct bfa_fcs_fabric_s *fabric,
304 enum bfa_fcs_fabric_event event) 284 enum bfa_fcs_fabric_event event)
305{ 285{
306 struct bfa_s *bfa = fabric->fcs->bfa;
307
308 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn); 286 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
309 bfa_trc(fabric->fcs, event); 287 bfa_trc(fabric->fcs, event);
310 288
311 switch (event) { 289 switch (event) {
312 case BFA_FCS_FABRIC_SM_START: 290 case BFA_FCS_FABRIC_SM_START:
313 if (!bfa_fcport_is_linkup(fabric->fcs->bfa)) { 291 if (bfa_fcport_is_linkup(fabric->fcs->bfa)) {
314 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
315 break;
316 }
317 if (bfa_fcport_get_topology(bfa) ==
318 BFA_PORT_TOPOLOGY_LOOP) {
319 fabric->fab_type = BFA_FCS_FABRIC_LOOP;
320 fabric->bport.pid = bfa_fcport_get_myalpa(bfa);
321 fabric->bport.pid = bfa_hton3b(fabric->bport.pid);
322 bfa_sm_set_state(fabric,
323 bfa_fcs_fabric_sm_online);
324 bfa_fcs_fabric_set_opertype(fabric);
325 bfa_fcs_lport_online(&fabric->bport);
326 } else {
327 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi); 292 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi);
328 bfa_fcs_fabric_login(fabric); 293 bfa_fcs_fabric_login(fabric);
329 } 294 } else
295 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
330 break; 296 break;
331 297
332 case BFA_FCS_FABRIC_SM_LINK_UP: 298 case BFA_FCS_FABRIC_SM_LINK_UP:
@@ -351,28 +317,16 @@ static void
351bfa_fcs_fabric_sm_linkdown(struct bfa_fcs_fabric_s *fabric, 317bfa_fcs_fabric_sm_linkdown(struct bfa_fcs_fabric_s *fabric,
352 enum bfa_fcs_fabric_event event) 318 enum bfa_fcs_fabric_event event)
353{ 319{
354 struct bfa_s *bfa = fabric->fcs->bfa;
355
356 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn); 320 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
357 bfa_trc(fabric->fcs, event); 321 bfa_trc(fabric->fcs, event);
358 322
359 switch (event) { 323 switch (event) {
360 case BFA_FCS_FABRIC_SM_LINK_UP: 324 case BFA_FCS_FABRIC_SM_LINK_UP:
361 if (bfa_fcport_get_topology(bfa) != BFA_PORT_TOPOLOGY_LOOP) { 325 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi);
362 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi); 326 bfa_fcs_fabric_login(fabric);
363 bfa_fcs_fabric_login(fabric);
364 break;
365 }
366 fabric->fab_type = BFA_FCS_FABRIC_LOOP;
367 fabric->bport.pid = bfa_fcport_get_myalpa(bfa);
368 fabric->bport.pid = bfa_hton3b(fabric->bport.pid);
369 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_online);
370 bfa_fcs_fabric_set_opertype(fabric);
371 bfa_fcs_lport_online(&fabric->bport);
372 break; 327 break;
373 328
374 case BFA_FCS_FABRIC_SM_RETRY_OP: 329 case BFA_FCS_FABRIC_SM_RETRY_OP:
375 case BFA_FCS_FABRIC_SM_LOOPBACK:
376 break; 330 break;
377 331
378 case BFA_FCS_FABRIC_SM_DELETE: 332 case BFA_FCS_FABRIC_SM_DELETE:
@@ -380,11 +334,6 @@ bfa_fcs_fabric_sm_linkdown(struct bfa_fcs_fabric_s *fabric,
380 bfa_fcs_fabric_delete(fabric); 334 bfa_fcs_fabric_delete(fabric);
381 break; 335 break;
382 336
383 case BFA_FCS_FABRIC_SM_STOP:
384 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
385 bfa_fcs_fabric_stop(fabric);
386 break;
387
388 default: 337 default:
389 bfa_sm_fault(fabric->fcs, event); 338 bfa_sm_fault(fabric->fcs, event);
390 } 339 }
@@ -621,20 +570,14 @@ void
621bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric, 570bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
622 enum bfa_fcs_fabric_event event) 571 enum bfa_fcs_fabric_event event)
623{ 572{
624 struct bfa_s *bfa = fabric->fcs->bfa;
625
626 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn); 573 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
627 bfa_trc(fabric->fcs, event); 574 bfa_trc(fabric->fcs, event);
628 575
629 switch (event) { 576 switch (event) {
630 case BFA_FCS_FABRIC_SM_LINK_DOWN: 577 case BFA_FCS_FABRIC_SM_LINK_DOWN:
631 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown); 578 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
632 if (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) { 579 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
633 bfa_fcs_lport_offline(&fabric->bport); 580 bfa_fcs_fabric_notify_offline(fabric);
634 } else {
635 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
636 bfa_fcs_fabric_notify_offline(fabric);
637 }
638 break; 581 break;
639 582
640 case BFA_FCS_FABRIC_SM_DELETE: 583 case BFA_FCS_FABRIC_SM_DELETE:
@@ -642,11 +585,6 @@ bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
642 bfa_fcs_fabric_delete(fabric); 585 bfa_fcs_fabric_delete(fabric);
643 break; 586 break;
644 587
645 case BFA_FCS_FABRIC_SM_STOP:
646 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_stopping);
647 bfa_fcs_fabric_stop(fabric);
648 break;
649
650 case BFA_FCS_FABRIC_SM_AUTH_FAILED: 588 case BFA_FCS_FABRIC_SM_AUTH_FAILED:
651 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_auth_failed); 589 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_auth_failed);
652 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE); 590 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
@@ -744,71 +682,7 @@ bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric,
744 } 682 }
745} 683}
746 684
747/*
748 * Fabric is being stopped, awaiting vport stop completions.
749 */
750static void
751bfa_fcs_fabric_sm_stopping(struct bfa_fcs_fabric_s *fabric,
752 enum bfa_fcs_fabric_event event)
753{
754 struct bfa_s *bfa = fabric->fcs->bfa;
755
756 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
757 bfa_trc(fabric->fcs, event);
758
759 switch (event) {
760 case BFA_FCS_FABRIC_SM_STOPCOMP:
761 if (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) {
762 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_created);
763 } else {
764 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
765 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_LOGOUT);
766 }
767 break;
768
769 case BFA_FCS_FABRIC_SM_LINK_UP:
770 break;
771
772 case BFA_FCS_FABRIC_SM_LINK_DOWN:
773 if (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)
774 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_created);
775 else
776 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
777 break;
778
779 default:
780 bfa_sm_fault(fabric->fcs, event);
781 }
782}
783
784/*
785 * Fabric is being stopped, cleanup without FLOGO
786 */
787static void
788bfa_fcs_fabric_sm_cleanup(struct bfa_fcs_fabric_s *fabric,
789 enum bfa_fcs_fabric_event event)
790{
791 bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
792 bfa_trc(fabric->fcs, event);
793
794 switch (event) {
795 case BFA_FCS_FABRIC_SM_STOPCOMP:
796 case BFA_FCS_FABRIC_SM_LOGOCOMP:
797 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_created);
798 bfa_wc_down(&(fabric->fcs)->wc);
799 break;
800
801 case BFA_FCS_FABRIC_SM_LINK_DOWN:
802 /*
803 * Ignore - can get this event if we get notified about IOC down
804 * before the fabric completion callbk is done.
805 */
806 break;
807 685
808 default:
809 bfa_sm_fault(fabric->fcs, event);
810 }
811}
812 686
813/* 687/*
814 * fcs_fabric_private fabric private functions 688 * fcs_fabric_private fabric private functions
@@ -886,44 +760,6 @@ bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric)
886} 760}
887 761
888/* 762/*
889 * Node Symbolic Name Creation for base port and all vports
890 */
891void
892bfa_fcs_fabric_nsymb_init(struct bfa_fcs_fabric_s *fabric)
893{
894 struct bfa_lport_cfg_s *port_cfg = &fabric->bport.port_cfg;
895 char model[BFA_ADAPTER_MODEL_NAME_LEN] = {0};
896 struct bfa_fcs_driver_info_s *driver_info = &fabric->fcs->driver_info;
897
898 bfa_ioc_get_adapter_model(&fabric->fcs->bfa->ioc, model);
899
900 /* Model name/number */
901 strncpy((char *)&port_cfg->node_sym_name, model,
902 BFA_FCS_PORT_SYMBNAME_MODEL_SZ);
903 strncat((char *)&port_cfg->node_sym_name,
904 BFA_FCS_PORT_SYMBNAME_SEPARATOR,
905 sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
906
907 /* Driver Version */
908 strncat((char *)&port_cfg->node_sym_name, (char *)driver_info->version,
909 BFA_FCS_PORT_SYMBNAME_VERSION_SZ);
910 strncat((char *)&port_cfg->node_sym_name,
911 BFA_FCS_PORT_SYMBNAME_SEPARATOR,
912 sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
913
914 /* Host machine name */
915 strncat((char *)&port_cfg->node_sym_name,
916 (char *)driver_info->host_machine_name,
917 BFA_FCS_PORT_SYMBNAME_MACHINENAME_SZ);
918 strncat((char *)&port_cfg->node_sym_name,
919 BFA_FCS_PORT_SYMBNAME_SEPARATOR,
920 sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
921
922 /* null terminate */
923 port_cfg->node_sym_name.symname[BFA_SYMNAME_MAXLEN - 1] = 0;
924}
925
926/*
927 * bfa lps login completion callback 763 * bfa lps login completion callback
928 */ 764 */
929void 765void
@@ -1016,6 +852,9 @@ bfa_fcs_fabric_login(struct bfa_fcs_fabric_s *fabric)
1016 struct bfa_lport_cfg_s *pcfg = &fabric->bport.port_cfg; 852 struct bfa_lport_cfg_s *pcfg = &fabric->bport.port_cfg;
1017 u8 alpa = 0, bb_scn = 0; 853 u8 alpa = 0, bb_scn = 0;
1018 854
855 if (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)
856 alpa = bfa_fcport_get_myalpa(bfa);
857
1019 if (bfa_fcs_fabric_is_bbscn_enabled(fabric) && 858 if (bfa_fcs_fabric_is_bbscn_enabled(fabric) &&
1020 (!fabric->fcs->bbscn_flogi_rjt)) 859 (!fabric->fcs->bbscn_flogi_rjt))
1021 bb_scn = BFA_FCS_PORT_DEF_BB_SCN; 860 bb_scn = BFA_FCS_PORT_DEF_BB_SCN;
@@ -1080,28 +919,6 @@ bfa_fcs_fabric_delay(void *cbarg)
1080} 919}
1081 920
1082/* 921/*
1083 * Stop all vports and wait for vport stop completions.
1084 */
1085static void
1086bfa_fcs_fabric_stop(struct bfa_fcs_fabric_s *fabric)
1087{
1088 struct bfa_fcs_vport_s *vport;
1089 struct list_head *qe, *qen;
1090
1091 bfa_wc_init(&fabric->stop_wc, bfa_fcs_fabric_stop_comp, fabric);
1092
1093 list_for_each_safe(qe, qen, &fabric->vport_q) {
1094 vport = (struct bfa_fcs_vport_s *) qe;
1095 bfa_wc_up(&fabric->stop_wc);
1096 bfa_fcs_vport_fcs_stop(vport);
1097 }
1098
1099 bfa_wc_up(&fabric->stop_wc);
1100 bfa_fcs_lport_stop(&fabric->bport);
1101 bfa_wc_wait(&fabric->stop_wc);
1102}
1103
1104/*
1105 * Computes operating BB_SCN value 922 * Computes operating BB_SCN value
1106 */ 923 */
1107static u8 924static u8
@@ -1161,14 +978,6 @@ bfa_fcs_fabric_delete_comp(void *cbarg)
1161 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_DELCOMP); 978 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_DELCOMP);
1162} 979}
1163 980
1164static void
1165bfa_fcs_fabric_stop_comp(void *cbarg)
1166{
1167 struct bfa_fcs_fabric_s *fabric = cbarg;
1168
1169 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_STOPCOMP);
1170}
1171
1172/* 981/*
1173 * fcs_fabric_public fabric public functions 982 * fcs_fabric_public fabric public functions
1174 */ 983 */
@@ -1230,19 +1039,6 @@ bfa_fcs_fabric_modexit(struct bfa_fcs_s *fcs)
1230} 1039}
1231 1040
1232/* 1041/*
1233 * Fabric module stop -- stop FCS actions
1234 */
1235void
1236bfa_fcs_fabric_modstop(struct bfa_fcs_s *fcs)
1237{
1238 struct bfa_fcs_fabric_s *fabric;
1239
1240 bfa_trc(fcs, 0);
1241 fabric = &fcs->fabric;
1242 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_STOP);
1243}
1244
1245/*
1246 * Fabric module start -- kick starts FCS actions 1042 * Fabric module start -- kick starts FCS actions
1247 */ 1043 */
1248void 1044void
@@ -1423,11 +1219,8 @@ bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric, struct fchs_s *fchs,
1423 return; 1219 return;
1424 } 1220 }
1425 } 1221 }
1426 1222 bfa_trc(fabric->fcs, els_cmd->els_code);
1427 if (!bfa_fcs_fabric_is_switched(fabric)) 1223 bfa_fcs_lport_uf_recv(&fabric->bport, fchs, len);
1428 bfa_fcs_lport_uf_recv(&fabric->bport, fchs, len);
1429
1430 bfa_trc(fabric->fcs, fchs->type);
1431} 1224}
1432 1225
1433/* 1226/*
@@ -1501,7 +1294,7 @@ bfa_fcs_fabric_send_flogi_acc(struct bfa_fcs_fabric_s *fabric)
1501 u16 reqlen; 1294 u16 reqlen;
1502 struct fchs_s fchs; 1295 struct fchs_s fchs;
1503 1296
1504 fcxp = bfa_fcs_fcxp_alloc(fabric->fcs, BFA_FALSE); 1297 fcxp = bfa_fcs_fcxp_alloc(fabric->fcs);
1505 /* 1298 /*
1506 * Do not expect this failure -- expect remote node to retry 1299 * Do not expect this failure -- expect remote node to retry
1507 */ 1300 */
@@ -1594,13 +1387,6 @@ bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
1594 } 1387 }
1595} 1388}
1596 1389
1597void
1598bfa_cb_lps_flogo_comp(void *bfad, void *uarg)
1599{
1600 struct bfa_fcs_fabric_s *fabric = uarg;
1601 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_LOGOCOMP);
1602}
1603
1604/* 1390/*
1605 * Returns FCS vf structure for a given vf_id. 1391 * Returns FCS vf structure for a given vf_id.
1606 * 1392 *
diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index a449706c6bc..e75e07d2591 100644
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -62,9 +62,9 @@ struct bfa_fcs_s;
62#define N2N_LOCAL_PID 0x010000 62#define N2N_LOCAL_PID 0x010000
63#define N2N_REMOTE_PID 0x020000 63#define N2N_REMOTE_PID 0x020000
64#define BFA_FCS_RETRY_TIMEOUT 2000 64#define BFA_FCS_RETRY_TIMEOUT 2000
65#define BFA_FCS_MAX_NS_RETRIES 5
66#define BFA_FCS_PID_IS_WKA(pid) ((bfa_ntoh3b(pid) > 0xFFF000) ? 1 : 0) 65#define BFA_FCS_PID_IS_WKA(pid) ((bfa_ntoh3b(pid) > 0xFFF000) ? 1 : 0)
67#define BFA_FCS_MAX_RPORT_LOGINS 1024 66
67
68 68
69struct bfa_fcs_lport_ns_s { 69struct bfa_fcs_lport_ns_s {
70 bfa_sm_t sm; /* state machine */ 70 bfa_sm_t sm; /* state machine */
@@ -72,8 +72,6 @@ struct bfa_fcs_lport_ns_s {
72 struct bfa_fcs_lport_s *port; /* parent port */ 72 struct bfa_fcs_lport_s *port; /* parent port */
73 struct bfa_fcxp_s *fcxp; 73 struct bfa_fcxp_s *fcxp;
74 struct bfa_fcxp_wqe_s fcxp_wqe; 74 struct bfa_fcxp_wqe_s fcxp_wqe;
75 u8 num_rnnid_retries;
76 u8 num_rsnn_nn_retries;
77}; 75};
78 76
79 77
@@ -118,9 +116,9 @@ struct bfa_fcs_lport_fab_s {
118#define MAX_ALPA_COUNT 127 116#define MAX_ALPA_COUNT 127
119 117
120struct bfa_fcs_lport_loop_s { 118struct bfa_fcs_lport_loop_s {
121 u8 num_alpa; /* Num of ALPA entries in the map */ 119 u8 num_alpa; /* Num of ALPA entries in the map */
122 u8 alpabm_valid; /* alpa bitmap valid or not (1 or 0) */ 120 u8 alpa_pos_map[MAX_ALPA_COUNT]; /* ALPA Positional
123 u8 alpa_pos_map[MAX_ALPA_COUNT]; /* ALPA Positional Map */ 121 *Map */
124 struct bfa_fcs_lport_s *port; /* parent port */ 122 struct bfa_fcs_lport_s *port; /* parent port */
125}; 123};
126 124
@@ -175,7 +173,6 @@ enum bfa_fcs_fabric_type {
175 BFA_FCS_FABRIC_UNKNOWN = 0, 173 BFA_FCS_FABRIC_UNKNOWN = 0,
176 BFA_FCS_FABRIC_SWITCHED = 1, 174 BFA_FCS_FABRIC_SWITCHED = 1,
177 BFA_FCS_FABRIC_N2N = 2, 175 BFA_FCS_FABRIC_N2N = 2,
178 BFA_FCS_FABRIC_LOOP = 3,
179}; 176};
180 177
181 178
@@ -208,7 +205,6 @@ struct bfa_fcs_fabric_s {
208 struct bfa_lps_s *lps; /* lport login services */ 205 struct bfa_lps_s *lps; /* lport login services */
209 u8 fabric_ip_addr[BFA_FCS_FABRIC_IPADDR_SZ]; 206 u8 fabric_ip_addr[BFA_FCS_FABRIC_IPADDR_SZ];
210 /* attached fabric's ip addr */ 207 /* attached fabric's ip addr */
211 struct bfa_wc_s stop_wc; /* wait counter for stop */
212}; 208};
213 209
214#define bfa_fcs_fabric_npiv_capable(__f) ((__f)->is_npiv) 210#define bfa_fcs_fabric_npiv_capable(__f) ((__f)->is_npiv)
@@ -268,7 +264,6 @@ struct bfa_fcs_fabric_s;
268#define bfa_fcs_lport_get_pwwn(_lport) ((_lport)->port_cfg.pwwn) 264#define bfa_fcs_lport_get_pwwn(_lport) ((_lport)->port_cfg.pwwn)
269#define bfa_fcs_lport_get_nwwn(_lport) ((_lport)->port_cfg.nwwn) 265#define bfa_fcs_lport_get_nwwn(_lport) ((_lport)->port_cfg.nwwn)
270#define bfa_fcs_lport_get_psym_name(_lport) ((_lport)->port_cfg.sym_name) 266#define bfa_fcs_lport_get_psym_name(_lport) ((_lport)->port_cfg.sym_name)
271#define bfa_fcs_lport_get_nsym_name(_lport) ((_lport)->port_cfg.node_sym_name)
272#define bfa_fcs_lport_is_initiator(_lport) \ 267#define bfa_fcs_lport_is_initiator(_lport) \
273 ((_lport)->port_cfg.roles & BFA_LPORT_ROLE_FCP_IM) 268 ((_lport)->port_cfg.roles & BFA_LPORT_ROLE_FCP_IM)
274#define bfa_fcs_lport_get_nrports(_lport) \ 269#define bfa_fcs_lport_get_nrports(_lport) \
@@ -291,8 +286,9 @@ bfa_fcs_lport_get_drvport(struct bfa_fcs_lport_s *port)
291 286
292bfa_boolean_t bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port); 287bfa_boolean_t bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port);
293struct bfa_fcs_lport_s *bfa_fcs_get_base_port(struct bfa_fcs_s *fcs); 288struct bfa_fcs_lport_s *bfa_fcs_get_base_port(struct bfa_fcs_s *fcs);
294void bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port, 289void bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
295 struct bfa_rport_qualifier_s rport[], int *nrports); 290 wwn_t rport_wwns[], int *nrports);
291
296wwn_t bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, 292wwn_t bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn,
297 int index, int nrports, bfa_boolean_t bwwn); 293 int index, int nrports, bfa_boolean_t bwwn);
298 294
@@ -328,17 +324,12 @@ void bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport,
328void bfa_fcs_lport_online(struct bfa_fcs_lport_s *port); 324void bfa_fcs_lport_online(struct bfa_fcs_lport_s *port);
329void bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port); 325void bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port);
330void bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port); 326void bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port);
331void bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port);
332struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pid( 327struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pid(
333 struct bfa_fcs_lport_s *port, u32 pid); 328 struct bfa_fcs_lport_s *port, u32 pid);
334struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_old_pid(
335 struct bfa_fcs_lport_s *port, u32 pid);
336struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pwwn( 329struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pwwn(
337 struct bfa_fcs_lport_s *port, wwn_t pwwn); 330 struct bfa_fcs_lport_s *port, wwn_t pwwn);
338struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_nwwn( 331struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_nwwn(
339 struct bfa_fcs_lport_s *port, wwn_t nwwn); 332 struct bfa_fcs_lport_s *port, wwn_t nwwn);
340struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_qualifier(
341 struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 pid);
342void bfa_fcs_lport_add_rport(struct bfa_fcs_lport_s *port, 333void bfa_fcs_lport_add_rport(struct bfa_fcs_lport_s *port,
343 struct bfa_fcs_rport_s *rport); 334 struct bfa_fcs_rport_s *rport);
344void bfa_fcs_lport_del_rport(struct bfa_fcs_lport_s *port, 335void bfa_fcs_lport_del_rport(struct bfa_fcs_lport_s *port,
@@ -347,14 +338,11 @@ void bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *vport);
347void bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *vport); 338void bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *vport);
348void bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *vport); 339void bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *vport);
349void bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port); 340void bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port);
350void bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg,
351 struct bfa_fcxp_s *fcxp_alloced);
352void bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *vport); 341void bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *vport);
353void bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *vport); 342void bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *vport);
354void bfa_fcs_lport_fab_scn_online(struct bfa_fcs_lport_s *vport); 343void bfa_fcs_lport_scn_online(struct bfa_fcs_lport_s *vport);
355void bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port, 344void bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port,
356 struct fchs_s *rx_frame, u32 len); 345 struct fchs_s *rx_frame, u32 len);
357void bfa_fcs_lport_lip_scn_online(bfa_fcs_lport_t *port);
358 346
359struct bfa_fcs_vport_s { 347struct bfa_fcs_vport_s {
360 struct list_head qe; /* queue elem */ 348 struct list_head qe; /* queue elem */
@@ -394,7 +382,6 @@ void bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport);
394void bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport); 382void bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport);
395void bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport); 383void bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport);
396void bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport); 384void bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport);
397void bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport);
398void bfa_fcs_vport_stop_comp(struct bfa_fcs_vport_s *vport); 385void bfa_fcs_vport_stop_comp(struct bfa_fcs_vport_s *vport);
399 386
400#define BFA_FCS_RPORT_DEF_DEL_TIMEOUT 90 /* in secs */ 387#define BFA_FCS_RPORT_DEF_DEL_TIMEOUT 90 /* in secs */
@@ -432,7 +419,6 @@ struct bfa_fcs_rport_s {
432 struct bfa_fcs_s *fcs; /* fcs instance */ 419 struct bfa_fcs_s *fcs; /* fcs instance */
433 struct bfad_rport_s *rp_drv; /* driver peer instance */ 420 struct bfad_rport_s *rp_drv; /* driver peer instance */
434 u32 pid; /* port ID of rport */ 421 u32 pid; /* port ID of rport */
435 u32 old_pid; /* PID before rport goes offline */
436 u16 maxfrsize; /* maximum frame size */ 422 u16 maxfrsize; /* maximum frame size */
437 __be16 reply_oxid; /* OX_ID of inbound requests */ 423 __be16 reply_oxid; /* OX_ID of inbound requests */
438 enum fc_cos fc_cos; /* FC classes of service supp */ 424 enum fc_cos fc_cos; /* FC classes of service supp */
@@ -455,7 +441,6 @@ struct bfa_fcs_rport_s {
455 struct bfa_rport_stats_s stats; /* rport stats */ 441 struct bfa_rport_stats_s stats; /* rport stats */
456 enum bfa_rport_function scsi_function; /* Initiator/Target */ 442 enum bfa_rport_function scsi_function; /* Initiator/Target */
457 struct bfa_fcs_rpf_s rpf; /* Rport features module */ 443 struct bfa_fcs_rpf_s rpf; /* Rport features module */
458 bfa_boolean_t scn_online; /* SCN online flag */
459}; 444};
460 445
461static inline struct bfa_rport_s * 446static inline struct bfa_rport_s *
@@ -474,7 +459,7 @@ struct bfa_fcs_rport_s *bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port,
474struct bfa_fcs_rport_s *bfa_fcs_rport_lookup_by_nwwn( 459struct bfa_fcs_rport_s *bfa_fcs_rport_lookup_by_nwwn(
475 struct bfa_fcs_lport_s *port, wwn_t rnwwn); 460 struct bfa_fcs_lport_s *port, wwn_t rnwwn);
476void bfa_fcs_rport_set_del_timeout(u8 rport_tmo); 461void bfa_fcs_rport_set_del_timeout(u8 rport_tmo);
477void bfa_fcs_rport_set_max_logins(u32 max_logins); 462
478void bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport, 463void bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport,
479 struct fchs_s *fchs, u16 len); 464 struct fchs_s *fchs, u16 len);
480void bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport); 465void bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport);
@@ -520,13 +505,12 @@ struct bfa_fcs_itnim_s {
520 struct bfa_fcxp_s *fcxp; /* FCXP in use */ 505 struct bfa_fcxp_s *fcxp; /* FCXP in use */
521 struct bfa_itnim_stats_s stats; /* itn statistics */ 506 struct bfa_itnim_stats_s stats; /* itn statistics */
522}; 507};
523#define bfa_fcs_fcxp_alloc(__fcs, __req) \ 508#define bfa_fcs_fcxp_alloc(__fcs) \
524 bfa_fcxp_req_rsp_alloc(NULL, (__fcs)->bfa, 0, 0, \ 509 bfa_fcxp_alloc(NULL, (__fcs)->bfa, 0, 0, NULL, NULL, NULL, NULL)
525 NULL, NULL, NULL, NULL, __req) 510
526#define bfa_fcs_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn, \ 511#define bfa_fcs_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn, __alloc_cbarg) \
527 __alloc_cbarg, __req) \ 512 bfa_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn, __alloc_cbarg, \
528 bfa_fcxp_req_rsp_alloc_wait(__bfa, __wqe, __alloc_cbfn, \ 513 NULL, 0, 0, NULL, NULL, NULL, NULL)
529 __alloc_cbarg, NULL, 0, 0, NULL, NULL, NULL, NULL, __req)
530 514
531static inline struct bfad_port_s * 515static inline struct bfad_port_s *
532bfa_fcs_itnim_get_drvport(struct bfa_fcs_itnim_s *itnim) 516bfa_fcs_itnim_get_drvport(struct bfa_fcs_itnim_s *itnim)
@@ -608,7 +592,7 @@ bfa_status_t bfa_fcs_itnim_stats_clear(struct bfa_fcs_lport_s *port,
608struct bfa_fcs_itnim_s *bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport); 592struct bfa_fcs_itnim_s *bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport);
609void bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim); 593void bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim);
610void bfa_fcs_itnim_rport_offline(struct bfa_fcs_itnim_s *itnim); 594void bfa_fcs_itnim_rport_offline(struct bfa_fcs_itnim_s *itnim);
611void bfa_fcs_itnim_brp_online(struct bfa_fcs_itnim_s *itnim); 595void bfa_fcs_itnim_rport_online(struct bfa_fcs_itnim_s *itnim);
612bfa_status_t bfa_fcs_itnim_get_online_state(struct bfa_fcs_itnim_s *itnim); 596bfa_status_t bfa_fcs_itnim_get_online_state(struct bfa_fcs_itnim_s *itnim);
613void bfa_fcs_itnim_is_initiator(struct bfa_fcs_itnim_s *itnim); 597void bfa_fcs_itnim_is_initiator(struct bfa_fcs_itnim_s *itnim);
614void bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim, 598void bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim,
@@ -642,9 +626,9 @@ struct bfa_fcs_fdmi_hba_attr_s {
642 u8 model[16]; 626 u8 model[16];
643 u8 model_desc[256]; 627 u8 model_desc[256];
644 u8 hw_version[8]; 628 u8 hw_version[8];
645 u8 driver_version[BFA_VERSION_LEN]; 629 u8 driver_version[8];
646 u8 option_rom_ver[BFA_VERSION_LEN]; 630 u8 option_rom_ver[BFA_VERSION_LEN];
647 u8 fw_version[BFA_VERSION_LEN]; 631 u8 fw_version[8];
648 u8 os_name[256]; 632 u8 os_name[256];
649 __be32 max_ct_pyld; 633 __be32 max_ct_pyld;
650}; 634};
@@ -692,7 +676,6 @@ struct bfa_fcs_s {
692 struct bfa_fcs_stats_s stats; /* FCS statistics */ 676 struct bfa_fcs_stats_s stats; /* FCS statistics */
693 struct bfa_wc_s wc; /* waiting counter */ 677 struct bfa_wc_s wc; /* waiting counter */
694 int fcs_aen_seq; 678 int fcs_aen_seq;
695 u32 num_rport_logins;
696}; 679};
697 680
698/* 681/*
@@ -719,9 +702,6 @@ enum bfa_fcs_fabric_event {
719 BFA_FCS_FABRIC_SM_DELCOMP = 14, /* all vports deleted event */ 702 BFA_FCS_FABRIC_SM_DELCOMP = 14, /* all vports deleted event */
720 BFA_FCS_FABRIC_SM_LOOPBACK = 15, /* Received our own FLOGI */ 703 BFA_FCS_FABRIC_SM_LOOPBACK = 15, /* Received our own FLOGI */
721 BFA_FCS_FABRIC_SM_START = 16, /* from driver */ 704 BFA_FCS_FABRIC_SM_START = 16, /* from driver */
722 BFA_FCS_FABRIC_SM_STOP = 17, /* Stop from driver */
723 BFA_FCS_FABRIC_SM_STOPCOMP = 18, /* Stop completion */
724 BFA_FCS_FABRIC_SM_LOGOCOMP = 19, /* FLOGO completion */
725}; 705};
726 706
727/* 707/*
@@ -736,7 +716,7 @@ enum rport_event {
736 RPSM_EVENT_LOGO_IMP = 5, /* implicit logo for SLER */ 716 RPSM_EVENT_LOGO_IMP = 5, /* implicit logo for SLER */
737 RPSM_EVENT_FCXP_SENT = 6, /* Frame from has been sent */ 717 RPSM_EVENT_FCXP_SENT = 6, /* Frame from has been sent */
738 RPSM_EVENT_DELETE = 7, /* RPORT delete request */ 718 RPSM_EVENT_DELETE = 7, /* RPORT delete request */
739 RPSM_EVENT_FAB_SCN = 8, /* state change notification */ 719 RPSM_EVENT_SCN = 8, /* state change notification */
740 RPSM_EVENT_ACCEPTED = 9, /* Good response from remote device */ 720 RPSM_EVENT_ACCEPTED = 9, /* Good response from remote device */
741 RPSM_EVENT_FAILED = 10, /* Request to rport failed. */ 721 RPSM_EVENT_FAILED = 10, /* Request to rport failed. */
742 RPSM_EVENT_TIMEOUT = 11, /* Rport SM timeout event */ 722 RPSM_EVENT_TIMEOUT = 11, /* Rport SM timeout event */
@@ -747,28 +727,6 @@ enum rport_event {
747 RPSM_EVENT_ADDRESS_DISC = 16, /* Need to Discover rport's PID */ 727 RPSM_EVENT_ADDRESS_DISC = 16, /* Need to Discover rport's PID */
748 RPSM_EVENT_PRLO_RCVD = 17, /* PRLO from remote device */ 728 RPSM_EVENT_PRLO_RCVD = 17, /* PRLO from remote device */
749 RPSM_EVENT_PLOGI_RETRY = 18, /* Retry PLOGI continuously */ 729 RPSM_EVENT_PLOGI_RETRY = 18, /* Retry PLOGI continuously */
750 RPSM_EVENT_SCN_OFFLINE = 19, /* loop scn offline */
751 RPSM_EVENT_SCN_ONLINE = 20, /* loop scn online */
752 RPSM_EVENT_FC4_FCS_ONLINE = 21, /* FC-4 FCS online complete */
753};
754
755/*
756 * fcs_itnim_sm FCS itnim state machine events
757 */
758enum bfa_fcs_itnim_event {
759 BFA_FCS_ITNIM_SM_FCS_ONLINE = 1, /* rport online event */
760 BFA_FCS_ITNIM_SM_OFFLINE = 2, /* rport offline */
761 BFA_FCS_ITNIM_SM_FRMSENT = 3, /* prli frame is sent */
762 BFA_FCS_ITNIM_SM_RSP_OK = 4, /* good response */
763 BFA_FCS_ITNIM_SM_RSP_ERROR = 5, /* error response */
764 BFA_FCS_ITNIM_SM_TIMEOUT = 6, /* delay timeout */
765 BFA_FCS_ITNIM_SM_HCB_OFFLINE = 7, /* BFA online callback */
766 BFA_FCS_ITNIM_SM_HCB_ONLINE = 8, /* BFA offline callback */
767 BFA_FCS_ITNIM_SM_INITIATOR = 9, /* rport is initiator */
768 BFA_FCS_ITNIM_SM_DELETE = 10, /* delete event from rport */
769 BFA_FCS_ITNIM_SM_PRLO = 11, /* delete event from rport */
770 BFA_FCS_ITNIM_SM_RSP_NOT_SUPP = 12, /* cmd not supported rsp */
771 BFA_FCS_ITNIM_SM_HAL_ONLINE = 13, /* bfa rport online event */
772}; 730};
773 731
774/* 732/*
@@ -783,7 +741,6 @@ void bfa_fcs_update_cfg(struct bfa_fcs_s *fcs);
783void bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs, 741void bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
784 struct bfa_fcs_driver_info_s *driver_info); 742 struct bfa_fcs_driver_info_s *driver_info);
785void bfa_fcs_exit(struct bfa_fcs_s *fcs); 743void bfa_fcs_exit(struct bfa_fcs_s *fcs);
786void bfa_fcs_stop(struct bfa_fcs_s *fcs);
787 744
788/* 745/*
789 * bfa fcs vf public functions 746 * bfa fcs vf public functions
@@ -809,13 +766,11 @@ void bfa_fcs_fabric_modstart(struct bfa_fcs_s *fcs);
809void bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric, 766void bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric,
810 struct fchs_s *fchs, u16 len); 767 struct fchs_s *fchs, u16 len);
811void bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric); 768void bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric);
812void bfa_fcs_fabric_nsymb_init(struct bfa_fcs_fabric_s *fabric);
813void bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric, 769void bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
814 wwn_t fabric_name); 770 wwn_t fabric_name);
815u16 bfa_fcs_fabric_get_switch_oui(struct bfa_fcs_fabric_s *fabric); 771u16 bfa_fcs_fabric_get_switch_oui(struct bfa_fcs_fabric_s *fabric);
816void bfa_fcs_uf_attach(struct bfa_fcs_s *fcs); 772void bfa_fcs_uf_attach(struct bfa_fcs_s *fcs);
817void bfa_fcs_port_attach(struct bfa_fcs_s *fcs); 773void bfa_fcs_port_attach(struct bfa_fcs_s *fcs);
818void bfa_fcs_fabric_modstop(struct bfa_fcs_s *fcs);
819void bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric, 774void bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
820 enum bfa_fcs_fabric_event event); 775 enum bfa_fcs_fabric_event event);
821void bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric, 776void bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric,
@@ -844,6 +799,9 @@ struct bfad_port_s *bfa_fcb_lport_new(struct bfad_s *bfad,
844 enum bfa_lport_role roles, 799 enum bfa_lport_role roles,
845 struct bfad_vf_s *vf_drv, 800 struct bfad_vf_s *vf_drv,
846 struct bfad_vport_s *vp_drv); 801 struct bfad_vport_s *vp_drv);
802void bfa_fcb_lport_delete(struct bfad_s *bfad, enum bfa_lport_role roles,
803 struct bfad_vf_s *vf_drv,
804 struct bfad_vport_s *vp_drv);
847 805
848/* 806/*
849 * vport callbacks 807 * vport callbacks
diff --git a/drivers/scsi/bfa/bfa_fcs_fcpim.c b/drivers/scsi/bfa/bfa_fcs_fcpim.c
index 6dc7926a3ed..9272840a240 100644
--- a/drivers/scsi/bfa/bfa_fcs_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcs_fcpim.c
@@ -40,6 +40,25 @@ static void bfa_fcs_itnim_prli_response(void *fcsarg,
40static void bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim, 40static void bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
41 enum bfa_itnim_aen_event event); 41 enum bfa_itnim_aen_event event);
42 42
43/*
44 * fcs_itnim_sm FCS itnim state machine events
45 */
46
47enum bfa_fcs_itnim_event {
48 BFA_FCS_ITNIM_SM_ONLINE = 1, /* rport online event */
49 BFA_FCS_ITNIM_SM_OFFLINE = 2, /* rport offline */
50 BFA_FCS_ITNIM_SM_FRMSENT = 3, /* prli frame is sent */
51 BFA_FCS_ITNIM_SM_RSP_OK = 4, /* good response */
52 BFA_FCS_ITNIM_SM_RSP_ERROR = 5, /* error response */
53 BFA_FCS_ITNIM_SM_TIMEOUT = 6, /* delay timeout */
54 BFA_FCS_ITNIM_SM_HCB_OFFLINE = 7, /* BFA online callback */
55 BFA_FCS_ITNIM_SM_HCB_ONLINE = 8, /* BFA offline callback */
56 BFA_FCS_ITNIM_SM_INITIATOR = 9, /* rport is initiator */
57 BFA_FCS_ITNIM_SM_DELETE = 10, /* delete event from rport */
58 BFA_FCS_ITNIM_SM_PRLO = 11, /* delete event from rport */
59 BFA_FCS_ITNIM_SM_RSP_NOT_SUPP = 12, /* cmd not supported rsp */
60};
61
43static void bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim, 62static void bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
44 enum bfa_fcs_itnim_event event); 63 enum bfa_fcs_itnim_event event);
45static void bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim, 64static void bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
@@ -50,8 +69,6 @@ static void bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
50 enum bfa_fcs_itnim_event event); 69 enum bfa_fcs_itnim_event event);
51static void bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim, 70static void bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
52 enum bfa_fcs_itnim_event event); 71 enum bfa_fcs_itnim_event event);
53static void bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
54 enum bfa_fcs_itnim_event event);
55static void bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim, 72static void bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
56 enum bfa_fcs_itnim_event event); 73 enum bfa_fcs_itnim_event event);
57static void bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim, 74static void bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
@@ -82,7 +99,7 @@ bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
82 bfa_trc(itnim->fcs, event); 99 bfa_trc(itnim->fcs, event);
83 100
84 switch (event) { 101 switch (event) {
85 case BFA_FCS_ITNIM_SM_FCS_ONLINE: 102 case BFA_FCS_ITNIM_SM_ONLINE:
86 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_send); 103 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_send);
87 itnim->prli_retries = 0; 104 itnim->prli_retries = 0;
88 bfa_fcs_itnim_send_prli(itnim, NULL); 105 bfa_fcs_itnim_send_prli(itnim, NULL);
@@ -121,7 +138,6 @@ bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
121 case BFA_FCS_ITNIM_SM_INITIATOR: 138 case BFA_FCS_ITNIM_SM_INITIATOR:
122 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator); 139 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
123 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe); 140 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
124 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
125 break; 141 break;
126 142
127 case BFA_FCS_ITNIM_SM_OFFLINE: 143 case BFA_FCS_ITNIM_SM_OFFLINE:
@@ -150,13 +166,12 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
150 166
151 switch (event) { 167 switch (event) {
152 case BFA_FCS_ITNIM_SM_RSP_OK: 168 case BFA_FCS_ITNIM_SM_RSP_OK:
153 if (itnim->rport->scsi_function == BFA_RPORT_INITIATOR) 169 if (itnim->rport->scsi_function == BFA_RPORT_INITIATOR) {
154 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator); 170 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
155 else 171 } else {
156 bfa_sm_set_state(itnim, 172 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_online);
157 bfa_fcs_itnim_sm_hal_rport_online); 173 bfa_itnim_online(itnim->bfa_itnim, itnim->seq_rec);
158 174 }
159 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
160 break; 175 break;
161 176
162 case BFA_FCS_ITNIM_SM_RSP_ERROR: 177 case BFA_FCS_ITNIM_SM_RSP_ERROR:
@@ -179,7 +194,6 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
179 case BFA_FCS_ITNIM_SM_INITIATOR: 194 case BFA_FCS_ITNIM_SM_INITIATOR:
180 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator); 195 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
181 bfa_fcxp_discard(itnim->fcxp); 196 bfa_fcxp_discard(itnim->fcxp);
182 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
183 break; 197 break;
184 198
185 case BFA_FCS_ITNIM_SM_DELETE: 199 case BFA_FCS_ITNIM_SM_DELETE:
@@ -194,44 +208,6 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
194} 208}
195 209
196static void 210static void
197bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
198 enum bfa_fcs_itnim_event event)
199{
200 bfa_trc(itnim->fcs, itnim->rport->pwwn);
201 bfa_trc(itnim->fcs, event);
202
203 switch (event) {
204 case BFA_FCS_ITNIM_SM_HAL_ONLINE:
205 if (!itnim->bfa_itnim)
206 itnim->bfa_itnim = bfa_itnim_create(itnim->fcs->bfa,
207 itnim->rport->bfa_rport, itnim);
208
209 if (itnim->bfa_itnim) {
210 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_online);
211 bfa_itnim_online(itnim->bfa_itnim, itnim->seq_rec);
212 } else {
213 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
214 bfa_sm_send_event(itnim->rport, RPSM_EVENT_DELETE);
215 }
216
217 break;
218
219 case BFA_FCS_ITNIM_SM_OFFLINE:
220 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
221 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
222 break;
223
224 case BFA_FCS_ITNIM_SM_DELETE:
225 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
226 bfa_fcs_itnim_free(itnim);
227 break;
228
229 default:
230 bfa_sm_fault(itnim->fcs, event);
231 }
232}
233
234static void
235bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim, 211bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
236 enum bfa_fcs_itnim_event event) 212 enum bfa_fcs_itnim_event event)
237{ 213{
@@ -262,7 +238,6 @@ bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
262 case BFA_FCS_ITNIM_SM_INITIATOR: 238 case BFA_FCS_ITNIM_SM_INITIATOR:
263 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator); 239 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
264 bfa_timer_stop(&itnim->timer); 240 bfa_timer_stop(&itnim->timer);
265 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
266 break; 241 break;
267 242
268 case BFA_FCS_ITNIM_SM_DELETE: 243 case BFA_FCS_ITNIM_SM_DELETE:
@@ -300,8 +275,9 @@ bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
300 break; 275 break;
301 276
302 case BFA_FCS_ITNIM_SM_OFFLINE: 277 case BFA_FCS_ITNIM_SM_OFFLINE:
303 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline); 278 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
304 bfa_itnim_offline(itnim->bfa_itnim); 279 bfa_itnim_offline(itnim->bfa_itnim);
280 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
305 break; 281 break;
306 282
307 case BFA_FCS_ITNIM_SM_DELETE: 283 case BFA_FCS_ITNIM_SM_DELETE:
@@ -396,14 +372,8 @@ bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
396 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE); 372 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
397 break; 373 break;
398 374
399 /*
400 * fcs_online is expected here for well known initiator ports
401 */
402 case BFA_FCS_ITNIM_SM_FCS_ONLINE:
403 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
404 break;
405
406 case BFA_FCS_ITNIM_SM_RSP_ERROR: 375 case BFA_FCS_ITNIM_SM_RSP_ERROR:
376 case BFA_FCS_ITNIM_SM_ONLINE:
407 case BFA_FCS_ITNIM_SM_INITIATOR: 377 case BFA_FCS_ITNIM_SM_INITIATOR:
408 break; 378 break;
409 379
@@ -456,12 +426,11 @@ bfa_fcs_itnim_send_prli(void *itnim_cbarg, struct bfa_fcxp_s *fcxp_alloced)
456 426
457 bfa_trc(itnim->fcs, itnim->rport->pwwn); 427 bfa_trc(itnim->fcs, itnim->rport->pwwn);
458 428
459 fcxp = fcxp_alloced ? fcxp_alloced : 429 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
460 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
461 if (!fcxp) { 430 if (!fcxp) {
462 itnim->stats.fcxp_alloc_wait++; 431 itnim->stats.fcxp_alloc_wait++;
463 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &itnim->fcxp_wqe, 432 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &itnim->fcxp_wqe,
464 bfa_fcs_itnim_send_prli, itnim, BFA_TRUE); 433 bfa_fcs_itnim_send_prli, itnim);
465 return; 434 return;
466 } 435 }
467 itnim->fcxp = fcxp; 436 itnim->fcxp = fcxp;
@@ -514,7 +483,7 @@ bfa_fcs_itnim_prli_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
514 if (prli_resp->parampage.servparams.initiator) { 483 if (prli_resp->parampage.servparams.initiator) {
515 bfa_trc(itnim->fcs, prli_resp->parampage.type); 484 bfa_trc(itnim->fcs, prli_resp->parampage.type);
516 itnim->rport->scsi_function = 485 itnim->rport->scsi_function =
517 BFA_RPORT_INITIATOR; 486 BFA_RPORT_INITIATOR;
518 itnim->stats.prli_rsp_acc++; 487 itnim->stats.prli_rsp_acc++;
519 itnim->stats.initiator++; 488 itnim->stats.initiator++;
520 bfa_sm_send_event(itnim, 489 bfa_sm_send_event(itnim,
@@ -562,11 +531,7 @@ bfa_fcs_itnim_timeout(void *arg)
562static void 531static void
563bfa_fcs_itnim_free(struct bfa_fcs_itnim_s *itnim) 532bfa_fcs_itnim_free(struct bfa_fcs_itnim_s *itnim)
564{ 533{
565 if (itnim->bfa_itnim) { 534 bfa_itnim_delete(itnim->bfa_itnim);
566 bfa_itnim_delete(itnim->bfa_itnim);
567 itnim->bfa_itnim = NULL;
568 }
569
570 bfa_fcb_itnim_free(itnim->fcs->bfad, itnim->itnim_drv); 535 bfa_fcb_itnim_free(itnim->fcs->bfad, itnim->itnim_drv);
571} 536}
572 537
@@ -587,6 +552,7 @@ bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
587 struct bfa_fcs_lport_s *port = rport->port; 552 struct bfa_fcs_lport_s *port = rport->port;
588 struct bfa_fcs_itnim_s *itnim; 553 struct bfa_fcs_itnim_s *itnim;
589 struct bfad_itnim_s *itnim_drv; 554 struct bfad_itnim_s *itnim_drv;
555 struct bfa_itnim_s *bfa_itnim;
590 556
591 /* 557 /*
592 * call bfad to allocate the itnim 558 * call bfad to allocate the itnim
@@ -604,7 +570,20 @@ bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
604 itnim->fcs = rport->fcs; 570 itnim->fcs = rport->fcs;
605 itnim->itnim_drv = itnim_drv; 571 itnim->itnim_drv = itnim_drv;
606 572
607 itnim->bfa_itnim = NULL; 573 /*
574 * call BFA to create the itnim
575 */
576 bfa_itnim =
577 bfa_itnim_create(port->fcs->bfa, rport->bfa_rport, itnim);
578
579 if (bfa_itnim == NULL) {
580 bfa_trc(port->fcs, rport->pwwn);
581 bfa_fcb_itnim_free(port->fcs->bfad, itnim_drv);
582 WARN_ON(1);
583 return NULL;
584 }
585
586 itnim->bfa_itnim = bfa_itnim;
608 itnim->seq_rec = BFA_FALSE; 587 itnim->seq_rec = BFA_FALSE;
609 itnim->rec_support = BFA_FALSE; 588 itnim->rec_support = BFA_FALSE;
610 itnim->conf_comp = BFA_FALSE; 589 itnim->conf_comp = BFA_FALSE;
@@ -634,12 +613,20 @@ bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim)
634 * Notification from rport that PLOGI is complete to initiate FC-4 session. 613 * Notification from rport that PLOGI is complete to initiate FC-4 session.
635 */ 614 */
636void 615void
637bfa_fcs_itnim_brp_online(struct bfa_fcs_itnim_s *itnim) 616bfa_fcs_itnim_rport_online(struct bfa_fcs_itnim_s *itnim)
638{ 617{
639 itnim->stats.onlines++; 618 itnim->stats.onlines++;
640 619
641 if (!BFA_FCS_PID_IS_WKA(itnim->rport->pid)) 620 if (!BFA_FCS_PID_IS_WKA(itnim->rport->pid)) {
642 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_HAL_ONLINE); 621 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_ONLINE);
622 } else {
623 /*
624 * For well known addresses, we set the itnim to initiator
625 * state
626 */
627 itnim->stats.initiator++;
628 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_INITIATOR);
629 }
643} 630}
644 631
645/* 632/*
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index 1224d0462a4..d4f951fe753 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -23,34 +23,6 @@
23 23
24BFA_TRC_FILE(FCS, PORT); 24BFA_TRC_FILE(FCS, PORT);
25 25
26/*
27 * ALPA to LIXA bitmap mapping
28 *
29 * ALPA 0x00 (Word 0, Bit 30) is invalid for N_Ports. Also Word 0 Bit 31
30 * is for L_bit (login required) and is filled as ALPA 0x00 here.
31 */
32static const u8 loop_alpa_map[] = {
33 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x0F, 0x10, /* Word 0 Bits 31..24 */
34 0x17, 0x18, 0x1B, 0x1D, 0x1E, 0x1F, 0x23, 0x25, /* Word 0 Bits 23..16 */
35 0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, /* Word 0 Bits 15..08 */
36 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x39, 0x3A, /* Word 0 Bits 07..00 */
37
38 0x3C, 0x43, 0x45, 0x46, 0x47, 0x49, 0x4A, 0x4B, /* Word 1 Bits 31..24 */
39 0x4C, 0x4D, 0x4E, 0x51, 0x52, 0x53, 0x54, 0x55, /* Word 1 Bits 23..16 */
40 0x56, 0x59, 0x5A, 0x5C, 0x63, 0x65, 0x66, 0x67, /* Word 1 Bits 15..08 */
41 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, /* Word 1 Bits 07..00 */
42
43 0x73, 0x74, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x80, /* Word 2 Bits 31..24 */
44 0x81, 0x82, 0x84, 0x88, 0x8F, 0x90, 0x97, 0x98, /* Word 2 Bits 23..16 */
45 0x9B, 0x9D, 0x9E, 0x9F, 0xA3, 0xA5, 0xA6, 0xA7, /* Word 2 Bits 15..08 */
46 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xB1, 0xB2, /* Word 2 Bits 07..00 */
47
48 0xB3, 0xB4, 0xB5, 0xB6, 0xB9, 0xBA, 0xBC, 0xC3, /* Word 3 Bits 31..24 */
49 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, /* Word 3 Bits 23..16 */
50 0xCE, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD9, /* Word 3 Bits 15..08 */
51 0xDA, 0xDC, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xEF, /* Word 3 Bits 07..00 */
52};
53
54static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, 26static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port,
55 struct fchs_s *rx_fchs, u8 reason_code, 27 struct fchs_s *rx_fchs, u8 reason_code,
56 u8 reason_code_expl); 28 u8 reason_code_expl);
@@ -79,10 +51,6 @@ static void bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port);
79static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port); 51static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port);
80static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port); 52static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port);
81 53
82static void bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port);
83static void bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port);
84static void bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port);
85
86static struct { 54static struct {
87 void (*init) (struct bfa_fcs_lport_s *port); 55 void (*init) (struct bfa_fcs_lport_s *port);
88 void (*online) (struct bfa_fcs_lport_s *port); 56 void (*online) (struct bfa_fcs_lport_s *port);
@@ -94,9 +62,7 @@ static struct {
94 bfa_fcs_lport_fab_init, bfa_fcs_lport_fab_online, 62 bfa_fcs_lport_fab_init, bfa_fcs_lport_fab_online,
95 bfa_fcs_lport_fab_offline}, { 63 bfa_fcs_lport_fab_offline}, {
96 bfa_fcs_lport_n2n_init, bfa_fcs_lport_n2n_online, 64 bfa_fcs_lport_n2n_init, bfa_fcs_lport_n2n_online,
97 bfa_fcs_lport_n2n_offline}, { 65 bfa_fcs_lport_n2n_offline},
98 bfa_fcs_lport_loop_init, bfa_fcs_lport_loop_online,
99 bfa_fcs_lport_loop_offline},
100 }; 66 };
101 67
102/* 68/*
@@ -165,8 +131,6 @@ bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
165 /* If vport - send completion call back */ 131 /* If vport - send completion call back */
166 if (port->vport) 132 if (port->vport)
167 bfa_fcs_vport_stop_comp(port->vport); 133 bfa_fcs_vport_stop_comp(port->vport);
168 else
169 bfa_wc_down(&(port->fabric->stop_wc));
170 break; 134 break;
171 135
172 case BFA_FCS_PORT_SM_OFFLINE: 136 case BFA_FCS_PORT_SM_OFFLINE:
@@ -202,8 +166,6 @@ bfa_fcs_lport_sm_online(
202 /* If vport - send completion call back */ 166 /* If vport - send completion call back */
203 if (port->vport) 167 if (port->vport)
204 bfa_fcs_vport_stop_comp(port->vport); 168 bfa_fcs_vport_stop_comp(port->vport);
205 else
206 bfa_wc_down(&(port->fabric->stop_wc));
207 } else { 169 } else {
208 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping); 170 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
209 list_for_each_safe(qe, qen, &port->rport_q) { 171 list_for_each_safe(qe, qen, &port->rport_q) {
@@ -260,8 +222,6 @@ bfa_fcs_lport_sm_offline(
260 /* If vport - send completion call back */ 222 /* If vport - send completion call back */
261 if (port->vport) 223 if (port->vport)
262 bfa_fcs_vport_stop_comp(port->vport); 224 bfa_fcs_vport_stop_comp(port->vport);
263 else
264 bfa_wc_down(&(port->fabric->stop_wc));
265 } else { 225 } else {
266 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping); 226 bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
267 list_for_each_safe(qe, qen, &port->rport_q) { 227 list_for_each_safe(qe, qen, &port->rport_q) {
@@ -307,8 +267,6 @@ bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port,
307 /* If vport - send completion call back */ 267 /* If vport - send completion call back */
308 if (port->vport) 268 if (port->vport)
309 bfa_fcs_vport_stop_comp(port->vport); 269 bfa_fcs_vport_stop_comp(port->vport);
310 else
311 bfa_wc_down(&(port->fabric->stop_wc));
312 } 270 }
313 break; 271 break;
314 272
@@ -382,7 +340,7 @@ bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
382 bfa_trc(port->fcs, rx_fchs->d_id); 340 bfa_trc(port->fcs, rx_fchs->d_id);
383 bfa_trc(port->fcs, rx_fchs->s_id); 341 bfa_trc(port->fcs, rx_fchs->s_id);
384 342
385 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 343 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
386 if (!fcxp) 344 if (!fcxp)
387 return; 345 return;
388 346
@@ -412,7 +370,7 @@ bfa_fcs_lport_send_fcgs_rjt(struct bfa_fcs_lport_s *port,
412 bfa_trc(port->fcs, rx_fchs->d_id); 370 bfa_trc(port->fcs, rx_fchs->d_id);
413 bfa_trc(port->fcs, rx_fchs->s_id); 371 bfa_trc(port->fcs, rx_fchs->s_id);
414 372
415 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 373 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
416 if (!fcxp) 374 if (!fcxp)
417 return; 375 return;
418 376
@@ -549,7 +507,7 @@ bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
549 bfa_trc(port->fcs, rx_fchs->s_id); 507 bfa_trc(port->fcs, rx_fchs->s_id);
550 bfa_trc(port->fcs, rx_fchs->d_id); 508 bfa_trc(port->fcs, rx_fchs->d_id);
551 509
552 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 510 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
553 if (!fcxp) 511 if (!fcxp)
554 return; 512 return;
555 513
@@ -594,7 +552,7 @@ bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
594 bfa_trc(port->fcs, rx_fchs->d_id); 552 bfa_trc(port->fcs, rx_fchs->d_id);
595 bfa_trc(port->fcs, rx_len); 553 bfa_trc(port->fcs, rx_len);
596 554
597 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 555 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
598 if (!fcxp) 556 if (!fcxp)
599 return; 557 return;
600 558
@@ -658,7 +616,7 @@ bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port)
658 __port_action[port->fabric->fab_type].online(port); 616 __port_action[port->fabric->fab_type].online(port);
659 617
660 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 618 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
661 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 619 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
662 "Logical port online: WWN = %s Role = %s\n", 620 "Logical port online: WWN = %s Role = %s\n",
663 lpwwn_buf, "Initiator"); 621 lpwwn_buf, "Initiator");
664 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_ONLINE); 622 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_ONLINE);
@@ -681,12 +639,12 @@ bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
681 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 639 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
682 if (bfa_sm_cmp_state(port->fabric, 640 if (bfa_sm_cmp_state(port->fabric,
683 bfa_fcs_fabric_sm_online) == BFA_TRUE) { 641 bfa_fcs_fabric_sm_online) == BFA_TRUE) {
684 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 642 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
685 "Logical port lost fabric connectivity: WWN = %s Role = %s\n", 643 "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
686 lpwwn_buf, "Initiator"); 644 lpwwn_buf, "Initiator");
687 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DISCONNECT); 645 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DISCONNECT);
688 } else { 646 } else {
689 BFA_LOG(KERN_WARNING, bfad, bfa_log_level, 647 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
690 "Logical port taken offline: WWN = %s Role = %s\n", 648 "Logical port taken offline: WWN = %s Role = %s\n",
691 lpwwn_buf, "Initiator"); 649 lpwwn_buf, "Initiator");
692 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_OFFLINE); 650 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_OFFLINE);
@@ -726,7 +684,7 @@ bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs)
726 bfa_trc(port->fcs, rx_fchs->d_id); 684 bfa_trc(port->fcs, rx_fchs->d_id);
727 bfa_trc(port->fcs, rx_fchs->s_id); 685 bfa_trc(port->fcs, rx_fchs->s_id);
728 686
729 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 687 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
730 if (!fcxp) 688 if (!fcxp)
731 return; 689 return;
732 690
@@ -751,10 +709,14 @@ bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
751 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DELETE); 709 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DELETE);
752 710
753 /* Base port will be deleted by the OS driver */ 711 /* Base port will be deleted by the OS driver */
754 if (port->vport) 712 if (port->vport) {
713 bfa_fcb_lport_delete(port->fcs->bfad, port->port_cfg.roles,
714 port->fabric->vf_drv,
715 port->vport ? port->vport->vport_drv : NULL);
755 bfa_fcs_vport_delete_comp(port->vport); 716 bfa_fcs_vport_delete_comp(port->vport);
756 else 717 } else {
757 bfa_wc_down(&port->fabric->wc); 718 bfa_wc_down(&port->fabric->wc);
719 }
758} 720}
759 721
760 722
@@ -896,25 +858,6 @@ bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s *port, u32 pid)
896} 858}
897 859
898/* 860/*
899 * OLD_PID based Lookup for a R-Port in the Port R-Port Queue
900 */
901struct bfa_fcs_rport_s *
902bfa_fcs_lport_get_rport_by_old_pid(struct bfa_fcs_lport_s *port, u32 pid)
903{
904 struct bfa_fcs_rport_s *rport;
905 struct list_head *qe;
906
907 list_for_each(qe, &port->rport_q) {
908 rport = (struct bfa_fcs_rport_s *) qe;
909 if (rport->old_pid == pid)
910 return rport;
911 }
912
913 bfa_trc(port->fcs, pid);
914 return NULL;
915}
916
917/*
918 * PWWN based Lookup for a R-Port in the Port R-Port Queue 861 * PWWN based Lookup for a R-Port in the Port R-Port Queue
919 */ 862 */
920struct bfa_fcs_rport_s * 863struct bfa_fcs_rport_s *
@@ -953,26 +896,6 @@ bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t nwwn)
953} 896}
954 897
955/* 898/*
956 * PWWN & PID based Lookup for a R-Port in the Port R-Port Queue
957 */
958struct bfa_fcs_rport_s *
959bfa_fcs_lport_get_rport_by_qualifier(struct bfa_fcs_lport_s *port,
960 wwn_t pwwn, u32 pid)
961{
962 struct bfa_fcs_rport_s *rport;
963 struct list_head *qe;
964
965 list_for_each(qe, &port->rport_q) {
966 rport = (struct bfa_fcs_rport_s *) qe;
967 if (wwn_is_equal(rport->pwwn, pwwn) && rport->pid == pid)
968 return rport;
969 }
970
971 bfa_trc(port->fcs, pwwn);
972 return NULL;
973}
974
975/*
976 * Called by rport module when new rports are discovered. 899 * Called by rport module when new rports are discovered.
977 */ 900 */
978void 901void
@@ -1020,16 +943,6 @@ bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port)
1020} 943}
1021 944
1022/* 945/*
1023 * Called by fabric for base port and by vport for virtual ports
1024 * when target mode driver is unloaded.
1025 */
1026void
1027bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port)
1028{
1029 bfa_sm_send_event(port, BFA_FCS_PORT_SM_STOP);
1030}
1031
1032/*
1033 * Called by fabric to delete base lport and associated resources. 946 * Called by fabric to delete base lport and associated resources.
1034 * 947 *
1035 * Called by vport to delete lport and associated resources. Should call 948 * Called by vport to delete lport and associated resources. Should call
@@ -1161,7 +1074,7 @@ static void
1161bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port) 1074bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port)
1162{ 1075{
1163 bfa_fcs_lport_ns_online(port); 1076 bfa_fcs_lport_ns_online(port);
1164 bfa_fcs_lport_fab_scn_online(port); 1077 bfa_fcs_lport_scn_online(port);
1165} 1078}
1166 1079
1167/* 1080/*
@@ -1255,98 +1168,6 @@ bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port)
1255 n2n_port->reply_oxid = 0; 1168 n2n_port->reply_oxid = 0;
1256} 1169}
1257 1170
1258void
1259bfa_fcport_get_loop_attr(struct bfa_fcs_lport_s *port)
1260{
1261 int i = 0, j = 0, bit = 0, alpa_bit = 0;
1262 u8 k = 0;
1263 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(port->fcs->bfa);
1264
1265 port->port_topo.ploop.alpabm_valid = fcport->alpabm_valid;
1266 port->pid = fcport->myalpa;
1267 port->pid = bfa_hton3b(port->pid);
1268
1269 for (i = 0; i < (FC_ALPA_MAX / 8); i++) {
1270 for (j = 0, alpa_bit = 0; j < 8; j++, alpa_bit++) {
1271 bfa_trc(port->fcs->bfa, fcport->alpabm.alpa_bm[i]);
1272 bit = (fcport->alpabm.alpa_bm[i] & (1 << (7 - j)));
1273 if (bit) {
1274 port->port_topo.ploop.alpa_pos_map[k] =
1275 loop_alpa_map[(i * 8) + alpa_bit];
1276 k++;
1277 bfa_trc(port->fcs->bfa, k);
1278 bfa_trc(port->fcs->bfa,
1279 port->port_topo.ploop.alpa_pos_map[k]);
1280 }
1281 }
1282 }
1283 port->port_topo.ploop.num_alpa = k;
1284}
1285
1286/*
1287 * Called by fcs/port to initialize Loop topology.
1288 */
1289static void
1290bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port)
1291{
1292}
1293
1294/*
1295 * Called by fcs/port to notify transition to online state.
1296 */
1297static void
1298bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port)
1299{
1300 u8 num_alpa = 0, alpabm_valid = 0;
1301 struct bfa_fcs_rport_s *rport;
1302 u8 *alpa_map = NULL;
1303 int i = 0;
1304 u32 pid;
1305
1306 bfa_fcport_get_loop_attr(port);
1307
1308 num_alpa = port->port_topo.ploop.num_alpa;
1309 alpabm_valid = port->port_topo.ploop.alpabm_valid;
1310 alpa_map = port->port_topo.ploop.alpa_pos_map;
1311
1312 bfa_trc(port->fcs->bfa, port->pid);
1313 bfa_trc(port->fcs->bfa, num_alpa);
1314 if (alpabm_valid == 1) {
1315 for (i = 0; i < num_alpa; i++) {
1316 bfa_trc(port->fcs->bfa, alpa_map[i]);
1317 if (alpa_map[i] != bfa_hton3b(port->pid)) {
1318 pid = alpa_map[i];
1319 bfa_trc(port->fcs->bfa, pid);
1320 rport = bfa_fcs_lport_get_rport_by_pid(port,
1321 bfa_hton3b(pid));
1322 if (!rport)
1323 rport = bfa_fcs_rport_create(port,
1324 bfa_hton3b(pid));
1325 }
1326 }
1327 } else {
1328 for (i = 0; i < MAX_ALPA_COUNT; i++) {
1329 if (alpa_map[i] != port->pid) {
1330 pid = loop_alpa_map[i];
1331 bfa_trc(port->fcs->bfa, pid);
1332 rport = bfa_fcs_lport_get_rport_by_pid(port,
1333 bfa_hton3b(pid));
1334 if (!rport)
1335 rport = bfa_fcs_rport_create(port,
1336 bfa_hton3b(pid));
1337 }
1338 }
1339 }
1340}
1341
1342/*
1343 * Called by fcs/port to notify transition to offline state.
1344 */
1345static void
1346bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port)
1347{
1348}
1349
1350#define BFA_FCS_FDMI_CMD_MAX_RETRIES 2 1171#define BFA_FCS_FDMI_CMD_MAX_RETRIES 2
1351 1172
1352/* 1173/*
@@ -1840,11 +1661,10 @@ bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1840 1661
1841 bfa_trc(port->fcs, port->port_cfg.pwwn); 1662 bfa_trc(port->fcs, port->port_cfg.pwwn);
1842 1663
1843 fcxp = fcxp_alloced ? fcxp_alloced : 1664 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
1844 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1845 if (!fcxp) { 1665 if (!fcxp) {
1846 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 1666 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
1847 bfa_fcs_lport_fdmi_send_rhba, fdmi, BFA_TRUE); 1667 bfa_fcs_lport_fdmi_send_rhba, fdmi);
1848 return; 1668 return;
1849 } 1669 }
1850 fdmi->fcxp = fcxp; 1670 fdmi->fcxp = fcxp;
@@ -2014,10 +1834,13 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
2014 sizeof(templen)); 1834 sizeof(templen));
2015 } 1835 }
2016 1836
1837 /*
1838 * f/w Version = driver version
1839 */
2017 attr = (struct fdmi_attr_s *) curr_ptr; 1840 attr = (struct fdmi_attr_s *) curr_ptr;
2018 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION); 1841 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION);
2019 templen = (u16) strlen(fcs_hba_attr->fw_version); 1842 templen = (u16) strlen(fcs_hba_attr->driver_version);
2020 memcpy(attr->value, fcs_hba_attr->fw_version, templen); 1843 memcpy(attr->value, fcs_hba_attr->driver_version, templen);
2021 templen = fc_roundup(templen, sizeof(u32)); 1844 templen = fc_roundup(templen, sizeof(u32));
2022 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen; 1845 curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2023 len += templen; 1846 len += templen;
@@ -2112,11 +1935,10 @@ bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2112 1935
2113 bfa_trc(port->fcs, port->port_cfg.pwwn); 1936 bfa_trc(port->fcs, port->port_cfg.pwwn);
2114 1937
2115 fcxp = fcxp_alloced ? fcxp_alloced : 1938 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
2116 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
2117 if (!fcxp) { 1939 if (!fcxp) {
2118 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 1940 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
2119 bfa_fcs_lport_fdmi_send_rprt, fdmi, BFA_TRUE); 1941 bfa_fcs_lport_fdmi_send_rprt, fdmi);
2120 return; 1942 return;
2121 } 1943 }
2122 fdmi->fcxp = fcxp; 1944 fdmi->fcxp = fcxp;
@@ -2328,11 +2150,10 @@ bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2328 2150
2329 bfa_trc(port->fcs, port->port_cfg.pwwn); 2151 bfa_trc(port->fcs, port->port_cfg.pwwn);
2330 2152
2331 fcxp = fcxp_alloced ? fcxp_alloced : 2153 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
2332 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
2333 if (!fcxp) { 2154 if (!fcxp) {
2334 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe, 2155 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
2335 bfa_fcs_lport_fdmi_send_rpa, fdmi, BFA_TRUE); 2156 bfa_fcs_lport_fdmi_send_rpa, fdmi);
2336 return; 2157 return;
2337 } 2158 }
2338 fdmi->fcxp = fcxp; 2159 fdmi->fcxp = fcxp;
@@ -2419,7 +2240,6 @@ bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
2419{ 2240{
2420 struct bfa_fcs_lport_s *port = fdmi->ms->port; 2241 struct bfa_fcs_lport_s *port = fdmi->ms->port;
2421 struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info; 2242 struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
2422 struct bfa_fcs_fdmi_port_attr_s fcs_port_attr;
2423 2243
2424 memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s)); 2244 memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s));
2425 2245
@@ -2455,9 +2275,7 @@ bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
2455 sizeof(driver_info->host_os_patch)); 2275 sizeof(driver_info->host_os_patch));
2456 } 2276 }
2457 2277
2458 /* Retrieve the max frame size from the port attr */ 2278 hba_attr->max_ct_pyld = cpu_to_be32(FC_MAX_PDUSZ);
2459 bfa_fcs_fdmi_get_portattr(fdmi, &fcs_port_attr);
2460 hba_attr->max_ct_pyld = fcs_port_attr.max_frm_size;
2461} 2279}
2462 2280
2463static void 2281static void
@@ -2517,7 +2335,7 @@ bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
2517 /* 2335 /*
2518 * Max PDU Size. 2336 * Max PDU Size.
2519 */ 2337 */
2520 port_attr->max_frm_size = cpu_to_be32(pport_attr.pport_cfg.maxfrsize); 2338 port_attr->max_frm_size = cpu_to_be32(FC_MAX_PDUSZ);
2521 2339
2522 /* 2340 /*
2523 * OS device Name 2341 * OS device Name
@@ -2922,11 +2740,10 @@ bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2922 2740
2923 bfa_trc(port->fcs, port->pid); 2741 bfa_trc(port->fcs, port->pid);
2924 2742
2925 fcxp = fcxp_alloced ? fcxp_alloced : 2743 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
2926 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
2927 if (!fcxp) { 2744 if (!fcxp) {
2928 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 2745 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
2929 bfa_fcs_lport_ms_send_gmal, ms, BFA_TRUE); 2746 bfa_fcs_lport_ms_send_gmal, ms);
2930 return; 2747 return;
2931 } 2748 }
2932 ms->fcxp = fcxp; 2749 ms->fcxp = fcxp;
@@ -3123,11 +2940,10 @@ bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3123 2940
3124 bfa_trc(port->fcs, port->pid); 2941 bfa_trc(port->fcs, port->pid);
3125 2942
3126 fcxp = fcxp_alloced ? fcxp_alloced : 2943 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
3127 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3128 if (!fcxp) { 2944 if (!fcxp) {
3129 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 2945 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
3130 bfa_fcs_lport_ms_send_gfn, ms, BFA_TRUE); 2946 bfa_fcs_lport_ms_send_gfn, ms);
3131 return; 2947 return;
3132 } 2948 }
3133 ms->fcxp = fcxp; 2949 ms->fcxp = fcxp;
@@ -3200,12 +3016,11 @@ bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3200 3016
3201 bfa_trc(port->fcs, port->pid); 3017 bfa_trc(port->fcs, port->pid);
3202 3018
3203 fcxp = fcxp_alloced ? fcxp_alloced : 3019 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
3204 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3205 if (!fcxp) { 3020 if (!fcxp) {
3206 port->stats.ms_plogi_alloc_wait++; 3021 port->stats.ms_plogi_alloc_wait++;
3207 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe, 3022 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
3208 bfa_fcs_lport_ms_send_plogi, ms, BFA_TRUE); 3023 bfa_fcs_lport_ms_send_plogi, ms);
3209 return; 3024 return;
3210 } 3025 }
3211 ms->fcxp = fcxp; 3026 ms->fcxp = fcxp;
@@ -3355,10 +3170,6 @@ static void bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg,
3355 struct bfa_fcxp_s *fcxp_alloced); 3170 struct bfa_fcxp_s *fcxp_alloced);
3356static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, 3171static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg,
3357 struct bfa_fcxp_s *fcxp_alloced); 3172 struct bfa_fcxp_s *fcxp_alloced);
3358static void bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg,
3359 struct bfa_fcxp_s *fcxp_alloced);
3360static void bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg,
3361 struct bfa_fcxp_s *fcxp_alloced);
3362static void bfa_fcs_lport_ns_timeout(void *arg); 3173static void bfa_fcs_lport_ns_timeout(void *arg);
3363static void bfa_fcs_lport_ns_plogi_response(void *fcsarg, 3174static void bfa_fcs_lport_ns_plogi_response(void *fcsarg,
3364 struct bfa_fcxp_s *fcxp, 3175 struct bfa_fcxp_s *fcxp,
@@ -3395,20 +3206,6 @@ static void bfa_fcs_lport_ns_gid_ft_response(void *fcsarg,
3395 u32 rsp_len, 3206 u32 rsp_len,
3396 u32 resid_len, 3207 u32 resid_len,
3397 struct fchs_s *rsp_fchs); 3208 struct fchs_s *rsp_fchs);
3398static void bfa_fcs_lport_ns_rnn_id_response(void *fcsarg,
3399 struct bfa_fcxp_s *fcxp,
3400 void *cbarg,
3401 bfa_status_t req_status,
3402 u32 rsp_len,
3403 u32 resid_len,
3404 struct fchs_s *rsp_fchs);
3405static void bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg,
3406 struct bfa_fcxp_s *fcxp,
3407 void *cbarg,
3408 bfa_status_t req_status,
3409 u32 rsp_len,
3410 u32 resid_len,
3411 struct fchs_s *rsp_fchs);
3412static void bfa_fcs_lport_ns_process_gidft_pids( 3209static void bfa_fcs_lport_ns_process_gidft_pids(
3413 struct bfa_fcs_lport_s *port, 3210 struct bfa_fcs_lport_s *port,
3414 u32 *pid_buf, u32 n_pids); 3211 u32 *pid_buf, u32 n_pids);
@@ -3433,8 +3230,6 @@ enum vport_ns_event {
3433 NSSM_EVENT_RFTID_SENT = 9, 3230 NSSM_EVENT_RFTID_SENT = 9,
3434 NSSM_EVENT_RFFID_SENT = 10, 3231 NSSM_EVENT_RFFID_SENT = 10,
3435 NSSM_EVENT_GIDFT_SENT = 11, 3232 NSSM_EVENT_GIDFT_SENT = 11,
3436 NSSM_EVENT_RNNID_SENT = 12,
3437 NSSM_EVENT_RSNN_NN_SENT = 13,
3438}; 3233};
3439 3234
3440static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns, 3235static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
@@ -3475,21 +3270,6 @@ static void bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
3475 enum vport_ns_event event); 3270 enum vport_ns_event event);
3476static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns, 3271static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
3477 enum vport_ns_event event); 3272 enum vport_ns_event event);
3478static void bfa_fcs_lport_ns_sm_sending_rnn_id(
3479 struct bfa_fcs_lport_ns_s *ns,
3480 enum vport_ns_event event);
3481static void bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3482 enum vport_ns_event event);
3483static void bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3484 enum vport_ns_event event);
3485static void bfa_fcs_lport_ns_sm_sending_rsnn_nn(
3486 struct bfa_fcs_lport_ns_s *ns,
3487 enum vport_ns_event event);
3488static void bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3489 enum vport_ns_event event);
3490static void bfa_fcs_lport_ns_sm_rsnn_nn_retry(
3491 struct bfa_fcs_lport_ns_s *ns,
3492 enum vport_ns_event event);
3493/* 3273/*
3494 * Start in offline state - awaiting linkup 3274 * Start in offline state - awaiting linkup
3495 */ 3275 */
@@ -3557,9 +3337,8 @@ bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
3557 break; 3337 break;
3558 3338
3559 case NSSM_EVENT_RSP_OK: 3339 case NSSM_EVENT_RSP_OK:
3560 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id); 3340 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
3561 ns->num_rnnid_retries = 0; 3341 bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
3562 bfa_fcs_lport_ns_send_rnn_id(ns, NULL);
3563 break; 3342 break;
3564 3343
3565 case NSSM_EVENT_PORT_OFFLINE: 3344 case NSSM_EVENT_PORT_OFFLINE:
@@ -3599,176 +3378,6 @@ bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
3599} 3378}
3600 3379
3601static void 3380static void
3602bfa_fcs_lport_ns_sm_sending_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3603 enum vport_ns_event event)
3604{
3605 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3606 bfa_trc(ns->port->fcs, event);
3607
3608 switch (event) {
3609 case NSSM_EVENT_RNNID_SENT:
3610 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id);
3611 break;
3612
3613 case NSSM_EVENT_PORT_OFFLINE:
3614 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3615 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3616 &ns->fcxp_wqe);
3617 break;
3618 default:
3619 bfa_sm_fault(ns->port->fcs, event);
3620 }
3621}
3622
3623static void
3624bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3625 enum vport_ns_event event)
3626{
3627 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3628 bfa_trc(ns->port->fcs, event);
3629
3630 switch (event) {
3631 case NSSM_EVENT_RSP_OK:
3632 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
3633 ns->num_rnnid_retries = 0;
3634 ns->num_rsnn_nn_retries = 0;
3635 bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL);
3636 break;
3637
3638 case NSSM_EVENT_RSP_ERROR:
3639 if (ns->num_rnnid_retries < BFA_FCS_MAX_NS_RETRIES) {
3640 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id_retry);
3641 ns->port->stats.ns_retries++;
3642 ns->num_rnnid_retries++;
3643 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3644 &ns->timer, bfa_fcs_lport_ns_timeout, ns,
3645 BFA_FCS_RETRY_TIMEOUT);
3646 } else {
3647 bfa_sm_set_state(ns,
3648 bfa_fcs_lport_ns_sm_sending_rspn_id);
3649 bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
3650 }
3651 break;
3652
3653 case NSSM_EVENT_PORT_OFFLINE:
3654 bfa_fcxp_discard(ns->fcxp);
3655 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3656 break;
3657
3658 default:
3659 bfa_sm_fault(ns->port->fcs, event);
3660 }
3661}
3662
3663static void
3664bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3665 enum vport_ns_event event)
3666{
3667 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3668 bfa_trc(ns->port->fcs, event);
3669
3670 switch (event) {
3671 case NSSM_EVENT_TIMEOUT:
3672 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id);
3673 bfa_fcs_lport_ns_send_rnn_id(ns, NULL);
3674 break;
3675
3676 case NSSM_EVENT_PORT_OFFLINE:
3677 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3678 bfa_timer_stop(&ns->timer);
3679 break;
3680
3681 default:
3682 bfa_sm_fault(ns->port->fcs, event);
3683 }
3684}
3685
3686static void
3687bfa_fcs_lport_ns_sm_sending_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3688 enum vport_ns_event event)
3689{
3690 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3691 bfa_trc(ns->port->fcs, event);
3692
3693 switch (event) {
3694 case NSSM_EVENT_RSNN_NN_SENT:
3695 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn);
3696 break;
3697
3698 case NSSM_EVENT_PORT_OFFLINE:
3699 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3700 bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3701 &ns->fcxp_wqe);
3702 break;
3703
3704 default:
3705 bfa_sm_fault(ns->port->fcs, event);
3706 }
3707}
3708
3709static void
3710bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3711 enum vport_ns_event event)
3712{
3713 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3714 bfa_trc(ns->port->fcs, event);
3715
3716 switch (event) {
3717 case NSSM_EVENT_RSP_OK:
3718 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
3719 ns->num_rsnn_nn_retries = 0;
3720 bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
3721 break;
3722
3723 case NSSM_EVENT_RSP_ERROR:
3724 if (ns->num_rsnn_nn_retries < BFA_FCS_MAX_NS_RETRIES) {
3725 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn_retry);
3726 ns->port->stats.ns_retries++;
3727 ns->num_rsnn_nn_retries++;
3728 bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3729 &ns->timer, bfa_fcs_lport_ns_timeout,
3730 ns, BFA_FCS_RETRY_TIMEOUT);
3731 } else {
3732 bfa_sm_set_state(ns,
3733 bfa_fcs_lport_ns_sm_sending_rspn_id);
3734 bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
3735 }
3736 break;
3737
3738 case NSSM_EVENT_PORT_OFFLINE:
3739 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3740 bfa_fcxp_discard(ns->fcxp);
3741 break;
3742
3743 default:
3744 bfa_sm_fault(ns->port->fcs, event);
3745 }
3746}
3747
3748static void
3749bfa_fcs_lport_ns_sm_rsnn_nn_retry(struct bfa_fcs_lport_ns_s *ns,
3750 enum vport_ns_event event)
3751{
3752 bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3753 bfa_trc(ns->port->fcs, event);
3754
3755 switch (event) {
3756 case NSSM_EVENT_TIMEOUT:
3757 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
3758 bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL);
3759 break;
3760
3761 case NSSM_EVENT_PORT_OFFLINE:
3762 bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3763 bfa_timer_stop(&ns->timer);
3764 break;
3765
3766 default:
3767 bfa_sm_fault(ns->port->fcs, event);
3768 }
3769}
3770
3771static void
3772bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns, 3381bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns,
3773 enum vport_ns_event event) 3382 enum vport_ns_event event)
3774{ 3383{
@@ -4165,12 +3774,11 @@ bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4165 3774
4166 bfa_trc(port->fcs, port->pid); 3775 bfa_trc(port->fcs, port->pid);
4167 3776
4168 fcxp = fcxp_alloced ? fcxp_alloced : 3777 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
4169 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4170 if (!fcxp) { 3778 if (!fcxp) {
4171 port->stats.ns_plogi_alloc_wait++; 3779 port->stats.ns_plogi_alloc_wait++;
4172 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 3780 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4173 bfa_fcs_lport_ns_send_plogi, ns, BFA_TRUE); 3781 bfa_fcs_lport_ns_send_plogi, ns);
4174 return; 3782 return;
4175 } 3783 }
4176 ns->fcxp = fcxp; 3784 ns->fcxp = fcxp;
@@ -4249,162 +3857,6 @@ bfa_fcs_lport_ns_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4249} 3857}
4250 3858
4251/* 3859/*
4252 * Register node name for port_id
4253 */
4254static void
4255bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4256{
4257 struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4258 struct bfa_fcs_lport_s *port = ns->port;
4259 struct fchs_s fchs;
4260 int len;
4261 struct bfa_fcxp_s *fcxp;
4262
4263 bfa_trc(port->fcs, port->port_cfg.pwwn);
4264
4265 fcxp = fcxp_alloced ? fcxp_alloced :
4266 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4267 if (!fcxp) {
4268 port->stats.ns_rnnid_alloc_wait++;
4269 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4270 bfa_fcs_lport_ns_send_rnn_id, ns, BFA_TRUE);
4271 return;
4272 }
4273
4274 ns->fcxp = fcxp;
4275
4276 len = fc_rnnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
4277 bfa_fcs_lport_get_fcid(port),
4278 bfa_fcs_lport_get_fcid(port),
4279 bfa_fcs_lport_get_nwwn(port));
4280
4281 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
4282 FC_CLASS_3, len, &fchs,
4283 bfa_fcs_lport_ns_rnn_id_response, (void *)ns,
4284 FC_MAX_PDUSZ, FC_FCCT_TOV);
4285
4286 port->stats.ns_rnnid_sent++;
4287 bfa_sm_send_event(ns, NSSM_EVENT_RNNID_SENT);
4288}
4289
4290static void
4291bfa_fcs_lport_ns_rnn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4292 void *cbarg, bfa_status_t req_status,
4293 u32 rsp_len, u32 resid_len,
4294 struct fchs_s *rsp_fchs)
4295
4296{
4297 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4298 struct bfa_fcs_lport_s *port = ns->port;
4299 struct ct_hdr_s *cthdr = NULL;
4300
4301 bfa_trc(port->fcs, port->port_cfg.pwwn);
4302
4303 /*
4304 * Sanity Checks
4305 */
4306 if (req_status != BFA_STATUS_OK) {
4307 bfa_trc(port->fcs, req_status);
4308 port->stats.ns_rnnid_rsp_err++;
4309 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4310 return;
4311 }
4312
4313 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4314 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4315
4316 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4317 port->stats.ns_rnnid_accepts++;
4318 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4319 return;
4320 }
4321
4322 port->stats.ns_rnnid_rejects++;
4323 bfa_trc(port->fcs, cthdr->reason_code);
4324 bfa_trc(port->fcs, cthdr->exp_code);
4325 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4326}
4327
4328/*
4329 * Register the symbolic node name for a given node name.
4330 */
4331static void
4332bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4333{
4334 struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4335 struct bfa_fcs_lport_s *port = ns->port;
4336 struct fchs_s fchs;
4337 int len;
4338 struct bfa_fcxp_s *fcxp;
4339 u8 *nsymbl;
4340
4341 bfa_trc(port->fcs, port->port_cfg.pwwn);
4342
4343 fcxp = fcxp_alloced ? fcxp_alloced :
4344 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4345 if (!fcxp) {
4346 port->stats.ns_rsnn_nn_alloc_wait++;
4347 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4348 bfa_fcs_lport_ns_send_rsnn_nn, ns, BFA_TRUE);
4349 return;
4350 }
4351 ns->fcxp = fcxp;
4352
4353 nsymbl = (u8 *) &(bfa_fcs_lport_get_nsym_name(
4354 bfa_fcs_get_base_port(port->fcs)));
4355
4356 len = fc_rsnn_nn_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
4357 bfa_fcs_lport_get_fcid(port),
4358 bfa_fcs_lport_get_nwwn(port), nsymbl);
4359
4360 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
4361 FC_CLASS_3, len, &fchs,
4362 bfa_fcs_lport_ns_rsnn_nn_response, (void *)ns,
4363 FC_MAX_PDUSZ, FC_FCCT_TOV);
4364
4365 port->stats.ns_rsnn_nn_sent++;
4366
4367 bfa_sm_send_event(ns, NSSM_EVENT_RSNN_NN_SENT);
4368}
4369
4370static void
4371bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4372 void *cbarg, bfa_status_t req_status,
4373 u32 rsp_len, u32 resid_len,
4374 struct fchs_s *rsp_fchs)
4375{
4376 struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4377 struct bfa_fcs_lport_s *port = ns->port;
4378 struct ct_hdr_s *cthdr = NULL;
4379
4380 bfa_trc(port->fcs, port->port_cfg.pwwn);
4381
4382 /*
4383 * Sanity Checks
4384 */
4385 if (req_status != BFA_STATUS_OK) {
4386 bfa_trc(port->fcs, req_status);
4387 port->stats.ns_rsnn_nn_rsp_err++;
4388 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4389 return;
4390 }
4391
4392 cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4393 cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4394
4395 if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4396 port->stats.ns_rsnn_nn_accepts++;
4397 bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4398 return;
4399 }
4400
4401 port->stats.ns_rsnn_nn_rejects++;
4402 bfa_trc(port->fcs, cthdr->reason_code);
4403 bfa_trc(port->fcs, cthdr->exp_code);
4404 bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4405}
4406
4407/*
4408 * Register the symbolic port name. 3860 * Register the symbolic port name.
4409 */ 3861 */
4410static void 3862static void
@@ -4422,12 +3874,11 @@ bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4422 3874
4423 bfa_trc(port->fcs, port->port_cfg.pwwn); 3875 bfa_trc(port->fcs, port->port_cfg.pwwn);
4424 3876
4425 fcxp = fcxp_alloced ? fcxp_alloced : 3877 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
4426 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4427 if (!fcxp) { 3878 if (!fcxp) {
4428 port->stats.ns_rspnid_alloc_wait++; 3879 port->stats.ns_rspnid_alloc_wait++;
4429 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 3880 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4430 bfa_fcs_lport_ns_send_rspn_id, ns, BFA_TRUE); 3881 bfa_fcs_lport_ns_send_rspn_id, ns);
4431 return; 3882 return;
4432 } 3883 }
4433 ns->fcxp = fcxp; 3884 ns->fcxp = fcxp;
@@ -4524,12 +3975,11 @@ bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4524 3975
4525 bfa_trc(port->fcs, port->port_cfg.pwwn); 3976 bfa_trc(port->fcs, port->port_cfg.pwwn);
4526 3977
4527 fcxp = fcxp_alloced ? fcxp_alloced : 3978 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
4528 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4529 if (!fcxp) { 3979 if (!fcxp) {
4530 port->stats.ns_rftid_alloc_wait++; 3980 port->stats.ns_rftid_alloc_wait++;
4531 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 3981 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4532 bfa_fcs_lport_ns_send_rft_id, ns, BFA_TRUE); 3982 bfa_fcs_lport_ns_send_rft_id, ns);
4533 return; 3983 return;
4534 } 3984 }
4535 ns->fcxp = fcxp; 3985 ns->fcxp = fcxp;
@@ -4598,12 +4048,11 @@ bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4598 4048
4599 bfa_trc(port->fcs, port->port_cfg.pwwn); 4049 bfa_trc(port->fcs, port->port_cfg.pwwn);
4600 4050
4601 fcxp = fcxp_alloced ? fcxp_alloced : 4051 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
4602 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4603 if (!fcxp) { 4052 if (!fcxp) {
4604 port->stats.ns_rffid_alloc_wait++; 4053 port->stats.ns_rffid_alloc_wait++;
4605 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4054 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4606 bfa_fcs_lport_ns_send_rff_id, ns, BFA_TRUE); 4055 bfa_fcs_lport_ns_send_rff_id, ns);
4607 return; 4056 return;
4608 } 4057 }
4609 ns->fcxp = fcxp; 4058 ns->fcxp = fcxp;
@@ -4682,12 +4131,11 @@ bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4682 4131
4683 bfa_trc(port->fcs, port->pid); 4132 bfa_trc(port->fcs, port->pid);
4684 4133
4685 fcxp = fcxp_alloced ? fcxp_alloced : 4134 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
4686 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4687 if (!fcxp) { 4135 if (!fcxp) {
4688 port->stats.ns_gidft_alloc_wait++; 4136 port->stats.ns_gidft_alloc_wait++;
4689 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe, 4137 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4690 bfa_fcs_lport_ns_send_gid_ft, ns, BFA_TRUE); 4138 bfa_fcs_lport_ns_send_gid_ft, ns);
4691 return; 4139 return;
4692 } 4140 }
4693 ns->fcxp = fcxp; 4141 ns->fcxp = fcxp;
@@ -4817,10 +4265,6 @@ bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
4817 struct fcgs_gidft_resp_s *gidft_entry; 4265 struct fcgs_gidft_resp_s *gidft_entry;
4818 struct bfa_fcs_rport_s *rport; 4266 struct bfa_fcs_rport_s *rport;
4819 u32 ii; 4267 u32 ii;
4820 struct bfa_fcs_fabric_s *fabric = port->fabric;
4821 struct bfa_fcs_vport_s *vport;
4822 struct list_head *qe;
4823 u8 found = 0;
4824 4268
4825 for (ii = 0; ii < n_pids; ii++) { 4269 for (ii = 0; ii < n_pids; ii++) {
4826 gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii]; 4270 gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii];
@@ -4829,29 +4273,6 @@ bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
4829 continue; 4273 continue;
4830 4274
4831 /* 4275 /*
4832 * Ignore PID if it is of base port
4833 * (Avoid vports discovering base port as remote port)
4834 */
4835 if (gidft_entry->pid == fabric->bport.pid)
4836 continue;
4837
4838 /*
4839 * Ignore PID if it is of vport created on the same base port
4840 * (Avoid vport discovering every other vport created on the
4841 * same port as remote port)
4842 */
4843 list_for_each(qe, &fabric->vport_q) {
4844 vport = (struct bfa_fcs_vport_s *) qe;
4845 if (vport->lport.pid == gidft_entry->pid)
4846 found = 1;
4847 }
4848
4849 if (found) {
4850 found = 0;
4851 continue;
4852 }
4853
4854 /*
4855 * Check if this rport already exists 4276 * Check if this rport already exists
4856 */ 4277 */
4857 rport = bfa_fcs_lport_get_rport_by_pid(port, gidft_entry->pid); 4278 rport = bfa_fcs_lport_get_rport_by_pid(port, gidft_entry->pid);
@@ -4918,8 +4339,7 @@ bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port)
4918 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port); 4339 struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
4919 4340
4920 bfa_trc(port->fcs, port->pid); 4341 bfa_trc(port->fcs, port->pid);
4921 if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_online)) 4342 bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
4922 bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
4923} 4343}
4924 4344
4925static void 4345static void
@@ -4939,70 +4359,6 @@ bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
4939 } 4359 }
4940} 4360}
4941 4361
4942void
4943bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg, struct bfa_fcxp_s *fcxp_alloced)
4944{
4945 struct bfa_fcs_lport_ns_s *ns = cbarg;
4946 struct bfa_fcs_lport_s *port = ns->port;
4947 struct fchs_s fchs;
4948 struct bfa_fcxp_s *fcxp;
4949 u8 symbl[256];
4950 u8 *psymbl = &symbl[0];
4951 int len;
4952
4953 if (!bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
4954 return;
4955
4956 /* Avoid sending RSPN in the following states. */
4957 if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_offline) ||
4958 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_sending) ||
4959 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi) ||
4960 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_retry) ||
4961 bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry))
4962 return;
4963
4964 memset(symbl, 0, sizeof(symbl));
4965 bfa_trc(port->fcs, port->port_cfg.pwwn);
4966
4967 fcxp = fcxp_alloced ? fcxp_alloced :
4968 bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
4969 if (!fcxp) {
4970 port->stats.ns_rspnid_alloc_wait++;
4971 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4972 bfa_fcs_lport_ns_util_send_rspn_id, ns, BFA_FALSE);
4973 return;
4974 }
4975
4976 ns->fcxp = fcxp;
4977
4978 if (port->vport) {
4979 /*
4980 * For Vports, we append the vport's port symbolic name
4981 * to that of the base port.
4982 */
4983 strncpy((char *)psymbl, (char *)&(bfa_fcs_lport_get_psym_name
4984 (bfa_fcs_get_base_port(port->fcs))),
4985 strlen((char *)&bfa_fcs_lport_get_psym_name(
4986 bfa_fcs_get_base_port(port->fcs))));
4987
4988 /* Ensure we have a null terminating string. */
4989 ((char *)psymbl)[strlen((char *)&bfa_fcs_lport_get_psym_name(
4990 bfa_fcs_get_base_port(port->fcs)))] = 0;
4991
4992 strncat((char *)psymbl,
4993 (char *)&(bfa_fcs_lport_get_psym_name(port)),
4994 strlen((char *)&bfa_fcs_lport_get_psym_name(port)));
4995 }
4996
4997 len = fc_rspnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
4998 bfa_fcs_lport_get_fcid(port), 0, psymbl);
4999
5000 bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
5001 FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
5002
5003 port->stats.ns_rspnid_sent++;
5004}
5005
5006/* 4362/*
5007 * FCS SCN 4363 * FCS SCN
5008 */ 4364 */
@@ -5177,11 +4533,10 @@ bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced)
5177 bfa_trc(port->fcs, port->pid); 4533 bfa_trc(port->fcs, port->pid);
5178 bfa_trc(port->fcs, port->port_cfg.pwwn); 4534 bfa_trc(port->fcs, port->port_cfg.pwwn);
5179 4535
5180 fcxp = fcxp_alloced ? fcxp_alloced : 4536 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
5181 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
5182 if (!fcxp) { 4537 if (!fcxp) {
5183 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe, 4538 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe,
5184 bfa_fcs_lport_scn_send_scr, scn, BFA_TRUE); 4539 bfa_fcs_lport_scn_send_scr, scn);
5185 return; 4540 return;
5186 } 4541 }
5187 scn->fcxp = fcxp; 4542 scn->fcxp = fcxp;
@@ -5263,7 +4618,7 @@ bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
5263 4618
5264 bfa_trc(port->fcs, rx_fchs->s_id); 4619 bfa_trc(port->fcs, rx_fchs->s_id);
5265 4620
5266 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 4621 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
5267 if (!fcxp) 4622 if (!fcxp)
5268 return; 4623 return;
5269 4624
@@ -5325,7 +4680,7 @@ bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *port)
5325} 4680}
5326 4681
5327void 4682void
5328bfa_fcs_lport_fab_scn_online(struct bfa_fcs_lport_s *port) 4683bfa_fcs_lport_scn_online(struct bfa_fcs_lport_s *port)
5329{ 4684{
5330 struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port); 4685 struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
5331 4686
@@ -5337,33 +4692,14 @@ static void
5337bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid) 4692bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid)
5338{ 4693{
5339 struct bfa_fcs_rport_s *rport; 4694 struct bfa_fcs_rport_s *rport;
5340 struct bfa_fcs_fabric_s *fabric = port->fabric;
5341 struct bfa_fcs_vport_s *vport;
5342 struct list_head *qe;
5343 4695
5344 bfa_trc(port->fcs, rpid); 4696 bfa_trc(port->fcs, rpid);
5345 4697
5346 /* 4698 /*
5347 * Ignore PID if it is of base port or of vports created on the
5348 * same base port. It is to avoid vports discovering base port or
5349 * other vports created on same base port as remote port
5350 */
5351 if (rpid == fabric->bport.pid)
5352 return;
5353
5354 list_for_each(qe, &fabric->vport_q) {
5355 vport = (struct bfa_fcs_vport_s *) qe;
5356 if (vport->lport.pid == rpid)
5357 return;
5358 }
5359 /*
5360 * If this is an unknown device, then it just came online. 4699 * If this is an unknown device, then it just came online.
5361 * Otherwise let rport handle the RSCN event. 4700 * Otherwise let rport handle the RSCN event.
5362 */ 4701 */
5363 rport = bfa_fcs_lport_get_rport_by_pid(port, rpid); 4702 rport = bfa_fcs_lport_get_rport_by_pid(port, rpid);
5364 if (!rport)
5365 rport = bfa_fcs_lport_get_rport_by_old_pid(port, rpid);
5366
5367 if (rport == NULL) { 4703 if (rport == NULL) {
5368 /* 4704 /*
5369 * If min cfg mode is enabled, we donot need to 4705 * If min cfg mode is enabled, we donot need to
@@ -5556,15 +4892,15 @@ bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index,
5556} 4892}
5557 4893
5558void 4894void
5559bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port, 4895bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
5560 struct bfa_rport_qualifier_s rports[], int *nrports) 4896 wwn_t rport_wwns[], int *nrports)
5561{ 4897{
5562 struct list_head *qh, *qe; 4898 struct list_head *qh, *qe;
5563 struct bfa_fcs_rport_s *rport = NULL; 4899 struct bfa_fcs_rport_s *rport = NULL;
5564 int i; 4900 int i;
5565 struct bfa_fcs_s *fcs; 4901 struct bfa_fcs_s *fcs;
5566 4902
5567 if (port == NULL || rports == NULL || *nrports == 0) 4903 if (port == NULL || rport_wwns == NULL || *nrports == 0)
5568 return; 4904 return;
5569 4905
5570 fcs = port->fcs; 4906 fcs = port->fcs;
@@ -5584,13 +4920,7 @@ bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port,
5584 continue; 4920 continue;
5585 } 4921 }
5586 4922
5587 if (!rport->pwwn && !rport->pid) { 4923 rport_wwns[i] = rport->pwwn;
5588 qe = bfa_q_next(qe);
5589 continue;
5590 }
5591
5592 rports[i].pwwn = rport->pwwn;
5593 rports[i].pid = rport->pid;
5594 4924
5595 i++; 4925 i++;
5596 qe = bfa_q_next(qe); 4926 qe = bfa_q_next(qe);
@@ -5747,15 +5077,6 @@ bfa_fcs_lport_clear_stats(struct bfa_fcs_lport_s *fcs_port)
5747} 5077}
5748 5078
5749/* 5079/*
5750 * Let new loop map create missing rports
5751 */
5752void
5753bfa_fcs_lport_lip_scn_online(struct bfa_fcs_lport_s *port)
5754{
5755 bfa_fcs_lport_loop_online(port);
5756}
5757
5758/*
5759 * FCS virtual port state machine 5080 * FCS virtual port state machine
5760 */ 5081 */
5761 5082
@@ -6393,21 +5714,15 @@ bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport)
6393 (struct bfad_vport_s *)vport->vport_drv; 5714 (struct bfad_vport_s *)vport->vport_drv;
6394 5715
6395 bfa_fcs_fabric_delvport(__vport_fabric(vport), vport); 5716 bfa_fcs_fabric_delvport(__vport_fabric(vport), vport);
6396 bfa_lps_delete(vport->lps);
6397 5717
6398 if (vport_drv->comp_del) { 5718 if (vport_drv->comp_del)
6399 complete(vport_drv->comp_del); 5719 complete(vport_drv->comp_del);
6400 return;
6401 }
6402 5720
6403 /* 5721 bfa_lps_delete(vport->lps);
6404 * We queue the vport delete work to the IM work_q from here.
6405 * The memory for the bfad_vport_s is freed from the FC function
6406 * template vport_delete entry point.
6407 */
6408 bfad_im_port_delete(vport_drv->drv_port.bfad, &vport_drv->drv_port);
6409} 5722}
6410 5723
5724
5725
6411/* 5726/*
6412 * fcs_vport_public FCS virtual port public interfaces 5727 * fcs_vport_public FCS virtual port public interfaces
6413 */ 5728 */
@@ -6443,16 +5758,6 @@ bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport)
6443{ 5758{
6444 vport->vport_stats.fab_cleanup++; 5759 vport->vport_stats.fab_cleanup++;
6445} 5760}
6446
6447/*
6448 * Stop notification from fabric SM. To be invoked from within FCS.
6449 */
6450void
6451bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport)
6452{
6453 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP);
6454}
6455
6456/* 5761/*
6457 * delete notification from fabric SM. To be invoked from within FCS. 5762 * delete notification from fabric SM. To be invoked from within FCS.
6458 */ 5763 */
diff --git a/drivers/scsi/bfa/bfa_fcs_rport.c b/drivers/scsi/bfa/bfa_fcs_rport.c
index 58ac643ba9f..52628d5d3c9 100644
--- a/drivers/scsi/bfa/bfa_fcs_rport.c
+++ b/drivers/scsi/bfa/bfa_fcs_rport.c
@@ -30,22 +30,14 @@ static u32
30bfa_fcs_rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT * 1000; 30bfa_fcs_rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT * 1000;
31 /* In millisecs */ 31 /* In millisecs */
32/* 32/*
33 * bfa_fcs_rport_max_logins is max count of bfa_fcs_rports
34 * whereas DEF_CFG_NUM_RPORTS is max count of bfa_rports
35 */
36static u32 bfa_fcs_rport_max_logins = BFA_FCS_MAX_RPORT_LOGINS;
37
38/*
39 * forward declarations 33 * forward declarations
40 */ 34 */
41static struct bfa_fcs_rport_s *bfa_fcs_rport_alloc( 35static struct bfa_fcs_rport_s *bfa_fcs_rport_alloc(
42 struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid); 36 struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid);
43static void bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport); 37static void bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport);
44static void bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport); 38static void bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport);
45static void bfa_fcs_rport_fcs_online_action(struct bfa_fcs_rport_s *rport); 39static void bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport);
46static void bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport); 40static void bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport);
47static void bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport);
48static void bfa_fcs_rport_hal_offline_action(struct bfa_fcs_rport_s *rport);
49static void bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, 41static void bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport,
50 struct fc_logi_s *plogi); 42 struct fc_logi_s *plogi);
51static void bfa_fcs_rport_timeout(void *arg); 43static void bfa_fcs_rport_timeout(void *arg);
@@ -84,7 +76,6 @@ static void bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport,
84static void bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport, 76static void bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
85 struct fchs_s *rx_fchs, u16 len); 77 struct fchs_s *rx_fchs, u16 len);
86static void bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport); 78static void bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport);
87static void bfa_fcs_rport_hal_offline(struct bfa_fcs_rport_s *rport);
88 79
89static void bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, 80static void bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport,
90 enum rport_event event); 81 enum rport_event event);
@@ -96,8 +87,6 @@ static void bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
96 enum rport_event event); 87 enum rport_event event);
97static void bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, 88static void bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport,
98 enum rport_event event); 89 enum rport_event event);
99static void bfa_fcs_rport_sm_fc4_fcs_online(struct bfa_fcs_rport_s *rport,
100 enum rport_event event);
101static void bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport, 90static void bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
102 enum rport_event event); 91 enum rport_event event);
103static void bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, 92static void bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport,
@@ -106,13 +95,9 @@ static void bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
106 enum rport_event event); 95 enum rport_event event);
107static void bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, 96static void bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport,
108 enum rport_event event); 97 enum rport_event event);
109static void bfa_fcs_rport_sm_adisc_online_sending( 98static void bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
110 struct bfa_fcs_rport_s *rport, enum rport_event event); 99 enum rport_event event);
111static void bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport, 100static void bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport,
112 enum rport_event event);
113static void bfa_fcs_rport_sm_adisc_offline_sending(struct bfa_fcs_rport_s
114 *rport, enum rport_event event);
115static void bfa_fcs_rport_sm_adisc_offline(struct bfa_fcs_rport_s *rport,
116 enum rport_event event); 101 enum rport_event event);
117static void bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport, 102static void bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
118 enum rport_event event); 103 enum rport_event event);
@@ -138,10 +123,6 @@ static void bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
138 enum rport_event event); 123 enum rport_event event);
139static void bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport, 124static void bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
140 enum rport_event event); 125 enum rport_event event);
141static void bfa_fcs_rport_sm_fc4_off_delete(struct bfa_fcs_rport_s *rport,
142 enum rport_event event);
143static void bfa_fcs_rport_sm_delete_pending(struct bfa_fcs_rport_s *rport,
144 enum rport_event event);
145 126
146static struct bfa_sm_table_s rport_sm_table[] = { 127static struct bfa_sm_table_s rport_sm_table[] = {
147 {BFA_SM(bfa_fcs_rport_sm_uninit), BFA_RPORT_UNINIT}, 128 {BFA_SM(bfa_fcs_rport_sm_uninit), BFA_RPORT_UNINIT},
@@ -149,15 +130,12 @@ static struct bfa_sm_table_s rport_sm_table[] = {
149 {BFA_SM(bfa_fcs_rport_sm_plogiacc_sending), BFA_RPORT_ONLINE}, 130 {BFA_SM(bfa_fcs_rport_sm_plogiacc_sending), BFA_RPORT_ONLINE},
150 {BFA_SM(bfa_fcs_rport_sm_plogi_retry), BFA_RPORT_PLOGI_RETRY}, 131 {BFA_SM(bfa_fcs_rport_sm_plogi_retry), BFA_RPORT_PLOGI_RETRY},
151 {BFA_SM(bfa_fcs_rport_sm_plogi), BFA_RPORT_PLOGI}, 132 {BFA_SM(bfa_fcs_rport_sm_plogi), BFA_RPORT_PLOGI},
152 {BFA_SM(bfa_fcs_rport_sm_fc4_fcs_online), BFA_RPORT_ONLINE},
153 {BFA_SM(bfa_fcs_rport_sm_hal_online), BFA_RPORT_ONLINE}, 133 {BFA_SM(bfa_fcs_rport_sm_hal_online), BFA_RPORT_ONLINE},
154 {BFA_SM(bfa_fcs_rport_sm_online), BFA_RPORT_ONLINE}, 134 {BFA_SM(bfa_fcs_rport_sm_online), BFA_RPORT_ONLINE},
155 {BFA_SM(bfa_fcs_rport_sm_nsquery_sending), BFA_RPORT_NSQUERY}, 135 {BFA_SM(bfa_fcs_rport_sm_nsquery_sending), BFA_RPORT_NSQUERY},
156 {BFA_SM(bfa_fcs_rport_sm_nsquery), BFA_RPORT_NSQUERY}, 136 {BFA_SM(bfa_fcs_rport_sm_nsquery), BFA_RPORT_NSQUERY},
157 {BFA_SM(bfa_fcs_rport_sm_adisc_online_sending), BFA_RPORT_ADISC}, 137 {BFA_SM(bfa_fcs_rport_sm_adisc_sending), BFA_RPORT_ADISC},
158 {BFA_SM(bfa_fcs_rport_sm_adisc_online), BFA_RPORT_ADISC}, 138 {BFA_SM(bfa_fcs_rport_sm_adisc), BFA_RPORT_ADISC},
159 {BFA_SM(bfa_fcs_rport_sm_adisc_offline_sending), BFA_RPORT_ADISC},
160 {BFA_SM(bfa_fcs_rport_sm_adisc_offline), BFA_RPORT_ADISC},
161 {BFA_SM(bfa_fcs_rport_sm_fc4_logorcv), BFA_RPORT_LOGORCV}, 139 {BFA_SM(bfa_fcs_rport_sm_fc4_logorcv), BFA_RPORT_LOGORCV},
162 {BFA_SM(bfa_fcs_rport_sm_fc4_logosend), BFA_RPORT_LOGO}, 140 {BFA_SM(bfa_fcs_rport_sm_fc4_logosend), BFA_RPORT_LOGO},
163 {BFA_SM(bfa_fcs_rport_sm_fc4_offline), BFA_RPORT_OFFLINE}, 141 {BFA_SM(bfa_fcs_rport_sm_fc4_offline), BFA_RPORT_OFFLINE},
@@ -189,8 +167,8 @@ bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, enum rport_event event)
189 break; 167 break;
190 168
191 case RPSM_EVENT_PLOGI_RCVD: 169 case RPSM_EVENT_PLOGI_RCVD:
192 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 170 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
193 bfa_fcs_rport_fcs_online_action(rport); 171 bfa_fcs_rport_send_plogiacc(rport, NULL);
194 break; 172 break;
195 173
196 case RPSM_EVENT_PLOGI_COMP: 174 case RPSM_EVENT_PLOGI_COMP:
@@ -237,19 +215,10 @@ bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,
237 bfa_fcs_rport_send_plogiacc(rport, NULL); 215 bfa_fcs_rport_send_plogiacc(rport, NULL);
238 break; 216 break;
239 217
240 case RPSM_EVENT_SCN_OFFLINE:
241 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
242 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
243 bfa_timer_start(rport->fcs->bfa, &rport->timer,
244 bfa_fcs_rport_timeout, rport,
245 bfa_fcs_rport_del_timeout);
246 break;
247 case RPSM_EVENT_ADDRESS_CHANGE: 218 case RPSM_EVENT_ADDRESS_CHANGE:
248 case RPSM_EVENT_FAB_SCN: 219 case RPSM_EVENT_SCN:
249 /* query the NS */ 220 /* query the NS */
250 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 221 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
251 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
252 BFA_PORT_TOPOLOGY_LOOP));
253 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 222 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
254 rport->ns_retries = 0; 223 rport->ns_retries = 0;
255 bfa_fcs_rport_send_nsdisc(rport, NULL); 224 bfa_fcs_rport_send_nsdisc(rport, NULL);
@@ -283,8 +252,8 @@ bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
283 252
284 switch (event) { 253 switch (event) {
285 case RPSM_EVENT_FCXP_SENT: 254 case RPSM_EVENT_FCXP_SENT:
286 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 255 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
287 bfa_fcs_rport_fcs_online_action(rport); 256 bfa_fcs_rport_hal_online(rport);
288 break; 257 break;
289 258
290 case RPSM_EVENT_DELETE: 259 case RPSM_EVENT_DELETE:
@@ -295,20 +264,12 @@ bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
295 264
296 case RPSM_EVENT_PLOGI_RCVD: 265 case RPSM_EVENT_PLOGI_RCVD:
297 case RPSM_EVENT_PLOGI_COMP: 266 case RPSM_EVENT_PLOGI_COMP:
298 case RPSM_EVENT_FAB_SCN: 267 case RPSM_EVENT_SCN:
299 /* 268 /*
300 * Ignore, SCN is possibly online notification. 269 * Ignore, SCN is possibly online notification.
301 */ 270 */
302 break; 271 break;
303 272
304 case RPSM_EVENT_SCN_OFFLINE:
305 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
306 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
307 bfa_timer_start(rport->fcs->bfa, &rport->timer,
308 bfa_fcs_rport_timeout, rport,
309 bfa_fcs_rport_del_timeout);
310 break;
311
312 case RPSM_EVENT_ADDRESS_CHANGE: 273 case RPSM_EVENT_ADDRESS_CHANGE:
313 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 274 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
314 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 275 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
@@ -369,19 +330,9 @@ bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
369 bfa_fcs_rport_send_plogiacc(rport, NULL); 330 bfa_fcs_rport_send_plogiacc(rport, NULL);
370 break; 331 break;
371 332
372 case RPSM_EVENT_SCN_OFFLINE:
373 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
374 bfa_timer_stop(&rport->timer);
375 bfa_timer_start(rport->fcs->bfa, &rport->timer,
376 bfa_fcs_rport_timeout, rport,
377 bfa_fcs_rport_del_timeout);
378 break;
379
380 case RPSM_EVENT_ADDRESS_CHANGE: 333 case RPSM_EVENT_ADDRESS_CHANGE:
381 case RPSM_EVENT_FAB_SCN: 334 case RPSM_EVENT_SCN:
382 bfa_timer_stop(&rport->timer); 335 bfa_timer_stop(&rport->timer);
383 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
384 BFA_PORT_TOPOLOGY_LOOP));
385 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 336 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
386 rport->ns_retries = 0; 337 rport->ns_retries = 0;
387 bfa_fcs_rport_send_nsdisc(rport, NULL); 338 bfa_fcs_rport_send_nsdisc(rport, NULL);
@@ -397,9 +348,9 @@ bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
397 break; 348 break;
398 349
399 case RPSM_EVENT_PLOGI_COMP: 350 case RPSM_EVENT_PLOGI_COMP:
400 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 351 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
401 bfa_timer_stop(&rport->timer); 352 bfa_timer_stop(&rport->timer);
402 bfa_fcs_rport_fcs_online_action(rport); 353 bfa_fcs_rport_hal_online(rport);
403 break; 354 break;
404 355
405 default: 356 default:
@@ -419,9 +370,9 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
419 370
420 switch (event) { 371 switch (event) {
421 case RPSM_EVENT_ACCEPTED: 372 case RPSM_EVENT_ACCEPTED:
422 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 373 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
423 rport->plogi_retries = 0; 374 rport->plogi_retries = 0;
424 bfa_fcs_rport_fcs_online_action(rport); 375 bfa_fcs_rport_hal_online(rport);
425 break; 376 break;
426 377
427 case RPSM_EVENT_LOGO_RCVD: 378 case RPSM_EVENT_LOGO_RCVD:
@@ -446,7 +397,6 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
446 BFA_FCS_RETRY_TIMEOUT); 397 BFA_FCS_RETRY_TIMEOUT);
447 } else { 398 } else {
448 bfa_stats(rport->port, rport_del_max_plogi_retry); 399 bfa_stats(rport->port, rport_del_max_plogi_retry);
449 rport->old_pid = rport->pid;
450 rport->pid = 0; 400 rport->pid = 0;
451 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline); 401 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
452 bfa_timer_start(rport->fcs->bfa, &rport->timer, 402 bfa_timer_start(rport->fcs->bfa, &rport->timer,
@@ -455,18 +405,7 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
455 } 405 }
456 break; 406 break;
457 407
458 case RPSM_EVENT_SCN_ONLINE: 408 case RPSM_EVENT_PLOGI_RETRY:
459 break;
460
461 case RPSM_EVENT_SCN_OFFLINE:
462 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
463 bfa_fcxp_discard(rport->fcxp);
464 bfa_timer_start(rport->fcs->bfa, &rport->timer,
465 bfa_fcs_rport_timeout, rport,
466 bfa_fcs_rport_del_timeout);
467 break;
468
469 case RPSM_EVENT_PLOGI_RETRY:
470 rport->plogi_retries = 0; 409 rport->plogi_retries = 0;
471 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry); 410 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry);
472 bfa_timer_start(rport->fcs->bfa, &rport->timer, 411 bfa_timer_start(rport->fcs->bfa, &rport->timer,
@@ -484,10 +423,8 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
484 break; 423 break;
485 424
486 case RPSM_EVENT_ADDRESS_CHANGE: 425 case RPSM_EVENT_ADDRESS_CHANGE:
487 case RPSM_EVENT_FAB_SCN: 426 case RPSM_EVENT_SCN:
488 bfa_fcxp_discard(rport->fcxp); 427 bfa_fcxp_discard(rport->fcxp);
489 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
490 BFA_PORT_TOPOLOGY_LOOP));
491 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 428 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
492 rport->ns_retries = 0; 429 rport->ns_retries = 0;
493 bfa_fcs_rport_send_nsdisc(rport, NULL); 430 bfa_fcs_rport_send_nsdisc(rport, NULL);
@@ -506,78 +443,13 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
506 break; 443 break;
507 444
508 case RPSM_EVENT_PLOGI_COMP: 445 case RPSM_EVENT_PLOGI_COMP:
509 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 446 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
510 bfa_fcxp_discard(rport->fcxp); 447 bfa_fcxp_discard(rport->fcxp);
511 bfa_fcs_rport_fcs_online_action(rport); 448 bfa_fcs_rport_hal_online(rport);
512 break;
513
514 default:
515 bfa_sm_fault(rport->fcs, event);
516 }
517}
518
519/*
520 * PLOGI is done. Await bfa_fcs_itnim to ascertain the scsi function
521 */
522static void
523bfa_fcs_rport_sm_fc4_fcs_online(struct bfa_fcs_rport_s *rport,
524 enum rport_event event)
525{
526 bfa_trc(rport->fcs, rport->pwwn);
527 bfa_trc(rport->fcs, rport->pid);
528 bfa_trc(rport->fcs, event);
529
530 switch (event) {
531 case RPSM_EVENT_FC4_FCS_ONLINE:
532 if (rport->scsi_function == BFA_RPORT_INITIATOR) {
533 if (!BFA_FCS_PID_IS_WKA(rport->pid))
534 bfa_fcs_rpf_rport_online(rport);
535 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
536 break;
537 }
538
539 if (!rport->bfa_rport)
540 rport->bfa_rport =
541 bfa_rport_create(rport->fcs->bfa, rport);
542
543 if (rport->bfa_rport) {
544 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
545 bfa_fcs_rport_hal_online(rport);
546 } else {
547 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
548 bfa_fcs_rport_fcs_offline_action(rport);
549 }
550 break;
551
552 case RPSM_EVENT_PLOGI_RCVD:
553 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
554 rport->plogi_pending = BFA_TRUE;
555 bfa_fcs_rport_fcs_offline_action(rport);
556 break;
557
558 case RPSM_EVENT_PLOGI_COMP:
559 case RPSM_EVENT_LOGO_IMP:
560 case RPSM_EVENT_ADDRESS_CHANGE:
561 case RPSM_EVENT_FAB_SCN:
562 case RPSM_EVENT_SCN_OFFLINE:
563 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
564 bfa_fcs_rport_fcs_offline_action(rport);
565 break;
566
567 case RPSM_EVENT_LOGO_RCVD:
568 case RPSM_EVENT_PRLO_RCVD:
569 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
570 bfa_fcs_rport_fcs_offline_action(rport);
571 break;
572
573 case RPSM_EVENT_DELETE:
574 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
575 bfa_fcs_rport_fcs_offline_action(rport);
576 break; 449 break;
577 450
578 default: 451 default:
579 bfa_sm_fault(rport->fcs, event); 452 bfa_sm_fault(rport->fcs, event);
580 break;
581 } 453 }
582} 454}
583 455
@@ -596,35 +468,41 @@ bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
596 switch (event) { 468 switch (event) {
597 case RPSM_EVENT_HCB_ONLINE: 469 case RPSM_EVENT_HCB_ONLINE:
598 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online); 470 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
599 bfa_fcs_rport_hal_online_action(rport); 471 bfa_fcs_rport_online_action(rport);
600 break; 472 break;
601 473
474 case RPSM_EVENT_PRLO_RCVD:
602 case RPSM_EVENT_PLOGI_COMP: 475 case RPSM_EVENT_PLOGI_COMP:
603 break; 476 break;
604 477
605 case RPSM_EVENT_PRLO_RCVD:
606 case RPSM_EVENT_LOGO_RCVD: 478 case RPSM_EVENT_LOGO_RCVD:
607 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 479 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);
608 bfa_fcs_rport_fcs_offline_action(rport); 480 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
609 break; 481 break;
610 482
611 case RPSM_EVENT_FAB_SCN:
612 case RPSM_EVENT_LOGO_IMP: 483 case RPSM_EVENT_LOGO_IMP:
613 case RPSM_EVENT_ADDRESS_CHANGE: 484 case RPSM_EVENT_ADDRESS_CHANGE:
614 case RPSM_EVENT_SCN_OFFLINE: 485 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
615 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 486 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
616 bfa_fcs_rport_fcs_offline_action(rport);
617 break; 487 break;
618 488
619 case RPSM_EVENT_PLOGI_RCVD: 489 case RPSM_EVENT_PLOGI_RCVD:
620 rport->plogi_pending = BFA_TRUE; 490 rport->plogi_pending = BFA_TRUE;
621 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 491 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
622 bfa_fcs_rport_fcs_offline_action(rport); 492 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
623 break; 493 break;
624 494
625 case RPSM_EVENT_DELETE: 495 case RPSM_EVENT_DELETE:
626 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 496 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
627 bfa_fcs_rport_fcs_offline_action(rport); 497 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
498 break;
499
500 case RPSM_EVENT_SCN:
501 /*
502 * @todo
503 * Ignore SCN - PLOGI just completed, FC-4 login should detect
504 * device failures.
505 */
628 break; 506 break;
629 507
630 default: 508 default:
@@ -643,15 +521,14 @@ bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
643 bfa_trc(rport->fcs, event); 521 bfa_trc(rport->fcs, event);
644 522
645 switch (event) { 523 switch (event) {
646 case RPSM_EVENT_FAB_SCN: 524 case RPSM_EVENT_SCN:
647 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) { 525 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
648 bfa_sm_set_state(rport, 526 bfa_sm_set_state(rport,
649 bfa_fcs_rport_sm_nsquery_sending); 527 bfa_fcs_rport_sm_nsquery_sending);
650 rport->ns_retries = 0; 528 rport->ns_retries = 0;
651 bfa_fcs_rport_send_nsdisc(rport, NULL); 529 bfa_fcs_rport_send_nsdisc(rport, NULL);
652 } else { 530 } else {
653 bfa_sm_set_state(rport, 531 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_sending);
654 bfa_fcs_rport_sm_adisc_online_sending);
655 bfa_fcs_rport_send_adisc(rport, NULL); 532 bfa_fcs_rport_send_adisc(rport, NULL);
656 } 533 }
657 break; 534 break;
@@ -659,23 +536,21 @@ bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
659 case RPSM_EVENT_PLOGI_RCVD: 536 case RPSM_EVENT_PLOGI_RCVD:
660 case RPSM_EVENT_LOGO_IMP: 537 case RPSM_EVENT_LOGO_IMP:
661 case RPSM_EVENT_ADDRESS_CHANGE: 538 case RPSM_EVENT_ADDRESS_CHANGE:
662 case RPSM_EVENT_SCN_OFFLINE:
663 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 539 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
664 bfa_fcs_rport_hal_offline_action(rport); 540 bfa_fcs_rport_offline_action(rport);
665 break; 541 break;
666 542
667 case RPSM_EVENT_DELETE: 543 case RPSM_EVENT_DELETE:
668 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 544 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
669 bfa_fcs_rport_hal_offline_action(rport); 545 bfa_fcs_rport_offline_action(rport);
670 break; 546 break;
671 547
672 case RPSM_EVENT_LOGO_RCVD: 548 case RPSM_EVENT_LOGO_RCVD:
673 case RPSM_EVENT_PRLO_RCVD: 549 case RPSM_EVENT_PRLO_RCVD:
674 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 550 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
675 bfa_fcs_rport_hal_offline_action(rport); 551 bfa_fcs_rport_offline_action(rport);
676 break; 552 break;
677 553
678 case RPSM_EVENT_SCN_ONLINE:
679 case RPSM_EVENT_PLOGI_COMP: 554 case RPSM_EVENT_PLOGI_COMP:
680 break; 555 break;
681 556
@@ -704,10 +579,10 @@ bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
704 case RPSM_EVENT_DELETE: 579 case RPSM_EVENT_DELETE:
705 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 580 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
706 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 581 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
707 bfa_fcs_rport_hal_offline_action(rport); 582 bfa_fcs_rport_offline_action(rport);
708 break; 583 break;
709 584
710 case RPSM_EVENT_FAB_SCN: 585 case RPSM_EVENT_SCN:
711 /* 586 /*
712 * ignore SCN, wait for response to query itself 587 * ignore SCN, wait for response to query itself
713 */ 588 */
@@ -717,16 +592,24 @@ bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
717 case RPSM_EVENT_PRLO_RCVD: 592 case RPSM_EVENT_PRLO_RCVD:
718 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 593 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
719 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 594 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
720 bfa_fcs_rport_hal_offline_action(rport); 595 bfa_fcs_rport_offline_action(rport);
721 break; 596 break;
722 597
723 case RPSM_EVENT_LOGO_IMP: 598 case RPSM_EVENT_LOGO_IMP:
599 rport->pid = 0;
600 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
601 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
602 bfa_timer_start(rport->fcs->bfa, &rport->timer,
603 bfa_fcs_rport_timeout, rport,
604 bfa_fcs_rport_del_timeout);
605 break;
606
724 case RPSM_EVENT_PLOGI_RCVD: 607 case RPSM_EVENT_PLOGI_RCVD:
725 case RPSM_EVENT_ADDRESS_CHANGE: 608 case RPSM_EVENT_ADDRESS_CHANGE:
726 case RPSM_EVENT_PLOGI_COMP: 609 case RPSM_EVENT_PLOGI_COMP:
727 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 610 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
728 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 611 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
729 bfa_fcs_rport_hal_offline_action(rport); 612 bfa_fcs_rport_offline_action(rport);
730 break; 613 break;
731 614
732 default: 615 default:
@@ -747,7 +630,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
747 630
748 switch (event) { 631 switch (event) {
749 case RPSM_EVENT_ACCEPTED: 632 case RPSM_EVENT_ACCEPTED:
750 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_online_sending); 633 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_sending);
751 bfa_fcs_rport_send_adisc(rport, NULL); 634 bfa_fcs_rport_send_adisc(rport, NULL);
752 break; 635 break;
753 636
@@ -759,24 +642,24 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
759 bfa_fcs_rport_send_nsdisc(rport, NULL); 642 bfa_fcs_rport_send_nsdisc(rport, NULL);
760 } else { 643 } else {
761 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 644 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
762 bfa_fcs_rport_hal_offline_action(rport); 645 bfa_fcs_rport_offline_action(rport);
763 } 646 }
764 break; 647 break;
765 648
766 case RPSM_EVENT_DELETE: 649 case RPSM_EVENT_DELETE:
767 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 650 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
768 bfa_fcxp_discard(rport->fcxp); 651 bfa_fcxp_discard(rport->fcxp);
769 bfa_fcs_rport_hal_offline_action(rport); 652 bfa_fcs_rport_offline_action(rport);
770 break; 653 break;
771 654
772 case RPSM_EVENT_FAB_SCN: 655 case RPSM_EVENT_SCN:
773 break; 656 break;
774 657
775 case RPSM_EVENT_LOGO_RCVD: 658 case RPSM_EVENT_LOGO_RCVD:
776 case RPSM_EVENT_PRLO_RCVD: 659 case RPSM_EVENT_PRLO_RCVD:
777 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 660 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
778 bfa_fcxp_discard(rport->fcxp); 661 bfa_fcxp_discard(rport->fcxp);
779 bfa_fcs_rport_hal_offline_action(rport); 662 bfa_fcs_rport_offline_action(rport);
780 break; 663 break;
781 664
782 case RPSM_EVENT_PLOGI_COMP: 665 case RPSM_EVENT_PLOGI_COMP:
@@ -785,7 +668,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
785 case RPSM_EVENT_LOGO_IMP: 668 case RPSM_EVENT_LOGO_IMP:
786 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 669 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
787 bfa_fcxp_discard(rport->fcxp); 670 bfa_fcxp_discard(rport->fcxp);
788 bfa_fcs_rport_hal_offline_action(rport); 671 bfa_fcs_rport_offline_action(rport);
789 break; 672 break;
790 673
791 default: 674 default:
@@ -798,7 +681,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
798 * authenticating with rport. FC-4s are paused. 681 * authenticating with rport. FC-4s are paused.
799 */ 682 */
800static void 683static void
801bfa_fcs_rport_sm_adisc_online_sending(struct bfa_fcs_rport_s *rport, 684bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
802 enum rport_event event) 685 enum rport_event event)
803{ 686{
804 bfa_trc(rport->fcs, rport->pwwn); 687 bfa_trc(rport->fcs, rport->pwwn);
@@ -807,36 +690,36 @@ bfa_fcs_rport_sm_adisc_online_sending(struct bfa_fcs_rport_s *rport,
807 690
808 switch (event) { 691 switch (event) {
809 case RPSM_EVENT_FCXP_SENT: 692 case RPSM_EVENT_FCXP_SENT:
810 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_online); 693 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc);
811 break; 694 break;
812 695
813 case RPSM_EVENT_DELETE: 696 case RPSM_EVENT_DELETE:
814 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 697 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
815 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 698 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
816 bfa_fcs_rport_hal_offline_action(rport); 699 bfa_fcs_rport_offline_action(rport);
817 break; 700 break;
818 701
819 case RPSM_EVENT_LOGO_IMP: 702 case RPSM_EVENT_LOGO_IMP:
820 case RPSM_EVENT_ADDRESS_CHANGE: 703 case RPSM_EVENT_ADDRESS_CHANGE:
821 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 704 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
822 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 705 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
823 bfa_fcs_rport_hal_offline_action(rport); 706 bfa_fcs_rport_offline_action(rport);
824 break; 707 break;
825 708
826 case RPSM_EVENT_LOGO_RCVD: 709 case RPSM_EVENT_LOGO_RCVD:
827 case RPSM_EVENT_PRLO_RCVD: 710 case RPSM_EVENT_PRLO_RCVD:
828 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 711 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
829 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 712 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
830 bfa_fcs_rport_hal_offline_action(rport); 713 bfa_fcs_rport_offline_action(rport);
831 break; 714 break;
832 715
833 case RPSM_EVENT_FAB_SCN: 716 case RPSM_EVENT_SCN:
834 break; 717 break;
835 718
836 case RPSM_EVENT_PLOGI_RCVD: 719 case RPSM_EVENT_PLOGI_RCVD:
837 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 720 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
838 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 721 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
839 bfa_fcs_rport_hal_offline_action(rport); 722 bfa_fcs_rport_offline_action(rport);
840 break; 723 break;
841 724
842 default: 725 default:
@@ -849,8 +732,7 @@ bfa_fcs_rport_sm_adisc_online_sending(struct bfa_fcs_rport_s *rport,
849 * FC-4s are paused. 732 * FC-4s are paused.
850 */ 733 */
851static void 734static void
852bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport, 735bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport, enum rport_event event)
853 enum rport_event event)
854{ 736{
855 bfa_trc(rport->fcs, rport->pwwn); 737 bfa_trc(rport->fcs, rport->pwwn);
856 bfa_trc(rport->fcs, rport->pid); 738 bfa_trc(rport->fcs, rport->pid);
@@ -874,16 +756,16 @@ bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport,
874 case RPSM_EVENT_FAILED: 756 case RPSM_EVENT_FAILED:
875 case RPSM_EVENT_ADDRESS_CHANGE: 757 case RPSM_EVENT_ADDRESS_CHANGE:
876 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 758 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
877 bfa_fcs_rport_hal_offline_action(rport); 759 bfa_fcs_rport_offline_action(rport);
878 break; 760 break;
879 761
880 case RPSM_EVENT_DELETE: 762 case RPSM_EVENT_DELETE:
881 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend); 763 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
882 bfa_fcxp_discard(rport->fcxp); 764 bfa_fcxp_discard(rport->fcxp);
883 bfa_fcs_rport_hal_offline_action(rport); 765 bfa_fcs_rport_offline_action(rport);
884 break; 766 break;
885 767
886 case RPSM_EVENT_FAB_SCN: 768 case RPSM_EVENT_SCN:
887 /* 769 /*
888 * already processing RSCN 770 * already processing RSCN
889 */ 771 */
@@ -892,103 +774,14 @@ bfa_fcs_rport_sm_adisc_online(struct bfa_fcs_rport_s *rport,
892 case RPSM_EVENT_LOGO_IMP: 774 case RPSM_EVENT_LOGO_IMP:
893 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline); 775 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
894 bfa_fcxp_discard(rport->fcxp); 776 bfa_fcxp_discard(rport->fcxp);
895 bfa_fcs_rport_hal_offline_action(rport); 777 bfa_fcs_rport_offline_action(rport);
896 break; 778 break;
897 779
898 case RPSM_EVENT_LOGO_RCVD: 780 case RPSM_EVENT_LOGO_RCVD:
899 case RPSM_EVENT_PRLO_RCVD: 781 case RPSM_EVENT_PRLO_RCVD:
900 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv); 782 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
901 bfa_fcxp_discard(rport->fcxp); 783 bfa_fcxp_discard(rport->fcxp);
902 bfa_fcs_rport_hal_offline_action(rport); 784 bfa_fcs_rport_offline_action(rport);
903 break;
904
905 default:
906 bfa_sm_fault(rport->fcs, event);
907 }
908}
909
910/*
911 * ADISC is being sent for authenticating with rport
912 * Already did offline actions.
913 */
914static void
915bfa_fcs_rport_sm_adisc_offline_sending(struct bfa_fcs_rport_s *rport,
916 enum rport_event event)
917{
918 bfa_trc(rport->fcs, rport->pwwn);
919 bfa_trc(rport->fcs, rport->pid);
920 bfa_trc(rport->fcs, event);
921
922 switch (event) {
923 case RPSM_EVENT_FCXP_SENT:
924 bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_offline);
925 break;
926
927 case RPSM_EVENT_DELETE:
928 case RPSM_EVENT_SCN_OFFLINE:
929 case RPSM_EVENT_LOGO_IMP:
930 case RPSM_EVENT_LOGO_RCVD:
931 case RPSM_EVENT_PRLO_RCVD:
932 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
933 bfa_fcxp_walloc_cancel(rport->fcs->bfa,
934 &rport->fcxp_wqe);
935 bfa_timer_start(rport->fcs->bfa, &rport->timer,
936 bfa_fcs_rport_timeout, rport,
937 bfa_fcs_rport_del_timeout);
938 break;
939
940 case RPSM_EVENT_PLOGI_RCVD:
941 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
942 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
943 bfa_fcs_rport_send_plogiacc(rport, NULL);
944 break;
945
946 default:
947 bfa_sm_fault(rport->fcs, event);
948 }
949}
950
951/*
952 * ADISC to rport
953 * Already did offline actions
954 */
955static void
956bfa_fcs_rport_sm_adisc_offline(struct bfa_fcs_rport_s *rport,
957 enum rport_event event)
958{
959 bfa_trc(rport->fcs, rport->pwwn);
960 bfa_trc(rport->fcs, rport->pid);
961 bfa_trc(rport->fcs, event);
962
963 switch (event) {
964 case RPSM_EVENT_ACCEPTED:
965 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
966 bfa_fcs_rport_hal_online(rport);
967 break;
968
969 case RPSM_EVENT_PLOGI_RCVD:
970 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
971 bfa_fcxp_discard(rport->fcxp);
972 bfa_fcs_rport_send_plogiacc(rport, NULL);
973 break;
974
975 case RPSM_EVENT_FAILED:
976 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
977 bfa_timer_start(rport->fcs->bfa, &rport->timer,
978 bfa_fcs_rport_timeout, rport,
979 bfa_fcs_rport_del_timeout);
980 break;
981
982 case RPSM_EVENT_DELETE:
983 case RPSM_EVENT_SCN_OFFLINE:
984 case RPSM_EVENT_LOGO_IMP:
985 case RPSM_EVENT_LOGO_RCVD:
986 case RPSM_EVENT_PRLO_RCVD:
987 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
988 bfa_fcxp_discard(rport->fcxp);
989 bfa_timer_start(rport->fcs->bfa, &rport->timer,
990 bfa_fcs_rport_timeout, rport,
991 bfa_fcs_rport_del_timeout);
992 break; 785 break;
993 786
994 default: 787 default:
@@ -997,7 +790,7 @@ bfa_fcs_rport_sm_adisc_offline(struct bfa_fcs_rport_s *rport,
997} 790}
998 791
999/* 792/*
1000 * Rport has sent LOGO. Awaiting FC-4 offline completion callback. 793 * Rport has sent LOGO. Awaiting FC-4 offline completion callback.
1001 */ 794 */
1002static void 795static void
1003bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport, 796bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
@@ -1010,21 +803,13 @@ bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
1010 switch (event) { 803 switch (event) {
1011 case RPSM_EVENT_FC4_OFFLINE: 804 case RPSM_EVENT_FC4_OFFLINE:
1012 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv); 805 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);
1013 bfa_fcs_rport_hal_offline(rport); 806 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
1014 break; 807 break;
1015 808
1016 case RPSM_EVENT_DELETE: 809 case RPSM_EVENT_DELETE:
1017 if (rport->pid && (rport->prlo == BFA_TRUE)) 810 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
1018 bfa_fcs_rport_send_prlo_acc(rport);
1019 if (rport->pid && (rport->prlo == BFA_FALSE))
1020 bfa_fcs_rport_send_logo_acc(rport);
1021
1022 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
1023 break; 811 break;
1024 812
1025 case RPSM_EVENT_SCN_ONLINE:
1026 case RPSM_EVENT_SCN_OFFLINE:
1027 case RPSM_EVENT_HCB_ONLINE:
1028 case RPSM_EVENT_LOGO_RCVD: 813 case RPSM_EVENT_LOGO_RCVD:
1029 case RPSM_EVENT_PRLO_RCVD: 814 case RPSM_EVENT_PRLO_RCVD:
1030 case RPSM_EVENT_ADDRESS_CHANGE: 815 case RPSM_EVENT_ADDRESS_CHANGE:
@@ -1050,20 +835,7 @@ bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
1050 switch (event) { 835 switch (event) {
1051 case RPSM_EVENT_FC4_OFFLINE: 836 case RPSM_EVENT_FC4_OFFLINE:
1052 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend); 837 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
1053 bfa_fcs_rport_hal_offline(rport); 838 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
1054 break;
1055
1056 case RPSM_EVENT_LOGO_RCVD:
1057 bfa_fcs_rport_send_logo_acc(rport);
1058 case RPSM_EVENT_PRLO_RCVD:
1059 if (rport->prlo == BFA_TRUE)
1060 bfa_fcs_rport_send_prlo_acc(rport);
1061 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
1062 break;
1063
1064 case RPSM_EVENT_HCB_ONLINE:
1065 case RPSM_EVENT_DELETE:
1066 /* Rport is being deleted */
1067 break; 839 break;
1068 840
1069 default: 841 default:
@@ -1085,26 +857,13 @@ bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
1085 switch (event) { 857 switch (event) {
1086 case RPSM_EVENT_FC4_OFFLINE: 858 case RPSM_EVENT_FC4_OFFLINE:
1087 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline); 859 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
1088 bfa_fcs_rport_hal_offline(rport); 860 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
1089 break; 861 break;
1090 862
1091 case RPSM_EVENT_SCN_ONLINE: 863 case RPSM_EVENT_SCN:
1092 break; 864 case RPSM_EVENT_LOGO_IMP:
1093 case RPSM_EVENT_LOGO_RCVD: 865 case RPSM_EVENT_LOGO_RCVD:
1094 /*
1095 * Rport is going offline. Just ack the logo
1096 */
1097 bfa_fcs_rport_send_logo_acc(rport);
1098 break;
1099
1100 case RPSM_EVENT_PRLO_RCVD: 866 case RPSM_EVENT_PRLO_RCVD:
1101 bfa_fcs_rport_send_prlo_acc(rport);
1102 break;
1103
1104 case RPSM_EVENT_SCN_OFFLINE:
1105 case RPSM_EVENT_HCB_ONLINE:
1106 case RPSM_EVENT_FAB_SCN:
1107 case RPSM_EVENT_LOGO_IMP:
1108 case RPSM_EVENT_ADDRESS_CHANGE: 867 case RPSM_EVENT_ADDRESS_CHANGE:
1109 /* 868 /*
1110 * rport is already going offline. 869 * rport is already going offline.
@@ -1148,36 +907,24 @@ bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
1148 */ 907 */
1149 908
1150 case RPSM_EVENT_ADDRESS_CHANGE: 909 case RPSM_EVENT_ADDRESS_CHANGE:
1151 if (!bfa_fcs_lport_is_online(rport->port)) { 910 if (bfa_fcs_lport_is_online(rport->port)) {
1152 rport->pid = 0; 911 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
1153 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1154 bfa_timer_start(rport->fcs->bfa, &rport->timer,
1155 bfa_fcs_rport_timeout, rport,
1156 bfa_fcs_rport_del_timeout);
1157 break;
1158 }
1159 if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
1160 bfa_sm_set_state(rport,
1161 bfa_fcs_rport_sm_nsdisc_sending);
1162 rport->ns_retries = 0;
1163 bfa_fcs_rport_send_nsdisc(rport, NULL);
1164 } else if (bfa_fcport_get_topology(rport->port->fcs->bfa) ==
1165 BFA_PORT_TOPOLOGY_LOOP) {
1166 if (rport->scn_online) {
1167 bfa_sm_set_state(rport, 912 bfa_sm_set_state(rport,
1168 bfa_fcs_rport_sm_adisc_offline_sending); 913 bfa_fcs_rport_sm_nsdisc_sending);
1169 bfa_fcs_rport_send_adisc(rport, NULL); 914 rport->ns_retries = 0;
915 bfa_fcs_rport_send_nsdisc(rport, NULL);
1170 } else { 916 } else {
1171 bfa_sm_set_state(rport, 917 bfa_sm_set_state(rport,
1172 bfa_fcs_rport_sm_offline); 918 bfa_fcs_rport_sm_plogi_sending);
1173 bfa_timer_start(rport->fcs->bfa, &rport->timer, 919 rport->plogi_retries = 0;
1174 bfa_fcs_rport_timeout, rport, 920 bfa_fcs_rport_send_plogi(rport, NULL);
1175 bfa_fcs_rport_del_timeout);
1176 } 921 }
1177 } else { 922 } else {
1178 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending); 923 rport->pid = 0;
1179 rport->plogi_retries = 0; 924 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1180 bfa_fcs_rport_send_plogi(rport, NULL); 925 bfa_timer_start(rport->fcs->bfa, &rport->timer,
926 bfa_fcs_rport_timeout, rport,
927 bfa_fcs_rport_del_timeout);
1181 } 928 }
1182 break; 929 break;
1183 930
@@ -1186,9 +933,7 @@ bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
1186 bfa_fcs_rport_free(rport); 933 bfa_fcs_rport_free(rport);
1187 break; 934 break;
1188 935
1189 case RPSM_EVENT_SCN_ONLINE: 936 case RPSM_EVENT_SCN:
1190 case RPSM_EVENT_SCN_OFFLINE:
1191 case RPSM_EVENT_FAB_SCN:
1192 case RPSM_EVENT_LOGO_RCVD: 937 case RPSM_EVENT_LOGO_RCVD:
1193 case RPSM_EVENT_PRLO_RCVD: 938 case RPSM_EVENT_PRLO_RCVD:
1194 case RPSM_EVENT_PLOGI_RCVD: 939 case RPSM_EVENT_PLOGI_RCVD:
@@ -1256,19 +1001,13 @@ bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
1256 break; 1001 break;
1257 1002
1258 case RPSM_EVENT_DELETE: 1003 case RPSM_EVENT_DELETE:
1259 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending); 1004 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
1260 if (rport->pid && (rport->prlo == BFA_TRUE))
1261 bfa_fcs_rport_send_prlo_acc(rport);
1262 if (rport->pid && (rport->prlo == BFA_FALSE))
1263 bfa_fcs_rport_send_logo_acc(rport);
1264 break; 1005 break;
1265 1006
1266 case RPSM_EVENT_LOGO_IMP: 1007 case RPSM_EVENT_LOGO_IMP:
1267 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline); 1008 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
1268 break; 1009 break;
1269 1010
1270 case RPSM_EVENT_SCN_ONLINE:
1271 case RPSM_EVENT_SCN_OFFLINE:
1272 case RPSM_EVENT_LOGO_RCVD: 1011 case RPSM_EVENT_LOGO_RCVD:
1273 case RPSM_EVENT_PRLO_RCVD: 1012 case RPSM_EVENT_PRLO_RCVD:
1274 /* 1013 /*
@@ -1301,16 +1040,7 @@ bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
1301 break; 1040 break;
1302 1041
1303 case RPSM_EVENT_LOGO_RCVD: 1042 case RPSM_EVENT_LOGO_RCVD:
1304 bfa_fcs_rport_send_logo_acc(rport);
1305 case RPSM_EVENT_PRLO_RCVD: 1043 case RPSM_EVENT_PRLO_RCVD:
1306 if (rport->prlo == BFA_TRUE)
1307 bfa_fcs_rport_send_prlo_acc(rport);
1308
1309 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
1310 break;
1311
1312 case RPSM_EVENT_SCN_ONLINE:
1313 case RPSM_EVENT_SCN_OFFLINE:
1314 case RPSM_EVENT_ADDRESS_CHANGE: 1044 case RPSM_EVENT_ADDRESS_CHANGE:
1315 break; 1045 break;
1316 1046
@@ -1337,18 +1067,12 @@ bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
1337 bfa_fcs_rport_free(rport); 1067 bfa_fcs_rport_free(rport);
1338 break; 1068 break;
1339 1069
1340 case RPSM_EVENT_SCN_ONLINE: 1070 case RPSM_EVENT_SCN:
1341 case RPSM_EVENT_SCN_OFFLINE:
1342 case RPSM_EVENT_FAB_SCN:
1343 case RPSM_EVENT_ADDRESS_CHANGE: 1071 case RPSM_EVENT_ADDRESS_CHANGE:
1344 break; 1072 break;
1345 1073
1346 case RPSM_EVENT_LOGO_RCVD: 1074 case RPSM_EVENT_LOGO_RCVD:
1347 bfa_fcs_rport_send_logo_acc(rport);
1348 case RPSM_EVENT_PRLO_RCVD: 1075 case RPSM_EVENT_PRLO_RCVD:
1349 if (rport->prlo == BFA_TRUE)
1350 bfa_fcs_rport_send_prlo_acc(rport);
1351
1352 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit); 1076 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1353 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 1077 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1354 bfa_fcs_rport_free(rport); 1078 bfa_fcs_rport_free(rport);
@@ -1376,12 +1100,10 @@ bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
1376 bfa_fcs_rport_free(rport); 1100 bfa_fcs_rport_free(rport);
1377 break; 1101 break;
1378 1102
1379 case RPSM_EVENT_FAB_SCN: 1103 case RPSM_EVENT_SCN:
1380 case RPSM_EVENT_ADDRESS_CHANGE: 1104 case RPSM_EVENT_ADDRESS_CHANGE:
1381 bfa_timer_stop(&rport->timer);
1382 WARN_ON(!(bfa_fcport_get_topology(rport->port->fcs->bfa) !=
1383 BFA_PORT_TOPOLOGY_LOOP));
1384 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 1105 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
1106 bfa_timer_stop(&rport->timer);
1385 rport->ns_retries = 0; 1107 rport->ns_retries = 0;
1386 bfa_fcs_rport_send_nsdisc(rport, NULL); 1108 bfa_fcs_rport_send_nsdisc(rport, NULL);
1387 break; 1109 break;
@@ -1401,19 +1123,12 @@ bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
1401 case RPSM_EVENT_LOGO_RCVD: 1123 case RPSM_EVENT_LOGO_RCVD:
1402 case RPSM_EVENT_PRLO_RCVD: 1124 case RPSM_EVENT_PRLO_RCVD:
1403 case RPSM_EVENT_LOGO_IMP: 1125 case RPSM_EVENT_LOGO_IMP:
1404 case RPSM_EVENT_SCN_OFFLINE:
1405 break; 1126 break;
1406 1127
1407 case RPSM_EVENT_PLOGI_COMP: 1128 case RPSM_EVENT_PLOGI_COMP:
1408 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 1129 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
1409 bfa_timer_stop(&rport->timer);
1410 bfa_fcs_rport_fcs_online_action(rport);
1411 break;
1412
1413 case RPSM_EVENT_SCN_ONLINE:
1414 bfa_timer_stop(&rport->timer); 1130 bfa_timer_stop(&rport->timer);
1415 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending); 1131 bfa_fcs_rport_hal_online(rport);
1416 bfa_fcs_rport_send_plogi(rport, NULL);
1417 break; 1132 break;
1418 1133
1419 case RPSM_EVENT_PLOGI_SEND: 1134 case RPSM_EVENT_PLOGI_SEND:
@@ -1456,7 +1171,7 @@ bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
1456 bfa_fcs_rport_send_plogiacc(rport, NULL); 1171 bfa_fcs_rport_send_plogiacc(rport, NULL);
1457 break; 1172 break;
1458 1173
1459 case RPSM_EVENT_FAB_SCN: 1174 case RPSM_EVENT_SCN:
1460 case RPSM_EVENT_LOGO_RCVD: 1175 case RPSM_EVENT_LOGO_RCVD:
1461 case RPSM_EVENT_PRLO_RCVD: 1176 case RPSM_EVENT_PRLO_RCVD:
1462 case RPSM_EVENT_PLOGI_SEND: 1177 case RPSM_EVENT_PLOGI_SEND:
@@ -1475,9 +1190,9 @@ bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
1475 break; 1190 break;
1476 1191
1477 case RPSM_EVENT_PLOGI_COMP: 1192 case RPSM_EVENT_PLOGI_COMP:
1478 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 1193 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
1479 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe); 1194 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
1480 bfa_fcs_rport_fcs_online_action(rport); 1195 bfa_fcs_rport_hal_online(rport);
1481 break; 1196 break;
1482 1197
1483 default: 1198 default:
@@ -1502,7 +1217,7 @@ bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
1502 bfa_fcs_rport_send_nsdisc(rport, NULL); 1217 bfa_fcs_rport_send_nsdisc(rport, NULL);
1503 break; 1218 break;
1504 1219
1505 case RPSM_EVENT_FAB_SCN: 1220 case RPSM_EVENT_SCN:
1506 case RPSM_EVENT_ADDRESS_CHANGE: 1221 case RPSM_EVENT_ADDRESS_CHANGE:
1507 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending); 1222 bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
1508 bfa_timer_stop(&rport->timer); 1223 bfa_timer_stop(&rport->timer);
@@ -1539,9 +1254,9 @@ bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
1539 break; 1254 break;
1540 1255
1541 case RPSM_EVENT_PLOGI_COMP: 1256 case RPSM_EVENT_PLOGI_COMP:
1542 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 1257 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
1543 bfa_timer_stop(&rport->timer); 1258 bfa_timer_stop(&rport->timer);
1544 bfa_fcs_rport_fcs_online_action(rport); 1259 bfa_fcs_rport_hal_online(rport);
1545 break; 1260 break;
1546 1261
1547 default: 1262 default:
@@ -1581,7 +1296,6 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
1581 bfa_fcs_rport_sm_nsdisc_sending); 1296 bfa_fcs_rport_sm_nsdisc_sending);
1582 bfa_fcs_rport_send_nsdisc(rport, NULL); 1297 bfa_fcs_rport_send_nsdisc(rport, NULL);
1583 } else { 1298 } else {
1584 rport->old_pid = rport->pid;
1585 rport->pid = 0; 1299 rport->pid = 0;
1586 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline); 1300 bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
1587 bfa_timer_start(rport->fcs->bfa, &rport->timer, 1301 bfa_timer_start(rport->fcs->bfa, &rport->timer,
@@ -1615,7 +1329,7 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
1615 case RPSM_EVENT_PRLO_RCVD: 1329 case RPSM_EVENT_PRLO_RCVD:
1616 bfa_fcs_rport_send_prlo_acc(rport); 1330 bfa_fcs_rport_send_prlo_acc(rport);
1617 break; 1331 break;
1618 case RPSM_EVENT_FAB_SCN: 1332 case RPSM_EVENT_SCN:
1619 /* 1333 /*
1620 * ignore, wait for NS query response 1334 * ignore, wait for NS query response
1621 */ 1335 */
@@ -1629,73 +1343,17 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
1629 break; 1343 break;
1630 1344
1631 case RPSM_EVENT_PLOGI_COMP: 1345 case RPSM_EVENT_PLOGI_COMP:
1632 bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online); 1346 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
1633 bfa_fcxp_discard(rport->fcxp); 1347 bfa_fcxp_discard(rport->fcxp);
1634 bfa_fcs_rport_fcs_online_action(rport); 1348 bfa_fcs_rport_hal_online(rport);
1635 break;
1636
1637 default:
1638 bfa_sm_fault(rport->fcs, event);
1639 }
1640}
1641
1642/*
1643 * Rport needs to be deleted
1644 * waiting for ITNIM clean up to finish
1645 */
1646static void
1647bfa_fcs_rport_sm_fc4_off_delete(struct bfa_fcs_rport_s *rport,
1648 enum rport_event event)
1649{
1650 bfa_trc(rport->fcs, rport->pwwn);
1651 bfa_trc(rport->fcs, rport->pid);
1652 bfa_trc(rport->fcs, event);
1653
1654 switch (event) {
1655 case RPSM_EVENT_FC4_OFFLINE:
1656 bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
1657 bfa_fcs_rport_hal_offline(rport);
1658 break;
1659
1660 case RPSM_EVENT_DELETE:
1661 case RPSM_EVENT_PLOGI_RCVD:
1662 /* Ignore these events */
1663 break; 1349 break;
1664 1350
1665 default: 1351 default:
1666 bfa_sm_fault(rport->fcs, event); 1352 bfa_sm_fault(rport->fcs, event);
1667 break;
1668 } 1353 }
1669} 1354}
1670 1355
1671/*
1672 * RPort needs to be deleted
1673 * waiting for BFA/FW to finish current processing
1674 */
1675static void
1676bfa_fcs_rport_sm_delete_pending(struct bfa_fcs_rport_s *rport,
1677 enum rport_event event)
1678{
1679 bfa_trc(rport->fcs, rport->pwwn);
1680 bfa_trc(rport->fcs, rport->pid);
1681 bfa_trc(rport->fcs, event);
1682 1356
1683 switch (event) {
1684 case RPSM_EVENT_HCB_OFFLINE:
1685 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
1686 bfa_fcs_rport_free(rport);
1687 break;
1688
1689 case RPSM_EVENT_DELETE:
1690 case RPSM_EVENT_LOGO_IMP:
1691 case RPSM_EVENT_PLOGI_RCVD:
1692 /* Ignore these events */
1693 break;
1694
1695 default:
1696 bfa_sm_fault(rport->fcs, event);
1697 }
1698}
1699 1357
1700/* 1358/*
1701 * fcs_rport_private FCS RPORT provate functions 1359 * fcs_rport_private FCS RPORT provate functions
@@ -1712,11 +1370,10 @@ bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1712 1370
1713 bfa_trc(rport->fcs, rport->pwwn); 1371 bfa_trc(rport->fcs, rport->pwwn);
1714 1372
1715 fcxp = fcxp_alloced ? fcxp_alloced : 1373 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
1716 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1717 if (!fcxp) { 1374 if (!fcxp) {
1718 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe, 1375 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1719 bfa_fcs_rport_send_plogi, rport, BFA_TRUE); 1376 bfa_fcs_rport_send_plogi, rport);
1720 return; 1377 return;
1721 } 1378 }
1722 rport->fcxp = fcxp; 1379 rport->fcxp = fcxp;
@@ -1833,11 +1490,10 @@ bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1833 bfa_trc(rport->fcs, rport->pwwn); 1490 bfa_trc(rport->fcs, rport->pwwn);
1834 bfa_trc(rport->fcs, rport->reply_oxid); 1491 bfa_trc(rport->fcs, rport->reply_oxid);
1835 1492
1836 fcxp = fcxp_alloced ? fcxp_alloced : 1493 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
1837 bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
1838 if (!fcxp) { 1494 if (!fcxp) {
1839 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe, 1495 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1840 bfa_fcs_rport_send_plogiacc, rport, BFA_FALSE); 1496 bfa_fcs_rport_send_plogiacc, rport);
1841 return; 1497 return;
1842 } 1498 }
1843 rport->fcxp = fcxp; 1499 rport->fcxp = fcxp;
@@ -1866,11 +1522,10 @@ bfa_fcs_rport_send_adisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1866 1522
1867 bfa_trc(rport->fcs, rport->pwwn); 1523 bfa_trc(rport->fcs, rport->pwwn);
1868 1524
1869 fcxp = fcxp_alloced ? fcxp_alloced : 1525 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
1870 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1871 if (!fcxp) { 1526 if (!fcxp) {
1872 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe, 1527 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1873 bfa_fcs_rport_send_adisc, rport, BFA_TRUE); 1528 bfa_fcs_rport_send_adisc, rport);
1874 return; 1529 return;
1875 } 1530 }
1876 rport->fcxp = fcxp; 1531 rport->fcxp = fcxp;
@@ -1930,11 +1585,10 @@ bfa_fcs_rport_send_nsdisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1930 1585
1931 bfa_trc(rport->fcs, rport->pid); 1586 bfa_trc(rport->fcs, rport->pid);
1932 1587
1933 fcxp = fcxp_alloced ? fcxp_alloced : 1588 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
1934 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1935 if (!fcxp) { 1589 if (!fcxp) {
1936 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe, 1590 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
1937 bfa_fcs_rport_send_nsdisc, rport, BFA_TRUE); 1591 bfa_fcs_rport_send_nsdisc, rport);
1938 return; 1592 return;
1939 } 1593 }
1940 rport->fcxp = fcxp; 1594 rport->fcxp = fcxp;
@@ -2087,11 +1741,10 @@ bfa_fcs_rport_send_logo(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2087 1741
2088 port = rport->port; 1742 port = rport->port;
2089 1743
2090 fcxp = fcxp_alloced ? fcxp_alloced : 1744 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
2091 bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
2092 if (!fcxp) { 1745 if (!fcxp) {
2093 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe, 1746 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
2094 bfa_fcs_rport_send_logo, rport, BFA_FALSE); 1747 bfa_fcs_rport_send_logo, rport);
2095 return; 1748 return;
2096 } 1749 }
2097 rport->fcxp = fcxp; 1750 rport->fcxp = fcxp;
@@ -2125,7 +1778,7 @@ bfa_fcs_rport_send_logo_acc(void *rport_cbarg)
2125 1778
2126 port = rport->port; 1779 port = rport->port;
2127 1780
2128 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 1781 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
2129 if (!fcxp) 1782 if (!fcxp)
2130 return; 1783 return;
2131 1784
@@ -2196,7 +1849,7 @@ bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
2196 bfa_fcs_itnim_is_initiator(rport->itnim); 1849 bfa_fcs_itnim_is_initiator(rport->itnim);
2197 } 1850 }
2198 1851
2199 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 1852 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
2200 if (!fcxp) 1853 if (!fcxp)
2201 return; 1854 return;
2202 1855
@@ -2233,7 +1886,7 @@ bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
2233 1886
2234 speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed); 1887 speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
2235 1888
2236 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 1889 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
2237 if (!fcxp) 1890 if (!fcxp)
2238 return; 1891 return;
2239 1892
@@ -2267,7 +1920,7 @@ bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
2267 */ 1920 */
2268 if (bfa_fcs_itnim_get_online_state(rport->itnim) == BFA_STATUS_OK) { 1921 if (bfa_fcs_itnim_get_online_state(rport->itnim) == BFA_STATUS_OK) {
2269 1922
2270 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 1923 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
2271 if (!fcxp) 1924 if (!fcxp)
2272 return; 1925 return;
2273 1926
@@ -2304,15 +1957,6 @@ bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport)
2304 bfa_rport_online(rport->bfa_rport, &rport_info); 1957 bfa_rport_online(rport->bfa_rport, &rport_info);
2305} 1958}
2306 1959
2307static void
2308bfa_fcs_rport_hal_offline(struct bfa_fcs_rport_s *rport)
2309{
2310 if (rport->bfa_rport)
2311 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
2312 else
2313 bfa_cb_rport_offline(rport);
2314}
2315
2316static struct bfa_fcs_rport_s * 1960static struct bfa_fcs_rport_s *
2317bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid) 1961bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
2318{ 1962{
@@ -2323,11 +1967,6 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
2323 /* 1967 /*
2324 * allocate rport 1968 * allocate rport
2325 */ 1969 */
2326 if (fcs->num_rport_logins >= bfa_fcs_rport_max_logins) {
2327 bfa_trc(fcs, rpid);
2328 return NULL;
2329 }
2330
2331 if (bfa_fcb_rport_alloc(fcs->bfad, &rport, &rport_drv) 1970 if (bfa_fcb_rport_alloc(fcs->bfad, &rport, &rport_drv)
2332 != BFA_STATUS_OK) { 1971 != BFA_STATUS_OK) {
2333 bfa_trc(fcs, rpid); 1972 bfa_trc(fcs, rpid);
@@ -2342,9 +1981,16 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
2342 rport->rp_drv = rport_drv; 1981 rport->rp_drv = rport_drv;
2343 rport->pid = rpid; 1982 rport->pid = rpid;
2344 rport->pwwn = pwwn; 1983 rport->pwwn = pwwn;
2345 rport->old_pid = 0;
2346 1984
2347 rport->bfa_rport = NULL; 1985 /*
1986 * allocate BFA rport
1987 */
1988 rport->bfa_rport = bfa_rport_create(port->fcs->bfa, rport);
1989 if (!rport->bfa_rport) {
1990 bfa_trc(fcs, rpid);
1991 kfree(rport_drv);
1992 return NULL;
1993 }
2348 1994
2349 /* 1995 /*
2350 * allocate FC-4s 1996 * allocate FC-4s
@@ -2355,13 +2001,14 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
2355 rport->itnim = bfa_fcs_itnim_create(rport); 2001 rport->itnim = bfa_fcs_itnim_create(rport);
2356 if (!rport->itnim) { 2002 if (!rport->itnim) {
2357 bfa_trc(fcs, rpid); 2003 bfa_trc(fcs, rpid);
2004 bfa_sm_send_event(rport->bfa_rport,
2005 BFA_RPORT_SM_DELETE);
2358 kfree(rport_drv); 2006 kfree(rport_drv);
2359 return NULL; 2007 return NULL;
2360 } 2008 }
2361 } 2009 }
2362 2010
2363 bfa_fcs_lport_add_rport(port, rport); 2011 bfa_fcs_lport_add_rport(port, rport);
2364 fcs->num_rport_logins++;
2365 2012
2366 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit); 2013 bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
2367 2014
@@ -2377,28 +2024,20 @@ static void
2377bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport) 2024bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
2378{ 2025{
2379 struct bfa_fcs_lport_s *port = rport->port; 2026 struct bfa_fcs_lport_s *port = rport->port;
2380 struct bfa_fcs_s *fcs = port->fcs;
2381 2027
2382 /* 2028 /*
2383 * - delete FC-4s 2029 * - delete FC-4s
2384 * - delete BFA rport 2030 * - delete BFA rport
2385 * - remove from queue of rports 2031 * - remove from queue of rports
2386 */ 2032 */
2387 rport->plogi_pending = BFA_FALSE;
2388
2389 if (bfa_fcs_lport_is_initiator(port)) { 2033 if (bfa_fcs_lport_is_initiator(port)) {
2390 bfa_fcs_itnim_delete(rport->itnim); 2034 bfa_fcs_itnim_delete(rport->itnim);
2391 if (rport->pid != 0 && !BFA_FCS_PID_IS_WKA(rport->pid)) 2035 if (rport->pid != 0 && !BFA_FCS_PID_IS_WKA(rport->pid))
2392 bfa_fcs_rpf_rport_offline(rport); 2036 bfa_fcs_rpf_rport_offline(rport);
2393 } 2037 }
2394 2038
2395 if (rport->bfa_rport) { 2039 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);
2396 bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);
2397 rport->bfa_rport = NULL;
2398 }
2399
2400 bfa_fcs_lport_del_rport(port, rport); 2040 bfa_fcs_lport_del_rport(port, rport);
2401 fcs->num_rport_logins--;
2402 kfree(rport->rp_drv); 2041 kfree(rport->rp_drv);
2403} 2042}
2404 2043
@@ -2432,18 +2071,7 @@ bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
2432} 2071}
2433 2072
2434static void 2073static void
2435bfa_fcs_rport_fcs_online_action(struct bfa_fcs_rport_s *rport) 2074bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
2436{
2437 if ((!rport->pid) || (!rport->pwwn)) {
2438 bfa_trc(rport->fcs, rport->pid);
2439 bfa_sm_fault(rport->fcs, rport->pid);
2440 }
2441
2442 bfa_sm_send_event(rport->itnim, BFA_FCS_ITNIM_SM_FCS_ONLINE);
2443}
2444
2445static void
2446bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport)
2447{ 2075{
2448 struct bfa_fcs_lport_s *port = rport->port; 2076 struct bfa_fcs_lport_s *port = rport->port;
2449 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad; 2077 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
@@ -2458,7 +2086,7 @@ bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport)
2458 } 2086 }
2459 2087
2460 if (bfa_fcs_lport_is_initiator(port)) { 2088 if (bfa_fcs_lport_is_initiator(port)) {
2461 bfa_fcs_itnim_brp_online(rport->itnim); 2089 bfa_fcs_itnim_rport_online(rport->itnim);
2462 if (!BFA_FCS_PID_IS_WKA(rport->pid)) 2090 if (!BFA_FCS_PID_IS_WKA(rport->pid))
2463 bfa_fcs_rpf_rport_online(rport); 2091 bfa_fcs_rpf_rport_online(rport);
2464 }; 2092 };
@@ -2474,28 +2102,15 @@ bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport)
2474} 2102}
2475 2103
2476static void 2104static void
2477bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport) 2105bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport)
2478{
2479 if (!BFA_FCS_PID_IS_WKA(rport->pid))
2480 bfa_fcs_rpf_rport_offline(rport);
2481
2482 bfa_fcs_itnim_rport_offline(rport->itnim);
2483}
2484
2485static void
2486bfa_fcs_rport_hal_offline_action(struct bfa_fcs_rport_s *rport)
2487{ 2106{
2488 struct bfa_fcs_lport_s *port = rport->port; 2107 struct bfa_fcs_lport_s *port = rport->port;
2489 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad; 2108 struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
2490 char lpwwn_buf[BFA_STRING_32]; 2109 char lpwwn_buf[BFA_STRING_32];
2491 char rpwwn_buf[BFA_STRING_32]; 2110 char rpwwn_buf[BFA_STRING_32];
2492 2111
2493 if (!rport->bfa_rport) {
2494 bfa_fcs_rport_fcs_offline_action(rport);
2495 return;
2496 }
2497
2498 rport->stats.offlines++; 2112 rport->stats.offlines++;
2113 rport->plogi_pending = BFA_FALSE;
2499 2114
2500 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port)); 2115 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
2501 wwn2str(rpwwn_buf, rport->pwwn); 2116 wwn2str(rpwwn_buf, rport->pwwn);
@@ -2554,10 +2169,7 @@ bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, struct fc_logi_s *plogi)
2554 * - MAX receive frame size 2169 * - MAX receive frame size
2555 */ 2170 */
2556 rport->cisc = plogi->csp.cisc; 2171 rport->cisc = plogi->csp.cisc;
2557 if (be16_to_cpu(plogi->class3.rxsz) < be16_to_cpu(plogi->csp.rxsz)) 2172 rport->maxfrsize = be16_to_cpu(plogi->class3.rxsz);
2558 rport->maxfrsize = be16_to_cpu(plogi->class3.rxsz);
2559 else
2560 rport->maxfrsize = be16_to_cpu(plogi->csp.rxsz);
2561 2173
2562 bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred)); 2174 bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred));
2563 bfa_trc(port->fcs, port->fabric->bb_credit); 2175 bfa_trc(port->fcs, port->fabric->bb_credit);
@@ -2722,9 +2334,10 @@ void
2722bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport) 2334bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport)
2723{ 2335{
2724 rport->stats.rscns++; 2336 rport->stats.rscns++;
2725 bfa_sm_send_event(rport, RPSM_EVENT_FAB_SCN); 2337 bfa_sm_send_event(rport, RPSM_EVENT_SCN);
2726} 2338}
2727 2339
2340
2728/* 2341/*
2729 * brief 2342 * brief
2730 * This routine BFA callback for bfa_rport_online() call. 2343 * This routine BFA callback for bfa_rport_online() call.
@@ -2797,48 +2410,6 @@ bfa_cb_rport_qos_scn_flowid(void *cbarg,
2797 bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_FLOWID, &aen_data); 2410 bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_FLOWID, &aen_data);
2798} 2411}
2799 2412
2800void
2801bfa_cb_rport_scn_online(struct bfa_s *bfa)
2802{
2803 struct bfa_fcs_s *fcs = &((struct bfad_s *)bfa->bfad)->bfa_fcs;
2804 struct bfa_fcs_lport_s *port = bfa_fcs_get_base_port(fcs);
2805 struct bfa_fcs_rport_s *rp;
2806 struct list_head *qe;
2807
2808 list_for_each(qe, &port->rport_q) {
2809 rp = (struct bfa_fcs_rport_s *) qe;
2810 bfa_sm_send_event(rp, RPSM_EVENT_SCN_ONLINE);
2811 rp->scn_online = BFA_TRUE;
2812 }
2813
2814 if (bfa_fcs_lport_is_online(port))
2815 bfa_fcs_lport_lip_scn_online(port);
2816}
2817
2818void
2819bfa_cb_rport_scn_no_dev(void *rport)
2820{
2821 struct bfa_fcs_rport_s *rp = rport;
2822
2823 bfa_sm_send_event(rp, RPSM_EVENT_SCN_OFFLINE);
2824 rp->scn_online = BFA_FALSE;
2825}
2826
2827void
2828bfa_cb_rport_scn_offline(struct bfa_s *bfa)
2829{
2830 struct bfa_fcs_s *fcs = &((struct bfad_s *)bfa->bfad)->bfa_fcs;
2831 struct bfa_fcs_lport_s *port = bfa_fcs_get_base_port(fcs);
2832 struct bfa_fcs_rport_s *rp;
2833 struct list_head *qe;
2834
2835 list_for_each(qe, &port->rport_q) {
2836 rp = (struct bfa_fcs_rport_s *) qe;
2837 bfa_sm_send_event(rp, RPSM_EVENT_SCN_OFFLINE);
2838 rp->scn_online = BFA_FALSE;
2839 }
2840}
2841
2842/* 2413/*
2843 * brief 2414 * brief
2844 * This routine is a static BFA callback when there is a QoS priority 2415 * This routine is a static BFA callback when there is a QoS priority
@@ -2934,7 +2505,7 @@ bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport)
2934 2505
2935 bfa_trc(rport->fcs, rport->pid); 2506 bfa_trc(rport->fcs, rport->pid);
2936 2507
2937 fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE); 2508 fcxp = bfa_fcs_fcxp_alloc(port->fcs);
2938 if (!fcxp) 2509 if (!fcxp)
2939 return; 2510 return;
2940 len = fc_prlo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), 2511 len = fc_prlo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
@@ -2960,7 +2531,7 @@ bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
2960 2531
2961 bfa_trc(rport->fcs, rx_fchs->s_id); 2532 bfa_trc(rport->fcs, rx_fchs->s_id);
2962 2533
2963 fcxp = bfa_fcs_fcxp_alloc(rport->fcs, BFA_FALSE); 2534 fcxp = bfa_fcs_fcxp_alloc(rport->fcs);
2964 if (!fcxp) 2535 if (!fcxp)
2965 return; 2536 return;
2966 2537
@@ -3008,17 +2579,6 @@ bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id)
3008 bfa_sm_send_event(rport, RPSM_EVENT_PRLO_RCVD); 2579 bfa_sm_send_event(rport, RPSM_EVENT_PRLO_RCVD);
3009} 2580}
3010 2581
3011/*
3012 * Called by BFAD to set the max limit on number of bfa_fcs_rport allocation
3013 * which limits number of concurrent logins to remote ports
3014 */
3015void
3016bfa_fcs_rport_set_max_logins(u32 max_logins)
3017{
3018 if (max_logins > 0)
3019 bfa_fcs_rport_max_logins = max_logins;
3020}
3021
3022void 2582void
3023bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport, 2583bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
3024 struct bfa_rport_attr_s *rport_attr) 2584 struct bfa_rport_attr_s *rport_attr)
@@ -3026,9 +2586,6 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
3026 struct bfa_rport_qos_attr_s qos_attr; 2586 struct bfa_rport_qos_attr_s qos_attr;
3027 struct bfa_fcs_lport_s *port = rport->port; 2587 struct bfa_fcs_lport_s *port = rport->port;
3028 bfa_port_speed_t rport_speed = rport->rpf.rpsc_speed; 2588 bfa_port_speed_t rport_speed = rport->rpf.rpsc_speed;
3029 struct bfa_port_attr_s port_attr;
3030
3031 bfa_fcport_get_attr(rport->fcs->bfa, &port_attr);
3032 2589
3033 memset(rport_attr, 0, sizeof(struct bfa_rport_attr_s)); 2590 memset(rport_attr, 0, sizeof(struct bfa_rport_attr_s));
3034 memset(&qos_attr, 0, sizeof(struct bfa_rport_qos_attr_s)); 2591 memset(&qos_attr, 0, sizeof(struct bfa_rport_qos_attr_s));
@@ -3045,11 +2602,9 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
3045 rport_attr->curr_speed = rport->rpf.rpsc_speed; 2602 rport_attr->curr_speed = rport->rpf.rpsc_speed;
3046 rport_attr->assigned_speed = rport->rpf.assigned_speed; 2603 rport_attr->assigned_speed = rport->rpf.assigned_speed;
3047 2604
3048 if (rport->bfa_rport) { 2605 qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority;
3049 qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority; 2606 qos_attr.qos_flow_id =
3050 qos_attr.qos_flow_id = 2607 cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
3051 cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
3052 }
3053 rport_attr->qos_attr = qos_attr; 2608 rport_attr->qos_attr = qos_attr;
3054 2609
3055 rport_attr->trl_enforced = BFA_FALSE; 2610 rport_attr->trl_enforced = BFA_FALSE;
@@ -3059,8 +2614,7 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
3059 rport_speed = 2614 rport_speed =
3060 bfa_fcport_get_ratelim_speed(rport->fcs->bfa); 2615 bfa_fcport_get_ratelim_speed(rport->fcs->bfa);
3061 2616
3062 if ((bfa_fcs_lport_get_rport_max_speed(port) != 2617 if (rport_speed < bfa_fcs_lport_get_rport_max_speed(port))
3063 BFA_PORT_SPEED_UNKNOWN) && (rport_speed < port_attr.speed))
3064 rport_attr->trl_enforced = BFA_TRUE; 2618 rport_attr->trl_enforced = BFA_TRUE;
3065 } 2619 }
3066} 2620}
@@ -3383,11 +2937,10 @@ bfa_fcs_rpf_send_rpsc2(void *rpf_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3383 2937
3384 bfa_trc(rport->fcs, rport->pwwn); 2938 bfa_trc(rport->fcs, rport->pwwn);
3385 2939
3386 fcxp = fcxp_alloced ? fcxp_alloced : 2940 fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
3387 bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3388 if (!fcxp) { 2941 if (!fcxp) {
3389 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rpf->fcxp_wqe, 2942 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rpf->fcxp_wqe,
3390 bfa_fcs_rpf_send_rpsc2, rpf, BFA_TRUE); 2943 bfa_fcs_rpf_send_rpsc2, rpf);
3391 return; 2944 return;
3392 } 2945 }
3393 rpf->fcxp = fcxp; 2946 rpf->fcxp = fcxp;
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index 0116c1032e2..1ac5aecf25a 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -88,13 +88,16 @@ static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
88static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc); 88static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
89static void bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc); 89static void bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc);
90static void bfa_ioc_recover(struct bfa_ioc_s *ioc); 90static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
91static void bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc);
91static void bfa_ioc_event_notify(struct bfa_ioc_s *ioc , 92static void bfa_ioc_event_notify(struct bfa_ioc_s *ioc ,
92 enum bfa_ioc_event_e event); 93 enum bfa_ioc_event_e event);
93static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc); 94static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
94static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc); 95static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
96static void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
95static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc); 97static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);
96static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc); 98static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
97 99
100
98/* 101/*
99 * IOC state machine definitions/declarations 102 * IOC state machine definitions/declarations
100 */ 103 */
@@ -111,6 +114,7 @@ enum ioc_event {
111 IOC_E_HWERROR = 10, /* hardware error interrupt */ 114 IOC_E_HWERROR = 10, /* hardware error interrupt */
112 IOC_E_TIMEOUT = 11, /* timeout */ 115 IOC_E_TIMEOUT = 11, /* timeout */
113 IOC_E_HWFAILED = 12, /* PCI mapping failure notice */ 116 IOC_E_HWFAILED = 12, /* PCI mapping failure notice */
117 IOC_E_FWRSP_ACQ_ADDR = 13, /* Acquiring address */
114}; 118};
115 119
116bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event); 120bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
@@ -123,6 +127,7 @@ bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
123bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event); 127bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
124bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event); 128bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
125bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc_s, enum ioc_event); 129bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc_s, enum ioc_event);
130bfa_fsm_state_decl(bfa_ioc, acq_addr, struct bfa_ioc_s, enum ioc_event);
126 131
127static struct bfa_sm_table_s ioc_sm_table[] = { 132static struct bfa_sm_table_s ioc_sm_table[] = {
128 {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT}, 133 {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
@@ -135,6 +140,7 @@ static struct bfa_sm_table_s ioc_sm_table[] = {
135 {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING}, 140 {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
136 {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED}, 141 {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
137 {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL}, 142 {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL},
143 {BFA_SM(bfa_ioc_sm_acq_addr), BFA_IOC_ACQ_ADDR},
138}; 144};
139 145
140/* 146/*
@@ -365,9 +371,17 @@ bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
365 switch (event) { 371 switch (event) {
366 case IOC_E_FWRSP_GETATTR: 372 case IOC_E_FWRSP_GETATTR:
367 bfa_ioc_timer_stop(ioc); 373 bfa_ioc_timer_stop(ioc);
374 bfa_ioc_check_attr_wwns(ioc);
375 bfa_ioc_hb_monitor(ioc);
368 bfa_fsm_set_state(ioc, bfa_ioc_sm_op); 376 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
369 break; 377 break;
370 378
379 case IOC_E_FWRSP_ACQ_ADDR:
380 bfa_ioc_timer_stop(ioc);
381 bfa_ioc_hb_monitor(ioc);
382 bfa_fsm_set_state(ioc, bfa_ioc_sm_acq_addr);
383 break;
384
371 case IOC_E_PFFAILED: 385 case IOC_E_PFFAILED:
372 case IOC_E_HWERROR: 386 case IOC_E_HWERROR:
373 bfa_ioc_timer_stop(ioc); 387 bfa_ioc_timer_stop(ioc);
@@ -392,6 +406,51 @@ bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
392 } 406 }
393} 407}
394 408
409/*
410 * Acquiring address from fabric (entry function)
411 */
412static void
413bfa_ioc_sm_acq_addr_entry(struct bfa_ioc_s *ioc)
414{
415}
416
417/*
418 * Acquiring address from the fabric
419 */
420static void
421bfa_ioc_sm_acq_addr(struct bfa_ioc_s *ioc, enum ioc_event event)
422{
423 bfa_trc(ioc, event);
424
425 switch (event) {
426 case IOC_E_FWRSP_GETATTR:
427 bfa_ioc_check_attr_wwns(ioc);
428 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
429 break;
430
431 case IOC_E_PFFAILED:
432 case IOC_E_HWERROR:
433 bfa_hb_timer_stop(ioc);
434 case IOC_E_HBFAIL:
435 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
436 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
437 if (event != IOC_E_PFFAILED)
438 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
439 break;
440
441 case IOC_E_DISABLE:
442 bfa_hb_timer_stop(ioc);
443 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
444 break;
445
446 case IOC_E_ENABLE:
447 break;
448
449 default:
450 bfa_sm_fault(ioc, event);
451 }
452}
453
395static void 454static void
396bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc) 455bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
397{ 456{
@@ -399,7 +458,6 @@ bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
399 458
400 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK); 459 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
401 bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED); 460 bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
402 bfa_ioc_hb_monitor(ioc);
403 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n"); 461 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n");
404 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE); 462 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
405} 463}
@@ -598,9 +656,8 @@ bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
598 break; 656 break;
599 657
600 case IOC_E_HWERROR: 658 case IOC_E_HWERROR:
601 case IOC_E_HWFAILED:
602 /* 659 /*
603 * HB failure / HW error notification, ignore. 660 * HB failure notification, ignore.
604 */ 661 */
605 break; 662 break;
606 default: 663 default:
@@ -632,10 +689,6 @@ bfa_ioc_sm_hwfail(struct bfa_ioc_s *ioc, enum ioc_event event)
632 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit); 689 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
633 break; 690 break;
634 691
635 case IOC_E_HWERROR:
636 /* Ignore - already in hwfail state */
637 break;
638
639 default: 692 default:
640 bfa_sm_fault(ioc, event); 693 bfa_sm_fault(ioc, event);
641 } 694 }
@@ -685,59 +738,26 @@ static void
685bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf) 738bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)
686{ 739{
687 struct bfi_ioc_image_hdr_s fwhdr; 740 struct bfi_ioc_image_hdr_s fwhdr;
688 u32 r32, fwstate, pgnum, pgoff, loff = 0; 741 u32 fwstate = readl(iocpf->ioc->ioc_regs.ioc_fwstate);
689 int i;
690
691 /*
692 * Spin on init semaphore to serialize.
693 */
694 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
695 while (r32 & 0x1) {
696 udelay(20);
697 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
698 }
699 742
700 /* h/w sem init */ 743 /* h/w sem init */
701 fwstate = readl(iocpf->ioc->ioc_regs.ioc_fwstate); 744 if (fwstate == BFI_IOC_UNINIT)
702 if (fwstate == BFI_IOC_UNINIT) {
703 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
704 goto sem_get; 745 goto sem_get;
705 }
706 746
707 bfa_ioc_fwver_get(iocpf->ioc, &fwhdr); 747 bfa_ioc_fwver_get(iocpf->ioc, &fwhdr);
708 748
709 if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL) { 749 if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL)
710 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
711 goto sem_get; 750 goto sem_get;
712 }
713
714 /*
715 * Clear fwver hdr
716 */
717 pgnum = PSS_SMEM_PGNUM(iocpf->ioc->ioc_regs.smem_pg0, loff);
718 pgoff = PSS_SMEM_PGOFF(loff);
719 writel(pgnum, iocpf->ioc->ioc_regs.host_page_num_fn);
720
721 for (i = 0; i < sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32); i++) {
722 bfa_mem_write(iocpf->ioc->ioc_regs.smem_page_start, loff, 0);
723 loff += sizeof(u32);
724 }
725 751
726 bfa_trc(iocpf->ioc, fwstate); 752 bfa_trc(iocpf->ioc, fwstate);
727 bfa_trc(iocpf->ioc, swab32(fwhdr.exec)); 753 bfa_trc(iocpf->ioc, fwhdr.exec);
728 writel(BFI_IOC_UNINIT, iocpf->ioc->ioc_regs.ioc_fwstate); 754 writel(BFI_IOC_UNINIT, iocpf->ioc->ioc_regs.ioc_fwstate);
729 writel(BFI_IOC_UNINIT, iocpf->ioc->ioc_regs.alt_ioc_fwstate);
730 755
731 /* 756 /*
732 * Unlock the hw semaphore. Should be here only once per boot. 757 * Try to lock and then unlock the semaphore.
733 */ 758 */
734 bfa_ioc_ownership_reset(iocpf->ioc); 759 readl(iocpf->ioc->ioc_regs.ioc_sem_reg);
735 760 writel(1, iocpf->ioc->ioc_regs.ioc_sem_reg);
736 /*
737 * unlock init semaphore.
738 */
739 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
740
741sem_get: 761sem_get:
742 bfa_ioc_hw_sem_get(iocpf->ioc); 762 bfa_ioc_hw_sem_get(iocpf->ioc);
743} 763}
@@ -1458,7 +1478,7 @@ bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1458 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0); 1478 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1459 1479
1460 for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) { 1480 for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
1461 if (fwhdr->md5sum[i] != cpu_to_le32(drv_fwhdr->md5sum[i])) { 1481 if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i]) {
1462 bfa_trc(ioc, i); 1482 bfa_trc(ioc, i);
1463 bfa_trc(ioc, fwhdr->md5sum[i]); 1483 bfa_trc(ioc, fwhdr->md5sum[i]);
1464 bfa_trc(ioc, drv_fwhdr->md5sum[i]); 1484 bfa_trc(ioc, drv_fwhdr->md5sum[i]);
@@ -1483,7 +1503,7 @@ bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
1483 drv_fwhdr = (struct bfi_ioc_image_hdr_s *) 1503 drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1484 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0); 1504 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1485 1505
1486 if (fwhdr.signature != cpu_to_le32(drv_fwhdr->signature)) { 1506 if (fwhdr.signature != drv_fwhdr->signature) {
1487 bfa_trc(ioc, fwhdr.signature); 1507 bfa_trc(ioc, fwhdr.signature);
1488 bfa_trc(ioc, drv_fwhdr->signature); 1508 bfa_trc(ioc, drv_fwhdr->signature);
1489 return BFA_FALSE; 1509 return BFA_FALSE;
@@ -1687,6 +1707,11 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1687 u32 i; 1707 u32 i;
1688 u32 asicmode; 1708 u32 asicmode;
1689 1709
1710 /*
1711 * Initialize LMEM first before code download
1712 */
1713 bfa_ioc_lmem_init(ioc);
1714
1690 bfa_trc(ioc, bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc))); 1715 bfa_trc(ioc, bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)));
1691 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), chunkno); 1716 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), chunkno);
1692 1717
@@ -1707,7 +1732,7 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1707 * write smem 1732 * write smem
1708 */ 1733 */
1709 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, 1734 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
1710 cpu_to_le32(fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)])); 1735 fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
1711 1736
1712 loff += sizeof(u32); 1737 loff += sizeof(u32);
1713 1738
@@ -1750,7 +1775,6 @@ bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
1750 attr->card_type = be32_to_cpu(attr->card_type); 1775 attr->card_type = be32_to_cpu(attr->card_type);
1751 attr->maxfrsize = be16_to_cpu(attr->maxfrsize); 1776 attr->maxfrsize = be16_to_cpu(attr->maxfrsize);
1752 ioc->fcmode = (attr->port_mode == BFI_PORT_MODE_FC); 1777 ioc->fcmode = (attr->port_mode == BFI_PORT_MODE_FC);
1753 attr->mfg_year = be16_to_cpu(attr->mfg_year);
1754 1778
1755 bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR); 1779 bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1756} 1780}
@@ -1975,12 +1999,6 @@ bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
1975 bfa_ioc_pll_init_asic(ioc); 1999 bfa_ioc_pll_init_asic(ioc);
1976 2000
1977 ioc->pllinit = BFA_TRUE; 2001 ioc->pllinit = BFA_TRUE;
1978
1979 /*
1980 * Initialize LMEM
1981 */
1982 bfa_ioc_lmem_init(ioc);
1983
1984 /* 2002 /*
1985 * release semaphore. 2003 * release semaphore.
1986 */ 2004 */
@@ -2104,6 +2122,10 @@ bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
2104 bfa_ioc_getattr_reply(ioc); 2122 bfa_ioc_getattr_reply(ioc);
2105 break; 2123 break;
2106 2124
2125 case BFI_IOC_I2H_ACQ_ADDR_REPLY:
2126 bfa_fsm_send_event(ioc, IOC_E_FWRSP_ACQ_ADDR);
2127 break;
2128
2107 default: 2129 default:
2108 bfa_trc(ioc, msg->mh.msg_id); 2130 bfa_trc(ioc, msg->mh.msg_id);
2109 WARN_ON(1); 2131 WARN_ON(1);
@@ -2264,12 +2286,6 @@ bfa_ioc_disable(struct bfa_ioc_s *ioc)
2264 bfa_fsm_send_event(ioc, IOC_E_DISABLE); 2286 bfa_fsm_send_event(ioc, IOC_E_DISABLE);
2265} 2287}
2266 2288
2267void
2268bfa_ioc_suspend(struct bfa_ioc_s *ioc)
2269{
2270 ioc->dbg_fwsave_once = BFA_TRUE;
2271 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2272}
2273 2289
2274/* 2290/*
2275 * Initialize memory for saving firmware trace. Driver must initialize 2291 * Initialize memory for saving firmware trace. Driver must initialize
@@ -2279,7 +2295,7 @@ void
2279bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave) 2295bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
2280{ 2296{
2281 ioc->dbg_fwsave = dbg_fwsave; 2297 ioc->dbg_fwsave = dbg_fwsave;
2282 ioc->dbg_fwsave_len = BFA_DBG_FWTRC_LEN; 2298 ioc->dbg_fwsave_len = (ioc->iocpf.auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
2283} 2299}
2284 2300
2285/* 2301/*
@@ -2367,7 +2383,7 @@ bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc)
2367 return; 2383 return;
2368 } 2384 }
2369 2385
2370 if ((mc >= BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL)) 2386 if ((mc > BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
2371 return; 2387 return;
2372 2388
2373 mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m); 2389 mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
@@ -2400,6 +2416,15 @@ bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
2400} 2416}
2401 2417
2402/* 2418/*
2419 * Return TRUE if IOC is in acquiring address state
2420 */
2421bfa_boolean_t
2422bfa_ioc_is_acq_addr(struct bfa_ioc_s *ioc)
2423{
2424 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_acq_addr);
2425}
2426
2427/*
2403 * return true if IOC firmware is different. 2428 * return true if IOC firmware is different.
2404 */ 2429 */
2405bfa_boolean_t 2430bfa_boolean_t
@@ -2497,9 +2522,6 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
2497 ad_attr->cna_capable = bfa_ioc_is_cna(ioc); 2522 ad_attr->cna_capable = bfa_ioc_is_cna(ioc);
2498 ad_attr->trunk_capable = (ad_attr->nports > 1) && 2523 ad_attr->trunk_capable = (ad_attr->nports > 1) &&
2499 !bfa_ioc_is_cna(ioc) && !ad_attr->is_mezz; 2524 !bfa_ioc_is_cna(ioc) && !ad_attr->is_mezz;
2500 ad_attr->mfg_day = ioc_attr->mfg_day;
2501 ad_attr->mfg_month = ioc_attr->mfg_month;
2502 ad_attr->mfg_year = ioc_attr->mfg_year;
2503} 2525}
2504 2526
2505enum bfa_ioc_type_e 2527enum bfa_ioc_type_e
@@ -2869,7 +2891,7 @@ bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
2869/* 2891/*
2870 * Save firmware trace if configured. 2892 * Save firmware trace if configured.
2871 */ 2893 */
2872void 2894static void
2873bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc) 2895bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc)
2874{ 2896{
2875 int tlen; 2897 int tlen;
@@ -2894,6 +2916,17 @@ bfa_ioc_recover(struct bfa_ioc_s *ioc)
2894 bfa_fsm_send_event(ioc, IOC_E_HBFAIL); 2916 bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
2895} 2917}
2896 2918
2919static void
2920bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
2921{
2922 if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
2923 return;
2924 if (ioc->attr->nwwn == 0)
2925 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_NWWN);
2926 if (ioc->attr->pwwn == 0)
2927 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_PWWN);
2928}
2929
2897/* 2930/*
2898 * BFA IOC PF private functions 2931 * BFA IOC PF private functions
2899 */ 2932 */
@@ -2926,7 +2959,7 @@ bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc)
2926 return; 2959 return;
2927 } 2960 }
2928 2961
2929 if (ioc->iocpf.poll_time >= (3 * BFA_IOC_TOV)) 2962 if (ioc->iocpf.poll_time >= BFA_IOC_TOV)
2930 bfa_iocpf_timeout(ioc); 2963 bfa_iocpf_timeout(ioc);
2931 else { 2964 else {
2932 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV; 2965 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV;
@@ -3019,6 +3052,7 @@ bfa_ablk_config_swap(struct bfa_ablk_cfg_s *cfg)
3019 struct bfa_ablk_cfg_inst_s *cfg_inst; 3052 struct bfa_ablk_cfg_inst_s *cfg_inst;
3020 int i, j; 3053 int i, j;
3021 u16 be16; 3054 u16 be16;
3055 u32 be32;
3022 3056
3023 for (i = 0; i < BFA_ABLK_MAX; i++) { 3057 for (i = 0; i < BFA_ABLK_MAX; i++) {
3024 cfg_inst = &cfg->inst[i]; 3058 cfg_inst = &cfg->inst[i];
@@ -3029,10 +3063,8 @@ bfa_ablk_config_swap(struct bfa_ablk_cfg_s *cfg)
3029 cfg_inst->pf_cfg[j].num_qpairs = be16_to_cpu(be16); 3063 cfg_inst->pf_cfg[j].num_qpairs = be16_to_cpu(be16);
3030 be16 = cfg_inst->pf_cfg[j].num_vectors; 3064 be16 = cfg_inst->pf_cfg[j].num_vectors;
3031 cfg_inst->pf_cfg[j].num_vectors = be16_to_cpu(be16); 3065 cfg_inst->pf_cfg[j].num_vectors = be16_to_cpu(be16);
3032 be16 = cfg_inst->pf_cfg[j].bw_min; 3066 be32 = cfg_inst->pf_cfg[j].bw;
3033 cfg_inst->pf_cfg[j].bw_min = be16_to_cpu(be16); 3067 cfg_inst->pf_cfg[j].bw = be16_to_cpu(be32);
3034 be16 = cfg_inst->pf_cfg[j].bw_max;
3035 cfg_inst->pf_cfg[j].bw_max = be16_to_cpu(be16);
3036 } 3068 }
3037 } 3069 }
3038} 3070}
@@ -3174,8 +3206,7 @@ bfa_ablk_query(struct bfa_ablk_s *ablk, struct bfa_ablk_cfg_s *ablk_cfg,
3174 3206
3175bfa_status_t 3207bfa_status_t
3176bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn, 3208bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
3177 u8 port, enum bfi_pcifn_class personality, 3209 u8 port, enum bfi_pcifn_class personality, int bw,
3178 u16 bw_min, u16 bw_max,
3179 bfa_ablk_cbfn_t cbfn, void *cbarg) 3210 bfa_ablk_cbfn_t cbfn, void *cbarg)
3180{ 3211{
3181 struct bfi_ablk_h2i_pf_req_s *m; 3212 struct bfi_ablk_h2i_pf_req_s *m;
@@ -3199,8 +3230,7 @@ bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
3199 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_CREATE, 3230 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_CREATE,
3200 bfa_ioc_portid(ablk->ioc)); 3231 bfa_ioc_portid(ablk->ioc));
3201 m->pers = cpu_to_be16((u16)personality); 3232 m->pers = cpu_to_be16((u16)personality);
3202 m->bw_min = cpu_to_be16(bw_min); 3233 m->bw = cpu_to_be32(bw);
3203 m->bw_max = cpu_to_be16(bw_max);
3204 m->port = port; 3234 m->port = port;
3205 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb); 3235 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3206 3236
@@ -3300,8 +3330,8 @@ bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port, enum bfa_mode_s mode,
3300} 3330}
3301 3331
3302bfa_status_t 3332bfa_status_t
3303bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, u16 bw_min, 3333bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, int bw,
3304 u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg) 3334 bfa_ablk_cbfn_t cbfn, void *cbarg)
3305{ 3335{
3306 struct bfi_ablk_h2i_pf_req_s *m; 3336 struct bfi_ablk_h2i_pf_req_s *m;
3307 3337
@@ -3323,8 +3353,7 @@ bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, u16 bw_min,
3323 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_UPDATE, 3353 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_UPDATE,
3324 bfa_ioc_portid(ablk->ioc)); 3354 bfa_ioc_portid(ablk->ioc));
3325 m->pcifn = (u8)pcifn; 3355 m->pcifn = (u8)pcifn;
3326 m->bw_min = cpu_to_be16(bw_min); 3356 m->bw = cpu_to_be32(bw);
3327 m->bw_max = cpu_to_be16(bw_max);
3328 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb); 3357 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3329 3358
3330 return BFA_STATUS_OK; 3359 return BFA_STATUS_OK;
@@ -3698,11 +3727,11 @@ bfa_sfp_media_get(struct bfa_sfp_s *sfp)
3698 (xmtr_tech & SFP_XMTR_TECH_SA)) 3727 (xmtr_tech & SFP_XMTR_TECH_SA))
3699 *media = BFA_SFP_MEDIA_SW; 3728 *media = BFA_SFP_MEDIA_SW;
3700 /* Check 10G Ethernet Compilance code */ 3729 /* Check 10G Ethernet Compilance code */
3701 else if (e10g.r.e10g_sr) 3730 else if (e10g.b & 0x10)
3702 *media = BFA_SFP_MEDIA_SW; 3731 *media = BFA_SFP_MEDIA_SW;
3703 else if (e10g.r.e10g_lrm && e10g.r.e10g_lr) 3732 else if (e10g.b & 0x60)
3704 *media = BFA_SFP_MEDIA_LW; 3733 *media = BFA_SFP_MEDIA_LW;
3705 else if (e10g.r.e10g_unall) 3734 else if (e10g.r.e10g_unall & 0x80)
3706 *media = BFA_SFP_MEDIA_UNKNOWN; 3735 *media = BFA_SFP_MEDIA_UNKNOWN;
3707 else 3736 else
3708 bfa_trc(sfp, 0); 3737 bfa_trc(sfp, 0);
@@ -4466,7 +4495,7 @@ bfa_flash_read_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4466 */ 4495 */
4467 4496
4468#define BFA_DIAG_MEMTEST_TOV 50000 /* memtest timeout in msec */ 4497#define BFA_DIAG_MEMTEST_TOV 50000 /* memtest timeout in msec */
4469#define CT2_BFA_DIAG_MEMTEST_TOV (9*30*1000) /* 4.5 min */ 4498#define BFA_DIAG_FWPING_TOV 1000 /* msec */
4470 4499
4471/* IOC event handler */ 4500/* IOC event handler */
4472static void 4501static void
@@ -4687,25 +4716,22 @@ diag_tempsensor_comp(struct bfa_diag_s *diag, bfi_diag_ts_rsp_t *rsp)
4687 diag->tsensor.temp->temp = be16_to_cpu(rsp->temp); 4716 diag->tsensor.temp->temp = be16_to_cpu(rsp->temp);
4688 diag->tsensor.temp->ts_junc = rsp->ts_junc; 4717 diag->tsensor.temp->ts_junc = rsp->ts_junc;
4689 diag->tsensor.temp->ts_brd = rsp->ts_brd; 4718 diag->tsensor.temp->ts_brd = rsp->ts_brd;
4719 diag->tsensor.temp->status = BFA_STATUS_OK;
4690 4720
4691 if (rsp->ts_brd) { 4721 if (rsp->ts_brd) {
4692 /* tsensor.temp->status is brd_temp status */
4693 diag->tsensor.temp->status = rsp->status;
4694 if (rsp->status == BFA_STATUS_OK) { 4722 if (rsp->status == BFA_STATUS_OK) {
4695 diag->tsensor.temp->brd_temp = 4723 diag->tsensor.temp->brd_temp =
4696 be16_to_cpu(rsp->brd_temp); 4724 be16_to_cpu(rsp->brd_temp);
4697 } else 4725 } else {
4726 bfa_trc(diag, rsp->status);
4698 diag->tsensor.temp->brd_temp = 0; 4727 diag->tsensor.temp->brd_temp = 0;
4728 diag->tsensor.temp->status = BFA_STATUS_DEVBUSY;
4729 }
4699 } 4730 }
4700
4701 bfa_trc(diag, rsp->status);
4702 bfa_trc(diag, rsp->ts_junc); 4731 bfa_trc(diag, rsp->ts_junc);
4703 bfa_trc(diag, rsp->temp); 4732 bfa_trc(diag, rsp->temp);
4704 bfa_trc(diag, rsp->ts_brd); 4733 bfa_trc(diag, rsp->ts_brd);
4705 bfa_trc(diag, rsp->brd_temp); 4734 bfa_trc(diag, rsp->brd_temp);
4706
4707 /* tsensor status is always good bcos we always have junction temp */
4708 diag->tsensor.status = BFA_STATUS_OK;
4709 diag->tsensor.cbfn(diag->tsensor.cbarg, diag->tsensor.status); 4735 diag->tsensor.cbfn(diag->tsensor.cbarg, diag->tsensor.status);
4710 diag->tsensor.lock = 0; 4736 diag->tsensor.lock = 0;
4711} 4737}
@@ -4746,7 +4772,7 @@ diag_ledtest_send(struct bfa_diag_s *diag, struct bfa_diag_ledtest_s *ledtest)
4746} 4772}
4747 4773
4748static void 4774static void
4749diag_ledtest_comp(struct bfa_diag_s *diag, struct bfi_diag_ledtest_rsp_s *msg) 4775diag_ledtest_comp(struct bfa_diag_s *diag, struct bfi_diag_ledtest_rsp_s * msg)
4750{ 4776{
4751 bfa_trc(diag, diag->ledtest.lock); 4777 bfa_trc(diag, diag->ledtest.lock);
4752 diag->ledtest.lock = BFA_FALSE; 4778 diag->ledtest.lock = BFA_FALSE;
@@ -4824,8 +4850,6 @@ bfa_diag_memtest(struct bfa_diag_s *diag, struct bfa_diag_memtest_s *memtest,
4824 u32 pattern, struct bfa_diag_memtest_result *result, 4850 u32 pattern, struct bfa_diag_memtest_result *result,
4825 bfa_cb_diag_t cbfn, void *cbarg) 4851 bfa_cb_diag_t cbfn, void *cbarg)
4826{ 4852{
4827 u32 memtest_tov;
4828
4829 bfa_trc(diag, pattern); 4853 bfa_trc(diag, pattern);
4830 4854
4831 if (!bfa_ioc_adapter_is_disabled(diag->ioc)) 4855 if (!bfa_ioc_adapter_is_disabled(diag->ioc))
@@ -4845,10 +4869,8 @@ bfa_diag_memtest(struct bfa_diag_s *diag, struct bfa_diag_memtest_s *memtest,
4845 /* download memtest code and take LPU0 out of reset */ 4869 /* download memtest code and take LPU0 out of reset */
4846 bfa_ioc_boot(diag->ioc, BFI_FWBOOT_TYPE_MEMTEST, BFI_FWBOOT_ENV_OS); 4870 bfa_ioc_boot(diag->ioc, BFI_FWBOOT_TYPE_MEMTEST, BFI_FWBOOT_ENV_OS);
4847 4871
4848 memtest_tov = (bfa_ioc_asic_gen(diag->ioc) == BFI_ASIC_GEN_CT2) ?
4849 CT2_BFA_DIAG_MEMTEST_TOV : BFA_DIAG_MEMTEST_TOV;
4850 bfa_timer_begin(diag->ioc->timer_mod, &diag->timer, 4872 bfa_timer_begin(diag->ioc->timer_mod, &diag->timer,
4851 bfa_diag_memtest_done, diag, memtest_tov); 4873 bfa_diag_memtest_done, diag, BFA_DIAG_MEMTEST_TOV);
4852 diag->timer_active = 1; 4874 diag->timer_active = 1;
4853 return BFA_STATUS_OK; 4875 return BFA_STATUS_OK;
4854} 4876}
@@ -4934,7 +4956,6 @@ bfa_diag_tsensor_query(struct bfa_diag_s *diag,
4934 diag->tsensor.temp = result; 4956 diag->tsensor.temp = result;
4935 diag->tsensor.cbfn = cbfn; 4957 diag->tsensor.cbfn = cbfn;
4936 diag->tsensor.cbarg = cbarg; 4958 diag->tsensor.cbarg = cbarg;
4937 diag->tsensor.status = BFA_STATUS_OK;
4938 4959
4939 /* Send msg to fw */ 4960 /* Send msg to fw */
4940 diag_tempsensor_send(diag); 4961 diag_tempsensor_send(diag);
@@ -5608,7 +5629,7 @@ static bfa_status_t bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf);
5608static void bfa_dconf_init_cb(void *arg, bfa_status_t status); 5629static void bfa_dconf_init_cb(void *arg, bfa_status_t status);
5609 5630
5610/* 5631/*
5611 * Beginning state of dconf module. Waiting for an event to start. 5632 * Begining state of dconf module. Waiting for an event to start.
5612 */ 5633 */
5613static void 5634static void
5614bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event) 5635bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
@@ -5620,27 +5641,24 @@ bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5620 case BFA_DCONF_SM_INIT: 5641 case BFA_DCONF_SM_INIT:
5621 if (dconf->min_cfg) { 5642 if (dconf->min_cfg) {
5622 bfa_trc(dconf->bfa, dconf->min_cfg); 5643 bfa_trc(dconf->bfa, dconf->min_cfg);
5623 bfa_fsm_send_event(&dconf->bfa->iocfc,
5624 IOCFC_E_DCONF_DONE);
5625 return; 5644 return;
5626 } 5645 }
5627 bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read); 5646 bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read);
5628 bfa_timer_start(dconf->bfa, &dconf->timer, 5647 dconf->flashdone = BFA_FALSE;
5629 bfa_dconf_timer, dconf, 2 * BFA_DCONF_UPDATE_TOV); 5648 bfa_trc(dconf->bfa, dconf->flashdone);
5630 bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa), 5649 bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa),
5631 BFA_FLASH_PART_DRV, dconf->instance, 5650 BFA_FLASH_PART_DRV, dconf->instance,
5632 dconf->dconf, 5651 dconf->dconf,
5633 sizeof(struct bfa_dconf_s), 0, 5652 sizeof(struct bfa_dconf_s), 0,
5634 bfa_dconf_init_cb, dconf->bfa); 5653 bfa_dconf_init_cb, dconf->bfa);
5635 if (bfa_status != BFA_STATUS_OK) { 5654 if (bfa_status != BFA_STATUS_OK) {
5636 bfa_timer_stop(&dconf->timer);
5637 bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED); 5655 bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED);
5638 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5656 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5639 return; 5657 return;
5640 } 5658 }
5641 break; 5659 break;
5642 case BFA_DCONF_SM_EXIT: 5660 case BFA_DCONF_SM_EXIT:
5643 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE); 5661 dconf->flashdone = BFA_TRUE;
5644 case BFA_DCONF_SM_IOCDISABLE: 5662 case BFA_DCONF_SM_IOCDISABLE:
5645 case BFA_DCONF_SM_WR: 5663 case BFA_DCONF_SM_WR:
5646 case BFA_DCONF_SM_FLASH_COMP: 5664 case BFA_DCONF_SM_FLASH_COMP:
@@ -5661,20 +5679,15 @@ bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
5661 5679
5662 switch (event) { 5680 switch (event) {
5663 case BFA_DCONF_SM_FLASH_COMP: 5681 case BFA_DCONF_SM_FLASH_COMP:
5664 bfa_timer_stop(&dconf->timer);
5665 bfa_sm_set_state(dconf, bfa_dconf_sm_ready); 5682 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5666 break; 5683 break;
5667 case BFA_DCONF_SM_TIMEOUT: 5684 case BFA_DCONF_SM_TIMEOUT:
5668 bfa_sm_set_state(dconf, bfa_dconf_sm_ready); 5685 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5669 bfa_ioc_suspend(&dconf->bfa->ioc);
5670 break; 5686 break;
5671 case BFA_DCONF_SM_EXIT: 5687 case BFA_DCONF_SM_EXIT:
5672 bfa_timer_stop(&dconf->timer); 5688 dconf->flashdone = BFA_TRUE;
5673 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5689 bfa_trc(dconf->bfa, dconf->flashdone);
5674 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5675 break;
5676 case BFA_DCONF_SM_IOCDISABLE: 5690 case BFA_DCONF_SM_IOCDISABLE:
5677 bfa_timer_stop(&dconf->timer);
5678 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5691 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5679 break; 5692 break;
5680 default: 5693 default:
@@ -5697,8 +5710,9 @@ bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5697 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty); 5710 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5698 break; 5711 break;
5699 case BFA_DCONF_SM_EXIT: 5712 case BFA_DCONF_SM_EXIT:
5713 dconf->flashdone = BFA_TRUE;
5714 bfa_trc(dconf->bfa, dconf->flashdone);
5700 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5715 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5701 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5702 break; 5716 break;
5703 case BFA_DCONF_SM_INIT: 5717 case BFA_DCONF_SM_INIT:
5704 case BFA_DCONF_SM_IOCDISABLE: 5718 case BFA_DCONF_SM_IOCDISABLE:
@@ -5760,7 +5774,9 @@ bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
5760 bfa_timer_stop(&dconf->timer); 5774 bfa_timer_stop(&dconf->timer);
5761 case BFA_DCONF_SM_TIMEOUT: 5775 case BFA_DCONF_SM_TIMEOUT:
5762 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5776 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5763 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE); 5777 dconf->flashdone = BFA_TRUE;
5778 bfa_trc(dconf->bfa, dconf->flashdone);
5779 bfa_ioc_disable(&dconf->bfa->ioc);
5764 break; 5780 break;
5765 default: 5781 default:
5766 bfa_sm_fault(dconf->bfa, event); 5782 bfa_sm_fault(dconf->bfa, event);
@@ -5807,8 +5823,8 @@ bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
5807 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty); 5823 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5808 break; 5824 break;
5809 case BFA_DCONF_SM_EXIT: 5825 case BFA_DCONF_SM_EXIT:
5826 dconf->flashdone = BFA_TRUE;
5810 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit); 5827 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5811 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5812 break; 5828 break;
5813 case BFA_DCONF_SM_IOCDISABLE: 5829 case BFA_DCONF_SM_IOCDISABLE:
5814 break; 5830 break;
@@ -5849,6 +5865,11 @@ bfa_dconf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5849 if (cfg->drvcfg.min_cfg) { 5865 if (cfg->drvcfg.min_cfg) {
5850 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s); 5866 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s);
5851 dconf->min_cfg = BFA_TRUE; 5867 dconf->min_cfg = BFA_TRUE;
5868 /*
5869 * Set the flashdone flag to TRUE explicitly as no flash
5870 * write will happen in min_cfg mode.
5871 */
5872 dconf->flashdone = BFA_TRUE;
5852 } else { 5873 } else {
5853 dconf->min_cfg = BFA_FALSE; 5874 dconf->min_cfg = BFA_FALSE;
5854 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s); 5875 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s);
@@ -5864,6 +5885,9 @@ bfa_dconf_init_cb(void *arg, bfa_status_t status)
5864 struct bfa_s *bfa = arg; 5885 struct bfa_s *bfa = arg;
5865 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa); 5886 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5866 5887
5888 dconf->flashdone = BFA_TRUE;
5889 bfa_trc(bfa, dconf->flashdone);
5890 bfa_iocfc_cb_dconf_modinit(bfa, status);
5867 if (status == BFA_STATUS_OK) { 5891 if (status == BFA_STATUS_OK) {
5868 bfa_dconf_read_data_valid(bfa) = BFA_TRUE; 5892 bfa_dconf_read_data_valid(bfa) = BFA_TRUE;
5869 if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE) 5893 if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE)
@@ -5872,7 +5896,6 @@ bfa_dconf_init_cb(void *arg, bfa_status_t status)
5872 dconf->dconf->hdr.version = BFI_DCONF_VERSION; 5896 dconf->dconf->hdr.version = BFI_DCONF_VERSION;
5873 } 5897 }
5874 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP); 5898 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
5875 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DCONF_DONE);
5876} 5899}
5877 5900
5878void 5901void
@@ -5954,450 +5977,7 @@ void
5954bfa_dconf_modexit(struct bfa_s *bfa) 5977bfa_dconf_modexit(struct bfa_s *bfa)
5955{ 5978{
5956 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa); 5979 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5980 BFA_DCONF_MOD(bfa)->flashdone = BFA_FALSE;
5981 bfa_trc(bfa, BFA_DCONF_MOD(bfa)->flashdone);
5957 bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT); 5982 bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT);
5958} 5983}
5959
5960/*
5961 * FRU specific functions
5962 */
5963
5964#define BFA_FRU_DMA_BUF_SZ 0x02000 /* 8k dma buffer */
5965#define BFA_FRU_CHINOOK_MAX_SIZE 0x10000
5966#define BFA_FRU_LIGHTNING_MAX_SIZE 0x200
5967
5968static void
5969bfa_fru_notify(void *cbarg, enum bfa_ioc_event_e event)
5970{
5971 struct bfa_fru_s *fru = cbarg;
5972
5973 bfa_trc(fru, event);
5974
5975 switch (event) {
5976 case BFA_IOC_E_DISABLED:
5977 case BFA_IOC_E_FAILED:
5978 if (fru->op_busy) {
5979 fru->status = BFA_STATUS_IOC_FAILURE;
5980 fru->cbfn(fru->cbarg, fru->status);
5981 fru->op_busy = 0;
5982 }
5983 break;
5984
5985 default:
5986 break;
5987 }
5988}
5989
5990/*
5991 * Send fru write request.
5992 *
5993 * @param[in] cbarg - callback argument
5994 */
5995static void
5996bfa_fru_write_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
5997{
5998 struct bfa_fru_s *fru = cbarg;
5999 struct bfi_fru_write_req_s *msg =
6000 (struct bfi_fru_write_req_s *) fru->mb.msg;
6001 u32 len;
6002
6003 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6004 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6005 fru->residue : BFA_FRU_DMA_BUF_SZ;
6006 msg->length = cpu_to_be32(len);
6007
6008 /*
6009 * indicate if it's the last msg of the whole write operation
6010 */
6011 msg->last = (len == fru->residue) ? 1 : 0;
6012
6013 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6014 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6015
6016 memcpy(fru->dbuf_kva, fru->ubuf + fru->offset, len);
6017 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6018
6019 fru->residue -= len;
6020 fru->offset += len;
6021}
6022
6023/*
6024 * Send fru read request.
6025 *
6026 * @param[in] cbarg - callback argument
6027 */
6028static void
6029bfa_fru_read_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
6030{
6031 struct bfa_fru_s *fru = cbarg;
6032 struct bfi_fru_read_req_s *msg =
6033 (struct bfi_fru_read_req_s *) fru->mb.msg;
6034 u32 len;
6035
6036 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6037 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6038 fru->residue : BFA_FRU_DMA_BUF_SZ;
6039 msg->length = cpu_to_be32(len);
6040 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6041 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6042 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6043}
6044
6045/*
6046 * Flash memory info API.
6047 *
6048 * @param[in] mincfg - minimal cfg variable
6049 */
6050u32
6051bfa_fru_meminfo(bfa_boolean_t mincfg)
6052{
6053 /* min driver doesn't need fru */
6054 if (mincfg)
6055 return 0;
6056
6057 return BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6058}
6059
6060/*
6061 * Flash attach API.
6062 *
6063 * @param[in] fru - fru structure
6064 * @param[in] ioc - ioc structure
6065 * @param[in] dev - device structure
6066 * @param[in] trcmod - trace module
6067 * @param[in] logmod - log module
6068 */
6069void
6070bfa_fru_attach(struct bfa_fru_s *fru, struct bfa_ioc_s *ioc, void *dev,
6071 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
6072{
6073 fru->ioc = ioc;
6074 fru->trcmod = trcmod;
6075 fru->cbfn = NULL;
6076 fru->cbarg = NULL;
6077 fru->op_busy = 0;
6078
6079 bfa_ioc_mbox_regisr(fru->ioc, BFI_MC_FRU, bfa_fru_intr, fru);
6080 bfa_q_qe_init(&fru->ioc_notify);
6081 bfa_ioc_notify_init(&fru->ioc_notify, bfa_fru_notify, fru);
6082 list_add_tail(&fru->ioc_notify.qe, &fru->ioc->notify_q);
6083
6084 /* min driver doesn't need fru */
6085 if (mincfg) {
6086 fru->dbuf_kva = NULL;
6087 fru->dbuf_pa = 0;
6088 }
6089}
6090
6091/*
6092 * Claim memory for fru
6093 *
6094 * @param[in] fru - fru structure
6095 * @param[in] dm_kva - pointer to virtual memory address
6096 * @param[in] dm_pa - frusical memory address
6097 * @param[in] mincfg - minimal cfg variable
6098 */
6099void
6100bfa_fru_memclaim(struct bfa_fru_s *fru, u8 *dm_kva, u64 dm_pa,
6101 bfa_boolean_t mincfg)
6102{
6103 if (mincfg)
6104 return;
6105
6106 fru->dbuf_kva = dm_kva;
6107 fru->dbuf_pa = dm_pa;
6108 memset(fru->dbuf_kva, 0, BFA_FRU_DMA_BUF_SZ);
6109 dm_kva += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6110 dm_pa += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6111}
6112
6113/*
6114 * Update fru vpd image.
6115 *
6116 * @param[in] fru - fru structure
6117 * @param[in] buf - update data buffer
6118 * @param[in] len - data buffer length
6119 * @param[in] offset - offset relative to starting address
6120 * @param[in] cbfn - callback function
6121 * @param[in] cbarg - callback argument
6122 *
6123 * Return status.
6124 */
6125bfa_status_t
6126bfa_fruvpd_update(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6127 bfa_cb_fru_t cbfn, void *cbarg)
6128{
6129 bfa_trc(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6130 bfa_trc(fru, len);
6131 bfa_trc(fru, offset);
6132
6133 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6134 return BFA_STATUS_FRU_NOT_PRESENT;
6135
6136 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK)
6137 return BFA_STATUS_CMD_NOTSUPP;
6138
6139 if (!bfa_ioc_is_operational(fru->ioc))
6140 return BFA_STATUS_IOC_NON_OP;
6141
6142 if (fru->op_busy) {
6143 bfa_trc(fru, fru->op_busy);
6144 return BFA_STATUS_DEVBUSY;
6145 }
6146
6147 fru->op_busy = 1;
6148
6149 fru->cbfn = cbfn;
6150 fru->cbarg = cbarg;
6151 fru->residue = len;
6152 fru->offset = 0;
6153 fru->addr_off = offset;
6154 fru->ubuf = buf;
6155
6156 bfa_fru_write_send(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6157
6158 return BFA_STATUS_OK;
6159}
6160
6161/*
6162 * Read fru vpd image.
6163 *
6164 * @param[in] fru - fru structure
6165 * @param[in] buf - read data buffer
6166 * @param[in] len - data buffer length
6167 * @param[in] offset - offset relative to starting address
6168 * @param[in] cbfn - callback function
6169 * @param[in] cbarg - callback argument
6170 *
6171 * Return status.
6172 */
6173bfa_status_t
6174bfa_fruvpd_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6175 bfa_cb_fru_t cbfn, void *cbarg)
6176{
6177 bfa_trc(fru, BFI_FRUVPD_H2I_READ_REQ);
6178 bfa_trc(fru, len);
6179 bfa_trc(fru, offset);
6180
6181 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6182 return BFA_STATUS_FRU_NOT_PRESENT;
6183
6184 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK)
6185 return BFA_STATUS_CMD_NOTSUPP;
6186
6187 if (!bfa_ioc_is_operational(fru->ioc))
6188 return BFA_STATUS_IOC_NON_OP;
6189
6190 if (fru->op_busy) {
6191 bfa_trc(fru, fru->op_busy);
6192 return BFA_STATUS_DEVBUSY;
6193 }
6194
6195 fru->op_busy = 1;
6196
6197 fru->cbfn = cbfn;
6198 fru->cbarg = cbarg;
6199 fru->residue = len;
6200 fru->offset = 0;
6201 fru->addr_off = offset;
6202 fru->ubuf = buf;
6203 bfa_fru_read_send(fru, BFI_FRUVPD_H2I_READ_REQ);
6204
6205 return BFA_STATUS_OK;
6206}
6207
6208/*
6209 * Get maximum size fru vpd image.
6210 *
6211 * @param[in] fru - fru structure
6212 * @param[out] size - maximum size of fru vpd data
6213 *
6214 * Return status.
6215 */
6216bfa_status_t
6217bfa_fruvpd_get_max_size(struct bfa_fru_s *fru, u32 *max_size)
6218{
6219 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6220 return BFA_STATUS_FRU_NOT_PRESENT;
6221
6222 if (!bfa_ioc_is_operational(fru->ioc))
6223 return BFA_STATUS_IOC_NON_OP;
6224
6225 if (fru->ioc->attr->card_type == BFA_MFG_TYPE_CHINOOK)
6226 *max_size = BFA_FRU_CHINOOK_MAX_SIZE;
6227 else
6228 return BFA_STATUS_CMD_NOTSUPP;
6229 return BFA_STATUS_OK;
6230}
6231/*
6232 * tfru write.
6233 *
6234 * @param[in] fru - fru structure
6235 * @param[in] buf - update data buffer
6236 * @param[in] len - data buffer length
6237 * @param[in] offset - offset relative to starting address
6238 * @param[in] cbfn - callback function
6239 * @param[in] cbarg - callback argument
6240 *
6241 * Return status.
6242 */
6243bfa_status_t
6244bfa_tfru_write(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6245 bfa_cb_fru_t cbfn, void *cbarg)
6246{
6247 bfa_trc(fru, BFI_TFRU_H2I_WRITE_REQ);
6248 bfa_trc(fru, len);
6249 bfa_trc(fru, offset);
6250 bfa_trc(fru, *((u8 *) buf));
6251
6252 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6253 return BFA_STATUS_FRU_NOT_PRESENT;
6254
6255 if (!bfa_ioc_is_operational(fru->ioc))
6256 return BFA_STATUS_IOC_NON_OP;
6257
6258 if (fru->op_busy) {
6259 bfa_trc(fru, fru->op_busy);
6260 return BFA_STATUS_DEVBUSY;
6261 }
6262
6263 fru->op_busy = 1;
6264
6265 fru->cbfn = cbfn;
6266 fru->cbarg = cbarg;
6267 fru->residue = len;
6268 fru->offset = 0;
6269 fru->addr_off = offset;
6270 fru->ubuf = buf;
6271
6272 bfa_fru_write_send(fru, BFI_TFRU_H2I_WRITE_REQ);
6273
6274 return BFA_STATUS_OK;
6275}
6276
6277/*
6278 * tfru read.
6279 *
6280 * @param[in] fru - fru structure
6281 * @param[in] buf - read data buffer
6282 * @param[in] len - data buffer length
6283 * @param[in] offset - offset relative to starting address
6284 * @param[in] cbfn - callback function
6285 * @param[in] cbarg - callback argument
6286 *
6287 * Return status.
6288 */
6289bfa_status_t
6290bfa_tfru_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6291 bfa_cb_fru_t cbfn, void *cbarg)
6292{
6293 bfa_trc(fru, BFI_TFRU_H2I_READ_REQ);
6294 bfa_trc(fru, len);
6295 bfa_trc(fru, offset);
6296
6297 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6298 return BFA_STATUS_FRU_NOT_PRESENT;
6299
6300 if (!bfa_ioc_is_operational(fru->ioc))
6301 return BFA_STATUS_IOC_NON_OP;
6302
6303 if (fru->op_busy) {
6304 bfa_trc(fru, fru->op_busy);
6305 return BFA_STATUS_DEVBUSY;
6306 }
6307
6308 fru->op_busy = 1;
6309
6310 fru->cbfn = cbfn;
6311 fru->cbarg = cbarg;
6312 fru->residue = len;
6313 fru->offset = 0;
6314 fru->addr_off = offset;
6315 fru->ubuf = buf;
6316 bfa_fru_read_send(fru, BFI_TFRU_H2I_READ_REQ);
6317
6318 return BFA_STATUS_OK;
6319}
6320
6321/*
6322 * Process fru response messages upon receiving interrupts.
6323 *
6324 * @param[in] fruarg - fru structure
6325 * @param[in] msg - message structure
6326 */
6327void
6328bfa_fru_intr(void *fruarg, struct bfi_mbmsg_s *msg)
6329{
6330 struct bfa_fru_s *fru = fruarg;
6331 struct bfi_fru_rsp_s *rsp = (struct bfi_fru_rsp_s *)msg;
6332 u32 status;
6333
6334 bfa_trc(fru, msg->mh.msg_id);
6335
6336 if (!fru->op_busy) {
6337 /*
6338 * receiving response after ioc failure
6339 */
6340 bfa_trc(fru, 0x9999);
6341 return;
6342 }
6343
6344 switch (msg->mh.msg_id) {
6345 case BFI_FRUVPD_I2H_WRITE_RSP:
6346 case BFI_TFRU_I2H_WRITE_RSP:
6347 status = be32_to_cpu(rsp->status);
6348 bfa_trc(fru, status);
6349
6350 if (status != BFA_STATUS_OK || fru->residue == 0) {
6351 fru->status = status;
6352 fru->op_busy = 0;
6353 if (fru->cbfn)
6354 fru->cbfn(fru->cbarg, fru->status);
6355 } else {
6356 bfa_trc(fru, fru->offset);
6357 if (msg->mh.msg_id == BFI_FRUVPD_I2H_WRITE_RSP)
6358 bfa_fru_write_send(fru,
6359 BFI_FRUVPD_H2I_WRITE_REQ);
6360 else
6361 bfa_fru_write_send(fru,
6362 BFI_TFRU_H2I_WRITE_REQ);
6363 }
6364 break;
6365 case BFI_FRUVPD_I2H_READ_RSP:
6366 case BFI_TFRU_I2H_READ_RSP:
6367 status = be32_to_cpu(rsp->status);
6368 bfa_trc(fru, status);
6369
6370 if (status != BFA_STATUS_OK) {
6371 fru->status = status;
6372 fru->op_busy = 0;
6373 if (fru->cbfn)
6374 fru->cbfn(fru->cbarg, fru->status);
6375 } else {
6376 u32 len = be32_to_cpu(rsp->length);
6377
6378 bfa_trc(fru, fru->offset);
6379 bfa_trc(fru, len);
6380
6381 memcpy(fru->ubuf + fru->offset, fru->dbuf_kva, len);
6382 fru->residue -= len;
6383 fru->offset += len;
6384
6385 if (fru->residue == 0) {
6386 fru->status = status;
6387 fru->op_busy = 0;
6388 if (fru->cbfn)
6389 fru->cbfn(fru->cbarg, fru->status);
6390 } else {
6391 if (msg->mh.msg_id == BFI_FRUVPD_I2H_READ_RSP)
6392 bfa_fru_read_send(fru,
6393 BFI_FRUVPD_H2I_READ_REQ);
6394 else
6395 bfa_fru_read_send(fru,
6396 BFI_TFRU_H2I_READ_REQ);
6397 }
6398 }
6399 break;
6400 default:
6401 WARN_ON(1);
6402 }
6403}
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index 23a90e7b710..546d46b3710 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -373,22 +373,6 @@ struct bfa_cb_qe_s {
373}; 373};
374 374
375/* 375/*
376 * IOCFC state machine definitions/declarations
377 */
378enum iocfc_event {
379 IOCFC_E_INIT = 1, /* IOCFC init request */
380 IOCFC_E_START = 2, /* IOCFC mod start request */
381 IOCFC_E_STOP = 3, /* IOCFC stop request */
382 IOCFC_E_ENABLE = 4, /* IOCFC enable request */
383 IOCFC_E_DISABLE = 5, /* IOCFC disable request */
384 IOCFC_E_IOC_ENABLED = 6, /* IOC enabled message */
385 IOCFC_E_IOC_DISABLED = 7, /* IOC disabled message */
386 IOCFC_E_IOC_FAILED = 8, /* failure notice by IOC sm */
387 IOCFC_E_DCONF_DONE = 9, /* dconf read/write done */
388 IOCFC_E_CFG_DONE = 10, /* IOCFC config complete */
389};
390
391/*
392 * ASIC block configurtion related 376 * ASIC block configurtion related
393 */ 377 */
394 378
@@ -530,7 +514,7 @@ struct bfa_diag_results_fwping {
530 514
531struct bfa_diag_qtest_result_s { 515struct bfa_diag_qtest_result_s {
532 u32 status; 516 u32 status;
533 u16 count; /* successful queue test count */ 517 u16 count; /* sucessful queue test count */
534 u8 queue; 518 u8 queue;
535 u8 rsvd; /* 64-bit align */ 519 u8 rsvd; /* 64-bit align */
536}; 520};
@@ -702,55 +686,6 @@ void bfa_phy_memclaim(struct bfa_phy_s *phy,
702void bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg); 686void bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg);
703 687
704/* 688/*
705 * FRU module specific
706 */
707typedef void (*bfa_cb_fru_t) (void *cbarg, bfa_status_t status);
708
709struct bfa_fru_s {
710 struct bfa_ioc_s *ioc; /* back pointer to ioc */
711 struct bfa_trc_mod_s *trcmod; /* trace module */
712 u8 op_busy; /* operation busy flag */
713 u8 rsv[3];
714 u32 residue; /* residual length */
715 u32 offset; /* offset */
716 bfa_status_t status; /* status */
717 u8 *dbuf_kva; /* dma buf virtual address */
718 u64 dbuf_pa; /* dma buf physical address */
719 struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */
720 bfa_cb_fru_t cbfn; /* user callback function */
721 void *cbarg; /* user callback arg */
722 u8 *ubuf; /* user supplied buffer */
723 struct bfa_cb_qe_s hcb_qe; /* comp: BFA callback qelem */
724 u32 addr_off; /* fru address offset */
725 struct bfa_mbox_cmd_s mb; /* mailbox */
726 struct bfa_ioc_notify_s ioc_notify; /* ioc event notify */
727 struct bfa_mem_dma_s fru_dma;
728};
729
730#define BFA_FRU(__bfa) (&(__bfa)->modules.fru)
731#define BFA_MEM_FRU_DMA(__bfa) (&(BFA_FRU(__bfa)->fru_dma))
732
733bfa_status_t bfa_fruvpd_update(struct bfa_fru_s *fru,
734 void *buf, u32 len, u32 offset,
735 bfa_cb_fru_t cbfn, void *cbarg);
736bfa_status_t bfa_fruvpd_read(struct bfa_fru_s *fru,
737 void *buf, u32 len, u32 offset,
738 bfa_cb_fru_t cbfn, void *cbarg);
739bfa_status_t bfa_fruvpd_get_max_size(struct bfa_fru_s *fru, u32 *max_size);
740bfa_status_t bfa_tfru_write(struct bfa_fru_s *fru,
741 void *buf, u32 len, u32 offset,
742 bfa_cb_fru_t cbfn, void *cbarg);
743bfa_status_t bfa_tfru_read(struct bfa_fru_s *fru,
744 void *buf, u32 len, u32 offset,
745 bfa_cb_fru_t cbfn, void *cbarg);
746u32 bfa_fru_meminfo(bfa_boolean_t mincfg);
747void bfa_fru_attach(struct bfa_fru_s *fru, struct bfa_ioc_s *ioc,
748 void *dev, struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg);
749void bfa_fru_memclaim(struct bfa_fru_s *fru,
750 u8 *dm_kva, u64 dm_pa, bfa_boolean_t mincfg);
751void bfa_fru_intr(void *fruarg, struct bfi_mbmsg_s *msg);
752
753/*
754 * Driver Config( dconf) specific 689 * Driver Config( dconf) specific
755 */ 690 */
756#define BFI_DCONF_SIGNATURE 0xabcdabcd 691#define BFI_DCONF_SIGNATURE 0xabcdabcd
@@ -765,13 +700,13 @@ struct bfa_dconf_hdr_s {
765struct bfa_dconf_s { 700struct bfa_dconf_s {
766 struct bfa_dconf_hdr_s hdr; 701 struct bfa_dconf_hdr_s hdr;
767 struct bfa_lunmask_cfg_s lun_mask; 702 struct bfa_lunmask_cfg_s lun_mask;
768 struct bfa_throttle_cfg_s throttle_cfg;
769}; 703};
770#pragma pack() 704#pragma pack()
771 705
772struct bfa_dconf_mod_s { 706struct bfa_dconf_mod_s {
773 bfa_sm_t sm; 707 bfa_sm_t sm;
774 u8 instance; 708 u8 instance;
709 bfa_boolean_t flashdone;
775 bfa_boolean_t read_data_valid; 710 bfa_boolean_t read_data_valid;
776 bfa_boolean_t min_cfg; 711 bfa_boolean_t min_cfg;
777 struct bfa_timer_s timer; 712 struct bfa_timer_s timer;
@@ -788,8 +723,6 @@ struct bfa_dconf_mod_s {
788#define bfa_dconf_read_data_valid(__bfa) \ 723#define bfa_dconf_read_data_valid(__bfa) \
789 (BFA_DCONF_MOD(__bfa)->read_data_valid) 724 (BFA_DCONF_MOD(__bfa)->read_data_valid)
790#define BFA_DCONF_UPDATE_TOV 5000 /* memtest timeout in msec */ 725#define BFA_DCONF_UPDATE_TOV 5000 /* memtest timeout in msec */
791#define bfa_dconf_get_min_cfg(__bfa) \
792 (BFA_DCONF_MOD(__bfa)->min_cfg)
793 726
794void bfa_dconf_modinit(struct bfa_s *bfa); 727void bfa_dconf_modinit(struct bfa_s *bfa);
795void bfa_dconf_modexit(struct bfa_s *bfa); 728void bfa_dconf_modexit(struct bfa_s *bfa);
@@ -813,8 +746,7 @@ bfa_status_t bfa_dconf_update(struct bfa_s *bfa);
813#define bfa_ioc_maxfrsize(__ioc) ((__ioc)->attr->maxfrsize) 746#define bfa_ioc_maxfrsize(__ioc) ((__ioc)->attr->maxfrsize)
814#define bfa_ioc_rx_bbcredit(__ioc) ((__ioc)->attr->rx_bbcredit) 747#define bfa_ioc_rx_bbcredit(__ioc) ((__ioc)->attr->rx_bbcredit)
815#define bfa_ioc_speed_sup(__ioc) \ 748#define bfa_ioc_speed_sup(__ioc) \
816 ((bfa_ioc_is_cna(__ioc)) ? BFA_PORT_SPEED_10GBPS : \ 749 BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop)
817 BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop))
818#define bfa_ioc_get_nports(__ioc) \ 750#define bfa_ioc_get_nports(__ioc) \
819 BFI_ADAPTER_GETP(NPORTS, (__ioc)->attr->adapter_prop) 751 BFI_ADAPTER_GETP(NPORTS, (__ioc)->attr->adapter_prop)
820 752
@@ -873,7 +805,6 @@ void bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa,
873 struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod); 805 struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod);
874void bfa_ioc_auto_recover(bfa_boolean_t auto_recover); 806void bfa_ioc_auto_recover(bfa_boolean_t auto_recover);
875void bfa_ioc_detach(struct bfa_ioc_s *ioc); 807void bfa_ioc_detach(struct bfa_ioc_s *ioc);
876void bfa_ioc_suspend(struct bfa_ioc_s *ioc);
877void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev, 808void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
878 enum bfi_pcifn_class clscode); 809 enum bfi_pcifn_class clscode);
879void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa); 810void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa);
@@ -920,7 +851,6 @@ bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
920void bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event); 851void bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event);
921bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats); 852bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats);
922bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc); 853bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc);
923void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
924 854
925/* 855/*
926 * asic block configuration related APIs 856 * asic block configuration related APIs
@@ -938,12 +868,12 @@ bfa_status_t bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port,
938 enum bfa_mode_s mode, int max_pf, int max_vf, 868 enum bfa_mode_s mode, int max_pf, int max_vf,
939 bfa_ablk_cbfn_t cbfn, void *cbarg); 869 bfa_ablk_cbfn_t cbfn, void *cbarg);
940bfa_status_t bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn, 870bfa_status_t bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
941 u8 port, enum bfi_pcifn_class personality, 871 u8 port, enum bfi_pcifn_class personality, int bw,
942 u16 bw_min, u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg); 872 bfa_ablk_cbfn_t cbfn, void *cbarg);
943bfa_status_t bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn, 873bfa_status_t bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn,
944 bfa_ablk_cbfn_t cbfn, void *cbarg); 874 bfa_ablk_cbfn_t cbfn, void *cbarg);
945bfa_status_t bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, 875bfa_status_t bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, int bw,
946 u16 bw_min, u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg); 876 bfa_ablk_cbfn_t cbfn, void *cbarg);
947bfa_status_t bfa_ablk_optrom_en(struct bfa_ablk_s *ablk, 877bfa_status_t bfa_ablk_optrom_en(struct bfa_ablk_s *ablk,
948 bfa_ablk_cbfn_t cbfn, void *cbarg); 878 bfa_ablk_cbfn_t cbfn, void *cbarg);
949bfa_status_t bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk, 879bfa_status_t bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk,
diff --git a/drivers/scsi/bfa/bfa_ioc_ct.c b/drivers/scsi/bfa/bfa_ioc_ct.c
index de4e726a126..d1b8f0caaa7 100644
--- a/drivers/scsi/bfa/bfa_ioc_ct.c
+++ b/drivers/scsi/bfa/bfa_ioc_ct.c
@@ -57,6 +57,13 @@ bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
57 u32 usecnt; 57 u32 usecnt;
58 struct bfi_ioc_image_hdr_s fwhdr; 58 struct bfi_ioc_image_hdr_s fwhdr;
59 59
60 /*
61 * If bios boot (flash based) -- do not increment usage count
62 */
63 if (bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)) <
64 BFA_IOC_FWIMG_MINSZ)
65 return BFA_TRUE;
66
60 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); 67 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
61 usecnt = readl(ioc->ioc_regs.ioc_usage_reg); 68 usecnt = readl(ioc->ioc_regs.ioc_usage_reg);
62 69
@@ -108,6 +115,13 @@ bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc)
108 u32 usecnt; 115 u32 usecnt;
109 116
110 /* 117 /*
118 * If bios boot (flash based) -- do not decrement usage count
119 */
120 if (bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)) <
121 BFA_IOC_FWIMG_MINSZ)
122 return;
123
124 /*
111 * decrement usage count 125 * decrement usage count
112 */ 126 */
113 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); 127 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
@@ -386,12 +400,13 @@ static void
386bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc) 400bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc)
387{ 401{
388 402
389 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); 403 if (bfa_ioc_is_cna(ioc)) {
390 writel(0, ioc->ioc_regs.ioc_usage_reg); 404 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
391 readl(ioc->ioc_regs.ioc_usage_sem_reg); 405 writel(0, ioc->ioc_regs.ioc_usage_reg);
392 writel(1, ioc->ioc_regs.ioc_usage_sem_reg); 406 readl(ioc->ioc_regs.ioc_usage_sem_reg);
407 writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
408 }
393 409
394 writel(0, ioc->ioc_regs.ioc_fail_sync);
395 /* 410 /*
396 * Read the hw sem reg to make sure that it is locked 411 * Read the hw sem reg to make sure that it is locked
397 * before we clear it. If it is not locked, writing 1 412 * before we clear it. If it is not locked, writing 1
@@ -744,77 +759,8 @@ bfa_ioc_ct2_mem_init(void __iomem *rb)
744void 759void
745bfa_ioc_ct2_mac_reset(void __iomem *rb) 760bfa_ioc_ct2_mac_reset(void __iomem *rb)
746{ 761{
747 /* put port0, port1 MAC & AHB in reset */
748 writel((__CSI_MAC_RESET | __CSI_MAC_AHB_RESET),
749 rb + CT2_CSI_MAC_CONTROL_REG(0));
750 writel((__CSI_MAC_RESET | __CSI_MAC_AHB_RESET),
751 rb + CT2_CSI_MAC_CONTROL_REG(1));
752}
753
754static void
755bfa_ioc_ct2_enable_flash(void __iomem *rb)
756{
757 u32 r32;
758
759 r32 = readl((rb + PSS_GPIO_OUT_REG));
760 writel(r32 & ~1, (rb + PSS_GPIO_OUT_REG));
761 r32 = readl((rb + PSS_GPIO_OE_REG));
762 writel(r32 | 1, (rb + PSS_GPIO_OE_REG));
763}
764
765#define CT2_NFC_MAX_DELAY 1000
766#define CT2_NFC_PAUSE_MAX_DELAY 4000
767#define CT2_NFC_VER_VALID 0x147
768#define CT2_NFC_STATE_RUNNING 0x20000001
769#define BFA_IOC_PLL_POLL 1000000
770
771static bfa_boolean_t
772bfa_ioc_ct2_nfc_halted(void __iomem *rb)
773{
774 u32 r32; 762 u32 r32;
775 763
776 r32 = readl(rb + CT2_NFC_CSR_SET_REG);
777 if (r32 & __NFC_CONTROLLER_HALTED)
778 return BFA_TRUE;
779
780 return BFA_FALSE;
781}
782
783static void
784bfa_ioc_ct2_nfc_halt(void __iomem *rb)
785{
786 int i;
787
788 writel(__HALT_NFC_CONTROLLER, rb + CT2_NFC_CSR_SET_REG);
789 for (i = 0; i < CT2_NFC_MAX_DELAY; i++) {
790 if (bfa_ioc_ct2_nfc_halted(rb))
791 break;
792 udelay(1000);
793 }
794 WARN_ON(!bfa_ioc_ct2_nfc_halted(rb));
795}
796
797static void
798bfa_ioc_ct2_nfc_resume(void __iomem *rb)
799{
800 u32 r32;
801 int i;
802
803 writel(__HALT_NFC_CONTROLLER, rb + CT2_NFC_CSR_CLR_REG);
804 for (i = 0; i < CT2_NFC_MAX_DELAY; i++) {
805 r32 = readl(rb + CT2_NFC_CSR_SET_REG);
806 if (!(r32 & __NFC_CONTROLLER_HALTED))
807 return;
808 udelay(1000);
809 }
810 WARN_ON(1);
811}
812
813static void
814bfa_ioc_ct2_clk_reset(void __iomem *rb)
815{
816 u32 r32;
817
818 bfa_ioc_ct2_sclk_init(rb); 764 bfa_ioc_ct2_sclk_init(rb);
819 bfa_ioc_ct2_lclk_init(rb); 765 bfa_ioc_ct2_lclk_init(rb);
820 766
@@ -823,129 +769,92 @@ bfa_ioc_ct2_clk_reset(void __iomem *rb)
823 */ 769 */
824 r32 = readl((rb + CT2_APP_PLL_SCLK_CTL_REG)); 770 r32 = readl((rb + CT2_APP_PLL_SCLK_CTL_REG));
825 writel(r32 & ~__APP_PLL_SCLK_LOGIC_SOFT_RESET, 771 writel(r32 & ~__APP_PLL_SCLK_LOGIC_SOFT_RESET,
826 (rb + CT2_APP_PLL_SCLK_CTL_REG)); 772 (rb + CT2_APP_PLL_SCLK_CTL_REG));
827 773
774 /*
775 * release soft reset on s_clk & l_clk
776 */
828 r32 = readl((rb + CT2_APP_PLL_LCLK_CTL_REG)); 777 r32 = readl((rb + CT2_APP_PLL_LCLK_CTL_REG));
829 writel(r32 & ~__APP_PLL_LCLK_LOGIC_SOFT_RESET, 778 writel(r32 & ~__APP_PLL_LCLK_LOGIC_SOFT_RESET,
830 (rb + CT2_APP_PLL_LCLK_CTL_REG)); 779 (rb + CT2_APP_PLL_LCLK_CTL_REG));
831
832}
833 780
834static void 781 /* put port0, port1 MAC & AHB in reset */
835bfa_ioc_ct2_nfc_clk_reset(void __iomem *rb) 782 writel((__CSI_MAC_RESET | __CSI_MAC_AHB_RESET),
836{ 783 rb + CT2_CSI_MAC_CONTROL_REG(0));
837 u32 r32, i; 784 writel((__CSI_MAC_RESET | __CSI_MAC_AHB_RESET),
838 785 rb + CT2_CSI_MAC_CONTROL_REG(1));
839 r32 = readl((rb + PSS_CTL_REG));
840 r32 |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
841 writel(r32, (rb + PSS_CTL_REG));
842
843 writel(__RESET_AND_START_SCLK_LCLK_PLLS, rb + CT2_CSI_FW_CTL_SET_REG);
844
845 for (i = 0; i < BFA_IOC_PLL_POLL; i++) {
846 r32 = readl(rb + CT2_NFC_FLASH_STS_REG);
847
848 if ((r32 & __FLASH_PLL_INIT_AND_RESET_IN_PROGRESS))
849 break;
850 }
851 WARN_ON(!(r32 & __FLASH_PLL_INIT_AND_RESET_IN_PROGRESS));
852
853 for (i = 0; i < BFA_IOC_PLL_POLL; i++) {
854 r32 = readl(rb + CT2_NFC_FLASH_STS_REG);
855
856 if (!(r32 & __FLASH_PLL_INIT_AND_RESET_IN_PROGRESS))
857 break;
858 }
859 WARN_ON((r32 & __FLASH_PLL_INIT_AND_RESET_IN_PROGRESS));
860
861 r32 = readl(rb + CT2_CSI_FW_CTL_REG);
862 WARN_ON((r32 & __RESET_AND_START_SCLK_LCLK_PLLS));
863}
864
865static void
866bfa_ioc_ct2_wait_till_nfc_running(void __iomem *rb)
867{
868 u32 r32;
869 int i;
870
871 if (bfa_ioc_ct2_nfc_halted(rb))
872 bfa_ioc_ct2_nfc_resume(rb);
873 for (i = 0; i < CT2_NFC_PAUSE_MAX_DELAY; i++) {
874 r32 = readl(rb + CT2_NFC_STS_REG);
875 if (r32 == CT2_NFC_STATE_RUNNING)
876 return;
877 udelay(1000);
878 }
879
880 r32 = readl(rb + CT2_NFC_STS_REG);
881 WARN_ON(!(r32 == CT2_NFC_STATE_RUNNING));
882} 786}
883 787
788#define CT2_NFC_MAX_DELAY 1000
884bfa_status_t 789bfa_status_t
885bfa_ioc_ct2_pll_init(void __iomem *rb, enum bfi_asic_mode mode) 790bfa_ioc_ct2_pll_init(void __iomem *rb, enum bfi_asic_mode mode)
886{ 791{
887 u32 wgn, r32, nfc_ver; 792 u32 wgn, r32;
793 int i;
888 794
795 /*
796 * Initialize PLL if not already done by NFC
797 */
889 wgn = readl(rb + CT2_WGN_STATUS); 798 wgn = readl(rb + CT2_WGN_STATUS);
890 799 if (!(wgn & __GLBL_PF_VF_CFG_RDY)) {
891 if (wgn == (__WGN_READY | __GLBL_PF_VF_CFG_RDY)) { 800 writel(__HALT_NFC_CONTROLLER, rb + CT2_NFC_CSR_SET_REG);
892 /* 801 for (i = 0; i < CT2_NFC_MAX_DELAY; i++) {
893 * If flash is corrupted, enable flash explicitly 802 r32 = readl(rb + CT2_NFC_CSR_SET_REG);
894 */ 803 if (r32 & __NFC_CONTROLLER_HALTED)
895 bfa_ioc_ct2_clk_reset(rb); 804 break;
896 bfa_ioc_ct2_enable_flash(rb); 805 udelay(1000);
897
898 bfa_ioc_ct2_mac_reset(rb);
899
900 bfa_ioc_ct2_clk_reset(rb);
901 bfa_ioc_ct2_enable_flash(rb);
902
903 } else {
904 nfc_ver = readl(rb + CT2_RSC_GPR15_REG);
905
906 if ((nfc_ver >= CT2_NFC_VER_VALID) &&
907 (wgn == (__A2T_AHB_LOAD | __WGN_READY))) {
908
909 bfa_ioc_ct2_wait_till_nfc_running(rb);
910
911 bfa_ioc_ct2_nfc_clk_reset(rb);
912 } else {
913 bfa_ioc_ct2_nfc_halt(rb);
914
915 bfa_ioc_ct2_clk_reset(rb);
916 bfa_ioc_ct2_mac_reset(rb);
917 bfa_ioc_ct2_clk_reset(rb);
918
919 } 806 }
920 } 807 }
921 808
922 /* 809 /*
923 * Mask the interrupts and clear any 810 * Mask the interrupts and clear any
924 * pending interrupts left by BIOS/EFI 811 * pending interrupts.
925 */ 812 */
926
927 writel(1, (rb + CT2_LPU0_HOSTFN_MBOX0_MSK)); 813 writel(1, (rb + CT2_LPU0_HOSTFN_MBOX0_MSK));
928 writel(1, (rb + CT2_LPU1_HOSTFN_MBOX0_MSK)); 814 writel(1, (rb + CT2_LPU1_HOSTFN_MBOX0_MSK));
929 815
930 /* For first time initialization, no need to clear interrupts */ 816 r32 = readl((rb + CT2_LPU0_HOSTFN_CMD_STAT));
931 r32 = readl(rb + HOST_SEM5_REG); 817 if (r32 == 1) {
932 if (r32 & 0x1) { 818 writel(1, (rb + CT2_LPU0_HOSTFN_CMD_STAT));
933 r32 = readl((rb + CT2_LPU0_HOSTFN_CMD_STAT)); 819 readl((rb + CT2_LPU0_HOSTFN_CMD_STAT));
934 if (r32 == 1) { 820 }
935 writel(1, (rb + CT2_LPU0_HOSTFN_CMD_STAT)); 821 r32 = readl((rb + CT2_LPU1_HOSTFN_CMD_STAT));
936 readl((rb + CT2_LPU0_HOSTFN_CMD_STAT)); 822 if (r32 == 1) {
937 } 823 writel(1, (rb + CT2_LPU1_HOSTFN_CMD_STAT));
938 r32 = readl((rb + CT2_LPU1_HOSTFN_CMD_STAT)); 824 readl((rb + CT2_LPU1_HOSTFN_CMD_STAT));
939 if (r32 == 1) { 825 }
940 writel(1, (rb + CT2_LPU1_HOSTFN_CMD_STAT)); 826
941 readl((rb + CT2_LPU1_HOSTFN_CMD_STAT)); 827 bfa_ioc_ct2_mac_reset(rb);
942 } 828 bfa_ioc_ct2_sclk_init(rb);
829 bfa_ioc_ct2_lclk_init(rb);
830
831 /*
832 * release soft reset on s_clk & l_clk
833 */
834 r32 = readl((rb + CT2_APP_PLL_SCLK_CTL_REG));
835 writel(r32 & ~__APP_PLL_SCLK_LOGIC_SOFT_RESET,
836 (rb + CT2_APP_PLL_SCLK_CTL_REG));
837
838 /*
839 * release soft reset on s_clk & l_clk
840 */
841 r32 = readl((rb + CT2_APP_PLL_LCLK_CTL_REG));
842 writel(r32 & ~__APP_PLL_LCLK_LOGIC_SOFT_RESET,
843 (rb + CT2_APP_PLL_LCLK_CTL_REG));
844
845 /*
846 * Announce flash device presence, if flash was corrupted.
847 */
848 if (wgn == (__WGN_READY | __GLBL_PF_VF_CFG_RDY)) {
849 r32 = readl((rb + PSS_GPIO_OUT_REG));
850 writel(r32 & ~1, (rb + PSS_GPIO_OUT_REG));
851 r32 = readl((rb + PSS_GPIO_OE_REG));
852 writel(r32 | 1, (rb + PSS_GPIO_OE_REG));
943 } 853 }
944 854
945 bfa_ioc_ct2_mem_init(rb); 855 bfa_ioc_ct2_mem_init(rb);
946 856
947 writel(BFI_IOC_UNINIT, (rb + CT2_BFA_IOC0_STATE_REG)); 857 writel(BFI_IOC_UNINIT, (rb + CT2_BFA_IOC0_STATE_REG));
948 writel(BFI_IOC_UNINIT, (rb + CT2_BFA_IOC1_STATE_REG)); 858 writel(BFI_IOC_UNINIT, (rb + CT2_BFA_IOC1_STATE_REG));
949
950 return BFA_STATUS_OK; 859 return BFA_STATUS_OK;
951} 860}
diff --git a/drivers/scsi/bfa/bfa_modules.h b/drivers/scsi/bfa/bfa_modules.h
index a14c784ff3f..2d36e482383 100644
--- a/drivers/scsi/bfa/bfa_modules.h
+++ b/drivers/scsi/bfa/bfa_modules.h
@@ -45,7 +45,6 @@ struct bfa_modules_s {
45 struct bfa_diag_s diag_mod; /* diagnostics module */ 45 struct bfa_diag_s diag_mod; /* diagnostics module */
46 struct bfa_phy_s phy; /* phy module */ 46 struct bfa_phy_s phy; /* phy module */
47 struct bfa_dconf_mod_s dconf_mod; /* DCONF common module */ 47 struct bfa_dconf_mod_s dconf_mod; /* DCONF common module */
48 struct bfa_fru_s fru; /* fru module */
49}; 48};
50 49
51/* 50/*
@@ -122,7 +121,6 @@ struct bfa_s {
122 bfa_boolean_t fcs; /* FCS is attached to BFA */ 121 bfa_boolean_t fcs; /* FCS is attached to BFA */
123 struct bfa_msix_s msix; 122 struct bfa_msix_s msix;
124 int bfa_aen_seq; 123 int bfa_aen_seq;
125 bfa_boolean_t intr_enabled; /* Status of interrupts */
126}; 124};
127 125
128extern bfa_boolean_t bfa_auto_recover; 126extern bfa_boolean_t bfa_auto_recover;
diff --git a/drivers/scsi/bfa/bfa_port.c b/drivers/scsi/bfa/bfa_port.c
index 8ea7697deb9..95e4ad8759a 100644
--- a/drivers/scsi/bfa/bfa_port.c
+++ b/drivers/scsi/bfa/bfa_port.c
@@ -250,12 +250,6 @@ bfa_port_enable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
250 return BFA_STATUS_IOC_FAILURE; 250 return BFA_STATUS_IOC_FAILURE;
251 } 251 }
252 252
253 /* if port is d-port enabled, return error */
254 if (port->dport_enabled) {
255 bfa_trc(port, BFA_STATUS_DPORT_ERR);
256 return BFA_STATUS_DPORT_ERR;
257 }
258
259 if (port->endis_pending) { 253 if (port->endis_pending) {
260 bfa_trc(port, BFA_STATUS_DEVBUSY); 254 bfa_trc(port, BFA_STATUS_DEVBUSY);
261 return BFA_STATUS_DEVBUSY; 255 return BFA_STATUS_DEVBUSY;
@@ -306,12 +300,6 @@ bfa_port_disable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
306 return BFA_STATUS_IOC_FAILURE; 300 return BFA_STATUS_IOC_FAILURE;
307 } 301 }
308 302
309 /* if port is d-port enabled, return error */
310 if (port->dport_enabled) {
311 bfa_trc(port, BFA_STATUS_DPORT_ERR);
312 return BFA_STATUS_DPORT_ERR;
313 }
314
315 if (port->endis_pending) { 303 if (port->endis_pending) {
316 bfa_trc(port, BFA_STATUS_DEVBUSY); 304 bfa_trc(port, BFA_STATUS_DEVBUSY);
317 return BFA_STATUS_DEVBUSY; 305 return BFA_STATUS_DEVBUSY;
@@ -443,10 +431,6 @@ bfa_port_notify(void *arg, enum bfa_ioc_event_e event)
443 port->endis_cbfn = NULL; 431 port->endis_cbfn = NULL;
444 port->endis_pending = BFA_FALSE; 432 port->endis_pending = BFA_FALSE;
445 } 433 }
446
447 /* clear D-port mode */
448 if (port->dport_enabled)
449 bfa_port_set_dportenabled(port, BFA_FALSE);
450 break; 434 break;
451 default: 435 default:
452 break; 436 break;
@@ -483,7 +467,6 @@ bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
483 port->stats_cbfn = NULL; 467 port->stats_cbfn = NULL;
484 port->endis_cbfn = NULL; 468 port->endis_cbfn = NULL;
485 port->pbc_disabled = BFA_FALSE; 469 port->pbc_disabled = BFA_FALSE;
486 port->dport_enabled = BFA_FALSE;
487 470
488 bfa_ioc_mbox_regisr(port->ioc, BFI_MC_PORT, bfa_port_isr, port); 471 bfa_ioc_mbox_regisr(port->ioc, BFI_MC_PORT, bfa_port_isr, port);
489 bfa_q_qe_init(&port->ioc_notify); 472 bfa_q_qe_init(&port->ioc_notify);
@@ -500,21 +483,6 @@ bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
500} 483}
501 484
502/* 485/*
503 * bfa_port_set_dportenabled();
504 *
505 * Port module- set pbc disabled flag
506 *
507 * @param[in] port - Pointer to the Port module data structure
508 *
509 * @return void
510 */
511void
512bfa_port_set_dportenabled(struct bfa_port_s *port, bfa_boolean_t enabled)
513{
514 port->dport_enabled = enabled;
515}
516
517/*
518 * CEE module specific definitions 486 * CEE module specific definitions
519 */ 487 */
520 488
diff --git a/drivers/scsi/bfa/bfa_port.h b/drivers/scsi/bfa/bfa_port.h
index 2fcab6bc628..947f897328d 100644
--- a/drivers/scsi/bfa/bfa_port.h
+++ b/drivers/scsi/bfa/bfa_port.h
@@ -45,7 +45,6 @@ struct bfa_port_s {
45 bfa_status_t endis_status; 45 bfa_status_t endis_status;
46 struct bfa_ioc_notify_s ioc_notify; 46 struct bfa_ioc_notify_s ioc_notify;
47 bfa_boolean_t pbc_disabled; 47 bfa_boolean_t pbc_disabled;
48 bfa_boolean_t dport_enabled;
49 struct bfa_mem_dma_s port_dma; 48 struct bfa_mem_dma_s port_dma;
50}; 49};
51 50
@@ -67,8 +66,6 @@ bfa_status_t bfa_port_disable(struct bfa_port_s *port,
67u32 bfa_port_meminfo(void); 66u32 bfa_port_meminfo(void);
68void bfa_port_mem_claim(struct bfa_port_s *port, 67void bfa_port_mem_claim(struct bfa_port_s *port,
69 u8 *dma_kva, u64 dma_pa); 68 u8 *dma_kva, u64 dma_pa);
70void bfa_port_set_dportenabled(struct bfa_port_s *port,
71 bfa_boolean_t enabled);
72 69
73/* 70/*
74 * CEE declaration 71 * CEE declaration
diff --git a/drivers/scsi/bfa/bfa_svc.c b/drivers/scsi/bfa/bfa_svc.c
index 299c1c889b3..aa8a0eaf91f 100644
--- a/drivers/scsi/bfa/bfa_svc.c
+++ b/drivers/scsi/bfa/bfa_svc.c
@@ -67,9 +67,6 @@ enum bfa_fcport_sm_event {
67 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */ 67 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */
68 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */ 68 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */
69 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */ 69 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */
70 BFA_FCPORT_SM_DPORTENABLE = 10, /* enable dport */
71 BFA_FCPORT_SM_DPORTDISABLE = 11,/* disable dport */
72 BFA_FCPORT_SM_FAA_MISCONFIG = 12, /* FAA misconfiguratin */
73}; 70};
74 71
75/* 72/*
@@ -200,10 +197,6 @@ static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
200 enum bfa_fcport_sm_event event); 197 enum bfa_fcport_sm_event event);
201static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport, 198static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
202 enum bfa_fcport_sm_event event); 199 enum bfa_fcport_sm_event event);
203static void bfa_fcport_sm_dport(struct bfa_fcport_s *fcport,
204 enum bfa_fcport_sm_event event);
205static void bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
206 enum bfa_fcport_sm_event event);
207 200
208static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln, 201static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
209 enum bfa_fcport_ln_sm_event event); 202 enum bfa_fcport_ln_sm_event event);
@@ -233,8 +226,6 @@ static struct bfa_sm_table_s hal_port_sm_table[] = {
233 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED}, 226 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
234 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN}, 227 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
235 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN}, 228 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
236 {BFA_SM(bfa_fcport_sm_dport), BFA_PORT_ST_DPORT},
237 {BFA_SM(bfa_fcport_sm_faa_misconfig), BFA_PORT_ST_FAA_MISCONFIG},
238}; 229};
239 230
240 231
@@ -449,11 +440,9 @@ claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
449 fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod); 440 fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod);
450 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps); 441 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
451 442
452 INIT_LIST_HEAD(&mod->fcxp_req_free_q); 443 INIT_LIST_HEAD(&mod->fcxp_free_q);
453 INIT_LIST_HEAD(&mod->fcxp_rsp_free_q);
454 INIT_LIST_HEAD(&mod->fcxp_active_q); 444 INIT_LIST_HEAD(&mod->fcxp_active_q);
455 INIT_LIST_HEAD(&mod->fcxp_req_unused_q); 445 INIT_LIST_HEAD(&mod->fcxp_unused_q);
456 INIT_LIST_HEAD(&mod->fcxp_rsp_unused_q);
457 446
458 mod->fcxp_list = fcxp; 447 mod->fcxp_list = fcxp;
459 448
@@ -461,14 +450,7 @@ claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
461 fcxp->fcxp_mod = mod; 450 fcxp->fcxp_mod = mod;
462 fcxp->fcxp_tag = i; 451 fcxp->fcxp_tag = i;
463 452
464 if (i < (mod->num_fcxps / 2)) { 453 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
465 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
466 fcxp->req_rsp = BFA_TRUE;
467 } else {
468 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
469 fcxp->req_rsp = BFA_FALSE;
470 }
471
472 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp); 454 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
473 fcxp->reqq_waiting = BFA_FALSE; 455 fcxp->reqq_waiting = BFA_FALSE;
474 456
@@ -532,8 +514,7 @@ bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
532 if (!cfg->drvcfg.min_cfg) 514 if (!cfg->drvcfg.min_cfg)
533 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ; 515 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
534 516
535 INIT_LIST_HEAD(&mod->req_wait_q); 517 INIT_LIST_HEAD(&mod->wait_q);
536 INIT_LIST_HEAD(&mod->rsp_wait_q);
537 518
538 claim_fcxps_mem(mod); 519 claim_fcxps_mem(mod);
539} 520}
@@ -561,8 +542,7 @@ bfa_fcxp_iocdisable(struct bfa_s *bfa)
561 struct list_head *qe, *qen; 542 struct list_head *qe, *qen;
562 543
563 /* Enqueue unused fcxp resources to free_q */ 544 /* Enqueue unused fcxp resources to free_q */
564 list_splice_tail_init(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q); 545 list_splice_tail_init(&mod->fcxp_unused_q, &mod->fcxp_free_q);
565 list_splice_tail_init(&mod->fcxp_rsp_unused_q, &mod->fcxp_rsp_free_q);
566 546
567 list_for_each_safe(qe, qen, &mod->fcxp_active_q) { 547 list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
568 fcxp = (struct bfa_fcxp_s *) qe; 548 fcxp = (struct bfa_fcxp_s *) qe;
@@ -579,14 +559,11 @@ bfa_fcxp_iocdisable(struct bfa_s *bfa)
579} 559}
580 560
581static struct bfa_fcxp_s * 561static struct bfa_fcxp_s *
582bfa_fcxp_get(struct bfa_fcxp_mod_s *fm, bfa_boolean_t req) 562bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
583{ 563{
584 struct bfa_fcxp_s *fcxp; 564 struct bfa_fcxp_s *fcxp;
585 565
586 if (req) 566 bfa_q_deq(&fm->fcxp_free_q, &fcxp);
587 bfa_q_deq(&fm->fcxp_req_free_q, &fcxp);
588 else
589 bfa_q_deq(&fm->fcxp_rsp_free_q, &fcxp);
590 567
591 if (fcxp) 568 if (fcxp)
592 list_add_tail(&fcxp->qe, &fm->fcxp_active_q); 569 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
@@ -665,11 +642,7 @@ bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
665 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 642 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
666 struct bfa_fcxp_wqe_s *wqe; 643 struct bfa_fcxp_wqe_s *wqe;
667 644
668 if (fcxp->req_rsp) 645 bfa_q_deq(&mod->wait_q, &wqe);
669 bfa_q_deq(&mod->req_wait_q, &wqe);
670 else
671 bfa_q_deq(&mod->rsp_wait_q, &wqe);
672
673 if (wqe) { 646 if (wqe) {
674 bfa_trc(mod->bfa, fcxp->fcxp_tag); 647 bfa_trc(mod->bfa, fcxp->fcxp_tag);
675 648
@@ -684,11 +657,7 @@ bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
684 657
685 WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp)); 658 WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
686 list_del(&fcxp->qe); 659 list_del(&fcxp->qe);
687 660 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
688 if (fcxp->req_rsp)
689 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
690 else
691 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
692} 661}
693 662
694static void 663static void
@@ -931,23 +900,21 @@ bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
931 * Address (given the sge index). 900 * Address (given the sge index).
932 * @param[in] get_rsp_sglen function ptr to be called to get a response SG 901 * @param[in] get_rsp_sglen function ptr to be called to get a response SG
933 * len (given the sge index). 902 * len (given the sge index).
934 * @param[in] req Allocated FCXP is used to send req or rsp?
935 * request - BFA_TRUE, response - BFA_FALSE
936 * 903 *
937 * @return FCXP instance. NULL on failure. 904 * @return FCXP instance. NULL on failure.
938 */ 905 */
939struct bfa_fcxp_s * 906struct bfa_fcxp_s *
940bfa_fcxp_req_rsp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles, 907bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
941 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn, 908 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
942 bfa_fcxp_get_sglen_t req_sglen_cbfn, 909 bfa_fcxp_get_sglen_t req_sglen_cbfn,
943 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn, 910 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
944 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req) 911 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
945{ 912{
946 struct bfa_fcxp_s *fcxp = NULL; 913 struct bfa_fcxp_s *fcxp = NULL;
947 914
948 WARN_ON(bfa == NULL); 915 WARN_ON(bfa == NULL);
949 916
950 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa), req); 917 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
951 if (fcxp == NULL) 918 if (fcxp == NULL)
952 return NULL; 919 return NULL;
953 920
@@ -1104,20 +1071,17 @@ bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1104} 1071}
1105 1072
1106void 1073void
1107bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe, 1074bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1108 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg, 1075 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1109 void *caller, int nreq_sgles, 1076 void *caller, int nreq_sgles,
1110 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn, 1077 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1111 bfa_fcxp_get_sglen_t req_sglen_cbfn, 1078 bfa_fcxp_get_sglen_t req_sglen_cbfn,
1112 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn, 1079 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1113 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req) 1080 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
1114{ 1081{
1115 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1082 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1116 1083
1117 if (req) 1084 WARN_ON(!list_empty(&mod->fcxp_free_q));
1118 WARN_ON(!list_empty(&mod->fcxp_req_free_q));
1119 else
1120 WARN_ON(!list_empty(&mod->fcxp_rsp_free_q));
1121 1085
1122 wqe->alloc_cbfn = alloc_cbfn; 1086 wqe->alloc_cbfn = alloc_cbfn;
1123 wqe->alloc_cbarg = alloc_cbarg; 1087 wqe->alloc_cbarg = alloc_cbarg;
@@ -1130,10 +1094,7 @@ bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1130 wqe->rsp_sga_cbfn = rsp_sga_cbfn; 1094 wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1131 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn; 1095 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1132 1096
1133 if (req) 1097 list_add_tail(&wqe->qe, &mod->wait_q);
1134 list_add_tail(&wqe->qe, &mod->req_wait_q);
1135 else
1136 list_add_tail(&wqe->qe, &mod->rsp_wait_q);
1137} 1098}
1138 1099
1139void 1100void
@@ -1141,8 +1102,7 @@ bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1141{ 1102{
1142 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1103 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1143 1104
1144 WARN_ON(!bfa_q_is_on_q(&mod->req_wait_q, wqe) || 1105 WARN_ON(!bfa_q_is_on_q(&mod->wait_q, wqe));
1145 !bfa_q_is_on_q(&mod->rsp_wait_q, wqe));
1146 list_del(&wqe->qe); 1106 list_del(&wqe->qe);
1147} 1107}
1148 1108
@@ -1193,13 +1153,8 @@ bfa_fcxp_res_recfg(struct bfa_s *bfa, u16 num_fcxp_fw)
1193 int i; 1153 int i;
1194 1154
1195 for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) { 1155 for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) {
1196 if (i < ((mod->num_fcxps - num_fcxp_fw) / 2)) { 1156 bfa_q_deq_tail(&mod->fcxp_free_q, &qe);
1197 bfa_q_deq_tail(&mod->fcxp_req_free_q, &qe); 1157 list_add_tail(qe, &mod->fcxp_unused_q);
1198 list_add_tail(qe, &mod->fcxp_req_unused_q);
1199 } else {
1200 bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe);
1201 list_add_tail(qe, &mod->fcxp_rsp_unused_q);
1202 }
1203 } 1158 }
1204} 1159}
1205 1160
@@ -1253,12 +1208,6 @@ bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1253 * Just ignore 1208 * Just ignore
1254 */ 1209 */
1255 break; 1210 break;
1256 case BFA_LPS_SM_SET_N2N_PID:
1257 /*
1258 * When topology is set to loop, bfa_lps_set_n2n_pid() sends
1259 * this event. Ignore this event.
1260 */
1261 break;
1262 1211
1263 default: 1212 default:
1264 bfa_sm_fault(lps->bfa, event); 1213 bfa_sm_fault(lps->bfa, event);
@@ -1276,7 +1225,6 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1276 1225
1277 switch (event) { 1226 switch (event) {
1278 case BFA_LPS_SM_FWRSP: 1227 case BFA_LPS_SM_FWRSP:
1279 case BFA_LPS_SM_OFFLINE:
1280 if (lps->status == BFA_STATUS_OK) { 1228 if (lps->status == BFA_STATUS_OK) {
1281 bfa_sm_set_state(lps, bfa_lps_sm_online); 1229 bfa_sm_set_state(lps, bfa_lps_sm_online);
1282 if (lps->fdisc) 1230 if (lps->fdisc)
@@ -1305,6 +1253,7 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1305 bfa_lps_login_comp(lps); 1253 bfa_lps_login_comp(lps);
1306 break; 1254 break;
1307 1255
1256 case BFA_LPS_SM_OFFLINE:
1308 case BFA_LPS_SM_DELETE: 1257 case BFA_LPS_SM_DELETE:
1309 bfa_sm_set_state(lps, bfa_lps_sm_init); 1258 bfa_sm_set_state(lps, bfa_lps_sm_init);
1310 break; 1259 break;
@@ -1331,7 +1280,6 @@ bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1331 switch (event) { 1280 switch (event) {
1332 case BFA_LPS_SM_RESUME: 1281 case BFA_LPS_SM_RESUME:
1333 bfa_sm_set_state(lps, bfa_lps_sm_login); 1282 bfa_sm_set_state(lps, bfa_lps_sm_login);
1334 bfa_lps_send_login(lps);
1335 break; 1283 break;
1336 1284
1337 case BFA_LPS_SM_OFFLINE: 1285 case BFA_LPS_SM_OFFLINE:
@@ -1455,11 +1403,11 @@ bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1455 1403
1456 switch (event) { 1404 switch (event) {
1457 case BFA_LPS_SM_FWRSP: 1405 case BFA_LPS_SM_FWRSP:
1458 case BFA_LPS_SM_OFFLINE:
1459 bfa_sm_set_state(lps, bfa_lps_sm_init); 1406 bfa_sm_set_state(lps, bfa_lps_sm_init);
1460 bfa_lps_logout_comp(lps); 1407 bfa_lps_logout_comp(lps);
1461 break; 1408 break;
1462 1409
1410 case BFA_LPS_SM_OFFLINE:
1463 case BFA_LPS_SM_DELETE: 1411 case BFA_LPS_SM_DELETE:
1464 bfa_sm_set_state(lps, bfa_lps_sm_init); 1412 bfa_sm_set_state(lps, bfa_lps_sm_init);
1465 break; 1413 break;
@@ -1630,7 +1578,7 @@ bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1630 break; 1578 break;
1631 1579
1632 case BFA_STATUS_VPORT_MAX: 1580 case BFA_STATUS_VPORT_MAX:
1633 if (rsp->ext_status) 1581 if (!rsp->ext_status)
1634 bfa_lps_no_res(lps, rsp->ext_status); 1582 bfa_lps_no_res(lps, rsp->ext_status);
1635 break; 1583 break;
1636 1584
@@ -1837,8 +1785,6 @@ bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1837 1785
1838 if (lps->fdisc) 1786 if (lps->fdisc)
1839 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg); 1787 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1840 else
1841 bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
1842} 1788}
1843 1789
1844/* 1790/*
@@ -2184,12 +2130,6 @@ bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2184 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2130 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2185 break; 2131 break;
2186 2132
2187 case BFA_FCPORT_SM_FAA_MISCONFIG:
2188 bfa_fcport_reset_linkinfo(fcport);
2189 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2190 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2191 break;
2192
2193 default: 2133 default:
2194 bfa_sm_fault(fcport->bfa, event); 2134 bfa_sm_fault(fcport->bfa, event);
2195 } 2135 }
@@ -2246,12 +2186,6 @@ bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2246 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2186 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2247 break; 2187 break;
2248 2188
2249 case BFA_FCPORT_SM_FAA_MISCONFIG:
2250 bfa_fcport_reset_linkinfo(fcport);
2251 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2252 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2253 break;
2254
2255 default: 2189 default:
2256 bfa_sm_fault(fcport->bfa, event); 2190 bfa_sm_fault(fcport->bfa, event);
2257 } 2191 }
@@ -2277,11 +2211,11 @@ bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2277 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) { 2211 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2278 2212
2279 bfa_trc(fcport->bfa, 2213 bfa_trc(fcport->bfa,
2280 pevent->link_state.attr.vc_fcf.fcf.fipenabled); 2214 pevent->link_state.vc_fcf.fcf.fipenabled);
2281 bfa_trc(fcport->bfa, 2215 bfa_trc(fcport->bfa,
2282 pevent->link_state.attr.vc_fcf.fcf.fipfailed); 2216 pevent->link_state.vc_fcf.fcf.fipfailed);
2283 2217
2284 if (pevent->link_state.attr.vc_fcf.fcf.fipfailed) 2218 if (pevent->link_state.vc_fcf.fcf.fipfailed)
2285 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2219 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2286 BFA_PL_EID_FIP_FCF_DISC, 0, 2220 BFA_PL_EID_FIP_FCF_DISC, 0,
2287 "FIP FCF Discovery Failed"); 2221 "FIP FCF Discovery Failed");
@@ -2338,12 +2272,6 @@ bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2338 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2272 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2339 break; 2273 break;
2340 2274
2341 case BFA_FCPORT_SM_FAA_MISCONFIG:
2342 bfa_fcport_reset_linkinfo(fcport);
2343 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2344 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2345 break;
2346
2347 default: 2275 default:
2348 bfa_sm_fault(fcport->bfa, event); 2276 bfa_sm_fault(fcport->bfa, event);
2349 } 2277 }
@@ -2437,12 +2365,6 @@ bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2437 } 2365 }
2438 break; 2366 break;
2439 2367
2440 case BFA_FCPORT_SM_FAA_MISCONFIG:
2441 bfa_fcport_reset_linkinfo(fcport);
2442 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2443 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2444 break;
2445
2446 default: 2368 default:
2447 bfa_sm_fault(fcport->bfa, event); 2369 bfa_sm_fault(fcport->bfa, event);
2448 } 2370 }
@@ -2488,12 +2410,6 @@ bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2488 bfa_reqq_wcancel(&fcport->reqq_wait); 2410 bfa_reqq_wcancel(&fcport->reqq_wait);
2489 break; 2411 break;
2490 2412
2491 case BFA_FCPORT_SM_FAA_MISCONFIG:
2492 bfa_fcport_reset_linkinfo(fcport);
2493 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2494 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2495 break;
2496
2497 default: 2413 default:
2498 bfa_sm_fault(fcport->bfa, event); 2414 bfa_sm_fault(fcport->bfa, event);
2499 } 2415 }
@@ -2645,10 +2561,6 @@ bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2645 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2561 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2646 break; 2562 break;
2647 2563
2648 case BFA_FCPORT_SM_DPORTENABLE:
2649 bfa_sm_set_state(fcport, bfa_fcport_sm_dport);
2650 break;
2651
2652 default: 2564 default:
2653 bfa_sm_fault(fcport->bfa, event); 2565 bfa_sm_fault(fcport->bfa, event);
2654 } 2566 }
@@ -2729,81 +2641,6 @@ bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2729 } 2641 }
2730} 2642}
2731 2643
2732static void
2733bfa_fcport_sm_dport(struct bfa_fcport_s *fcport, enum bfa_fcport_sm_event event)
2734{
2735 bfa_trc(fcport->bfa, event);
2736
2737 switch (event) {
2738 case BFA_FCPORT_SM_DPORTENABLE:
2739 case BFA_FCPORT_SM_DISABLE:
2740 case BFA_FCPORT_SM_ENABLE:
2741 case BFA_FCPORT_SM_START:
2742 /*
2743 * Ignore event for a port that is dport
2744 */
2745 break;
2746
2747 case BFA_FCPORT_SM_STOP:
2748 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2749 break;
2750
2751 case BFA_FCPORT_SM_HWFAIL:
2752 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2753 break;
2754
2755 case BFA_FCPORT_SM_DPORTDISABLE:
2756 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2757 break;
2758
2759 default:
2760 bfa_sm_fault(fcport->bfa, event);
2761 }
2762}
2763
2764static void
2765bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
2766 enum bfa_fcport_sm_event event)
2767{
2768 bfa_trc(fcport->bfa, event);
2769
2770 switch (event) {
2771 case BFA_FCPORT_SM_DPORTENABLE:
2772 case BFA_FCPORT_SM_ENABLE:
2773 case BFA_FCPORT_SM_START:
2774 /*
2775 * Ignore event for a port as there is FAA misconfig
2776 */
2777 break;
2778
2779 case BFA_FCPORT_SM_DISABLE:
2780 if (bfa_fcport_send_disable(fcport))
2781 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2782 else
2783 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2784
2785 bfa_fcport_reset_linkinfo(fcport);
2786 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2787 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2788 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2789 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2790 break;
2791
2792 case BFA_FCPORT_SM_STOP:
2793 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2794 break;
2795
2796 case BFA_FCPORT_SM_HWFAIL:
2797 bfa_fcport_reset_linkinfo(fcport);
2798 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2799 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2800 break;
2801
2802 default:
2803 bfa_sm_fault(fcport->bfa, event);
2804 }
2805}
2806
2807/* 2644/*
2808 * Link state is down 2645 * Link state is down
2809 */ 2646 */
@@ -3067,7 +2904,6 @@ bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3067 */ 2904 */
3068 do_gettimeofday(&tv); 2905 do_gettimeofday(&tv);
3069 fcport->stats_reset_time = tv.tv_sec; 2906 fcport->stats_reset_time = tv.tv_sec;
3070 fcport->stats_dma_ready = BFA_FALSE;
3071 2907
3072 /* 2908 /*
3073 * initialize and set default configuration 2909 * initialize and set default configuration
@@ -3078,9 +2914,6 @@ bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3078 port_cfg->maxfrsize = 0; 2914 port_cfg->maxfrsize = 0;
3079 2915
3080 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS; 2916 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
3081 port_cfg->qos_bw.high = BFA_QOS_BW_HIGH;
3082 port_cfg->qos_bw.med = BFA_QOS_BW_MED;
3083 port_cfg->qos_bw.low = BFA_QOS_BW_LOW;
3084 2917
3085 INIT_LIST_HEAD(&fcport->stats_pending_q); 2918 INIT_LIST_HEAD(&fcport->stats_pending_q);
3086 INIT_LIST_HEAD(&fcport->statsclr_pending_q); 2919 INIT_LIST_HEAD(&fcport->statsclr_pending_q);
@@ -3124,21 +2957,6 @@ bfa_fcport_iocdisable(struct bfa_s *bfa)
3124 bfa_trunk_iocdisable(bfa); 2957 bfa_trunk_iocdisable(bfa);
3125} 2958}
3126 2959
3127/*
3128 * Update loop info in fcport for SCN online
3129 */
3130static void
3131bfa_fcport_update_loop_info(struct bfa_fcport_s *fcport,
3132 struct bfa_fcport_loop_info_s *loop_info)
3133{
3134 fcport->myalpa = loop_info->myalpa;
3135 fcport->alpabm_valid =
3136 loop_info->alpabm_val;
3137 memcpy(fcport->alpabm.alpa_bm,
3138 loop_info->alpabm.alpa_bm,
3139 sizeof(struct fc_alpabm_s));
3140}
3141
3142static void 2960static void
3143bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport) 2961bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
3144{ 2962{
@@ -3148,15 +2966,12 @@ bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
3148 fcport->speed = pevent->link_state.speed; 2966 fcport->speed = pevent->link_state.speed;
3149 fcport->topology = pevent->link_state.topology; 2967 fcport->topology = pevent->link_state.topology;
3150 2968
3151 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP) { 2969 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)
3152 bfa_fcport_update_loop_info(fcport, 2970 fcport->myalpa = 0;
3153 &pevent->link_state.attr.loop_info);
3154 return;
3155 }
3156 2971
3157 /* QoS Details */ 2972 /* QoS Details */
3158 fcport->qos_attr = pevent->link_state.qos_attr; 2973 fcport->qos_attr = pevent->link_state.qos_attr;
3159 fcport->qos_vc_attr = pevent->link_state.attr.vc_fcf.qos_vc_attr; 2974 fcport->qos_vc_attr = pevent->link_state.vc_fcf.qos_vc_attr;
3160 2975
3161 /* 2976 /*
3162 * update trunk state if applicable 2977 * update trunk state if applicable
@@ -3165,8 +2980,7 @@ bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
3165 trunk->attr.state = BFA_TRUNK_DISABLED; 2980 trunk->attr.state = BFA_TRUNK_DISABLED;
3166 2981
3167 /* update FCoE specific */ 2982 /* update FCoE specific */
3168 fcport->fcoe_vlan = 2983 fcport->fcoe_vlan = be16_to_cpu(pevent->link_state.vc_fcf.fcf.vlan);
3169 be16_to_cpu(pevent->link_state.attr.vc_fcf.fcf.vlan);
3170 2984
3171 bfa_trc(fcport->bfa, fcport->speed); 2985 bfa_trc(fcport->bfa, fcport->speed);
3172 bfa_trc(fcport->bfa, fcport->topology); 2986 bfa_trc(fcport->bfa, fcport->topology);
@@ -3270,6 +3084,33 @@ bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3270} 3084}
3271 3085
3272static void 3086static void
3087bfa_fcport_send_txcredit(void *port_cbarg)
3088{
3089
3090 struct bfa_fcport_s *fcport = port_cbarg;
3091 struct bfi_fcport_set_svc_params_req_s *m;
3092
3093 /*
3094 * check for room in queue to send request now
3095 */
3096 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3097 if (!m) {
3098 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
3099 return;
3100 }
3101
3102 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
3103 bfa_fn_lpu(fcport->bfa));
3104 m->tx_bbcredit = cpu_to_be16((u16)fcport->cfg.tx_bbcredit);
3105 m->bb_scn = fcport->cfg.bb_scn;
3106
3107 /*
3108 * queue I/O message to firmware
3109 */
3110 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
3111}
3112
3113static void
3273bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d, 3114bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3274 struct bfa_qos_stats_s *s) 3115 struct bfa_qos_stats_s *s)
3275{ 3116{
@@ -3600,7 +3441,6 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3600 case BFI_FCPORT_I2H_ENABLE_RSP: 3441 case BFI_FCPORT_I2H_ENABLE_RSP:
3601 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) { 3442 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
3602 3443
3603 fcport->stats_dma_ready = BFA_TRUE;
3604 if (fcport->use_flash_cfg) { 3444 if (fcport->use_flash_cfg) {
3605 fcport->cfg = i2hmsg.penable_rsp->port_cfg; 3445 fcport->cfg = i2hmsg.penable_rsp->port_cfg;
3606 fcport->cfg.maxfrsize = 3446 fcport->cfg.maxfrsize =
@@ -3616,8 +3456,6 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3616 else 3456 else
3617 fcport->trunk.attr.state = 3457 fcport->trunk.attr.state =
3618 BFA_TRUNK_DISABLED; 3458 BFA_TRUNK_DISABLED;
3619 fcport->qos_attr.qos_bw =
3620 i2hmsg.penable_rsp->port_cfg.qos_bw;
3621 fcport->use_flash_cfg = BFA_FALSE; 3459 fcport->use_flash_cfg = BFA_FALSE;
3622 } 3460 }
3623 3461
@@ -3626,9 +3464,6 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3626 else 3464 else
3627 fcport->qos_attr.state = BFA_QOS_DISABLED; 3465 fcport->qos_attr.state = BFA_QOS_DISABLED;
3628 3466
3629 fcport->qos_attr.qos_bw_op =
3630 i2hmsg.penable_rsp->port_cfg.qos_bw;
3631
3632 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP); 3467 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3633 } 3468 }
3634 break; 3469 break;
@@ -3641,17 +3476,8 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3641 case BFI_FCPORT_I2H_EVENT: 3476 case BFI_FCPORT_I2H_EVENT:
3642 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP) 3477 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3643 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP); 3478 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3644 else { 3479 else
3645 if (i2hmsg.event->link_state.linkstate_rsn == 3480 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
3646 BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG)
3647 bfa_sm_send_event(fcport,
3648 BFA_FCPORT_SM_FAA_MISCONFIG);
3649 else
3650 bfa_sm_send_event(fcport,
3651 BFA_FCPORT_SM_LINKDOWN);
3652 }
3653 fcport->qos_attr.qos_bw_op =
3654 i2hmsg.event->link_state.qos_attr.qos_bw_op;
3655 break; 3481 break;
3656 3482
3657 case BFI_FCPORT_I2H_TRUNK_SCN: 3483 case BFI_FCPORT_I2H_TRUNK_SCN:
@@ -3771,32 +3597,31 @@ bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3771 3597
3772 if (fcport->cfg.trunked == BFA_TRUE) 3598 if (fcport->cfg.trunked == BFA_TRUE)
3773 return BFA_STATUS_TRUNK_ENABLED; 3599 return BFA_STATUS_TRUNK_ENABLED;
3774 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
3775 (speed == BFA_PORT_SPEED_16GBPS))
3776 return BFA_STATUS_UNSUPP_SPEED;
3777 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) { 3600 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3778 bfa_trc(bfa, fcport->speed_sup); 3601 bfa_trc(bfa, fcport->speed_sup);
3779 return BFA_STATUS_UNSUPP_SPEED; 3602 return BFA_STATUS_UNSUPP_SPEED;
3780 } 3603 }
3781 3604
3782 /* Port speed entered needs to be checked */ 3605 /* For Mezz card, port speed entered needs to be checked */
3783 if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) { 3606 if (bfa_mfg_is_mezz(fcport->bfa->ioc.attr->card_type)) {
3784 /* For CT2, 1G is not supported */ 3607 if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) {
3785 if ((speed == BFA_PORT_SPEED_1GBPS) && 3608 /* For CT2, 1G is not supported */
3786 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) 3609 if ((speed == BFA_PORT_SPEED_1GBPS) &&
3787 return BFA_STATUS_UNSUPP_SPEED; 3610 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
3611 return BFA_STATUS_UNSUPP_SPEED;
3788 3612
3789 /* Already checked for Auto Speed and Max Speed supp */ 3613 /* Already checked for Auto Speed and Max Speed supp */
3790 if (!(speed == BFA_PORT_SPEED_1GBPS || 3614 if (!(speed == BFA_PORT_SPEED_1GBPS ||
3791 speed == BFA_PORT_SPEED_2GBPS || 3615 speed == BFA_PORT_SPEED_2GBPS ||
3792 speed == BFA_PORT_SPEED_4GBPS || 3616 speed == BFA_PORT_SPEED_4GBPS ||
3793 speed == BFA_PORT_SPEED_8GBPS || 3617 speed == BFA_PORT_SPEED_8GBPS ||
3794 speed == BFA_PORT_SPEED_16GBPS || 3618 speed == BFA_PORT_SPEED_16GBPS ||
3795 speed == BFA_PORT_SPEED_AUTO)) 3619 speed == BFA_PORT_SPEED_AUTO))
3796 return BFA_STATUS_UNSUPP_SPEED; 3620 return BFA_STATUS_UNSUPP_SPEED;
3797 } else { 3621 } else {
3798 if (speed != BFA_PORT_SPEED_10GBPS) 3622 if (speed != BFA_PORT_SPEED_10GBPS)
3799 return BFA_STATUS_UNSUPP_SPEED; 3623 return BFA_STATUS_UNSUPP_SPEED;
3624 }
3800 } 3625 }
3801 3626
3802 fcport->cfg.speed = speed; 3627 fcport->cfg.speed = speed;
@@ -3828,26 +3653,7 @@ bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3828 3653
3829 switch (topology) { 3654 switch (topology) {
3830 case BFA_PORT_TOPOLOGY_P2P: 3655 case BFA_PORT_TOPOLOGY_P2P:
3831 break;
3832
3833 case BFA_PORT_TOPOLOGY_LOOP: 3656 case BFA_PORT_TOPOLOGY_LOOP:
3834 if ((bfa_fcport_is_qos_enabled(bfa) != BFA_FALSE) ||
3835 (fcport->qos_attr.state != BFA_QOS_DISABLED))
3836 return BFA_STATUS_ERROR_QOS_ENABLED;
3837 if (fcport->cfg.ratelimit != BFA_FALSE)
3838 return BFA_STATUS_ERROR_TRL_ENABLED;
3839 if ((bfa_fcport_is_trunk_enabled(bfa) != BFA_FALSE) ||
3840 (fcport->trunk.attr.state != BFA_TRUNK_DISABLED))
3841 return BFA_STATUS_ERROR_TRUNK_ENABLED;
3842 if ((bfa_fcport_get_speed(bfa) == BFA_PORT_SPEED_16GBPS) ||
3843 (fcport->cfg.speed == BFA_PORT_SPEED_16GBPS))
3844 return BFA_STATUS_UNSUPP_SPEED;
3845 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type))
3846 return BFA_STATUS_LOOP_UNSUPP_MEZZ;
3847 if (bfa_fcport_is_dport(bfa) != BFA_FALSE)
3848 return BFA_STATUS_DPORT_ERR;
3849 break;
3850
3851 case BFA_PORT_TOPOLOGY_AUTO: 3657 case BFA_PORT_TOPOLOGY_AUTO:
3852 break; 3658 break;
3853 3659
@@ -3870,17 +3676,6 @@ bfa_fcport_get_topology(struct bfa_s *bfa)
3870 return fcport->topology; 3676 return fcport->topology;
3871} 3677}
3872 3678
3873/**
3874 * Get config topology.
3875 */
3876enum bfa_port_topology
3877bfa_fcport_get_cfg_topology(struct bfa_s *bfa)
3878{
3879 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3880
3881 return fcport->cfg.topology;
3882}
3883
3884bfa_status_t 3679bfa_status_t
3885bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa) 3680bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3886{ 3681{
@@ -3956,11 +3751,9 @@ bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3956u8 3751u8
3957bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa) 3752bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3958{ 3753{
3959 if (bfa_fcport_get_topology(bfa) != BFA_PORT_TOPOLOGY_LOOP) 3754 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3960 return (BFA_FCPORT_MOD(bfa))->cfg.rx_bbcredit;
3961 3755
3962 else 3756 return fcport->cfg.rx_bbcredit;
3963 return 0;
3964} 3757}
3965 3758
3966void 3759void
@@ -3972,6 +3765,7 @@ bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit, u8 bb_scn)
3972 fcport->cfg.bb_scn = bb_scn; 3765 fcport->cfg.bb_scn = bb_scn;
3973 if (bb_scn) 3766 if (bb_scn)
3974 fcport->bbsc_op_state = BFA_TRUE; 3767 fcport->bbsc_op_state = BFA_TRUE;
3768 bfa_fcport_send_txcredit(fcport);
3975} 3769}
3976 3770
3977/* 3771/*
@@ -4031,6 +3825,8 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
4031 attr->port_state = BFA_PORT_ST_IOCDIS; 3825 attr->port_state = BFA_PORT_ST_IOCDIS;
4032 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc)) 3826 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
4033 attr->port_state = BFA_PORT_ST_FWMISMATCH; 3827 attr->port_state = BFA_PORT_ST_FWMISMATCH;
3828 else if (bfa_ioc_is_acq_addr(&fcport->bfa->ioc))
3829 attr->port_state = BFA_PORT_ST_ACQ_ADDR;
4034 } 3830 }
4035 3831
4036 /* FCoE vlan */ 3832 /* FCoE vlan */
@@ -4047,9 +3843,8 @@ bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
4047{ 3843{
4048 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3844 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4049 3845
4050 if (!bfa_iocfc_is_operational(bfa) || 3846 if (bfa_ioc_is_disabled(&bfa->ioc))
4051 !fcport->stats_dma_ready) 3847 return BFA_STATUS_IOC_DISABLED;
4052 return BFA_STATUS_IOC_NON_OP;
4053 3848
4054 if (!list_empty(&fcport->statsclr_pending_q)) 3849 if (!list_empty(&fcport->statsclr_pending_q))
4055 return BFA_STATUS_DEVBUSY; 3850 return BFA_STATUS_DEVBUSY;
@@ -4074,10 +3869,6 @@ bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
4074{ 3869{
4075 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3870 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4076 3871
4077 if (!bfa_iocfc_is_operational(bfa) ||
4078 !fcport->stats_dma_ready)
4079 return BFA_STATUS_IOC_NON_OP;
4080
4081 if (!list_empty(&fcport->stats_pending_q)) 3872 if (!list_empty(&fcport->stats_pending_q))
4082 return BFA_STATUS_DEVBUSY; 3873 return BFA_STATUS_DEVBUSY;
4083 3874
@@ -4107,40 +3898,6 @@ bfa_fcport_is_disabled(struct bfa_s *bfa)
4107} 3898}
4108 3899
4109bfa_boolean_t 3900bfa_boolean_t
4110bfa_fcport_is_dport(struct bfa_s *bfa)
4111{
4112 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4113
4114 return (bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
4115 BFA_PORT_ST_DPORT);
4116}
4117
4118bfa_status_t
4119bfa_fcport_set_qos_bw(struct bfa_s *bfa, struct bfa_qos_bw_s *qos_bw)
4120{
4121 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4122 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
4123
4124 bfa_trc(bfa, ioc_type);
4125
4126 if ((qos_bw->high == 0) || (qos_bw->med == 0) || (qos_bw->low == 0))
4127 return BFA_STATUS_QOS_BW_INVALID;
4128
4129 if ((qos_bw->high + qos_bw->med + qos_bw->low) != 100)
4130 return BFA_STATUS_QOS_BW_INVALID;
4131
4132 if ((qos_bw->med > qos_bw->high) || (qos_bw->low > qos_bw->med) ||
4133 (qos_bw->low > qos_bw->high))
4134 return BFA_STATUS_QOS_BW_INVALID;
4135
4136 if ((ioc_type == BFA_IOC_TYPE_FC) &&
4137 (fcport->cfg.topology != BFA_PORT_TOPOLOGY_LOOP))
4138 fcport->cfg.qos_bw = *qos_bw;
4139
4140 return BFA_STATUS_OK;
4141}
4142
4143bfa_boolean_t
4144bfa_fcport_is_ratelim(struct bfa_s *bfa) 3901bfa_fcport_is_ratelim(struct bfa_s *bfa)
4145{ 3902{
4146 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3903 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
@@ -4217,26 +3974,6 @@ bfa_fcport_is_trunk_enabled(struct bfa_s *bfa)
4217 return fcport->cfg.trunked; 3974 return fcport->cfg.trunked;
4218} 3975}
4219 3976
4220void
4221bfa_fcport_dportenable(struct bfa_s *bfa)
4222{
4223 /*
4224 * Assume caller check for port is in disable state
4225 */
4226 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTENABLE);
4227 bfa_port_set_dportenabled(&bfa->modules.port, BFA_TRUE);
4228}
4229
4230void
4231bfa_fcport_dportdisable(struct bfa_s *bfa)
4232{
4233 /*
4234 * Assume caller check for port is in disable state
4235 */
4236 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTDISABLE);
4237 bfa_port_set_dportenabled(&bfa->modules.port, BFA_FALSE);
4238}
4239
4240/* 3977/*
4241 * Rport State machine functions 3978 * Rport State machine functions
4242 */ 3979 */
@@ -4531,10 +4268,6 @@ bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4531 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4268 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4532 break; 4269 break;
4533 4270
4534 case BFA_RPORT_SM_OFFLINE:
4535 bfa_rport_offline_cb(rp);
4536 break;
4537
4538 default: 4271 default:
4539 bfa_stats(rp, sm_off_unexp); 4272 bfa_stats(rp, sm_off_unexp);
4540 bfa_sm_fault(rp->bfa, event); 4273 bfa_sm_fault(rp->bfa, event);
@@ -4651,7 +4384,6 @@ bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4651 case BFA_RPORT_SM_HWFAIL: 4384 case BFA_RPORT_SM_HWFAIL:
4652 bfa_stats(rp, sm_offp_hwf); 4385 bfa_stats(rp, sm_offp_hwf);
4653 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4386 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4654 bfa_rport_offline_cb(rp);
4655 break; 4387 break;
4656 4388
4657 default: 4389 default:
@@ -4963,21 +4695,6 @@ bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4963 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN); 4695 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4964 break; 4696 break;
4965 4697
4966 case BFI_RPORT_I2H_LIP_SCN_ONLINE:
4967 bfa_fcport_update_loop_info(BFA_FCPORT_MOD(bfa),
4968 &msg.lip_scn->loop_info);
4969 bfa_cb_rport_scn_online(bfa);
4970 break;
4971
4972 case BFI_RPORT_I2H_LIP_SCN_OFFLINE:
4973 bfa_cb_rport_scn_offline(bfa);
4974 break;
4975
4976 case BFI_RPORT_I2H_NO_DEV:
4977 rp = BFA_RPORT_FROM_TAG(bfa, msg.lip_scn->bfa_handle);
4978 bfa_cb_rport_scn_no_dev(rp->rport_drv);
4979 break;
4980
4981 default: 4698 default:
4982 bfa_trc(bfa, m->mhdr.msg_id); 4699 bfa_trc(bfa, m->mhdr.msg_id);
4983 WARN_ON(1); 4700 WARN_ON(1);
@@ -5045,10 +4762,8 @@ bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
5045 WARN_ON(speed == 0); 4762 WARN_ON(speed == 0);
5046 WARN_ON(speed == BFA_PORT_SPEED_AUTO); 4763 WARN_ON(speed == BFA_PORT_SPEED_AUTO);
5047 4764
5048 if (rport) { 4765 rport->rport_info.speed = speed;
5049 rport->rport_info.speed = speed; 4766 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
5050 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
5051 }
5052} 4767}
5053 4768
5054/* Set Rport LUN Mask */ 4769/* Set Rport LUN Mask */
@@ -5619,37 +5334,6 @@ bfa_uf_res_recfg(struct bfa_s *bfa, u16 num_uf_fw)
5619} 5334}
5620 5335
5621/* 5336/*
5622 * Dport forward declaration
5623 */
5624
5625/*
5626 * BFA DPORT state machine events
5627 */
5628enum bfa_dport_sm_event {
5629 BFA_DPORT_SM_ENABLE = 1, /* dport enable event */
5630 BFA_DPORT_SM_DISABLE = 2, /* dport disable event */
5631 BFA_DPORT_SM_FWRSP = 3, /* fw enable/disable rsp */
5632 BFA_DPORT_SM_QRESUME = 4, /* CQ space available */
5633 BFA_DPORT_SM_HWFAIL = 5, /* IOC h/w failure */
5634};
5635
5636static void bfa_dport_sm_disabled(struct bfa_dport_s *dport,
5637 enum bfa_dport_sm_event event);
5638static void bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
5639 enum bfa_dport_sm_event event);
5640static void bfa_dport_sm_enabling(struct bfa_dport_s *dport,
5641 enum bfa_dport_sm_event event);
5642static void bfa_dport_sm_enabled(struct bfa_dport_s *dport,
5643 enum bfa_dport_sm_event event);
5644static void bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
5645 enum bfa_dport_sm_event event);
5646static void bfa_dport_sm_disabling(struct bfa_dport_s *dport,
5647 enum bfa_dport_sm_event event);
5648static void bfa_dport_qresume(void *cbarg);
5649static void bfa_dport_req_comp(struct bfa_dport_s *dport,
5650 bfi_diag_dport_rsp_t *msg);
5651
5652/*
5653 * BFA fcdiag module 5337 * BFA fcdiag module
5654 */ 5338 */
5655#define BFA_DIAG_QTEST_TOV 1000 /* msec */ 5339#define BFA_DIAG_QTEST_TOV 1000 /* msec */
@@ -5679,24 +5363,15 @@ bfa_fcdiag_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5679 struct bfa_pcidev_s *pcidev) 5363 struct bfa_pcidev_s *pcidev)
5680{ 5364{
5681 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5365 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5682 struct bfa_dport_s *dport = &fcdiag->dport;
5683
5684 fcdiag->bfa = bfa; 5366 fcdiag->bfa = bfa;
5685 fcdiag->trcmod = bfa->trcmod; 5367 fcdiag->trcmod = bfa->trcmod;
5686 /* The common DIAG attach bfa_diag_attach() will do all memory claim */ 5368 /* The common DIAG attach bfa_diag_attach() will do all memory claim */
5687 dport->bfa = bfa;
5688 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
5689 bfa_reqq_winit(&dport->reqq_wait, bfa_dport_qresume, dport);
5690 dport->cbfn = NULL;
5691 dport->cbarg = NULL;
5692} 5369}
5693 5370
5694static void 5371static void
5695bfa_fcdiag_iocdisable(struct bfa_s *bfa) 5372bfa_fcdiag_iocdisable(struct bfa_s *bfa)
5696{ 5373{
5697 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5374 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5698 struct bfa_dport_s *dport = &fcdiag->dport;
5699
5700 bfa_trc(fcdiag, fcdiag->lb.lock); 5375 bfa_trc(fcdiag, fcdiag->lb.lock);
5701 if (fcdiag->lb.lock) { 5376 if (fcdiag->lb.lock) {
5702 fcdiag->lb.status = BFA_STATUS_IOC_FAILURE; 5377 fcdiag->lb.status = BFA_STATUS_IOC_FAILURE;
@@ -5704,8 +5379,6 @@ bfa_fcdiag_iocdisable(struct bfa_s *bfa)
5704 fcdiag->lb.lock = 0; 5379 fcdiag->lb.lock = 0;
5705 bfa_fcdiag_set_busy_status(fcdiag); 5380 bfa_fcdiag_set_busy_status(fcdiag);
5706 } 5381 }
5707
5708 bfa_sm_send_event(dport, BFA_DPORT_SM_HWFAIL);
5709} 5382}
5710 5383
5711static void 5384static void
@@ -5890,9 +5563,6 @@ bfa_fcdiag_intr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5890 case BFI_DIAG_I2H_QTEST: 5563 case BFI_DIAG_I2H_QTEST:
5891 bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg); 5564 bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg);
5892 break; 5565 break;
5893 case BFI_DIAG_I2H_DPORT:
5894 bfa_dport_req_comp(&fcdiag->dport, (bfi_diag_dport_rsp_t *)msg);
5895 break;
5896 default: 5566 default:
5897 bfa_trc(fcdiag, msg->mhdr.msg_id); 5567 bfa_trc(fcdiag, msg->mhdr.msg_id);
5898 WARN_ON(1); 5568 WARN_ON(1);
@@ -5962,18 +5632,12 @@ bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode,
5962 } 5632 }
5963 } 5633 }
5964 5634
5965 /*
5966 * For CT2, 1G is not supported
5967 */
5968 if ((speed == BFA_PORT_SPEED_1GBPS) &&
5969 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) {
5970 bfa_trc(fcdiag, speed);
5971 return BFA_STATUS_UNSUPP_SPEED;
5972 }
5973
5974 /* For Mezz card, port speed entered needs to be checked */ 5635 /* For Mezz card, port speed entered needs to be checked */
5975 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) { 5636 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) {
5976 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) { 5637 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5638 if ((speed == BFA_PORT_SPEED_1GBPS) &&
5639 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
5640 return BFA_STATUS_UNSUPP_SPEED;
5977 if (!(speed == BFA_PORT_SPEED_1GBPS || 5641 if (!(speed == BFA_PORT_SPEED_1GBPS ||
5978 speed == BFA_PORT_SPEED_2GBPS || 5642 speed == BFA_PORT_SPEED_2GBPS ||
5979 speed == BFA_PORT_SPEED_4GBPS || 5643 speed == BFA_PORT_SPEED_4GBPS ||
@@ -6086,379 +5750,3 @@ bfa_fcdiag_lb_is_running(struct bfa_s *bfa)
6086 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5750 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6087 return fcdiag->lb.lock ? BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK; 5751 return fcdiag->lb.lock ? BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK;
6088} 5752}
6089
6090/*
6091 * D-port
6092 */
6093static bfa_boolean_t bfa_dport_send_req(struct bfa_dport_s *dport,
6094 enum bfi_dport_req req);
6095static void
6096bfa_cb_fcdiag_dport(struct bfa_dport_s *dport, bfa_status_t bfa_status)
6097{
6098 if (dport->cbfn != NULL) {
6099 dport->cbfn(dport->cbarg, bfa_status);
6100 dport->cbfn = NULL;
6101 dport->cbarg = NULL;
6102 }
6103}
6104
6105static void
6106bfa_dport_sm_disabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6107{
6108 bfa_trc(dport->bfa, event);
6109
6110 switch (event) {
6111 case BFA_DPORT_SM_ENABLE:
6112 bfa_fcport_dportenable(dport->bfa);
6113 if (bfa_dport_send_req(dport, BFI_DPORT_ENABLE))
6114 bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6115 else
6116 bfa_sm_set_state(dport, bfa_dport_sm_enabling_qwait);
6117 break;
6118
6119 case BFA_DPORT_SM_DISABLE:
6120 /* Already disabled */
6121 break;
6122
6123 case BFA_DPORT_SM_HWFAIL:
6124 /* ignore */
6125 break;
6126
6127 default:
6128 bfa_sm_fault(dport->bfa, event);
6129 }
6130}
6131
6132static void
6133bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
6134 enum bfa_dport_sm_event event)
6135{
6136 bfa_trc(dport->bfa, event);
6137
6138 switch (event) {
6139 case BFA_DPORT_SM_QRESUME:
6140 bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6141 bfa_dport_send_req(dport, BFI_DPORT_ENABLE);
6142 break;
6143
6144 case BFA_DPORT_SM_HWFAIL:
6145 bfa_reqq_wcancel(&dport->reqq_wait);
6146 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6147 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6148 break;
6149
6150 default:
6151 bfa_sm_fault(dport->bfa, event);
6152 }
6153}
6154
6155static void
6156bfa_dport_sm_enabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6157{
6158 bfa_trc(dport->bfa, event);
6159
6160 switch (event) {
6161 case BFA_DPORT_SM_FWRSP:
6162 bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6163 break;
6164
6165 case BFA_DPORT_SM_HWFAIL:
6166 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6167 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6168 break;
6169
6170 default:
6171 bfa_sm_fault(dport->bfa, event);
6172 }
6173}
6174
6175static void
6176bfa_dport_sm_enabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6177{
6178 bfa_trc(dport->bfa, event);
6179
6180 switch (event) {
6181 case BFA_DPORT_SM_ENABLE:
6182 /* Already enabled */
6183 break;
6184
6185 case BFA_DPORT_SM_DISABLE:
6186 bfa_fcport_dportdisable(dport->bfa);
6187 if (bfa_dport_send_req(dport, BFI_DPORT_DISABLE))
6188 bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6189 else
6190 bfa_sm_set_state(dport, bfa_dport_sm_disabling_qwait);
6191 break;
6192
6193 case BFA_DPORT_SM_HWFAIL:
6194 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6195 break;
6196
6197 default:
6198 bfa_sm_fault(dport->bfa, event);
6199 }
6200}
6201
6202static void
6203bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
6204 enum bfa_dport_sm_event event)
6205{
6206 bfa_trc(dport->bfa, event);
6207
6208 switch (event) {
6209 case BFA_DPORT_SM_QRESUME:
6210 bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6211 bfa_dport_send_req(dport, BFI_DPORT_DISABLE);
6212 break;
6213
6214 case BFA_DPORT_SM_HWFAIL:
6215 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6216 bfa_reqq_wcancel(&dport->reqq_wait);
6217 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6218 break;
6219
6220 default:
6221 bfa_sm_fault(dport->bfa, event);
6222 }
6223}
6224
6225static void
6226bfa_dport_sm_disabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6227{
6228 bfa_trc(dport->bfa, event);
6229
6230 switch (event) {
6231 case BFA_DPORT_SM_FWRSP:
6232 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6233 break;
6234
6235 case BFA_DPORT_SM_HWFAIL:
6236 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6237 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6238 break;
6239
6240 default:
6241 bfa_sm_fault(dport->bfa, event);
6242 }
6243}
6244
6245
6246static bfa_boolean_t
6247bfa_dport_send_req(struct bfa_dport_s *dport, enum bfi_dport_req req)
6248{
6249 struct bfi_diag_dport_req_s *m;
6250
6251 /*
6252 * Increment message tag before queue check, so that responses to old
6253 * requests are discarded.
6254 */
6255 dport->msgtag++;
6256
6257 /*
6258 * check for room in queue to send request now
6259 */
6260 m = bfa_reqq_next(dport->bfa, BFA_REQQ_DIAG);
6261 if (!m) {
6262 bfa_reqq_wait(dport->bfa, BFA_REQQ_PORT, &dport->reqq_wait);
6263 return BFA_FALSE;
6264 }
6265
6266 bfi_h2i_set(m->mh, BFI_MC_DIAG, BFI_DIAG_H2I_DPORT,
6267 bfa_fn_lpu(dport->bfa));
6268 m->req = req;
6269 m->msgtag = dport->msgtag;
6270
6271 /*
6272 * queue I/O message to firmware
6273 */
6274 bfa_reqq_produce(dport->bfa, BFA_REQQ_DIAG, m->mh);
6275
6276 return BFA_TRUE;
6277}
6278
6279static void
6280bfa_dport_qresume(void *cbarg)
6281{
6282 struct bfa_dport_s *dport = cbarg;
6283
6284 bfa_sm_send_event(dport, BFA_DPORT_SM_QRESUME);
6285}
6286
6287static void
6288bfa_dport_req_comp(struct bfa_dport_s *dport, bfi_diag_dport_rsp_t *msg)
6289{
6290 bfa_sm_send_event(dport, BFA_DPORT_SM_FWRSP);
6291 bfa_cb_fcdiag_dport(dport, msg->status);
6292}
6293
6294/*
6295 * Dport enable
6296 *
6297 * @param[in] *bfa - bfa data struct
6298 */
6299bfa_status_t
6300bfa_dport_enable(struct bfa_s *bfa, bfa_cb_diag_t cbfn, void *cbarg)
6301{
6302 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6303 struct bfa_dport_s *dport = &fcdiag->dport;
6304
6305 /*
6306 * Dport is not support in MEZZ card
6307 */
6308 if (bfa_mfg_is_mezz(dport->bfa->ioc.attr->card_type)) {
6309 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6310 return BFA_STATUS_CMD_NOTSUPP_MEZZ;
6311 }
6312
6313 /*
6314 * Check to see if IOC is down
6315 */
6316 if (!bfa_iocfc_is_operational(bfa))
6317 return BFA_STATUS_IOC_NON_OP;
6318
6319 /* if port is PBC disabled, return error */
6320 if (bfa_fcport_is_pbcdisabled(bfa)) {
6321 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6322 return BFA_STATUS_PBC;
6323 }
6324
6325 /*
6326 * Check if port mode is FC port
6327 */
6328 if (bfa_ioc_get_type(&bfa->ioc) != BFA_IOC_TYPE_FC) {
6329 bfa_trc(dport->bfa, bfa_ioc_get_type(&bfa->ioc));
6330 return BFA_STATUS_CMD_NOTSUPP_CNA;
6331 }
6332
6333 /*
6334 * Check if port is in LOOP mode
6335 */
6336 if ((bfa_fcport_get_cfg_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) ||
6337 (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)) {
6338 bfa_trc(dport->bfa, 0);
6339 return BFA_STATUS_TOPOLOGY_LOOP;
6340 }
6341
6342 /*
6343 * Check if port is TRUNK mode
6344 */
6345 if (bfa_fcport_is_trunk_enabled(bfa)) {
6346 bfa_trc(dport->bfa, 0);
6347 return BFA_STATUS_ERROR_TRUNK_ENABLED;
6348 }
6349
6350 /*
6351 * Check to see if port is disable or in dport state
6352 */
6353 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6354 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6355 bfa_trc(dport->bfa, 0);
6356 return BFA_STATUS_PORT_NOT_DISABLED;
6357 }
6358
6359 /*
6360 * Check if dport is busy
6361 */
6362 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling) ||
6363 bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait) ||
6364 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling) ||
6365 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait)) {
6366 return BFA_STATUS_DEVBUSY;
6367 }
6368
6369 /*
6370 * Check if dport is already enabled
6371 */
6372 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6373 bfa_trc(dport->bfa, 0);
6374 return BFA_STATUS_DPORT_ENABLED;
6375 }
6376
6377 dport->cbfn = cbfn;
6378 dport->cbarg = cbarg;
6379
6380 bfa_sm_send_event(dport, BFA_DPORT_SM_ENABLE);
6381 return BFA_STATUS_OK;
6382}
6383
6384/*
6385 * Dport disable
6386 *
6387 * @param[in] *bfa - bfa data struct
6388 */
6389bfa_status_t
6390bfa_dport_disable(struct bfa_s *bfa, bfa_cb_diag_t cbfn, void *cbarg)
6391{
6392 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6393 struct bfa_dport_s *dport = &fcdiag->dport;
6394
6395 if (bfa_ioc_is_disabled(&bfa->ioc))
6396 return BFA_STATUS_IOC_DISABLED;
6397
6398 /* if port is PBC disabled, return error */
6399 if (bfa_fcport_is_pbcdisabled(bfa)) {
6400 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6401 return BFA_STATUS_PBC;
6402 }
6403
6404 /*
6405 * Check to see if port is disable or in dport state
6406 */
6407 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6408 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6409 bfa_trc(dport->bfa, 0);
6410 return BFA_STATUS_PORT_NOT_DISABLED;
6411 }
6412
6413 /*
6414 * Check if dport is busy
6415 */
6416 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling) ||
6417 bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait) ||
6418 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling) ||
6419 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait))
6420 return BFA_STATUS_DEVBUSY;
6421
6422 /*
6423 * Check if dport is already disabled
6424 */
6425 if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabled)) {
6426 bfa_trc(dport->bfa, 0);
6427 return BFA_STATUS_DPORT_DISABLED;
6428 }
6429
6430 dport->cbfn = cbfn;
6431 dport->cbarg = cbarg;
6432
6433 bfa_sm_send_event(dport, BFA_DPORT_SM_DISABLE);
6434 return BFA_STATUS_OK;
6435}
6436
6437/*
6438 * Get D-port state
6439 *
6440 * @param[in] *bfa - bfa data struct
6441 */
6442
6443bfa_status_t
6444bfa_dport_get_state(struct bfa_s *bfa, enum bfa_dport_state *state)
6445{
6446 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6447 struct bfa_dport_s *dport = &fcdiag->dport;
6448
6449 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabled))
6450 *state = BFA_DPORT_ST_ENABLED;
6451 else if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling) ||
6452 bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait))
6453 *state = BFA_DPORT_ST_ENABLING;
6454 else if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabled))
6455 *state = BFA_DPORT_ST_DISABLED;
6456 else if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabling) ||
6457 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait))
6458 *state = BFA_DPORT_ST_DISABLING;
6459 else {
6460 bfa_trc(dport->bfa, BFA_STATUS_EINVAL);
6461 return BFA_STATUS_EINVAL;
6462 }
6463 return BFA_STATUS_OK;
6464}
diff --git a/drivers/scsi/bfa/bfa_svc.h b/drivers/scsi/bfa/bfa_svc.h
index 8d7fbecfcb2..95adb86d376 100644
--- a/drivers/scsi/bfa/bfa_svc.h
+++ b/drivers/scsi/bfa/bfa_svc.h
@@ -97,13 +97,10 @@ struct bfa_fcxp_mod_s {
97 struct bfa_s *bfa; /* backpointer to BFA */ 97 struct bfa_s *bfa; /* backpointer to BFA */
98 struct bfa_fcxp_s *fcxp_list; /* array of FCXPs */ 98 struct bfa_fcxp_s *fcxp_list; /* array of FCXPs */
99 u16 num_fcxps; /* max num FCXP requests */ 99 u16 num_fcxps; /* max num FCXP requests */
100 struct list_head fcxp_req_free_q; /* free FCXPs used for sending req */ 100 struct list_head fcxp_free_q; /* free FCXPs */
101 struct list_head fcxp_rsp_free_q; /* free FCXPs used for sending req */ 101 struct list_head fcxp_active_q; /* active FCXPs */
102 struct list_head fcxp_active_q; /* active FCXPs */ 102 struct list_head wait_q; /* wait queue for free fcxp */
103 struct list_head req_wait_q; /* wait queue for free req_fcxp */ 103 struct list_head fcxp_unused_q; /* unused fcxps */
104 struct list_head rsp_wait_q; /* wait queue for free rsp_fcxp */
105 struct list_head fcxp_req_unused_q; /* unused req_fcxps */
106 struct list_head fcxp_rsp_unused_q; /* unused rsp_fcxps */
107 u32 req_pld_sz; 104 u32 req_pld_sz;
108 u32 rsp_pld_sz; 105 u32 rsp_pld_sz;
109 struct bfa_mem_dma_s dma_seg[BFA_FCXP_DMA_SEGS]; 106 struct bfa_mem_dma_s dma_seg[BFA_FCXP_DMA_SEGS];
@@ -200,7 +197,6 @@ struct bfa_fcxp_s {
200 struct bfa_cb_qe_s hcb_qe; /* comp: callback qelem */ 197 struct bfa_cb_qe_s hcb_qe; /* comp: callback qelem */
201 struct bfa_reqq_wait_s reqq_wqe; 198 struct bfa_reqq_wait_s reqq_wqe;
202 bfa_boolean_t reqq_waiting; 199 bfa_boolean_t reqq_waiting;
203 bfa_boolean_t req_rsp; /* Used to track req/rsp fcxp */
204}; 200};
205 201
206struct bfa_fcxp_wqe_s { 202struct bfa_fcxp_wqe_s {
@@ -474,10 +470,8 @@ struct bfa_fcport_s {
474 /* supported speeds */ 470 /* supported speeds */
475 enum bfa_port_speed speed; /* current speed */ 471 enum bfa_port_speed speed; /* current speed */
476 enum bfa_port_topology topology; /* current topology */ 472 enum bfa_port_topology topology; /* current topology */
477 u8 rsvd[3];
478 u8 myalpa; /* my ALPA in LOOP topology */ 473 u8 myalpa; /* my ALPA in LOOP topology */
479 u8 alpabm_valid; /* alpa bitmap valid or not */ 474 u8 rsvd[3];
480 struct fc_alpabm_s alpabm; /* alpa bitmap */
481 struct bfa_port_cfg_s cfg; /* current port configuration */ 475 struct bfa_port_cfg_s cfg; /* current port configuration */
482 bfa_boolean_t use_flash_cfg; /* get port cfg from flash */ 476 bfa_boolean_t use_flash_cfg; /* get port cfg from flash */
483 struct bfa_qos_attr_s qos_attr; /* QoS Attributes */ 477 struct bfa_qos_attr_s qos_attr; /* QoS Attributes */
@@ -514,7 +508,6 @@ struct bfa_fcport_s {
514 struct bfa_fcport_trunk_s trunk; 508 struct bfa_fcport_trunk_s trunk;
515 u16 fcoe_vlan; 509 u16 fcoe_vlan;
516 struct bfa_mem_dma_s fcport_dma; 510 struct bfa_mem_dma_s fcport_dma;
517 bfa_boolean_t stats_dma_ready;
518}; 511};
519 512
520#define BFA_FCPORT_MOD(__bfa) (&(__bfa)->modules.fcport) 513#define BFA_FCPORT_MOD(__bfa) (&(__bfa)->modules.fcport)
@@ -537,7 +530,6 @@ enum bfa_port_speed bfa_fcport_get_speed(struct bfa_s *bfa);
537bfa_status_t bfa_fcport_cfg_topology(struct bfa_s *bfa, 530bfa_status_t bfa_fcport_cfg_topology(struct bfa_s *bfa,
538 enum bfa_port_topology topo); 531 enum bfa_port_topology topo);
539enum bfa_port_topology bfa_fcport_get_topology(struct bfa_s *bfa); 532enum bfa_port_topology bfa_fcport_get_topology(struct bfa_s *bfa);
540enum bfa_port_topology bfa_fcport_get_cfg_topology(struct bfa_s *bfa);
541bfa_status_t bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa); 533bfa_status_t bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa);
542bfa_boolean_t bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa); 534bfa_boolean_t bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa);
543u8 bfa_fcport_get_myalpa(struct bfa_s *bfa); 535u8 bfa_fcport_get_myalpa(struct bfa_s *bfa);
@@ -551,9 +543,6 @@ void bfa_fcport_event_register(struct bfa_s *bfa,
551 void (*event_cbfn) (void *cbarg, 543 void (*event_cbfn) (void *cbarg,
552 enum bfa_port_linkstate event), void *event_cbarg); 544 enum bfa_port_linkstate event), void *event_cbarg);
553bfa_boolean_t bfa_fcport_is_disabled(struct bfa_s *bfa); 545bfa_boolean_t bfa_fcport_is_disabled(struct bfa_s *bfa);
554bfa_boolean_t bfa_fcport_is_dport(struct bfa_s *bfa);
555bfa_status_t bfa_fcport_set_qos_bw(struct bfa_s *bfa,
556 struct bfa_qos_bw_s *qos_bw);
557enum bfa_port_speed bfa_fcport_get_ratelim_speed(struct bfa_s *bfa); 546enum bfa_port_speed bfa_fcport_get_ratelim_speed(struct bfa_s *bfa);
558 547
559void bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit, u8 bb_scn); 548void bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit, u8 bb_scn);
@@ -567,8 +556,6 @@ bfa_status_t bfa_fcport_clear_stats(struct bfa_s *bfa,
567 struct bfa_cb_pending_q_s *cb); 556 struct bfa_cb_pending_q_s *cb);
568bfa_boolean_t bfa_fcport_is_qos_enabled(struct bfa_s *bfa); 557bfa_boolean_t bfa_fcport_is_qos_enabled(struct bfa_s *bfa);
569bfa_boolean_t bfa_fcport_is_trunk_enabled(struct bfa_s *bfa); 558bfa_boolean_t bfa_fcport_is_trunk_enabled(struct bfa_s *bfa);
570void bfa_fcport_dportenable(struct bfa_s *bfa);
571void bfa_fcport_dportdisable(struct bfa_s *bfa);
572bfa_status_t bfa_fcport_is_pbcdisabled(struct bfa_s *bfa); 559bfa_status_t bfa_fcport_is_pbcdisabled(struct bfa_s *bfa);
573void bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state); 560void bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state);
574 561
@@ -584,9 +571,6 @@ void bfa_cb_rport_offline(void *rport);
584void bfa_cb_rport_qos_scn_flowid(void *rport, 571void bfa_cb_rport_qos_scn_flowid(void *rport,
585 struct bfa_rport_qos_attr_s old_qos_attr, 572 struct bfa_rport_qos_attr_s old_qos_attr,
586 struct bfa_rport_qos_attr_s new_qos_attr); 573 struct bfa_rport_qos_attr_s new_qos_attr);
587void bfa_cb_rport_scn_online(struct bfa_s *bfa);
588void bfa_cb_rport_scn_offline(struct bfa_s *bfa);
589void bfa_cb_rport_scn_no_dev(void *rp);
590void bfa_cb_rport_qos_scn_prio(void *rport, 574void bfa_cb_rport_qos_scn_prio(void *rport,
591 struct bfa_rport_qos_attr_s old_qos_attr, 575 struct bfa_rport_qos_attr_s old_qos_attr,
592 struct bfa_rport_qos_attr_s new_qos_attr); 576 struct bfa_rport_qos_attr_s new_qos_attr);
@@ -598,26 +582,29 @@ void bfa_cb_rport_qos_scn_prio(void *rport,
598#define BFA_LP_TAG_INVALID 0xff 582#define BFA_LP_TAG_INVALID 0xff
599void bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp); 583void bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp);
600void bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp); 584void bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp);
585bfa_boolean_t bfa_rport_lunmask_active(struct bfa_rport_s *rp);
586wwn_t bfa_rport_get_pwwn(struct bfa_s *bfa, struct bfa_rport_s *rp);
587struct bfa_rport_s *bfa_rport_get_by_wwn(struct bfa_s *bfa, u16 vf_id,
588 wwn_t *lpwwn, wwn_t rpwwn);
589void *bfa_cb_get_rp_by_wwn(void *arg, u16 vf_id, wwn_t *lpwwn, wwn_t rpwwn);
601 590
602/* 591/*
603 * bfa fcxp API functions 592 * bfa fcxp API functions
604 */ 593 */
605struct bfa_fcxp_s *bfa_fcxp_req_rsp_alloc(void *bfad_fcxp, struct bfa_s *bfa, 594struct bfa_fcxp_s *bfa_fcxp_alloc(void *bfad_fcxp, struct bfa_s *bfa,
606 int nreq_sgles, int nrsp_sgles, 595 int nreq_sgles, int nrsp_sgles,
607 bfa_fcxp_get_sgaddr_t get_req_sga, 596 bfa_fcxp_get_sgaddr_t get_req_sga,
608 bfa_fcxp_get_sglen_t get_req_sglen, 597 bfa_fcxp_get_sglen_t get_req_sglen,
609 bfa_fcxp_get_sgaddr_t get_rsp_sga, 598 bfa_fcxp_get_sgaddr_t get_rsp_sga,
610 bfa_fcxp_get_sglen_t get_rsp_sglen, 599 bfa_fcxp_get_sglen_t get_rsp_sglen);
611 bfa_boolean_t req); 600void bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
612void bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
613 bfa_fcxp_alloc_cbfn_t alloc_cbfn, 601 bfa_fcxp_alloc_cbfn_t alloc_cbfn,
614 void *cbarg, void *bfad_fcxp, 602 void *cbarg, void *bfad_fcxp,
615 int nreq_sgles, int nrsp_sgles, 603 int nreq_sgles, int nrsp_sgles,
616 bfa_fcxp_get_sgaddr_t get_req_sga, 604 bfa_fcxp_get_sgaddr_t get_req_sga,
617 bfa_fcxp_get_sglen_t get_req_sglen, 605 bfa_fcxp_get_sglen_t get_req_sglen,
618 bfa_fcxp_get_sgaddr_t get_rsp_sga, 606 bfa_fcxp_get_sgaddr_t get_rsp_sga,
619 bfa_fcxp_get_sglen_t get_rsp_sglen, 607 bfa_fcxp_get_sglen_t get_rsp_sglen);
620 bfa_boolean_t req);
621void bfa_fcxp_walloc_cancel(struct bfa_s *bfa, 608void bfa_fcxp_walloc_cancel(struct bfa_s *bfa,
622 struct bfa_fcxp_wqe_s *wqe); 609 struct bfa_fcxp_wqe_s *wqe);
623void bfa_fcxp_discard(struct bfa_fcxp_s *fcxp); 610void bfa_fcxp_discard(struct bfa_fcxp_s *fcxp);
@@ -676,12 +663,15 @@ u8 bfa_lps_get_fwtag(struct bfa_s *bfa, u8 lp_tag);
676u32 bfa_lps_get_base_pid(struct bfa_s *bfa); 663u32 bfa_lps_get_base_pid(struct bfa_s *bfa);
677u8 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid); 664u8 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid);
678void bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status); 665void bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status);
679void bfa_cb_lps_flogo_comp(void *bfad, void *uarg);
680void bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status); 666void bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status);
681void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg); 667void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg);
682void bfa_cb_lps_cvl_event(void *bfad, void *uarg); 668void bfa_cb_lps_cvl_event(void *bfad, void *uarg);
683 669
684/* FAA specific APIs */ 670/* FAA specific APIs */
671bfa_status_t bfa_faa_enable(struct bfa_s *bfa,
672 bfa_cb_iocfc_t cbfn, void *cbarg);
673bfa_status_t bfa_faa_disable(struct bfa_s *bfa,
674 bfa_cb_iocfc_t cbfn, void *cbarg);
685bfa_status_t bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr, 675bfa_status_t bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
686 bfa_cb_iocfc_t cbfn, void *cbarg); 676 bfa_cb_iocfc_t cbfn, void *cbarg);
687 677
@@ -709,21 +699,11 @@ struct bfa_fcdiag_lb_s {
709 u32 status; 699 u32 status;
710}; 700};
711 701
712struct bfa_dport_s {
713 struct bfa_s *bfa; /* Back pointer to BFA */
714 bfa_sm_t sm; /* finite state machine */
715 u32 msgtag; /* firmware msg tag for reply */
716 struct bfa_reqq_wait_s reqq_wait;
717 bfa_cb_diag_t cbfn;
718 void *cbarg;
719};
720
721struct bfa_fcdiag_s { 702struct bfa_fcdiag_s {
722 struct bfa_s *bfa; /* Back pointer to BFA */ 703 struct bfa_s *bfa; /* Back pointer to BFA */
723 struct bfa_trc_mod_s *trcmod; 704 struct bfa_trc_mod_s *trcmod;
724 struct bfa_fcdiag_lb_s lb; 705 struct bfa_fcdiag_lb_s lb;
725 struct bfa_fcdiag_qtest_s qtest; 706 struct bfa_fcdiag_qtest_s qtest;
726 struct bfa_dport_s dport;
727}; 707};
728 708
729#define BFA_FCDIAG_MOD(__bfa) (&(__bfa)->modules.fcdiag) 709#define BFA_FCDIAG_MOD(__bfa) (&(__bfa)->modules.fcdiag)
@@ -739,11 +719,5 @@ bfa_status_t bfa_fcdiag_queuetest(struct bfa_s *bfa, u32 ignore,
739 u32 queue, struct bfa_diag_qtest_result_s *result, 719 u32 queue, struct bfa_diag_qtest_result_s *result,
740 bfa_cb_diag_t cbfn, void *cbarg); 720 bfa_cb_diag_t cbfn, void *cbarg);
741bfa_status_t bfa_fcdiag_lb_is_running(struct bfa_s *bfa); 721bfa_status_t bfa_fcdiag_lb_is_running(struct bfa_s *bfa);
742bfa_status_t bfa_dport_enable(struct bfa_s *bfa, bfa_cb_diag_t cbfn,
743 void *cbarg);
744bfa_status_t bfa_dport_disable(struct bfa_s *bfa, bfa_cb_diag_t cbfn,
745 void *cbarg);
746bfa_status_t bfa_dport_get_state(struct bfa_s *bfa,
747 enum bfa_dport_state *state);
748 722
749#endif /* __BFA_SVC_H__ */ 723#endif /* __BFA_SVC_H__ */
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index e6bf12675db..66fb72531b3 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -57,15 +57,14 @@ int pcie_max_read_reqsz;
57int bfa_debugfs_enable = 1; 57int bfa_debugfs_enable = 1;
58int msix_disable_cb = 0, msix_disable_ct = 0; 58int msix_disable_cb = 0, msix_disable_ct = 0;
59int max_xfer_size = BFAD_MAX_SECTORS >> 1; 59int max_xfer_size = BFAD_MAX_SECTORS >> 1;
60int max_rport_logins = BFA_FCS_MAX_RPORT_LOGINS;
61 60
62/* Firmware releated */ 61/* Firmware releated */
63u32 bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size; 62u32 bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size;
64u32 *bfi_image_cb, *bfi_image_ct, *bfi_image_ct2; 63u32 *bfi_image_cb, *bfi_image_ct, *bfi_image_ct2;
65 64
66#define BFAD_FW_FILE_CB "cbfw-3.1.0.0.bin" 65#define BFAD_FW_FILE_CB "cbfw.bin"
67#define BFAD_FW_FILE_CT "ctfw-3.1.0.0.bin" 66#define BFAD_FW_FILE_CT "ctfw.bin"
68#define BFAD_FW_FILE_CT2 "ct2fw-3.1.0.0.bin" 67#define BFAD_FW_FILE_CT2 "ct2fw.bin"
69 68
70static u32 *bfad_load_fwimg(struct pci_dev *pdev); 69static u32 *bfad_load_fwimg(struct pci_dev *pdev);
71static void bfad_free_fwimg(void); 70static void bfad_free_fwimg(void);
@@ -149,8 +148,6 @@ MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1,"
149module_param(max_xfer_size, int, S_IRUGO | S_IWUSR); 148module_param(max_xfer_size, int, S_IRUGO | S_IWUSR);
150MODULE_PARM_DESC(max_xfer_size, "default=32MB," 149MODULE_PARM_DESC(max_xfer_size, "default=32MB,"
151 " Range[64k|128k|256k|512k|1024k|2048k]"); 150 " Range[64k|128k|256k|512k|1024k|2048k]");
152module_param(max_rport_logins, int, S_IRUGO | S_IWUSR);
153MODULE_PARM_DESC(max_rport_logins, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024");
154 151
155static void 152static void
156bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event); 153bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event);
@@ -459,6 +456,23 @@ bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port,
459 return port_drv; 456 return port_drv;
460} 457}
461 458
459void
460bfa_fcb_lport_delete(struct bfad_s *bfad, enum bfa_lport_role roles,
461 struct bfad_vf_s *vf_drv, struct bfad_vport_s *vp_drv)
462{
463 struct bfad_port_s *port_drv;
464
465 /* this will be only called from rmmod context */
466 if (vp_drv && !vp_drv->comp_del) {
467 port_drv = (vp_drv) ? (&(vp_drv)->drv_port) :
468 ((vf_drv) ? (&(vf_drv)->base_port) :
469 (&(bfad)->pport));
470 bfa_trc(bfad, roles);
471 if (roles & BFA_LPORT_ROLE_FCP_IM)
472 bfad_im_port_delete(bfad, port_drv);
473 }
474}
475
462/* 476/*
463 * FCS RPORT alloc callback, after successful PLOGI by FCS 477 * FCS RPORT alloc callback, after successful PLOGI by FCS
464 */ 478 */
@@ -660,7 +674,6 @@ bfad_vport_create(struct bfad_s *bfad, u16 vf_id,
660 674
661 spin_lock_irqsave(&bfad->bfad_lock, flags); 675 spin_lock_irqsave(&bfad->bfad_lock, flags);
662 bfa_fcs_vport_start(&vport->fcs_vport); 676 bfa_fcs_vport_start(&vport->fcs_vport);
663 list_add_tail(&vport->list_entry, &bfad->vport_list);
664 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 677 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
665 678
666 return BFA_STATUS_OK; 679 return BFA_STATUS_OK;
@@ -739,9 +752,6 @@ bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
739 } 752 }
740 } 753 }
741 754
742 /* Enable PCIE Advanced Error Recovery (AER) if kernel supports */
743 pci_enable_pcie_error_reporting(pdev);
744
745 bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0)); 755 bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
746 bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2)); 756 bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2));
747 757
@@ -812,8 +822,6 @@ bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
812 } 822 }
813 } 823 }
814 824
815 pci_save_state(pdev);
816
817 return 0; 825 return 0;
818 826
819out_release_region: 827out_release_region:
@@ -830,8 +838,6 @@ bfad_pci_uninit(struct pci_dev *pdev, struct bfad_s *bfad)
830 pci_iounmap(pdev, bfad->pci_bar0_kva); 838 pci_iounmap(pdev, bfad->pci_bar0_kva);
831 pci_iounmap(pdev, bfad->pci_bar2_kva); 839 pci_iounmap(pdev, bfad->pci_bar2_kva);
832 pci_release_regions(pdev); 840 pci_release_regions(pdev);
833 /* Disable PCIE Advanced Error Recovery (AER) */
834 pci_disable_pcie_error_reporting(pdev);
835 pci_disable_device(pdev); 841 pci_disable_device(pdev);
836 pci_set_drvdata(pdev, NULL); 842 pci_set_drvdata(pdev, NULL);
837} 843}
@@ -1268,16 +1274,6 @@ bfad_setup_intr(struct bfad_s *bfad)
1268 1274
1269 error = pci_enable_msix(bfad->pcidev, msix_entries, bfad->nvec); 1275 error = pci_enable_msix(bfad->pcidev, msix_entries, bfad->nvec);
1270 if (error) { 1276 if (error) {
1271 /* In CT1 & CT2, try to allocate just one vector */
1272 if (bfa_asic_id_ctc(pdev->device)) {
1273 printk(KERN_WARNING "bfa %s: trying one msix "
1274 "vector failed to allocate %d[%d]\n",
1275 bfad->pci_name, bfad->nvec, error);
1276 bfad->nvec = 1;
1277 error = pci_enable_msix(bfad->pcidev,
1278 msix_entries, bfad->nvec);
1279 }
1280
1281 /* 1277 /*
1282 * Only error number of vector is available. 1278 * Only error number of vector is available.
1283 * We don't have a mechanism to map multiple 1279 * We don't have a mechanism to map multiple
@@ -1287,13 +1283,12 @@ bfad_setup_intr(struct bfad_s *bfad)
1287 * vectors. Linux doesn't duplicate vectors 1283 * vectors. Linux doesn't duplicate vectors
1288 * in the MSIX table for this case. 1284 * in the MSIX table for this case.
1289 */ 1285 */
1290 if (error) { 1286
1291 printk(KERN_WARNING "bfad%d: " 1287 printk(KERN_WARNING "bfad%d: "
1292 "pci_enable_msix failed (%d), " 1288 "pci_enable_msix failed (%d),"
1293 "use line based.\n", 1289 " use line based.\n", bfad->inst_no, error);
1294 bfad->inst_no, error); 1290
1295 goto line_based; 1291 goto line_based;
1296 }
1297 } 1292 }
1298 1293
1299 /* Disable INTX in MSI-X mode */ 1294 /* Disable INTX in MSI-X mode */
@@ -1404,14 +1399,11 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
1404 bfa_sm_set_state(bfad, bfad_sm_uninit); 1399 bfa_sm_set_state(bfad, bfad_sm_uninit);
1405 1400
1406 spin_lock_init(&bfad->bfad_lock); 1401 spin_lock_init(&bfad->bfad_lock);
1407 spin_lock_init(&bfad->bfad_aen_spinlock);
1408
1409 pci_set_drvdata(pdev, bfad); 1402 pci_set_drvdata(pdev, bfad);
1410 1403
1411 bfad->ref_count = 0; 1404 bfad->ref_count = 0;
1412 bfad->pport.bfad = bfad; 1405 bfad->pport.bfad = bfad;
1413 INIT_LIST_HEAD(&bfad->pbc_vport_list); 1406 INIT_LIST_HEAD(&bfad->pbc_vport_list);
1414 INIT_LIST_HEAD(&bfad->vport_list);
1415 1407
1416 /* Setup the debugfs node for this bfad */ 1408 /* Setup the debugfs node for this bfad */
1417 if (bfa_debugfs_enable) 1409 if (bfa_debugfs_enable)
@@ -1491,197 +1483,6 @@ bfad_pci_remove(struct pci_dev *pdev)
1491 kfree(bfad); 1483 kfree(bfad);
1492} 1484}
1493 1485
1494/*
1495 * PCI Error Recovery entry, error detected.
1496 */
1497static pci_ers_result_t
1498bfad_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
1499{
1500 struct bfad_s *bfad = pci_get_drvdata(pdev);
1501 unsigned long flags;
1502 pci_ers_result_t ret = PCI_ERS_RESULT_NONE;
1503
1504 dev_printk(KERN_ERR, &pdev->dev,
1505 "error detected state: %d - flags: 0x%x\n",
1506 state, bfad->bfad_flags);
1507
1508 switch (state) {
1509 case pci_channel_io_normal: /* non-fatal error */
1510 spin_lock_irqsave(&bfad->bfad_lock, flags);
1511 bfad->bfad_flags &= ~BFAD_EEH_BUSY;
1512 /* Suspend/fail all bfa operations */
1513 bfa_ioc_suspend(&bfad->bfa.ioc);
1514 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1515 del_timer_sync(&bfad->hal_tmo);
1516 ret = PCI_ERS_RESULT_CAN_RECOVER;
1517 break;
1518 case pci_channel_io_frozen: /* fatal error */
1519 init_completion(&bfad->comp);
1520 spin_lock_irqsave(&bfad->bfad_lock, flags);
1521 bfad->bfad_flags |= BFAD_EEH_BUSY;
1522 /* Suspend/fail all bfa operations */
1523 bfa_ioc_suspend(&bfad->bfa.ioc);
1524 bfa_fcs_stop(&bfad->bfa_fcs);
1525 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1526 wait_for_completion(&bfad->comp);
1527
1528 bfad_remove_intr(bfad);
1529 del_timer_sync(&bfad->hal_tmo);
1530 pci_disable_device(pdev);
1531 ret = PCI_ERS_RESULT_NEED_RESET;
1532 break;
1533 case pci_channel_io_perm_failure: /* PCI Card is DEAD */
1534 spin_lock_irqsave(&bfad->bfad_lock, flags);
1535 bfad->bfad_flags |= BFAD_EEH_BUSY |
1536 BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE;
1537 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1538
1539 /* If the error_detected handler is called with the reason
1540 * pci_channel_io_perm_failure - it will subsequently call
1541 * pci_remove() entry point to remove the pci device from the
1542 * system - So defer the cleanup to pci_remove(); cleaning up
1543 * here causes inconsistent state during pci_remove().
1544 */
1545 ret = PCI_ERS_RESULT_DISCONNECT;
1546 break;
1547 default:
1548 WARN_ON(1);
1549 }
1550
1551 return ret;
1552}
1553
1554int
1555restart_bfa(struct bfad_s *bfad)
1556{
1557 unsigned long flags;
1558 struct pci_dev *pdev = bfad->pcidev;
1559
1560 bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg,
1561 &bfad->meminfo, &bfad->hal_pcidev);
1562
1563 /* Enable Interrupt and wait bfa_init completion */
1564 if (bfad_setup_intr(bfad)) {
1565 dev_printk(KERN_WARNING, &pdev->dev,
1566 "%s: bfad_setup_intr failed\n", bfad->pci_name);
1567 bfa_sm_send_event(bfad, BFAD_E_INTR_INIT_FAILED);
1568 return -1;
1569 }
1570
1571 init_completion(&bfad->comp);
1572 spin_lock_irqsave(&bfad->bfad_lock, flags);
1573 bfa_iocfc_init(&bfad->bfa);
1574 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1575
1576 /* Set up interrupt handler for each vectors */
1577 if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
1578 bfad_install_msix_handler(bfad))
1579 dev_printk(KERN_WARNING, &pdev->dev,
1580 "%s: install_msix failed.\n", bfad->pci_name);
1581
1582 bfad_init_timer(bfad);
1583 wait_for_completion(&bfad->comp);
1584 bfad_drv_start(bfad);
1585
1586 return 0;
1587}
1588
1589/*
1590 * PCI Error Recovery entry, re-initialize the chip.
1591 */
1592static pci_ers_result_t
1593bfad_pci_slot_reset(struct pci_dev *pdev)
1594{
1595 struct bfad_s *bfad = pci_get_drvdata(pdev);
1596 u8 byte;
1597
1598 dev_printk(KERN_ERR, &pdev->dev,
1599 "bfad_pci_slot_reset flags: 0x%x\n", bfad->bfad_flags);
1600
1601 if (pci_enable_device(pdev)) {
1602 dev_printk(KERN_ERR, &pdev->dev, "Cannot re-enable "
1603 "PCI device after reset.\n");
1604 return PCI_ERS_RESULT_DISCONNECT;
1605 }
1606
1607 pci_restore_state(pdev);
1608
1609 /*
1610 * Read some byte (e.g. DMA max. payload size which can't
1611 * be 0xff any time) to make sure - we did not hit another PCI error
1612 * in the middle of recovery. If we did, then declare permanent failure.
1613 */
1614 pci_read_config_byte(pdev, 0x68, &byte);
1615 if (byte == 0xff) {
1616 dev_printk(KERN_ERR, &pdev->dev,
1617 "slot_reset failed ... got another PCI error !\n");
1618 goto out_disable_device;
1619 }
1620
1621 pci_save_state(pdev);
1622 pci_set_master(pdev);
1623
1624 if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(64)) != 0)
1625 if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(32)) != 0)
1626 goto out_disable_device;
1627
1628 pci_cleanup_aer_uncorrect_error_status(pdev);
1629
1630 if (restart_bfa(bfad) == -1)
1631 goto out_disable_device;
1632
1633 pci_enable_pcie_error_reporting(pdev);
1634 dev_printk(KERN_WARNING, &pdev->dev,
1635 "slot_reset completed flags: 0x%x!\n", bfad->bfad_flags);
1636
1637 return PCI_ERS_RESULT_RECOVERED;
1638
1639out_disable_device:
1640 pci_disable_device(pdev);
1641 return PCI_ERS_RESULT_DISCONNECT;
1642}
1643
1644static pci_ers_result_t
1645bfad_pci_mmio_enabled(struct pci_dev *pdev)
1646{
1647 unsigned long flags;
1648 struct bfad_s *bfad = pci_get_drvdata(pdev);
1649
1650 dev_printk(KERN_INFO, &pdev->dev, "mmio_enabled\n");
1651
1652 /* Fetch FW diagnostic information */
1653 bfa_ioc_debug_save_ftrc(&bfad->bfa.ioc);
1654
1655 /* Cancel all pending IOs */
1656 spin_lock_irqsave(&bfad->bfad_lock, flags);
1657 init_completion(&bfad->comp);
1658 bfa_fcs_stop(&bfad->bfa_fcs);
1659 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1660 wait_for_completion(&bfad->comp);
1661
1662 bfad_remove_intr(bfad);
1663 del_timer_sync(&bfad->hal_tmo);
1664 pci_disable_device(pdev);
1665
1666 return PCI_ERS_RESULT_NEED_RESET;
1667}
1668
1669static void
1670bfad_pci_resume(struct pci_dev *pdev)
1671{
1672 unsigned long flags;
1673 struct bfad_s *bfad = pci_get_drvdata(pdev);
1674
1675 dev_printk(KERN_WARNING, &pdev->dev, "resume\n");
1676
1677 /* wait until the link is online */
1678 bfad_rport_online_wait(bfad);
1679
1680 spin_lock_irqsave(&bfad->bfad_lock, flags);
1681 bfad->bfad_flags &= ~BFAD_EEH_BUSY;
1682 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1683}
1684
1685struct pci_device_id bfad_id_table[] = { 1486struct pci_device_id bfad_id_table[] = {
1686 { 1487 {
1687 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1488 .vendor = BFA_PCI_VENDOR_ID_BROCADE,
@@ -1725,22 +1526,11 @@ struct pci_device_id bfad_id_table[] = {
1725 1526
1726MODULE_DEVICE_TABLE(pci, bfad_id_table); 1527MODULE_DEVICE_TABLE(pci, bfad_id_table);
1727 1528
1728/*
1729 * PCI error recovery handlers.
1730 */
1731static struct pci_error_handlers bfad_err_handler = {
1732 .error_detected = bfad_pci_error_detected,
1733 .slot_reset = bfad_pci_slot_reset,
1734 .mmio_enabled = bfad_pci_mmio_enabled,
1735 .resume = bfad_pci_resume,
1736};
1737
1738static struct pci_driver bfad_pci_driver = { 1529static struct pci_driver bfad_pci_driver = {
1739 .name = BFAD_DRIVER_NAME, 1530 .name = BFAD_DRIVER_NAME,
1740 .id_table = bfad_id_table, 1531 .id_table = bfad_id_table,
1741 .probe = bfad_pci_probe, 1532 .probe = bfad_pci_probe,
1742 .remove = bfad_pci_remove, 1533 .remove = __devexit_p(bfad_pci_remove),
1743 .err_handler = &bfad_err_handler,
1744}; 1534};
1745 1535
1746/* 1536/*
@@ -1769,7 +1559,6 @@ bfad_init(void)
1769 1559
1770 bfa_auto_recover = ioc_auto_recover; 1560 bfa_auto_recover = ioc_auto_recover;
1771 bfa_fcs_rport_set_del_timeout(rport_del_timeout); 1561 bfa_fcs_rport_set_del_timeout(rport_del_timeout);
1772 bfa_fcs_rport_set_max_logins(max_rport_logins);
1773 1562
1774 error = pci_register_driver(&bfad_pci_driver); 1563 error = pci_register_driver(&bfad_pci_driver);
1775 if (error) { 1564 if (error) {
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index 72f5dc32cc1..9d95844ab46 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -426,23 +426,6 @@ bfad_im_vport_create(struct fc_vport *fc_vport, bool disable)
426 vshost = vport->drv_port.im_port->shost; 426 vshost = vport->drv_port.im_port->shost;
427 fc_host_node_name(vshost) = wwn_to_u64((u8 *)&port_cfg.nwwn); 427 fc_host_node_name(vshost) = wwn_to_u64((u8 *)&port_cfg.nwwn);
428 fc_host_port_name(vshost) = wwn_to_u64((u8 *)&port_cfg.pwwn); 428 fc_host_port_name(vshost) = wwn_to_u64((u8 *)&port_cfg.pwwn);
429 fc_host_supported_classes(vshost) = FC_COS_CLASS3;
430
431 memset(fc_host_supported_fc4s(vshost), 0,
432 sizeof(fc_host_supported_fc4s(vshost)));
433
434 /* For FCP type 0x08 */
435 if (supported_fc4s & BFA_LPORT_ROLE_FCP_IM)
436 fc_host_supported_fc4s(vshost)[2] = 1;
437
438 /* For fibre channel services type 0x20 */
439 fc_host_supported_fc4s(vshost)[7] = 1;
440
441 fc_host_supported_speeds(vshost) =
442 bfad_im_supported_speeds(&bfad->bfa);
443 fc_host_maxframe_size(vshost) =
444 bfa_fcport_get_maxfrsize(&bfad->bfa);
445
446 fc_vport->dd_data = vport; 429 fc_vport->dd_data = vport;
447 vport->drv_port.im_port->fc_vport = fc_vport; 430 vport->drv_port.im_port->fc_vport = fc_vport;
448 } else if (rc == BFA_STATUS_INVALID_WWN) 431 } else if (rc == BFA_STATUS_INVALID_WWN)
@@ -459,43 +442,6 @@ bfad_im_vport_create(struct fc_vport *fc_vport, bool disable)
459 return status; 442 return status;
460} 443}
461 444
462int
463bfad_im_issue_fc_host_lip(struct Scsi_Host *shost)
464{
465 struct bfad_im_port_s *im_port =
466 (struct bfad_im_port_s *) shost->hostdata[0];
467 struct bfad_s *bfad = im_port->bfad;
468 struct bfad_hal_comp fcomp;
469 unsigned long flags;
470 uint32_t status;
471
472 init_completion(&fcomp.comp);
473 spin_lock_irqsave(&bfad->bfad_lock, flags);
474 status = bfa_port_disable(&bfad->bfa.modules.port,
475 bfad_hcb_comp, &fcomp);
476 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
477
478 if (status != BFA_STATUS_OK)
479 return -EIO;
480
481 wait_for_completion(&fcomp.comp);
482 if (fcomp.status != BFA_STATUS_OK)
483 return -EIO;
484
485 spin_lock_irqsave(&bfad->bfad_lock, flags);
486 status = bfa_port_enable(&bfad->bfa.modules.port,
487 bfad_hcb_comp, &fcomp);
488 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
489 if (status != BFA_STATUS_OK)
490 return -EIO;
491
492 wait_for_completion(&fcomp.comp);
493 if (fcomp.status != BFA_STATUS_OK)
494 return -EIO;
495
496 return 0;
497}
498
499static int 445static int
500bfad_im_vport_delete(struct fc_vport *fc_vport) 446bfad_im_vport_delete(struct fc_vport *fc_vport)
501{ 447{
@@ -511,12 +457,8 @@ bfad_im_vport_delete(struct fc_vport *fc_vport)
511 unsigned long flags; 457 unsigned long flags;
512 struct completion fcomp; 458 struct completion fcomp;
513 459
514 if (im_port->flags & BFAD_PORT_DELETE) { 460 if (im_port->flags & BFAD_PORT_DELETE)
515 bfad_scsi_host_free(bfad, im_port); 461 goto free_scsi_host;
516 list_del(&vport->list_entry);
517 kfree(vport);
518 return 0;
519 }
520 462
521 port = im_port->port; 463 port = im_port->port;
522 464
@@ -547,8 +489,9 @@ bfad_im_vport_delete(struct fc_vport *fc_vport)
547 489
548 wait_for_completion(vport->comp_del); 490 wait_for_completion(vport->comp_del);
549 491
492free_scsi_host:
550 bfad_scsi_host_free(bfad, im_port); 493 bfad_scsi_host_free(bfad, im_port);
551 list_del(&vport->list_entry); 494
552 kfree(vport); 495 kfree(vport);
553 496
554 return 0; 497 return 0;
@@ -587,37 +530,6 @@ bfad_im_vport_disable(struct fc_vport *fc_vport, bool disable)
587 return 0; 530 return 0;
588} 531}
589 532
590void
591bfad_im_vport_set_symbolic_name(struct fc_vport *fc_vport)
592{
593 struct bfad_vport_s *vport = (struct bfad_vport_s *)fc_vport->dd_data;
594 struct bfad_im_port_s *im_port =
595 (struct bfad_im_port_s *)vport->drv_port.im_port;
596 struct bfad_s *bfad = im_port->bfad;
597 struct Scsi_Host *vshost = vport->drv_port.im_port->shost;
598 char *sym_name = fc_vport->symbolic_name;
599 struct bfa_fcs_vport_s *fcs_vport;
600 wwn_t pwwn;
601 unsigned long flags;
602
603 u64_to_wwn(fc_host_port_name(vshost), (u8 *)&pwwn);
604
605 spin_lock_irqsave(&bfad->bfad_lock, flags);
606 fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs, 0, pwwn);
607 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
608
609 if (fcs_vport == NULL)
610 return;
611
612 spin_lock_irqsave(&bfad->bfad_lock, flags);
613 if (strlen(sym_name) > 0) {
614 strcpy(fcs_vport->lport.port_cfg.sym_name.symname, sym_name);
615 bfa_fcs_lport_ns_util_send_rspn_id(
616 BFA_FCS_GET_NS_FROM_PORT((&fcs_vport->lport)), NULL);
617 }
618 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
619}
620
621struct fc_function_template bfad_im_fc_function_template = { 533struct fc_function_template bfad_im_fc_function_template = {
622 534
623 /* Target dynamic attributes */ 535 /* Target dynamic attributes */
@@ -667,11 +579,10 @@ struct fc_function_template bfad_im_fc_function_template = {
667 .show_rport_dev_loss_tmo = 1, 579 .show_rport_dev_loss_tmo = 1,
668 .get_rport_dev_loss_tmo = bfad_im_get_rport_loss_tmo, 580 .get_rport_dev_loss_tmo = bfad_im_get_rport_loss_tmo,
669 .set_rport_dev_loss_tmo = bfad_im_set_rport_loss_tmo, 581 .set_rport_dev_loss_tmo = bfad_im_set_rport_loss_tmo,
670 .issue_fc_host_lip = bfad_im_issue_fc_host_lip, 582
671 .vport_create = bfad_im_vport_create, 583 .vport_create = bfad_im_vport_create,
672 .vport_delete = bfad_im_vport_delete, 584 .vport_delete = bfad_im_vport_delete,
673 .vport_disable = bfad_im_vport_disable, 585 .vport_disable = bfad_im_vport_disable,
674 .set_vport_symbolic_name = bfad_im_vport_set_symbolic_name,
675 .bsg_request = bfad_im_bsg_request, 586 .bsg_request = bfad_im_bsg_request,
676 .bsg_timeout = bfad_im_bsg_timeout, 587 .bsg_timeout = bfad_im_bsg_timeout,
677}; 588};
@@ -808,10 +719,25 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
808 else if (!strcmp(model, "Brocade-804")) 719 else if (!strcmp(model, "Brocade-804"))
809 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN, 720 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
810 "Brocade 8Gbps FC HBA for HP Bladesystem C-class"); 721 "Brocade 8Gbps FC HBA for HP Bladesystem C-class");
811 else if (!strcmp(model, "Brocade-1741")) 722 else if (!strcmp(model, "Brocade-902") ||
723 !strcmp(model, "Brocade-1741"))
812 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN, 724 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
813 "Brocade 10Gbps CNA for Dell M-Series Blade Servers"); 725 "Brocade 10Gbps CNA for Dell M-Series Blade Servers");
814 else if (strstr(model, "Brocade-1860")) { 726 else if (strstr(model, "Brocade-1560")) {
727 if (nports == 1)
728 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
729 "Brocade 16Gbps PCIe single port FC HBA");
730 else
731 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
732 "Brocade 16Gbps PCIe dual port FC HBA");
733 } else if (strstr(model, "Brocade-1710")) {
734 if (nports == 1)
735 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
736 "Brocade 10Gbps single port CNA");
737 else
738 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
739 "Brocade 10Gbps dual port CNA");
740 } else if (strstr(model, "Brocade-1860")) {
815 if (nports == 1 && bfa_ioc_is_cna(&bfad->bfa.ioc)) 741 if (nports == 1 && bfa_ioc_is_cna(&bfad->bfa.ioc))
816 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN, 742 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
817 "Brocade 10Gbps single port CNA"); 743 "Brocade 10Gbps single port CNA");
@@ -824,13 +750,6 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
824 else if (nports == 2 && !bfa_ioc_is_cna(&bfad->bfa.ioc)) 750 else if (nports == 2 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
825 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN, 751 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
826 "Brocade 16Gbps PCIe dual port FC HBA"); 752 "Brocade 16Gbps PCIe dual port FC HBA");
827 } else if (!strcmp(model, "Brocade-1867")) {
828 if (nports == 1 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
829 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
830 "Brocade 16Gbps PCIe single port FC HBA for IBM");
831 else if (nports == 2 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
832 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
833 "Brocade 16Gbps PCIe dual port FC HBA for IBM");
834 } else 753 } else
835 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN, 754 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
836 "Invalid Model"); 755 "Invalid Model");
@@ -948,16 +867,15 @@ bfad_im_num_of_discovered_ports_show(struct device *dev,
948 struct bfad_port_s *port = im_port->port; 867 struct bfad_port_s *port = im_port->port;
949 struct bfad_s *bfad = im_port->bfad; 868 struct bfad_s *bfad = im_port->bfad;
950 int nrports = 2048; 869 int nrports = 2048;
951 struct bfa_rport_qualifier_s *rports = NULL; 870 wwn_t *rports = NULL;
952 unsigned long flags; 871 unsigned long flags;
953 872
954 rports = kzalloc(sizeof(struct bfa_rport_qualifier_s) * nrports, 873 rports = kzalloc(sizeof(wwn_t) * nrports , GFP_ATOMIC);
955 GFP_ATOMIC);
956 if (rports == NULL) 874 if (rports == NULL)
957 return snprintf(buf, PAGE_SIZE, "Failed\n"); 875 return snprintf(buf, PAGE_SIZE, "Failed\n");
958 876
959 spin_lock_irqsave(&bfad->bfad_lock, flags); 877 spin_lock_irqsave(&bfad->bfad_lock, flags);
960 bfa_fcs_lport_get_rport_quals(port->fcs_port, rports, &nrports); 878 bfa_fcs_lport_get_rports(port->fcs_port, rports, &nrports);
961 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 879 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
962 kfree(rports); 880 kfree(rports);
963 881
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 555e7db94a1..06fc00caeb4 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -33,7 +33,7 @@ bfad_iocmd_ioc_enable(struct bfad_s *bfad, void *cmd)
33 /* If IOC is not in disabled state - return */ 33 /* If IOC is not in disabled state - return */
34 if (!bfa_ioc_is_disabled(&bfad->bfa.ioc)) { 34 if (!bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
35 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 35 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
36 iocmd->status = BFA_STATUS_OK; 36 iocmd->status = BFA_STATUS_IOC_FAILURE;
37 return rc; 37 return rc;
38 } 38 }
39 39
@@ -54,12 +54,6 @@ bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
54 unsigned long flags; 54 unsigned long flags;
55 55
56 spin_lock_irqsave(&bfad->bfad_lock, flags); 56 spin_lock_irqsave(&bfad->bfad_lock, flags);
57 if (bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
58 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
59 iocmd->status = BFA_STATUS_OK;
60 return rc;
61 }
62
63 if (bfad->disable_active) { 57 if (bfad->disable_active) {
64 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 58 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
65 return -EBUSY; 59 return -EBUSY;
@@ -107,10 +101,9 @@ bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
107 101
108 /* set adapter hw path */ 102 /* set adapter hw path */
109 strcpy(iocmd->adapter_hwpath, bfad->pci_name); 103 strcpy(iocmd->adapter_hwpath, bfad->pci_name);
110 for (i = 0; iocmd->adapter_hwpath[i] != ':' && i < BFA_STRING_32; i++) 104 i = strlen(iocmd->adapter_hwpath) - 1;
111 ; 105 while (iocmd->adapter_hwpath[i] != '.')
112 for (; iocmd->adapter_hwpath[++i] != ':' && i < BFA_STRING_32; ) 106 i--;
113 ;
114 iocmd->adapter_hwpath[i] = '\0'; 107 iocmd->adapter_hwpath[i] = '\0';
115 iocmd->status = BFA_STATUS_OK; 108 iocmd->status = BFA_STATUS_OK;
116 return 0; 109 return 0;
@@ -542,8 +535,7 @@ bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
542 535
543 if (bfad_chk_iocmd_sz(payload_len, 536 if (bfad_chk_iocmd_sz(payload_len,
544 sizeof(struct bfa_bsg_lport_get_rports_s), 537 sizeof(struct bfa_bsg_lport_get_rports_s),
545 sizeof(struct bfa_rport_qualifier_s) * iocmd->nrports) 538 sizeof(wwn_t) * iocmd->nrports) != BFA_STATUS_OK) {
546 != BFA_STATUS_OK) {
547 iocmd->status = BFA_STATUS_VERSION_FAIL; 539 iocmd->status = BFA_STATUS_VERSION_FAIL;
548 return 0; 540 return 0;
549 } 541 }
@@ -560,9 +552,8 @@ bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
560 goto out; 552 goto out;
561 } 553 }
562 554
563 bfa_fcs_lport_get_rport_quals(fcs_port, 555 bfa_fcs_lport_get_rports(fcs_port, (wwn_t *)iocmd_bufptr,
564 (struct bfa_rport_qualifier_s *)iocmd_bufptr, 556 &iocmd->nrports);
565 &iocmd->nrports);
566 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 557 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
567 iocmd->status = BFA_STATUS_OK; 558 iocmd->status = BFA_STATUS_OK;
568out: 559out:
@@ -587,11 +578,7 @@ bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
587 goto out; 578 goto out;
588 } 579 }
589 580
590 if (iocmd->pid) 581 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
591 fcs_rport = bfa_fcs_lport_get_rport_by_qualifier(fcs_port,
592 iocmd->rpwwn, iocmd->pid);
593 else
594 fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
595 if (fcs_rport == NULL) { 582 if (fcs_rport == NULL) {
596 bfa_trc(bfad, 0); 583 bfa_trc(bfad, 0);
597 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 584 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -684,11 +671,9 @@ bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
684 671
685 memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats, 672 memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
686 sizeof(struct bfa_rport_stats_s)); 673 sizeof(struct bfa_rport_stats_s));
687 if (bfa_fcs_rport_get_halrport(fcs_rport)) { 674 memcpy((void *)&iocmd->stats.hal_stats,
688 memcpy((void *)&iocmd->stats.hal_stats, 675 (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
689 (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats), 676 sizeof(struct bfa_rport_hal_stats_s));
690 sizeof(struct bfa_rport_hal_stats_s));
691 }
692 677
693 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 678 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
694 iocmd->status = BFA_STATUS_OK; 679 iocmd->status = BFA_STATUS_OK;
@@ -724,8 +709,7 @@ bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
724 709
725 memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s)); 710 memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
726 rport = bfa_fcs_rport_get_halrport(fcs_rport); 711 rport = bfa_fcs_rport_get_halrport(fcs_rport);
727 if (rport) 712 memset(&rport->stats, 0, sizeof(rport->stats));
728 memset(&rport->stats, 0, sizeof(rport->stats));
729 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 713 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
730 iocmd->status = BFA_STATUS_OK; 714 iocmd->status = BFA_STATUS_OK;
731out: 715out:
@@ -760,8 +744,7 @@ bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
760 fcs_rport->rpf.assigned_speed = iocmd->speed; 744 fcs_rport->rpf.assigned_speed = iocmd->speed;
761 /* Set this speed in f/w only if the RPSC speed is not available */ 745 /* Set this speed in f/w only if the RPSC speed is not available */
762 if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN) 746 if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
763 if (fcs_rport->bfa_rport) 747 bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
764 bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
765 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 748 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
766 iocmd->status = BFA_STATUS_OK; 749 iocmd->status = BFA_STATUS_OK;
767out: 750out:
@@ -887,19 +870,6 @@ out:
887} 870}
888 871
889int 872int
890bfad_iocmd_qos_set_bw(struct bfad_s *bfad, void *pcmd)
891{
892 struct bfa_bsg_qos_bw_s *iocmd = (struct bfa_bsg_qos_bw_s *)pcmd;
893 unsigned long flags;
894
895 spin_lock_irqsave(&bfad->bfad_lock, flags);
896 iocmd->status = bfa_fcport_set_qos_bw(&bfad->bfa, &iocmd->qos_bw);
897 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
898
899 return 0;
900}
901
902int
903bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd) 873bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
904{ 874{
905 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd; 875 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
@@ -908,22 +878,16 @@ bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
908 878
909 spin_lock_irqsave(&bfad->bfad_lock, flags); 879 spin_lock_irqsave(&bfad->bfad_lock, flags);
910 880
911 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 881 if (cmd == IOCMD_RATELIM_ENABLE)
912 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 882 fcport->cfg.ratelimit = BFA_TRUE;
913 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP; 883 else if (cmd == IOCMD_RATELIM_DISABLE)
914 else { 884 fcport->cfg.ratelimit = BFA_FALSE;
915 if (cmd == IOCMD_RATELIM_ENABLE)
916 fcport->cfg.ratelimit = BFA_TRUE;
917 else if (cmd == IOCMD_RATELIM_DISABLE)
918 fcport->cfg.ratelimit = BFA_FALSE;
919
920 if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
921 fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
922 885
923 iocmd->status = BFA_STATUS_OK; 886 if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
924 } 887 fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
925 888
926 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 889 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
890 iocmd->status = BFA_STATUS_OK;
927 891
928 return 0; 892 return 0;
929} 893}
@@ -945,13 +909,8 @@ bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
945 return 0; 909 return 0;
946 } 910 }
947 911
948 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 912 fcport->cfg.trl_def_speed = iocmd->speed;
949 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 913 iocmd->status = BFA_STATUS_OK;
950 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
951 else {
952 fcport->cfg.trl_def_speed = iocmd->speed;
953 iocmd->status = BFA_STATUS_OK;
954 }
955 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 914 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
956 915
957 return 0; 916 return 0;
@@ -1071,10 +1030,9 @@ bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
1071 iocmd->status = BFA_STATUS_UNKNOWN_RWWN; 1030 iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
1072 else { 1031 else {
1073 iocmd->status = BFA_STATUS_OK; 1032 iocmd->status = BFA_STATUS_OK;
1074 if (bfa_fcs_itnim_get_halitn(itnim)) 1033 memcpy((void *)&iocmd->iostats, (void *)
1075 memcpy((void *)&iocmd->iostats, (void *) 1034 &(bfa_fcs_itnim_get_halitn(itnim)->stats),
1076 &(bfa_fcs_itnim_get_halitn(itnim)->stats), 1035 sizeof(struct bfa_itnim_iostats_s));
1077 sizeof(struct bfa_itnim_iostats_s));
1078 } 1036 }
1079 } 1037 }
1080 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1038 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -1198,8 +1156,8 @@ bfad_iocmd_pcifn_create(struct bfad_s *bfad, void *cmd)
1198 spin_lock_irqsave(&bfad->bfad_lock, flags); 1156 spin_lock_irqsave(&bfad->bfad_lock, flags);
1199 iocmd->status = bfa_ablk_pf_create(&bfad->bfa.modules.ablk, 1157 iocmd->status = bfa_ablk_pf_create(&bfad->bfa.modules.ablk,
1200 &iocmd->pcifn_id, iocmd->port, 1158 &iocmd->pcifn_id, iocmd->port,
1201 iocmd->pcifn_class, iocmd->bw_min, 1159 iocmd->pcifn_class, iocmd->bandwidth,
1202 iocmd->bw_max, bfad_hcb_comp, &fcomp); 1160 bfad_hcb_comp, &fcomp);
1203 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1161 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1204 if (iocmd->status != BFA_STATUS_OK) 1162 if (iocmd->status != BFA_STATUS_OK)
1205 goto out; 1163 goto out;
@@ -1242,8 +1200,8 @@ bfad_iocmd_pcifn_bw(struct bfad_s *bfad, void *cmd)
1242 init_completion(&fcomp.comp); 1200 init_completion(&fcomp.comp);
1243 spin_lock_irqsave(&bfad->bfad_lock, flags); 1201 spin_lock_irqsave(&bfad->bfad_lock, flags);
1244 iocmd->status = bfa_ablk_pf_update(&bfad->bfa.modules.ablk, 1202 iocmd->status = bfa_ablk_pf_update(&bfad->bfa.modules.ablk,
1245 iocmd->pcifn_id, iocmd->bw_min, 1203 iocmd->pcifn_id, iocmd->bandwidth,
1246 iocmd->bw_max, bfad_hcb_comp, &fcomp); 1204 bfad_hcb_comp, &fcomp);
1247 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1205 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1248 bfa_trc(bfad, iocmd->status); 1206 bfa_trc(bfad, iocmd->status);
1249 if (iocmd->status != BFA_STATUS_OK) 1207 if (iocmd->status != BFA_STATUS_OK)
@@ -1330,6 +1288,50 @@ out:
1330} 1288}
1331 1289
1332int 1290int
1291bfad_iocmd_faa_enable(struct bfad_s *bfad, void *cmd)
1292{
1293 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1294 unsigned long flags;
1295 struct bfad_hal_comp fcomp;
1296
1297 init_completion(&fcomp.comp);
1298 iocmd->status = BFA_STATUS_OK;
1299 spin_lock_irqsave(&bfad->bfad_lock, flags);
1300 iocmd->status = bfa_faa_enable(&bfad->bfa, bfad_hcb_comp, &fcomp);
1301 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1302
1303 if (iocmd->status != BFA_STATUS_OK)
1304 goto out;
1305
1306 wait_for_completion(&fcomp.comp);
1307 iocmd->status = fcomp.status;
1308out:
1309 return 0;
1310}
1311
1312int
1313bfad_iocmd_faa_disable(struct bfad_s *bfad, void *cmd)
1314{
1315 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
1316 unsigned long flags;
1317 struct bfad_hal_comp fcomp;
1318
1319 init_completion(&fcomp.comp);
1320 iocmd->status = BFA_STATUS_OK;
1321 spin_lock_irqsave(&bfad->bfad_lock, flags);
1322 iocmd->status = bfa_faa_disable(&bfad->bfa, bfad_hcb_comp, &fcomp);
1323 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1324
1325 if (iocmd->status != BFA_STATUS_OK)
1326 goto out;
1327
1328 wait_for_completion(&fcomp.comp);
1329 iocmd->status = fcomp.status;
1330out:
1331 return 0;
1332}
1333
1334int
1333bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd) 1335bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd)
1334{ 1336{
1335 struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd; 1337 struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd;
@@ -1767,52 +1769,6 @@ bfad_iocmd_diag_lb_stat(struct bfad_s *bfad, void *cmd)
1767} 1769}
1768 1770
1769int 1771int
1770bfad_iocmd_diag_cfg_dport(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
1771{
1772 struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
1773 unsigned long flags;
1774 struct bfad_hal_comp fcomp;
1775
1776 init_completion(&fcomp.comp);
1777 spin_lock_irqsave(&bfad->bfad_lock, flags);
1778 if (cmd == IOCMD_DIAG_DPORT_ENABLE)
1779 iocmd->status = bfa_dport_enable(&bfad->bfa,
1780 bfad_hcb_comp, &fcomp);
1781 else if (cmd == IOCMD_DIAG_DPORT_DISABLE)
1782 iocmd->status = bfa_dport_disable(&bfad->bfa,
1783 bfad_hcb_comp, &fcomp);
1784 else {
1785 bfa_trc(bfad, 0);
1786 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1787 return -EINVAL;
1788 }
1789 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1790
1791 if (iocmd->status != BFA_STATUS_OK)
1792 bfa_trc(bfad, iocmd->status);
1793 else {
1794 wait_for_completion(&fcomp.comp);
1795 iocmd->status = fcomp.status;
1796 }
1797
1798 return 0;
1799}
1800
1801int
1802bfad_iocmd_diag_dport_get_state(struct bfad_s *bfad, void *pcmd)
1803{
1804 struct bfa_bsg_diag_dport_get_state_s *iocmd =
1805 (struct bfa_bsg_diag_dport_get_state_s *)pcmd;
1806 unsigned long flags;
1807
1808 spin_lock_irqsave(&bfad->bfad_lock, flags);
1809 iocmd->status = bfa_dport_get_state(&bfad->bfa, &iocmd->state);
1810 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1811
1812 return 0;
1813}
1814
1815int
1816bfad_iocmd_phy_get_attr(struct bfad_s *bfad, void *cmd) 1772bfad_iocmd_phy_get_attr(struct bfad_s *bfad, void *cmd)
1817{ 1773{
1818 struct bfa_bsg_phy_attr_s *iocmd = 1774 struct bfa_bsg_phy_attr_s *iocmd =
@@ -1962,7 +1918,6 @@ bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
1962 struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd; 1918 struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
1963 void *iocmd_bufptr; 1919 void *iocmd_bufptr;
1964 unsigned long flags; 1920 unsigned long flags;
1965 u32 offset;
1966 1921
1967 if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s), 1922 if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),
1968 BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) { 1923 BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {
@@ -1980,10 +1935,8 @@ bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
1980 1935
1981 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s); 1936 iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
1982 spin_lock_irqsave(&bfad->bfad_lock, flags); 1937 spin_lock_irqsave(&bfad->bfad_lock, flags);
1983 offset = iocmd->offset;
1984 iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr, 1938 iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr,
1985 &offset, &iocmd->bufsz); 1939 (u32 *)&iocmd->offset, &iocmd->bufsz);
1986 iocmd->offset = offset;
1987 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1940 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1988out: 1941out:
1989 return 0; 1942 return 0;
@@ -2129,7 +2082,7 @@ bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
2129 init_completion(&fcomp.comp); 2082 init_completion(&fcomp.comp);
2130 spin_lock_irqsave(&bfad->bfad_lock, flags); 2083 spin_lock_irqsave(&bfad->bfad_lock, flags);
2131 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa), 2084 iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
2132 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id, 2085 BFA_FLASH_PART_BOOT, PCI_FUNC(bfad->pcidev->devfn),
2133 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0, 2086 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2134 bfad_hcb_comp, &fcomp); 2087 bfad_hcb_comp, &fcomp);
2135 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2088 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -2151,7 +2104,7 @@ bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
2151 init_completion(&fcomp.comp); 2104 init_completion(&fcomp.comp);
2152 spin_lock_irqsave(&bfad->bfad_lock, flags); 2105 spin_lock_irqsave(&bfad->bfad_lock, flags);
2153 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa), 2106 iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
2154 BFA_FLASH_PART_BOOT, bfad->bfa.ioc.port_id, 2107 BFA_FLASH_PART_BOOT, PCI_FUNC(bfad->pcidev->devfn),
2155 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0, 2108 &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
2156 bfad_hcb_comp, &fcomp); 2109 bfad_hcb_comp, &fcomp);
2157 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2110 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -2238,31 +2191,22 @@ bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2238 2191
2239 spin_lock_irqsave(&bfad->bfad_lock, flags); 2192 spin_lock_irqsave(&bfad->bfad_lock, flags);
2240 2193
2241 if (bfa_fcport_is_dport(&bfad->bfa)) 2194 if (v_cmd == IOCMD_TRUNK_ENABLE) {
2242 return BFA_STATUS_DPORT_ERR; 2195 trunk->attr.state = BFA_TRUNK_OFFLINE;
2243 2196 bfa_fcport_disable(&bfad->bfa);
2244 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) || 2197 fcport->cfg.trunked = BFA_TRUE;
2245 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 2198 } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2246 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP; 2199 trunk->attr.state = BFA_TRUNK_DISABLED;
2247 else { 2200 bfa_fcport_disable(&bfad->bfa);
2248 if (v_cmd == IOCMD_TRUNK_ENABLE) { 2201 fcport->cfg.trunked = BFA_FALSE;
2249 trunk->attr.state = BFA_TRUNK_OFFLINE;
2250 bfa_fcport_disable(&bfad->bfa);
2251 fcport->cfg.trunked = BFA_TRUE;
2252 } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
2253 trunk->attr.state = BFA_TRUNK_DISABLED;
2254 bfa_fcport_disable(&bfad->bfa);
2255 fcport->cfg.trunked = BFA_FALSE;
2256 }
2257
2258 if (!bfa_fcport_is_disabled(&bfad->bfa))
2259 bfa_fcport_enable(&bfad->bfa);
2260
2261 iocmd->status = BFA_STATUS_OK;
2262 } 2202 }
2263 2203
2204 if (!bfa_fcport_is_disabled(&bfad->bfa))
2205 bfa_fcport_enable(&bfad->bfa);
2206
2264 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2207 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2265 2208
2209 iocmd->status = BFA_STATUS_OK;
2266 return 0; 2210 return 0;
2267} 2211}
2268 2212
@@ -2275,17 +2219,12 @@ bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
2275 unsigned long flags; 2219 unsigned long flags;
2276 2220
2277 spin_lock_irqsave(&bfad->bfad_lock, flags); 2221 spin_lock_irqsave(&bfad->bfad_lock, flags);
2278 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) || 2222 memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2279 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 2223 sizeof(struct bfa_trunk_attr_s));
2280 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP; 2224 iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
2281 else {
2282 memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
2283 sizeof(struct bfa_trunk_attr_s));
2284 iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
2285 iocmd->status = BFA_STATUS_OK;
2286 }
2287 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2225 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2288 2226
2227 iocmd->status = BFA_STATUS_OK;
2289 return 0; 2228 return 0;
2290} 2229}
2291 2230
@@ -2298,22 +2237,14 @@ bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2298 2237
2299 spin_lock_irqsave(&bfad->bfad_lock, flags); 2238 spin_lock_irqsave(&bfad->bfad_lock, flags);
2300 if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) { 2239 if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
2301 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 2240 if (v_cmd == IOCMD_QOS_ENABLE)
2302 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 2241 fcport->cfg.qos_enabled = BFA_TRUE;
2303 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP; 2242 else if (v_cmd == IOCMD_QOS_DISABLE)
2304 else { 2243 fcport->cfg.qos_enabled = BFA_FALSE;
2305 if (v_cmd == IOCMD_QOS_ENABLE)
2306 fcport->cfg.qos_enabled = BFA_TRUE;
2307 else if (v_cmd == IOCMD_QOS_DISABLE) {
2308 fcport->cfg.qos_enabled = BFA_FALSE;
2309 fcport->cfg.qos_bw.high = BFA_QOS_BW_HIGH;
2310 fcport->cfg.qos_bw.med = BFA_QOS_BW_MED;
2311 fcport->cfg.qos_bw.low = BFA_QOS_BW_LOW;
2312 }
2313 }
2314 } 2244 }
2315 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2245 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2316 2246
2247 iocmd->status = BFA_STATUS_OK;
2317 return 0; 2248 return 0;
2318} 2249}
2319 2250
@@ -2325,21 +2256,11 @@ bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
2325 unsigned long flags; 2256 unsigned long flags;
2326 2257
2327 spin_lock_irqsave(&bfad->bfad_lock, flags); 2258 spin_lock_irqsave(&bfad->bfad_lock, flags);
2328 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 2259 iocmd->attr.state = fcport->qos_attr.state;
2329 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)) 2260 iocmd->attr.total_bb_cr = be32_to_cpu(fcport->qos_attr.total_bb_cr);
2330 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2331 else {
2332 iocmd->attr.state = fcport->qos_attr.state;
2333 iocmd->attr.total_bb_cr =
2334 be32_to_cpu(fcport->qos_attr.total_bb_cr);
2335 iocmd->attr.qos_bw.high = fcport->cfg.qos_bw.high;
2336 iocmd->attr.qos_bw.med = fcport->cfg.qos_bw.med;
2337 iocmd->attr.qos_bw.low = fcport->cfg.qos_bw.low;
2338 iocmd->attr.qos_bw_op = fcport->qos_attr.qos_bw_op;
2339 iocmd->status = BFA_STATUS_OK;
2340 }
2341 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2261 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2342 2262
2263 iocmd->status = BFA_STATUS_OK;
2343 return 0; 2264 return 0;
2344} 2265}
2345 2266
@@ -2383,7 +2304,6 @@ bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2383 struct bfad_hal_comp fcomp; 2304 struct bfad_hal_comp fcomp;
2384 unsigned long flags; 2305 unsigned long flags;
2385 struct bfa_cb_pending_q_s cb_qe; 2306 struct bfa_cb_pending_q_s cb_qe;
2386 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2387 2307
2388 init_completion(&fcomp.comp); 2308 init_completion(&fcomp.comp);
2389 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp, 2309 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
@@ -2391,11 +2311,7 @@ bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
2391 2311
2392 spin_lock_irqsave(&bfad->bfad_lock, flags); 2312 spin_lock_irqsave(&bfad->bfad_lock, flags);
2393 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc)); 2313 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2394 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 2314 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2395 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2396 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2397 else
2398 iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
2399 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2315 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2400 if (iocmd->status != BFA_STATUS_OK) { 2316 if (iocmd->status != BFA_STATUS_OK) {
2401 bfa_trc(bfad, iocmd->status); 2317 bfa_trc(bfad, iocmd->status);
@@ -2414,7 +2330,6 @@ bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2414 struct bfad_hal_comp fcomp; 2330 struct bfad_hal_comp fcomp;
2415 unsigned long flags; 2331 unsigned long flags;
2416 struct bfa_cb_pending_q_s cb_qe; 2332 struct bfa_cb_pending_q_s cb_qe;
2417 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
2418 2333
2419 init_completion(&fcomp.comp); 2334 init_completion(&fcomp.comp);
2420 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp, 2335 bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
@@ -2422,11 +2337,7 @@ bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
2422 2337
2423 spin_lock_irqsave(&bfad->bfad_lock, flags); 2338 spin_lock_irqsave(&bfad->bfad_lock, flags);
2424 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc)); 2339 WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
2425 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 2340 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2426 (fcport->topology == BFA_PORT_TOPOLOGY_LOOP))
2427 iocmd->status = BFA_STATUS_TOPOLOGY_LOOP;
2428 else
2429 iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
2430 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2341 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2431 if (iocmd->status != BFA_STATUS_OK) { 2342 if (iocmd->status != BFA_STATUS_OK) {
2432 bfa_trc(bfad, iocmd->status); 2343 bfa_trc(bfad, iocmd->status);
@@ -2483,21 +2394,6 @@ out:
2483 return 0; 2394 return 0;
2484} 2395}
2485 2396
2486/* Function to reset the LUN SCAN mode */
2487static void
2488bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg)
2489{
2490 struct bfad_im_port_s *pport_im = bfad->pport.im_port;
2491 struct bfad_vport_s *vport = NULL;
2492
2493 /* Set the scsi device LUN SCAN flags for base port */
2494 bfad_reset_sdev_bflags(pport_im, lunmask_cfg);
2495
2496 /* Set the scsi device LUN SCAN flags for the vports */
2497 list_for_each_entry(vport, &bfad->vport_list, list_entry)
2498 bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);
2499}
2500
2501int 2397int
2502bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd) 2398bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2503{ 2399{
@@ -2505,17 +2401,11 @@ bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
2505 unsigned long flags; 2401 unsigned long flags;
2506 2402
2507 spin_lock_irqsave(&bfad->bfad_lock, flags); 2403 spin_lock_irqsave(&bfad->bfad_lock, flags);
2508 if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE) { 2404 if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE)
2509 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE); 2405 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE);
2510 /* Set the LUN Scanning mode to be Sequential scan */ 2406 else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE)
2511 if (iocmd->status == BFA_STATUS_OK)
2512 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_TRUE);
2513 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE) {
2514 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE); 2407 iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE);
2515 /* Set the LUN Scanning mode to default REPORT_LUNS scan */ 2408 else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2516 if (iocmd->status == BFA_STATUS_OK)
2517 bfad_iocmd_lunmask_reset_lunscan_mode(bfad, BFA_FALSE);
2518 } else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
2519 iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa); 2409 iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa);
2520 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2410 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2521 return 0; 2411 return 0;
@@ -2554,139 +2444,6 @@ bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
2554 return 0; 2444 return 0;
2555} 2445}
2556 2446
2557int
2558bfad_iocmd_fcpim_throttle_query(struct bfad_s *bfad, void *cmd)
2559{
2560 struct bfa_bsg_fcpim_throttle_s *iocmd =
2561 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2562 unsigned long flags;
2563
2564 spin_lock_irqsave(&bfad->bfad_lock, flags);
2565 iocmd->status = bfa_fcpim_throttle_get(&bfad->bfa,
2566 (void *)&iocmd->throttle);
2567 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2568
2569 return 0;
2570}
2571
2572int
2573bfad_iocmd_fcpim_throttle_set(struct bfad_s *bfad, void *cmd)
2574{
2575 struct bfa_bsg_fcpim_throttle_s *iocmd =
2576 (struct bfa_bsg_fcpim_throttle_s *)cmd;
2577 unsigned long flags;
2578
2579 spin_lock_irqsave(&bfad->bfad_lock, flags);
2580 iocmd->status = bfa_fcpim_throttle_set(&bfad->bfa,
2581 iocmd->throttle.cfg_value);
2582 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2583
2584 return 0;
2585}
2586
2587int
2588bfad_iocmd_tfru_read(struct bfad_s *bfad, void *cmd)
2589{
2590 struct bfa_bsg_tfru_s *iocmd =
2591 (struct bfa_bsg_tfru_s *)cmd;
2592 struct bfad_hal_comp fcomp;
2593 unsigned long flags = 0;
2594
2595 init_completion(&fcomp.comp);
2596 spin_lock_irqsave(&bfad->bfad_lock, flags);
2597 iocmd->status = bfa_tfru_read(BFA_FRU(&bfad->bfa),
2598 &iocmd->data, iocmd->len, iocmd->offset,
2599 bfad_hcb_comp, &fcomp);
2600 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2601 if (iocmd->status == BFA_STATUS_OK) {
2602 wait_for_completion(&fcomp.comp);
2603 iocmd->status = fcomp.status;
2604 }
2605
2606 return 0;
2607}
2608
2609int
2610bfad_iocmd_tfru_write(struct bfad_s *bfad, void *cmd)
2611{
2612 struct bfa_bsg_tfru_s *iocmd =
2613 (struct bfa_bsg_tfru_s *)cmd;
2614 struct bfad_hal_comp fcomp;
2615 unsigned long flags = 0;
2616
2617 init_completion(&fcomp.comp);
2618 spin_lock_irqsave(&bfad->bfad_lock, flags);
2619 iocmd->status = bfa_tfru_write(BFA_FRU(&bfad->bfa),
2620 &iocmd->data, iocmd->len, iocmd->offset,
2621 bfad_hcb_comp, &fcomp);
2622 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2623 if (iocmd->status == BFA_STATUS_OK) {
2624 wait_for_completion(&fcomp.comp);
2625 iocmd->status = fcomp.status;
2626 }
2627
2628 return 0;
2629}
2630
2631int
2632bfad_iocmd_fruvpd_read(struct bfad_s *bfad, void *cmd)
2633{
2634 struct bfa_bsg_fruvpd_s *iocmd =
2635 (struct bfa_bsg_fruvpd_s *)cmd;
2636 struct bfad_hal_comp fcomp;
2637 unsigned long flags = 0;
2638
2639 init_completion(&fcomp.comp);
2640 spin_lock_irqsave(&bfad->bfad_lock, flags);
2641 iocmd->status = bfa_fruvpd_read(BFA_FRU(&bfad->bfa),
2642 &iocmd->data, iocmd->len, iocmd->offset,
2643 bfad_hcb_comp, &fcomp);
2644 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2645 if (iocmd->status == BFA_STATUS_OK) {
2646 wait_for_completion(&fcomp.comp);
2647 iocmd->status = fcomp.status;
2648 }
2649
2650 return 0;
2651}
2652
2653int
2654bfad_iocmd_fruvpd_update(struct bfad_s *bfad, void *cmd)
2655{
2656 struct bfa_bsg_fruvpd_s *iocmd =
2657 (struct bfa_bsg_fruvpd_s *)cmd;
2658 struct bfad_hal_comp fcomp;
2659 unsigned long flags = 0;
2660
2661 init_completion(&fcomp.comp);
2662 spin_lock_irqsave(&bfad->bfad_lock, flags);
2663 iocmd->status = bfa_fruvpd_update(BFA_FRU(&bfad->bfa),
2664 &iocmd->data, iocmd->len, iocmd->offset,
2665 bfad_hcb_comp, &fcomp);
2666 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2667 if (iocmd->status == BFA_STATUS_OK) {
2668 wait_for_completion(&fcomp.comp);
2669 iocmd->status = fcomp.status;
2670 }
2671
2672 return 0;
2673}
2674
2675int
2676bfad_iocmd_fruvpd_get_max_size(struct bfad_s *bfad, void *cmd)
2677{
2678 struct bfa_bsg_fruvpd_max_size_s *iocmd =
2679 (struct bfa_bsg_fruvpd_max_size_s *)cmd;
2680 unsigned long flags = 0;
2681
2682 spin_lock_irqsave(&bfad->bfad_lock, flags);
2683 iocmd->status = bfa_fruvpd_get_max_size(BFA_FRU(&bfad->bfa),
2684 &iocmd->max_size);
2685 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
2686
2687 return 0;
2688}
2689
2690static int 2447static int
2691bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 2448bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2692 unsigned int payload_len) 2449 unsigned int payload_len)
@@ -2855,6 +2612,12 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2855 case IOCMD_FLASH_DISABLE_OPTROM: 2612 case IOCMD_FLASH_DISABLE_OPTROM:
2856 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd); 2613 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd);
2857 break; 2614 break;
2615 case IOCMD_FAA_ENABLE:
2616 rc = bfad_iocmd_faa_enable(bfad, iocmd);
2617 break;
2618 case IOCMD_FAA_DISABLE:
2619 rc = bfad_iocmd_faa_disable(bfad, iocmd);
2620 break;
2858 case IOCMD_FAA_QUERY: 2621 case IOCMD_FAA_QUERY:
2859 rc = bfad_iocmd_faa_query(bfad, iocmd); 2622 rc = bfad_iocmd_faa_query(bfad, iocmd);
2860 break; 2623 break;
@@ -2912,13 +2675,6 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
2912 case IOCMD_DIAG_LB_STAT: 2675 case IOCMD_DIAG_LB_STAT:
2913 rc = bfad_iocmd_diag_lb_stat(bfad, iocmd); 2676 rc = bfad_iocmd_diag_lb_stat(bfad, iocmd);
2914 break; 2677 break;
2915 case IOCMD_DIAG_DPORT_ENABLE:
2916 case IOCMD_DIAG_DPORT_DISABLE:
2917 rc = bfad_iocmd_diag_cfg_dport(bfad, cmd, iocmd);
2918 break;
2919 case IOCMD_DIAG_DPORT_GET_STATE:
2920 rc = bfad_iocmd_diag_dport_get_state(bfad, iocmd);
2921 break;
2922 case IOCMD_PHY_GET_ATTR: 2678 case IOCMD_PHY_GET_ATTR:
2923 rc = bfad_iocmd_phy_get_attr(bfad, iocmd); 2679 rc = bfad_iocmd_phy_get_attr(bfad, iocmd);
2924 break; 2680 break;
@@ -3000,9 +2756,6 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
3000 case IOCMD_QOS_RESET_STATS: 2756 case IOCMD_QOS_RESET_STATS:
3001 rc = bfad_iocmd_qos_reset_stats(bfad, iocmd); 2757 rc = bfad_iocmd_qos_reset_stats(bfad, iocmd);
3002 break; 2758 break;
3003 case IOCMD_QOS_SET_BW:
3004 rc = bfad_iocmd_qos_set_bw(bfad, iocmd);
3005 break;
3006 case IOCMD_VF_GET_STATS: 2759 case IOCMD_VF_GET_STATS:
3007 rc = bfad_iocmd_vf_get_stats(bfad, iocmd); 2760 rc = bfad_iocmd_vf_get_stats(bfad, iocmd);
3008 break; 2761 break;
@@ -3021,29 +2774,6 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
3021 case IOCMD_FCPIM_LUNMASK_DELETE: 2774 case IOCMD_FCPIM_LUNMASK_DELETE:
3022 rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd); 2775 rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd);
3023 break; 2776 break;
3024 case IOCMD_FCPIM_THROTTLE_QUERY:
3025 rc = bfad_iocmd_fcpim_throttle_query(bfad, iocmd);
3026 break;
3027 case IOCMD_FCPIM_THROTTLE_SET:
3028 rc = bfad_iocmd_fcpim_throttle_set(bfad, iocmd);
3029 break;
3030 /* TFRU */
3031 case IOCMD_TFRU_READ:
3032 rc = bfad_iocmd_tfru_read(bfad, iocmd);
3033 break;
3034 case IOCMD_TFRU_WRITE:
3035 rc = bfad_iocmd_tfru_write(bfad, iocmd);
3036 break;
3037 /* FRU */
3038 case IOCMD_FRUVPD_READ:
3039 rc = bfad_iocmd_fruvpd_read(bfad, iocmd);
3040 break;
3041 case IOCMD_FRUVPD_UPDATE:
3042 rc = bfad_iocmd_fruvpd_update(bfad, iocmd);
3043 break;
3044 case IOCMD_FRUVPD_GET_MAX_SIZE:
3045 rc = bfad_iocmd_fruvpd_get_max_size(bfad, iocmd);
3046 break;
3047 default: 2777 default:
3048 rc = -EINVAL; 2778 rc = -EINVAL;
3049 break; 2779 break;
@@ -3058,16 +2788,9 @@ bfad_im_bsg_vendor_request(struct fc_bsg_job *job)
3058 struct bfad_im_port_s *im_port = 2788 struct bfad_im_port_s *im_port =
3059 (struct bfad_im_port_s *) job->shost->hostdata[0]; 2789 (struct bfad_im_port_s *) job->shost->hostdata[0];
3060 struct bfad_s *bfad = im_port->bfad; 2790 struct bfad_s *bfad = im_port->bfad;
3061 struct request_queue *request_q = job->req->q;
3062 void *payload_kbuf; 2791 void *payload_kbuf;
3063 int rc = -EINVAL; 2792 int rc = -EINVAL;
3064 2793
3065 /*
3066 * Set the BSG device request_queue size to 256 to support
3067 * payloads larger than 512*1024K bytes.
3068 */
3069 blk_queue_max_segments(request_q, 256);
3070
3071 /* Allocate a temp buffer to hold the passed in user space command */ 2794 /* Allocate a temp buffer to hold the passed in user space command */
3072 payload_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL); 2795 payload_kbuf = kzalloc(job->request_payload.payload_len, GFP_KERNEL);
3073 if (!payload_kbuf) { 2796 if (!payload_kbuf) {
@@ -3245,13 +2968,13 @@ bfad_fcxp_bsg_send(struct fc_bsg_job *job, struct bfad_fcxp *drv_fcxp,
3245 spin_lock_irqsave(&bfad->bfad_lock, flags); 2968 spin_lock_irqsave(&bfad->bfad_lock, flags);
3246 2969
3247 /* Allocate bfa_fcxp structure */ 2970 /* Allocate bfa_fcxp structure */
3248 hal_fcxp = bfa_fcxp_req_rsp_alloc(drv_fcxp, &bfad->bfa, 2971 hal_fcxp = bfa_fcxp_alloc(drv_fcxp, &bfad->bfa,
3249 drv_fcxp->num_req_sgles, 2972 drv_fcxp->num_req_sgles,
3250 drv_fcxp->num_rsp_sgles, 2973 drv_fcxp->num_rsp_sgles,
3251 bfad_fcxp_get_req_sgaddr_cb, 2974 bfad_fcxp_get_req_sgaddr_cb,
3252 bfad_fcxp_get_req_sglen_cb, 2975 bfad_fcxp_get_req_sglen_cb,
3253 bfad_fcxp_get_rsp_sgaddr_cb, 2976 bfad_fcxp_get_rsp_sgaddr_cb,
3254 bfad_fcxp_get_rsp_sglen_cb, BFA_TRUE); 2977 bfad_fcxp_get_rsp_sglen_cb);
3255 if (!hal_fcxp) { 2978 if (!hal_fcxp) {
3256 bfa_trc(bfad, 0); 2979 bfa_trc(bfad, 0);
3257 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 2980 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -3303,22 +3026,19 @@ bfad_im_bsg_els_ct_request(struct fc_bsg_job *job)
3303 * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload 3026 * Allocate buffer for bsg_fcpt and do a copy_from_user op for payload
3304 * buffer of size bsg_data->payload_len 3027 * buffer of size bsg_data->payload_len
3305 */ 3028 */
3306 bsg_fcpt = kzalloc(bsg_data->payload_len, GFP_KERNEL); 3029 bsg_fcpt = (struct bfa_bsg_fcpt_s *)
3307 if (!bsg_fcpt) { 3030 kzalloc(bsg_data->payload_len, GFP_KERNEL);
3308 rc = -ENOMEM; 3031 if (!bsg_fcpt)
3309 goto out; 3032 goto out;
3310 }
3311 3033
3312 if (copy_from_user((uint8_t *)bsg_fcpt, bsg_data->payload, 3034 if (copy_from_user((uint8_t *)bsg_fcpt, bsg_data->payload,
3313 bsg_data->payload_len)) { 3035 bsg_data->payload_len)) {
3314 kfree(bsg_fcpt); 3036 kfree(bsg_fcpt);
3315 rc = -EIO;
3316 goto out; 3037 goto out;
3317 } 3038 }
3318 3039
3319 drv_fcxp = kzalloc(sizeof(struct bfad_fcxp), GFP_KERNEL); 3040 drv_fcxp = kzalloc(sizeof(struct bfad_fcxp), GFP_KERNEL);
3320 if (drv_fcxp == NULL) { 3041 if (drv_fcxp == NULL) {
3321 kfree(bsg_fcpt);
3322 rc = -ENOMEM; 3042 rc = -ENOMEM;
3323 goto out; 3043 goto out;
3324 } 3044 }
diff --git a/drivers/scsi/bfa/bfad_bsg.h b/drivers/scsi/bfa/bfad_bsg.h
index 15e1fc8e796..e859adb9aa9 100644
--- a/drivers/scsi/bfa/bfad_bsg.h
+++ b/drivers/scsi/bfa/bfad_bsg.h
@@ -83,6 +83,8 @@ enum {
83 IOCMD_PORT_CFG_MODE, 83 IOCMD_PORT_CFG_MODE,
84 IOCMD_FLASH_ENABLE_OPTROM, 84 IOCMD_FLASH_ENABLE_OPTROM,
85 IOCMD_FLASH_DISABLE_OPTROM, 85 IOCMD_FLASH_DISABLE_OPTROM,
86 IOCMD_FAA_ENABLE,
87 IOCMD_FAA_DISABLE,
86 IOCMD_FAA_QUERY, 88 IOCMD_FAA_QUERY,
87 IOCMD_CEE_GET_ATTR, 89 IOCMD_CEE_GET_ATTR,
88 IOCMD_CEE_GET_STATS, 90 IOCMD_CEE_GET_STATS,
@@ -141,17 +143,6 @@ enum {
141 IOCMD_FCPIM_LUNMASK_QUERY, 143 IOCMD_FCPIM_LUNMASK_QUERY,
142 IOCMD_FCPIM_LUNMASK_ADD, 144 IOCMD_FCPIM_LUNMASK_ADD,
143 IOCMD_FCPIM_LUNMASK_DELETE, 145 IOCMD_FCPIM_LUNMASK_DELETE,
144 IOCMD_DIAG_DPORT_ENABLE,
145 IOCMD_DIAG_DPORT_DISABLE,
146 IOCMD_DIAG_DPORT_GET_STATE,
147 IOCMD_QOS_SET_BW,
148 IOCMD_FCPIM_THROTTLE_QUERY,
149 IOCMD_FCPIM_THROTTLE_SET,
150 IOCMD_TFRU_READ,
151 IOCMD_TFRU_WRITE,
152 IOCMD_FRUVPD_READ,
153 IOCMD_FRUVPD_UPDATE,
154 IOCMD_FRUVPD_GET_MAX_SIZE,
155}; 146};
156 147
157struct bfa_bsg_gen_s { 148struct bfa_bsg_gen_s {
@@ -330,8 +321,6 @@ struct bfa_bsg_rport_attr_s {
330 u16 vf_id; 321 u16 vf_id;
331 wwn_t pwwn; 322 wwn_t pwwn;
332 wwn_t rpwwn; 323 wwn_t rpwwn;
333 u32 pid;
334 u32 rsvd;
335 struct bfa_rport_attr_s attr; 324 struct bfa_rport_attr_s attr;
336}; 325};
337 326
@@ -474,8 +463,7 @@ struct bfa_bsg_pcifn_s {
474 bfa_status_t status; 463 bfa_status_t status;
475 u16 bfad_num; 464 u16 bfad_num;
476 u16 pcifn_id; 465 u16 pcifn_id;
477 u16 bw_min; 466 u32 bandwidth;
478 u16 bw_max;
479 u8 port; 467 u8 port;
480 enum bfi_pcifn_class pcifn_class; 468 enum bfi_pcifn_class pcifn_class;
481 u8 rsvd[1]; 469 u8 rsvd[1];
@@ -625,13 +613,6 @@ struct bfa_bsg_diag_lb_stat_s {
625 u16 rsvd; 613 u16 rsvd;
626}; 614};
627 615
628struct bfa_bsg_diag_dport_get_state_s {
629 bfa_status_t status;
630 u16 bfad_num;
631 u16 rsvd;
632 enum bfa_dport_state state;
633};
634
635struct bfa_bsg_phy_attr_s { 616struct bfa_bsg_phy_attr_s {
636 bfa_status_t status; 617 bfa_status_t status;
637 u16 bfad_num; 618 u16 bfad_num;
@@ -713,13 +694,6 @@ struct bfa_bsg_qos_vc_attr_s {
713 struct bfa_qos_vc_attr_s attr; 694 struct bfa_qos_vc_attr_s attr;
714}; 695};
715 696
716struct bfa_bsg_qos_bw_s {
717 bfa_status_t status;
718 u16 bfad_num;
719 u16 rsvd;
720 struct bfa_qos_bw_s qos_bw;
721};
722
723struct bfa_bsg_vf_stats_s { 697struct bfa_bsg_vf_stats_s {
724 bfa_status_t status; 698 bfa_status_t status;
725 u16 bfad_num; 699 u16 bfad_num;
@@ -748,41 +722,6 @@ struct bfa_bsg_fcpim_lunmask_s {
748 struct scsi_lun lun; 722 struct scsi_lun lun;
749}; 723};
750 724
751struct bfa_bsg_fcpim_throttle_s {
752 bfa_status_t status;
753 u16 bfad_num;
754 u16 vf_id;
755 struct bfa_defs_fcpim_throttle_s throttle;
756};
757
758#define BFA_TFRU_DATA_SIZE 64
759#define BFA_MAX_FRUVPD_TRANSFER_SIZE 0x1000
760
761struct bfa_bsg_tfru_s {
762 bfa_status_t status;
763 u16 bfad_num;
764 u16 rsvd;
765 u32 offset;
766 u32 len;
767 u8 data[BFA_TFRU_DATA_SIZE];
768};
769
770struct bfa_bsg_fruvpd_s {
771 bfa_status_t status;
772 u16 bfad_num;
773 u16 rsvd;
774 u32 offset;
775 u32 len;
776 u8 data[BFA_MAX_FRUVPD_TRANSFER_SIZE];
777};
778
779struct bfa_bsg_fruvpd_max_size_s {
780 bfa_status_t status;
781 u16 bfad_num;
782 u16 rsvd;
783 u32 max_size;
784};
785
786struct bfa_bsg_fcpt_s { 725struct bfa_bsg_fcpt_s {
787 bfa_status_t status; 726 bfa_status_t status;
788 u16 vf_id; 727 u16 vf_id;
diff --git a/drivers/scsi/bfa/bfad_debugfs.c b/drivers/scsi/bfa/bfad_debugfs.c
index 439c012be76..b412e0300dd 100644
--- a/drivers/scsi/bfa/bfad_debugfs.c
+++ b/drivers/scsi/bfa/bfad_debugfs.c
@@ -16,7 +16,6 @@
16 */ 16 */
17 17
18#include <linux/debugfs.h> 18#include <linux/debugfs.h>
19#include <linux/export.h>
20 19
21#include "bfad_drv.h" 20#include "bfad_drv.h"
22#include "bfad_im.h" 21#include "bfad_im.h"
@@ -472,7 +471,7 @@ static const struct file_operations bfad_debugfs_op_regwr = {
472 471
473struct bfad_debugfs_entry { 472struct bfad_debugfs_entry {
474 const char *name; 473 const char *name;
475 umode_t mode; 474 mode_t mode;
476 const struct file_operations *fops; 475 const struct file_operations *fops;
477}; 476};
478 477
@@ -557,7 +556,8 @@ bfad_debugfs_exit(struct bfad_port_s *port)
557 } 556 }
558 } 557 }
559 558
560 /* Remove the pci_dev debugfs directory for the port */ 559 /*
560 * Remove the pci_dev debugfs directory for the port */
561 if (port->port_debugfs_root) { 561 if (port->port_debugfs_root) {
562 debugfs_remove(port->port_debugfs_root); 562 debugfs_remove(port->port_debugfs_root);
563 port->port_debugfs_root = NULL; 563 port->port_debugfs_root = NULL;
diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index 0c64a04f01f..bda999ad9f5 100644
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -27,6 +27,7 @@
27#define __BFAD_DRV_H__ 27#define __BFAD_DRV_H__
28 28
29#include <linux/types.h> 29#include <linux/types.h>
30#include <linux/version.h>
30#include <linux/pci.h> 31#include <linux/pci.h>
31#include <linux/dma-mapping.h> 32#include <linux/dma-mapping.h>
32#include <linux/idr.h> 33#include <linux/idr.h>
@@ -37,14 +38,12 @@
37#include <linux/vmalloc.h> 38#include <linux/vmalloc.h>
38#include <linux/workqueue.h> 39#include <linux/workqueue.h>
39#include <linux/bitops.h> 40#include <linux/bitops.h>
40#include <linux/aer.h>
41#include <scsi/scsi.h> 41#include <scsi/scsi.h>
42#include <scsi/scsi_host.h> 42#include <scsi/scsi_host.h>
43#include <scsi/scsi_tcq.h> 43#include <scsi/scsi_tcq.h>
44#include <scsi/scsi_transport_fc.h> 44#include <scsi/scsi_transport_fc.h>
45#include <scsi/scsi_transport.h> 45#include <scsi/scsi_transport.h>
46#include <scsi/scsi_bsg_fc.h> 46#include <scsi/scsi_bsg_fc.h>
47#include <scsi/scsi_devinfo.h>
48 47
49#include "bfa_modules.h" 48#include "bfa_modules.h"
50#include "bfa_fcs.h" 49#include "bfa_fcs.h"
@@ -57,7 +56,7 @@
57#ifdef BFA_DRIVER_VERSION 56#ifdef BFA_DRIVER_VERSION
58#define BFAD_DRIVER_VERSION BFA_DRIVER_VERSION 57#define BFAD_DRIVER_VERSION BFA_DRIVER_VERSION
59#else 58#else
60#define BFAD_DRIVER_VERSION "3.1.2.1" 59#define BFAD_DRIVER_VERSION "3.0.2.2"
61#endif 60#endif
62 61
63#define BFAD_PROTO_NAME FCPI_NAME 62#define BFAD_PROTO_NAME FCPI_NAME
@@ -82,8 +81,6 @@
82#define BFAD_FC4_PROBE_DONE 0x00000200 81#define BFAD_FC4_PROBE_DONE 0x00000200
83#define BFAD_PORT_DELETE 0x00000001 82#define BFAD_PORT_DELETE 0x00000001
84#define BFAD_INTX_ON 0x00000400 83#define BFAD_INTX_ON 0x00000400
85#define BFAD_EEH_BUSY 0x00000800
86#define BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE 0x00001000
87/* 84/*
88 * BFAD related definition 85 * BFAD related definition
89 */ 86 */
@@ -231,7 +228,6 @@ struct bfad_s {
231 struct list_head active_aen_q; 228 struct list_head active_aen_q;
232 struct bfa_aen_entry_s aen_list[BFA_AEN_MAX_ENTRY]; 229 struct bfa_aen_entry_s aen_list[BFA_AEN_MAX_ENTRY];
233 spinlock_t bfad_aen_spinlock; 230 spinlock_t bfad_aen_spinlock;
234 struct list_head vport_list;
235}; 231};
236 232
237/* BFAD state machine events */ 233/* BFAD state machine events */
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index 8f92732655c..01312381639 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -19,8 +19,6 @@
19 * bfad_im.c Linux driver IM module. 19 * bfad_im.c Linux driver IM module.
20 */ 20 */
21 21
22#include <linux/export.h>
23
24#include "bfad_drv.h" 22#include "bfad_drv.h"
25#include "bfad_im.h" 23#include "bfad_im.h"
26#include "bfa_fcs.h" 24#include "bfa_fcs.h"
@@ -687,21 +685,25 @@ bfa_status_t
687bfad_im_probe(struct bfad_s *bfad) 685bfad_im_probe(struct bfad_s *bfad)
688{ 686{
689 struct bfad_im_s *im; 687 struct bfad_im_s *im;
688 bfa_status_t rc = BFA_STATUS_OK;
690 689
691 im = kzalloc(sizeof(struct bfad_im_s), GFP_KERNEL); 690 im = kzalloc(sizeof(struct bfad_im_s), GFP_KERNEL);
692 if (im == NULL) 691 if (im == NULL) {
693 return BFA_STATUS_ENOMEM; 692 rc = BFA_STATUS_ENOMEM;
693 goto ext;
694 }
694 695
695 bfad->im = im; 696 bfad->im = im;
696 im->bfad = bfad; 697 im->bfad = bfad;
697 698
698 if (bfad_thread_workq(bfad) != BFA_STATUS_OK) { 699 if (bfad_thread_workq(bfad) != BFA_STATUS_OK) {
699 kfree(im); 700 kfree(im);
700 return BFA_STATUS_FAILED; 701 rc = BFA_STATUS_FAILED;
701 } 702 }
702 703
703 INIT_WORK(&im->aen_im_notify_work, bfad_aen_im_notify_handler); 704 INIT_WORK(&im->aen_im_notify_work, bfad_aen_im_notify_handler);
704 return BFA_STATUS_OK; 705ext:
706 return rc;
705} 707}
706 708
707void 709void
@@ -914,76 +916,22 @@ bfad_get_itnim(struct bfad_im_port_s *im_port, int id)
914} 916}
915 917
916/* 918/*
917 * Function is invoked from the SCSI Host Template slave_alloc() entry point.
918 * Has the logic to query the LUN Mask database to check if this LUN needs to
919 * be made visible to the SCSI mid-layer or not.
920 *
921 * Returns BFA_STATUS_OK if this LUN needs to be added to the OS stack.
922 * Returns -ENXIO to notify SCSI mid-layer to not add this LUN to the OS stack.
923 */
924static int
925bfad_im_check_if_make_lun_visible(struct scsi_device *sdev,
926 struct fc_rport *rport)
927{
928 struct bfad_itnim_data_s *itnim_data =
929 (struct bfad_itnim_data_s *) rport->dd_data;
930 struct bfa_s *bfa = itnim_data->itnim->bfa_itnim->bfa;
931 struct bfa_rport_s *bfa_rport = itnim_data->itnim->bfa_itnim->rport;
932 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(bfa);
933 int i = 0, ret = -ENXIO;
934
935 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
936 if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE &&
937 scsilun_to_int(&lun_list[i].lun) == sdev->lun &&
938 lun_list[i].rp_tag == bfa_rport->rport_tag &&
939 lun_list[i].lp_tag == (u8)bfa_rport->rport_info.lp_tag) {
940 ret = BFA_STATUS_OK;
941 break;
942 }
943 }
944 return ret;
945}
946
947/*
948 * Scsi_Host template entry slave_alloc 919 * Scsi_Host template entry slave_alloc
949 */ 920 */
950static int 921static int
951bfad_im_slave_alloc(struct scsi_device *sdev) 922bfad_im_slave_alloc(struct scsi_device *sdev)
952{ 923{
953 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 924 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
954 struct bfad_itnim_data_s *itnim_data =
955 (struct bfad_itnim_data_s *) rport->dd_data;
956 struct bfa_s *bfa = itnim_data->itnim->bfa_itnim->bfa;
957 925
958 if (!rport || fc_remote_port_chkready(rport)) 926 if (!rport || fc_remote_port_chkready(rport))
959 return -ENXIO; 927 return -ENXIO;
960 928
961 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED) {
962 /*
963 * We should not mask LUN 0 - since this will translate
964 * to no LUN / TARGET for SCSI ml resulting no scan.
965 */
966 if (sdev->lun == 0) {
967 sdev->sdev_bflags |= BLIST_NOREPORTLUN |
968 BLIST_SPARSELUN;
969 goto done;
970 }
971
972 /*
973 * Query LUN Mask configuration - to expose this LUN
974 * to the SCSI mid-layer or to mask it.
975 */
976 if (bfad_im_check_if_make_lun_visible(sdev, rport) !=
977 BFA_STATUS_OK)
978 return -ENXIO;
979 }
980done:
981 sdev->hostdata = rport->dd_data; 929 sdev->hostdata = rport->dd_data;
982 930
983 return 0; 931 return 0;
984} 932}
985 933
986u32 934static u32
987bfad_im_supported_speeds(struct bfa_s *bfa) 935bfad_im_supported_speeds(struct bfa_s *bfa)
988{ 936{
989 struct bfa_ioc_attr_s *ioc_attr; 937 struct bfa_ioc_attr_s *ioc_attr;
@@ -1087,8 +1035,6 @@ bfad_im_fc_rport_add(struct bfad_im_port_s *im_port, struct bfad_itnim_s *itnim)
1087 && (fc_rport->scsi_target_id < MAX_FCP_TARGET)) 1035 && (fc_rport->scsi_target_id < MAX_FCP_TARGET))
1088 itnim->scsi_tgt_id = fc_rport->scsi_target_id; 1036 itnim->scsi_tgt_id = fc_rport->scsi_target_id;
1089 1037
1090 itnim->channel = fc_rport->channel;
1091
1092 return; 1038 return;
1093} 1039}
1094 1040
@@ -1216,15 +1162,6 @@ bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd
1216 return 0; 1162 return 0;
1217 } 1163 }
1218 1164
1219 if (bfad->bfad_flags & BFAD_EEH_BUSY) {
1220 if (bfad->bfad_flags & BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE)
1221 cmnd->result = DID_NO_CONNECT << 16;
1222 else
1223 cmnd->result = DID_REQUEUE << 16;
1224 done(cmnd);
1225 return 0;
1226 }
1227
1228 sg_cnt = scsi_dma_map(cmnd); 1165 sg_cnt = scsi_dma_map(cmnd);
1229 if (sg_cnt < 0) 1166 if (sg_cnt < 0)
1230 return SCSI_MLQUEUE_HOST_BUSY; 1167 return SCSI_MLQUEUE_HOST_BUSY;
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index f6c1023e502..004b6cf848d 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -37,7 +37,6 @@ int bfad_im_scsi_host_alloc(struct bfad_s *bfad,
37 struct bfad_im_port_s *im_port, struct device *dev); 37 struct bfad_im_port_s *im_port, struct device *dev);
38void bfad_im_scsi_host_free(struct bfad_s *bfad, 38void bfad_im_scsi_host_free(struct bfad_s *bfad,
39 struct bfad_im_port_s *im_port); 39 struct bfad_im_port_s *im_port);
40u32 bfad_im_supported_speeds(struct bfa_s *bfa);
41 40
42#define MAX_FCP_TARGET 1024 41#define MAX_FCP_TARGET 1024
43#define MAX_FCP_LUN 16384 42#define MAX_FCP_LUN 16384
@@ -92,7 +91,6 @@ struct bfad_itnim_s {
92 struct fc_rport *fc_rport; 91 struct fc_rport *fc_rport;
93 struct bfa_itnim_s *bfa_itnim; 92 struct bfa_itnim_s *bfa_itnim;
94 u16 scsi_tgt_id; 93 u16 scsi_tgt_id;
95 u16 channel;
96 u16 queue_work; 94 u16 queue_work;
97 unsigned long last_ramp_up_time; 95 unsigned long last_ramp_up_time;
98 unsigned long last_queue_full_time; 96 unsigned long last_queue_full_time;
@@ -168,30 +166,4 @@ irqreturn_t bfad_intx(int irq, void *dev_id);
168int bfad_im_bsg_request(struct fc_bsg_job *job); 166int bfad_im_bsg_request(struct fc_bsg_job *job);
169int bfad_im_bsg_timeout(struct fc_bsg_job *job); 167int bfad_im_bsg_timeout(struct fc_bsg_job *job);
170 168
171/*
172 * Macro to set the SCSI device sdev_bflags - sdev_bflags are used by the
173 * SCSI mid-layer to choose LUN Scanning mode REPORT_LUNS vs. Sequential Scan
174 *
175 * Internally iterate's over all the ITNIM's part of the im_port & set's the
176 * sdev_bflags for the scsi_device associated with LUN #0.
177 */
178#define bfad_reset_sdev_bflags(__im_port, __lunmask_cfg) do { \
179 struct scsi_device *__sdev = NULL; \
180 struct bfad_itnim_s *__itnim = NULL; \
181 u32 scan_flags = BLIST_NOREPORTLUN | BLIST_SPARSELUN; \
182 list_for_each_entry(__itnim, &((__im_port)->itnim_mapped_list), \
183 list_entry) { \
184 __sdev = scsi_device_lookup((__im_port)->shost, \
185 __itnim->channel, \
186 __itnim->scsi_tgt_id, 0); \
187 if (__sdev) { \
188 if ((__lunmask_cfg) == BFA_TRUE) \
189 __sdev->sdev_bflags |= scan_flags; \
190 else \
191 __sdev->sdev_bflags &= ~scan_flags; \
192 scsi_device_put(__sdev); \
193 } \
194 } \
195} while (0)
196
197#endif 169#endif
diff --git a/drivers/scsi/bfa/bfi.h b/drivers/scsi/bfa/bfi.h
index 57b146bca18..b2ba0b2e91b 100644
--- a/drivers/scsi/bfa/bfi.h
+++ b/drivers/scsi/bfa/bfi.h
@@ -210,8 +210,7 @@ enum bfi_mclass {
210 BFI_MC_PORT = 21, /* Physical port */ 210 BFI_MC_PORT = 21, /* Physical port */
211 BFI_MC_SFP = 22, /* SFP module */ 211 BFI_MC_SFP = 22, /* SFP module */
212 BFI_MC_PHY = 25, /* External PHY message class */ 212 BFI_MC_PHY = 25, /* External PHY message class */
213 BFI_MC_FRU = 34, 213 BFI_MC_MAX = 32
214 BFI_MC_MAX = 35
215}; 214};
216 215
217#define BFI_IOC_MAX_CQS 4 216#define BFI_IOC_MAX_CQS 4
@@ -289,9 +288,6 @@ struct bfi_ioc_attr_s {
289 char optrom_version[BFA_VERSION_LEN]; 288 char optrom_version[BFA_VERSION_LEN];
290 struct bfa_mfg_vpd_s vpd; 289 struct bfa_mfg_vpd_s vpd;
291 u32 card_type; /* card type */ 290 u32 card_type; /* card type */
292 u8 mfg_day; /* manufacturing day */
293 u8 mfg_month; /* manufacturing month */
294 u16 mfg_year; /* manufacturing year */
295}; 291};
296 292
297/* 293/*
@@ -691,8 +687,7 @@ struct bfi_ablk_h2i_pf_req_s {
691 u8 pcifn; 687 u8 pcifn;
692 u8 port; 688 u8 port;
693 u16 pers; 689 u16 pers;
694 u16 bw_min; /* percent BW @ max speed */ 690 u32 bw;
695 u16 bw_max; /* percent BW @ max speed */
696}; 691};
697 692
698/* BFI_ABLK_H2I_OPTROM_ENABLE, BFI_ABLK_H2I_OPTROM_DISABLE */ 693/* BFI_ABLK_H2I_OPTROM_ENABLE, BFI_ABLK_H2I_OPTROM_DISABLE */
@@ -962,7 +957,6 @@ enum bfi_diag_h2i {
962 BFI_DIAG_H2I_TEMPSENSOR = 4, 957 BFI_DIAG_H2I_TEMPSENSOR = 4,
963 BFI_DIAG_H2I_LEDTEST = 5, 958 BFI_DIAG_H2I_LEDTEST = 5,
964 BFI_DIAG_H2I_QTEST = 6, 959 BFI_DIAG_H2I_QTEST = 6,
965 BFI_DIAG_H2I_DPORT = 7,
966}; 960};
967 961
968enum bfi_diag_i2h { 962enum bfi_diag_i2h {
@@ -972,7 +966,6 @@ enum bfi_diag_i2h {
972 BFI_DIAG_I2H_TEMPSENSOR = BFA_I2HM(BFI_DIAG_H2I_TEMPSENSOR), 966 BFI_DIAG_I2H_TEMPSENSOR = BFA_I2HM(BFI_DIAG_H2I_TEMPSENSOR),
973 BFI_DIAG_I2H_LEDTEST = BFA_I2HM(BFI_DIAG_H2I_LEDTEST), 967 BFI_DIAG_I2H_LEDTEST = BFA_I2HM(BFI_DIAG_H2I_LEDTEST),
974 BFI_DIAG_I2H_QTEST = BFA_I2HM(BFI_DIAG_H2I_QTEST), 968 BFI_DIAG_I2H_QTEST = BFA_I2HM(BFI_DIAG_H2I_QTEST),
975 BFI_DIAG_I2H_DPORT = BFA_I2HM(BFI_DIAG_H2I_DPORT),
976}; 969};
977 970
978#define BFI_DIAG_MAX_SGES 2 971#define BFI_DIAG_MAX_SGES 2
@@ -1059,23 +1052,6 @@ struct bfi_diag_qtest_req_s {
1059#define bfi_diag_qtest_rsp_t struct bfi_diag_qtest_req_s 1052#define bfi_diag_qtest_rsp_t struct bfi_diag_qtest_req_s
1060 1053
1061/* 1054/*
1062 * D-port test
1063 */
1064enum bfi_dport_req {
1065 BFI_DPORT_DISABLE = 0, /* disable dport request */
1066 BFI_DPORT_ENABLE = 1, /* enable dport request */
1067};
1068
1069struct bfi_diag_dport_req_s {
1070 struct bfi_mhdr_s mh; /* 4 bytes */
1071 u8 req; /* request 1: enable 0: disable */
1072 u8 status; /* reply status */
1073 u8 rsvd[2];
1074 u32 msgtag; /* msgtag for reply */
1075};
1076#define bfi_diag_dport_rsp_t struct bfi_diag_dport_req_s
1077
1078/*
1079 * PHY module specific 1055 * PHY module specific
1080 */ 1056 */
1081enum bfi_phy_h2i_msgs_e { 1057enum bfi_phy_h2i_msgs_e {
@@ -1171,50 +1147,6 @@ struct bfi_phy_write_rsp_s {
1171 u32 length; 1147 u32 length;
1172}; 1148};
1173 1149
1174enum bfi_fru_h2i_msgs {
1175 BFI_FRUVPD_H2I_WRITE_REQ = 1,
1176 BFI_FRUVPD_H2I_READ_REQ = 2,
1177 BFI_TFRU_H2I_WRITE_REQ = 3,
1178 BFI_TFRU_H2I_READ_REQ = 4,
1179};
1180
1181enum bfi_fru_i2h_msgs {
1182 BFI_FRUVPD_I2H_WRITE_RSP = BFA_I2HM(1),
1183 BFI_FRUVPD_I2H_READ_RSP = BFA_I2HM(2),
1184 BFI_TFRU_I2H_WRITE_RSP = BFA_I2HM(3),
1185 BFI_TFRU_I2H_READ_RSP = BFA_I2HM(4),
1186};
1187
1188/*
1189 * FRU write request
1190 */
1191struct bfi_fru_write_req_s {
1192 struct bfi_mhdr_s mh; /* Common msg header */
1193 u8 last;
1194 u8 rsv[3];
1195 u32 offset;
1196 u32 length;
1197 struct bfi_alen_s alen;
1198};
1199
1200/*
1201 * FRU read request
1202 */
1203struct bfi_fru_read_req_s {
1204 struct bfi_mhdr_s mh; /* Common msg header */
1205 u32 offset;
1206 u32 length;
1207 struct bfi_alen_s alen;
1208};
1209
1210/*
1211 * FRU response
1212 */
1213struct bfi_fru_rsp_s {
1214 struct bfi_mhdr_s mh; /* Common msg header */
1215 u32 status;
1216 u32 length;
1217};
1218#pragma pack() 1150#pragma pack()
1219 1151
1220#endif /* __BFI_H__ */ 1152#endif /* __BFI_H__ */
diff --git a/drivers/scsi/bfa/bfi_ms.h b/drivers/scsi/bfa/bfi_ms.h
index 5ae2c167b2c..0d9f1fb50db 100644
--- a/drivers/scsi/bfa/bfi_ms.h
+++ b/drivers/scsi/bfa/bfi_ms.h
@@ -28,15 +28,17 @@ enum bfi_iocfc_h2i_msgs {
28 BFI_IOCFC_H2I_CFG_REQ = 1, 28 BFI_IOCFC_H2I_CFG_REQ = 1,
29 BFI_IOCFC_H2I_SET_INTR_REQ = 2, 29 BFI_IOCFC_H2I_SET_INTR_REQ = 2,
30 BFI_IOCFC_H2I_UPDATEQ_REQ = 3, 30 BFI_IOCFC_H2I_UPDATEQ_REQ = 3,
31 BFI_IOCFC_H2I_FAA_QUERY_REQ = 4, 31 BFI_IOCFC_H2I_FAA_ENABLE_REQ = 4,
32 BFI_IOCFC_H2I_ADDR_REQ = 5, 32 BFI_IOCFC_H2I_FAA_DISABLE_REQ = 5,
33 BFI_IOCFC_H2I_FAA_QUERY_REQ = 6,
33}; 34};
34 35
35enum bfi_iocfc_i2h_msgs { 36enum bfi_iocfc_i2h_msgs {
36 BFI_IOCFC_I2H_CFG_REPLY = BFA_I2HM(1), 37 BFI_IOCFC_I2H_CFG_REPLY = BFA_I2HM(1),
37 BFI_IOCFC_I2H_UPDATEQ_RSP = BFA_I2HM(3), 38 BFI_IOCFC_I2H_UPDATEQ_RSP = BFA_I2HM(3),
38 BFI_IOCFC_I2H_FAA_QUERY_RSP = BFA_I2HM(4), 39 BFI_IOCFC_I2H_FAA_ENABLE_RSP = BFA_I2HM(4),
39 BFI_IOCFC_I2H_ADDR_MSG = BFA_I2HM(5), 40 BFI_IOCFC_I2H_FAA_DISABLE_RSP = BFA_I2HM(5),
41 BFI_IOCFC_I2H_FAA_QUERY_RSP = BFA_I2HM(6),
40}; 42};
41 43
42struct bfi_iocfc_cfg_s { 44struct bfi_iocfc_cfg_s {
@@ -182,13 +184,6 @@ struct bfi_faa_en_dis_s {
182 struct bfi_mhdr_s mh; /* common msg header */ 184 struct bfi_mhdr_s mh; /* common msg header */
183}; 185};
184 186
185struct bfi_faa_addr_msg_s {
186 struct bfi_mhdr_s mh; /* common msg header */
187 u8 rsvd[4];
188 wwn_t pwwn; /* Fabric acquired PWWN */
189 wwn_t nwwn; /* Fabric acquired PWWN */
190};
191
192/* 187/*
193 * BFI_IOCFC_H2I_FAA_QUERY_REQ message 188 * BFI_IOCFC_H2I_FAA_QUERY_REQ message
194 */ 189 */
@@ -426,7 +421,6 @@ struct bfi_lps_login_req_s {
426 u8 auth_en; 421 u8 auth_en;
427 u8 lps_role; 422 u8 lps_role;
428 u8 bb_scn; 423 u8 bb_scn;
429 u32 vvl_flag;
430}; 424};
431 425
432struct bfi_lps_login_rsp_s { 426struct bfi_lps_login_rsp_s {
@@ -500,9 +494,6 @@ enum bfi_rport_i2h_msgs {
500 BFI_RPORT_I2H_CREATE_RSP = BFA_I2HM(1), 494 BFI_RPORT_I2H_CREATE_RSP = BFA_I2HM(1),
501 BFI_RPORT_I2H_DELETE_RSP = BFA_I2HM(2), 495 BFI_RPORT_I2H_DELETE_RSP = BFA_I2HM(2),
502 BFI_RPORT_I2H_QOS_SCN = BFA_I2HM(3), 496 BFI_RPORT_I2H_QOS_SCN = BFA_I2HM(3),
503 BFI_RPORT_I2H_LIP_SCN_ONLINE = BFA_I2HM(4),
504 BFI_RPORT_I2H_LIP_SCN_OFFLINE = BFA_I2HM(5),
505 BFI_RPORT_I2H_NO_DEV = BFA_I2HM(6),
506}; 497};
507 498
508struct bfi_rport_create_req_s { 499struct bfi_rport_create_req_s {
@@ -555,14 +546,6 @@ struct bfi_rport_qos_scn_s {
555 struct bfa_rport_qos_attr_s new_qos_attr; /* New QoS Attributes */ 546 struct bfa_rport_qos_attr_s new_qos_attr; /* New QoS Attributes */
556}; 547};
557 548
558struct bfi_rport_lip_scn_s {
559 struct bfi_mhdr_s mh; /*!< common msg header */
560 u16 bfa_handle; /*!< host rport handle */
561 u8 status; /*!< scn online status */
562 u8 rsvd;
563 struct bfa_fcport_loop_info_s loop_info;
564};
565
566union bfi_rport_h2i_msg_u { 549union bfi_rport_h2i_msg_u {
567 struct bfi_msg_s *msg; 550 struct bfi_msg_s *msg;
568 struct bfi_rport_create_req_s *create_req; 551 struct bfi_rport_create_req_s *create_req;
@@ -575,7 +558,6 @@ union bfi_rport_i2h_msg_u {
575 struct bfi_rport_create_rsp_s *create_rsp; 558 struct bfi_rport_create_rsp_s *create_rsp;
576 struct bfi_rport_delete_rsp_s *delete_rsp; 559 struct bfi_rport_delete_rsp_s *delete_rsp;
577 struct bfi_rport_qos_scn_s *qos_scn_evt; 560 struct bfi_rport_qos_scn_s *qos_scn_evt;
578 struct bfi_rport_lip_scn_s *lip_scn;
579}; 561};
580 562
581/* 563/*
@@ -841,7 +823,6 @@ enum bfi_tskim_status {
841 */ 823 */
842 BFI_TSKIM_STS_TIMEOUT = 10, /* TM request timedout */ 824 BFI_TSKIM_STS_TIMEOUT = 10, /* TM request timedout */
843 BFI_TSKIM_STS_ABORTED = 11, /* Aborted on host request */ 825 BFI_TSKIM_STS_ABORTED = 11, /* Aborted on host request */
844 BFI_TSKIM_STS_UTAG = 12, /* unknown tag for request */
845}; 826};
846 827
847struct bfi_tskim_rsp_s { 828struct bfi_tskim_rsp_s {
diff --git a/drivers/scsi/bfa/bfi_reg.h b/drivers/scsi/bfa/bfi_reg.h
index 99133bcf53f..d892064b64a 100644
--- a/drivers/scsi/bfa/bfi_reg.h
+++ b/drivers/scsi/bfa/bfi_reg.h
@@ -335,18 +335,11 @@ enum {
335#define __PMM_1T_PNDB_P 0x00000002 335#define __PMM_1T_PNDB_P 0x00000002
336#define CT2_PMM_1T_CONTROL_REG_P1 0x00023c1c 336#define CT2_PMM_1T_CONTROL_REG_P1 0x00023c1c
337#define CT2_WGN_STATUS 0x00014990 337#define CT2_WGN_STATUS 0x00014990
338#define __A2T_AHB_LOAD 0x00000800
339#define __WGN_READY 0x00000400 338#define __WGN_READY 0x00000400
340#define __GLBL_PF_VF_CFG_RDY 0x00000200 339#define __GLBL_PF_VF_CFG_RDY 0x00000200
341#define CT2_NFC_STS_REG 0x00027410
342#define CT2_NFC_CSR_CLR_REG 0x00027420
343#define CT2_NFC_CSR_SET_REG 0x00027424 340#define CT2_NFC_CSR_SET_REG 0x00027424
344#define __HALT_NFC_CONTROLLER 0x00000002 341#define __HALT_NFC_CONTROLLER 0x00000002
345#define __NFC_CONTROLLER_HALTED 0x00001000 342#define __NFC_CONTROLLER_HALTED 0x00001000
346#define CT2_RSC_GPR15_REG 0x0002765c
347#define CT2_CSI_FW_CTL_REG 0x00027080
348#define CT2_CSI_FW_CTL_SET_REG 0x00027088
349#define __RESET_AND_START_SCLK_LCLK_PLLS 0x00010000
350 343
351#define CT2_CSI_MAC0_CONTROL_REG 0x000270d0 344#define CT2_CSI_MAC0_CONTROL_REG 0x000270d0
352#define __CSI_MAC_RESET 0x00000010 345#define __CSI_MAC_RESET 0x00000010
@@ -356,8 +349,6 @@ enum {
356 (CT2_CSI_MAC0_CONTROL_REG + \ 349 (CT2_CSI_MAC0_CONTROL_REG + \
357 (__n) * (CT2_CSI_MAC1_CONTROL_REG - CT2_CSI_MAC0_CONTROL_REG)) 350 (__n) * (CT2_CSI_MAC1_CONTROL_REG - CT2_CSI_MAC0_CONTROL_REG))
358 351
359#define CT2_NFC_FLASH_STS_REG 0x00014834
360#define __FLASH_PLL_INIT_AND_RESET_IN_PROGRESS 0x00000020
361/* 352/*
362 * Name semaphore registers based on usage 353 * Name semaphore registers based on usage
363 */ 354 */
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-19 12:35:31 -0400