0ff2378988
Sponsored by: Solarflare Communications, Inc. Approved by: gnn (mentor)
605 lines
14 KiB
C
605 lines
14 KiB
C
/*-
|
|
* Copyright 2009 Solarflare Communications Inc. 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "efsys.h"
|
|
#include "efx.h"
|
|
#include "efx_types.h"
|
|
#include "efx_regs.h"
|
|
#include "efx_impl.h"
|
|
|
|
#if EFSYS_OPT_VPD
|
|
|
|
#if EFSYS_OPT_SIENA
|
|
|
|
static __checkReturn int
|
|
siena_vpd_get_static(
|
|
__in efx_nic_t *enp,
|
|
__in unsigned int partn,
|
|
__deref_out_bcount_opt(*sizep) caddr_t *svpdp,
|
|
__out size_t *sizep)
|
|
{
|
|
siena_mc_static_config_hdr_t *scfg;
|
|
caddr_t svpd;
|
|
size_t size;
|
|
uint8_t cksum;
|
|
unsigned int vpd_offset;
|
|
unsigned int vpd_length;
|
|
unsigned int hdr_length;
|
|
unsigned int pos;
|
|
unsigned int region;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(partn == MC_CMD_NVRAM_TYPE_STATIC_CFG_PORT0 ||
|
|
partn == MC_CMD_NVRAM_TYPE_STATIC_CFG_PORT1);
|
|
|
|
/* Allocate sufficient memory for the entire static cfg area */
|
|
if ((rc = siena_nvram_partn_size(enp, partn, &size)) != 0)
|
|
goto fail1;
|
|
|
|
EFSYS_KMEM_ALLOC(enp->en_esip, size, scfg);
|
|
if (scfg == NULL) {
|
|
rc = ENOMEM;
|
|
goto fail2;
|
|
}
|
|
|
|
if ((rc = siena_nvram_partn_read(enp, partn, 0,
|
|
(caddr_t)scfg, SIENA_NVRAM_CHUNK)) != 0)
|
|
goto fail3;
|
|
|
|
/* Verify the magic number */
|
|
if (EFX_DWORD_FIELD(scfg->magic, EFX_DWORD_0) !=
|
|
SIENA_MC_STATIC_CONFIG_MAGIC) {
|
|
rc = EINVAL;
|
|
goto fail4;
|
|
}
|
|
|
|
/* All future versions of the structure must be backwards compatable */
|
|
EFX_STATIC_ASSERT(SIENA_MC_STATIC_CONFIG_VERSION == 0);
|
|
|
|
hdr_length = EFX_WORD_FIELD(scfg->length, EFX_WORD_0);
|
|
vpd_offset = EFX_DWORD_FIELD(scfg->static_vpd_offset, EFX_DWORD_0);
|
|
vpd_length = EFX_DWORD_FIELD(scfg->static_vpd_length, EFX_DWORD_0);
|
|
|
|
/* Verify the hdr doesn't overflow the sector size */
|
|
if (hdr_length > size || vpd_offset > size || vpd_length > size ||
|
|
vpd_length + vpd_offset > size) {
|
|
rc = EINVAL;
|
|
goto fail5;
|
|
}
|
|
|
|
/* Read the remainder of scfg + static vpd */
|
|
region = vpd_offset + vpd_length;
|
|
if (region > SIENA_NVRAM_CHUNK) {
|
|
if ((rc = siena_nvram_partn_read(enp, partn, SIENA_NVRAM_CHUNK,
|
|
(caddr_t)scfg + SIENA_NVRAM_CHUNK,
|
|
region - SIENA_NVRAM_CHUNK)) != 0)
|
|
goto fail6;
|
|
}
|
|
|
|
/* Verify checksum */
|
|
cksum = 0;
|
|
for (pos = 0; pos < hdr_length; pos++)
|
|
cksum += ((uint8_t *)scfg)[pos];
|
|
if (cksum != 0) {
|
|
rc = EINVAL;
|
|
goto fail7;
|
|
}
|
|
|
|
if (vpd_length == 0)
|
|
svpd = NULL;
|
|
else {
|
|
/* Copy the vpd data out */
|
|
EFSYS_KMEM_ALLOC(enp->en_esip, vpd_length, svpd);
|
|
if (svpd == NULL) {
|
|
rc = ENOMEM;
|
|
goto fail8;
|
|
}
|
|
memcpy(svpd, (caddr_t)scfg + vpd_offset, vpd_length);
|
|
}
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, size, scfg);
|
|
|
|
*svpdp = svpd;
|
|
*sizep = vpd_length;
|
|
|
|
return (0);
|
|
|
|
fail8:
|
|
EFSYS_PROBE(fail8);
|
|
fail7:
|
|
EFSYS_PROBE(fail7);
|
|
fail6:
|
|
EFSYS_PROBE(fail6);
|
|
fail5:
|
|
EFSYS_PROBE(fail5);
|
|
fail4:
|
|
EFSYS_PROBE(fail4);
|
|
fail3:
|
|
EFSYS_PROBE(fail3);
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, size, scfg);
|
|
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_init(
|
|
__in efx_nic_t *enp)
|
|
{
|
|
efx_mcdi_iface_t *emip = &(enp->en_u.siena.enu_mip);
|
|
caddr_t svpd = NULL;
|
|
unsigned partn;
|
|
size_t size = 0;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
partn = (emip->emi_port == 1)
|
|
? MC_CMD_NVRAM_TYPE_STATIC_CFG_PORT0
|
|
: MC_CMD_NVRAM_TYPE_STATIC_CFG_PORT1;
|
|
|
|
/*
|
|
* We need the static VPD sector to present a unified static+dynamic
|
|
* VPD, that is, basically on every read, write, verify cycle. Since
|
|
* it should *never* change we can just cache it here.
|
|
*/
|
|
if ((rc = siena_vpd_get_static(enp, partn, &svpd, &size)) != 0)
|
|
goto fail1;
|
|
|
|
if (svpd != NULL && size > 0) {
|
|
if ((rc = efx_vpd_hunk_verify(svpd, size, NULL)) != 0)
|
|
goto fail2;
|
|
}
|
|
|
|
enp->en_u.siena.enu_svpd = svpd;
|
|
enp->en_u.siena.enu_svpd_length = size;
|
|
|
|
return (0);
|
|
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, size, svpd);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_size(
|
|
__in efx_nic_t *enp,
|
|
__out size_t *sizep)
|
|
{
|
|
efx_mcdi_iface_t *emip = &(enp->en_u.siena.enu_mip);
|
|
unsigned int partn;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
/*
|
|
* This function returns the total size the user should allocate
|
|
* for all VPD operations. We've already cached the static vpd,
|
|
* so we just need to return an upper bound on the dynamic vpd.
|
|
* Since the dynamic_config structure can change under our feet,
|
|
* (as version numbers are inserted), just be safe and return the
|
|
* total size of the dynamic_config *sector*
|
|
*/
|
|
partn = (emip->emi_port == 1)
|
|
? MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT0
|
|
: MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT1;
|
|
|
|
if ((rc = siena_nvram_partn_size(enp, partn, sizep)) != 0)
|
|
goto fail1;
|
|
|
|
return (0);
|
|
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_read(
|
|
__in efx_nic_t *enp,
|
|
__out_bcount(size) caddr_t data,
|
|
__in size_t size)
|
|
{
|
|
efx_mcdi_iface_t *emip = &(enp->en_u.siena.enu_mip);
|
|
siena_mc_dynamic_config_hdr_t *dcfg;
|
|
unsigned int vpd_length;
|
|
unsigned int vpd_offset;
|
|
unsigned int dcfg_partn;
|
|
size_t dcfg_size;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
dcfg_partn = (emip->emi_port == 1)
|
|
? MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT0
|
|
: MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT1;
|
|
|
|
if ((rc = siena_nvram_get_dynamic_cfg(enp, dcfg_partn,
|
|
B_TRUE, &dcfg, &dcfg_size)) != 0)
|
|
goto fail1;
|
|
|
|
vpd_length = EFX_DWORD_FIELD(dcfg->dynamic_vpd_length, EFX_DWORD_0);
|
|
vpd_offset = EFX_DWORD_FIELD(dcfg->dynamic_vpd_offset, EFX_DWORD_0);
|
|
|
|
if (vpd_length > size) {
|
|
rc = EFAULT; /* Invalid dcfg: header bigger than sector */
|
|
goto fail2;
|
|
}
|
|
|
|
EFSYS_ASSERT3U(vpd_length, <=, size);
|
|
memcpy(data, (caddr_t)dcfg + vpd_offset, vpd_length);
|
|
|
|
/* Pad data with all-1s, consistent with update operations */
|
|
memset(data + vpd_length, 0xff, size - vpd_length);
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, dcfg_size, dcfg);
|
|
|
|
return (0);
|
|
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, dcfg_size, dcfg);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_verify(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size)
|
|
{
|
|
efx_vpd_tag_t stag;
|
|
efx_vpd_tag_t dtag;
|
|
efx_vpd_keyword_t skey;
|
|
efx_vpd_keyword_t dkey;
|
|
unsigned int scont;
|
|
unsigned int dcont;
|
|
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
/*
|
|
* Strictly you could take the view that dynamic vpd is optional.
|
|
* Instead, to conform more closely to the read/verify/reinit()
|
|
* paradigm, we require dynamic vpd. siena_vpd_reinit() will
|
|
* reinitialize it as required.
|
|
*/
|
|
if ((rc = efx_vpd_hunk_verify(data, size, NULL)) != 0)
|
|
goto fail1;
|
|
|
|
/*
|
|
* Verify that there is no duplication between the static and
|
|
* dynamic cfg sectors.
|
|
*/
|
|
if (enp->en_u.siena.enu_svpd_length == 0)
|
|
goto done;
|
|
|
|
dcont = 0;
|
|
_NOTE(CONSTANTCONDITION)
|
|
while (1) {
|
|
if ((rc = efx_vpd_hunk_next(data, size, &dtag,
|
|
&dkey, NULL, NULL, &dcont)) != 0)
|
|
goto fail2;
|
|
if (dcont == 0)
|
|
break;
|
|
|
|
scont = 0;
|
|
_NOTE(CONSTANTCONDITION)
|
|
while (1) {
|
|
if ((rc = efx_vpd_hunk_next(
|
|
enp->en_u.siena.enu_svpd,
|
|
enp->en_u.siena.enu_svpd_length, &stag, &skey,
|
|
NULL, NULL, &scont)) != 0)
|
|
goto fail3;
|
|
if (scont == 0)
|
|
break;
|
|
|
|
if (stag == dtag && skey == dkey) {
|
|
rc = EEXIST;
|
|
goto fail4;
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
return (0);
|
|
|
|
fail4:
|
|
EFSYS_PROBE(fail4);
|
|
fail3:
|
|
EFSYS_PROBE(fail3);
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_reinit(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size)
|
|
{
|
|
boolean_t wantpid;
|
|
int rc;
|
|
|
|
/*
|
|
* Only create a PID if the dynamic cfg doesn't have one
|
|
*/
|
|
if (enp->en_u.siena.enu_svpd_length == 0)
|
|
wantpid = B_TRUE;
|
|
else {
|
|
unsigned int offset;
|
|
uint8_t length;
|
|
|
|
rc = efx_vpd_hunk_get(enp->en_u.siena.enu_svpd,
|
|
enp->en_u.siena.enu_svpd_length,
|
|
EFX_VPD_ID, 0, &offset, &length);
|
|
if (rc == 0)
|
|
wantpid = B_FALSE;
|
|
else if (rc == ENOENT)
|
|
wantpid = B_TRUE;
|
|
else
|
|
goto fail1;
|
|
}
|
|
|
|
if ((rc = efx_vpd_hunk_reinit(data, size, wantpid)) != 0)
|
|
goto fail2;
|
|
|
|
return (0);
|
|
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_get(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size,
|
|
__inout efx_vpd_value_t *evvp)
|
|
{
|
|
unsigned int offset;
|
|
uint8_t length;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
/* Attempt to satisfy the request from svpd first */
|
|
if (enp->en_u.siena.enu_svpd_length > 0) {
|
|
if ((rc = efx_vpd_hunk_get(enp->en_u.siena.enu_svpd,
|
|
enp->en_u.siena.enu_svpd_length, evvp->evv_tag,
|
|
evvp->evv_keyword, &offset, &length)) == 0) {
|
|
evvp->evv_length = length;
|
|
memcpy(evvp->evv_value,
|
|
enp->en_u.siena.enu_svpd + offset, length);
|
|
return (0);
|
|
} else if (rc != ENOENT)
|
|
goto fail1;
|
|
}
|
|
|
|
/* And then from the provided data buffer */
|
|
if ((rc = efx_vpd_hunk_get(data, size, evvp->evv_tag,
|
|
evvp->evv_keyword, &offset, &length)) != 0)
|
|
goto fail2;
|
|
|
|
evvp->evv_length = length;
|
|
memcpy(evvp->evv_value, data + offset, length);
|
|
|
|
return (0);
|
|
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_set(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size,
|
|
__in efx_vpd_value_t *evvp)
|
|
{
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
/* If the provided (tag,keyword) exists in svpd, then it is readonly */
|
|
if (enp->en_u.siena.enu_svpd_length > 0) {
|
|
unsigned int offset;
|
|
uint8_t length;
|
|
|
|
if ((rc = efx_vpd_hunk_get(enp->en_u.siena.enu_svpd,
|
|
enp->en_u.siena.enu_svpd_length, evvp->evv_tag,
|
|
evvp->evv_keyword, &offset, &length)) == 0) {
|
|
rc = EACCES;
|
|
goto fail1;
|
|
}
|
|
}
|
|
|
|
if ((rc = efx_vpd_hunk_set(data, size, evvp)) != 0)
|
|
goto fail2;
|
|
|
|
return (0);
|
|
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_next(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size,
|
|
__out efx_vpd_value_t *evvp,
|
|
__inout unsigned int *contp)
|
|
{
|
|
_NOTE(ARGUNUSED(enp, data, size, evvp, contp))
|
|
|
|
return (ENOTSUP);
|
|
}
|
|
|
|
__checkReturn int
|
|
siena_vpd_write(
|
|
__in efx_nic_t *enp,
|
|
__in_bcount(size) caddr_t data,
|
|
__in size_t size)
|
|
{
|
|
efx_mcdi_iface_t *emip = &(enp->en_u.siena.enu_mip);
|
|
siena_mc_dynamic_config_hdr_t *dcfg;
|
|
unsigned int vpd_offset;
|
|
unsigned int dcfg_partn;
|
|
unsigned int hdr_length;
|
|
unsigned int pos;
|
|
uint8_t cksum;
|
|
size_t partn_size, dcfg_size;
|
|
size_t vpd_length;
|
|
int rc;
|
|
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
/* Determine total length of all tags */
|
|
if ((rc = efx_vpd_hunk_length(data, size, &vpd_length)) != 0)
|
|
goto fail1;
|
|
|
|
/* Lock dynamic config sector for write, and read structure only */
|
|
dcfg_partn = (emip->emi_port == 1)
|
|
? MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT0
|
|
: MC_CMD_NVRAM_TYPE_DYNAMIC_CFG_PORT1;
|
|
|
|
if ((rc = siena_nvram_partn_size(enp, dcfg_partn, &partn_size)) != 0)
|
|
goto fail2;
|
|
|
|
if ((rc = siena_nvram_partn_lock(enp, dcfg_partn)) != 0)
|
|
goto fail2;
|
|
|
|
if ((rc = siena_nvram_get_dynamic_cfg(enp, dcfg_partn,
|
|
B_FALSE, &dcfg, &dcfg_size)) != 0)
|
|
goto fail3;
|
|
|
|
hdr_length = EFX_WORD_FIELD(dcfg->length, EFX_WORD_0);
|
|
|
|
/* Allocated memory should have room for the new VPD */
|
|
if (hdr_length + vpd_length > dcfg_size) {
|
|
rc = ENOSPC;
|
|
goto fail3;
|
|
}
|
|
|
|
/* Copy in new vpd and update header */
|
|
vpd_offset = dcfg_size - vpd_length;
|
|
EFX_POPULATE_DWORD_1(dcfg->dynamic_vpd_offset, EFX_DWORD_0, vpd_offset);
|
|
memcpy((caddr_t)dcfg + vpd_offset, data, vpd_length);
|
|
EFX_POPULATE_DWORD_1(dcfg->dynamic_vpd_length, EFX_DWORD_0, vpd_length);
|
|
|
|
/* Update the checksum */
|
|
cksum = 0;
|
|
for (pos = 0; pos < hdr_length; pos++)
|
|
cksum += ((uint8_t *)dcfg)[pos];
|
|
dcfg->csum.eb_u8[0] -= cksum;
|
|
|
|
/* Erase and write the new sector */
|
|
if ((rc = siena_nvram_partn_erase(enp, dcfg_partn, 0, partn_size)) != 0)
|
|
goto fail4;
|
|
|
|
/* Write out the new structure to nvram */
|
|
if ((rc = siena_nvram_partn_write(enp, dcfg_partn, 0, (caddr_t)dcfg,
|
|
vpd_offset + vpd_length)) != 0)
|
|
goto fail5;
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, dcfg_size, dcfg);
|
|
|
|
siena_nvram_partn_unlock(enp, dcfg_partn);
|
|
|
|
return (0);
|
|
|
|
fail5:
|
|
EFSYS_PROBE(fail5);
|
|
fail4:
|
|
EFSYS_PROBE(fail4);
|
|
fail3:
|
|
EFSYS_PROBE(fail3);
|
|
|
|
EFSYS_KMEM_FREE(enp->en_esip, dcfg_size, dcfg);
|
|
fail2:
|
|
EFSYS_PROBE(fail2);
|
|
|
|
siena_nvram_partn_unlock(enp, dcfg_partn);
|
|
fail1:
|
|
EFSYS_PROBE1(fail1, int, rc);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
void
|
|
siena_vpd_fini(
|
|
__in efx_nic_t *enp)
|
|
{
|
|
EFSYS_ASSERT(enp->en_family == EFX_FAMILY_SIENA);
|
|
|
|
if (enp->en_u.siena.enu_svpd_length > 0) {
|
|
EFSYS_KMEM_FREE(enp->en_esip, enp->en_u.siena.enu_svpd_length,
|
|
enp->en_u.siena.enu_svpd);
|
|
|
|
enp->en_u.siena.enu_svpd = NULL;
|
|
enp->en_u.siena.enu_svpd_length = 0;
|
|
}
|
|
}
|
|
|
|
#endif /* EFSYS_OPT_SIENA */
|
|
|
|
#endif /* EFSYS_OPT_VPD */
|