/* * 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 * or http://www.opensolaris.org/os/licensing. * 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 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include "rge.h" #define RGE_DBG RGE_DBG_STATS /* debug flag for this code */ /* * Local datatype for defining tables of (Offset, Name) pairs */ typedef struct { offset_t index; char *name; } rge_ksindex_t; static const rge_ksindex_t rge_driverinfo[] = { { 0, "rx_ring_addr" }, { 1, "rx_next" }, { 2, "rx_free" }, { 3, "rx_bcopy" }, { 4, "tx_ring_addr" }, { 5, "tx_next" }, { 6, "tx_free" }, { 7, "tx_flow" }, { 8, "resched_needed" }, { 9, "watchdog" }, { 10, "rx_config" }, { 11, "tx_config" }, { 12, "mac_ver" }, { 13, "phy_ver" }, { 14, "chip_reset" }, { 15, "phy_reset" }, { 16, "loop_mode" }, { -1, NULL } }; static int rge_driverinfo_update(kstat_t *ksp, int flag) { rge_t *rgep; kstat_named_t *knp; if (flag != KSTAT_READ) return (EACCES); rgep = ksp->ks_private; knp = ksp->ks_data; (knp++)->value.ui64 = rgep->dma_area_rxdesc.cookie.dmac_laddress; (knp++)->value.ui64 = rgep->rx_next; (knp++)->value.ui64 = rgep->rx_free; (knp++)->value.ui64 = rgep->rx_bcopy; (knp++)->value.ui64 = rgep->dma_area_txdesc.cookie.dmac_laddress; (knp++)->value.ui64 = rgep->tx_next; (knp++)->value.ui64 = rgep->tx_free; (knp++)->value.ui64 = rgep->tx_flow; (knp++)->value.ui64 = rgep->resched_needed; (knp++)->value.ui64 = rgep->watchdog; (knp++)->value.ui64 = rgep->chipid.rxconfig; (knp++)->value.ui64 = rgep->chipid.txconfig; (knp++)->value.ui64 = rgep->chipid.mac_ver; (knp++)->value.ui64 = rgep->chipid.phy_ver; (knp++)->value.ui64 = rgep->stats.chip_reset; (knp++)->value.ui64 = rgep->stats.phy_reset; (knp++)->value.ui64 = rgep->param_loop_mode; return (0); } static kstat_t * rge_setup_named_kstat(rge_t *rgep, int instance, char *name, const rge_ksindex_t *ksip, size_t size, int (*update)(kstat_t *, int)) { kstat_t *ksp; kstat_named_t *knp; char *np; int type; size /= sizeof (rge_ksindex_t); ksp = kstat_create(RGE_DRIVER_NAME, instance, name, "net", KSTAT_TYPE_NAMED, size-1, KSTAT_FLAG_PERSISTENT); if (ksp == NULL) return (NULL); ksp->ks_private = rgep; ksp->ks_update = update; for (knp = ksp->ks_data; (np = ksip->name) != NULL; ++knp, ++ksip) { switch (*np) { default: type = KSTAT_DATA_UINT64; break; case '%': np += 1; type = KSTAT_DATA_UINT32; break; case '$': np += 1; type = KSTAT_DATA_STRING; break; case '&': np += 1; type = KSTAT_DATA_CHAR; break; } kstat_named_init(knp, np, type); } kstat_install(ksp); return (ksp); } void rge_init_kstats(rge_t *rgep, int instance) { rgep->rge_kstats[RGE_KSTAT_DRIVER] = rge_setup_named_kstat(rgep, instance, "driverinfo", rge_driverinfo, sizeof (rge_driverinfo), rge_driverinfo_update); } void rge_fini_kstats(rge_t *rgep) { int i; for (i = RGE_KSTAT_COUNT; --i >= 0; ) if (rgep->rge_kstats[i] != NULL) { kstat_delete(rgep->rge_kstats[i]); } } int rge_m_stat(void *arg, uint_t stat, uint64_t *val) { rge_t *rgep = arg; rge_hw_stats_t *bstp; mutex_enter(rgep->genlock); rge_hw_stats_dump(rgep); mutex_exit(rgep->genlock); bstp = rgep->hw_stats; switch (stat) { case MAC_STAT_IFSPEED: *val = rgep->param_link_speed * 1000000ull; break; case MAC_STAT_MULTIRCV: *val = RGE_BSWAP_32(bstp->multi_rcv); break; case MAC_STAT_BRDCSTRCV: *val = RGE_BSWAP_64(bstp->brdcst_rcv); break; case MAC_STAT_NORCVBUF: *val = RGE_BSWAP_16(bstp->in_discards); break; case MAC_STAT_IERRORS: *val = RGE_BSWAP_32(bstp->rcv_err); break; case MAC_STAT_OERRORS: *val = RGE_BSWAP_64(bstp->xmt_err); break; case MAC_STAT_COLLISIONS: *val = RGE_BSWAP_32(bstp->xmt_1col + bstp->xmt_mcol); break; case MAC_STAT_RBYTES: *val = rgep->stats.rbytes; break; case MAC_STAT_IPACKETS: *val = RGE_BSWAP_64(bstp->rcv_ok); break; case MAC_STAT_OBYTES: *val = rgep->stats.obytes; break; case MAC_STAT_OPACKETS: *val = RGE_BSWAP_64(bstp->xmt_ok); break; case ETHER_STAT_ALIGN_ERRORS: *val = RGE_BSWAP_16(bstp->frame_err); break; case ETHER_STAT_FIRST_COLLISIONS: *val = RGE_BSWAP_32(bstp->xmt_1col); break; case ETHER_STAT_MULTI_COLLISIONS: *val = RGE_BSWAP_32(bstp->xmt_mcol); break; case ETHER_STAT_DEFER_XMTS: *val = rgep->stats.defer; break; case ETHER_STAT_XCVR_ADDR: *val = rgep->phy_mii_addr; break; case ETHER_STAT_XCVR_ID: mutex_enter(rgep->genlock); *val = rge_mii_get16(rgep, MII_PHYIDH); *val <<= 16; *val |= rge_mii_get16(rgep, MII_PHYIDL); mutex_exit(rgep->genlock); break; case ETHER_STAT_XCVR_INUSE: *val = XCVR_1000T; break; case ETHER_STAT_CAP_1000FDX: *val = 1; break; case ETHER_STAT_CAP_1000HDX: *val = 0; break; case ETHER_STAT_CAP_100FDX: *val = 1; break; case ETHER_STAT_CAP_100HDX: *val = 1; break; case ETHER_STAT_CAP_10FDX: *val = 1; break; case ETHER_STAT_CAP_10HDX: *val = 1; break; case ETHER_STAT_CAP_ASMPAUSE: *val = 1; break; case ETHER_STAT_CAP_PAUSE: *val = 1; break; case ETHER_STAT_CAP_AUTONEG: *val = 1; break; case ETHER_STAT_ADV_CAP_1000FDX: *val = rgep->param_adv_1000fdx; break; case ETHER_STAT_ADV_CAP_1000HDX: *val = rgep->param_adv_1000hdx; break; case ETHER_STAT_ADV_CAP_100FDX: *val = rgep->param_adv_100fdx; break; case ETHER_STAT_ADV_CAP_100HDX: *val = rgep->param_adv_100hdx; break; case ETHER_STAT_ADV_CAP_10FDX: *val = rgep->param_adv_10fdx; break; case ETHER_STAT_ADV_CAP_10HDX: *val = rgep->param_adv_10hdx; break; case ETHER_STAT_ADV_CAP_ASMPAUSE: *val = rgep->param_adv_asym_pause; break; case ETHER_STAT_ADV_CAP_PAUSE: *val = rgep->param_adv_pause; break; case ETHER_STAT_ADV_CAP_AUTONEG: *val = rgep->param_adv_autoneg; break; case ETHER_STAT_LINK_DUPLEX: *val = rgep->param_link_duplex; break; default: return (ENOTSUP); } return (0); }