man/man9f/ddi_intr_dup_handler.9f

int
add_msix_interrupts(intr_state_t *state)
{
 int x, y;

 /*
 * For this example, assume the device supports multiple
 * interrupt vectors, but only request to be allocated
 * 1 MSI-X to use and then dup the rest.
 */
 if (ddi_intr_get_nintrs(state->dip, DDI_INTR_TYPE_MSIX,
 &state->intr_count) != DDI_SUCCESS) {
 cmn_err(CE_WARN, "Failed to retrieve the MSI-X interrupt count");
 return (DDI_FAILURE);
 }

 state->intr_size = state->intr_count * sizeof (ddi_intr_handle_t);
 state->intr_htable = kmem_zalloc(state->intr_size, KM_SLEEP);

 /* Allocate one MSI-X interrupt handle */
 if (ddi_intr_alloc(state->dip, state->intr_htable,
 DDI_INTR_TYPE_MSIX, state->inum, 1, &state->actual,
 DDI_INTR_ALLOC_STRICT) != DDI_SUCCESS) {
 cmn_err(CE_WARN, "Failed to allocate MSI-X interrupt");
 kmem_free(state->intr_htable, state->intr_size);
 return (DDI_FAILURE);
 }

 /* Get the count of how many MSI-X interrupts we dup */
 state->dup_cnt = state->intr_count - state->actual;

 if (ddi_intr_get_pri(state->intr_htable[0],
 &state->intr_pri) != DDI_SUCCESS) {
 cmn_err(CE_WARN, "Failed to get interrupt priority");
 goto error1;
 }

 /* Make sure the MSI-X priority is below 'high level' */
 if (state->intr_pri >= ddi_intr_get_hilevel_pri()) {
 cmn_err(CE_WARN, "Interrupt PRI is too high");
 goto error1;
 }

 /*
 * Add the handler for the interrupt
 */
 if (ddi_intr_add_handler(state->intr_htable[0],
 (ddi_intr_handler_t *)intr_isr, (caddr_t)state,
 NULL) != DDI_SUCCESS) {
 cmn_err(CE_WARN, "Failed to add interrupt handler");
 goto error1;
 }

 /* Enable the main MSI-X handle first */
 if (ddi_intr_enable(state->intr_htable[0]) != DDI_SUCCESS) {
 cmn_err(CE_WARN, "Failed to enable interrupt");
 goto error2;
 }

 /*
 * Create and enable dups of the original MSI-X handler, note
 * that the inum we are using starts at 0.
 */
 for (x = 1; x < state->dup_cnt; x++) {
 if (ddi_intr_dup_handler(state->intr_htable[0],
 state->inum + x, &state->intr_htable[x]) != DDI_SUCCESS) {
 for (y = x - 1; y > 0; y--) {
 (void) ddi_intr_disable(state->intr_htable[y]);
 (void) ddi_intr_free(state->intr_htable[y]);
 }

 goto error2;
 }
 if (ddi_intr_enable(state->intr_htable[x]) != DDI_SUCCESS) {
 for (y = x; y > 0; y--) {
 (void) ddi_intr_disable(state->intr_htable[y]);
 (void) ddi_intr_free(state->intr_htable[y]);
 }

 goto error2;
 }
 }

 return (DDI_SUCCESS);

error2:
 (void) ddi_intr_remove_handler(state->intr_htable[0]);
error1:
 (void) ddi_intr_free(state->intr_htable[0]);

 kmem_free(state->intr_htable, state->intr_size);
 return (DDI_FAILURE);
}

void
remove_msix_interrupts(intr_state_t *state)
{
 int x;

 /*
 * Disable all the handles and free the dup-ed handles
 * before we can remove the main MSI-X interrupt handle.
 */
 for (x = 1; x < state->dup_cnt; x++) {
 (void) ddi_intr_disable(state->intr_htable[x]);
 (void) ddi_intr_free(state->intr_htable[x]);
 }

 /*
 * We can remove and free the main MSI-X handler now
 * that all the dups have been freed.
 */
 (void) ddi_intr_disable(state->intr_htable[0]);
 (void) ddi_intr_remove_handler(state->intr_htable[0]);
 (void) ddi_intr_free(state->intr_htable[0]);

 kmem_free(state->intr_htable, state->intr_size);
}