sfe_util.c revision 915ebf8da9f4ef3e7b2e34dd367f64d358a628d9
2N/A * sfe_util.c: general ethernet mac driver framework version 2.6
#include "sfe_mii.h"
#include "sfe_util.h"
#ifdef GEM_DEBUG_LEVEL
#define ASSERT(x)
#ifndef INT32_MAX
#ifndef VTAG_SIZE
#ifndef VTAG_TPID
#ifndef offsetof
#define offsetof(t, m) ((long)&(((t *) 0)->m))
#define BOOLEAN(x) ((x) != 0)
return (crc);
int idx;
int bit;
return (crc);
int cnt;
cnt = 0;
cnt++;
return (cnt);
#ifdef GEM_DEBUG_LEVEL
#ifdef GEM_DEBUG_VLAN
uint8_t *p;
int rest;
int len;
char *bp;
msg[0] = 0;
offset = 0;
if (rest == 0) {
offset = 0;
if (check_cksum) {
__INLINE__ void
if ((m = nslot - n) > 0) {
(off_t)0,
how);
nslot = n;
how);
__INLINE__ void
if ((m = nslot - n) > 0) {
how);
nslot = n;
how);
struct rxbuf *
int err;
if (rbp) {
return (rbp);
return (NULL);
return (NULL);
NULL,
return (NULL);
NULL,
return (NULL);
return (rbp);
int err;
int tx_buf_len;
if (req_size > 0) {
return (ENOMEM);
return (ENOMEM);
return (ENOMEM);
goto err_alloc_dh;
goto err_alloc_dh;
goto err_alloc_dh;
return (ENOMEM);
for (i = 0; i < rx_ring_size; i++) {
* Prepare rx buffers and put them into the rx buffer/descriptor ring.
int nrbuf;
for (i = 0; i < nrbuf; i++) {
#ifdef GEM_DEBUG_LEVEL
int total;
for (i = 0; i < rx_ring_size; i++) {
#ifdef GEM_DEBUG_LEVEL
total = 0;
#ifdef GEM_DEBUG_LEVEL
total++;
* Initialize an empty transmit buffer/descriptor ring
for (i = 0; i < tx_ring_size; i++) {
#pragma inline(gem_txbuf_free_dma_resources)
#ifdef GEM_DEBUG_LEVEL
int err;
for (i = 0; i < tx_ring_size; i++) {
#ifdef GEM_DEBUG_LEVEL
err = 0;
sn++;
if (err) {
* Reclaim transmitted buffers from tx buffer/descriptor ring.
__INLINE__ int
now--;
#ifdef DEBUG
int ndescs;
if (ndescs == 0) {
if (txstat == 0) {
sn++;
return (err);
#pragma inline(gem_reclaim_txbuf)
int (*tx_desc_write)
flags = 0;
sn++;
static size_t
off = 0;
min_pkt));
#ifdef DEBUG_MULTIFRAGS
return (off);
#pragma inline(gem_setup_txbuf_copy)
#pragma inline(gem_tx_start_unit)
#ifdef GEM_DEBUG_LEVEL
static uint64_t
int off;
return (flag);
mblk_t *
int nmblk;
int avail;
nmblk++;
#ifdef GEM_DEBUG_LEVEL
gem_send_cnt[0]++;
while (mp) {
return (NULL);
return (mp_head);
if (avail == 0) {
goto done;
ETHERADDRL) == 0) {
bcast++;
mcast++;
done:
return (mp_head);
#ifdef GEM_DEBUG_LEVEL
return (GEM_FAILURE);
goto err;
goto err;
goto err;
goto err;
return (GEM_SUCCESS);
err:
return (GEM_FAILURE);
goto schedule_next;
goto schedule_next;
goto schedule_next;
goto schedule_next;
if (tx_sched) {
#pragma inline(gem_append_rxbuf)
mblk_t *
return (mp);
#ifdef GEM_DEBUG_LEVEL
int cnt = 0;
int len;
if (cnt == 0) {
cnt,
if (rx_header_len > 0) {
cnt--;
goto next;
goto next;
goto next;
goto next;
#ifdef GEM_DEBUG_VLAN
ETHERADDRL) == 0) {
next:
if (newbufs) {
if (rx_head) {
#ifdef GEM_DEBUG_LEVEL
return (cnt);
return (tx_sched);
static uint_t
return (DDI_INTR_UNCLAIMED);
return (ret);
return (ret);
#define fc_cap_decode(x) \
return (GEM_FAILURE);
val = 0;
return (GEM_SUCCESS);
static char *gem_fc_type[] = {
int linkdown_action;
case MII_STATE_UNKNOWN:
goto reset_phy;
case MII_STATE_RESETTING:
goto next;
goto reset_phy;
goto next_nowait;
goto autonego;
goto next;
goto autonego;
goto autonego;
goto next;
goto next;
diff = 0;
goto next_nowait;
case MII_STATE_AN_DONE:
goto next;
exp = 0;
ctl1000 = 0;
stat1000 = 0;
} else if (lpable == 0) {
goto reset_phy;
case MII_STATE_MEDIA_SETUP:
case GEM_SPD_1000:
case GEM_SPD_100:
case GEM_SPD_10:
goto next_nowait;
case MII_STATE_LINKDOWN:
goto next;
goto restart_autonego;
case MII_STATE_LINKUP:
goto restart_autonego;
goto next;
goto next;
goto next;
switch (linkdown_action) {
case MII_ACTION_RESET:
goto reset_phy;
case MII_ACTION_NONE:
goto autonego;
goto next;
case MII_ACTION_RSA:
goto autonego;
goto next;
next:
return (tx_sched);
if (tx_sched) {
goto PHY_found;
return (GEM_FAILURE);
goto PHY_found;
goto PHY_found;
return (GEM_FAILURE);
return (GEM_SUCCESS);
char *valstr;
char *cp;
uint8_t v;
uint8_t d;
return (B_FALSE);
goto syntax_err;
ored = 0;
c = *cp++;
goto syntax_err;
mac[j++] = v;
ored |= v;
if (j == ETHERADDRL) {
c = *cp++;
goto syntax_err;
if (ored == 0) {
goto err;
for (i = 0; i < ETHERADDRL; i++) {
return (B_TRUE);
err:
return (B_FALSE);
return (GEM_FAILURE);
return (GEM_FAILURE);
return (GEM_SUCCESS);
return (GEM_FAILURE);
return (GEM_FAILURE);
return (GEM_SUCCESS);
#ifdef GEM_DEBUG_LEVEL
return (GEM_SUCCESS);
#ifdef GEM_DEBUG_LEVEL
if (i > wait_time) {
return (ret);
int cnt;
int err;
return (GEM_FAILURE);
return (err);
int cnt;
int err;
return (GEM_FAILURE);
for (i = 0; i < cnt; i++) {
if (len > 0) {
return (err);
#ifdef DEBUG_RESUME
enum ioc_reply {
struct gem_nd_arg {
int item;
long val;
switch (item) {
case PARAM_AUTONEG_CAP:
case PARAM_PAUSE_CAP:
case PARAM_ASYM_PAUSE_CAP:
case PARAM_1000FDX_CAP:
case PARAM_1000HDX_CAP:
case PARAM_100T4_CAP:
case PARAM_100FDX_CAP:
case PARAM_100HDX_CAP:
case PARAM_10FDX_CAP:
case PARAM_10HDX_CAP:
case PARAM_ADV_AUTONEG_CAP:
case PARAM_ADV_PAUSE_CAP:
case PARAM_ADV_ASYM_PAUSE_CAP:
case PARAM_ADV_1000FDX_CAP:
case PARAM_ADV_1000HDX_CAP:
case PARAM_ADV_100T4_CAP:
case PARAM_ADV_100FDX_CAP:
case PARAM_ADV_100HDX_CAP:
case PARAM_ADV_10FDX_CAP:
case PARAM_ADV_10HDX_CAP:
case PARAM_LP_AUTONEG_CAP:
case PARAM_LP_PAUSE_CAP:
case PARAM_LP_ASYM_PAUSE_CAP:
case PARAM_LP_1000FDX_CAP:
case PARAM_LP_1000HDX_CAP:
case PARAM_LP_100T4_CAP:
case PARAM_LP_100FDX_CAP:
case PARAM_LP_100HDX_CAP:
case PARAM_LP_10FDX_CAP:
case PARAM_LP_10HDX_CAP:
case PARAM_LINK_STATUS:
case PARAM_LINK_SPEED:
case PARAM_LINK_DUPLEX:
val = 0;
case PARAM_LINK_AUTONEG:
case PARAM_LINK_RX_PAUSE:
case PARAM_LINK_TX_PAUSE:
#ifdef DEBUG_RESUME
case PARAM_RESUME_TEST:
val = 0;
long val;
char *end;
return (EINVAL);
return (EINVAL);
switch (item) {
case PARAM_ADV_AUTONEG_CAP:
goto err;
goto err;
case PARAM_ADV_PAUSE_CAP:
goto err;
if (val) {
case PARAM_ADV_ASYM_PAUSE_CAP:
goto err;
if (val) {
case PARAM_ADV_1000FDX_CAP:
goto err;
MII_XSTATUS_1000BASEX_FD)) == 0) {
goto err;
case PARAM_ADV_1000HDX_CAP:
goto err;
goto err;
case PARAM_ADV_100T4_CAP:
goto err;
goto err;
case PARAM_ADV_100FDX_CAP:
goto err;
goto err;
case PARAM_ADV_100HDX_CAP:
goto err;
goto err;
case PARAM_ADV_10FDX_CAP:
goto err;
goto err;
case PARAM_ADV_10HDX_CAP:
goto err;
goto err;
err:
return (EINVAL);
#ifdef DEBUG_RESUME
enum ioc_reply
case ND_GET:
case ND_SET:
if (!ok) {
return (IOC_INVAL);
return (IOC_REPLY);
return (IOC_RESTART_REPLY);
return (IOC_INVAL);
int cmd;
switch (cmd) {
case ND_GET:
case ND_SET:
#ifdef DEBUG_RESUME
switch (status) {
case IOC_INVAL:
case IOC_DONE:
case IOC_RESTART_ACK:
case IOC_ACK:
case IOC_RESTART_REPLY:
case IOC_REPLY:
#ifndef SYS_MAC_H
#define XCVR_UNDEFINED 0
return (val);
static int gem_m_start(void *);
static void gem_m_stop(void *);
static void gem_m_resources(void *);
int err = 0;
return (err);
int err;
int ret;
if (add) {
err = 0;
return (err);
return (EIO);
if (on) {
return (err);
return (EIO);
return (EIO);
return (EIO);
switch (stat) {
case MAC_STAT_IFSPEED:
case MAC_STAT_MULTIRCV:
case MAC_STAT_BRDCSTRCV:
case MAC_STAT_MULTIXMT:
case MAC_STAT_BRDCSTXMT:
case MAC_STAT_NORCVBUF:
case MAC_STAT_IERRORS:
case MAC_STAT_NOXMTBUF:
case MAC_STAT_OERRORS:
case MAC_STAT_COLLISIONS:
case MAC_STAT_RBYTES:
case MAC_STAT_IPACKETS:
case MAC_STAT_OBYTES:
case MAC_STAT_OPACKETS:
case MAC_STAT_UNDERFLOWS:
case MAC_STAT_OVERFLOWS:
case ETHER_STAT_ALIGN_ERRORS:
case ETHER_STAT_FCS_ERRORS:
case ETHER_STAT_SQE_ERRORS:
case ETHER_STAT_DEFER_XMTS:
case ETHER_STAT_EX_COLLISIONS:
case ETHER_STAT_MACXMT_ERRORS:
case ETHER_STAT_MACRCV_ERRORS:
case ETHER_STAT_XCVR_ADDR:
case ETHER_STAT_XCVR_ID:
case ETHER_STAT_XCVR_INUSE:
case ETHER_STAT_CAP_1000FDX:
case ETHER_STAT_CAP_1000HDX:
case ETHER_STAT_CAP_100FDX:
case ETHER_STAT_CAP_100HDX:
case ETHER_STAT_CAP_10FDX:
case ETHER_STAT_CAP_10HDX:
case ETHER_STAT_CAP_ASMPAUSE:
case ETHER_STAT_CAP_PAUSE:
case ETHER_STAT_CAP_AUTONEG:
case ETHER_STAT_ADV_CAP_10FDX:
case ETHER_STAT_ADV_CAP_10HDX:
case ETHER_STAT_ADV_CAP_PAUSE:
case ETHER_STAT_LP_CAP_100FDX:
case ETHER_STAT_LP_CAP_100HDX:
case ETHER_STAT_LP_CAP_10FDX:
case ETHER_STAT_LP_CAP_10HDX:
case ETHER_STAT_LP_CAP_PAUSE:
case ETHER_STAT_LINK_ASMPAUSE:
case ETHER_STAT_LINK_PAUSE:
case ETHER_STAT_LINK_AUTONEG:
case ETHER_STAT_LINK_DUPLEX:
case ETHER_STAT_LP_REMFAULT:
case ETHER_STAT_JABBER_ERRORS:
case ETHER_STAT_CAP_100T4:
case ETHER_STAT_ADV_CAP_100T4:
case ETHER_STAT_LP_CAP_100T4:
return (ENOTSUP);
int err = 0;
return (EIO);
return (err);
static mblk_t *
while (mp) {
return (NULL);
static boolean_t
switch (cap) {
case MAC_CAPAB_POLL:
return (ret);
int val;
switch (val) {
(sizeof (struct gem_dev) + \
struct gem_dev *
int ret;
int unit;
int nports;
unit));
return (NULL);
goto err_free_private;
goto err_free_regs;
goto err_free_regs;
#ifdef DEBUG_MULTIFRAGS
goto err_free_regs;
goto err_free_ring;
goto err_free_ring;
goto err_release_stats;
goto err_unregister;
goto err_unregister;
return (dp);
if (macp) {
return (NULL);
int priv_size;
return (DDI_SUCCESS);
while (dp) {
return (DDI_FAILURE);
return (DDI_SUCCESS);
return (DDI_SUCCESS);
/* gem_xxx.c layer to setup power management state. */
goto err;
goto err_reset;
goto err_reset;
goto err_reset;
(void *)dp,
goto err_reset;
return (DDI_SUCCESS);
err:
return (DDI_FAILURE);
while (pci_cap_ptr) {
return (pci_cap_ptr);
const char *drv_name;
if (pci_cap_ptr == 0) {
return (DDI_FAILURE);
return (DDI_SUCCESS);
uint_t n;
uint_t i;
int ret;
const char *drv_name;
len = 0;
return (DDI_FAILURE);
#if GEM_DEBUG_LEVEL > 0
goto address_range_found;
return (DDI_FAILURE);
!= DDI_SUCCESS) {
return (ret);