1 /*- 2 * Copyright (c) 2017 Broadcom. All rights reserved. 3 * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the copyright holder nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34 /** 35 * @file 36 * Defines and implements the Hardware Abstraction Layer (HW). 37 * All interaction with the hardware is performed through the HW, which abstracts 38 * the details of the underlying SLI-4 implementation. 39 */ 40 41 /** 42 * @defgroup devInitShutdown Device Initialization and Shutdown 43 * @defgroup domain Domain Functions 44 * @defgroup port Port Functions 45 * @defgroup node Remote Node Functions 46 * @defgroup io IO Functions 47 * @defgroup interrupt Interrupt handling 48 * @defgroup os OS Required Functions 49 */ 50 51 #include "ocs.h" 52 #include "ocs_os.h" 53 #include "ocs_hw.h" 54 #include "ocs_hw_queues.h" 55 56 #define OCS_HW_MQ_DEPTH 128 57 #define OCS_HW_READ_FCF_SIZE 4096 58 #define OCS_HW_DEFAULT_AUTO_XFER_RDY_IOS 256 59 #define OCS_HW_WQ_TIMER_PERIOD_MS 500 60 61 /* values used for setting the auto xfer rdy parameters */ 62 #define OCS_HW_AUTO_XFER_RDY_BLK_SIZE_DEFAULT 0 /* 512 bytes */ 63 #define OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA_DEFAULT TRUE 64 #define OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID_DEFAULT FALSE 65 #define OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE_DEFAULT 0 66 #define OCS_HW_REQUE_XRI_REGTAG 65534 67 /* max command and response buffer lengths -- arbitrary at the moment */ 68 #define OCS_HW_DMTF_CLP_CMD_MAX 256 69 #define OCS_HW_DMTF_CLP_RSP_MAX 256 70 71 /* HW global data */ 72 ocs_hw_global_t hw_global; 73 74 static void ocs_hw_queue_hash_add(ocs_queue_hash_t *, uint16_t, uint16_t); 75 static void ocs_hw_adjust_wqs(ocs_hw_t *hw); 76 static uint32_t ocs_hw_get_num_chutes(ocs_hw_t *hw); 77 static int32_t ocs_hw_cb_link(void *, void *); 78 static int32_t ocs_hw_cb_fip(void *, void *); 79 static int32_t ocs_hw_command_process(ocs_hw_t *, int32_t, uint8_t *, size_t); 80 static int32_t ocs_hw_mq_process(ocs_hw_t *, int32_t, sli4_queue_t *); 81 static int32_t ocs_hw_cb_read_fcf(ocs_hw_t *, int32_t, uint8_t *, void *); 82 static int32_t ocs_hw_cb_node_attach(ocs_hw_t *, int32_t, uint8_t *, void *); 83 static int32_t ocs_hw_cb_node_free(ocs_hw_t *, int32_t, uint8_t *, void *); 84 static int32_t ocs_hw_cb_node_free_all(ocs_hw_t *, int32_t, uint8_t *, void *); 85 static ocs_hw_rtn_e ocs_hw_setup_io(ocs_hw_t *); 86 static ocs_hw_rtn_e ocs_hw_init_io(ocs_hw_t *); 87 static int32_t ocs_hw_flush(ocs_hw_t *); 88 static int32_t ocs_hw_command_cancel(ocs_hw_t *); 89 static int32_t ocs_hw_io_cancel(ocs_hw_t *); 90 static void ocs_hw_io_quarantine(ocs_hw_t *hw, hw_wq_t *wq, ocs_hw_io_t *io); 91 static void ocs_hw_io_restore_sgl(ocs_hw_t *, ocs_hw_io_t *); 92 static int32_t ocs_hw_io_ini_sge(ocs_hw_t *, ocs_hw_io_t *, ocs_dma_t *, uint32_t, ocs_dma_t *); 93 static ocs_hw_rtn_e ocs_hw_firmware_write_lancer(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg); 94 static int32_t ocs_hw_cb_fw_write(ocs_hw_t *, int32_t, uint8_t *, void *); 95 static int32_t ocs_hw_cb_sfp(ocs_hw_t *, int32_t, uint8_t *, void *); 96 static int32_t ocs_hw_cb_temp(ocs_hw_t *, int32_t, uint8_t *, void *); 97 static int32_t ocs_hw_cb_link_stat(ocs_hw_t *, int32_t, uint8_t *, void *); 98 static int32_t ocs_hw_cb_host_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg); 99 static void ocs_hw_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg); 100 static int32_t ocs_hw_clp_resp_get_value(ocs_hw_t *hw, const char *keyword, char *value, uint32_t value_len, const char *resp, uint32_t resp_len); 101 typedef void (*ocs_hw_dmtf_clp_cb_t)(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg); 102 static ocs_hw_rtn_e ocs_hw_exec_dmtf_clp_cmd(ocs_hw_t *hw, ocs_dma_t *dma_cmd, ocs_dma_t *dma_resp, uint32_t opts, ocs_hw_dmtf_clp_cb_t cb, void *arg); 103 static void ocs_hw_linkcfg_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg); 104 105 static int32_t __ocs_read_topology_cb(ocs_hw_t *, int32_t, uint8_t *, void *); 106 static ocs_hw_rtn_e ocs_hw_get_linkcfg(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *); 107 static ocs_hw_rtn_e ocs_hw_get_linkcfg_lancer(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *); 108 static ocs_hw_rtn_e ocs_hw_get_linkcfg_skyhawk(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *); 109 static ocs_hw_rtn_e ocs_hw_set_linkcfg(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *); 110 static ocs_hw_rtn_e ocs_hw_set_linkcfg_lancer(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *); 111 static ocs_hw_rtn_e ocs_hw_set_linkcfg_skyhawk(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *); 112 static void ocs_hw_init_linkcfg_cb(int32_t status, uintptr_t value, void *arg); 113 static ocs_hw_rtn_e ocs_hw_set_eth_license(ocs_hw_t *hw, uint32_t license); 114 static ocs_hw_rtn_e ocs_hw_set_dif_seed(ocs_hw_t *hw); 115 static ocs_hw_rtn_e ocs_hw_set_dif_mode(ocs_hw_t *hw); 116 static void ocs_hw_io_free_internal(void *arg); 117 static void ocs_hw_io_free_port_owned(void *arg); 118 static ocs_hw_rtn_e ocs_hw_config_auto_xfer_rdy_t10pi(ocs_hw_t *hw, uint8_t *buf); 119 static ocs_hw_rtn_e ocs_hw_config_set_fdt_xfer_hint(ocs_hw_t *hw, uint32_t fdt_xfer_hint); 120 static void ocs_hw_wq_process_abort(void *arg, uint8_t *cqe, int32_t status); 121 static int32_t ocs_hw_config_mrq(ocs_hw_t *hw, uint8_t, uint16_t, uint16_t); 122 static ocs_hw_rtn_e ocs_hw_config_watchdog_timer(ocs_hw_t *hw); 123 static ocs_hw_rtn_e ocs_hw_config_sli_port_health_check(ocs_hw_t *hw, uint8_t query, uint8_t enable); 124 125 /* HW domain database operations */ 126 static int32_t ocs_hw_domain_add(ocs_hw_t *, ocs_domain_t *); 127 static int32_t ocs_hw_domain_del(ocs_hw_t *, ocs_domain_t *); 128 129 /* Port state machine */ 130 static void *__ocs_hw_port_alloc_init(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 131 static void *__ocs_hw_port_alloc_read_sparm64(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 132 static void *__ocs_hw_port_alloc_init_vpi(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 133 static void *__ocs_hw_port_done(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 134 static void *__ocs_hw_port_free_unreg_vpi(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 135 136 /* Domain state machine */ 137 static void *__ocs_hw_domain_init(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 138 static void *__ocs_hw_domain_alloc_reg_fcfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 139 static void * __ocs_hw_domain_alloc_init_vfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 140 static void *__ocs_hw_domain_free_unreg_vfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *); 141 static void *__ocs_hw_domain_free_unreg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data); 142 static int32_t __ocs_hw_domain_cb(ocs_hw_t *, int32_t, uint8_t *, void *); 143 static int32_t __ocs_hw_port_cb(ocs_hw_t *, int32_t, uint8_t *, void *); 144 static int32_t __ocs_hw_port_realloc_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg); 145 146 /* BZ 161832 */ 147 static void ocs_hw_check_sec_hio_list(ocs_hw_t *hw); 148 149 /* WQE timeouts */ 150 static void target_wqe_timer_cb(void *arg); 151 static void shutdown_target_wqe_timer(ocs_hw_t *hw); 152 153 static inline void 154 ocs_hw_add_io_timed_wqe(ocs_hw_t *hw, ocs_hw_io_t *io) 155 { 156 if (hw->config.emulate_tgt_wqe_timeout && io->tgt_wqe_timeout) { 157 /* 158 * Active WQE list currently only used for 159 * target WQE timeouts. 160 */ 161 ocs_lock(&hw->io_lock); 162 ocs_list_add_tail(&hw->io_timed_wqe, io); 163 io->submit_ticks = ocs_get_os_ticks(); 164 ocs_unlock(&hw->io_lock); 165 } 166 } 167 168 static inline void 169 ocs_hw_remove_io_timed_wqe(ocs_hw_t *hw, ocs_hw_io_t *io) 170 { 171 if (hw->config.emulate_tgt_wqe_timeout) { 172 /* 173 * If target wqe timeouts are enabled, 174 * remove from active wqe list. 175 */ 176 ocs_lock(&hw->io_lock); 177 if (ocs_list_on_list(&io->wqe_link)) { 178 ocs_list_remove(&hw->io_timed_wqe, io); 179 } 180 ocs_unlock(&hw->io_lock); 181 } 182 } 183 184 static uint8_t ocs_hw_iotype_is_originator(uint16_t io_type) 185 { 186 switch (io_type) { 187 case OCS_HW_IO_INITIATOR_READ: 188 case OCS_HW_IO_INITIATOR_WRITE: 189 case OCS_HW_IO_INITIATOR_NODATA: 190 case OCS_HW_FC_CT: 191 case OCS_HW_ELS_REQ: 192 return 1; 193 default: 194 return 0; 195 } 196 } 197 198 static uint8_t ocs_hw_wcqe_abort_needed(uint16_t status, uint8_t ext, uint8_t xb) 199 { 200 /* if exchange not active, nothing to abort */ 201 if (!xb) { 202 return FALSE; 203 } 204 if (status == SLI4_FC_WCQE_STATUS_LOCAL_REJECT) { 205 switch (ext) { 206 /* exceptions where abort is not needed */ 207 case SLI4_FC_LOCAL_REJECT_INVALID_RPI: /* lancer returns this after unreg_rpi */ 208 case SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED: /* abort already in progress */ 209 return FALSE; 210 default: 211 break; 212 } 213 } 214 return TRUE; 215 } 216 217 /** 218 * @brief Determine the number of chutes on the device. 219 * 220 * @par Description 221 * Some devices require queue resources allocated per protocol processor 222 * (chute). This function returns the number of chutes on this device. 223 * 224 * @param hw Hardware context allocated by the caller. 225 * 226 * @return Returns the number of chutes on the device for protocol. 227 */ 228 static uint32_t 229 ocs_hw_get_num_chutes(ocs_hw_t *hw) 230 { 231 uint32_t num_chutes = 1; 232 233 if (sli_get_is_dual_ulp_capable(&hw->sli) && 234 sli_get_is_ulp_enabled(&hw->sli, 0) && 235 sli_get_is_ulp_enabled(&hw->sli, 1)) { 236 num_chutes = 2; 237 } 238 return num_chutes; 239 } 240 241 static ocs_hw_rtn_e 242 ocs_hw_link_event_init(ocs_hw_t *hw) 243 { 244 ocs_hw_assert(hw); 245 246 hw->link.status = SLI_LINK_STATUS_MAX; 247 hw->link.topology = SLI_LINK_TOPO_NONE; 248 hw->link.medium = SLI_LINK_MEDIUM_MAX; 249 hw->link.speed = 0; 250 hw->link.loop_map = NULL; 251 hw->link.fc_id = UINT32_MAX; 252 253 return OCS_HW_RTN_SUCCESS; 254 } 255 256 /** 257 * @ingroup devInitShutdown 258 * @brief If this is physical port 0, then read the max dump size. 259 * 260 * @par Description 261 * Queries the FW for the maximum dump size 262 * 263 * @param hw Hardware context allocated by the caller. 264 * 265 * @return Returns 0 on success, or a non-zero value on failure. 266 */ 267 static ocs_hw_rtn_e 268 ocs_hw_read_max_dump_size(ocs_hw_t *hw) 269 { 270 uint8_t buf[SLI4_BMBX_SIZE]; 271 uint8_t bus, dev, func; 272 int rc; 273 274 /* lancer only */ 275 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 276 ocs_log_debug(hw->os, "Function only supported for I/F type 2\n"); 277 return OCS_HW_RTN_ERROR; 278 } 279 280 /* 281 * Make sure the FW is new enough to support this command. If the FW 282 * is too old, the FW will UE. 283 */ 284 if (hw->workaround.disable_dump_loc) { 285 ocs_log_test(hw->os, "FW version is too old for this feature\n"); 286 return OCS_HW_RTN_ERROR; 287 } 288 289 /* attempt to detemine the dump size for function 0 only. */ 290 ocs_get_bus_dev_func(hw->os, &bus, &dev, &func); 291 if (func == 0) { 292 if (sli_cmd_common_set_dump_location(&hw->sli, buf, 293 SLI4_BMBX_SIZE, 1, 0, NULL, 0)) { 294 sli4_res_common_set_dump_location_t *rsp = 295 (sli4_res_common_set_dump_location_t *) 296 (buf + offsetof(sli4_cmd_sli_config_t, 297 payload.embed)); 298 299 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 300 if (rc != OCS_HW_RTN_SUCCESS) { 301 ocs_log_test(hw->os, "set dump location command failed\n"); 302 return rc; 303 } else { 304 hw->dump_size = rsp->buffer_length; 305 ocs_log_debug(hw->os, "Dump size %x\n", rsp->buffer_length); 306 } 307 } 308 } 309 return OCS_HW_RTN_SUCCESS; 310 } 311 312 /** 313 * @ingroup devInitShutdown 314 * @brief Set up the Hardware Abstraction Layer module. 315 * 316 * @par Description 317 * Calls set up to configure the hardware. 318 * 319 * @param hw Hardware context allocated by the caller. 320 * @param os Device abstraction. 321 * @param port_type Protocol type of port, such as FC and NIC. 322 * 323 * @todo Why is port_type a parameter? 324 * 325 * @return Returns 0 on success, or a non-zero value on failure. 326 */ 327 ocs_hw_rtn_e 328 ocs_hw_setup(ocs_hw_t *hw, ocs_os_handle_t os, sli4_port_type_e port_type) 329 { 330 uint32_t i; 331 char prop_buf[32]; 332 333 if (hw == NULL) { 334 ocs_log_err(os, "bad parameter(s) hw=%p\n", hw); 335 return OCS_HW_RTN_ERROR; 336 } 337 338 if (hw->hw_setup_called) { 339 /* Setup run-time workarounds. 340 * Call for each setup, to allow for hw_war_version 341 */ 342 ocs_hw_workaround_setup(hw); 343 return OCS_HW_RTN_SUCCESS; 344 } 345 346 /* 347 * ocs_hw_init() relies on NULL pointers indicating that a structure 348 * needs allocation. If a structure is non-NULL, ocs_hw_init() won't 349 * free/realloc that memory 350 */ 351 ocs_memset(hw, 0, sizeof(ocs_hw_t)); 352 353 hw->hw_setup_called = TRUE; 354 355 hw->os = os; 356 357 ocs_lock_init(hw->os, &hw->cmd_lock, "HW_cmd_lock[%d]", ocs_instance(hw->os)); 358 ocs_list_init(&hw->cmd_head, ocs_command_ctx_t, link); 359 ocs_list_init(&hw->cmd_pending, ocs_command_ctx_t, link); 360 hw->cmd_head_count = 0; 361 362 ocs_lock_init(hw->os, &hw->io_lock, "HW_io_lock[%d]", ocs_instance(hw->os)); 363 ocs_lock_init(hw->os, &hw->io_abort_lock, "HW_io_abort_lock[%d]", ocs_instance(hw->os)); 364 365 ocs_atomic_init(&hw->io_alloc_failed_count, 0); 366 367 hw->config.speed = FC_LINK_SPEED_AUTO_16_8_4; 368 hw->config.dif_seed = 0; 369 hw->config.auto_xfer_rdy_blk_size_chip = OCS_HW_AUTO_XFER_RDY_BLK_SIZE_DEFAULT; 370 hw->config.auto_xfer_rdy_ref_tag_is_lba = OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA_DEFAULT; 371 hw->config.auto_xfer_rdy_app_tag_valid = OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID_DEFAULT; 372 hw->config.auto_xfer_rdy_app_tag_value = OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE_DEFAULT; 373 374 if (sli_setup(&hw->sli, hw->os, port_type)) { 375 ocs_log_err(hw->os, "SLI setup failed\n"); 376 return OCS_HW_RTN_ERROR; 377 } 378 379 ocs_memset(hw->domains, 0, sizeof(hw->domains)); 380 381 ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi)); 382 383 ocs_hw_link_event_init(hw); 384 385 sli_callback(&hw->sli, SLI4_CB_LINK, ocs_hw_cb_link, hw); 386 sli_callback(&hw->sli, SLI4_CB_FIP, ocs_hw_cb_fip, hw); 387 388 /* 389 * Set all the queue sizes to the maximum allowed. These values may 390 * be changes later by the adjust and workaround functions. 391 */ 392 for (i = 0; i < ARRAY_SIZE(hw->num_qentries); i++) { 393 hw->num_qentries[i] = sli_get_max_qentries(&hw->sli, i); 394 } 395 396 /* 397 * The RQ assignment for RQ pair mode. 398 */ 399 hw->config.rq_default_buffer_size = OCS_HW_RQ_SIZE_PAYLOAD; 400 hw->config.n_io = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI); 401 if (ocs_get_property("auto_xfer_rdy_xri_cnt", prop_buf, sizeof(prop_buf)) == 0) { 402 hw->config.auto_xfer_rdy_xri_cnt = ocs_strtoul(prop_buf, 0, 0); 403 } 404 405 /* by default, enable initiator-only auto-ABTS emulation */ 406 hw->config.i_only_aab = TRUE; 407 408 /* Setup run-time workarounds */ 409 ocs_hw_workaround_setup(hw); 410 411 /* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */ 412 if (hw->workaround.override_fcfi) { 413 hw->first_domain_idx = -1; 414 } 415 416 /* Must be done after the workaround setup */ 417 if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) { 418 (void)ocs_hw_read_max_dump_size(hw); 419 } 420 421 /* calculate the number of WQs required. */ 422 ocs_hw_adjust_wqs(hw); 423 424 /* Set the default dif mode */ 425 if (! sli_is_dif_inline_capable(&hw->sli)) { 426 ocs_log_test(hw->os, "not inline capable, setting mode to separate\n"); 427 hw->config.dif_mode = OCS_HW_DIF_MODE_SEPARATE; 428 } 429 /* Workaround: BZ 161832 */ 430 if (hw->workaround.use_dif_sec_xri) { 431 ocs_list_init(&hw->sec_hio_wait_list, ocs_hw_io_t, link); 432 } 433 434 /* 435 * Figure out the starting and max ULP to spread the WQs across the 436 * ULPs. 437 */ 438 if (sli_get_is_dual_ulp_capable(&hw->sli)) { 439 if (sli_get_is_ulp_enabled(&hw->sli, 0) && 440 sli_get_is_ulp_enabled(&hw->sli, 1)) { 441 hw->ulp_start = 0; 442 hw->ulp_max = 1; 443 } else if (sli_get_is_ulp_enabled(&hw->sli, 0)) { 444 hw->ulp_start = 0; 445 hw->ulp_max = 0; 446 } else { 447 hw->ulp_start = 1; 448 hw->ulp_max = 1; 449 } 450 } else { 451 if (sli_get_is_ulp_enabled(&hw->sli, 0)) { 452 hw->ulp_start = 0; 453 hw->ulp_max = 0; 454 } else { 455 hw->ulp_start = 1; 456 hw->ulp_max = 1; 457 } 458 } 459 ocs_log_debug(hw->os, "ulp_start %d, ulp_max %d\n", 460 hw->ulp_start, hw->ulp_max); 461 hw->config.queue_topology = hw_global.queue_topology_string; 462 463 hw->qtop = ocs_hw_qtop_parse(hw, hw->config.queue_topology); 464 465 hw->config.n_eq = hw->qtop->entry_counts[QTOP_EQ]; 466 hw->config.n_cq = hw->qtop->entry_counts[QTOP_CQ]; 467 hw->config.n_rq = hw->qtop->entry_counts[QTOP_RQ]; 468 hw->config.n_wq = hw->qtop->entry_counts[QTOP_WQ]; 469 hw->config.n_mq = hw->qtop->entry_counts[QTOP_MQ]; 470 471 /* Verify qtop configuration against driver supported configuration */ 472 if (hw->config.n_rq > OCE_HW_MAX_NUM_MRQ_PAIRS) { 473 ocs_log_crit(hw->os, "Max supported MRQ pairs = %d\n", 474 OCE_HW_MAX_NUM_MRQ_PAIRS); 475 return OCS_HW_RTN_ERROR; 476 } 477 478 if (hw->config.n_eq > OCS_HW_MAX_NUM_EQ) { 479 ocs_log_crit(hw->os, "Max supported EQs = %d\n", 480 OCS_HW_MAX_NUM_EQ); 481 return OCS_HW_RTN_ERROR; 482 } 483 484 if (hw->config.n_cq > OCS_HW_MAX_NUM_CQ) { 485 ocs_log_crit(hw->os, "Max supported CQs = %d\n", 486 OCS_HW_MAX_NUM_CQ); 487 return OCS_HW_RTN_ERROR; 488 } 489 490 if (hw->config.n_wq > OCS_HW_MAX_NUM_WQ) { 491 ocs_log_crit(hw->os, "Max supported WQs = %d\n", 492 OCS_HW_MAX_NUM_WQ); 493 return OCS_HW_RTN_ERROR; 494 } 495 496 if (hw->config.n_mq > OCS_HW_MAX_NUM_MQ) { 497 ocs_log_crit(hw->os, "Max supported MQs = %d\n", 498 OCS_HW_MAX_NUM_MQ); 499 return OCS_HW_RTN_ERROR; 500 } 501 502 return OCS_HW_RTN_SUCCESS; 503 } 504 505 /** 506 * @ingroup devInitShutdown 507 * @brief Allocate memory structures to prepare for the device operation. 508 * 509 * @par Description 510 * Allocates memory structures needed by the device and prepares the device 511 * for operation. 512 * @n @n @b Note: This function may be called more than once (for example, at 513 * initialization and then after a reset), but the size of the internal resources 514 * may not be changed without tearing down the HW (ocs_hw_teardown()). 515 * 516 * @param hw Hardware context allocated by the caller. 517 * 518 * @return Returns 0 on success, or a non-zero value on failure. 519 */ 520 ocs_hw_rtn_e 521 ocs_hw_init(ocs_hw_t *hw) 522 { 523 ocs_hw_rtn_e rc; 524 uint32_t i = 0; 525 uint8_t buf[SLI4_BMBX_SIZE]; 526 uint32_t max_rpi; 527 int rem_count; 528 int written_size = 0; 529 uint32_t count; 530 char prop_buf[32]; 531 uint32_t ramdisc_blocksize = 512; 532 uint32_t q_count = 0; 533 /* 534 * Make sure the command lists are empty. If this is start-of-day, 535 * they'll be empty since they were just initialized in ocs_hw_setup. 536 * If we've just gone through a reset, the command and command pending 537 * lists should have been cleaned up as part of the reset (ocs_hw_reset()). 538 */ 539 ocs_lock(&hw->cmd_lock); 540 if (!ocs_list_empty(&hw->cmd_head)) { 541 ocs_log_test(hw->os, "command found on cmd list\n"); 542 ocs_unlock(&hw->cmd_lock); 543 return OCS_HW_RTN_ERROR; 544 } 545 if (!ocs_list_empty(&hw->cmd_pending)) { 546 ocs_log_test(hw->os, "command found on pending list\n"); 547 ocs_unlock(&hw->cmd_lock); 548 return OCS_HW_RTN_ERROR; 549 } 550 ocs_unlock(&hw->cmd_lock); 551 552 /* Free RQ buffers if prevously allocated */ 553 ocs_hw_rx_free(hw); 554 555 /* 556 * The IO queues must be initialized here for the reset case. The 557 * ocs_hw_init_io() function will re-add the IOs to the free list. 558 * The cmd_head list should be OK since we free all entries in 559 * ocs_hw_command_cancel() that is called in the ocs_hw_reset(). 560 */ 561 562 /* If we are in this function due to a reset, there may be stale items 563 * on lists that need to be removed. Clean them up. 564 */ 565 rem_count=0; 566 if (ocs_list_valid(&hw->io_wait_free)) { 567 while ((!ocs_list_empty(&hw->io_wait_free))) { 568 rem_count++; 569 ocs_list_remove_head(&hw->io_wait_free); 570 } 571 if (rem_count > 0) { 572 ocs_log_debug(hw->os, "removed %d items from io_wait_free list\n", rem_count); 573 } 574 } 575 rem_count=0; 576 if (ocs_list_valid(&hw->io_inuse)) { 577 while ((!ocs_list_empty(&hw->io_inuse))) { 578 rem_count++; 579 ocs_list_remove_head(&hw->io_inuse); 580 } 581 if (rem_count > 0) { 582 ocs_log_debug(hw->os, "removed %d items from io_inuse list\n", rem_count); 583 } 584 } 585 rem_count=0; 586 if (ocs_list_valid(&hw->io_free)) { 587 while ((!ocs_list_empty(&hw->io_free))) { 588 rem_count++; 589 ocs_list_remove_head(&hw->io_free); 590 } 591 if (rem_count > 0) { 592 ocs_log_debug(hw->os, "removed %d items from io_free list\n", rem_count); 593 } 594 } 595 if (ocs_list_valid(&hw->io_port_owned)) { 596 while ((!ocs_list_empty(&hw->io_port_owned))) { 597 ocs_list_remove_head(&hw->io_port_owned); 598 } 599 } 600 ocs_list_init(&hw->io_inuse, ocs_hw_io_t, link); 601 ocs_list_init(&hw->io_free, ocs_hw_io_t, link); 602 ocs_list_init(&hw->io_port_owned, ocs_hw_io_t, link); 603 ocs_list_init(&hw->io_wait_free, ocs_hw_io_t, link); 604 ocs_list_init(&hw->io_timed_wqe, ocs_hw_io_t, wqe_link); 605 ocs_list_init(&hw->io_port_dnrx, ocs_hw_io_t, dnrx_link); 606 607 /* If MRQ not required, Make sure we dont request feature. */ 608 if (hw->config.n_rq == 1) { 609 hw->sli.config.features.flag.mrqp = FALSE; 610 } 611 612 if (sli_init(&hw->sli)) { 613 ocs_log_err(hw->os, "SLI failed to initialize\n"); 614 return OCS_HW_RTN_ERROR; 615 } 616 617 /* 618 * Enable the auto xfer rdy feature if requested. 619 */ 620 hw->auto_xfer_rdy_enabled = FALSE; 621 if (sli_get_auto_xfer_rdy_capable(&hw->sli) && 622 hw->config.auto_xfer_rdy_size > 0) { 623 if (hw->config.esoc){ 624 if (ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf)) == 0) { 625 ramdisc_blocksize = ocs_strtoul(prop_buf, 0, 0); 626 } 627 written_size = sli_cmd_config_auto_xfer_rdy_hp(&hw->sli, buf, SLI4_BMBX_SIZE, hw->config.auto_xfer_rdy_size, 1, ramdisc_blocksize); 628 } else { 629 written_size = sli_cmd_config_auto_xfer_rdy(&hw->sli, buf, SLI4_BMBX_SIZE, hw->config.auto_xfer_rdy_size); 630 } 631 if (written_size) { 632 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 633 if (rc != OCS_HW_RTN_SUCCESS) { 634 ocs_log_err(hw->os, "config auto xfer rdy failed\n"); 635 return rc; 636 } 637 } 638 hw->auto_xfer_rdy_enabled = TRUE; 639 640 if (hw->config.auto_xfer_rdy_t10_enable) { 641 rc = ocs_hw_config_auto_xfer_rdy_t10pi(hw, buf); 642 if (rc != OCS_HW_RTN_SUCCESS) { 643 ocs_log_err(hw->os, "set parameters auto xfer rdy T10 PI failed\n"); 644 return rc; 645 } 646 } 647 } 648 649 if(hw->sliport_healthcheck) { 650 rc = ocs_hw_config_sli_port_health_check(hw, 0, 1); 651 if (rc != OCS_HW_RTN_SUCCESS) { 652 ocs_log_err(hw->os, "Enabling Sliport Health check failed \n"); 653 return rc; 654 } 655 } 656 657 /* 658 * Set FDT transfer hint, only works on Lancer 659 */ 660 if ((hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) && (OCS_HW_FDT_XFER_HINT != 0)) { 661 /* 662 * Non-fatal error. In particular, we can disregard failure to set OCS_HW_FDT_XFER_HINT on 663 * devices with legacy firmware that do not support OCS_HW_FDT_XFER_HINT feature. 664 */ 665 ocs_hw_config_set_fdt_xfer_hint(hw, OCS_HW_FDT_XFER_HINT); 666 } 667 668 /* 669 * Verify that we have not exceeded any queue sizes 670 */ 671 q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_EQ), 672 OCS_HW_MAX_NUM_EQ); 673 if (hw->config.n_eq > q_count) { 674 ocs_log_err(hw->os, "requested %d EQ but %d allowed\n", 675 hw->config.n_eq, q_count); 676 return OCS_HW_RTN_ERROR; 677 } 678 679 q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_CQ), 680 OCS_HW_MAX_NUM_CQ); 681 if (hw->config.n_cq > q_count) { 682 ocs_log_err(hw->os, "requested %d CQ but %d allowed\n", 683 hw->config.n_cq, q_count); 684 return OCS_HW_RTN_ERROR; 685 } 686 687 q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_MQ), 688 OCS_HW_MAX_NUM_MQ); 689 if (hw->config.n_mq > q_count) { 690 ocs_log_err(hw->os, "requested %d MQ but %d allowed\n", 691 hw->config.n_mq, q_count); 692 return OCS_HW_RTN_ERROR; 693 } 694 695 q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_RQ), 696 OCS_HW_MAX_NUM_RQ); 697 if (hw->config.n_rq > q_count) { 698 ocs_log_err(hw->os, "requested %d RQ but %d allowed\n", 699 hw->config.n_rq, q_count); 700 return OCS_HW_RTN_ERROR; 701 } 702 703 q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_WQ), 704 OCS_HW_MAX_NUM_WQ); 705 if (hw->config.n_wq > q_count) { 706 ocs_log_err(hw->os, "requested %d WQ but %d allowed\n", 707 hw->config.n_wq, q_count); 708 return OCS_HW_RTN_ERROR; 709 } 710 711 /* zero the hashes */ 712 ocs_memset(hw->cq_hash, 0, sizeof(hw->cq_hash)); 713 ocs_log_debug(hw->os, "Max CQs %d, hash size = %d\n", 714 OCS_HW_MAX_NUM_CQ, OCS_HW_Q_HASH_SIZE); 715 716 ocs_memset(hw->rq_hash, 0, sizeof(hw->rq_hash)); 717 ocs_log_debug(hw->os, "Max RQs %d, hash size = %d\n", 718 OCS_HW_MAX_NUM_RQ, OCS_HW_Q_HASH_SIZE); 719 720 ocs_memset(hw->wq_hash, 0, sizeof(hw->wq_hash)); 721 ocs_log_debug(hw->os, "Max WQs %d, hash size = %d\n", 722 OCS_HW_MAX_NUM_WQ, OCS_HW_Q_HASH_SIZE); 723 724 rc = ocs_hw_init_queues(hw, hw->qtop); 725 if (rc != OCS_HW_RTN_SUCCESS) { 726 return rc; 727 } 728 729 max_rpi = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI); 730 i = sli_fc_get_rpi_requirements(&hw->sli, max_rpi); 731 if (i) { 732 ocs_dma_t payload_memory; 733 734 rc = OCS_HW_RTN_ERROR; 735 736 if (hw->rnode_mem.size) { 737 ocs_dma_free(hw->os, &hw->rnode_mem); 738 } 739 740 if (ocs_dma_alloc(hw->os, &hw->rnode_mem, i, 4096)) { 741 ocs_log_err(hw->os, "remote node memory allocation fail\n"); 742 return OCS_HW_RTN_NO_MEMORY; 743 } 744 745 payload_memory.size = 0; 746 if (sli_cmd_fcoe_post_hdr_templates(&hw->sli, buf, SLI4_BMBX_SIZE, 747 &hw->rnode_mem, UINT16_MAX, &payload_memory)) { 748 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 749 750 if (payload_memory.size != 0) { 751 /* The command was non-embedded - need to free the dma buffer */ 752 ocs_dma_free(hw->os, &payload_memory); 753 } 754 } 755 756 if (rc != OCS_HW_RTN_SUCCESS) { 757 ocs_log_err(hw->os, "header template registration failed\n"); 758 return rc; 759 } 760 } 761 762 /* Allocate and post RQ buffers */ 763 rc = ocs_hw_rx_allocate(hw); 764 if (rc) { 765 ocs_log_err(hw->os, "rx_allocate failed\n"); 766 return rc; 767 } 768 769 /* Populate hw->seq_free_list */ 770 if (hw->seq_pool == NULL) { 771 uint32_t count = 0; 772 uint32_t i; 773 774 /* Sum up the total number of RQ entries, to use to allocate the sequence object pool */ 775 for (i = 0; i < hw->hw_rq_count; i++) { 776 count += hw->hw_rq[i]->entry_count; 777 } 778 779 hw->seq_pool = ocs_array_alloc(hw->os, sizeof(ocs_hw_sequence_t), count); 780 if (hw->seq_pool == NULL) { 781 ocs_log_err(hw->os, "malloc seq_pool failed\n"); 782 return OCS_HW_RTN_NO_MEMORY; 783 } 784 } 785 786 if(ocs_hw_rx_post(hw)) { 787 ocs_log_err(hw->os, "WARNING - error posting RQ buffers\n"); 788 } 789 790 /* Allocate rpi_ref if not previously allocated */ 791 if (hw->rpi_ref == NULL) { 792 hw->rpi_ref = ocs_malloc(hw->os, max_rpi * sizeof(*hw->rpi_ref), 793 OCS_M_ZERO | OCS_M_NOWAIT); 794 if (hw->rpi_ref == NULL) { 795 ocs_log_err(hw->os, "rpi_ref allocation failure (%d)\n", i); 796 return OCS_HW_RTN_NO_MEMORY; 797 } 798 } 799 800 for (i = 0; i < max_rpi; i ++) { 801 ocs_atomic_init(&hw->rpi_ref[i].rpi_count, 0); 802 ocs_atomic_init(&hw->rpi_ref[i].rpi_attached, 0); 803 } 804 805 ocs_memset(hw->domains, 0, sizeof(hw->domains)); 806 807 /* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */ 808 if (hw->workaround.override_fcfi) { 809 hw->first_domain_idx = -1; 810 } 811 812 ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi)); 813 814 /* Register a FCFI to allow unsolicited frames to be routed to the driver */ 815 if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) { 816 if (hw->hw_mrq_count) { 817 ocs_log_debug(hw->os, "using REG_FCFI MRQ\n"); 818 819 rc = ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_FCFI_MODE, 0, 0); 820 if (rc != OCS_HW_RTN_SUCCESS) { 821 ocs_log_err(hw->os, "REG_FCFI_MRQ FCFI registration failed\n"); 822 return rc; 823 } 824 825 rc = ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_MRQ_MODE, 0, 0); 826 if (rc != OCS_HW_RTN_SUCCESS) { 827 ocs_log_err(hw->os, "REG_FCFI_MRQ MRQ registration failed\n"); 828 return rc; 829 } 830 } else { 831 sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG]; 832 833 ocs_log_debug(hw->os, "using REG_FCFI standard\n"); 834 835 /* Set the filter match/mask values from hw's filter_def values */ 836 for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) { 837 rq_cfg[i].rq_id = 0xffff; 838 rq_cfg[i].r_ctl_mask = (uint8_t) hw->config.filter_def[i]; 839 rq_cfg[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8); 840 rq_cfg[i].type_mask = (uint8_t) (hw->config.filter_def[i] >> 16); 841 rq_cfg[i].type_match = (uint8_t) (hw->config.filter_def[i] >> 24); 842 } 843 844 /* 845 * Update the rq_id's of the FCF configuration (don't update more than the number 846 * of rq_cfg elements) 847 */ 848 for (i = 0; i < OCS_MIN(hw->hw_rq_count, SLI4_CMD_REG_FCFI_NUM_RQ_CFG); i++) { 849 hw_rq_t *rq = hw->hw_rq[i]; 850 uint32_t j; 851 for (j = 0; j < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; j++) { 852 uint32_t mask = (rq->filter_mask != 0) ? rq->filter_mask : 1; 853 if (mask & (1U << j)) { 854 rq_cfg[j].rq_id = rq->hdr->id; 855 ocs_log_debug(hw->os, "REG_FCFI: filter[%d] %08X -> RQ[%d] id=%d\n", 856 j, hw->config.filter_def[j], i, rq->hdr->id); 857 } 858 } 859 } 860 861 rc = OCS_HW_RTN_ERROR; 862 863 if (sli_cmd_reg_fcfi(&hw->sli, buf, SLI4_BMBX_SIZE, 0, rq_cfg, 0)) { 864 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 865 } 866 867 if (rc != OCS_HW_RTN_SUCCESS) { 868 ocs_log_err(hw->os, "FCFI registration failed\n"); 869 return rc; 870 } 871 hw->fcf_indicator = ((sli4_cmd_reg_fcfi_t *)buf)->fcfi; 872 } 873 } 874 875 /* 876 * Allocate the WQ request tag pool, if not previously allocated (the request tag value is 16 bits, 877 * thus the pool allocation size of 64k) 878 */ 879 rc = ocs_hw_reqtag_init(hw); 880 if (rc) { 881 ocs_log_err(hw->os, "ocs_pool_alloc hw_wq_callback_t failed: %d\n", rc); 882 return rc; 883 } 884 885 rc = ocs_hw_setup_io(hw); 886 if (rc) { 887 ocs_log_err(hw->os, "IO allocation failure\n"); 888 return rc; 889 } 890 891 rc = ocs_hw_init_io(hw); 892 if (rc) { 893 ocs_log_err(hw->os, "IO initialization failure\n"); 894 return rc; 895 } 896 897 ocs_queue_history_init(hw->os, &hw->q_hist); 898 899 /* get hw link config; polling, so callback will be called immediately */ 900 hw->linkcfg = OCS_HW_LINKCFG_NA; 901 ocs_hw_get_linkcfg(hw, OCS_CMD_POLL, ocs_hw_init_linkcfg_cb, hw); 902 903 /* if lancer ethernet, ethernet ports need to be enabled */ 904 if ((hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) && 905 (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_ETHERNET)) { 906 if (ocs_hw_set_eth_license(hw, hw->eth_license)) { 907 /* log warning but continue */ 908 ocs_log_err(hw->os, "Failed to set ethernet license\n"); 909 } 910 } 911 912 /* Set the DIF seed - only for lancer right now */ 913 if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli) && 914 ocs_hw_set_dif_seed(hw) != OCS_HW_RTN_SUCCESS) { 915 ocs_log_err(hw->os, "Failed to set DIF seed value\n"); 916 return rc; 917 } 918 919 /* Set the DIF mode - skyhawk only */ 920 if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli) && 921 sli_get_dif_capable(&hw->sli)) { 922 rc = ocs_hw_set_dif_mode(hw); 923 if (rc != OCS_HW_RTN_SUCCESS) { 924 ocs_log_err(hw->os, "Failed to set DIF mode value\n"); 925 return rc; 926 } 927 } 928 929 /* 930 * Arming the EQ allows (e.g.) interrupts when CQ completions write EQ entries 931 */ 932 for (i = 0; i < hw->eq_count; i++) { 933 sli_queue_arm(&hw->sli, &hw->eq[i], TRUE); 934 } 935 936 /* 937 * Initialize RQ hash 938 */ 939 for (i = 0; i < hw->rq_count; i++) { 940 ocs_hw_queue_hash_add(hw->rq_hash, hw->rq[i].id, i); 941 } 942 943 /* 944 * Initialize WQ hash 945 */ 946 for (i = 0; i < hw->wq_count; i++) { 947 ocs_hw_queue_hash_add(hw->wq_hash, hw->wq[i].id, i); 948 } 949 950 /* 951 * Arming the CQ allows (e.g.) MQ completions to write CQ entries 952 */ 953 for (i = 0; i < hw->cq_count; i++) { 954 ocs_hw_queue_hash_add(hw->cq_hash, hw->cq[i].id, i); 955 sli_queue_arm(&hw->sli, &hw->cq[i], TRUE); 956 } 957 958 /* record the fact that the queues are functional */ 959 hw->state = OCS_HW_STATE_ACTIVE; 960 961 /* Note: Must be after the IOs are setup and the state is active*/ 962 if (ocs_hw_rqpair_init(hw)) { 963 ocs_log_err(hw->os, "WARNING - error initializing RQ pair\n"); 964 } 965 966 /* finally kick off periodic timer to check for timed out target WQEs */ 967 if (hw->config.emulate_tgt_wqe_timeout) { 968 ocs_setup_timer(hw->os, &hw->wqe_timer, target_wqe_timer_cb, hw, 969 OCS_HW_WQ_TIMER_PERIOD_MS); 970 } 971 972 /* 973 * Allocate a HW IOs for send frame. Allocate one for each Class 1 WQ, or if there 974 * are none of those, allocate one for WQ[0] 975 */ 976 if ((count = ocs_varray_get_count(hw->wq_class_array[1])) > 0) { 977 for (i = 0; i < count; i++) { 978 hw_wq_t *wq = ocs_varray_iter_next(hw->wq_class_array[1]); 979 wq->send_frame_io = ocs_hw_io_alloc(hw); 980 if (wq->send_frame_io == NULL) { 981 ocs_log_err(hw->os, "ocs_hw_io_alloc for send_frame_io failed\n"); 982 } 983 } 984 } else { 985 hw->hw_wq[0]->send_frame_io = ocs_hw_io_alloc(hw); 986 if (hw->hw_wq[0]->send_frame_io == NULL) { 987 ocs_log_err(hw->os, "ocs_hw_io_alloc for send_frame_io failed\n"); 988 } 989 } 990 991 /* Initialize send frame frame sequence id */ 992 ocs_atomic_init(&hw->send_frame_seq_id, 0); 993 994 /* Initialize watchdog timer if enabled by user */ 995 hw->expiration_logged = 0; 996 if(hw->watchdog_timeout) { 997 if((hw->watchdog_timeout < 1) || (hw->watchdog_timeout > 65534)) { 998 ocs_log_err(hw->os, "watchdog_timeout out of range: Valid range is 1 - 65534\n"); 999 }else if(!ocs_hw_config_watchdog_timer(hw)) { 1000 ocs_log_info(hw->os, "watchdog timer configured with timeout = %d seconds \n", hw->watchdog_timeout); 1001 } 1002 } 1003 1004 if (ocs_dma_alloc(hw->os, &hw->domain_dmem, 112, 4)) { 1005 ocs_log_err(hw->os, "domain node memory allocation fail\n"); 1006 return OCS_HW_RTN_NO_MEMORY; 1007 } 1008 1009 if (ocs_dma_alloc(hw->os, &hw->fcf_dmem, OCS_HW_READ_FCF_SIZE, OCS_HW_READ_FCF_SIZE)) { 1010 ocs_log_err(hw->os, "domain fcf memory allocation fail\n"); 1011 return OCS_HW_RTN_NO_MEMORY; 1012 } 1013 1014 if ((0 == hw->loop_map.size) && ocs_dma_alloc(hw->os, &hw->loop_map, 1015 SLI4_MIN_LOOP_MAP_BYTES, 4)) { 1016 ocs_log_err(hw->os, "Loop dma alloc failed size:%d \n", hw->loop_map.size); 1017 } 1018 1019 return OCS_HW_RTN_SUCCESS; 1020 } 1021 1022 /** 1023 * @brief Configure Multi-RQ 1024 * 1025 * @param hw Hardware context allocated by the caller. 1026 * @param mode 1 to set MRQ filters and 0 to set FCFI index 1027 * @param vlanid valid in mode 0 1028 * @param fcf_index valid in mode 0 1029 * 1030 * @return Returns 0 on success, or a non-zero value on failure. 1031 */ 1032 static int32_t 1033 ocs_hw_config_mrq(ocs_hw_t *hw, uint8_t mode, uint16_t vlanid, uint16_t fcf_index) 1034 { 1035 uint8_t buf[SLI4_BMBX_SIZE], mrq_bitmask = 0; 1036 hw_rq_t *rq; 1037 sli4_cmd_reg_fcfi_mrq_t *rsp = NULL; 1038 uint32_t i, j; 1039 sli4_cmd_rq_cfg_t rq_filter[SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG]; 1040 int32_t rc; 1041 1042 if (mode == SLI4_CMD_REG_FCFI_SET_FCFI_MODE) { 1043 goto issue_cmd; 1044 } 1045 1046 /* Set the filter match/mask values from hw's filter_def values */ 1047 for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) { 1048 rq_filter[i].rq_id = 0xffff; 1049 rq_filter[i].r_ctl_mask = (uint8_t) hw->config.filter_def[i]; 1050 rq_filter[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8); 1051 rq_filter[i].type_mask = (uint8_t) (hw->config.filter_def[i] >> 16); 1052 rq_filter[i].type_match = (uint8_t) (hw->config.filter_def[i] >> 24); 1053 } 1054 1055 /* Accumulate counts for each filter type used, build rq_ids[] list */ 1056 for (i = 0; i < hw->hw_rq_count; i++) { 1057 rq = hw->hw_rq[i]; 1058 for (j = 0; j < SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG; j++) { 1059 if (rq->filter_mask & (1U << j)) { 1060 if (rq_filter[j].rq_id != 0xffff) { 1061 /* Already used. Bailout ifts not RQset case */ 1062 if (!rq->is_mrq || (rq_filter[j].rq_id != rq->base_mrq_id)) { 1063 ocs_log_err(hw->os, "Wrong queue topology.\n"); 1064 return OCS_HW_RTN_ERROR; 1065 } 1066 continue; 1067 } 1068 1069 if (rq->is_mrq) { 1070 rq_filter[j].rq_id = rq->base_mrq_id; 1071 mrq_bitmask |= (1U << j); 1072 } else { 1073 rq_filter[j].rq_id = rq->hdr->id; 1074 } 1075 } 1076 } 1077 } 1078 1079 issue_cmd: 1080 /* Invoke REG_FCFI_MRQ */ 1081 rc = sli_cmd_reg_fcfi_mrq(&hw->sli, 1082 buf, /* buf */ 1083 SLI4_BMBX_SIZE, /* size */ 1084 mode, /* mode 1 */ 1085 fcf_index, /* fcf_index */ 1086 vlanid, /* vlan_id */ 1087 hw->config.rq_selection_policy, /* RQ selection policy*/ 1088 mrq_bitmask, /* MRQ bitmask */ 1089 hw->hw_mrq_count, /* num_mrqs */ 1090 rq_filter); /* RQ filter */ 1091 if (rc == 0) { 1092 ocs_log_err(hw->os, "sli_cmd_reg_fcfi_mrq() failed: %d\n", rc); 1093 return OCS_HW_RTN_ERROR; 1094 } 1095 1096 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 1097 1098 rsp = (sli4_cmd_reg_fcfi_mrq_t *)buf; 1099 1100 if ((rc != OCS_HW_RTN_SUCCESS) || (rsp->hdr.status)) { 1101 ocs_log_err(hw->os, "FCFI MRQ registration failed. cmd = %x status = %x\n", 1102 rsp->hdr.command, rsp->hdr.status); 1103 return OCS_HW_RTN_ERROR; 1104 } 1105 1106 if (mode == SLI4_CMD_REG_FCFI_SET_FCFI_MODE) { 1107 hw->fcf_indicator = rsp->fcfi; 1108 } 1109 return 0; 1110 } 1111 1112 /** 1113 * @brief Callback function for getting linkcfg during HW initialization. 1114 * 1115 * @param status Status of the linkcfg get operation. 1116 * @param value Link configuration enum to which the link configuration is set. 1117 * @param arg Callback argument (ocs_hw_t *). 1118 * 1119 * @return None. 1120 */ 1121 static void 1122 ocs_hw_init_linkcfg_cb(int32_t status, uintptr_t value, void *arg) 1123 { 1124 ocs_hw_t *hw = (ocs_hw_t *)arg; 1125 if (status == 0) { 1126 hw->linkcfg = (ocs_hw_linkcfg_e)value; 1127 } else { 1128 hw->linkcfg = OCS_HW_LINKCFG_NA; 1129 } 1130 ocs_log_debug(hw->os, "linkcfg=%d\n", hw->linkcfg); 1131 } 1132 1133 /** 1134 * @ingroup devInitShutdown 1135 * @brief Tear down the Hardware Abstraction Layer module. 1136 * 1137 * @par Description 1138 * Frees memory structures needed by the device, and shuts down the device. Does 1139 * not free the HW context memory (which is done by the caller). 1140 * 1141 * @param hw Hardware context allocated by the caller. 1142 * 1143 * @return Returns 0 on success, or a non-zero value on failure. 1144 */ 1145 ocs_hw_rtn_e 1146 ocs_hw_teardown(ocs_hw_t *hw) 1147 { 1148 uint32_t i = 0; 1149 uint32_t iters = 10;/*XXX*/ 1150 uint32_t max_rpi; 1151 uint32_t destroy_queues; 1152 uint32_t free_memory; 1153 1154 if (!hw) { 1155 ocs_log_err(NULL, "bad parameter(s) hw=%p\n", hw); 1156 return OCS_HW_RTN_ERROR; 1157 } 1158 1159 destroy_queues = (hw->state == OCS_HW_STATE_ACTIVE); 1160 free_memory = (hw->state != OCS_HW_STATE_UNINITIALIZED); 1161 1162 /* shutdown target wqe timer */ 1163 shutdown_target_wqe_timer(hw); 1164 1165 /* Cancel watchdog timer if enabled */ 1166 if(hw->watchdog_timeout) { 1167 hw->watchdog_timeout = 0; 1168 ocs_hw_config_watchdog_timer(hw); 1169 } 1170 1171 /* Cancel Sliport Healthcheck */ 1172 if(hw->sliport_healthcheck) { 1173 hw->sliport_healthcheck = 0; 1174 ocs_hw_config_sli_port_health_check(hw, 0, 0); 1175 } 1176 1177 if (hw->state != OCS_HW_STATE_QUEUES_ALLOCATED) { 1178 hw->state = OCS_HW_STATE_TEARDOWN_IN_PROGRESS; 1179 1180 ocs_hw_flush(hw); 1181 1182 /* If there are outstanding commands, wait for them to complete */ 1183 while (!ocs_list_empty(&hw->cmd_head) && iters) { 1184 ocs_udelay(10000); 1185 ocs_hw_flush(hw); 1186 iters--; 1187 } 1188 1189 if (ocs_list_empty(&hw->cmd_head)) { 1190 ocs_log_debug(hw->os, "All commands completed on MQ queue\n"); 1191 } else { 1192 ocs_log_debug(hw->os, "Some commands still pending on MQ queue\n"); 1193 } 1194 1195 /* Cancel any remaining commands */ 1196 ocs_hw_command_cancel(hw); 1197 } else { 1198 hw->state = OCS_HW_STATE_TEARDOWN_IN_PROGRESS; 1199 } 1200 1201 ocs_lock_free(&hw->cmd_lock); 1202 1203 /* Free unregistered RPI if workaround is in force */ 1204 if (hw->workaround.use_unregistered_rpi) { 1205 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, hw->workaround.unregistered_rid); 1206 } 1207 1208 max_rpi = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI); 1209 if (hw->rpi_ref) { 1210 for (i = 0; i < max_rpi; i++) { 1211 if (ocs_atomic_read(&hw->rpi_ref[i].rpi_count)) { 1212 ocs_log_debug(hw->os, "non-zero ref [%d]=%d\n", 1213 i, ocs_atomic_read(&hw->rpi_ref[i].rpi_count)); 1214 } 1215 } 1216 ocs_free(hw->os, hw->rpi_ref, max_rpi * sizeof(*hw->rpi_ref)); 1217 hw->rpi_ref = NULL; 1218 } 1219 1220 ocs_dma_free(hw->os, &hw->rnode_mem); 1221 1222 if (hw->io) { 1223 for (i = 0; i < hw->config.n_io; i++) { 1224 if (hw->io[i] && (hw->io[i]->sgl != NULL) && 1225 (hw->io[i]->sgl->virt != NULL)) { 1226 if(hw->io[i]->is_port_owned) { 1227 ocs_lock_free(&hw->io[i]->axr_lock); 1228 } 1229 ocs_dma_free(hw->os, hw->io[i]->sgl); 1230 } 1231 ocs_free(hw->os, hw->io[i], sizeof(ocs_hw_io_t)); 1232 hw->io[i] = NULL; 1233 } 1234 ocs_free(hw->os, hw->wqe_buffs, hw->config.n_io * hw->sli.config.wqe_size); 1235 hw->wqe_buffs = NULL; 1236 ocs_free(hw->os, hw->io, hw->config.n_io * sizeof(ocs_hw_io_t *)); 1237 hw->io = NULL; 1238 } 1239 1240 ocs_dma_free(hw->os, &hw->xfer_rdy); 1241 ocs_dma_free(hw->os, &hw->dump_sges); 1242 ocs_dma_free(hw->os, &hw->loop_map); 1243 1244 ocs_lock_free(&hw->io_lock); 1245 ocs_lock_free(&hw->io_abort_lock); 1246 1247 for (i = 0; i < hw->wq_count; i++) { 1248 sli_queue_free(&hw->sli, &hw->wq[i], destroy_queues, free_memory); 1249 } 1250 1251 for (i = 0; i < hw->rq_count; i++) { 1252 sli_queue_free(&hw->sli, &hw->rq[i], destroy_queues, free_memory); 1253 } 1254 1255 for (i = 0; i < hw->mq_count; i++) { 1256 sli_queue_free(&hw->sli, &hw->mq[i], destroy_queues, free_memory); 1257 } 1258 1259 for (i = 0; i < hw->cq_count; i++) { 1260 sli_queue_free(&hw->sli, &hw->cq[i], destroy_queues, free_memory); 1261 } 1262 1263 for (i = 0; i < hw->eq_count; i++) { 1264 sli_queue_free(&hw->sli, &hw->eq[i], destroy_queues, free_memory); 1265 } 1266 1267 ocs_hw_qtop_free(hw->qtop); 1268 1269 /* Free rq buffers */ 1270 ocs_hw_rx_free(hw); 1271 1272 hw_queue_teardown(hw); 1273 1274 ocs_hw_rqpair_teardown(hw); 1275 1276 if (sli_teardown(&hw->sli)) { 1277 ocs_log_err(hw->os, "SLI teardown failed\n"); 1278 } 1279 1280 ocs_queue_history_free(&hw->q_hist); 1281 1282 /* record the fact that the queues are non-functional */ 1283 hw->state = OCS_HW_STATE_UNINITIALIZED; 1284 1285 /* free sequence free pool */ 1286 ocs_array_free(hw->seq_pool); 1287 hw->seq_pool = NULL; 1288 1289 /* free hw_wq_callback pool */ 1290 ocs_pool_free(hw->wq_reqtag_pool); 1291 1292 ocs_dma_free(hw->os, &hw->domain_dmem); 1293 ocs_dma_free(hw->os, &hw->fcf_dmem); 1294 /* Mark HW setup as not having been called */ 1295 hw->hw_setup_called = FALSE; 1296 1297 return OCS_HW_RTN_SUCCESS; 1298 } 1299 1300 ocs_hw_rtn_e 1301 ocs_hw_reset(ocs_hw_t *hw, ocs_hw_reset_e reset) 1302 { 1303 uint32_t i; 1304 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 1305 uint32_t iters; 1306 ocs_hw_state_e prev_state = hw->state; 1307 1308 if (hw->state != OCS_HW_STATE_ACTIVE) { 1309 ocs_log_test(hw->os, "HW state %d is not active\n", hw->state); 1310 } 1311 1312 hw->state = OCS_HW_STATE_RESET_IN_PROGRESS; 1313 1314 /* shutdown target wqe timer */ 1315 shutdown_target_wqe_timer(hw); 1316 1317 ocs_hw_flush(hw); 1318 1319 /* 1320 * If an mailbox command requiring a DMA is outstanding (i.e. SFP/DDM), 1321 * then the FW will UE when the reset is issued. So attempt to complete 1322 * all mailbox commands. 1323 */ 1324 iters = 10; 1325 while (!ocs_list_empty(&hw->cmd_head) && iters) { 1326 ocs_udelay(10000); 1327 ocs_hw_flush(hw); 1328 iters--; 1329 } 1330 1331 if (ocs_list_empty(&hw->cmd_head)) { 1332 ocs_log_debug(hw->os, "All commands completed on MQ queue\n"); 1333 } else { 1334 ocs_log_debug(hw->os, "Some commands still pending on MQ queue\n"); 1335 } 1336 1337 /* Reset the chip */ 1338 switch(reset) { 1339 case OCS_HW_RESET_FUNCTION: 1340 ocs_log_debug(hw->os, "issuing function level reset\n"); 1341 if (sli_reset(&hw->sli)) { 1342 ocs_log_err(hw->os, "sli_reset failed\n"); 1343 rc = OCS_HW_RTN_ERROR; 1344 } 1345 break; 1346 case OCS_HW_RESET_FIRMWARE: 1347 ocs_log_debug(hw->os, "issuing firmware reset\n"); 1348 if (sli_fw_reset(&hw->sli)) { 1349 ocs_log_err(hw->os, "sli_soft_reset failed\n"); 1350 rc = OCS_HW_RTN_ERROR; 1351 } 1352 /* 1353 * Because the FW reset leaves the FW in a non-running state, 1354 * follow that with a regular reset. 1355 */ 1356 ocs_log_debug(hw->os, "issuing function level reset\n"); 1357 if (sli_reset(&hw->sli)) { 1358 ocs_log_err(hw->os, "sli_reset failed\n"); 1359 rc = OCS_HW_RTN_ERROR; 1360 } 1361 break; 1362 default: 1363 ocs_log_test(hw->os, "unknown reset type - no reset performed\n"); 1364 hw->state = prev_state; 1365 return OCS_HW_RTN_ERROR; 1366 } 1367 1368 /* Not safe to walk command/io lists unless they've been initialized */ 1369 if (prev_state != OCS_HW_STATE_UNINITIALIZED) { 1370 ocs_hw_command_cancel(hw); 1371 1372 /* Clean up the inuse list, the free list and the wait free list */ 1373 ocs_hw_io_cancel(hw); 1374 1375 ocs_memset(hw->domains, 0, sizeof(hw->domains)); 1376 ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi)); 1377 1378 ocs_hw_link_event_init(hw); 1379 1380 ocs_lock(&hw->io_lock); 1381 /* The io lists should be empty, but remove any that didn't get cleaned up. */ 1382 while (!ocs_list_empty(&hw->io_timed_wqe)) { 1383 ocs_list_remove_head(&hw->io_timed_wqe); 1384 } 1385 /* Don't clean up the io_inuse list, the backend will do that when it finishes the IO */ 1386 1387 while (!ocs_list_empty(&hw->io_free)) { 1388 ocs_list_remove_head(&hw->io_free); 1389 } 1390 while (!ocs_list_empty(&hw->io_wait_free)) { 1391 ocs_list_remove_head(&hw->io_wait_free); 1392 } 1393 1394 /* Reset the request tag pool, the HW IO request tags are reassigned in ocs_hw_setup_io() */ 1395 ocs_hw_reqtag_reset(hw); 1396 1397 ocs_unlock(&hw->io_lock); 1398 } 1399 1400 if (prev_state != OCS_HW_STATE_UNINITIALIZED) { 1401 for (i = 0; i < hw->wq_count; i++) { 1402 sli_queue_reset(&hw->sli, &hw->wq[i]); 1403 } 1404 1405 for (i = 0; i < hw->rq_count; i++) { 1406 sli_queue_reset(&hw->sli, &hw->rq[i]); 1407 } 1408 1409 for (i = 0; i < hw->hw_rq_count; i++) { 1410 hw_rq_t *rq = hw->hw_rq[i]; 1411 if (rq->rq_tracker != NULL) { 1412 uint32_t j; 1413 1414 for (j = 0; j < rq->entry_count; j++) { 1415 rq->rq_tracker[j] = NULL; 1416 } 1417 } 1418 } 1419 1420 for (i = 0; i < hw->mq_count; i++) { 1421 sli_queue_reset(&hw->sli, &hw->mq[i]); 1422 } 1423 1424 for (i = 0; i < hw->cq_count; i++) { 1425 sli_queue_reset(&hw->sli, &hw->cq[i]); 1426 } 1427 1428 for (i = 0; i < hw->eq_count; i++) { 1429 sli_queue_reset(&hw->sli, &hw->eq[i]); 1430 } 1431 1432 /* Free rq buffers */ 1433 ocs_hw_rx_free(hw); 1434 1435 /* Teardown the HW queue topology */ 1436 hw_queue_teardown(hw); 1437 } else { 1438 /* Free rq buffers */ 1439 ocs_hw_rx_free(hw); 1440 } 1441 1442 /* 1443 * Re-apply the run-time workarounds after clearing the SLI config 1444 * fields in sli_reset. 1445 */ 1446 ocs_hw_workaround_setup(hw); 1447 hw->state = OCS_HW_STATE_QUEUES_ALLOCATED; 1448 1449 return rc; 1450 } 1451 1452 int32_t 1453 ocs_hw_get_num_eq(ocs_hw_t *hw) 1454 { 1455 return hw->eq_count; 1456 } 1457 1458 static int32_t 1459 ocs_hw_get_fw_timed_out(ocs_hw_t *hw) 1460 { 1461 /* The error values below are taken from LOWLEVEL_SET_WATCHDOG_TIMER_rev1.pdf 1462 * No further explanation is given in the document. 1463 * */ 1464 return (sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR1) == 0x2 && 1465 sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR2) == 0x10); 1466 } 1467 1468 ocs_hw_rtn_e 1469 ocs_hw_get(ocs_hw_t *hw, ocs_hw_property_e prop, uint32_t *value) 1470 { 1471 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 1472 int32_t tmp; 1473 1474 if (!value) { 1475 return OCS_HW_RTN_ERROR; 1476 } 1477 1478 *value = 0; 1479 1480 switch (prop) { 1481 case OCS_HW_N_IO: 1482 *value = hw->config.n_io; 1483 break; 1484 case OCS_HW_N_SGL: 1485 *value = (hw->config.n_sgl - SLI4_SGE_MAX_RESERVED); 1486 break; 1487 case OCS_HW_MAX_IO: 1488 *value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI); 1489 break; 1490 case OCS_HW_MAX_NODES: 1491 *value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI); 1492 break; 1493 case OCS_HW_MAX_RQ_ENTRIES: 1494 *value = hw->num_qentries[SLI_QTYPE_RQ]; 1495 break; 1496 case OCS_HW_RQ_DEFAULT_BUFFER_SIZE: 1497 *value = hw->config.rq_default_buffer_size; 1498 break; 1499 case OCS_HW_AUTO_XFER_RDY_CAPABLE: 1500 *value = sli_get_auto_xfer_rdy_capable(&hw->sli); 1501 break; 1502 case OCS_HW_AUTO_XFER_RDY_XRI_CNT: 1503 *value = hw->config.auto_xfer_rdy_xri_cnt; 1504 break; 1505 case OCS_HW_AUTO_XFER_RDY_SIZE: 1506 *value = hw->config.auto_xfer_rdy_size; 1507 break; 1508 case OCS_HW_AUTO_XFER_RDY_BLK_SIZE: 1509 switch (hw->config.auto_xfer_rdy_blk_size_chip) { 1510 case 0: 1511 *value = 512; 1512 break; 1513 case 1: 1514 *value = 1024; 1515 break; 1516 case 2: 1517 *value = 2048; 1518 break; 1519 case 3: 1520 *value = 4096; 1521 break; 1522 case 4: 1523 *value = 520; 1524 break; 1525 default: 1526 *value = 0; 1527 rc = OCS_HW_RTN_ERROR; 1528 break; 1529 } 1530 break; 1531 case OCS_HW_AUTO_XFER_RDY_T10_ENABLE: 1532 *value = hw->config.auto_xfer_rdy_t10_enable; 1533 break; 1534 case OCS_HW_AUTO_XFER_RDY_P_TYPE: 1535 *value = hw->config.auto_xfer_rdy_p_type; 1536 break; 1537 case OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA: 1538 *value = hw->config.auto_xfer_rdy_ref_tag_is_lba; 1539 break; 1540 case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID: 1541 *value = hw->config.auto_xfer_rdy_app_tag_valid; 1542 break; 1543 case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE: 1544 *value = hw->config.auto_xfer_rdy_app_tag_value; 1545 break; 1546 case OCS_HW_MAX_SGE: 1547 *value = sli_get_max_sge(&hw->sli); 1548 break; 1549 case OCS_HW_MAX_SGL: 1550 *value = sli_get_max_sgl(&hw->sli); 1551 break; 1552 case OCS_HW_TOPOLOGY: 1553 /* 1554 * Infer link.status based on link.speed. 1555 * Report OCS_HW_TOPOLOGY_NONE if the link is down. 1556 */ 1557 if (hw->link.speed == 0) { 1558 *value = OCS_HW_TOPOLOGY_NONE; 1559 break; 1560 } 1561 switch (hw->link.topology) { 1562 case SLI_LINK_TOPO_NPORT: 1563 *value = OCS_HW_TOPOLOGY_NPORT; 1564 break; 1565 case SLI_LINK_TOPO_LOOP: 1566 *value = OCS_HW_TOPOLOGY_LOOP; 1567 break; 1568 case SLI_LINK_TOPO_NONE: 1569 *value = OCS_HW_TOPOLOGY_NONE; 1570 break; 1571 default: 1572 ocs_log_test(hw->os, "unsupported topology %#x\n", hw->link.topology); 1573 rc = OCS_HW_RTN_ERROR; 1574 break; 1575 } 1576 break; 1577 case OCS_HW_CONFIG_TOPOLOGY: 1578 *value = hw->config.topology; 1579 break; 1580 case OCS_HW_LINK_SPEED: 1581 *value = hw->link.speed; 1582 break; 1583 case OCS_HW_LINK_CONFIG_SPEED: 1584 switch (hw->config.speed) { 1585 case FC_LINK_SPEED_10G: 1586 *value = 10000; 1587 break; 1588 case FC_LINK_SPEED_AUTO_16_8_4: 1589 *value = 0; 1590 break; 1591 case FC_LINK_SPEED_2G: 1592 *value = 2000; 1593 break; 1594 case FC_LINK_SPEED_4G: 1595 *value = 4000; 1596 break; 1597 case FC_LINK_SPEED_8G: 1598 *value = 8000; 1599 break; 1600 case FC_LINK_SPEED_16G: 1601 *value = 16000; 1602 break; 1603 case FC_LINK_SPEED_32G: 1604 *value = 32000; 1605 break; 1606 default: 1607 ocs_log_test(hw->os, "unsupported speed %#x\n", hw->config.speed); 1608 rc = OCS_HW_RTN_ERROR; 1609 break; 1610 } 1611 break; 1612 case OCS_HW_IF_TYPE: 1613 *value = sli_get_if_type(&hw->sli); 1614 break; 1615 case OCS_HW_SLI_REV: 1616 *value = sli_get_sli_rev(&hw->sli); 1617 break; 1618 case OCS_HW_SLI_FAMILY: 1619 *value = sli_get_sli_family(&hw->sli); 1620 break; 1621 case OCS_HW_DIF_CAPABLE: 1622 *value = sli_get_dif_capable(&hw->sli); 1623 break; 1624 case OCS_HW_DIF_SEED: 1625 *value = hw->config.dif_seed; 1626 break; 1627 case OCS_HW_DIF_MODE: 1628 *value = hw->config.dif_mode; 1629 break; 1630 case OCS_HW_DIF_MULTI_SEPARATE: 1631 /* Lancer supports multiple DIF separates */ 1632 if (hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) { 1633 *value = TRUE; 1634 } else { 1635 *value = FALSE; 1636 } 1637 break; 1638 case OCS_HW_DUMP_MAX_SIZE: 1639 *value = hw->dump_size; 1640 break; 1641 case OCS_HW_DUMP_READY: 1642 *value = sli_dump_is_ready(&hw->sli); 1643 break; 1644 case OCS_HW_DUMP_PRESENT: 1645 *value = sli_dump_is_present(&hw->sli); 1646 break; 1647 case OCS_HW_RESET_REQUIRED: 1648 tmp = sli_reset_required(&hw->sli); 1649 if(tmp < 0) { 1650 rc = OCS_HW_RTN_ERROR; 1651 } else { 1652 *value = tmp; 1653 } 1654 break; 1655 case OCS_HW_FW_ERROR: 1656 *value = sli_fw_error_status(&hw->sli); 1657 break; 1658 case OCS_HW_FW_READY: 1659 *value = sli_fw_ready(&hw->sli); 1660 break; 1661 case OCS_HW_FW_TIMED_OUT: 1662 *value = ocs_hw_get_fw_timed_out(hw); 1663 break; 1664 case OCS_HW_HIGH_LOGIN_MODE: 1665 *value = sli_get_hlm_capable(&hw->sli); 1666 break; 1667 case OCS_HW_PREREGISTER_SGL: 1668 *value = sli_get_sgl_preregister_required(&hw->sli); 1669 break; 1670 case OCS_HW_HW_REV1: 1671 *value = sli_get_hw_revision(&hw->sli, 0); 1672 break; 1673 case OCS_HW_HW_REV2: 1674 *value = sli_get_hw_revision(&hw->sli, 1); 1675 break; 1676 case OCS_HW_HW_REV3: 1677 *value = sli_get_hw_revision(&hw->sli, 2); 1678 break; 1679 case OCS_HW_LINKCFG: 1680 *value = hw->linkcfg; 1681 break; 1682 case OCS_HW_ETH_LICENSE: 1683 *value = hw->eth_license; 1684 break; 1685 case OCS_HW_LINK_MODULE_TYPE: 1686 *value = sli_get_link_module_type(&hw->sli); 1687 break; 1688 case OCS_HW_NUM_CHUTES: 1689 *value = ocs_hw_get_num_chutes(hw); 1690 break; 1691 case OCS_HW_DISABLE_AR_TGT_DIF: 1692 *value = hw->workaround.disable_ar_tgt_dif; 1693 break; 1694 case OCS_HW_EMULATE_I_ONLY_AAB: 1695 *value = hw->config.i_only_aab; 1696 break; 1697 case OCS_HW_EMULATE_TARGET_WQE_TIMEOUT: 1698 *value = hw->config.emulate_tgt_wqe_timeout; 1699 break; 1700 case OCS_HW_VPD_LEN: 1701 *value = sli_get_vpd_len(&hw->sli); 1702 break; 1703 case OCS_HW_SGL_CHAINING_CAPABLE: 1704 *value = sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported; 1705 break; 1706 case OCS_HW_SGL_CHAINING_ALLOWED: 1707 /* 1708 * SGL Chaining is allowed in the following cases: 1709 * 1. Lancer with host SGL Lists 1710 * 2. Skyhawk with pre-registered SGL Lists 1711 */ 1712 *value = FALSE; 1713 if ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) && 1714 !sli_get_sgl_preregister(&hw->sli) && 1715 SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) { 1716 *value = TRUE; 1717 } 1718 1719 if ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) && 1720 sli_get_sgl_preregister(&hw->sli) && 1721 ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) || 1722 (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli)))) { 1723 *value = TRUE; 1724 } 1725 break; 1726 case OCS_HW_SGL_CHAINING_HOST_ALLOCATED: 1727 /* Only lancer supports host allocated SGL Chaining buffers. */ 1728 *value = ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) && 1729 (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli))); 1730 break; 1731 case OCS_HW_SEND_FRAME_CAPABLE: 1732 if (hw->workaround.ignore_send_frame) { 1733 *value = 0; 1734 } else { 1735 /* Only lancer is capable */ 1736 *value = sli_get_if_type(&hw->sli) == SLI4_IF_TYPE_LANCER_FC_ETH; 1737 } 1738 break; 1739 case OCS_HW_RQ_SELECTION_POLICY: 1740 *value = hw->config.rq_selection_policy; 1741 break; 1742 case OCS_HW_RR_QUANTA: 1743 *value = hw->config.rr_quanta; 1744 break; 1745 case OCS_HW_MAX_VPORTS: 1746 *value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_VPI); 1747 break; 1748 default: 1749 ocs_log_test(hw->os, "unsupported property %#x\n", prop); 1750 rc = OCS_HW_RTN_ERROR; 1751 } 1752 1753 return rc; 1754 } 1755 1756 void * 1757 ocs_hw_get_ptr(ocs_hw_t *hw, ocs_hw_property_e prop) 1758 { 1759 void *rc = NULL; 1760 1761 switch (prop) { 1762 case OCS_HW_WWN_NODE: 1763 rc = sli_get_wwn_node(&hw->sli); 1764 break; 1765 case OCS_HW_WWN_PORT: 1766 rc = sli_get_wwn_port(&hw->sli); 1767 break; 1768 case OCS_HW_VPD: 1769 /* make sure VPD length is non-zero */ 1770 if (sli_get_vpd_len(&hw->sli)) { 1771 rc = sli_get_vpd(&hw->sli); 1772 } 1773 break; 1774 case OCS_HW_FW_REV: 1775 rc = sli_get_fw_name(&hw->sli, 0); 1776 break; 1777 case OCS_HW_FW_REV2: 1778 rc = sli_get_fw_name(&hw->sli, 1); 1779 break; 1780 case OCS_HW_IPL: 1781 rc = sli_get_ipl_name(&hw->sli); 1782 break; 1783 case OCS_HW_PORTNUM: 1784 rc = sli_get_portnum(&hw->sli); 1785 break; 1786 case OCS_HW_BIOS_VERSION_STRING: 1787 rc = sli_get_bios_version_string(&hw->sli); 1788 break; 1789 default: 1790 ocs_log_test(hw->os, "unsupported property %#x\n", prop); 1791 } 1792 1793 return rc; 1794 } 1795 1796 ocs_hw_rtn_e 1797 ocs_hw_set(ocs_hw_t *hw, ocs_hw_property_e prop, uint32_t value) 1798 { 1799 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 1800 1801 switch (prop) { 1802 case OCS_HW_N_IO: 1803 if (value > sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI) || 1804 value == 0) { 1805 ocs_log_test(hw->os, "IO value out of range %d vs %d\n", 1806 value, sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI)); 1807 rc = OCS_HW_RTN_ERROR; 1808 } else { 1809 hw->config.n_io = value; 1810 } 1811 break; 1812 case OCS_HW_N_SGL: 1813 value += SLI4_SGE_MAX_RESERVED; 1814 if (value > sli_get_max_sgl(&hw->sli)) { 1815 ocs_log_test(hw->os, "SGL value out of range %d vs %d\n", 1816 value, sli_get_max_sgl(&hw->sli)); 1817 rc = OCS_HW_RTN_ERROR; 1818 } else { 1819 hw->config.n_sgl = value; 1820 } 1821 break; 1822 case OCS_HW_TOPOLOGY: 1823 if ((sli_get_medium(&hw->sli) != SLI_LINK_MEDIUM_FC) && 1824 (value != OCS_HW_TOPOLOGY_AUTO)) { 1825 ocs_log_test(hw->os, "unsupported topology=%#x medium=%#x\n", 1826 value, sli_get_medium(&hw->sli)); 1827 rc = OCS_HW_RTN_ERROR; 1828 break; 1829 } 1830 1831 switch (value) { 1832 case OCS_HW_TOPOLOGY_AUTO: 1833 if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) { 1834 sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC); 1835 } else { 1836 sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FCOE); 1837 } 1838 break; 1839 case OCS_HW_TOPOLOGY_NPORT: 1840 sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC_DA); 1841 break; 1842 case OCS_HW_TOPOLOGY_LOOP: 1843 sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC_AL); 1844 break; 1845 default: 1846 ocs_log_test(hw->os, "unsupported topology %#x\n", value); 1847 rc = OCS_HW_RTN_ERROR; 1848 } 1849 hw->config.topology = value; 1850 break; 1851 case OCS_HW_LINK_SPEED: 1852 if (sli_get_medium(&hw->sli) != SLI_LINK_MEDIUM_FC) { 1853 switch (value) { 1854 case 0: /* Auto-speed negotiation */ 1855 case 10000: /* FCoE speed */ 1856 hw->config.speed = FC_LINK_SPEED_10G; 1857 break; 1858 default: 1859 ocs_log_test(hw->os, "unsupported speed=%#x medium=%#x\n", 1860 value, sli_get_medium(&hw->sli)); 1861 rc = OCS_HW_RTN_ERROR; 1862 } 1863 break; 1864 } 1865 1866 switch (value) { 1867 case 0: /* Auto-speed negotiation */ 1868 hw->config.speed = FC_LINK_SPEED_AUTO_16_8_4; 1869 break; 1870 case 2000: /* FC speeds */ 1871 hw->config.speed = FC_LINK_SPEED_2G; 1872 break; 1873 case 4000: 1874 hw->config.speed = FC_LINK_SPEED_4G; 1875 break; 1876 case 8000: 1877 hw->config.speed = FC_LINK_SPEED_8G; 1878 break; 1879 case 16000: 1880 hw->config.speed = FC_LINK_SPEED_16G; 1881 break; 1882 case 32000: 1883 hw->config.speed = FC_LINK_SPEED_32G; 1884 break; 1885 default: 1886 ocs_log_test(hw->os, "unsupported speed %d\n", value); 1887 rc = OCS_HW_RTN_ERROR; 1888 } 1889 break; 1890 case OCS_HW_DIF_SEED: 1891 /* Set the DIF seed - only for lancer right now */ 1892 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 1893 ocs_log_test(hw->os, "DIF seed not supported for this device\n"); 1894 rc = OCS_HW_RTN_ERROR; 1895 } else { 1896 hw->config.dif_seed = value; 1897 } 1898 break; 1899 case OCS_HW_DIF_MODE: 1900 switch (value) { 1901 case OCS_HW_DIF_MODE_INLINE: 1902 /* 1903 * Make sure we support inline DIF. 1904 * 1905 * Note: Having both bits clear means that we have old 1906 * FW that doesn't set the bits. 1907 */ 1908 if (sli_is_dif_inline_capable(&hw->sli)) { 1909 hw->config.dif_mode = value; 1910 } else { 1911 ocs_log_test(hw->os, "chip does not support DIF inline\n"); 1912 rc = OCS_HW_RTN_ERROR; 1913 } 1914 break; 1915 case OCS_HW_DIF_MODE_SEPARATE: 1916 /* Make sure we support DIF separates. */ 1917 if (sli_is_dif_separate_capable(&hw->sli)) { 1918 hw->config.dif_mode = value; 1919 } else { 1920 ocs_log_test(hw->os, "chip does not support DIF separate\n"); 1921 rc = OCS_HW_RTN_ERROR; 1922 } 1923 } 1924 break; 1925 case OCS_HW_RQ_PROCESS_LIMIT: { 1926 hw_rq_t *rq; 1927 uint32_t i; 1928 1929 /* For each hw_rq object, set its parent CQ limit value */ 1930 for (i = 0; i < hw->hw_rq_count; i++) { 1931 rq = hw->hw_rq[i]; 1932 hw->cq[rq->cq->instance].proc_limit = value; 1933 } 1934 break; 1935 } 1936 case OCS_HW_RQ_DEFAULT_BUFFER_SIZE: 1937 hw->config.rq_default_buffer_size = value; 1938 break; 1939 case OCS_HW_AUTO_XFER_RDY_XRI_CNT: 1940 hw->config.auto_xfer_rdy_xri_cnt = value; 1941 break; 1942 case OCS_HW_AUTO_XFER_RDY_SIZE: 1943 hw->config.auto_xfer_rdy_size = value; 1944 break; 1945 case OCS_HW_AUTO_XFER_RDY_BLK_SIZE: 1946 switch (value) { 1947 case 512: 1948 hw->config.auto_xfer_rdy_blk_size_chip = 0; 1949 break; 1950 case 1024: 1951 hw->config.auto_xfer_rdy_blk_size_chip = 1; 1952 break; 1953 case 2048: 1954 hw->config.auto_xfer_rdy_blk_size_chip = 2; 1955 break; 1956 case 4096: 1957 hw->config.auto_xfer_rdy_blk_size_chip = 3; 1958 break; 1959 case 520: 1960 hw->config.auto_xfer_rdy_blk_size_chip = 4; 1961 break; 1962 default: 1963 ocs_log_err(hw->os, "Invalid block size %d\n", 1964 value); 1965 rc = OCS_HW_RTN_ERROR; 1966 } 1967 break; 1968 case OCS_HW_AUTO_XFER_RDY_T10_ENABLE: 1969 hw->config.auto_xfer_rdy_t10_enable = value; 1970 break; 1971 case OCS_HW_AUTO_XFER_RDY_P_TYPE: 1972 hw->config.auto_xfer_rdy_p_type = value; 1973 break; 1974 case OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA: 1975 hw->config.auto_xfer_rdy_ref_tag_is_lba = value; 1976 break; 1977 case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID: 1978 hw->config.auto_xfer_rdy_app_tag_valid = value; 1979 break; 1980 case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE: 1981 hw->config.auto_xfer_rdy_app_tag_value = value; 1982 break; 1983 case OCS_ESOC: 1984 hw->config.esoc = value; 1985 break; 1986 case OCS_HW_HIGH_LOGIN_MODE: 1987 rc = sli_set_hlm(&hw->sli, value); 1988 break; 1989 case OCS_HW_PREREGISTER_SGL: 1990 rc = sli_set_sgl_preregister(&hw->sli, value); 1991 break; 1992 case OCS_HW_ETH_LICENSE: 1993 hw->eth_license = value; 1994 break; 1995 case OCS_HW_EMULATE_I_ONLY_AAB: 1996 hw->config.i_only_aab = value; 1997 break; 1998 case OCS_HW_EMULATE_TARGET_WQE_TIMEOUT: 1999 hw->config.emulate_tgt_wqe_timeout = value; 2000 break; 2001 case OCS_HW_BOUNCE: 2002 hw->config.bounce = value; 2003 break; 2004 case OCS_HW_RQ_SELECTION_POLICY: 2005 hw->config.rq_selection_policy = value; 2006 break; 2007 case OCS_HW_RR_QUANTA: 2008 hw->config.rr_quanta = value; 2009 break; 2010 default: 2011 ocs_log_test(hw->os, "unsupported property %#x\n", prop); 2012 rc = OCS_HW_RTN_ERROR; 2013 } 2014 2015 return rc; 2016 } 2017 2018 ocs_hw_rtn_e 2019 ocs_hw_set_ptr(ocs_hw_t *hw, ocs_hw_property_e prop, void *value) 2020 { 2021 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2022 2023 switch (prop) { 2024 case OCS_HW_WAR_VERSION: 2025 hw->hw_war_version = value; 2026 break; 2027 case OCS_HW_FILTER_DEF: { 2028 char *p = value; 2029 uint32_t idx = 0; 2030 2031 for (idx = 0; idx < ARRAY_SIZE(hw->config.filter_def); idx++) { 2032 hw->config.filter_def[idx] = 0; 2033 } 2034 2035 for (idx = 0; (idx < ARRAY_SIZE(hw->config.filter_def)) && (p != NULL) && *p; ) { 2036 hw->config.filter_def[idx++] = ocs_strtoul(p, 0, 0); 2037 p = ocs_strchr(p, ','); 2038 if (p != NULL) { 2039 p++; 2040 } 2041 } 2042 2043 break; 2044 } 2045 default: 2046 ocs_log_test(hw->os, "unsupported property %#x\n", prop); 2047 rc = OCS_HW_RTN_ERROR; 2048 break; 2049 } 2050 return rc; 2051 } 2052 /** 2053 * @ingroup interrupt 2054 * @brief Check for the events associated with the interrupt vector. 2055 * 2056 * @param hw Hardware context. 2057 * @param vector Zero-based interrupt vector number. 2058 * 2059 * @return Returns 0 on success, or a non-zero value on failure. 2060 */ 2061 int32_t 2062 ocs_hw_event_check(ocs_hw_t *hw, uint32_t vector) 2063 { 2064 int32_t rc = 0; 2065 2066 if (!hw) { 2067 ocs_log_err(NULL, "HW context NULL?!?\n"); 2068 return -1; 2069 } 2070 2071 if (vector > hw->eq_count) { 2072 ocs_log_err(hw->os, "vector %d. max %d\n", 2073 vector, hw->eq_count); 2074 return -1; 2075 } 2076 2077 /* 2078 * The caller should disable interrupts if they wish to prevent us 2079 * from processing during a shutdown. The following states are defined: 2080 * OCS_HW_STATE_UNINITIALIZED - No queues allocated 2081 * OCS_HW_STATE_QUEUES_ALLOCATED - The state after a chip reset, 2082 * queues are cleared. 2083 * OCS_HW_STATE_ACTIVE - Chip and queues are operational 2084 * OCS_HW_STATE_RESET_IN_PROGRESS - reset, we still want completions 2085 * OCS_HW_STATE_TEARDOWN_IN_PROGRESS - We still want mailbox 2086 * completions. 2087 */ 2088 if (hw->state != OCS_HW_STATE_UNINITIALIZED) { 2089 rc = sli_queue_is_empty(&hw->sli, &hw->eq[vector]); 2090 2091 /* Re-arm queue if there are no entries */ 2092 if (rc != 0) { 2093 sli_queue_arm(&hw->sli, &hw->eq[vector], TRUE); 2094 } 2095 } 2096 return rc; 2097 } 2098 2099 void 2100 ocs_hw_unsol_process_bounce(void *arg) 2101 { 2102 ocs_hw_sequence_t *seq = arg; 2103 ocs_hw_t *hw = seq->hw; 2104 2105 ocs_hw_assert(hw != NULL); 2106 ocs_hw_assert(hw->callback.unsolicited != NULL); 2107 2108 hw->callback.unsolicited(hw->args.unsolicited, seq); 2109 } 2110 2111 int32_t 2112 ocs_hw_process(ocs_hw_t *hw, uint32_t vector, uint32_t max_isr_time_msec) 2113 { 2114 hw_eq_t *eq; 2115 int32_t rc = 0; 2116 2117 CPUTRACE(""); 2118 2119 /* 2120 * The caller should disable interrupts if they wish to prevent us 2121 * from processing during a shutdown. The following states are defined: 2122 * OCS_HW_STATE_UNINITIALIZED - No queues allocated 2123 * OCS_HW_STATE_QUEUES_ALLOCATED - The state after a chip reset, 2124 * queues are cleared. 2125 * OCS_HW_STATE_ACTIVE - Chip and queues are operational 2126 * OCS_HW_STATE_RESET_IN_PROGRESS - reset, we still want completions 2127 * OCS_HW_STATE_TEARDOWN_IN_PROGRESS - We still want mailbox 2128 * completions. 2129 */ 2130 if (hw->state == OCS_HW_STATE_UNINITIALIZED) { 2131 return 0; 2132 } 2133 2134 /* Get pointer to hw_eq_t */ 2135 eq = hw->hw_eq[vector]; 2136 2137 OCS_STAT(eq->use_count++); 2138 2139 rc = ocs_hw_eq_process(hw, eq, max_isr_time_msec); 2140 2141 return rc; 2142 } 2143 2144 /** 2145 * @ingroup interrupt 2146 * @brief Process events associated with an EQ. 2147 * 2148 * @par Description 2149 * Loop termination: 2150 * @n @n Without a mechanism to terminate the completion processing loop, it 2151 * is possible under some workload conditions for the loop to never terminate 2152 * (or at least take longer than the OS is happy to have an interrupt handler 2153 * or kernel thread context hold a CPU without yielding). 2154 * @n @n The approach taken here is to periodically check how much time 2155 * we have been in this 2156 * processing loop, and if we exceed a predetermined time (multiple seconds), the 2157 * loop is terminated, and ocs_hw_process() returns. 2158 * 2159 * @param hw Hardware context. 2160 * @param eq Pointer to HW EQ object. 2161 * @param max_isr_time_msec Maximum time in msec to stay in this function. 2162 * 2163 * @return Returns 0 on success, or a non-zero value on failure. 2164 */ 2165 int32_t 2166 ocs_hw_eq_process(ocs_hw_t *hw, hw_eq_t *eq, uint32_t max_isr_time_msec) 2167 { 2168 uint8_t eqe[sizeof(sli4_eqe_t)] = { 0 }; 2169 uint32_t done = FALSE; 2170 uint32_t tcheck_count; 2171 time_t tstart; 2172 time_t telapsed; 2173 2174 tcheck_count = OCS_HW_TIMECHECK_ITERATIONS; 2175 tstart = ocs_msectime(); 2176 2177 CPUTRACE(""); 2178 2179 while (!done && !sli_queue_read(&hw->sli, eq->queue, eqe)) { 2180 uint16_t cq_id = 0; 2181 int32_t rc; 2182 2183 rc = sli_eq_parse(&hw->sli, eqe, &cq_id); 2184 if (unlikely(rc)) { 2185 if (rc > 0) { 2186 uint32_t i; 2187 2188 /* 2189 * Received a sentinel EQE indicating the EQ is full. 2190 * Process all CQs 2191 */ 2192 for (i = 0; i < hw->cq_count; i++) { 2193 ocs_hw_cq_process(hw, hw->hw_cq[i]); 2194 } 2195 continue; 2196 } else { 2197 return rc; 2198 } 2199 } else { 2200 int32_t index = ocs_hw_queue_hash_find(hw->cq_hash, cq_id); 2201 if (likely(index >= 0)) { 2202 ocs_hw_cq_process(hw, hw->hw_cq[index]); 2203 } else { 2204 ocs_log_err(hw->os, "bad CQ_ID %#06x\n", cq_id); 2205 } 2206 } 2207 2208 if (eq->queue->n_posted > (eq->queue->posted_limit)) { 2209 sli_queue_arm(&hw->sli, eq->queue, FALSE); 2210 } 2211 2212 if (tcheck_count && (--tcheck_count == 0)) { 2213 tcheck_count = OCS_HW_TIMECHECK_ITERATIONS; 2214 telapsed = ocs_msectime() - tstart; 2215 if (telapsed >= max_isr_time_msec) { 2216 done = TRUE; 2217 } 2218 } 2219 } 2220 sli_queue_eq_arm(&hw->sli, eq->queue, TRUE); 2221 2222 return 0; 2223 } 2224 2225 /** 2226 * @brief Submit queued (pending) mbx commands. 2227 * 2228 * @par Description 2229 * Submit queued mailbox commands. 2230 * --- Assumes that hw->cmd_lock is held --- 2231 * 2232 * @param hw Hardware context. 2233 * 2234 * @return Returns 0 on success, or a negative error code value on failure. 2235 */ 2236 static int32_t 2237 ocs_hw_cmd_submit_pending(ocs_hw_t *hw) 2238 { 2239 ocs_command_ctx_t *ctx; 2240 int32_t rc = 0; 2241 2242 /* Assumes lock held */ 2243 2244 /* Only submit MQE if there's room */ 2245 while (hw->cmd_head_count < (OCS_HW_MQ_DEPTH - 1)) { 2246 ctx = ocs_list_remove_head(&hw->cmd_pending); 2247 if (ctx == NULL) { 2248 break; 2249 } 2250 ocs_list_add_tail(&hw->cmd_head, ctx); 2251 hw->cmd_head_count++; 2252 if (sli_queue_write(&hw->sli, hw->mq, ctx->buf) < 0) { 2253 ocs_log_test(hw->os, "sli_queue_write failed: %d\n", rc); 2254 rc = -1; 2255 break; 2256 } 2257 } 2258 return rc; 2259 } 2260 2261 /** 2262 * @ingroup io 2263 * @brief Issue a SLI command. 2264 * 2265 * @par Description 2266 * Send a mailbox command to the hardware, and either wait for a completion 2267 * (OCS_CMD_POLL) or get an optional asynchronous completion (OCS_CMD_NOWAIT). 2268 * 2269 * @param hw Hardware context. 2270 * @param cmd Buffer containing a formatted command and results. 2271 * @param opts Command options: 2272 * - OCS_CMD_POLL - Command executes synchronously and busy-waits for the completion. 2273 * - OCS_CMD_NOWAIT - Command executes asynchronously. Uses callback. 2274 * @param cb Function callback used for asynchronous mode. May be NULL. 2275 * @n Prototype is <tt>(*cb)(void *arg, uint8_t *cmd)</tt>. 2276 * @n @n @b Note: If the 2277 * callback function pointer is NULL, the results of the command are silently 2278 * discarded, allowing this pointer to exist solely on the stack. 2279 * @param arg Argument passed to an asynchronous callback. 2280 * 2281 * @return Returns 0 on success, or a non-zero value on failure. 2282 */ 2283 ocs_hw_rtn_e 2284 ocs_hw_command(ocs_hw_t *hw, uint8_t *cmd, uint32_t opts, void *cb, void *arg) 2285 { 2286 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 2287 2288 /* 2289 * If the chip is in an error state (UE'd) then reject this mailbox 2290 * command. 2291 */ 2292 if (sli_fw_error_status(&hw->sli) > 0) { 2293 uint32_t err1 = sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR1); 2294 uint32_t err2 = sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR2); 2295 if (hw->expiration_logged == 0 && err1 == 0x2 && err2 == 0x10) { 2296 hw->expiration_logged = 1; 2297 ocs_log_crit(hw->os,"Emulex: Heartbeat expired after %d seconds\n", 2298 hw->watchdog_timeout); 2299 } 2300 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2301 ocs_log_crit(hw->os, "status=%#x error1=%#x error2=%#x\n", 2302 sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_STATUS), 2303 err1, err2); 2304 2305 return OCS_HW_RTN_ERROR; 2306 } 2307 2308 if (OCS_CMD_POLL == opts) { 2309 ocs_lock(&hw->cmd_lock); 2310 if (hw->mq->length && !sli_queue_is_empty(&hw->sli, hw->mq)) { 2311 /* 2312 * Can't issue Boot-strap mailbox command with other 2313 * mail-queue commands pending as this interaction is 2314 * undefined 2315 */ 2316 rc = OCS_HW_RTN_ERROR; 2317 } else { 2318 void *bmbx = hw->sli.bmbx.virt; 2319 2320 ocs_memset(bmbx, 0, SLI4_BMBX_SIZE); 2321 ocs_memcpy(bmbx, cmd, SLI4_BMBX_SIZE); 2322 2323 if (sli_bmbx_command(&hw->sli) == 0) { 2324 rc = OCS_HW_RTN_SUCCESS; 2325 ocs_memcpy(cmd, bmbx, SLI4_BMBX_SIZE); 2326 } 2327 } 2328 ocs_unlock(&hw->cmd_lock); 2329 } else if (OCS_CMD_NOWAIT == opts) { 2330 ocs_command_ctx_t *ctx = NULL; 2331 2332 ctx = ocs_malloc(hw->os, sizeof(ocs_command_ctx_t), OCS_M_ZERO | OCS_M_NOWAIT); 2333 if (!ctx) { 2334 ocs_log_err(hw->os, "can't allocate command context\n"); 2335 return OCS_HW_RTN_NO_RESOURCES; 2336 } 2337 2338 if (hw->state != OCS_HW_STATE_ACTIVE) { 2339 ocs_log_err(hw->os, "Can't send command, HW state=%d\n", hw->state); 2340 ocs_free(hw->os, ctx, sizeof(*ctx)); 2341 return OCS_HW_RTN_ERROR; 2342 } 2343 2344 if (cb) { 2345 ctx->cb = cb; 2346 ctx->arg = arg; 2347 } 2348 ctx->buf = cmd; 2349 ctx->ctx = hw; 2350 2351 ocs_lock(&hw->cmd_lock); 2352 2353 /* Add to pending list */ 2354 ocs_list_add_tail(&hw->cmd_pending, ctx); 2355 2356 /* Submit as much of the pending list as we can */ 2357 if (ocs_hw_cmd_submit_pending(hw) == 0) { 2358 rc = OCS_HW_RTN_SUCCESS; 2359 } 2360 2361 ocs_unlock(&hw->cmd_lock); 2362 } 2363 2364 return rc; 2365 } 2366 2367 /** 2368 * @ingroup devInitShutdown 2369 * @brief Register a callback for the given event. 2370 * 2371 * @param hw Hardware context. 2372 * @param which Event of interest. 2373 * @param func Function to call when the event occurs. 2374 * @param arg Argument passed to the callback function. 2375 * 2376 * @return Returns 0 on success, or a non-zero value on failure. 2377 */ 2378 ocs_hw_rtn_e 2379 ocs_hw_callback(ocs_hw_t *hw, ocs_hw_callback_e which, void *func, void *arg) 2380 { 2381 2382 if (!hw || !func || (which >= OCS_HW_CB_MAX)) { 2383 ocs_log_err(NULL, "bad parameter hw=%p which=%#x func=%p\n", 2384 hw, which, func); 2385 return OCS_HW_RTN_ERROR; 2386 } 2387 2388 switch (which) { 2389 case OCS_HW_CB_DOMAIN: 2390 hw->callback.domain = func; 2391 hw->args.domain = arg; 2392 break; 2393 case OCS_HW_CB_PORT: 2394 hw->callback.port = func; 2395 hw->args.port = arg; 2396 break; 2397 case OCS_HW_CB_UNSOLICITED: 2398 hw->callback.unsolicited = func; 2399 hw->args.unsolicited = arg; 2400 break; 2401 case OCS_HW_CB_REMOTE_NODE: 2402 hw->callback.rnode = func; 2403 hw->args.rnode = arg; 2404 break; 2405 case OCS_HW_CB_BOUNCE: 2406 hw->callback.bounce = func; 2407 hw->args.bounce = arg; 2408 break; 2409 default: 2410 ocs_log_test(hw->os, "unknown callback %#x\n", which); 2411 return OCS_HW_RTN_ERROR; 2412 } 2413 2414 return OCS_HW_RTN_SUCCESS; 2415 } 2416 2417 /** 2418 * @ingroup port 2419 * @brief Allocate a port object. 2420 * 2421 * @par Description 2422 * This function allocates a VPI object for the port and stores it in the 2423 * indicator field of the port object. 2424 * 2425 * @param hw Hardware context. 2426 * @param sport SLI port object used to connect to the domain. 2427 * @param domain Domain object associated with this port (may be NULL). 2428 * @param wwpn Port's WWPN in big-endian order, or NULL to use default. 2429 * 2430 * @return Returns 0 on success, or a non-zero value on failure. 2431 */ 2432 ocs_hw_rtn_e 2433 ocs_hw_port_alloc(ocs_hw_t *hw, ocs_sli_port_t *sport, ocs_domain_t *domain, 2434 uint8_t *wwpn) 2435 { 2436 uint8_t *cmd = NULL; 2437 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2438 uint32_t index; 2439 2440 sport->indicator = UINT32_MAX; 2441 sport->hw = hw; 2442 sport->ctx.app = sport; 2443 sport->sm_free_req_pending = 0; 2444 2445 /* 2446 * Check if the chip is in an error state (UE'd) before proceeding. 2447 */ 2448 if (sli_fw_error_status(&hw->sli) > 0) { 2449 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2450 return OCS_HW_RTN_ERROR; 2451 } 2452 2453 if (wwpn) { 2454 ocs_memcpy(&sport->sli_wwpn, wwpn, sizeof(sport->sli_wwpn)); 2455 } 2456 2457 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_VPI, &sport->indicator, &index)) { 2458 ocs_log_err(hw->os, "FCOE_VPI allocation failure\n"); 2459 return OCS_HW_RTN_ERROR; 2460 } 2461 2462 if (domain != NULL) { 2463 ocs_sm_function_t next = NULL; 2464 2465 cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 2466 if (!cmd) { 2467 ocs_log_err(hw->os, "command memory allocation failed\n"); 2468 rc = OCS_HW_RTN_NO_MEMORY; 2469 goto ocs_hw_port_alloc_out; 2470 } 2471 2472 /* If the WWPN is NULL, fetch the default WWPN and WWNN before 2473 * initializing the VPI 2474 */ 2475 if (!wwpn) { 2476 next = __ocs_hw_port_alloc_read_sparm64; 2477 } else { 2478 next = __ocs_hw_port_alloc_init_vpi; 2479 } 2480 2481 ocs_sm_transition(&sport->ctx, next, cmd); 2482 } else if (!wwpn) { 2483 /* This is the convention for the HW, not SLI */ 2484 ocs_log_test(hw->os, "need WWN for physical port\n"); 2485 rc = OCS_HW_RTN_ERROR; 2486 } else { 2487 /* domain NULL and wwpn non-NULL */ 2488 ocs_sm_transition(&sport->ctx, __ocs_hw_port_alloc_init, NULL); 2489 } 2490 2491 ocs_hw_port_alloc_out: 2492 if (rc != OCS_HW_RTN_SUCCESS) { 2493 ocs_free(hw->os, cmd, SLI4_BMBX_SIZE); 2494 2495 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator); 2496 } 2497 2498 return rc; 2499 } 2500 2501 /** 2502 * @ingroup port 2503 * @brief Attach a physical/virtual SLI port to a domain. 2504 * 2505 * @par Description 2506 * This function registers a previously-allocated VPI with the 2507 * device. 2508 * 2509 * @param hw Hardware context. 2510 * @param sport Pointer to the SLI port object. 2511 * @param fc_id Fibre Channel ID to associate with this port. 2512 * 2513 * @return Returns OCS_HW_RTN_SUCCESS on success, or an error code on failure. 2514 */ 2515 ocs_hw_rtn_e 2516 ocs_hw_port_attach(ocs_hw_t *hw, ocs_sli_port_t *sport, uint32_t fc_id) 2517 { 2518 uint8_t *buf = NULL; 2519 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2520 2521 if (!hw || !sport) { 2522 ocs_log_err(hw ? hw->os : NULL, 2523 "bad parameter(s) hw=%p sport=%p\n", hw, 2524 sport); 2525 return OCS_HW_RTN_ERROR; 2526 } 2527 2528 /* 2529 * Check if the chip is in an error state (UE'd) before proceeding. 2530 */ 2531 if (sli_fw_error_status(&hw->sli) > 0) { 2532 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2533 return OCS_HW_RTN_ERROR; 2534 } 2535 2536 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2537 if (!buf) { 2538 ocs_log_err(hw->os, "no buffer for command\n"); 2539 return OCS_HW_RTN_NO_MEMORY; 2540 } 2541 2542 sport->fc_id = fc_id; 2543 ocs_sm_post_event(&sport->ctx, OCS_EVT_HW_PORT_REQ_ATTACH, buf); 2544 return rc; 2545 } 2546 2547 /** 2548 * @brief Called when the port control command completes. 2549 * 2550 * @par Description 2551 * We only need to free the mailbox command buffer. 2552 * 2553 * @param hw Hardware context. 2554 * @param status Status field from the mbox completion. 2555 * @param mqe Mailbox response structure. 2556 * @param arg Pointer to a callback function that signals the caller that the command is done. 2557 * 2558 * @return Returns 0. 2559 */ 2560 static int32_t 2561 ocs_hw_cb_port_control(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 2562 { 2563 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 2564 return 0; 2565 } 2566 2567 /** 2568 * @ingroup port 2569 * @brief Control a port (initialize, shutdown, or set link configuration). 2570 * 2571 * @par Description 2572 * This function controls a port depending on the @c ctrl parameter: 2573 * - @b OCS_HW_PORT_INIT - 2574 * Issues the CONFIG_LINK and INIT_LINK commands for the specified port. 2575 * The HW generates an OCS_HW_DOMAIN_FOUND event when the link comes up. 2576 * . 2577 * - @b OCS_HW_PORT_SHUTDOWN - 2578 * Issues the DOWN_LINK command for the specified port. 2579 * The HW generates an OCS_HW_DOMAIN_LOST event when the link is down. 2580 * . 2581 * - @b OCS_HW_PORT_SET_LINK_CONFIG - 2582 * Sets the link configuration. 2583 * 2584 * @param hw Hardware context. 2585 * @param ctrl Specifies the operation: 2586 * - OCS_HW_PORT_INIT 2587 * - OCS_HW_PORT_SHUTDOWN 2588 * - OCS_HW_PORT_SET_LINK_CONFIG 2589 * 2590 * @param value Operation-specific value. 2591 * - OCS_HW_PORT_INIT - Selective reset AL_PA 2592 * - OCS_HW_PORT_SHUTDOWN - N/A 2593 * - OCS_HW_PORT_SET_LINK_CONFIG - An enum #ocs_hw_linkcfg_e value. 2594 * 2595 * @param cb Callback function to invoke the following operation. 2596 * - OCS_HW_PORT_INIT/OCS_HW_PORT_SHUTDOWN - NULL (link events 2597 * are handled by the OCS_HW_CB_DOMAIN callbacks). 2598 * - OCS_HW_PORT_SET_LINK_CONFIG - Invoked after linkcfg mailbox command 2599 * completes. 2600 * 2601 * @param arg Callback argument invoked after the command completes. 2602 * - OCS_HW_PORT_INIT/OCS_HW_PORT_SHUTDOWN - NULL (link events 2603 * are handled by the OCS_HW_CB_DOMAIN callbacks). 2604 * - OCS_HW_PORT_SET_LINK_CONFIG - Invoked after linkcfg mailbox command 2605 * completes. 2606 * 2607 * @return Returns 0 on success, or a non-zero value on failure. 2608 */ 2609 ocs_hw_rtn_e 2610 ocs_hw_port_control(ocs_hw_t *hw, ocs_hw_port_e ctrl, uintptr_t value, ocs_hw_port_control_cb_t cb, void *arg) 2611 { 2612 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 2613 2614 switch (ctrl) { 2615 case OCS_HW_PORT_INIT: 2616 { 2617 uint8_t *init_link; 2618 uint32_t speed = 0; 2619 uint8_t reset_alpa = 0; 2620 2621 if (SLI_LINK_MEDIUM_FC == sli_get_medium(&hw->sli)) { 2622 uint8_t *cfg_link; 2623 2624 cfg_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2625 if (cfg_link == NULL) { 2626 ocs_log_err(hw->os, "no buffer for command\n"); 2627 return OCS_HW_RTN_NO_MEMORY; 2628 } 2629 2630 if (sli_cmd_config_link(&hw->sli, cfg_link, SLI4_BMBX_SIZE)) { 2631 rc = ocs_hw_command(hw, cfg_link, OCS_CMD_NOWAIT, 2632 ocs_hw_cb_port_control, NULL); 2633 } 2634 2635 if (rc != OCS_HW_RTN_SUCCESS) { 2636 ocs_free(hw->os, cfg_link, SLI4_BMBX_SIZE); 2637 ocs_log_err(hw->os, "CONFIG_LINK failed\n"); 2638 break; 2639 } 2640 speed = hw->config.speed; 2641 reset_alpa = (uint8_t)(value & 0xff); 2642 } else { 2643 speed = FC_LINK_SPEED_10G; 2644 } 2645 2646 /* 2647 * Bring link up, unless FW version is not supported 2648 */ 2649 if (hw->workaround.fw_version_too_low) { 2650 if (SLI4_IF_TYPE_LANCER_FC_ETH == hw->sli.if_type) { 2651 ocs_log_err(hw->os, "Cannot bring up link. Please update firmware to %s or later (current version is %s)\n", 2652 OCS_FW_VER_STR(OCS_MIN_FW_VER_LANCER), (char *) sli_get_fw_name(&hw->sli,0)); 2653 } else { 2654 ocs_log_err(hw->os, "Cannot bring up link. Please update firmware to %s or later (current version is %s)\n", 2655 OCS_FW_VER_STR(OCS_MIN_FW_VER_SKYHAWK), (char *) sli_get_fw_name(&hw->sli, 0)); 2656 } 2657 2658 return OCS_HW_RTN_ERROR; 2659 } 2660 2661 rc = OCS_HW_RTN_ERROR; 2662 2663 /* Allocate a new buffer for the init_link command */ 2664 init_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2665 if (init_link == NULL) { 2666 ocs_log_err(hw->os, "no buffer for command\n"); 2667 return OCS_HW_RTN_NO_MEMORY; 2668 } 2669 2670 if (sli_cmd_init_link(&hw->sli, init_link, SLI4_BMBX_SIZE, speed, reset_alpa)) { 2671 rc = ocs_hw_command(hw, init_link, OCS_CMD_NOWAIT, 2672 ocs_hw_cb_port_control, NULL); 2673 } 2674 /* Free buffer on error, since no callback is coming */ 2675 if (rc != OCS_HW_RTN_SUCCESS) { 2676 ocs_free(hw->os, init_link, SLI4_BMBX_SIZE); 2677 ocs_log_err(hw->os, "INIT_LINK failed\n"); 2678 } 2679 break; 2680 } 2681 case OCS_HW_PORT_SHUTDOWN: 2682 { 2683 uint8_t *down_link; 2684 2685 down_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2686 if (down_link == NULL) { 2687 ocs_log_err(hw->os, "no buffer for command\n"); 2688 return OCS_HW_RTN_NO_MEMORY; 2689 } 2690 if (sli_cmd_down_link(&hw->sli, down_link, SLI4_BMBX_SIZE)) { 2691 rc = ocs_hw_command(hw, down_link, OCS_CMD_NOWAIT, 2692 ocs_hw_cb_port_control, NULL); 2693 } 2694 /* Free buffer on error, since no callback is coming */ 2695 if (rc != OCS_HW_RTN_SUCCESS) { 2696 ocs_free(hw->os, down_link, SLI4_BMBX_SIZE); 2697 ocs_log_err(hw->os, "DOWN_LINK failed\n"); 2698 } 2699 break; 2700 } 2701 case OCS_HW_PORT_SET_LINK_CONFIG: 2702 rc = ocs_hw_set_linkcfg(hw, (ocs_hw_linkcfg_e)value, OCS_CMD_NOWAIT, cb, arg); 2703 break; 2704 default: 2705 ocs_log_test(hw->os, "unhandled control %#x\n", ctrl); 2706 break; 2707 } 2708 2709 return rc; 2710 } 2711 2712 /** 2713 * @ingroup port 2714 * @brief Free port resources. 2715 * 2716 * @par Description 2717 * Issue the UNREG_VPI command to free the assigned VPI context. 2718 * 2719 * @param hw Hardware context. 2720 * @param sport SLI port object used to connect to the domain. 2721 * 2722 * @return Returns 0 on success, or a non-zero value on failure. 2723 */ 2724 ocs_hw_rtn_e 2725 ocs_hw_port_free(ocs_hw_t *hw, ocs_sli_port_t *sport) 2726 { 2727 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2728 2729 if (!hw || !sport) { 2730 ocs_log_err(hw ? hw->os : NULL, 2731 "bad parameter(s) hw=%p sport=%p\n", hw, 2732 sport); 2733 return OCS_HW_RTN_ERROR; 2734 } 2735 2736 /* 2737 * Check if the chip is in an error state (UE'd) before proceeding. 2738 */ 2739 if (sli_fw_error_status(&hw->sli) > 0) { 2740 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2741 return OCS_HW_RTN_ERROR; 2742 } 2743 2744 ocs_sm_post_event(&sport->ctx, OCS_EVT_HW_PORT_REQ_FREE, NULL); 2745 return rc; 2746 } 2747 2748 /** 2749 * @ingroup domain 2750 * @brief Allocate a fabric domain object. 2751 * 2752 * @par Description 2753 * This function starts a series of commands needed to connect to the domain, including 2754 * - REG_FCFI 2755 * - INIT_VFI 2756 * - READ_SPARMS 2757 * . 2758 * @b Note: Not all SLI interface types use all of the above commands. 2759 * @n @n Upon successful allocation, the HW generates a OCS_HW_DOMAIN_ALLOC_OK 2760 * event. On failure, it generates a OCS_HW_DOMAIN_ALLOC_FAIL event. 2761 * 2762 * @param hw Hardware context. 2763 * @param domain Pointer to the domain object. 2764 * @param fcf FCF index. 2765 * @param vlan VLAN ID. 2766 * 2767 * @return Returns 0 on success, or a non-zero value on failure. 2768 */ 2769 ocs_hw_rtn_e 2770 ocs_hw_domain_alloc(ocs_hw_t *hw, ocs_domain_t *domain, uint32_t fcf, uint32_t vlan) 2771 { 2772 uint8_t *cmd = NULL; 2773 uint32_t index; 2774 2775 if (!hw || !domain || !domain->sport) { 2776 ocs_log_err(NULL, "bad parameter(s) hw=%p domain=%p sport=%p\n", 2777 hw, domain, domain ? domain->sport : NULL); 2778 return OCS_HW_RTN_ERROR; 2779 } 2780 2781 /* 2782 * Check if the chip is in an error state (UE'd) before proceeding. 2783 */ 2784 if (sli_fw_error_status(&hw->sli) > 0) { 2785 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2786 return OCS_HW_RTN_ERROR; 2787 } 2788 2789 cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 2790 if (!cmd) { 2791 ocs_log_err(hw->os, "command memory allocation failed\n"); 2792 return OCS_HW_RTN_NO_MEMORY; 2793 } 2794 2795 domain->dma = hw->domain_dmem; 2796 2797 domain->hw = hw; 2798 domain->sm.app = domain; 2799 domain->fcf = fcf; 2800 domain->fcf_indicator = UINT32_MAX; 2801 domain->vlan_id = vlan; 2802 domain->indicator = UINT32_MAX; 2803 2804 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_VFI, &domain->indicator, &index)) { 2805 ocs_log_err(hw->os, "FCOE_VFI allocation failure\n"); 2806 2807 ocs_free(hw->os, cmd, SLI4_BMBX_SIZE); 2808 2809 return OCS_HW_RTN_ERROR; 2810 } 2811 2812 ocs_sm_transition(&domain->sm, __ocs_hw_domain_init, cmd); 2813 return OCS_HW_RTN_SUCCESS; 2814 } 2815 2816 /** 2817 * @ingroup domain 2818 * @brief Attach a SLI port to a domain. 2819 * 2820 * @param hw Hardware context. 2821 * @param domain Pointer to the domain object. 2822 * @param fc_id Fibre Channel ID to associate with this port. 2823 * 2824 * @return Returns 0 on success, or a non-zero value on failure. 2825 */ 2826 ocs_hw_rtn_e 2827 ocs_hw_domain_attach(ocs_hw_t *hw, ocs_domain_t *domain, uint32_t fc_id) 2828 { 2829 uint8_t *buf = NULL; 2830 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2831 2832 if (!hw || !domain) { 2833 ocs_log_err(hw ? hw->os : NULL, 2834 "bad parameter(s) hw=%p domain=%p\n", 2835 hw, domain); 2836 return OCS_HW_RTN_ERROR; 2837 } 2838 2839 /* 2840 * Check if the chip is in an error state (UE'd) before proceeding. 2841 */ 2842 if (sli_fw_error_status(&hw->sli) > 0) { 2843 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2844 return OCS_HW_RTN_ERROR; 2845 } 2846 2847 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2848 if (!buf) { 2849 ocs_log_err(hw->os, "no buffer for command\n"); 2850 return OCS_HW_RTN_NO_MEMORY; 2851 } 2852 2853 domain->sport->fc_id = fc_id; 2854 ocs_sm_post_event(&domain->sm, OCS_EVT_HW_DOMAIN_REQ_ATTACH, buf); 2855 return rc; 2856 } 2857 2858 /** 2859 * @ingroup domain 2860 * @brief Free a fabric domain object. 2861 * 2862 * @par Description 2863 * Free both the driver and SLI port resources associated with the domain. 2864 * 2865 * @param hw Hardware context. 2866 * @param domain Pointer to the domain object. 2867 * 2868 * @return Returns 0 on success, or a non-zero value on failure. 2869 */ 2870 ocs_hw_rtn_e 2871 ocs_hw_domain_free(ocs_hw_t *hw, ocs_domain_t *domain) 2872 { 2873 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 2874 2875 if (!hw || !domain) { 2876 ocs_log_err(hw ? hw->os : NULL, 2877 "bad parameter(s) hw=%p domain=%p\n", 2878 hw, domain); 2879 return OCS_HW_RTN_ERROR; 2880 } 2881 2882 /* 2883 * Check if the chip is in an error state (UE'd) before proceeding. 2884 */ 2885 if (sli_fw_error_status(&hw->sli) > 0) { 2886 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2887 return OCS_HW_RTN_ERROR; 2888 } 2889 2890 ocs_sm_post_event(&domain->sm, OCS_EVT_HW_DOMAIN_REQ_FREE, NULL); 2891 return rc; 2892 } 2893 2894 /** 2895 * @ingroup domain 2896 * @brief Free a fabric domain object. 2897 * 2898 * @par Description 2899 * Free the driver resources associated with the domain. The difference between 2900 * this call and ocs_hw_domain_free() is that this call assumes resources no longer 2901 * exist on the SLI port, due to a reset or after some error conditions. 2902 * 2903 * @param hw Hardware context. 2904 * @param domain Pointer to the domain object. 2905 * 2906 * @return Returns 0 on success, or a non-zero value on failure. 2907 */ 2908 ocs_hw_rtn_e 2909 ocs_hw_domain_force_free(ocs_hw_t *hw, ocs_domain_t *domain) 2910 { 2911 if (!hw || !domain) { 2912 ocs_log_err(NULL, "bad parameter(s) hw=%p domain=%p\n", hw, domain); 2913 return OCS_HW_RTN_ERROR; 2914 } 2915 2916 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator); 2917 2918 return OCS_HW_RTN_SUCCESS; 2919 } 2920 2921 /** 2922 * @ingroup node 2923 * @brief Allocate a remote node object. 2924 * 2925 * @param hw Hardware context. 2926 * @param rnode Allocated remote node object to initialize. 2927 * @param fc_addr FC address of the remote node. 2928 * @param sport SLI port used to connect to remote node. 2929 * 2930 * @return Returns 0 on success, or a non-zero value on failure. 2931 */ 2932 ocs_hw_rtn_e 2933 ocs_hw_node_alloc(ocs_hw_t *hw, ocs_remote_node_t *rnode, uint32_t fc_addr, 2934 ocs_sli_port_t *sport) 2935 { 2936 /* Check for invalid indicator */ 2937 if (UINT32_MAX != rnode->indicator) { 2938 ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x rpi=%#x\n", 2939 fc_addr, rnode->indicator); 2940 return OCS_HW_RTN_ERROR; 2941 } 2942 2943 /* 2944 * Check if the chip is in an error state (UE'd) before proceeding. 2945 */ 2946 if (sli_fw_error_status(&hw->sli) > 0) { 2947 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2948 return OCS_HW_RTN_ERROR; 2949 } 2950 2951 /* NULL SLI port indicates an unallocated remote node */ 2952 rnode->sport = NULL; 2953 2954 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &rnode->indicator, &rnode->index)) { 2955 ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x\n", 2956 fc_addr); 2957 return OCS_HW_RTN_ERROR; 2958 } 2959 2960 rnode->fc_id = fc_addr; 2961 rnode->sport = sport; 2962 2963 return OCS_HW_RTN_SUCCESS; 2964 } 2965 2966 /** 2967 * @ingroup node 2968 * @brief Update a remote node object with the remote port's service parameters. 2969 * 2970 * @param hw Hardware context. 2971 * @param rnode Allocated remote node object to initialize. 2972 * @param sparms DMA buffer containing the remote port's service parameters. 2973 * 2974 * @return Returns 0 on success, or a non-zero value on failure. 2975 */ 2976 ocs_hw_rtn_e 2977 ocs_hw_node_attach(ocs_hw_t *hw, ocs_remote_node_t *rnode, ocs_dma_t *sparms) 2978 { 2979 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 2980 uint8_t *buf = NULL; 2981 uint32_t count = 0; 2982 2983 if (!hw || !rnode || !sparms) { 2984 ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p sparms=%p\n", 2985 hw, rnode, sparms); 2986 return OCS_HW_RTN_ERROR; 2987 } 2988 2989 /* 2990 * Check if the chip is in an error state (UE'd) before proceeding. 2991 */ 2992 if (sli_fw_error_status(&hw->sli) > 0) { 2993 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 2994 return OCS_HW_RTN_ERROR; 2995 } 2996 2997 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 2998 if (!buf) { 2999 ocs_log_err(hw->os, "no buffer for command\n"); 3000 return OCS_HW_RTN_NO_MEMORY; 3001 } 3002 3003 /* 3004 * If the attach count is non-zero, this RPI has already been registered. 3005 * Otherwise, register the RPI 3006 */ 3007 if (rnode->index == UINT32_MAX) { 3008 ocs_log_err(NULL, "bad parameter rnode->index invalid\n"); 3009 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 3010 return OCS_HW_RTN_ERROR; 3011 } 3012 count = ocs_atomic_add_return(&hw->rpi_ref[rnode->index].rpi_count, 1); 3013 if (count) { 3014 /* 3015 * Can't attach multiple FC_ID's to a node unless High Login 3016 * Mode is enabled 3017 */ 3018 if (sli_get_hlm(&hw->sli) == FALSE) { 3019 ocs_log_test(hw->os, "attach to already attached node HLM=%d count=%d\n", 3020 sli_get_hlm(&hw->sli), count); 3021 rc = OCS_HW_RTN_SUCCESS; 3022 } else { 3023 rnode->node_group = TRUE; 3024 rnode->attached = ocs_atomic_read(&hw->rpi_ref[rnode->index].rpi_attached); 3025 rc = rnode->attached ? OCS_HW_RTN_SUCCESS_SYNC : OCS_HW_RTN_SUCCESS; 3026 } 3027 } else { 3028 rnode->node_group = FALSE; 3029 3030 ocs_display_sparams("", "reg rpi", 0, NULL, sparms->virt); 3031 if (sli_cmd_reg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, rnode->fc_id, 3032 rnode->indicator, rnode->sport->indicator, 3033 sparms, 0, (hw->auto_xfer_rdy_enabled && hw->config.auto_xfer_rdy_t10_enable))) { 3034 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, 3035 ocs_hw_cb_node_attach, rnode); 3036 } 3037 } 3038 3039 if (count || rc) { 3040 if (rc < OCS_HW_RTN_SUCCESS) { 3041 ocs_atomic_sub_return(&hw->rpi_ref[rnode->index].rpi_count, 1); 3042 ocs_log_err(hw->os, "%s error\n", count ? "HLM" : "REG_RPI"); 3043 } 3044 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 3045 } 3046 3047 return rc; 3048 } 3049 3050 /** 3051 * @ingroup node 3052 * @brief Free a remote node resource. 3053 * 3054 * @param hw Hardware context. 3055 * @param rnode Remote node object to free. 3056 * 3057 * @return Returns 0 on success, or a non-zero value on failure. 3058 */ 3059 ocs_hw_rtn_e 3060 ocs_hw_node_free_resources(ocs_hw_t *hw, ocs_remote_node_t *rnode) 3061 { 3062 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 3063 3064 if (!hw || !rnode) { 3065 ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p\n", 3066 hw, rnode); 3067 return OCS_HW_RTN_ERROR; 3068 } 3069 3070 if (rnode->sport) { 3071 if (!rnode->attached) { 3072 if (rnode->indicator != UINT32_MAX) { 3073 if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, rnode->indicator)) { 3074 ocs_log_err(hw->os, "FCOE_RPI free failure RPI %d addr=%#x\n", 3075 rnode->indicator, rnode->fc_id); 3076 rc = OCS_HW_RTN_ERROR; 3077 } else { 3078 rnode->node_group = FALSE; 3079 rnode->indicator = UINT32_MAX; 3080 rnode->index = UINT32_MAX; 3081 rnode->free_group = FALSE; 3082 } 3083 } 3084 } else { 3085 ocs_log_err(hw->os, "Error: rnode is still attached\n"); 3086 rc = OCS_HW_RTN_ERROR; 3087 } 3088 } 3089 3090 return rc; 3091 } 3092 3093 /** 3094 * @ingroup node 3095 * @brief Free a remote node object. 3096 * 3097 * @param hw Hardware context. 3098 * @param rnode Remote node object to free. 3099 * 3100 * @return Returns 0 on success, or a non-zero value on failure. 3101 */ 3102 ocs_hw_rtn_e 3103 ocs_hw_node_detach(ocs_hw_t *hw, ocs_remote_node_t *rnode) 3104 { 3105 uint8_t *buf = NULL; 3106 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS_SYNC; 3107 uint32_t index = UINT32_MAX; 3108 3109 if (!hw || !rnode) { 3110 ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p\n", 3111 hw, rnode); 3112 return OCS_HW_RTN_ERROR; 3113 } 3114 3115 /* 3116 * Check if the chip is in an error state (UE'd) before proceeding. 3117 */ 3118 if (sli_fw_error_status(&hw->sli) > 0) { 3119 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 3120 return OCS_HW_RTN_ERROR; 3121 } 3122 3123 index = rnode->index; 3124 3125 if (rnode->sport) { 3126 uint32_t count = 0; 3127 uint32_t fc_id; 3128 3129 if (!rnode->attached) { 3130 return OCS_HW_RTN_SUCCESS_SYNC; 3131 } 3132 3133 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 3134 if (!buf) { 3135 ocs_log_err(hw->os, "no buffer for command\n"); 3136 return OCS_HW_RTN_NO_MEMORY; 3137 } 3138 3139 count = ocs_atomic_sub_return(&hw->rpi_ref[index].rpi_count, 1); 3140 3141 if (count <= 1) { 3142 /* There are no other references to this RPI 3143 * so unregister it and free the resource. */ 3144 fc_id = UINT32_MAX; 3145 rnode->node_group = FALSE; 3146 rnode->free_group = TRUE; 3147 } else { 3148 if (sli_get_hlm(&hw->sli) == FALSE) { 3149 ocs_log_test(hw->os, "Invalid count with HLM disabled, count=%d\n", 3150 count); 3151 } 3152 fc_id = rnode->fc_id & 0x00ffffff; 3153 } 3154 3155 rc = OCS_HW_RTN_ERROR; 3156 3157 if (sli_cmd_unreg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, rnode->indicator, 3158 SLI_RSRC_FCOE_RPI, fc_id)) { 3159 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_node_free, rnode); 3160 } 3161 3162 if (rc != OCS_HW_RTN_SUCCESS) { 3163 ocs_log_err(hw->os, "UNREG_RPI failed\n"); 3164 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 3165 rc = OCS_HW_RTN_ERROR; 3166 } 3167 } 3168 3169 return rc; 3170 } 3171 3172 /** 3173 * @ingroup node 3174 * @brief Free all remote node objects. 3175 * 3176 * @param hw Hardware context. 3177 * 3178 * @return Returns 0 on success, or a non-zero value on failure. 3179 */ 3180 ocs_hw_rtn_e 3181 ocs_hw_node_free_all(ocs_hw_t *hw) 3182 { 3183 uint8_t *buf = NULL; 3184 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 3185 3186 if (!hw) { 3187 ocs_log_err(NULL, "bad parameter hw=%p\n", hw); 3188 return OCS_HW_RTN_ERROR; 3189 } 3190 3191 /* 3192 * Check if the chip is in an error state (UE'd) before proceeding. 3193 */ 3194 if (sli_fw_error_status(&hw->sli) > 0) { 3195 ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n"); 3196 return OCS_HW_RTN_ERROR; 3197 } 3198 3199 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 3200 if (!buf) { 3201 ocs_log_err(hw->os, "no buffer for command\n"); 3202 return OCS_HW_RTN_NO_MEMORY; 3203 } 3204 3205 if (sli_cmd_unreg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, 0xffff, 3206 SLI_RSRC_FCOE_FCFI, UINT32_MAX)) { 3207 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_node_free_all, 3208 NULL); 3209 } 3210 3211 if (rc != OCS_HW_RTN_SUCCESS) { 3212 ocs_log_err(hw->os, "UNREG_RPI failed\n"); 3213 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 3214 rc = OCS_HW_RTN_ERROR; 3215 } 3216 3217 return rc; 3218 } 3219 3220 ocs_hw_rtn_e 3221 ocs_hw_node_group_alloc(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup) 3222 { 3223 3224 if (!hw || !ngroup) { 3225 ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p\n", 3226 hw, ngroup); 3227 return OCS_HW_RTN_ERROR; 3228 } 3229 3230 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &ngroup->indicator, 3231 &ngroup->index)) { 3232 ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x\n", 3233 ngroup->indicator); 3234 return OCS_HW_RTN_ERROR; 3235 } 3236 3237 return OCS_HW_RTN_SUCCESS; 3238 } 3239 3240 ocs_hw_rtn_e 3241 ocs_hw_node_group_attach(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup, ocs_remote_node_t *rnode) 3242 { 3243 3244 if (!hw || !ngroup || !rnode) { 3245 ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p rnode=%p\n", 3246 hw, ngroup, rnode); 3247 return OCS_HW_RTN_ERROR; 3248 } 3249 3250 if (rnode->attached) { 3251 ocs_log_err(hw->os, "node already attached RPI=%#x addr=%#x\n", 3252 rnode->indicator, rnode->fc_id); 3253 return OCS_HW_RTN_ERROR; 3254 } 3255 3256 if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, rnode->indicator)) { 3257 ocs_log_err(hw->os, "FCOE_RPI free failure RPI=%#x\n", 3258 rnode->indicator); 3259 return OCS_HW_RTN_ERROR; 3260 } 3261 3262 rnode->indicator = ngroup->indicator; 3263 rnode->index = ngroup->index; 3264 3265 return OCS_HW_RTN_SUCCESS; 3266 } 3267 3268 ocs_hw_rtn_e 3269 ocs_hw_node_group_free(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup) 3270 { 3271 int ref; 3272 3273 if (!hw || !ngroup) { 3274 ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p\n", 3275 hw, ngroup); 3276 return OCS_HW_RTN_ERROR; 3277 } 3278 3279 ref = ocs_atomic_read(&hw->rpi_ref[ngroup->index].rpi_count); 3280 if (ref) { 3281 /* Hmmm, the reference count is non-zero */ 3282 ocs_log_debug(hw->os, "node group reference=%d (RPI=%#x)\n", 3283 ref, ngroup->indicator); 3284 3285 if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, ngroup->indicator)) { 3286 ocs_log_err(hw->os, "FCOE_RPI free failure RPI=%#x\n", 3287 ngroup->indicator); 3288 return OCS_HW_RTN_ERROR; 3289 } 3290 3291 ocs_atomic_set(&hw->rpi_ref[ngroup->index].rpi_count, 0); 3292 } 3293 3294 ngroup->indicator = UINT32_MAX; 3295 ngroup->index = UINT32_MAX; 3296 3297 return OCS_HW_RTN_SUCCESS; 3298 } 3299 3300 /** 3301 * @brief Initialize IO fields on each free call. 3302 * 3303 * @n @b Note: This is done on each free call (as opposed to each 3304 * alloc call) because port-owned XRIs are not 3305 * allocated with ocs_hw_io_alloc() but are freed with this 3306 * function. 3307 * 3308 * @param io Pointer to HW IO. 3309 */ 3310 static inline void 3311 ocs_hw_init_free_io(ocs_hw_io_t *io) 3312 { 3313 /* 3314 * Set io->done to NULL, to avoid any callbacks, should 3315 * a completion be received for one of these IOs 3316 */ 3317 io->done = NULL; 3318 io->abort_done = NULL; 3319 io->status_saved = 0; 3320 io->abort_in_progress = FALSE; 3321 io->port_owned_abort_count = 0; 3322 io->rnode = NULL; 3323 io->type = 0xFFFF; 3324 io->wq = NULL; 3325 io->ul_io = NULL; 3326 io->tgt_wqe_timeout = 0; 3327 } 3328 3329 /** 3330 * @ingroup io 3331 * @brief Lockless allocate a HW IO object. 3332 * 3333 * @par Description 3334 * Assume that hw->ocs_lock is held. This function is only used if 3335 * use_dif_sec_xri workaround is being used. 3336 * 3337 * @param hw Hardware context. 3338 * 3339 * @return Returns a pointer to an object on success, or NULL on failure. 3340 */ 3341 static inline ocs_hw_io_t * 3342 _ocs_hw_io_alloc(ocs_hw_t *hw) 3343 { 3344 ocs_hw_io_t *io = NULL; 3345 3346 if (NULL != (io = ocs_list_remove_head(&hw->io_free))) { 3347 ocs_list_add_tail(&hw->io_inuse, io); 3348 io->state = OCS_HW_IO_STATE_INUSE; 3349 io->quarantine = FALSE; 3350 io->quarantine_first_phase = TRUE; 3351 io->abort_reqtag = UINT32_MAX; 3352 ocs_ref_init(&io->ref, ocs_hw_io_free_internal, io); 3353 } else { 3354 ocs_atomic_add_return(&hw->io_alloc_failed_count, 1); 3355 } 3356 3357 return io; 3358 } 3359 /** 3360 * @ingroup io 3361 * @brief Allocate a HW IO object. 3362 * 3363 * @par Description 3364 * @n @b Note: This function applies to non-port owned XRIs 3365 * only. 3366 * 3367 * @param hw Hardware context. 3368 * 3369 * @return Returns a pointer to an object on success, or NULL on failure. 3370 */ 3371 ocs_hw_io_t * 3372 ocs_hw_io_alloc(ocs_hw_t *hw) 3373 { 3374 ocs_hw_io_t *io = NULL; 3375 3376 ocs_lock(&hw->io_lock); 3377 io = _ocs_hw_io_alloc(hw); 3378 ocs_unlock(&hw->io_lock); 3379 3380 return io; 3381 } 3382 3383 /** 3384 * @ingroup io 3385 * @brief Allocate/Activate a port owned HW IO object. 3386 * 3387 * @par Description 3388 * This function is called by the transport layer when an XRI is 3389 * allocated by the SLI-Port. This will "activate" the HW IO 3390 * associated with the XRI received from the SLI-Port to mirror 3391 * the state of the XRI. 3392 * @n @n @b Note: This function applies to port owned XRIs only. 3393 * 3394 * @param hw Hardware context. 3395 * @param io Pointer HW IO to activate/allocate. 3396 * 3397 * @return Returns a pointer to an object on success, or NULL on failure. 3398 */ 3399 ocs_hw_io_t * 3400 ocs_hw_io_activate_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io) 3401 { 3402 if (ocs_ref_read_count(&io->ref) > 0) { 3403 ocs_log_err(hw->os, "Bad parameter: refcount > 0\n"); 3404 return NULL; 3405 } 3406 3407 if (io->wq != NULL) { 3408 ocs_log_err(hw->os, "XRI %x already in use\n", io->indicator); 3409 return NULL; 3410 } 3411 3412 ocs_ref_init(&io->ref, ocs_hw_io_free_port_owned, io); 3413 io->xbusy = TRUE; 3414 3415 return io; 3416 } 3417 3418 /** 3419 * @ingroup io 3420 * @brief When an IO is freed, depending on the exchange busy flag, and other 3421 * workarounds, move it to the correct list. 3422 * 3423 * @par Description 3424 * @n @b Note: Assumes that the hw->io_lock is held and the item has been removed 3425 * from the busy or wait_free list. 3426 * 3427 * @param hw Hardware context. 3428 * @param io Pointer to the IO object to move. 3429 */ 3430 static void 3431 ocs_hw_io_free_move_correct_list(ocs_hw_t *hw, ocs_hw_io_t *io) 3432 { 3433 if (io->xbusy) { 3434 /* add to wait_free list and wait for XRI_ABORTED CQEs to clean up */ 3435 ocs_list_add_tail(&hw->io_wait_free, io); 3436 io->state = OCS_HW_IO_STATE_WAIT_FREE; 3437 } else { 3438 /* IO not busy, add to free list */ 3439 ocs_list_add_tail(&hw->io_free, io); 3440 io->state = OCS_HW_IO_STATE_FREE; 3441 } 3442 3443 /* BZ 161832 workaround */ 3444 if (hw->workaround.use_dif_sec_xri) { 3445 ocs_hw_check_sec_hio_list(hw); 3446 } 3447 } 3448 3449 /** 3450 * @ingroup io 3451 * @brief Free a HW IO object. Perform cleanup common to 3452 * port and host-owned IOs. 3453 * 3454 * @param hw Hardware context. 3455 * @param io Pointer to the HW IO object. 3456 */ 3457 static inline void 3458 ocs_hw_io_free_common(ocs_hw_t *hw, ocs_hw_io_t *io) 3459 { 3460 /* initialize IO fields */ 3461 ocs_hw_init_free_io(io); 3462 3463 /* Restore default SGL */ 3464 ocs_hw_io_restore_sgl(hw, io); 3465 } 3466 3467 /** 3468 * @ingroup io 3469 * @brief Free a HW IO object associated with a port-owned XRI. 3470 * 3471 * @param arg Pointer to the HW IO object. 3472 */ 3473 static void 3474 ocs_hw_io_free_port_owned(void *arg) 3475 { 3476 ocs_hw_io_t *io = (ocs_hw_io_t *)arg; 3477 ocs_hw_t *hw = io->hw; 3478 3479 /* 3480 * For auto xfer rdy, if the dnrx bit is set, then add it to the list of XRIs 3481 * waiting for buffers. 3482 */ 3483 if (io->auto_xfer_rdy_dnrx) { 3484 ocs_lock(&hw->io_lock); 3485 /* take a reference count because we still own the IO until the buffer is posted */ 3486 ocs_ref_init(&io->ref, ocs_hw_io_free_port_owned, io); 3487 ocs_list_add_tail(&hw->io_port_dnrx, io); 3488 ocs_unlock(&hw->io_lock); 3489 } 3490 3491 /* perform common cleanup */ 3492 ocs_hw_io_free_common(hw, io); 3493 } 3494 3495 /** 3496 * @ingroup io 3497 * @brief Free a previously-allocated HW IO object. Called when 3498 * IO refcount goes to zero (host-owned IOs only). 3499 * 3500 * @param arg Pointer to the HW IO object. 3501 */ 3502 static void 3503 ocs_hw_io_free_internal(void *arg) 3504 { 3505 ocs_hw_io_t *io = (ocs_hw_io_t *)arg; 3506 ocs_hw_t *hw = io->hw; 3507 3508 /* perform common cleanup */ 3509 ocs_hw_io_free_common(hw, io); 3510 3511 ocs_lock(&hw->io_lock); 3512 /* remove from in-use list */ 3513 ocs_list_remove(&hw->io_inuse, io); 3514 ocs_hw_io_free_move_correct_list(hw, io); 3515 ocs_unlock(&hw->io_lock); 3516 } 3517 3518 /** 3519 * @ingroup io 3520 * @brief Free a previously-allocated HW IO object. 3521 * 3522 * @par Description 3523 * @n @b Note: This function applies to port and host owned XRIs. 3524 * 3525 * @param hw Hardware context. 3526 * @param io Pointer to the HW IO object. 3527 * 3528 * @return Returns a non-zero value if HW IO was freed, 0 if references 3529 * on the IO still exist, or a negative value if an error occurred. 3530 */ 3531 int32_t 3532 ocs_hw_io_free(ocs_hw_t *hw, ocs_hw_io_t *io) 3533 { 3534 /* just put refcount */ 3535 if (ocs_ref_read_count(&io->ref) <= 0) { 3536 ocs_log_err(hw->os, "Bad parameter: refcount <= 0 xri=%x tag=%x\n", 3537 io->indicator, io->reqtag); 3538 return -1; 3539 } 3540 3541 return ocs_ref_put(&io->ref); /* ocs_ref_get(): ocs_hw_io_alloc() */ 3542 } 3543 3544 /** 3545 * @ingroup io 3546 * @brief Check if given HW IO is in-use 3547 * 3548 * @par Description 3549 * This function returns TRUE if the given HW IO has been 3550 * allocated and is in-use, and FALSE otherwise. It applies to 3551 * port and host owned XRIs. 3552 * 3553 * @param hw Hardware context. 3554 * @param io Pointer to the HW IO object. 3555 * 3556 * @return TRUE if an IO is in use, or FALSE otherwise. 3557 */ 3558 uint8_t 3559 ocs_hw_io_inuse(ocs_hw_t *hw, ocs_hw_io_t *io) 3560 { 3561 return (ocs_ref_read_count(&io->ref) > 0); 3562 } 3563 3564 /** 3565 * @brief Write a HW IO to a work queue. 3566 * 3567 * @par Description 3568 * A HW IO is written to a work queue. 3569 * 3570 * @param wq Pointer to work queue. 3571 * @param wqe Pointer to WQ entry. 3572 * 3573 * @n @b Note: Assumes the SLI-4 queue lock is held. 3574 * 3575 * @return Returns 0 on success, or a negative error code value on failure. 3576 */ 3577 static int32_t 3578 _hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe) 3579 { 3580 int32_t rc; 3581 int32_t queue_rc; 3582 3583 /* Every so often, set the wqec bit to generate comsummed completions */ 3584 if (wq->wqec_count) { 3585 wq->wqec_count--; 3586 } 3587 if (wq->wqec_count == 0) { 3588 sli4_generic_wqe_t *genwqe = (void*)wqe->wqebuf; 3589 genwqe->wqec = 1; 3590 wq->wqec_count = wq->wqec_set_count; 3591 } 3592 3593 /* Decrement WQ free count */ 3594 wq->free_count--; 3595 3596 queue_rc = _sli_queue_write(&wq->hw->sli, wq->queue, wqe->wqebuf); 3597 3598 if (queue_rc < 0) { 3599 rc = -1; 3600 } else { 3601 rc = 0; 3602 ocs_queue_history_wq(&wq->hw->q_hist, (void *) wqe->wqebuf, wq->queue->id, queue_rc); 3603 } 3604 3605 return rc; 3606 } 3607 3608 /** 3609 * @brief Write a HW IO to a work queue. 3610 * 3611 * @par Description 3612 * A HW IO is written to a work queue. 3613 * 3614 * @param wq Pointer to work queue. 3615 * @param wqe Pointer to WQE entry. 3616 * 3617 * @n @b Note: Takes the SLI-4 queue lock. 3618 * 3619 * @return Returns 0 on success, or a negative error code value on failure. 3620 */ 3621 int32_t 3622 hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe) 3623 { 3624 int32_t rc = 0; 3625 3626 sli_queue_lock(wq->queue); 3627 if ( ! ocs_list_empty(&wq->pending_list)) { 3628 ocs_list_add_tail(&wq->pending_list, wqe); 3629 OCS_STAT(wq->wq_pending_count++;) 3630 while ((wq->free_count > 0) && ((wqe = ocs_list_remove_head(&wq->pending_list)) != NULL)) { 3631 rc = _hw_wq_write(wq, wqe); 3632 if (rc < 0) { 3633 break; 3634 } 3635 if (wqe->abort_wqe_submit_needed) { 3636 wqe->abort_wqe_submit_needed = 0; 3637 sli_abort_wqe(&wq->hw->sli, wqe->wqebuf, wq->hw->sli.config.wqe_size, SLI_ABORT_XRI, 3638 wqe->send_abts, wqe->id, 0, wqe->abort_reqtag, SLI4_CQ_DEFAULT ); 3639 ocs_list_add_tail(&wq->pending_list, wqe); 3640 OCS_STAT(wq->wq_pending_count++;) 3641 } 3642 } 3643 } else { 3644 if (wq->free_count > 0) { 3645 rc = _hw_wq_write(wq, wqe); 3646 } else { 3647 ocs_list_add_tail(&wq->pending_list, wqe); 3648 OCS_STAT(wq->wq_pending_count++;) 3649 } 3650 } 3651 3652 sli_queue_unlock(wq->queue); 3653 3654 return rc; 3655 3656 } 3657 3658 /** 3659 * @brief Update free count and submit any pending HW IOs 3660 * 3661 * @par Description 3662 * The WQ free count is updated, and any pending HW IOs are submitted that 3663 * will fit in the queue. 3664 * 3665 * @param wq Pointer to work queue. 3666 * @param update_free_count Value added to WQs free count. 3667 * 3668 * @return None. 3669 */ 3670 static void 3671 hw_wq_submit_pending(hw_wq_t *wq, uint32_t update_free_count) 3672 { 3673 ocs_hw_wqe_t *wqe; 3674 3675 sli_queue_lock(wq->queue); 3676 3677 /* Update free count with value passed in */ 3678 wq->free_count += update_free_count; 3679 3680 while ((wq->free_count > 0) && ((wqe = ocs_list_remove_head(&wq->pending_list)) != NULL)) { 3681 _hw_wq_write(wq, wqe); 3682 3683 if (wqe->abort_wqe_submit_needed) { 3684 wqe->abort_wqe_submit_needed = 0; 3685 sli_abort_wqe(&wq->hw->sli, wqe->wqebuf, wq->hw->sli.config.wqe_size, SLI_ABORT_XRI, 3686 wqe->send_abts, wqe->id, 0, wqe->abort_reqtag, SLI4_CQ_DEFAULT); 3687 ocs_list_add_tail(&wq->pending_list, wqe); 3688 OCS_STAT(wq->wq_pending_count++;) 3689 } 3690 } 3691 3692 sli_queue_unlock(wq->queue); 3693 } 3694 3695 /** 3696 * @brief Check to see if there are any BZ 161832 workaround waiting IOs 3697 * 3698 * @par Description 3699 * Checks hw->sec_hio_wait_list, if an IO is waiting for a HW IO, then try 3700 * to allocate a secondary HW io, and dispatch it. 3701 * 3702 * @n @b Note: hw->io_lock MUST be taken when called. 3703 * 3704 * @param hw pointer to HW object 3705 * 3706 * @return none 3707 */ 3708 static void 3709 ocs_hw_check_sec_hio_list(ocs_hw_t *hw) 3710 { 3711 ocs_hw_io_t *io; 3712 ocs_hw_io_t *sec_io; 3713 int rc = 0; 3714 3715 while (!ocs_list_empty(&hw->sec_hio_wait_list)) { 3716 uint16_t flags; 3717 3718 sec_io = _ocs_hw_io_alloc(hw); 3719 if (sec_io == NULL) { 3720 break; 3721 } 3722 3723 io = ocs_list_remove_head(&hw->sec_hio_wait_list); 3724 ocs_list_add_tail(&hw->io_inuse, io); 3725 io->state = OCS_HW_IO_STATE_INUSE; 3726 io->sec_hio = sec_io; 3727 3728 /* mark secondary XRI for second and subsequent data phase as quarantine */ 3729 if (io->xbusy) { 3730 sec_io->quarantine = TRUE; 3731 } 3732 3733 flags = io->sec_iparam.fcp_tgt.flags; 3734 if (io->xbusy) { 3735 flags |= SLI4_IO_CONTINUATION; 3736 } else { 3737 flags &= ~SLI4_IO_CONTINUATION; 3738 } 3739 3740 io->tgt_wqe_timeout = io->sec_iparam.fcp_tgt.timeout; 3741 3742 /* Complete (continue) TRECV IO */ 3743 if (io->xbusy) { 3744 if (sli_fcp_cont_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, 3745 io->first_data_sge, 3746 io->sec_iparam.fcp_tgt.offset, io->sec_len, io->indicator, io->sec_hio->indicator, 3747 io->reqtag, SLI4_CQ_DEFAULT, 3748 io->sec_iparam.fcp_tgt.ox_id, io->rnode->indicator, io->rnode, 3749 flags, 3750 io->sec_iparam.fcp_tgt.dif_oper, io->sec_iparam.fcp_tgt.blk_size, io->sec_iparam.fcp_tgt.cs_ctl, io->sec_iparam.fcp_tgt.app_id)) { 3751 ocs_log_test(hw->os, "TRECEIVE WQE error\n"); 3752 break; 3753 } 3754 } else { 3755 if (sli_fcp_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, 3756 io->first_data_sge, 3757 io->sec_iparam.fcp_tgt.offset, io->sec_len, io->indicator, 3758 io->reqtag, SLI4_CQ_DEFAULT, 3759 io->sec_iparam.fcp_tgt.ox_id, io->rnode->indicator, io->rnode, 3760 flags, 3761 io->sec_iparam.fcp_tgt.dif_oper, io->sec_iparam.fcp_tgt.blk_size, 3762 io->sec_iparam.fcp_tgt.cs_ctl, io->sec_iparam.fcp_tgt.app_id)) { 3763 ocs_log_test(hw->os, "TRECEIVE WQE error\n"); 3764 break; 3765 } 3766 } 3767 3768 if (io->wq == NULL) { 3769 io->wq = ocs_hw_queue_next_wq(hw, io); 3770 ocs_hw_assert(io->wq != NULL); 3771 } 3772 io->xbusy = TRUE; 3773 3774 /* 3775 * Add IO to active io wqe list before submitting, in case the 3776 * wcqe processing preempts this thread. 3777 */ 3778 ocs_hw_add_io_timed_wqe(hw, io); 3779 rc = hw_wq_write(io->wq, &io->wqe); 3780 if (rc >= 0) { 3781 /* non-negative return is success */ 3782 rc = 0; 3783 } else { 3784 /* failed to write wqe, remove from active wqe list */ 3785 ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc); 3786 io->xbusy = FALSE; 3787 ocs_hw_remove_io_timed_wqe(hw, io); 3788 } 3789 } 3790 } 3791 3792 /** 3793 * @ingroup io 3794 * @brief Send a Single Request/Response Sequence (SRRS). 3795 * 3796 * @par Description 3797 * This routine supports communication sequences consisting of a single 3798 * request and single response between two endpoints. Examples include: 3799 * - Sending an ELS request. 3800 * - Sending an ELS response - To send an ELS reponse, the caller must provide 3801 * the OX_ID from the received request. 3802 * - Sending a FC Common Transport (FC-CT) request - To send a FC-CT request, 3803 * the caller must provide the R_CTL, TYPE, and DF_CTL 3804 * values to place in the FC frame header. 3805 * . 3806 * @n @b Note: The caller is expected to provide both send and receive 3807 * buffers for requests. In the case of sending a response, no receive buffer 3808 * is necessary and the caller may pass in a NULL pointer. 3809 * 3810 * @param hw Hardware context. 3811 * @param type Type of sequence (ELS request/response, FC-CT). 3812 * @param io Previously-allocated HW IO object. 3813 * @param send DMA memory holding data to send (for example, ELS request, BLS response). 3814 * @param len Length, in bytes, of data to send. 3815 * @param receive Optional DMA memory to hold a response. 3816 * @param rnode Destination of data (that is, a remote node). 3817 * @param iparam IO parameters (ELS response and FC-CT). 3818 * @param cb Function call upon completion of sending the data (may be NULL). 3819 * @param arg Argument to pass to IO completion function. 3820 * 3821 * @return Returns 0 on success, or a non-zero on failure. 3822 */ 3823 ocs_hw_rtn_e 3824 ocs_hw_srrs_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io, 3825 ocs_dma_t *send, uint32_t len, ocs_dma_t *receive, 3826 ocs_remote_node_t *rnode, ocs_hw_io_param_t *iparam, 3827 ocs_hw_srrs_cb_t cb, void *arg) 3828 { 3829 sli4_sge_t *sge = NULL; 3830 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 3831 uint16_t local_flags = 0; 3832 3833 if (!hw || !io || !rnode || !iparam) { 3834 ocs_log_err(NULL, "bad parm hw=%p io=%p send=%p receive=%p rnode=%p iparam=%p\n", 3835 hw, io, send, receive, rnode, iparam); 3836 return OCS_HW_RTN_ERROR; 3837 } 3838 3839 if (hw->state != OCS_HW_STATE_ACTIVE) { 3840 ocs_log_test(hw->os, "cannot send SRRS, HW state=%d\n", hw->state); 3841 return OCS_HW_RTN_ERROR; 3842 } 3843 3844 if (ocs_hw_is_xri_port_owned(hw, io->indicator)) { 3845 /* We must set the XC bit for port owned XRIs */ 3846 local_flags |= SLI4_IO_CONTINUATION; 3847 } 3848 io->rnode = rnode; 3849 io->type = type; 3850 io->done = cb; 3851 io->arg = arg; 3852 3853 sge = io->sgl->virt; 3854 3855 /* clear both SGE */ 3856 ocs_memset(io->sgl->virt, 0, 2 * sizeof(sli4_sge_t)); 3857 3858 if (send) { 3859 sge[0].buffer_address_high = ocs_addr32_hi(send->phys); 3860 sge[0].buffer_address_low = ocs_addr32_lo(send->phys); 3861 sge[0].sge_type = SLI4_SGE_TYPE_DATA; 3862 sge[0].buffer_length = len; 3863 } 3864 3865 if ((OCS_HW_ELS_REQ == type) || (OCS_HW_FC_CT == type)) { 3866 sge[1].buffer_address_high = ocs_addr32_hi(receive->phys); 3867 sge[1].buffer_address_low = ocs_addr32_lo(receive->phys); 3868 sge[1].sge_type = SLI4_SGE_TYPE_DATA; 3869 sge[1].buffer_length = receive->size; 3870 sge[1].last = TRUE; 3871 } else { 3872 sge[0].last = TRUE; 3873 } 3874 3875 switch (type) { 3876 case OCS_HW_ELS_REQ: 3877 if ( (!send) || sli_els_request64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl, 3878 *((uint8_t *)(send->virt)), /* req_type */ 3879 len, receive->size, 3880 iparam->els.timeout, io->indicator, io->reqtag, SLI4_CQ_DEFAULT, rnode)) { 3881 ocs_log_err(hw->os, "REQ WQE error\n"); 3882 rc = OCS_HW_RTN_ERROR; 3883 } 3884 break; 3885 case OCS_HW_ELS_RSP: 3886 if ( (!send) || sli_xmit_els_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len, 3887 io->indicator, io->reqtag, SLI4_CQ_DEFAULT, 3888 iparam->els.ox_id, 3889 rnode, local_flags, UINT32_MAX)) { 3890 ocs_log_err(hw->os, "RSP WQE error\n"); 3891 rc = OCS_HW_RTN_ERROR; 3892 } 3893 break; 3894 case OCS_HW_ELS_RSP_SID: 3895 if ( (!send) || sli_xmit_els_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len, 3896 io->indicator, io->reqtag, SLI4_CQ_DEFAULT, 3897 iparam->els_sid.ox_id, 3898 rnode, local_flags, iparam->els_sid.s_id)) { 3899 ocs_log_err(hw->os, "RSP (SID) WQE error\n"); 3900 rc = OCS_HW_RTN_ERROR; 3901 } 3902 break; 3903 case OCS_HW_FC_CT: 3904 if ( (!send) || sli_gen_request64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl, len, 3905 receive->size, iparam->fc_ct.timeout, io->indicator, 3906 io->reqtag, SLI4_CQ_DEFAULT, rnode, iparam->fc_ct.r_ctl, 3907 iparam->fc_ct.type, iparam->fc_ct.df_ctl)) { 3908 ocs_log_err(hw->os, "GEN WQE error\n"); 3909 rc = OCS_HW_RTN_ERROR; 3910 } 3911 break; 3912 case OCS_HW_FC_CT_RSP: 3913 if ( (!send) || sli_xmit_sequence64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl, len, 3914 iparam->fc_ct_rsp.timeout, iparam->fc_ct_rsp.ox_id, io->indicator, 3915 io->reqtag, rnode, iparam->fc_ct_rsp.r_ctl, 3916 iparam->fc_ct_rsp.type, iparam->fc_ct_rsp.df_ctl)) { 3917 ocs_log_err(hw->os, "XMIT SEQ WQE error\n"); 3918 rc = OCS_HW_RTN_ERROR; 3919 } 3920 break; 3921 case OCS_HW_BLS_ACC: 3922 case OCS_HW_BLS_RJT: 3923 { 3924 sli_bls_payload_t bls; 3925 3926 if (OCS_HW_BLS_ACC == type) { 3927 bls.type = SLI_BLS_ACC; 3928 ocs_memcpy(&bls.u.acc, iparam->bls.payload, sizeof(bls.u.acc)); 3929 } else { 3930 bls.type = SLI_BLS_RJT; 3931 ocs_memcpy(&bls.u.rjt, iparam->bls.payload, sizeof(bls.u.rjt)); 3932 } 3933 3934 bls.ox_id = iparam->bls.ox_id; 3935 bls.rx_id = iparam->bls.rx_id; 3936 3937 if (sli_xmit_bls_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &bls, 3938 io->indicator, io->reqtag, 3939 SLI4_CQ_DEFAULT, 3940 rnode, UINT32_MAX)) { 3941 ocs_log_err(hw->os, "XMIT_BLS_RSP64 WQE error\n"); 3942 rc = OCS_HW_RTN_ERROR; 3943 } 3944 break; 3945 } 3946 case OCS_HW_BLS_ACC_SID: 3947 { 3948 sli_bls_payload_t bls; 3949 3950 bls.type = SLI_BLS_ACC; 3951 ocs_memcpy(&bls.u.acc, iparam->bls_sid.payload, sizeof(bls.u.acc)); 3952 3953 bls.ox_id = iparam->bls_sid.ox_id; 3954 bls.rx_id = iparam->bls_sid.rx_id; 3955 3956 if (sli_xmit_bls_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &bls, 3957 io->indicator, io->reqtag, 3958 SLI4_CQ_DEFAULT, 3959 rnode, iparam->bls_sid.s_id)) { 3960 ocs_log_err(hw->os, "XMIT_BLS_RSP64 WQE SID error\n"); 3961 rc = OCS_HW_RTN_ERROR; 3962 } 3963 break; 3964 } 3965 case OCS_HW_BCAST: 3966 if ( (!send) || sli_xmit_bcast64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len, 3967 iparam->bcast.timeout, io->indicator, io->reqtag, 3968 SLI4_CQ_DEFAULT, rnode, 3969 iparam->bcast.r_ctl, iparam->bcast.type, iparam->bcast.df_ctl)) { 3970 ocs_log_err(hw->os, "XMIT_BCAST64 WQE error\n"); 3971 rc = OCS_HW_RTN_ERROR; 3972 } 3973 break; 3974 default: 3975 ocs_log_err(hw->os, "bad SRRS type %#x\n", type); 3976 rc = OCS_HW_RTN_ERROR; 3977 } 3978 3979 if (OCS_HW_RTN_SUCCESS == rc) { 3980 if (io->wq == NULL) { 3981 io->wq = ocs_hw_queue_next_wq(hw, io); 3982 ocs_hw_assert(io->wq != NULL); 3983 } 3984 io->xbusy = TRUE; 3985 3986 /* 3987 * Add IO to active io wqe list before submitting, in case the 3988 * wcqe processing preempts this thread. 3989 */ 3990 OCS_STAT(io->wq->use_count++); 3991 ocs_hw_add_io_timed_wqe(hw, io); 3992 rc = hw_wq_write(io->wq, &io->wqe); 3993 if (rc >= 0) { 3994 /* non-negative return is success */ 3995 rc = 0; 3996 } else { 3997 /* failed to write wqe, remove from active wqe list */ 3998 ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc); 3999 io->xbusy = FALSE; 4000 ocs_hw_remove_io_timed_wqe(hw, io); 4001 } 4002 } 4003 4004 return rc; 4005 } 4006 4007 /** 4008 * @ingroup io 4009 * @brief Send a read, write, or response IO. 4010 * 4011 * @par Description 4012 * This routine supports sending a higher-level IO (for example, FCP) between two endpoints 4013 * as a target or initiator. Examples include: 4014 * - Sending read data and good response (target). 4015 * - Sending a response (target with no data or after receiving write data). 4016 * . 4017 * This routine assumes all IOs use the SGL associated with the HW IO. Prior to 4018 * calling this routine, the data should be loaded using ocs_hw_io_add_sge(). 4019 * 4020 * @param hw Hardware context. 4021 * @param type Type of IO (target read, target response, and so on). 4022 * @param io Previously-allocated HW IO object. 4023 * @param len Length, in bytes, of data to send. 4024 * @param iparam IO parameters. 4025 * @param rnode Destination of data (that is, a remote node). 4026 * @param cb Function call upon completion of sending data (may be NULL). 4027 * @param arg Argument to pass to IO completion function. 4028 * 4029 * @return Returns 0 on success, or a non-zero value on failure. 4030 * 4031 * @todo 4032 * - Support specifiying relative offset. 4033 * - Use a WQ other than 0. 4034 */ 4035 ocs_hw_rtn_e 4036 ocs_hw_io_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io, 4037 uint32_t len, ocs_hw_io_param_t *iparam, ocs_remote_node_t *rnode, 4038 void *cb, void *arg) 4039 { 4040 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 4041 uint32_t rpi; 4042 uint8_t send_wqe = TRUE; 4043 4044 CPUTRACE(""); 4045 4046 if (!hw || !io || !rnode || !iparam) { 4047 ocs_log_err(NULL, "bad parm hw=%p io=%p iparam=%p rnode=%p\n", 4048 hw, io, iparam, rnode); 4049 return OCS_HW_RTN_ERROR; 4050 } 4051 4052 if (hw->state != OCS_HW_STATE_ACTIVE) { 4053 ocs_log_err(hw->os, "cannot send IO, HW state=%d\n", hw->state); 4054 return OCS_HW_RTN_ERROR; 4055 } 4056 4057 rpi = rnode->indicator; 4058 4059 if (hw->workaround.use_unregistered_rpi && (rpi == UINT32_MAX)) { 4060 rpi = hw->workaround.unregistered_rid; 4061 ocs_log_test(hw->os, "using unregistered RPI: %d\n", rpi); 4062 } 4063 4064 /* 4065 * Save state needed during later stages 4066 */ 4067 io->rnode = rnode; 4068 io->type = type; 4069 io->done = cb; 4070 io->arg = arg; 4071 4072 /* 4073 * Format the work queue entry used to send the IO 4074 */ 4075 switch (type) { 4076 case OCS_HW_IO_INITIATOR_READ: 4077 /* 4078 * If use_dif_quarantine workaround is in effect, and dif_separates then mark the 4079 * initiator read IO for quarantine 4080 */ 4081 if (hw->workaround.use_dif_quarantine && (hw->config.dif_mode == OCS_HW_DIF_MODE_SEPARATE) && 4082 (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) { 4083 io->quarantine = TRUE; 4084 } 4085 4086 ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size, 4087 iparam->fcp_ini.rsp); 4088 4089 if (sli_fcp_iread64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, len, 4090 io->indicator, io->reqtag, SLI4_CQ_DEFAULT, rpi, rnode, 4091 iparam->fcp_ini.dif_oper, iparam->fcp_ini.blk_size, 4092 iparam->fcp_ini.timeout)) { 4093 ocs_log_err(hw->os, "IREAD WQE error\n"); 4094 rc = OCS_HW_RTN_ERROR; 4095 } 4096 break; 4097 case OCS_HW_IO_INITIATOR_WRITE: 4098 ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size, 4099 iparam->fcp_ini.rsp); 4100 4101 if (sli_fcp_iwrite64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, 4102 len, iparam->fcp_ini.first_burst, 4103 io->indicator, io->reqtag, 4104 SLI4_CQ_DEFAULT, rpi, rnode, 4105 iparam->fcp_ini.dif_oper, iparam->fcp_ini.blk_size, 4106 iparam->fcp_ini.timeout)) { 4107 ocs_log_err(hw->os, "IWRITE WQE error\n"); 4108 rc = OCS_HW_RTN_ERROR; 4109 } 4110 break; 4111 case OCS_HW_IO_INITIATOR_NODATA: 4112 ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size, 4113 iparam->fcp_ini.rsp); 4114 4115 if (sli_fcp_icmnd64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, 4116 io->indicator, io->reqtag, SLI4_CQ_DEFAULT, 4117 rpi, rnode, iparam->fcp_ini.timeout)) { 4118 ocs_log_err(hw->os, "ICMND WQE error\n"); 4119 rc = OCS_HW_RTN_ERROR; 4120 } 4121 break; 4122 case OCS_HW_IO_TARGET_WRITE: { 4123 uint16_t flags = iparam->fcp_tgt.flags; 4124 fcp_xfer_rdy_iu_t *xfer = io->xfer_rdy.virt; 4125 4126 /* 4127 * Fill in the XFER_RDY for IF_TYPE 0 devices 4128 */ 4129 *((uint32_t *)xfer->fcp_data_ro) = ocs_htobe32(iparam->fcp_tgt.offset); 4130 *((uint32_t *)xfer->fcp_burst_len) = ocs_htobe32(len); 4131 *((uint32_t *)xfer->rsvd) = 0; 4132 4133 if (io->xbusy) { 4134 flags |= SLI4_IO_CONTINUATION; 4135 } else { 4136 flags &= ~SLI4_IO_CONTINUATION; 4137 } 4138 4139 io->tgt_wqe_timeout = iparam->fcp_tgt.timeout; 4140 4141 /* 4142 * If use_dif_quarantine workaround is in effect, and this is a DIF enabled IO 4143 * then mark the target write IO for quarantine 4144 */ 4145 if (hw->workaround.use_dif_quarantine && (hw->config.dif_mode == OCS_HW_DIF_MODE_SEPARATE) && 4146 (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) { 4147 io->quarantine = TRUE; 4148 } 4149 4150 /* 4151 * BZ 161832 Workaround: 4152 * Check for use_dif_sec_xri workaround. Note, even though the first dataphase 4153 * doesn't really need a secondary XRI, we allocate one anyway, as this avoids the 4154 * potential for deadlock where all XRI's are allocated as primaries to IOs that 4155 * are on hw->sec_hio_wait_list. If this secondary XRI is not for the first 4156 * data phase, it is marked for quarantine. 4157 */ 4158 if (hw->workaround.use_dif_sec_xri && (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) { 4159 /* 4160 * If we have allocated a chained SGL for skyhawk, then 4161 * we can re-use this for the sec_hio. 4162 */ 4163 if (io->ovfl_io != NULL) { 4164 io->sec_hio = io->ovfl_io; 4165 io->sec_hio->quarantine = TRUE; 4166 } else { 4167 io->sec_hio = ocs_hw_io_alloc(hw); 4168 } 4169 if (io->sec_hio == NULL) { 4170 /* Failed to allocate, so save full request context and put 4171 * this IO on the wait list 4172 */ 4173 io->sec_iparam = *iparam; 4174 io->sec_len = len; 4175 ocs_lock(&hw->io_lock); 4176 ocs_list_remove(&hw->io_inuse, io); 4177 ocs_list_add_tail(&hw->sec_hio_wait_list, io); 4178 io->state = OCS_HW_IO_STATE_WAIT_SEC_HIO; 4179 hw->sec_hio_wait_count++; 4180 ocs_unlock(&hw->io_lock); 4181 send_wqe = FALSE; 4182 /* Done */ 4183 break; 4184 } 4185 /* We quarantine the secondary IO if this is the second or subsequent data phase */ 4186 if (io->xbusy) { 4187 io->sec_hio->quarantine = TRUE; 4188 } 4189 } 4190 4191 /* 4192 * If not the first data phase, and io->sec_hio has been allocated, then issue 4193 * FCP_CONT_TRECEIVE64 WQE, otherwise use the usual FCP_TRECEIVE64 WQE 4194 */ 4195 if (io->xbusy && (io->sec_hio != NULL)) { 4196 if (sli_fcp_cont_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, 4197 iparam->fcp_tgt.offset, len, io->indicator, io->sec_hio->indicator, 4198 io->reqtag, SLI4_CQ_DEFAULT, 4199 iparam->fcp_tgt.ox_id, rpi, rnode, 4200 flags, 4201 iparam->fcp_tgt.dif_oper, iparam->fcp_tgt.blk_size, 4202 iparam->fcp_tgt.cs_ctl, iparam->fcp_tgt.app_id)) { 4203 ocs_log_err(hw->os, "TRECEIVE WQE error\n"); 4204 rc = OCS_HW_RTN_ERROR; 4205 } 4206 } else { 4207 if (sli_fcp_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, 4208 iparam->fcp_tgt.offset, len, io->indicator, io->reqtag, 4209 SLI4_CQ_DEFAULT, 4210 iparam->fcp_tgt.ox_id, rpi, rnode, 4211 flags, 4212 iparam->fcp_tgt.dif_oper, iparam->fcp_tgt.blk_size, 4213 iparam->fcp_tgt.cs_ctl, iparam->fcp_tgt.app_id)) { 4214 ocs_log_err(hw->os, "TRECEIVE WQE error\n"); 4215 rc = OCS_HW_RTN_ERROR; 4216 } 4217 } 4218 break; 4219 } 4220 case OCS_HW_IO_TARGET_READ: { 4221 uint16_t flags = iparam->fcp_tgt.flags; 4222 4223 if (io->xbusy) { 4224 flags |= SLI4_IO_CONTINUATION; 4225 } else { 4226 flags &= ~SLI4_IO_CONTINUATION; 4227 } 4228 4229 io->tgt_wqe_timeout = iparam->fcp_tgt.timeout; 4230 if (sli_fcp_tsend64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, 4231 iparam->fcp_tgt.offset, len, io->indicator, io->reqtag, 4232 SLI4_CQ_DEFAULT, 4233 iparam->fcp_tgt.ox_id, rpi, rnode, 4234 flags, 4235 iparam->fcp_tgt.dif_oper, 4236 iparam->fcp_tgt.blk_size, 4237 iparam->fcp_tgt.cs_ctl, 4238 iparam->fcp_tgt.app_id)) { 4239 ocs_log_err(hw->os, "TSEND WQE error\n"); 4240 rc = OCS_HW_RTN_ERROR; 4241 } else if (hw->workaround.retain_tsend_io_length) { 4242 io->length = len; 4243 } 4244 break; 4245 } 4246 case OCS_HW_IO_TARGET_RSP: { 4247 uint16_t flags = iparam->fcp_tgt.flags; 4248 4249 if (io->xbusy) { 4250 flags |= SLI4_IO_CONTINUATION; 4251 } else { 4252 flags &= ~SLI4_IO_CONTINUATION; 4253 } 4254 4255 /* post a new auto xfer ready buffer */ 4256 if (hw->auto_xfer_rdy_enabled && io->is_port_owned) { 4257 if ((io->auto_xfer_rdy_dnrx = ocs_hw_rqpair_auto_xfer_rdy_buffer_post(hw, io, 1))) { 4258 flags |= SLI4_IO_DNRX; 4259 } 4260 } 4261 4262 io->tgt_wqe_timeout = iparam->fcp_tgt.timeout; 4263 if (sli_fcp_trsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, 4264 &io->def_sgl, 4265 len, 4266 io->indicator, io->reqtag, 4267 SLI4_CQ_DEFAULT, 4268 iparam->fcp_tgt.ox_id, 4269 rpi, rnode, 4270 flags, iparam->fcp_tgt.cs_ctl, 4271 io->is_port_owned, 4272 iparam->fcp_tgt.app_id)) { 4273 ocs_log_err(hw->os, "TRSP WQE error\n"); 4274 rc = OCS_HW_RTN_ERROR; 4275 } 4276 4277 break; 4278 } 4279 default: 4280 ocs_log_err(hw->os, "unsupported IO type %#x\n", type); 4281 rc = OCS_HW_RTN_ERROR; 4282 } 4283 4284 if (send_wqe && (OCS_HW_RTN_SUCCESS == rc)) { 4285 if (io->wq == NULL) { 4286 io->wq = ocs_hw_queue_next_wq(hw, io); 4287 ocs_hw_assert(io->wq != NULL); 4288 } 4289 4290 io->xbusy = TRUE; 4291 4292 /* 4293 * Add IO to active io wqe list before submitting, in case the 4294 * wcqe processing preempts this thread. 4295 */ 4296 OCS_STAT(hw->tcmd_wq_submit[io->wq->instance]++); 4297 OCS_STAT(io->wq->use_count++); 4298 ocs_hw_add_io_timed_wqe(hw, io); 4299 rc = hw_wq_write(io->wq, &io->wqe); 4300 if (rc >= 0) { 4301 /* non-negative return is success */ 4302 rc = 0; 4303 } else { 4304 /* failed to write wqe, remove from active wqe list */ 4305 ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc); 4306 io->xbusy = FALSE; 4307 ocs_hw_remove_io_timed_wqe(hw, io); 4308 } 4309 } 4310 4311 return rc; 4312 } 4313 4314 /** 4315 * @brief Send a raw frame 4316 * 4317 * @par Description 4318 * Using the SEND_FRAME_WQE, a frame consisting of header and payload is sent. 4319 * 4320 * @param hw Pointer to HW object. 4321 * @param hdr Pointer to a little endian formatted FC header. 4322 * @param sof Value to use as the frame SOF. 4323 * @param eof Value to use as the frame EOF. 4324 * @param payload Pointer to payload DMA buffer. 4325 * @param ctx Pointer to caller provided send frame context. 4326 * @param callback Callback function. 4327 * @param arg Callback function argument. 4328 * 4329 * @return Returns 0 on success, or a negative error code value on failure. 4330 */ 4331 ocs_hw_rtn_e 4332 ocs_hw_send_frame(ocs_hw_t *hw, fc_header_le_t *hdr, uint8_t sof, uint8_t eof, ocs_dma_t *payload, 4333 ocs_hw_send_frame_context_t *ctx, void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg) 4334 { 4335 int32_t rc; 4336 ocs_hw_wqe_t *wqe; 4337 uint32_t xri; 4338 hw_wq_t *wq; 4339 4340 wqe = &ctx->wqe; 4341 4342 /* populate the callback object */ 4343 ctx->hw = hw; 4344 4345 /* Fetch and populate request tag */ 4346 ctx->wqcb = ocs_hw_reqtag_alloc(hw, callback, arg); 4347 if (ctx->wqcb == NULL) { 4348 ocs_log_err(hw->os, "can't allocate request tag\n"); 4349 return OCS_HW_RTN_NO_RESOURCES; 4350 } 4351 4352 /* Choose a work queue, first look for a class[1] wq, otherwise just use wq[0] */ 4353 wq = ocs_varray_iter_next(hw->wq_class_array[1]); 4354 if (wq == NULL) { 4355 wq = hw->hw_wq[0]; 4356 } 4357 4358 /* Set XRI and RX_ID in the header based on which WQ, and which send_frame_io we are using */ 4359 xri = wq->send_frame_io->indicator; 4360 4361 /* Build the send frame WQE */ 4362 rc = sli_send_frame_wqe(&hw->sli, wqe->wqebuf, hw->sli.config.wqe_size, sof, eof, (uint32_t*) hdr, payload, 4363 payload->len, OCS_HW_SEND_FRAME_TIMEOUT, xri, ctx->wqcb->instance_index); 4364 if (rc) { 4365 ocs_log_err(hw->os, "sli_send_frame_wqe failed: %d\n", rc); 4366 return OCS_HW_RTN_ERROR; 4367 } 4368 4369 /* Write to WQ */ 4370 rc = hw_wq_write(wq, wqe); 4371 if (rc) { 4372 ocs_log_err(hw->os, "hw_wq_write failed: %d\n", rc); 4373 return OCS_HW_RTN_ERROR; 4374 } 4375 4376 OCS_STAT(wq->use_count++); 4377 4378 return OCS_HW_RTN_SUCCESS; 4379 } 4380 4381 ocs_hw_rtn_e 4382 ocs_hw_io_register_sgl(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_dma_t *sgl, uint32_t sgl_count) 4383 { 4384 if (sli_get_sgl_preregister(&hw->sli)) { 4385 ocs_log_err(hw->os, "can't use temporary SGL with pre-registered SGLs\n"); 4386 return OCS_HW_RTN_ERROR; 4387 } 4388 io->ovfl_sgl = sgl; 4389 io->ovfl_sgl_count = sgl_count; 4390 io->ovfl_io = NULL; 4391 4392 return OCS_HW_RTN_SUCCESS; 4393 } 4394 4395 static void 4396 ocs_hw_io_restore_sgl(ocs_hw_t *hw, ocs_hw_io_t *io) 4397 { 4398 /* Restore the default */ 4399 io->sgl = &io->def_sgl; 4400 io->sgl_count = io->def_sgl_count; 4401 4402 /* 4403 * For skyhawk, we need to free the IO allocated for the chained 4404 * SGL. For all devices, clear the overflow fields on the IO. 4405 * 4406 * Note: For DIF IOs, we may be using the same XRI for the sec_hio and 4407 * the chained SGLs. If so, then we clear the ovfl_io field 4408 * when the sec_hio is freed. 4409 */ 4410 if (io->ovfl_io != NULL) { 4411 ocs_hw_io_free(hw, io->ovfl_io); 4412 io->ovfl_io = NULL; 4413 } 4414 4415 /* Clear the overflow SGL */ 4416 io->ovfl_sgl = NULL; 4417 io->ovfl_sgl_count = 0; 4418 io->ovfl_lsp = NULL; 4419 } 4420 4421 /** 4422 * @ingroup io 4423 * @brief Initialize the scatter gather list entries of an IO. 4424 * 4425 * @param hw Hardware context. 4426 * @param io Previously-allocated HW IO object. 4427 * @param type Type of IO (target read, target response, and so on). 4428 * 4429 * @return Returns 0 on success, or a non-zero value on failure. 4430 */ 4431 ocs_hw_rtn_e 4432 ocs_hw_io_init_sges(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_io_type_e type) 4433 { 4434 sli4_sge_t *data = NULL; 4435 uint32_t i = 0; 4436 uint32_t skips = 0; 4437 4438 if (!hw || !io) { 4439 ocs_log_err(hw ? hw->os : NULL, "bad parameter hw=%p io=%p\n", 4440 hw, io); 4441 return OCS_HW_RTN_ERROR; 4442 } 4443 4444 /* Clear / reset the scatter-gather list */ 4445 io->sgl = &io->def_sgl; 4446 io->sgl_count = io->def_sgl_count; 4447 io->first_data_sge = 0; 4448 4449 ocs_memset(io->sgl->virt, 0, 2 * sizeof(sli4_sge_t)); 4450 io->n_sge = 0; 4451 io->sge_offset = 0; 4452 4453 io->type = type; 4454 4455 data = io->sgl->virt; 4456 4457 /* 4458 * Some IO types have underlying hardware requirements on the order 4459 * of SGEs. Process all special entries here. 4460 */ 4461 switch (type) { 4462 case OCS_HW_IO_INITIATOR_READ: 4463 case OCS_HW_IO_INITIATOR_WRITE: 4464 case OCS_HW_IO_INITIATOR_NODATA: 4465 /* 4466 * No skips, 2 special for initiator I/Os 4467 * The addresses and length are written later 4468 */ 4469 /* setup command pointer */ 4470 data->sge_type = SLI4_SGE_TYPE_DATA; 4471 data++; 4472 4473 /* setup response pointer */ 4474 data->sge_type = SLI4_SGE_TYPE_DATA; 4475 4476 if (OCS_HW_IO_INITIATOR_NODATA == type) { 4477 data->last = TRUE; 4478 } 4479 data++; 4480 4481 io->n_sge = 2; 4482 break; 4483 case OCS_HW_IO_TARGET_WRITE: 4484 #define OCS_TARGET_WRITE_SKIPS 2 4485 skips = OCS_TARGET_WRITE_SKIPS; 4486 4487 /* populate host resident XFER_RDY buffer */ 4488 data->sge_type = SLI4_SGE_TYPE_DATA; 4489 data->buffer_address_high = ocs_addr32_hi(io->xfer_rdy.phys); 4490 data->buffer_address_low = ocs_addr32_lo(io->xfer_rdy.phys); 4491 data->buffer_length = io->xfer_rdy.size; 4492 data++; 4493 4494 skips--; 4495 4496 io->n_sge = 1; 4497 break; 4498 case OCS_HW_IO_TARGET_READ: 4499 /* 4500 * For FCP_TSEND64, the first 2 entries are SKIP SGE's 4501 */ 4502 #define OCS_TARGET_READ_SKIPS 2 4503 skips = OCS_TARGET_READ_SKIPS; 4504 break; 4505 case OCS_HW_IO_TARGET_RSP: 4506 /* 4507 * No skips, etc. for FCP_TRSP64 4508 */ 4509 break; 4510 default: 4511 ocs_log_err(hw->os, "unsupported IO type %#x\n", type); 4512 return OCS_HW_RTN_ERROR; 4513 } 4514 4515 /* 4516 * Write skip entries 4517 */ 4518 for (i = 0; i < skips; i++) { 4519 data->sge_type = SLI4_SGE_TYPE_SKIP; 4520 data++; 4521 } 4522 4523 io->n_sge += skips; 4524 4525 /* 4526 * Set last 4527 */ 4528 data->last = TRUE; 4529 4530 return OCS_HW_RTN_SUCCESS; 4531 } 4532 4533 /** 4534 * @ingroup io 4535 * @brief Add a T10 PI seed scatter gather list entry. 4536 * 4537 * @param hw Hardware context. 4538 * @param io Previously-allocated HW IO object. 4539 * @param dif_info Pointer to T10 DIF fields, or NULL if no DIF. 4540 * 4541 * @return Returns 0 on success, or a non-zero value on failure. 4542 */ 4543 ocs_hw_rtn_e 4544 ocs_hw_io_add_seed_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_dif_info_t *dif_info) 4545 { 4546 sli4_sge_t *data = NULL; 4547 sli4_diseed_sge_t *dif_seed; 4548 4549 /* If no dif_info, or dif_oper is disabled, then just return success */ 4550 if ((dif_info == NULL) || (dif_info->dif_oper == OCS_HW_DIF_OPER_DISABLED)) { 4551 return OCS_HW_RTN_SUCCESS; 4552 } 4553 4554 if (!hw || !io) { 4555 ocs_log_err(hw ? hw->os : NULL, "bad parameter hw=%p io=%p dif_info=%p\n", 4556 hw, io, dif_info); 4557 return OCS_HW_RTN_ERROR; 4558 } 4559 4560 data = io->sgl->virt; 4561 data += io->n_sge; 4562 4563 /* If we are doing T10 DIF add the DIF Seed SGE */ 4564 ocs_memset(data, 0, sizeof(sli4_diseed_sge_t)); 4565 dif_seed = (sli4_diseed_sge_t *)data; 4566 dif_seed->ref_tag_cmp = dif_info->ref_tag_cmp; 4567 dif_seed->ref_tag_repl = dif_info->ref_tag_repl; 4568 dif_seed->app_tag_repl = dif_info->app_tag_repl; 4569 dif_seed->repl_app_tag = dif_info->repl_app_tag; 4570 if (SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type) { 4571 dif_seed->atrt = dif_info->disable_app_ref_ffff; 4572 dif_seed->at = dif_info->disable_app_ffff; 4573 } 4574 dif_seed->sge_type = SLI4_SGE_TYPE_DISEED; 4575 /* Workaround for SKH (BZ157233) */ 4576 if (((io->type == OCS_HW_IO_TARGET_WRITE) || (io->type == OCS_HW_IO_INITIATOR_READ)) && 4577 (SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type) && dif_info->dif_separate) { 4578 dif_seed->sge_type = SLI4_SGE_TYPE_SKIP; 4579 } 4580 4581 dif_seed->app_tag_cmp = dif_info->app_tag_cmp; 4582 dif_seed->dif_blk_size = dif_info->blk_size; 4583 dif_seed->auto_incr_ref_tag = dif_info->auto_incr_ref_tag; 4584 dif_seed->check_app_tag = dif_info->check_app_tag; 4585 dif_seed->check_ref_tag = dif_info->check_ref_tag; 4586 dif_seed->check_crc = dif_info->check_guard; 4587 dif_seed->new_ref_tag = dif_info->repl_ref_tag; 4588 4589 switch(dif_info->dif_oper) { 4590 case OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC: 4591 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC; 4592 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC; 4593 break; 4594 case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF: 4595 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF; 4596 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF; 4597 break; 4598 case OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM: 4599 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM; 4600 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM; 4601 break; 4602 case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF: 4603 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF; 4604 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF; 4605 break; 4606 case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC: 4607 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC; 4608 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC; 4609 break; 4610 case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM: 4611 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM; 4612 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM; 4613 break; 4614 case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM: 4615 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CHKSUM; 4616 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CHKSUM; 4617 break; 4618 case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC: 4619 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CRC; 4620 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CRC; 4621 break; 4622 case OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW: 4623 dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_RAW_OUT_RAW; 4624 dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_RAW_OUT_RAW; 4625 break; 4626 default: 4627 ocs_log_err(hw->os, "unsupported DIF operation %#x\n", 4628 dif_info->dif_oper); 4629 return OCS_HW_RTN_ERROR; 4630 } 4631 4632 /* 4633 * Set last, clear previous last 4634 */ 4635 data->last = TRUE; 4636 if (io->n_sge) { 4637 data[-1].last = FALSE; 4638 } 4639 4640 io->n_sge++; 4641 4642 return OCS_HW_RTN_SUCCESS; 4643 } 4644 4645 static ocs_hw_rtn_e 4646 ocs_hw_io_overflow_sgl(ocs_hw_t *hw, ocs_hw_io_t *io) 4647 { 4648 sli4_lsp_sge_t *lsp; 4649 4650 /* fail if we're already pointing to the overflow SGL */ 4651 if (io->sgl == io->ovfl_sgl) { 4652 return OCS_HW_RTN_ERROR; 4653 } 4654 4655 /* 4656 * For skyhawk, we can use another SGL to extend the SGL list. The 4657 * Chained entry must not be in the first 4 entries. 4658 * 4659 * Note: For DIF enabled IOs, we will use the ovfl_io for the sec_hio. 4660 */ 4661 if (sli_get_sgl_preregister(&hw->sli) && 4662 io->def_sgl_count > 4 && 4663 io->ovfl_io == NULL && 4664 ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) || 4665 (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli)))) { 4666 io->ovfl_io = ocs_hw_io_alloc(hw); 4667 if (io->ovfl_io != NULL) { 4668 /* 4669 * Note: We can't call ocs_hw_io_register_sgl() here 4670 * because it checks that SGLs are not pre-registered 4671 * and for shyhawk, preregistered SGLs are required. 4672 */ 4673 io->ovfl_sgl = &io->ovfl_io->def_sgl; 4674 io->ovfl_sgl_count = io->ovfl_io->def_sgl_count; 4675 } 4676 } 4677 4678 /* fail if we don't have an overflow SGL registered */ 4679 if (io->ovfl_io == NULL || io->ovfl_sgl == NULL) { 4680 return OCS_HW_RTN_ERROR; 4681 } 4682 4683 /* 4684 * Overflow, we need to put a link SGE in the last location of the current SGL, after 4685 * copying the the last SGE to the overflow SGL 4686 */ 4687 4688 ((sli4_sge_t*)io->ovfl_sgl->virt)[0] = ((sli4_sge_t*)io->sgl->virt)[io->n_sge - 1]; 4689 4690 lsp = &((sli4_lsp_sge_t*)io->sgl->virt)[io->n_sge - 1]; 4691 ocs_memset(lsp, 0, sizeof(*lsp)); 4692 4693 if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) || 4694 (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) { 4695 sli_skh_chain_sge_build(&hw->sli, 4696 (sli4_sge_t*)lsp, 4697 io->ovfl_io->indicator, 4698 0, /* frag_num */ 4699 0); /* offset */ 4700 } else { 4701 lsp->buffer_address_high = ocs_addr32_hi(io->ovfl_sgl->phys); 4702 lsp->buffer_address_low = ocs_addr32_lo(io->ovfl_sgl->phys); 4703 lsp->sge_type = SLI4_SGE_TYPE_LSP; 4704 lsp->last = 0; 4705 io->ovfl_lsp = lsp; 4706 io->ovfl_lsp->segment_length = sizeof(sli4_sge_t); 4707 } 4708 4709 /* Update the current SGL pointer, and n_sgl */ 4710 io->sgl = io->ovfl_sgl; 4711 io->sgl_count = io->ovfl_sgl_count; 4712 io->n_sge = 1; 4713 4714 return OCS_HW_RTN_SUCCESS; 4715 } 4716 4717 /** 4718 * @ingroup io 4719 * @brief Add a scatter gather list entry to an IO. 4720 * 4721 * @param hw Hardware context. 4722 * @param io Previously-allocated HW IO object. 4723 * @param addr Physical address. 4724 * @param length Length of memory pointed to by @c addr. 4725 * 4726 * @return Returns 0 on success, or a non-zero value on failure. 4727 */ 4728 ocs_hw_rtn_e 4729 ocs_hw_io_add_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr, uint32_t length) 4730 { 4731 sli4_sge_t *data = NULL; 4732 4733 if (!hw || !io || !addr || !length) { 4734 ocs_log_err(hw ? hw->os : NULL, 4735 "bad parameter hw=%p io=%p addr=%lx length=%u\n", 4736 hw, io, addr, length); 4737 return OCS_HW_RTN_ERROR; 4738 } 4739 4740 if ((length != 0) && (io->n_sge + 1) > io->sgl_count) { 4741 if (ocs_hw_io_overflow_sgl(hw, io) != OCS_HW_RTN_SUCCESS) { 4742 ocs_log_err(hw->os, "SGL full (%d)\n", io->n_sge); 4743 return OCS_HW_RTN_ERROR; 4744 } 4745 } 4746 4747 if (length > sli_get_max_sge(&hw->sli)) { 4748 ocs_log_err(hw->os, "length of SGE %d bigger than allowed %d\n", 4749 length, sli_get_max_sge(&hw->sli)); 4750 return OCS_HW_RTN_ERROR; 4751 } 4752 4753 data = io->sgl->virt; 4754 data += io->n_sge; 4755 4756 data->sge_type = SLI4_SGE_TYPE_DATA; 4757 data->buffer_address_high = ocs_addr32_hi(addr); 4758 data->buffer_address_low = ocs_addr32_lo(addr); 4759 data->buffer_length = length; 4760 data->data_offset = io->sge_offset; 4761 /* 4762 * Always assume this is the last entry and mark as such. 4763 * If this is not the first entry unset the "last SGE" 4764 * indication for the previous entry 4765 */ 4766 data->last = TRUE; 4767 if (io->n_sge) { 4768 data[-1].last = FALSE; 4769 } 4770 4771 /* Set first_data_bde if not previously set */ 4772 if (io->first_data_sge == 0) { 4773 io->first_data_sge = io->n_sge; 4774 } 4775 4776 io->sge_offset += length; 4777 io->n_sge++; 4778 4779 /* Update the linked segment length (only executed after overflow has begun) */ 4780 if (io->ovfl_lsp != NULL) { 4781 io->ovfl_lsp->segment_length = io->n_sge * sizeof(sli4_sge_t); 4782 } 4783 4784 return OCS_HW_RTN_SUCCESS; 4785 } 4786 4787 /** 4788 * @ingroup io 4789 * @brief Add a T10 DIF scatter gather list entry to an IO. 4790 * 4791 * @param hw Hardware context. 4792 * @param io Previously-allocated HW IO object. 4793 * @param addr DIF physical address. 4794 * 4795 * @return Returns 0 on success, or a non-zero value on failure. 4796 */ 4797 ocs_hw_rtn_e 4798 ocs_hw_io_add_dif_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr) 4799 { 4800 sli4_dif_sge_t *data = NULL; 4801 4802 if (!hw || !io || !addr) { 4803 ocs_log_err(hw ? hw->os : NULL, 4804 "bad parameter hw=%p io=%p addr=%lx\n", 4805 hw, io, addr); 4806 return OCS_HW_RTN_ERROR; 4807 } 4808 4809 if ((io->n_sge + 1) > hw->config.n_sgl) { 4810 if (ocs_hw_io_overflow_sgl(hw, io) != OCS_HW_RTN_ERROR) { 4811 ocs_log_err(hw->os, "SGL full (%d)\n", io->n_sge); 4812 return OCS_HW_RTN_ERROR; 4813 } 4814 } 4815 4816 data = io->sgl->virt; 4817 data += io->n_sge; 4818 4819 data->sge_type = SLI4_SGE_TYPE_DIF; 4820 /* Workaround for SKH (BZ157233) */ 4821 if (((io->type == OCS_HW_IO_TARGET_WRITE) || (io->type == OCS_HW_IO_INITIATOR_READ)) && 4822 (SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type)) { 4823 data->sge_type = SLI4_SGE_TYPE_SKIP; 4824 } 4825 4826 data->buffer_address_high = ocs_addr32_hi(addr); 4827 data->buffer_address_low = ocs_addr32_lo(addr); 4828 4829 /* 4830 * Always assume this is the last entry and mark as such. 4831 * If this is not the first entry unset the "last SGE" 4832 * indication for the previous entry 4833 */ 4834 data->last = TRUE; 4835 if (io->n_sge) { 4836 data[-1].last = FALSE; 4837 } 4838 4839 io->n_sge++; 4840 4841 return OCS_HW_RTN_SUCCESS; 4842 } 4843 4844 /** 4845 * @ingroup io 4846 * @brief Abort a previously-started IO. 4847 * 4848 * @param hw Hardware context. 4849 * @param io_to_abort The IO to abort. 4850 * @param send_abts Boolean to have the hardware automatically 4851 * generate an ABTS. 4852 * @param cb Function call upon completion of the abort (may be NULL). 4853 * @param arg Argument to pass to abort completion function. 4854 * 4855 * @return Returns 0 on success, or a non-zero value on failure. 4856 */ 4857 ocs_hw_rtn_e 4858 ocs_hw_io_abort(ocs_hw_t *hw, ocs_hw_io_t *io_to_abort, uint32_t send_abts, void *cb, void *arg) 4859 { 4860 sli4_abort_type_e atype = SLI_ABORT_MAX; 4861 uint32_t id = 0, mask = 0; 4862 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 4863 hw_wq_callback_t *wqcb; 4864 4865 if (!hw || !io_to_abort) { 4866 ocs_log_err(hw ? hw->os : NULL, 4867 "bad parameter hw=%p io=%p\n", 4868 hw, io_to_abort); 4869 return OCS_HW_RTN_ERROR; 4870 } 4871 4872 if (hw->state != OCS_HW_STATE_ACTIVE) { 4873 ocs_log_err(hw->os, "cannot send IO abort, HW state=%d\n", 4874 hw->state); 4875 return OCS_HW_RTN_ERROR; 4876 } 4877 4878 /* take a reference on IO being aborted */ 4879 if (ocs_ref_get_unless_zero(&io_to_abort->ref) == 0) { 4880 /* command no longer active */ 4881 ocs_log_test(hw ? hw->os : NULL, 4882 "io not active xri=0x%x tag=0x%x\n", 4883 io_to_abort->indicator, io_to_abort->reqtag); 4884 return OCS_HW_RTN_IO_NOT_ACTIVE; 4885 } 4886 4887 /* non-port owned XRI checks */ 4888 /* Must have a valid WQ reference */ 4889 if (io_to_abort->wq == NULL) { 4890 ocs_log_test(hw->os, "io_to_abort xri=0x%x not active on WQ\n", 4891 io_to_abort->indicator); 4892 ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */ 4893 return OCS_HW_RTN_IO_NOT_ACTIVE; 4894 } 4895 4896 /* Validation checks complete; now check to see if already being aborted */ 4897 ocs_lock(&hw->io_abort_lock); 4898 if (io_to_abort->abort_in_progress) { 4899 ocs_unlock(&hw->io_abort_lock); 4900 ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */ 4901 ocs_log_debug(hw ? hw->os : NULL, 4902 "io already being aborted xri=0x%x tag=0x%x\n", 4903 io_to_abort->indicator, io_to_abort->reqtag); 4904 return OCS_HW_RTN_IO_ABORT_IN_PROGRESS; 4905 } 4906 4907 /* 4908 * This IO is not already being aborted. Set flag so we won't try to 4909 * abort it again. After all, we only have one abort_done callback. 4910 */ 4911 io_to_abort->abort_in_progress = 1; 4912 ocs_unlock(&hw->io_abort_lock); 4913 4914 /* 4915 * If we got here, the possibilities are: 4916 * - host owned xri 4917 * - io_to_abort->wq_index != UINT32_MAX 4918 * - submit ABORT_WQE to same WQ 4919 * - port owned xri: 4920 * - rxri: io_to_abort->wq_index == UINT32_MAX 4921 * - submit ABORT_WQE to any WQ 4922 * - non-rxri 4923 * - io_to_abort->index != UINT32_MAX 4924 * - submit ABORT_WQE to same WQ 4925 * - io_to_abort->index == UINT32_MAX 4926 * - submit ABORT_WQE to any WQ 4927 */ 4928 io_to_abort->abort_done = cb; 4929 io_to_abort->abort_arg = arg; 4930 4931 atype = SLI_ABORT_XRI; 4932 id = io_to_abort->indicator; 4933 4934 /* Allocate a request tag for the abort portion of this IO */ 4935 wqcb = ocs_hw_reqtag_alloc(hw, ocs_hw_wq_process_abort, io_to_abort); 4936 if (wqcb == NULL) { 4937 ocs_log_err(hw->os, "can't allocate request tag\n"); 4938 return OCS_HW_RTN_NO_RESOURCES; 4939 } 4940 io_to_abort->abort_reqtag = wqcb->instance_index; 4941 4942 /* 4943 * If the wqe is on the pending list, then set this wqe to be 4944 * aborted when the IO's wqe is removed from the list. 4945 */ 4946 if (io_to_abort->wq != NULL) { 4947 sli_queue_lock(io_to_abort->wq->queue); 4948 if (ocs_list_on_list(&io_to_abort->wqe.link)) { 4949 io_to_abort->wqe.abort_wqe_submit_needed = 1; 4950 io_to_abort->wqe.send_abts = send_abts; 4951 io_to_abort->wqe.id = id; 4952 io_to_abort->wqe.abort_reqtag = io_to_abort->abort_reqtag; 4953 sli_queue_unlock(io_to_abort->wq->queue); 4954 return 0; 4955 } 4956 sli_queue_unlock(io_to_abort->wq->queue); 4957 } 4958 4959 if (sli_abort_wqe(&hw->sli, io_to_abort->wqe.wqebuf, hw->sli.config.wqe_size, atype, send_abts, id, mask, 4960 io_to_abort->abort_reqtag, SLI4_CQ_DEFAULT)) { 4961 ocs_log_err(hw->os, "ABORT WQE error\n"); 4962 io_to_abort->abort_reqtag = UINT32_MAX; 4963 ocs_hw_reqtag_free(hw, wqcb); 4964 rc = OCS_HW_RTN_ERROR; 4965 } 4966 4967 if (OCS_HW_RTN_SUCCESS == rc) { 4968 if (io_to_abort->wq == NULL) { 4969 io_to_abort->wq = ocs_hw_queue_next_wq(hw, io_to_abort); 4970 ocs_hw_assert(io_to_abort->wq != NULL); 4971 } 4972 /* ABORT_WQE does not actually utilize an XRI on the Port, 4973 * therefore, keep xbusy as-is to track the exchange's state, 4974 * not the ABORT_WQE's state 4975 */ 4976 rc = hw_wq_write(io_to_abort->wq, &io_to_abort->wqe); 4977 if (rc > 0) { 4978 /* non-negative return is success */ 4979 rc = 0; 4980 /* can't abort an abort so skip adding to timed wqe list */ 4981 } 4982 } 4983 4984 if (OCS_HW_RTN_SUCCESS != rc) { 4985 ocs_lock(&hw->io_abort_lock); 4986 io_to_abort->abort_in_progress = 0; 4987 ocs_unlock(&hw->io_abort_lock); 4988 ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */ 4989 } 4990 return rc; 4991 } 4992 4993 /** 4994 * @ingroup io 4995 * @brief Return the OX_ID/RX_ID of the IO. 4996 * 4997 * @param hw Hardware context. 4998 * @param io HW IO object. 4999 * 5000 * @return Returns X_ID on success, or -1 on failure. 5001 */ 5002 int32_t 5003 ocs_hw_io_get_xid(ocs_hw_t *hw, ocs_hw_io_t *io) 5004 { 5005 if (!hw || !io) { 5006 ocs_log_err(hw ? hw->os : NULL, 5007 "bad parameter hw=%p io=%p\n", hw, io); 5008 return -1; 5009 } 5010 5011 return io->indicator; 5012 } 5013 5014 typedef struct ocs_hw_fw_write_cb_arg { 5015 ocs_hw_fw_cb_t cb; 5016 void *arg; 5017 } ocs_hw_fw_write_cb_arg_t; 5018 5019 typedef struct ocs_hw_sfp_cb_arg { 5020 ocs_hw_sfp_cb_t cb; 5021 void *arg; 5022 ocs_dma_t payload; 5023 } ocs_hw_sfp_cb_arg_t; 5024 5025 typedef struct ocs_hw_temp_cb_arg { 5026 ocs_hw_temp_cb_t cb; 5027 void *arg; 5028 } ocs_hw_temp_cb_arg_t; 5029 5030 typedef struct ocs_hw_link_stat_cb_arg { 5031 ocs_hw_link_stat_cb_t cb; 5032 void *arg; 5033 } ocs_hw_link_stat_cb_arg_t; 5034 5035 typedef struct ocs_hw_host_stat_cb_arg { 5036 ocs_hw_host_stat_cb_t cb; 5037 void *arg; 5038 } ocs_hw_host_stat_cb_arg_t; 5039 5040 typedef struct ocs_hw_dump_get_cb_arg { 5041 ocs_hw_dump_get_cb_t cb; 5042 void *arg; 5043 void *mbox_cmd; 5044 } ocs_hw_dump_get_cb_arg_t; 5045 5046 typedef struct ocs_hw_dump_clear_cb_arg { 5047 ocs_hw_dump_clear_cb_t cb; 5048 void *arg; 5049 void *mbox_cmd; 5050 } ocs_hw_dump_clear_cb_arg_t; 5051 5052 /** 5053 * @brief Write a portion of a firmware image to the device. 5054 * 5055 * @par Description 5056 * Calls the correct firmware write function based on the device type. 5057 * 5058 * @param hw Hardware context. 5059 * @param dma DMA structure containing the firmware image chunk. 5060 * @param size Size of the firmware image chunk. 5061 * @param offset Offset, in bytes, from the beginning of the firmware image. 5062 * @param last True if this is the last chunk of the image. 5063 * Causes the image to be committed to flash. 5064 * @param cb Pointer to a callback function that is called when the command completes. 5065 * The callback function prototype is 5066 * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>. 5067 * @param arg Pointer to be passed to the callback function. 5068 * 5069 * @return Returns 0 on success, or a non-zero value on failure. 5070 */ 5071 ocs_hw_rtn_e 5072 ocs_hw_firmware_write(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg) 5073 { 5074 if (hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) { 5075 return ocs_hw_firmware_write_lancer(hw, dma, size, offset, last, cb, arg); 5076 } else { 5077 /* Write firmware_write for BE3/Skyhawk not supported */ 5078 return -1; 5079 } 5080 } 5081 5082 /** 5083 * @brief Write a portion of a firmware image to the Emulex XE201 ASIC (Lancer). 5084 * 5085 * @par Description 5086 * Creates a SLI_CONFIG mailbox command, fills it with the correct values to write a 5087 * firmware image chunk, and then sends the command with ocs_hw_command(). On completion, 5088 * the callback function ocs_hw_fw_write_cb() gets called to free the mailbox 5089 * and to signal the caller that the write has completed. 5090 * 5091 * @param hw Hardware context. 5092 * @param dma DMA structure containing the firmware image chunk. 5093 * @param size Size of the firmware image chunk. 5094 * @param offset Offset, in bytes, from the beginning of the firmware image. 5095 * @param last True if this is the last chunk of the image. Causes the image to be committed to flash. 5096 * @param cb Pointer to a callback function that is called when the command completes. 5097 * The callback function prototype is 5098 * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>. 5099 * @param arg Pointer to be passed to the callback function. 5100 * 5101 * @return Returns 0 on success, or a non-zero value on failure. 5102 */ 5103 ocs_hw_rtn_e 5104 ocs_hw_firmware_write_lancer(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg) 5105 { 5106 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 5107 uint8_t *mbxdata; 5108 ocs_hw_fw_write_cb_arg_t *cb_arg; 5109 int noc=0; /* No Commit bit - set to 1 for testing */ 5110 5111 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 5112 ocs_log_test(hw->os, "Function only supported for I/F type 2\n"); 5113 return OCS_HW_RTN_ERROR; 5114 } 5115 5116 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 5117 if (mbxdata == NULL) { 5118 ocs_log_err(hw->os, "failed to malloc mbox\n"); 5119 return OCS_HW_RTN_NO_MEMORY; 5120 } 5121 5122 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_fw_write_cb_arg_t), OCS_M_NOWAIT); 5123 if (cb_arg == NULL) { 5124 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 5125 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5126 return OCS_HW_RTN_NO_MEMORY; 5127 } 5128 5129 cb_arg->cb = cb; 5130 cb_arg->arg = arg; 5131 5132 if (sli_cmd_common_write_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE, noc, last, 5133 size, offset, "/prg/", dma)) { 5134 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_fw_write, cb_arg); 5135 } 5136 5137 if (rc != OCS_HW_RTN_SUCCESS) { 5138 ocs_log_test(hw->os, "COMMON_WRITE_OBJECT failed\n"); 5139 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5140 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t)); 5141 } 5142 5143 return rc; 5144 5145 } 5146 5147 /** 5148 * @brief Called when the WRITE OBJECT command completes. 5149 * 5150 * @par Description 5151 * Get the number of bytes actually written out of the response, free the mailbox 5152 * that was malloc'd by ocs_hw_firmware_write(), 5153 * then call the callback and pass the status and bytes written. 5154 * 5155 * @param hw Hardware context. 5156 * @param status Status field from the mbox completion. 5157 * @param mqe Mailbox response structure. 5158 * @param arg Pointer to a callback function that signals the caller that the command is done. 5159 * The callback function prototype is <tt>void cb(int32_t status, uint32_t bytes_written)</tt>. 5160 * 5161 * @return Returns 0. 5162 */ 5163 static int32_t 5164 ocs_hw_cb_fw_write(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5165 { 5166 5167 sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe; 5168 sli4_res_common_write_object_t* wr_obj_rsp = (sli4_res_common_write_object_t*) &(mbox_rsp->payload.embed); 5169 ocs_hw_fw_write_cb_arg_t *cb_arg = arg; 5170 uint32_t bytes_written; 5171 uint16_t mbox_status; 5172 uint32_t change_status; 5173 5174 bytes_written = wr_obj_rsp->actual_write_length; 5175 mbox_status = mbox_rsp->hdr.status; 5176 change_status = wr_obj_rsp->change_status; 5177 5178 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 5179 5180 if (cb_arg) { 5181 if (cb_arg->cb) { 5182 if ((status == 0) && mbox_status) { 5183 status = mbox_status; 5184 } 5185 cb_arg->cb(status, bytes_written, change_status, cb_arg->arg); 5186 } 5187 5188 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t)); 5189 } 5190 5191 return 0; 5192 5193 } 5194 5195 /** 5196 * @brief Called when the READ_TRANSCEIVER_DATA command completes. 5197 * 5198 * @par Description 5199 * Get the number of bytes read out of the response, free the mailbox that was malloc'd 5200 * by ocs_hw_get_sfp(), then call the callback and pass the status and bytes written. 5201 * 5202 * @param hw Hardware context. 5203 * @param status Status field from the mbox completion. 5204 * @param mqe Mailbox response structure. 5205 * @param arg Pointer to a callback function that signals the caller that the command is done. 5206 * The callback function prototype is 5207 * <tt>void cb(int32_t status, uint32_t bytes_written, uint32_t *data, void *arg)</tt>. 5208 * 5209 * @return Returns 0. 5210 */ 5211 static int32_t 5212 ocs_hw_cb_sfp(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5213 { 5214 5215 ocs_hw_sfp_cb_arg_t *cb_arg = arg; 5216 ocs_dma_t *payload = NULL; 5217 sli4_res_common_read_transceiver_data_t* mbox_rsp = NULL; 5218 uint32_t bytes_written; 5219 5220 if (cb_arg) { 5221 payload = &(cb_arg->payload); 5222 if (cb_arg->cb) { 5223 mbox_rsp = (sli4_res_common_read_transceiver_data_t*) payload->virt; 5224 bytes_written = mbox_rsp->hdr.response_length; 5225 if ((status == 0) && mbox_rsp->hdr.status) { 5226 status = mbox_rsp->hdr.status; 5227 } 5228 cb_arg->cb(hw->os, status, bytes_written, mbox_rsp->page_data, cb_arg->arg); 5229 } 5230 5231 ocs_dma_free(hw->os, &cb_arg->payload); 5232 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t)); 5233 } 5234 5235 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 5236 return 0; 5237 } 5238 5239 /** 5240 * @ingroup io 5241 * @brief Function to retrieve the SFP information. 5242 * 5243 * @param hw Hardware context. 5244 * @param page The page of SFP data to retrieve (0xa0 or 0xa2). 5245 * @param cb Function call upon completion of sending the data (may be NULL). 5246 * @param arg Argument to pass to IO completion function. 5247 * 5248 * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY. 5249 */ 5250 ocs_hw_rtn_e 5251 ocs_hw_get_sfp(ocs_hw_t *hw, uint16_t page, ocs_hw_sfp_cb_t cb, void *arg) 5252 { 5253 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 5254 ocs_hw_sfp_cb_arg_t *cb_arg; 5255 uint8_t *mbxdata; 5256 5257 /* mbxdata holds the header of the command */ 5258 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 5259 if (mbxdata == NULL) { 5260 ocs_log_err(hw->os, "failed to malloc mbox\n"); 5261 return OCS_HW_RTN_NO_MEMORY; 5262 } 5263 5264 /* cb_arg holds the data that will be passed to the callback on completion */ 5265 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_sfp_cb_arg_t), OCS_M_NOWAIT); 5266 if (cb_arg == NULL) { 5267 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 5268 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5269 return OCS_HW_RTN_NO_MEMORY; 5270 } 5271 5272 cb_arg->cb = cb; 5273 cb_arg->arg = arg; 5274 5275 /* payload holds the non-embedded portion */ 5276 if (ocs_dma_alloc(hw->os, &cb_arg->payload, sizeof(sli4_res_common_read_transceiver_data_t), 5277 OCS_MIN_DMA_ALIGNMENT)) { 5278 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 5279 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t)); 5280 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5281 return OCS_HW_RTN_NO_MEMORY; 5282 } 5283 5284 /* Send the HW command */ 5285 if (sli_cmd_common_read_transceiver_data(&hw->sli, mbxdata, SLI4_BMBX_SIZE, page, 5286 &cb_arg->payload)) { 5287 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_sfp, cb_arg); 5288 } 5289 5290 if (rc != OCS_HW_RTN_SUCCESS) { 5291 ocs_log_test(hw->os, "READ_TRANSCEIVER_DATA failed with status %d\n", 5292 rc); 5293 ocs_dma_free(hw->os, &cb_arg->payload); 5294 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t)); 5295 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5296 } 5297 5298 return rc; 5299 } 5300 5301 /** 5302 * @brief Function to retrieve the temperature information. 5303 * 5304 * @param hw Hardware context. 5305 * @param cb Function call upon completion of sending the data (may be NULL). 5306 * @param arg Argument to pass to IO completion function. 5307 * 5308 * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY. 5309 */ 5310 ocs_hw_rtn_e 5311 ocs_hw_get_temperature(ocs_hw_t *hw, ocs_hw_temp_cb_t cb, void *arg) 5312 { 5313 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 5314 ocs_hw_temp_cb_arg_t *cb_arg; 5315 uint8_t *mbxdata; 5316 5317 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 5318 if (mbxdata == NULL) { 5319 ocs_log_err(hw->os, "failed to malloc mbox"); 5320 return OCS_HW_RTN_NO_MEMORY; 5321 } 5322 5323 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_temp_cb_arg_t), OCS_M_NOWAIT); 5324 if (cb_arg == NULL) { 5325 ocs_log_err(hw->os, "failed to malloc cb_arg"); 5326 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5327 return OCS_HW_RTN_NO_MEMORY; 5328 } 5329 5330 cb_arg->cb = cb; 5331 cb_arg->arg = arg; 5332 5333 if (sli_cmd_dump_type4(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 5334 SLI4_WKI_TAG_SAT_TEM)) { 5335 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_temp, cb_arg); 5336 } 5337 5338 if (rc != OCS_HW_RTN_SUCCESS) { 5339 ocs_log_test(hw->os, "DUMP_TYPE4 failed\n"); 5340 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5341 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_temp_cb_arg_t)); 5342 } 5343 5344 return rc; 5345 } 5346 5347 /** 5348 * @brief Called when the DUMP command completes. 5349 * 5350 * @par Description 5351 * Get the temperature data out of the response, free the mailbox that was malloc'd 5352 * by ocs_hw_get_temperature(), then call the callback and pass the status and data. 5353 * 5354 * @param hw Hardware context. 5355 * @param status Status field from the mbox completion. 5356 * @param mqe Mailbox response structure. 5357 * @param arg Pointer to a callback function that signals the caller that the command is done. 5358 * The callback function prototype is defined by ocs_hw_temp_cb_t. 5359 * 5360 * @return Returns 0. 5361 */ 5362 static int32_t 5363 ocs_hw_cb_temp(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5364 { 5365 5366 sli4_cmd_dump4_t* mbox_rsp = (sli4_cmd_dump4_t*) mqe; 5367 ocs_hw_temp_cb_arg_t *cb_arg = arg; 5368 uint32_t curr_temp = mbox_rsp->resp_data[0]; /* word 5 */ 5369 uint32_t crit_temp_thrshld = mbox_rsp->resp_data[1]; /* word 6*/ 5370 uint32_t warn_temp_thrshld = mbox_rsp->resp_data[2]; /* word 7 */ 5371 uint32_t norm_temp_thrshld = mbox_rsp->resp_data[3]; /* word 8 */ 5372 uint32_t fan_off_thrshld = mbox_rsp->resp_data[4]; /* word 9 */ 5373 uint32_t fan_on_thrshld = mbox_rsp->resp_data[5]; /* word 10 */ 5374 5375 if (cb_arg) { 5376 if (cb_arg->cb) { 5377 if ((status == 0) && mbox_rsp->hdr.status) { 5378 status = mbox_rsp->hdr.status; 5379 } 5380 cb_arg->cb(status, 5381 curr_temp, 5382 crit_temp_thrshld, 5383 warn_temp_thrshld, 5384 norm_temp_thrshld, 5385 fan_off_thrshld, 5386 fan_on_thrshld, 5387 cb_arg->arg); 5388 } 5389 5390 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_temp_cb_arg_t)); 5391 } 5392 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 5393 5394 return 0; 5395 } 5396 5397 /** 5398 * @brief Function to retrieve the link statistics. 5399 * 5400 * @param hw Hardware context. 5401 * @param req_ext_counters If TRUE, then the extended counters will be requested. 5402 * @param clear_overflow_flags If TRUE, then overflow flags will be cleared. 5403 * @param clear_all_counters If TRUE, the counters will be cleared. 5404 * @param cb Function call upon completion of sending the data (may be NULL). 5405 * @param arg Argument to pass to IO completion function. 5406 * 5407 * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY. 5408 */ 5409 ocs_hw_rtn_e 5410 ocs_hw_get_link_stats(ocs_hw_t *hw, 5411 uint8_t req_ext_counters, 5412 uint8_t clear_overflow_flags, 5413 uint8_t clear_all_counters, 5414 ocs_hw_link_stat_cb_t cb, 5415 void *arg) 5416 { 5417 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 5418 ocs_hw_link_stat_cb_arg_t *cb_arg; 5419 uint8_t *mbxdata; 5420 5421 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 5422 if (mbxdata == NULL) { 5423 ocs_log_err(hw->os, "failed to malloc mbox"); 5424 return OCS_HW_RTN_NO_MEMORY; 5425 } 5426 5427 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_link_stat_cb_arg_t), OCS_M_NOWAIT); 5428 if (cb_arg == NULL) { 5429 ocs_log_err(hw->os, "failed to malloc cb_arg"); 5430 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5431 return OCS_HW_RTN_NO_MEMORY; 5432 } 5433 5434 cb_arg->cb = cb; 5435 cb_arg->arg = arg; 5436 5437 if (sli_cmd_read_link_stats(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 5438 req_ext_counters, 5439 clear_overflow_flags, 5440 clear_all_counters)) { 5441 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_link_stat, cb_arg); 5442 } 5443 5444 if (rc != OCS_HW_RTN_SUCCESS) { 5445 ocs_log_test(hw->os, "READ_LINK_STATS failed\n"); 5446 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5447 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_link_stat_cb_arg_t)); 5448 } 5449 5450 return rc; 5451 } 5452 5453 /** 5454 * @brief Called when the READ_LINK_STAT command completes. 5455 * 5456 * @par Description 5457 * Get the counters out of the response, free the mailbox that was malloc'd 5458 * by ocs_hw_get_link_stats(), then call the callback and pass the status and data. 5459 * 5460 * @param hw Hardware context. 5461 * @param status Status field from the mbox completion. 5462 * @param mqe Mailbox response structure. 5463 * @param arg Pointer to a callback function that signals the caller that the command is done. 5464 * The callback function prototype is defined by ocs_hw_link_stat_cb_t. 5465 * 5466 * @return Returns 0. 5467 */ 5468 static int32_t 5469 ocs_hw_cb_link_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5470 { 5471 5472 sli4_cmd_read_link_stats_t* mbox_rsp = (sli4_cmd_read_link_stats_t*) mqe; 5473 ocs_hw_link_stat_cb_arg_t *cb_arg = arg; 5474 ocs_hw_link_stat_counts_t counts[OCS_HW_LINK_STAT_MAX]; 5475 uint32_t num_counters = (mbox_rsp->gec ? 20 : 13); 5476 5477 ocs_memset(counts, 0, sizeof(ocs_hw_link_stat_counts_t) * 5478 OCS_HW_LINK_STAT_MAX); 5479 5480 counts[OCS_HW_LINK_STAT_LINK_FAILURE_COUNT].overflow = mbox_rsp->w02of; 5481 counts[OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].overflow = mbox_rsp->w03of; 5482 counts[OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT].overflow = mbox_rsp->w04of; 5483 counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].overflow = mbox_rsp->w05of; 5484 counts[OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].overflow = mbox_rsp->w06of; 5485 counts[OCS_HW_LINK_STAT_CRC_COUNT].overflow = mbox_rsp->w07of; 5486 counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT].overflow = mbox_rsp->w08of; 5487 counts[OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT].overflow = mbox_rsp->w09of; 5488 counts[OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT].overflow = mbox_rsp->w10of; 5489 counts[OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT].overflow = mbox_rsp->w11of; 5490 counts[OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT].overflow = mbox_rsp->w12of; 5491 counts[OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT].overflow = mbox_rsp->w13of; 5492 counts[OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT].overflow = mbox_rsp->w14of; 5493 counts[OCS_HW_LINK_STAT_RCV_EOFA_COUNT].overflow = mbox_rsp->w15of; 5494 counts[OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT].overflow = mbox_rsp->w16of; 5495 counts[OCS_HW_LINK_STAT_RCV_EOFNI_COUNT].overflow = mbox_rsp->w17of; 5496 counts[OCS_HW_LINK_STAT_RCV_SOFF_COUNT].overflow = mbox_rsp->w18of; 5497 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT].overflow = mbox_rsp->w19of; 5498 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT].overflow = mbox_rsp->w20of; 5499 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT].overflow = mbox_rsp->w21of; 5500 5501 counts[OCS_HW_LINK_STAT_LINK_FAILURE_COUNT].counter = mbox_rsp->link_failure_error_count; 5502 counts[OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].counter = mbox_rsp->loss_of_sync_error_count; 5503 counts[OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT].counter = mbox_rsp->loss_of_signal_error_count; 5504 counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].counter = mbox_rsp->primitive_sequence_error_count; 5505 counts[OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].counter = mbox_rsp->invalid_transmission_word_error_count; 5506 counts[OCS_HW_LINK_STAT_CRC_COUNT].counter = mbox_rsp->crc_error_count; 5507 counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT].counter = mbox_rsp->primitive_sequence_event_timeout_count; 5508 counts[OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT].counter = mbox_rsp->elastic_buffer_overrun_error_count; 5509 counts[OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT].counter = mbox_rsp->arbitration_fc_al_timout_count; 5510 counts[OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT].counter = mbox_rsp->advertised_receive_bufftor_to_buffer_credit; 5511 counts[OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT].counter = mbox_rsp->current_receive_buffer_to_buffer_credit; 5512 counts[OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT].counter = mbox_rsp->advertised_transmit_buffer_to_buffer_credit; 5513 counts[OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT].counter = mbox_rsp->current_transmit_buffer_to_buffer_credit; 5514 counts[OCS_HW_LINK_STAT_RCV_EOFA_COUNT].counter = mbox_rsp->received_eofa_count; 5515 counts[OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT].counter = mbox_rsp->received_eofdti_count; 5516 counts[OCS_HW_LINK_STAT_RCV_EOFNI_COUNT].counter = mbox_rsp->received_eofni_count; 5517 counts[OCS_HW_LINK_STAT_RCV_SOFF_COUNT].counter = mbox_rsp->received_soff_count; 5518 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT].counter = mbox_rsp->received_dropped_no_aer_count; 5519 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT].counter = mbox_rsp->received_dropped_no_available_rpi_resources_count; 5520 counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT].counter = mbox_rsp->received_dropped_no_available_xri_resources_count; 5521 5522 if (cb_arg) { 5523 if (cb_arg->cb) { 5524 if ((status == 0) && mbox_rsp->hdr.status) { 5525 status = mbox_rsp->hdr.status; 5526 } 5527 cb_arg->cb(status, 5528 num_counters, 5529 counts, 5530 cb_arg->arg); 5531 } 5532 5533 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_link_stat_cb_arg_t)); 5534 } 5535 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 5536 5537 return 0; 5538 } 5539 5540 /** 5541 * @brief Function to retrieve the link and host statistics. 5542 * 5543 * @param hw Hardware context. 5544 * @param cc clear counters, if TRUE all counters will be cleared. 5545 * @param cb Function call upon completion of receiving the data. 5546 * @param arg Argument to pass to pointer fc hosts statistics structure. 5547 * 5548 * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY. 5549 */ 5550 ocs_hw_rtn_e 5551 ocs_hw_get_host_stats(ocs_hw_t *hw, uint8_t cc, ocs_hw_host_stat_cb_t cb, void *arg) 5552 { 5553 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 5554 ocs_hw_host_stat_cb_arg_t *cb_arg; 5555 uint8_t *mbxdata; 5556 5557 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO); 5558 if (mbxdata == NULL) { 5559 ocs_log_err(hw->os, "failed to malloc mbox"); 5560 return OCS_HW_RTN_NO_MEMORY; 5561 } 5562 5563 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_host_stat_cb_arg_t), 0); 5564 if (cb_arg == NULL) { 5565 ocs_log_err(hw->os, "failed to malloc cb_arg"); 5566 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5567 return OCS_HW_RTN_NO_MEMORY; 5568 } 5569 5570 cb_arg->cb = cb; 5571 cb_arg->arg = arg; 5572 5573 /* Send the HW command to get the host stats */ 5574 if (sli_cmd_read_status(&hw->sli, mbxdata, SLI4_BMBX_SIZE, cc)) { 5575 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_host_stat, cb_arg); 5576 } 5577 5578 if (rc != OCS_HW_RTN_SUCCESS) { 5579 ocs_log_test(hw->os, "READ_HOST_STATS failed\n"); 5580 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5581 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_host_stat_cb_arg_t)); 5582 } 5583 5584 return rc; 5585 } 5586 5587 /** 5588 * @brief Called when the READ_STATUS command completes. 5589 * 5590 * @par Description 5591 * Get the counters out of the response, free the mailbox that was malloc'd 5592 * by ocs_hw_get_host_stats(), then call the callback and pass 5593 * the status and data. 5594 * 5595 * @param hw Hardware context. 5596 * @param status Status field from the mbox completion. 5597 * @param mqe Mailbox response structure. 5598 * @param arg Pointer to a callback function that signals the caller that the command is done. 5599 * The callback function prototype is defined by 5600 * ocs_hw_host_stat_cb_t. 5601 * 5602 * @return Returns 0. 5603 */ 5604 static int32_t 5605 ocs_hw_cb_host_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5606 { 5607 5608 sli4_cmd_read_status_t* mbox_rsp = (sli4_cmd_read_status_t*) mqe; 5609 ocs_hw_host_stat_cb_arg_t *cb_arg = arg; 5610 ocs_hw_host_stat_counts_t counts[OCS_HW_HOST_STAT_MAX]; 5611 uint32_t num_counters = OCS_HW_HOST_STAT_MAX; 5612 5613 ocs_memset(counts, 0, sizeof(ocs_hw_host_stat_counts_t) * 5614 OCS_HW_HOST_STAT_MAX); 5615 5616 counts[OCS_HW_HOST_STAT_TX_KBYTE_COUNT].counter = mbox_rsp->transmit_kbyte_count; 5617 counts[OCS_HW_HOST_STAT_RX_KBYTE_COUNT].counter = mbox_rsp->receive_kbyte_count; 5618 counts[OCS_HW_HOST_STAT_TX_FRAME_COUNT].counter = mbox_rsp->transmit_frame_count; 5619 counts[OCS_HW_HOST_STAT_RX_FRAME_COUNT].counter = mbox_rsp->receive_frame_count; 5620 counts[OCS_HW_HOST_STAT_TX_SEQ_COUNT].counter = mbox_rsp->transmit_sequence_count; 5621 counts[OCS_HW_HOST_STAT_RX_SEQ_COUNT].counter = mbox_rsp->receive_sequence_count; 5622 counts[OCS_HW_HOST_STAT_TOTAL_EXCH_ORIG].counter = mbox_rsp->total_exchanges_originator; 5623 counts[OCS_HW_HOST_STAT_TOTAL_EXCH_RESP].counter = mbox_rsp->total_exchanges_responder; 5624 counts[OCS_HW_HOSY_STAT_RX_P_BSY_COUNT].counter = mbox_rsp->receive_p_bsy_count; 5625 counts[OCS_HW_HOST_STAT_RX_F_BSY_COUNT].counter = mbox_rsp->receive_f_bsy_count; 5626 counts[OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT].counter = mbox_rsp->dropped_frames_due_to_no_rq_buffer_count; 5627 counts[OCS_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT].counter = mbox_rsp->empty_rq_timeout_count; 5628 counts[OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT].counter = mbox_rsp->dropped_frames_due_to_no_xri_count; 5629 counts[OCS_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT].counter = mbox_rsp->empty_xri_pool_count; 5630 5631 if (cb_arg) { 5632 if (cb_arg->cb) { 5633 if ((status == 0) && mbox_rsp->hdr.status) { 5634 status = mbox_rsp->hdr.status; 5635 } 5636 cb_arg->cb(status, 5637 num_counters, 5638 counts, 5639 cb_arg->arg); 5640 } 5641 5642 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_host_stat_cb_arg_t)); 5643 } 5644 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 5645 5646 return 0; 5647 } 5648 5649 /** 5650 * @brief HW link configuration enum to the CLP string value mapping. 5651 * 5652 * This structure provides a mapping from the ocs_hw_linkcfg_e 5653 * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port 5654 * control) to the CLP string that is used 5655 * in the DMTF_CLP_CMD mailbox command. 5656 */ 5657 typedef struct ocs_hw_linkcfg_map_s { 5658 ocs_hw_linkcfg_e linkcfg; 5659 const char *clp_str; 5660 } ocs_hw_linkcfg_map_t; 5661 5662 /** 5663 * @brief Mapping from the HW linkcfg enum to the CLP command value 5664 * string. 5665 */ 5666 static ocs_hw_linkcfg_map_t linkcfg_map[] = { 5667 {OCS_HW_LINKCFG_4X10G, "ELX_4x10G"}, 5668 {OCS_HW_LINKCFG_1X40G, "ELX_1x40G"}, 5669 {OCS_HW_LINKCFG_2X16G, "ELX_2x16G"}, 5670 {OCS_HW_LINKCFG_4X8G, "ELX_4x8G"}, 5671 {OCS_HW_LINKCFG_4X1G, "ELX_4x1G"}, 5672 {OCS_HW_LINKCFG_2X10G, "ELX_2x10G"}, 5673 {OCS_HW_LINKCFG_2X10G_2X8G, "ELX_2x10G_2x8G"}}; 5674 5675 /** 5676 * @brief HW link configuration enum to Skyhawk link config ID mapping. 5677 * 5678 * This structure provides a mapping from the ocs_hw_linkcfg_e 5679 * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port 5680 * control) to the link config ID numbers used by Skyhawk 5681 */ 5682 typedef struct ocs_hw_skyhawk_linkcfg_map_s { 5683 ocs_hw_linkcfg_e linkcfg; 5684 uint32_t config_id; 5685 } ocs_hw_skyhawk_linkcfg_map_t; 5686 5687 /** 5688 * @brief Mapping from the HW linkcfg enum to the Skyhawk link config IDs 5689 */ 5690 static ocs_hw_skyhawk_linkcfg_map_t skyhawk_linkcfg_map[] = { 5691 {OCS_HW_LINKCFG_4X10G, 0x0a}, 5692 {OCS_HW_LINKCFG_1X40G, 0x09}, 5693 }; 5694 5695 /** 5696 * @brief Helper function for getting the HW linkcfg enum from the CLP 5697 * string value 5698 * 5699 * @param clp_str CLP string value from OEMELX_LinkConfig. 5700 * 5701 * @return Returns the HW linkcfg enum corresponding to clp_str. 5702 */ 5703 static ocs_hw_linkcfg_e 5704 ocs_hw_linkcfg_from_clp(const char *clp_str) 5705 { 5706 uint32_t i; 5707 for (i = 0; i < ARRAY_SIZE(linkcfg_map); i++) { 5708 if (ocs_strncmp(linkcfg_map[i].clp_str, clp_str, ocs_strlen(clp_str)) == 0) { 5709 return linkcfg_map[i].linkcfg; 5710 } 5711 } 5712 return OCS_HW_LINKCFG_NA; 5713 } 5714 5715 /** 5716 * @brief Helper function for getting the CLP string value from the HW 5717 * linkcfg enum. 5718 * 5719 * @param linkcfg HW linkcfg enum. 5720 * 5721 * @return Returns the OEMELX_LinkConfig CLP string value corresponding to 5722 * given linkcfg. 5723 */ 5724 static const char * 5725 ocs_hw_clp_from_linkcfg(ocs_hw_linkcfg_e linkcfg) 5726 { 5727 uint32_t i; 5728 for (i = 0; i < ARRAY_SIZE(linkcfg_map); i++) { 5729 if (linkcfg_map[i].linkcfg == linkcfg) { 5730 return linkcfg_map[i].clp_str; 5731 } 5732 } 5733 return NULL; 5734 } 5735 5736 /** 5737 * @brief Helper function for getting a Skyhawk link config ID from the HW 5738 * linkcfg enum. 5739 * 5740 * @param linkcfg HW linkcfg enum. 5741 * 5742 * @return Returns the Skyhawk link config ID corresponding to 5743 * given linkcfg. 5744 */ 5745 static uint32_t 5746 ocs_hw_config_id_from_linkcfg(ocs_hw_linkcfg_e linkcfg) 5747 { 5748 uint32_t i; 5749 for (i = 0; i < ARRAY_SIZE(skyhawk_linkcfg_map); i++) { 5750 if (skyhawk_linkcfg_map[i].linkcfg == linkcfg) { 5751 return skyhawk_linkcfg_map[i].config_id; 5752 } 5753 } 5754 return 0; 5755 } 5756 5757 /** 5758 * @brief Helper function for getting the HW linkcfg enum from a 5759 * Skyhawk config ID. 5760 * 5761 * @param config_id Skyhawk link config ID. 5762 * 5763 * @return Returns the HW linkcfg enum corresponding to config_id. 5764 */ 5765 static ocs_hw_linkcfg_e 5766 ocs_hw_linkcfg_from_config_id(const uint32_t config_id) 5767 { 5768 uint32_t i; 5769 for (i = 0; i < ARRAY_SIZE(skyhawk_linkcfg_map); i++) { 5770 if (skyhawk_linkcfg_map[i].config_id == config_id) { 5771 return skyhawk_linkcfg_map[i].linkcfg; 5772 } 5773 } 5774 return OCS_HW_LINKCFG_NA; 5775 } 5776 5777 /** 5778 * @brief Link configuration callback argument. 5779 */ 5780 typedef struct ocs_hw_linkcfg_cb_arg_s { 5781 ocs_hw_port_control_cb_t cb; 5782 void *arg; 5783 uint32_t opts; 5784 int32_t status; 5785 ocs_dma_t dma_cmd; 5786 ocs_dma_t dma_resp; 5787 uint32_t result_len; 5788 } ocs_hw_linkcfg_cb_arg_t; 5789 5790 /** 5791 * @brief Set link configuration. 5792 * 5793 * @param hw Hardware context. 5794 * @param value Link configuration enum to which the link configuration is 5795 * set. 5796 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 5797 * @param cb Callback function to invoke following mbx command. 5798 * @param arg Callback argument. 5799 * 5800 * @return Returns OCS_HW_RTN_SUCCESS on success. 5801 */ 5802 static ocs_hw_rtn_e 5803 ocs_hw_set_linkcfg(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 5804 { 5805 if (!sli_link_is_configurable(&hw->sli)) { 5806 ocs_log_debug(hw->os, "Function not supported\n"); 5807 return OCS_HW_RTN_ERROR; 5808 } 5809 5810 if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) { 5811 return ocs_hw_set_linkcfg_lancer(hw, value, opts, cb, arg); 5812 } else if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) || 5813 (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) { 5814 return ocs_hw_set_linkcfg_skyhawk(hw, value, opts, cb, arg); 5815 } else { 5816 ocs_log_test(hw->os, "Function not supported for this IF_TYPE\n"); 5817 return OCS_HW_RTN_ERROR; 5818 } 5819 } 5820 5821 /** 5822 * @brief Set link configuration for Lancer 5823 * 5824 * @param hw Hardware context. 5825 * @param value Link configuration enum to which the link configuration is 5826 * set. 5827 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 5828 * @param cb Callback function to invoke following mbx command. 5829 * @param arg Callback argument. 5830 * 5831 * @return Returns OCS_HW_RTN_SUCCESS on success. 5832 */ 5833 static ocs_hw_rtn_e 5834 ocs_hw_set_linkcfg_lancer(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 5835 { 5836 char cmd[OCS_HW_DMTF_CLP_CMD_MAX]; 5837 ocs_hw_linkcfg_cb_arg_t *cb_arg; 5838 const char *value_str = NULL; 5839 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 5840 5841 /* translate ocs_hw_linkcfg_e to CLP string */ 5842 value_str = ocs_hw_clp_from_linkcfg(value); 5843 5844 /* allocate memory for callback argument */ 5845 cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT); 5846 if (cb_arg == NULL) { 5847 ocs_log_err(hw->os, "failed to malloc cb_arg"); 5848 return OCS_HW_RTN_NO_MEMORY; 5849 } 5850 5851 ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "set / OEMELX_LinkConfig=%s", value_str); 5852 /* allocate DMA for command */ 5853 if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, ocs_strlen(cmd)+1, 4096)) { 5854 ocs_log_err(hw->os, "malloc failed\n"); 5855 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 5856 return OCS_HW_RTN_NO_MEMORY; 5857 } 5858 ocs_memset(cb_arg->dma_cmd.virt, 0, ocs_strlen(cmd)+1); 5859 ocs_memcpy(cb_arg->dma_cmd.virt, cmd, ocs_strlen(cmd)); 5860 5861 /* allocate DMA for response */ 5862 if (ocs_dma_alloc(hw->os, &cb_arg->dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) { 5863 ocs_log_err(hw->os, "malloc failed\n"); 5864 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 5865 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 5866 return OCS_HW_RTN_NO_MEMORY; 5867 } 5868 cb_arg->cb = cb; 5869 cb_arg->arg = arg; 5870 cb_arg->opts = opts; 5871 5872 rc = ocs_hw_exec_dmtf_clp_cmd(hw, &cb_arg->dma_cmd, &cb_arg->dma_resp, 5873 opts, ocs_hw_linkcfg_dmtf_clp_cb, cb_arg); 5874 5875 if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) { 5876 /* if failed, or polling, free memory here; if success and not 5877 * polling, will free in callback function 5878 */ 5879 if (rc) { 5880 ocs_log_test(hw->os, "CLP cmd=\"%s\" failed\n", 5881 (char *)cb_arg->dma_cmd.virt); 5882 } 5883 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 5884 ocs_dma_free(hw->os, &cb_arg->dma_resp); 5885 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 5886 } 5887 return rc; 5888 } 5889 5890 /** 5891 * @brief Callback for ocs_hw_set_linkcfg_skyhawk 5892 * 5893 * @param hw Hardware context. 5894 * @param status Status from the RECONFIG_GET_LINK_INFO command. 5895 * @param mqe Mailbox response structure. 5896 * @param arg Pointer to a callback argument. 5897 * 5898 * @return none 5899 */ 5900 static void 5901 ocs_hw_set_active_link_config_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 5902 { 5903 ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg; 5904 5905 if (status) { 5906 ocs_log_test(hw->os, "SET_RECONFIG_LINK_ID failed, status=%d\n", status); 5907 } 5908 5909 /* invoke callback */ 5910 if (cb_arg->cb) { 5911 cb_arg->cb(status, 0, cb_arg->arg); 5912 } 5913 5914 /* if polling, will free memory in calling function */ 5915 if (cb_arg->opts != OCS_CMD_POLL) { 5916 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 5917 } 5918 } 5919 5920 /** 5921 * @brief Set link configuration for a Skyhawk 5922 * 5923 * @param hw Hardware context. 5924 * @param value Link configuration enum to which the link configuration is 5925 * set. 5926 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 5927 * @param cb Callback function to invoke following mbx command. 5928 * @param arg Callback argument. 5929 * 5930 * @return Returns OCS_HW_RTN_SUCCESS on success. 5931 */ 5932 static ocs_hw_rtn_e 5933 ocs_hw_set_linkcfg_skyhawk(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 5934 { 5935 uint8_t *mbxdata; 5936 ocs_hw_linkcfg_cb_arg_t *cb_arg; 5937 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 5938 uint32_t config_id; 5939 5940 config_id = ocs_hw_config_id_from_linkcfg(value); 5941 5942 if (config_id == 0) { 5943 ocs_log_test(hw->os, "Link config %d not supported by Skyhawk\n", value); 5944 return OCS_HW_RTN_ERROR; 5945 } 5946 5947 /* mbxdata holds the header of the command */ 5948 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 5949 if (mbxdata == NULL) { 5950 ocs_log_err(hw->os, "failed to malloc mbox\n"); 5951 return OCS_HW_RTN_NO_MEMORY; 5952 } 5953 5954 /* cb_arg holds the data that will be passed to the callback on completion */ 5955 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_linkcfg_cb_arg_t), OCS_M_NOWAIT); 5956 if (cb_arg == NULL) { 5957 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 5958 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5959 return OCS_HW_RTN_NO_MEMORY; 5960 } 5961 5962 cb_arg->cb = cb; 5963 cb_arg->arg = arg; 5964 5965 if (sli_cmd_common_set_reconfig_link_id(&hw->sli, mbxdata, SLI4_BMBX_SIZE, NULL, 0, config_id)) { 5966 rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_set_active_link_config_cb, cb_arg); 5967 } 5968 5969 if (rc != OCS_HW_RTN_SUCCESS) { 5970 ocs_log_err(hw->os, "SET_RECONFIG_LINK_ID failed\n"); 5971 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5972 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t)); 5973 } else if (opts == OCS_CMD_POLL) { 5974 /* if we're polling we have to call the callback here. */ 5975 ocs_hw_set_active_link_config_cb(hw, 0, mbxdata, cb_arg); 5976 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5977 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t)); 5978 } else { 5979 /* We weren't poling, so the callback got called */ 5980 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 5981 } 5982 5983 return rc; 5984 } 5985 5986 /** 5987 * @brief Get link configuration. 5988 * 5989 * @param hw Hardware context. 5990 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 5991 * @param cb Callback function to invoke following mbx command. 5992 * @param arg Callback argument. 5993 * 5994 * @return Returns OCS_HW_RTN_SUCCESS on success. 5995 */ 5996 static ocs_hw_rtn_e 5997 ocs_hw_get_linkcfg(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 5998 { 5999 if (!sli_link_is_configurable(&hw->sli)) { 6000 ocs_log_debug(hw->os, "Function not supported\n"); 6001 return OCS_HW_RTN_ERROR; 6002 } 6003 6004 if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) { 6005 return ocs_hw_get_linkcfg_lancer(hw, opts, cb, arg); 6006 } else if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) || 6007 (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) { 6008 return ocs_hw_get_linkcfg_skyhawk(hw, opts, cb, arg); 6009 } else { 6010 ocs_log_test(hw->os, "Function not supported for this IF_TYPE\n"); 6011 return OCS_HW_RTN_ERROR; 6012 } 6013 } 6014 6015 /** 6016 * @brief Get link configuration for a Lancer 6017 * 6018 * @param hw Hardware context. 6019 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 6020 * @param cb Callback function to invoke following mbx command. 6021 * @param arg Callback argument. 6022 * 6023 * @return Returns OCS_HW_RTN_SUCCESS on success. 6024 */ 6025 static ocs_hw_rtn_e 6026 ocs_hw_get_linkcfg_lancer(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 6027 { 6028 char cmd[OCS_HW_DMTF_CLP_CMD_MAX]; 6029 ocs_hw_linkcfg_cb_arg_t *cb_arg; 6030 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6031 6032 /* allocate memory for callback argument */ 6033 cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT); 6034 if (cb_arg == NULL) { 6035 ocs_log_err(hw->os, "failed to malloc cb_arg"); 6036 return OCS_HW_RTN_NO_MEMORY; 6037 } 6038 6039 ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "show / OEMELX_LinkConfig"); 6040 6041 /* allocate DMA for command */ 6042 if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, ocs_strlen(cmd)+1, 4096)) { 6043 ocs_log_err(hw->os, "malloc failed\n"); 6044 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6045 return OCS_HW_RTN_NO_MEMORY; 6046 } 6047 6048 /* copy CLP command to DMA command */ 6049 ocs_memset(cb_arg->dma_cmd.virt, 0, ocs_strlen(cmd)+1); 6050 ocs_memcpy(cb_arg->dma_cmd.virt, cmd, ocs_strlen(cmd)); 6051 6052 /* allocate DMA for response */ 6053 if (ocs_dma_alloc(hw->os, &cb_arg->dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) { 6054 ocs_log_err(hw->os, "malloc failed\n"); 6055 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6056 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6057 return OCS_HW_RTN_NO_MEMORY; 6058 } 6059 cb_arg->cb = cb; 6060 cb_arg->arg = arg; 6061 cb_arg->opts = opts; 6062 6063 rc = ocs_hw_exec_dmtf_clp_cmd(hw, &cb_arg->dma_cmd, &cb_arg->dma_resp, 6064 opts, ocs_hw_linkcfg_dmtf_clp_cb, cb_arg); 6065 6066 if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) { 6067 /* if failed or polling, free memory here; if not polling and success, 6068 * will free in callback function 6069 */ 6070 if (rc) { 6071 ocs_log_test(hw->os, "CLP cmd=\"%s\" failed\n", 6072 (char *)cb_arg->dma_cmd.virt); 6073 } 6074 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6075 ocs_dma_free(hw->os, &cb_arg->dma_resp); 6076 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6077 } 6078 return rc; 6079 } 6080 6081 /** 6082 * @brief Get the link configuration callback. 6083 * 6084 * @param hw Hardware context. 6085 * @param status Status from the RECONFIG_GET_LINK_INFO command. 6086 * @param mqe Mailbox response structure. 6087 * @param arg Pointer to a callback argument. 6088 * 6089 * @return none 6090 */ 6091 static void 6092 ocs_hw_get_active_link_config_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 6093 { 6094 ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg; 6095 sli4_res_common_get_reconfig_link_info_t *rsp = cb_arg->dma_cmd.virt; 6096 ocs_hw_linkcfg_e value = OCS_HW_LINKCFG_NA; 6097 6098 if (status) { 6099 ocs_log_test(hw->os, "GET_RECONFIG_LINK_INFO failed, status=%d\n", status); 6100 } else { 6101 /* Call was successful */ 6102 value = ocs_hw_linkcfg_from_config_id(rsp->active_link_config_id); 6103 } 6104 6105 /* invoke callback */ 6106 if (cb_arg->cb) { 6107 cb_arg->cb(status, value, cb_arg->arg); 6108 } 6109 6110 /* if polling, will free memory in calling function */ 6111 if (cb_arg->opts != OCS_CMD_POLL) { 6112 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6113 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6114 } 6115 } 6116 6117 /** 6118 * @brief Get link configuration for a Skyhawk. 6119 * 6120 * @param hw Hardware context. 6121 * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL). 6122 * @param cb Callback function to invoke following mbx command. 6123 * @param arg Callback argument. 6124 * 6125 * @return Returns OCS_HW_RTN_SUCCESS on success. 6126 */ 6127 static ocs_hw_rtn_e 6128 ocs_hw_get_linkcfg_skyhawk(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg) 6129 { 6130 uint8_t *mbxdata; 6131 ocs_hw_linkcfg_cb_arg_t *cb_arg; 6132 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6133 6134 /* mbxdata holds the header of the command */ 6135 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 6136 if (mbxdata == NULL) { 6137 ocs_log_err(hw->os, "failed to malloc mbox\n"); 6138 return OCS_HW_RTN_NO_MEMORY; 6139 } 6140 6141 /* cb_arg holds the data that will be passed to the callback on completion */ 6142 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_linkcfg_cb_arg_t), OCS_M_NOWAIT); 6143 if (cb_arg == NULL) { 6144 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 6145 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6146 return OCS_HW_RTN_NO_MEMORY; 6147 } 6148 6149 cb_arg->cb = cb; 6150 cb_arg->arg = arg; 6151 cb_arg->opts = opts; 6152 6153 /* dma_mem holds the non-embedded portion */ 6154 if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, sizeof(sli4_res_common_get_reconfig_link_info_t), 4)) { 6155 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 6156 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6157 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t)); 6158 return OCS_HW_RTN_NO_MEMORY; 6159 } 6160 6161 if (sli_cmd_common_get_reconfig_link_info(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->dma_cmd)) { 6162 rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_get_active_link_config_cb, cb_arg); 6163 } 6164 6165 if (rc != OCS_HW_RTN_SUCCESS) { 6166 ocs_log_err(hw->os, "GET_RECONFIG_LINK_INFO failed\n"); 6167 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6168 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6169 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t)); 6170 } else if (opts == OCS_CMD_POLL) { 6171 /* if we're polling we have to call the callback here. */ 6172 ocs_hw_get_active_link_config_cb(hw, 0, mbxdata, cb_arg); 6173 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6174 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6175 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t)); 6176 } else { 6177 /* We weren't poling, so the callback got called */ 6178 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6179 } 6180 6181 return rc; 6182 } 6183 6184 /** 6185 * @brief Sets the DIF seed value. 6186 * 6187 * @param hw Hardware context. 6188 * 6189 * @return Returns OCS_HW_RTN_SUCCESS on success. 6190 */ 6191 static ocs_hw_rtn_e 6192 ocs_hw_set_dif_seed(ocs_hw_t *hw) 6193 { 6194 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6195 uint8_t buf[SLI4_BMBX_SIZE]; 6196 sli4_req_common_set_features_dif_seed_t seed_param; 6197 6198 ocs_memset(&seed_param, 0, sizeof(seed_param)); 6199 seed_param.seed = hw->config.dif_seed; 6200 6201 /* send set_features command */ 6202 if (sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE, 6203 SLI4_SET_FEATURES_DIF_SEED, 6204 4, 6205 (uint32_t*)&seed_param)) { 6206 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 6207 if (rc) { 6208 ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc); 6209 } else { 6210 ocs_log_debug(hw->os, "DIF seed set to 0x%x\n", 6211 hw->config.dif_seed); 6212 } 6213 } else { 6214 ocs_log_err(hw->os, "sli_cmd_common_set_features failed\n"); 6215 rc = OCS_HW_RTN_ERROR; 6216 } 6217 return rc; 6218 } 6219 6220 /** 6221 * @brief Sets the DIF mode value. 6222 * 6223 * @param hw Hardware context. 6224 * 6225 * @return Returns OCS_HW_RTN_SUCCESS on success. 6226 */ 6227 static ocs_hw_rtn_e 6228 ocs_hw_set_dif_mode(ocs_hw_t *hw) 6229 { 6230 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6231 uint8_t buf[SLI4_BMBX_SIZE]; 6232 sli4_req_common_set_features_t10_pi_mem_model_t mode_param; 6233 6234 ocs_memset(&mode_param, 0, sizeof(mode_param)); 6235 mode_param.tmm = (hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE ? 0 : 1); 6236 6237 /* send set_features command */ 6238 if (sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE, 6239 SLI4_SET_FEATURES_DIF_MEMORY_MODE, 6240 sizeof(mode_param), 6241 (uint32_t*)&mode_param)) { 6242 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 6243 if (rc) { 6244 ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc); 6245 } else { 6246 ocs_log_test(hw->os, "DIF mode set to %s\n", 6247 (hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE ? "inline" : "separate")); 6248 } 6249 } else { 6250 ocs_log_err(hw->os, "sli_cmd_common_set_features failed\n"); 6251 rc = OCS_HW_RTN_ERROR; 6252 } 6253 return rc; 6254 } 6255 6256 static void 6257 ocs_hw_watchdog_timer_cb(void *arg) 6258 { 6259 ocs_hw_t *hw = (ocs_hw_t *)arg; 6260 6261 ocs_hw_config_watchdog_timer(hw); 6262 return; 6263 } 6264 6265 static void 6266 ocs_hw_cb_cfg_watchdog(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 6267 { 6268 uint16_t timeout = hw->watchdog_timeout; 6269 6270 if (status != 0) { 6271 ocs_log_err(hw->os, "config watchdog timer failed, rc = %d\n", status); 6272 } else { 6273 if(timeout != 0) { 6274 /* keeping callback 500ms before timeout to keep heartbeat alive */ 6275 ocs_setup_timer(hw->os, &hw->watchdog_timer, ocs_hw_watchdog_timer_cb, hw, (timeout*1000 - 500) ); 6276 }else { 6277 ocs_del_timer(&hw->watchdog_timer); 6278 } 6279 } 6280 6281 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 6282 return; 6283 } 6284 6285 /** 6286 * @brief Set configuration parameters for watchdog timer feature. 6287 * 6288 * @param hw Hardware context. 6289 * @param timeout Timeout for watchdog timer in seconds 6290 * 6291 * @return Returns OCS_HW_RTN_SUCCESS on success. 6292 */ 6293 static ocs_hw_rtn_e 6294 ocs_hw_config_watchdog_timer(ocs_hw_t *hw) 6295 { 6296 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6297 uint8_t *buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 6298 6299 if (!buf) { 6300 ocs_log_err(hw->os, "no buffer for command\n"); 6301 return OCS_HW_RTN_NO_MEMORY; 6302 } 6303 6304 sli4_cmd_lowlevel_set_watchdog(&hw->sli, buf, SLI4_BMBX_SIZE, hw->watchdog_timeout); 6305 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_cfg_watchdog, NULL); 6306 if (rc) { 6307 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 6308 ocs_log_err(hw->os, "config watchdog timer failed, rc = %d\n", rc); 6309 } 6310 return rc; 6311 } 6312 6313 /** 6314 * @brief Set configuration parameters for auto-generate xfer_rdy T10 PI feature. 6315 * 6316 * @param hw Hardware context. 6317 * @param buf Pointer to a mailbox buffer area. 6318 * 6319 * @return Returns OCS_HW_RTN_SUCCESS on success. 6320 */ 6321 static ocs_hw_rtn_e 6322 ocs_hw_config_auto_xfer_rdy_t10pi(ocs_hw_t *hw, uint8_t *buf) 6323 { 6324 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6325 sli4_req_common_set_features_xfer_rdy_t10pi_t param; 6326 6327 ocs_memset(¶m, 0, sizeof(param)); 6328 param.rtc = (hw->config.auto_xfer_rdy_ref_tag_is_lba ? 0 : 1); 6329 param.atv = (hw->config.auto_xfer_rdy_app_tag_valid ? 1 : 0); 6330 param.tmm = ((hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE) ? 0 : 1); 6331 param.app_tag = hw->config.auto_xfer_rdy_app_tag_value; 6332 param.blk_size = hw->config.auto_xfer_rdy_blk_size_chip; 6333 6334 switch (hw->config.auto_xfer_rdy_p_type) { 6335 case 1: 6336 param.p_type = 0; 6337 break; 6338 case 3: 6339 param.p_type = 2; 6340 break; 6341 default: 6342 ocs_log_err(hw->os, "unsupported p_type %d\n", 6343 hw->config.auto_xfer_rdy_p_type); 6344 return OCS_HW_RTN_ERROR; 6345 } 6346 6347 /* build the set_features command */ 6348 sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE, 6349 SLI4_SET_FEATURES_SET_CONFIG_AUTO_XFER_RDY_T10PI, 6350 sizeof(param), 6351 ¶m); 6352 6353 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 6354 if (rc) { 6355 ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc); 6356 } else { 6357 ocs_log_test(hw->os, "Auto XFER RDY T10 PI configured rtc:%d atv:%d p_type:%d app_tag:%x blk_size:%d\n", 6358 param.rtc, param.atv, param.p_type, 6359 param.app_tag, param.blk_size); 6360 } 6361 6362 return rc; 6363 } 6364 6365 /** 6366 * @brief enable sli port health check 6367 * 6368 * @param hw Hardware context. 6369 * @param buf Pointer to a mailbox buffer area. 6370 * @param query current status of the health check feature enabled/disabled 6371 * @param enable if 1: enable 0: disable 6372 * @param buf Pointer to a mailbox buffer area. 6373 * 6374 * @return Returns OCS_HW_RTN_SUCCESS on success. 6375 */ 6376 static ocs_hw_rtn_e 6377 ocs_hw_config_sli_port_health_check(ocs_hw_t *hw, uint8_t query, uint8_t enable) 6378 { 6379 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6380 uint8_t buf[SLI4_BMBX_SIZE]; 6381 sli4_req_common_set_features_health_check_t param; 6382 6383 ocs_memset(¶m, 0, sizeof(param)); 6384 param.hck = enable; 6385 param.qry = query; 6386 6387 /* build the set_features command */ 6388 sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE, 6389 SLI4_SET_FEATURES_SLI_PORT_HEALTH_CHECK, 6390 sizeof(param), 6391 ¶m); 6392 6393 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 6394 if (rc) { 6395 ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc); 6396 } else { 6397 ocs_log_test(hw->os, "SLI Port Health Check is enabled \n"); 6398 } 6399 6400 return rc; 6401 } 6402 6403 /** 6404 * @brief Set FTD transfer hint feature 6405 * 6406 * @param hw Hardware context. 6407 * @param fdt_xfer_hint size in bytes where read requests are segmented. 6408 * 6409 * @return Returns OCS_HW_RTN_SUCCESS on success. 6410 */ 6411 static ocs_hw_rtn_e 6412 ocs_hw_config_set_fdt_xfer_hint(ocs_hw_t *hw, uint32_t fdt_xfer_hint) 6413 { 6414 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6415 uint8_t buf[SLI4_BMBX_SIZE]; 6416 sli4_req_common_set_features_set_fdt_xfer_hint_t param; 6417 6418 ocs_memset(¶m, 0, sizeof(param)); 6419 param.fdt_xfer_hint = fdt_xfer_hint; 6420 /* build the set_features command */ 6421 sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE, 6422 SLI4_SET_FEATURES_SET_FTD_XFER_HINT, 6423 sizeof(param), 6424 ¶m); 6425 6426 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL); 6427 if (rc) { 6428 ocs_log_warn(hw->os, "set FDT hint %d failed: %d\n", fdt_xfer_hint, rc); 6429 } else { 6430 ocs_log_debug(hw->os, "Set FTD transfer hint to %d\n", param.fdt_xfer_hint); 6431 } 6432 6433 return rc; 6434 } 6435 6436 /** 6437 * @brief Get the link configuration callback. 6438 * 6439 * @param hw Hardware context. 6440 * @param status Status from the DMTF CLP command. 6441 * @param result_len Length, in bytes, of the DMTF CLP result. 6442 * @param arg Pointer to a callback argument. 6443 * 6444 * @return Returns OCS_HW_RTN_SUCCESS on success. 6445 */ 6446 static void 6447 ocs_hw_linkcfg_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg) 6448 { 6449 int32_t rval; 6450 char retdata_str[64]; 6451 ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg; 6452 ocs_hw_linkcfg_e linkcfg = OCS_HW_LINKCFG_NA; 6453 6454 if (status) { 6455 ocs_log_test(hw->os, "CLP cmd failed, status=%d\n", status); 6456 } else { 6457 /* parse CLP response to get return data */ 6458 rval = ocs_hw_clp_resp_get_value(hw, "retdata", retdata_str, 6459 sizeof(retdata_str), 6460 cb_arg->dma_resp.virt, 6461 result_len); 6462 6463 if (rval <= 0) { 6464 ocs_log_err(hw->os, "failed to get retdata %d\n", result_len); 6465 } else { 6466 /* translate string into hw enum */ 6467 linkcfg = ocs_hw_linkcfg_from_clp(retdata_str); 6468 } 6469 } 6470 6471 /* invoke callback */ 6472 if (cb_arg->cb) { 6473 cb_arg->cb(status, linkcfg, cb_arg->arg); 6474 } 6475 6476 /* if polling, will free memory in calling function */ 6477 if (cb_arg->opts != OCS_CMD_POLL) { 6478 ocs_dma_free(hw->os, &cb_arg->dma_cmd); 6479 ocs_dma_free(hw->os, &cb_arg->dma_resp); 6480 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6481 } 6482 } 6483 6484 /** 6485 * @brief Set the Lancer dump location 6486 * @par Description 6487 * This function tells a Lancer chip to use a specific DMA 6488 * buffer as a dump location rather than the internal flash. 6489 * 6490 * @param hw Hardware context. 6491 * @param num_buffers The number of DMA buffers to hold the dump (1..n). 6492 * @param dump_buffers DMA buffers to hold the dump. 6493 * 6494 * @return Returns OCS_HW_RTN_SUCCESS on success. 6495 */ 6496 ocs_hw_rtn_e 6497 ocs_hw_set_dump_location(ocs_hw_t *hw, uint32_t num_buffers, ocs_dma_t *dump_buffers, uint8_t fdb) 6498 { 6499 uint8_t bus, dev, func; 6500 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6501 uint8_t buf[SLI4_BMBX_SIZE]; 6502 6503 /* 6504 * Make sure the FW is new enough to support this command. If the FW 6505 * is too old, the FW will UE. 6506 */ 6507 if (hw->workaround.disable_dump_loc) { 6508 ocs_log_test(hw->os, "FW version is too old for this feature\n"); 6509 return OCS_HW_RTN_ERROR; 6510 } 6511 6512 /* This command is only valid for physical port 0 */ 6513 ocs_get_bus_dev_func(hw->os, &bus, &dev, &func); 6514 if (fdb == 0 && func != 0) { 6515 ocs_log_test(hw->os, "function only valid for pci function 0, %d passed\n", 6516 func); 6517 return OCS_HW_RTN_ERROR; 6518 } 6519 6520 /* 6521 * If a single buffer is used, then it may be passed as is to the chip. For multiple buffers, 6522 * We must allocate a SGL list and then pass the address of the list to the chip. 6523 */ 6524 if (num_buffers > 1) { 6525 uint32_t sge_size = num_buffers * sizeof(sli4_sge_t); 6526 sli4_sge_t *sge; 6527 uint32_t i; 6528 6529 if (hw->dump_sges.size < sge_size) { 6530 ocs_dma_free(hw->os, &hw->dump_sges); 6531 if (ocs_dma_alloc(hw->os, &hw->dump_sges, sge_size, OCS_MIN_DMA_ALIGNMENT)) { 6532 ocs_log_err(hw->os, "SGE DMA allocation failed\n"); 6533 return OCS_HW_RTN_NO_MEMORY; 6534 } 6535 } 6536 /* build the SGE list */ 6537 ocs_memset(hw->dump_sges.virt, 0, hw->dump_sges.size); 6538 hw->dump_sges.len = sge_size; 6539 sge = hw->dump_sges.virt; 6540 for (i = 0; i < num_buffers; i++) { 6541 sge[i].buffer_address_high = ocs_addr32_hi(dump_buffers[i].phys); 6542 sge[i].buffer_address_low = ocs_addr32_lo(dump_buffers[i].phys); 6543 sge[i].last = (i == num_buffers - 1 ? 1 : 0); 6544 sge[i].buffer_length = dump_buffers[i].size; 6545 } 6546 rc = sli_cmd_common_set_dump_location(&hw->sli, (void *)buf, 6547 SLI4_BMBX_SIZE, FALSE, TRUE, 6548 &hw->dump_sges, fdb); 6549 } else { 6550 dump_buffers->len = dump_buffers->size; 6551 rc = sli_cmd_common_set_dump_location(&hw->sli, (void *)buf, 6552 SLI4_BMBX_SIZE, FALSE, FALSE, 6553 dump_buffers, fdb); 6554 } 6555 6556 if (rc) { 6557 rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, 6558 NULL, NULL); 6559 if (rc) { 6560 ocs_log_err(hw->os, "ocs_hw_command returns %d\n", 6561 rc); 6562 } 6563 } else { 6564 ocs_log_err(hw->os, 6565 "sli_cmd_common_set_dump_location failed\n"); 6566 rc = OCS_HW_RTN_ERROR; 6567 } 6568 6569 return rc; 6570 } 6571 6572 /** 6573 * @brief Set the Ethernet license. 6574 * 6575 * @par Description 6576 * This function sends the appropriate mailbox command (DMTF 6577 * CLP) to set the Ethernet license to the given license value. 6578 * Since it is used during the time of ocs_hw_init(), the mailbox 6579 * command is sent via polling (the BMBX route). 6580 * 6581 * @param hw Hardware context. 6582 * @param license 32-bit license value. 6583 * 6584 * @return Returns OCS_HW_RTN_SUCCESS on success. 6585 */ 6586 static ocs_hw_rtn_e 6587 ocs_hw_set_eth_license(ocs_hw_t *hw, uint32_t license) 6588 { 6589 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6590 char cmd[OCS_HW_DMTF_CLP_CMD_MAX]; 6591 ocs_dma_t dma_cmd; 6592 ocs_dma_t dma_resp; 6593 6594 /* only for lancer right now */ 6595 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 6596 ocs_log_test(hw->os, "Function only supported for I/F type 2\n"); 6597 return OCS_HW_RTN_ERROR; 6598 } 6599 6600 ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "set / OEMELX_Ethernet_License=%X", license); 6601 /* allocate DMA for command */ 6602 if (ocs_dma_alloc(hw->os, &dma_cmd, ocs_strlen(cmd)+1, 4096)) { 6603 ocs_log_err(hw->os, "malloc failed\n"); 6604 return OCS_HW_RTN_NO_MEMORY; 6605 } 6606 ocs_memset(dma_cmd.virt, 0, ocs_strlen(cmd)+1); 6607 ocs_memcpy(dma_cmd.virt, cmd, ocs_strlen(cmd)); 6608 6609 /* allocate DMA for response */ 6610 if (ocs_dma_alloc(hw->os, &dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) { 6611 ocs_log_err(hw->os, "malloc failed\n"); 6612 ocs_dma_free(hw->os, &dma_cmd); 6613 return OCS_HW_RTN_NO_MEMORY; 6614 } 6615 6616 /* send DMTF CLP command mbx and poll */ 6617 if (ocs_hw_exec_dmtf_clp_cmd(hw, &dma_cmd, &dma_resp, OCS_CMD_POLL, NULL, NULL)) { 6618 ocs_log_err(hw->os, "CLP cmd=\"%s\" failed\n", (char *)dma_cmd.virt); 6619 rc = OCS_HW_RTN_ERROR; 6620 } 6621 6622 ocs_dma_free(hw->os, &dma_cmd); 6623 ocs_dma_free(hw->os, &dma_resp); 6624 return rc; 6625 } 6626 6627 /** 6628 * @brief Callback argument structure for the DMTF CLP commands. 6629 */ 6630 typedef struct ocs_hw_clp_cb_arg_s { 6631 ocs_hw_dmtf_clp_cb_t cb; 6632 ocs_dma_t *dma_resp; 6633 int32_t status; 6634 uint32_t opts; 6635 void *arg; 6636 } ocs_hw_clp_cb_arg_t; 6637 6638 /** 6639 * @brief Execute the DMTF CLP command. 6640 * 6641 * @param hw Hardware context. 6642 * @param dma_cmd DMA buffer containing the CLP command. 6643 * @param dma_resp DMA buffer that will contain the response (if successful). 6644 * @param opts Mailbox command options (such as OCS_CMD_NOWAIT and POLL). 6645 * @param cb Callback function. 6646 * @param arg Callback argument. 6647 * 6648 * @return Returns the number of bytes written to the response 6649 * buffer on success, or a negative value if failed. 6650 */ 6651 static ocs_hw_rtn_e 6652 ocs_hw_exec_dmtf_clp_cmd(ocs_hw_t *hw, ocs_dma_t *dma_cmd, ocs_dma_t *dma_resp, uint32_t opts, ocs_hw_dmtf_clp_cb_t cb, void *arg) 6653 { 6654 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 6655 ocs_hw_clp_cb_arg_t *cb_arg; 6656 uint8_t *mbxdata; 6657 6658 /* allocate DMA for mailbox */ 6659 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 6660 if (mbxdata == NULL) { 6661 ocs_log_err(hw->os, "failed to malloc mbox\n"); 6662 return OCS_HW_RTN_NO_MEMORY; 6663 } 6664 6665 /* allocate memory for callback argument */ 6666 cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT); 6667 if (cb_arg == NULL) { 6668 ocs_log_err(hw->os, "failed to malloc cb_arg"); 6669 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6670 return OCS_HW_RTN_NO_MEMORY; 6671 } 6672 6673 cb_arg->cb = cb; 6674 cb_arg->arg = arg; 6675 cb_arg->dma_resp = dma_resp; 6676 cb_arg->opts = opts; 6677 6678 /* Send the HW command */ 6679 if (sli_cmd_dmtf_exec_clp_cmd(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 6680 dma_cmd, dma_resp)) { 6681 rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_dmtf_clp_cb, cb_arg); 6682 6683 if (opts == OCS_CMD_POLL && rc == OCS_HW_RTN_SUCCESS) { 6684 /* if we're polling, copy response and invoke callback to 6685 * parse result */ 6686 ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE); 6687 ocs_hw_dmtf_clp_cb(hw, 0, mbxdata, cb_arg); 6688 6689 /* set rc to resulting or "parsed" status */ 6690 rc = cb_arg->status; 6691 } 6692 6693 /* if failed, or polling, free memory here */ 6694 if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) { 6695 if (rc != OCS_HW_RTN_SUCCESS) { 6696 ocs_log_test(hw->os, "ocs_hw_command failed\n"); 6697 } 6698 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6699 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6700 } 6701 } else { 6702 ocs_log_test(hw->os, "sli_cmd_dmtf_exec_clp_cmd failed\n"); 6703 rc = OCS_HW_RTN_ERROR; 6704 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6705 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6706 } 6707 6708 return rc; 6709 } 6710 6711 /** 6712 * @brief Called when the DMTF CLP command completes. 6713 * 6714 * @param hw Hardware context. 6715 * @param status Status field from the mbox completion. 6716 * @param mqe Mailbox response structure. 6717 * @param arg Pointer to a callback argument. 6718 * 6719 * @return None. 6720 * 6721 */ 6722 static void 6723 ocs_hw_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 6724 { 6725 int32_t cb_status = 0; 6726 sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe; 6727 sli4_res_dmtf_exec_clp_cmd_t *clp_rsp = (sli4_res_dmtf_exec_clp_cmd_t *) mbox_rsp->payload.embed; 6728 ocs_hw_clp_cb_arg_t *cb_arg = arg; 6729 uint32_t result_len = 0; 6730 int32_t stat_len; 6731 char stat_str[8]; 6732 6733 /* there are several status codes here, check them all and condense 6734 * into a single callback status 6735 */ 6736 if (status || mbox_rsp->hdr.status || clp_rsp->clp_status) { 6737 ocs_log_debug(hw->os, "status=x%x/x%x/x%x addl=x%x clp=x%x detail=x%x\n", 6738 status, 6739 mbox_rsp->hdr.status, 6740 clp_rsp->hdr.status, 6741 clp_rsp->hdr.additional_status, 6742 clp_rsp->clp_status, 6743 clp_rsp->clp_detailed_status); 6744 if (status) { 6745 cb_status = status; 6746 } else if (mbox_rsp->hdr.status) { 6747 cb_status = mbox_rsp->hdr.status; 6748 } else { 6749 cb_status = clp_rsp->clp_status; 6750 } 6751 } else { 6752 result_len = clp_rsp->resp_length; 6753 } 6754 6755 if (cb_status) { 6756 goto ocs_hw_cb_dmtf_clp_done; 6757 } 6758 6759 if ((result_len == 0) || (cb_arg->dma_resp->size < result_len)) { 6760 ocs_log_test(hw->os, "Invalid response length: resp_len=%zu result len=%d\n", 6761 cb_arg->dma_resp->size, result_len); 6762 cb_status = -1; 6763 goto ocs_hw_cb_dmtf_clp_done; 6764 } 6765 6766 /* parse CLP response to get status */ 6767 stat_len = ocs_hw_clp_resp_get_value(hw, "status", stat_str, 6768 sizeof(stat_str), 6769 cb_arg->dma_resp->virt, 6770 result_len); 6771 6772 if (stat_len <= 0) { 6773 ocs_log_test(hw->os, "failed to get status %d\n", stat_len); 6774 cb_status = -1; 6775 goto ocs_hw_cb_dmtf_clp_done; 6776 } 6777 6778 if (ocs_strcmp(stat_str, "0") != 0) { 6779 ocs_log_test(hw->os, "CLP status indicates failure=%s\n", stat_str); 6780 cb_status = -1; 6781 goto ocs_hw_cb_dmtf_clp_done; 6782 } 6783 6784 ocs_hw_cb_dmtf_clp_done: 6785 6786 /* save status in cb_arg for callers with NULL cb's + polling */ 6787 cb_arg->status = cb_status; 6788 if (cb_arg->cb) { 6789 cb_arg->cb(hw, cb_status, result_len, cb_arg->arg); 6790 } 6791 /* if polling, caller will free memory */ 6792 if (cb_arg->opts != OCS_CMD_POLL) { 6793 ocs_free(hw->os, cb_arg, sizeof(*cb_arg)); 6794 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 6795 } 6796 } 6797 6798 /** 6799 * @brief Parse the CLP result and get the value corresponding to the given 6800 * keyword. 6801 * 6802 * @param hw Hardware context. 6803 * @param keyword CLP keyword for which the value is returned. 6804 * @param value Location to which the resulting value is copied. 6805 * @param value_len Length of the value parameter. 6806 * @param resp Pointer to the response buffer that is searched 6807 * for the keyword and value. 6808 * @param resp_len Length of response buffer passed in. 6809 * 6810 * @return Returns the number of bytes written to the value 6811 * buffer on success, or a negative vaue on failure. 6812 */ 6813 static int32_t 6814 ocs_hw_clp_resp_get_value(ocs_hw_t *hw, const char *keyword, char *value, uint32_t value_len, const char *resp, uint32_t resp_len) 6815 { 6816 char *start = NULL; 6817 char *end = NULL; 6818 6819 /* look for specified keyword in string */ 6820 start = ocs_strstr(resp, keyword); 6821 if (start == NULL) { 6822 ocs_log_test(hw->os, "could not find keyword=%s in CLP response\n", 6823 keyword); 6824 return -1; 6825 } 6826 6827 /* now look for '=' and go one past */ 6828 start = ocs_strchr(start, '='); 6829 if (start == NULL) { 6830 ocs_log_test(hw->os, "could not find \'=\' in CLP response for keyword=%s\n", 6831 keyword); 6832 return -1; 6833 } 6834 start++; 6835 6836 /* \r\n terminates value */ 6837 end = ocs_strstr(start, "\r\n"); 6838 if (end == NULL) { 6839 ocs_log_test(hw->os, "could not find \\r\\n for keyword=%s in CLP response\n", 6840 keyword); 6841 return -1; 6842 } 6843 6844 /* make sure given result array is big enough */ 6845 if ((end - start + 1) > value_len) { 6846 ocs_log_test(hw->os, "value len=%d not large enough for actual=%ld\n", 6847 value_len, (end-start)); 6848 return -1; 6849 } 6850 6851 ocs_strncpy(value, start, (end - start)); 6852 value[end-start] = '\0'; 6853 return (end-start+1); 6854 } 6855 6856 /** 6857 * @brief Cause chip to enter an unrecoverable error state. 6858 * 6859 * @par Description 6860 * Cause chip to enter an unrecoverable error state. This is 6861 * used when detecting unexpected FW behavior so that the FW can be 6862 * hwted from the driver as soon as the error is detected. 6863 * 6864 * @param hw Hardware context. 6865 * @param dump Generate dump as part of reset. 6866 * 6867 * @return Returns 0 on success, or a non-zero value on failure. 6868 * 6869 */ 6870 ocs_hw_rtn_e 6871 ocs_hw_raise_ue(ocs_hw_t *hw, uint8_t dump) 6872 { 6873 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 6874 6875 if (sli_raise_ue(&hw->sli, dump) != 0) { 6876 rc = OCS_HW_RTN_ERROR; 6877 } else { 6878 if (hw->state != OCS_HW_STATE_UNINITIALIZED) { 6879 hw->state = OCS_HW_STATE_QUEUES_ALLOCATED; 6880 } 6881 } 6882 6883 return rc; 6884 } 6885 6886 /** 6887 * @brief Called when the OBJECT_GET command completes. 6888 * 6889 * @par Description 6890 * Get the number of bytes actually written out of the response, free the mailbox 6891 * that was malloc'd by ocs_hw_dump_get(), then call the callback 6892 * and pass the status and bytes read. 6893 * 6894 * @param hw Hardware context. 6895 * @param status Status field from the mbox completion. 6896 * @param mqe Mailbox response structure. 6897 * @param arg Pointer to a callback function that signals the caller that the command is done. 6898 * The callback function prototype is <tt>void cb(int32_t status, uint32_t bytes_read)</tt>. 6899 * 6900 * @return Returns 0. 6901 */ 6902 static int32_t 6903 ocs_hw_cb_dump_get(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 6904 { 6905 sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe; 6906 sli4_res_common_read_object_t* rd_obj_rsp = (sli4_res_common_read_object_t*) mbox_rsp->payload.embed; 6907 ocs_hw_dump_get_cb_arg_t *cb_arg = arg; 6908 uint32_t bytes_read; 6909 uint8_t eof; 6910 6911 bytes_read = rd_obj_rsp->actual_read_length; 6912 eof = rd_obj_rsp->eof; 6913 6914 if (cb_arg) { 6915 if (cb_arg->cb) { 6916 if ((status == 0) && mbox_rsp->hdr.status) { 6917 status = mbox_rsp->hdr.status; 6918 } 6919 cb_arg->cb(status, bytes_read, eof, cb_arg->arg); 6920 } 6921 6922 ocs_free(hw->os, cb_arg->mbox_cmd, SLI4_BMBX_SIZE); 6923 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_get_cb_arg_t)); 6924 } 6925 6926 return 0; 6927 } 6928 6929 /** 6930 * @brief Read a dump image to the host. 6931 * 6932 * @par Description 6933 * Creates a SLI_CONFIG mailbox command, fills in the correct values to read a 6934 * dump image chunk, then sends the command with the ocs_hw_command(). On completion, 6935 * the callback function ocs_hw_cb_dump_get() gets called to free the mailbox 6936 * and signal the caller that the read has completed. 6937 * 6938 * @param hw Hardware context. 6939 * @param dma DMA structure to transfer the dump chunk into. 6940 * @param size Size of the dump chunk. 6941 * @param offset Offset, in bytes, from the beginning of the dump. 6942 * @param cb Pointer to a callback function that is called when the command completes. 6943 * The callback function prototype is 6944 * <tt>void cb(int32_t status, uint32_t bytes_read, uint8_t eof, void *arg)</tt>. 6945 * @param arg Pointer to be passed to the callback function. 6946 * 6947 * @return Returns 0 on success, or a non-zero value on failure. 6948 */ 6949 ocs_hw_rtn_e 6950 ocs_hw_dump_get(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, ocs_hw_dump_get_cb_t cb, void *arg) 6951 { 6952 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 6953 uint8_t *mbxdata; 6954 ocs_hw_dump_get_cb_arg_t *cb_arg; 6955 uint32_t opts = (hw->state == OCS_HW_STATE_ACTIVE ? OCS_CMD_NOWAIT : OCS_CMD_POLL); 6956 6957 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 6958 ocs_log_test(hw->os, "Function only supported for I/F type 2\n"); 6959 return OCS_HW_RTN_ERROR; 6960 } 6961 6962 if (1 != sli_dump_is_present(&hw->sli)) { 6963 ocs_log_test(hw->os, "No dump is present\n"); 6964 return OCS_HW_RTN_ERROR; 6965 } 6966 6967 if (1 == sli_reset_required(&hw->sli)) { 6968 ocs_log_test(hw->os, "device reset required\n"); 6969 return OCS_HW_RTN_ERROR; 6970 } 6971 6972 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 6973 if (mbxdata == NULL) { 6974 ocs_log_err(hw->os, "failed to malloc mbox\n"); 6975 return OCS_HW_RTN_NO_MEMORY; 6976 } 6977 6978 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_dump_get_cb_arg_t), OCS_M_NOWAIT); 6979 if (cb_arg == NULL) { 6980 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 6981 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 6982 return OCS_HW_RTN_NO_MEMORY; 6983 } 6984 6985 cb_arg->cb = cb; 6986 cb_arg->arg = arg; 6987 cb_arg->mbox_cmd = mbxdata; 6988 6989 if (sli_cmd_common_read_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 6990 size, offset, "/dbg/dump.bin", dma)) { 6991 rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_cb_dump_get, cb_arg); 6992 if (rc == 0 && opts == OCS_CMD_POLL) { 6993 ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE); 6994 rc = ocs_hw_cb_dump_get(hw, 0, mbxdata, cb_arg); 6995 } 6996 } 6997 6998 if (rc != OCS_HW_RTN_SUCCESS) { 6999 ocs_log_test(hw->os, "COMMON_READ_OBJECT failed\n"); 7000 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7001 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_get_cb_arg_t)); 7002 } 7003 7004 return rc; 7005 } 7006 7007 /** 7008 * @brief Called when the OBJECT_DELETE command completes. 7009 * 7010 * @par Description 7011 * Free the mailbox that was malloc'd 7012 * by ocs_hw_dump_clear(), then call the callback and pass the status. 7013 * 7014 * @param hw Hardware context. 7015 * @param status Status field from the mbox completion. 7016 * @param mqe Mailbox response structure. 7017 * @param arg Pointer to a callback function that signals the caller that the command is done. 7018 * The callback function prototype is <tt>void cb(int32_t status, void *arg)</tt>. 7019 * 7020 * @return Returns 0. 7021 */ 7022 static int32_t 7023 ocs_hw_cb_dump_clear(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7024 { 7025 ocs_hw_dump_clear_cb_arg_t *cb_arg = arg; 7026 sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe; 7027 7028 if (cb_arg) { 7029 if (cb_arg->cb) { 7030 if ((status == 0) && mbox_rsp->hdr.status) { 7031 status = mbox_rsp->hdr.status; 7032 } 7033 cb_arg->cb(status, cb_arg->arg); 7034 } 7035 7036 ocs_free(hw->os, cb_arg->mbox_cmd, SLI4_BMBX_SIZE); 7037 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_clear_cb_arg_t)); 7038 } 7039 7040 return 0; 7041 } 7042 7043 /** 7044 * @brief Clear a dump image from the device. 7045 * 7046 * @par Description 7047 * Creates a SLI_CONFIG mailbox command, fills it with the correct values to clear 7048 * the dump, then sends the command with ocs_hw_command(). On completion, 7049 * the callback function ocs_hw_cb_dump_clear() gets called to free the mailbox 7050 * and to signal the caller that the write has completed. 7051 * 7052 * @param hw Hardware context. 7053 * @param cb Pointer to a callback function that is called when the command completes. 7054 * The callback function prototype is 7055 * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>. 7056 * @param arg Pointer to be passed to the callback function. 7057 * 7058 * @return Returns 0 on success, or a non-zero value on failure. 7059 */ 7060 ocs_hw_rtn_e 7061 ocs_hw_dump_clear(ocs_hw_t *hw, ocs_hw_dump_clear_cb_t cb, void *arg) 7062 { 7063 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 7064 uint8_t *mbxdata; 7065 ocs_hw_dump_clear_cb_arg_t *cb_arg; 7066 uint32_t opts = (hw->state == OCS_HW_STATE_ACTIVE ? OCS_CMD_NOWAIT : OCS_CMD_POLL); 7067 7068 if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) { 7069 ocs_log_test(hw->os, "Function only supported for I/F type 2\n"); 7070 return OCS_HW_RTN_ERROR; 7071 } 7072 7073 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7074 if (mbxdata == NULL) { 7075 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7076 return OCS_HW_RTN_NO_MEMORY; 7077 } 7078 7079 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_dump_clear_cb_arg_t), OCS_M_NOWAIT); 7080 if (cb_arg == NULL) { 7081 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7082 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7083 return OCS_HW_RTN_NO_MEMORY; 7084 } 7085 7086 cb_arg->cb = cb; 7087 cb_arg->arg = arg; 7088 cb_arg->mbox_cmd = mbxdata; 7089 7090 if (sli_cmd_common_delete_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 7091 "/dbg/dump.bin")) { 7092 rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_cb_dump_clear, cb_arg); 7093 if (rc == 0 && opts == OCS_CMD_POLL) { 7094 ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE); 7095 rc = ocs_hw_cb_dump_clear(hw, 0, mbxdata, cb_arg); 7096 } 7097 } 7098 7099 if (rc != OCS_HW_RTN_SUCCESS) { 7100 ocs_log_test(hw->os, "COMMON_DELETE_OBJECT failed\n"); 7101 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7102 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_clear_cb_arg_t)); 7103 } 7104 7105 return rc; 7106 } 7107 7108 typedef struct ocs_hw_get_port_protocol_cb_arg_s { 7109 ocs_get_port_protocol_cb_t cb; 7110 void *arg; 7111 uint32_t pci_func; 7112 ocs_dma_t payload; 7113 } ocs_hw_get_port_protocol_cb_arg_t; 7114 7115 /** 7116 * @brief Called for the completion of get_port_profile for a 7117 * user request. 7118 * 7119 * @param hw Hardware context. 7120 * @param status The status from the MQE. 7121 * @param mqe Pointer to mailbox command buffer. 7122 * @param arg Pointer to a callback argument. 7123 * 7124 * @return Returns 0 on success, or a non-zero value on failure. 7125 */ 7126 static int32_t 7127 ocs_hw_get_port_protocol_cb(ocs_hw_t *hw, int32_t status, 7128 uint8_t *mqe, void *arg) 7129 { 7130 ocs_hw_get_port_protocol_cb_arg_t *cb_arg = arg; 7131 ocs_dma_t *payload = &(cb_arg->payload); 7132 sli4_res_common_get_profile_config_t* response = (sli4_res_common_get_profile_config_t*) payload->virt; 7133 ocs_hw_port_protocol_e port_protocol; 7134 int num_descriptors; 7135 sli4_resource_descriptor_v1_t *desc_p; 7136 sli4_pcie_resource_descriptor_v1_t *pcie_desc_p; 7137 int i; 7138 7139 port_protocol = OCS_HW_PORT_PROTOCOL_OTHER; 7140 7141 num_descriptors = response->desc_count; 7142 desc_p = (sli4_resource_descriptor_v1_t *)response->desc; 7143 for (i=0; i<num_descriptors; i++) { 7144 if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) { 7145 pcie_desc_p = (sli4_pcie_resource_descriptor_v1_t*) desc_p; 7146 if (pcie_desc_p->pf_number == cb_arg->pci_func) { 7147 switch(pcie_desc_p->pf_type) { 7148 case 0x02: 7149 port_protocol = OCS_HW_PORT_PROTOCOL_ISCSI; 7150 break; 7151 case 0x04: 7152 port_protocol = OCS_HW_PORT_PROTOCOL_FCOE; 7153 break; 7154 case 0x10: 7155 port_protocol = OCS_HW_PORT_PROTOCOL_FC; 7156 break; 7157 default: 7158 port_protocol = OCS_HW_PORT_PROTOCOL_OTHER; 7159 break; 7160 } 7161 } 7162 } 7163 7164 desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length); 7165 } 7166 7167 if (cb_arg->cb) { 7168 cb_arg->cb(status, port_protocol, cb_arg->arg); 7169 } 7170 7171 ocs_dma_free(hw->os, &cb_arg->payload); 7172 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t)); 7173 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7174 7175 return 0; 7176 } 7177 7178 /** 7179 * @ingroup io 7180 * @brief Get the current port protocol. 7181 * @par Description 7182 * Issues a SLI4 COMMON_GET_PROFILE_CONFIG mailbox. When the 7183 * command completes the provided mgmt callback function is 7184 * called. 7185 * 7186 * @param hw Hardware context. 7187 * @param pci_func PCI function to query for current protocol. 7188 * @param cb Callback function to be called when the command completes. 7189 * @param ul_arg An argument that is passed to the callback function. 7190 * 7191 * @return 7192 * - OCS_HW_RTN_SUCCESS on success. 7193 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7194 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7195 * context. 7196 * - OCS_HW_RTN_ERROR on any other error. 7197 */ 7198 ocs_hw_rtn_e 7199 ocs_hw_get_port_protocol(ocs_hw_t *hw, uint32_t pci_func, 7200 ocs_get_port_protocol_cb_t cb, void* ul_arg) 7201 { 7202 uint8_t *mbxdata; 7203 ocs_hw_get_port_protocol_cb_arg_t *cb_arg; 7204 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7205 7206 /* Only supported on Skyhawk */ 7207 if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) { 7208 return OCS_HW_RTN_ERROR; 7209 } 7210 7211 /* mbxdata holds the header of the command */ 7212 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7213 if (mbxdata == NULL) { 7214 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7215 return OCS_HW_RTN_NO_MEMORY; 7216 } 7217 7218 /* cb_arg holds the data that will be passed to the callback on completion */ 7219 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_port_protocol_cb_arg_t), OCS_M_NOWAIT); 7220 if (cb_arg == NULL) { 7221 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7222 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7223 return OCS_HW_RTN_NO_MEMORY; 7224 } 7225 7226 cb_arg->cb = cb; 7227 cb_arg->arg = ul_arg; 7228 cb_arg->pci_func = pci_func; 7229 7230 /* dma_mem holds the non-embedded portion */ 7231 if (ocs_dma_alloc(hw->os, &cb_arg->payload, 4096, 4)) { 7232 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 7233 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7234 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t)); 7235 return OCS_HW_RTN_NO_MEMORY; 7236 } 7237 7238 if (sli_cmd_common_get_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->payload)) { 7239 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_port_protocol_cb, cb_arg); 7240 } 7241 7242 if (rc != OCS_HW_RTN_SUCCESS) { 7243 ocs_log_test(hw->os, "GET_PROFILE_CONFIG failed\n"); 7244 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7245 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t)); 7246 ocs_dma_free(hw->os, &cb_arg->payload); 7247 } 7248 7249 return rc; 7250 7251 } 7252 7253 typedef struct ocs_hw_set_port_protocol_cb_arg_s { 7254 ocs_set_port_protocol_cb_t cb; 7255 void *arg; 7256 ocs_dma_t payload; 7257 uint32_t new_protocol; 7258 uint32_t pci_func; 7259 } ocs_hw_set_port_protocol_cb_arg_t; 7260 7261 /** 7262 * @brief Called for the completion of set_port_profile for a 7263 * user request. 7264 * 7265 * @par Description 7266 * This is the second of two callbacks for the set_port_protocol 7267 * function. The set operation is a read-modify-write. This 7268 * callback is called when the write (SET_PROFILE_CONFIG) 7269 * completes. 7270 * 7271 * @param hw Hardware context. 7272 * @param status The status from the MQE. 7273 * @param mqe Pointer to mailbox command buffer. 7274 * @param arg Pointer to a callback argument. 7275 * 7276 * @return 0 on success, non-zero otherwise 7277 */ 7278 static int32_t 7279 ocs_hw_set_port_protocol_cb2(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7280 { 7281 ocs_hw_set_port_protocol_cb_arg_t *cb_arg = arg; 7282 7283 if (cb_arg->cb) { 7284 cb_arg->cb( status, cb_arg->arg); 7285 } 7286 7287 ocs_dma_free(hw->os, &(cb_arg->payload)); 7288 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7289 ocs_free(hw->os, arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t)); 7290 7291 return 0; 7292 } 7293 7294 /** 7295 * @brief Called for the completion of set_port_profile for a 7296 * user request. 7297 * 7298 * @par Description 7299 * This is the first of two callbacks for the set_port_protocol 7300 * function. The set operation is a read-modify-write. This 7301 * callback is called when the read completes 7302 * (GET_PROFILE_CONFG). It will updated the resource 7303 * descriptors, then queue the write (SET_PROFILE_CONFIG). 7304 * 7305 * On entry there are three memory areas that were allocated by 7306 * ocs_hw_set_port_protocol. If a failure is detected in this 7307 * function those need to be freed. If this function succeeds 7308 * it allocates three more areas. 7309 * 7310 * @param hw Hardware context. 7311 * @param status The status from the MQE 7312 * @param mqe Pointer to mailbox command buffer. 7313 * @param arg Pointer to a callback argument. 7314 * 7315 * @return Returns 0 on success, or a non-zero value otherwise. 7316 */ 7317 static int32_t 7318 ocs_hw_set_port_protocol_cb1(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7319 { 7320 ocs_hw_set_port_protocol_cb_arg_t *cb_arg = arg; 7321 ocs_dma_t *payload = &(cb_arg->payload); 7322 sli4_res_common_get_profile_config_t* response = (sli4_res_common_get_profile_config_t*) payload->virt; 7323 int num_descriptors; 7324 sli4_resource_descriptor_v1_t *desc_p; 7325 sli4_pcie_resource_descriptor_v1_t *pcie_desc_p; 7326 int i; 7327 ocs_hw_set_port_protocol_cb_arg_t *new_cb_arg; 7328 ocs_hw_port_protocol_e new_protocol; 7329 uint8_t *dst; 7330 sli4_isap_resouce_descriptor_v1_t *isap_desc_p; 7331 uint8_t *mbxdata; 7332 int pci_descriptor_count; 7333 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7334 int num_fcoe_ports = 0; 7335 int num_iscsi_ports = 0; 7336 7337 new_protocol = (ocs_hw_port_protocol_e)cb_arg->new_protocol; 7338 7339 num_descriptors = response->desc_count; 7340 7341 /* Count PCI descriptors */ 7342 pci_descriptor_count = 0; 7343 desc_p = (sli4_resource_descriptor_v1_t *)response->desc; 7344 for (i=0; i<num_descriptors; i++) { 7345 if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) { 7346 ++pci_descriptor_count; 7347 } 7348 desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length); 7349 } 7350 7351 /* mbxdata holds the header of the command */ 7352 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7353 if (mbxdata == NULL) { 7354 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7355 return OCS_HW_RTN_NO_MEMORY; 7356 } 7357 7358 /* cb_arg holds the data that will be passed to the callback on completion */ 7359 new_cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_port_protocol_cb_arg_t), OCS_M_NOWAIT); 7360 if (new_cb_arg == NULL) { 7361 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7362 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7363 return OCS_HW_RTN_NO_MEMORY; 7364 } 7365 7366 new_cb_arg->cb = cb_arg->cb; 7367 new_cb_arg->arg = cb_arg->arg; 7368 7369 /* Allocate memory for the descriptors we're going to send. This is 7370 * one for each PCI descriptor plus one ISAP descriptor. */ 7371 if (ocs_dma_alloc(hw->os, &new_cb_arg->payload, sizeof(sli4_req_common_set_profile_config_t) + 7372 (pci_descriptor_count * sizeof(sli4_pcie_resource_descriptor_v1_t)) + 7373 sizeof(sli4_isap_resouce_descriptor_v1_t), 4)) { 7374 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 7375 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7376 ocs_free(hw->os, new_cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t)); 7377 return OCS_HW_RTN_NO_MEMORY; 7378 } 7379 7380 sli_cmd_common_set_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 7381 &new_cb_arg->payload, 7382 0, pci_descriptor_count+1, 1); 7383 7384 /* Point dst to the first descriptor entry in the SET_PROFILE_CONFIG command */ 7385 dst = (uint8_t *)&(((sli4_req_common_set_profile_config_t *) new_cb_arg->payload.virt)->desc); 7386 7387 /* Loop over all descriptors. If the descriptor is a PCIe descriptor, copy it 7388 * to the SET_PROFILE_CONFIG command to be written back. If it's the descriptor 7389 * that we're trying to change also set its pf_type. 7390 */ 7391 desc_p = (sli4_resource_descriptor_v1_t *)response->desc; 7392 for (i=0; i<num_descriptors; i++) { 7393 if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) { 7394 pcie_desc_p = (sli4_pcie_resource_descriptor_v1_t*) desc_p; 7395 if (pcie_desc_p->pf_number == cb_arg->pci_func) { 7396 /* This is the PCIe descriptor for this OCS instance. 7397 * Update it with the new pf_type */ 7398 switch(new_protocol) { 7399 case OCS_HW_PORT_PROTOCOL_FC: 7400 pcie_desc_p->pf_type = SLI4_PROTOCOL_FC; 7401 break; 7402 case OCS_HW_PORT_PROTOCOL_FCOE: 7403 pcie_desc_p->pf_type = SLI4_PROTOCOL_FCOE; 7404 break; 7405 case OCS_HW_PORT_PROTOCOL_ISCSI: 7406 pcie_desc_p->pf_type = SLI4_PROTOCOL_ISCSI; 7407 break; 7408 default: 7409 pcie_desc_p->pf_type = SLI4_PROTOCOL_DEFAULT; 7410 break; 7411 } 7412 } 7413 7414 if (pcie_desc_p->pf_type == SLI4_PROTOCOL_FCOE) { 7415 ++num_fcoe_ports; 7416 } 7417 if (pcie_desc_p->pf_type == SLI4_PROTOCOL_ISCSI) { 7418 ++num_iscsi_ports; 7419 } 7420 ocs_memcpy(dst, pcie_desc_p, sizeof(sli4_pcie_resource_descriptor_v1_t)); 7421 dst += sizeof(sli4_pcie_resource_descriptor_v1_t); 7422 } 7423 7424 desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length); 7425 } 7426 7427 /* Create an ISAP resource descriptor */ 7428 isap_desc_p = (sli4_isap_resouce_descriptor_v1_t*)dst; 7429 isap_desc_p->descriptor_type = SLI4_RESOURCE_DESCRIPTOR_TYPE_ISAP; 7430 isap_desc_p->descriptor_length = sizeof(sli4_isap_resouce_descriptor_v1_t); 7431 if (num_iscsi_ports > 0) { 7432 isap_desc_p->iscsi_tgt = 1; 7433 isap_desc_p->iscsi_ini = 1; 7434 isap_desc_p->iscsi_dif = 1; 7435 } 7436 if (num_fcoe_ports > 0) { 7437 isap_desc_p->fcoe_tgt = 1; 7438 isap_desc_p->fcoe_ini = 1; 7439 isap_desc_p->fcoe_dif = 1; 7440 } 7441 7442 /* At this point we're done with the memory allocated by ocs_port_set_protocol */ 7443 ocs_dma_free(hw->os, &cb_arg->payload); 7444 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7445 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t)); 7446 7447 /* Send a SET_PROFILE_CONFIG mailbox command with the new descriptors */ 7448 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_port_protocol_cb2, new_cb_arg); 7449 if (rc) { 7450 ocs_log_err(hw->os, "Error posting COMMON_SET_PROFILE_CONFIG\n"); 7451 /* Call the upper level callback to report a failure */ 7452 if (new_cb_arg->cb) { 7453 new_cb_arg->cb( rc, new_cb_arg->arg); 7454 } 7455 7456 /* Free the memory allocated by this function */ 7457 ocs_dma_free(hw->os, &new_cb_arg->payload); 7458 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7459 ocs_free(hw->os, new_cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t)); 7460 } 7461 7462 return rc; 7463 } 7464 7465 /** 7466 * @ingroup io 7467 * @brief Set the port protocol. 7468 * @par Description 7469 * Setting the port protocol is a read-modify-write operation. 7470 * This function submits a GET_PROFILE_CONFIG command to read 7471 * the current settings. The callback function will modify the 7472 * settings and issue the write. 7473 * 7474 * On successful completion this function will have allocated 7475 * two regular memory areas and one dma area which will need to 7476 * get freed later in the callbacks. 7477 * 7478 * @param hw Hardware context. 7479 * @param new_protocol New protocol to use. 7480 * @param pci_func PCI function to configure. 7481 * @param cb Callback function to be called when the command completes. 7482 * @param ul_arg An argument that is passed to the callback function. 7483 * 7484 * @return 7485 * - OCS_HW_RTN_SUCCESS on success. 7486 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7487 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7488 * context. 7489 * - OCS_HW_RTN_ERROR on any other error. 7490 */ 7491 ocs_hw_rtn_e 7492 ocs_hw_set_port_protocol(ocs_hw_t *hw, ocs_hw_port_protocol_e new_protocol, 7493 uint32_t pci_func, ocs_set_port_protocol_cb_t cb, void *ul_arg) 7494 { 7495 uint8_t *mbxdata; 7496 ocs_hw_set_port_protocol_cb_arg_t *cb_arg; 7497 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 7498 7499 /* Only supported on Skyhawk */ 7500 if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) { 7501 return OCS_HW_RTN_ERROR; 7502 } 7503 7504 /* mbxdata holds the header of the command */ 7505 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7506 if (mbxdata == NULL) { 7507 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7508 return OCS_HW_RTN_NO_MEMORY; 7509 } 7510 7511 /* cb_arg holds the data that will be passed to the callback on completion */ 7512 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_port_protocol_cb_arg_t), OCS_M_NOWAIT); 7513 if (cb_arg == NULL) { 7514 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7515 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7516 return OCS_HW_RTN_NO_MEMORY; 7517 } 7518 7519 cb_arg->cb = cb; 7520 cb_arg->arg = ul_arg; 7521 cb_arg->new_protocol = new_protocol; 7522 cb_arg->pci_func = pci_func; 7523 7524 /* dma_mem holds the non-embedded portion */ 7525 if (ocs_dma_alloc(hw->os, &cb_arg->payload, 4096, 4)) { 7526 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 7527 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7528 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t)); 7529 return OCS_HW_RTN_NO_MEMORY; 7530 } 7531 7532 if (sli_cmd_common_get_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->payload)) { 7533 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_port_protocol_cb1, cb_arg); 7534 } 7535 7536 if (rc != OCS_HW_RTN_SUCCESS) { 7537 ocs_log_test(hw->os, "GET_PROFILE_CONFIG failed\n"); 7538 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7539 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t)); 7540 ocs_dma_free(hw->os, &cb_arg->payload); 7541 } 7542 7543 return rc; 7544 } 7545 7546 typedef struct ocs_hw_get_profile_list_cb_arg_s { 7547 ocs_get_profile_list_cb_t cb; 7548 void *arg; 7549 ocs_dma_t payload; 7550 } ocs_hw_get_profile_list_cb_arg_t; 7551 7552 /** 7553 * @brief Called for the completion of get_profile_list for a 7554 * user request. 7555 * @par Description 7556 * This function is called when the COMMMON_GET_PROFILE_LIST 7557 * mailbox completes. The response will be in 7558 * ctx->non_embedded_mem.virt. This function parses the 7559 * response and creates a ocs_hw_profile_list, then calls the 7560 * mgmt_cb callback function and passes that list to it. 7561 * 7562 * @param hw Hardware context. 7563 * @param status The status from the MQE 7564 * @param mqe Pointer to mailbox command buffer. 7565 * @param arg Pointer to a callback argument. 7566 * 7567 * @return Returns 0 on success, or a non-zero value on failure. 7568 */ 7569 static int32_t 7570 ocs_hw_get_profile_list_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7571 { 7572 ocs_hw_profile_list_t *list; 7573 ocs_hw_get_profile_list_cb_arg_t *cb_arg = arg; 7574 ocs_dma_t *payload = &(cb_arg->payload); 7575 sli4_res_common_get_profile_list_t *response = (sli4_res_common_get_profile_list_t *)payload->virt; 7576 int i; 7577 int num_descriptors; 7578 7579 list = ocs_malloc(hw->os, sizeof(ocs_hw_profile_list_t), OCS_M_ZERO); 7580 list->num_descriptors = response->profile_descriptor_count; 7581 7582 num_descriptors = list->num_descriptors; 7583 if (num_descriptors > OCS_HW_MAX_PROFILES) { 7584 num_descriptors = OCS_HW_MAX_PROFILES; 7585 } 7586 7587 for (i=0; i<num_descriptors; i++) { 7588 list->descriptors[i].profile_id = response->profile_descriptor[i].profile_id; 7589 list->descriptors[i].profile_index = response->profile_descriptor[i].profile_index; 7590 ocs_strcpy(list->descriptors[i].profile_description, (char *)response->profile_descriptor[i].profile_description); 7591 } 7592 7593 if (cb_arg->cb) { 7594 cb_arg->cb(status, list, cb_arg->arg); 7595 } else { 7596 ocs_free(hw->os, list, sizeof(*list)); 7597 } 7598 7599 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7600 ocs_dma_free(hw->os, &cb_arg->payload); 7601 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t)); 7602 7603 return 0; 7604 } 7605 7606 /** 7607 * @ingroup io 7608 * @brief Get a list of available profiles. 7609 * @par Description 7610 * Issues a SLI-4 COMMON_GET_PROFILE_LIST mailbox. When the 7611 * command completes the provided mgmt callback function is 7612 * called. 7613 * 7614 * @param hw Hardware context. 7615 * @param cb Callback function to be called when the 7616 * command completes. 7617 * @param ul_arg An argument that is passed to the callback 7618 * function. 7619 * 7620 * @return 7621 * - OCS_HW_RTN_SUCCESS on success. 7622 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7623 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7624 * context. 7625 * - OCS_HW_RTN_ERROR on any other error. 7626 */ 7627 ocs_hw_rtn_e 7628 ocs_hw_get_profile_list(ocs_hw_t *hw, ocs_get_profile_list_cb_t cb, void* ul_arg) 7629 { 7630 uint8_t *mbxdata; 7631 ocs_hw_get_profile_list_cb_arg_t *cb_arg; 7632 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7633 7634 /* Only supported on Skyhawk */ 7635 if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) { 7636 return OCS_HW_RTN_ERROR; 7637 } 7638 7639 /* mbxdata holds the header of the command */ 7640 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7641 if (mbxdata == NULL) { 7642 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7643 return OCS_HW_RTN_NO_MEMORY; 7644 } 7645 7646 /* cb_arg holds the data that will be passed to the callback on completion */ 7647 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_profile_list_cb_arg_t), OCS_M_NOWAIT); 7648 if (cb_arg == NULL) { 7649 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7650 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7651 return OCS_HW_RTN_NO_MEMORY; 7652 } 7653 7654 cb_arg->cb = cb; 7655 cb_arg->arg = ul_arg; 7656 7657 /* dma_mem holds the non-embedded portion */ 7658 if (ocs_dma_alloc(hw->os, &cb_arg->payload, sizeof(sli4_res_common_get_profile_list_t), 4)) { 7659 ocs_log_err(hw->os, "Failed to allocate DMA buffer\n"); 7660 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7661 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t)); 7662 return OCS_HW_RTN_NO_MEMORY; 7663 } 7664 7665 if (sli_cmd_common_get_profile_list(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 0, &cb_arg->payload)) { 7666 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_profile_list_cb, cb_arg); 7667 } 7668 7669 if (rc != OCS_HW_RTN_SUCCESS) { 7670 ocs_log_test(hw->os, "GET_PROFILE_LIST failed\n"); 7671 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7672 ocs_dma_free(hw->os, &cb_arg->payload); 7673 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t)); 7674 } 7675 7676 return rc; 7677 } 7678 7679 typedef struct ocs_hw_get_active_profile_cb_arg_s { 7680 ocs_get_active_profile_cb_t cb; 7681 void *arg; 7682 } ocs_hw_get_active_profile_cb_arg_t; 7683 7684 /** 7685 * @brief Called for the completion of get_active_profile for a 7686 * user request. 7687 * 7688 * @param hw Hardware context. 7689 * @param status The status from the MQE 7690 * @param mqe Pointer to mailbox command buffer. 7691 * @param arg Pointer to a callback argument. 7692 * 7693 * @return Returns 0 on success, or a non-zero value on failure. 7694 */ 7695 static int32_t 7696 ocs_hw_get_active_profile_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7697 { 7698 ocs_hw_get_active_profile_cb_arg_t *cb_arg = arg; 7699 sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe; 7700 sli4_res_common_get_active_profile_t* response = (sli4_res_common_get_active_profile_t*) mbox_rsp->payload.embed; 7701 uint32_t active_profile; 7702 7703 active_profile = response->active_profile_id; 7704 7705 if (cb_arg->cb) { 7706 cb_arg->cb(status, active_profile, cb_arg->arg); 7707 } 7708 7709 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7710 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t)); 7711 7712 return 0; 7713 } 7714 7715 /** 7716 * @ingroup io 7717 * @brief Get the currently active profile. 7718 * @par Description 7719 * Issues a SLI-4 COMMON_GET_ACTIVE_PROFILE mailbox. When the 7720 * command completes the provided mgmt callback function is 7721 * called. 7722 * 7723 * @param hw Hardware context. 7724 * @param cb Callback function to be called when the 7725 * command completes. 7726 * @param ul_arg An argument that is passed to the callback 7727 * function. 7728 * 7729 * @return 7730 * - OCS_HW_RTN_SUCCESS on success. 7731 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7732 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7733 * context. 7734 * - OCS_HW_RTN_ERROR on any other error. 7735 */ 7736 int32_t 7737 ocs_hw_get_active_profile(ocs_hw_t *hw, ocs_get_active_profile_cb_t cb, void* ul_arg) 7738 { 7739 uint8_t *mbxdata; 7740 ocs_hw_get_active_profile_cb_arg_t *cb_arg; 7741 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7742 7743 /* Only supported on Skyhawk */ 7744 if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) { 7745 return OCS_HW_RTN_ERROR; 7746 } 7747 7748 /* mbxdata holds the header of the command */ 7749 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7750 if (mbxdata == NULL) { 7751 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7752 return OCS_HW_RTN_NO_MEMORY; 7753 } 7754 7755 /* cb_arg holds the data that will be passed to the callback on completion */ 7756 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_active_profile_cb_arg_t), OCS_M_NOWAIT); 7757 if (cb_arg == NULL) { 7758 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7759 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7760 return OCS_HW_RTN_NO_MEMORY; 7761 } 7762 7763 cb_arg->cb = cb; 7764 cb_arg->arg = ul_arg; 7765 7766 if (sli_cmd_common_get_active_profile(&hw->sli, mbxdata, SLI4_BMBX_SIZE)) { 7767 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_active_profile_cb, cb_arg); 7768 } 7769 7770 if (rc != OCS_HW_RTN_SUCCESS) { 7771 ocs_log_test(hw->os, "GET_ACTIVE_PROFILE failed\n"); 7772 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7773 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t)); 7774 } 7775 7776 return rc; 7777 } 7778 7779 typedef struct ocs_hw_get_nvparms_cb_arg_s { 7780 ocs_get_nvparms_cb_t cb; 7781 void *arg; 7782 } ocs_hw_get_nvparms_cb_arg_t; 7783 7784 /** 7785 * @brief Called for the completion of get_nvparms for a 7786 * user request. 7787 * 7788 * @param hw Hardware context. 7789 * @param status The status from the MQE. 7790 * @param mqe Pointer to mailbox command buffer. 7791 * @param arg Pointer to a callback argument. 7792 * 7793 * @return 0 on success, non-zero otherwise 7794 */ 7795 static int32_t 7796 ocs_hw_get_nvparms_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7797 { 7798 ocs_hw_get_nvparms_cb_arg_t *cb_arg = arg; 7799 sli4_cmd_read_nvparms_t* mbox_rsp = (sli4_cmd_read_nvparms_t*) mqe; 7800 7801 if (cb_arg->cb) { 7802 cb_arg->cb(status, mbox_rsp->wwpn, mbox_rsp->wwnn, mbox_rsp->hard_alpa, 7803 mbox_rsp->preferred_d_id, cb_arg->arg); 7804 } 7805 7806 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7807 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_nvparms_cb_arg_t)); 7808 7809 return 0; 7810 } 7811 7812 /** 7813 * @ingroup io 7814 * @brief Read non-volatile parms. 7815 * @par Description 7816 * Issues a SLI-4 READ_NVPARMS mailbox. When the 7817 * command completes the provided mgmt callback function is 7818 * called. 7819 * 7820 * @param hw Hardware context. 7821 * @param cb Callback function to be called when the 7822 * command completes. 7823 * @param ul_arg An argument that is passed to the callback 7824 * function. 7825 * 7826 * @return 7827 * - OCS_HW_RTN_SUCCESS on success. 7828 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7829 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7830 * context. 7831 * - OCS_HW_RTN_ERROR on any other error. 7832 */ 7833 int32_t 7834 ocs_hw_get_nvparms(ocs_hw_t *hw, ocs_get_nvparms_cb_t cb, void* ul_arg) 7835 { 7836 uint8_t *mbxdata; 7837 ocs_hw_get_nvparms_cb_arg_t *cb_arg; 7838 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7839 7840 /* mbxdata holds the header of the command */ 7841 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7842 if (mbxdata == NULL) { 7843 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7844 return OCS_HW_RTN_NO_MEMORY; 7845 } 7846 7847 /* cb_arg holds the data that will be passed to the callback on completion */ 7848 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_nvparms_cb_arg_t), OCS_M_NOWAIT); 7849 if (cb_arg == NULL) { 7850 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7851 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7852 return OCS_HW_RTN_NO_MEMORY; 7853 } 7854 7855 cb_arg->cb = cb; 7856 cb_arg->arg = ul_arg; 7857 7858 if (sli_cmd_read_nvparms(&hw->sli, mbxdata, SLI4_BMBX_SIZE)) { 7859 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_nvparms_cb, cb_arg); 7860 } 7861 7862 if (rc != OCS_HW_RTN_SUCCESS) { 7863 ocs_log_test(hw->os, "READ_NVPARMS failed\n"); 7864 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7865 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_nvparms_cb_arg_t)); 7866 } 7867 7868 return rc; 7869 } 7870 7871 typedef struct ocs_hw_set_nvparms_cb_arg_s { 7872 ocs_set_nvparms_cb_t cb; 7873 void *arg; 7874 } ocs_hw_set_nvparms_cb_arg_t; 7875 7876 /** 7877 * @brief Called for the completion of set_nvparms for a 7878 * user request. 7879 * 7880 * @param hw Hardware context. 7881 * @param status The status from the MQE. 7882 * @param mqe Pointer to mailbox command buffer. 7883 * @param arg Pointer to a callback argument. 7884 * 7885 * @return Returns 0 on success, or a non-zero value on failure. 7886 */ 7887 static int32_t 7888 ocs_hw_set_nvparms_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 7889 { 7890 ocs_hw_set_nvparms_cb_arg_t *cb_arg = arg; 7891 7892 if (cb_arg->cb) { 7893 cb_arg->cb(status, cb_arg->arg); 7894 } 7895 7896 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 7897 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_nvparms_cb_arg_t)); 7898 7899 return 0; 7900 } 7901 7902 /** 7903 * @ingroup io 7904 * @brief Write non-volatile parms. 7905 * @par Description 7906 * Issues a SLI-4 WRITE_NVPARMS mailbox. When the 7907 * command completes the provided mgmt callback function is 7908 * called. 7909 * 7910 * @param hw Hardware context. 7911 * @param cb Callback function to be called when the 7912 * command completes. 7913 * @param wwpn Port's WWPN in big-endian order, or NULL to use default. 7914 * @param wwnn Port's WWNN in big-endian order, or NULL to use default. 7915 * @param hard_alpa A hard AL_PA address setting used during loop 7916 * initialization. If no hard AL_PA is required, set to 0. 7917 * @param preferred_d_id A preferred D_ID address setting 7918 * that may be overridden with the CONFIG_LINK mailbox command. 7919 * If there is no preference, set to 0. 7920 * @param ul_arg An argument that is passed to the callback 7921 * function. 7922 * 7923 * @return 7924 * - OCS_HW_RTN_SUCCESS on success. 7925 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 7926 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 7927 * context. 7928 * - OCS_HW_RTN_ERROR on any other error. 7929 */ 7930 int32_t 7931 ocs_hw_set_nvparms(ocs_hw_t *hw, ocs_set_nvparms_cb_t cb, uint8_t *wwpn, 7932 uint8_t *wwnn, uint8_t hard_alpa, uint32_t preferred_d_id, void* ul_arg) 7933 { 7934 uint8_t *mbxdata; 7935 ocs_hw_set_nvparms_cb_arg_t *cb_arg; 7936 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 7937 7938 /* mbxdata holds the header of the command */ 7939 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 7940 if (mbxdata == NULL) { 7941 ocs_log_err(hw->os, "failed to malloc mbox\n"); 7942 return OCS_HW_RTN_NO_MEMORY; 7943 } 7944 7945 /* cb_arg holds the data that will be passed to the callback on completion */ 7946 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_nvparms_cb_arg_t), OCS_M_NOWAIT); 7947 if (cb_arg == NULL) { 7948 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 7949 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7950 return OCS_HW_RTN_NO_MEMORY; 7951 } 7952 7953 cb_arg->cb = cb; 7954 cb_arg->arg = ul_arg; 7955 7956 if (sli_cmd_write_nvparms(&hw->sli, mbxdata, SLI4_BMBX_SIZE, wwpn, wwnn, hard_alpa, preferred_d_id)) { 7957 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_nvparms_cb, cb_arg); 7958 } 7959 7960 if (rc != OCS_HW_RTN_SUCCESS) { 7961 ocs_log_test(hw->os, "SET_NVPARMS failed\n"); 7962 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 7963 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_nvparms_cb_arg_t)); 7964 } 7965 7966 return rc; 7967 } 7968 7969 /** 7970 * @brief Called to obtain the count for the specified type. 7971 * 7972 * @param hw Hardware context. 7973 * @param io_count_type IO count type (inuse, free, wait_free). 7974 * 7975 * @return Returns the number of IOs on the specified list type. 7976 */ 7977 uint32_t 7978 ocs_hw_io_get_count(ocs_hw_t *hw, ocs_hw_io_count_type_e io_count_type) 7979 { 7980 ocs_hw_io_t *io = NULL; 7981 uint32_t count = 0; 7982 7983 ocs_lock(&hw->io_lock); 7984 7985 switch (io_count_type) { 7986 case OCS_HW_IO_INUSE_COUNT : 7987 ocs_list_foreach(&hw->io_inuse, io) { 7988 count++; 7989 } 7990 break; 7991 case OCS_HW_IO_FREE_COUNT : 7992 ocs_list_foreach(&hw->io_free, io) { 7993 count++; 7994 } 7995 break; 7996 case OCS_HW_IO_WAIT_FREE_COUNT : 7997 ocs_list_foreach(&hw->io_wait_free, io) { 7998 count++; 7999 } 8000 break; 8001 case OCS_HW_IO_PORT_OWNED_COUNT: 8002 ocs_list_foreach(&hw->io_port_owned, io) { 8003 count++; 8004 } 8005 break; 8006 case OCS_HW_IO_N_TOTAL_IO_COUNT : 8007 count = hw->config.n_io; 8008 break; 8009 } 8010 8011 ocs_unlock(&hw->io_lock); 8012 8013 return count; 8014 } 8015 8016 /** 8017 * @brief Called to obtain the count of produced RQs. 8018 * 8019 * @param hw Hardware context. 8020 * 8021 * @return Returns the number of RQs produced. 8022 */ 8023 uint32_t 8024 ocs_hw_get_rqes_produced_count(ocs_hw_t *hw) 8025 { 8026 uint32_t count = 0; 8027 uint32_t i; 8028 uint32_t j; 8029 8030 for (i = 0; i < hw->hw_rq_count; i++) { 8031 hw_rq_t *rq = hw->hw_rq[i]; 8032 if (rq->rq_tracker != NULL) { 8033 for (j = 0; j < rq->entry_count; j++) { 8034 if (rq->rq_tracker[j] != NULL) { 8035 count++; 8036 } 8037 } 8038 } 8039 } 8040 8041 return count; 8042 } 8043 8044 typedef struct ocs_hw_set_active_profile_cb_arg_s { 8045 ocs_set_active_profile_cb_t cb; 8046 void *arg; 8047 } ocs_hw_set_active_profile_cb_arg_t; 8048 8049 /** 8050 * @brief Called for the completion of set_active_profile for a 8051 * user request. 8052 * 8053 * @param hw Hardware context. 8054 * @param status The status from the MQE 8055 * @param mqe Pointer to mailbox command buffer. 8056 * @param arg Pointer to a callback argument. 8057 * 8058 * @return Returns 0 on success, or a non-zero value on failure. 8059 */ 8060 static int32_t 8061 ocs_hw_set_active_profile_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 8062 { 8063 ocs_hw_set_active_profile_cb_arg_t *cb_arg = arg; 8064 8065 if (cb_arg->cb) { 8066 cb_arg->cb(status, cb_arg->arg); 8067 } 8068 8069 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 8070 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t)); 8071 8072 return 0; 8073 } 8074 8075 /** 8076 * @ingroup io 8077 * @brief Set the currently active profile. 8078 * @par Description 8079 * Issues a SLI4 COMMON_GET_ACTIVE_PROFILE mailbox. When the 8080 * command completes the provided mgmt callback function is 8081 * called. 8082 * 8083 * @param hw Hardware context. 8084 * @param profile_id Profile ID to activate. 8085 * @param cb Callback function to be called when the command completes. 8086 * @param ul_arg An argument that is passed to the callback function. 8087 * 8088 * @return 8089 * - OCS_HW_RTN_SUCCESS on success. 8090 * - OCS_HW_RTN_NO_MEMORY if a malloc fails. 8091 * - OCS_HW_RTN_NO_RESOURCES if unable to get a command 8092 * context. 8093 * - OCS_HW_RTN_ERROR on any other error. 8094 */ 8095 int32_t 8096 ocs_hw_set_active_profile(ocs_hw_t *hw, ocs_set_active_profile_cb_t cb, uint32_t profile_id, void* ul_arg) 8097 { 8098 uint8_t *mbxdata; 8099 ocs_hw_set_active_profile_cb_arg_t *cb_arg; 8100 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 8101 8102 /* Only supported on Skyhawk */ 8103 if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) { 8104 return OCS_HW_RTN_ERROR; 8105 } 8106 8107 /* mbxdata holds the header of the command */ 8108 mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 8109 if (mbxdata == NULL) { 8110 ocs_log_err(hw->os, "failed to malloc mbox\n"); 8111 return OCS_HW_RTN_NO_MEMORY; 8112 } 8113 8114 /* cb_arg holds the data that will be passed to the callback on completion */ 8115 cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_active_profile_cb_arg_t), OCS_M_NOWAIT); 8116 if (cb_arg == NULL) { 8117 ocs_log_err(hw->os, "failed to malloc cb_arg\n"); 8118 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 8119 return OCS_HW_RTN_NO_MEMORY; 8120 } 8121 8122 cb_arg->cb = cb; 8123 cb_arg->arg = ul_arg; 8124 8125 if (sli_cmd_common_set_active_profile(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 0, profile_id)) { 8126 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_active_profile_cb, cb_arg); 8127 } 8128 8129 if (rc != OCS_HW_RTN_SUCCESS) { 8130 ocs_log_test(hw->os, "SET_ACTIVE_PROFILE failed\n"); 8131 ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE); 8132 ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_active_profile_cb_arg_t)); 8133 } 8134 8135 return rc; 8136 } 8137 8138 /* 8139 * Private functions 8140 */ 8141 8142 /** 8143 * @brief Update the queue hash with the ID and index. 8144 * 8145 * @param hash Pointer to hash table. 8146 * @param id ID that was created. 8147 * @param index The index into the hash object. 8148 */ 8149 static void 8150 ocs_hw_queue_hash_add(ocs_queue_hash_t *hash, uint16_t id, uint16_t index) 8151 { 8152 uint32_t hash_index = id & (OCS_HW_Q_HASH_SIZE - 1); 8153 8154 /* 8155 * Since the hash is always bigger than the number of queues, then we 8156 * never have to worry about an infinite loop. 8157 */ 8158 while(hash[hash_index].in_use) { 8159 hash_index = (hash_index + 1) & (OCS_HW_Q_HASH_SIZE - 1); 8160 } 8161 8162 /* not used, claim the entry */ 8163 hash[hash_index].id = id; 8164 hash[hash_index].in_use = 1; 8165 hash[hash_index].index = index; 8166 } 8167 8168 /** 8169 * @brief Find index given queue ID. 8170 * 8171 * @param hash Pointer to hash table. 8172 * @param id ID to find. 8173 * 8174 * @return Returns the index into the HW cq array or -1 if not found. 8175 */ 8176 int32_t 8177 ocs_hw_queue_hash_find(ocs_queue_hash_t *hash, uint16_t id) 8178 { 8179 int32_t rc = -1; 8180 int32_t index = id & (OCS_HW_Q_HASH_SIZE - 1); 8181 8182 /* 8183 * Since the hash is always bigger than the maximum number of Qs, then we 8184 * never have to worry about an infinite loop. We will always find an 8185 * unused entry. 8186 */ 8187 do { 8188 if (hash[index].in_use && 8189 hash[index].id == id) { 8190 rc = hash[index].index; 8191 } else { 8192 index = (index + 1) & (OCS_HW_Q_HASH_SIZE - 1); 8193 } 8194 } while(rc == -1 && hash[index].in_use); 8195 8196 return rc; 8197 } 8198 8199 static int32_t 8200 ocs_hw_domain_add(ocs_hw_t *hw, ocs_domain_t *domain) 8201 { 8202 int32_t rc = OCS_HW_RTN_ERROR; 8203 uint16_t fcfi = UINT16_MAX; 8204 8205 if ((hw == NULL) || (domain == NULL)) { 8206 ocs_log_err(NULL, "bad parameter hw=%p domain=%p\n", 8207 hw, domain); 8208 return OCS_HW_RTN_ERROR; 8209 } 8210 8211 fcfi = domain->fcf_indicator; 8212 8213 if (fcfi < SLI4_MAX_FCFI) { 8214 uint16_t fcf_index = UINT16_MAX; 8215 8216 ocs_log_debug(hw->os, "adding domain %p @ %#x\n", 8217 domain, fcfi); 8218 hw->domains[fcfi] = domain; 8219 8220 /* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */ 8221 if (hw->workaround.override_fcfi) { 8222 if (hw->first_domain_idx < 0) { 8223 hw->first_domain_idx = fcfi; 8224 } 8225 } 8226 8227 fcf_index = domain->fcf; 8228 8229 if (fcf_index < SLI4_MAX_FCF_INDEX) { 8230 ocs_log_debug(hw->os, "adding map of FCF index %d to FCFI %d\n", 8231 fcf_index, fcfi); 8232 hw->fcf_index_fcfi[fcf_index] = fcfi; 8233 rc = OCS_HW_RTN_SUCCESS; 8234 } else { 8235 ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n", 8236 fcf_index, SLI4_MAX_FCF_INDEX); 8237 hw->domains[fcfi] = NULL; 8238 } 8239 } else { 8240 ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n", 8241 fcfi, SLI4_MAX_FCFI); 8242 } 8243 8244 return rc; 8245 } 8246 8247 static int32_t 8248 ocs_hw_domain_del(ocs_hw_t *hw, ocs_domain_t *domain) 8249 { 8250 int32_t rc = OCS_HW_RTN_ERROR; 8251 uint16_t fcfi = UINT16_MAX; 8252 8253 if ((hw == NULL) || (domain == NULL)) { 8254 ocs_log_err(NULL, "bad parameter hw=%p domain=%p\n", 8255 hw, domain); 8256 return OCS_HW_RTN_ERROR; 8257 } 8258 8259 fcfi = domain->fcf_indicator; 8260 8261 if (fcfi < SLI4_MAX_FCFI) { 8262 uint16_t fcf_index = UINT16_MAX; 8263 8264 ocs_log_debug(hw->os, "deleting domain %p @ %#x\n", 8265 domain, fcfi); 8266 8267 if (domain != hw->domains[fcfi]) { 8268 ocs_log_test(hw->os, "provided domain %p does not match stored domain %p\n", 8269 domain, hw->domains[fcfi]); 8270 return OCS_HW_RTN_ERROR; 8271 } 8272 8273 hw->domains[fcfi] = NULL; 8274 8275 /* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */ 8276 if (hw->workaround.override_fcfi) { 8277 if (hw->first_domain_idx == fcfi) { 8278 hw->first_domain_idx = -1; 8279 } 8280 } 8281 8282 fcf_index = domain->fcf; 8283 8284 if (fcf_index < SLI4_MAX_FCF_INDEX) { 8285 if (hw->fcf_index_fcfi[fcf_index] == fcfi) { 8286 hw->fcf_index_fcfi[fcf_index] = 0; 8287 rc = OCS_HW_RTN_SUCCESS; 8288 } else { 8289 ocs_log_test(hw->os, "indexed FCFI %#x doesn't match provided %#x @ %d\n", 8290 hw->fcf_index_fcfi[fcf_index], fcfi, fcf_index); 8291 } 8292 } else { 8293 ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n", 8294 fcf_index, SLI4_MAX_FCF_INDEX); 8295 } 8296 } else { 8297 ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n", 8298 fcfi, SLI4_MAX_FCFI); 8299 } 8300 8301 return rc; 8302 } 8303 8304 ocs_domain_t * 8305 ocs_hw_domain_get(ocs_hw_t *hw, uint16_t fcfi) 8306 { 8307 8308 if (hw == NULL) { 8309 ocs_log_err(NULL, "bad parameter hw=%p\n", hw); 8310 return NULL; 8311 } 8312 8313 if (fcfi < SLI4_MAX_FCFI) { 8314 return hw->domains[fcfi]; 8315 } else { 8316 ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n", 8317 fcfi, SLI4_MAX_FCFI); 8318 return NULL; 8319 } 8320 } 8321 8322 static ocs_domain_t * 8323 ocs_hw_domain_get_indexed(ocs_hw_t *hw, uint16_t fcf_index) 8324 { 8325 8326 if (hw == NULL) { 8327 ocs_log_err(NULL, "bad parameter hw=%p\n", hw); 8328 return NULL; 8329 } 8330 8331 if (fcf_index < SLI4_MAX_FCF_INDEX) { 8332 return ocs_hw_domain_get(hw, hw->fcf_index_fcfi[fcf_index]); 8333 } else { 8334 ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n", 8335 fcf_index, SLI4_MAX_FCF_INDEX); 8336 return NULL; 8337 } 8338 } 8339 8340 /** 8341 * @brief Quaratine an IO by taking a reference count and adding it to the 8342 * quarantine list. When the IO is popped from the list then the 8343 * count is released and the IO MAY be freed depending on whether 8344 * it is still referenced by the IO. 8345 * 8346 * @n @b Note: BZ 160124 - If this is a target write or an initiator read using 8347 * DIF, then we must add the XRI to a quarantine list until we receive 8348 * 4 more completions of this same type. 8349 * 8350 * @param hw Hardware context. 8351 * @param wq Pointer to the WQ associated with the IO object to quarantine. 8352 * @param io Pointer to the io object to quarantine. 8353 */ 8354 static void 8355 ocs_hw_io_quarantine(ocs_hw_t *hw, hw_wq_t *wq, ocs_hw_io_t *io) 8356 { 8357 ocs_quarantine_info_t *q_info = &wq->quarantine_info; 8358 uint32_t index; 8359 ocs_hw_io_t *free_io = NULL; 8360 8361 /* return if the QX bit was clear */ 8362 if (!io->quarantine) { 8363 return; 8364 } 8365 8366 /* increment the IO refcount to prevent it from being freed before the quarantine is over */ 8367 if (ocs_ref_get_unless_zero(&io->ref) == 0) { 8368 /* command no longer active */ 8369 ocs_log_debug(hw ? hw->os : NULL, 8370 "io not active xri=0x%x tag=0x%x\n", 8371 io->indicator, io->reqtag); 8372 return; 8373 } 8374 8375 sli_queue_lock(wq->queue); 8376 index = q_info->quarantine_index; 8377 free_io = q_info->quarantine_ios[index]; 8378 q_info->quarantine_ios[index] = io; 8379 q_info->quarantine_index = (index + 1) % OCS_HW_QUARANTINE_QUEUE_DEPTH; 8380 sli_queue_unlock(wq->queue); 8381 8382 if (free_io != NULL) { 8383 ocs_ref_put(&free_io->ref); /* ocs_ref_get(): same function */ 8384 } 8385 } 8386 8387 /** 8388 * @brief Process entries on the given completion queue. 8389 * 8390 * @param hw Hardware context. 8391 * @param cq Pointer to the HW completion queue object. 8392 * 8393 * @return None. 8394 */ 8395 void 8396 ocs_hw_cq_process(ocs_hw_t *hw, hw_cq_t *cq) 8397 { 8398 uint8_t cqe[sizeof(sli4_mcqe_t)]; 8399 uint16_t rid = UINT16_MAX; 8400 sli4_qentry_e ctype; /* completion type */ 8401 int32_t status; 8402 uint32_t n_processed = 0; 8403 time_t tstart; 8404 time_t telapsed; 8405 8406 tstart = ocs_msectime(); 8407 8408 while (!sli_queue_read(&hw->sli, cq->queue, cqe)) { 8409 status = sli_cq_parse(&hw->sli, cq->queue, cqe, &ctype, &rid); 8410 /* 8411 * The sign of status is significant. If status is: 8412 * == 0 : call completed correctly and the CQE indicated success 8413 * > 0 : call completed correctly and the CQE indicated an error 8414 * < 0 : call failed and no information is available about the CQE 8415 */ 8416 if (status < 0) { 8417 if (status == -2) { 8418 /* Notification that an entry was consumed, but not completed */ 8419 continue; 8420 } 8421 8422 break; 8423 } 8424 8425 switch (ctype) { 8426 case SLI_QENTRY_ASYNC: 8427 CPUTRACE("async"); 8428 sli_cqe_async(&hw->sli, cqe); 8429 break; 8430 case SLI_QENTRY_MQ: 8431 /* 8432 * Process MQ entry. Note there is no way to determine 8433 * the MQ_ID from the completion entry. 8434 */ 8435 CPUTRACE("mq"); 8436 ocs_hw_mq_process(hw, status, hw->mq); 8437 break; 8438 case SLI_QENTRY_OPT_WRITE_CMD: 8439 ocs_hw_rqpair_process_auto_xfr_rdy_cmd(hw, cq, cqe); 8440 break; 8441 case SLI_QENTRY_OPT_WRITE_DATA: 8442 ocs_hw_rqpair_process_auto_xfr_rdy_data(hw, cq, cqe); 8443 break; 8444 case SLI_QENTRY_WQ: 8445 CPUTRACE("wq"); 8446 ocs_hw_wq_process(hw, cq, cqe, status, rid); 8447 break; 8448 case SLI_QENTRY_WQ_RELEASE: { 8449 uint32_t wq_id = rid; 8450 int32_t index = ocs_hw_queue_hash_find(hw->wq_hash, wq_id); 8451 8452 if (unlikely(index < 0)) { 8453 ocs_log_err(hw->os, "unknown idx=%#x rid=%#x\n", 8454 index, rid); 8455 break; 8456 } 8457 8458 hw_wq_t *wq = hw->hw_wq[index]; 8459 8460 /* Submit any HW IOs that are on the WQ pending list */ 8461 hw_wq_submit_pending(wq, wq->wqec_set_count); 8462 8463 break; 8464 } 8465 8466 case SLI_QENTRY_RQ: 8467 CPUTRACE("rq"); 8468 ocs_hw_rqpair_process_rq(hw, cq, cqe); 8469 break; 8470 case SLI_QENTRY_XABT: { 8471 CPUTRACE("xabt"); 8472 ocs_hw_xabt_process(hw, cq, cqe, rid); 8473 break; 8474 } 8475 default: 8476 ocs_log_test(hw->os, "unhandled ctype=%#x rid=%#x\n", ctype, rid); 8477 break; 8478 } 8479 8480 n_processed++; 8481 if (n_processed == cq->queue->proc_limit) { 8482 break; 8483 } 8484 8485 if (cq->queue->n_posted >= (cq->queue->posted_limit)) { 8486 sli_queue_arm(&hw->sli, cq->queue, FALSE); 8487 } 8488 } 8489 8490 sli_queue_arm(&hw->sli, cq->queue, TRUE); 8491 8492 if (n_processed > cq->queue->max_num_processed) { 8493 cq->queue->max_num_processed = n_processed; 8494 } 8495 telapsed = ocs_msectime() - tstart; 8496 if (telapsed > cq->queue->max_process_time) { 8497 cq->queue->max_process_time = telapsed; 8498 } 8499 } 8500 8501 /** 8502 * @brief Process WQ completion queue entries. 8503 * 8504 * @param hw Hardware context. 8505 * @param cq Pointer to the HW completion queue object. 8506 * @param cqe Pointer to WQ completion queue. 8507 * @param status Completion status. 8508 * @param rid Resource ID (IO tag). 8509 * 8510 * @return none 8511 */ 8512 void 8513 ocs_hw_wq_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, int32_t status, uint16_t rid) 8514 { 8515 hw_wq_callback_t *wqcb; 8516 8517 ocs_queue_history_cqe(&hw->q_hist, SLI_QENTRY_WQ, (void *)cqe, ((sli4_fc_wcqe_t *)cqe)->status, cq->queue->id, 8518 ((cq->queue->index - 1) & (cq->queue->length - 1))); 8519 8520 if(rid == OCS_HW_REQUE_XRI_REGTAG) { 8521 if(status) { 8522 ocs_log_err(hw->os, "reque xri failed, status = %d \n", status); 8523 } 8524 return; 8525 } 8526 8527 wqcb = ocs_hw_reqtag_get_instance(hw, rid); 8528 if (wqcb == NULL) { 8529 ocs_log_err(hw->os, "invalid request tag: x%x\n", rid); 8530 return; 8531 } 8532 8533 if (wqcb->callback == NULL) { 8534 ocs_log_err(hw->os, "wqcb callback is NULL\n"); 8535 return; 8536 } 8537 8538 (*wqcb->callback)(wqcb->arg, cqe, status); 8539 } 8540 8541 /** 8542 * @brief Process WQ completions for IO requests 8543 * 8544 * @param arg Generic callback argument 8545 * @param cqe Pointer to completion queue entry 8546 * @param status Completion status 8547 * 8548 * @par Description 8549 * @n @b Note: Regarding io->reqtag, the reqtag is assigned once when HW IOs are initialized 8550 * in ocs_hw_setup_io(), and don't need to be returned to the hw->wq_reqtag_pool. 8551 * 8552 * @return None. 8553 */ 8554 static void 8555 ocs_hw_wq_process_io(void *arg, uint8_t *cqe, int32_t status) 8556 { 8557 ocs_hw_io_t *io = arg; 8558 ocs_hw_t *hw = io->hw; 8559 sli4_fc_wcqe_t *wcqe = (void *)cqe; 8560 uint32_t len = 0; 8561 uint32_t ext = 0; 8562 uint8_t out_of_order_axr_cmd = 0; 8563 uint8_t out_of_order_axr_data = 0; 8564 uint8_t lock_taken = 0; 8565 #if defined(OCS_DISC_SPIN_DELAY) 8566 uint32_t delay = 0; 8567 char prop_buf[32]; 8568 #endif 8569 8570 /* 8571 * For the primary IO, this will also be used for the 8572 * response. So it is important to only set/clear this 8573 * flag on the first data phase of the IO because 8574 * subsequent phases will be done on the secondary XRI. 8575 */ 8576 if (io->quarantine && io->quarantine_first_phase) { 8577 io->quarantine = (wcqe->qx == 1); 8578 ocs_hw_io_quarantine(hw, io->wq, io); 8579 } 8580 io->quarantine_first_phase = FALSE; 8581 8582 /* BZ 161832 - free secondary HW IO */ 8583 if (io->sec_hio != NULL && 8584 io->sec_hio->quarantine) { 8585 /* 8586 * If the quarantine flag is set on the 8587 * IO, then set it on the secondary IO 8588 * based on the quarantine XRI (QX) bit 8589 * sent by the FW. 8590 */ 8591 io->sec_hio->quarantine = (wcqe->qx == 1); 8592 /* use the primary io->wq because it is not set on the secondary IO. */ 8593 ocs_hw_io_quarantine(hw, io->wq, io->sec_hio); 8594 } 8595 8596 ocs_hw_remove_io_timed_wqe(hw, io); 8597 8598 /* clear xbusy flag if WCQE[XB] is clear */ 8599 if (io->xbusy && wcqe->xb == 0) { 8600 io->xbusy = FALSE; 8601 } 8602 8603 /* get extended CQE status */ 8604 switch (io->type) { 8605 case OCS_HW_BLS_ACC: 8606 case OCS_HW_BLS_ACC_SID: 8607 break; 8608 case OCS_HW_ELS_REQ: 8609 sli_fc_els_did(&hw->sli, cqe, &ext); 8610 len = sli_fc_response_length(&hw->sli, cqe); 8611 break; 8612 case OCS_HW_ELS_RSP: 8613 case OCS_HW_ELS_RSP_SID: 8614 case OCS_HW_FC_CT_RSP: 8615 break; 8616 case OCS_HW_FC_CT: 8617 len = sli_fc_response_length(&hw->sli, cqe); 8618 break; 8619 case OCS_HW_IO_TARGET_WRITE: 8620 len = sli_fc_io_length(&hw->sli, cqe); 8621 #if defined(OCS_DISC_SPIN_DELAY) 8622 if (ocs_get_property("disk_spin_delay", prop_buf, sizeof(prop_buf)) == 0) { 8623 delay = ocs_strtoul(prop_buf, 0, 0); 8624 ocs_udelay(delay); 8625 } 8626 #endif 8627 break; 8628 case OCS_HW_IO_TARGET_READ: 8629 len = sli_fc_io_length(&hw->sli, cqe); 8630 /* 8631 * if_type == 2 seems to return 0 "total length placed" on 8632 * FCP_TSEND64_WQE completions. If this appears to happen, 8633 * use the CTIO data transfer length instead. 8634 */ 8635 if (hw->workaround.retain_tsend_io_length && !len && !status) { 8636 len = io->length; 8637 } 8638 8639 break; 8640 case OCS_HW_IO_TARGET_RSP: 8641 if(io->is_port_owned) { 8642 ocs_lock(&io->axr_lock); 8643 lock_taken = 1; 8644 if(io->axr_buf->call_axr_cmd) { 8645 out_of_order_axr_cmd = 1; 8646 } 8647 if(io->axr_buf->call_axr_data) { 8648 out_of_order_axr_data = 1; 8649 } 8650 } 8651 break; 8652 case OCS_HW_IO_INITIATOR_READ: 8653 len = sli_fc_io_length(&hw->sli, cqe); 8654 break; 8655 case OCS_HW_IO_INITIATOR_WRITE: 8656 len = sli_fc_io_length(&hw->sli, cqe); 8657 break; 8658 case OCS_HW_IO_INITIATOR_NODATA: 8659 break; 8660 case OCS_HW_IO_DNRX_REQUEUE: 8661 /* release the count for re-posting the buffer */ 8662 //ocs_hw_io_free(hw, io); 8663 break; 8664 default: 8665 ocs_log_test(hw->os, "XXX unhandled io type %#x for XRI 0x%x\n", 8666 io->type, io->indicator); 8667 break; 8668 } 8669 if (status) { 8670 ext = sli_fc_ext_status(&hw->sli, cqe); 8671 /* Emulate IAAB=0 for initiator WQEs only; i.e. automatically 8672 * abort exchange if an error occurred and exchange is still busy. 8673 */ 8674 if (hw->config.i_only_aab && 8675 (ocs_hw_iotype_is_originator(io->type)) && 8676 (ocs_hw_wcqe_abort_needed(status, ext, wcqe->xb))) { 8677 ocs_hw_rtn_e rc; 8678 8679 ocs_log_debug(hw->os, "aborting xri=%#x tag=%#x\n", 8680 io->indicator, io->reqtag); 8681 /* 8682 * Because the initiator will not issue another IO phase, then it is OK to to issue the 8683 * callback on the abort completion, but for consistency with the target, wait for the 8684 * XRI_ABORTED CQE to issue the IO callback. 8685 */ 8686 rc = ocs_hw_io_abort(hw, io, TRUE, NULL, NULL); 8687 8688 if (rc == OCS_HW_RTN_SUCCESS) { 8689 /* latch status to return after abort is complete */ 8690 io->status_saved = 1; 8691 io->saved_status = status; 8692 io->saved_ext = ext; 8693 io->saved_len = len; 8694 goto exit_ocs_hw_wq_process_io; 8695 } else if (rc == OCS_HW_RTN_IO_ABORT_IN_PROGRESS) { 8696 /* 8697 * Already being aborted by someone else (ABTS 8698 * perhaps). Just fall through and return original 8699 * error. 8700 */ 8701 ocs_log_debug(hw->os, "abort in progress xri=%#x tag=%#x\n", 8702 io->indicator, io->reqtag); 8703 8704 } else { 8705 /* Failed to abort for some other reason, log error */ 8706 ocs_log_test(hw->os, "Failed to abort xri=%#x tag=%#x rc=%d\n", 8707 io->indicator, io->reqtag, rc); 8708 } 8709 } 8710 8711 /* 8712 * If we're not an originator IO, and XB is set, then issue abort for the IO from within the HW 8713 */ 8714 if ( (! ocs_hw_iotype_is_originator(io->type)) && wcqe->xb) { 8715 ocs_hw_rtn_e rc; 8716 8717 ocs_log_debug(hw->os, "aborting xri=%#x tag=%#x\n", io->indicator, io->reqtag); 8718 8719 /* 8720 * Because targets may send a response when the IO completes using the same XRI, we must 8721 * wait for the XRI_ABORTED CQE to issue the IO callback 8722 */ 8723 rc = ocs_hw_io_abort(hw, io, FALSE, NULL, NULL); 8724 if (rc == OCS_HW_RTN_SUCCESS) { 8725 /* latch status to return after abort is complete */ 8726 io->status_saved = 1; 8727 io->saved_status = status; 8728 io->saved_ext = ext; 8729 io->saved_len = len; 8730 goto exit_ocs_hw_wq_process_io; 8731 } else if (rc == OCS_HW_RTN_IO_ABORT_IN_PROGRESS) { 8732 /* 8733 * Already being aborted by someone else (ABTS 8734 * perhaps). Just fall through and return original 8735 * error. 8736 */ 8737 ocs_log_debug(hw->os, "abort in progress xri=%#x tag=%#x\n", 8738 io->indicator, io->reqtag); 8739 8740 } else { 8741 /* Failed to abort for some other reason, log error */ 8742 ocs_log_test(hw->os, "Failed to abort xri=%#x tag=%#x rc=%d\n", 8743 io->indicator, io->reqtag, rc); 8744 } 8745 } 8746 } 8747 /* BZ 161832 - free secondary HW IO */ 8748 if (io->sec_hio != NULL) { 8749 ocs_hw_io_free(hw, io->sec_hio); 8750 io->sec_hio = NULL; 8751 } 8752 8753 if (io->done != NULL) { 8754 ocs_hw_done_t done = io->done; 8755 void *arg = io->arg; 8756 8757 io->done = NULL; 8758 8759 if (io->status_saved) { 8760 /* use latched status if exists */ 8761 status = io->saved_status; 8762 len = io->saved_len; 8763 ext = io->saved_ext; 8764 io->status_saved = 0; 8765 } 8766 8767 /* Restore default SGL */ 8768 ocs_hw_io_restore_sgl(hw, io); 8769 done(io, io->rnode, len, status, ext, arg); 8770 } 8771 8772 if(out_of_order_axr_cmd) { 8773 /* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */ 8774 if (hw->config.bounce) { 8775 fc_header_t *hdr = io->axr_buf->cmd_seq->header->dma.virt; 8776 uint32_t s_id = fc_be24toh(hdr->s_id); 8777 uint32_t d_id = fc_be24toh(hdr->d_id); 8778 uint32_t ox_id = ocs_be16toh(hdr->ox_id); 8779 if (hw->callback.bounce != NULL) { 8780 (*hw->callback.bounce)(ocs_hw_unsol_process_bounce, io->axr_buf->cmd_seq, s_id, d_id, ox_id); 8781 } 8782 }else { 8783 hw->callback.unsolicited(hw->args.unsolicited, io->axr_buf->cmd_seq); 8784 } 8785 8786 if(out_of_order_axr_data) { 8787 /* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */ 8788 if (hw->config.bounce) { 8789 fc_header_t *hdr = io->axr_buf->seq.header->dma.virt; 8790 uint32_t s_id = fc_be24toh(hdr->s_id); 8791 uint32_t d_id = fc_be24toh(hdr->d_id); 8792 uint32_t ox_id = ocs_be16toh(hdr->ox_id); 8793 if (hw->callback.bounce != NULL) { 8794 (*hw->callback.bounce)(ocs_hw_unsol_process_bounce, &io->axr_buf->seq, s_id, d_id, ox_id); 8795 } 8796 }else { 8797 hw->callback.unsolicited(hw->args.unsolicited, &io->axr_buf->seq); 8798 } 8799 } 8800 } 8801 8802 exit_ocs_hw_wq_process_io: 8803 if(lock_taken) { 8804 ocs_unlock(&io->axr_lock); 8805 } 8806 } 8807 8808 /** 8809 * @brief Process WQ completions for abort requests. 8810 * 8811 * @param arg Generic callback argument. 8812 * @param cqe Pointer to completion queue entry. 8813 * @param status Completion status. 8814 * 8815 * @return None. 8816 */ 8817 static void 8818 ocs_hw_wq_process_abort(void *arg, uint8_t *cqe, int32_t status) 8819 { 8820 ocs_hw_io_t *io = arg; 8821 ocs_hw_t *hw = io->hw; 8822 uint32_t ext = 0; 8823 uint32_t len = 0; 8824 hw_wq_callback_t *wqcb; 8825 8826 /* 8827 * For IOs that were aborted internally, we may need to issue the callback here depending 8828 * on whether a XRI_ABORTED CQE is expected ot not. If the status is Local Reject/No XRI, then 8829 * issue the callback now. 8830 */ 8831 ext = sli_fc_ext_status(&hw->sli, cqe); 8832 if (status == SLI4_FC_WCQE_STATUS_LOCAL_REJECT && 8833 ext == SLI4_FC_LOCAL_REJECT_NO_XRI && 8834 io->done != NULL) { 8835 ocs_hw_done_t done = io->done; 8836 void *arg = io->arg; 8837 8838 io->done = NULL; 8839 8840 /* 8841 * Use latched status as this is always saved for an internal abort 8842 * 8843 * Note: We wont have both a done and abort_done function, so don't worry about 8844 * clobbering the len, status and ext fields. 8845 */ 8846 status = io->saved_status; 8847 len = io->saved_len; 8848 ext = io->saved_ext; 8849 io->status_saved = 0; 8850 done(io, io->rnode, len, status, ext, arg); 8851 } 8852 8853 if (io->abort_done != NULL) { 8854 ocs_hw_done_t done = io->abort_done; 8855 void *arg = io->abort_arg; 8856 8857 io->abort_done = NULL; 8858 8859 done(io, io->rnode, len, status, ext, arg); 8860 } 8861 ocs_lock(&hw->io_abort_lock); 8862 /* clear abort bit to indicate abort is complete */ 8863 io->abort_in_progress = 0; 8864 ocs_unlock(&hw->io_abort_lock); 8865 8866 /* Free the WQ callback */ 8867 ocs_hw_assert(io->abort_reqtag != UINT32_MAX); 8868 wqcb = ocs_hw_reqtag_get_instance(hw, io->abort_reqtag); 8869 ocs_hw_reqtag_free(hw, wqcb); 8870 8871 /* 8872 * Call ocs_hw_io_free() because this releases the WQ reservation as 8873 * well as doing the refcount put. Don't duplicate the code here. 8874 */ 8875 (void)ocs_hw_io_free(hw, io); 8876 } 8877 8878 /** 8879 * @brief Process XABT completions 8880 * 8881 * @param hw Hardware context. 8882 * @param cq Pointer to the HW completion queue object. 8883 * @param cqe Pointer to WQ completion queue. 8884 * @param rid Resource ID (IO tag). 8885 * 8886 * 8887 * @return None. 8888 */ 8889 void 8890 ocs_hw_xabt_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, uint16_t rid) 8891 { 8892 /* search IOs wait free list */ 8893 ocs_hw_io_t *io = NULL; 8894 8895 io = ocs_hw_io_lookup(hw, rid); 8896 8897 ocs_queue_history_cqe(&hw->q_hist, SLI_QENTRY_XABT, (void *)cqe, 0, cq->queue->id, 8898 ((cq->queue->index - 1) & (cq->queue->length - 1))); 8899 if (io == NULL) { 8900 /* IO lookup failure should never happen */ 8901 ocs_log_err(hw->os, "Error: xabt io lookup failed rid=%#x\n", rid); 8902 return; 8903 } 8904 8905 if (!io->xbusy) { 8906 ocs_log_debug(hw->os, "xabt io not busy rid=%#x\n", rid); 8907 } else { 8908 /* mark IO as no longer busy */ 8909 io->xbusy = FALSE; 8910 } 8911 8912 if (io->is_port_owned) { 8913 ocs_lock(&hw->io_lock); 8914 /* Take reference so that below callback will not free io before reque */ 8915 ocs_ref_get(&io->ref); 8916 ocs_unlock(&hw->io_lock); 8917 } 8918 8919 /* For IOs that were aborted internally, we need to issue any pending callback here. */ 8920 if (io->done != NULL) { 8921 ocs_hw_done_t done = io->done; 8922 void *arg = io->arg; 8923 8924 /* Use latched status as this is always saved for an internal abort */ 8925 int32_t status = io->saved_status; 8926 uint32_t len = io->saved_len; 8927 uint32_t ext = io->saved_ext; 8928 8929 io->done = NULL; 8930 io->status_saved = 0; 8931 8932 done(io, io->rnode, len, status, ext, arg); 8933 } 8934 8935 /* Check to see if this is a port owned XRI */ 8936 if (io->is_port_owned) { 8937 ocs_lock(&hw->io_lock); 8938 ocs_hw_reque_xri(hw, io); 8939 ocs_unlock(&hw->io_lock); 8940 /* Not hanlding reque xri completion, free io */ 8941 ocs_hw_io_free(hw, io); 8942 return; 8943 } 8944 8945 ocs_lock(&hw->io_lock); 8946 if ((io->state == OCS_HW_IO_STATE_INUSE) || (io->state == OCS_HW_IO_STATE_WAIT_FREE)) { 8947 /* if on wait_free list, caller has already freed IO; 8948 * remove from wait_free list and add to free list. 8949 * if on in-use list, already marked as no longer busy; 8950 * just leave there and wait for caller to free. 8951 */ 8952 if (io->state == OCS_HW_IO_STATE_WAIT_FREE) { 8953 io->state = OCS_HW_IO_STATE_FREE; 8954 ocs_list_remove(&hw->io_wait_free, io); 8955 ocs_hw_io_free_move_correct_list(hw, io); 8956 } 8957 } 8958 ocs_unlock(&hw->io_lock); 8959 } 8960 8961 /** 8962 * @brief Adjust the number of WQs and CQs within the HW. 8963 * 8964 * @par Description 8965 * Calculates the number of WQs and associated CQs needed in the HW based on 8966 * the number of IOs. Calculates the starting CQ index for each WQ, RQ and 8967 * MQ. 8968 * 8969 * @param hw Hardware context allocated by the caller. 8970 */ 8971 static void 8972 ocs_hw_adjust_wqs(ocs_hw_t *hw) 8973 { 8974 uint32_t max_wq_num = sli_get_max_queue(&hw->sli, SLI_QTYPE_WQ); 8975 uint32_t max_wq_entries = hw->num_qentries[SLI_QTYPE_WQ]; 8976 uint32_t max_cq_entries = hw->num_qentries[SLI_QTYPE_CQ]; 8977 8978 /* 8979 * possibly adjust the the size of the WQs so that the CQ is twice as 8980 * big as the WQ to allow for 2 completions per IO. This allows us to 8981 * handle multi-phase as well as aborts. 8982 */ 8983 if (max_cq_entries < max_wq_entries * 2) { 8984 max_wq_entries = hw->num_qentries[SLI_QTYPE_WQ] = max_cq_entries / 2; 8985 } 8986 8987 /* 8988 * Calculate the number of WQs to use base on the number of IOs. 8989 * 8990 * Note: We need to reserve room for aborts which must be sent down 8991 * the same WQ as the IO. So we allocate enough WQ space to 8992 * handle 2 times the number of IOs. Half of the space will be 8993 * used for normal IOs and the other hwf is reserved for aborts. 8994 */ 8995 hw->config.n_wq = ((hw->config.n_io * 2) + (max_wq_entries - 1)) / max_wq_entries; 8996 8997 /* 8998 * For performance reasons, it is best to use use a minimum of 4 WQs 8999 * for BE3 and Skyhawk. 9000 */ 9001 if (hw->config.n_wq < 4 && 9002 SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) { 9003 hw->config.n_wq = 4; 9004 } 9005 9006 /* 9007 * For dual-chute support, we need to have at least one WQ per chute. 9008 */ 9009 if (hw->config.n_wq < 2 && 9010 ocs_hw_get_num_chutes(hw) > 1) { 9011 hw->config.n_wq = 2; 9012 } 9013 9014 /* make sure we haven't exceeded the max supported in the HW */ 9015 if (hw->config.n_wq > OCS_HW_MAX_NUM_WQ) { 9016 hw->config.n_wq = OCS_HW_MAX_NUM_WQ; 9017 } 9018 9019 /* make sure we haven't exceeded the chip maximum */ 9020 if (hw->config.n_wq > max_wq_num) { 9021 hw->config.n_wq = max_wq_num; 9022 } 9023 9024 /* 9025 * Using Queue Topology string, we divide by number of chutes 9026 */ 9027 hw->config.n_wq /= ocs_hw_get_num_chutes(hw); 9028 } 9029 9030 static int32_t 9031 ocs_hw_command_process(ocs_hw_t *hw, int32_t status, uint8_t *mqe, size_t size) 9032 { 9033 ocs_command_ctx_t *ctx = NULL; 9034 9035 ocs_lock(&hw->cmd_lock); 9036 if (NULL == (ctx = ocs_list_remove_head(&hw->cmd_head))) { 9037 ocs_log_err(hw->os, "XXX no command context?!?\n"); 9038 ocs_unlock(&hw->cmd_lock); 9039 return -1; 9040 } 9041 9042 hw->cmd_head_count--; 9043 9044 /* Post any pending requests */ 9045 ocs_hw_cmd_submit_pending(hw); 9046 9047 ocs_unlock(&hw->cmd_lock); 9048 9049 if (ctx->cb) { 9050 if (ctx->buf) { 9051 ocs_memcpy(ctx->buf, mqe, size); 9052 } 9053 ctx->cb(hw, status, ctx->buf, ctx->arg); 9054 } 9055 9056 ocs_memset(ctx, 0, sizeof(ocs_command_ctx_t)); 9057 ocs_free(hw->os, ctx, sizeof(ocs_command_ctx_t)); 9058 9059 return 0; 9060 } 9061 9062 /** 9063 * @brief Process entries on the given mailbox queue. 9064 * 9065 * @param hw Hardware context. 9066 * @param status CQE status. 9067 * @param mq Pointer to the mailbox queue object. 9068 * 9069 * @return Returns 0 on success, or a non-zero value on failure. 9070 */ 9071 static int32_t 9072 ocs_hw_mq_process(ocs_hw_t *hw, int32_t status, sli4_queue_t *mq) 9073 { 9074 uint8_t mqe[SLI4_BMBX_SIZE]; 9075 9076 if (!sli_queue_read(&hw->sli, mq, mqe)) { 9077 ocs_hw_command_process(hw, status, mqe, mq->size); 9078 } 9079 9080 return 0; 9081 } 9082 9083 /** 9084 * @brief Read a FCF table entry. 9085 * 9086 * @param hw Hardware context. 9087 * @param index Table index to read. Use SLI4_FCOE_FCF_TABLE_FIRST for the first 9088 * read and the next_index field from the FCOE_READ_FCF_TABLE command 9089 * for subsequent reads. 9090 * 9091 * @return Returns 0 on success, or a non-zero value on failure. 9092 */ 9093 static ocs_hw_rtn_e 9094 ocs_hw_read_fcf(ocs_hw_t *hw, uint32_t index) 9095 { 9096 uint8_t *buf = NULL; 9097 int32_t rc = OCS_HW_RTN_ERROR; 9098 9099 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 9100 if (!buf) { 9101 ocs_log_err(hw->os, "no buffer for command\n"); 9102 return OCS_HW_RTN_NO_MEMORY; 9103 } 9104 9105 if (sli_cmd_fcoe_read_fcf_table(&hw->sli, buf, SLI4_BMBX_SIZE, &hw->fcf_dmem, 9106 index)) { 9107 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_read_fcf, &hw->fcf_dmem); 9108 } 9109 9110 if (rc != OCS_HW_RTN_SUCCESS) { 9111 ocs_log_test(hw->os, "FCOE_READ_FCF_TABLE failed\n"); 9112 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 9113 } 9114 9115 return rc; 9116 } 9117 9118 /** 9119 * @brief Callback function for the FCOE_READ_FCF_TABLE command. 9120 * 9121 * @par Description 9122 * Note that the caller has allocated: 9123 * - DMA memory to hold the table contents 9124 * - DMA memory structure 9125 * - Command/results buffer 9126 * . 9127 * Each of these must be freed here. 9128 * 9129 * @param hw Hardware context. 9130 * @param status Hardware status. 9131 * @param mqe Pointer to the mailbox command/results buffer. 9132 * @param arg Pointer to the DMA memory structure. 9133 * 9134 * @return Returns 0 on success, or a non-zero value on failure. 9135 */ 9136 static int32_t 9137 ocs_hw_cb_read_fcf(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 9138 { 9139 ocs_dma_t *dma = arg; 9140 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 9141 9142 if (status || hdr->status) { 9143 ocs_log_test(hw->os, "bad status cqe=%#x mqe=%#x\n", 9144 status, hdr->status); 9145 } else if (dma->virt) { 9146 sli4_res_fcoe_read_fcf_table_t *read_fcf = dma->virt; 9147 9148 /* if FC or FCOE and FCF entry valid, process it */ 9149 if (read_fcf->fcf_entry.fc || 9150 (read_fcf->fcf_entry.val && !read_fcf->fcf_entry.sol)) { 9151 if (hw->callback.domain != NULL) { 9152 ocs_domain_record_t drec = {0}; 9153 9154 if (read_fcf->fcf_entry.fc) { 9155 /* 9156 * This is a pseudo FCF entry. Create a domain 9157 * record based on the read topology information 9158 */ 9159 drec.speed = hw->link.speed; 9160 drec.fc_id = hw->link.fc_id; 9161 drec.is_fc = TRUE; 9162 if (SLI_LINK_TOPO_LOOP == hw->link.topology) { 9163 drec.is_loop = TRUE; 9164 ocs_memcpy(drec.map.loop, hw->link.loop_map, 9165 sizeof(drec.map.loop)); 9166 } else if (SLI_LINK_TOPO_NPORT == hw->link.topology) { 9167 drec.is_nport = TRUE; 9168 } 9169 } else { 9170 drec.index = read_fcf->fcf_entry.fcf_index; 9171 drec.priority = read_fcf->fcf_entry.fip_priority; 9172 9173 /* copy address, wwn and vlan_bitmap */ 9174 ocs_memcpy(drec.address, read_fcf->fcf_entry.fcf_mac_address, 9175 sizeof(drec.address)); 9176 ocs_memcpy(drec.wwn, read_fcf->fcf_entry.fabric_name_id, 9177 sizeof(drec.wwn)); 9178 ocs_memcpy(drec.map.vlan, read_fcf->fcf_entry.vlan_bitmap, 9179 sizeof(drec.map.vlan)); 9180 9181 drec.is_ethernet = TRUE; 9182 drec.is_nport = TRUE; 9183 } 9184 9185 hw->callback.domain(hw->args.domain, 9186 OCS_HW_DOMAIN_FOUND, 9187 &drec); 9188 } 9189 } else { 9190 /* if FCOE and FCF is not valid, ignore it */ 9191 ocs_log_test(hw->os, "ignore invalid FCF entry\n"); 9192 } 9193 9194 if (SLI4_FCOE_FCF_TABLE_LAST != read_fcf->next_index) { 9195 ocs_hw_read_fcf(hw, read_fcf->next_index); 9196 } 9197 } 9198 9199 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9200 //ocs_dma_free(hw->os, dma); 9201 //ocs_free(hw->os, dma, sizeof(ocs_dma_t)); 9202 9203 return 0; 9204 } 9205 9206 /** 9207 * @brief Callback function for the SLI link events. 9208 * 9209 * @par Description 9210 * This function allocates memory which must be freed in its callback. 9211 * 9212 * @param ctx Hardware context pointer (that is, ocs_hw_t *). 9213 * @param e Event structure pointer (that is, sli4_link_event_t *). 9214 * 9215 * @return Returns 0 on success, or a non-zero value on failure. 9216 */ 9217 static int32_t 9218 ocs_hw_cb_link(void *ctx, void *e) 9219 { 9220 ocs_hw_t *hw = ctx; 9221 sli4_link_event_t *event = e; 9222 ocs_domain_t *d = NULL; 9223 uint32_t i = 0; 9224 int32_t rc = OCS_HW_RTN_ERROR; 9225 ocs_t *ocs = hw->os; 9226 9227 ocs_hw_link_event_init(hw); 9228 9229 switch (event->status) { 9230 case SLI_LINK_STATUS_UP: 9231 9232 hw->link = *event; 9233 9234 if (SLI_LINK_TOPO_NPORT == event->topology) { 9235 device_printf(ocs->dev, "Link Up, NPORT, speed is %d\n", event->speed); 9236 ocs_hw_read_fcf(hw, SLI4_FCOE_FCF_TABLE_FIRST); 9237 } else if (SLI_LINK_TOPO_LOOP == event->topology) { 9238 uint8_t *buf = NULL; 9239 device_printf(ocs->dev, "Link Up, LOOP, speed is %d\n", event->speed); 9240 9241 buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 9242 if (!buf) { 9243 ocs_log_err(hw->os, "no buffer for command\n"); 9244 break; 9245 } 9246 9247 if (sli_cmd_read_topology(&hw->sli, buf, SLI4_BMBX_SIZE, &hw->loop_map)) { 9248 rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, __ocs_read_topology_cb, NULL); 9249 } 9250 9251 if (rc != OCS_HW_RTN_SUCCESS) { 9252 ocs_log_test(hw->os, "READ_TOPOLOGY failed\n"); 9253 ocs_free(hw->os, buf, SLI4_BMBX_SIZE); 9254 } 9255 } else { 9256 device_printf(ocs->dev, "Link Up, unsupported topology (%#x), speed is %d\n", 9257 event->topology, event->speed); 9258 } 9259 break; 9260 case SLI_LINK_STATUS_DOWN: 9261 device_printf(ocs->dev, "Link Down\n"); 9262 9263 hw->link.status = event->status; 9264 9265 for (i = 0; i < SLI4_MAX_FCFI; i++) { 9266 d = hw->domains[i]; 9267 if (d != NULL && 9268 hw->callback.domain != NULL) { 9269 hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, d); 9270 } 9271 } 9272 break; 9273 default: 9274 ocs_log_test(hw->os, "unhandled link status %#x\n", event->status); 9275 break; 9276 } 9277 9278 return 0; 9279 } 9280 9281 static int32_t 9282 ocs_hw_cb_fip(void *ctx, void *e) 9283 { 9284 ocs_hw_t *hw = ctx; 9285 ocs_domain_t *domain = NULL; 9286 sli4_fip_event_t *event = e; 9287 9288 ocs_hw_assert(event); 9289 ocs_hw_assert(hw); 9290 9291 /* Find the associated domain object */ 9292 if (event->type == SLI4_FCOE_FIP_FCF_CLEAR_VLINK) { 9293 ocs_domain_t *d = NULL; 9294 uint32_t i = 0; 9295 9296 /* Clear VLINK is different from the other FIP events as it passes back 9297 * a VPI instead of a FCF index. Check all attached SLI ports for a 9298 * matching VPI */ 9299 for (i = 0; i < SLI4_MAX_FCFI; i++) { 9300 d = hw->domains[i]; 9301 if (d != NULL) { 9302 ocs_sport_t *sport = NULL; 9303 9304 ocs_list_foreach(&d->sport_list, sport) { 9305 if (sport->indicator == event->index) { 9306 domain = d; 9307 break; 9308 } 9309 } 9310 9311 if (domain != NULL) { 9312 break; 9313 } 9314 } 9315 } 9316 } else { 9317 domain = ocs_hw_domain_get_indexed(hw, event->index); 9318 } 9319 9320 switch (event->type) { 9321 case SLI4_FCOE_FIP_FCF_DISCOVERED: 9322 ocs_hw_read_fcf(hw, event->index); 9323 break; 9324 case SLI4_FCOE_FIP_FCF_DEAD: 9325 if (domain != NULL && 9326 hw->callback.domain != NULL) { 9327 hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain); 9328 } 9329 break; 9330 case SLI4_FCOE_FIP_FCF_CLEAR_VLINK: 9331 if (domain != NULL && 9332 hw->callback.domain != NULL) { 9333 /* 9334 * We will want to issue rediscover FCF when this domain is free'd in order 9335 * to invalidate the FCF table 9336 */ 9337 domain->req_rediscover_fcf = TRUE; 9338 hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain); 9339 } 9340 break; 9341 case SLI4_FCOE_FIP_FCF_MODIFIED: 9342 if (domain != NULL && 9343 hw->callback.domain != NULL) { 9344 hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain); 9345 } 9346 9347 ocs_hw_read_fcf(hw, event->index); 9348 break; 9349 default: 9350 ocs_log_test(hw->os, "unsupported event %#x\n", event->type); 9351 } 9352 9353 return 0; 9354 } 9355 9356 static int32_t 9357 ocs_hw_cb_node_attach(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 9358 { 9359 ocs_remote_node_t *rnode = arg; 9360 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 9361 ocs_hw_remote_node_event_e evt = 0; 9362 9363 if (status || hdr->status) { 9364 ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status, 9365 hdr->status); 9366 ocs_atomic_sub_return(&hw->rpi_ref[rnode->index].rpi_count, 1); 9367 rnode->attached = FALSE; 9368 ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 0); 9369 evt = OCS_HW_NODE_ATTACH_FAIL; 9370 } else { 9371 rnode->attached = TRUE; 9372 ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 1); 9373 evt = OCS_HW_NODE_ATTACH_OK; 9374 } 9375 9376 if (hw->callback.rnode != NULL) { 9377 hw->callback.rnode(hw->args.rnode, evt, rnode); 9378 } 9379 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9380 9381 return 0; 9382 } 9383 9384 static int32_t 9385 ocs_hw_cb_node_free(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 9386 { 9387 ocs_remote_node_t *rnode = arg; 9388 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 9389 ocs_hw_remote_node_event_e evt = OCS_HW_NODE_FREE_FAIL; 9390 int32_t rc = 0; 9391 9392 if (status || hdr->status) { 9393 ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status, 9394 hdr->status); 9395 9396 /* 9397 * In certain cases, a non-zero MQE status is OK (all must be true): 9398 * - node is attached 9399 * - if High Login Mode is enabled, node is part of a node group 9400 * - status is 0x1400 9401 */ 9402 if (!rnode->attached || ((sli_get_hlm(&hw->sli) == TRUE) && !rnode->node_group) || 9403 (hdr->status != SLI4_MBOX_STATUS_RPI_NOT_REG)) { 9404 rc = -1; 9405 } 9406 } 9407 9408 if (rc == 0) { 9409 rnode->node_group = FALSE; 9410 rnode->attached = FALSE; 9411 9412 if (ocs_atomic_read(&hw->rpi_ref[rnode->index].rpi_count) == 0) { 9413 ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 0); 9414 } 9415 9416 evt = OCS_HW_NODE_FREE_OK; 9417 } 9418 9419 if (hw->callback.rnode != NULL) { 9420 hw->callback.rnode(hw->args.rnode, evt, rnode); 9421 } 9422 9423 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9424 9425 return rc; 9426 } 9427 9428 static int32_t 9429 ocs_hw_cb_node_free_all(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 9430 { 9431 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 9432 ocs_hw_remote_node_event_e evt = OCS_HW_NODE_FREE_FAIL; 9433 int32_t rc = 0; 9434 uint32_t i; 9435 9436 if (status || hdr->status) { 9437 ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status, 9438 hdr->status); 9439 } else { 9440 evt = OCS_HW_NODE_FREE_ALL_OK; 9441 } 9442 9443 if (evt == OCS_HW_NODE_FREE_ALL_OK) { 9444 for (i = 0; i < sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI); i++) { 9445 ocs_atomic_set(&hw->rpi_ref[i].rpi_count, 0); 9446 } 9447 9448 if (sli_resource_reset(&hw->sli, SLI_RSRC_FCOE_RPI)) { 9449 ocs_log_test(hw->os, "FCOE_RPI free all failure\n"); 9450 rc = -1; 9451 } 9452 } 9453 9454 if (hw->callback.rnode != NULL) { 9455 hw->callback.rnode(hw->args.rnode, evt, NULL); 9456 } 9457 9458 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9459 9460 return rc; 9461 } 9462 9463 /** 9464 * @brief Initialize the pool of HW IO objects. 9465 * 9466 * @param hw Hardware context. 9467 * 9468 * @return Returns 0 on success, or a non-zero value on failure. 9469 */ 9470 static ocs_hw_rtn_e 9471 ocs_hw_setup_io(ocs_hw_t *hw) 9472 { 9473 uint32_t i = 0; 9474 ocs_hw_io_t *io = NULL; 9475 uintptr_t xfer_virt = 0; 9476 uintptr_t xfer_phys = 0; 9477 uint32_t index; 9478 uint8_t new_alloc = TRUE; 9479 9480 if (NULL == hw->io) { 9481 hw->io = ocs_malloc(hw->os, hw->config.n_io * sizeof(ocs_hw_io_t *), OCS_M_ZERO | OCS_M_NOWAIT); 9482 9483 if (NULL == hw->io) { 9484 ocs_log_err(hw->os, "IO pointer memory allocation failed, %d Ios at size %zu\n", 9485 hw->config.n_io, 9486 sizeof(ocs_hw_io_t *)); 9487 return OCS_HW_RTN_NO_MEMORY; 9488 } 9489 for (i = 0; i < hw->config.n_io; i++) { 9490 hw->io[i] = ocs_malloc(hw->os, sizeof(ocs_hw_io_t), 9491 OCS_M_ZERO | OCS_M_NOWAIT); 9492 if (hw->io[i] == NULL) { 9493 ocs_log_err(hw->os, "IO(%d) memory allocation failed\n", i); 9494 goto error; 9495 } 9496 } 9497 9498 /* Create WQE buffs for IO */ 9499 hw->wqe_buffs = ocs_malloc(hw->os, hw->config.n_io * hw->sli.config.wqe_size, 9500 OCS_M_ZERO | OCS_M_NOWAIT); 9501 if (NULL == hw->wqe_buffs) { 9502 ocs_free(hw->os, hw->io, hw->config.n_io * sizeof(ocs_hw_io_t)); 9503 ocs_log_err(hw->os, "%s: IO WQE buff allocation failed, %d Ios at size %zu\n", 9504 __func__, hw->config.n_io, hw->sli.config.wqe_size); 9505 return OCS_HW_RTN_NO_MEMORY; 9506 } 9507 9508 } else { 9509 /* re-use existing IOs, including SGLs */ 9510 new_alloc = FALSE; 9511 } 9512 9513 if (new_alloc) { 9514 if (ocs_dma_alloc(hw->os, &hw->xfer_rdy, 9515 sizeof(fcp_xfer_rdy_iu_t) * hw->config.n_io, 9516 4/*XXX what does this need to be? */)) { 9517 ocs_log_err(hw->os, "XFER_RDY buffer allocation failed\n"); 9518 return OCS_HW_RTN_NO_MEMORY; 9519 } 9520 } 9521 xfer_virt = (uintptr_t)hw->xfer_rdy.virt; 9522 xfer_phys = hw->xfer_rdy.phys; 9523 9524 for (i = 0; i < hw->config.n_io; i++) { 9525 hw_wq_callback_t *wqcb; 9526 9527 io = hw->io[i]; 9528 9529 /* initialize IO fields */ 9530 io->hw = hw; 9531 9532 /* Assign a WQE buff */ 9533 io->wqe.wqebuf = &hw->wqe_buffs[i * hw->sli.config.wqe_size]; 9534 9535 /* Allocate the request tag for this IO */ 9536 wqcb = ocs_hw_reqtag_alloc(hw, ocs_hw_wq_process_io, io); 9537 if (wqcb == NULL) { 9538 ocs_log_err(hw->os, "can't allocate request tag\n"); 9539 return OCS_HW_RTN_NO_RESOURCES; 9540 } 9541 io->reqtag = wqcb->instance_index; 9542 9543 /* Now for the fields that are initialized on each free */ 9544 ocs_hw_init_free_io(io); 9545 9546 /* The XB flag isn't cleared on IO free, so initialize it to zero here */ 9547 io->xbusy = 0; 9548 9549 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_XRI, &io->indicator, &index)) { 9550 ocs_log_err(hw->os, "sli_resource_alloc failed @ %d\n", i); 9551 return OCS_HW_RTN_NO_MEMORY; 9552 } 9553 9554 if (new_alloc && ocs_dma_alloc(hw->os, &io->def_sgl, hw->config.n_sgl * sizeof(sli4_sge_t), 64)) { 9555 ocs_log_err(hw->os, "ocs_dma_alloc failed @ %d\n", i); 9556 ocs_memset(&io->def_sgl, 0, sizeof(ocs_dma_t)); 9557 return OCS_HW_RTN_NO_MEMORY; 9558 } 9559 io->def_sgl_count = hw->config.n_sgl; 9560 io->sgl = &io->def_sgl; 9561 io->sgl_count = io->def_sgl_count; 9562 9563 if (hw->xfer_rdy.size) { 9564 io->xfer_rdy.virt = (void *)xfer_virt; 9565 io->xfer_rdy.phys = xfer_phys; 9566 io->xfer_rdy.size = sizeof(fcp_xfer_rdy_iu_t); 9567 9568 xfer_virt += sizeof(fcp_xfer_rdy_iu_t); 9569 xfer_phys += sizeof(fcp_xfer_rdy_iu_t); 9570 } 9571 } 9572 9573 return OCS_HW_RTN_SUCCESS; 9574 error: 9575 for (i = 0; i < hw->config.n_io && hw->io[i]; i++) { 9576 ocs_free(hw->os, hw->io[i], sizeof(ocs_hw_io_t)); 9577 hw->io[i] = NULL; 9578 } 9579 9580 return OCS_HW_RTN_NO_MEMORY; 9581 } 9582 9583 static ocs_hw_rtn_e 9584 ocs_hw_init_io(ocs_hw_t *hw) 9585 { 9586 uint32_t i = 0, io_index = 0; 9587 uint32_t prereg = 0; 9588 ocs_hw_io_t *io = NULL; 9589 uint8_t cmd[SLI4_BMBX_SIZE]; 9590 ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS; 9591 uint32_t nremaining; 9592 uint32_t n = 0; 9593 uint32_t sgls_per_request = 256; 9594 ocs_dma_t **sgls = NULL; 9595 ocs_dma_t reqbuf = { 0 }; 9596 9597 prereg = sli_get_sgl_preregister(&hw->sli); 9598 9599 if (prereg) { 9600 sgls = ocs_malloc(hw->os, sizeof(*sgls) * sgls_per_request, OCS_M_NOWAIT); 9601 if (sgls == NULL) { 9602 ocs_log_err(hw->os, "ocs_malloc sgls failed\n"); 9603 return OCS_HW_RTN_NO_MEMORY; 9604 } 9605 9606 rc = ocs_dma_alloc(hw->os, &reqbuf, 32 + sgls_per_request*16, OCS_MIN_DMA_ALIGNMENT); 9607 if (rc) { 9608 ocs_log_err(hw->os, "ocs_dma_alloc reqbuf failed\n"); 9609 ocs_free(hw->os, sgls, sizeof(*sgls) * sgls_per_request); 9610 return OCS_HW_RTN_NO_MEMORY; 9611 } 9612 } 9613 9614 io = hw->io[io_index]; 9615 for (nremaining = hw->config.n_io; nremaining; nremaining -= n) { 9616 if (prereg) { 9617 /* Copy address of SGL's into local sgls[] array, break out if the xri 9618 * is not contiguous. 9619 */ 9620 for (n = 0; n < MIN(sgls_per_request, nremaining); n++) { 9621 /* Check that we have contiguous xri values */ 9622 if (n > 0) { 9623 if (hw->io[io_index + n]->indicator != (hw->io[io_index + n-1]->indicator+1)) { 9624 break; 9625 } 9626 } 9627 sgls[n] = hw->io[io_index + n]->sgl; 9628 } 9629 9630 if (sli_cmd_fcoe_post_sgl_pages(&hw->sli, cmd, sizeof(cmd), 9631 io->indicator, n, sgls, NULL, &reqbuf)) { 9632 if (ocs_hw_command(hw, cmd, OCS_CMD_POLL, NULL, NULL)) { 9633 rc = OCS_HW_RTN_ERROR; 9634 ocs_log_err(hw->os, "SGL post failed\n"); 9635 break; 9636 } 9637 } 9638 } else { 9639 n = nremaining; 9640 } 9641 9642 /* Add to tail if successful */ 9643 for (i = 0; i < n; i ++) { 9644 io->is_port_owned = 0; 9645 io->state = OCS_HW_IO_STATE_FREE; 9646 ocs_list_add_tail(&hw->io_free, io); 9647 io = hw->io[io_index+1]; 9648 io_index++; 9649 } 9650 } 9651 9652 if (prereg) { 9653 ocs_dma_free(hw->os, &reqbuf); 9654 ocs_free(hw->os, sgls, sizeof(*sgls) * sgls_per_request); 9655 } 9656 9657 return rc; 9658 } 9659 9660 static int32_t 9661 ocs_hw_flush(ocs_hw_t *hw) 9662 { 9663 uint32_t i = 0; 9664 9665 /* Process any remaining completions */ 9666 for (i = 0; i < hw->eq_count; i++) { 9667 ocs_hw_process(hw, i, ~0); 9668 } 9669 9670 return 0; 9671 } 9672 9673 static int32_t 9674 ocs_hw_command_cancel(ocs_hw_t *hw) 9675 { 9676 9677 ocs_lock(&hw->cmd_lock); 9678 9679 /* 9680 * Manually clean up remaining commands. Note: since this calls 9681 * ocs_hw_command_process(), we'll also process the cmd_pending 9682 * list, so no need to manually clean that out. 9683 */ 9684 while (!ocs_list_empty(&hw->cmd_head)) { 9685 uint8_t mqe[SLI4_BMBX_SIZE] = { 0 }; 9686 ocs_command_ctx_t *ctx = ocs_list_get_head(&hw->cmd_head); 9687 9688 ocs_log_test(hw->os, "hung command %08x\n", 9689 NULL == ctx ? UINT32_MAX : 9690 (NULL == ctx->buf ? UINT32_MAX : *((uint32_t *)ctx->buf))); 9691 ocs_unlock(&hw->cmd_lock); 9692 ocs_hw_command_process(hw, -1/*Bad status*/, mqe, SLI4_BMBX_SIZE); 9693 ocs_lock(&hw->cmd_lock); 9694 } 9695 9696 ocs_unlock(&hw->cmd_lock); 9697 9698 return 0; 9699 } 9700 9701 /** 9702 * @brief Find IO given indicator (xri). 9703 * 9704 * @param hw Hal context. 9705 * @param indicator Indicator (xri) to look for. 9706 * 9707 * @return Returns io if found, NULL otherwise. 9708 */ 9709 ocs_hw_io_t * 9710 ocs_hw_io_lookup(ocs_hw_t *hw, uint32_t xri) 9711 { 9712 uint32_t ioindex; 9713 ioindex = xri - hw->sli.config.extent[SLI_RSRC_FCOE_XRI].base[0]; 9714 return hw->io[ioindex]; 9715 } 9716 9717 /** 9718 * @brief Issue any pending callbacks for an IO and remove off the timer and pending lists. 9719 * 9720 * @param hw Hal context. 9721 * @param io Pointer to the IO to cleanup. 9722 */ 9723 static void 9724 ocs_hw_io_cancel_cleanup(ocs_hw_t *hw, ocs_hw_io_t *io) 9725 { 9726 ocs_hw_done_t done = io->done; 9727 ocs_hw_done_t abort_done = io->abort_done; 9728 9729 /* first check active_wqe list and remove if there */ 9730 if (ocs_list_on_list(&io->wqe_link)) { 9731 ocs_list_remove(&hw->io_timed_wqe, io); 9732 } 9733 9734 /* Remove from WQ pending list */ 9735 if ((io->wq != NULL) && ocs_list_on_list(&io->wq->pending_list)) { 9736 ocs_list_remove(&io->wq->pending_list, io); 9737 } 9738 9739 if (io->done) { 9740 void *arg = io->arg; 9741 9742 io->done = NULL; 9743 ocs_unlock(&hw->io_lock); 9744 done(io, io->rnode, 0, SLI4_FC_WCQE_STATUS_SHUTDOWN, 0, arg); 9745 ocs_lock(&hw->io_lock); 9746 } 9747 9748 if (io->abort_done != NULL) { 9749 void *abort_arg = io->abort_arg; 9750 9751 io->abort_done = NULL; 9752 ocs_unlock(&hw->io_lock); 9753 abort_done(io, io->rnode, 0, SLI4_FC_WCQE_STATUS_SHUTDOWN, 0, abort_arg); 9754 ocs_lock(&hw->io_lock); 9755 } 9756 } 9757 9758 static int32_t 9759 ocs_hw_io_cancel(ocs_hw_t *hw) 9760 { 9761 ocs_hw_io_t *io = NULL; 9762 ocs_hw_io_t *tmp_io = NULL; 9763 uint32_t iters = 100; /* One second limit */ 9764 9765 /* 9766 * Manually clean up outstanding IO. 9767 * Only walk through list once: the backend will cleanup any IOs when done/abort_done is called. 9768 */ 9769 ocs_lock(&hw->io_lock); 9770 ocs_list_foreach_safe(&hw->io_inuse, io, tmp_io) { 9771 ocs_hw_done_t done = io->done; 9772 ocs_hw_done_t abort_done = io->abort_done; 9773 9774 ocs_hw_io_cancel_cleanup(hw, io); 9775 9776 /* 9777 * Since this is called in a reset/shutdown 9778 * case, If there is no callback, then just 9779 * free the IO. 9780 * 9781 * Note: A port owned XRI cannot be on 9782 * the in use list. We cannot call 9783 * ocs_hw_io_free() because we already 9784 * hold the io_lock. 9785 */ 9786 if (done == NULL && 9787 abort_done == NULL) { 9788 /* 9789 * Since this is called in a reset/shutdown 9790 * case, If there is no callback, then just 9791 * free the IO. 9792 */ 9793 ocs_hw_io_free_common(hw, io); 9794 ocs_list_remove(&hw->io_inuse, io); 9795 ocs_hw_io_free_move_correct_list(hw, io); 9796 } 9797 } 9798 9799 /* 9800 * For port owned XRIs, they are not on the in use list, so 9801 * walk though XRIs and issue any callbacks. 9802 */ 9803 ocs_list_foreach_safe(&hw->io_port_owned, io, tmp_io) { 9804 /* check list and remove if there */ 9805 if (ocs_list_on_list(&io->dnrx_link)) { 9806 ocs_list_remove(&hw->io_port_dnrx, io); 9807 ocs_ref_put(&io->ref); /* ocs_ref_get(): same function */ 9808 } 9809 ocs_hw_io_cancel_cleanup(hw, io); 9810 ocs_list_remove(&hw->io_port_owned, io); 9811 ocs_hw_io_free_common(hw, io); 9812 } 9813 ocs_unlock(&hw->io_lock); 9814 9815 /* Give time for the callbacks to complete */ 9816 do { 9817 ocs_udelay(10000); 9818 iters--; 9819 } while (!ocs_list_empty(&hw->io_inuse) && iters); 9820 9821 /* Leave a breadcrumb that cleanup is not yet complete. */ 9822 if (!ocs_list_empty(&hw->io_inuse)) { 9823 ocs_log_test(hw->os, "io_inuse list is not empty\n"); 9824 } 9825 9826 return 0; 9827 } 9828 9829 static int32_t 9830 ocs_hw_io_ini_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_dma_t *cmnd, uint32_t cmnd_size, 9831 ocs_dma_t *rsp) 9832 { 9833 sli4_sge_t *data = NULL; 9834 9835 if (!hw || !io) { 9836 ocs_log_err(NULL, "bad parm hw=%p io=%p\n", hw, io); 9837 return OCS_HW_RTN_ERROR; 9838 } 9839 9840 data = io->def_sgl.virt; 9841 9842 /* setup command pointer */ 9843 data->buffer_address_high = ocs_addr32_hi(cmnd->phys); 9844 data->buffer_address_low = ocs_addr32_lo(cmnd->phys); 9845 data->buffer_length = cmnd_size; 9846 data++; 9847 9848 /* setup response pointer */ 9849 data->buffer_address_high = ocs_addr32_hi(rsp->phys); 9850 data->buffer_address_low = ocs_addr32_lo(rsp->phys); 9851 data->buffer_length = rsp->size; 9852 9853 return 0; 9854 } 9855 9856 static int32_t 9857 __ocs_read_topology_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 9858 { 9859 sli4_cmd_read_topology_t *read_topo = (sli4_cmd_read_topology_t *)mqe; 9860 9861 if (status || read_topo->hdr.status) { 9862 ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", 9863 status, read_topo->hdr.status); 9864 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9865 return -1; 9866 } 9867 9868 switch (read_topo->attention_type) { 9869 case SLI4_READ_TOPOLOGY_LINK_UP: 9870 hw->link.status = SLI_LINK_STATUS_UP; 9871 break; 9872 case SLI4_READ_TOPOLOGY_LINK_DOWN: 9873 hw->link.status = SLI_LINK_STATUS_DOWN; 9874 break; 9875 case SLI4_READ_TOPOLOGY_LINK_NO_ALPA: 9876 hw->link.status = SLI_LINK_STATUS_NO_ALPA; 9877 break; 9878 default: 9879 hw->link.status = SLI_LINK_STATUS_MAX; 9880 break; 9881 } 9882 9883 switch (read_topo->topology) { 9884 case SLI4_READ_TOPOLOGY_NPORT: 9885 hw->link.topology = SLI_LINK_TOPO_NPORT; 9886 break; 9887 case SLI4_READ_TOPOLOGY_FC_AL: 9888 hw->link.topology = SLI_LINK_TOPO_LOOP; 9889 if (SLI_LINK_STATUS_UP == hw->link.status) { 9890 hw->link.loop_map = hw->loop_map.virt; 9891 } 9892 hw->link.fc_id = read_topo->acquired_al_pa; 9893 break; 9894 default: 9895 hw->link.topology = SLI_LINK_TOPO_MAX; 9896 break; 9897 } 9898 9899 hw->link.medium = SLI_LINK_MEDIUM_FC; 9900 9901 switch (read_topo->link_current.link_speed) { 9902 case SLI4_READ_TOPOLOGY_SPEED_1G: 9903 hw->link.speed = 1 * 1000; 9904 break; 9905 case SLI4_READ_TOPOLOGY_SPEED_2G: 9906 hw->link.speed = 2 * 1000; 9907 break; 9908 case SLI4_READ_TOPOLOGY_SPEED_4G: 9909 hw->link.speed = 4 * 1000; 9910 break; 9911 case SLI4_READ_TOPOLOGY_SPEED_8G: 9912 hw->link.speed = 8 * 1000; 9913 break; 9914 case SLI4_READ_TOPOLOGY_SPEED_16G: 9915 hw->link.speed = 16 * 1000; 9916 hw->link.loop_map = NULL; 9917 break; 9918 case SLI4_READ_TOPOLOGY_SPEED_32G: 9919 hw->link.speed = 32 * 1000; 9920 hw->link.loop_map = NULL; 9921 break; 9922 } 9923 9924 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 9925 9926 ocs_hw_read_fcf(hw, SLI4_FCOE_FCF_TABLE_FIRST); 9927 9928 return 0; 9929 } 9930 9931 static int32_t 9932 __ocs_hw_port_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 9933 { 9934 ocs_sli_port_t *sport = ctx->app; 9935 ocs_hw_t *hw = sport->hw; 9936 9937 smtrace("port"); 9938 9939 switch (evt) { 9940 case OCS_EVT_EXIT: 9941 /* ignore */ 9942 break; 9943 9944 case OCS_EVT_HW_PORT_REQ_FREE: 9945 case OCS_EVT_HW_PORT_REQ_ATTACH: 9946 if (data != NULL) { 9947 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 9948 } 9949 /* fall through */ 9950 default: 9951 ocs_log_test(hw->os, "%s %-20s not handled\n", funcname, ocs_sm_event_name(evt)); 9952 break; 9953 } 9954 9955 return 0; 9956 } 9957 9958 static void * 9959 __ocs_hw_port_free_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 9960 { 9961 ocs_sli_port_t *sport = ctx->app; 9962 ocs_hw_t *hw = sport->hw; 9963 9964 smtrace("port"); 9965 9966 switch (evt) { 9967 case OCS_EVT_ENTER: 9968 if (data != NULL) { 9969 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 9970 } 9971 if (hw->callback.port != NULL) { 9972 hw->callback.port(hw->args.port, 9973 OCS_HW_PORT_FREE_FAIL, sport); 9974 } 9975 break; 9976 default: 9977 break; 9978 } 9979 9980 return NULL; 9981 } 9982 9983 static void * 9984 __ocs_hw_port_freed(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 9985 { 9986 ocs_sli_port_t *sport = ctx->app; 9987 ocs_hw_t *hw = sport->hw; 9988 9989 smtrace("port"); 9990 9991 switch (evt) { 9992 case OCS_EVT_ENTER: 9993 /* free SLI resource */ 9994 if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator)) { 9995 ocs_log_err(hw->os, "FCOE_VPI free failure addr=%#x\n", sport->fc_id); 9996 } 9997 9998 /* free mailbox buffer */ 9999 if (data != NULL) { 10000 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10001 } 10002 if (hw->callback.port != NULL) { 10003 hw->callback.port(hw->args.port, 10004 OCS_HW_PORT_FREE_OK, sport); 10005 } 10006 break; 10007 default: 10008 break; 10009 } 10010 10011 return NULL; 10012 } 10013 10014 static void * 10015 __ocs_hw_port_attach_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10016 { 10017 ocs_sli_port_t *sport = ctx->app; 10018 ocs_hw_t *hw = sport->hw; 10019 10020 smtrace("port"); 10021 10022 switch (evt) { 10023 case OCS_EVT_ENTER: 10024 /* free SLI resource */ 10025 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator); 10026 10027 /* free mailbox buffer */ 10028 if (data != NULL) { 10029 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10030 } 10031 10032 if (hw->callback.port != NULL) { 10033 hw->callback.port(hw->args.port, 10034 OCS_HW_PORT_ATTACH_FAIL, sport); 10035 } 10036 if (sport->sm_free_req_pending) { 10037 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10038 } 10039 break; 10040 default: 10041 __ocs_hw_port_common(__func__, ctx, evt, data); 10042 break; 10043 } 10044 10045 return NULL; 10046 } 10047 10048 static void * 10049 __ocs_hw_port_free_unreg_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10050 { 10051 ocs_sli_port_t *sport = ctx->app; 10052 ocs_hw_t *hw = sport->hw; 10053 uint8_t *cmd = NULL; 10054 10055 smtrace("port"); 10056 10057 switch (evt) { 10058 case OCS_EVT_ENTER: 10059 /* allocate memory and send unreg_vpi */ 10060 cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 10061 if (!cmd) { 10062 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10063 break; 10064 } 10065 10066 if (0 == sli_cmd_unreg_vpi(&hw->sli, cmd, SLI4_BMBX_SIZE, sport->indicator, 10067 SLI4_UNREG_TYPE_PORT)) { 10068 ocs_log_err(hw->os, "UNREG_VPI format failure\n"); 10069 ocs_free(hw->os, cmd, SLI4_BMBX_SIZE); 10070 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10071 break; 10072 } 10073 10074 if (ocs_hw_command(hw, cmd, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) { 10075 ocs_log_err(hw->os, "UNREG_VPI command failure\n"); 10076 ocs_free(hw->os, cmd, SLI4_BMBX_SIZE); 10077 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10078 break; 10079 } 10080 break; 10081 case OCS_EVT_RESPONSE: 10082 ocs_sm_transition(ctx, __ocs_hw_port_freed, data); 10083 break; 10084 case OCS_EVT_ERROR: 10085 ocs_sm_transition(ctx, __ocs_hw_port_free_report_fail, data); 10086 break; 10087 default: 10088 __ocs_hw_port_common(__func__, ctx, evt, data); 10089 break; 10090 } 10091 10092 return NULL; 10093 } 10094 10095 static void * 10096 __ocs_hw_port_free_nop(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10097 { 10098 ocs_sli_port_t *sport = ctx->app; 10099 ocs_hw_t *hw = sport->hw; 10100 10101 smtrace("port"); 10102 10103 switch (evt) { 10104 case OCS_EVT_ENTER: 10105 /* Forward to execute in mailbox completion processing context */ 10106 if (ocs_hw_async_call(hw, __ocs_hw_port_realloc_cb, sport)) { 10107 ocs_log_err(hw->os, "ocs_hw_async_call failed\n"); 10108 } 10109 break; 10110 case OCS_EVT_RESPONSE: 10111 ocs_sm_transition(ctx, __ocs_hw_port_freed, data); 10112 break; 10113 case OCS_EVT_ERROR: 10114 ocs_sm_transition(ctx, __ocs_hw_port_free_report_fail, data); 10115 break; 10116 default: 10117 break; 10118 } 10119 10120 return NULL; 10121 } 10122 10123 static void * 10124 __ocs_hw_port_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10125 { 10126 ocs_sli_port_t *sport = ctx->app; 10127 ocs_hw_t *hw = sport->hw; 10128 10129 smtrace("port"); 10130 10131 switch (evt) { 10132 case OCS_EVT_ENTER: 10133 if (data != NULL) { 10134 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10135 } 10136 if (hw->callback.port != NULL) { 10137 hw->callback.port(hw->args.port, 10138 OCS_HW_PORT_ATTACH_OK, sport); 10139 } 10140 if (sport->sm_free_req_pending) { 10141 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10142 } 10143 break; 10144 case OCS_EVT_HW_PORT_REQ_FREE: 10145 /* virtual/physical port request free */ 10146 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10147 break; 10148 default: 10149 __ocs_hw_port_common(__func__, ctx, evt, data); 10150 break; 10151 } 10152 10153 return NULL; 10154 } 10155 10156 static void * 10157 __ocs_hw_port_attach_reg_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10158 { 10159 ocs_sli_port_t *sport = ctx->app; 10160 ocs_hw_t *hw = sport->hw; 10161 10162 smtrace("port"); 10163 10164 switch (evt) { 10165 case OCS_EVT_ENTER: 10166 if (0 == sli_cmd_reg_vpi(&hw->sli, data, SLI4_BMBX_SIZE, sport, FALSE)) { 10167 ocs_log_err(hw->os, "REG_VPI format failure\n"); 10168 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10169 break; 10170 } 10171 10172 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) { 10173 ocs_log_err(hw->os, "REG_VPI command failure\n"); 10174 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10175 break; 10176 } 10177 break; 10178 case OCS_EVT_RESPONSE: 10179 ocs_sm_transition(ctx, __ocs_hw_port_attached, data); 10180 break; 10181 case OCS_EVT_ERROR: 10182 ocs_sm_transition(ctx, __ocs_hw_port_attach_report_fail, data); 10183 break; 10184 case OCS_EVT_HW_PORT_REQ_FREE: 10185 /* Wait for attach response and then free */ 10186 sport->sm_free_req_pending = 1; 10187 break; 10188 default: 10189 __ocs_hw_port_common(__func__, ctx, evt, data); 10190 break; 10191 } 10192 10193 return NULL; 10194 } 10195 10196 static void * 10197 __ocs_hw_port_done(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10198 { 10199 ocs_sli_port_t *sport = ctx->app; 10200 ocs_hw_t *hw = sport->hw; 10201 10202 smtrace("port"); 10203 10204 switch (evt) { 10205 case OCS_EVT_ENTER: 10206 /* free SLI resource */ 10207 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator); 10208 10209 /* free mailbox buffer */ 10210 if (data != NULL) { 10211 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10212 } 10213 break; 10214 default: 10215 __ocs_hw_port_common(__func__, ctx, evt, data); 10216 break; 10217 } 10218 10219 return NULL; 10220 } 10221 10222 static void * 10223 __ocs_hw_port_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10224 { 10225 ocs_sli_port_t *sport = ctx->app; 10226 ocs_hw_t *hw = sport->hw; 10227 10228 smtrace("port"); 10229 10230 switch (evt) { 10231 case OCS_EVT_ENTER: 10232 if (data != NULL) { 10233 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10234 } 10235 if (hw->callback.port != NULL) { 10236 hw->callback.port(hw->args.port, 10237 OCS_HW_PORT_ALLOC_OK, sport); 10238 } 10239 /* If there is a pending free request, then handle it now */ 10240 if (sport->sm_free_req_pending) { 10241 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10242 } 10243 break; 10244 case OCS_EVT_HW_PORT_REQ_ATTACH: 10245 /* virtual port requests attach */ 10246 ocs_sm_transition(ctx, __ocs_hw_port_attach_reg_vpi, data); 10247 break; 10248 case OCS_EVT_HW_PORT_ATTACH_OK: 10249 /* physical port attached (as part of attaching domain) */ 10250 ocs_sm_transition(ctx, __ocs_hw_port_attached, data); 10251 break; 10252 case OCS_EVT_HW_PORT_REQ_FREE: 10253 /* virtual port request free */ 10254 if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) { 10255 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10256 } else { 10257 /* 10258 * Note: BE3/Skyhawk will respond with a status of 0x20 10259 * unless the reg_vpi has been issued, so we can 10260 * skip the unreg_vpi for these adapters. 10261 * 10262 * Send a nop to make sure that free doesn't occur in 10263 * same context 10264 */ 10265 ocs_sm_transition(ctx, __ocs_hw_port_free_nop, NULL); 10266 } 10267 break; 10268 default: 10269 __ocs_hw_port_common(__func__, ctx, evt, data); 10270 break; 10271 } 10272 10273 return NULL; 10274 } 10275 10276 static void * 10277 __ocs_hw_port_alloc_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10278 { 10279 ocs_sli_port_t *sport = ctx->app; 10280 ocs_hw_t *hw = sport->hw; 10281 10282 smtrace("port"); 10283 10284 switch (evt) { 10285 case OCS_EVT_ENTER: 10286 /* free SLI resource */ 10287 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator); 10288 10289 /* free mailbox buffer */ 10290 if (data != NULL) { 10291 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10292 } 10293 10294 if (hw->callback.port != NULL) { 10295 hw->callback.port(hw->args.port, 10296 OCS_HW_PORT_ALLOC_FAIL, sport); 10297 } 10298 10299 /* If there is a pending free request, then handle it now */ 10300 if (sport->sm_free_req_pending) { 10301 ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL); 10302 } 10303 break; 10304 default: 10305 __ocs_hw_port_common(__func__, ctx, evt, data); 10306 break; 10307 } 10308 10309 return NULL; 10310 } 10311 10312 static void * 10313 __ocs_hw_port_alloc_read_sparm64(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10314 { 10315 ocs_sli_port_t *sport = ctx->app; 10316 ocs_hw_t *hw = sport->hw; 10317 uint8_t *payload = NULL; 10318 10319 smtrace("port"); 10320 10321 switch (evt) { 10322 case OCS_EVT_ENTER: 10323 /* allocate memory for the service parameters */ 10324 if (ocs_dma_alloc(hw->os, &sport->dma, 112, 4)) { 10325 ocs_log_err(hw->os, "Failed to allocate DMA memory\n"); 10326 ocs_sm_transition(ctx, __ocs_hw_port_done, data); 10327 break; 10328 } 10329 10330 if (0 == sli_cmd_read_sparm64(&hw->sli, data, SLI4_BMBX_SIZE, 10331 &sport->dma, sport->indicator)) { 10332 ocs_log_err(hw->os, "READ_SPARM64 allocation failure\n"); 10333 ocs_dma_free(hw->os, &sport->dma); 10334 ocs_sm_transition(ctx, __ocs_hw_port_done, data); 10335 break; 10336 } 10337 10338 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) { 10339 ocs_log_err(hw->os, "READ_SPARM64 command failure\n"); 10340 ocs_dma_free(hw->os, &sport->dma); 10341 ocs_sm_transition(ctx, __ocs_hw_port_done, data); 10342 break; 10343 } 10344 break; 10345 case OCS_EVT_RESPONSE: 10346 payload = sport->dma.virt; 10347 10348 ocs_display_sparams(sport->display_name, "sport sparm64", 0, NULL, payload); 10349 10350 ocs_memcpy(&sport->sli_wwpn, payload + SLI4_READ_SPARM64_WWPN_OFFSET, 10351 sizeof(sport->sli_wwpn)); 10352 ocs_memcpy(&sport->sli_wwnn, payload + SLI4_READ_SPARM64_WWNN_OFFSET, 10353 sizeof(sport->sli_wwnn)); 10354 10355 ocs_dma_free(hw->os, &sport->dma); 10356 ocs_sm_transition(ctx, __ocs_hw_port_alloc_init_vpi, data); 10357 break; 10358 case OCS_EVT_ERROR: 10359 ocs_dma_free(hw->os, &sport->dma); 10360 ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, data); 10361 break; 10362 case OCS_EVT_HW_PORT_REQ_FREE: 10363 /* Wait for attach response and then free */ 10364 sport->sm_free_req_pending = 1; 10365 break; 10366 case OCS_EVT_EXIT: 10367 break; 10368 default: 10369 __ocs_hw_port_common(__func__, ctx, evt, data); 10370 break; 10371 } 10372 10373 return NULL; 10374 } 10375 10376 static void * 10377 __ocs_hw_port_alloc_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10378 { 10379 ocs_sli_port_t *sport = ctx->app; 10380 10381 smtrace("port"); 10382 10383 switch (evt) { 10384 case OCS_EVT_ENTER: 10385 /* no-op */ 10386 break; 10387 case OCS_EVT_HW_PORT_ALLOC_OK: 10388 ocs_sm_transition(ctx, __ocs_hw_port_allocated, NULL); 10389 break; 10390 case OCS_EVT_HW_PORT_ALLOC_FAIL: 10391 ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, NULL); 10392 break; 10393 case OCS_EVT_HW_PORT_REQ_FREE: 10394 /* Wait for attach response and then free */ 10395 sport->sm_free_req_pending = 1; 10396 break; 10397 default: 10398 __ocs_hw_port_common(__func__, ctx, evt, data); 10399 break; 10400 } 10401 10402 return NULL; 10403 } 10404 10405 static void * 10406 __ocs_hw_port_alloc_init_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10407 { 10408 ocs_sli_port_t *sport = ctx->app; 10409 ocs_hw_t *hw = sport->hw; 10410 10411 smtrace("port"); 10412 10413 switch (evt) { 10414 case OCS_EVT_ENTER: 10415 /* If there is a pending free request, then handle it now */ 10416 if (sport->sm_free_req_pending) { 10417 ocs_sm_transition(ctx, __ocs_hw_port_freed, NULL); 10418 return NULL; 10419 } 10420 10421 /* TODO XXX transitioning to done only works if this is called 10422 * directly from ocs_hw_port_alloc BUT not if called from 10423 * read_sparm64. In the later case, we actually want to go 10424 * through report_ok/fail 10425 */ 10426 if (0 == sli_cmd_init_vpi(&hw->sli, data, SLI4_BMBX_SIZE, 10427 sport->indicator, sport->domain->indicator)) { 10428 ocs_log_err(hw->os, "INIT_VPI allocation failure\n"); 10429 ocs_sm_transition(ctx, __ocs_hw_port_done, data); 10430 break; 10431 } 10432 10433 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) { 10434 ocs_log_err(hw->os, "INIT_VPI command failure\n"); 10435 ocs_sm_transition(ctx, __ocs_hw_port_done, data); 10436 break; 10437 } 10438 break; 10439 case OCS_EVT_RESPONSE: 10440 ocs_sm_transition(ctx, __ocs_hw_port_allocated, data); 10441 break; 10442 case OCS_EVT_ERROR: 10443 ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, data); 10444 break; 10445 case OCS_EVT_HW_PORT_REQ_FREE: 10446 /* Wait for attach response and then free */ 10447 sport->sm_free_req_pending = 1; 10448 break; 10449 case OCS_EVT_EXIT: 10450 break; 10451 default: 10452 __ocs_hw_port_common(__func__, ctx, evt, data); 10453 break; 10454 } 10455 10456 return NULL; 10457 } 10458 10459 static int32_t 10460 __ocs_hw_port_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 10461 { 10462 ocs_sli_port_t *sport = arg; 10463 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 10464 ocs_sm_event_t evt; 10465 10466 if (status || hdr->status) { 10467 ocs_log_debug(hw->os, "bad status vpi=%#x st=%x hdr=%x\n", 10468 sport->indicator, status, hdr->status); 10469 evt = OCS_EVT_ERROR; 10470 } else { 10471 evt = OCS_EVT_RESPONSE; 10472 } 10473 10474 ocs_sm_post_event(&sport->ctx, evt, mqe); 10475 10476 return 0; 10477 } 10478 10479 static int32_t 10480 __ocs_hw_port_realloc_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 10481 { 10482 ocs_sli_port_t *sport = arg; 10483 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 10484 ocs_sm_event_t evt; 10485 uint8_t *mqecpy; 10486 10487 if (status || hdr->status) { 10488 ocs_log_debug(hw->os, "bad status vpi=%#x st=%x hdr=%x\n", 10489 sport->indicator, status, hdr->status); 10490 evt = OCS_EVT_ERROR; 10491 } else { 10492 evt = OCS_EVT_RESPONSE; 10493 } 10494 10495 /* 10496 * In this case we have to malloc a mailbox command buffer, as it is reused 10497 * in the state machine post event call, and eventually freed 10498 */ 10499 mqecpy = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 10500 if (mqecpy == NULL) { 10501 ocs_log_err(hw->os, "malloc mqecpy failed\n"); 10502 return -1; 10503 } 10504 ocs_memcpy(mqecpy, mqe, SLI4_BMBX_SIZE); 10505 10506 ocs_sm_post_event(&sport->ctx, evt, mqecpy); 10507 10508 return 0; 10509 } 10510 10511 /*************************************************************************** 10512 * Domain state machine 10513 */ 10514 10515 static int32_t 10516 __ocs_hw_domain_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10517 { 10518 ocs_domain_t *domain = ctx->app; 10519 ocs_hw_t *hw = domain->hw; 10520 10521 smtrace("domain"); 10522 10523 switch (evt) { 10524 case OCS_EVT_EXIT: 10525 /* ignore */ 10526 break; 10527 10528 default: 10529 ocs_log_test(hw->os, "%s %-20s not handled\n", funcname, ocs_sm_event_name(evt)); 10530 break; 10531 } 10532 10533 return 0; 10534 } 10535 10536 static void * 10537 __ocs_hw_domain_alloc_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10538 { 10539 ocs_domain_t *domain = ctx->app; 10540 ocs_hw_t *hw = domain->hw; 10541 10542 smtrace("domain"); 10543 10544 switch (evt) { 10545 case OCS_EVT_ENTER: 10546 /* free command buffer */ 10547 if (data != NULL) { 10548 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10549 } 10550 /* free SLI resources */ 10551 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator); 10552 /* TODO how to free FCFI (or do we at all)? */ 10553 10554 if (hw->callback.domain != NULL) { 10555 hw->callback.domain(hw->args.domain, 10556 OCS_HW_DOMAIN_ALLOC_FAIL, 10557 domain); 10558 } 10559 break; 10560 default: 10561 __ocs_hw_domain_common(__func__, ctx, evt, data); 10562 break; 10563 } 10564 10565 return NULL; 10566 } 10567 10568 static void * 10569 __ocs_hw_domain_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10570 { 10571 ocs_domain_t *domain = ctx->app; 10572 ocs_hw_t *hw = domain->hw; 10573 10574 smtrace("domain"); 10575 10576 switch (evt) { 10577 case OCS_EVT_ENTER: 10578 /* free mailbox buffer and send alloc ok to physical sport */ 10579 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10580 ocs_sm_post_event(&domain->sport->ctx, OCS_EVT_HW_PORT_ATTACH_OK, NULL); 10581 10582 /* now inform registered callbacks */ 10583 if (hw->callback.domain != NULL) { 10584 hw->callback.domain(hw->args.domain, 10585 OCS_HW_DOMAIN_ATTACH_OK, 10586 domain); 10587 } 10588 break; 10589 case OCS_EVT_HW_DOMAIN_REQ_FREE: 10590 ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_vfi, NULL); 10591 break; 10592 default: 10593 __ocs_hw_domain_common(__func__, ctx, evt, data); 10594 break; 10595 } 10596 10597 return NULL; 10598 } 10599 10600 static void * 10601 __ocs_hw_domain_attach_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10602 { 10603 ocs_domain_t *domain = ctx->app; 10604 ocs_hw_t *hw = domain->hw; 10605 10606 smtrace("domain"); 10607 10608 switch (evt) { 10609 case OCS_EVT_ENTER: 10610 if (data != NULL) { 10611 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10612 } 10613 /* free SLI resources */ 10614 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator); 10615 /* TODO how to free FCFI (or do we at all)? */ 10616 10617 if (hw->callback.domain != NULL) { 10618 hw->callback.domain(hw->args.domain, 10619 OCS_HW_DOMAIN_ATTACH_FAIL, 10620 domain); 10621 } 10622 break; 10623 case OCS_EVT_EXIT: 10624 break; 10625 default: 10626 __ocs_hw_domain_common(__func__, ctx, evt, data); 10627 break; 10628 } 10629 10630 return NULL; 10631 } 10632 10633 static void * 10634 __ocs_hw_domain_attach_reg_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10635 { 10636 ocs_domain_t *domain = ctx->app; 10637 ocs_hw_t *hw = domain->hw; 10638 10639 smtrace("domain"); 10640 10641 switch (evt) { 10642 case OCS_EVT_ENTER: 10643 10644 ocs_display_sparams("", "reg vpi", 0, NULL, domain->dma.virt); 10645 10646 if (0 == sli_cmd_reg_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain)) { 10647 ocs_log_err(hw->os, "REG_VFI format failure\n"); 10648 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10649 break; 10650 } 10651 10652 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 10653 ocs_log_err(hw->os, "REG_VFI command failure\n"); 10654 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10655 break; 10656 } 10657 break; 10658 case OCS_EVT_RESPONSE: 10659 ocs_sm_transition(ctx, __ocs_hw_domain_attached, data); 10660 break; 10661 case OCS_EVT_ERROR: 10662 ocs_sm_transition(ctx, __ocs_hw_domain_attach_report_fail, data); 10663 break; 10664 default: 10665 __ocs_hw_domain_common(__func__, ctx, evt, data); 10666 break; 10667 } 10668 10669 return NULL; 10670 } 10671 10672 static void * 10673 __ocs_hw_domain_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10674 { 10675 ocs_domain_t *domain = ctx->app; 10676 ocs_hw_t *hw = domain->hw; 10677 10678 smtrace("domain"); 10679 10680 switch (evt) { 10681 case OCS_EVT_ENTER: 10682 /* free mailbox buffer and send alloc ok to physical sport */ 10683 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 10684 ocs_sm_post_event(&domain->sport->ctx, OCS_EVT_HW_PORT_ALLOC_OK, NULL); 10685 10686 ocs_hw_domain_add(hw, domain); 10687 10688 /* now inform registered callbacks */ 10689 if (hw->callback.domain != NULL) { 10690 hw->callback.domain(hw->args.domain, 10691 OCS_HW_DOMAIN_ALLOC_OK, 10692 domain); 10693 } 10694 break; 10695 case OCS_EVT_HW_DOMAIN_REQ_ATTACH: 10696 ocs_sm_transition(ctx, __ocs_hw_domain_attach_reg_vfi, data); 10697 break; 10698 case OCS_EVT_HW_DOMAIN_REQ_FREE: 10699 /* unreg_fcfi/vfi */ 10700 if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) { 10701 ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, NULL); 10702 } else { 10703 ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_vfi, NULL); 10704 } 10705 break; 10706 default: 10707 __ocs_hw_domain_common(__func__, ctx, evt, data); 10708 break; 10709 } 10710 10711 return NULL; 10712 } 10713 10714 static void * 10715 __ocs_hw_domain_alloc_read_sparm64(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10716 { 10717 ocs_domain_t *domain = ctx->app; 10718 ocs_hw_t *hw = domain->hw; 10719 10720 smtrace("domain"); 10721 10722 switch (evt) { 10723 case OCS_EVT_ENTER: 10724 if (0 == sli_cmd_read_sparm64(&hw->sli, data, SLI4_BMBX_SIZE, 10725 &domain->dma, SLI4_READ_SPARM64_VPI_DEFAULT)) { 10726 ocs_log_err(hw->os, "READ_SPARM64 format failure\n"); 10727 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10728 break; 10729 } 10730 10731 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 10732 ocs_log_err(hw->os, "READ_SPARM64 command failure\n"); 10733 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10734 break; 10735 } 10736 break; 10737 case OCS_EVT_EXIT: 10738 break; 10739 case OCS_EVT_RESPONSE: 10740 ocs_display_sparams(domain->display_name, "domain sparm64", 0, NULL, domain->dma.virt); 10741 10742 ocs_sm_transition(ctx, __ocs_hw_domain_allocated, data); 10743 break; 10744 case OCS_EVT_ERROR: 10745 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data); 10746 break; 10747 default: 10748 __ocs_hw_domain_common(__func__, ctx, evt, data); 10749 break; 10750 } 10751 10752 return NULL; 10753 } 10754 10755 static void * 10756 __ocs_hw_domain_alloc_init_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10757 { 10758 ocs_domain_t *domain = ctx->app; 10759 ocs_sli_port_t *sport = domain->sport; 10760 ocs_hw_t *hw = domain->hw; 10761 10762 smtrace("domain"); 10763 10764 switch (evt) { 10765 case OCS_EVT_ENTER: 10766 if (0 == sli_cmd_init_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->indicator, 10767 domain->fcf_indicator, sport->indicator)) { 10768 ocs_log_err(hw->os, "INIT_VFI format failure\n"); 10769 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10770 break; 10771 } 10772 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 10773 ocs_log_err(hw->os, "INIT_VFI command failure\n"); 10774 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10775 break; 10776 } 10777 break; 10778 case OCS_EVT_EXIT: 10779 break; 10780 case OCS_EVT_RESPONSE: 10781 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_read_sparm64, data); 10782 break; 10783 case OCS_EVT_ERROR: 10784 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data); 10785 break; 10786 default: 10787 __ocs_hw_domain_common(__func__, ctx, evt, data); 10788 break; 10789 } 10790 10791 return NULL; 10792 } 10793 10794 static void * 10795 __ocs_hw_domain_alloc_reg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10796 { 10797 ocs_domain_t *domain = ctx->app; 10798 ocs_hw_t *hw = domain->hw; 10799 10800 smtrace("domain"); 10801 10802 switch (evt) { 10803 case OCS_EVT_ENTER: { 10804 sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG]; 10805 uint32_t i; 10806 10807 /* Set the filter match/mask values from hw's filter_def values */ 10808 for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) { 10809 rq_cfg[i].rq_id = 0xffff; 10810 rq_cfg[i].r_ctl_mask = (uint8_t) hw->config.filter_def[i]; 10811 rq_cfg[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8); 10812 rq_cfg[i].type_mask = (uint8_t) (hw->config.filter_def[i] >> 16); 10813 rq_cfg[i].type_match = (uint8_t) (hw->config.filter_def[i] >> 24); 10814 } 10815 10816 /* Set the rq_id for each, in order of RQ definition */ 10817 for (i = 0; i < hw->hw_rq_count; i++) { 10818 if (i >= ARRAY_SIZE(rq_cfg)) { 10819 ocs_log_warn(hw->os, "more RQs than REG_FCFI filter entries\n"); 10820 break; 10821 } 10822 rq_cfg[i].rq_id = hw->hw_rq[i]->hdr->id; 10823 } 10824 10825 if (!data) { 10826 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10827 break; 10828 } 10829 10830 if (hw->hw_mrq_count) { 10831 if (OCS_HW_RTN_SUCCESS != ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_FCFI_MODE, 10832 domain->vlan_id, domain->fcf)) { 10833 ocs_log_err(hw->os, "REG_FCFI_MRQ format failure\n"); 10834 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10835 break; 10836 } 10837 10838 } else { 10839 if (0 == sli_cmd_reg_fcfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf, 10840 rq_cfg, domain->vlan_id)) { 10841 ocs_log_err(hw->os, "REG_FCFI format failure\n"); 10842 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10843 break; 10844 } 10845 } 10846 10847 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 10848 ocs_log_err(hw->os, "REG_FCFI command failure\n"); 10849 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10850 break; 10851 } 10852 break; 10853 } 10854 case OCS_EVT_EXIT: 10855 break; 10856 case OCS_EVT_RESPONSE: 10857 if (!data) { 10858 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 10859 break; 10860 } 10861 10862 domain->fcf_indicator = ((sli4_cmd_reg_fcfi_t *)data)->fcfi; 10863 10864 /* 10865 * IF_TYPE 0 devices do not support explicit VFI and VPI initialization 10866 * and instead rely on implicit initialization during VFI registration. 10867 * Short circuit normal processing here for those devices. 10868 */ 10869 if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) { 10870 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_read_sparm64, data); 10871 } else { 10872 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_init_vfi, data); 10873 } 10874 break; 10875 case OCS_EVT_ERROR: 10876 ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data); 10877 break; 10878 default: 10879 __ocs_hw_domain_common(__func__, ctx, evt, data); 10880 break; 10881 } 10882 10883 return NULL; 10884 } 10885 10886 static void * 10887 __ocs_hw_domain_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10888 { 10889 ocs_domain_t *domain = ctx->app; 10890 ocs_hw_t *hw = domain->hw; 10891 10892 smtrace("domain"); 10893 10894 switch (evt) { 10895 case OCS_EVT_ENTER: 10896 if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) { 10897 /* 10898 * For FC, the HW alread registered a FCFI 10899 * Copy FCF information into the domain and jump to INIT_VFI 10900 */ 10901 domain->fcf_indicator = hw->fcf_indicator; 10902 ocs_sm_transition(&domain->sm, __ocs_hw_domain_alloc_init_vfi, data); 10903 } else { 10904 ocs_sm_transition(&domain->sm, __ocs_hw_domain_alloc_reg_fcfi, data); 10905 } 10906 break; 10907 default: 10908 __ocs_hw_domain_common(__func__, ctx, evt, data); 10909 break; 10910 } 10911 10912 return NULL; 10913 } 10914 10915 static void * 10916 __ocs_hw_domain_free_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10917 { 10918 ocs_domain_t *domain = ctx->app; 10919 10920 smtrace("domain"); 10921 10922 switch (evt) { 10923 case OCS_EVT_ENTER: 10924 if (domain != NULL) { 10925 ocs_hw_t *hw = domain->hw; 10926 10927 ocs_hw_domain_del(hw, domain); 10928 10929 if (hw->callback.domain != NULL) { 10930 hw->callback.domain(hw->args.domain, 10931 OCS_HW_DOMAIN_FREE_FAIL, 10932 domain); 10933 } 10934 } 10935 10936 /* free command buffer */ 10937 if (data != NULL) { 10938 ocs_free(domain != NULL ? domain->hw->os : NULL, data, SLI4_BMBX_SIZE); 10939 } 10940 break; 10941 case OCS_EVT_EXIT: 10942 break; 10943 default: 10944 __ocs_hw_domain_common(__func__, ctx, evt, data); 10945 break; 10946 } 10947 10948 return NULL; 10949 } 10950 10951 static void * 10952 __ocs_hw_domain_freed(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10953 { 10954 ocs_domain_t *domain = ctx->app; 10955 10956 smtrace("domain"); 10957 10958 switch (evt) { 10959 case OCS_EVT_ENTER: 10960 /* Free DMA and mailbox buffer */ 10961 if (domain != NULL) { 10962 ocs_hw_t *hw = domain->hw; 10963 10964 /* free VFI resource */ 10965 sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, 10966 domain->indicator); 10967 10968 ocs_hw_domain_del(hw, domain); 10969 10970 /* inform registered callbacks */ 10971 if (hw->callback.domain != NULL) { 10972 hw->callback.domain(hw->args.domain, 10973 OCS_HW_DOMAIN_FREE_OK, 10974 domain); 10975 } 10976 } 10977 if (data != NULL) { 10978 ocs_free(NULL, data, SLI4_BMBX_SIZE); 10979 } 10980 break; 10981 case OCS_EVT_EXIT: 10982 break; 10983 default: 10984 __ocs_hw_domain_common(__func__, ctx, evt, data); 10985 break; 10986 } 10987 10988 return NULL; 10989 } 10990 10991 static void * 10992 __ocs_hw_domain_free_redisc_fcf(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 10993 { 10994 ocs_domain_t *domain = ctx->app; 10995 ocs_hw_t *hw = domain->hw; 10996 10997 smtrace("domain"); 10998 10999 switch (evt) { 11000 case OCS_EVT_ENTER: 11001 /* if we're in the middle of a teardown, skip sending rediscover */ 11002 if (hw->state == OCS_HW_STATE_TEARDOWN_IN_PROGRESS) { 11003 ocs_sm_transition(ctx, __ocs_hw_domain_freed, data); 11004 break; 11005 } 11006 if (0 == sli_cmd_fcoe_rediscover_fcf(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf)) { 11007 ocs_log_err(hw->os, "REDISCOVER_FCF format failure\n"); 11008 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11009 break; 11010 } 11011 11012 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 11013 ocs_log_err(hw->os, "REDISCOVER_FCF command failure\n"); 11014 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11015 } 11016 break; 11017 case OCS_EVT_RESPONSE: 11018 case OCS_EVT_ERROR: 11019 /* REDISCOVER_FCF can fail if none exist */ 11020 ocs_sm_transition(ctx, __ocs_hw_domain_freed, data); 11021 break; 11022 case OCS_EVT_EXIT: 11023 break; 11024 default: 11025 __ocs_hw_domain_common(__func__, ctx, evt, data); 11026 break; 11027 } 11028 11029 return NULL; 11030 } 11031 11032 static void * 11033 __ocs_hw_domain_free_unreg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 11034 { 11035 ocs_domain_t *domain = ctx->app; 11036 ocs_hw_t *hw = domain->hw; 11037 11038 smtrace("domain"); 11039 11040 switch (evt) { 11041 case OCS_EVT_ENTER: 11042 if (data == NULL) { 11043 data = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 11044 if (!data) { 11045 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11046 break; 11047 } 11048 } 11049 11050 if (0 == sli_cmd_unreg_fcfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf_indicator)) { 11051 ocs_log_err(hw->os, "UNREG_FCFI format failure\n"); 11052 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 11053 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11054 break; 11055 } 11056 11057 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 11058 ocs_log_err(hw->os, "UNREG_FCFI command failure\n"); 11059 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 11060 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11061 break; 11062 } 11063 break; 11064 case OCS_EVT_RESPONSE: 11065 if (domain->req_rediscover_fcf) { 11066 domain->req_rediscover_fcf = FALSE; 11067 ocs_sm_transition(ctx, __ocs_hw_domain_free_redisc_fcf, data); 11068 } else { 11069 ocs_sm_transition(ctx, __ocs_hw_domain_freed, data); 11070 } 11071 break; 11072 case OCS_EVT_ERROR: 11073 ocs_sm_transition(ctx, __ocs_hw_domain_free_report_fail, data); 11074 break; 11075 case OCS_EVT_EXIT: 11076 break; 11077 default: 11078 __ocs_hw_domain_common(__func__, ctx, evt, data); 11079 break; 11080 } 11081 11082 return NULL; 11083 } 11084 11085 static void * 11086 __ocs_hw_domain_free_unreg_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data) 11087 { 11088 ocs_domain_t *domain = ctx->app; 11089 ocs_hw_t *hw = domain->hw; 11090 uint8_t is_fc = FALSE; 11091 11092 smtrace("domain"); 11093 11094 is_fc = (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC); 11095 11096 switch (evt) { 11097 case OCS_EVT_ENTER: 11098 if (data == NULL) { 11099 data = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT); 11100 if (!data) { 11101 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11102 break; 11103 } 11104 } 11105 11106 if (0 == sli_cmd_unreg_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain, 11107 SLI4_UNREG_TYPE_DOMAIN)) { 11108 ocs_log_err(hw->os, "UNREG_VFI format failure\n"); 11109 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 11110 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11111 break; 11112 } 11113 11114 if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) { 11115 ocs_log_err(hw->os, "UNREG_VFI command failure\n"); 11116 ocs_free(hw->os, data, SLI4_BMBX_SIZE); 11117 ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL); 11118 break; 11119 } 11120 break; 11121 case OCS_EVT_ERROR: 11122 if (is_fc) { 11123 ocs_sm_transition(ctx, __ocs_hw_domain_free_report_fail, data); 11124 } else { 11125 ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, data); 11126 } 11127 break; 11128 case OCS_EVT_RESPONSE: 11129 if (is_fc) { 11130 ocs_sm_transition(ctx, __ocs_hw_domain_freed, data); 11131 } else { 11132 ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, data); 11133 } 11134 break; 11135 default: 11136 __ocs_hw_domain_common(__func__, ctx, evt, data); 11137 break; 11138 } 11139 11140 return NULL; 11141 } 11142 11143 /* callback for domain alloc/attach/free */ 11144 static int32_t 11145 __ocs_hw_domain_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 11146 { 11147 ocs_domain_t *domain = arg; 11148 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 11149 ocs_sm_event_t evt; 11150 11151 if (status || hdr->status) { 11152 ocs_log_debug(hw->os, "bad status vfi=%#x st=%x hdr=%x\n", 11153 domain->indicator, status, hdr->status); 11154 evt = OCS_EVT_ERROR; 11155 } else { 11156 evt = OCS_EVT_RESPONSE; 11157 } 11158 11159 ocs_sm_post_event(&domain->sm, evt, mqe); 11160 11161 return 0; 11162 } 11163 11164 static int32_t 11165 target_wqe_timer_nop_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 11166 { 11167 ocs_hw_io_t *io = NULL; 11168 ocs_hw_io_t *io_next = NULL; 11169 uint64_t ticks_current = ocs_get_os_ticks(); 11170 uint32_t sec_elapsed; 11171 ocs_hw_rtn_e rc; 11172 11173 sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mqe; 11174 11175 if (status || hdr->status) { 11176 ocs_log_debug(hw->os, "bad status st=%x hdr=%x\n", 11177 status, hdr->status); 11178 /* go ahead and proceed with wqe timer checks... */ 11179 } 11180 11181 /* loop through active WQE list and check for timeouts */ 11182 ocs_lock(&hw->io_lock); 11183 ocs_list_foreach_safe(&hw->io_timed_wqe, io, io_next) { 11184 sec_elapsed = ((ticks_current - io->submit_ticks) / ocs_get_os_tick_freq()); 11185 11186 /* 11187 * If elapsed time > timeout, abort it. No need to check type since 11188 * it wouldn't be on this list unless it was a target WQE 11189 */ 11190 if (sec_elapsed > io->tgt_wqe_timeout) { 11191 ocs_log_test(hw->os, "IO timeout xri=0x%x tag=0x%x type=%d\n", 11192 io->indicator, io->reqtag, io->type); 11193 11194 /* remove from active_wqe list so won't try to abort again */ 11195 ocs_list_remove(&hw->io_timed_wqe, io); 11196 11197 /* save status of "timed out" for when abort completes */ 11198 io->status_saved = 1; 11199 io->saved_status = SLI4_FC_WCQE_STATUS_TARGET_WQE_TIMEOUT; 11200 io->saved_ext = 0; 11201 io->saved_len = 0; 11202 11203 /* now abort outstanding IO */ 11204 rc = ocs_hw_io_abort(hw, io, FALSE, NULL, NULL); 11205 if (rc) { 11206 ocs_log_test(hw->os, 11207 "abort failed xri=%#x tag=%#x rc=%d\n", 11208 io->indicator, io->reqtag, rc); 11209 } 11210 } 11211 /* 11212 * need to go through entire list since each IO could have a 11213 * different timeout value 11214 */ 11215 } 11216 ocs_unlock(&hw->io_lock); 11217 11218 /* if we're not in the middle of shutting down, schedule next timer */ 11219 if (!hw->active_wqe_timer_shutdown) { 11220 ocs_setup_timer(hw->os, &hw->wqe_timer, target_wqe_timer_cb, hw, OCS_HW_WQ_TIMER_PERIOD_MS); 11221 } 11222 hw->in_active_wqe_timer = FALSE; 11223 return 0; 11224 } 11225 11226 static void 11227 target_wqe_timer_cb(void *arg) 11228 { 11229 ocs_hw_t *hw = (ocs_hw_t *)arg; 11230 11231 /* delete existing timer; will kick off new timer after checking wqe timeouts */ 11232 hw->in_active_wqe_timer = TRUE; 11233 ocs_del_timer(&hw->wqe_timer); 11234 11235 /* Forward timer callback to execute in the mailbox completion processing context */ 11236 if (ocs_hw_async_call(hw, target_wqe_timer_nop_cb, hw)) { 11237 ocs_log_test(hw->os, "ocs_hw_async_call failed\n"); 11238 } 11239 } 11240 11241 static void 11242 shutdown_target_wqe_timer(ocs_hw_t *hw) 11243 { 11244 uint32_t iters = 100; 11245 11246 if (hw->config.emulate_tgt_wqe_timeout) { 11247 /* request active wqe timer shutdown, then wait for it to complete */ 11248 hw->active_wqe_timer_shutdown = TRUE; 11249 11250 /* delete WQE timer and wait for timer handler to complete (if necessary) */ 11251 ocs_del_timer(&hw->wqe_timer); 11252 11253 /* now wait for timer handler to complete (if necessary) */ 11254 while (hw->in_active_wqe_timer && iters) { 11255 /* 11256 * if we happen to have just sent NOP mailbox command, make sure 11257 * completions are being processed 11258 */ 11259 ocs_hw_flush(hw); 11260 iters--; 11261 } 11262 11263 if (iters == 0) { 11264 ocs_log_test(hw->os, "Failed to shutdown active wqe timer\n"); 11265 } 11266 } 11267 } 11268 11269 /** 11270 * @brief Determine if HW IO is owned by the port. 11271 * 11272 * @par Description 11273 * Determines if the given HW IO has been posted to the chip. 11274 * 11275 * @param hw Hardware context allocated by the caller. 11276 * @param io HW IO. 11277 * 11278 * @return Returns TRUE if given HW IO is port-owned. 11279 */ 11280 uint8_t 11281 ocs_hw_is_io_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io) 11282 { 11283 /* Check to see if this is a port owned XRI */ 11284 return io->is_port_owned; 11285 } 11286 11287 /** 11288 * @brief Return TRUE if exchange is port-owned. 11289 * 11290 * @par Description 11291 * Test to see if the xri is a port-owned xri. 11292 * 11293 * @param hw Hardware context. 11294 * @param xri Exchange indicator. 11295 * 11296 * @return Returns TRUE if XRI is a port owned XRI. 11297 */ 11298 11299 uint8_t 11300 ocs_hw_is_xri_port_owned(ocs_hw_t *hw, uint32_t xri) 11301 { 11302 ocs_hw_io_t *io = ocs_hw_io_lookup(hw, xri); 11303 return (io == NULL ? FALSE : io->is_port_owned); 11304 } 11305 11306 /** 11307 * @brief Returns an XRI from the port owned list to the host. 11308 * 11309 * @par Description 11310 * Used when the POST_XRI command fails as well as when the RELEASE_XRI completes. 11311 * 11312 * @param hw Hardware context. 11313 * @param xri_base The starting XRI number. 11314 * @param xri_count The number of XRIs to free from the base. 11315 */ 11316 static void 11317 ocs_hw_reclaim_xri(ocs_hw_t *hw, uint16_t xri_base, uint16_t xri_count) 11318 { 11319 ocs_hw_io_t *io; 11320 uint32_t i; 11321 11322 for (i = 0; i < xri_count; i++) { 11323 io = ocs_hw_io_lookup(hw, xri_base + i); 11324 11325 /* 11326 * if this is an auto xfer rdy XRI, then we need to release any 11327 * buffer attached to the XRI before moving the XRI back to the free pool. 11328 */ 11329 if (hw->auto_xfer_rdy_enabled) { 11330 ocs_hw_rqpair_auto_xfer_rdy_move_to_host(hw, io); 11331 } 11332 11333 ocs_lock(&hw->io_lock); 11334 ocs_list_remove(&hw->io_port_owned, io); 11335 io->is_port_owned = 0; 11336 ocs_list_add_tail(&hw->io_free, io); 11337 ocs_unlock(&hw->io_lock); 11338 } 11339 } 11340 11341 /** 11342 * @brief Called when the POST_XRI command completes. 11343 * 11344 * @par Description 11345 * Free the mailbox command buffer and reclaim the XRIs on failure. 11346 * 11347 * @param hw Hardware context. 11348 * @param status Status field from the mbox completion. 11349 * @param mqe Mailbox response structure. 11350 * @param arg Pointer to a callback function that signals the caller that the command is done. 11351 * 11352 * @return Returns 0. 11353 */ 11354 static int32_t 11355 ocs_hw_cb_post_xri(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 11356 { 11357 sli4_cmd_post_xri_t *post_xri = (sli4_cmd_post_xri_t*)mqe; 11358 11359 /* Reclaim the XRIs as host owned if the command fails */ 11360 if (status != 0) { 11361 ocs_log_debug(hw->os, "Status 0x%x for XRI base 0x%x, cnt =x%x\n", 11362 status, post_xri->xri_base, post_xri->xri_count); 11363 ocs_hw_reclaim_xri(hw, post_xri->xri_base, post_xri->xri_count); 11364 } 11365 11366 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 11367 return 0; 11368 } 11369 11370 /** 11371 * @brief Issues a mailbox command to move XRIs from the host-controlled pool to the port. 11372 * 11373 * @param hw Hardware context. 11374 * @param xri_start The starting XRI to post. 11375 * @param num_to_post The number of XRIs to post. 11376 * 11377 * @return Returns OCS_HW_RTN_NO_MEMORY, OCS_HW_RTN_ERROR, or OCS_HW_RTN_SUCCESS. 11378 */ 11379 11380 static ocs_hw_rtn_e 11381 ocs_hw_post_xri(ocs_hw_t *hw, uint32_t xri_start, uint32_t num_to_post) 11382 { 11383 uint8_t *post_xri; 11384 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 11385 11386 /* Since we need to allocate for mailbox queue, just always allocate */ 11387 post_xri = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 11388 if (post_xri == NULL) { 11389 ocs_log_err(hw->os, "no buffer for command\n"); 11390 return OCS_HW_RTN_NO_MEMORY; 11391 } 11392 11393 /* Register the XRIs */ 11394 if (sli_cmd_post_xri(&hw->sli, post_xri, SLI4_BMBX_SIZE, 11395 xri_start, num_to_post)) { 11396 rc = ocs_hw_command(hw, post_xri, OCS_CMD_NOWAIT, ocs_hw_cb_post_xri, NULL); 11397 if (rc != OCS_HW_RTN_SUCCESS) { 11398 ocs_free(hw->os, post_xri, SLI4_BMBX_SIZE); 11399 ocs_log_err(hw->os, "post_xri failed\n"); 11400 } 11401 } 11402 return rc; 11403 } 11404 11405 /** 11406 * @brief Move XRIs from the host-controlled pool to the port. 11407 * 11408 * @par Description 11409 * Removes IOs from the free list and moves them to the port. 11410 * 11411 * @param hw Hardware context. 11412 * @param num_xri The number of XRIs being requested to move to the chip. 11413 * 11414 * @return Returns the number of XRIs that were moved. 11415 */ 11416 11417 uint32_t 11418 ocs_hw_xri_move_to_port_owned(ocs_hw_t *hw, uint32_t num_xri) 11419 { 11420 ocs_hw_io_t *io; 11421 uint32_t i; 11422 uint32_t num_posted = 0; 11423 11424 /* 11425 * Note: We cannot use ocs_hw_io_alloc() because that would place the 11426 * IO on the io_inuse list. We need to move from the io_free to 11427 * the io_port_owned list. 11428 */ 11429 ocs_lock(&hw->io_lock); 11430 11431 for (i = 0; i < num_xri; i++) { 11432 if (NULL != (io = ocs_list_remove_head(&hw->io_free))) { 11433 ocs_hw_rtn_e rc; 11434 11435 /* 11436 * if this is an auto xfer rdy XRI, then we need to attach a 11437 * buffer to the XRI before submitting it to the chip. If a 11438 * buffer is unavailable, then we cannot post it, so return it 11439 * to the free pool. 11440 */ 11441 if (hw->auto_xfer_rdy_enabled) { 11442 /* Note: uses the IO lock to get the auto xfer rdy buffer */ 11443 ocs_unlock(&hw->io_lock); 11444 rc = ocs_hw_rqpair_auto_xfer_rdy_move_to_port(hw, io); 11445 ocs_lock(&hw->io_lock); 11446 if (rc != OCS_HW_RTN_SUCCESS) { 11447 ocs_list_add_head(&hw->io_free, io); 11448 break; 11449 } 11450 } 11451 ocs_lock_init(hw->os, &io->axr_lock, "HW_axr_lock[%d]", io->indicator); 11452 io->is_port_owned = 1; 11453 ocs_list_add_tail(&hw->io_port_owned, io); 11454 11455 /* Post XRI */ 11456 if (ocs_hw_post_xri(hw, io->indicator, 1) != OCS_HW_RTN_SUCCESS ) { 11457 ocs_hw_reclaim_xri(hw, io->indicator, i); 11458 break; 11459 } 11460 num_posted++; 11461 } else { 11462 /* no more free XRIs */ 11463 break; 11464 } 11465 } 11466 ocs_unlock(&hw->io_lock); 11467 11468 return num_posted; 11469 } 11470 11471 /** 11472 * @brief Called when the RELEASE_XRI command completes. 11473 * 11474 * @par Description 11475 * Move the IOs back to the free pool on success. 11476 * 11477 * @param hw Hardware context. 11478 * @param status Status field from the mbox completion. 11479 * @param mqe Mailbox response structure. 11480 * @param arg Pointer to a callback function that signals the caller that the command is done. 11481 * 11482 * @return Returns 0. 11483 */ 11484 static int32_t 11485 ocs_hw_cb_release_xri(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 11486 { 11487 sli4_cmd_release_xri_t *release_xri = (sli4_cmd_release_xri_t*)mqe; 11488 uint8_t i; 11489 11490 /* Reclaim the XRIs as host owned if the command fails */ 11491 if (status != 0) { 11492 ocs_log_err(hw->os, "Status 0x%x\n", status); 11493 } else { 11494 for (i = 0; i < release_xri->released_xri_count; i++) { 11495 uint16_t xri = ((i & 1) == 0 ? release_xri->xri_tbl[i/2].xri_tag0 : 11496 release_xri->xri_tbl[i/2].xri_tag1); 11497 ocs_hw_reclaim_xri(hw, xri, 1); 11498 } 11499 } 11500 11501 ocs_free(hw->os, mqe, SLI4_BMBX_SIZE); 11502 return 0; 11503 } 11504 11505 /** 11506 * @brief Move XRIs from the port-controlled pool to the host. 11507 * 11508 * Requests XRIs from the FW to return to the host-owned pool. 11509 * 11510 * @param hw Hardware context. 11511 * @param num_xri The number of XRIs being requested to moved from the chip. 11512 * 11513 * @return Returns 0 for success, or a negative error code value for failure. 11514 */ 11515 11516 ocs_hw_rtn_e 11517 ocs_hw_xri_move_to_host_owned(ocs_hw_t *hw, uint8_t num_xri) 11518 { 11519 uint8_t *release_xri; 11520 ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR; 11521 11522 /* non-local buffer required for mailbox queue */ 11523 release_xri = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT); 11524 if (release_xri == NULL) { 11525 ocs_log_err(hw->os, "no buffer for command\n"); 11526 return OCS_HW_RTN_NO_MEMORY; 11527 } 11528 11529 /* release the XRIs */ 11530 if (sli_cmd_release_xri(&hw->sli, release_xri, SLI4_BMBX_SIZE, num_xri)) { 11531 rc = ocs_hw_command(hw, release_xri, OCS_CMD_NOWAIT, ocs_hw_cb_release_xri, NULL); 11532 if (rc != OCS_HW_RTN_SUCCESS) { 11533 ocs_log_err(hw->os, "release_xri failed\n"); 11534 } 11535 } 11536 /* If we are polling or an error occurred, then free the mailbox buffer */ 11537 if (release_xri != NULL && rc != OCS_HW_RTN_SUCCESS) { 11538 ocs_free(hw->os, release_xri, SLI4_BMBX_SIZE); 11539 } 11540 return rc; 11541 } 11542 11543 /** 11544 * @brief Allocate an ocs_hw_rx_buffer_t array. 11545 * 11546 * @par Description 11547 * An ocs_hw_rx_buffer_t array is allocated, along with the required DMA memory. 11548 * 11549 * @param hw Pointer to HW object. 11550 * @param rqindex RQ index for this buffer. 11551 * @param count Count of buffers in array. 11552 * @param size Size of buffer. 11553 * 11554 * @return Returns the pointer to the allocated ocs_hw_rq_buffer_t array. 11555 */ 11556 static ocs_hw_rq_buffer_t * 11557 ocs_hw_rx_buffer_alloc(ocs_hw_t *hw, uint32_t rqindex, uint32_t count, uint32_t size) 11558 { 11559 ocs_t *ocs = hw->os; 11560 ocs_hw_rq_buffer_t *rq_buf = NULL; 11561 ocs_hw_rq_buffer_t *prq; 11562 uint32_t i; 11563 11564 if (count != 0) { 11565 rq_buf = ocs_malloc(hw->os, sizeof(*rq_buf) * count, OCS_M_NOWAIT | OCS_M_ZERO); 11566 if (rq_buf == NULL) { 11567 ocs_log_err(hw->os, "Failure to allocate unsolicited DMA trackers\n"); 11568 return NULL; 11569 } 11570 11571 for (i = 0, prq = rq_buf; i < count; i ++, prq++) { 11572 prq->rqindex = rqindex; 11573 if (ocs_dma_alloc(ocs, &prq->dma, size, OCS_MIN_DMA_ALIGNMENT)) { 11574 ocs_log_err(hw->os, "DMA allocation failed\n"); 11575 ocs_free(hw->os, rq_buf, sizeof(*rq_buf) * count); 11576 rq_buf = NULL; 11577 break; 11578 } 11579 } 11580 } 11581 return rq_buf; 11582 } 11583 11584 /** 11585 * @brief Free an ocs_hw_rx_buffer_t array. 11586 * 11587 * @par Description 11588 * The ocs_hw_rx_buffer_t array is freed, along with allocated DMA memory. 11589 * 11590 * @param hw Pointer to HW object. 11591 * @param rq_buf Pointer to ocs_hw_rx_buffer_t array. 11592 * @param count Count of buffers in array. 11593 * 11594 * @return None. 11595 */ 11596 static void 11597 ocs_hw_rx_buffer_free(ocs_hw_t *hw, ocs_hw_rq_buffer_t *rq_buf, uint32_t count) 11598 { 11599 ocs_t *ocs = hw->os; 11600 uint32_t i; 11601 ocs_hw_rq_buffer_t *prq; 11602 11603 if (rq_buf != NULL) { 11604 for (i = 0, prq = rq_buf; i < count; i++, prq++) { 11605 ocs_dma_free(ocs, &prq->dma); 11606 } 11607 ocs_free(hw->os, rq_buf, sizeof(*rq_buf) * count); 11608 } 11609 } 11610 11611 /** 11612 * @brief Allocate the RQ data buffers. 11613 * 11614 * @param hw Pointer to HW object. 11615 * 11616 * @return Returns 0 on success, or a non-zero value on failure. 11617 */ 11618 ocs_hw_rtn_e 11619 ocs_hw_rx_allocate(ocs_hw_t *hw) 11620 { 11621 ocs_t *ocs = hw->os; 11622 uint32_t i; 11623 int32_t rc = OCS_HW_RTN_SUCCESS; 11624 uint32_t rqindex = 0; 11625 hw_rq_t *rq; 11626 uint32_t hdr_size = OCS_HW_RQ_SIZE_HDR; 11627 uint32_t payload_size = hw->config.rq_default_buffer_size; 11628 11629 rqindex = 0; 11630 11631 for (i = 0; i < hw->hw_rq_count; i++) { 11632 rq = hw->hw_rq[i]; 11633 11634 /* Allocate header buffers */ 11635 rq->hdr_buf = ocs_hw_rx_buffer_alloc(hw, rqindex, rq->entry_count, hdr_size); 11636 if (rq->hdr_buf == NULL) { 11637 ocs_log_err(ocs, "ocs_hw_rx_buffer_alloc hdr_buf failed\n"); 11638 rc = OCS_HW_RTN_ERROR; 11639 break; 11640 } 11641 11642 ocs_log_debug(hw->os, "rq[%2d] rq_id %02d header %4d by %4d bytes\n", i, rq->hdr->id, 11643 rq->entry_count, hdr_size); 11644 11645 rqindex++; 11646 11647 /* Allocate payload buffers */ 11648 rq->payload_buf = ocs_hw_rx_buffer_alloc(hw, rqindex, rq->entry_count, payload_size); 11649 if (rq->payload_buf == NULL) { 11650 ocs_log_err(ocs, "ocs_hw_rx_buffer_alloc fb_buf failed\n"); 11651 rc = OCS_HW_RTN_ERROR; 11652 break; 11653 } 11654 ocs_log_debug(hw->os, "rq[%2d] rq_id %02d default %4d by %4d bytes\n", i, rq->data->id, 11655 rq->entry_count, payload_size); 11656 rqindex++; 11657 } 11658 11659 return rc ? OCS_HW_RTN_ERROR : OCS_HW_RTN_SUCCESS; 11660 } 11661 11662 /** 11663 * @brief Post the RQ data buffers to the chip. 11664 * 11665 * @param hw Pointer to HW object. 11666 * 11667 * @return Returns 0 on success, or a non-zero value on failure. 11668 */ 11669 ocs_hw_rtn_e 11670 ocs_hw_rx_post(ocs_hw_t *hw) 11671 { 11672 uint32_t i; 11673 uint32_t idx; 11674 uint32_t rq_idx; 11675 int32_t rc = 0; 11676 11677 /* 11678 * In RQ pair mode, we MUST post the header and payload buffer at the 11679 * same time. 11680 */ 11681 for (rq_idx = 0, idx = 0; rq_idx < hw->hw_rq_count; rq_idx++) { 11682 hw_rq_t *rq = hw->hw_rq[rq_idx]; 11683 11684 for (i = 0; i < rq->entry_count-1; i++) { 11685 ocs_hw_sequence_t *seq = ocs_array_get(hw->seq_pool, idx++); 11686 ocs_hw_assert(seq != NULL); 11687 11688 seq->header = &rq->hdr_buf[i]; 11689 11690 seq->payload = &rq->payload_buf[i]; 11691 11692 rc = ocs_hw_sequence_free(hw, seq); 11693 if (rc) { 11694 break; 11695 } 11696 } 11697 if (rc) { 11698 break; 11699 } 11700 } 11701 11702 return rc; 11703 } 11704 11705 /** 11706 * @brief Free the RQ data buffers. 11707 * 11708 * @param hw Pointer to HW object. 11709 * 11710 */ 11711 void 11712 ocs_hw_rx_free(ocs_hw_t *hw) 11713 { 11714 hw_rq_t *rq; 11715 uint32_t i; 11716 11717 /* Free hw_rq buffers */ 11718 for (i = 0; i < hw->hw_rq_count; i++) { 11719 rq = hw->hw_rq[i]; 11720 if (rq != NULL) { 11721 ocs_hw_rx_buffer_free(hw, rq->hdr_buf, rq->entry_count); 11722 rq->hdr_buf = NULL; 11723 ocs_hw_rx_buffer_free(hw, rq->payload_buf, rq->entry_count); 11724 rq->payload_buf = NULL; 11725 } 11726 } 11727 } 11728 11729 /** 11730 * @brief HW async call context structure. 11731 */ 11732 typedef struct { 11733 ocs_hw_async_cb_t callback; 11734 void *arg; 11735 uint8_t cmd[SLI4_BMBX_SIZE]; 11736 } ocs_hw_async_call_ctx_t; 11737 11738 /** 11739 * @brief HW async callback handler 11740 * 11741 * @par Description 11742 * This function is called when the NOP mailbox command completes. The callback stored 11743 * in the requesting context is invoked. 11744 * 11745 * @param hw Pointer to HW object. 11746 * @param status Completion status. 11747 * @param mqe Pointer to mailbox completion queue entry. 11748 * @param arg Caller-provided argument. 11749 * 11750 * @return None. 11751 */ 11752 static void 11753 ocs_hw_async_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg) 11754 { 11755 ocs_hw_async_call_ctx_t *ctx = arg; 11756 11757 if (ctx != NULL) { 11758 if (ctx->callback != NULL) { 11759 (*ctx->callback)(hw, status, mqe, ctx->arg); 11760 } 11761 ocs_free(hw->os, ctx, sizeof(*ctx)); 11762 } 11763 } 11764 11765 /** 11766 * @brief Make an async callback using NOP mailbox command 11767 * 11768 * @par Description 11769 * Post a NOP mailbox command; the callback with argument is invoked upon completion 11770 * while in the event processing context. 11771 * 11772 * @param hw Pointer to HW object. 11773 * @param callback Pointer to callback function. 11774 * @param arg Caller-provided callback. 11775 * 11776 * @return Returns 0 on success, or a negative error code value on failure. 11777 */ 11778 int32_t 11779 ocs_hw_async_call(ocs_hw_t *hw, ocs_hw_async_cb_t callback, void *arg) 11780 { 11781 int32_t rc = 0; 11782 ocs_hw_async_call_ctx_t *ctx; 11783 11784 /* 11785 * Allocate a callback context (which includes the mailbox command buffer), we need 11786 * this to be persistent as the mailbox command submission may be queued and executed later 11787 * execution. 11788 */ 11789 ctx = ocs_malloc(hw->os, sizeof(*ctx), OCS_M_ZERO | OCS_M_NOWAIT); 11790 if (ctx == NULL) { 11791 ocs_log_err(hw->os, "failed to malloc async call context\n"); 11792 return OCS_HW_RTN_NO_MEMORY; 11793 } 11794 ctx->callback = callback; 11795 ctx->arg = arg; 11796 11797 /* Build and send a NOP mailbox command */ 11798 if (sli_cmd_common_nop(&hw->sli, ctx->cmd, sizeof(ctx->cmd), 0) == 0) { 11799 ocs_log_err(hw->os, "COMMON_NOP format failure\n"); 11800 ocs_free(hw->os, ctx, sizeof(*ctx)); 11801 rc = -1; 11802 } 11803 11804 if (ocs_hw_command(hw, ctx->cmd, OCS_CMD_NOWAIT, ocs_hw_async_cb, ctx)) { 11805 ocs_log_err(hw->os, "COMMON_NOP command failure\n"); 11806 ocs_free(hw->os, ctx, sizeof(*ctx)); 11807 rc = -1; 11808 } 11809 return rc; 11810 } 11811 11812 /** 11813 * @brief Initialize the reqtag pool. 11814 * 11815 * @par Description 11816 * The WQ request tag pool is initialized. 11817 * 11818 * @param hw Pointer to HW object. 11819 * 11820 * @return Returns 0 on success, or a negative error code value on failure. 11821 */ 11822 ocs_hw_rtn_e 11823 ocs_hw_reqtag_init(ocs_hw_t *hw) 11824 { 11825 if (hw->wq_reqtag_pool == NULL) { 11826 hw->wq_reqtag_pool = ocs_pool_alloc(hw->os, sizeof(hw_wq_callback_t), 65536, TRUE); 11827 if (hw->wq_reqtag_pool == NULL) { 11828 ocs_log_err(hw->os, "ocs_pool_alloc hw_wq_callback_t failed\n"); 11829 return OCS_HW_RTN_NO_MEMORY; 11830 } 11831 } 11832 ocs_hw_reqtag_reset(hw); 11833 return OCS_HW_RTN_SUCCESS; 11834 } 11835 11836 /** 11837 * @brief Allocate a WQ request tag. 11838 * 11839 * Allocate and populate a WQ request tag from the WQ request tag pool. 11840 * 11841 * @param hw Pointer to HW object. 11842 * @param callback Callback function. 11843 * @param arg Pointer to callback argument. 11844 * 11845 * @return Returns pointer to allocated WQ request tag, or NULL if object cannot be allocated. 11846 */ 11847 hw_wq_callback_t * 11848 ocs_hw_reqtag_alloc(ocs_hw_t *hw, void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg) 11849 { 11850 hw_wq_callback_t *wqcb; 11851 11852 ocs_hw_assert(callback != NULL); 11853 11854 wqcb = ocs_pool_get(hw->wq_reqtag_pool); 11855 if (wqcb != NULL) { 11856 ocs_hw_assert(wqcb->callback == NULL); 11857 wqcb->callback = callback; 11858 wqcb->arg = arg; 11859 } 11860 return wqcb; 11861 } 11862 11863 /** 11864 * @brief Free a WQ request tag. 11865 * 11866 * Free the passed in WQ request tag. 11867 * 11868 * @param hw Pointer to HW object. 11869 * @param wqcb Pointer to WQ request tag object to free. 11870 * 11871 * @return None. 11872 */ 11873 void 11874 ocs_hw_reqtag_free(ocs_hw_t *hw, hw_wq_callback_t *wqcb) 11875 { 11876 ocs_hw_assert(wqcb->callback != NULL); 11877 wqcb->callback = NULL; 11878 wqcb->arg = NULL; 11879 ocs_pool_put(hw->wq_reqtag_pool, wqcb); 11880 } 11881 11882 /** 11883 * @brief Return WQ request tag by index. 11884 * 11885 * @par Description 11886 * Return pointer to WQ request tag object given an index. 11887 * 11888 * @param hw Pointer to HW object. 11889 * @param instance_index Index of WQ request tag to return. 11890 * 11891 * @return Pointer to WQ request tag, or NULL. 11892 */ 11893 hw_wq_callback_t * 11894 ocs_hw_reqtag_get_instance(ocs_hw_t *hw, uint32_t instance_index) 11895 { 11896 hw_wq_callback_t *wqcb; 11897 11898 wqcb = ocs_pool_get_instance(hw->wq_reqtag_pool, instance_index); 11899 if (wqcb == NULL) { 11900 ocs_log_err(hw->os, "wqcb for instance %d is null\n", instance_index); 11901 } 11902 return wqcb; 11903 } 11904 11905 /** 11906 * @brief Reset the WQ request tag pool. 11907 * 11908 * @par Description 11909 * Reset the WQ request tag pool, returning all to the free list. 11910 * 11911 * @param hw pointer to HW object. 11912 * 11913 * @return None. 11914 */ 11915 void 11916 ocs_hw_reqtag_reset(ocs_hw_t *hw) 11917 { 11918 hw_wq_callback_t *wqcb; 11919 uint32_t i; 11920 11921 /* Remove all from freelist */ 11922 while(ocs_pool_get(hw->wq_reqtag_pool) != NULL) { 11923 ; 11924 } 11925 11926 /* Put them all back */ 11927 for (i = 0; ((wqcb = ocs_pool_get_instance(hw->wq_reqtag_pool, i)) != NULL); i++) { 11928 wqcb->instance_index = i; 11929 wqcb->callback = NULL; 11930 wqcb->arg = NULL; 11931 ocs_pool_put(hw->wq_reqtag_pool, wqcb); 11932 } 11933 } 11934 11935 /** 11936 * @brief Handle HW assertion 11937 * 11938 * HW assert, display diagnostic message, and abort. 11939 * 11940 * @param cond string describing failing assertion condition 11941 * @param filename file name 11942 * @param linenum line number 11943 * 11944 * @return none 11945 */ 11946 void 11947 _ocs_hw_assert(const char *cond, const char *filename, int linenum) 11948 { 11949 ocs_printf("%s(%d): HW assertion (%s) failed\n", filename, linenum, cond); 11950 ocs_abort(); 11951 /* no return */ 11952 } 11953 11954 /** 11955 * @brief Handle HW verify 11956 * 11957 * HW verify, display diagnostic message, dump stack and return. 11958 * 11959 * @param cond string describing failing verify condition 11960 * @param filename file name 11961 * @param linenum line number 11962 * 11963 * @return none 11964 */ 11965 void 11966 _ocs_hw_verify(const char *cond, const char *filename, int linenum) 11967 { 11968 ocs_printf("%s(%d): HW verify (%s) failed\n", filename, linenum, cond); 11969 ocs_print_stack(); 11970 } 11971 11972 /** 11973 * @brief Reque XRI 11974 * 11975 * @par Description 11976 * Reque XRI 11977 * 11978 * @param hw Pointer to HW object. 11979 * @param io Pointer to HW IO 11980 * 11981 * @return Return 0 if successful else returns -1 11982 */ 11983 int32_t 11984 ocs_hw_reque_xri( ocs_hw_t *hw, ocs_hw_io_t *io ) 11985 { 11986 int32_t rc = 0; 11987 11988 rc = ocs_hw_rqpair_auto_xfer_rdy_buffer_post(hw, io, 1); 11989 if (rc) { 11990 ocs_list_add_tail(&hw->io_port_dnrx, io); 11991 rc = -1; 11992 goto exit_ocs_hw_reque_xri; 11993 } 11994 11995 io->auto_xfer_rdy_dnrx = 0; 11996 io->type = OCS_HW_IO_DNRX_REQUEUE; 11997 if (sli_requeue_xri_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->indicator, OCS_HW_REQUE_XRI_REGTAG, SLI4_CQ_DEFAULT)) { 11998 /* Clear buffer from XRI */ 11999 ocs_pool_put(hw->auto_xfer_rdy_buf_pool, io->axr_buf); 12000 io->axr_buf = NULL; 12001 12002 ocs_log_err(hw->os, "requeue_xri WQE error\n"); 12003 ocs_list_add_tail(&hw->io_port_dnrx, io); 12004 12005 rc = -1; 12006 goto exit_ocs_hw_reque_xri; 12007 } 12008 12009 if (io->wq == NULL) { 12010 io->wq = ocs_hw_queue_next_wq(hw, io); 12011 ocs_hw_assert(io->wq != NULL); 12012 } 12013 12014 /* 12015 * Add IO to active io wqe list before submitting, in case the 12016 * wcqe processing preempts this thread. 12017 */ 12018 OCS_STAT(hw->tcmd_wq_submit[io->wq->instance]++); 12019 OCS_STAT(io->wq->use_count++); 12020 12021 rc = hw_wq_write(io->wq, &io->wqe); 12022 if (rc < 0) { 12023 ocs_log_err(hw->os, "sli_queue_write reque xri failed: %d\n", rc); 12024 rc = -1; 12025 } 12026 12027 exit_ocs_hw_reque_xri: 12028 return 0; 12029 } 12030 12031 uint32_t 12032 ocs_hw_get_def_wwn(ocs_t *ocs, uint32_t chan, uint64_t *wwpn, uint64_t *wwnn) 12033 { 12034 sli4_t *sli4 = &ocs->hw.sli; 12035 ocs_dma_t dma; 12036 uint8_t *payload = NULL; 12037 12038 int indicator = sli4->config.extent[SLI_RSRC_FCOE_VPI].base[0] + chan; 12039 12040 /* allocate memory for the service parameters */ 12041 if (ocs_dma_alloc(ocs, &dma, 112, 4)) { 12042 ocs_log_err(ocs, "Failed to allocate DMA memory\n"); 12043 return 1; 12044 } 12045 12046 if (0 == sli_cmd_read_sparm64(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, 12047 &dma, indicator)) { 12048 ocs_log_err(ocs, "READ_SPARM64 allocation failure\n"); 12049 ocs_dma_free(ocs, &dma); 12050 return 1; 12051 } 12052 12053 if (sli_bmbx_command(sli4)) { 12054 ocs_log_err(ocs, "READ_SPARM64 command failure\n"); 12055 ocs_dma_free(ocs, &dma); 12056 return 1; 12057 } 12058 12059 payload = dma.virt; 12060 ocs_memcpy(wwpn, payload + SLI4_READ_SPARM64_WWPN_OFFSET, sizeof(*wwpn)); 12061 ocs_memcpy(wwnn, payload + SLI4_READ_SPARM64_WWNN_OFFSET, sizeof(*wwnn)); 12062 ocs_dma_free(ocs, &dma); 12063 return 0; 12064 } 12065 12066 /** 12067 * @page fc_hw_api_overview HW APIs 12068 * - @ref devInitShutdown 12069 * - @ref domain 12070 * - @ref port 12071 * - @ref node 12072 * - @ref io 12073 * - @ref interrupt 12074 * 12075 * <div class="overview"> 12076 * The Hardware Abstraction Layer (HW) insulates the higher-level code from the SLI-4 12077 * message details, but the higher level code must still manage domains, ports, 12078 * IT nexuses, and IOs. The HW API is designed to help the higher level manage 12079 * these objects.<br><br> 12080 * 12081 * The HW uses function callbacks to notify the higher-level code of events 12082 * that are received from the chip. There are currently three types of 12083 * functions that may be registered: 12084 * 12085 * <ul><li>domain – This function is called whenever a domain event is generated 12086 * within the HW. Examples include a new FCF is discovered, a connection 12087 * to a domain is disrupted, and allocation callbacks.</li> 12088 * <li>unsolicited – This function is called whenever new data is received in 12089 * the SLI-4 receive queue.</li> 12090 * <li>rnode – This function is called for remote node events, such as attach status 12091 * and allocation callbacks.</li></ul> 12092 * 12093 * Upper layer functions may be registered by using the ocs_hw_callback() function. 12094 * 12095 * <img src="elx_fc_hw.jpg" alt="FC/FCoE HW" title="FC/FCoE HW" align="right"/> 12096 * <h2>FC/FCoE HW API</h2> 12097 * The FC/FCoE HW component builds upon the SLI-4 component to establish a flexible 12098 * interface for creating the necessary common objects and sending I/Os. It may be used 12099 * “as is” in customer implementations or it can serve as an example of typical interactions 12100 * between a driver and the SLI-4 hardware. The broad categories of functionality include: 12101 * 12102 * <ul><li>Setting-up and tearing-down of the HW.</li> 12103 * <li>Allocating and using the common objects (SLI Port, domain, remote node).</li> 12104 * <li>Sending and receiving I/Os.</li></ul> 12105 * 12106 * <h3>HW Setup</h3> 12107 * To set up the HW: 12108 * 12109 * <ol> 12110 * <li>Set up the HW object using ocs_hw_setup().<br> 12111 * This step performs a basic configuration of the SLI-4 component and the HW to 12112 * enable querying the hardware for its capabilities. At this stage, the HW is not 12113 * capable of general operations (such as, receiving events or sending I/Os).</li><br><br> 12114 * <li>Configure the HW according to the driver requirements.<br> 12115 * The HW provides functions to discover hardware capabilities (ocs_hw_get()), as 12116 * well as configures the amount of resources required (ocs_hw_set()). The driver 12117 * must also register callback functions (ocs_hw_callback()) to receive notification of 12118 * various asynchronous events.<br><br> 12119 * @b Note: Once configured, the driver must initialize the HW (ocs_hw_init()). This 12120 * step creates the underlying queues, commits resources to the hardware, and 12121 * prepares the hardware for operation. While the hardware is operational, the 12122 * port is not online, and cannot send or receive data.</li><br><br> 12123 * <br><br> 12124 * <li>Finally, the driver can bring the port online (ocs_hw_port_control()).<br> 12125 * When the link comes up, the HW determines if a domain is present and notifies the 12126 * driver using the domain callback function. This is the starting point of the driver's 12127 * interaction with the common objects.<br><br> 12128 * @b Note: For FCoE, there may be more than one domain available and, therefore, 12129 * more than one callback.</li> 12130 * </ol> 12131 * 12132 * <h3>Allocating and Using Common Objects</h3> 12133 * Common objects provide a mechanism through which the various OneCore Storage 12134 * driver components share and track information. These data structures are primarily 12135 * used to track SLI component information but can be extended by other components, if 12136 * needed. The main objects are: 12137 * 12138 * <ul><li>DMA – the ocs_dma_t object describes a memory region suitable for direct 12139 * memory access (DMA) transactions.</li> 12140 * <li>SCSI domain – the ocs_domain_t object represents the SCSI domain, including 12141 * any infrastructure devices such as FC switches and FC forwarders. The domain 12142 * object contains both an FCFI and a VFI.</li> 12143 * <li>SLI Port (sport) – the ocs_sli_port_t object represents the connection between 12144 * the driver and the SCSI domain. The SLI Port object contains a VPI.</li> 12145 * <li>Remote node – the ocs_remote_node_t represents a connection between the SLI 12146 * Port and another device in the SCSI domain. The node object contains an RPI.</li></ul> 12147 * 12148 * Before the driver can send I/Os, it must allocate the SCSI domain, SLI Port, and remote 12149 * node common objects and establish the connections between them. The goal is to 12150 * connect the driver to the SCSI domain to exchange I/Os with other devices. These 12151 * common object connections are shown in the following figure, FC Driver Common Objects: 12152 * <img src="elx_fc_common_objects.jpg" 12153 * alt="FC Driver Common Objects" title="FC Driver Common Objects" align="center"/> 12154 * 12155 * The first step is to create a connection to the domain by allocating an SLI Port object. 12156 * The SLI Port object represents a particular FC ID and must be initialized with one. With 12157 * the SLI Port object, the driver can discover the available SCSI domain(s). On identifying 12158 * a domain, the driver allocates a domain object and attaches to it using the previous SLI 12159 * port object.<br><br> 12160 * 12161 * @b Note: In some cases, the driver may need to negotiate service parameters (that is, 12162 * FLOGI) with the domain before attaching.<br><br> 12163 * 12164 * Once attached to the domain, the driver can discover and attach to other devices 12165 * (remote nodes). The exact discovery method depends on the driver, but it typically 12166 * includes using a position map, querying the fabric name server, or an out-of-band 12167 * method. In most cases, it is necessary to log in with devices before performing I/Os. 12168 * Prior to sending login-related ELS commands (ocs_hw_srrs_send()), the driver must 12169 * allocate a remote node object (ocs_hw_node_alloc()). If the login negotiation is 12170 * successful, the driver must attach the nodes (ocs_hw_node_attach()) to the SLI Port 12171 * before exchanging FCP I/O.<br><br> 12172 * 12173 * @b Note: The HW manages both the well known fabric address and the name server as 12174 * nodes in the domain. Therefore, the driver must allocate node objects prior to 12175 * communicating with either of these entities. 12176 * 12177 * <h3>Sending and Receiving I/Os</h3> 12178 * The HW provides separate interfaces for sending BLS/ ELS/ FC-CT and FCP, but the 12179 * commands are conceptually similar. Since the commands complete asynchronously, 12180 * the caller must provide a HW I/O object that maintains the I/O state, as well as 12181 * provide a callback function. The driver may use the same callback function for all I/O 12182 * operations, but each operation must use a unique HW I/O object. In the SLI-4 12183 * architecture, there is a direct association between the HW I/O object and the SGL used 12184 * to describe the data. Therefore, a driver typically performs the following operations: 12185 * 12186 * <ul><li>Allocates a HW I/O object (ocs_hw_io_alloc()).</li> 12187 * <li>Formats the SGL, specifying both the HW I/O object and the SGL. 12188 * (ocs_hw_io_init_sges() and ocs_hw_io_add_sge()).</li> 12189 * <li>Sends the HW I/O (ocs_hw_io_send()).</li></ul> 12190 * 12191 * <h3>HW Tear Down</h3> 12192 * To tear-down the HW: 12193 * 12194 * <ol><li>Take the port offline (ocs_hw_port_control()) to prevent receiving further 12195 * data andevents.</li> 12196 * <li>Destroy the HW object (ocs_hw_teardown()).</li> 12197 * <li>Free any memory used by the HW, such as buffers for unsolicited data.</li></ol> 12198 * <br> 12199 * </div><!-- overview --> 12200 * 12201 */ 12202 12203 /** 12204 * This contains all hw runtime workaround code. Based on the asic type, 12205 * asic revision, and range of fw revisions, a particular workaround may be enabled. 12206 * 12207 * A workaround may consist of overriding a particular HW/SLI4 value that was initialized 12208 * during ocs_hw_setup() (for example the MAX_QUEUE overrides for mis-reported queue 12209 * sizes). Or if required, elements of the ocs_hw_workaround_t structure may be set to 12210 * control specific runtime behavior. 12211 * 12212 * It is intended that the controls in ocs_hw_workaround_t be defined functionally. So we 12213 * would have the driver look like: "if (hw->workaround.enable_xxx) then ...", rather than 12214 * what we might previously see as "if this is a BE3, then do xxx" 12215 * 12216 */ 12217 12218 #define HW_FWREV_ZERO (0ull) 12219 #define HW_FWREV_MAX (~0ull) 12220 12221 #define SLI4_ASIC_TYPE_ANY 0 12222 #define SLI4_ASIC_REV_ANY 0 12223 12224 /** 12225 * @brief Internal definition of workarounds 12226 */ 12227 12228 typedef enum { 12229 HW_WORKAROUND_TEST = 1, 12230 HW_WORKAROUND_MAX_QUEUE, /**< Limits all queues */ 12231 HW_WORKAROUND_MAX_RQ, /**< Limits only the RQ */ 12232 HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH, 12233 HW_WORKAROUND_WQE_COUNT_METHOD, 12234 HW_WORKAROUND_RQE_COUNT_METHOD, 12235 HW_WORKAROUND_USE_UNREGISTERD_RPI, 12236 HW_WORKAROUND_DISABLE_AR_TGT_DIF, /**< Disable of auto-response target DIF */ 12237 HW_WORKAROUND_DISABLE_SET_DUMP_LOC, 12238 HW_WORKAROUND_USE_DIF_QUARANTINE, 12239 HW_WORKAROUND_USE_DIF_SEC_XRI, /**< Use secondary xri for multiple data phases */ 12240 HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB, /**< FCFI reported in SRB not correct, use "first" registered domain */ 12241 HW_WORKAROUND_FW_VERSION_TOO_LOW, /**< The FW version is not the min version supported by this driver */ 12242 HW_WORKAROUND_SGLC_MISREPORTED, /**< Chip supports SGL Chaining but SGLC is not set in SLI4_PARAMS */ 12243 HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE, /**< Don't use SEND_FRAME capable if FW version is too old */ 12244 } hw_workaround_e; 12245 12246 /** 12247 * @brief Internal workaround structure instance 12248 */ 12249 12250 typedef struct { 12251 sli4_asic_type_e asic_type; 12252 sli4_asic_rev_e asic_rev; 12253 uint64_t fwrev_low; 12254 uint64_t fwrev_high; 12255 12256 hw_workaround_e workaround; 12257 uint32_t value; 12258 } hw_workaround_t; 12259 12260 static hw_workaround_t hw_workarounds[] = { 12261 {SLI4_ASIC_TYPE_ANY, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12262 HW_WORKAROUND_TEST, 999}, 12263 12264 /* Bug: 127585: if_type == 2 returns 0 for total length placed on 12265 * FCP_TSEND64_WQE completions. Note, original driver code enables this 12266 * workaround for all asic types 12267 */ 12268 {SLI4_ASIC_TYPE_ANY, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12269 HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH, 0}, 12270 12271 /* Bug: unknown, Lancer A0 has mis-reported max queue depth */ 12272 {SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_A0, HW_FWREV_ZERO, HW_FWREV_MAX, 12273 HW_WORKAROUND_MAX_QUEUE, 2048}, 12274 12275 /* Bug: 143399, BE3 has mis-reported max RQ queue depth */ 12276 {SLI4_ASIC_TYPE_BE3, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,6,293,0), 12277 HW_WORKAROUND_MAX_RQ, 2048}, 12278 12279 /* Bug: 143399, skyhawk has mis-reported max RQ queue depth */ 12280 {SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(10,0,594,0), 12281 HW_WORKAROUND_MAX_RQ, 2048}, 12282 12283 /* Bug: 103487, BE3 before f/w 4.2.314.0 has mis-reported WQE count method */ 12284 {SLI4_ASIC_TYPE_BE3, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,2,314,0), 12285 HW_WORKAROUND_WQE_COUNT_METHOD, 1}, 12286 12287 /* Bug: 103487, BE3 before f/w 4.2.314.0 has mis-reported RQE count method */ 12288 {SLI4_ASIC_TYPE_BE3, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,2,314,0), 12289 HW_WORKAROUND_RQE_COUNT_METHOD, 1}, 12290 12291 /* Bug: 142968, BE3 UE with RPI == 0xffff */ 12292 {SLI4_ASIC_TYPE_BE3, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12293 HW_WORKAROUND_USE_UNREGISTERD_RPI, 0}, 12294 12295 /* Bug: unknown, Skyhawk won't support auto-response on target T10-PI */ 12296 {SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12297 HW_WORKAROUND_DISABLE_AR_TGT_DIF, 0}, 12298 12299 {SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(1,1,65,0), 12300 HW_WORKAROUND_DISABLE_SET_DUMP_LOC, 0}, 12301 12302 /* Bug: 160124, Skyhawk quarantine DIF XRIs */ 12303 {SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12304 HW_WORKAROUND_USE_DIF_QUARANTINE, 0}, 12305 12306 /* Bug: 161832, Skyhawk use secondary XRI for multiple data phase TRECV */ 12307 {SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12308 HW_WORKAROUND_USE_DIF_SEC_XRI, 0}, 12309 12310 /* Bug: xxxxxx, FCFI reported in SRB not corrrect */ 12311 {SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12312 HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB, 0}, 12313 #if 0 12314 /* Bug: 165642, FW version check for driver */ 12315 {SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_1(OCS_MIN_FW_VER_LANCER), 12316 HW_WORKAROUND_FW_VERSION_TOO_LOW, 0}, 12317 #endif 12318 {SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_1(OCS_MIN_FW_VER_SKYHAWK), 12319 HW_WORKAROUND_FW_VERSION_TOO_LOW, 0}, 12320 12321 /* Bug 177061, Lancer FW does not set the SGLC bit */ 12322 {SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12323 HW_WORKAROUND_SGLC_MISREPORTED, 0}, 12324 12325 /* BZ 181208/183914, enable this workaround for ALL revisions */ 12326 {SLI4_ASIC_TYPE_ANY, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX, 12327 HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE, 0}, 12328 }; 12329 12330 /** 12331 * @brief Function prototypes 12332 */ 12333 12334 static int32_t ocs_hw_workaround_match(ocs_hw_t *hw, hw_workaround_t *w); 12335 12336 /** 12337 * @brief Parse the firmware version (name) 12338 * 12339 * Parse a string of the form a.b.c.d, returning a uint64_t packed as defined 12340 * by the HW_FWREV() macro 12341 * 12342 * @param fwrev_string pointer to the firmware string 12343 * 12344 * @return packed firmware revision value 12345 */ 12346 12347 static uint64_t 12348 parse_fw_version(const char *fwrev_string) 12349 { 12350 int v[4] = {0}; 12351 const char *p; 12352 int i; 12353 12354 for (p = fwrev_string, i = 0; *p && (i < 4); i ++) { 12355 v[i] = ocs_strtoul(p, 0, 0); 12356 while(*p && *p != '.') { 12357 p ++; 12358 } 12359 if (*p) { 12360 p ++; 12361 } 12362 } 12363 12364 /* Special case for bootleg releases with f/w rev 0.0.9999.0, set to max value */ 12365 if (v[2] == 9999) { 12366 return HW_FWREV_MAX; 12367 } else { 12368 return HW_FWREV(v[0], v[1], v[2], v[3]); 12369 } 12370 } 12371 12372 /** 12373 * @brief Test for a workaround match 12374 * 12375 * Looks at the asic type, asic revision, and fw revision, and returns TRUE if match. 12376 * 12377 * @param hw Pointer to the HW structure 12378 * @param w Pointer to a workaround structure entry 12379 * 12380 * @return Return TRUE for a match 12381 */ 12382 12383 static int32_t 12384 ocs_hw_workaround_match(ocs_hw_t *hw, hw_workaround_t *w) 12385 { 12386 return (((w->asic_type == SLI4_ASIC_TYPE_ANY) || (w->asic_type == hw->sli.asic_type)) && 12387 ((w->asic_rev == SLI4_ASIC_REV_ANY) || (w->asic_rev == hw->sli.asic_rev)) && 12388 (w->fwrev_low <= hw->workaround.fwrev) && 12389 ((w->fwrev_high == HW_FWREV_MAX) || (hw->workaround.fwrev < w->fwrev_high))); 12390 } 12391 12392 /** 12393 * @brief Setup HW runtime workarounds 12394 * 12395 * The function is called at the end of ocs_hw_setup() to setup any runtime workarounds 12396 * based on the HW/SLI setup. 12397 * 12398 * @param hw Pointer to HW structure 12399 * 12400 * @return none 12401 */ 12402 12403 void 12404 ocs_hw_workaround_setup(struct ocs_hw_s *hw) 12405 { 12406 hw_workaround_t *w; 12407 sli4_t *sli4 = &hw->sli; 12408 uint32_t i; 12409 12410 /* Initialize the workaround settings */ 12411 ocs_memset(&hw->workaround, 0, sizeof(hw->workaround)); 12412 12413 /* If hw_war_version is non-null, then its a value that was set by a module parameter 12414 * (sorry for the break in abstraction, but workarounds are ... well, workarounds) 12415 */ 12416 12417 if (hw->hw_war_version) { 12418 hw->workaround.fwrev = parse_fw_version(hw->hw_war_version); 12419 } else { 12420 hw->workaround.fwrev = parse_fw_version((char*) sli4->config.fw_name[0]); 12421 } 12422 12423 /* Walk the workaround list, if a match is found, then handle it */ 12424 for (i = 0, w = hw_workarounds; i < ARRAY_SIZE(hw_workarounds); i++, w++) { 12425 if (ocs_hw_workaround_match(hw, w)) { 12426 switch(w->workaround) { 12427 case HW_WORKAROUND_TEST: { 12428 ocs_log_debug(hw->os, "Override: test: %d\n", w->value); 12429 break; 12430 } 12431 12432 case HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH: { 12433 ocs_log_debug(hw->os, "HW Workaround: retain TSEND IO length\n"); 12434 hw->workaround.retain_tsend_io_length = 1; 12435 break; 12436 } 12437 case HW_WORKAROUND_MAX_QUEUE: { 12438 sli4_qtype_e q; 12439 12440 ocs_log_debug(hw->os, "HW Workaround: override max_qentries: %d\n", w->value); 12441 for (q = SLI_QTYPE_EQ; q < SLI_QTYPE_MAX; q++) { 12442 if (hw->num_qentries[q] > w->value) { 12443 hw->num_qentries[q] = w->value; 12444 } 12445 } 12446 break; 12447 } 12448 case HW_WORKAROUND_MAX_RQ: { 12449 ocs_log_debug(hw->os, "HW Workaround: override RQ max_qentries: %d\n", w->value); 12450 if (hw->num_qentries[SLI_QTYPE_RQ] > w->value) { 12451 hw->num_qentries[SLI_QTYPE_RQ] = w->value; 12452 } 12453 break; 12454 } 12455 case HW_WORKAROUND_WQE_COUNT_METHOD: { 12456 ocs_log_debug(hw->os, "HW Workaround: set WQE count method=%d\n", w->value); 12457 sli4->config.count_method[SLI_QTYPE_WQ] = w->value; 12458 sli_calc_max_qentries(sli4); 12459 break; 12460 } 12461 case HW_WORKAROUND_RQE_COUNT_METHOD: { 12462 ocs_log_debug(hw->os, "HW Workaround: set RQE count method=%d\n", w->value); 12463 sli4->config.count_method[SLI_QTYPE_RQ] = w->value; 12464 sli_calc_max_qentries(sli4); 12465 break; 12466 } 12467 case HW_WORKAROUND_USE_UNREGISTERD_RPI: 12468 ocs_log_debug(hw->os, "HW Workaround: use unreg'd RPI if rnode->indicator == 0xFFFF\n"); 12469 hw->workaround.use_unregistered_rpi = TRUE; 12470 /* 12471 * Allocate an RPI that is never registered, to be used in the case where 12472 * a node has been unregistered, and its indicator (RPI) value is set to 0xFFFF 12473 */ 12474 if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &hw->workaround.unregistered_rid, 12475 &hw->workaround.unregistered_index)) { 12476 ocs_log_err(hw->os, "sli_resource_alloc unregistered RPI failed\n"); 12477 hw->workaround.use_unregistered_rpi = FALSE; 12478 } 12479 break; 12480 case HW_WORKAROUND_DISABLE_AR_TGT_DIF: 12481 ocs_log_debug(hw->os, "HW Workaround: disable AR on T10-PI TSEND\n"); 12482 hw->workaround.disable_ar_tgt_dif = TRUE; 12483 break; 12484 case HW_WORKAROUND_DISABLE_SET_DUMP_LOC: 12485 ocs_log_debug(hw->os, "HW Workaround: disable set_dump_loc\n"); 12486 hw->workaround.disable_dump_loc = TRUE; 12487 break; 12488 case HW_WORKAROUND_USE_DIF_QUARANTINE: 12489 ocs_log_debug(hw->os, "HW Workaround: use DIF quarantine\n"); 12490 hw->workaround.use_dif_quarantine = TRUE; 12491 break; 12492 case HW_WORKAROUND_USE_DIF_SEC_XRI: 12493 ocs_log_debug(hw->os, "HW Workaround: use DIF secondary xri\n"); 12494 hw->workaround.use_dif_sec_xri = TRUE; 12495 break; 12496 case HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB: 12497 ocs_log_debug(hw->os, "HW Workaround: override FCFI in SRB\n"); 12498 hw->workaround.override_fcfi = TRUE; 12499 break; 12500 12501 case HW_WORKAROUND_FW_VERSION_TOO_LOW: 12502 ocs_log_debug(hw->os, "HW Workaround: fw version is below the minimum for this driver\n"); 12503 hw->workaround.fw_version_too_low = TRUE; 12504 break; 12505 case HW_WORKAROUND_SGLC_MISREPORTED: 12506 ocs_log_debug(hw->os, "HW Workaround: SGLC misreported - chaining is enabled\n"); 12507 hw->workaround.sglc_misreported = TRUE; 12508 break; 12509 case HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE: 12510 ocs_log_debug(hw->os, "HW Workaround: not SEND_FRAME capable - disabled\n"); 12511 hw->workaround.ignore_send_frame = TRUE; 12512 break; 12513 } /* switch(w->workaround) */ 12514 } 12515 } 12516 } 12517