static int isci_sysctl_coalesce_number(SYSCTL_HANDLER_ARGS) { struct isci_softc *isci = (struct isci_softc *)arg1; int error = sysctl_handle_int(oidp, &isci->coalesce_number, 0, req); int i; if (error) return (error); for (i = 0; i < isci->controller_count; i++) scif_controller_set_interrupt_coalescence( isci->controllers[i].scif_controller_handle, isci->coalesce_number, isci->coalesce_timeout); return (0); }
int isci_initialize(struct isci_softc *isci) { int error; uint32_t status = 0; uint32_t library_object_size; uint32_t verbosity_mask; uint32_t scic_log_object_mask; uint32_t scif_log_object_mask; uint8_t *header_buffer; library_object_size = scif_library_get_object_size(SCI_MAX_CONTROLLERS); isci->sci_library_memory = malloc(library_object_size, M_ISCI, M_NOWAIT | M_ZERO ); isci->sci_library_handle = scif_library_construct( isci->sci_library_memory, SCI_MAX_CONTROLLERS); sci_object_set_association( isci->sci_library_handle, (void *)isci); verbosity_mask = (1<<SCI_LOG_VERBOSITY_ERROR) | (1<<SCI_LOG_VERBOSITY_WARNING) | (1<<SCI_LOG_VERBOSITY_INFO) | (1<<SCI_LOG_VERBOSITY_TRACE); scic_log_object_mask = 0xFFFFFFFF; scic_log_object_mask &= ~SCIC_LOG_OBJECT_COMPLETION_QUEUE; scic_log_object_mask &= ~SCIC_LOG_OBJECT_SSP_IO_REQUEST; scic_log_object_mask &= ~SCIC_LOG_OBJECT_STP_IO_REQUEST; scic_log_object_mask &= ~SCIC_LOG_OBJECT_SMP_IO_REQUEST; scic_log_object_mask &= ~SCIC_LOG_OBJECT_CONTROLLER; scif_log_object_mask = 0xFFFFFFFF; scif_log_object_mask &= ~SCIF_LOG_OBJECT_CONTROLLER; scif_log_object_mask &= ~SCIF_LOG_OBJECT_IO_REQUEST; TUNABLE_INT_FETCH("hw.isci.debug_level", &g_isci_debug_level); sci_logger_enable(sci_object_get_logger(isci->sci_library_handle), scif_log_object_mask, verbosity_mask); sci_logger_enable(sci_object_get_logger( scif_library_get_scic_handle(isci->sci_library_handle)), scic_log_object_mask, verbosity_mask); header_buffer = (uint8_t *)&isci->pci_common_header; for (uint8_t i = 0; i < sizeof(isci->pci_common_header); i++) header_buffer[i] = pci_read_config(isci->device, i, 1); scic_library_set_pci_info( scif_library_get_scic_handle(isci->sci_library_handle), &isci->pci_common_header); isci->oem_parameters_found = FALSE; isci_get_oem_parameters(isci); /* trigger interrupt if 32 completions occur before timeout expires */ isci->coalesce_number = 32; /* trigger interrupt if 2 microseconds elapse after a completion occurs, * regardless if "coalesce_number" completions have occurred */ isci->coalesce_timeout = 2; isci->controller_count = scic_library_get_pci_device_controller_count( scif_library_get_scic_handle(isci->sci_library_handle)); for (int index = 0; index < isci->controller_count; index++) { struct ISCI_CONTROLLER *controller = &isci->controllers[index]; SCI_CONTROLLER_HANDLE_T scif_controller_handle; controller->index = index; isci_controller_construct(controller, isci); scif_controller_handle = controller->scif_controller_handle; status = isci_controller_initialize(controller); if(status != SCI_SUCCESS) { isci_log_message(0, "ISCI", "isci_controller_initialize FAILED: %x\n", status); return (status); } error = isci_controller_allocate_memory(controller); if (error != 0) return (error); scif_controller_set_interrupt_coalescence( scif_controller_handle, isci->coalesce_number, isci->coalesce_timeout); } /* FreeBSD provides us a hook to ensure we get a chance to start * our controllers and complete initial domain discovery before * it searches for the boot device. Once we're done, we'll * disestablish the hook, signaling the kernel that is can proceed * with the boot process. */ isci->config_hook.ich_func = &isci_controller_start; isci->config_hook.ich_arg = &isci->controllers[0]; if (config_intrhook_establish(&isci->config_hook) != 0) isci_log_message(0, "ISCI", "config_intrhook_establish failed!\n"); return (status); }