1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2008 Cisco Systems, Inc. All rights reserved. 4 * Copyright 2007 Nuova Systems, Inc. All rights reserved. 5 */ 6 7 #include <linux/workqueue.h> 8 #include "fnic.h" 9 #include "fdls_fc.h" 10 #include "fnic_fdls.h" 11 #include <scsi/fc/fc_fcp.h> 12 #include <scsi/scsi_transport_fc.h> 13 #include <linux/utsname.h> 14 15 #define FC_FC4_TYPE_SCSI 0x08 16 #define PORT_SPEED_BIT_8 8 17 #define PORT_SPEED_BIT_9 9 18 #define PORT_SPEED_BIT_14 14 19 #define PORT_SPEED_BIT_15 15 20 21 /* FNIC FDMI Register HBA Macros */ 22 #define FNIC_FDMI_NUM_PORTS 1 23 #define FNIC_FDMI_NUM_HBA_ATTRS 9 24 #define FNIC_FDMI_TYPE_NODE_NAME 0X1 25 #define FNIC_FDMI_TYPE_MANUFACTURER 0X2 26 #define FNIC_FDMI_MANUFACTURER "Cisco Systems" 27 #define FNIC_FDMI_TYPE_SERIAL_NUMBER 0X3 28 #define FNIC_FDMI_TYPE_MODEL 0X4 29 #define FNIC_FDMI_TYPE_MODEL_DES 0X5 30 #define FNIC_FDMI_MODEL_DESCRIPTION "Cisco Virtual Interface Card" 31 #define FNIC_FDMI_TYPE_HARDWARE_VERSION 0X6 32 #define FNIC_FDMI_TYPE_DRIVER_VERSION 0X7 33 #define FNIC_FDMI_TYPE_ROM_VERSION 0X8 34 #define FNIC_FDMI_TYPE_FIRMWARE_VERSION 0X9 35 #define FNIC_FDMI_NN_LEN 8 36 #define FNIC_FDMI_MANU_LEN 20 37 #define FNIC_FDMI_SERIAL_LEN 16 38 #define FNIC_FDMI_MODEL_LEN 12 39 #define FNIC_FDMI_MODEL_DES_LEN 56 40 #define FNIC_FDMI_HW_VER_LEN 16 41 #define FNIC_FDMI_DR_VER_LEN 28 42 #define FNIC_FDMI_ROM_VER_LEN 8 43 #define FNIC_FDMI_FW_VER_LEN 16 44 45 /* FNIC FDMI Register PA Macros */ 46 #define FNIC_FDMI_TYPE_FC4_TYPES 0X1 47 #define FNIC_FDMI_TYPE_SUPPORTED_SPEEDS 0X2 48 #define FNIC_FDMI_TYPE_CURRENT_SPEED 0X3 49 #define FNIC_FDMI_TYPE_MAX_FRAME_SIZE 0X4 50 #define FNIC_FDMI_TYPE_OS_NAME 0X5 51 #define FNIC_FDMI_TYPE_HOST_NAME 0X6 52 #define FNIC_FDMI_NUM_PORT_ATTRS 6 53 #define FNIC_FDMI_FC4_LEN 32 54 #define FNIC_FDMI_SUPP_SPEED_LEN 4 55 #define FNIC_FDMI_CUR_SPEED_LEN 4 56 #define FNIC_FDMI_MFS_LEN 4 57 #define FNIC_FDMI_MFS 0x800 58 #define FNIC_FDMI_OS_NAME_LEN 16 59 #define FNIC_FDMI_HN_LEN 24 60 61 #define FDLS_FDMI_PLOGI_PENDING 0x1 62 #define FDLS_FDMI_REG_HBA_PENDING 0x2 63 #define FDLS_FDMI_RPA_PENDING 0x4 64 #define FDLS_FDMI_ABORT_PENDING 0x8 65 #define FDLS_FDMI_MAX_RETRY 3 66 67 #define RETRIES_EXHAUSTED(iport) \ 68 (iport->fabric.retry_counter == FABRIC_LOGO_MAX_RETRY) 69 70 #define FNIC_TPORT_MAX_NEXUS_RESTART (8) 71 72 #define SCHEDULE_OXID_FREE_RETRY_TIME (300) 73 74 /* Private Functions */ 75 static void fdls_fdmi_register_hba(struct fnic_iport_s *iport); 76 static void fdls_fdmi_register_pa(struct fnic_iport_s *iport); 77 static void fdls_send_rpn_id(struct fnic_iport_s *iport); 78 static void fdls_process_flogi_rsp(struct fnic_iport_s *iport, 79 struct fc_frame_header *fchdr, 80 void *rx_frame); 81 static void fnic_fdls_start_plogi(struct fnic_iport_s *iport); 82 static void fnic_fdls_start_flogi(struct fnic_iport_s *iport); 83 static struct fnic_tport_s *fdls_create_tport(struct fnic_iport_s *iport, 84 uint32_t fcid, 85 uint64_t wwpn); 86 static void fdls_target_restart_nexus(struct fnic_tport_s *tport); 87 static void fdls_start_tport_timer(struct fnic_iport_s *iport, 88 struct fnic_tport_s *tport, int timeout); 89 static void fdls_tport_timer_callback(struct timer_list *t); 90 static void fdls_send_fdmi_plogi(struct fnic_iport_s *iport); 91 static void fdls_start_fabric_timer(struct fnic_iport_s *iport, 92 int timeout); 93 static void fdls_init_plogi_frame(uint8_t *frame, struct fnic_iport_s *iport); 94 static void fdls_init_els_acc_frame(uint8_t *frame, struct fnic_iport_s *iport); 95 static void fdls_init_els_rjt_frame(uint8_t *frame, struct fnic_iport_s *iport); 96 static void fdls_init_logo_frame(uint8_t *frame, struct fnic_iport_s *iport); 97 static void fdls_init_fabric_abts_frame(uint8_t *frame, 98 struct fnic_iport_s *iport); 99 100 uint8_t *fdls_alloc_frame(struct fnic_iport_s *iport) 101 { 102 struct fnic *fnic = iport->fnic; 103 uint8_t *frame = NULL; 104 105 frame = mempool_alloc(fnic->frame_pool, GFP_ATOMIC); 106 if (frame == NULL) { 107 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 108 "Failed to allocate frame"); 109 return NULL; 110 } 111 112 memset(frame, 0, FNIC_FCOE_FRAME_MAXSZ); 113 return frame; 114 } 115 116 /** 117 * fdls_alloc_oxid - Allocate an oxid from the bitmap based oxid pool 118 * @iport: Handle to iport instance 119 * @oxid_frame_type: Type of frame to allocate 120 * @active_oxid: the oxid which is in use 121 * 122 * Called with fnic lock held 123 */ 124 uint16_t fdls_alloc_oxid(struct fnic_iport_s *iport, int oxid_frame_type, 125 uint16_t *active_oxid) 126 { 127 struct fnic *fnic = iport->fnic; 128 struct fnic_oxid_pool_s *oxid_pool = &iport->oxid_pool; 129 int idx; 130 uint16_t oxid; 131 132 lockdep_assert_held(&fnic->fnic_lock); 133 134 /* 135 * Allocate next available oxid from bitmap 136 */ 137 idx = find_next_zero_bit(oxid_pool->bitmap, FNIC_OXID_POOL_SZ, oxid_pool->next_idx); 138 if (idx == FNIC_OXID_POOL_SZ) { 139 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 140 "Alloc oxid: all oxid slots are busy iport state:%d\n", 141 iport->state); 142 return FNIC_UNASSIGNED_OXID; 143 } 144 145 WARN_ON(test_and_set_bit(idx, oxid_pool->bitmap)); 146 oxid_pool->next_idx = (idx + 1) % FNIC_OXID_POOL_SZ; /* cycle through the bitmap */ 147 148 oxid = FNIC_OXID_ENCODE(idx, oxid_frame_type); 149 *active_oxid = oxid; 150 151 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 152 "alloc oxid: 0x%x, iport state: %d\n", 153 oxid, iport->state); 154 return oxid; 155 } 156 157 /** 158 * fdls_free_oxid_idx - Free the oxid using the idx 159 * @iport: Handle to iport instance 160 * @oxid_idx: The index to free 161 * 162 * Free the oxid immediately and make it available for new requests 163 * Called with fnic lock held 164 */ 165 static void fdls_free_oxid_idx(struct fnic_iport_s *iport, uint16_t oxid_idx) 166 { 167 struct fnic *fnic = iport->fnic; 168 struct fnic_oxid_pool_s *oxid_pool = &iport->oxid_pool; 169 170 lockdep_assert_held(&fnic->fnic_lock); 171 172 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 173 "free oxid idx: 0x%x\n", oxid_idx); 174 175 WARN_ON(!test_and_clear_bit(oxid_idx, oxid_pool->bitmap)); 176 } 177 178 /** 179 * fdls_reclaim_oxid_handler - Callback handler for delayed_oxid_work 180 * @work: Handle to work_struct 181 * 182 * Scheduled when an oxid is to be freed later 183 * After freeing expired oxid(s), the handler schedules 184 * another callback with the remaining time 185 * of next unexpired entry in the reclaim list. 186 */ 187 void fdls_reclaim_oxid_handler(struct work_struct *work) 188 { 189 struct fnic_oxid_pool_s *oxid_pool = container_of(work, 190 struct fnic_oxid_pool_s, oxid_reclaim_work.work); 191 struct fnic_iport_s *iport = container_of(oxid_pool, 192 struct fnic_iport_s, oxid_pool); 193 struct fnic *fnic = iport->fnic; 194 struct reclaim_entry_s *reclaim_entry, *next; 195 unsigned long delay_j, cur_jiffies; 196 197 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 198 "Reclaim oxid callback\n"); 199 200 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 201 202 /* Though the work was scheduled for one entry, 203 * walk through and free the expired entries which might have been scheduled 204 * at around the same time as the first entry 205 */ 206 list_for_each_entry_safe(reclaim_entry, next, 207 &(oxid_pool->oxid_reclaim_list), links) { 208 209 /* The list is always maintained in the order of expiry time */ 210 cur_jiffies = jiffies; 211 if (time_before(cur_jiffies, reclaim_entry->expires)) 212 break; 213 214 list_del(&reclaim_entry->links); 215 fdls_free_oxid_idx(iport, reclaim_entry->oxid_idx); 216 kfree(reclaim_entry); 217 } 218 219 /* schedule to free up the next entry */ 220 if (!list_empty(&oxid_pool->oxid_reclaim_list)) { 221 reclaim_entry = list_first_entry(&oxid_pool->oxid_reclaim_list, 222 struct reclaim_entry_s, links); 223 224 delay_j = reclaim_entry->expires - cur_jiffies; 225 schedule_delayed_work(&oxid_pool->oxid_reclaim_work, delay_j); 226 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 227 "Scheduling next callback at:%ld jiffies\n", delay_j); 228 } 229 230 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 231 } 232 233 /** 234 * fdls_free_oxid - Helper function to free the oxid 235 * @iport: Handle to iport instance 236 * @oxid: oxid to free 237 * @active_oxid: the oxid which is in use 238 * 239 * Called with fnic lock held 240 */ 241 void fdls_free_oxid(struct fnic_iport_s *iport, 242 uint16_t oxid, uint16_t *active_oxid) 243 { 244 fdls_free_oxid_idx(iport, FNIC_OXID_IDX(oxid)); 245 *active_oxid = FNIC_UNASSIGNED_OXID; 246 } 247 248 /** 249 * fdls_schedule_oxid_free - Schedule oxid to be freed later 250 * @iport: Handle to iport instance 251 * @active_oxid: the oxid which is in use 252 * 253 * Gets called in a rare case scenario when both a command 254 * (fdls or target discovery) timed out and the following ABTS 255 * timed out as well, without a link change. 256 * 257 * Called with fnic lock held 258 */ 259 void fdls_schedule_oxid_free(struct fnic_iport_s *iport, uint16_t *active_oxid) 260 { 261 struct fnic *fnic = iport->fnic; 262 struct fnic_oxid_pool_s *oxid_pool = &iport->oxid_pool; 263 struct reclaim_entry_s *reclaim_entry; 264 unsigned long delay_j = msecs_to_jiffies(OXID_RECLAIM_TOV(iport)); 265 int oxid_idx = FNIC_OXID_IDX(*active_oxid); 266 267 lockdep_assert_held(&fnic->fnic_lock); 268 269 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 270 "Schedule oxid free. oxid: 0x%x\n", *active_oxid); 271 272 *active_oxid = FNIC_UNASSIGNED_OXID; 273 274 reclaim_entry = (struct reclaim_entry_s *) 275 kzalloc(sizeof(struct reclaim_entry_s), GFP_ATOMIC); 276 277 if (!reclaim_entry) { 278 FNIC_FCS_DBG(KERN_WARNING, fnic->host, fnic->fnic_num, 279 "Failed to allocate memory for reclaim struct for oxid idx: %d\n", 280 oxid_idx); 281 282 /* Retry the scheduling */ 283 WARN_ON(test_and_set_bit(oxid_idx, oxid_pool->pending_schedule_free)); 284 schedule_delayed_work(&oxid_pool->schedule_oxid_free_retry, 0); 285 return; 286 } 287 288 reclaim_entry->oxid_idx = oxid_idx; 289 reclaim_entry->expires = round_jiffies(jiffies + delay_j); 290 291 list_add_tail(&reclaim_entry->links, &oxid_pool->oxid_reclaim_list); 292 293 schedule_delayed_work(&oxid_pool->oxid_reclaim_work, delay_j); 294 } 295 296 /** 297 * fdls_schedule_oxid_free_retry_work - Thread to schedule the 298 * oxid to be freed later 299 * 300 * @work: Handle to the work struct 301 */ 302 void fdls_schedule_oxid_free_retry_work(struct work_struct *work) 303 { 304 struct fnic_oxid_pool_s *oxid_pool = container_of(work, 305 struct fnic_oxid_pool_s, schedule_oxid_free_retry.work); 306 struct fnic_iport_s *iport = container_of(oxid_pool, 307 struct fnic_iport_s, oxid_pool); 308 struct fnic *fnic = iport->fnic; 309 struct reclaim_entry_s *reclaim_entry; 310 unsigned long delay_j = msecs_to_jiffies(OXID_RECLAIM_TOV(iport)); 311 int idx; 312 313 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 314 315 for_each_set_bit(idx, oxid_pool->pending_schedule_free, FNIC_OXID_POOL_SZ) { 316 317 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 318 "Schedule oxid free. oxid idx: %d\n", idx); 319 320 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 321 reclaim_entry = (struct reclaim_entry_s *) 322 kzalloc(sizeof(struct reclaim_entry_s), GFP_KERNEL); 323 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 324 325 if (!reclaim_entry) { 326 FNIC_FCS_DBG(KERN_WARNING, fnic->host, fnic->fnic_num, 327 "Failed to allocate memory for reclaim struct for oxid idx: 0x%x\n", 328 idx); 329 330 schedule_delayed_work(&oxid_pool->schedule_oxid_free_retry, 331 msecs_to_jiffies(SCHEDULE_OXID_FREE_RETRY_TIME)); 332 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 333 return; 334 } 335 336 if (test_and_clear_bit(idx, oxid_pool->pending_schedule_free)) { 337 reclaim_entry->oxid_idx = idx; 338 reclaim_entry->expires = round_jiffies(jiffies + delay_j); 339 list_add_tail(&reclaim_entry->links, &oxid_pool->oxid_reclaim_list); 340 schedule_delayed_work(&oxid_pool->oxid_reclaim_work, delay_j); 341 } else { 342 /* unlikely scenario, free the allocated memory and continue */ 343 kfree(reclaim_entry); 344 } 345 } 346 347 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 348 } 349 350 static bool fdls_is_oxid_fabric_req(uint16_t oxid) 351 { 352 int oxid_frame_type = FNIC_FRAME_TYPE(oxid); 353 354 switch (oxid_frame_type) { 355 case FNIC_FRAME_TYPE_FABRIC_FLOGI: 356 case FNIC_FRAME_TYPE_FABRIC_PLOGI: 357 case FNIC_FRAME_TYPE_FABRIC_RPN: 358 case FNIC_FRAME_TYPE_FABRIC_RFT: 359 case FNIC_FRAME_TYPE_FABRIC_RFF: 360 case FNIC_FRAME_TYPE_FABRIC_GPN_FT: 361 case FNIC_FRAME_TYPE_FABRIC_LOGO: 362 break; 363 default: 364 return false; 365 } 366 return true; 367 } 368 369 static bool fdls_is_oxid_fdmi_req(uint16_t oxid) 370 { 371 int oxid_frame_type = FNIC_FRAME_TYPE(oxid); 372 373 switch (oxid_frame_type) { 374 case FNIC_FRAME_TYPE_FDMI_PLOGI: 375 case FNIC_FRAME_TYPE_FDMI_RHBA: 376 case FNIC_FRAME_TYPE_FDMI_RPA: 377 break; 378 default: 379 return false; 380 } 381 return true; 382 } 383 384 static bool fdls_is_oxid_tgt_req(uint16_t oxid) 385 { 386 int oxid_frame_type = FNIC_FRAME_TYPE(oxid); 387 388 switch (oxid_frame_type) { 389 case FNIC_FRAME_TYPE_TGT_PLOGI: 390 case FNIC_FRAME_TYPE_TGT_PRLI: 391 case FNIC_FRAME_TYPE_TGT_ADISC: 392 case FNIC_FRAME_TYPE_TGT_LOGO: 393 break; 394 default: 395 return false; 396 } 397 return true; 398 } 399 400 static void fdls_reset_oxid_pool(struct fnic_iport_s *iport) 401 { 402 struct fnic_oxid_pool_s *oxid_pool = &iport->oxid_pool; 403 404 oxid_pool->next_idx = 0; 405 } 406 407 void fnic_del_fabric_timer_sync(struct fnic *fnic) 408 { 409 fnic->iport.fabric.del_timer_inprogress = 1; 410 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 411 del_timer_sync(&fnic->iport.fabric.retry_timer); 412 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 413 fnic->iport.fabric.del_timer_inprogress = 0; 414 } 415 416 void fnic_del_tport_timer_sync(struct fnic *fnic, 417 struct fnic_tport_s *tport) 418 { 419 tport->del_timer_inprogress = 1; 420 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 421 del_timer_sync(&tport->retry_timer); 422 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 423 tport->del_timer_inprogress = 0; 424 } 425 426 static void 427 fdls_start_fabric_timer(struct fnic_iport_s *iport, int timeout) 428 { 429 u64 fabric_tov; 430 struct fnic *fnic = iport->fnic; 431 432 if (iport->fabric.timer_pending) { 433 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 434 "iport fcid: 0x%x: Canceling fabric disc timer\n", 435 iport->fcid); 436 fnic_del_fabric_timer_sync(fnic); 437 iport->fabric.timer_pending = 0; 438 } 439 440 if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) 441 iport->fabric.retry_counter++; 442 443 fabric_tov = jiffies + msecs_to_jiffies(timeout); 444 mod_timer(&iport->fabric.retry_timer, round_jiffies(fabric_tov)); 445 iport->fabric.timer_pending = 1; 446 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 447 "fabric timer is %d ", timeout); 448 } 449 450 static void 451 fdls_start_tport_timer(struct fnic_iport_s *iport, 452 struct fnic_tport_s *tport, int timeout) 453 { 454 u64 fabric_tov; 455 struct fnic *fnic = iport->fnic; 456 457 if (tport->timer_pending) { 458 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 459 "tport fcid 0x%x: Canceling disc timer\n", 460 tport->fcid); 461 fnic_del_tport_timer_sync(fnic, tport); 462 tport->timer_pending = 0; 463 } 464 465 if (!(tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) 466 tport->retry_counter++; 467 468 fabric_tov = jiffies + msecs_to_jiffies(timeout); 469 mod_timer(&tport->retry_timer, round_jiffies(fabric_tov)); 470 tport->timer_pending = 1; 471 } 472 473 void fdls_init_plogi_frame(uint8_t *frame, 474 struct fnic_iport_s *iport) 475 { 476 struct fc_std_flogi *pplogi; 477 uint8_t s_id[3]; 478 479 pplogi = (struct fc_std_flogi *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 480 *pplogi = (struct fc_std_flogi) { 481 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REQ, .fh_d_id = {0xFF, 0xFF, 0xFC}, 482 .fh_type = FC_TYPE_ELS, .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 483 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 484 .els = { 485 .fl_cmd = ELS_PLOGI, 486 .fl_csp = {.sp_hi_ver = FNIC_FC_PH_VER_HI, 487 .sp_lo_ver = FNIC_FC_PH_VER_LO, 488 .sp_bb_cred = cpu_to_be16(FNIC_FC_B2B_CREDIT), 489 .sp_features = cpu_to_be16(FC_SP_FT_CIRO), 490 .sp_bb_data = cpu_to_be16(FNIC_FC_B2B_RDF_SZ), 491 .sp_tot_seq = cpu_to_be16(FNIC_FC_CONCUR_SEQS), 492 .sp_rel_off = cpu_to_be16(FNIC_FC_RO_INFO), 493 .sp_e_d_tov = cpu_to_be32(FC_DEF_E_D_TOV)}, 494 .fl_cssp[2].cp_class = cpu_to_be16(FC_CPC_VALID | FC_CPC_SEQ), 495 .fl_cssp[2].cp_rdfs = cpu_to_be16(0x800), 496 .fl_cssp[2].cp_con_seq = cpu_to_be16(0xFF), 497 .fl_cssp[2].cp_open_seq = 1} 498 }; 499 500 FNIC_STD_SET_NPORT_NAME(&pplogi->els.fl_wwpn, iport->wwpn); 501 FNIC_STD_SET_NODE_NAME(&pplogi->els.fl_wwnn, iport->wwnn); 502 FNIC_LOGI_SET_RDF_SIZE(pplogi->els, iport->max_payload_size); 503 504 hton24(s_id, iport->fcid); 505 FNIC_STD_SET_S_ID(pplogi->fchdr, s_id); 506 } 507 508 static void fdls_init_els_acc_frame(uint8_t *frame, 509 struct fnic_iport_s *iport) 510 { 511 struct fc_std_els_acc_rsp *pels_acc; 512 uint8_t s_id[3]; 513 514 pels_acc = (struct fc_std_els_acc_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 515 *pels_acc = (struct fc_std_els_acc_rsp) { 516 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REP, 517 .fh_type = FC_TYPE_ELS, .fh_f_ctl = {FNIC_ELS_REP_FCTL, 0, 0}}, 518 .acc.la_cmd = ELS_LS_ACC, 519 }; 520 521 hton24(s_id, iport->fcid); 522 FNIC_STD_SET_S_ID(pels_acc->fchdr, s_id); 523 FNIC_STD_SET_RX_ID(pels_acc->fchdr, FNIC_UNASSIGNED_RXID); 524 } 525 526 static void fdls_init_els_rjt_frame(uint8_t *frame, 527 struct fnic_iport_s *iport) 528 { 529 struct fc_std_els_rjt_rsp *pels_rjt; 530 531 pels_rjt = (struct fc_std_els_rjt_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 532 *pels_rjt = (struct fc_std_els_rjt_rsp) { 533 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REP, .fh_type = FC_TYPE_ELS, 534 .fh_f_ctl = {FNIC_ELS_REP_FCTL, 0, 0}}, 535 .rej.er_cmd = ELS_LS_RJT, 536 }; 537 538 FNIC_STD_SET_RX_ID(pels_rjt->fchdr, FNIC_UNASSIGNED_RXID); 539 } 540 541 static void fdls_init_logo_frame(uint8_t *frame, 542 struct fnic_iport_s *iport) 543 { 544 struct fc_std_logo *plogo; 545 uint8_t s_id[3]; 546 547 plogo = (struct fc_std_logo *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 548 *plogo = (struct fc_std_logo) { 549 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REQ, .fh_type = FC_TYPE_ELS, 550 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}}, 551 .els.fl_cmd = ELS_LOGO, 552 }; 553 554 hton24(s_id, iport->fcid); 555 FNIC_STD_SET_S_ID(plogo->fchdr, s_id); 556 memcpy(plogo->els.fl_n_port_id, s_id, 3); 557 558 FNIC_STD_SET_NPORT_NAME(&plogo->els.fl_n_port_wwn, 559 iport->wwpn); 560 } 561 562 static void fdls_init_fabric_abts_frame(uint8_t *frame, 563 struct fnic_iport_s *iport) 564 { 565 struct fc_frame_header *pfabric_abts; 566 567 pfabric_abts = (struct fc_frame_header *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 568 *pfabric_abts = (struct fc_frame_header) { 569 .fh_r_ctl = FC_RCTL_BA_ABTS, /* ABTS */ 570 .fh_s_id = {0x00, 0x00, 0x00}, 571 .fh_cs_ctl = 0x00, .fh_type = FC_TYPE_BLS, 572 .fh_f_ctl = {FNIC_REQ_ABTS_FCTL, 0, 0}, .fh_seq_id = 0x00, 573 .fh_df_ctl = 0x00, .fh_seq_cnt = 0x0000, 574 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID), 575 .fh_parm_offset = 0x00000000, /* bit:0 = 0 Abort a exchange */ 576 }; 577 } 578 579 static void 580 fdls_send_rscn_resp(struct fnic_iport_s *iport, 581 struct fc_frame_header *rscn_fchdr) 582 { 583 uint8_t *frame; 584 struct fc_std_els_acc_rsp *pels_acc; 585 struct fnic *fnic = iport->fnic; 586 uint16_t oxid; 587 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 588 sizeof(struct fc_std_els_acc_rsp); 589 590 frame = fdls_alloc_frame(iport); 591 if (frame == NULL) { 592 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 593 "Failed to allocate frame to send RSCN response"); 594 return; 595 } 596 597 pels_acc = (struct fc_std_els_acc_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 598 fdls_init_els_acc_frame(frame, iport); 599 600 FNIC_STD_SET_D_ID(pels_acc->fchdr, rscn_fchdr->fh_s_id); 601 602 oxid = FNIC_STD_GET_OX_ID(rscn_fchdr); 603 FNIC_STD_SET_OX_ID(pels_acc->fchdr, oxid); 604 605 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 606 "0x%x: FDLS send RSCN response with oxid: 0x%x", 607 iport->fcid, oxid); 608 609 fnic_send_fcoe_frame(iport, frame, frame_size); 610 } 611 612 static void 613 fdls_send_logo_resp(struct fnic_iport_s *iport, 614 struct fc_frame_header *req_fchdr) 615 { 616 uint8_t *frame; 617 struct fc_std_els_acc_rsp *plogo_resp; 618 struct fnic *fnic = iport->fnic; 619 uint16_t oxid; 620 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 621 sizeof(struct fc_std_els_acc_rsp); 622 623 frame = fdls_alloc_frame(iport); 624 if (frame == NULL) { 625 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 626 "Failed to allocate frame to send LOGO response"); 627 return; 628 } 629 630 plogo_resp = (struct fc_std_els_acc_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 631 fdls_init_els_acc_frame(frame, iport); 632 633 FNIC_STD_SET_D_ID(plogo_resp->fchdr, req_fchdr->fh_s_id); 634 635 oxid = FNIC_STD_GET_OX_ID(req_fchdr); 636 FNIC_STD_SET_OX_ID(plogo_resp->fchdr, oxid); 637 638 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 639 "0x%x: FDLS send LOGO response with oxid: 0x%x", 640 iport->fcid, oxid); 641 642 fnic_send_fcoe_frame(iport, frame, frame_size); 643 } 644 645 void 646 fdls_send_tport_abts(struct fnic_iport_s *iport, 647 struct fnic_tport_s *tport) 648 { 649 uint8_t *frame; 650 uint8_t s_id[3]; 651 uint8_t d_id[3]; 652 struct fnic *fnic = iport->fnic; 653 struct fc_frame_header *ptport_abts; 654 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 655 sizeof(struct fc_frame_header); 656 657 frame = fdls_alloc_frame(iport); 658 if (frame == NULL) { 659 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 660 "Failed to allocate frame to send tport ABTS"); 661 return; 662 } 663 664 ptport_abts = (struct fc_frame_header *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 665 *ptport_abts = (struct fc_frame_header) { 666 .fh_r_ctl = FC_RCTL_BA_ABTS, /* ABTS */ 667 .fh_cs_ctl = 0x00, .fh_type = FC_TYPE_BLS, 668 .fh_f_ctl = {FNIC_REQ_ABTS_FCTL, 0, 0}, .fh_seq_id = 0x00, 669 .fh_df_ctl = 0x00, .fh_seq_cnt = 0x0000, 670 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID), 671 .fh_parm_offset = 0x00000000, /* bit:0 = 0 Abort a exchange */ 672 }; 673 674 hton24(s_id, iport->fcid); 675 hton24(d_id, tport->fcid); 676 FNIC_STD_SET_S_ID(*ptport_abts, s_id); 677 FNIC_STD_SET_D_ID(*ptport_abts, d_id); 678 tport->flags |= FNIC_FDLS_TGT_ABORT_ISSUED; 679 680 FNIC_STD_SET_OX_ID(*ptport_abts, tport->active_oxid); 681 682 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 683 "0x%x: FDLS send tport abts: tport->state: %d ", 684 iport->fcid, tport->state); 685 686 fnic_send_fcoe_frame(iport, frame, frame_size); 687 688 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 689 fdls_start_tport_timer(iport, tport, 2 * iport->e_d_tov); 690 } 691 static void fdls_send_fabric_abts(struct fnic_iport_s *iport) 692 { 693 uint8_t *frame; 694 uint8_t s_id[3]; 695 uint8_t d_id[3]; 696 struct fnic *fnic = iport->fnic; 697 struct fc_frame_header *pfabric_abts; 698 uint16_t oxid; 699 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 700 sizeof(struct fc_frame_header); 701 702 frame = fdls_alloc_frame(iport); 703 if (frame == NULL) { 704 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 705 "Failed to allocate frame to send fabric ABTS"); 706 return; 707 } 708 709 pfabric_abts = (struct fc_frame_header *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 710 fdls_init_fabric_abts_frame(frame, iport); 711 712 hton24(s_id, iport->fcid); 713 714 switch (iport->fabric.state) { 715 case FDLS_STATE_FABRIC_LOGO: 716 hton24(d_id, FC_FID_FLOGI); 717 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 718 break; 719 720 case FDLS_STATE_FABRIC_FLOGI: 721 hton24(d_id, FC_FID_FLOGI); 722 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 723 break; 724 725 case FDLS_STATE_FABRIC_PLOGI: 726 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 727 hton24(d_id, FC_FID_DIR_SERV); 728 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 729 break; 730 731 case FDLS_STATE_RPN_ID: 732 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 733 hton24(d_id, FC_FID_DIR_SERV); 734 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 735 break; 736 737 case FDLS_STATE_SCR: 738 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 739 hton24(d_id, FC_FID_FCTRL); 740 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 741 break; 742 743 case FDLS_STATE_REGISTER_FC4_TYPES: 744 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 745 hton24(d_id, FC_FID_DIR_SERV); 746 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 747 break; 748 749 case FDLS_STATE_REGISTER_FC4_FEATURES: 750 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 751 hton24(d_id, FC_FID_DIR_SERV); 752 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 753 break; 754 755 case FDLS_STATE_GPN_FT: 756 FNIC_STD_SET_S_ID(*pfabric_abts, s_id); 757 hton24(d_id, FC_FID_DIR_SERV); 758 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 759 break; 760 default: 761 return; 762 } 763 764 oxid = iport->active_oxid_fabric_req; 765 FNIC_STD_SET_OX_ID(*pfabric_abts, oxid); 766 767 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 768 "0x%x: FDLS send fabric abts. iport->fabric.state: %d oxid: 0x%x", 769 iport->fcid, iport->fabric.state, oxid); 770 771 iport->fabric.flags |= FNIC_FDLS_FABRIC_ABORT_ISSUED; 772 773 fnic_send_fcoe_frame(iport, frame, frame_size); 774 775 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 776 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 777 iport->fabric.timer_pending = 1; 778 } 779 780 static void fdls_send_fdmi_abts(struct fnic_iport_s *iport) 781 { 782 uint8_t *frame; 783 uint8_t d_id[3]; 784 struct fnic *fnic = iport->fnic; 785 struct fc_frame_header *pfabric_abts; 786 unsigned long fdmi_tov; 787 uint16_t oxid; 788 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 789 sizeof(struct fc_frame_header); 790 791 frame = fdls_alloc_frame(iport); 792 if (frame == NULL) { 793 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 794 "Failed to allocate frame to send FDMI ABTS"); 795 return; 796 } 797 798 pfabric_abts = (struct fc_frame_header *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 799 fdls_init_fabric_abts_frame(frame, iport); 800 801 hton24(d_id, FC_FID_MGMT_SERV); 802 FNIC_STD_SET_D_ID(*pfabric_abts, d_id); 803 804 if (iport->fabric.fdmi_pending & FDLS_FDMI_PLOGI_PENDING) { 805 oxid = iport->active_oxid_fdmi_plogi; 806 FNIC_STD_SET_OX_ID(*pfabric_abts, oxid); 807 fnic_send_fcoe_frame(iport, frame, frame_size); 808 } else { 809 if (iport->fabric.fdmi_pending & FDLS_FDMI_REG_HBA_PENDING) { 810 oxid = iport->active_oxid_fdmi_rhba; 811 FNIC_STD_SET_OX_ID(*pfabric_abts, oxid); 812 fnic_send_fcoe_frame(iport, frame, frame_size); 813 } 814 if (iport->fabric.fdmi_pending & FDLS_FDMI_RPA_PENDING) { 815 oxid = iport->active_oxid_fdmi_rpa; 816 FNIC_STD_SET_OX_ID(*pfabric_abts, oxid); 817 fnic_send_fcoe_frame(iport, frame, frame_size); 818 } 819 } 820 821 fdmi_tov = jiffies + msecs_to_jiffies(2 * iport->e_d_tov); 822 mod_timer(&iport->fabric.fdmi_timer, round_jiffies(fdmi_tov)); 823 iport->fabric.fdmi_pending |= FDLS_FDMI_ABORT_PENDING; 824 } 825 826 static void fdls_send_fabric_flogi(struct fnic_iport_s *iport) 827 { 828 uint8_t *frame; 829 struct fc_std_flogi *pflogi; 830 struct fnic *fnic = iport->fnic; 831 uint16_t oxid; 832 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 833 sizeof(struct fc_std_flogi); 834 835 frame = fdls_alloc_frame(iport); 836 if (frame == NULL) { 837 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 838 "Failed to allocate frame to send FLOGI"); 839 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 840 goto err_out; 841 } 842 843 pflogi = (struct fc_std_flogi *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 844 *pflogi = (struct fc_std_flogi) { 845 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REQ, .fh_d_id = {0xFF, 0xFF, 0xFE}, 846 .fh_type = FC_TYPE_ELS, .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 847 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 848 .els.fl_cmd = ELS_FLOGI, 849 .els.fl_csp = {.sp_hi_ver = FNIC_FC_PH_VER_HI, 850 .sp_lo_ver = FNIC_FC_PH_VER_LO, 851 .sp_bb_cred = cpu_to_be16(FNIC_FC_B2B_CREDIT), 852 .sp_bb_data = cpu_to_be16(FNIC_FC_B2B_RDF_SZ)}, 853 .els.fl_cssp[2].cp_class = cpu_to_be16(FC_CPC_VALID | FC_CPC_SEQ) 854 }; 855 856 FNIC_STD_SET_NPORT_NAME(&pflogi->els.fl_wwpn, iport->wwpn); 857 FNIC_STD_SET_NODE_NAME(&pflogi->els.fl_wwnn, iport->wwnn); 858 FNIC_LOGI_SET_RDF_SIZE(pflogi->els, iport->max_payload_size); 859 FNIC_LOGI_SET_R_A_TOV(pflogi->els, iport->r_a_tov); 860 FNIC_LOGI_SET_E_D_TOV(pflogi->els, iport->e_d_tov); 861 862 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_FLOGI, 863 &iport->active_oxid_fabric_req); 864 865 if (oxid == FNIC_UNASSIGNED_OXID) { 866 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 867 "0x%x: Failed to allocate OXID to send FLOGI", 868 iport->fcid); 869 mempool_free(frame, fnic->frame_pool); 870 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 871 goto err_out; 872 } 873 FNIC_STD_SET_OX_ID(pflogi->fchdr, oxid); 874 875 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 876 "0x%x: FDLS send fabric FLOGI with oxid: 0x%x", iport->fcid, 877 oxid); 878 879 fnic_send_fcoe_frame(iport, frame, frame_size); 880 atomic64_inc(&iport->iport_stats.fabric_flogi_sent); 881 err_out: 882 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 883 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 884 } 885 886 static void fdls_send_fabric_plogi(struct fnic_iport_s *iport) 887 { 888 uint8_t *frame; 889 struct fc_std_flogi *pplogi; 890 struct fnic *fnic = iport->fnic; 891 uint16_t oxid; 892 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 893 sizeof(struct fc_std_flogi); 894 895 frame = fdls_alloc_frame(iport); 896 if (frame == NULL) { 897 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 898 "Failed to allocate frame to send PLOGI"); 899 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 900 goto err_out; 901 } 902 903 pplogi = (struct fc_std_flogi *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 904 fdls_init_plogi_frame(frame, iport); 905 906 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_PLOGI, 907 &iport->active_oxid_fabric_req); 908 if (oxid == FNIC_UNASSIGNED_OXID) { 909 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 910 "0x%x: Failed to allocate OXID to send fabric PLOGI", 911 iport->fcid); 912 mempool_free(frame, fnic->frame_pool); 913 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 914 goto err_out; 915 } 916 FNIC_STD_SET_OX_ID(pplogi->fchdr, oxid); 917 918 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 919 "0x%x: FDLS send fabric PLOGI with oxid: 0x%x", iport->fcid, 920 oxid); 921 922 fnic_send_fcoe_frame(iport, frame, frame_size); 923 atomic64_inc(&iport->iport_stats.fabric_plogi_sent); 924 925 err_out: 926 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 927 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 928 } 929 930 static void fdls_send_fdmi_plogi(struct fnic_iport_s *iport) 931 { 932 uint8_t *frame; 933 struct fc_std_flogi *pplogi; 934 struct fnic *fnic = iport->fnic; 935 uint16_t oxid; 936 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 937 sizeof(struct fc_std_flogi); 938 uint8_t d_id[3]; 939 u64 fdmi_tov; 940 941 frame = fdls_alloc_frame(iport); 942 if (frame == NULL) { 943 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 944 "Failed to allocate frame to send FDMI PLOGI"); 945 goto err_out; 946 } 947 948 pplogi = (struct fc_std_flogi *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 949 fdls_init_plogi_frame(frame, iport); 950 951 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FDMI_PLOGI, 952 &iport->active_oxid_fdmi_plogi); 953 954 if (oxid == FNIC_UNASSIGNED_OXID) { 955 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 956 "0x%x: Failed to allocate OXID to send FDMI PLOGI", 957 iport->fcid); 958 mempool_free(frame, fnic->frame_pool); 959 goto err_out; 960 } 961 FNIC_STD_SET_OX_ID(pplogi->fchdr, oxid); 962 963 hton24(d_id, FC_FID_MGMT_SERV); 964 FNIC_STD_SET_D_ID(pplogi->fchdr, d_id); 965 966 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 967 "0x%x: FDLS send FDMI PLOGI with oxid: 0x%x", 968 iport->fcid, oxid); 969 970 fnic_send_fcoe_frame(iport, frame, frame_size); 971 972 err_out: 973 fdmi_tov = jiffies + msecs_to_jiffies(2 * iport->e_d_tov); 974 mod_timer(&iport->fabric.fdmi_timer, round_jiffies(fdmi_tov)); 975 iport->fabric.fdmi_pending = FDLS_FDMI_PLOGI_PENDING; 976 } 977 978 static void fdls_send_rpn_id(struct fnic_iport_s *iport) 979 { 980 uint8_t *frame; 981 struct fc_std_rpn_id *prpn_id; 982 struct fnic *fnic = iport->fnic; 983 uint16_t oxid; 984 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 985 sizeof(struct fc_std_rpn_id); 986 uint8_t fcid[3]; 987 988 frame = fdls_alloc_frame(iport); 989 if (frame == NULL) { 990 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 991 "Failed to allocate frame to send RPN_ID"); 992 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 993 goto err_out; 994 } 995 996 prpn_id = (struct fc_std_rpn_id *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 997 *prpn_id = (struct fc_std_rpn_id) { 998 .fchdr = {.fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 999 .fh_d_id = {0xFF, 0xFF, 0xFC}, .fh_type = FC_TYPE_CT, 1000 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1001 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1002 .fc_std_ct_hdr = {.ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_DIR, 1003 .ct_fs_subtype = FC_NS_SUBTYPE, 1004 .ct_cmd = cpu_to_be16(FC_NS_RPN_ID)} 1005 }; 1006 1007 hton24(fcid, iport->fcid); 1008 FNIC_STD_SET_S_ID(prpn_id->fchdr, fcid); 1009 1010 FNIC_STD_SET_PORT_ID(prpn_id->rpn_id, fcid); 1011 FNIC_STD_SET_PORT_NAME(prpn_id->rpn_id, iport->wwpn); 1012 1013 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_RPN, 1014 &iport->active_oxid_fabric_req); 1015 1016 if (oxid == FNIC_UNASSIGNED_OXID) { 1017 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1018 "0x%x: Failed to allocate OXID to send RPN_ID", 1019 iport->fcid); 1020 mempool_free(frame, fnic->frame_pool); 1021 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 1022 goto err_out; 1023 } 1024 FNIC_STD_SET_OX_ID(prpn_id->fchdr, oxid); 1025 1026 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1027 "0x%x: FDLS send RPN ID with oxid: 0x%x", iport->fcid, 1028 oxid); 1029 1030 fnic_send_fcoe_frame(iport, frame, frame_size); 1031 1032 err_out: 1033 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1034 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1035 } 1036 1037 static void fdls_send_scr(struct fnic_iport_s *iport) 1038 { 1039 uint8_t *frame; 1040 struct fc_std_scr *pscr; 1041 struct fnic *fnic = iport->fnic; 1042 uint16_t oxid; 1043 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1044 sizeof(struct fc_std_scr); 1045 uint8_t fcid[3]; 1046 1047 frame = fdls_alloc_frame(iport); 1048 if (frame == NULL) { 1049 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1050 "Failed to allocate frame to send SCR"); 1051 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 1052 goto err_out; 1053 } 1054 1055 pscr = (struct fc_std_scr *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1056 *pscr = (struct fc_std_scr) { 1057 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REQ, 1058 .fh_d_id = {0xFF, 0xFF, 0xFD}, .fh_type = FC_TYPE_ELS, 1059 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1060 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1061 .scr = {.scr_cmd = ELS_SCR, 1062 .scr_reg_func = ELS_SCRF_FULL} 1063 }; 1064 1065 hton24(fcid, iport->fcid); 1066 FNIC_STD_SET_S_ID(pscr->fchdr, fcid); 1067 1068 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_SCR, 1069 &iport->active_oxid_fabric_req); 1070 if (oxid == FNIC_UNASSIGNED_OXID) { 1071 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1072 "0x%x: Failed to allocate OXID to send SCR", 1073 iport->fcid); 1074 mempool_free(frame, fnic->frame_pool); 1075 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 1076 goto err_out; 1077 } 1078 FNIC_STD_SET_OX_ID(pscr->fchdr, oxid); 1079 1080 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1081 "0x%x: FDLS send SCR with oxid: 0x%x", iport->fcid, 1082 oxid); 1083 1084 fnic_send_fcoe_frame(iport, frame, frame_size); 1085 atomic64_inc(&iport->iport_stats.fabric_scr_sent); 1086 1087 err_out: 1088 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1089 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1090 } 1091 1092 static void fdls_send_gpn_ft(struct fnic_iport_s *iport, int fdls_state) 1093 { 1094 uint8_t *frame; 1095 struct fc_std_gpn_ft *pgpn_ft; 1096 struct fnic *fnic = iport->fnic; 1097 uint16_t oxid; 1098 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1099 sizeof(struct fc_std_gpn_ft); 1100 uint8_t fcid[3]; 1101 1102 frame = fdls_alloc_frame(iport); 1103 if (frame == NULL) { 1104 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1105 "Failed to allocate frame to send GPN FT"); 1106 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 1107 goto err_out; 1108 } 1109 1110 pgpn_ft = (struct fc_std_gpn_ft *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1111 *pgpn_ft = (struct fc_std_gpn_ft) { 1112 .fchdr = {.fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 1113 .fh_d_id = {0xFF, 0xFF, 0xFC}, .fh_type = FC_TYPE_CT, 1114 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1115 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1116 .fc_std_ct_hdr = {.ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_DIR, 1117 .ct_fs_subtype = FC_NS_SUBTYPE, 1118 .ct_cmd = cpu_to_be16(FC_NS_GPN_FT)}, 1119 .gpn_ft.fn_fc4_type = 0x08 1120 }; 1121 1122 hton24(fcid, iport->fcid); 1123 FNIC_STD_SET_S_ID(pgpn_ft->fchdr, fcid); 1124 1125 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_GPN_FT, 1126 &iport->active_oxid_fabric_req); 1127 1128 if (oxid == FNIC_UNASSIGNED_OXID) { 1129 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1130 "0x%x: Failed to allocate OXID to send GPN FT", 1131 iport->fcid); 1132 mempool_free(frame, fnic->frame_pool); 1133 iport->fabric.flags |= FNIC_FDLS_RETRY_FRAME; 1134 goto err_out; 1135 } 1136 FNIC_STD_SET_OX_ID(pgpn_ft->fchdr, oxid); 1137 1138 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1139 "0x%x: FDLS send GPN FT with oxid: 0x%x", iport->fcid, 1140 oxid); 1141 1142 fnic_send_fcoe_frame(iport, frame, frame_size); 1143 1144 err_out: 1145 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1146 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1147 fdls_set_state((&iport->fabric), fdls_state); 1148 } 1149 1150 static void 1151 fdls_send_tgt_adisc(struct fnic_iport_s *iport, struct fnic_tport_s *tport) 1152 { 1153 uint8_t *frame; 1154 struct fc_std_els_adisc *padisc; 1155 uint8_t s_id[3]; 1156 uint8_t d_id[3]; 1157 uint16_t oxid; 1158 struct fnic *fnic = iport->fnic; 1159 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1160 sizeof(struct fc_std_els_adisc); 1161 1162 frame = fdls_alloc_frame(iport); 1163 if (frame == NULL) { 1164 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1165 "Failed to allocate frame to send TGT ADISC"); 1166 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1167 goto err_out; 1168 } 1169 1170 padisc = (struct fc_std_els_adisc *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1171 1172 hton24(s_id, iport->fcid); 1173 hton24(d_id, tport->fcid); 1174 memcpy(padisc->els.adisc_port_id, s_id, 3); 1175 FNIC_STD_SET_S_ID(padisc->fchdr, s_id); 1176 FNIC_STD_SET_D_ID(padisc->fchdr, d_id); 1177 1178 FNIC_STD_SET_F_CTL(padisc->fchdr, FNIC_ELS_REQ_FCTL << 16); 1179 FNIC_STD_SET_R_CTL(padisc->fchdr, FC_RCTL_ELS_REQ); 1180 FNIC_STD_SET_TYPE(padisc->fchdr, FC_TYPE_ELS); 1181 1182 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_TGT_ADISC, &tport->active_oxid); 1183 if (oxid == FNIC_UNASSIGNED_OXID) { 1184 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1185 "0x%x: Failed to allocate OXID to send TGT ADISC", 1186 iport->fcid); 1187 mempool_free(frame, fnic->frame_pool); 1188 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1189 goto err_out; 1190 } 1191 FNIC_STD_SET_OX_ID(padisc->fchdr, oxid); 1192 FNIC_STD_SET_RX_ID(padisc->fchdr, FNIC_UNASSIGNED_RXID); 1193 1194 tport->flags &= ~FNIC_FDLS_TGT_ABORT_ISSUED; 1195 1196 FNIC_STD_SET_NPORT_NAME(&padisc->els.adisc_wwpn, 1197 iport->wwpn); 1198 FNIC_STD_SET_NODE_NAME(&padisc->els.adisc_wwnn, 1199 iport->wwnn); 1200 1201 padisc->els.adisc_cmd = ELS_ADISC; 1202 1203 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1204 "0x%x: FDLS send ADISC to tgt fcid: 0x%x", 1205 iport->fcid, tport->fcid); 1206 1207 atomic64_inc(&iport->iport_stats.tport_adisc_sent); 1208 1209 fnic_send_fcoe_frame(iport, frame, frame_size); 1210 1211 err_out: 1212 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1213 fdls_start_tport_timer(iport, tport, 2 * iport->e_d_tov); 1214 } 1215 1216 bool fdls_delete_tport(struct fnic_iport_s *iport, struct fnic_tport_s *tport) 1217 { 1218 struct fnic_tport_event_s *tport_del_evt; 1219 struct fnic *fnic = iport->fnic; 1220 1221 if ((tport->state == FDLS_TGT_STATE_OFFLINING) 1222 || (tport->state == FDLS_TGT_STATE_OFFLINE)) { 1223 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1224 "tport fcid 0x%x: tport state is offlining/offline\n", 1225 tport->fcid); 1226 return false; 1227 } 1228 1229 fdls_set_tport_state(tport, FDLS_TGT_STATE_OFFLINING); 1230 /* 1231 * By setting this flag, the tport will not be seen in a look-up 1232 * in an RSCN. Even if we move to multithreaded model, this tport 1233 * will be destroyed and a new RSCN will have to create a new one 1234 */ 1235 tport->flags |= FNIC_FDLS_TPORT_TERMINATING; 1236 1237 if (tport->timer_pending) { 1238 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1239 "tport fcid 0x%x: Canceling disc timer\n", 1240 tport->fcid); 1241 fnic_del_tport_timer_sync(fnic, tport); 1242 tport->timer_pending = 0; 1243 } 1244 1245 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 1246 fnic_rport_exch_reset(iport->fnic, tport->fcid); 1247 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 1248 1249 if (tport->flags & FNIC_FDLS_SCSI_REGISTERED) { 1250 tport_del_evt = 1251 kzalloc(sizeof(struct fnic_tport_event_s), GFP_ATOMIC); 1252 if (!tport_del_evt) { 1253 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1254 "Failed to allocate memory for tport fcid: 0x%0x\n", 1255 tport->fcid); 1256 return false; 1257 } 1258 tport_del_evt->event = TGT_EV_RPORT_DEL; 1259 tport_del_evt->arg1 = (void *) tport; 1260 list_add_tail(&tport_del_evt->links, &fnic->tport_event_list); 1261 queue_work(fnic_event_queue, &fnic->tport_work); 1262 } else { 1263 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1264 "tport 0x%x not reg with scsi_transport. Freeing locally", 1265 tport->fcid); 1266 list_del(&tport->links); 1267 kfree(tport); 1268 } 1269 return true; 1270 } 1271 1272 static void 1273 fdls_send_tgt_plogi(struct fnic_iport_s *iport, struct fnic_tport_s *tport) 1274 { 1275 uint8_t *frame; 1276 struct fc_std_flogi *pplogi; 1277 struct fnic *fnic = iport->fnic; 1278 uint16_t oxid; 1279 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1280 sizeof(struct fc_std_flogi); 1281 uint8_t d_id[3]; 1282 uint32_t timeout; 1283 1284 frame = fdls_alloc_frame(iport); 1285 if (frame == NULL) { 1286 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1287 "Failed to allocate frame to send TGT PLOGI"); 1288 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1289 goto err_out; 1290 } 1291 1292 pplogi = (struct fc_std_flogi *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1293 fdls_init_plogi_frame(frame, iport); 1294 1295 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_TGT_PLOGI, &tport->active_oxid); 1296 if (oxid == FNIC_UNASSIGNED_OXID) { 1297 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1298 "0x%x: Failed to allocate oxid to send PLOGI to fcid: 0x%x", 1299 iport->fcid, tport->fcid); 1300 mempool_free(frame, fnic->frame_pool); 1301 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1302 goto err_out; 1303 } 1304 FNIC_STD_SET_OX_ID(pplogi->fchdr, oxid); 1305 1306 tport->flags &= ~FNIC_FDLS_TGT_ABORT_ISSUED; 1307 1308 hton24(d_id, tport->fcid); 1309 FNIC_STD_SET_D_ID(pplogi->fchdr, d_id); 1310 1311 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1312 "0x%x: FDLS send tgt PLOGI to tgt: 0x%x with oxid: 0x%x", 1313 iport->fcid, tport->fcid, oxid); 1314 1315 fnic_send_fcoe_frame(iport, frame, frame_size); 1316 atomic64_inc(&iport->iport_stats.tport_plogi_sent); 1317 1318 err_out: 1319 timeout = max(2 * iport->e_d_tov, iport->plogi_timeout); 1320 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1321 fdls_start_tport_timer(iport, tport, timeout); 1322 } 1323 1324 static uint16_t 1325 fnic_fc_plogi_rsp_rdf(struct fnic_iport_s *iport, 1326 struct fc_std_flogi *plogi_rsp) 1327 { 1328 uint16_t b2b_rdf_size = 1329 be16_to_cpu(FNIC_LOGI_RDF_SIZE(plogi_rsp->els)); 1330 uint16_t spc3_rdf_size = 1331 be16_to_cpu(plogi_rsp->els.fl_cssp[2].cp_rdfs) & FNIC_FC_C3_RDF; 1332 struct fnic *fnic = iport->fnic; 1333 1334 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1335 "MFS: b2b_rdf_size: 0x%x spc3_rdf_size: 0x%x", 1336 b2b_rdf_size, spc3_rdf_size); 1337 1338 return min(b2b_rdf_size, spc3_rdf_size); 1339 } 1340 1341 static void fdls_send_register_fc4_types(struct fnic_iport_s *iport) 1342 { 1343 uint8_t *frame; 1344 struct fc_std_rft_id *prft_id; 1345 struct fnic *fnic = iport->fnic; 1346 uint16_t oxid; 1347 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1348 sizeof(struct fc_std_rft_id); 1349 uint8_t fcid[3]; 1350 1351 frame = fdls_alloc_frame(iport); 1352 if (frame == NULL) { 1353 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1354 "Failed to allocate frame to send RFT"); 1355 return; 1356 } 1357 1358 prft_id = (struct fc_std_rft_id *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1359 *prft_id = (struct fc_std_rft_id) { 1360 .fchdr = {.fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 1361 .fh_d_id = {0xFF, 0xFF, 0xFC}, .fh_type = FC_TYPE_CT, 1362 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1363 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1364 .fc_std_ct_hdr = {.ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_DIR, 1365 .ct_fs_subtype = FC_NS_SUBTYPE, 1366 .ct_cmd = cpu_to_be16(FC_NS_RFT_ID)} 1367 }; 1368 1369 hton24(fcid, iport->fcid); 1370 FNIC_STD_SET_S_ID(prft_id->fchdr, fcid); 1371 FNIC_STD_SET_PORT_ID(prft_id->rft_id, fcid); 1372 1373 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_RFT, 1374 &iport->active_oxid_fabric_req); 1375 1376 if (oxid == FNIC_UNASSIGNED_OXID) { 1377 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1378 "0x%x: Failed to allocate OXID to send RFT", 1379 iport->fcid); 1380 mempool_free(frame, fnic->frame_pool); 1381 return; 1382 } 1383 FNIC_STD_SET_OX_ID(prft_id->fchdr, oxid); 1384 1385 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1386 "0x%x: FDLS send RFT with oxid: 0x%x", iport->fcid, 1387 oxid); 1388 1389 prft_id->rft_id.fr_fts.ff_type_map[0] = 1390 cpu_to_be32(1 << FC_TYPE_FCP); 1391 1392 prft_id->rft_id.fr_fts.ff_type_map[1] = 1393 cpu_to_be32(1 << (FC_TYPE_CT % FC_NS_BPW)); 1394 1395 fnic_send_fcoe_frame(iport, frame, frame_size); 1396 1397 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1398 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1399 } 1400 1401 static void fdls_send_register_fc4_features(struct fnic_iport_s *iport) 1402 { 1403 uint8_t *frame; 1404 struct fc_std_rff_id *prff_id; 1405 struct fnic *fnic = iport->fnic; 1406 uint16_t oxid; 1407 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1408 sizeof(struct fc_std_rff_id); 1409 uint8_t fcid[3]; 1410 1411 frame = fdls_alloc_frame(iport); 1412 if (frame == NULL) { 1413 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1414 "Failed to allocate frame to send RFF"); 1415 return; 1416 } 1417 1418 prff_id = (struct fc_std_rff_id *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1419 *prff_id = (struct fc_std_rff_id) { 1420 .fchdr = {.fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 1421 .fh_d_id = {0xFF, 0xFF, 0xFC}, .fh_type = FC_TYPE_CT, 1422 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1423 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1424 .fc_std_ct_hdr = {.ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_DIR, 1425 .ct_fs_subtype = FC_NS_SUBTYPE, 1426 .ct_cmd = cpu_to_be16(FC_NS_RFF_ID)}, 1427 .rff_id.fr_feat = 0x2, 1428 .rff_id.fr_type = FC_TYPE_FCP 1429 }; 1430 1431 hton24(fcid, iport->fcid); 1432 FNIC_STD_SET_S_ID(prff_id->fchdr, fcid); 1433 FNIC_STD_SET_PORT_ID(prff_id->rff_id, fcid); 1434 1435 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_RFF, 1436 &iport->active_oxid_fabric_req); 1437 1438 if (oxid == FNIC_UNASSIGNED_OXID) { 1439 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1440 "0x%x: Failed to allocate OXID to send RFF", 1441 iport->fcid); 1442 mempool_free(frame, fnic->frame_pool); 1443 return; 1444 } 1445 FNIC_STD_SET_OX_ID(prff_id->fchdr, oxid); 1446 1447 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1448 "0x%x: FDLS send RFF with oxid: 0x%x", iport->fcid, 1449 oxid); 1450 1451 prff_id->rff_id.fr_type = FC_TYPE_FCP; 1452 1453 fnic_send_fcoe_frame(iport, frame, frame_size); 1454 1455 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1456 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1457 } 1458 1459 static void 1460 fdls_send_tgt_prli(struct fnic_iport_s *iport, struct fnic_tport_s *tport) 1461 { 1462 uint8_t *frame; 1463 struct fc_std_els_prli *pprli; 1464 struct fnic *fnic = iport->fnic; 1465 uint16_t oxid; 1466 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1467 sizeof(struct fc_std_els_prli); 1468 uint8_t s_id[3]; 1469 uint8_t d_id[3]; 1470 uint32_t timeout; 1471 1472 frame = fdls_alloc_frame(iport); 1473 if (frame == NULL) { 1474 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1475 "Failed to allocate frame to send TGT PRLI"); 1476 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1477 goto err_out; 1478 } 1479 1480 pprli = (struct fc_std_els_prli *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1481 *pprli = (struct fc_std_els_prli) { 1482 .fchdr = {.fh_r_ctl = FC_RCTL_ELS_REQ, .fh_type = FC_TYPE_ELS, 1483 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1484 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID)}, 1485 .els_prli = {.prli_cmd = ELS_PRLI, 1486 .prli_spp_len = 16, 1487 .prli_len = cpu_to_be16(0x14)}, 1488 .sp = {.spp_type = 0x08, .spp_flags = 0x0020, 1489 .spp_params = cpu_to_be32(0xA2)} 1490 }; 1491 1492 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_TGT_PRLI, &tport->active_oxid); 1493 if (oxid == FNIC_UNASSIGNED_OXID) { 1494 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1495 "0x%x: Failed to allocate OXID to send TGT PRLI to 0x%x", 1496 iport->fcid, tport->fcid); 1497 mempool_free(frame, fnic->frame_pool); 1498 tport->flags |= FNIC_FDLS_RETRY_FRAME; 1499 goto err_out; 1500 } 1501 1502 tport->flags &= ~FNIC_FDLS_TGT_ABORT_ISSUED; 1503 1504 hton24(s_id, iport->fcid); 1505 hton24(d_id, tport->fcid); 1506 1507 FNIC_STD_SET_OX_ID(pprli->fchdr, oxid); 1508 FNIC_STD_SET_S_ID(pprli->fchdr, s_id); 1509 FNIC_STD_SET_D_ID(pprli->fchdr, d_id); 1510 1511 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1512 "0x%x: FDLS send PRLI to tgt: 0x%x with oxid: 0x%x", 1513 iport->fcid, tport->fcid, oxid); 1514 1515 fnic_send_fcoe_frame(iport, frame, frame_size); 1516 atomic64_inc(&iport->iport_stats.tport_prli_sent); 1517 1518 err_out: 1519 timeout = max(2 * iport->e_d_tov, iport->plogi_timeout); 1520 /* Even if fnic_send_fcoe_frame() fails we want to retry after timeout */ 1521 fdls_start_tport_timer(iport, tport, timeout); 1522 } 1523 1524 /** 1525 * fdls_send_fabric_logo - Send flogo to the fcf 1526 * @iport: Handle to fnic iport 1527 * 1528 * This function does not change or check the fabric state. 1529 * It the caller's responsibility to set the appropriate iport fabric 1530 * state when this is called. Normally it is FDLS_STATE_FABRIC_LOGO. 1531 * Currently this assumes to be called with fnic lock held. 1532 */ 1533 void fdls_send_fabric_logo(struct fnic_iport_s *iport) 1534 { 1535 uint8_t *frame; 1536 struct fc_std_logo *plogo; 1537 struct fnic *fnic = iport->fnic; 1538 uint8_t d_id[3]; 1539 uint16_t oxid; 1540 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1541 sizeof(struct fc_std_logo); 1542 1543 frame = fdls_alloc_frame(iport); 1544 if (frame == NULL) { 1545 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1546 "Failed to allocate frame to send fabric LOGO"); 1547 return; 1548 } 1549 1550 plogo = (struct fc_std_logo *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1551 fdls_init_logo_frame(frame, iport); 1552 1553 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FABRIC_LOGO, 1554 &iport->active_oxid_fabric_req); 1555 1556 if (oxid == FNIC_UNASSIGNED_OXID) { 1557 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1558 "0x%x: Failed to allocate OXID to send fabric LOGO", 1559 iport->fcid); 1560 mempool_free(frame, fnic->frame_pool); 1561 return; 1562 } 1563 FNIC_STD_SET_OX_ID(plogo->fchdr, oxid); 1564 1565 hton24(d_id, FC_FID_FLOGI); 1566 FNIC_STD_SET_D_ID(plogo->fchdr, d_id); 1567 1568 iport->fabric.flags &= ~FNIC_FDLS_FABRIC_ABORT_ISSUED; 1569 1570 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1571 "0x%x: FDLS send fabric LOGO with oxid: 0x%x", 1572 iport->fcid, oxid); 1573 1574 fnic_send_fcoe_frame(iport, frame, frame_size); 1575 1576 fdls_start_fabric_timer(iport, 2 * iport->e_d_tov); 1577 } 1578 1579 /** 1580 * fdls_tgt_logout - Send plogo to the remote port 1581 * @iport: Handle to fnic iport 1582 * @tport: Handle to remote port 1583 * 1584 * This function does not change or check the fabric/tport state. 1585 * It the caller's responsibility to set the appropriate tport/fabric 1586 * state when this is called. Normally that is fdls_tgt_state_plogo. 1587 * This could be used to send plogo to nameserver process 1588 * also not just target processes 1589 */ 1590 void fdls_tgt_logout(struct fnic_iport_s *iport, struct fnic_tport_s *tport) 1591 { 1592 uint8_t *frame; 1593 struct fc_std_logo *plogo; 1594 struct fnic *fnic = iport->fnic; 1595 uint8_t d_id[3]; 1596 uint16_t oxid; 1597 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 1598 sizeof(struct fc_std_logo); 1599 1600 frame = fdls_alloc_frame(iport); 1601 if (frame == NULL) { 1602 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1603 "Failed to allocate frame to send fabric LOGO"); 1604 return; 1605 } 1606 1607 plogo = (struct fc_std_logo *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1608 fdls_init_logo_frame(frame, iport); 1609 1610 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_TGT_LOGO, &tport->active_oxid); 1611 if (oxid == FNIC_UNASSIGNED_OXID) { 1612 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1613 "0x%x: Failed to allocate OXID to send tgt LOGO", 1614 iport->fcid); 1615 mempool_free(frame, fnic->frame_pool); 1616 return; 1617 } 1618 FNIC_STD_SET_OX_ID(plogo->fchdr, oxid); 1619 1620 hton24(d_id, tport->fcid); 1621 FNIC_STD_SET_D_ID(plogo->fchdr, d_id); 1622 1623 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1624 "0x%x: FDLS send tgt LOGO with oxid: 0x%x", 1625 iport->fcid, oxid); 1626 1627 fnic_send_fcoe_frame(iport, frame, frame_size); 1628 1629 atomic64_inc(&iport->iport_stats.tport_logo_sent); 1630 } 1631 1632 static void fdls_tgt_discovery_start(struct fnic_iport_s *iport) 1633 { 1634 struct fnic_tport_s *tport, *next; 1635 u32 old_link_down_cnt = iport->fnic->link_down_cnt; 1636 struct fnic *fnic = iport->fnic; 1637 1638 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1639 "0x%x: Starting FDLS target discovery", iport->fcid); 1640 1641 list_for_each_entry_safe(tport, next, &iport->tport_list, links) { 1642 if ((old_link_down_cnt != iport->fnic->link_down_cnt) 1643 || (iport->state != FNIC_IPORT_STATE_READY)) { 1644 break; 1645 } 1646 /* if we marked the tport as deleted due to GPN_FT 1647 * We should not send ADISC anymore 1648 */ 1649 if ((tport->state == FDLS_TGT_STATE_OFFLINING) || 1650 (tport->state == FDLS_TGT_STATE_OFFLINE)) 1651 continue; 1652 1653 /* For tports which have received RSCN */ 1654 if (tport->flags & FNIC_FDLS_TPORT_SEND_ADISC) { 1655 tport->retry_counter = 0; 1656 fdls_set_tport_state(tport, FDLS_TGT_STATE_ADISC); 1657 tport->flags &= ~FNIC_FDLS_TPORT_SEND_ADISC; 1658 fdls_send_tgt_adisc(iport, tport); 1659 continue; 1660 } 1661 if (fdls_get_tport_state(tport) != FDLS_TGT_STATE_INIT) { 1662 /* Not a new port, skip */ 1663 continue; 1664 } 1665 tport->retry_counter = 0; 1666 fdls_set_tport_state(tport, FDLS_TGT_STATE_PLOGI); 1667 fdls_send_tgt_plogi(iport, tport); 1668 } 1669 fdls_set_state((&iport->fabric), FDLS_STATE_TGT_DISCOVERY); 1670 } 1671 1672 /* 1673 * Function to restart the IT nexus if we received any out of 1674 * sequence PLOGI/PRLI response from the target. 1675 * The memory for the new tport structure is allocated 1676 * inside fdls_create_tport and added to the iport's tport list. 1677 * This will get freed later during tport_offline/linkdown 1678 * or module unload. The new_tport pointer will go out of scope 1679 * safely since the memory it is 1680 * pointing to it will be freed later 1681 */ 1682 static void fdls_target_restart_nexus(struct fnic_tport_s *tport) 1683 { 1684 struct fnic_iport_s *iport = tport->iport; 1685 struct fnic_tport_s *new_tport = NULL; 1686 uint32_t fcid; 1687 uint64_t wwpn; 1688 int nexus_restart_count; 1689 struct fnic *fnic = iport->fnic; 1690 bool retval = true; 1691 1692 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1693 "tport fcid: 0x%x state: %d restart_count: %d", 1694 tport->fcid, tport->state, tport->nexus_restart_count); 1695 1696 fcid = tport->fcid; 1697 wwpn = tport->wwpn; 1698 nexus_restart_count = tport->nexus_restart_count; 1699 1700 retval = fdls_delete_tport(iport, tport); 1701 if (retval != true) { 1702 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1703 "Error deleting tport: 0x%x", fcid); 1704 return; 1705 } 1706 1707 if (nexus_restart_count >= FNIC_TPORT_MAX_NEXUS_RESTART) { 1708 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1709 "Exceeded nexus restart retries tport: 0x%x", 1710 fcid); 1711 return; 1712 } 1713 1714 /* 1715 * Allocate memory for the new tport and add it to 1716 * iport's tport list. 1717 * This memory will be freed during tport_offline/linkdown 1718 * or module unload. The pointer new_tport is safe to go 1719 * out of scope when this function returns, since the memory 1720 * it is pointing to is guaranteed to be freed later 1721 * as mentioned above. 1722 */ 1723 new_tport = fdls_create_tport(iport, fcid, wwpn); 1724 if (!new_tport) { 1725 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1726 "Error creating new tport: 0x%x", fcid); 1727 return; 1728 } 1729 1730 new_tport->nexus_restart_count = nexus_restart_count + 1; 1731 fdls_send_tgt_plogi(iport, new_tport); 1732 fdls_set_tport_state(new_tport, FDLS_TGT_STATE_PLOGI); 1733 } 1734 1735 struct fnic_tport_s *fnic_find_tport_by_fcid(struct fnic_iport_s *iport, 1736 uint32_t fcid) 1737 { 1738 struct fnic_tport_s *tport, *next; 1739 1740 list_for_each_entry_safe(tport, next, &(iport->tport_list), links) { 1741 if ((tport->fcid == fcid) 1742 && !(tport->flags & FNIC_FDLS_TPORT_TERMINATING)) 1743 return tport; 1744 } 1745 return NULL; 1746 } 1747 1748 static struct fnic_tport_s *fdls_create_tport(struct fnic_iport_s *iport, 1749 uint32_t fcid, uint64_t wwpn) 1750 { 1751 struct fnic_tport_s *tport; 1752 struct fnic *fnic = iport->fnic; 1753 1754 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1755 "FDLS create tport: fcid: 0x%x wwpn: 0x%llx", fcid, wwpn); 1756 1757 tport = kzalloc(sizeof(struct fnic_tport_s), GFP_ATOMIC); 1758 if (!tport) { 1759 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1760 "Memory allocation failure while creating tport: 0x%x\n", 1761 fcid); 1762 return NULL; 1763 } 1764 1765 tport->max_payload_size = FNIC_FCOE_MAX_FRAME_SZ; 1766 tport->r_a_tov = FC_DEF_R_A_TOV; 1767 tport->e_d_tov = FC_DEF_E_D_TOV; 1768 tport->fcid = fcid; 1769 tport->wwpn = wwpn; 1770 tport->iport = iport; 1771 1772 FNIC_FCS_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num, 1773 "Need to setup tport timer callback"); 1774 1775 timer_setup(&tport->retry_timer, fdls_tport_timer_callback, 0); 1776 1777 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1778 "Added tport 0x%x", tport->fcid); 1779 fdls_set_tport_state(tport, FDLS_TGT_STATE_INIT); 1780 list_add_tail(&tport->links, &iport->tport_list); 1781 atomic_set(&tport->in_flight, 0); 1782 return tport; 1783 } 1784 1785 struct fnic_tport_s *fnic_find_tport_by_wwpn(struct fnic_iport_s *iport, 1786 uint64_t wwpn) 1787 { 1788 struct fnic_tport_s *tport, *next; 1789 1790 list_for_each_entry_safe(tport, next, &(iport->tport_list), links) { 1791 if ((tport->wwpn == wwpn) 1792 && !(tport->flags & FNIC_FDLS_TPORT_TERMINATING)) 1793 return tport; 1794 } 1795 return NULL; 1796 } 1797 1798 static void 1799 fnic_fdmi_attr_set(void *attr_start, u16 type, u16 len, 1800 void *data, u32 *off) 1801 { 1802 u16 size = len + FC_FDMI_ATTR_ENTRY_HEADER_LEN; 1803 struct fc_fdmi_attr_entry *fdmi_attr = (struct fc_fdmi_attr_entry *) 1804 ((u8 *)attr_start + *off); 1805 1806 put_unaligned_be16(type, &fdmi_attr->type); 1807 put_unaligned_be16(size, &fdmi_attr->len); 1808 memcpy(fdmi_attr->value, data, len); 1809 *off += size; 1810 } 1811 1812 static void fdls_fdmi_register_hba(struct fnic_iport_s *iport) 1813 { 1814 uint8_t *frame; 1815 struct fc_std_fdmi_rhba *prhba; 1816 struct fc_fdmi_attr_entry *fdmi_attr; 1817 uint8_t fcid[3]; 1818 int err; 1819 struct fnic *fnic = iport->fnic; 1820 struct vnic_devcmd_fw_info *fw_info = NULL; 1821 uint16_t oxid; 1822 u32 attr_off_bytes, len; 1823 u8 data[64]; 1824 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET; 1825 1826 frame = fdls_alloc_frame(iport); 1827 if (frame == NULL) { 1828 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1829 "Failed to allocate frame to send FDMI RHBA"); 1830 return; 1831 } 1832 1833 prhba = (struct fc_std_fdmi_rhba *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1834 *prhba = (struct fc_std_fdmi_rhba) { 1835 .fchdr = { 1836 .fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 1837 .fh_d_id = {0xFF, 0XFF, 0XFA}, 1838 .fh_type = FC_TYPE_CT, 1839 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1840 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID) 1841 }, 1842 .fc_std_ct_hdr = { 1843 .ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_MGMT, 1844 .ct_fs_subtype = FC_FDMI_SUBTYPE, 1845 .ct_cmd = cpu_to_be16(FC_FDMI_RHBA) 1846 }, 1847 }; 1848 1849 hton24(fcid, iport->fcid); 1850 FNIC_STD_SET_S_ID(prhba->fchdr, fcid); 1851 1852 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FDMI_RHBA, 1853 &iport->active_oxid_fdmi_rhba); 1854 1855 if (oxid == FNIC_UNASSIGNED_OXID) { 1856 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1857 "0x%x: Failed to allocate OXID to send FDMI RHBA", 1858 iport->fcid); 1859 mempool_free(frame, fnic->frame_pool); 1860 return; 1861 } 1862 FNIC_STD_SET_OX_ID(prhba->fchdr, oxid); 1863 1864 put_unaligned_be64(iport->wwpn, &prhba->rhba.hbaid.id); 1865 put_unaligned_be32(FNIC_FDMI_NUM_PORTS, &prhba->rhba.port.numport); 1866 put_unaligned_be64(iport->wwpn, &prhba->rhba.port.port[0].portname); 1867 put_unaligned_be32(FNIC_FDMI_NUM_HBA_ATTRS, 1868 &prhba->rhba.hba_attrs.numattrs); 1869 1870 fdmi_attr = prhba->rhba.hba_attrs.attr; 1871 attr_off_bytes = 0; 1872 1873 put_unaligned_be64(iport->wwnn, data); 1874 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_NODE_NAME, 1875 FNIC_FDMI_NN_LEN, data, &attr_off_bytes); 1876 1877 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1878 "NN set, off=%d", attr_off_bytes); 1879 1880 strscpy_pad(data, FNIC_FDMI_MANUFACTURER, FNIC_FDMI_MANU_LEN); 1881 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_MANUFACTURER, 1882 FNIC_FDMI_MANU_LEN, data, &attr_off_bytes); 1883 1884 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1885 "MFG set <%s>, off=%d", data, attr_off_bytes); 1886 1887 err = vnic_dev_fw_info(fnic->vdev, &fw_info); 1888 if (!err) { 1889 strscpy_pad(data, fw_info->hw_serial_number, 1890 FNIC_FDMI_SERIAL_LEN); 1891 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_SERIAL_NUMBER, 1892 FNIC_FDMI_SERIAL_LEN, data, &attr_off_bytes); 1893 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1894 "SERIAL set <%s>, off=%d", data, attr_off_bytes); 1895 1896 } 1897 1898 if (fnic->subsys_desc_len >= FNIC_FDMI_MODEL_LEN) 1899 fnic->subsys_desc_len = FNIC_FDMI_MODEL_LEN - 1; 1900 strscpy_pad(data, fnic->subsys_desc, FNIC_FDMI_MODEL_LEN); 1901 data[FNIC_FDMI_MODEL_LEN - 1] = 0; 1902 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_MODEL, FNIC_FDMI_MODEL_LEN, 1903 data, &attr_off_bytes); 1904 1905 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1906 "MODEL set <%s>, off=%d", data, attr_off_bytes); 1907 1908 strscpy_pad(data, FNIC_FDMI_MODEL_DESCRIPTION, FNIC_FDMI_MODEL_DES_LEN); 1909 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_MODEL_DES, 1910 FNIC_FDMI_MODEL_DES_LEN, data, &attr_off_bytes); 1911 1912 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1913 "MODEL_DESC set <%s>, off=%d", data, attr_off_bytes); 1914 1915 if (!err) { 1916 strscpy_pad(data, fw_info->hw_version, FNIC_FDMI_HW_VER_LEN); 1917 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_HARDWARE_VERSION, 1918 FNIC_FDMI_HW_VER_LEN, data, &attr_off_bytes); 1919 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1920 "HW_VER set <%s>, off=%d", data, attr_off_bytes); 1921 1922 } 1923 1924 strscpy_pad(data, DRV_VERSION, FNIC_FDMI_DR_VER_LEN); 1925 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_DRIVER_VERSION, 1926 FNIC_FDMI_DR_VER_LEN, data, &attr_off_bytes); 1927 1928 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1929 "DRV_VER set <%s>, off=%d", data, attr_off_bytes); 1930 1931 strscpy_pad(data, "N/A", FNIC_FDMI_ROM_VER_LEN); 1932 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_ROM_VERSION, 1933 FNIC_FDMI_ROM_VER_LEN, data, &attr_off_bytes); 1934 1935 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1936 "ROM_VER set <%s>, off=%d", data, attr_off_bytes); 1937 1938 if (!err) { 1939 strscpy_pad(data, fw_info->fw_version, FNIC_FDMI_FW_VER_LEN); 1940 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_FIRMWARE_VERSION, 1941 FNIC_FDMI_FW_VER_LEN, data, &attr_off_bytes); 1942 1943 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1944 "FW_VER set <%s>, off=%d", data, attr_off_bytes); 1945 } 1946 1947 len = sizeof(struct fc_std_fdmi_rhba) + attr_off_bytes; 1948 frame_size += len; 1949 1950 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 1951 "0x%x: FDLS send FDMI RHBA with oxid: 0x%x fs: %d", iport->fcid, 1952 oxid, frame_size); 1953 1954 fnic_send_fcoe_frame(iport, frame, frame_size); 1955 iport->fabric.fdmi_pending |= FDLS_FDMI_REG_HBA_PENDING; 1956 } 1957 1958 static void fdls_fdmi_register_pa(struct fnic_iport_s *iport) 1959 { 1960 uint8_t *frame; 1961 struct fc_std_fdmi_rpa *prpa; 1962 struct fc_fdmi_attr_entry *fdmi_attr; 1963 uint8_t fcid[3]; 1964 struct fnic *fnic = iport->fnic; 1965 u32 port_speed_bm; 1966 u32 port_speed = vnic_dev_port_speed(fnic->vdev); 1967 uint16_t oxid; 1968 u32 attr_off_bytes, len; 1969 u8 tmp_data[16], data[64]; 1970 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET; 1971 1972 frame = fdls_alloc_frame(iport); 1973 if (frame == NULL) { 1974 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 1975 "Failed to allocate frame to send FDMI RPA"); 1976 return; 1977 } 1978 1979 prpa = (struct fc_std_fdmi_rpa *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 1980 *prpa = (struct fc_std_fdmi_rpa) { 1981 .fchdr = { 1982 .fh_r_ctl = FC_RCTL_DD_UNSOL_CTL, 1983 .fh_d_id = {0xFF, 0xFF, 0xFA}, 1984 .fh_type = FC_TYPE_CT, 1985 .fh_f_ctl = {FNIC_ELS_REQ_FCTL, 0, 0}, 1986 .fh_rx_id = cpu_to_be16(FNIC_UNASSIGNED_RXID) 1987 }, 1988 .fc_std_ct_hdr = { 1989 .ct_rev = FC_CT_REV, .ct_fs_type = FC_FST_MGMT, 1990 .ct_fs_subtype = FC_FDMI_SUBTYPE, 1991 .ct_cmd = cpu_to_be16(FC_FDMI_RPA) 1992 }, 1993 }; 1994 1995 hton24(fcid, iport->fcid); 1996 FNIC_STD_SET_S_ID(prpa->fchdr, fcid); 1997 1998 oxid = fdls_alloc_oxid(iport, FNIC_FRAME_TYPE_FDMI_RPA, 1999 &iport->active_oxid_fdmi_rpa); 2000 2001 if (oxid == FNIC_UNASSIGNED_OXID) { 2002 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2003 "0x%x: Failed to allocate OXID to send FDMI RPA", 2004 iport->fcid); 2005 mempool_free(frame, fnic->frame_pool); 2006 return; 2007 } 2008 FNIC_STD_SET_OX_ID(prpa->fchdr, oxid); 2009 2010 put_unaligned_be64(iport->wwpn, &prpa->rpa.port.portname); 2011 put_unaligned_be32(FNIC_FDMI_NUM_PORT_ATTRS, 2012 &prpa->rpa.hba_attrs.numattrs); 2013 2014 /* MDS does not support GIGE speed. 2015 * Bit shift standard definitions from scsi_transport_fc.h to 2016 * match FC spec. 2017 */ 2018 switch (port_speed) { 2019 case DCEM_PORTSPEED_10G: 2020 case DCEM_PORTSPEED_20G: 2021 /* There is no bit for 20G */ 2022 port_speed_bm = FC_PORTSPEED_10GBIT << PORT_SPEED_BIT_14; 2023 break; 2024 case DCEM_PORTSPEED_25G: 2025 port_speed_bm = FC_PORTSPEED_25GBIT << PORT_SPEED_BIT_8; 2026 break; 2027 case DCEM_PORTSPEED_40G: 2028 case DCEM_PORTSPEED_4x10G: 2029 port_speed_bm = FC_PORTSPEED_40GBIT << PORT_SPEED_BIT_9; 2030 break; 2031 case DCEM_PORTSPEED_100G: 2032 port_speed_bm = FC_PORTSPEED_100GBIT << PORT_SPEED_BIT_8; 2033 break; 2034 default: 2035 port_speed_bm = FC_PORTSPEED_1GBIT << PORT_SPEED_BIT_15; 2036 break; 2037 } 2038 attr_off_bytes = 0; 2039 2040 fdmi_attr = prpa->rpa.hba_attrs.attr; 2041 2042 put_unaligned_be64(iport->wwnn, data); 2043 2044 memset(data, 0, FNIC_FDMI_FC4_LEN); 2045 data[2] = 1; 2046 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_FC4_TYPES, 2047 FNIC_FDMI_FC4_LEN, data, &attr_off_bytes); 2048 2049 put_unaligned_be32(port_speed_bm, data); 2050 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_SUPPORTED_SPEEDS, 2051 FNIC_FDMI_SUPP_SPEED_LEN, data, &attr_off_bytes); 2052 2053 put_unaligned_be32(port_speed_bm, data); 2054 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_CURRENT_SPEED, 2055 FNIC_FDMI_CUR_SPEED_LEN, data, &attr_off_bytes); 2056 2057 put_unaligned_be32(FNIC_FDMI_MFS, data); 2058 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_MAX_FRAME_SIZE, 2059 FNIC_FDMI_MFS_LEN, data, &attr_off_bytes); 2060 2061 snprintf(tmp_data, FNIC_FDMI_OS_NAME_LEN - 1, "host%d", 2062 fnic->host->host_no); 2063 strscpy_pad(data, tmp_data, FNIC_FDMI_OS_NAME_LEN); 2064 data[FNIC_FDMI_OS_NAME_LEN - 1] = 0; 2065 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_OS_NAME, 2066 FNIC_FDMI_OS_NAME_LEN, data, &attr_off_bytes); 2067 2068 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2069 "OS name set <%s>, off=%d", data, attr_off_bytes); 2070 2071 sprintf(fc_host_system_hostname(fnic->host), "%s", utsname()->nodename); 2072 strscpy_pad(data, fc_host_system_hostname(fnic->host), 2073 FNIC_FDMI_HN_LEN); 2074 data[FNIC_FDMI_HN_LEN - 1] = 0; 2075 fnic_fdmi_attr_set(fdmi_attr, FNIC_FDMI_TYPE_HOST_NAME, 2076 FNIC_FDMI_HN_LEN, data, &attr_off_bytes); 2077 2078 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2079 "Host name set <%s>, off=%d", data, attr_off_bytes); 2080 2081 len = sizeof(struct fc_std_fdmi_rpa) + attr_off_bytes; 2082 frame_size += len; 2083 2084 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2085 "0x%x: FDLS send FDMI RPA with oxid: 0x%x fs: %d", iport->fcid, 2086 oxid, frame_size); 2087 2088 fnic_send_fcoe_frame(iport, frame, frame_size); 2089 iport->fabric.fdmi_pending |= FDLS_FDMI_RPA_PENDING; 2090 } 2091 2092 void fdls_fabric_timer_callback(struct timer_list *t) 2093 { 2094 struct fnic_fdls_fabric_s *fabric = from_timer(fabric, t, retry_timer); 2095 struct fnic_iport_s *iport = 2096 container_of(fabric, struct fnic_iport_s, fabric); 2097 struct fnic *fnic = iport->fnic; 2098 unsigned long flags; 2099 2100 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2101 "tp: %d fab state: %d fab retry counter: %d max_flogi_retries: %d", 2102 iport->fabric.timer_pending, iport->fabric.state, 2103 iport->fabric.retry_counter, iport->max_flogi_retries); 2104 2105 spin_lock_irqsave(&fnic->fnic_lock, flags); 2106 2107 if (!iport->fabric.timer_pending) { 2108 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2109 return; 2110 } 2111 2112 if (iport->fabric.del_timer_inprogress) { 2113 iport->fabric.del_timer_inprogress = 0; 2114 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2115 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2116 "fabric_del_timer inprogress(%d). Skip timer cb", 2117 iport->fabric.del_timer_inprogress); 2118 return; 2119 } 2120 2121 iport->fabric.timer_pending = 0; 2122 2123 /* The fabric state indicates which frames have time out, and we retry */ 2124 switch (iport->fabric.state) { 2125 case FDLS_STATE_FABRIC_FLOGI: 2126 /* Flogi received a LS_RJT with busy we retry from here */ 2127 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2128 && (iport->fabric.retry_counter < iport->max_flogi_retries)) { 2129 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2130 fdls_send_fabric_flogi(iport); 2131 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) { 2132 /* Flogi has time out 2*ed_tov send abts */ 2133 fdls_send_fabric_abts(iport); 2134 } else { 2135 /* ABTS has timed out 2136 * Mark the OXID to be freed after 2 * r_a_tov and retry the req 2137 */ 2138 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2139 if (iport->fabric.retry_counter < iport->max_flogi_retries) { 2140 iport->fabric.flags &= ~FNIC_FDLS_FABRIC_ABORT_ISSUED; 2141 fdls_send_fabric_flogi(iport); 2142 } else 2143 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2144 "Exceeded max FLOGI retries"); 2145 } 2146 break; 2147 case FDLS_STATE_FABRIC_PLOGI: 2148 /* Plogi received a LS_RJT with busy we retry from here */ 2149 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2150 && (iport->fabric.retry_counter < iport->max_plogi_retries)) { 2151 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2152 fdls_send_fabric_plogi(iport); 2153 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) { 2154 /* Plogi has timed out 2*ed_tov send abts */ 2155 fdls_send_fabric_abts(iport); 2156 } else { 2157 /* ABTS has timed out 2158 * Mark the OXID to be freed after 2 * r_a_tov and retry the req 2159 */ 2160 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2161 if (iport->fabric.retry_counter < iport->max_plogi_retries) { 2162 iport->fabric.flags &= ~FNIC_FDLS_FABRIC_ABORT_ISSUED; 2163 fdls_send_fabric_plogi(iport); 2164 } else 2165 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2166 "Exceeded max PLOGI retries"); 2167 } 2168 break; 2169 case FDLS_STATE_RPN_ID: 2170 /* Rpn_id received a LS_RJT with busy we retry from here */ 2171 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2172 && (iport->fabric.retry_counter < FDLS_RETRY_COUNT)) { 2173 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2174 fdls_send_rpn_id(iport); 2175 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) 2176 /* RPN has timed out. Send abts */ 2177 fdls_send_fabric_abts(iport); 2178 else { 2179 /* ABTS has timed out */ 2180 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2181 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 2182 } 2183 break; 2184 case FDLS_STATE_SCR: 2185 /* scr received a LS_RJT with busy we retry from here */ 2186 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2187 && (iport->fabric.retry_counter < FDLS_RETRY_COUNT)) { 2188 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2189 fdls_send_scr(iport); 2190 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) 2191 /* scr has timed out. Send abts */ 2192 fdls_send_fabric_abts(iport); 2193 else { 2194 /* ABTS has timed out */ 2195 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2196 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2197 "ABTS timed out. Starting PLOGI: %p", iport); 2198 fnic_fdls_start_plogi(iport); 2199 } 2200 break; 2201 case FDLS_STATE_REGISTER_FC4_TYPES: 2202 /* scr received a LS_RJT with busy we retry from here */ 2203 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2204 && (iport->fabric.retry_counter < FDLS_RETRY_COUNT)) { 2205 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2206 fdls_send_register_fc4_types(iport); 2207 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) { 2208 /* RFT_ID timed out send abts */ 2209 fdls_send_fabric_abts(iport); 2210 } else { 2211 /* ABTS has timed out */ 2212 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2213 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2214 "ABTS timed out. Starting PLOGI: %p", iport); 2215 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 2216 } 2217 break; 2218 case FDLS_STATE_REGISTER_FC4_FEATURES: 2219 /* scr received a LS_RJT with busy we retry from here */ 2220 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2221 && (iport->fabric.retry_counter < FDLS_RETRY_COUNT)) { 2222 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2223 fdls_send_register_fc4_features(iport); 2224 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) 2225 /* SCR has timed out. Send abts */ 2226 fdls_send_fabric_abts(iport); 2227 else { 2228 /* ABTS has timed out */ 2229 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2230 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2231 "ABTS timed out. Starting PLOGI %p", iport); 2232 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 2233 } 2234 break; 2235 case FDLS_STATE_RSCN_GPN_FT: 2236 case FDLS_STATE_SEND_GPNFT: 2237 case FDLS_STATE_GPN_FT: 2238 /* GPN_FT received a LS_RJT with busy we retry from here */ 2239 if ((iport->fabric.flags & FNIC_FDLS_RETRY_FRAME) 2240 && (iport->fabric.retry_counter < FDLS_RETRY_COUNT)) { 2241 iport->fabric.flags &= ~FNIC_FDLS_RETRY_FRAME; 2242 fdls_send_gpn_ft(iport, iport->fabric.state); 2243 } else if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) { 2244 /* gpn_ft has timed out. Send abts */ 2245 fdls_send_fabric_abts(iport); 2246 } else { 2247 /* ABTS has timed out */ 2248 fdls_schedule_oxid_free(iport, &iport->active_oxid_fabric_req); 2249 if (iport->fabric.retry_counter < FDLS_RETRY_COUNT) { 2250 fdls_send_gpn_ft(iport, iport->fabric.state); 2251 } else { 2252 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2253 "ABTS timeout for fabric GPN_FT. Check name server: %p", 2254 iport); 2255 } 2256 } 2257 break; 2258 default: 2259 break; 2260 } 2261 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2262 } 2263 2264 void fdls_fdmi_timer_callback(struct timer_list *t) 2265 { 2266 struct fnic_fdls_fabric_s *fabric = from_timer(fabric, t, fdmi_timer); 2267 struct fnic_iport_s *iport = 2268 container_of(fabric, struct fnic_iport_s, fabric); 2269 struct fnic *fnic = iport->fnic; 2270 unsigned long flags; 2271 2272 spin_lock_irqsave(&fnic->fnic_lock, flags); 2273 2274 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2275 "fdmi timer callback : 0x%x\n", iport->fabric.fdmi_pending); 2276 2277 if (!iport->fabric.fdmi_pending) { 2278 /* timer expired after fdmi responses received. */ 2279 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2280 return; 2281 } 2282 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2283 "fdmi timer callback : 0x%x\n", iport->fabric.fdmi_pending); 2284 2285 /* if not abort pending, send an abort */ 2286 if (!(iport->fabric.fdmi_pending & FDLS_FDMI_ABORT_PENDING)) { 2287 fdls_send_fdmi_abts(iport); 2288 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2289 return; 2290 } 2291 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2292 "fdmi timer callback : 0x%x\n", iport->fabric.fdmi_pending); 2293 2294 /* ABTS pending for an active fdmi request that is pending. 2295 * That means FDMI ABTS timed out 2296 * Schedule to free the OXID after 2*r_a_tov and proceed 2297 */ 2298 if (iport->fabric.fdmi_pending & FDLS_FDMI_PLOGI_PENDING) { 2299 fdls_schedule_oxid_free(iport, &iport->active_oxid_fdmi_plogi); 2300 } else { 2301 if (iport->fabric.fdmi_pending & FDLS_FDMI_REG_HBA_PENDING) 2302 fdls_schedule_oxid_free(iport, &iport->active_oxid_fdmi_rhba); 2303 if (iport->fabric.fdmi_pending & FDLS_FDMI_RPA_PENDING) 2304 fdls_schedule_oxid_free(iport, &iport->active_oxid_fdmi_rpa); 2305 } 2306 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2307 "fdmi timer callback : 0x%x\n", iport->fabric.fdmi_pending); 2308 2309 iport->fabric.fdmi_pending = 0; 2310 /* If max retries not exhaused, start over from fdmi plogi */ 2311 if (iport->fabric.fdmi_retry < FDLS_FDMI_MAX_RETRY) { 2312 iport->fabric.fdmi_retry++; 2313 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2314 "retry fdmi timer %d", iport->fabric.fdmi_retry); 2315 fdls_send_fdmi_plogi(iport); 2316 } 2317 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2318 "fdmi timer callback : 0x%x\n", iport->fabric.fdmi_pending); 2319 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2320 } 2321 2322 static void fdls_send_delete_tport_msg(struct fnic_tport_s *tport) 2323 { 2324 struct fnic_iport_s *iport = (struct fnic_iport_s *) tport->iport; 2325 struct fnic *fnic = iport->fnic; 2326 struct fnic_tport_event_s *tport_del_evt; 2327 2328 tport_del_evt = kzalloc(sizeof(struct fnic_tport_event_s), GFP_ATOMIC); 2329 if (!tport_del_evt) { 2330 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2331 "Failed to allocate memory for tport event fcid: 0x%x", 2332 tport->fcid); 2333 return; 2334 } 2335 tport_del_evt->event = TGT_EV_TPORT_DELETE; 2336 tport_del_evt->arg1 = (void *) tport; 2337 list_add_tail(&tport_del_evt->links, &fnic->tport_event_list); 2338 queue_work(fnic_event_queue, &fnic->tport_work); 2339 } 2340 2341 static void fdls_tport_timer_callback(struct timer_list *t) 2342 { 2343 struct fnic_tport_s *tport = from_timer(tport, t, retry_timer); 2344 struct fnic_iport_s *iport = (struct fnic_iport_s *) tport->iport; 2345 struct fnic *fnic = iport->fnic; 2346 uint16_t oxid; 2347 unsigned long flags; 2348 2349 spin_lock_irqsave(&fnic->fnic_lock, flags); 2350 if (!tport->timer_pending) { 2351 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2352 return; 2353 } 2354 2355 if (iport->state != FNIC_IPORT_STATE_READY) { 2356 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2357 return; 2358 } 2359 2360 if (tport->del_timer_inprogress) { 2361 tport->del_timer_inprogress = 0; 2362 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2363 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2364 "tport_del_timer inprogress. Skip timer cb tport fcid: 0x%x\n", 2365 tport->fcid); 2366 return; 2367 } 2368 2369 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2370 "tport fcid: 0x%x timer pending: %d state: %d retry counter: %d", 2371 tport->fcid, tport->timer_pending, tport->state, 2372 tport->retry_counter); 2373 2374 tport->timer_pending = 0; 2375 oxid = tport->active_oxid; 2376 2377 /* We retry plogi/prli/adisc frames depending on the tport state */ 2378 switch (tport->state) { 2379 case FDLS_TGT_STATE_PLOGI: 2380 /* PLOGI frame received a LS_RJT with busy, we retry from here */ 2381 if ((tport->flags & FNIC_FDLS_RETRY_FRAME) 2382 && (tport->retry_counter < iport->max_plogi_retries)) { 2383 tport->flags &= ~FNIC_FDLS_RETRY_FRAME; 2384 fdls_send_tgt_plogi(iport, tport); 2385 } else if (!(tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2386 /* Plogi frame has timed out, send abts */ 2387 fdls_send_tport_abts(iport, tport); 2388 } else if (tport->retry_counter < iport->max_plogi_retries) { 2389 /* 2390 * ABTS has timed out 2391 */ 2392 fdls_schedule_oxid_free(iport, &tport->active_oxid); 2393 fdls_send_tgt_plogi(iport, tport); 2394 } else { 2395 /* exceeded plogi retry count */ 2396 fdls_schedule_oxid_free(iport, &tport->active_oxid); 2397 fdls_send_delete_tport_msg(tport); 2398 } 2399 break; 2400 case FDLS_TGT_STATE_PRLI: 2401 /* PRLI received a LS_RJT with busy , hence we retry from here */ 2402 if ((tport->flags & FNIC_FDLS_RETRY_FRAME) 2403 && (tport->retry_counter < FDLS_RETRY_COUNT)) { 2404 tport->flags &= ~FNIC_FDLS_RETRY_FRAME; 2405 fdls_send_tgt_prli(iport, tport); 2406 } else if (!(tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2407 /* PRLI has time out, send abts */ 2408 fdls_send_tport_abts(iport, tport); 2409 } else { 2410 /* ABTS has timed out for prli, we go back to PLOGI */ 2411 fdls_schedule_oxid_free(iport, &tport->active_oxid); 2412 fdls_send_tgt_plogi(iport, tport); 2413 fdls_set_tport_state(tport, FDLS_TGT_STATE_PLOGI); 2414 } 2415 break; 2416 case FDLS_TGT_STATE_ADISC: 2417 /* ADISC timed out send an ABTS */ 2418 if (!(tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2419 fdls_send_tport_abts(iport, tport); 2420 } else if ((tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED) 2421 && (tport->retry_counter < FDLS_RETRY_COUNT)) { 2422 /* 2423 * ABTS has timed out 2424 */ 2425 fdls_schedule_oxid_free(iport, &tport->active_oxid); 2426 fdls_send_tgt_adisc(iport, tport); 2427 } else { 2428 /* exceeded retry count */ 2429 fdls_schedule_oxid_free(iport, &tport->active_oxid); 2430 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2431 "ADISC not responding. Deleting target port: 0x%x", 2432 tport->fcid); 2433 fdls_send_delete_tport_msg(tport); 2434 } 2435 break; 2436 default: 2437 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2438 "oxid: 0x%x Unknown tport state: 0x%x", oxid, tport->state); 2439 break; 2440 } 2441 spin_unlock_irqrestore(&fnic->fnic_lock, flags); 2442 } 2443 2444 static void fnic_fdls_start_flogi(struct fnic_iport_s *iport) 2445 { 2446 iport->fabric.retry_counter = 0; 2447 fdls_send_fabric_flogi(iport); 2448 fdls_set_state((&iport->fabric), FDLS_STATE_FABRIC_FLOGI); 2449 iport->fabric.flags = 0; 2450 } 2451 2452 static void fnic_fdls_start_plogi(struct fnic_iport_s *iport) 2453 { 2454 iport->fabric.retry_counter = 0; 2455 fdls_send_fabric_plogi(iport); 2456 fdls_set_state((&iport->fabric), FDLS_STATE_FABRIC_PLOGI); 2457 iport->fabric.flags &= ~FNIC_FDLS_FABRIC_ABORT_ISSUED; 2458 2459 if ((fnic_fdmi_support == 1) && (!(iport->flags & FNIC_FDMI_ACTIVE))) { 2460 /* we can do FDMI at the same time */ 2461 iport->fabric.fdmi_retry = 0; 2462 timer_setup(&iport->fabric.fdmi_timer, fdls_fdmi_timer_callback, 2463 0); 2464 fdls_send_fdmi_plogi(iport); 2465 iport->flags |= FNIC_FDMI_ACTIVE; 2466 } 2467 } 2468 static void 2469 fdls_process_tgt_adisc_rsp(struct fnic_iport_s *iport, 2470 struct fc_frame_header *fchdr) 2471 { 2472 uint32_t tgt_fcid; 2473 struct fnic_tport_s *tport; 2474 uint8_t *fcid; 2475 uint64_t frame_wwnn; 2476 uint64_t frame_wwpn; 2477 uint16_t oxid; 2478 struct fc_std_els_adisc *adisc_rsp = (struct fc_std_els_adisc *)fchdr; 2479 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *)fchdr; 2480 struct fnic *fnic = iport->fnic; 2481 2482 fcid = FNIC_STD_GET_S_ID(fchdr); 2483 tgt_fcid = ntoh24(fcid); 2484 tport = fnic_find_tport_by_fcid(iport, tgt_fcid); 2485 2486 if (!tport) { 2487 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2488 "Tgt ADISC response tport not found: 0x%x", tgt_fcid); 2489 return; 2490 } 2491 if ((iport->state != FNIC_IPORT_STATE_READY) 2492 || (tport->state != FDLS_TGT_STATE_ADISC) 2493 || (tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2494 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2495 "Dropping this ADISC response"); 2496 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2497 "iport state: %d tport state: %d Is abort issued on PRLI? %d", 2498 iport->state, tport->state, 2499 (tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)); 2500 return; 2501 } 2502 if (FNIC_STD_GET_OX_ID(fchdr) != tport->active_oxid) { 2503 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2504 "Dropping frame from target: 0x%x", 2505 tgt_fcid); 2506 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2507 "Reason: Stale ADISC/Aborted ADISC/OOO frame delivery"); 2508 return; 2509 } 2510 2511 oxid = FNIC_STD_GET_OX_ID(fchdr); 2512 fdls_free_oxid(iport, oxid, &tport->active_oxid); 2513 2514 switch (adisc_rsp->els.adisc_cmd) { 2515 case ELS_LS_ACC: 2516 atomic64_inc(&iport->iport_stats.tport_adisc_ls_accepts); 2517 if (tport->timer_pending) { 2518 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2519 "tport 0x%p Canceling fabric disc timer\n", 2520 tport); 2521 fnic_del_tport_timer_sync(fnic, tport); 2522 } 2523 tport->timer_pending = 0; 2524 tport->retry_counter = 0; 2525 frame_wwnn = get_unaligned_be64(&adisc_rsp->els.adisc_wwnn); 2526 frame_wwpn = get_unaligned_be64(&adisc_rsp->els.adisc_wwpn); 2527 if ((frame_wwnn == tport->wwnn) && (frame_wwpn == tport->wwpn)) { 2528 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2529 "ADISC accepted from target: 0x%x. Target logged in", 2530 tgt_fcid); 2531 fdls_set_tport_state(tport, FDLS_TGT_STATE_READY); 2532 } else { 2533 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2534 "Error mismatch frame: ADISC"); 2535 } 2536 break; 2537 2538 case ELS_LS_RJT: 2539 atomic64_inc(&iport->iport_stats.tport_adisc_ls_rejects); 2540 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 2541 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 2542 && (tport->retry_counter < FDLS_RETRY_COUNT)) { 2543 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2544 "ADISC ret ELS_LS_RJT BUSY. Retry from timer routine: 0x%x", 2545 tgt_fcid); 2546 2547 /* Retry ADISC again from the timer routine. */ 2548 tport->flags |= FNIC_FDLS_RETRY_FRAME; 2549 } else { 2550 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2551 "ADISC returned ELS_LS_RJT from target: 0x%x", 2552 tgt_fcid); 2553 fdls_delete_tport(iport, tport); 2554 } 2555 break; 2556 } 2557 } 2558 static void 2559 fdls_process_tgt_plogi_rsp(struct fnic_iport_s *iport, 2560 struct fc_frame_header *fchdr) 2561 { 2562 uint32_t tgt_fcid; 2563 struct fnic_tport_s *tport; 2564 uint8_t *fcid; 2565 uint16_t oxid; 2566 struct fc_std_flogi *plogi_rsp = (struct fc_std_flogi *)fchdr; 2567 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *)fchdr; 2568 uint16_t max_payload_size; 2569 struct fnic *fnic = iport->fnic; 2570 2571 fcid = FNIC_STD_GET_S_ID(fchdr); 2572 tgt_fcid = ntoh24(fcid); 2573 2574 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2575 "FDLS processing target PLOGI response: tgt_fcid: 0x%x", 2576 tgt_fcid); 2577 2578 tport = fnic_find_tport_by_fcid(iport, tgt_fcid); 2579 if (!tport) { 2580 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2581 "tport not found: 0x%x", tgt_fcid); 2582 return; 2583 } 2584 if ((iport->state != FNIC_IPORT_STATE_READY) 2585 || (tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2586 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2587 "Dropping frame! iport state: %d tport state: %d", 2588 iport->state, tport->state); 2589 return; 2590 } 2591 2592 if (tport->state != FDLS_TGT_STATE_PLOGI) { 2593 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2594 "PLOGI rsp recvd in wrong state. Drop the frame and restart nexus"); 2595 fdls_target_restart_nexus(tport); 2596 return; 2597 } 2598 2599 if (FNIC_STD_GET_OX_ID(fchdr) != tport->active_oxid) { 2600 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2601 "PLOGI response from target: 0x%x. Dropping frame", 2602 tgt_fcid); 2603 return; 2604 } 2605 2606 oxid = FNIC_STD_GET_OX_ID(fchdr); 2607 fdls_free_oxid(iport, oxid, &tport->active_oxid); 2608 2609 switch (plogi_rsp->els.fl_cmd) { 2610 case ELS_LS_ACC: 2611 atomic64_inc(&iport->iport_stats.tport_plogi_ls_accepts); 2612 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2613 "PLOGI accepted by target: 0x%x", tgt_fcid); 2614 break; 2615 2616 case ELS_LS_RJT: 2617 atomic64_inc(&iport->iport_stats.tport_plogi_ls_rejects); 2618 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 2619 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 2620 && (tport->retry_counter < iport->max_plogi_retries)) { 2621 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2622 "PLOGI ret ELS_LS_RJT BUSY. Retry from timer routine: 0x%x", 2623 tgt_fcid); 2624 /* Retry plogi again from the timer routine. */ 2625 tport->flags |= FNIC_FDLS_RETRY_FRAME; 2626 return; 2627 } 2628 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2629 "PLOGI returned ELS_LS_RJT from target: 0x%x", 2630 tgt_fcid); 2631 fdls_delete_tport(iport, tport); 2632 return; 2633 2634 default: 2635 atomic64_inc(&iport->iport_stats.tport_plogi_misc_rejects); 2636 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2637 "PLOGI not accepted from target fcid: 0x%x", 2638 tgt_fcid); 2639 return; 2640 } 2641 2642 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2643 "Found the PLOGI target: 0x%x and state: %d", 2644 (unsigned int) tgt_fcid, tport->state); 2645 2646 if (tport->timer_pending) { 2647 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2648 "tport fcid 0x%x: Canceling disc timer\n", 2649 tport->fcid); 2650 fnic_del_tport_timer_sync(fnic, tport); 2651 } 2652 2653 tport->timer_pending = 0; 2654 tport->wwpn = get_unaligned_be64(&FNIC_LOGI_PORT_NAME(plogi_rsp->els)); 2655 tport->wwnn = get_unaligned_be64(&FNIC_LOGI_NODE_NAME(plogi_rsp->els)); 2656 2657 /* Learn the Service Params */ 2658 2659 /* Max frame size - choose the lowest */ 2660 max_payload_size = fnic_fc_plogi_rsp_rdf(iport, plogi_rsp); 2661 tport->max_payload_size = 2662 min(max_payload_size, iport->max_payload_size); 2663 2664 if (tport->max_payload_size < FNIC_MIN_DATA_FIELD_SIZE) { 2665 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2666 "MFS: tport max frame size below spec bounds: %d", 2667 tport->max_payload_size); 2668 tport->max_payload_size = FNIC_MIN_DATA_FIELD_SIZE; 2669 } 2670 2671 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2672 "MAX frame size: %u iport max_payload_size: %d tport mfs: %d", 2673 max_payload_size, iport->max_payload_size, 2674 tport->max_payload_size); 2675 2676 tport->max_concur_seqs = FNIC_FC_PLOGI_RSP_CONCUR_SEQ(plogi_rsp); 2677 2678 tport->retry_counter = 0; 2679 fdls_set_tport_state(tport, FDLS_TGT_STATE_PRLI); 2680 fdls_send_tgt_prli(iport, tport); 2681 } 2682 static void 2683 fdls_process_tgt_prli_rsp(struct fnic_iport_s *iport, 2684 struct fc_frame_header *fchdr) 2685 { 2686 uint32_t tgt_fcid; 2687 struct fnic_tport_s *tport; 2688 uint8_t *fcid; 2689 uint16_t oxid; 2690 struct fc_std_els_prli *prli_rsp = (struct fc_std_els_prli *)fchdr; 2691 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *)fchdr; 2692 struct fnic_tport_event_s *tport_add_evt; 2693 struct fnic *fnic = iport->fnic; 2694 bool mismatched_tgt = false; 2695 2696 fcid = FNIC_STD_GET_S_ID(fchdr); 2697 tgt_fcid = ntoh24(fcid); 2698 2699 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2700 "FDLS process tgt PRLI response: 0x%x", tgt_fcid); 2701 2702 tport = fnic_find_tport_by_fcid(iport, tgt_fcid); 2703 if (!tport) { 2704 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2705 "tport not found: 0x%x", tgt_fcid); 2706 /* Handle or just drop? */ 2707 return; 2708 } 2709 2710 if ((iport->state != FNIC_IPORT_STATE_READY) 2711 || (tport->flags & FNIC_FDLS_TGT_ABORT_ISSUED)) { 2712 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2713 "Dropping frame! iport st: %d tport st: %d tport fcid: 0x%x", 2714 iport->state, tport->state, tport->fcid); 2715 return; 2716 } 2717 2718 if (tport->state != FDLS_TGT_STATE_PRLI) { 2719 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2720 "PRLI rsp recvd in wrong state. Drop frame. Restarting nexus"); 2721 fdls_target_restart_nexus(tport); 2722 return; 2723 } 2724 2725 if (FNIC_STD_GET_OX_ID(fchdr) != tport->active_oxid) { 2726 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2727 "Dropping PRLI response from target: 0x%x ", 2728 tgt_fcid); 2729 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2730 "Reason: Stale PRLI response/Aborted PDISC/OOO frame delivery"); 2731 return; 2732 } 2733 2734 oxid = FNIC_STD_GET_OX_ID(fchdr); 2735 fdls_free_oxid(iport, oxid, &tport->active_oxid); 2736 2737 switch (prli_rsp->els_prli.prli_cmd) { 2738 case ELS_LS_ACC: 2739 atomic64_inc(&iport->iport_stats.tport_prli_ls_accepts); 2740 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2741 "PRLI accepted from target: 0x%x", tgt_fcid); 2742 2743 if (prli_rsp->sp.spp_type != FC_FC4_TYPE_SCSI) { 2744 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2745 "mismatched target zoned with FC SCSI initiator: 0x%x", 2746 tgt_fcid); 2747 mismatched_tgt = true; 2748 } 2749 if (mismatched_tgt) { 2750 fdls_tgt_logout(iport, tport); 2751 fdls_delete_tport(iport, tport); 2752 return; 2753 } 2754 break; 2755 case ELS_LS_RJT: 2756 atomic64_inc(&iport->iport_stats.tport_prli_ls_rejects); 2757 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 2758 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 2759 && (tport->retry_counter < FDLS_RETRY_COUNT)) { 2760 2761 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2762 "PRLI ret ELS_LS_RJT BUSY. Retry from timer routine: 0x%x", 2763 tgt_fcid); 2764 2765 /*Retry Plogi again from the timer routine. */ 2766 tport->flags |= FNIC_FDLS_RETRY_FRAME; 2767 return; 2768 } 2769 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2770 "PRLI returned ELS_LS_RJT from target: 0x%x", 2771 tgt_fcid); 2772 2773 fdls_tgt_logout(iport, tport); 2774 fdls_delete_tport(iport, tport); 2775 return; 2776 default: 2777 atomic64_inc(&iport->iport_stats.tport_prli_misc_rejects); 2778 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2779 "PRLI not accepted from target: 0x%x", tgt_fcid); 2780 return; 2781 } 2782 2783 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2784 "Found the PRLI target: 0x%x and state: %d", 2785 (unsigned int) tgt_fcid, tport->state); 2786 2787 if (tport->timer_pending) { 2788 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2789 "tport fcid 0x%x: Canceling disc timer\n", 2790 tport->fcid); 2791 fnic_del_tport_timer_sync(fnic, tport); 2792 } 2793 tport->timer_pending = 0; 2794 2795 /* Learn Service Params */ 2796 tport->fcp_csp = be32_to_cpu(prli_rsp->sp.spp_params); 2797 tport->retry_counter = 0; 2798 2799 if (tport->fcp_csp & FCP_SPPF_RETRY) 2800 tport->tgt_flags |= FNIC_FC_RP_FLAGS_RETRY; 2801 2802 /* Check if the device plays Target Mode Function */ 2803 if (!(tport->fcp_csp & FCP_PRLI_FUNC_TARGET)) { 2804 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2805 "Remote port(0x%x): no target support. Deleting it\n", 2806 tgt_fcid); 2807 fdls_tgt_logout(iport, tport); 2808 fdls_delete_tport(iport, tport); 2809 return; 2810 } 2811 2812 fdls_set_tport_state(tport, FDLS_TGT_STATE_READY); 2813 2814 /* Inform the driver about new target added */ 2815 tport_add_evt = kzalloc(sizeof(struct fnic_tport_event_s), GFP_ATOMIC); 2816 if (!tport_add_evt) { 2817 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2818 "tport event memory allocation failure: 0x%0x\n", 2819 tport->fcid); 2820 return; 2821 } 2822 tport_add_evt->event = TGT_EV_RPORT_ADD; 2823 tport_add_evt->arg1 = (void *) tport; 2824 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2825 "iport fcid: 0x%x add tport event fcid: 0x%x\n", 2826 tport->fcid, iport->fcid); 2827 list_add_tail(&tport_add_evt->links, &fnic->tport_event_list); 2828 queue_work(fnic_event_queue, &fnic->tport_work); 2829 } 2830 2831 2832 static void 2833 fdls_process_rff_id_rsp(struct fnic_iport_s *iport, 2834 struct fc_frame_header *fchdr) 2835 { 2836 struct fnic *fnic = iport->fnic; 2837 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 2838 struct fc_std_rff_id *rff_rsp = (struct fc_std_rff_id *) fchdr; 2839 uint16_t rsp; 2840 uint8_t reason_code; 2841 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 2842 2843 if (fdls_get_state(fdls) != FDLS_STATE_REGISTER_FC4_FEATURES) { 2844 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2845 "RFF_ID resp recvd in state(%d). Dropping.", 2846 fdls_get_state(fdls)); 2847 return; 2848 } 2849 2850 if (iport->active_oxid_fabric_req != oxid) { 2851 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2852 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 2853 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 2854 return; 2855 } 2856 2857 rsp = FNIC_STD_GET_FC_CT_CMD((&rff_rsp->fc_std_ct_hdr)); 2858 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2859 "0x%x: FDLS process RFF ID response: 0x%04x", iport->fcid, 2860 (uint32_t) rsp); 2861 2862 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 2863 2864 switch (rsp) { 2865 case FC_FS_ACC: 2866 if (iport->fabric.timer_pending) { 2867 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2868 "Canceling fabric disc timer %p\n", iport); 2869 fnic_del_fabric_timer_sync(fnic); 2870 } 2871 iport->fabric.timer_pending = 0; 2872 fdls->retry_counter = 0; 2873 fdls_set_state((&iport->fabric), FDLS_STATE_SCR); 2874 fdls_send_scr(iport); 2875 break; 2876 case FC_FS_RJT: 2877 reason_code = rff_rsp->fc_std_ct_hdr.ct_reason; 2878 if (((reason_code == FC_FS_RJT_BSY) 2879 || (reason_code == FC_FS_RJT_UNABL)) 2880 && (fdls->retry_counter < FDLS_RETRY_COUNT)) { 2881 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2882 "RFF_ID ret ELS_LS_RJT BUSY. Retry from timer routine %p", 2883 iport); 2884 2885 /* Retry again from the timer routine */ 2886 fdls->flags |= FNIC_FDLS_RETRY_FRAME; 2887 } else { 2888 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2889 "RFF_ID returned ELS_LS_RJT. Halting discovery %p", 2890 iport); 2891 if (iport->fabric.timer_pending) { 2892 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2893 "Canceling fabric disc timer %p\n", iport); 2894 fnic_del_fabric_timer_sync(fnic); 2895 } 2896 fdls->timer_pending = 0; 2897 fdls->retry_counter = 0; 2898 } 2899 break; 2900 default: 2901 break; 2902 } 2903 } 2904 2905 static void 2906 fdls_process_rft_id_rsp(struct fnic_iport_s *iport, 2907 struct fc_frame_header *fchdr) 2908 { 2909 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 2910 struct fc_std_rft_id *rft_rsp = (struct fc_std_rft_id *) fchdr; 2911 uint16_t rsp; 2912 uint8_t reason_code; 2913 struct fnic *fnic = iport->fnic; 2914 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 2915 2916 if (fdls_get_state(fdls) != FDLS_STATE_REGISTER_FC4_TYPES) { 2917 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2918 "RFT_ID resp recvd in state(%d). Dropping.", 2919 fdls_get_state(fdls)); 2920 return; 2921 } 2922 2923 if (iport->active_oxid_fabric_req != oxid) { 2924 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2925 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 2926 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 2927 return; 2928 } 2929 2930 2931 rsp = FNIC_STD_GET_FC_CT_CMD((&rft_rsp->fc_std_ct_hdr)); 2932 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2933 "0x%x: FDLS process RFT ID response: 0x%04x", iport->fcid, 2934 (uint32_t) rsp); 2935 2936 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 2937 2938 switch (rsp) { 2939 case FC_FS_ACC: 2940 if (iport->fabric.timer_pending) { 2941 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2942 "Canceling fabric disc timer %p\n", iport); 2943 fnic_del_fabric_timer_sync(fnic); 2944 } 2945 iport->fabric.timer_pending = 0; 2946 fdls->retry_counter = 0; 2947 fdls_send_register_fc4_features(iport); 2948 fdls_set_state((&iport->fabric), FDLS_STATE_REGISTER_FC4_FEATURES); 2949 break; 2950 case FC_FS_RJT: 2951 reason_code = rft_rsp->fc_std_ct_hdr.ct_reason; 2952 if (((reason_code == FC_FS_RJT_BSY) 2953 || (reason_code == FC_FS_RJT_UNABL)) 2954 && (fdls->retry_counter < FDLS_RETRY_COUNT)) { 2955 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2956 "0x%x: RFT_ID ret ELS_LS_RJT BUSY. Retry from timer routine", 2957 iport->fcid); 2958 2959 /* Retry again from the timer routine */ 2960 fdls->flags |= FNIC_FDLS_RETRY_FRAME; 2961 } else { 2962 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2963 "0x%x: RFT_ID REJ. Halting discovery reason %d expl %d", 2964 iport->fcid, reason_code, 2965 rft_rsp->fc_std_ct_hdr.ct_explan); 2966 if (iport->fabric.timer_pending) { 2967 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2968 "Canceling fabric disc timer %p\n", iport); 2969 fnic_del_fabric_timer_sync(fnic); 2970 } 2971 fdls->timer_pending = 0; 2972 fdls->retry_counter = 0; 2973 } 2974 break; 2975 default: 2976 break; 2977 } 2978 } 2979 2980 static void 2981 fdls_process_rpn_id_rsp(struct fnic_iport_s *iport, 2982 struct fc_frame_header *fchdr) 2983 { 2984 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 2985 struct fc_std_rpn_id *rpn_rsp = (struct fc_std_rpn_id *) fchdr; 2986 uint16_t rsp; 2987 uint8_t reason_code; 2988 struct fnic *fnic = iport->fnic; 2989 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 2990 2991 if (fdls_get_state(fdls) != FDLS_STATE_RPN_ID) { 2992 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2993 "RPN_ID resp recvd in state(%d). Dropping.", 2994 fdls_get_state(fdls)); 2995 return; 2996 } 2997 if (iport->active_oxid_fabric_req != oxid) { 2998 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 2999 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3000 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 3001 return; 3002 } 3003 3004 rsp = FNIC_STD_GET_FC_CT_CMD((&rpn_rsp->fc_std_ct_hdr)); 3005 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3006 "0x%x: FDLS process RPN ID response: 0x%04x", iport->fcid, 3007 (uint32_t) rsp); 3008 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3009 3010 switch (rsp) { 3011 case FC_FS_ACC: 3012 if (iport->fabric.timer_pending) { 3013 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3014 "Canceling fabric disc timer %p\n", iport); 3015 fnic_del_fabric_timer_sync(fnic); 3016 } 3017 iport->fabric.timer_pending = 0; 3018 fdls->retry_counter = 0; 3019 fdls_send_register_fc4_types(iport); 3020 fdls_set_state((&iport->fabric), FDLS_STATE_REGISTER_FC4_TYPES); 3021 break; 3022 case FC_FS_RJT: 3023 reason_code = rpn_rsp->fc_std_ct_hdr.ct_reason; 3024 if (((reason_code == FC_FS_RJT_BSY) 3025 || (reason_code == FC_FS_RJT_UNABL)) 3026 && (fdls->retry_counter < FDLS_RETRY_COUNT)) { 3027 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3028 "RPN_ID returned REJ BUSY. Retry from timer routine %p", 3029 iport); 3030 3031 /* Retry again from the timer routine */ 3032 fdls->flags |= FNIC_FDLS_RETRY_FRAME; 3033 } else { 3034 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3035 "RPN_ID ELS_LS_RJT. Halting discovery %p", iport); 3036 if (iport->fabric.timer_pending) { 3037 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3038 "Canceling fabric disc timer %p\n", iport); 3039 fnic_del_fabric_timer_sync(fnic); 3040 } 3041 fdls->timer_pending = 0; 3042 fdls->retry_counter = 0; 3043 } 3044 break; 3045 default: 3046 break; 3047 } 3048 } 3049 3050 static void 3051 fdls_process_scr_rsp(struct fnic_iport_s *iport, 3052 struct fc_frame_header *fchdr) 3053 { 3054 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 3055 struct fc_std_scr *scr_rsp = (struct fc_std_scr *) fchdr; 3056 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *) fchdr; 3057 struct fnic *fnic = iport->fnic; 3058 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3059 3060 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3061 "FDLS process SCR response: 0x%04x", 3062 (uint32_t) scr_rsp->scr.scr_cmd); 3063 3064 if (fdls_get_state(fdls) != FDLS_STATE_SCR) { 3065 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3066 "SCR resp recvd in state(%d). Dropping.", 3067 fdls_get_state(fdls)); 3068 return; 3069 } 3070 if (iport->active_oxid_fabric_req != oxid) { 3071 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3072 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3073 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 3074 } 3075 3076 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3077 3078 switch (scr_rsp->scr.scr_cmd) { 3079 case ELS_LS_ACC: 3080 atomic64_inc(&iport->iport_stats.fabric_scr_ls_accepts); 3081 if (iport->fabric.timer_pending) { 3082 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3083 "Canceling fabric disc timer %p\n", iport); 3084 fnic_del_fabric_timer_sync(fnic); 3085 } 3086 iport->fabric.timer_pending = 0; 3087 iport->fabric.retry_counter = 0; 3088 fdls_send_gpn_ft(iport, FDLS_STATE_GPN_FT); 3089 break; 3090 3091 case ELS_LS_RJT: 3092 atomic64_inc(&iport->iport_stats.fabric_scr_ls_rejects); 3093 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 3094 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 3095 && (fdls->retry_counter < FDLS_RETRY_COUNT)) { 3096 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3097 "SCR ELS_LS_RJT BUSY. Retry from timer routine %p", 3098 iport); 3099 /* Retry again from the timer routine */ 3100 fdls->flags |= FNIC_FDLS_RETRY_FRAME; 3101 } else { 3102 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3103 "SCR returned ELS_LS_RJT. Halting discovery %p", 3104 iport); 3105 if (iport->fabric.timer_pending) { 3106 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3107 "Canceling fabric disc timer %p\n", 3108 iport); 3109 fnic_del_fabric_timer_sync(fnic); 3110 } 3111 fdls->timer_pending = 0; 3112 fdls->retry_counter = 0; 3113 } 3114 break; 3115 3116 default: 3117 atomic64_inc(&iport->iport_stats.fabric_scr_misc_rejects); 3118 break; 3119 } 3120 } 3121 3122 static void 3123 fdls_process_gpn_ft_tgt_list(struct fnic_iport_s *iport, 3124 struct fc_frame_header *fchdr, int len) 3125 { 3126 struct fc_gpn_ft_rsp_iu *gpn_ft_tgt; 3127 struct fnic_tport_s *tport, *next; 3128 uint32_t fcid; 3129 uint64_t wwpn; 3130 int rem_len = len; 3131 u32 old_link_down_cnt = iport->fnic->link_down_cnt; 3132 struct fnic *fnic = iport->fnic; 3133 3134 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3135 "0x%x: FDLS process GPN_FT tgt list", iport->fcid); 3136 3137 gpn_ft_tgt = 3138 (struct fc_gpn_ft_rsp_iu *)((uint8_t *) fchdr + 3139 sizeof(struct fc_frame_header) 3140 + sizeof(struct fc_ct_hdr)); 3141 len -= sizeof(struct fc_frame_header) + sizeof(struct fc_ct_hdr); 3142 3143 while (rem_len > 0) { 3144 3145 fcid = ntoh24(gpn_ft_tgt->fcid); 3146 wwpn = be64_to_cpu(gpn_ft_tgt->wwpn); 3147 3148 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3149 "tport: 0x%x: ctrl:0x%x", fcid, gpn_ft_tgt->ctrl); 3150 3151 if (fcid == iport->fcid) { 3152 if (gpn_ft_tgt->ctrl & FC_NS_FID_LAST) 3153 break; 3154 gpn_ft_tgt++; 3155 rem_len -= sizeof(struct fc_gpn_ft_rsp_iu); 3156 continue; 3157 } 3158 3159 tport = fnic_find_tport_by_wwpn(iport, wwpn); 3160 if (!tport) { 3161 /* 3162 * New port registered with the switch or first time query 3163 */ 3164 tport = fdls_create_tport(iport, fcid, wwpn); 3165 if (!tport) 3166 return; 3167 } 3168 /* 3169 * check if this was an existing tport with same fcid 3170 * but whose wwpn has changed now ,then remove it and 3171 * create a new one 3172 */ 3173 if (tport->fcid != fcid) { 3174 fdls_delete_tport(iport, tport); 3175 tport = fdls_create_tport(iport, fcid, wwpn); 3176 if (!tport) 3177 return; 3178 } 3179 3180 /* 3181 * If this GPN_FT rsp is after RSCN then mark the tports which 3182 * matches with the new GPN_FT list, if some tport is not 3183 * found in GPN_FT we went to delete that tport later. 3184 */ 3185 if (fdls_get_state((&iport->fabric)) == FDLS_STATE_RSCN_GPN_FT) 3186 tport->flags |= FNIC_FDLS_TPORT_IN_GPN_FT_LIST; 3187 3188 if (gpn_ft_tgt->ctrl & FC_NS_FID_LAST) 3189 break; 3190 3191 gpn_ft_tgt++; 3192 rem_len -= sizeof(struct fc_gpn_ft_rsp_iu); 3193 } 3194 if (rem_len <= 0) { 3195 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3196 "GPN_FT response: malformed/corrupt frame rxlen: %d remlen: %d", 3197 len, rem_len); 3198 } 3199 3200 /*remove those ports which was not listed in GPN_FT */ 3201 if (fdls_get_state((&iport->fabric)) == FDLS_STATE_RSCN_GPN_FT) { 3202 list_for_each_entry_safe(tport, next, &iport->tport_list, links) { 3203 3204 if (!(tport->flags & FNIC_FDLS_TPORT_IN_GPN_FT_LIST)) { 3205 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3206 "Remove port: 0x%x not found in GPN_FT list", 3207 tport->fcid); 3208 fdls_delete_tport(iport, tport); 3209 } else { 3210 tport->flags &= ~FNIC_FDLS_TPORT_IN_GPN_FT_LIST; 3211 } 3212 if ((old_link_down_cnt != iport->fnic->link_down_cnt) 3213 || (iport->state != FNIC_IPORT_STATE_READY)) { 3214 return; 3215 } 3216 } 3217 } 3218 } 3219 3220 static void 3221 fdls_process_gpn_ft_rsp(struct fnic_iport_s *iport, 3222 struct fc_frame_header *fchdr, int len) 3223 { 3224 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 3225 struct fc_std_gpn_ft *gpn_ft_rsp = (struct fc_std_gpn_ft *) fchdr; 3226 uint16_t rsp; 3227 uint8_t reason_code; 3228 int count = 0; 3229 struct fnic_tport_s *tport, *next; 3230 u32 old_link_down_cnt = iport->fnic->link_down_cnt; 3231 struct fnic *fnic = iport->fnic; 3232 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3233 3234 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3235 "FDLS process GPN_FT response: iport state: %d len: %d", 3236 iport->state, len); 3237 3238 /* 3239 * GPNFT response :- 3240 * FDLS_STATE_GPN_FT : GPNFT send after SCR state 3241 * during fabric discovery(FNIC_IPORT_STATE_FABRIC_DISC) 3242 * FDLS_STATE_RSCN_GPN_FT : GPNFT send in response to RSCN 3243 * FDLS_STATE_SEND_GPNFT : GPNFT send after deleting a Target, 3244 * e.g. after receiving Target LOGO 3245 * FDLS_STATE_TGT_DISCOVERY :Target discovery is currently in progress 3246 * from previous GPNFT response,a new GPNFT response has come. 3247 */ 3248 if (!(((iport->state == FNIC_IPORT_STATE_FABRIC_DISC) 3249 && (fdls_get_state(fdls) == FDLS_STATE_GPN_FT)) 3250 || ((iport->state == FNIC_IPORT_STATE_READY) 3251 && ((fdls_get_state(fdls) == FDLS_STATE_RSCN_GPN_FT) 3252 || (fdls_get_state(fdls) == FDLS_STATE_SEND_GPNFT) 3253 || (fdls_get_state(fdls) == FDLS_STATE_TGT_DISCOVERY))))) { 3254 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3255 "GPNFT resp recvd in fab state(%d) iport_state(%d). Dropping.", 3256 fdls_get_state(fdls), iport->state); 3257 return; 3258 } 3259 3260 if (iport->active_oxid_fabric_req != oxid) { 3261 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3262 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3263 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 3264 } 3265 3266 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3267 3268 iport->state = FNIC_IPORT_STATE_READY; 3269 rsp = FNIC_STD_GET_FC_CT_CMD((&gpn_ft_rsp->fc_std_ct_hdr)); 3270 3271 switch (rsp) { 3272 3273 case FC_FS_ACC: 3274 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3275 "0x%x: GPNFT_RSP accept", iport->fcid); 3276 if (iport->fabric.timer_pending) { 3277 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3278 "0x%x: Canceling fabric disc timer\n", 3279 iport->fcid); 3280 fnic_del_fabric_timer_sync(fnic); 3281 } 3282 iport->fabric.timer_pending = 0; 3283 iport->fabric.retry_counter = 0; 3284 fdls_process_gpn_ft_tgt_list(iport, fchdr, len); 3285 3286 /* 3287 * iport state can change only if link down event happened 3288 * We don't need to undo fdls_process_gpn_ft_tgt_list, 3289 * that will be taken care in next link up event 3290 */ 3291 if (iport->state != FNIC_IPORT_STATE_READY) { 3292 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3293 "Halting target discovery: fab st: %d iport st: %d ", 3294 fdls_get_state(fdls), iport->state); 3295 break; 3296 } 3297 fdls_tgt_discovery_start(iport); 3298 break; 3299 3300 case FC_FS_RJT: 3301 reason_code = gpn_ft_rsp->fc_std_ct_hdr.ct_reason; 3302 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3303 "0x%x: GPNFT_RSP Reject reason: %d", iport->fcid, reason_code); 3304 3305 if (((reason_code == FC_FS_RJT_BSY) 3306 || (reason_code == FC_FS_RJT_UNABL)) 3307 && (fdls->retry_counter < FDLS_RETRY_COUNT)) { 3308 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3309 "0x%x: GPNFT_RSP ret REJ/BSY. Retry from timer routine", 3310 iport->fcid); 3311 /* Retry again from the timer routine */ 3312 fdls->flags |= FNIC_FDLS_RETRY_FRAME; 3313 } else { 3314 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3315 "0x%x: GPNFT_RSP reject", iport->fcid); 3316 if (iport->fabric.timer_pending) { 3317 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3318 "0x%x: Canceling fabric disc timer\n", 3319 iport->fcid); 3320 fnic_del_fabric_timer_sync(fnic); 3321 } 3322 iport->fabric.timer_pending = 0; 3323 iport->fabric.retry_counter = 0; 3324 /* 3325 * If GPN_FT ls_rjt then we should delete 3326 * all existing tports 3327 */ 3328 count = 0; 3329 list_for_each_entry_safe(tport, next, &iport->tport_list, 3330 links) { 3331 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3332 "GPN_FT_REJECT: Remove port: 0x%x", 3333 tport->fcid); 3334 fdls_delete_tport(iport, tport); 3335 if ((old_link_down_cnt != iport->fnic->link_down_cnt) 3336 || (iport->state != FNIC_IPORT_STATE_READY)) { 3337 return; 3338 } 3339 count++; 3340 } 3341 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3342 "GPN_FT_REJECT: Removed (0x%x) ports", count); 3343 } 3344 break; 3345 3346 default: 3347 break; 3348 } 3349 } 3350 3351 /** 3352 * fdls_process_fabric_logo_rsp - Handle an flogo response from the fcf 3353 * @iport: Handle to fnic iport 3354 * @fchdr: Incoming frame 3355 */ 3356 static void 3357 fdls_process_fabric_logo_rsp(struct fnic_iport_s *iport, 3358 struct fc_frame_header *fchdr) 3359 { 3360 struct fc_std_flogi *flogo_rsp = (struct fc_std_flogi *) fchdr; 3361 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 3362 struct fnic *fnic = iport->fnic; 3363 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3364 3365 if (iport->active_oxid_fabric_req != oxid) { 3366 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3367 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3368 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 3369 } 3370 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3371 3372 switch (flogo_rsp->els.fl_cmd) { 3373 case ELS_LS_ACC: 3374 if (iport->fabric.state != FDLS_STATE_FABRIC_LOGO) { 3375 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3376 "Flogo response. Fabric not in LOGO state. Dropping! %p", 3377 iport); 3378 return; 3379 } 3380 3381 iport->fabric.state = FDLS_STATE_FLOGO_DONE; 3382 iport->state = FNIC_IPORT_STATE_LINK_WAIT; 3383 3384 if (iport->fabric.timer_pending) { 3385 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3386 "iport 0x%p Canceling fabric disc timer\n", 3387 iport); 3388 fnic_del_fabric_timer_sync(fnic); 3389 } 3390 iport->fabric.timer_pending = 0; 3391 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3392 "Flogo response from Fabric for did: 0x%x", 3393 ntoh24(fchdr->fh_d_id)); 3394 return; 3395 3396 case ELS_LS_RJT: 3397 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3398 "Flogo response from Fabric for did: 0x%x returned ELS_LS_RJT", 3399 ntoh24(fchdr->fh_d_id)); 3400 return; 3401 3402 default: 3403 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3404 "FLOGO response not accepted or rejected: 0x%x", 3405 flogo_rsp->els.fl_cmd); 3406 } 3407 } 3408 3409 static void 3410 fdls_process_flogi_rsp(struct fnic_iport_s *iport, 3411 struct fc_frame_header *fchdr, void *rx_frame) 3412 { 3413 struct fnic_fdls_fabric_s *fabric = &iport->fabric; 3414 struct fc_std_flogi *flogi_rsp = (struct fc_std_flogi *) fchdr; 3415 uint8_t *fcid; 3416 uint16_t rdf_size; 3417 uint8_t fcmac[6] = { 0x0E, 0XFC, 0x00, 0x00, 0x00, 0x00 }; 3418 struct fnic *fnic = iport->fnic; 3419 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3420 3421 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3422 "0x%x: FDLS processing FLOGI response", iport->fcid); 3423 3424 if (fdls_get_state(fabric) != FDLS_STATE_FABRIC_FLOGI) { 3425 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3426 "FLOGI response received in state (%d). Dropping frame", 3427 fdls_get_state(fabric)); 3428 return; 3429 } 3430 if (iport->active_oxid_fabric_req != oxid) { 3431 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3432 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3433 fdls_get_state(fabric), oxid, iport->active_oxid_fabric_req); 3434 return; 3435 } 3436 3437 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3438 3439 switch (flogi_rsp->els.fl_cmd) { 3440 case ELS_LS_ACC: 3441 atomic64_inc(&iport->iport_stats.fabric_flogi_ls_accepts); 3442 if (iport->fabric.timer_pending) { 3443 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3444 "iport fcid: 0x%x Canceling fabric disc timer\n", 3445 iport->fcid); 3446 fnic_del_fabric_timer_sync(fnic); 3447 } 3448 3449 iport->fabric.timer_pending = 0; 3450 iport->fabric.retry_counter = 0; 3451 fcid = FNIC_STD_GET_D_ID(fchdr); 3452 iport->fcid = ntoh24(fcid); 3453 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3454 "0x%x: FLOGI response accepted", iport->fcid); 3455 3456 /* Learn the Service Params */ 3457 rdf_size = be16_to_cpu(FNIC_LOGI_RDF_SIZE(flogi_rsp->els)); 3458 if ((rdf_size >= FNIC_MIN_DATA_FIELD_SIZE) 3459 && (rdf_size < FNIC_FC_MAX_PAYLOAD_LEN)) 3460 iport->max_payload_size = min(rdf_size, 3461 iport->max_payload_size); 3462 3463 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3464 "max_payload_size from fabric: %u set: %d", rdf_size, 3465 iport->max_payload_size); 3466 3467 iport->r_a_tov = be32_to_cpu(FNIC_LOGI_R_A_TOV(flogi_rsp->els)); 3468 iport->e_d_tov = be32_to_cpu(FNIC_LOGI_E_D_TOV(flogi_rsp->els)); 3469 3470 if (FNIC_LOGI_FEATURES(flogi_rsp->els) & FNIC_FC_EDTOV_NSEC) 3471 iport->e_d_tov = iport->e_d_tov / FNIC_NSEC_TO_MSEC; 3472 3473 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3474 "From fabric: R_A_TOV: %d E_D_TOV: %d", 3475 iport->r_a_tov, iport->e_d_tov); 3476 3477 fc_host_fabric_name(iport->fnic->host) = 3478 get_unaligned_be64(&FNIC_LOGI_NODE_NAME(flogi_rsp->els)); 3479 fc_host_port_id(iport->fnic->host) = iport->fcid; 3480 3481 fnic_fdls_learn_fcoe_macs(iport, rx_frame, fcid); 3482 3483 if (fnic_fdls_register_portid(iport, iport->fcid, rx_frame) != 0) { 3484 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3485 "0x%x: FLOGI registration failed", iport->fcid); 3486 break; 3487 } 3488 3489 memcpy(&fcmac[3], fcid, 3); 3490 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3491 "Adding vNIC device MAC addr: %02x:%02x:%02x:%02x:%02x:%02x", 3492 fcmac[0], fcmac[1], fcmac[2], fcmac[3], fcmac[4], 3493 fcmac[5]); 3494 vnic_dev_add_addr(iport->fnic->vdev, fcmac); 3495 3496 if (fdls_get_state(fabric) == FDLS_STATE_FABRIC_FLOGI) { 3497 fnic_fdls_start_plogi(iport); 3498 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3499 "FLOGI response received. Starting PLOGI"); 3500 } else { 3501 /* From FDLS_STATE_FABRIC_FLOGI state fabric can only go to 3502 * FDLS_STATE_LINKDOWN 3503 * state, hence we don't have to worry about undoing: 3504 * the fnic_fdls_register_portid and vnic_dev_add_addr 3505 */ 3506 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3507 "FLOGI response received in state (%d). Dropping frame", 3508 fdls_get_state(fabric)); 3509 } 3510 break; 3511 3512 case ELS_LS_RJT: 3513 atomic64_inc(&iport->iport_stats.fabric_flogi_ls_rejects); 3514 if (fabric->retry_counter < iport->max_flogi_retries) { 3515 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3516 "FLOGI returned ELS_LS_RJT BUSY. Retry from timer routine %p", 3517 iport); 3518 3519 /* Retry Flogi again from the timer routine. */ 3520 fabric->flags |= FNIC_FDLS_RETRY_FRAME; 3521 3522 } else { 3523 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3524 "FLOGI returned ELS_LS_RJT. Halting discovery %p", 3525 iport); 3526 if (iport->fabric.timer_pending) { 3527 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3528 "iport 0x%p Canceling fabric disc timer\n", 3529 iport); 3530 fnic_del_fabric_timer_sync(fnic); 3531 } 3532 fabric->timer_pending = 0; 3533 fabric->retry_counter = 0; 3534 } 3535 break; 3536 3537 default: 3538 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3539 "FLOGI response not accepted: 0x%x", 3540 flogi_rsp->els.fl_cmd); 3541 atomic64_inc(&iport->iport_stats.fabric_flogi_misc_rejects); 3542 break; 3543 } 3544 } 3545 3546 static void 3547 fdls_process_fabric_plogi_rsp(struct fnic_iport_s *iport, 3548 struct fc_frame_header *fchdr) 3549 { 3550 struct fc_std_flogi *plogi_rsp = (struct fc_std_flogi *) fchdr; 3551 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *) fchdr; 3552 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 3553 struct fnic *fnic = iport->fnic; 3554 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3555 3556 if (fdls_get_state((&iport->fabric)) != FDLS_STATE_FABRIC_PLOGI) { 3557 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3558 "Fabric PLOGI response received in state (%d). Dropping frame", 3559 fdls_get_state(&iport->fabric)); 3560 return; 3561 } 3562 if (iport->active_oxid_fabric_req != oxid) { 3563 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3564 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3565 fdls_get_state(fdls), oxid, iport->active_oxid_fabric_req); 3566 return; 3567 } 3568 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3569 3570 switch (plogi_rsp->els.fl_cmd) { 3571 case ELS_LS_ACC: 3572 atomic64_inc(&iport->iport_stats.fabric_plogi_ls_accepts); 3573 if (iport->fabric.timer_pending) { 3574 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3575 "iport fcid: 0x%x fabric PLOGI response: Accepted\n", 3576 iport->fcid); 3577 fnic_del_fabric_timer_sync(fnic); 3578 } 3579 iport->fabric.timer_pending = 0; 3580 iport->fabric.retry_counter = 0; 3581 fdls_set_state(&iport->fabric, FDLS_STATE_RPN_ID); 3582 fdls_send_rpn_id(iport); 3583 break; 3584 case ELS_LS_RJT: 3585 atomic64_inc(&iport->iport_stats.fabric_plogi_ls_rejects); 3586 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 3587 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 3588 && (iport->fabric.retry_counter < iport->max_plogi_retries)) { 3589 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3590 "0x%x: Fabric PLOGI ELS_LS_RJT BUSY. Retry from timer routine", 3591 iport->fcid); 3592 } else { 3593 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3594 "0x%x: Fabric PLOGI ELS_LS_RJT. Halting discovery", 3595 iport->fcid); 3596 if (iport->fabric.timer_pending) { 3597 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3598 "iport fcid: 0x%x Canceling fabric disc timer\n", 3599 iport->fcid); 3600 fnic_del_fabric_timer_sync(fnic); 3601 } 3602 iport->fabric.timer_pending = 0; 3603 iport->fabric.retry_counter = 0; 3604 return; 3605 } 3606 break; 3607 default: 3608 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3609 "PLOGI response not accepted: 0x%x", 3610 plogi_rsp->els.fl_cmd); 3611 atomic64_inc(&iport->iport_stats.fabric_plogi_misc_rejects); 3612 break; 3613 } 3614 } 3615 3616 static void fdls_process_fdmi_plogi_rsp(struct fnic_iport_s *iport, 3617 struct fc_frame_header *fchdr) 3618 { 3619 struct fc_std_flogi *plogi_rsp = (struct fc_std_flogi *)fchdr; 3620 struct fc_std_els_rjt_rsp *els_rjt = (struct fc_std_els_rjt_rsp *)fchdr; 3621 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 3622 struct fnic *fnic = iport->fnic; 3623 u64 fdmi_tov; 3624 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3625 3626 if (iport->active_oxid_fdmi_plogi != oxid) { 3627 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3628 "Incorrect OXID in response. state: %d, oxid recvd: 0x%x, active oxid: 0x%x\n", 3629 fdls_get_state(fdls), oxid, iport->active_oxid_fdmi_plogi); 3630 return; 3631 } 3632 3633 iport->fabric.fdmi_pending &= ~FDLS_FDMI_PLOGI_PENDING; 3634 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_plogi); 3635 3636 if (ntoh24(fchdr->fh_s_id) == FC_FID_MGMT_SERV) { 3637 del_timer_sync(&iport->fabric.fdmi_timer); 3638 iport->fabric.fdmi_pending = 0; 3639 switch (plogi_rsp->els.fl_cmd) { 3640 case ELS_LS_ACC: 3641 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3642 "FDLS process fdmi PLOGI response status: ELS_LS_ACC\n"); 3643 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3644 "Sending fdmi registration for port 0x%x\n", 3645 iport->fcid); 3646 3647 fdls_fdmi_register_hba(iport); 3648 fdls_fdmi_register_pa(iport); 3649 fdmi_tov = jiffies + msecs_to_jiffies(5000); 3650 mod_timer(&iport->fabric.fdmi_timer, 3651 round_jiffies(fdmi_tov)); 3652 break; 3653 case ELS_LS_RJT: 3654 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3655 "Fabric FDMI PLOGI returned ELS_LS_RJT reason: 0x%x", 3656 els_rjt->rej.er_reason); 3657 3658 if (((els_rjt->rej.er_reason == ELS_RJT_BUSY) 3659 || (els_rjt->rej.er_reason == ELS_RJT_UNAB)) 3660 && (iport->fabric.fdmi_retry < 7)) { 3661 iport->fabric.fdmi_retry++; 3662 fdls_send_fdmi_plogi(iport); 3663 } 3664 break; 3665 default: 3666 break; 3667 } 3668 } 3669 } 3670 static void fdls_process_fdmi_reg_ack(struct fnic_iport_s *iport, 3671 struct fc_frame_header *fchdr, 3672 int rsp_type) 3673 { 3674 struct fnic *fnic = iport->fnic; 3675 uint16_t oxid; 3676 3677 if (!iport->fabric.fdmi_pending) { 3678 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 3679 "Received FDMI ack while not waiting: 0x%x\n", 3680 FNIC_STD_GET_OX_ID(fchdr)); 3681 return; 3682 } 3683 3684 oxid = FNIC_STD_GET_OX_ID(fchdr); 3685 3686 if ((iport->active_oxid_fdmi_rhba != oxid) && 3687 (iport->active_oxid_fdmi_rpa != oxid)) { 3688 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3689 "Incorrect OXID in response. oxid recvd: 0x%x, active oxids(rhba,rpa): 0x%x, 0x%x\n", 3690 oxid, iport->active_oxid_fdmi_rhba, iport->active_oxid_fdmi_rpa); 3691 return; 3692 } 3693 if (FNIC_FRAME_TYPE(oxid) == FNIC_FRAME_TYPE_FDMI_RHBA) { 3694 iport->fabric.fdmi_pending &= ~FDLS_FDMI_REG_HBA_PENDING; 3695 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_rhba); 3696 } else { 3697 iport->fabric.fdmi_pending &= ~FDLS_FDMI_RPA_PENDING; 3698 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_rpa); 3699 } 3700 3701 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3702 "iport fcid: 0x%x: Received FDMI registration ack\n", 3703 iport->fcid); 3704 3705 if (!iport->fabric.fdmi_pending) { 3706 del_timer_sync(&iport->fabric.fdmi_timer); 3707 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3708 "iport fcid: 0x%x: Canceling FDMI timer\n", 3709 iport->fcid); 3710 } 3711 } 3712 3713 static void fdls_process_fdmi_abts_rsp(struct fnic_iport_s *iport, 3714 struct fc_frame_header *fchdr) 3715 { 3716 uint32_t s_id; 3717 struct fnic *fnic = iport->fnic; 3718 uint16_t oxid; 3719 3720 s_id = ntoh24(FNIC_STD_GET_S_ID(fchdr)); 3721 3722 if (!(s_id != FC_FID_MGMT_SERV)) { 3723 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3724 "Received abts rsp with invalid SID: 0x%x. Dropping frame", 3725 s_id); 3726 return; 3727 } 3728 3729 oxid = FNIC_STD_GET_OX_ID(fchdr); 3730 3731 switch (FNIC_FRAME_TYPE(oxid)) { 3732 case FNIC_FRAME_TYPE_FDMI_PLOGI: 3733 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_plogi); 3734 break; 3735 case FNIC_FRAME_TYPE_FDMI_RHBA: 3736 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_rhba); 3737 break; 3738 case FNIC_FRAME_TYPE_FDMI_RPA: 3739 fdls_free_oxid(iport, oxid, &iport->active_oxid_fdmi_rpa); 3740 break; 3741 default: 3742 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3743 "Received abts rsp with invalid oxid: 0x%x. Dropping frame", 3744 oxid); 3745 break; 3746 } 3747 3748 del_timer_sync(&iport->fabric.fdmi_timer); 3749 iport->fabric.fdmi_pending &= ~FDLS_FDMI_ABORT_PENDING; 3750 3751 fdls_send_fdmi_plogi(iport); 3752 } 3753 3754 static void 3755 fdls_process_fabric_abts_rsp(struct fnic_iport_s *iport, 3756 struct fc_frame_header *fchdr) 3757 { 3758 uint32_t s_id; 3759 struct fc_std_abts_ba_acc *ba_acc = (struct fc_std_abts_ba_acc *)fchdr; 3760 struct fc_std_abts_ba_rjt *ba_rjt; 3761 uint32_t fabric_state = iport->fabric.state; 3762 struct fnic *fnic = iport->fnic; 3763 int frame_type; 3764 uint16_t oxid; 3765 3766 s_id = ntoh24(fchdr->fh_s_id); 3767 ba_rjt = (struct fc_std_abts_ba_rjt *) fchdr; 3768 3769 if (!((s_id == FC_FID_DIR_SERV) || (s_id == FC_FID_FLOGI) 3770 || (s_id == FC_FID_FCTRL))) { 3771 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3772 "Received abts rsp with invalid SID: 0x%x. Dropping frame", 3773 s_id); 3774 return; 3775 } 3776 3777 oxid = FNIC_STD_GET_OX_ID(fchdr); 3778 if (iport->active_oxid_fabric_req != oxid) { 3779 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3780 "Received abts rsp with invalid oxid: 0x%x. Dropping frame", 3781 oxid); 3782 return; 3783 } 3784 3785 if (iport->fabric.timer_pending) { 3786 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3787 "Canceling fabric disc timer %p\n", iport); 3788 fnic_del_fabric_timer_sync(fnic); 3789 } 3790 iport->fabric.timer_pending = 0; 3791 iport->fabric.flags &= ~FNIC_FDLS_FABRIC_ABORT_ISSUED; 3792 3793 if (fchdr->fh_r_ctl == FC_RCTL_BA_ACC) { 3794 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3795 "Received abts rsp BA_ACC for fabric_state: %d OX_ID: 0x%x", 3796 fabric_state, be16_to_cpu(ba_acc->acc.ba_ox_id)); 3797 } else if (fchdr->fh_r_ctl == FC_RCTL_BA_RJT) { 3798 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3799 "BA_RJT fs: %d OX_ID: 0x%x rc: 0x%x rce: 0x%x", 3800 fabric_state, FNIC_STD_GET_OX_ID(&ba_rjt->fchdr), 3801 ba_rjt->rjt.br_reason, ba_rjt->rjt.br_explan); 3802 } 3803 3804 frame_type = FNIC_FRAME_TYPE(oxid); 3805 fdls_free_oxid(iport, oxid, &iport->active_oxid_fabric_req); 3806 3807 /* currently error handling/retry logic is same for ABTS BA_ACC & BA_RJT */ 3808 switch (frame_type) { 3809 case FNIC_FRAME_TYPE_FABRIC_FLOGI: 3810 if (iport->fabric.retry_counter < iport->max_flogi_retries) 3811 fdls_send_fabric_flogi(iport); 3812 else 3813 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3814 "Exceeded max FLOGI retries"); 3815 break; 3816 case FNIC_FRAME_TYPE_FABRIC_LOGO: 3817 if (iport->fabric.retry_counter < FABRIC_LOGO_MAX_RETRY) 3818 fdls_send_fabric_logo(iport); 3819 break; 3820 case FNIC_FRAME_TYPE_FABRIC_PLOGI: 3821 if (iport->fabric.retry_counter < iport->max_plogi_retries) 3822 fdls_send_fabric_plogi(iport); 3823 else 3824 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3825 "Exceeded max PLOGI retries"); 3826 break; 3827 case FNIC_FRAME_TYPE_FABRIC_RPN: 3828 if (iport->fabric.retry_counter < FDLS_RETRY_COUNT) 3829 fdls_send_rpn_id(iport); 3830 else 3831 /* go back to fabric Plogi */ 3832 fnic_fdls_start_plogi(iport); 3833 break; 3834 case FNIC_FRAME_TYPE_FABRIC_SCR: 3835 if (iport->fabric.retry_counter < FDLS_RETRY_COUNT) 3836 fdls_send_scr(iport); 3837 else { 3838 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3839 "SCR exhausted retries. Start fabric PLOGI %p", 3840 iport); 3841 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 3842 } 3843 break; 3844 case FNIC_FRAME_TYPE_FABRIC_RFT: 3845 if (iport->fabric.retry_counter < FDLS_RETRY_COUNT) 3846 fdls_send_register_fc4_types(iport); 3847 else { 3848 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3849 "RFT exhausted retries. Start fabric PLOGI %p", 3850 iport); 3851 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 3852 } 3853 break; 3854 case FNIC_FRAME_TYPE_FABRIC_RFF: 3855 if (iport->fabric.retry_counter < FDLS_RETRY_COUNT) 3856 fdls_send_register_fc4_features(iport); 3857 else { 3858 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3859 "RFF exhausted retries. Start fabric PLOGI %p", 3860 iport); 3861 fnic_fdls_start_plogi(iport); /* go back to fabric Plogi */ 3862 } 3863 break; 3864 case FNIC_FRAME_TYPE_FABRIC_GPN_FT: 3865 if (iport->fabric.retry_counter <= FDLS_RETRY_COUNT) 3866 fdls_send_gpn_ft(iport, fabric_state); 3867 else 3868 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3869 "GPN FT exhausted retries. Start fabric PLOGI %p", 3870 iport); 3871 break; 3872 default: 3873 /* 3874 * We should not be here since we already validated rx oxid with 3875 * our active_oxid_fabric_req 3876 */ 3877 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3878 "Invalid OXID/active oxid 0x%x\n", oxid); 3879 WARN_ON(true); 3880 return; 3881 } 3882 } 3883 3884 static void 3885 fdls_process_abts_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr) 3886 { 3887 uint8_t *frame; 3888 struct fc_std_abts_ba_acc *pba_acc; 3889 uint32_t nport_id; 3890 uint16_t oxid = FNIC_STD_GET_OX_ID(fchdr); 3891 struct fnic_tport_s *tport; 3892 struct fnic *fnic = iport->fnic; 3893 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 3894 sizeof(struct fc_std_abts_ba_acc); 3895 3896 nport_id = ntoh24(fchdr->fh_s_id); 3897 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3898 "Received abort from SID 0x%8x", nport_id); 3899 3900 tport = fnic_find_tport_by_fcid(iport, nport_id); 3901 if (tport) { 3902 if (tport->active_oxid == oxid) { 3903 tport->flags |= FNIC_FDLS_TGT_ABORT_ISSUED; 3904 fdls_free_oxid(iport, oxid, &tport->active_oxid); 3905 } 3906 } 3907 3908 frame = fdls_alloc_frame(iport); 3909 if (frame == NULL) { 3910 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 3911 "0x%x: Failed to allocate frame to send response for ABTS req", 3912 iport->fcid); 3913 return; 3914 } 3915 3916 pba_acc = (struct fc_std_abts_ba_acc *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 3917 *pba_acc = (struct fc_std_abts_ba_acc) { 3918 .fchdr = {.fh_r_ctl = FC_RCTL_BA_ACC, 3919 .fh_f_ctl = {FNIC_FCP_RSP_FCTL, 0, 0}}, 3920 .acc = {.ba_low_seq_cnt = 0, .ba_high_seq_cnt = cpu_to_be16(0xFFFF)} 3921 }; 3922 3923 FNIC_STD_SET_S_ID(pba_acc->fchdr, fchdr->fh_d_id); 3924 FNIC_STD_SET_D_ID(pba_acc->fchdr, fchdr->fh_s_id); 3925 FNIC_STD_SET_OX_ID(pba_acc->fchdr, FNIC_STD_GET_OX_ID(fchdr)); 3926 FNIC_STD_SET_RX_ID(pba_acc->fchdr, FNIC_STD_GET_RX_ID(fchdr)); 3927 3928 pba_acc->acc.ba_rx_id = cpu_to_be16(FNIC_STD_GET_RX_ID(fchdr)); 3929 pba_acc->acc.ba_ox_id = cpu_to_be16(FNIC_STD_GET_OX_ID(fchdr)); 3930 3931 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3932 "0x%x: FDLS send BA ACC with oxid: 0x%x", 3933 iport->fcid, oxid); 3934 3935 fnic_send_fcoe_frame(iport, frame, frame_size); 3936 } 3937 3938 static void 3939 fdls_process_unsupported_els_req(struct fnic_iport_s *iport, 3940 struct fc_frame_header *fchdr) 3941 { 3942 uint8_t *frame; 3943 struct fc_std_els_rjt_rsp *pls_rsp; 3944 uint16_t oxid; 3945 uint32_t d_id = ntoh24(fchdr->fh_d_id); 3946 struct fnic *fnic = iport->fnic; 3947 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 3948 sizeof(struct fc_std_els_rjt_rsp); 3949 3950 if (iport->fcid != d_id) { 3951 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3952 "Dropping unsupported ELS with illegal frame bits 0x%x\n", 3953 d_id); 3954 atomic64_inc(&iport->iport_stats.unsupported_frames_dropped); 3955 return; 3956 } 3957 3958 if ((iport->state != FNIC_IPORT_STATE_READY) 3959 && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) { 3960 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3961 "Dropping unsupported ELS request in iport state: %d", 3962 iport->state); 3963 atomic64_inc(&iport->iport_stats.unsupported_frames_dropped); 3964 return; 3965 } 3966 3967 frame = fdls_alloc_frame(iport); 3968 if (frame == NULL) { 3969 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 3970 "Failed to allocate frame to send response to unsupported ELS request"); 3971 return; 3972 } 3973 3974 pls_rsp = (struct fc_std_els_rjt_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 3975 fdls_init_els_rjt_frame(frame, iport); 3976 3977 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 3978 "0x%x: Process unsupported ELS request from SID: 0x%x", 3979 iport->fcid, ntoh24(fchdr->fh_s_id)); 3980 3981 /* We don't support this ELS request, send a reject */ 3982 pls_rsp->rej.er_reason = 0x0B; 3983 pls_rsp->rej.er_explan = 0x0; 3984 pls_rsp->rej.er_vendor = 0x0; 3985 3986 FNIC_STD_SET_S_ID(pls_rsp->fchdr, fchdr->fh_d_id); 3987 FNIC_STD_SET_D_ID(pls_rsp->fchdr, fchdr->fh_s_id); 3988 oxid = FNIC_STD_GET_OX_ID(fchdr); 3989 FNIC_STD_SET_OX_ID(pls_rsp->fchdr, oxid); 3990 3991 fnic_send_fcoe_frame(iport, frame, frame_size); 3992 } 3993 3994 static void 3995 fdls_process_rls_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr) 3996 { 3997 uint8_t *frame; 3998 struct fc_std_rls_acc *prls_acc_rsp; 3999 uint16_t oxid; 4000 struct fnic *fnic = iport->fnic; 4001 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 4002 sizeof(struct fc_std_rls_acc); 4003 4004 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4005 "Process RLS request %d", iport->fnic->fnic_num); 4006 4007 if ((iport->state != FNIC_IPORT_STATE_READY) 4008 && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) { 4009 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4010 "Received RLS req in iport state: %d. Dropping the frame.", 4011 iport->state); 4012 return; 4013 } 4014 4015 frame = fdls_alloc_frame(iport); 4016 if (frame == NULL) { 4017 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4018 "Failed to allocate frame to send RLS accept"); 4019 return; 4020 } 4021 prls_acc_rsp = (struct fc_std_rls_acc *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 4022 4023 FNIC_STD_SET_S_ID(prls_acc_rsp->fchdr, fchdr->fh_d_id); 4024 FNIC_STD_SET_D_ID(prls_acc_rsp->fchdr, fchdr->fh_s_id); 4025 4026 oxid = FNIC_STD_GET_OX_ID(fchdr); 4027 FNIC_STD_SET_OX_ID(prls_acc_rsp->fchdr, oxid); 4028 FNIC_STD_SET_RX_ID(prls_acc_rsp->fchdr, FNIC_UNASSIGNED_RXID); 4029 4030 FNIC_STD_SET_F_CTL(prls_acc_rsp->fchdr, FNIC_ELS_REP_FCTL << 16); 4031 FNIC_STD_SET_R_CTL(prls_acc_rsp->fchdr, FC_RCTL_ELS_REP); 4032 FNIC_STD_SET_TYPE(prls_acc_rsp->fchdr, FC_TYPE_ELS); 4033 4034 prls_acc_rsp->els.rls_cmd = ELS_LS_ACC; 4035 prls_acc_rsp->els.rls_lesb.lesb_link_fail = 4036 cpu_to_be32(iport->fnic->link_down_cnt); 4037 4038 fnic_send_fcoe_frame(iport, frame, frame_size); 4039 } 4040 4041 static void 4042 fdls_process_els_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr, 4043 uint32_t len) 4044 { 4045 uint8_t *frame; 4046 struct fc_std_els_acc_rsp *pels_acc; 4047 uint16_t oxid; 4048 uint8_t *fc_payload; 4049 uint8_t type; 4050 struct fnic *fnic = iport->fnic; 4051 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET; 4052 4053 fc_payload = (uint8_t *) fchdr + sizeof(struct fc_frame_header); 4054 type = *fc_payload; 4055 4056 if ((iport->state != FNIC_IPORT_STATE_READY) 4057 && (iport->state != FNIC_IPORT_STATE_FABRIC_DISC)) { 4058 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4059 "Dropping ELS frame type: 0x%x in iport state: %d", 4060 type, iport->state); 4061 return; 4062 } 4063 switch (type) { 4064 case ELS_ECHO: 4065 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4066 "sending LS_ACC for ECHO request %d\n", 4067 iport->fnic->fnic_num); 4068 break; 4069 4070 case ELS_RRQ: 4071 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4072 "sending LS_ACC for RRQ request %d\n", 4073 iport->fnic->fnic_num); 4074 break; 4075 4076 default: 4077 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4078 "sending LS_ACC for 0x%x ELS frame\n", type); 4079 break; 4080 } 4081 4082 frame = fdls_alloc_frame(iport); 4083 if (frame == NULL) { 4084 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4085 "Failed to allocate frame to send ELS response for 0x%x", 4086 type); 4087 return; 4088 } 4089 4090 if (type == ELS_ECHO) { 4091 /* Brocade sends a longer payload, copy all frame back */ 4092 memcpy(frame, fchdr, len); 4093 } 4094 4095 pels_acc = (struct fc_std_els_acc_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 4096 fdls_init_els_acc_frame(frame, iport); 4097 4098 FNIC_STD_SET_D_ID(pels_acc->fchdr, fchdr->fh_s_id); 4099 4100 oxid = FNIC_STD_GET_OX_ID(fchdr); 4101 FNIC_STD_SET_OX_ID(pels_acc->fchdr, oxid); 4102 4103 if (type == ELS_ECHO) 4104 frame_size += len; 4105 else 4106 frame_size += sizeof(struct fc_std_els_acc_rsp); 4107 4108 fnic_send_fcoe_frame(iport, frame, frame_size); 4109 } 4110 4111 static void 4112 fdls_process_tgt_abts_rsp(struct fnic_iport_s *iport, 4113 struct fc_frame_header *fchdr) 4114 { 4115 uint32_t s_id; 4116 struct fnic_tport_s *tport; 4117 uint32_t tport_state; 4118 struct fc_std_abts_ba_acc *ba_acc; 4119 struct fc_std_abts_ba_rjt *ba_rjt; 4120 uint16_t oxid; 4121 struct fnic *fnic = iport->fnic; 4122 int frame_type; 4123 4124 s_id = ntoh24(fchdr->fh_s_id); 4125 ba_acc = (struct fc_std_abts_ba_acc *)fchdr; 4126 ba_rjt = (struct fc_std_abts_ba_rjt *)fchdr; 4127 4128 tport = fnic_find_tport_by_fcid(iport, s_id); 4129 if (!tport) { 4130 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4131 "Received tgt abts rsp with invalid SID: 0x%x", s_id); 4132 return; 4133 } 4134 if (tport->timer_pending) { 4135 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4136 "tport 0x%p Canceling fabric disc timer\n", tport); 4137 fnic_del_tport_timer_sync(fnic, tport); 4138 } 4139 if (iport->state != FNIC_IPORT_STATE_READY) { 4140 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4141 "Received tgt abts rsp in iport state(%d). Dropping.", 4142 iport->state); 4143 return; 4144 } 4145 tport->timer_pending = 0; 4146 tport->flags &= ~FNIC_FDLS_TGT_ABORT_ISSUED; 4147 tport_state = tport->state; 4148 oxid = FNIC_STD_GET_OX_ID(fchdr); 4149 4150 /*This abort rsp is for ADISC */ 4151 frame_type = FNIC_FRAME_TYPE(oxid); 4152 switch (frame_type) { 4153 case FNIC_FRAME_TYPE_TGT_ADISC: 4154 if (fchdr->fh_r_ctl == FC_RCTL_BA_ACC) { 4155 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4156 "OX_ID: 0x%x tgt_fcid: 0x%x rcvd tgt adisc abts resp BA_ACC", 4157 be16_to_cpu(ba_acc->acc.ba_ox_id), 4158 tport->fcid); 4159 } else if (fchdr->fh_r_ctl == FC_RCTL_BA_RJT) { 4160 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4161 "ADISC BA_RJT rcvd tport_fcid: 0x%x tport_state: %d ", 4162 tport->fcid, tport_state); 4163 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4164 "reason code: 0x%x reason code explanation:0x%x ", 4165 ba_rjt->rjt.br_reason, 4166 ba_rjt->rjt.br_explan); 4167 } 4168 if ((tport->retry_counter < FDLS_RETRY_COUNT) 4169 && (fchdr->fh_r_ctl == FC_RCTL_BA_ACC)) { 4170 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4171 fdls_send_tgt_adisc(iport, tport); 4172 return; 4173 } 4174 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4175 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4176 "ADISC not responding. Deleting target port: 0x%x", 4177 tport->fcid); 4178 fdls_delete_tport(iport, tport); 4179 /* Restart discovery of targets */ 4180 if ((iport->state == FNIC_IPORT_STATE_READY) 4181 && (iport->fabric.state != FDLS_STATE_SEND_GPNFT) 4182 && (iport->fabric.state != FDLS_STATE_RSCN_GPN_FT)) { 4183 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT); 4184 } 4185 break; 4186 case FNIC_FRAME_TYPE_TGT_PLOGI: 4187 if (fchdr->fh_r_ctl == FC_RCTL_BA_ACC) { 4188 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4189 "Received tgt PLOGI abts response BA_ACC tgt_fcid: 0x%x", 4190 tport->fcid); 4191 } else if (fchdr->fh_r_ctl == FC_RCTL_BA_RJT) { 4192 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4193 "PLOGI BA_RJT received for tport_fcid: 0x%x OX_ID: 0x%x", 4194 tport->fcid, FNIC_STD_GET_OX_ID(fchdr)); 4195 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4196 "reason code: 0x%x reason code explanation: 0x%x", 4197 ba_rjt->rjt.br_reason, 4198 ba_rjt->rjt.br_explan); 4199 } 4200 if ((tport->retry_counter < iport->max_plogi_retries) 4201 && (fchdr->fh_r_ctl == FC_RCTL_BA_ACC)) { 4202 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4203 fdls_send_tgt_plogi(iport, tport); 4204 return; 4205 } 4206 4207 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4208 fdls_delete_tport(iport, tport); 4209 /* Restart discovery of targets */ 4210 if ((iport->state == FNIC_IPORT_STATE_READY) 4211 && (iport->fabric.state != FDLS_STATE_SEND_GPNFT) 4212 && (iport->fabric.state != FDLS_STATE_RSCN_GPN_FT)) { 4213 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT); 4214 } 4215 break; 4216 case FNIC_FRAME_TYPE_TGT_PRLI: 4217 if (fchdr->fh_r_ctl == FC_RCTL_BA_ACC) { 4218 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4219 "0x%x: Received tgt PRLI abts response BA_ACC", 4220 tport->fcid); 4221 } else if (fchdr->fh_r_ctl == FC_RCTL_BA_RJT) { 4222 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4223 "PRLI BA_RJT received for tport_fcid: 0x%x OX_ID: 0x%x ", 4224 tport->fcid, FNIC_STD_GET_OX_ID(fchdr)); 4225 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4226 "reason code: 0x%x reason code explanation: 0x%x", 4227 ba_rjt->rjt.br_reason, 4228 ba_rjt->rjt.br_explan); 4229 } 4230 if ((tport->retry_counter < FDLS_RETRY_COUNT) 4231 && (fchdr->fh_r_ctl == FC_RCTL_BA_ACC)) { 4232 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4233 fdls_send_tgt_prli(iport, tport); 4234 return; 4235 } 4236 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4237 fdls_send_tgt_plogi(iport, tport); /* go back to plogi */ 4238 fdls_set_tport_state(tport, FDLS_TGT_STATE_PLOGI); 4239 break; 4240 default: 4241 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4242 "Received ABTS response for unknown frame %p", iport); 4243 break; 4244 } 4245 4246 } 4247 4248 static void 4249 fdls_process_plogi_req(struct fnic_iport_s *iport, 4250 struct fc_frame_header *fchdr) 4251 { 4252 uint8_t *frame; 4253 struct fc_std_els_rjt_rsp *pplogi_rsp; 4254 uint16_t oxid; 4255 uint32_t d_id = ntoh24(fchdr->fh_d_id); 4256 struct fnic *fnic = iport->fnic; 4257 uint16_t frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 4258 sizeof(struct fc_std_els_rjt_rsp); 4259 4260 if (iport->fcid != d_id) { 4261 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4262 "Received PLOGI with illegal frame bits. Dropping frame from 0x%x", 4263 d_id); 4264 return; 4265 } 4266 4267 if (iport->state != FNIC_IPORT_STATE_READY) { 4268 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4269 "Received PLOGI request in iport state: %d Dropping frame", 4270 iport->state); 4271 return; 4272 } 4273 4274 frame = fdls_alloc_frame(iport); 4275 if (frame == NULL) { 4276 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4277 "Failed to allocate frame to send response to PLOGI request"); 4278 return; 4279 } 4280 4281 pplogi_rsp = (struct fc_std_els_rjt_rsp *) (frame + FNIC_ETH_FCOE_HDRS_OFFSET); 4282 fdls_init_els_rjt_frame(frame, iport); 4283 4284 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4285 "0x%x: Process PLOGI request from SID: 0x%x", 4286 iport->fcid, ntoh24(fchdr->fh_s_id)); 4287 4288 /* We don't support PLOGI request, send a reject */ 4289 pplogi_rsp->rej.er_reason = 0x0B; 4290 pplogi_rsp->rej.er_explan = 0x0; 4291 pplogi_rsp->rej.er_vendor = 0x0; 4292 4293 FNIC_STD_SET_S_ID(pplogi_rsp->fchdr, fchdr->fh_d_id); 4294 FNIC_STD_SET_D_ID(pplogi_rsp->fchdr, fchdr->fh_s_id); 4295 oxid = FNIC_STD_GET_OX_ID(fchdr); 4296 FNIC_STD_SET_OX_ID(pplogi_rsp->fchdr, oxid); 4297 4298 fnic_send_fcoe_frame(iport, frame, frame_size); 4299 } 4300 4301 static void 4302 fdls_process_logo_req(struct fnic_iport_s *iport, struct fc_frame_header *fchdr) 4303 { 4304 struct fc_std_logo *logo = (struct fc_std_logo *)fchdr; 4305 uint32_t nport_id; 4306 uint64_t nport_name; 4307 struct fnic_tport_s *tport; 4308 struct fnic *fnic = iport->fnic; 4309 uint16_t oxid; 4310 4311 nport_id = ntoh24(logo->els.fl_n_port_id); 4312 nport_name = be64_to_cpu(logo->els.fl_n_port_wwn); 4313 4314 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4315 "Process LOGO request from fcid: 0x%x", nport_id); 4316 4317 if (iport->state != FNIC_IPORT_STATE_READY) { 4318 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4319 "Dropping LOGO req from 0x%x in iport state: %d", 4320 nport_id, iport->state); 4321 return; 4322 } 4323 4324 tport = fnic_find_tport_by_fcid(iport, nport_id); 4325 4326 if (!tport) { 4327 /* We are not logged in with the nport, log and drop... */ 4328 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4329 "Received LOGO from an nport not logged in: 0x%x(0x%llx)", 4330 nport_id, nport_name); 4331 return; 4332 } 4333 if (tport->fcid != nport_id) { 4334 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4335 "Received LOGO with invalid target port fcid: 0x%x(0x%llx)", 4336 nport_id, nport_name); 4337 return; 4338 } 4339 if (tport->timer_pending) { 4340 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4341 "tport fcid 0x%x: Canceling disc timer\n", 4342 tport->fcid); 4343 fnic_del_tport_timer_sync(fnic, tport); 4344 tport->timer_pending = 0; 4345 } 4346 4347 /* got a logo in response to adisc to a target which has logged out */ 4348 if (tport->state == FDLS_TGT_STATE_ADISC) { 4349 tport->retry_counter = 0; 4350 oxid = tport->active_oxid; 4351 fdls_free_oxid(iport, oxid, &tport->active_oxid); 4352 fdls_delete_tport(iport, tport); 4353 fdls_send_logo_resp(iport, &logo->fchdr); 4354 if ((iport->state == FNIC_IPORT_STATE_READY) 4355 && (fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT) 4356 && (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) { 4357 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4358 "Sending GPNFT in response to LOGO from Target:0x%x", 4359 nport_id); 4360 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT); 4361 return; 4362 } 4363 } else { 4364 fdls_delete_tport(iport, tport); 4365 } 4366 if (iport->state == FNIC_IPORT_STATE_READY) { 4367 fdls_send_logo_resp(iport, &logo->fchdr); 4368 if ((fdls_get_state(&iport->fabric) != FDLS_STATE_SEND_GPNFT) && 4369 (fdls_get_state(&iport->fabric) != FDLS_STATE_RSCN_GPN_FT)) { 4370 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4371 "Sending GPNFT in response to LOGO from Target:0x%x", 4372 nport_id); 4373 fdls_send_gpn_ft(iport, FDLS_STATE_SEND_GPNFT); 4374 } 4375 } 4376 } 4377 4378 static void 4379 fdls_process_rscn(struct fnic_iport_s *iport, struct fc_frame_header *fchdr) 4380 { 4381 struct fc_std_rscn *rscn; 4382 struct fc_els_rscn_page *rscn_port = NULL; 4383 int num_ports; 4384 struct fnic_tport_s *tport, *next; 4385 uint32_t nport_id; 4386 uint8_t fcid[3]; 4387 int newports = 0; 4388 struct fnic_fdls_fabric_s *fdls = &iport->fabric; 4389 struct fnic *fnic = iport->fnic; 4390 int rscn_type = NOT_PC_RSCN; 4391 uint32_t sid = ntoh24(fchdr->fh_s_id); 4392 unsigned long reset_fnic_list_lock_flags = 0; 4393 uint16_t rscn_payload_len; 4394 4395 atomic64_inc(&iport->iport_stats.num_rscns); 4396 4397 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4398 "FDLS process RSCN %p", iport); 4399 4400 if (iport->state != FNIC_IPORT_STATE_READY) { 4401 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4402 "FDLS RSCN received in state(%d). Dropping", 4403 fdls_get_state(fdls)); 4404 return; 4405 } 4406 4407 rscn = (struct fc_std_rscn *)fchdr; 4408 rscn_payload_len = be16_to_cpu(rscn->els.rscn_plen); 4409 4410 /* frame validation */ 4411 if ((rscn_payload_len % 4 != 0) || (rscn_payload_len < 8) 4412 || (rscn_payload_len > 1024) 4413 || (rscn->els.rscn_page_len != 4)) { 4414 num_ports = 0; 4415 if ((rscn_payload_len == 0xFFFF) 4416 && (sid == FC_FID_FCTRL)) { 4417 rscn_type = PC_RSCN; 4418 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4419 "pcrscn: PCRSCN received. sid: 0x%x payload len: 0x%x", 4420 sid, rscn_payload_len); 4421 } else { 4422 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4423 "RSCN payload_len: 0x%x page_len: 0x%x", 4424 rscn_payload_len, rscn->els.rscn_page_len); 4425 /* if this happens then we need to send ADISC to all the tports. */ 4426 list_for_each_entry_safe(tport, next, &iport->tport_list, links) { 4427 if (tport->state == FDLS_TGT_STATE_READY) 4428 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC; 4429 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4430 "RSCN for port id: 0x%x", tport->fcid); 4431 } 4432 } /* end else */ 4433 } else { 4434 num_ports = (rscn_payload_len - 4) / rscn->els.rscn_page_len; 4435 rscn_port = (struct fc_els_rscn_page *)(rscn + 1); 4436 } 4437 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4438 "RSCN received for num_ports: %d payload_len: %d page_len: %d ", 4439 num_ports, rscn_payload_len, rscn->els.rscn_page_len); 4440 4441 /* 4442 * RSCN have at least one Port_ID page , but may not have any port_id 4443 * in it. If no port_id is specified in the Port_ID page , we send 4444 * ADISC to all the tports 4445 */ 4446 4447 while (num_ports) { 4448 4449 memcpy(fcid, rscn_port->rscn_fid, 3); 4450 4451 nport_id = ntoh24(fcid); 4452 rscn_port++; 4453 num_ports--; 4454 /* if this happens then we need to send ADISC to all the tports. */ 4455 if (nport_id == 0) { 4456 list_for_each_entry_safe(tport, next, &iport->tport_list, 4457 links) { 4458 if (tport->state == FDLS_TGT_STATE_READY) 4459 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC; 4460 4461 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4462 "RSCN for port id: 0x%x", tport->fcid); 4463 } 4464 break; 4465 } 4466 tport = fnic_find_tport_by_fcid(iport, nport_id); 4467 4468 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4469 "RSCN port id list: 0x%x", nport_id); 4470 4471 if (!tport) { 4472 newports++; 4473 continue; 4474 } 4475 if (tport->state == FDLS_TGT_STATE_READY) 4476 tport->flags |= FNIC_FDLS_TPORT_SEND_ADISC; 4477 } 4478 4479 if (pc_rscn_handling_feature_flag == PC_RSCN_HANDLING_FEATURE_ON && 4480 rscn_type == PC_RSCN && fnic->role == FNIC_ROLE_FCP_INITIATOR) { 4481 4482 if (fnic->pc_rscn_handling_status == PC_RSCN_HANDLING_IN_PROGRESS) { 4483 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4484 "PCRSCN handling already in progress. Skip host reset: %d", 4485 iport->fnic->fnic_num); 4486 return; 4487 } 4488 4489 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4490 "Processing PCRSCN. Queuing fnic for host reset: %d", 4491 iport->fnic->fnic_num); 4492 fnic->pc_rscn_handling_status = PC_RSCN_HANDLING_IN_PROGRESS; 4493 4494 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 4495 4496 spin_lock_irqsave(&reset_fnic_list_lock, 4497 reset_fnic_list_lock_flags); 4498 list_add_tail(&fnic->links, &reset_fnic_list); 4499 spin_unlock_irqrestore(&reset_fnic_list_lock, 4500 reset_fnic_list_lock_flags); 4501 4502 queue_work(reset_fnic_work_queue, &reset_fnic_work); 4503 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 4504 } else { 4505 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4506 "FDLS process RSCN sending GPN_FT: newports: %d", newports); 4507 fdls_send_gpn_ft(iport, FDLS_STATE_RSCN_GPN_FT); 4508 fdls_send_rscn_resp(iport, fchdr); 4509 } 4510 } 4511 4512 void fnic_fdls_disc_start(struct fnic_iport_s *iport) 4513 { 4514 struct fnic *fnic = iport->fnic; 4515 4516 fc_host_fabric_name(iport->fnic->host) = 0; 4517 fc_host_post_event(iport->fnic->host, fc_get_event_number(), 4518 FCH_EVT_LIPRESET, 0); 4519 4520 if (!iport->usefip) { 4521 if (iport->flags & FNIC_FIRST_LINK_UP) { 4522 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 4523 fnic_scsi_fcpio_reset(iport->fnic); 4524 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 4525 4526 iport->flags &= ~FNIC_FIRST_LINK_UP; 4527 } 4528 fnic_fdls_start_flogi(iport); 4529 } else 4530 fnic_fdls_start_plogi(iport); 4531 } 4532 4533 static void 4534 fdls_process_adisc_req(struct fnic_iport_s *iport, 4535 struct fc_frame_header *fchdr) 4536 { 4537 struct fc_std_els_adisc *padisc_acc; 4538 struct fc_std_els_adisc *adisc_req = (struct fc_std_els_adisc *)fchdr; 4539 uint64_t frame_wwnn; 4540 uint64_t frame_wwpn; 4541 uint32_t tgt_fcid; 4542 struct fnic_tport_s *tport; 4543 uint8_t *fcid; 4544 uint8_t *rjt_frame; 4545 uint8_t *acc_frame; 4546 struct fc_std_els_rjt_rsp *prjts_rsp; 4547 uint16_t oxid; 4548 struct fnic *fnic = iport->fnic; 4549 uint16_t rjt_frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 4550 sizeof(struct fc_std_els_rjt_rsp); 4551 uint16_t acc_frame_size = FNIC_ETH_FCOE_HDRS_OFFSET + 4552 sizeof(struct fc_std_els_adisc); 4553 4554 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4555 "Process ADISC request %d", iport->fnic->fnic_num); 4556 4557 fcid = FNIC_STD_GET_S_ID(fchdr); 4558 tgt_fcid = ntoh24(fcid); 4559 tport = fnic_find_tport_by_fcid(iport, tgt_fcid); 4560 if (!tport) { 4561 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4562 "tport for fcid: 0x%x not found. Dropping ADISC req.", 4563 tgt_fcid); 4564 return; 4565 } 4566 if (iport->state != FNIC_IPORT_STATE_READY) { 4567 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4568 "Dropping ADISC req from fcid: 0x%x in iport state: %d", 4569 tgt_fcid, iport->state); 4570 return; 4571 } 4572 4573 frame_wwnn = be64_to_cpu(adisc_req->els.adisc_wwnn); 4574 frame_wwpn = be64_to_cpu(adisc_req->els.adisc_wwpn); 4575 4576 if ((frame_wwnn != tport->wwnn) || (frame_wwpn != tport->wwpn)) { 4577 /* send reject */ 4578 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4579 "ADISC req from fcid: 0x%x mismatch wwpn: 0x%llx wwnn: 0x%llx", 4580 tgt_fcid, frame_wwpn, frame_wwnn); 4581 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4582 "local tport wwpn: 0x%llx wwnn: 0x%llx. Sending RJT", 4583 tport->wwpn, tport->wwnn); 4584 4585 rjt_frame = fdls_alloc_frame(iport); 4586 if (rjt_frame == NULL) { 4587 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4588 "Failed to allocate rjt_frame to send response to ADISC request"); 4589 return; 4590 } 4591 4592 prjts_rsp = (struct fc_std_els_rjt_rsp *) (rjt_frame + FNIC_ETH_FCOE_HDRS_OFFSET); 4593 fdls_init_els_rjt_frame(rjt_frame, iport); 4594 4595 prjts_rsp->rej.er_reason = 0x03; /* logical error */ 4596 prjts_rsp->rej.er_explan = 0x1E; /* N_port login required */ 4597 prjts_rsp->rej.er_vendor = 0x0; 4598 4599 FNIC_STD_SET_S_ID(prjts_rsp->fchdr, fchdr->fh_d_id); 4600 FNIC_STD_SET_D_ID(prjts_rsp->fchdr, fchdr->fh_s_id); 4601 oxid = FNIC_STD_GET_OX_ID(fchdr); 4602 FNIC_STD_SET_OX_ID(prjts_rsp->fchdr, oxid); 4603 4604 fnic_send_fcoe_frame(iport, rjt_frame, rjt_frame_size); 4605 return; 4606 } 4607 4608 acc_frame = fdls_alloc_frame(iport); 4609 if (acc_frame == NULL) { 4610 FNIC_FCS_DBG(KERN_ERR, fnic->host, fnic->fnic_num, 4611 "Failed to allocate frame to send ADISC accept"); 4612 return; 4613 } 4614 4615 padisc_acc = (struct fc_std_els_adisc *) (acc_frame + FNIC_ETH_FCOE_HDRS_OFFSET); 4616 4617 FNIC_STD_SET_S_ID(padisc_acc->fchdr, fchdr->fh_d_id); 4618 FNIC_STD_SET_D_ID(padisc_acc->fchdr, fchdr->fh_s_id); 4619 4620 FNIC_STD_SET_F_CTL(padisc_acc->fchdr, FNIC_ELS_REP_FCTL << 16); 4621 FNIC_STD_SET_R_CTL(padisc_acc->fchdr, FC_RCTL_ELS_REP); 4622 FNIC_STD_SET_TYPE(padisc_acc->fchdr, FC_TYPE_ELS); 4623 4624 oxid = FNIC_STD_GET_OX_ID(fchdr); 4625 FNIC_STD_SET_OX_ID(padisc_acc->fchdr, oxid); 4626 FNIC_STD_SET_RX_ID(padisc_acc->fchdr, FNIC_UNASSIGNED_RXID); 4627 4628 padisc_acc->els.adisc_cmd = ELS_LS_ACC; 4629 4630 FNIC_STD_SET_NPORT_NAME(&padisc_acc->els.adisc_wwpn, 4631 iport->wwpn); 4632 FNIC_STD_SET_NODE_NAME(&padisc_acc->els.adisc_wwnn, 4633 iport->wwnn); 4634 memcpy(padisc_acc->els.adisc_port_id, fchdr->fh_d_id, 3); 4635 4636 fnic_send_fcoe_frame(iport, acc_frame, acc_frame_size); 4637 } 4638 4639 /* 4640 * Performs a validation for all FCOE frames and return the frame type 4641 */ 4642 int 4643 fnic_fdls_validate_and_get_frame_type(struct fnic_iport_s *iport, 4644 struct fc_frame_header *fchdr) 4645 { 4646 uint8_t type; 4647 uint8_t *fc_payload; 4648 uint16_t oxid; 4649 uint32_t s_id; 4650 uint32_t d_id; 4651 struct fnic *fnic = iport->fnic; 4652 struct fnic_fdls_fabric_s *fabric = &iport->fabric; 4653 int oxid_frame_type; 4654 4655 oxid = FNIC_STD_GET_OX_ID(fchdr); 4656 fc_payload = (uint8_t *) fchdr + sizeof(struct fc_frame_header); 4657 type = *fc_payload; 4658 s_id = ntoh24(fchdr->fh_s_id); 4659 d_id = ntoh24(fchdr->fh_d_id); 4660 4661 /* some common validation */ 4662 if (fdls_get_state(fabric) > FDLS_STATE_FABRIC_FLOGI) { 4663 if ((iport->fcid != d_id) || (!FNIC_FC_FRAME_CS_CTL(fchdr))) { 4664 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4665 "invalid frame received. Dropping frame"); 4666 return -1; 4667 } 4668 } 4669 4670 /* BLS ABTS response */ 4671 if ((fchdr->fh_r_ctl == FC_RCTL_BA_ACC) 4672 || (fchdr->fh_r_ctl == FC_RCTL_BA_RJT)) { 4673 if (!(FNIC_FC_FRAME_TYPE_BLS(fchdr))) { 4674 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4675 "Received ABTS invalid frame. Dropping frame"); 4676 return -1; 4677 4678 } 4679 if (fdls_is_oxid_fabric_req(oxid)) { 4680 if (!(iport->fabric.flags & FNIC_FDLS_FABRIC_ABORT_ISSUED)) { 4681 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4682 "Received unexpected ABTS RSP(oxid:0x%x) from 0x%x. Dropping frame", 4683 oxid, s_id); 4684 return -1; 4685 } 4686 return FNIC_FABRIC_BLS_ABTS_RSP; 4687 } else if (fdls_is_oxid_fdmi_req(oxid)) { 4688 return FNIC_FDMI_BLS_ABTS_RSP; 4689 } else if (fdls_is_oxid_tgt_req(oxid)) { 4690 return FNIC_TPORT_BLS_ABTS_RSP; 4691 } 4692 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4693 "Received ABTS rsp with unknown oxid(0x%x) from 0x%x. Dropping frame", 4694 oxid, s_id); 4695 return -1; 4696 } 4697 4698 /* BLS ABTS Req */ 4699 if ((fchdr->fh_r_ctl == FC_RCTL_BA_ABTS) 4700 && (FNIC_FC_FRAME_TYPE_BLS(fchdr))) { 4701 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4702 "Receiving Abort Request from s_id: 0x%x", s_id); 4703 return FNIC_BLS_ABTS_REQ; 4704 } 4705 4706 /* unsolicited requests frames */ 4707 if (FNIC_FC_FRAME_UNSOLICITED(fchdr)) { 4708 switch (type) { 4709 case ELS_LOGO: 4710 if ((!FNIC_FC_FRAME_FCTL_FIRST_LAST_SEQINIT(fchdr)) 4711 || (!FNIC_FC_FRAME_UNSOLICITED(fchdr)) 4712 || (!FNIC_FC_FRAME_TYPE_ELS(fchdr))) { 4713 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4714 "Received LOGO invalid frame. Dropping frame"); 4715 return -1; 4716 } 4717 return FNIC_ELS_LOGO_REQ; 4718 case ELS_RSCN: 4719 if ((!FNIC_FC_FRAME_FCTL_FIRST_LAST_SEQINIT(fchdr)) 4720 || (!FNIC_FC_FRAME_TYPE_ELS(fchdr)) 4721 || (!FNIC_FC_FRAME_UNSOLICITED(fchdr))) { 4722 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4723 "Received RSCN invalid FCTL. Dropping frame"); 4724 return -1; 4725 } 4726 if (s_id != FC_FID_FCTRL) 4727 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4728 "Received RSCN from target FCTL: 0x%x type: 0x%x s_id: 0x%x.", 4729 fchdr->fh_f_ctl[0], fchdr->fh_type, s_id); 4730 return FNIC_ELS_RSCN_REQ; 4731 case ELS_PLOGI: 4732 return FNIC_ELS_PLOGI_REQ; 4733 case ELS_ECHO: 4734 return FNIC_ELS_ECHO_REQ; 4735 case ELS_ADISC: 4736 return FNIC_ELS_ADISC; 4737 case ELS_RLS: 4738 return FNIC_ELS_RLS; 4739 case ELS_RRQ: 4740 return FNIC_ELS_RRQ; 4741 default: 4742 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4743 "Unsupported frame (type:0x%02x) from fcid: 0x%x", 4744 type, s_id); 4745 return FNIC_ELS_UNSUPPORTED_REQ; 4746 } 4747 } 4748 4749 /* solicited response from fabric or target */ 4750 oxid_frame_type = FNIC_FRAME_TYPE(oxid); 4751 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4752 "oxid frame code: 0x%x, oxid: 0x%x\n", oxid_frame_type, oxid); 4753 switch (oxid_frame_type) { 4754 case FNIC_FRAME_TYPE_FABRIC_FLOGI: 4755 if (type == ELS_LS_ACC) { 4756 if ((s_id != FC_FID_FLOGI) 4757 || (!FNIC_FC_FRAME_TYPE_ELS(fchdr))) { 4758 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4759 "Received unknown frame. Dropping frame"); 4760 return -1; 4761 } 4762 } 4763 return FNIC_FABRIC_FLOGI_RSP; 4764 4765 case FNIC_FRAME_TYPE_FABRIC_PLOGI: 4766 if (type == ELS_LS_ACC) { 4767 if ((s_id != FC_FID_DIR_SERV) 4768 || (!FNIC_FC_FRAME_TYPE_ELS(fchdr))) { 4769 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4770 "Received unknown frame. Dropping frame"); 4771 return -1; 4772 } 4773 } 4774 return FNIC_FABRIC_PLOGI_RSP; 4775 4776 case FNIC_FRAME_TYPE_FABRIC_SCR: 4777 if (type == ELS_LS_ACC) { 4778 if ((s_id != FC_FID_FCTRL) 4779 || (!FNIC_FC_FRAME_TYPE_ELS(fchdr))) { 4780 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4781 "Received unknown frame. Dropping frame"); 4782 return -1; 4783 } 4784 } 4785 return FNIC_FABRIC_SCR_RSP; 4786 4787 case FNIC_FRAME_TYPE_FABRIC_RPN: 4788 if ((s_id != FC_FID_DIR_SERV) || (!FNIC_FC_FRAME_TYPE_FC_GS(fchdr))) { 4789 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4790 "Received unknown frame. Dropping frame"); 4791 return -1; 4792 } 4793 return FNIC_FABRIC_RPN_RSP; 4794 4795 case FNIC_FRAME_TYPE_FABRIC_RFT: 4796 if ((s_id != FC_FID_DIR_SERV) || (!FNIC_FC_FRAME_TYPE_FC_GS(fchdr))) { 4797 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4798 "Received unknown frame. Dropping frame"); 4799 return -1; 4800 } 4801 return FNIC_FABRIC_RFT_RSP; 4802 4803 case FNIC_FRAME_TYPE_FABRIC_RFF: 4804 if ((s_id != FC_FID_DIR_SERV) || (!FNIC_FC_FRAME_TYPE_FC_GS(fchdr))) { 4805 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4806 "Received unknown frame. Dropping frame"); 4807 return -1; 4808 } 4809 return FNIC_FABRIC_RFF_RSP; 4810 4811 case FNIC_FRAME_TYPE_FABRIC_GPN_FT: 4812 if ((s_id != FC_FID_DIR_SERV) || (!FNIC_FC_FRAME_TYPE_FC_GS(fchdr))) { 4813 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4814 "Received unknown frame. Dropping frame"); 4815 return -1; 4816 } 4817 return FNIC_FABRIC_GPN_FT_RSP; 4818 4819 case FNIC_FRAME_TYPE_FABRIC_LOGO: 4820 return FNIC_FABRIC_LOGO_RSP; 4821 case FNIC_FRAME_TYPE_FDMI_PLOGI: 4822 return FNIC_FDMI_PLOGI_RSP; 4823 case FNIC_FRAME_TYPE_FDMI_RHBA: 4824 return FNIC_FDMI_REG_HBA_RSP; 4825 case FNIC_FRAME_TYPE_FDMI_RPA: 4826 return FNIC_FDMI_RPA_RSP; 4827 case FNIC_FRAME_TYPE_TGT_PLOGI: 4828 return FNIC_TPORT_PLOGI_RSP; 4829 case FNIC_FRAME_TYPE_TGT_PRLI: 4830 return FNIC_TPORT_PRLI_RSP; 4831 case FNIC_FRAME_TYPE_TGT_ADISC: 4832 return FNIC_TPORT_ADISC_RSP; 4833 case FNIC_FRAME_TYPE_TGT_LOGO: 4834 if (!FNIC_FC_FRAME_TYPE_ELS(fchdr)) { 4835 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4836 "Dropping Unknown frame in tport solicited exchange range type: 0x%x.", 4837 fchdr->fh_type); 4838 return -1; 4839 } 4840 return FNIC_TPORT_LOGO_RSP; 4841 default: 4842 /* Drop the Rx frame and log/stats it */ 4843 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4844 "Solicited response: unknown OXID: 0x%x", oxid); 4845 return -1; 4846 } 4847 4848 return -1; 4849 } 4850 4851 void fnic_fdls_recv_frame(struct fnic_iport_s *iport, void *rx_frame, 4852 int len, int fchdr_offset) 4853 { 4854 struct fc_frame_header *fchdr; 4855 uint32_t s_id = 0; 4856 uint32_t d_id = 0; 4857 struct fnic *fnic = iport->fnic; 4858 int frame_type; 4859 4860 fchdr = (struct fc_frame_header *) ((uint8_t *) rx_frame + fchdr_offset); 4861 s_id = ntoh24(fchdr->fh_s_id); 4862 d_id = ntoh24(fchdr->fh_d_id); 4863 4864 fnic_debug_dump_fc_frame(fnic, fchdr, len, "Incoming"); 4865 4866 frame_type = 4867 fnic_fdls_validate_and_get_frame_type(iport, fchdr); 4868 4869 /*if we are in flogo drop everything else */ 4870 if (iport->fabric.state == FDLS_STATE_FABRIC_LOGO && 4871 frame_type != FNIC_FABRIC_LOGO_RSP) 4872 return; 4873 4874 switch (frame_type) { 4875 case FNIC_FABRIC_FLOGI_RSP: 4876 fdls_process_flogi_rsp(iport, fchdr, rx_frame); 4877 break; 4878 case FNIC_FABRIC_PLOGI_RSP: 4879 fdls_process_fabric_plogi_rsp(iport, fchdr); 4880 break; 4881 case FNIC_FDMI_PLOGI_RSP: 4882 fdls_process_fdmi_plogi_rsp(iport, fchdr); 4883 break; 4884 case FNIC_FABRIC_RPN_RSP: 4885 fdls_process_rpn_id_rsp(iport, fchdr); 4886 break; 4887 case FNIC_FABRIC_RFT_RSP: 4888 fdls_process_rft_id_rsp(iport, fchdr); 4889 break; 4890 case FNIC_FABRIC_RFF_RSP: 4891 fdls_process_rff_id_rsp(iport, fchdr); 4892 break; 4893 case FNIC_FABRIC_SCR_RSP: 4894 fdls_process_scr_rsp(iport, fchdr); 4895 break; 4896 case FNIC_FABRIC_GPN_FT_RSP: 4897 fdls_process_gpn_ft_rsp(iport, fchdr, len); 4898 break; 4899 case FNIC_TPORT_PLOGI_RSP: 4900 fdls_process_tgt_plogi_rsp(iport, fchdr); 4901 break; 4902 case FNIC_TPORT_PRLI_RSP: 4903 fdls_process_tgt_prli_rsp(iport, fchdr); 4904 break; 4905 case FNIC_TPORT_ADISC_RSP: 4906 fdls_process_tgt_adisc_rsp(iport, fchdr); 4907 break; 4908 case FNIC_TPORT_BLS_ABTS_RSP: 4909 fdls_process_tgt_abts_rsp(iport, fchdr); 4910 break; 4911 case FNIC_TPORT_LOGO_RSP: 4912 /* Logo response from tgt which we have deleted */ 4913 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4914 "Logo response from tgt: 0x%x", 4915 ntoh24(fchdr->fh_s_id)); 4916 break; 4917 case FNIC_FABRIC_LOGO_RSP: 4918 fdls_process_fabric_logo_rsp(iport, fchdr); 4919 break; 4920 case FNIC_FABRIC_BLS_ABTS_RSP: 4921 fdls_process_fabric_abts_rsp(iport, fchdr); 4922 break; 4923 case FNIC_FDMI_BLS_ABTS_RSP: 4924 fdls_process_fdmi_abts_rsp(iport, fchdr); 4925 break; 4926 case FNIC_BLS_ABTS_REQ: 4927 fdls_process_abts_req(iport, fchdr); 4928 break; 4929 case FNIC_ELS_UNSUPPORTED_REQ: 4930 fdls_process_unsupported_els_req(iport, fchdr); 4931 break; 4932 case FNIC_ELS_PLOGI_REQ: 4933 fdls_process_plogi_req(iport, fchdr); 4934 break; 4935 case FNIC_ELS_RSCN_REQ: 4936 fdls_process_rscn(iport, fchdr); 4937 break; 4938 case FNIC_ELS_LOGO_REQ: 4939 fdls_process_logo_req(iport, fchdr); 4940 break; 4941 case FNIC_ELS_RRQ: 4942 case FNIC_ELS_ECHO_REQ: 4943 fdls_process_els_req(iport, fchdr, len); 4944 break; 4945 case FNIC_ELS_ADISC: 4946 fdls_process_adisc_req(iport, fchdr); 4947 break; 4948 case FNIC_ELS_RLS: 4949 fdls_process_rls_req(iport, fchdr); 4950 break; 4951 case FNIC_FDMI_REG_HBA_RSP: 4952 case FNIC_FDMI_RPA_RSP: 4953 fdls_process_fdmi_reg_ack(iport, fchdr, frame_type); 4954 break; 4955 default: 4956 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4957 "s_id: 0x%x d_did: 0x%x", s_id, d_id); 4958 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4959 "Received unknown FCoE frame of len: %d. Dropping frame", len); 4960 break; 4961 } 4962 } 4963 4964 void fnic_fdls_disc_init(struct fnic_iport_s *iport) 4965 { 4966 fdls_reset_oxid_pool(iport); 4967 fdls_set_state((&iport->fabric), FDLS_STATE_INIT); 4968 } 4969 4970 void fnic_fdls_link_down(struct fnic_iport_s *iport) 4971 { 4972 struct fnic_tport_s *tport, *next; 4973 struct fnic *fnic = iport->fnic; 4974 4975 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4976 "0x%x: FDLS processing link down", iport->fcid); 4977 4978 fdls_set_state((&iport->fabric), FDLS_STATE_LINKDOWN); 4979 iport->fabric.flags = 0; 4980 4981 spin_unlock_irqrestore(&fnic->fnic_lock, fnic->lock_flags); 4982 fnic_scsi_fcpio_reset(iport->fnic); 4983 spin_lock_irqsave(&fnic->fnic_lock, fnic->lock_flags); 4984 list_for_each_entry_safe(tport, next, &iport->tport_list, links) { 4985 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4986 "removing rport: 0x%x", tport->fcid); 4987 fdls_delete_tport(iport, tport); 4988 } 4989 4990 if ((fnic_fdmi_support == 1) && (iport->fabric.fdmi_pending > 0)) { 4991 del_timer_sync(&iport->fabric.fdmi_timer); 4992 iport->fabric.fdmi_pending = 0; 4993 } 4994 4995 FNIC_FCS_DBG(KERN_INFO, fnic->host, fnic->fnic_num, 4996 "0x%x: FDLS finish processing link down", iport->fcid); 4997 } 4998