/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * hermon_event.c * Hermon Interrupt and Event Processing Routines * * Implements all the routines necessary for allocating, freeing, and * handling all of the various event types that the Hermon hardware can * generate. * These routines include the main Hermon interrupt service routine * (hermon_isr()) as well as all the code necessary to setup and handle * events from each of the many event queues used by the Hermon device. */ #include <sys/types.h> #include <sys/conf.h> #include <sys/ddi.h> #include <sys/sunddi.h> #include <sys/modctl.h> #include <sys/ib/adapters/hermon/hermon.h> static void hermon_eq_poll(hermon_state_t *state, hermon_eqhdl_t eq); static void hermon_eq_catastrophic(hermon_state_t *state); static int hermon_eq_alloc(hermon_state_t *state, uint32_t log_eq_size, uint_t intr, hermon_eqhdl_t *eqhdl); static int hermon_eq_free(hermon_state_t *state, hermon_eqhdl_t *eqhdl); static int hermon_eq_handler_init(hermon_state_t *state, hermon_eqhdl_t eq, uint_t evt_type_mask, int (*eqfunc)(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe)); static int hermon_eq_handler_fini(hermon_state_t *state, hermon_eqhdl_t eq); static int hermon_port_state_change_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_comm_estbl_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_local_wq_cat_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_invreq_local_wq_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_local_acc_vio_wq_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_sendq_drained_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_path_mig_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_path_mig_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_catastrophic_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_srq_last_wqe_reached_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_fexch_error_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_no_eqhandler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); static int hermon_eq_demux(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); /* * hermon_eq_init_all * Context: Only called from attach() path context */ int hermon_eq_init_all(hermon_state_t *state) { uint_t log_eq_size, intr_num; uint_t num_eq, num_eq_init, num_eq_unmap, num_eq_rsvd; uint32_t event_mask; /* used for multiple event types */ int status, i, num_extra; struct hermon_sw_eq_s **eq; ddi_acc_handle_t uarhdl = hermon_get_uarhdl(state); /* initialize the FMA retry loop */ hermon_pio_init(fm_loop_cnt, fm_status, fm_test); /* * For now, all Event Queues default to the same size (pulled from * the current configuration profile) and are all assigned to the * same interrupt or MSI. In the future we may support assigning * EQs to specific interrupts or MSIs XXX */ log_eq_size = state->hs_cfg_profile->cp_log_eq_sz; /* * Total number of supported EQs is fixed. Hermon hardware * supports up to 512 EQs, though in theory they will one day be * alloc'd to virtual HCA's. We are currently using only 47 of them * - that is, in Arbel and Tavor, before HERMON, where * we had set aside the first 32 for use with Completion Queues (CQ) * and reserved a few of the other 32 for each specific class of event * * However, with the coming of vitualization, we'll have only 4 per * potential guest - so, we'll try alloc'ing them differntly * (see below for more details). */ num_eq = HERMON_NUM_EQ_USED; num_eq_rsvd = state->hs_rsvd_eqs; eq = &state->hs_eqhdl[num_eq_rsvd]; /* * If MSI is to be used, then set intr_num to the MSI number. * Otherwise, for fixed (i.e. 'legacy') interrupts, * it is what the card tells us in 'inta_pin'. */ if (state->hs_intr_type_chosen == DDI_INTR_TYPE_FIXED) { intr_num = state->hs_adapter.inta_pin; num_extra = 0; } else { /* If we have more than one MSI-X vector, init them. */ for (i = 0; i + 1 < state->hs_intrmsi_allocd; i++) { status = hermon_eq_alloc(state, log_eq_size, i, &eq[i]); if (status != DDI_SUCCESS) { while (--i >= 0) { (void) hermon_eq_handler_fini(state, eq[i]); (void) hermon_eq_free(state, &eq[i]); } return (DDI_FAILURE); } (void) hermon_eq_handler_init(state, eq[i], HERMON_EVT_NO_MASK, hermon_cq_handler); } intr_num = i; num_extra = i; } /* * Allocate and initialize the rest of the Event Queues to be used. * If any of these EQ allocations fail then jump to the end, cleanup * what had been successfully initialized, and return an error. */ for (i = 0; i < num_eq; i++) { status = hermon_eq_alloc(state, log_eq_size, intr_num, &eq[num_extra + i]); if (status != DDI_SUCCESS) { num_eq_init = i; goto all_eq_init_fail; } } num_eq_init = num_eq; /* * The "num_eq_unmap" variable is used in any possible failure * cleanup (below) to indicate which events queues might require * possible event class unmapping. */ num_eq_unmap = 0; /* * Setup EQ0 (first avail) for use with Completion Queues. Note: We can * cast the return value to void here because, when we use the * HERMON_EVT_NO_MASK flag, it is not possible for * hermon_eq_handler_init() to return an error. */ (void) hermon_eq_handler_init(state, eq[num_eq_unmap + num_extra], HERMON_EVT_NO_MASK, hermon_cq_handler); num_eq_unmap++; /* * Setup EQ1 for handling Completion Queue Error Events. * * These events include things like CQ overflow or CQ access * violation errors. If this setup fails for any reason (which, in * general, it really never should), then jump to the end, cleanup * everything that has been successfully initialized, and return an * error. */ status = hermon_eq_handler_init(state, eq[num_eq_unmap + num_extra], HERMON_EVT_MSK_CQ_ERRORS, hermon_cq_err_handler); if (status != DDI_SUCCESS) { goto all_eq_init_fail; } state->hs_cq_erreqnum = num_eq_unmap + num_extra + num_eq_rsvd; num_eq_unmap++; /* * Setup EQ2 for handling most other things including: * * Port State Change Events * These events include things like Port Up and Port Down events. * * Communication Established Events * These events correspond to the IB affiliated asynchronous events * that are used for connection management * * Path Migration Succeeded Events * These evens corresponid to the IB affiliated asynchronous events * that are used to indicate successful completion of a * Path Migration. * * Command Completion Events * These events correspond to the Arbel generated events that are used * to indicate Arbel firmware command completion. * * Local WQ Catastrophic Error Events * Invalid Req Local WQ Error Events * Local Access Violation WQ Error Events * SRQ Catastrophic Error Events * SRQ Last WQE Reached Events * ECC error detection events * These events also correspond to the similarly-named IB affiliated * asynchronous error type. * * Send Queue Drained Events * These events correspond to the IB affiliated asynchronous events * that are used to indicate completion of a Send Queue Drained QP * state transition. * * Path Migration Failed Events * These events correspond to the IB affiliated asynchronous events * that are used to indicate that path migration was not successful. * * Fibre Channel Error Event * This event is affiliated with an Fexch QP. * * NOTE: When an event fires on this EQ, it will demux the type and * send it to the right specific handler routine * */ event_mask = HERMON_EVT_MSK_PORT_STATE_CHANGE | HERMON_EVT_MSK_COMM_ESTABLISHED | HERMON_EVT_MSK_COMMAND_INTF_COMP | HERMON_EVT_MSK_LOCAL_WQ_CAT_ERROR | HERMON_EVT_MSK_INV_REQ_LOCAL_WQ_ERROR | HERMON_EVT_MSK_LOCAL_ACC_VIO_WQ_ERROR | HERMON_EVT_MSK_SEND_QUEUE_DRAINED | HERMON_EVT_MSK_PATH_MIGRATED | HERMON_EVT_MSK_PATH_MIGRATE_FAILED | HERMON_EVT_MSK_SRQ_CATASTROPHIC_ERROR | HERMON_EVT_MSK_SRQ_LAST_WQE_REACHED | HERMON_EVT_MSK_FEXCH_ERROR; status = hermon_eq_handler_init(state, eq[num_eq_unmap + num_extra], event_mask, hermon_eq_demux); if (status != DDI_SUCCESS) { goto all_eq_init_fail; } num_eq_unmap++; /* * Setup EQ3 to catch all other types of events. Specifically, we * do not catch the "Local EEC Catastrophic Error Event" because we * should have no EEC (the Arbel driver does not support RD). We also * choose not to handle any of the address translation page fault * event types. Since we are not doing any page fault handling (and * since the Arbel firmware does not currently support any such * handling), we allow these events to go to the catch-all handler. */ status = hermon_eq_handler_init(state, eq[num_eq_unmap + num_extra], HERMON_EVT_CATCHALL_MASK, hermon_no_eqhandler); if (status != DDI_SUCCESS) { goto all_eq_init_fail; } num_eq_unmap++; /* the FMA retry loop starts. */ hermon_pio_start(state, uarhdl, all_eq_init_fail, fm_loop_cnt, fm_status, fm_test); /* * Run through and initialize the Consumer Index for each EQC. */ for (i = 0; i < num_eq + num_extra; i++) { ddi_put32(uarhdl, eq[i]->eq_doorbell, 0x0); } /* the FMA retry loop ends. */ hermon_pio_end(state, uarhdl, all_eq_init_fail, fm_loop_cnt, fm_status, fm_test); return (DDI_SUCCESS); all_eq_init_fail: /* Unmap any of the partially mapped EQs from above */ for (i = 0; i < num_eq_unmap + num_extra; i++) { (void) hermon_eq_handler_fini(state, eq[i]); } /* Free up any of the partially allocated EQs from above */ for (i = 0; i < num_eq_init + num_extra; i++) { (void) hermon_eq_free(state, &eq[i]); } /* If a HW error happen during ddi_pio, return DDI_FAILURE */ if (fm_status == HCA_PIO_PERSISTENT) { hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_NON_FATAL); status = DDI_FAILURE; } return (status); } /* * hermon_eq_fini_all * Context: Only called from attach() and/or detach() path contexts */ int hermon_eq_fini_all(hermon_state_t *state) { uint_t num_eq, num_eq_rsvd; int status, i; struct hermon_sw_eq_s **eq; /* * Grab the total number of supported EQs again. This is the same * hardcoded value that was used above (during the event queue * initialization.) */ num_eq = HERMON_NUM_EQ_USED + state->hs_intrmsi_allocd - 1; num_eq_rsvd = state->hs_rsvd_eqs; eq = &state->hs_eqhdl[num_eq_rsvd]; /* * For each of the event queues that we initialized and mapped * earlier, attempt to unmap the events from the EQ. */ for (i = 0; i < num_eq; i++) { status = hermon_eq_handler_fini(state, eq[i]); if (status != DDI_SUCCESS) { return (DDI_FAILURE); } } /* * Teardown and free up all the Event Queues that were allocated * earlier. */ for (i = 0; i < num_eq; i++) { status = hermon_eq_free(state, &eq[i]); if (status != DDI_SUCCESS) { return (DDI_FAILURE); } } return (DDI_SUCCESS); } /* * hermon_eq_reset_uar_baseaddr * Context: Only called from attach() */ void hermon_eq_reset_uar_baseaddr(hermon_state_t *state) { int i, num_eq; hermon_eqhdl_t eq, *eqh; num_eq = HERMON_NUM_EQ_USED + state->hs_intrmsi_allocd - 1; eqh = &state->hs_eqhdl[state->hs_rsvd_eqs]; for (i = 0; i < num_eq; i++) { eq = eqh[i]; eq->eq_doorbell = (uint32_t *) ((uintptr_t)state->hs_reg_uar_baseaddr + (uint32_t)ARM_EQ_INDEX(eq->eq_eqnum)); } } /* * hermon_eq_arm_all * Context: Only called from attach() and/or detach() path contexts */ int hermon_eq_arm_all(hermon_state_t *state) { uint_t num_eq, num_eq_rsvd; uint64_t offset; hermon_eqhdl_t eq; uint32_t eq_ci; int i; ddi_acc_handle_t uarhdl = hermon_get_uarhdl(state); /* initialize the FMA retry loop */ hermon_pio_init(fm_loop_cnt, fm_status, fm_test); num_eq = HERMON_NUM_EQ_USED + state->hs_intrmsi_allocd - 1; num_eq_rsvd = state->hs_rsvd_eqs; /* the FMA retry loop starts. */ hermon_pio_start(state, uarhdl, pio_error, fm_loop_cnt, fm_status, fm_test); for (i = 0; i < num_eq; i++) { offset = ARM_EQ_INDEX(i + num_eq_rsvd); eq = state->hs_eqhdl[i + num_eq_rsvd]; eq_ci = (eq->eq_consindx & HERMON_EQ_CI_MASK) | EQ_ARM_BIT; ddi_put32(uarhdl, (uint32_t *)((uintptr_t)state->hs_reg_uar_baseaddr + (uint32_t)offset), eq_ci); } /* the FMA retry loop ends. */ hermon_pio_end(state, uarhdl, pio_error, fm_loop_cnt, fm_status, fm_test); return (DDI_SUCCESS); pio_error: hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_NON_FATAL); return (DDI_FAILURE); } /* * hermon_isr() * Context: Only called from interrupt context (and during panic) */ uint_t hermon_isr(caddr_t arg1, caddr_t arg2) { hermon_state_t *state; int i, r; int intr; /* * Grab the Hermon softstate pointer from the input parameter */ state = (hermon_state_t *)(void *)arg1; /* Get the interrupt number */ intr = (int)(uintptr_t)arg2; /* * Clear the interrupt. Note: This is only needed for * fixed interrupts as the framework does what is needed for * MSI-X interrupts. */ if (state->hs_intr_type_chosen == DDI_INTR_TYPE_FIXED) { ddi_acc_handle_t cmdhdl = hermon_get_cmdhdl(state); /* initialize the FMA retry loop */ hermon_pio_init(fm_loop_cnt, fm_status, fm_test); /* the FMA retry loop starts. */ hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); ddi_put64(cmdhdl, state->hs_cmd_regs.clr_intr, (uint64_t)1 << state->hs_adapter.inta_pin); /* the FMA retry loop ends. */ hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); } /* * Loop through all the EQs looking for ones that have "fired". * To determine if an EQ is fired, the ownership will be the SW * (the HW will set the owner appropriately). Update the Consumer Index * of the Event Queue Entry (EQE) and pass it to HW by writing it * to the respective Set CI DB Register. * * The "else" case handles the extra EQs used only for completion * events, whereas the "if" case deals with the required interrupt * vector that is used for all classes of events. */ r = state->hs_rsvd_eqs; if (intr + 1 == state->hs_intrmsi_allocd) { /* last intr */ r += state->hs_intrmsi_allocd - 1; for (i = 0; i < HERMON_NUM_EQ_USED; i++) { hermon_eq_poll(state, state->hs_eqhdl[i + r]); } } else { /* only poll the one EQ */ hermon_eq_poll(state, state->hs_eqhdl[intr + r]); } return (DDI_INTR_CLAIMED); pio_error: hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_FATAL); return (DDI_INTR_UNCLAIMED); } /* * hermon_eq_poll * Context: Only called from interrupt context (and during panic) */ static void hermon_eq_poll(hermon_state_t *state, hermon_eqhdl_t eq) { hermon_hw_eqe_t *eqe; int polled_some; uint32_t cons_indx, wrap_around_mask, shift; int (*eqfunction)(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe); ddi_acc_handle_t uarhdl = hermon_get_uarhdl(state); /* initialize the FMA retry loop */ hermon_pio_init(fm_loop_cnt, fm_status, fm_test); _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*eq)) /* Get the consumer pointer index */ cons_indx = eq->eq_consindx; shift = eq->eq_log_eqsz - HERMON_EQE_OWNER_SHIFT; /* * Calculate the wrap around mask. Note: This operation only works * because all Hermon event queues have power-of-2 sizes */ wrap_around_mask = (eq->eq_bufsz - 1); /* Calculate the pointer to the first EQ entry */ eqe = &eq->eq_buf[(cons_indx & wrap_around_mask)]; _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*eqe)) /* * Pull the handler function for this EQ from the Hermon Event Queue * handle */ eqfunction = eq->eq_func; for (;;) { polled_some = 0; while (HERMON_EQE_OWNER_IS_SW(eq, eqe, cons_indx, shift)) { /* * Call the EQ handler function. But only call if we * are not in polled I/O mode (i.e. not processing * because of a system panic). Note: We don't call * the EQ handling functions from a system panic * because we are primarily concerned only with * ensuring that the event queues do not overflow (or, * more specifically, the event queue associated with * the CQ that is being used in the sync/dump process). * Also, we don't want to make any upcalls (to the * IBTF) because we can't guarantee when/if those * calls would ever return. And, if we're in panic, * then we reached here through a PollCQ() call (from * hermon_cq_poll()), and we need to ensure that we * successfully return any work completions to the * caller. */ if (ddi_in_panic() == 0) { eqfunction(state, eq, eqe); } /* Reset to hardware ownership is implicit */ /* Increment the consumer index */ cons_indx++; /* Update the pointer to the next EQ entry */ eqe = &eq->eq_buf[(cons_indx & wrap_around_mask)]; polled_some = 1; } /* * write consumer index via EQ set CI Doorbell, to keep overflow * from occuring during poll */ eq->eq_consindx = cons_indx; /* the FMA retry loop starts. */ hermon_pio_start(state, uarhdl, pio_error, fm_loop_cnt, fm_status, fm_test); ddi_put32(uarhdl, eq->eq_doorbell, (cons_indx & HERMON_EQ_CI_MASK) | EQ_ARM_BIT); /* the FMA retry loop starts. */ hermon_pio_end(state, uarhdl, pio_error, fm_loop_cnt, fm_status, fm_test); if (polled_some == 0) break; }; return; pio_error: hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_FATAL); } /* * hermon_eq_catastrophic * Context: Only called from interrupt context (and during panic) */ static void hermon_eq_catastrophic(hermon_state_t *state) { ddi_acc_handle_t cmdhdl = hermon_get_cmdhdl(state); ibt_async_code_t type; ibc_async_event_t event; uint32_t *base_addr; uint32_t buf_size; uint32_t word; uint8_t err_type; uint32_t err_buf; int i; /* initialize the FMA retry loop */ hermon_pio_init(fm_loop_cnt, fm_status, fm_test); bzero(&event, sizeof (ibc_async_event_t)); base_addr = state->hs_cmd_regs.fw_err_buf; buf_size = state->hs_fw.error_buf_sz; /* in #dwords */ /* the FMA retry loop starts. */ hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); word = ddi_get32(cmdhdl, base_addr); /* the FMA retry loop ends. */ hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); err_type = (word & 0xFF000000) >> 24; type = IBT_ERROR_LOCAL_CATASTROPHIC; switch (err_type) { case HERMON_CATASTROPHIC_INTERNAL_ERROR: cmn_err(CE_WARN, "Catastrophic Internal Error: 0x%02x", err_type); break; case HERMON_CATASTROPHIC_UPLINK_BUS_ERROR: cmn_err(CE_WARN, "Catastrophic Uplink Bus Error: 0x%02x", err_type); break; case HERMON_CATASTROPHIC_DDR_DATA_ERROR: cmn_err(CE_WARN, "Catastrophic DDR Data Error: 0x%02x", err_type); break; case HERMON_CATASTROPHIC_INTERNAL_PARITY_ERROR: cmn_err(CE_WARN, "Catastrophic Internal Parity Error: 0x%02x", err_type); break; default: /* Unknown type of Catastrophic error */ cmn_err(CE_WARN, "Catastrophic Unknown Error: 0x%02x", err_type); break; } /* the FMA retry loop starts. */ hermon_pio_start(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); /* * Read in the catastrophic error buffer from the hardware. */ for (i = 0; i < buf_size; i++) { base_addr = (state->hs_cmd_regs.fw_err_buf + i); err_buf = ddi_get32(cmdhdl, base_addr); cmn_err(CE_NOTE, "hermon%d: catastrophic_error[%02x]: %08X", state->hs_instance, i, err_buf); } /* the FMA retry loop ends. */ hermon_pio_end(state, cmdhdl, pio_error, fm_loop_cnt, fm_status, fm_test); /* * We also call the IBTF here to inform it of the catastrophic error. * Note: Since no event information (i.e. QP handles, CQ handles, * etc.) is necessary, we pass a NULL pointer instead of a pointer to * an empty ibc_async_event_t struct. * * But we also check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if (state->hs_ibtfpriv != NULL) { HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } pio_error: /* ignore these errors but log them because they're harmless. */ hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_NON_FATAL); } /* * hermon_eq_alloc() * Context: Only called from attach() path context */ static int hermon_eq_alloc(hermon_state_t *state, uint32_t log_eq_size, uint_t intr, hermon_eqhdl_t *eqhdl) { hermon_rsrc_t *eqc, *rsrc; hermon_hw_eqc_t eqc_entry; hermon_eqhdl_t eq; ibt_mr_attr_t mr_attr; hermon_mr_options_t op; hermon_pdhdl_t pd; hermon_mrhdl_t mr; hermon_hw_eqe_t *buf; int status; /* Use the internal protection domain (PD) for setting up EQs */ pd = state->hs_pdhdl_internal; /* Increment the reference count on the protection domain (PD) */ hermon_pd_refcnt_inc(pd); /* * Allocate an EQ context entry. This will be filled in with all * the necessary parameters to define the Event Queue. And then * ownership will be passed to the hardware in the final step * below. If we fail here, we must undo the protection domain * reference count. */ status = hermon_rsrc_alloc(state, HERMON_EQC, 1, HERMON_SLEEP, &eqc); if (status != DDI_SUCCESS) { status = DDI_FAILURE; goto eqalloc_fail1; } /* * Allocate the software structure for tracking the event queue (i.e. * the Hermon Event Queue handle). If we fail here, we must undo the * protection domain reference count and the previous resource * allocation. */ status = hermon_rsrc_alloc(state, HERMON_EQHDL, 1, HERMON_SLEEP, &rsrc); if (status != DDI_SUCCESS) { status = DDI_FAILURE; goto eqalloc_fail2; } eq = (hermon_eqhdl_t)rsrc->hr_addr; /* * Allocate the memory for Event Queue. */ eq->eq_eqinfo.qa_size = (1 << log_eq_size) * sizeof (hermon_hw_eqe_t); eq->eq_eqinfo.qa_alloc_align = eq->eq_eqinfo.qa_bind_align = PAGESIZE; eq->eq_eqinfo.qa_location = HERMON_QUEUE_LOCATION_NORMAL; status = hermon_queue_alloc(state, &eq->eq_eqinfo, HERMON_SLEEP); if (status != DDI_SUCCESS) { status = DDI_FAILURE; goto eqalloc_fail3; } buf = (hermon_hw_eqe_t *)eq->eq_eqinfo.qa_buf_aligned; /* * Initializing each of the Event Queue Entries (EQE) by setting their * ownership to hardware ("owner" bit set to HW) is now done by HW * when the transfer of ownership (below) of the * EQ context itself is done. */ /* * Register the memory for the EQ. * * Because we are in the attach path we use NOSLEEP here so that we * SPIN in the HCR since the event queues are not setup yet, and we * cannot NOSPIN at this point in time. */ mr_attr.mr_vaddr = (uint64_t)(uintptr_t)buf; mr_attr.mr_len = eq->eq_eqinfo.qa_size; mr_attr.mr_as = NULL; mr_attr.mr_flags = IBT_MR_NOSLEEP | IBT_MR_ENABLE_LOCAL_WRITE; op.mro_bind_type = state->hs_cfg_profile->cp_iommu_bypass; op.mro_bind_dmahdl = eq->eq_eqinfo.qa_dmahdl; op.mro_bind_override_addr = 0; status = hermon_mr_register(state, pd, &mr_attr, &mr, &op, HERMON_EQ_CMPT); if (status != DDI_SUCCESS) { status = DDI_FAILURE; goto eqalloc_fail4; } _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr)) /* * Fill in the EQC entry. This is the final step before passing * ownership of the EQC entry to the Hermon hardware. We use all of * the information collected/calculated above to fill in the * requisite portions of the EQC. Note: We create all EQs in the * "fired" state. We will arm them later (after our interrupt * routine had been registered.) */ bzero(&eqc_entry, sizeof (hermon_hw_eqc_t)); eqc_entry.state = HERMON_EQ_ARMED; eqc_entry.log_eq_sz = log_eq_size; eqc_entry.intr = intr; eqc_entry.log2_pgsz = mr->mr_log2_pgsz; eqc_entry.pg_offs = eq->eq_eqinfo.qa_pgoffs >> 5; eqc_entry.mtt_base_addrh = (uint32_t)((mr->mr_mttaddr >> 32) & 0xFF); eqc_entry.mtt_base_addrl = mr->mr_mttaddr >> 3; eqc_entry.cons_indx = 0x0; eqc_entry.prod_indx = 0x0; /* * Write the EQC entry to hardware. Lastly, we pass ownership of * the entry to the hardware (using the Hermon SW2HW_EQ firmware * command). Note: in general, this operation shouldn't fail. But * if it does, we have to undo everything we've done above before * returning error. */ status = hermon_cmn_ownership_cmd_post(state, SW2HW_EQ, &eqc_entry, sizeof (hermon_hw_eqc_t), eqc->hr_indx, HERMON_CMD_NOSLEEP_SPIN); if (status != HERMON_CMD_SUCCESS) { cmn_err(CE_NOTE, "hermon%d: SW2HW_EQ command failed: %08x\n", state->hs_instance, status); if (status == HERMON_CMD_INVALID_STATUS) { hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST); } status = ibc_get_ci_failure(0); goto eqalloc_fail5; } /* * Fill in the rest of the Hermon Event Queue handle. Having * successfully transferred ownership of the EQC, we can update the * following fields for use in further operations on the EQ. */ eq->eq_eqcrsrcp = eqc; eq->eq_rsrcp = rsrc; eq->eq_consindx = 0; eq->eq_eqnum = eqc->hr_indx; eq->eq_buf = buf; eq->eq_bufsz = (1 << log_eq_size); eq->eq_log_eqsz = log_eq_size; eq->eq_mrhdl = mr; eq->eq_doorbell = (uint32_t *)((uintptr_t)state->hs_reg_uar_baseaddr + (uint32_t)ARM_EQ_INDEX(eq->eq_eqnum)); *eqhdl = eq; return (DDI_SUCCESS); /* * The following is cleanup for all possible failure cases in this routine */ eqalloc_fail5: if (hermon_mr_deregister(state, &mr, HERMON_MR_DEREG_ALL, HERMON_NOSLEEP) != DDI_SUCCESS) { HERMON_WARNING(state, "failed to deregister EQ memory"); } eqalloc_fail4: hermon_queue_free(&eq->eq_eqinfo); eqalloc_fail3: hermon_rsrc_free(state, &rsrc); eqalloc_fail2: hermon_rsrc_free(state, &eqc); eqalloc_fail1: hermon_pd_refcnt_dec(pd); return (status); } /* * hermon_eq_free() * Context: Only called from attach() and/or detach() path contexts */ static int hermon_eq_free(hermon_state_t *state, hermon_eqhdl_t *eqhdl) { hermon_rsrc_t *eqc, *rsrc; hermon_hw_eqc_t eqc_entry; hermon_pdhdl_t pd; hermon_mrhdl_t mr; hermon_eqhdl_t eq; uint32_t eqnum; int status; /* * Pull all the necessary information from the Hermon Event Queue * handle. This is necessary here because the resource for the * EQ handle is going to be freed up as part of this operation. */ eq = *eqhdl; eqc = eq->eq_eqcrsrcp; rsrc = eq->eq_rsrcp; pd = state->hs_pdhdl_internal; mr = eq->eq_mrhdl; eqnum = eq->eq_eqnum; /* * Reclaim EQC entry from hardware (using the Hermon HW2SW_EQ * firmware command). If the ownership transfer fails for any reason, * then it is an indication that something (either in HW or SW) has * gone seriously wrong. */ status = hermon_cmn_ownership_cmd_post(state, HW2SW_EQ, &eqc_entry, sizeof (hermon_hw_eqc_t), eqnum, HERMON_CMD_NOSLEEP_SPIN); if (status != HERMON_CMD_SUCCESS) { HERMON_WARNING(state, "failed to reclaim EQC ownership"); cmn_err(CE_CONT, "Hermon: HW2SW_EQ command failed: %08x\n", status); return (DDI_FAILURE); } /* * Deregister the memory for the Event Queue. If this fails * for any reason, then it is an indication that something (either * in HW or SW) has gone seriously wrong. So we print a warning * message and continue. */ status = hermon_mr_deregister(state, &mr, HERMON_MR_DEREG_ALL, HERMON_NOSLEEP); if (status != DDI_SUCCESS) { HERMON_WARNING(state, "failed to deregister EQ memory"); } /* Free the memory for the EQ */ hermon_queue_free(&eq->eq_eqinfo); /* Free the Hermon Event Queue handle */ hermon_rsrc_free(state, &rsrc); /* Free up the EQC entry resource */ hermon_rsrc_free(state, &eqc); /* Decrement the reference count on the protection domain (PD) */ hermon_pd_refcnt_dec(pd); /* Set the eqhdl pointer to NULL and return success */ *eqhdl = NULL; return (DDI_SUCCESS); } /* * hermon_eq_handler_init * Context: Only called from attach() path context */ static int hermon_eq_handler_init(hermon_state_t *state, hermon_eqhdl_t eq, uint_t evt_type_mask, int (*eq_func)(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe)) { int status; /* * Save away the EQ handler function and the event type mask. These * will be used later during interrupt and event queue processing. */ eq->eq_func = eq_func; eq->eq_evttypemask = evt_type_mask; /* * Map the EQ to a specific class of event (or events) depending * on the mask value passed in. The HERMON_EVT_NO_MASK means not * to attempt associating the EQ with any specific class of event. * This is particularly useful when initializing the events queues * used for CQ events. The mapping is done using the Hermon MAP_EQ * firmware command. Note: This command should not, in general, fail. * If it does, then something (probably HW related) has gone seriously * wrong. */ if (evt_type_mask != HERMON_EVT_NO_MASK) { status = hermon_map_eq_cmd_post(state, HERMON_CMD_MAP_EQ_EVT_MAP, eq->eq_eqnum, evt_type_mask, HERMON_CMD_NOSLEEP_SPIN); if (status != HERMON_CMD_SUCCESS) { cmn_err(CE_NOTE, "hermon%d: MAP_EQ command failed: " "%08x\n", state->hs_instance, status); return (DDI_FAILURE); } } return (DDI_SUCCESS); } /* * hermon_eq_handler_fini * Context: Only called from attach() and/or detach() path contexts */ static int hermon_eq_handler_fini(hermon_state_t *state, hermon_eqhdl_t eq) { int status; /* * Unmap the EQ from the event class to which it had been previously * mapped. The unmapping is done using the Hermon MAP_EQ (in much * the same way that the initial mapping was done). The difference, * however, is in the HERMON_EQ_EVT_UNMAP flag that is passed to the * MAP_EQ firmware command. The HERMON_EVT_NO_MASK (which may have * been passed in at init time) still means that no association has * been made between the EQ and any specific class of event (and, * hence, no unmapping is necessary). Note: This command should not, * in general, fail. If it does, then something (probably HW related) * has gone seriously wrong. */ if (eq->eq_evttypemask != HERMON_EVT_NO_MASK) { status = hermon_map_eq_cmd_post(state, HERMON_CMD_MAP_EQ_EVT_UNMAP, eq->eq_eqnum, eq->eq_evttypemask, HERMON_CMD_NOSLEEP_SPIN); if (status != HERMON_CMD_SUCCESS) { cmn_err(CE_NOTE, "hermon%d: MAP_EQ command failed: " "%08x\n", state->hs_instance, status); return (DDI_FAILURE); } } return (DDI_SUCCESS); } /* * hermon_eq_demux() * Context: Called only from interrupt context * Usage: to demux the various type reported on one EQ */ static int hermon_eq_demux(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { uint_t eqe_evttype; int status = DDI_FAILURE; eqe_evttype = HERMON_EQE_EVTTYPE_GET(eq, eqe); switch (eqe_evttype) { case HERMON_EVT_PORT_STATE_CHANGE: status = hermon_port_state_change_handler(state, eq, eqe); break; case HERMON_EVT_COMM_ESTABLISHED: status = hermon_comm_estbl_handler(state, eq, eqe); break; case HERMON_EVT_COMMAND_INTF_COMP: status = hermon_cmd_complete_handler(state, eq, eqe); break; case HERMON_EVT_LOCAL_WQ_CAT_ERROR: HERMON_WARNING(state, HERMON_FMA_LOCCAT); status = hermon_local_wq_cat_err_handler(state, eq, eqe); break; case HERMON_EVT_INV_REQ_LOCAL_WQ_ERROR: HERMON_WARNING(state, HERMON_FMA_LOCINV); status = hermon_invreq_local_wq_err_handler(state, eq, eqe); break; case HERMON_EVT_LOCAL_ACC_VIO_WQ_ERROR: HERMON_WARNING(state, HERMON_FMA_LOCACEQ); IBTF_DPRINTF_L2("async", HERMON_FMA_LOCACEQ); status = hermon_local_acc_vio_wq_err_handler(state, eq, eqe); break; case HERMON_EVT_SEND_QUEUE_DRAINED: status = hermon_sendq_drained_handler(state, eq, eqe); break; case HERMON_EVT_PATH_MIGRATED: status = hermon_path_mig_handler(state, eq, eqe); break; case HERMON_EVT_PATH_MIGRATE_FAILED: HERMON_WARNING(state, HERMON_FMA_PATHMIG); status = hermon_path_mig_err_handler(state, eq, eqe); break; case HERMON_EVT_SRQ_CATASTROPHIC_ERROR: HERMON_WARNING(state, HERMON_FMA_SRQCAT); status = hermon_catastrophic_handler(state, eq, eqe); break; case HERMON_EVT_SRQ_LAST_WQE_REACHED: status = hermon_srq_last_wqe_reached_handler(state, eq, eqe); break; case HERMON_EVT_FEXCH_ERROR: status = hermon_fexch_error_handler(state, eq, eqe); break; default: break; } return (status); } /* * hermon_port_state_change_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_port_state_change_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { ibc_async_event_t event; ibt_async_code_t type; uint_t subtype; uint8_t port; char link_msg[24]; /* * Depending on the type of Port State Change event, pass the * appropriate asynch event to the IBTF. */ port = (uint8_t)HERMON_EQE_PORTNUM_GET(eq, eqe); /* Check for valid port number in event */ if ((port == 0) || (port > state->hs_cfg_profile->cp_num_ports)) { HERMON_WARNING(state, "Unexpected port number in port state " "change event"); cmn_err(CE_CONT, " Port number: %02x\n", port); return (DDI_FAILURE); } subtype = HERMON_EQE_EVTSUBTYPE_GET(eq, eqe); if (subtype == HERMON_PORT_LINK_ACTIVE) { event.ev_port = port; type = IBT_EVENT_PORT_UP; (void) snprintf(link_msg, 23, "port %d up", port); ddi_dev_report_fault(state->hs_dip, DDI_SERVICE_RESTORED, DDI_EXTERNAL_FAULT, link_msg); } else if (subtype == HERMON_PORT_LINK_DOWN) { event.ev_port = port; type = IBT_ERROR_PORT_DOWN; (void) snprintf(link_msg, 23, "port %d down", port); ddi_dev_report_fault(state->hs_dip, DDI_SERVICE_LOST, DDI_EXTERNAL_FAULT, link_msg); } else { HERMON_WARNING(state, "Unexpected subtype in port state change " "event"); cmn_err(CE_CONT, " Event type: %02x, subtype: %02x\n", HERMON_EQE_EVTTYPE_GET(eq, eqe), subtype); return (DDI_FAILURE); } /* * Deliver the event to the IBTF. Note: If "hs_ibtfpriv" is NULL, * then we have either received this event before we finished * attaching to the IBTF or we've received it while we are in the * process of detaching. */ if (state->hs_ibtfpriv != NULL) { HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_comm_estbl_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_comm_estbl_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_EVENT_COM_EST_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_local_wq_cat_err_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_local_wq_cat_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_ERROR_CATASTROPHIC_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_invreq_local_wq_err_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_invreq_local_wq_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_ERROR_INVALID_REQUEST_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_local_acc_vio_wq_err_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_local_acc_vio_wq_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_ERROR_ACCESS_VIOLATION_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_sendq_drained_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_sendq_drained_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; uint_t forward_sqd_event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * And then we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_EVENT_SQD; /* * Grab the QP lock and update the QP state to reflect that * the Send Queue Drained event has arrived. Also determine * whether the event is intended to be forwarded on to the * consumer or not. This information is used below in * determining whether or not to call the IBTF. */ mutex_enter(&qp->qp_lock); forward_sqd_event = qp->qp_forward_sqd_event; qp->qp_forward_sqd_event = 0; qp->qp_sqd_still_draining = 0; mutex_exit(&qp->qp_lock); if (forward_sqd_event != 0) { HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } } return (DDI_SUCCESS); } /* * hermon_path_mig_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_path_mig_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_EVENT_PATH_MIGRATED_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_path_mig_err_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_path_mig_err_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_ERROR_PATH_MIGRATE_REQ_QP; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_catastrophic_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_catastrophic_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; if (eq->eq_evttypemask == HERMON_EVT_MSK_LOCAL_CAT_ERROR) { HERMON_FMANOTE(state, HERMON_FMA_INTERNAL); hermon_eq_catastrophic(state); return (DDI_SUCCESS); } /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_srq_hdl = (ibt_srq_hdl_t)qp->qp_srqhdl->srq_hdlrarg; type = IBT_ERROR_CATASTROPHIC_SRQ; mutex_enter(&qp->qp_srqhdl->srq_lock); qp->qp_srqhdl->srq_state = HERMON_SRQ_STATE_ERROR; mutex_exit(&qp->qp_srqhdl->srq_lock); HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_srq_last_wqe_reached_handler() * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_srq_last_wqe_reached_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ qpnum = HERMON_EQE_QPNUM_GET(eq, eqe); qp = hermon_qphdl_from_qpnum(state, qpnum); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_EVENT_EMPTY_CHAN; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* ARGSUSED */ static int hermon_fexch_error_handler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { hermon_qphdl_t qp; uint_t qpnum; ibc_async_event_t event; ibt_async_code_t type; /* Get the QP handle from QP number in event descriptor */ event.ev_port = HERMON_EQE_FEXCH_PORTNUM_GET(eq, eqe); qpnum = hermon_fcoib_qpnum_from_fexch(state, event.ev_port, HERMON_EQE_FEXCH_FEXCH_GET(eq, eqe)); qp = hermon_qphdl_from_qpnum(state, qpnum); event.ev_fc = HERMON_EQE_FEXCH_SYNDROME_GET(eq, eqe); /* * If the QP handle is NULL, this is probably an indication * that the QP has been freed already. In which case, we * should not deliver this event. * * We also check that the QP number in the handle is the * same as the QP number in the event queue entry. This * extra check allows us to handle the case where a QP was * freed and then allocated again in the time it took to * handle the event queue processing. By constantly incrementing * the non-constrained portion of the QP number every time * a new QP is allocated, we mitigate (somewhat) the chance * that a stale event could be passed to the client's QP * handler. * * Lastly, we check if "hs_ibtfpriv" is NULL. If it is then it * means that we've have either received this event before we * finished attaching to the IBTF or we've received it while we * are in the process of detaching. */ if ((qp != NULL) && (qp->qp_qpnum == qpnum) && (state->hs_ibtfpriv != NULL)) { event.ev_qp_hdl = (ibtl_qp_hdl_t)qp->qp_hdlrarg; type = IBT_FEXCH_ERROR; HERMON_DO_IBTF_ASYNC_CALLB(state, type, &event); } return (DDI_SUCCESS); } /* * hermon_no_eqhandler * Context: Only called from interrupt context */ /* ARGSUSED */ static int hermon_no_eqhandler(hermon_state_t *state, hermon_eqhdl_t eq, hermon_hw_eqe_t *eqe) { uint_t data; int i; /* * This "unexpected event" handler (or "catch-all" handler) will * receive all events for which no other handler has been registered. * If we end up here, then something has probably gone seriously wrong * with the Hermon hardware (or, perhaps, with the software... though * it's unlikely in this case). The EQE provides all the information * about the event. So we print a warning message here along with * the contents of the EQE. */ HERMON_WARNING(state, "Unexpected Event handler"); cmn_err(CE_CONT, " Event type: %02x, subtype: %02x\n", HERMON_EQE_EVTTYPE_GET(eq, eqe), HERMON_EQE_EVTSUBTYPE_GET(eq, eqe)); for (i = 0; i < sizeof (hermon_hw_eqe_t) >> 2; i++) { data = ((uint_t *)eqe)[i]; cmn_err(CE_CONT, " EQE[%02x]: %08x\n", i, data); } return (DDI_SUCCESS); }
