common/ocs_fc/ocs_driver.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2018, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "ocs.h"
#include "ocs_driver.h"
#include "ocs_vpd.h"
#include "ocs_mgmt.h"
#include "ocs_gendump.h"
#include "ocs_ras.h"
#include "ocs_recovery.h"
#include "ocs_pm.h"
#include "ocs_els.h"

#include "ocs_params.h"

static void ocs_device_interrupt_handler(ocs_t *ocs, uint32_t vector);
static void ocs_driver_print_module_params(void);

void ocs_mgmt_driver_list(ocs_textbuf_t *textbuf, void *driver);
void ocs_mgmt_driver_get_all(ocs_textbuf_t *textbuf, void *driver);
int ocs_mgmt_driver_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *driver);
int ocs_mgmt_driver_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
        void *arg_out, uint32_t arg_out_length, void *driver);
int ocs_run_link_loopback(ocs_t *ocs, void *tx_buf, uint32_t tx_buflen, void *rx_buf, uint32_t rx_buflen);
int ocs_run_pci_loopback(ocs_t *ocs, void *tx_buf, uint32_t tx_buflen, void *rx_buf, uint32_t rx_buflen);
int ocs_set_loopback_mode(ocs_t *ocs, uint32_t arg_in);
int ocs_set_fc_trunk_mode(ocs_t *ocs, uint32_t trunk_mode);
int ocs_get_fc_trunk_info(ocs_t *ocs, uint32_t *trunk_config);
int ocs_ras_collect_diag_logs(ocs_t *ocs, void *user_tx_buf, uint32_t user_tx_buflen,
        void *user_rx_buf, uint32_t rx_buf_len);

static ocs_mgmt_functions_t driver_mgmt_functions = {
    .get_list_handler = ocs_mgmt_driver_list,
    .get_handler = ocs_mgmt_driver_get,
    .get_all_handler = ocs_mgmt_driver_get_all,
    .exec_handler = ocs_mgmt_driver_exec,
};

#define FW_WRITE_BUFSIZE 64*1024
typedef struct ocs_fw_write_result {
        ocs_sem_t semaphore;
        int32_t status;
    int32_t ext_status;
        uint32_t actual_xfer;
        uint32_t change_status;
} ocs_fw_write_result_t;

#define INTERNAL_LOOPBACK   0x1
#define EXTERNAL_LOOPBACK   0x2
#define PCI_LOOPBACK        0x3
#define LOOPBACK_FRAME_TIMEOUT_SEC 5

/* global param for ocs_app_watchdog_thread_t */
uint64_t g_app_watchdog_cpu_mask = 0;



static void
ocs_capture_hal_global_params(void)
{
    char prop_buf[32];
    uint32_t fw_diag_log_size = 0;
    uint32_t fw_diag_log_level = 1;

    hal_global.queue_topology_string = queue_topology;

        if (ocs_get_property("fw_diag_log_size", prop_buf, sizeof(prop_buf)) == 0) {
                char *p;
                fw_diag_log_size = ocs_strtoul(prop_buf, &p, 0);
                switch(*p) {
                case 'm': case 'M':
                        fw_diag_log_size *= 1024;
                        /* fallthrough */
                case 'k': case 'K':
                        fw_diag_log_size *= 1024;
                        break;
        default:
            // invalid parameter, disable the feature
            fw_diag_log_size *= 0;
                }
                if (fw_diag_log_size) {
                    if (fw_diag_log_size > OCS_RAS_LOGICAL_BUFFER_SIZE_MAX)
                            fw_diag_log_size = OCS_RAS_LOGICAL_BUFFER_SIZE_MAX;
                    if (fw_diag_log_size < OCS_RAS_LOGICAL_BUFFER_SIZE_MIN)
                            fw_diag_log_size = OCS_RAS_LOGICAL_BUFFER_SIZE_MIN;
            // verify and adjust logical buffer size to multiple of 128KB
                    fw_diag_log_size = (fw_diag_log_size / OCS_RAS_LOGICAL_BUFFER_SIZE_MIN) *
                       OCS_RAS_LOGICAL_BUFFER_SIZE_MIN;
                }
        }
    hal_global.fw_diag_log_size = fw_diag_log_size;

        if (ocs_get_property("fw_diag_log_level", prop_buf, sizeof(prop_buf)) == 0) {
        fw_diag_log_level = ocs_strtoul(prop_buf, 0, 0);
        if (fw_diag_log_level > OCS_RAS_FW_LOG_LEVEL_MAX)
            fw_diag_log_level = OCS_RAS_FW_LOG_LEVEL_MAX;
    }
    hal_global.fw_diag_log_level = fw_diag_log_level;
}


/**
 * @brief Perform driver wide initialization
 *
 * This function is called prior to enumerating PCI devices, with subsequent calls
 * to ocs_device_attach.  For OCS, this function invokes the back end functions
 * ocs_scsi_tgt_driver_init(), and ocs_scsi_ini_driver_init()
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
int32_t
ocs_device_init(void)
{
    int32_t rc;

    ocs_capture_hal_global_params();
    ocs_thread_init();

    /* Get the CPU mask */
    g_app_watchdog_cpu_mask = heartbeat_cpu_mask;

    /* driver-wide init for target-server */
    if (target) {
        rc = ocs_scsi_tgt_driver_init();
        if (rc) {
            ocs_log_err(NULL, "ocs_scsi_tgt_init failed rc=%d\n", rc);
            return -ENOMEM;
        }
    }

    /*
     * Attach ML FC transport template for both I+T modes.
     * For T only mode, this is required for Scsi_Host sysfs interface.
     */
    if (initiator || target) {
        rc = ocs_scsi_ini_driver_init(initiator);
        if (rc) {
            ocs_log_err(NULL, "ocs_scsi_ini_init failed rc=%d\n", rc);
            return -ENOMEM;
        }
    }

    /* Print module Parameters */
    ocs_driver_print_module_params();

    return 0;
}

/**
 * @brief Perform device initialization complete
 *
 * This function is called after all PCI device/functions have been enumerated.
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
int32_t
ocs_device_init_complete(void)
{
    ocs_t *ocs;
    int32_t rc, index = 0;

    /* Setup FW error recovery */
    if (enable_auto_recovery) {
        rc = ocs_fw_err_recovery_setup();
        if (rc < 0) {
            ocs_log_err(NULL, "Failed to setup FW error recovery\n");
            return rc;
        }
    }

    if (holdoff_link_online == 1) {
        while ((ocs = ocs_get_instance(index++)) != NULL) {
            ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
        }
    }

    return 0;
}

/**
 * @brief Perform driver wide shutdown actions
 *
 * This function is called prior to detatching devices during a driver
 * unload.
 *
 * @return none
 */
void
ocs_device_shutdown(void)
{
    if (enable_auto_recovery) {
        ocs_fw_err_recovery_stop();
    }
}

/**
 * @brief Perform driver wide shutdown complete actions
 *
 * This function is called shutdown for all devices has completed
 *
 * @return none
 */
void
ocs_device_shutdown_complete(void)
{
    if (initiator || target) {
        ocs_scsi_ini_driver_exit(initiator);
    }

    if (target) {
        ocs_scsi_tgt_driver_exit();
    }
}

/*
 * @brief allocate ocs device
 *
 * @param nid Numa node ID
 *
 * @return pointer to OCS structure
 */

void *ocs_device_alloc(int32_t nid)
{
    ocs_t *ocs = NULL;
    uint32_t i;

    /* Allocate memory using nid only if it has valid NUMA node avalible*/
    if (nid < 0) {
        ocs = ocs_malloc(NULL, sizeof(*ocs), OCS_M_NOWAIT | OCS_M_ZERO);
    } else {
        ocs = ocs_malloc_nid(nid, sizeof(*ocs), OCS_M_NOWAIT | OCS_M_ZERO);
    }
    if (ocs != NULL) {
        for (i = 0; i < ARRAY_SIZE(ocs_devices); i ++) {
            if (ocs_devices[i] == NULL) {
                ocs->instance_index = i;
                ocs_devices[i] = ocs;
                break;
            }
        }

        if (i == ARRAY_SIZE(ocs_devices)) {
            ocs_log_err(NULL, "failed\n");
            ocs_free(ocs, ocs, sizeof(*ocs));
            ocs = NULL;
        } else {
            /* If enabled, initailize a RAM logging buffer */
            if (logdest & 2) {
                ocs->ramlog = ocs_ramlog_init(ocs, ramlog_size/OCS_RAMLOG_DEFAULT_BUFFERS,
                    OCS_RAMLOG_DEFAULT_BUFFERS);
                /* If NULL was returned, then we'll simply skip using the ramlog but */
                /* set logdest to 1 to ensure that we at least get default logging.  */
                if (ocs->ramlog == NULL) {
                    logdest = 1;
                }
            }

            /* initialize a saved ddump */
            if (ddump_saved_size) {
                if (ocs_textbuf_alloc(ocs, &ocs->ddump_saved, ddump_saved_size)) {
                    ocs_log_err(ocs, "failed to allocate memory for saved ddump\n");
                }
            }

#if defined(ENABLE_LOCK_DEBUG)
            ocs_list_init(&ocs->ocs_os.locklist, ocs_lock_t, link);
            ocs_lock_init(NULL, &ocs->ocs_os.locklist_lock, "locklist_lock[%d]", ocs->instance_index);
#endif
            ocs_list_init(&ocs->domain_list, ocs_domain_t, link);
            ocs->ocs_os.interrupt_cb = ocs_device_interrupt_handler;
            ocs_device_lock_init(ocs);
            ocs->drv_ocs.attached = FALSE;
            ocs->ocs_os.hw_cmpl_context = hw_cmpl_context;
            ocs->mgmt_functions = &driver_mgmt_functions;
#ifdef OCS_DEBUG_MEMORY
            ocs_memory_tracker_init(ocs, &ocs->ocs_os.tracker);
#endif
        }
    }
    return ocs;
}

/**
 * @brief free ocs device
 *
 * @param ocs pointer to ocs structure
 *
 * @return none
 */

void ocs_device_free(ocs_t *ocs)
{
    if (ocs != NULL) {
        ocs_textbuf_free(ocs, &ocs->ddump_saved);
        ocs_ramlog_free(ocs, ocs->ramlog);
        ocs_devices[ocs->instance_index] = NULL;
        ocs_device_lock_free(ocs);
#if defined(ENABLE_LOCK_DEBUG)
        {
            ocs_os_t *os = &ocs->ocs_os;
            ocs_lock_t *l;
            uint32_t count = 0;
            ocs_list_foreach(&os->locklist, l) {
                ocs_log_debug(os, "%s not freed\n", l->name);
                count++;
            }
            if (count == 0) {
                ocs_log_debug(ocs, "all lock objects freed\n");
            }
        }
#endif
#ifdef OCS_DEBUG_MEMORY
        ocs_memory_allocated_print(&ocs->ocs_os.tracker);
        ocs_memory_tracker_teardown(&ocs->ocs_os.tracker);
#endif
        ocs_free(NULL, ocs, sizeof(*ocs));
    }
}

/**
 * @brief return the number of interrupts required per HBA
 *
 * @param ocs pointer to ocs structure
 *
 * @return the number of interrupts or a negative value on error.
 */
int32_t
ocs_device_interrupts_required(ocs_t *ocs)
{
    if (ocs_hal_setup(&ocs->hal, ocs, SLI4_PORT_TYPE_FC) !=
        OCS_HAL_RTN_SUCCESS) {
        return -1;
    }
    return ocs_hal_qtop_eq_count(&ocs->hal);
}

/**
 * @brief Initialize resources when pci devices attach
 *
 * @param ocs pointer to ocs structure
 *
 * @return 0 for success, a negative error code value for failure.
 */

int32_t
ocs_device_attach(ocs_t *ocs)
{
    uint32_t rc = 0;

    if (ocs->drv_ocs.attached) {
        ocs_log_warn(ocs, "Device is already attached\n");
        rc = -1;
    } else {
        ocs_snprintf(ocs->display_name, sizeof(ocs->display_name), "[%s%d] ", "fc",  ocs->instance_index);

        ocs->logmask = logmask;
        ocs->enable_ini = initiator;
        ocs->enable_tgt = target;
        ocs->ctrlmask = ctrlmask;
        ocs->topology = topology;
        ocs->speed = speed;
        ocs->ethernet_license = ethernet_license;
        ocs->num_scsi_ios = num_scsi_ios;
        ocs->enable_hlm = enable_hlm;
        ocs->enable_dpp = enable_dpp;
        ocs->hlm_group_size = hlm_group_size;
        ocs->max_remote_nodes = max_remote_nodes;
        ocs->hal_war_version = hal_war_version;
        ocs->watchdog_timeout = watchdog_timeout;
        ocs->sliport_healthcheck = sliport_healthcheck;
        ocs->disable_fec = disable_fec;
        ocs->enable_fw_ag_rsp = enable_fw_ag_rsp;
        ocs->sliport_pause_errors = sliport_pause_errors;
        ocs->enable_bbcr = enable_bbcr;
        ocs->enable_auto_recovery = enable_auto_recovery;
#if defined(OCS_INCLUDE_RAMD)
        ocs->esoc = esoc;
        ocs->num_vports = num_vports;
#endif
        ocs->max_isr_time_msec = OCS_OS_MAX_ISR_TIME_MSEC;
        ocs->explicit_buffer_list = explicit_buffer_list;
        ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device);
        ocs->fw_version = (const char*) ocs_hal_get_ptr(&ocs->hal, OCS_HAL_FW_REV);
        ocs->driver_version = DRV_VERSION;

        ocs->external_loopback = external_loopback;
        ocs->target_io_timer_sec = target_io_timer;
        ocs->tgt_wqe_timer = target_wqe_timer;

        ocs->tgt_rscn_delay_msec = 0;
        ocs->tgt_rscn_period_msec = 0;

        ocs->hal_bounce = hal_bounce;
        ocs->rq_threads = rq_threads;
        ocs->rq_selection_policy = rq_selection_policy;
        ocs->cq_process_limit = cq_process_limit;
        ocs->rr_quanta = rr_quanta;
        ocs->filter_def = filter_def;
        ocs->ocs_req_fw_upgrade = ocs_req_fw_upgrade;
        ocs->cfg_suppress_rsp = cfg_suppress_rsp;

        if (ocs->max_remote_nodes > MAX_REMOTE_NODES_ALLOWED) {
            ocs_log_err(ocs, "failed to allocate %d number of remote nodes, max remote nodes allowed is 8192\n ",ocs->max_remote_nodes);
            return -1;
        }

        if (fw_dump_type != FW_DUMP_TYPE_DUMPTOHOST &&
            fw_dump_type != FW_DUMP_TYPE_FLASH) {
            ocs_log_info(ocs, "Module param FW dump type is invalid. "
                     "Using FW dump type as default\n");
            fw_dump_type = MODPARAM_DEF_FW_DUMP_TYPE;
        }
        ocs_fw_dump_init(ocs, fw_dump_type);

        ocs_lock_init(ocs, &ocs->domain_list_empty_cb_lock,
                  "domain_list_empty_cb_lock[%d]", ocs_instance(ocs));

        if (target_wqe_timer > MAX_TARGET_WQE_TIMER) {
            ocs_log_err(ocs, "Invalid target wqe timer value %d\n", target_wqe_timer);
            return -1;
        }
        /* Allocate transport object and bring online */
        ocs->xport = ocs_xport_alloc(ocs);
        if (ocs->xport == NULL) {
            ocs_log_err(ocs, "failed to allocate transport object\n");
            rc = -1;
        } else if (ocs_xport_attach(ocs->xport) != 0) {
            ocs_log_err(ocs, "failed to attach transport object\n");
            rc = -1;
        } else if (ocs_xport_initialize(ocs->xport) != 0) {
            ocs_log_err(ocs, "failed to initialize transport object\n");
            rc = -1;
        } else if (ocs_start_event_processing(&ocs->ocs_os)) {
            ocs_log_err(ocs, "failed to start event processing\n");
            rc = -1;
        } else {
            /* For some drivers, such as SCST and LIO, the link is not brought up if
             * the driver is in target mode, because the link comes up after the target
             * is enabled.
             * If the driver is in initiator-only mode, then then bring the link up now.
             */

            if ((holdoff_link_online == 2) && ((!ocs->enable_tgt) && (ocs->enable_ini))) {
                holdoff_link_online = 0;
                ocs_log_debug(ocs, "holdoff_link_online param changed to %d\n",
                          holdoff_link_online);
            }

            if (holdoff_link_online == 0) {
                if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE) != 0) {
                    /*
                     * Only log a message.  Don't return the error,
                     * so that the driver will still attach to this port.
                     */
                    ocs_log_err(ocs, "failed to bring port online\n");
                }
            }

            ocs->holdoff_link_online = holdoff_link_online;

            /*
             * Setup stats timer only if scsi host template is
             * registered successfully
             */
            if (ocs_scsi_host_ml_registered(ocs)) {
                /* Get FC link and host statistics periodically */
                ocs_lock(&ocs->xport->fc_stats_lock);
                    ocs->xport->fc_stats_timer_shutdown = false;
                ocs_unlock(&ocs->xport->fc_stats_lock);
                ocs_xport_config_stats_timer(ocs);
            }
        }

        ocs->desc = ocs->hal.sli.config.modeldesc;
        ocs_log_info(ocs, "adapter model description: %s\n", ocs->hal.sli.config.modeldesc);

        if (rc == 0) {
            ocs->drv_ocs.attached = TRUE;

            if (ocs->ocs_req_fw_upgrade) {
                ocs_log_debug(ocs, "firmware update is in progress\n");
                ocs_request_firmware_update(ocs);
            }

        } else {
            ocs_teardown_msix((ocs_os_t *)ocs);
            if (ocs->xport != NULL) {
                ocs_xport_free(ocs->xport);
                ocs->xport = NULL;
            }
        }
    }

    return rc;
}

/**
 * @brief interrupt handler
 *
 * Interrupt handler
 *
 * @param ocs pointer to ocs structure
 * @param vector Zero-based interrupt vector number.
 *
 * @return none
 */

static void
ocs_device_interrupt_handler(ocs_t *ocs, uint32_t vector)
{
    ocs_hal_process(&ocs->hal, vector, ocs->max_isr_time_msec);
}

/**
 * @brief free resources when pci device detach
 *
 * @param ocs pointer to ocs structure
 *
 * @return 0 for success, a negative error code value for failure.
 */

int32_t
ocs_device_detach(ocs_t *ocs)
{
    int32_t rc = 0;

    if (ocs != NULL) {
        if (!ocs->drv_ocs.attached) {
            ocs_log_warn(ocs, "Device is not attached\n");
            return -1;
        }

        rc = ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN);
        if (rc) {
            ocs_log_err(ocs, "Transport Shutdown timed out\n");
        }

        if (ocs_hal_clear_dump_location(&ocs->hal)) {
            ocs_log_err(ocs, "failed to clear FW dump location\n");
        }

        ocs_stop_event_processing(&ocs->ocs_os);

        if (ocs_xport_detach(ocs->xport) != 0) {
            ocs_log_err(ocs, "Transport detach failed\n");
        }

        ocs_xport_free(ocs->xport);
        ocs->xport = NULL;
        ocs_hal_free_dump_to_host_buffers(&ocs->hal);
        ocs_lock_free(&ocs->domain_list_empty_cb_lock);
        ocs->drv_ocs.attached = FALSE;
    }

    return 0;
}

/**
 * @brief get driver wide property value
 *
 * Return valued driver wide property.   All property values using this interface
 * are returned as null terminated text.
 *
 * @param prop_name property name
 * @param buffer pointer to buffer
 * @param buffer_len length of buffer in bytes
 *
 * @return returns 0 for success, a negative error code value for failure.
 */

int32_t
ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len)
{
    if (FALSE)
        ;
    else if (strcmp(prop_name, "initiator") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", initiator);
    else if (strcmp(prop_name, "target") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", target);
    else if (strcmp(prop_name, "wwn_bump") == 0)
        ocs_snprintf(buffer, buffer_len, "%s", wwn_bump);
    else if (strcmp(prop_name, "dif_separate") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", dif_separate);
    else if (strcmp(prop_name, "p_type") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", p_type);
    else if (strcmp(prop_name, "fw_diag_log_level") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", fw_diag_log_level);
    else if (strcmp(prop_name, "fw_diag_log_size") == 0)
        ocs_snprintf(buffer, buffer_len, "%s", fw_diag_log_size);
    else if (strcmp(prop_name, "tow_feature") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", tow_feature);
    else if (strcmp(prop_name, "tow_io_size") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", tow_io_size);
    else if (strcmp(prop_name, "tow_xri_cnt") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", tow_xri_cnt);
#if defined(OCS_INCLUDE_SCST)
    else if (strcmp(prop_name, "scst_sg_table_size") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", scst_sg_table_size);
#endif
#if defined(OCS_INCLUDE_RAMD)
    else if (strcmp(prop_name, "global_ramdisc") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", global_ramdisc);
    else if (strcmp(prop_name, "ramdisc_size") == 0)
        ocs_strncpy(buffer, ramdisc_size, buffer_len);
    else if (strcmp(prop_name, "ramdisc_blocksize") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", ramdisc_blocksize);
    else if (strcmp(prop_name, "num_luns") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", num_luns);
    else if (strcmp(prop_name, "stub_res6_rel6") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", stub_res6_rel6);
    else if (strcmp(prop_name, "ramd_threading") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", ramd_threading);
    else if (strcmp(prop_name, "thread_cmds") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", thread_cmds);
    else if (strcmp(prop_name, "external_dif") == 0)
        ocs_strncpy(buffer, external_dif, buffer_len);
    else if (strcmp(prop_name, "esoc") == 0)
        ocs_snprintf(buffer, buffer_len, "%d", esoc);
#if defined(OCS_DISC_SPIN_DELAY)
    else if (strcmp(prop_name, "disk_spin_delay") == 0)
        ocs_snprintf(buffer, disk_spin_delay, "%d", disk_spin_delay);
#endif
#endif
    else {
        ocs_log_debug(NULL, "Error: unknown property %s\n", prop_name);
        ocs_snprintf(buffer, buffer_len, "%s", "");
        return -1;
    }
    return 0;
}

static void
ocs_fw_write_cb(int32_t status, int32_t ext_status, uint32_t actual_write_length, uint32_t change_status, void *arg)
{                       
        ocs_fw_write_result_t *result = arg;
                
        result->status = status;
        result->actual_xfer = actual_write_length;
        result->change_status = change_status;
    result->ext_status = ext_status;
        
        ocs_sem_v(&(result->semaphore));
}               
                
int     
ocs_firmware_write(ocs_t *ocs, const u8 *buf, size_t buf_len, uint8_t *change_status)
{       
        int rc = 0;
        uint32_t bytes_left;
        uint32_t xfer_size;
        uint32_t offset;
        ocs_dma_t dma;  
        int last = 0;           
        ocs_fw_write_result_t result;
                        
        ocs_sem_init(&(result.semaphore), 0, "fw_write");
                                        
        bytes_left = buf_len;                   
        offset = 0;             
                        
        if (ocs_dma_alloc(ocs, &dma, FW_WRITE_BUFSIZE, 4096)) {
                ocs_log_err(ocs, "ocs_firmware_write: malloc failed\n");
                return -ENOMEM;     
        }                       
                                
        while (bytes_left > 0) {
                                
                if (bytes_left > FW_WRITE_BUFSIZE) {
                        xfer_size = FW_WRITE_BUFSIZE;
                } else {        
                        xfer_size = bytes_left;
                }

                ocs_memcpy(dma.virt, buf + offset, xfer_size);

                if (bytes_left == xfer_size) {
                        last = 1;
                }

                ocs_hal_firmware_write(&ocs->hal, &dma, xfer_size, offset, last, ocs_fw_write_cb, &result);

                if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
                        rc = -ENXIO;
                        break;
                }

                if (result.actual_xfer == 0 || result.status != 0) {
            if (result.ext_status == SLI4_MBOX_EXT_STATUS_OBJ_UNSUPPORTED_FIRMWARE) {
                ocs_log_err(ocs, "Firmware does not meet minimum version requirement for this IPL\n");
                rc = -EACCES;
            } else {
                rc = -EFAULT;
            }
                        break;
                }

                if (last) {
                        *change_status = result.change_status;
                }

                bytes_left -= result.actual_xfer;
                offset += result.actual_xfer;
        }

        ocs_dma_free(ocs, &dma);
        return rc;
}

int
ocs_request_firmware_update(ocs_t *ocs)
{
        int rc = 0;
        uint8_t file_name[256], fw_change_status;
        const struct firmware *fw;
        struct ocs_hal_grp_hdr *fw_image;

        ocs_snprintf(file_name, 256, "%s.grp", ocs->model);
        rc = request_firmware(&fw, file_name, &ocs->ocs_os.pdev->dev);
        if (rc) {
                ocs_log_err(ocs, "Firmware file(%s) not found.\n", file_name);
                return rc;
        }
        fw_image = (struct ocs_hal_grp_hdr *)fw->data;

        /* Check if firmware provided is compatible with this particular
     * Adapter of not*/
        if ((ocs_be32toh(fw_image->magic_number) != OCS_HAL_OBJECT_G5) &&
                (ocs_be32toh(fw_image->magic_number) != OCS_HAL_OBJECT_G6)) {
                ocs_log_warn(ocs,
                        "Invalid FW image found Magic: 0x%x Size: %ld \n",
                        ocs_be32toh(fw_image->magic_number), fw->size);
                rc = -1;
                goto exit;

        }

        if (!strncmp(ocs->fw_version, fw_image->revision, strnlen(fw_image->revision, 16))) {
                ocs_log_debug(ocs, "No update req. Firmware is already up to date. \n");
                rc = 0;
                goto exit;
        }
        rc = ocs_firmware_write(ocs, fw->data, fw->size, &fw_change_status);
        if (rc) {
                ocs_log_err(ocs, "Firmware update failed. Return code = %d\n", rc);
        } else {
                ocs_log_info(ocs, "Firmware updated successfully\n");
                switch (fw_change_status) {
                        case 0x00:
                                ocs_log_debug(ocs, "No reset needed, new firmware is active.\n");
                                break;
                        case 0x01:
                                ocs_log_warn(ocs,
                                        "A physical device reset (host reboot) is needed to"
                                                "activate the new firmware\n");
                                break;
                        case 0x02:
                        case 0x03:
                                ocs_log_debug(ocs,
                                    "firmware is resetting to activate the new firmware\n");
                                ocs_fw_reset(ocs);
                                break;
                        default:
                                ocs_log_debug(ocs,
                                        "Unexected value change_status: %d\n",
                                        fw_change_status);
                                break;
                }

        }

exit:
        release_firmware(fw);

        return rc;

}





/**
 * @brief return OCS instance display name
 *
 * returns const char string of OCS instance display name
 *
 * @param os pointer to OS (ocs_t) object
 *
 * @return return display name
 */

const char *ocs_display_name(void *os)
{
    ocs_t *ocs = os;
    ocs_assert(ocs, "[?]");
    return ocs->display_name;
}

void ocs_mgmt_driver_list(ocs_textbuf_t *textbuf, void *object)
{

    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    /* Add my values to textbuf */
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "initiator");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "logmask");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ctrlmask");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "logdest");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramlog_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hal_war_version");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_scsi_ios");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "pm_state");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ddump_saved_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "dif_separate");
#if defined(OCS_INCLUDE_FC)
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwn_bump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "topology");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "speed");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "holdoff_link_online");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_hlm");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_dpp");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hlm_group_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "explicit_buffer_list");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hw_cmpl_context");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "external_loopback");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target_io_timer");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "target_wqe_timer");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "auto_xfer_rdy_size");
#endif
#if defined(OCS_INCLUDE_RAMD)
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_luns");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "global_ramd");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_blocksize");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ramdisc_size");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p_type");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "stub_res6_rel6");
#endif
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "fdb_gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "dump_to_host");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "fdb_dump_to_host");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "clear_ramlog");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_sleep");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_prepare");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_hibernate");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_resume");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gen_saved_ddump");

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");

}

int ocs_mgmt_driver_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
{
    char qualifier[80];
    int retval = -1;

    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    snprintf(qualifier, sizeof(qualifier), "%s/driver", parent);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
        char *unqualified_name = name + strlen(qualifier) +1;

        /* See if it's a value I can supply */
        if (FALSE) {
            ;
        } else if (ocs_strcmp(unqualified_name, "initiator") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "initiator", initiator);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "target") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "logmask") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logmask", "0x%x", logmask);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ctrlmask") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ctrlmask", "0x%x", ctrlmask);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "logdest") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logdest", "%d", logdest);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramlog_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramlog_size", "%d", ramlog_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hal_war_version") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "hal_war_version", hal_war_version);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "num_scsi_ios") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "pm_state") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pm_state", ocs_pm_get_state_string(textbuf->ocs));
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ddump_saved_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "dif_separate") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "dif_separate", dif_separate);
            retval = 0;
#if defined(OCS_INCLUDE_FC)
        } else if (ocs_strcmp(unqualified_name, "wwn_bump") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "wwn_bump", wwn_bump);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "topology") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "topology", "%d", topology);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "speed") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "speed", "%d", speed);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "holdoff_link_online") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "holdoff_link_online", holdoff_link_online);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_hlm") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hlm", enable_hlm);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "enable_dpp") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_dpp", enable_dpp);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hlm_group_size") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hlm_group_size", "%d", hlm_group_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "explicit_buffer_list") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "explicit_buffer_list", explicit_buffer_list);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hw_cmpl_context") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_cmpl_context", "%d", hw_cmpl_context);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "external_loopback") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "external_loopback", external_loopback);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "target_io_timer") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_io_timer", "%d", target_io_timer);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "target_wqe_timer") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_wqe_timer", "%d", target_wqe_timer);
            retval = 0;
#endif
#if defined(OCS_INCLUDE_RAMD)
        } else if (ocs_strcmp(unqualified_name, "num_luns") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramdisc_blocksize") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", "%d", ramdisc_blocksize);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "ramdisc_size") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "global_ramdisc") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "global_ramdisc", "%d", global_ramdisc);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "p_type") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p_type", "%d", p_type);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "stub_res6_rel6") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "stub_res6_rel6", "%d", stub_res6_rel6);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "esoc") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "esoc", "%d", esoc);
            retval = 0;
#endif
        }

    }

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");

    return retval;
}

void ocs_mgmt_driver_get_all(ocs_textbuf_t *textbuf, void *object)
{
    ocs_mgmt_start_unnumbered_section(textbuf, "driver");

    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "initiator", initiator);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "target", target);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logmask", "0x%x", logmask);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ctrlmask", "0x%x", ctrlmask);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "logdest", "%d", logdest);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "loglevel", "%d", loglevel);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rq_threads", "%d", rq_threads);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramlog_size", "%d", ramlog_size);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "hal_war_version", hal_war_version);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_scsi_ios", "%d", num_scsi_ios);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pm_state", ocs_pm_get_state_string(textbuf->ocs));
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ddump_saved_size", "%d", ddump_saved_size);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "dif_separate", dif_separate);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "queue_topology", queue_topology);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rq_selection_policy", "%d", rq_selection_policy);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "rr_quanta", "%d", rr_quanta);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "filter_def", filter_def);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "cq_process_limit", "%d", cq_process_limit);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "explicit_buffer_list", "%d", explicit_buffer_list);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "watchdog_timeout", "%d", watchdog_timeout);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "sliport_healthcheck", "%d", sliport_healthcheck);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "disable_fec", "%d", disable_fec);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ethernet_license", "%d", ethernet_license);
#if defined(OCS_INCLUDE_FC)
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "enable_dpp", "%d", enable_dpp);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "wwn_bump", wwn_bump);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "topology", "%d", topology);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "speed", "%d", speed);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "holdoff_link_online", holdoff_link_online);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_hlm", enable_hlm);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hlm_group_size", "%d", hlm_group_size);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "explicit_buffer_list", explicit_buffer_list);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_cmpl_context", "%d", hw_cmpl_context);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "external_loopback", external_loopback);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_io_timer", "%d", target_io_timer);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "target_wqe_timer", "%d", target_wqe_timer);
#endif
#if defined(OCS_INCLUDE_RAMD)
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_vports", "%d", num_vports);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_luns", "%d", num_luns);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramdisc_blocksize", "%d", ramdisc_blocksize);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ramdisc_size", ramdisc_size);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "global_ramdisc", "%d", global_ramdisc);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p_type", "%d", p_type);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ramd_threading", "%d", ramd_threading);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "thread_cmds", "%d", thread_cmds);
    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "external_dif", external_dif);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "stub_res6_rel6", stub_res6_rel6);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "esoc", "%d", esoc);

#endif
#if defined(OCS_DISC_SPIN_DELAY)
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "disk_spin_delay", "%d", disk_spin_delay);
#endif
    /* Actions */
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "fdb_gendump");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "dump_to_host");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "fdb_dump_to_host");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "clear_ramlog");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_sleep");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_prepare");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_hibernate");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "pm_resume");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "gen_saved_ddump");

    ocs_mgmt_end_unnumbered_section(textbuf, "driver");
}

int ocs_mgmt_driver_exec(char *parent, char *action_name, void *arg_in,
        uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length, void *object)
{
    char qualifier[80];
    int retval = -1;
    ocs_t *ocs = (ocs_t *)object;

    ocs_snprintf(qualifier, sizeof(qualifier), "%s/driver", parent);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(action_name, qualifier, strlen(qualifier)) == 0) {
        char *unqualified_name = action_name + strlen(qualifier) +1;

        /* See if it's a value I can supply */
        if (ocs_strcmp(unqualified_name, "gendump") == 0) {
            retval = ocs_gendump(ocs, FW_CHIP_LEVEL_DUMP);
        }
        if (ocs_strcmp(unqualified_name, "fdb_gendump") == 0) {
            retval = ocs_gendump(ocs, FW_FUNC_DESC_DUMP);
        }
        if (ocs_strcmp(unqualified_name, "dump_to_host") == 0) {
            retval = ocs_dump_to_host(ocs, arg_out, arg_out_length, FW_CHIP_LEVEL_DUMP);
        }
        if (ocs_strcmp(unqualified_name, "fdb_dump_to_host") == 0) {
            retval = ocs_dump_to_host(ocs, arg_out, arg_out_length, FW_FUNC_DESC_DUMP);
        }
        if (ocs_strcmp(unqualified_name, "trunk_mode") == 0) {
            uint32_t trunk_mode;
            retval = -1;
            if (arg_in && arg_in_length) {
                if (!ocs_copy_from_user(&trunk_mode, arg_in,
                    MIN(arg_in_length, sizeof(trunk_mode)))) {
                    retval = ocs_set_fc_trunk_mode(ocs, trunk_mode);
                }
            }
        }
        if (ocs_strcmp(unqualified_name, "trunk_info") == 0) {
            uint32_t trunk_info;
            if (arg_out && arg_out_length) {
                retval = ocs_get_fc_trunk_info(ocs, &trunk_info);
                if (retval || ocs_copy_to_user(arg_out, &trunk_info,
                    MIN(arg_out_length, sizeof(trunk_info)))) {
                    retval = -EPERM;
                }
            } else {
                retval = -EINVAL;
            }
        }
        if (ocs_strcmp(unqualified_name, "link_loopback") == 0) {
            retval = ocs_run_link_loopback(ocs, arg_in, arg_in_length, arg_out, arg_out_length);
        }
        if (ocs_strcmp(unqualified_name, "pci_loopback") == 0) {
            retval = ocs_run_pci_loopback(ocs, arg_in, arg_in_length, arg_out, arg_out_length);
        }
        if (ocs_strcmp(unqualified_name, "fw_diag_log") == 0) {
            retval = ocs_ras_collect_diag_logs(ocs, arg_in, arg_in_length, arg_out, arg_out_length);
        }
        if (ocs_strcmp(unqualified_name, "set_loopback") == 0) {
            uint32_t local_arg_in;
            retval = -1;
            if (arg_in && arg_in_length) {
                if (!ocs_copy_from_user(&local_arg_in, arg_in,
                    MIN(arg_in_length, sizeof(local_arg_in)))) {
                    retval = ocs_set_loopback_mode(ocs, local_arg_in);
                }
            }
        }
        if (ocs_strcmp(unqualified_name, "get_link_state") == 0) {
            ocs_xport_stats_t link_status;

            retval = ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &link_status);
            if (!retval && arg_out) {
                if (ocs_copy_to_user(arg_out, &link_status.value, sizeof(uint32_t))) {
                    retval = -1;
                }
            }
        }
        if (ocs_strcmp(unqualified_name, "set_link_state") == 0) {
            uint32_t local_arg_in;
            retval = -1;
            if (arg_in && arg_in_length) {
                if (!ocs_copy_from_user(&local_arg_in, arg_in,
                    MIN(arg_in_length, sizeof(local_arg_in)))) {
                    retval = ocs_xport_control(ocs->xport, local_arg_in);
                }
            }
        }

        if (ocs_strcmp(unqualified_name, "clear_ramlog") == 0) {
            char local_arg_in[128];
            int clear_start_of_day = 0;
            int clear_recent = 0;
            if (arg_in) {
                if (ocs_copy_from_user(local_arg_in, arg_in,
                    MIN(arg_in_length, sizeof(local_arg_in)-1))) {
                    ocs_log_warn(ocs, "Error: copy arg_in from user failed\n");
                    return -1;
                }

                local_arg_in[sizeof(local_arg_in)-1] = 0;
                if (ocs_strcmp(local_arg_in, "recent") == 0) {
                    clear_recent = 1;
                } else if (ocs_strcmp(local_arg_in, "start_of_day") == 0) {
                    clear_start_of_day = 1;
                } else if (ocs_strcmp(local_arg_in, "all") == 0) {
                    clear_recent = 1;
                    clear_start_of_day = 1;
                }
            } else {
                clear_recent = 1;
                clear_start_of_day = 1;
            }

            ocs_log_debug(ocs, "Clear ramlog:%s%s\n", clear_start_of_day ? " start_of_day" : "",
                clear_recent ? " recent" : "");

            ocs_ramlog_clear(ocs, ocs->ramlog, clear_start_of_day, clear_recent);
            retval = 0;
        }
        if (ocs_strcmp(unqualified_name, "pm_prepare") == 0) {
            retval = ocs_pm_request(ocs, OCS_PM_PREPARE, NULL, NULL);
        }
        if (ocs_strcmp(unqualified_name, "pm_sleep") == 0) {
            retval = ocs_pm_request(ocs, OCS_PM_SLEEP, NULL, NULL);
        }
        if (ocs_strcmp(unqualified_name, "pm_hibernate") == 0) {
            retval = ocs_pm_request(ocs, OCS_PM_HIBERNATE, NULL, NULL);
        }
        if (ocs_strcmp(unqualified_name, "pm_resume") == 0) {
            retval = ocs_pm_request(ocs, OCS_PM_RESUME, NULL, NULL);
        }
        if (ocs_strcmp(unqualified_name, "gen_saved_ddump") == 0) {
            retval = ocs_save_ddump(ocs, 0xff, ~0);
        }

        if (ocs_strcmp(unqualified_name, "lancer_temp") == 0) {
            retval = ocs_read_temperature_lancer(ocs, arg_out, arg_out_length);
            if (retval != 0) {
                ocs_log_err(ocs, "Failed to read temperature\n");
            }
        }
    }

    return retval;
}

static void
ocs_driver_print_module_params(void)
{
        ocs_log_info(NULL, "%s: driver version %s\n", DRV_NAME, DRV_VERSION);

    ocs_log_info(NULL, "  Module parameters:\n");
    ocs_log_info(NULL, "  Initiator = %d\n",        initiator);
    ocs_log_info(NULL, "  Target = %d\n",           target);
    ocs_log_info(NULL, "  ctrlmask = 0x%04x\n",     ctrlmask);
    ocs_log_info(NULL, "  loglevel = %d\n",         loglevel);
    ocs_log_info(NULL, "  logmask = 0x%04x\n",      logmask);
    ocs_log_info(NULL, "  ramlog_size = %d\n",      ramlog_size);
    ocs_log_info(NULL, "  rq_threads = %d\n",       rq_threads);
    ocs_log_info(NULL, "  wwn_bump = %s\n",         wwn_bump);
    ocs_log_info(NULL, "  topology = %d\n",         topology);
    ocs_log_info(NULL, "  speed = %d\n",            speed);
    ocs_log_info(NULL, "  holdoff_link_online = %d\n",  holdoff_link_online);
    ocs_log_info(NULL, "  enable_hlm = %d\n",       enable_hlm);
    ocs_log_info(NULL, "  hlm_group_size = %d\n",       hlm_group_size);
    ocs_log_info(NULL, "  max_remote_nodes = %d\n",     max_remote_nodes);
    ocs_log_info(NULL, "  ethernet_license = %d\n",     ethernet_license);
    ocs_log_info(NULL, "  num_scsi_ios = %d\n",     num_scsi_ios);
    ocs_log_info(NULL, "  dif_separate = %d\n",     dif_separate);
    ocs_log_info(NULL, "  tow_feature = %d\n",      tow_feature);
    ocs_log_info(NULL, "  tow_io_size = %d\n",      tow_io_size);
    ocs_log_info(NULL, "  tow_xri_cnt = %d\n",      tow_xri_cnt);
    ocs_log_info(NULL, "  queue_topology = %s\n",       queue_topology);
    ocs_log_info(NULL, "  rq_selection_policy = %d\n",      rq_selection_policy);
    ocs_log_info(NULL, "  rr_quanta = %d\n",                rr_quanta);
    ocs_log_info(NULL, "  filter_ref = %s\n",               filter_def);
    ocs_log_info(NULL, "  cq_process_limit = %d\n",     cq_process_limit);
    ocs_log_info(NULL, "  explicit_buffer_list = %d\n", explicit_buffer_list);
    ocs_log_info(NULL, "  external_loopback = %d\n",    external_loopback);
    ocs_log_info(NULL, "  target_io_timer = %d\n",      target_io_timer);
    ocs_log_info(NULL, "  target_wqe_timer = %d\n",     target_wqe_timer);
    ocs_log_info(NULL, "  ddump_saved_size = %d\n",     ddump_saved_size);
    ocs_log_info(NULL, "  hal_war_version = %s\n",      hal_war_version);
    ocs_log_info(NULL, "  hw_cmpl_context = %d\n",      hw_cmpl_context);
    ocs_log_info(NULL, "  watchdog_timeout = %d\n",     watchdog_timeout);
    ocs_log_info(NULL, "  heartbeat_cpu_mask = 0x%lx\n",    heartbeat_cpu_mask);
    ocs_log_info(NULL, "  sliport_healthcheck = %d\n",  sliport_healthcheck);
    ocs_log_info(NULL, "  disable_fec = %d\n",      disable_fec);
    ocs_log_info(NULL, "  enable_dpp = %d\n",       enable_dpp);
    ocs_log_info(NULL, "  sliport_pause_errors = %s\n", sliport_pause_errors);
    ocs_log_info(NULL, "  enable_bbcr = %d\n",      enable_bbcr);
    ocs_log_info(NULL, "  fw_dump_type = %d\n",     fw_dump_type);
    ocs_log_info(NULL, "  enable_auto_recovery = %d\n", enable_auto_recovery);
    ocs_log_info(NULL, "  cfg_suppress_rsp = %d\n",     cfg_suppress_rsp);
#if defined(OCS_DISC_SPIN_DELAY)
    ocs_log_info(NULL, "  disk_spin_delay = %d\n",      disk_spin_delay);
#endif

#if defined(OCS_INCLUDE_RAMD)
    ocs_log_info(NULL, "  num_vports = %d\n",       num_vports);
    ocs_log_info(NULL, "  p_type = %d\n",           p_type);
    ocs_log_info(NULL, "  ramdisc_size = %s\n",     ramdisc_size);
    ocs_log_info(NULL, "  ramdisc_blocksize = %d\n",    ramdisc_blocksize);
    ocs_log_info(NULL, "  num_luns = %d\n",         num_luns);
    ocs_log_info(NULL, "  global_ramdisc = %d\n",       global_ramdisc);
    ocs_log_info(NULL, "  stub_res6_rel6 = %d\n",       stub_res6_rel6);
    ocs_log_info(NULL, "  ramd_threading = %d\n",       ramd_threading);
    ocs_log_info(NULL, "  thread_cmds = %d\n",      thread_cmds);
    ocs_log_info(NULL, "  external_dif = %s\n",     external_dif);
    ocs_log_info(NULL, "  esoc = %d\n",                 esoc);
#endif
}

int32_t
ocs_set_fc_trunk_mode(ocs_t *ocs, uint32_t trunk_mode)
{
    int32_t rc;

    rc = ocs_hal_set_trunk_mode(&ocs->hal, trunk_mode);
    if (rc) {
        ocs_log_err(ocs, "failed to set trunk mode\n");
    } else {
        ocs_log_debug(ocs, "Trunk mode been set successfully\n");
    }
    return rc;
}

int32_t
ocs_get_fc_trunk_info(ocs_t *ocs, uint32_t *trunk_info)
{
    int32_t rc;

    rc = ocs_hal_get_trunk_info(&ocs->hal, trunk_info);
    if (rc) {
        ocs_log_err(ocs, "failed to get trunk info\n");
    } else {
        ocs_log_debug(ocs, "Trunk info obtained successfully\n");
    }
    return rc;
}

int
ocs_set_loopback_mode(ocs_t *ocs, uint32_t loopback_mode)
{
    int rc = 0;

    if (loopback_mode == INTERNAL_LOOPBACK) {
        ocs_log_debug(ocs, "Setting port to internal loopback mode\n");
    } else if (loopback_mode == EXTERNAL_LOOPBACK) {
        ocs_log_debug(ocs, "Setting port to external loopback mode\n");
    } else {
        ocs_log_debug(ocs, "Unsupported loopback mode: %d\n", loopback_mode);
        rc = -1;
        goto exit_set_loopback_mode;
    }

    ocs->external_loopback = 1;
    rc = ocs_hal_set_loopback_mode(&ocs->hal, loopback_mode);
    if (rc) {
        ocs_log_err(ocs, "failed to set loopback mode\n");
    } else {
        ocs_log_debug(ocs, "Loopback mode been set successfully\n");
    }

exit_set_loopback_mode:
    return rc;
}

int
ocs_run_link_loopback(ocs_t *ocs, void *user_tx_buf, uint32_t user_tx_buflen, void *user_rx_buf, uint32_t rx_buf_len)
{
    ocs_node_t *node = NULL;
    int rc = 0;
    void *tx_buf = NULL;
    void *rx_buf = NULL;
    ocs_io_t *els = NULL;

    if ((user_tx_buflen == 0) || (rx_buf_len == 0) || (user_tx_buflen != rx_buf_len)) {
        ocs_log_test(ocs, "Error: loopback tx/rx buffer length is invalid\n");
        rc = -1;
        goto free_and_return;
    }

    if (!user_tx_buf || !user_rx_buf) {
        ocs_log_test(ocs, "Error: loopback either tx data or rx buffer not provided\n");
        rc = -1;
        goto free_and_return;
    }

    tx_buf = ocs_malloc(ocs, user_tx_buflen , OCS_M_ZERO | OCS_M_NOWAIT);
    if (tx_buf == NULL) {
        ocs_log_err(ocs, "Failed to allocate buffer for TX frame\n");
        rc = -1;
        goto free_and_return;
    }

    rx_buf = ocs_malloc(ocs, rx_buf_len , OCS_M_ZERO | OCS_M_NOWAIT);
    if (rx_buf == NULL) {
        ocs_log_err(ocs, "Failed to allocate buffer for TX frame\n");
        rc = -1;
        goto free_and_return;
    }

    if (ocs_copy_from_user(tx_buf, user_tx_buf, user_tx_buflen)) {
        ocs_log_err(ocs, "Failed to copy user data into TX buf\n");
        rc = -1;
        goto free_and_return;
    }

    if (ocs->domain) {
        node = ocs_node_find(ocs->domain->sport, 1);
    }

    if (node == NULL) {
        ocs_log_err(ocs, "Failed to find node for loopback test\n");
        rc = -1;
        goto free_and_return;
    }

    els = ocs_ns_send_loopback_frame(node, tx_buf, user_tx_buflen, rx_buf, rx_buf_len, LOOPBACK_FRAME_TIMEOUT_SEC, 0, NULL, NULL);
    if (els == NULL) {
        ocs_log_err(ocs, "loopback els IO submission failed\n");
        rc = -1;
        goto free_and_return;
    }

    if (ocs_sem_p(&els->loopback_evt_data.wait_io_sem, (LOOPBACK_FRAME_TIMEOUT_SEC + 1) * 1000 * 1000) != 0) {
        ocs_log_err(ocs, "sem failed. loopback frame not received\n");
        els->loopback_evt_data.loopback_rx_data = NULL;
        rc = -1;
        goto free_and_return;
    }

    if (ocs_copy_to_user(user_rx_buf, rx_buf, rx_buf_len)) {
        ocs_log_err(ocs, "Failed to copy RX data into user buf\n");
        rc = -1;
        goto free_and_return;
    }

free_and_return:
    ocs->external_loopback = 0;
    if (tx_buf) {
        ocs_free(ocs, tx_buf, user_tx_buflen);
    }
    if (rx_buf) {
        ocs_free(ocs, rx_buf, rx_buf_len);
    }
    if (els) {
        ocs_ref_put(&els->ref);
    }
    return rc;
}

int
ocs_run_pci_loopback(ocs_t *ocs, void *user_tx_buf, uint32_t user_tx_buflen,
             void *user_rx_buf, uint32_t user_rx_buf_len)
{
    int rc = 0;
    void *tx_buf = NULL;
    void *rx_buf = NULL;

    if ((user_tx_buflen == 0) || (user_rx_buf_len == 0) ||
        (user_tx_buflen != user_rx_buf_len)) {
        ocs_log_test(ocs, "Error: loopback tx/rx buffer length is invalid\n");
        rc = -1;
        goto free_and_return;
    }

    if (!user_tx_buf || !user_rx_buf) {
        ocs_log_test(ocs, "Error: loopback either tx data or rx buffer not provided\n");
        rc = -1;
        goto free_and_return;
    }

    tx_buf = ocs_malloc(ocs, user_tx_buflen , OCS_M_ZERO | OCS_M_NOWAIT);
    if (tx_buf == NULL) {
        ocs_log_err(ocs, "Failed to allocate buffer for TX frame\n");
        rc = -1;
        goto free_and_return;
    }

    rx_buf = ocs_malloc(ocs, user_rx_buf_len , OCS_M_ZERO | OCS_M_NOWAIT);
    if (rx_buf == NULL) {
        ocs_log_err(ocs, "Failed to allocate buffer for TX frame\n");
        rc = -1;
        goto free_and_return;
    }

    if (ocs_copy_from_user(tx_buf, user_tx_buf, user_tx_buflen)) {
        ocs_log_err(ocs, "Failed to copy user data into TX buf\n");
        rc = -1;
        goto free_and_return;
    }

    rc = ocs_hal_run_biu_diag(&ocs->hal, tx_buf, user_tx_buflen,
                 rx_buf, user_rx_buf_len);
    if (rc) {
        ocs_log_err(ocs, "BIU DIAG MBOX command is failed\n");
        goto free_and_return;
    }
    
    if (ocs_copy_to_user(user_rx_buf, rx_buf, user_rx_buf_len)) {
        ocs_log_err(ocs, "Failed to copy RX data into user buf\n");
        rc = -1;
        goto free_and_return;
    }

free_and_return:
    if (tx_buf) {
        ocs_free(ocs, tx_buf, user_tx_buflen);
    }
    if (rx_buf) {
        ocs_free(ocs, rx_buf, user_rx_buf_len);
    }
    return rc;
}

int
ocs_ras_collect_diag_logs(ocs_t *ocs, void *user_tx_buf, uint32_t user_tx_buflen, void *user_rx_buf, uint32_t rx_buf_len)
{
    int rc = 0;
    void *rx_buf = NULL;
    int32_t buf_len;

    if (!rx_buf_len || !user_rx_buf) {
        ocs_log_err(ocs, "Error: tx/rx buffer is invalid\n");
        return -EINVAL;
    }

    buf_len = rx_buf_len;

    rx_buf = ocs_vmalloc(ocs, buf_len, OCS_M_ZERO);
    if (rx_buf == NULL) {
        ocs_log_err(ocs, "unable to allocate memory\n");
        return -ENOMEM;
    }

    buf_len = ocs_ras_copy_logs(ocs, rx_buf + sizeof(uint32_t), buf_len - sizeof(uint32_t));
    *((uint32_t *)rx_buf) = buf_len;
    if (buf_len > 0) {
        if (ocs_copy_to_user(user_rx_buf, rx_buf, buf_len + sizeof(uint32_t))) {
            ocs_log_err(ocs, "Failed to copy buffer for fw diag log\n");
            rc = -EPERM;
        } else {
            rc = 0;
        }
    } else {
        rc = -EINVAL;
    }

    ocs_vfree(ocs, rx_buf, rx_buf_len);
    return rc;
}