ql_xioctl.c revision 4f8b8adc54496e548e2d73094de038a131d9cd45
/*
* 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
* 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 2009 QLogic Corporation */
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "Copyright 2009 QLogic Corporation; ql_xioctl.c"
/*
* ISP2xxx Solaris Fibre Channel Adapter (FCA) driver source file.
*
* ***********************************************************************
* * **
* * NOTICE **
* * COPYRIGHT (C) 1996-2009 QLOGIC CORPORATION **
* * ALL RIGHTS RESERVED **
* * **
* ***********************************************************************
*
*/
#include <ql_apps.h>
#include <ql_api.h>
#include <ql_debug.h>
#include <ql_init.h>
#include <ql_iocb.h>
#include <ql_ioctl.h>
#include <ql_mbx.h>
#include <ql_xioctl.h>
/*
* Local data
*/
/*
* Local prototypes
*/
static int ql_sdm_ioctl(ql_adapter_state_t *, int, void *, int);
uint8_t);
static int ql_24xx_flash_desc(ql_adapter_state_t *);
static int ql_setup_flash(ql_adapter_state_t *);
uint32_t, int);
uint8_t);
static int ql_dump_sfp(ql_adapter_state_t *, void *, int);
static void ql_flash_nvram_defaults(ql_adapter_state_t *);
static void ql_restart_hba(ql_adapter_state_t *);
static void ql_update_flash_caches(ql_adapter_state_t *);
/* ******************************************************************** */
/* External IOCTL support. */
/* ******************************************************************** */
/*
* ql_alloc_xioctl_resource
* Allocates resources needed by module code.
*
* Input:
* ha: adapter state pointer.
*
* Returns:
* SYS_ERRNO
*
* Context:
* Kernel context.
*/
int
{
return (0);
}
return (ENOMEM);
}
/* Allocate AEN tracking buffer */
sizeof (EXT_ASYNC_EVENT), KM_SLEEP);
return (ENOMEM);
}
return (0);
}
/*
* ql_free_xioctl_resource
* Frees resources used by module code.
*
* Input:
* ha: adapter state pointer.
*
* Context:
* Kernel context.
*/
void
{
return;
}
sizeof (EXT_ASYNC_EVENT));
}
}
/*
* ql_xioctl
* External IOCTL processing.
*
* Input:
* ha: adapter state pointer.
* cmd: function to perform
* arg: data type varies with request
* mode: flags
* cred_p: credentials pointer
* rval_p: pointer to result value
*
* Returns:
* 0: success
* ENXIO: No such device or address
* ENOPROTOOPT: Protocol not available
*
* Context:
* Kernel context.
*/
/* ARGSUSED */
int
{
int rval;
return (ENXIO);
}
switch (cmd) {
case EXT_CC_QUERY:
case EXT_CC_REG_AEN:
case EXT_CC_GET_AEN:
case EXT_CC_WWPN_TO_SCSIADDR:
case EXT_CC_SEND_ELS_RNID:
case EXT_CC_SET_DATA:
case EXT_CC_GET_DATA:
case EXT_CC_HOST_IDX:
case EXT_CC_READ_NVRAM:
case EXT_CC_UPDATE_NVRAM:
case EXT_CC_READ_OPTION_ROM:
case EXT_CC_UPDATE_OPTION_ROM:
case EXT_CC_GET_VPD:
case EXT_CC_SET_VPD:
case EXT_CC_LOOPBACK:
case EXT_CC_GET_FCACHE:
case EXT_CC_GET_FCACHE_EX:
case EXT_CC_HOST_DRVNAME:
case EXT_CC_GET_SFP_DATA:
case EXT_CC_PORT_PARAM:
case EXT_CC_GET_PCI_DATA:
case EXT_CC_GET_FWEXTTRACE:
case EXT_CC_GET_FWFCETRACE:
case EXT_CC_GET_VP_CNT_ID:
case EXT_CC_VPORT_CMD:
case EXT_CC_ACCESS_FLASH:
case EXT_CC_RESET_FW:
break;
default:
/* function not supported. */
rval = ENOPROTOOPT;
}
return (rval);
}
/*
* ql_sdm_ioctl
* AKA External Ioctl functions.
*
* Input:
* ha: adapter state pointer.
* ioctl_code: ioctl function to perform
* arg: Pointer to EXT_IOCTL cmd data in application land.
* mode: flags
*
* Returns:
* 0: success
* ENOMEM: Alloc of local EXT_IOCTL struct failed.
* EFAULT: Copyin of caller's EXT_IOCTL struct failed or
* copyout of EXT_IOCTL status info failed.
* EINVAL: Signature or version of caller's EXT_IOCTL invalid.
* EBUSY: Device busy
*
* Context:
* Kernel context.
*/
static int
{
int rval;
/* Copy argument structure (EXT_IOCTL) from application land. */
ql_validate_signature)) != 0) {
/*
* a non-zero value at this time means a problem getting
* the requested information from application land, just
* return the error code and hope for the best.
*/
return (rval);
}
/*
* Map the physical ha ptr (which the ioctl is called with)
* to the virtual ha that the caller is addressing.
*/
/*
* Special case: HbaSelect == 0 is physical ha
*/
break;
}
}
/*
* If we can't find the specified vp index then
* we probably have an error (vp indexes shifting
* under our feet?).
*/
cmd->ResponseLen = 0;
return (EFAULT);
}
}
}
/*
* If driver is suspended, stalled, or powered down rtn BUSY
*/
"driver suspended" :
"FCA powered down"));
cmd->ResponseLen = 0;
/* Return results to caller */
}
return (rval);
}
switch (ioctl_code) {
case EXT_CC_QUERY_OS:
break;
break;
case EXT_CC_REG_AEN_OS:
break;
case EXT_CC_GET_AEN_OS:
break;
case EXT_CC_GET_DATA_OS:
break;
case EXT_CC_SET_DATA_OS:
break;
case EXT_CC_SEND_ELS_RNID_OS:
break;
case EXT_CC_SCSI_PASSTHRU_OS:
break;
break;
case EXT_CC_HOST_IDX_OS:
break;
case EXT_CC_HOST_DRVNAME_OS:
break;
case EXT_CC_READ_NVRAM_OS:
break;
case EXT_CC_UPDATE_NVRAM_OS:
break;
break;
break;
case EXT_CC_LOOPBACK_OS:
break;
case EXT_CC_GET_VPD_OS:
break;
case EXT_CC_SET_VPD_OS:
break;
case EXT_CC_GET_FCACHE_OS:
break;
case EXT_CC_GET_FCACHE_EX_OS:
break;
case EXT_CC_GET_SFP_DATA_OS:
break;
case EXT_CC_PORT_PARAM_OS:
break;
case EXT_CC_GET_PCI_DATA_OS:
break;
case EXT_CC_GET_FWEXTTRACE_OS:
break;
case EXT_CC_GET_FWFCETRACE_OS:
break;
case EXT_CC_MENLO_RESET:
break;
break;
case EXT_CC_MENLO_UPDATE_FW:
break;
case EXT_CC_MENLO_MANAGE_INFO:
break;
case EXT_CC_GET_VP_CNT_ID_OS:
break;
case EXT_CC_VPORT_CMD_OS:
break;
case EXT_CC_ACCESS_FLASH_OS:
break;
case EXT_CC_RESET_FW_OS:
break;
default:
/* function not supported. */
cmd->ResponseLen = 0;
break;
}
/* Return results to caller */
return (EFAULT);
}
return (0);
}
/*
* ql_sdm_setup
* Make a local copy of the EXT_IOCTL struct and validate it.
*
* Input:
* ha: adapter state pointer.
* cmd_struct: Pointer to location to store local adrs of EXT_IOCTL.
* arg: Address of application EXT_IOCTL cmd data
* mode: flags
* val_sig: Pointer to a function to validate the ioctl signature.
*
* Returns:
* 0: success
* EFAULT: Copy in error of application EXT_IOCTL struct.
* EINVAL: Invalid version, signature.
* ENOMEM: Local allocation of EXT_IOCTL failed.
*
* Context:
* Kernel context.
*/
static int
{
int rval;
/* Allocate local memory for EXT_IOCTL. */
*cmd_struct = NULL;
return (ENOMEM);
}
/* Get argument structure. */
if (rval != 0) {
} else {
/*
* Check signature and the version.
* If either are not valid then neither is the
* structure so don't attempt to return any error status
* because we can't trust what caller's arg points to.
* Just return the errno.
*/
}
}
if (rval == 0) {
*cmd_struct = cmd;
cmd->DetailStatus = 0;
} else {
}
return (rval);
}
/*
* ql_validate_signature
* Validate the signature string for an external ioctl call.
*
* Input:
* sg: Pointer to EXT_IOCTL signature to validate.
*
* Returns:
* B_TRUE: Signature is valid.
* B_FALSE: Signature is NOT valid.
*
* Context:
* Kernel context.
*/
static boolean_t
{
/*
* Check signature.
*
* If signature is not valid then neither is the rest of
* the structure (e.g., can't trust it), so don't attempt
* to return any error status other than the errno.
*/
return (B_FALSE);
}
return (B_TRUE);
}
/*
* ql_sdm_return
*
* Input:
* ha: adapter state pointer.
* cmd: Pointer to kernel copy of requestor's EXT_IOCTL struct.
* ioctl_code: ioctl function to perform
* arg: EXT_IOCTL cmd data in application land.
* mode: flags
*
* Returns:
* 0: success
* EFAULT: Copy out error.
*
* Context:
* Kernel context.
*/
/* ARGSUSED */
static int
{
int rval = 0;
mode);
if (rval != 0) {
/* Some copyout operation failed */
return (EFAULT);
}
return (0);
}
/*
* ql_query
* Performs all EXT_CC_QUERY functions.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
/* case off on command subcode */
case EXT_SC_QUERY_HBA_NODE:
break;
case EXT_SC_QUERY_HBA_PORT:
break;
case EXT_SC_QUERY_DISC_PORT:
break;
case EXT_SC_QUERY_DISC_TGT:
break;
case EXT_SC_QUERY_DRIVER:
break;
case EXT_SC_QUERY_FW:
break;
case EXT_SC_QUERY_CHIP:
break;
case EXT_SC_QUERY_DISC_LUN:
default:
/* function not supported. */
break;
}
}
/*
* ql_qry_hba_node
* Performs EXT_SC_QUERY_HBA_NODE subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_HBA_NODE tmp_node = {0};
cmd->ResponseLen = 0;
return;
}
/* fill in the values */
uint16_t w;
char *tmpptr;
} else {
(uint16_t *)
} else {
((w & 0xf0) >> 4), (w & 0x0f));
}
}
}
case FWATTRIB_EF:
break;
case FWATTRIB_TP:
break;
case FWATTRIB_IP:
break;
case FWATTRIB_IPX:
break;
case FWATTRIB_FL:
break;
case FWATTRIB_FPX:
break;
default:
break;
}
}
/* FCode version. */
/*LINTED [Solaris DDI_DEV_T_ANY Lint error]*/
(int *)&len) == DDI_PROP_SUCCESS) {
if (len < EXT_DEF_MAX_STR_SIZE) {
} else {
EXT_DEF_MAX_STR_SIZE - 1);
'\0';
}
} else {
}
if (ddi_copyout((void *)&tmp_node,
sizeof (EXT_HBA_NODE), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_qry_hba_port
* Performs EXT_SC_QUERY_HBA_PORT subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_HBA_PORT tmp_port = {0};
int rval;
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
/* fill in the values */
/* For now we are initiator only driver */
} else if (DRIVER_SUSPENDED(ha)) {
} else {
}
} else {
}
/*
* fill in the portspeed values.
*
* default to not yet negotiated state
*/
if (rval != QL_SUCCESS) {
} else {
case IIDMA_RATE_1GB:
break;
case IIDMA_RATE_2GB:
break;
case IIDMA_RATE_4GB:
break;
case IIDMA_RATE_8GB:
break;
case IIDMA_RATE_10GB:
break;
default:
break;
}
}
} else {
}
}
/* Report all supported port speeds */
/*
* Correct supported speeds based on type of
* sfp that is present
*/
case 1:
/* no sfp detected */
break;
case 2:
case 4:
/* 4GB sfp */
break;
case 3:
case 5:
/* 8GB sfp */
break;
default:
break;
}
} else {
}
port_cnt = 0;
tgt_cnt = 0;
continue;
}
port_cnt++;
tgt_cnt++;
}
}
}
sizeof (EXT_HBA_PORT), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_qry_disc_port
* Performs EXT_SC_QUERY_DISC_PORT subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* cmd->Instance = Port instance in fcport chain.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_DISC_PORT tmp_port = {0};
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
continue;
}
inst++;
continue;
}
/* fill in the values */
break;
}
}
/* no matching device */
cmd->ResponseLen = 0;
return;
}
}
} else {
}
if (ddi_copyout((void *)&tmp_port,
sizeof (EXT_DISC_PORT), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_qry_disc_tgt
* Performs EXT_SC_QUERY_DISC_TGT subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* cmd->Instance = Port instance in fcport chain.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_DISC_TARGET tmp_tgt = {0};
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
/* Scan port list for requested target and fill in the values */
continue;
}
inst++;
continue;
}
/* fill in the values */
break;
}
}
/* no matching device */
cmd->ResponseLen = 0;
return;
}
}
}
} else {
}
if (ddi_copyout((void *)&tmp_tgt,
sizeof (EXT_DISC_TARGET), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_qry_fw
* Performs EXT_SC_QUERY_FW subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
if (ddi_copyout((void *)&fw_info,
cmd->ResponseLen = 0;
return;
} else {
}
}
/*
* ql_qry_chip
* Performs EXT_SC_QUERY_CHIP subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
}
if (ddi_copyout((void *)&chip,
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_qry_driver
* Performs EXT_SC_QUERY_DRIVER subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_DRIVER qd = {0};
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
sizeof (EXT_DRIVER), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_fcct
* IOCTL management server FC-CT passthrough.
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int rval;
/* Get CT argument structure. */
cmd->ResponseLen = 0;
return;
}
if (DRIVER_SUSPENDED(ha)) {
cmd->ResponseLen = 0;
return;
}
/* Login management server device. */
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
} else {
}
}
/* Allocate a DMA Memory Descriptor */
cmd->ResponseLen = 0;
return;
}
/* Determine maximum buffer size. */
} else {
}
/* Allocate command block. */
cmd->ResponseLen = 0;
return;
}
/* Get command payload data. */
cmd->ResponseLen = 0;
return;
}
/* Get DMA memory for the IOCB */
QL_DMA_RING_ALIGN) != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Copy out going payload data to IOCB DMA buffer. */
/* Sync IOCB DMA buffer. */
/*
* Setup IOCB
*/
/* Set loop ID */
/* Set ISP command timeout. */
/* Load ct cmd byte count. */
/* Load ct rsp byte count. */
/* Load MS command entry data segments. */
/* Load MS response entry data segments. */
sizeof (ql_mbx_iocb_t));
if (comp_status == CS_DATA_UNDERRUN) {
}
}
0) {
"es=%xh, ss_l=%xh, rval=%xh\n",
cmd->ResponseLen = 0;
return;
}
} else {
/* Set loop ID */
} else {
}
/* Set ISP command timeout. */
/* Set data segment counts. */
/* Response total byte count. */
/* Command total byte count. */
sizeof (ql_mbx_iocb_t));
if (comp_status == CS_DATA_UNDERRUN) {
}
}
cmd->ResponseLen = 0;
return;
}
}
/* Sync in coming DMA buffer. */
/* Copy in coming DMA data. */
/* Copy response payload from DMA buffer to application. */
if (cmd->ResponseLen != 0) {
cmd->ResponseLen);
/* Send response payload. */
if (ql_send_buffer_data(pld,
cmd->ResponseLen = 0;
}
}
}
/*
* ql_aen_reg
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int rval = 0;
if (rval == 0) {
if (reg_struct.Enable) {
} else {
/* Empty the queue. */
xp->aen_q_head = 0;
xp->aen_q_tail = 0;
}
} else {
}
}
/*
* ql_aen_get
* IOCTL management server Asynchronous Event Record Transfer.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
uint8_t i;
/* Compute the number of events that can be returned */
if (request_cnt < EXT_DEF_MAX_AEN_QUEUE) {
"Len=%xh\n", request_cnt);
cmd->ResponseLen = 0;
return;
}
/* 1st: Make a local copy of the entire queue content. */
queue_cnt = 0;
i = xp->aen_q_head;
for (; queue_cnt < EXT_DEF_MAX_AEN_QUEUE; ) {
if (tmp_q[i].AsyncEventCode != 0) {
sizeof (EXT_ASYNC_EVENT));
queue_cnt++;
}
if (i == xp->aen_q_tail) {
/* done. */
break;
}
i++;
if (i == EXT_DEF_MAX_AEN_QUEUE) {
i = 0;
}
}
/* Empty the queue. */
xp->aen_q_head = 0;
xp->aen_q_tail = 0;
/* 2nd: Now transfer the queue content to user buffer */
/* Copy the entire queue to user's buffer. */
if (queue_cnt == 0) {
cmd->ResponseLen = 0;
} else if (ddi_copyout((void *)&aen[0],
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_enqueue_aen
*
* Input:
* ha: adapter state pointer.
* event_code: async event code of the event to add to queue.
* payload: event payload for the queue.
* INTR_LOCK must be already obtained.
*
* Context:
* Interrupt or Kernel context, no mailbox commands allowed.
*/
void
{
return;
}
/* Need to change queue pointers to make room. */
/* Increment tail for adding new entry. */
xp->aen_q_tail++;
xp->aen_q_tail = 0;
}
/*
* We're overwriting the oldest entry, so need to
* update the head pointer.
*/
xp->aen_q_head++;
xp->aen_q_head = 0;
}
}
}
/* Update payload */
switch (event_code) {
case MBA_LIP_OCCURRED:
case MBA_LOOP_UP:
case MBA_LOOP_DOWN:
case MBA_LIP_F8:
case MBA_LIP_RESET:
case MBA_PORT_UPDATE:
break;
case MBA_RSCN_UPDATE:
/* al_pa */
/* area */
/* domain */
/* save in big endian */
break;
default:
/* Not supported */
break;
}
}
}
/*
* ql_scsi_passthru
* IOCTL SCSI passthrough.
*
* Input:
* ha: adapter state pointer.
* cmd: User space SCSI command pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int rval;
union _passthru {
} pt_req; /* Passthru request */
/* SCSI request struct for SCSI passthrough IOs. */
struct {
} scsi_req;
struct {
} sts;
/* Verify Sub Code and set cnt to needed request size. */
pld_size = sizeof (EXT_SCSI_PASSTHRU);
pld_size = sizeof (EXT_FC_SCSI_PASSTHRU);
} else {
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Verify the size of and copy in the passthru request structure. */
/* Return error */
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/*
* Find fc_port from SCSI PASSTHRU structure fill in the scsi_req
* request data structure.
*/
} else {
/*
* Must be FC PASSTHRU, verified above.
*/
"wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
name[7]);
"wwnn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
name[7]);
} else {
cmd->ResponseLen = 0;
return;
}
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Allocate command block. */
cmd->ResponseLen) {
cmd->ResponseLen = 0;
return;
}
/* Get DMA memory for the IOCB */
QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
} else {
cmd->ResponseLen = 0;
/* Get command payload. */
if (ql_get_buffer_data(
return;
}
/* Copy out going data to DMA buffer. */
/* Sync DMA buffer. */
}
} else {
cmd->ResponseLen = 0;
pkt_size = sizeof (ql_mbx_iocb_t);
return;
}
pld_size = 0;
}
/* retries = ha->port_down_retry_count; */
retries = 1;
do {
if (DRIVER_SUSPENDED(ha)) {
break;
}
/* Set LUN number */
/* Set N_port handle */
/* Set VP Index */
/* Set target ID */
/* Set ISP command timeout. */
/* Load SCSI CDB */
+ cnt, 4);
}
/* Set tag queue control flags */
if (pld_size) {
/* Set transfer direction. */
/* Set data segment count. */
/* Load total byte count. */
/* Load data descriptor. */
}
} else {
}
}
if (pld_size) {
}
} else {
} else {
}
}
if (pld_size) {
}
}
/* Go issue command and wait for completion. */
if (pld_size) {
/* Sync in coming DMA buffer. */
/* Copy in coming DMA data. */
}
} else {
}
}
/*
* We have verified about all the request that can be so far.
* Now we need to start verification of our ability to
* actually issue the CDB.
*/
if (DRIVER_SUSPENDED(ha)) {
break;
} else if (status == QL_SUCCESS &&
LFF_NO_PLOGI, &mr);
if (rval != QL_SUCCESS) {
}
} else {
LLF_NONE);
if (rval != QL_SUCCESS) {
}
}
} else {
break;
}
} while (retries--);
/* Cannot issue command now, maybe later */
cmd->ResponseLen = 0;
return;
}
if (status != QL_SUCCESS) {
/* Command error */
cmd->ResponseLen = 0;
return;
}
/* Setup status. */
/* Setup residuals. */
/* Setup state flags. */
} else {
}
}
/* Setup FCP response info. */
}
/* Setup sense data. */
} else {
sts.req_sense_length = 0;
}
}
} else {
/* Setup residuals. */
/* Setup state flags. */
/* Setup FCP response info. */
/* Setup sense data. */
}
switch (sts.comp_status) {
case CS_INCOMPLETE:
case CS_ABORTED:
case CS_DEVICE_UNAVAILABLE:
case CS_PORT_UNAVAILABLE:
case CS_PORT_LOGGED_OUT:
case CS_PORT_CONFIG_CHG:
case CS_PORT_BUSY:
case CS_LOOP_DOWN_ABORT:
break;
case CS_RESET:
case CS_QUEUE_FULL:
break;
case CS_TIMEOUT:
break;
case CS_DATA_OVERRUN:
break;
case CS_DATA_UNDERRUN:
break;
}
/*
* If non data transfer commands fix tranfer counts.
*/
/*
* Non data transfer command, clear sts_entry residual
* length.
*/
sts.residual_length = 0;
cmd->ResponseLen = 0;
}
} else {
}
/* Correct ISP completion status */
} else {
cmd->ResponseLen = 0;
}
} else {
/*
* Handle residual count on SCSI check
* condition.
*
* - If Residual Under / Over is set, use the
* Residual Transfer Length field in IOCB.
* - If Residual Under / Over is not set, and
* Transferred Data bit is set in State Flags
* field of IOCB, report residual value of 0
* (you may want to do this for tape
* Write-type commands only). This takes care
* of logical end of tape problem and does
* not break Unit Attention.
* - If Residual Under / Over is not set, and
* Transferred Data bit is not set in State
* Flags, report residual value equal to
* original data transfer length.
*/
if (sts.scsi_status_h &
(FCP_RESID_OVER | FCP_RESID_UNDER)) {
} else if (sts.state_flags_h &
}
}
}
/*
* Check condition with vaild sense data flag set and sense
* length != 0
*/
} else {
}
}
}
/* Copy response payload from DMA buffer to application. */
cmd->ResponseLen != 0) {
/* Send response payload. */
if (ql_send_buffer_data(pld,
cmd->ResponseLen = 0;
}
}
} else {
/*EMPTY*/
}
}
/*
* ql_wwpn_to_scsiaddr
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Context:
* Kernel context.
*/
static void
{
int status;
/* Return error */
return;
}
if (status != 0) {
return;
}
/* no matching device */
return;
}
/* Copy out the IDs found. For now we can only return target ID. */
if (status != 0) {
} else {
}
}
/*
* ql_host_idx
* Gets host order index.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_host_drvname
* Gets host driver name
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen = 0;
return;
}
if (ddi_copyout((void *)&drvname,
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_read_nvram
* Get NVRAM contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
sizeof (nvram_24xx_t) : sizeof (nvram_t));
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
/* Get NVRAM data. */
mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_write_nvram
* Loads NVRAM contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
sizeof (nvram_24xx_t) : sizeof (nvram_t));
cmd->RequestLen);
return;
}
/* Load NVRAM data. */
mode) != 0) {
} else {
/*EMPTY*/
}
}
/*
* ql_write_vpd
* Loads VPD contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
return;
}
cmd->RequestLen);
return;
}
/* Load VPD data. */
mode)) != 0) {
} else {
/*EMPTY*/
}
}
/*
* ql_read_vpd
* Dumps VPD contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
return;
}
cmd->ResponseLen);
return;
}
/* Dump VPD data. */
mode)) != 0) {
} else {
/*EMPTY*/
}
}
/*
* ql_get_fcache
* Dumps flash cache contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
CACHE_LOCK(ha);
return;
}
bsize = 100;
} else {
bsize = 400;
}
return;
}
boff = 0;
bsize = 0;
/*
* For backwards compatibility, get one of each image type
*/
/* Get the next image */
cmd->DetailStatus = 0;
return;
}
boff += 100;
}
}
/*
* Get the firmware image -- it needs to be last in the
* buffer at offset 300 for backwards compatibility. Also for
* backwards compatibility, the pci header is stripped off.
*/
cmd->DetailStatus = 0;
return;
}
cmd->DetailStatus = 0;
return;
}
bsize += 100;
}
}
/*
* ql_get_fcache_ex
* Dumps flash cache contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
CACHE_LOCK(ha);
return;
}
/* Make sure user passed enough buffer space */
}
if (cmd->ResponseLen != 0) {
}
return;
}
boff = 0;
/* Get the next image */
mode) != 0) {
cmd->DetailStatus = 0;
return;
}
}
}
/*
* ql_read_flash
* Get flash contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
} else {
/* adjust read size to flash size */
}
/* Get flash data. */
if (ql_flash_fcode_dump(ha,
cmd->ResponseLen = 0;
}
}
/* Resume I/O */
} else {
}
}
/*
* ql_write_flash
* Loads flash contents.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
} else {
/* Load flash data. */
} else if (ql_flash_fcode_load(ha,
}
}
/* Resume I/O */
} else {
}
}
/*
* ql_diagnostic_loopback
* Performs EXT_CC_LOOPBACK Command
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
/* Get loop back request. */
cmd->ResponseLen = 0;
return;
}
/* Check transfer length fits in buffer. */
cmd->ResponseLen = 0;
return;
}
/* Allocate command memory. */
cmd->ResponseLen = 0;
return;
}
/* Get loopback data. */
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Shutdown IP. */
(void) ql_shutdown_ip(ha);
}
/* determine topology so we can send the loopback or the echo */
/* Echo is supported on 2300's only and above */
} else {
}
/* Restart IP if it was shutdown. */
(void) ql_initialize_ip(ha);
}
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Return loopback data. */
cmd->ResponseLen = 0;
return;
}
/* Return loopback results. */
plbrsp.CrcErrorCount = 0;
} else {
}
sizeof (EXT_LOOPBACK_RSP), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
return;
}
}
/*
* ql_send_els_rnid
* IOCTL for extended link service RNID command.
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int rval = 0;
if (DRIVER_SUSPENDED(ha)) {
cmd->ResponseLen = 0;
return;
}
/* parameter error */
cmd->RequestLen);
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Find loop ID of the device */
EXT_DEF_WWN_NAME_SIZE) == 0) {
local_hba = 1;
} else {
}
EXT_DEF_WWN_NAME_SIZE) == 0) {
local_hba = 1;
} else {
}
/*
* Copy caller's d_id to tmp space.
*/
EXT_DEF_PORTID_SIZE_ACTUAL) == 0) {
local_hba = 1;
} else {
QLNT_PID);
}
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
if (local_hba) {
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Save gotten RNID data. */
/* Now build the Send RNID response */
tmp_buf[0] = (char)(EXT_DEF_RNID_DFORMAT_TOPO_DISC);
tmp_buf[2] = 0;
} else {
}
sizeof (EXT_RNID_DATA));
} else {
/* no matching device */
cmd->ResponseLen = 0;
return;
}
/* Send command */
if (rval != QL_SUCCESS) {
while (LOOP_NOT_READY(ha)) {
if (loop_ready_wait-- == 0) {
cmd->ResponseLen = 0;
}
}
tmp_buf);
if (rval != QL_SUCCESS) {
/* error */
cmd->ResponseLen = 0;
return;
}
}
}
/* Copy the response */
} else {
if (copy_len < SEND_RNID_RSP_SIZE) {
} else {
}
}
}
/*
* ql_set_host_data
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
/*
* case off on command subcode
*/
case EXT_SC_SET_RNID:
break;
case EXT_SC_RST_STATISTICS:
break;
case EXT_SC_SET_BEACON_STATE:
break;
case EXT_SC_SET_PARMS:
case EXT_SC_SET_BUS_MODE:
case EXT_SC_SET_DR_DUMP_BUF:
case EXT_SC_SET_RISC_CODE:
case EXT_SC_SET_FLASH_RAM:
case EXT_SC_SET_LUN_BITMASK:
case EXT_SC_SET_RETRY_CNT:
case EXT_SC_SET_RTIN:
case EXT_SC_ADD_TARGET_DEVICE:
case EXT_SC_SET_SEL_TIMEOUT:
default:
/* function not supported. */
break;
}
} else {
/*EMPTY*/
}
}
/*
* ql_get_host_data
* Performs EXT_CC_GET_DATA subcommands.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int out_size = 0;
/* case off on command subcode */
case EXT_SC_GET_STATISTICS:
out_size = sizeof (EXT_HBA_PORT_STAT);
break;
case EXT_SC_GET_FC_STATISTICS:
out_size = sizeof (EXT_HBA_PORT_STAT);
break;
case EXT_SC_GET_PORT_SUMMARY:
out_size = sizeof (EXT_DEVICEDATA);
break;
case EXT_SC_GET_RNID:
out_size = sizeof (EXT_RNID_DATA);
break;
case EXT_SC_GET_TARGET_ID:
out_size = sizeof (EXT_DEST_ADDR);
break;
case EXT_SC_GET_BEACON_STATE:
out_size = sizeof (EXT_BEACON_CONTROL);
break;
out_size = sizeof (EXT_HBA_FC4STATISTICS);
break;
case EXT_SC_GET_DCBX_PARAM:
break;
case EXT_SC_GET_SCSI_ADDR:
case EXT_SC_GET_BUS_MODE:
case EXT_SC_GET_DR_DUMP_BUF:
case EXT_SC_GET_RISC_CODE:
case EXT_SC_GET_FLASH_RAM:
case EXT_SC_GET_LINK_STATUS:
case EXT_SC_GET_LOOP_ID:
case EXT_SC_GET_LUN_BITMASK:
case EXT_SC_GET_PORT_DATABASE:
case EXT_SC_GET_POSITION_MAP:
case EXT_SC_GET_RETRY_CNT:
case EXT_SC_GET_RTIN:
case EXT_SC_GET_SEL_TIMEOUT:
default:
/* function not supported. */
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
case EXT_SC_GET_RNID:
break;
case EXT_SC_GET_STATISTICS:
break;
case EXT_SC_GET_FC_STATISTICS:
break;
break;
case EXT_SC_GET_PORT_SUMMARY:
break;
case EXT_SC_GET_TARGET_ID:
break;
case EXT_SC_GET_BEACON_STATE:
break;
case EXT_SC_GET_DCBX_PARAM:
break;
}
} else {
/*EMPTY*/
}
}
/* ******************************************************************** */
/* Helper Functions */
/* ******************************************************************** */
/*
* ql_lun_count
* Get numbers of LUNS on target.
*
* Input:
* ha: adapter state pointer.
* q: device queue pointer.
*
* Returns:
* Number of LUNs.
*
* Context:
* Kernel context.
*/
static int
{
int cnt;
/* Bypass LUNs that failed. */
if (cnt == 0) {
}
return (cnt);
}
/*
* ql_report_lun
* Get numbers of LUNS using report LUN command.
*
* Input:
* ha: adapter state pointer.
* q: target queue pointer.
*
* Returns:
* Number of LUNs.
*
* Context:
* Kernel context.
*/
static int
{
int rval;
if (DRIVER_SUSPENDED(ha)) {
return (0);
}
return (0);
}
/* Get DMA memory for the IOCB */
return (0);
}
/* Set N_port handle */
/* Set target ID */
/* Set ISP command timeout. */
/* Load SCSI CDB */
+ cnt, 4);
}
/* Set tag queue control flags */
/* Set transfer direction. */
/* Set data segment count. */
/* Load total byte count. */
/* Load data descriptor. */
LE_32(sizeof (ql_rpt_lun_lst_t));
LE_32(sizeof (ql_rpt_lun_lst_t));
} else {
}
LE_32(sizeof (ql_rpt_lun_lst_t));
LE_32(sizeof (ql_rpt_lun_lst_t));
} else {
} else {
}
LE_32(sizeof (ql_rpt_lun_lst_t));
LE_32(sizeof (ql_rpt_lun_lst_t));
}
sizeof (ql_mbx_iocb_t));
/* Sync in coming DMA buffer. */
/* Copy in coming DMA data. */
} else {
}
}
/* Device underrun, treat as OK. */
if (rval == QL_SUCCESS &&
comp_status == CS_DATA_UNDERRUN &&
break;
}
if (rval == QL_SUCCESS) {
if ((comp_status == CS_TIMEOUT) ||
(comp_status == CS_PORT_UNAVAILABLE) ||
(comp_status == CS_PORT_LOGGED_OUT)) {
break;
}
} else if (rval == QL_ABORTED) {
break;
}
if (scsi_status_l & STATUS_CHECK) {
"%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh"
"%3xh%3xh%3xh%3xh%3xh%3xh%3xh\n", reqs[0],
reqs[17]);
}
} else {
break;
}
}
if (rval != QL_SUCCESS) {
rval = 0;
} else {
}
return (rval);
}
/*
* ql_inq_scan
* Get numbers of LUNS using inquiry command.
*
* Input:
* ha: adapter state pointer.
* tq: target queue pointer.
* count: scan for the number of existing LUNs.
*
* Returns:
* Number of LUNs.
*
* Context:
* Kernel context.
*/
static int
{
return (0);
}
cnt = 0;
if (DRIVER_SUSPENDED(ha)) {
rval = QL_LOOP_DOWN;
cnt = 0;
break;
}
if (rval == QL_SUCCESS) {
switch (*inq) {
case DTYPE_DIRECT:
case DTYPE_PROCESSOR: /* Appliance. */
case DTYPE_WORM:
case DTYPE_RODIRECT:
case DTYPE_SCANNER:
case DTYPE_OPTICAL:
case DTYPE_CHANGER:
case DTYPE_ESI:
cnt++;
break;
case DTYPE_SEQUENTIAL:
cnt++;
break;
default:
"unsupported device id=%xh, lun=%d, "
break;
}
break;
}
cnt = 0;
break;
}
}
return (cnt);
}
/*
* ql_inq
* Issue inquiry command.
*
* Input:
* ha: adapter state pointer.
* tq: target queue pointer.
* lun: LUN number.
* pkt: command and buffer pointer.
* inq_len: amount of inquiry data.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
static int
{
if (DRIVER_SUSPENDED(ha)) {
return (QL_FUNCTION_TIMEOUT);
}
/* Get DMA memory for the IOCB */
return (0);
}
/* Set LUN number */
/* Set N_port handle */
/* Set target ID */
/* Set ISP command timeout. */
/* Load SCSI CDB */
+ cnt, 4);
}
/* Set tag queue control flags */
/* Set transfer direction. */
/* Set data segment count. */
/* Load total byte count. */
/* Load data descriptor. */
} else {
}
} else {
} else {
}
}
/* rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size); */
sizeof (ql_mbx_iocb_t));
/* Sync in coming IOCB DMA buffer. */
/* Copy in coming DMA data. */
} else {
}
}
if (rval == QL_SUCCESS) {
if ((comp_status == CS_TIMEOUT) ||
(comp_status == CS_PORT_UNAVAILABLE) ||
(comp_status == CS_PORT_LOGGED_OUT)) {
break;
}
}
if (scsi_status_l & STATUS_CHECK) {
"%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh"
"%3xh%3xh%3xh%3xh%3xh%3xh%3xh\n", reqs[0],
reqs[17]);
}
} else {
break;
}
}
return (rval);
}
/*
* ql_get_buffer_data
* Copies data from user space to kernal buffer.
*
* Input:
* src: User source buffer address.
* dst: Kernal destination buffer address.
* size: Amount of data.
* mode: flags.
*
* Returns:
* Returns number of bytes transferred.
*
* Context:
* Kernel context.
*/
static uint32_t
{
break;
}
}
return (cnt);
}
/*
* ql_send_buffer_data
* Copies data from kernal buffer to user space.
*
* Input:
* src: Kernal source buffer address.
* dst: User destination buffer address.
* size: Amount of data.
* mode: flags.
*
* Returns:
* Returns number of bytes transferred.
*
* Context:
* Kernel context.
*/
static uint32_t
{
break;
}
}
return (cnt);
}
/*
* ql_find_port
* Locates device queue.
*
* Input:
* ha: adapter state pointer.
* name: device port name.
*
* Returns:
* Returns target queue pointer.
*
* Context:
* Kernel context.
*/
static ql_tgt_t *
{
/* Scan port list for requested target */
switch (type) {
case QLNT_LOOP_ID:
sizeof (uint16_t)) == 0) {
return (tq);
}
break;
case QLNT_PORT:
return (tq);
}
break;
case QLNT_NODE:
return (tq);
}
break;
case QLNT_PID:
return (tq);
}
break;
default:
return (NULL);
}
}
}
return (NULL);
}
/*
* ql_24xx_flash_desc
* Get flash descriptor table.
*
* Input:
* ha: adapter state pointer.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
static int
{
int rval;
if (ha->flash_desc_addr == 0) {
return (QL_FUNCTION_FAILED);
}
return (QL_MEMORY_ALLOC_FAILED);
}
if (rval != QL_SUCCESS) {
return (rval);
}
chksum = 0;
}
/* flash size in desc table is in 1024 bytes */
return (QL_FUNCTION_FAILED);
}
return (QL_SUCCESS);
}
/*
* ql_setup_flash
* Gets the manufacturer and id number of the flash chip, and
* sets up the size parameter.
*
* Input:
* ha: adapter state pointer.
*
* Returns:
* int: ql local function return status code.
*
* Context:
* Kernel context.
*/
static int
{
int rval = QL_SUCCESS;
return (rval);
}
return (QL_FUNCTION_FAILED);
}
/*
* Temporarily set the ha->xioctl->fdesc.flash_size to
* 25xx flash size to avoid failing of ql_dump_focde.
*/
0x200000 : 0x400000;
return (rval);
}
(void) ql_24xx_flash_id(ha);
(void) ql_24xx_flash_id(ha);
} else {
} else {
}
}
/* Default flash descriptor table. */
case AMD_FLASH:
case SPAN_FLASHID_2048K:
break;
case AMD_FLASHID_1024K:
break;
case AMD_FLASHID_512K:
case AMD_FLASHID_512Kt:
case AMD_FLASHID_512Kb:
} else {
}
break;
case AMD_FLASHID_128K:
break;
default:
break;
}
break;
case ST_FLASH:
case ST_FLASHID_128K:
break;
case ST_FLASHID_512K:
break;
case ST_FLASHID_M25PXX:
} else {
}
break;
default:
break;
}
break;
case SST_FLASH:
case SST_FLASHID_128K:
break;
case SST_FLASHID_1024K_A:
break;
case SST_FLASHID_1024K:
case SST_FLASHID_1024K_B:
break;
case SST_FLASHID_2048K:
break;
default:
break;
}
break;
case MXIC_FLASH:
case MXIC_FLASHID_512K:
break;
case MXIC_FLASHID_1024K:
break;
case MXIC_FLASHID_25LXX:
} else {
}
break;
default:
break;
}
break;
case ATMEL_FLASH:
case ATMEL_FLASHID_1024K:
break;
default:
break;
}
break;
case WINBOND_FLASH:
case WINBOND_FLASHID:
} else {
}
break;
default:
break;
}
break;
case INTEL_FLASH:
case INTEL_FLASHID:
} else {
}
break;
default:
break;
}
break;
default:
break;
}
/* Try flash table later. */
return (QL_SUCCESS);
}
/*
* hack for non std 2312 and 6312 boards. hardware people need to
* use either the 128k flash chip (original), or something larger.
* For driver purposes, we'll treat it as a 128k flash chip.
*/
}
if (rval == QL_SUCCESS) {
} else {
}
return (rval);
}
/*
* ql_flash_fcode_load
* Loads fcode data into flash from application.
*
* Input:
* ha: adapter state pointer.
* bp: user buffer address.
* size: user buffer size.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static int
int mode)
{
int rval = 0;
return (ENOMEM);
}
} else {
} else {
/* Reset caches on all adapter instances. */
rval = 0;
}
}
return (rval);
}
/*
* ql_load_fcode
* Loads fcode in to flash.
*
* Input:
* ha: adapter state pointer.
* dp: data pointer.
* size: data length.
* addr: flash byte address.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
int
{
int rval;
}
/*
* sbus has an additional check to make
* sure they don't brick the HBA.
*/
if (dp[0] != 0xf1) {
return (QL_FUNCTION_PARAMETER_ERROR);
}
}
/* Erase flash prior to write. */
if (rval == QL_SUCCESS) {
/* Write fcode data to flash. */
/* Allow other system activity. */
if (cnt % 0x1000 == 0) {
drv_usecwait(1);
}
if (rval != QL_SUCCESS)
break;
}
}
if (rval != QL_SUCCESS) {
} else {
/*EMPTY*/
}
return (rval);
}
/*
* ql_flash_fcode_dump
* Dumps FLASH to application.
*
* Input:
* ha: adapter state pointer.
* bp: user buffer address.
* bsize: user buffer size
* faddr: flash byte address
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static int
{
int rval;
/* adjust max read size to flash size */
}
} else {
/* Dump Flash fcode. */
if (rval != QL_SUCCESS) {
} else {
rval = 0;
}
}
return (rval);
}
/*
* ql_dump_fcode
* Dumps fcode from flash.
*
* Input:
* ha: adapter state pointer.
* dp: data pointer.
* size: data length in bytes.
* startpos: starting position in flash (byte address).
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*
*/
int
{
int rval = QL_SUCCESS;
/* make sure startpos+size doesn't exceed flash */
return (QL_FUNCTION_PARAMETER_ERROR);
}
/* check start addr is 32 bit aligned for 24xx */
if ((startpos & 0x3) != 0) {
if (rval != QL_SUCCESS) {
return (rval);
}
startpos++;
size--;
}
if (size == 0) {
return (rval);
}
}
/* adjust 24xx start addr for 32 bit words */
}
}
/* Read fcode data from flash. */
while (size) {
/* Allow other system activity. */
if (size % 0x1000 == 0) {
}
if (rval != QL_SUCCESS) {
break;
}
}
} else {
size--;
}
}
}
if (rval != QL_SUCCESS) {
} else {
/*EMPTY*/
}
return (rval);
}
/*
* ql_program_flash_address
* Program flash address.
*
* Input:
* ha: adapter state pointer.
* addr: flash byte address.
* data: data to be written to flash.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
static int
{
int rval;
/* Write Program Command Sequence */
} else {
}
/* Wait for write to complete. */
if (rval != QL_SUCCESS) {
}
return (rval);
}
/*
* ql_set_rnid_parameters
* Set RNID parameters.
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*/
static void
{
int rval = 0;
if (DRIVER_SUSPENDED(ha)) {
cmd->ResponseLen = 0;
return;
}
/* parameter error */
cmd->RequestLen);
cmd->ResponseLen = 0;
return;
}
if (rval != 0) {
cmd->ResponseLen = 0;
return;
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
if (rval != QL_SUCCESS) {
/* error */
cmd->ResponseLen = 0;
return;
}
/* Now set the requested params. */
if (rval != QL_SUCCESS) {
/* error */
cmd->ResponseLen = 0;
}
}
/*
* ql_get_rnid_parameters
* Get RNID parameters.
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*/
static void
{
if (DRIVER_SUSPENDED(ha)) {
cmd->ResponseLen = 0;
return;
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
/* Send command */
if (rval != QL_SUCCESS) {
/* error */
cmd->ResponseLen = 0;
return;
}
/* Copy the response */
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_reset_statistics
* Performs EXT_SC_RST_STATISTICS subcommand. of EXT_CC_SET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static int
{
int rval = 0;
if (DRIVER_SUSPENDED(ha)) {
cmd->ResponseLen = 0;
return (QL_FUNCTION_SUSPENDED);
}
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
}
xp->IosRequested = 0;
xp->BytesRequested = 0;
xp->IOInputRequests = 0;
xp->IOOutputRequests = 0;
xp->IOControlRequests = 0;
xp->IOInputMByteCnt = 0;
xp->IOOutputMByteCnt = 0;
xp->IOOutputByteCnt = 0;
xp->IOInputByteCnt = 0;
xp->ControllerErrorCount = 0;
xp->DeviceErrorCount = 0;
xp->TotalLipResets = 0;
xp->TotalInterrupts = 0;
return (rval);
}
/*
* ql_get_statistics
* Performs EXT_SC_GET_STATISTICS subcommand. of EXT_CC_GET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_HBA_PORT_STAT ps = {0};
int rval;
int retry = 10;
while (ha->task_daemon_flags &
retry--;
if (retry == 0) { /* effectively 100 seconds */
cmd->ResponseLen = 0;
return;
}
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
/*
* I think these are supposed to be port statistics
* the loop ID or port ID should be in cmd->Instance.
*/
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
} else {
sizeof (EXT_HBA_PORT_STAT), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
}
/*
* ql_get_statistics_fc
* Performs EXT_SC_GET_FC_STATISTICS subcommand. of EXT_CC_GET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_HBA_PORT_STAT ps = {0};
int rval;
int retry = 10;
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
while (ha->task_daemon_flags &
retry--;
if (retry == 0) { /* effectively 100 seconds */
cmd->ResponseLen = 0;
return;
}
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
} else {
sizeof (EXT_HBA_PORT_STAT), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
}
/*
* ql_get_statistics_fc4
* Performs EXT_SC_GET_FC_STATISTICS subcommand. of EXT_CC_GET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_HBA_FC4STATISTICS fc4stats = {0};
sizeof (EXT_HBA_FC4STATISTICS), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_set_led_state
* Performs EXT_SET_BEACON_STATE subcommand of EXT_CC_SET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
cmd->ResponseLen = 0;
return;
}
cmd->DetailStatus = 0;
cmd->ResponseLen = 0;
return;
}
if (rval != 0) {
return;
}
case EXT_DEF_GRN_BLINK_OFF: /* turn beacon off */
/* not quite an error -- LED state is already off */
break;
}
} else {
}
break;
case EXT_DEF_GRN_BLINK_ON: /* turn beacon on */
/* not quite an error -- LED state is already on */
break;
}
break;
}
} else {
}
break;
default:
break;
}
}
/*
* ql_get_led_state
* Performs EXT_GET_BEACON_STATE subcommand of EXT_CC_GET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_BEACON_CONTROL bstate = {0};
cmd->ResponseLen = 0;
return;
}
cmd->DetailStatus = 0;
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* inform the user of the current beacon state (off or on) */
sizeof (EXT_BEACON_CONTROL), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_blink_led
* Determine the next state of the LED and drive it
*
* Input:
* ha: adapter state pointer.
*
* Context:
* Interrupt context.
*/
void
{
/* determine the next led state */
} else {
}
/* turn the led on or off */
}
}
/*
* ql_drive_led
* drive the led's as determined by LEDflags
*
* Input:
* ha: adapter state pointer.
* LEDflags: LED flags
*
* Context:
*/
static void
{
/* setup to send new data */
/* read current data and clear out old led data */
/* set in the new led data. */
/* write out the new led data */
/* setup to send new data */
/* read current data and clear out old led data */
/* set in the new led data */
/* write out the new led data */
} else {
}
}
/*
* ql_setup_led
* Setup LED for driver control
*
* Input:
* ha: adapter state pointer.
*
* Context:
*/
static uint32_t
{
/* decouple the LED control from the fw */
if (rval != QL_SUCCESS) {
return (rval);
}
/* set the appropriate options */
/* send it back to the firmware */
if (rval != QL_SUCCESS) {
return (rval);
}
/* initally, turn the LED's off */
return (rval);
}
/*
* ql_wrapup_led
* Return LED control to the firmware
*
* Input:
* ha: adapter state pointer.
*
* Context:
*/
static uint32_t
{
/* Turn all LED's off */
/* disable the LED update mask */
/* write out the data */
}
/* give LED control back to the f/w */
if (rval != QL_SUCCESS) {
return (rval);
}
if (rval != QL_SUCCESS) {
return (rval);
}
return (rval);
}
/*
* ql_get_port_summary
* Performs EXT_SC_GET_PORT_SUMMARY subcommand. of EXT_CC_GET_DATA.
*
* The EXT_IOCTL->RequestAdr points to a single
* UINT32 which identifies the device type.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_DEVICEDATA dd = {0};
int rval = 0;
/*
* Get the type of device the requestor is looking for.
*
* We ignore this for now.
*/
if (rval != 0) {
cmd->ResponseLen = 0;
return;
}
/*
* Count the number of entries to be returned. Count devices
* that are offlline, but have been persistently bound.
*/
continue; /* Skip this one */
}
dd.TotalDevices++;
}
}
/*
* Compute the number of entries that can be returned
* based upon the size of caller's response buffer.
*/
dd.ReturnListEntryCount = 0;
if (dd.TotalDevices == 0) {
} else {
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
continue; /* Skip this one */
}
"wwnn=%02x%02x%02x%02x%02x%02x%02x%02x, "
"wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
sizeof (EXT_DEVICEDATAENTRY), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
break;
}
uddep++;
sizeof (EXT_DEVICEDATAENTRY);
}
}
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_get_target_id
* Performs EXT_SC_GET_TARGET_ID subcommand. of EXT_CC_GET_DATA.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_DEST_ADDR extdestaddr = {0};
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
if (rval != 0) {
cmd->ResponseLen = 0;
}
}
/*
* ql_setup_fcache
* Populates selected flash sections into the cache
*
* Input:
* ha = adapter state pointer.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*
* Note:
* Driver must be in stalled state prior to entering or
* add code to this function prior to calling ql_setup_flash()
*/
int
{
int rval;
CACHE_LOCK(ha);
/* If we already have populated it, rtn */
return (QL_SUCCESS);
}
return (rval);
}
while (freadpos != 0xffffffff) {
/* Allocate & populate this node */
break;
}
/* link in the new node */
} else {
}
/* Do the firmware node first for 24xx/25xx's */
if (fw_done == 0) {
}
fw_done = 1;
}
freadpos)) != QL_SUCCESS) {
break;
}
/* checkout the pci data / format */
break;
}
}
if (rval != QL_SUCCESS) {
/* release all resources we have */
}
} else {
}
return (rval);
}
/*
* ql_update_fcache
* re-populates updated flash into the fcache. If
* boot), this routine will create and the populate it.
*
* Input:
* ha = adapter state pointer.
* *bpf = Pointer to flash buffer.
* bsize = Size of flash buffer.
*
* Returns:
*
* Context:
* Kernel context.
*/
void
{
int rval = QL_SUCCESS;
while (freadpos != 0xffffffff) {
/* Allocate & populate this node */
break;
}
/* link in the new node */
} else {
}
/* Do the firmware node first for 24xx's */
if (fw_done == 0) {
}
fw_done = 1;
}
/* read in first FBUFSIZE bytes of this flash section */
break;
}
/* checkout the pci data / format */
break;
}
}
if (rval != QL_SUCCESS) {
/*
* release all resources we have
*/
} else {
/*
* Release previous fcache resources and update with new
*/
CACHE_LOCK(ha);
}
}
/*
* ql_setup_fnode
* Allocates fcache node
*
* Input:
* ha = adapter state pointer.
* node = point to allocated fcache node (NULL = failed)
*
* Returns:
*
* Context:
* Kernel context.
*
* Note:
* Driver must be in stalled state prior to entering or
* add code to this function prior to calling ql_setup_flash()
*/
static ql_fcache_t *
{
} else {
}
return (fnode);
}
/*
* ql_fcache_rel
* Releases the fcache resources
*
* Input:
* ha = adapter state pointer.
* head = Pointer to fcache linked list
*
* Returns:
*
* Context:
* Kernel context.
*
*/
void
{
/* release all resources we have */
}
}
/*
* ql_update_flash_caches
* Updates driver flash caches
*
* Input:
* ha: adapter state pointer.
*
* Context:
* Kernel context.
*/
static void
{
/* Get base path length. */
break;
}
}
/* Reset fcache on all adapter instances. */
continue;
}
}
}
(void) ql_setup_fcache(ha2);
}
}
/*
* ql_get_fbuf
* Search the fcache list for the type specified
*
* Input:
* fptr = Pointer to fcache linked list
* ftype = Type of image to be returned.
*
* Returns:
* Pointer to ql_fcache_t.
* NULL means not found.
*
* Context:
* Kernel context.
*
*
*/
{
/* does this image meet criteria? */
break;
}
}
return (fptr);
}
/*
* ql_check_pci
*
* checks the passed buffer for a valid pci signature and
* expected (and in range) pci length values.
*
* For firmware type, a pci header is added since the image in
* the flash does not have one (!!!).
*
* On successful pci check, nextpos adjusted to next pci header.
*
* Returns:
* -1 --> last pci image
* 0 --> pci header valid
* 1 --> pci header invalid.
*
* Context:
* Kernel context.
*/
static int
{
} else {
return (1);
}
return (1);
}
if (pciinfo[0] != SBUS_CODE_FCODE) {
return (1);
}
/*LINTED [Solaris DDI_DEV_T_ANY Lint error]*/
(int *)&len) == DDI_PROP_SUCCESS) {
}
*nextpos = 0xffffffff;
return (0);
}
pci_header_t fwh = {0};
pci_data_t fwd = {0};
/*
* Build a pci header for the firmware module
*/
NULL) {
return (1);
}
bufp += sizeof (pci_header_t);
bufp += sizeof (pci_data_t);
sizeof (pci_data_t)));
return (0);
}
/* get to the pci header image length */
/* some header section sanity check */
return (1);
}
/* a slight sanity data section check */
return (1);
}
8)) * PCI_SECTOR_SIZE);
}
*nextpos = 0xffffffff;
} else {
/* adjust the next flash read start position */
}
case PCI_CODE_X86PC:
break;
case PCI_CODE_FCODE:
break;
case PCI_CODE_EFI:
break;
case PCI_CODE_HPPA:
break;
default:
break;
}
return (0);
}
/*
* ql_flash_layout_table
* Obtains flash addresses from table
*
* Input:
* ha: adapter state pointer.
* flt_paddr: flash layout pointer address.
*
* Context:
* Kernel context.
*/
static void
{
int rval;
/* Process flash layout table header */
return;
}
/* Process pointer to flash layout table */
QL_SUCCESS) {
rval);
return;
}
/* Verify pointer to flash layout table. */
}
return;
}
/* Process flash layout table. */
QL_SUCCESS) {
return;
}
/* Verify flash layout table. */
sizeof (ql_flt_hdr_t));
if (len > FLASH_LAYOUT_TABLE_SIZE) {
chksum = 0xffff;
} else {
}
}
return;
}
/* Process flash layout table regions */
faddr >>= 2;
case FLASH_FW_REGION:
break;
case FLASH_GOLDEN_FW_REGION:
break;
case FLASH_VPD_0_REGION:
}
break;
case FLASH_NVRAM_0_REGION:
}
break;
case FLASH_VPD_1_REGION:
}
break;
case FLASH_NVRAM_1_REGION:
}
break;
case FLASH_DESC_TABLE_REGION:
break;
case FLASH_ERROR_LOG_0_REGION:
}
break;
case FLASH_ERROR_LOG_1_REGION:
}
break;
default:
break;
}
}
}
/*
* ql_flash_nvram_defaults
* Flash default addresses.
*
* Input:
* ha: adapter state pointer.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
static void
{
}
} else {
}
}
}
/*
* ql_get_sfp
* Returns sfp data to sdmapi caller
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
return;
}
cmd->ResponseLen);
return;
}
/* Dump SFP data in user buffer */
mode)) != 0) {
} else {
}
}
/*
* ql_dump_sfp
* Dumps SFP.
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static int
{
/* Get memory for SFP. */
QL_DMA_DATA_ALIGN)) != QL_SUCCESS) {
return (ENOMEM);
}
if (rval2 != QL_SUCCESS) {
break;
}
/* copy the data back */
/* ddi copy error */
break;
}
/* adjust the buffer pointer */
}
return (rval);
}
/*
* ql_port_param
* Retrieves or sets the firmware port speed settings
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*
*/
static void
{
EXT_PORT_PARAM port_param = {0};
cmd->ResponseLen = 0;
return;
}
if (LOOP_NOT_READY(ha)) {
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
switch (port_param.Mode) {
case EXT_IIDMA_MODE_GET:
/*
* Report the firmware's port rate for the wwpn
*/
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
} else {
switch (idma_rate) {
case IIDMA_RATE_1GB:
break;
case IIDMA_RATE_2GB:
break;
case IIDMA_RATE_4GB:
break;
case IIDMA_RATE_8GB:
break;
case IIDMA_RATE_10GB:
break;
default:
break;
}
/* Copy back the data */
sizeof (EXT_PORT_PARAM), mode);
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
sizeof (EXT_PORT_PARAM);
}
}
break;
case EXT_IIDMA_MODE_SET:
/*
* Set the firmware's port rate for the wwpn
*/
switch (port_param.Speed) {
case EXT_DEF_PORTSPEED_1GBIT:
break;
case EXT_DEF_PORTSPEED_2GBIT:
break;
case EXT_DEF_PORTSPEED_4GBIT:
break;
case EXT_DEF_PORTSPEED_8GBIT:
break;
case EXT_DEF_PORTSPEED_10GBIT:
break;
default:
cmd->ResponseLen = 0;
break;
}
if (rval == QL_SUCCESS) {
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
}
}
break;
default:
cmd->ResponseLen = 0;
cmd->DetailStatus = 0;
break;
}
}
/*
* ql_get_fwexttrace
* Dumps f/w extended trace buffer
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
/* ARGSUSED */
static void
{
int rval;
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Time Stamp */
if (rval != QL_SUCCESS) {
"time stamp failed: %xh\n", rval);
cmd->ResponseLen = 0;
return;
}
/* Disable Tracing */
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Allocate payload buffer */
cmd->ResponseLen = 0;
return;
}
/* Sync DMA buffer. */
/* Copy trace buffer data. */
/* Send payload to application. */
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_get_fwfcetrace
* Dumps f/w fibre channel event trace buffer
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
/* ARGSUSED */
static void
{
int rval;
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Disable Tracing */
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Allocate payload buffer */
cmd->ResponseLen = 0;
return;
}
/* Sync DMA buffer. */
/* Copy trace buffer data. */
/* Send payload to application. */
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_get_pci_data
* Retrieves pci config space data
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*
*/
static void
{
/*
* First check the "Capabilities List" bit of the status register.
*/
/*
* Now get the capability pointer
*/
while (cap_ptr != PCI_CAP_NEXT_PTR_NULL) {
/*
* Check for the pcie capability.
*/
if (cap_id == PCI_CAP_ID_PCI_E) {
buf_size = 4096;
break;
}
(cap_ptr + PCI_CAP_NEXT_PTR));
}
}
cmd->ResponseLen);
return;
}
/* Dump PCI config data. */
cmd->DetailStatus = 0;
} else {
}
}
/*
* ql_pci_dump
* Dumps PCI config data to application buffer.
*
* Input:
* ha = adapter state pointer.
* bp = user buffer address.
*
* Returns:
*
* Context:
* Kernel context.
*/
int
{
return (ENOMEM);
}
/* store the initial value of ptr32 */
ptr32++;
}
0) {
return (EFAULT);
}
return (0);
}
/*
* ql_menlo_reset
* Reset Menlo
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static void
{
int rval;
cmd->ResponseLen = 0;
return;
}
/*
* TODO: only vp_index 0 can do this (?)
*/
/* Verify the size of request structure. */
/* Return error */
sizeof (EXT_MENLO_RESET));
cmd->ResponseLen = 0;
return;
}
/* Get reset request. */
cmd->ResponseLen = 0;
return;
}
/* Wait for I/O to stop and daemon to stall. */
cmd->ResponseLen = 0;
return;
}
if (rval != QL_SUCCESS) {
cmd->ResponseLen = 0;
cmd->ResponseLen = 0;
}
}
/*
* ql_menlo_get_fw_version
* Get Menlo firmware version.
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static void
{
int rval;
EXT_MENLO_GET_FW_VERSION ver = {0};
cmd->ResponseLen = 0;
return;
}
sizeof (EXT_MENLO_GET_FW_VERSION));
cmd->ResponseLen = 0;
return;
}
/* Allocate packet. */
cmd->ResponseLen = 0;
return;
}
/* Command error */
cmd->ResponseLen = 0;
} else if (ddi_copyout((void *)&ver,
sizeof (EXT_MENLO_GET_FW_VERSION), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_menlo_update_fw
* Get Menlo update firmware.
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static void
{
int rval;
cmd->ResponseLen = 0;
return;
}
/*
* TODO: only vp_index 0 can do this (?)
*/
/* Verify the size of request structure. */
/* Return error */
sizeof (EXT_MENLO_UPDATE_FW));
cmd->ResponseLen = 0;
return;
}
/* Get update fw request. */
sizeof (EXT_MENLO_UPDATE_FW), mode) != 0) {
cmd->ResponseLen = 0;
return;
}
/* Wait for I/O to stop and daemon to stall. */
cmd->ResponseLen = 0;
return;
}
/* Allocate packet. */
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Get DMA memory for the IOCB */
QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
cmd->ResponseLen = 0;
return;
}
/* Get firmware data. */
cmd->ResponseLen = 0;
return;
}
/* Sync DMA buffer. */
/* Command error */
cmd->ResponseLen = 0;
}
}
/*
* ql_menlo_manage_info
* Get Menlo manage info.
*
* Input:
* ha: adapter state pointer.
* bp: buffer address.
* mode: flags
*
* Returns:
*
* Context:
* Kernel context.
*/
static void
{
int rval;
cmd->ResponseLen = 0;
return;
}
/* Verify the size of request structure. */
/* Return error */
sizeof (EXT_MENLO_MANAGE_INFO));
cmd->ResponseLen = 0;
return;
}
/* Get manage info request. */
cmd->ResponseLen = 0;
return;
}
/* Allocate packet. */
cmd->ResponseLen = 0;
return;
}
/* Get DMA memory for the IOCB */
KM_SLEEP);
cmd->ResponseLen = 0;
return;
}
cmd->ResponseLen = 0;
return;
}
/* Get data. */
if (ql_get_buffer_data(
cmd->ResponseLen = 0;
return;
}
}
}
/* Command error */
cmd->ResponseLen = 0;
cmd->ResponseLen = 0;
}
}
}
/*
* ql_suspend_hba
* Suspends all adapter ports.
*
* Input:
* ha: adapter state pointer.
* options: BIT_0 --> leave driver stalled on exit if
* failed.
*
* Returns:
* ql local function return status code.
*
* Context:
* Kernel context.
*/
static int
{
int rval = QL_SUCCESS;
/* Quiesce I/O on all adapter ports */
continue;
}
break;
}
}
return (rval);
}
/*
* ql_restart_hba
* Restarts adapter.
*
* Input:
* ha: adapter state pointer.
*
* Context:
* Kernel context.
*/
static void
{
/* Resume I/O on all adapter ports */
continue;
}
}
}
/*
* ql_get_vp_cnt_id
* Retrieves pci config space data
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*
*/
static void
{
int id = 0;
int rval;
char name[MAXPATHLEN];
/*
* To be backward compatible with older API
* check for the size of old EXT_VPORT_ID_CNT
*/
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
ptmp_vp = (EXT_VPORT_ID_CNT *)
cmd->ResponseLen = 0;
return;
}
id++;
}
if (rval != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_vp_ioctl
* Performs all EXT_CC_VPORT_CMD functions.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
/* case off on command subcode */
case EXT_VF_SC_VPORT_GETINFO:
break;
default:
/* function not supported. */
break;
}
}
/*
* ql_qry_vport
* Performs EXT_VF_SC_VPORT_GETINFO subfunction.
*
* Input:
* ha: adapter state pointer.
* cmd: EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
EXT_VPORT_INFO tmp_vport = {0};
int max_vport;
cmd->ResponseLen);
cmd->ResponseLen = 0;
return;
}
/* Fill in the vport information. */
}
}
if (ddi_copyout((void *)&tmp_vport,
sizeof (EXT_VPORT_INFO), mode) != 0) {
cmd->ResponseLen = 0;
} else {
}
}
/*
* ql_access_flash
* Performs all EXT_CC_ACCESS_FLASH_OS functions.
*
* Input:
* pi: port info pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
* mode: flags.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
int rval;
case EXT_SC_FLASH_READ:
cmd->ResponseLen = 0;
}
break;
case EXT_SC_FLASH_WRITE:
QL_SUCCESS) {
cmd->ResponseLen = 0;
} else {
/* Reset caches on all adapter instances. */
}
break;
default:
cmd->ResponseLen = 0;
break;
}
}
/*
* ql_reset_cmd
* Performs all EXT_CC_RESET_FW_OS functions.
*
* Input:
* ha: adapter state pointer.
* cmd: Local EXT_IOCTL cmd struct pointer.
*
* Returns:
* None, request status indicated in cmd->Status.
*
* Context:
* Kernel context.
*/
static void
{
case EXT_SC_RESET_FC_FW:
break;
case EXT_SC_RESET_MPI_FW:
cmd->ResponseLen = 0;
} else {
/* Wait for I/O to stop and daemon to stall. */
cmd->ResponseLen = 0;
cmd->ResponseLen = 0;
}
}
break;
default:
cmd->ResponseLen = 0;
break;
}
}
/*
* ql_get_dcbx_parameters
* Get DCBX parameters.
*
* Input:
* ha: adapter state pointer.
* cmd: User space CT arguments pointer.
* mode: flags.
*/
static void
{
int rval;
cmd->ResponseLen = 0;
}
cmd->ResponseLen = 0;
return;
}
/* Allocate memory for command. */
cmd->ResponseLen = 0;
return;
}
/* Send command */
if (rval != QL_SUCCESS) {
/* error */
cmd->ResponseLen = 0;
return;
}
/* Copy the response */
cmd->ResponseLen = 0;
} else {
}
}