diff options
29 files changed, 2544 insertions, 2463 deletions
diff --git a/usr/src/uts/common/io/e1000g/e1000g_ndd.c b/deleted_files/usr/src/uts/common/io/e1000g/e1000g_ndd.c index 5964006c2b..5964006c2b 100644 --- a/usr/src/uts/common/io/e1000g/e1000g_ndd.c +++ b/deleted_files/usr/src/uts/common/io/e1000g/e1000g_ndd.c diff --git a/usr/src/cmd/cmd-inet/usr.sbin/Makefile b/usr/src/cmd/cmd-inet/usr.sbin/Makefile index ee027aee81..b8005a3fed 100644 --- a/usr/src/cmd/cmd-inet/usr.sbin/Makefile +++ b/usr/src/cmd/cmd-inet/usr.sbin/Makefile @@ -20,7 +20,7 @@ # # -# Copyright 2007 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # # ident "%Z%%M% %I% %E% SMI" @@ -146,6 +146,7 @@ $(TSNETPROG) := LDLIBS += $(ZLAZYLOAD) -ltsnet $(ZNOLAZYLOAD) in.rarpd := LDLIBS += -linetutil -ldlpi route := CPPFLAGS += -DNDEBUG +ndd := LDLIBS += -ldladm gettable in.comsat := LDFLAGS += $(MAPFILE.NGB:%=-M%) .KEEP_STATE: diff --git a/usr/src/cmd/cmd-inet/usr.sbin/ndd.c b/usr/src/cmd/cmd-inet/usr.sbin/ndd.c index e36b27a264..4aac580e67 100644 --- a/usr/src/cmd/cmd-inet/usr.sbin/ndd.c +++ b/usr/src/cmd/cmd-inet/usr.sbin/ndd.c @@ -2,9 +2,8 @@ * CDDL HEADER START * * The contents of this file are subject to the terms of the - * Common Development and Distribution License, Version 1.0 only - * (the "License"). You may not use this file except in compliance - * with the License. + * 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. @@ -20,7 +19,7 @@ * CDDL HEADER END */ /* - * Copyright 1998, 2000, 2003 Sun Microsystems, Inc. All rights reserved. + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ @@ -42,6 +41,8 @@ #include <inet/nd.h> #include <string.h> #include <stdlib.h> +#include <libdllink.h> +#include <libintl.h> static boolean_t do_getset(int fd, int cmd, char *buf, int buf_len); static int get_value(char *msg, char *buf, int buf_len); @@ -56,6 +57,33 @@ static char gbuf[65536]; /* Need 20k for 160 IREs ... */ static char usage_str[] = "usage: ndd -set device_name name value\n" " ndd [-get] device_name name [name ...]"; +static void +gldv3_warning(char *module) +{ + datalink_id_t linkid; + dladm_status_t status; + char buf[DLADM_PROP_VAL_MAX], *cp; + uint_t cnt; + char *link; + + link = strrchr(module, '/'); + if (link == NULL) + return; + status = dladm_name2info(++link, &linkid, + NULL, NULL, NULL); + if (status != DLADM_STATUS_OK) + return; + cp = buf; + status = dladm_get_linkprop(linkid, DLADM_PROP_VAL_CURRENT, "flowctrl", + &cp, &cnt); + if (status != DLADM_STATUS_OK) + return; + (void) fprintf(stderr, gettext( + "WARNING: The ndd commands for datalink administration " + "are obsolete and may be removed in a future release of " + "Solaris. Use dladm(1M) to manage datalink tunables.\n")); +} + /* ARGSUSED */ int main(int argc, char **argv) @@ -64,6 +92,7 @@ main(int argc, char **argv) int cmd; int fd; + if (!(cp = *++argv)) { while ((fd = open_device()) != -1) { getset_interactive(fd); @@ -81,6 +110,7 @@ main(int argc, char **argv) if (!(cp = *++argv)) fatal(usage_str); } + gldv3_warning(cp); if ((fd = open(cp, O_RDWR)) == -1) fatal("open of %s failed: %s", cp, errmsg(errno)); @@ -252,6 +282,7 @@ printe(boolean_t print_errno, char *fmt, ...) (void) printf("\n"); } + static int open_device(void) { @@ -269,6 +300,8 @@ open_device(void) continue; } + gldv3_warning(name); + if (isastream(fd)) return (fd); diff --git a/usr/src/cmd/dladm/dladm.c b/usr/src/cmd/dladm/dladm.c index 91e660dd8b..f8e745b3a5 100644 --- a/usr/src/cmd/dladm/dladm.c +++ b/usr/src/cmd/dladm/dladm.c @@ -476,7 +476,7 @@ typedef struct link_fields_buf_s { char link_mtu[11]; char link_state[DLADM_STRSIZE]; char link_over[MAXLINKNAMELEN]; - char link_phys_state[6]; + char link_phys_state[DLADM_STRSIZE]; char link_phys_media[DLADM_STRSIZE]; char link_phys_speed[DLADM_STRSIZE]; char link_phys_duplex[DLPI_LINKNAME_MAX]; @@ -5431,11 +5431,11 @@ show_etherprop(datalink_id_t linkid, void *arg) speed = speed/1000; speed_unit = 'G'; } - (void) get_linkduplex(ebuf.eth_link, B_FALSE, buf); + (void) get_linkduplex(ebuf.eth_link, B_TRUE, buf); (void) snprintf(ebuf.eth_spdx, sizeof (ebuf.eth_spdx), "%d%c-%c", speed, speed_unit, buf[0]); - (void) get_linkstate(ebuf.eth_link, B_FALSE, buf); + (void) get_linkstate(ebuf.eth_link, B_TRUE, buf); (void) snprintf(ebuf.eth_state, sizeof (ebuf.eth_state), "%s", buf); diff --git a/usr/src/lib/libdladm/common/linkprop.c b/usr/src/lib/libdladm/common/linkprop.c index 01afc3a78a..e06c6cd0b6 100644 --- a/usr/src/lib/libdladm/common/linkprop.c +++ b/usr/src/lib/libdladm/common/linkprop.c @@ -64,7 +64,7 @@ struct prop_desc; typedef dladm_status_t pd_getf_t(struct prop_desc *pd, datalink_id_t, char **propstp, uint_t *cntp, - datalink_media_t); + datalink_media_t, uint_t); /* * The linkprop set() callback. @@ -109,16 +109,16 @@ typedef struct dld_public_prop_s { } dld_public_prop_t; static dld_ioc_prop_t *dld_buf_alloc(size_t, datalink_id_t, const char *, - dladm_status_t *); + uint_t, dladm_status_t *); static dladm_status_t dld_set_prop(datalink_id_t, const char *, char **, uint_t, uint_t); static dladm_status_t dld_get_prop(datalink_id_t, const char *, char **, - uint_t *, dladm_prop_type_t); + uint_t *, dladm_prop_type_t, uint_t); static pd_getf_t do_get_zone, do_get_autopush, do_get_rate_mod, do_get_rate_prop, do_get_channel_prop, do_get_powermode_prop, do_get_radio_prop, dld_duplex_get, dld_status_get, - dld_binary_get, dld_uint64_get, dld_flowctl_get; + dld_binary_get, dld_uint32_get, dld_flowctl_get; static pd_setf_t do_set_zone, do_set_autopush, do_set_rate_prop, do_set_powermode_prop, do_set_radio_prop, dld_set_public_prop; @@ -126,7 +126,7 @@ static pd_checkf_t do_check_zone, do_check_autopush, do_check_rate, dld_defmtu_check; static dladm_status_t dld_speed_get(struct prop_desc *, datalink_id_t, - char **, uint_t *); + char **, uint_t *, uint_t); typedef struct prop_desc { /* @@ -179,6 +179,7 @@ typedef struct prop_desc { uint_t pd_flags; #define PD_TEMPONLY 0x1 /* property is temporary only */ #define PD_CHECK_ALLOC 0x2 /* alloc vd_val as part of pd_check */ +#define PD_EMPTY_RESET 0x4 /* Use "" to reset the link property */ /* * indicate link classes this property applies to. */ @@ -194,19 +195,19 @@ typedef struct prop_desc { static dld_public_prop_t dld_prop[] = { - { DLD_PROP_DUPLEX, sizeof (uint8_t), + { DLD_PROP_DUPLEX, sizeof (link_duplex_t), "duplex", "link duplex mode" }, {DLD_PROP_SPEED, sizeof (uint64_t), "speed", "link speed (bps)" }, - { DLD_PROP_STATUS, sizeof (uint8_t), + { DLD_PROP_STATUS, sizeof (link_state_t), "state", "link up/down" }, { DLD_PROP_AUTONEG, sizeof (uint8_t), "adv_autoneg_cap", "Advertised auto-negotiation" }, - { DLD_PROP_DEFMTU, sizeof (uint64_t), + { DLD_PROP_MTU, sizeof (uint32_t), "mtu", "current link mtu" }, { DLD_PROP_FLOWCTRL, sizeof (link_flowctrl_t), @@ -256,11 +257,6 @@ static val_desc_t link_duplex_vals[] = { { "half", LINK_DUPLEX_HALF }, { "full", LINK_DUPLEX_HALF } }; -static val_desc_t link_speed_vals[] = { - { "10", 10 }, - { "100", 100 }, - { "1000", 1000 } -}; static val_desc_t link_status_vals[] = { { "up", LINK_STATE_UP }, { "down", LINK_STATE_DOWN } @@ -275,9 +271,6 @@ static val_desc_t link_flow_vals[] = { { "rx", LINK_FLOWCTRL_RX }, { "bi", LINK_FLOWCTRL_BI } }; -static val_desc_t macdefaultmtu_vals[] = { - { "68-9000", NULL } -}; #define VALCNT(vals) (sizeof ((vals)) / sizeof (val_desc_t)) @@ -316,17 +309,17 @@ static prop_desc_t prop_table[] = { do_get_rate_prop, do_check_rate, 0, DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE }, - { "autopush", { "", NULL }, NULL, 0, + { "autopush", { "", 0 }, NULL, 0, do_set_autopush, NULL, - do_get_autopush, do_check_autopush, PD_CHECK_ALLOC, + do_get_autopush, do_check_autopush, PD_CHECK_ALLOC|PD_EMPTY_RESET, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, - { "zone", { "", NULL }, NULL, 0, + { "zone", { "", 0 }, NULL, 0, do_set_zone, NULL, - do_get_zone, do_check_zone, PD_TEMPONLY, + do_get_zone, do_check_zone, PD_TEMPONLY|PD_EMPTY_RESET, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, - { "duplex", { "full", LINK_DUPLEX_FULL }, + { "duplex", { "", 0 }, link_duplex_vals, VALCNT(link_duplex_vals), NULL, NULL, dld_duplex_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, @@ -334,79 +327,78 @@ static prop_desc_t prop_table[] = { { "state", { "up", LINK_STATE_UP }, link_status_vals, VALCNT(link_status_vals), NULL, NULL, dld_status_get, NULL, - 0, DATALINK_CLASS_PHYS, DL_ETHER }, + 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, { "adv_autoneg_cap", { "1", 1 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "mtu", { NULL, NULL }, - macdefaultmtu_vals, VALCNT(macdefaultmtu_vals), - dld_set_public_prop, NULL, dld_uint64_get, dld_defmtu_check, - PD_CHECK_ALLOC, DATALINK_CLASS_PHYS, DL_ETHER }, + { "mtu", { "", 0 }, NULL, 0, + dld_set_public_prop, NULL, dld_uint32_get, + dld_defmtu_check, 0, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE }, - { "flowctrl", { "bi", LINK_FLOWCTRL_BI }, + { "flowctrl", { "", 0 }, link_flow_vals, VALCNT(link_flow_vals), dld_set_public_prop, NULL, dld_flowctl_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_1000fdx_cap", { NULL, NULL }, - link_01_vals, 0, + { "adv_1000fdx_cap", { "", 0 }, + link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_1000fdx_cap", { NULL, NULL }, + { "en_1000fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_1000hdx_cap", { NULL, NULL }, + { "adv_1000hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_1000hdx_cap", { NULL, NULL }, + { "en_1000hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_100fdx_cap", { NULL, NULL }, + { "adv_100fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_100fdx_cap", { NULL, NULL }, + { "en_100fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_100hdx_cap", { NULL, NULL }, + { "adv_100hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_100hdx_cap", { NULL, NULL }, + { "en_100hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_10fdx_cap", { NULL, NULL }, + { "adv_10fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_10fdx_cap", { NULL, NULL }, + { "en_10fdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "adv_10hdx_cap", { NULL, NULL }, + { "adv_10hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), NULL, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER }, - { "en_10hdx_cap", { NULL, NULL }, + { "en_10hdx_cap", { "", 0 }, link_01_vals, VALCNT(link_01_vals), dld_set_public_prop, NULL, dld_binary_get, NULL, 0, DATALINK_CLASS_PHYS, DL_ETHER } @@ -423,7 +415,8 @@ static dladm_status_t i_dladm_set_single_prop(datalink_id_t, datalink_class_t, uint32_t, prop_desc_t *, char **, uint_t, uint_t); static dladm_status_t i_dladm_set_linkprop(datalink_id_t, const char *, char **, uint_t, uint_t); - +static dladm_status_t i_dladm_getset_defval(prop_desc_t *, datalink_id_t, + datalink_media_t, uint_t); /* * Unfortunately, MAX_SCAN_SUPPORT_RATES is too small to allow all * rates to be retrieved. However, we cannot increase it at this @@ -513,10 +506,17 @@ i_dladm_set_single_prop(datalink_id_t linkid, datalink_class_t class, if (pdp->pd_defval.vd_name == NULL) return (DLADM_STATUS_NOTSUP); - if ((vdp = malloc(sizeof (val_desc_t))) == NULL) - return (DLADM_STATUS_NOMEM); - - (void) memcpy(vdp, &pdp->pd_defval, sizeof (val_desc_t)); + if ((pdp->pd_flags & PD_EMPTY_RESET) != 0 || + strlen(pdp->pd_defval.vd_name) > 0) { + if ((vdp = malloc(sizeof (val_desc_t))) == NULL) + return (DLADM_STATUS_NOMEM); + (void) memcpy(vdp, &pdp->pd_defval, + sizeof (val_desc_t)); + } else { + status = i_dladm_getset_defval(pdp, linkid, + media, flags); + return (status); + } cnt = 1; } status = pdp->pd_set(pdp, linkid, vdp, cnt, flags, media); @@ -651,9 +651,12 @@ dladm_get_linkprop(datalink_id_t linkid, dladm_prop_type_t type, datalink_class_t class; uint_t media; prop_desc_t *pdp; - uint_t cnt; + uint_t cnt, dld_flags = 0; int i; + if (type == DLADM_PROP_VAL_DEFAULT) + dld_flags = DLD_DEFAULT; + if (linkid == DATALINK_INVALID_LINKID || prop_name == NULL || prop_val == NULL || val_cntp == NULL || *val_cntp == 0) return (DLADM_STATUS_BADARG); @@ -668,7 +671,7 @@ dladm_get_linkprop(datalink_id_t linkid, dladm_prop_type_t type, * private property. */ return (dld_get_prop(linkid, prop_name, - prop_val, val_cntp, type)); + prop_val, val_cntp, type, dld_flags)); } else { return (DLADM_STATUS_NOTFOUND); } @@ -688,7 +691,8 @@ dladm_get_linkprop(datalink_id_t linkid, dladm_prop_type_t type, switch (type) { case DLADM_PROP_VAL_CURRENT: - status = pdp->pd_get(pdp, linkid, prop_val, val_cntp, media); + status = pdp->pd_get(pdp, linkid, prop_val, val_cntp, media, + dld_flags); break; case DLADM_PROP_VAL_DEFAULT: @@ -696,14 +700,20 @@ dladm_get_linkprop(datalink_id_t linkid, dladm_prop_type_t type, status = DLADM_STATUS_NOTSUP; break; } - (void) strcpy(*prop_val, pdp->pd_defval.vd_name); + + if (strlen(pdp->pd_defval.vd_name) == 0) { + status = pdp->pd_get(pdp, linkid, prop_val, val_cntp, + media, dld_flags); + } else { + (void) strcpy(*prop_val, pdp->pd_defval.vd_name); + } *val_cntp = 1; break; case DLADM_PROP_VAL_MODIFIABLE: if (pdp->pd_getmod != NULL) { status = pdp->pd_getmod(pdp, linkid, prop_val, - val_cntp, media); + val_cntp, media, dld_flags); break; } cnt = pdp->pd_noptval; @@ -791,12 +801,15 @@ dladm_init_linkprop(datalink_id_t linkid) /* ARGSUSED */ static dladm_status_t do_get_zone(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { char zone_name[ZONENAME_MAX]; zoneid_t zid; dladm_status_t status; + if (flags != 0) + return (DLADM_STATUS_NOTSUP); + status = dladm_getzid(linkid, &zid); if (status != DLADM_STATUS_OK) return (status); @@ -998,11 +1011,14 @@ do_check_zone(struct prop_desc *pd, datalink_id_t linkid, char **prop_val, /* ARGSUSED */ static dladm_status_t do_get_autopush(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { dld_ioc_ap_t dia; int fd, i, len; + if (flags & DLD_DEFAULT) + return (DLADM_STATUS_NOTSUP); + if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) return (dladm_errno2status(errno)); @@ -1187,29 +1203,27 @@ done: static dladm_status_t do_get_rate_prop(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { if (media != DL_WIFI) - return (dld_speed_get(pd, linkid, prop_val, val_cnt)); + return (dld_speed_get(pd, linkid, prop_val, val_cnt, flags)); return (do_get_rate_common(pd, linkid, prop_val, val_cnt, WL_DESIRED_RATES)); } +/* ARGSUSED */ static dladm_status_t do_get_rate_mod(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { - int i; - switch (media) { case DL_ETHER: - if (VALCNT(link_speed_vals) > *val_cnt) - return (DLADM_STATUS_TOOSMALL); - for (i = 0; i < VALCNT(link_speed_vals); i++) - (void) strcpy(prop_val[i], link_speed_vals[i].vd_name); - *val_cnt = VALCNT(link_speed_vals); - return (DLADM_STATUS_OK); + /* + * Speed for ethernet links is unbounded. E.g., 802.11b + * links can have a speed of 5.5 Gbps. + */ + return (DLADM_STATUS_NOTSUP); case DL_WIFI: return (do_get_rate_common(pd, linkid, prop_val, val_cnt, @@ -1299,7 +1313,7 @@ do_check_rate(struct prop_desc *pd, datalink_id_t linkid, char **prop_val, i * DLADM_STRSIZE; } - status = do_get_rate_mod(NULL, linkid, modval, &modval_cnt, media); + status = do_get_rate_mod(NULL, linkid, modval, &modval_cnt, media, 0); if (status != DLADM_STATUS_OK) goto done; @@ -1327,7 +1341,7 @@ do_get_phyconf(datalink_id_t linkid, wldp_t *gbuf) /* ARGSUSED */ static dladm_status_t do_get_channel_prop(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { uint32_t channel; wldp_t *gbuf; @@ -1362,7 +1376,7 @@ do_get_powermode(datalink_id_t linkid, wldp_t *gbuf) /* ARGSUSED */ static dladm_status_t do_get_powermode_prop(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { wl_ps_mode_t *mode; const char *s; @@ -1447,7 +1461,7 @@ do_get_radio(datalink_id_t linkid, wldp_t *gbuf) /* ARGSUSED */ static dladm_status_t do_get_radio_prop(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { wl_radio_t radio; const char *s; @@ -1602,7 +1616,7 @@ dladm_name2prop(const char *prop_name) static dld_ioc_prop_t * dld_buf_alloc(size_t valsize, datalink_id_t linkid, const char *prop_name, - dladm_status_t *status) + uint_t flags, dladm_status_t *status) { int dsize; dld_ioc_prop_t *dip; @@ -1621,10 +1635,11 @@ dld_buf_alloc(size_t valsize, datalink_id_t linkid, const char *prop_name, } bzero(dip, dsize); dip->pr_valsize = valsize; - (void) strlcpy(dip->pr_name, prop_name, DLD_LINKPROP_NAME_MAX); + (void) strlcpy(dip->pr_name, prop_name, sizeof (dip->pr_name)); dip->pr_version = DLD_PROP_VERSION; dip->pr_linkid = linkid; dip->pr_num = p->pp_id; + dip->pr_flags = flags; return (dip); } @@ -1641,7 +1656,7 @@ dld_set_public_prop(prop_desc_t *pd, datalink_id_t linkid, uint32_t u32; void *val; - dip = dld_buf_alloc(0, linkid, pd->pd_name, &status); + dip = dld_buf_alloc(0, linkid, pd->pd_name, 0, &status); if (dip == NULL) return (status); @@ -1682,26 +1697,40 @@ dld_set_public_prop(prop_desc_t *pd, datalink_id_t linkid, (void) close(fd); done: + free(dip); return (status); } -static dladm_status_t -dld_get_public_prop(dld_ioc_prop_t *dip) +static dld_ioc_prop_t * +dld_get_public_prop(datalink_id_t linkid, char *prop_name, uint_t flags, + dladm_status_t *status) { int fd, dsize; - dladm_status_t status = DLADM_STATUS_OK; + dld_ioc_prop_t *dip = NULL; + + *status = DLADM_STATUS_OK; + + dip = dld_buf_alloc(0, linkid, prop_name, flags, status); + if (dip == NULL) + return (NULL); dsize = DLD_PROPBUF_SIZE(dip->pr_valsize); if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) { - status = dladm_errno2status(errno); + *status = dladm_errno2status(errno); goto done; } if (i_dladm_ioctl(fd, DLDIOCGETPROP, dip, dsize) < 0) { - status = dladm_errno2status(errno); + *status = dladm_errno2status(errno); } + + (void) close(fd); done: - return (status); + if (*status != DLADM_STATUS_OK) { + free(dip); + return (NULL); + } + return (dip); } /* ARGSUSED */ @@ -1709,26 +1738,23 @@ static dladm_status_t dld_defmtu_check(struct prop_desc *pd, datalink_id_t linkid, char **prop_val, uint_t val_cnt, val_desc_t *v, datalink_media_t media) { - uint64_t mtu; - if (val_cnt != 1) return (DLADM_STATUS_BADVAL); - mtu = atoll(prop_val[0]); - v->vd_val = (uintptr_t)malloc(sizeof (uint64_t)); - if ((void *)v->vd_val == NULL) - return (DLADM_STATUS_NOMEM); - bcopy(&mtu, (void *)v->vd_val, sizeof (mtu)); + v->vd_val = atoi(prop_val[0]); return (DLADM_STATUS_OK); } /* ARGSUSED */ static dladm_status_t dld_duplex_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { link_duplex_t link_duplex; dladm_status_t status; + if (flags & DLD_DEFAULT) + return (DLADM_STATUS_NOTSUP); + if ((status = dladm_get_single_mac_stat(linkid, "link_duplex", KSTAT_DATA_UINT32, &link_duplex)) != 0) return (status); @@ -1751,14 +1777,18 @@ dld_duplex_get(struct prop_desc *pd, datalink_id_t linkid, /* ARGSUSED */ static dladm_status_t dld_speed_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt) + char **prop_val, uint_t *val_cnt, uint_t flags) { uint64_t ifspeed = 0; dladm_status_t status; + if (flags & DLD_DEFAULT) + return (DLADM_STATUS_NOTSUP); + if ((status = dladm_get_single_mac_stat(linkid, "ifspeed", KSTAT_DATA_UINT64, &ifspeed)) != 0) return (status); + if ((ifspeed % 1000000) != 0) { (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%llf", ifspeed / (float)1000000); /* Mbps */ @@ -1773,14 +1803,20 @@ dld_speed_get(struct prop_desc *pd, datalink_id_t linkid, /* ARGSUSED */ static dladm_status_t dld_status_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { - link_state_t link_state; - dladm_status_t status; + link_state_t link_state; + dladm_status_t status; + uchar_t *cp; + dld_ioc_prop_t *dip; - if ((status = dladm_get_single_mac_stat(linkid, "link_state", - KSTAT_DATA_UINT32, &link_state)) != 0) + if (flags & DLD_DEFAULT) + return (DLADM_STATUS_NOTSUP); + dip = dld_get_public_prop(linkid, pd->pd_name, flags, &status); + if (status != DLADM_STATUS_OK) return (status); + cp = (uchar_t *)dip->pr_val; + (void) memcpy(&link_state, cp, sizeof (link_state)); switch (link_state) { case LINK_STATE_UP: @@ -1794,23 +1830,21 @@ dld_status_get(struct prop_desc *pd, datalink_id_t linkid, break; } *val_cnt = 1; + free(dip); return (DLADM_STATUS_OK); } /* ARGSUSED */ static dladm_status_t dld_binary_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { dld_ioc_prop_t *dip; dladm_status_t status; - if ((dip = dld_buf_alloc(0, linkid, pd->pd_name, &status)) == NULL) - return (status); - if ((status = dld_get_public_prop(dip)) != DLADM_STATUS_OK) { - free(dip); + dip = dld_get_public_prop(linkid, pd->pd_name, flags, &status); + if (dip == NULL) return (status); - } (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%x", dip->pr_val[0]); free(dip); *val_cnt = 1; @@ -1819,23 +1853,20 @@ dld_binary_get(struct prop_desc *pd, datalink_id_t linkid, /* ARGSUSED */ static dladm_status_t -dld_uint64_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) +dld_uint32_get(struct prop_desc *pd, datalink_id_t linkid, + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { dld_ioc_prop_t *dip; - uint64_t v = 0; + uint32_t v = 0; uchar_t *cp; dladm_status_t status; - if ((dip = dld_buf_alloc(0, linkid, pd->pd_name, &status)) == NULL) - return (status); - if ((status = dld_get_public_prop(dip)) != DLADM_STATUS_OK) { - free(dip); + dip = dld_get_public_prop(linkid, pd->pd_name, flags, &status); + if (dip == NULL) return (status); - } cp = (uchar_t *)dip->pr_val; (void) memcpy(&v, cp, sizeof (v)); - (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%" PRIu64, v); + (void) snprintf(*prop_val, DLADM_PROP_VAL_MAX, "%ld", v); free(dip); *val_cnt = 1; return (DLADM_STATUS_OK); @@ -1844,20 +1875,16 @@ dld_uint64_get(struct prop_desc *pd, datalink_id_t linkid, /* ARGSUSED */ static dladm_status_t dld_flowctl_get(struct prop_desc *pd, datalink_id_t linkid, - char **prop_val, uint_t *val_cnt, datalink_media_t media) + char **prop_val, uint_t *val_cnt, datalink_media_t media, uint_t flags) { dld_ioc_prop_t *dip; link_flowctrl_t v; dladm_status_t status; uchar_t *cp; - if ((dip = dld_buf_alloc(0, linkid, pd->pd_name, &status)) == NULL) - return (status); - - if ((status = dld_get_public_prop(dip)) != DLADM_STATUS_OK) { - free(dip); + dip = dld_get_public_prop(linkid, pd->pd_name, flags, &status); + if (dip == NULL) return (status); - } cp = (uchar_t *)dip->pr_val; (void) memcpy(&v, cp, sizeof (v)); switch (v) { @@ -1890,7 +1917,7 @@ dld_set_prop(datalink_id_t linkid, const char *prop_name, dld_ioc_prop_t *dip = NULL; uchar_t *dp; dld_public_prop_t *p; - dladm_status_t status; + dladm_status_t status = DLADM_STATUS_OK; if ((prop_name == NULL && prop_val != NULL) || (prop_val != NULL && val_cnt == 0)) @@ -1906,42 +1933,60 @@ dld_set_prop(datalink_id_t linkid, const char *prop_name, for (i = 0; i < val_cnt; i++) { bufsize += strlen(prop_val[i]) + 1; } - dip = dld_buf_alloc(bufsize + 1, linkid, prop_name, &status); + + if (prop_val == NULL) { + /* + * getting default value. so use more buffer space. + */ + bufsize += 1024; + } + + dip = dld_buf_alloc(bufsize + 1, linkid, prop_name, + (prop_val != NULL ? 0 : DLD_DEFAULT), &status); if (dip == NULL) return (status); dp = (uchar_t *)dip->pr_val; dsize = sizeof (dld_ioc_prop_t) + bufsize; slen = 0; - for (i = 0; i < val_cnt; i++) { - int plen = 0; - - plen = strlen(prop_val[i]); - bcopy(prop_val[i], dp, plen); - slen += plen; - /* - * add a "," separator and update dp. - */ - if (i != (val_cnt -1)) - dp[slen++] = ','; - dp += (plen + 1); - } if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) { - free(dip); - return (dladm_errno2status(errno)); + status = dladm_errno2status(errno); + goto done; } - if ((status = i_dladm_ioctl(fd, DLDIOCSETPROP, dip, dsize)) < 0) { - free(dip); - return (status); + if (prop_val == NULL) { + if (i_dladm_ioctl(fd, DLDIOCGETPROP, dip, dsize) < 0) { + status = dladm_errno2status(errno); + goto done; + } + } else { + for (i = 0; i < val_cnt; i++) { + int plen = 0; + + plen = strlen(prop_val[i]); + bcopy(prop_val[i], dp, plen); + slen += plen; + /* + * add a "," separator and update dp. + */ + if (i != (val_cnt -1)) + dp[slen++] = ','; + dp += (plen + 1); + } + } + if (i_dladm_ioctl(fd, DLDIOCSETPROP, dip, dsize) < 0) { + status = dladm_errno2status(errno); } + +done: + if (fd > 0) + (void) close(fd); free(dip); - (void) close(fd); - return (DLADM_STATUS_OK); + return (status); } static dladm_status_t dld_get_prop(datalink_id_t linkid, const char *prop_name, - char **prop_val, uint_t *val_cnt, dladm_prop_type_t type) + char **prop_val, uint_t *val_cnt, dladm_prop_type_t type, uint_t dld_flags) { int fd; dladm_status_t status = DLADM_STATUS_OK; @@ -1958,8 +2003,7 @@ dld_get_prop(datalink_id_t linkid, const char *prop_name, if (p->pp_id != DLD_PROP_PRIVATE) return (DLADM_STATUS_BADARG); - if (type == DLADM_PROP_VAL_DEFAULT || - type == DLADM_PROP_VAL_MODIFIABLE) { + if (type == DLADM_PROP_VAL_MODIFIABLE) { *prop_val = &tmp; *val_cnt = 1; return (DLADM_STATUS_OK); @@ -1968,13 +2012,15 @@ dld_get_prop(datalink_id_t linkid, const char *prop_name, /* * private properties: all parsing is done in the kernel. */ - dip = dld_buf_alloc(1024, linkid, prop_name, &status); + dip = dld_buf_alloc(1024, linkid, prop_name, dld_flags, &status); if (dip == NULL) return (status); dsize = DLD_PROPBUF_SIZE(dip->pr_valsize); - if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) + if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0) { + free(dip); return (DLADM_STATUS_BADARG); + } if ((status = i_dladm_ioctl(fd, DLDIOCGETPROP, dip, dsize)) < 0) { status = dladm_errno2status(errno); @@ -1982,5 +2028,42 @@ dld_get_prop(datalink_id_t linkid, const char *prop_name, (void) strncpy(*prop_val, dip->pr_val, DLADM_PROP_VAL_MAX); *val_cnt = 1; } + + (void) close(fd); + free(dip); + return (status); +} + + +static dladm_status_t +i_dladm_getset_defval(prop_desc_t *pdp, datalink_id_t linkid, + datalink_media_t media, uint_t flags) +{ + dladm_status_t status; + char **prop_vals = NULL, *buf; + size_t bufsize; + uint_t cnt; + int i; + + /* + * Allocate buffer needed for prop_vals array. We can have at most + * DLADM_MAX_PROP_VALCNT char *prop_vals[] entries, where + * each entry has max size DLADM_PROP_VAL_MAX + */ + bufsize = + (sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT; + buf = malloc(bufsize); + prop_vals = (char **)(void *)buf; + for (i = 0; i < DLADM_MAX_PROP_VALCNT; i++) { + prop_vals[i] = buf + + sizeof (char *) * DLADM_MAX_PROP_VALCNT + + i * DLADM_PROP_VAL_MAX; + } + status = pdp->pd_get(pdp, linkid, prop_vals, &cnt, media, DLD_DEFAULT); + if (status == DLADM_STATUS_OK) { + status = i_dladm_set_single_prop(linkid, pdp->pd_class, + media, pdp, prop_vals, cnt, flags); + } + free(buf); return (status); } diff --git a/usr/src/uts/common/Makefile.files b/usr/src/uts/common/Makefile.files index de89498de3..d08fb4f088 100644 --- a/usr/src/uts/common/Makefile.files +++ b/usr/src/uts/common/Makefile.files @@ -567,7 +567,7 @@ DLS_OBJS += dls.o dls_link.o dls_mod.o dls_stat.o dls_vlan.o \ GLD_OBJS += gld.o gldutil.o -MAC_OBJS += mac.o mac_mod.o mac_stat.o +MAC_OBJS += mac.o mac_mod.o mac_stat.o mac_ndd.o MAC_ETHER_OBJS += mac_ether.o @@ -1560,7 +1560,7 @@ E1000G_OBJS += e1000_80003es2lan.o e1000_82540.o e1000_82541.o e1000_82542.o \ e1000_82543.o e1000_82571.o e1000_api.o e1000_ich8lan.o \ e1000_mac.o e1000_manage.o e1000_nvm.o e1000_osdep.o \ e1000_phy.o e1000g_debug.o e1000g_main.o e1000g_alloc.o \ - e1000g_tx.o e1000g_rx.o e1000g_stat.o e1000g_ndd.o + e1000g_tx.o e1000g_rx.o e1000g_stat.o # # Intel 82575 1G NIC driver module diff --git a/usr/src/uts/common/io/bge/bge_impl.h b/usr/src/uts/common/io/bge/bge_impl.h index 2da4240765..f801f7f305 100644 --- a/usr/src/uts/common/io/bge/bge_impl.h +++ b/usr/src/uts/common/io/bge/bge_impl.h @@ -639,73 +639,6 @@ typedef struct { boolean_t (*phys_check)(struct bge *, boolean_t); } phys_ops_t; -/* - * Named Data (ND) Parameter Management Structure - */ -typedef struct { - int ndp_info; - int ndp_min; - int ndp_max; - int ndp_val; - char *ndp_name; -} nd_param_t; /* 0x18 (24) bytes */ - -/* - * NDD parameter indexes, divided into: - * - * read-only parameters describing the hardware's capabilities - * read-write parameters controlling the advertised capabilities - * read-only parameters describing the partner's capabilities - * read-only parameters describing the link state - */ -enum { - PARAM_AUTONEG_CAP, - PARAM_PAUSE_CAP, - PARAM_ASYM_PAUSE_CAP, - PARAM_1000FDX_CAP, - PARAM_1000HDX_CAP, - PARAM_100T4_CAP, - PARAM_100FDX_CAP, - PARAM_100HDX_CAP, - PARAM_10FDX_CAP, - PARAM_10HDX_CAP, - - PARAM_ADV_AUTONEG_CAP, - PARAM_ADV_PAUSE_CAP, - PARAM_ADV_ASYM_PAUSE_CAP, - PARAM_ADV_1000FDX_CAP, - PARAM_ADV_1000HDX_CAP, - PARAM_ADV_100T4_CAP, - PARAM_ADV_100FDX_CAP, - PARAM_ADV_100HDX_CAP, - PARAM_ADV_10FDX_CAP, - PARAM_ADV_10HDX_CAP, - - PARAM_LP_AUTONEG_CAP, - PARAM_LP_PAUSE_CAP, - PARAM_LP_ASYM_PAUSE_CAP, - PARAM_LP_1000FDX_CAP, - PARAM_LP_1000HDX_CAP, - PARAM_LP_100T4_CAP, - PARAM_LP_100FDX_CAP, - PARAM_LP_100HDX_CAP, - PARAM_LP_10FDX_CAP, - PARAM_LP_10HDX_CAP, - - PARAM_LINK_STATUS, - PARAM_LINK_SPEED, - PARAM_LINK_DUPLEX, - - PARAM_LINK_AUTONEG, - PARAM_LINK_RX_PAUSE, - PARAM_LINK_TX_PAUSE, - - PARAM_MSI_CNT, - - PARAM_DRAIN_MAX, - - PARAM_COUNT -}; /* * Actual state of the BCM570x chip @@ -936,7 +869,6 @@ typedef struct bge { * NDD parameters (protected by genlock) */ caddr_t nd_data_p; - nd_param_t *nd_params; /* * A flag to prevent excessive config space accesses @@ -972,9 +904,36 @@ typedef struct bge { param_en_100hdx:1, param_en_10fdx:1, param_en_10hdx:1, - param_pad_to_32:24; + param_adv_autoneg:1, + param_adv_1000fdx:1, + param_adv_1000hdx:1, + param_adv_100fdx:1, + param_adv_100hdx:1, + param_adv_10fdx:1, + param_adv_10hdx:1, + param_lp_autoneg:1, + param_lp_pause:1, + param_lp_asym_pause:1, + param_lp_1000fdx:1, + param_lp_1000hdx:1, + param_lp_100fdx:1, + param_lp_100hdx:1, + param_lp_10fdx:1, + param_lp_10hdx:1, + param_link_up:1, + param_link_autoneg:1, + param_adv_pause:1, + param_adv_asym_pause:1, + param_link_rx_pause:1, + param_link_tx_pause:1, + param_pad_to_32:2; uint32_t param_loop_mode; + uint32_t param_msi_cnt; + uint32_t param_drain_max; + uint64_t param_link_speed; + link_duplex_t param_link_duplex; + } bge_t; /* @@ -993,39 +952,6 @@ typedef struct bge { #define PROGRESS_KSTATS 0x2000 /* kstats created */ #define PROGRESS_READY 0x8000 /* ready for work */ -/* - * Shorthand for the NDD parameters - */ -#define param_adv_autoneg nd_params[PARAM_ADV_AUTONEG_CAP].ndp_val -#define param_adv_pause nd_params[PARAM_ADV_PAUSE_CAP].ndp_val -#define param_adv_asym_pause nd_params[PARAM_ADV_ASYM_PAUSE_CAP].ndp_val -#define param_adv_1000fdx nd_params[PARAM_ADV_1000FDX_CAP].ndp_val -#define param_adv_1000hdx nd_params[PARAM_ADV_1000HDX_CAP].ndp_val -#define param_adv_100fdx nd_params[PARAM_ADV_100FDX_CAP].ndp_val -#define param_adv_100hdx nd_params[PARAM_ADV_100HDX_CAP].ndp_val -#define param_adv_10fdx nd_params[PARAM_ADV_10FDX_CAP].ndp_val -#define param_adv_10hdx nd_params[PARAM_ADV_10HDX_CAP].ndp_val - -#define param_lp_autoneg nd_params[PARAM_LP_AUTONEG_CAP].ndp_val -#define param_lp_pause nd_params[PARAM_LP_PAUSE_CAP].ndp_val -#define param_lp_asym_pause nd_params[PARAM_LP_ASYM_PAUSE_CAP].ndp_val -#define param_lp_1000fdx nd_params[PARAM_LP_1000FDX_CAP].ndp_val -#define param_lp_1000hdx nd_params[PARAM_LP_1000HDX_CAP].ndp_val -#define param_lp_100fdx nd_params[PARAM_LP_100FDX_CAP].ndp_val -#define param_lp_100hdx nd_params[PARAM_LP_100HDX_CAP].ndp_val -#define param_lp_10fdx nd_params[PARAM_LP_10FDX_CAP].ndp_val -#define param_lp_10hdx nd_params[PARAM_LP_10HDX_CAP].ndp_val - -#define param_link_up nd_params[PARAM_LINK_STATUS].ndp_val -#define param_link_speed nd_params[PARAM_LINK_SPEED].ndp_val -#define param_link_duplex nd_params[PARAM_LINK_DUPLEX].ndp_val - -#define param_link_autoneg nd_params[PARAM_LINK_AUTONEG].ndp_val -#define param_link_rx_pause nd_params[PARAM_LINK_RX_PAUSE].ndp_val -#define param_link_tx_pause nd_params[PARAM_LINK_TX_PAUSE].ndp_val - -#define param_msi_cnt nd_params[PARAM_MSI_CNT].ndp_val -#define param_drain_max nd_params[PARAM_DRAIN_MAX].ndp_val /* * Sync a DMA area described by a dma_area_t @@ -1286,9 +1212,6 @@ boolean_t bge_phys_check(bge_t *bgep); /* bge_ndd.c */ int bge_nd_init(bge_t *bgep); -enum ioc_reply bge_nd_ioctl(bge_t *bgep, queue_t *wq, mblk_t *mp, - struct iocblk *iocp); -void bge_nd_cleanup(bge_t *bgep); /* bge_recv.c */ void bge_receive(bge_t *bgep, bge_status_t *bsp); diff --git a/usr/src/uts/common/io/bge/bge_main2.c b/usr/src/uts/common/io/bge/bge_main2.c index c9db4a1da2..a5ec142b25 100644 --- a/usr/src/uts/common/io/bge/bge_main2.c +++ b/usr/src/uts/common/io/bge/bge_main2.c @@ -34,7 +34,7 @@ * This is the string displayed by modinfo, etc. * Make sure you keep the version ID up to date! */ -static char bge_ident[] = "Broadcom Gb Ethernet v0.61"; +static char bge_ident[] = "Broadcom Gb Ethernet"; /* * Property names @@ -131,11 +131,11 @@ static int bge_m_unicst_get(void *, mac_multi_addr_t *); static int bge_m_setprop(void *, const char *, mac_prop_id_t, uint_t, const void *); static int bge_m_getprop(void *, const char *, mac_prop_id_t, - uint_t, void *); + uint_t, uint_t, void *); static int bge_set_priv_prop(bge_t *, const char *, uint_t, const void *); static int bge_get_priv_prop(bge_t *, const char *, uint_t, - void *); + uint_t, void *); #define BGE_M_CALLBACK_FLAGS\ (MC_RESOURCES | MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP) @@ -158,6 +158,14 @@ static mac_callbacks_t bge_m_callbacks = { bge_m_getprop }; +mac_priv_prop_t bge_priv_prop[] = { + {"_adv_asym_pause_cap", MAC_PROP_PERM_RW}, + {"_adv_pause_cap", MAC_PROP_PERM_RW} +}; + +#define BGE_MAX_PRIV_PROPS \ + (sizeof (bge_priv_prop) / sizeof (mac_priv_prop_t)) + /* * ========== Transmit and receive ring reinitialisation ========== */ @@ -885,7 +893,7 @@ bge_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, { bge_t *bgep = barg; int err = 0; - uint64_t cur_mtu, new_mtu; + uint32_t cur_mtu, new_mtu; uint_t maxsdu; link_flowctrl_t fl; @@ -899,6 +907,19 @@ bge_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, mutex_exit(bgep->genlock); return (EBUSY); } + if ((bgep->chipid.flags & CHIP_FLAG_SERDES) && + ((pr_num == DLD_PROP_EN_100FDX_CAP) || + (pr_num == DLD_PROP_EN_100FDX_CAP) || + (pr_num == DLD_PROP_EN_10FDX_CAP) || + (pr_num == DLD_PROP_EN_10HDX_CAP))) { + /* + * these properties are read/write on copper, + * read-only and 0 on serdes + */ + mutex_exit(bgep->genlock); + return (ENOTSUP); + } + switch (pr_num) { case DLD_PROP_EN_1000FDX_CAP: bgep->param_en_1000fdx = *(uint8_t *)pr_val; @@ -936,16 +957,17 @@ reprogram: case DLD_PROP_STATUS: case DLD_PROP_SPEED: case DLD_PROP_DUPLEX: - err = EINVAL; /* read-only prop. Can't set this */ + err = ENOTSUP; /* read-only prop. Can't set this */ break; case DLD_PROP_AUTONEG: bgep->param_adv_autoneg = *(uint8_t *)pr_val; if (bge_reprogram(bgep) == IOC_INVAL) err = EINVAL; break; - case DLD_PROP_DEFMTU: + case DLD_PROP_MTU: cur_mtu = bgep->chipid.default_mtu; bcopy(pr_val, &new_mtu, sizeof (new_mtu)); + if (new_mtu == cur_mtu) { err = 0; break; @@ -984,7 +1006,7 @@ reprogram: bcopy(pr_val, &fl, sizeof (fl)); switch (fl) { default: - err = EINVAL; + err = ENOTSUP; break; case LINK_FLOWCTRL_NONE: bgep->param_adv_pause = 0; @@ -1035,56 +1057,66 @@ reprogram: } break; - default: + case DLD_PROP_PRIVATE: err = bge_set_priv_prop(bgep, pr_name, pr_valsize, pr_val); break; + default: + err = ENOTSUP; + break; } mutex_exit(bgep->genlock); return (err); } + static int bge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, - uint_t pr_valsize, void *pr_val) + uint_t pr_flags, uint_t pr_valsize, void *pr_val) { bge_t *bgep = barg; int err = 0; link_flowctrl_t fl; - uint64_t tmp = 0; + uint64_t speed; + int flags = bgep->chipid.flags; + boolean_t is_default = (pr_flags & DLD_DEFAULT); + if (pr_valsize == 0) + return (EINVAL); bzero(pr_val, pr_valsize); switch (pr_num) { case DLD_PROP_DUPLEX: - if (pr_valsize < sizeof (uint8_t)) + if (pr_valsize < sizeof (link_duplex_t)) return (EINVAL); - *(uint8_t *)pr_val = bgep->param_link_duplex; + bcopy(&bgep->param_link_duplex, pr_val, + sizeof (link_duplex_t)); break; case DLD_PROP_SPEED: - if (pr_valsize < sizeof (uint64_t)) + if (pr_valsize < sizeof (speed)) return (EINVAL); - tmp = bgep->param_link_speed * 1000000ull; - bcopy(&tmp, pr_val, sizeof (tmp)); + speed = bgep->param_link_speed * 1000000ull; + bcopy(&speed, pr_val, sizeof (speed)); break; case DLD_PROP_STATUS: - if (pr_valsize < sizeof (uint8_t)) + if (pr_valsize < sizeof (link_state_t)) return (EINVAL); - *(uint8_t *)pr_val = bgep->param_link_up; + bcopy(&bgep->link_state, pr_val, + sizeof (link_state_t)); break; case DLD_PROP_AUTONEG: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_autoneg; + if (is_default) + *(uint8_t *)pr_val = 1; + else + *(uint8_t *)pr_val = bgep->param_adv_autoneg; break; - case DLD_PROP_DEFMTU: { - if (pr_valsize < sizeof (uint64_t)) - return (EINVAL); - tmp = bgep->chipid.default_mtu; - bcopy(&tmp, pr_val, sizeof (tmp)); - break; - } case DLD_PROP_FLOWCTRL: - if (pr_valsize < sizeof (link_flowctrl_t)) + if (pr_valsize < sizeof (fl)) return (EINVAL); + if (is_default) { + fl = LINK_FLOWCTRL_BI; + bcopy(&fl, pr_val, sizeof (fl)); + break; + } + if (bgep->param_link_rx_pause && !bgep->param_link_tx_pause) fl = LINK_FLOWCTRL_RX; @@ -1103,69 +1135,103 @@ bge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, bcopy(&fl, pr_val, sizeof (fl)); break; case DLD_PROP_ADV_1000FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_1000fdx; + if (is_default) + *(uint8_t *)pr_val = 1; + else + *(uint8_t *)pr_val = bgep->param_adv_1000fdx; break; case DLD_PROP_EN_1000FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_1000fdx; + if (is_default) + *(uint8_t *)pr_val = 1; + else + *(uint8_t *)pr_val = bgep->param_en_1000fdx; break; case DLD_PROP_ADV_1000HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_1000hdx; + if (is_default) + *(uint8_t *)pr_val = 1; + else + *(uint8_t *)pr_val = bgep->param_adv_1000hdx; break; case DLD_PROP_EN_1000HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_1000hdx; + if (is_default) + *(uint8_t *)pr_val = 1; + else + *(uint8_t *)pr_val = bgep->param_en_1000hdx; break; case DLD_PROP_ADV_100FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_100fdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_adv_100fdx; + } break; case DLD_PROP_EN_100FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_100fdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_en_100fdx; + } break; case DLD_PROP_ADV_100HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_100hdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_adv_100hdx; + } break; case DLD_PROP_EN_100HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_100hdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_en_100hdx; + } break; case DLD_PROP_ADV_10FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_10fdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_adv_10fdx; + } break; case DLD_PROP_EN_10FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_10fdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_en_10fdx; + } break; case DLD_PROP_ADV_10HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_adv_10hdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_adv_10hdx; + } break; case DLD_PROP_EN_10HDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); - *(uint8_t *)pr_val = bgep->param_en_10hdx; + if (is_default) { + *(uint8_t *)pr_val = + ((flags & CHIP_FLAG_SERDES) ? 0 : 1); + } else { + *(uint8_t *)pr_val = bgep->param_en_10hdx; + } break; - default: - err = bge_get_priv_prop(bgep, pr_name, pr_valsize, - pr_val); + case DLD_PROP_ADV_100T4_CAP: + case DLD_PROP_EN_100T4_CAP: + *(uint8_t *)pr_val = 0; + break; + case DLD_PROP_PRIVATE: + err = bge_get_priv_prop(bgep, pr_name, pr_flags, + pr_valsize, pr_val); return (err); + default: + return (ENOTSUP); } return (0); } @@ -1178,6 +1244,28 @@ bge_set_priv_prop(bge_t *bgep, const char *pr_name, uint_t pr_valsize, int err = 0; long result; + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + (void) ddi_strtol(pr_val, (char **)NULL, 0, &result); + if (result > 1 || result < 0) { + err = EINVAL; + } else { + bgep->param_adv_pause = result; + if (bge_reprogram(bgep) == IOC_INVAL) + err = EINVAL; + } + return (err); + } + if (strcmp(pr_name, "_adv_asym_pause_cap") == 0) { + (void) ddi_strtol(pr_val, (char **)NULL, 0, &result); + if (result > 1 || result < 0) { + err = EINVAL; + } else { + bgep->param_adv_asym_pause = result; + if (bge_reprogram(bgep) == IOC_INVAL) + err = EINVAL; + } + return (err); + } if (strcmp(pr_name, "_drain_max") == 0) { /* @@ -1220,9 +1308,8 @@ bge_set_priv_prop(bge_t *bgep, const char *pr_name, uint_t pr_valsize, return (err); } if (strcmp(pr_name, "_intr_coalesce_blank_time") == 0) { - if (ddi_strtol(pr_val, (char **)NULL, 0, &result) != 0) { + if (ddi_strtol(pr_val, (char **)NULL, 0, &result) != 0) return (EINVAL); - } bgep->chipid.rx_ticks_norm = result; return (0); @@ -1235,49 +1322,55 @@ bge_set_priv_prop(bge_t *bgep, const char *pr_name, uint_t pr_valsize, bgep->chipid.rx_count_norm = result; return (0); } - return (EINVAL); + return (ENOTSUP); } static int -bge_get_priv_prop(bge_t *bge, const char *pr_name, uint_t pr_valsize, - void *pr_val) +bge_get_priv_prop(bge_t *bge, const char *pr_name, uint_t pr_flags, + uint_t pr_valsize, void *pr_val) { - char valstr[MAXNAMELEN]; - int err = EINVAL; - uint_t strsize; - + int err = ENOTSUP; + boolean_t is_default = (pr_flags & DLD_DEFAULT); + int value; + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + value = (is_default? 1 : bge->param_adv_pause); + err = 0; + goto done; + } + if (strcmp(pr_name, "_adv_asym_pause_cap") == 0) { + value = (is_default? 1 : bge->param_adv_asym_pause); + err = 0; + goto done; + } if (strcmp(pr_name, "_drain_max") == 0) { - (void) sprintf(valstr, "%d", bge->param_drain_max); + value = (is_default? 64 : bge->param_drain_max); err = 0; goto done; } if (strcmp(pr_name, "_msi_cnt") == 0) { - (void) sprintf(valstr, "%d", bge->param_msi_cnt); + value = (is_default? 0 : bge->param_msi_cnt); err = 0; goto done; } if (strcmp(pr_name, "_intr_coalesce_blank_time") == 0) { - (void) sprintf(valstr, "%d", bge->chipid.rx_ticks_norm); + value = (is_default? bge_rx_ticks_norm : + bge->chipid.rx_ticks_norm); err = 0; goto done; } if (strcmp(pr_name, "_intr_coalesce_pkt_cnt") == 0) { - (void) sprintf(valstr, "%d", bge->chipid.rx_count_norm); + value = (is_default? bge_rx_count_norm : + bge->chipid.rx_count_norm); err = 0; goto done; } done: - if (err != 0) { - strsize = (uint_t)strlen(valstr); - if (pr_valsize < strsize) { - err = ENOBUFS; - } else { - (void) strlcpy(pr_val, valstr, pr_valsize); - } + if (err == 0) { + (void) snprintf(pr_val, pr_valsize, "%d", value); } return (err); } @@ -1640,11 +1733,6 @@ bge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) case LB_SET_MODE: break; - case ND_GET: - need_privilege = B_FALSE; - /* FALLTHRU */ - case ND_SET: - break; } if (need_privilege) { @@ -1694,10 +1782,6 @@ bge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) status = bge_loop_ioctl(bgep, wq, mp, iocp); break; - case ND_GET: - case ND_SET: - status = bge_nd_ioctl(bgep, wq, mp, iocp); - break; } /* @@ -2780,8 +2864,6 @@ bge_unattach(bge_t *bgep) } if (bgep->progress & PROGRESS_KSTATS) bge_fini_kstats(bgep); - if (bgep->progress & PROGRESS_NDD) - bge_nd_cleanup(bgep); if (bgep->progress & PROGRESS_PHY) bge_phys_reset(bgep); if (bgep->progress & PROGRESS_HWINT) { @@ -2836,7 +2918,6 @@ bge_unattach(bge_t *bgep) ddi_remove_minor_node(bgep->devinfo, NULL); kmem_free(bgep->pstats, sizeof (bge_statistics_reg_t)); - kmem_free(bgep->nd_params, PARAM_COUNT * sizeof (nd_param_t)); kmem_free(bgep, sizeof (*bgep)); } @@ -2957,8 +3038,6 @@ bge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) bgep = kmem_zalloc(sizeof (*bgep), KM_SLEEP); bgep->pstats = kmem_zalloc(sizeof (bge_statistics_reg_t), KM_SLEEP); - bgep->nd_params = - kmem_zalloc(PARAM_COUNT * sizeof (nd_param_t), KM_SLEEP); ddi_set_driver_private(devinfo, bgep); bgep->bge_guard = BGE_GUARD; bgep->devinfo = devinfo; @@ -3101,6 +3180,8 @@ bge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) ddi_fm_service_impact(bgep->devinfo, DDI_SERVICE_LOST); goto attach_fail; } + + err = bge_alloc_bufs(bgep); if (err != DDI_SUCCESS) { bge_problem(bgep, "DMA buffer allocation failed"); @@ -3267,7 +3348,7 @@ bge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) bgep->progress |= PROGRESS_PHY; /* - * Register NDD-tweakable parameters + * initialize NDD-tweakable parameters */ if (bge_nd_init(bgep)) { bge_problem(bgep, "bge_nd_init() failed"); @@ -3306,6 +3387,9 @@ bge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) macp->m_min_sdu = 0; macp->m_max_sdu = cidp->ethmax_size - sizeof (struct ether_header); macp->m_margin = VLAN_TAGSZ; + macp->m_priv_props = bge_priv_prop; + macp->m_priv_prop_count = BGE_MAX_PRIV_PROPS; + /* * Finally, we're ready to register ourselves with the MAC layer * interface; if this succeeds, we're all ready to start() diff --git a/usr/src/uts/common/io/bge/bge_ndd.c b/usr/src/uts/common/io/bge/bge_ndd.c index 280f3b6bcb..e70b894d2b 100644 --- a/usr/src/uts/common/io/bge/bge_ndd.c +++ b/usr/src/uts/common/io/bge/bge_ndd.c @@ -39,103 +39,6 @@ static char duplex_propname[] = "full-duplex"; static char supported_net[] = "supported-network-types"; /* - * Notes: - * The first character of the <name> field encodes the read/write - * status of the parameter: - * '=' => read-only, - * '-' => read-only and forced to 0 on serdes - * '+' => read/write, - * '?' => read/write on copper, read-only and 0 on serdes - * '!' => invisible! - * - * For writable parameters, we check for a driver property with the - * same name; if found, and its value is in range, we initialise - * the parameter from the property, overriding the default in the - * table below. - * - * A NULL in the <name> field terminates the array. - * - * The <info> field is used here to provide the index of the - * parameter to be initialised; thus it doesn't matter whether - * this table is kept ordered or not. - * - * The <info> field in the per-instance copy, on the other hand, - * is used to count assignments so that we can tell when a magic - * parameter has been set via ndd (see bge_param_set()). - */ -static const nd_param_t nd_template[] = { -/* info min max init r/w+name */ - -/* Our hardware capabilities */ -{ PARAM_AUTONEG_CAP, 0, 1, 1, "=autoneg_cap" }, -{ PARAM_PAUSE_CAP, 0, 1, 1, "=pause_cap" }, -{ PARAM_ASYM_PAUSE_CAP, 0, 1, 1, "=asym_pause_cap" }, -{ PARAM_1000FDX_CAP, 0, 1, 1, "=1000fdx_cap" }, -{ PARAM_1000HDX_CAP, 0, 1, 1, "=1000hdx_cap" }, -{ PARAM_100T4_CAP, 0, 1, 0, "=100T4_cap" }, -{ PARAM_100FDX_CAP, 0, 1, 1, "-100fdx_cap" }, -{ PARAM_100HDX_CAP, 0, 1, 1, "-100hdx_cap" }, -{ PARAM_10FDX_CAP, 0, 1, 1, "-10fdx_cap" }, -{ PARAM_10HDX_CAP, 0, 1, 1, "-10hdx_cap" }, - -/* Our advertised capabilities */ -{ PARAM_ADV_AUTONEG_CAP, 0, 1, 1, "+adv_autoneg_cap" }, -{ PARAM_ADV_PAUSE_CAP, 0, 1, 1, "+adv_pause_cap" }, -{ PARAM_ADV_ASYM_PAUSE_CAP, 0, 1, 1, "+adv_asym_pause_cap" }, -{ PARAM_ADV_1000FDX_CAP, 0, 1, 1, "+adv_1000fdx_cap" }, -{ PARAM_ADV_1000HDX_CAP, 0, 1, 1, "+adv_1000hdx_cap" }, -{ PARAM_ADV_100T4_CAP, 0, 1, 0, "=adv_100T4_cap" }, -{ PARAM_ADV_100FDX_CAP, 0, 1, 1, "?adv_100fdx_cap" }, -{ PARAM_ADV_100HDX_CAP, 0, 1, 1, "?adv_100hdx_cap" }, -{ PARAM_ADV_10FDX_CAP, 0, 1, 1, "?adv_10fdx_cap" }, -{ PARAM_ADV_10HDX_CAP, 0, 1, 1, "?adv_10hdx_cap" }, - -/* Partner's advertised capabilities */ -{ PARAM_LP_AUTONEG_CAP, 0, 1, 0, "-lp_autoneg_cap" }, -{ PARAM_LP_PAUSE_CAP, 0, 1, 0, "-lp_pause_cap" }, -{ PARAM_LP_ASYM_PAUSE_CAP, 0, 1, 0, "-lp_asym_pause_cap" }, -{ PARAM_LP_1000FDX_CAP, 0, 1, 0, "-lp_1000fdx_cap" }, -{ PARAM_LP_1000HDX_CAP, 0, 1, 0, "-lp_1000hdx_cap" }, -{ PARAM_LP_100T4_CAP, 0, 1, 0, "-lp_100T4_cap" }, -{ PARAM_LP_100FDX_CAP, 0, 1, 0, "-lp_100fdx_cap" }, -{ PARAM_LP_100HDX_CAP, 0, 1, 0, "-lp_100hdx_cap" }, -{ PARAM_LP_10FDX_CAP, 0, 1, 0, "-lp_10fdx_cap" }, -{ PARAM_LP_10HDX_CAP, 0, 1, 0, "-lp_10hdx_cap" }, - -/* Current operating modes */ -{ PARAM_LINK_STATUS, 0, 1, 0, "-link_status" }, -{ PARAM_LINK_SPEED, 0, 1000, 0, "-link_speed" }, -{ PARAM_LINK_DUPLEX, 0, 2, 0, "-link_duplex" }, - -{ PARAM_LINK_AUTONEG, 0, 1, 0, "-link_autoneg" }, -{ PARAM_LINK_RX_PAUSE, 0, 1, 0, "-link_rx_pause" }, -{ PARAM_LINK_TX_PAUSE, 0, 1, 0, "-link_tx_pause" }, - -/* Terminator */ -{ PARAM_COUNT, 0, 0, 0, NULL } -}; - - -/* ============== NDD Support Functions =============== */ - -/* - * Extracts the value from the bge parameter array and prints - * the parameter value. cp points to the required parameter. - */ -static int -bge_param_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) -{ - nd_param_t *ndp; - - _NOTE(ARGUNUSED(q, credp)) - - ndp = (nd_param_t *)cp; - (void) mi_mpprintf(mp, "%d", ndp->ndp_val); - - return (0); -} - -/* * synchronize the adv* and en* parameters. * * See comments in <sys/dld.h> for details of the *_en_* @@ -156,115 +59,60 @@ bge_param_sync(bge_t *bgep) bgep->param_en_10hdx = bgep->param_adv_10hdx; } -/* - * Validates the request to set a BGE parameter to a specific value. - * If the request is OK, the parameter is set. Also the <info> field - * is incremented to show that the parameter was touched, even though - * it may have been set to the same value it already had. - */ -static int -bge_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *credp) +boolean_t +bge_nd_get_prop_val(dev_info_t *dip, char *nm, long min, long max, int *pval) { - nd_param_t *ndp; - long new_value; - char *end; - - _NOTE(ARGUNUSED(q, mp, credp)) - - ndp = (nd_param_t *)cp; - new_value = mi_strtol(value, &end, 10); - if (end == value) - return (EINVAL); - if (new_value < ndp->ndp_min || new_value > ndp->ndp_max) - return (EINVAL); + /* + * If there is a driver.conf setting for the prop, we use + * it to initialise the parameter. If it exists but is + * out of range, it's ignored. + */ + if (BGE_PROP_EXISTS(dip, nm)) { + *pval = BGE_PROP_GET_INT(dip, nm); + if (*pval >= min && *pval <= max) + return (B_TRUE); + } + return (B_FALSE); +} - ndp->ndp_val = new_value; - ndp->ndp_info += 1; - return (0); +#define BGE_INIT_PROP(propname, fieldname, initval) { \ + if (bge_nd_get_prop_val(dip, propname, 0, 1, &propval)) \ + bgep->fieldname = propval; \ + else \ + bgep->fieldname = initval; \ } -/* - * Initialise the per-instance parameter array from the global prototype, - * and register each element with the named dispatch handler using nd_load() - */ -static int -bge_param_register(bge_t *bgep) +static void +bge_nd_param_init(bge_t *bgep) { - const nd_param_t *tmplp; dev_info_t *dip; - nd_param_t *ndp; - caddr_t *nddpp; - pfi_t setfn; - char *nm; - int pval; - - BGE_TRACE(("bge_param_register($%p)", (void *)bgep)); + int flags = bgep->chipid.flags; + int propval; dip = bgep->devinfo; - nddpp = &bgep->nd_data_p; - ASSERT(*nddpp == NULL); - - for (tmplp = nd_template; tmplp->ndp_name != NULL; ++tmplp) { - /* - * Copy the template from nd_template[] into the - * proper slot in the per-instance parameters, - * then register the parameter with nd_load() - */ - ndp = &bgep->nd_params[tmplp->ndp_info]; - *ndp = *tmplp; - nm = &ndp->ndp_name[0]; - setfn = bge_param_set; - if (bgep->chipid.flags & CHIP_FLAG_SERDES) - switch (*nm) { - default: - break; - - case '-': - case '?': - ndp->ndp_val = 0; - setfn = NULL; - break; - } - switch (*nm) { - default: - case '!': - continue; - - case '+': - case '?': - break; - - case '=': - case '-': - setfn = NULL; - break; - } - - if (!nd_load(nddpp, ++nm, bge_param_get, setfn, (caddr_t)ndp)) - goto nd_fail; - - /* - * If the parameter is writable, and there's a property - * with the same name, and its value is in range, we use - * it to initialise the parameter. If it exists but is - * out of range, it's ignored. - */ - if (setfn && BGE_PROP_EXISTS(dip, nm)) { - pval = BGE_PROP_GET_INT(dip, nm); - if (pval >= ndp->ndp_min && pval <= ndp->ndp_max) - ndp->ndp_val = pval; - } + /* + * initialize values to those from driver.conf (if available) + * or the default value otherwise. + */ + BGE_INIT_PROP("adv_autoneg_cap", param_adv_autoneg, 1); + BGE_INIT_PROP("adv_1000fdx_cap", param_adv_1000fdx, 1); + BGE_INIT_PROP("adv_1000hdx_cap", param_adv_1000hdx, 1); + BGE_INIT_PROP("adv_pause_cap", param_adv_pause, 1); + BGE_INIT_PROP("adv_asym_pause_cap", param_adv_asym_pause, 1); + + if (flags & CHIP_FLAG_SERDES) { + bgep->param_adv_100fdx = 0; + bgep->param_adv_100hdx = 0; + bgep->param_adv_10fdx = 0; + bgep->param_adv_10hdx = 0; + } else { + BGE_INIT_PROP("adv_100fdx_cap", param_adv_100fdx, 1); + BGE_INIT_PROP("adv_100hdx_cap", param_adv_100hdx, 1); + BGE_INIT_PROP("adv_10fdx_cap", param_adv_10fdx, 1); + BGE_INIT_PROP("adv_10hdx_cap", param_adv_10hdx, 1); } - BGE_DEBUG(("bge_param_register: OK")); - return (DDI_SUCCESS); - -nd_fail: - BGE_DEBUG(("bge_param_register: FAILED at index %d [info %d]", - tmplp-nd_template, tmplp->ndp_info)); - nd_free(nddpp); - return (DDI_FAILURE); } int @@ -277,14 +125,11 @@ bge_nd_init(bge_t *bgep) uint_t noptions; BGE_TRACE(("bge_nd_init($%p)", (void *)bgep)); + bge_nd_param_init(bgep); /* - * Register all the per-instance properties, initialising - * them from the table above or from driver properties set - * in the .conf file + * initialize from .conf file, if appropriate. */ - if (bge_param_register(bgep) != DDI_SUCCESS) - return (-1); /* * check the OBP property "supported-network-types" @@ -456,107 +301,7 @@ bge_nd_init(bge_t *bgep) } } - BGE_DEBUG(("bge_nd_init: autoneg %d" - "pause %d asym_pause %d " - "1000fdx %d 1000hdx %d " - "100fdx %d 100hdx %d " - "10fdx %d 10hdx %d ", - bgep->param_adv_autoneg, - bgep->param_adv_pause, bgep->param_adv_asym_pause, - bgep->param_adv_1000fdx, bgep->param_adv_1000hdx, - bgep->param_adv_100fdx, bgep->param_adv_100hdx, - bgep->param_adv_10fdx, bgep->param_adv_10hdx)); - bge_param_sync(bgep); return (0); } - -enum ioc_reply -bge_nd_ioctl(bge_t *bgep, queue_t *wq, mblk_t *mp, struct iocblk *iocp) -{ - nd_param_t *ndp; - boolean_t ok; - int info; - int cmd; - - BGE_TRACE(("bge_nd_ioctl($%p, $%p, $%p, $%p)", - (void *)bgep, (void *)wq, (void *)mp, (void *)iocp)); - - ASSERT(mutex_owned(bgep->genlock)); - - cmd = iocp->ioc_cmd; - switch (cmd) { - default: - /* NOTREACHED */ - bge_error(bgep, "bge_nd_ioctl: invalid cmd 0x%x", cmd); - return (IOC_INVAL); - - case ND_GET: - /* - * If nd_getset() returns B_FALSE, the command was - * not valid (e.g. unknown name), so we just tell the - * top-level ioctl code to send a NAK (with code EINVAL). - * - * Otherwise, nd_getset() will have built the reply to - * be sent (but not actually sent it), so we tell the - * caller to send the prepared reply. - */ - ok = nd_getset(wq, bgep->nd_data_p, mp); - BGE_DEBUG(("bge_nd_ioctl: get %s", ok ? "OK" : "FAIL")); - return (ok ? IOC_REPLY : IOC_INVAL); - - case ND_SET: - /* - * All adv_* parameters are locked (read-only) while - * the device is in any sort of loopback mode ... - */ - if (bgep->param_loop_mode != BGE_LOOP_NONE) { - iocp->ioc_error = EBUSY; - return (IOC_INVAL); - } - - /* - * Before calling nd_getset(), we save the <info> field - * of the 'autonegotiation' parameter so that we can tell - * whether it was assigned (even if its value doesn't - * actually change). - */ - ndp = &bgep->nd_params[PARAM_ADV_AUTONEG_CAP]; - info = ndp->ndp_info; - ok = nd_getset(wq, bgep->nd_data_p, mp); - - bge_param_sync(bgep); - - /* - * If nd_getset() returns B_FALSE, the command was - * not valid (e.g. unknown name), so we just tell - * the top-level ioctl code to send a NAK (with code - * EINVAL by default). - * - * Otherwise, nd_getset() will have built the reply to - * be sent - but that doesn't imply success! In some - * cases, the reply it's built will have a non-zero - * error code in it (e.g. EPERM if not superuser). - * So, we also drop out in that case ... - */ - BGE_DEBUG(("bge_nd_ioctl: set %s err %d autoneg %d info %d/%d", - ok ? "OK" : "FAIL", iocp->ioc_error, - ndp->ndp_val, info, ndp->ndp_info)); - if (!ok) - return (IOC_INVAL); - if (iocp->ioc_error) - return (IOC_REPLY); - - return (IOC_RESTART_REPLY); - } -} - -/* Free the Named Dispatch Table by calling nd_free */ -void -bge_nd_cleanup(bge_t *bgep) -{ - BGE_TRACE(("bge_nd_cleanup($%p)", (void *)bgep)); - - nd_free(&bgep->nd_data_p); -} diff --git a/usr/src/uts/common/io/dld/dld_drv.c b/usr/src/uts/common/io/dld/dld_drv.c index a499eb7a79..cd2755685f 100644 --- a/usr/src/uts/common/io/dld/dld_drv.c +++ b/usr/src/uts/common/io/dld/dld_drv.c @@ -542,6 +542,7 @@ drv_ioc_prop_common(dld_ctl_str_t *ctls, mblk_t *mp, boolean_t set) macprop.mp_name = dipp->pr_name; macprop.mp_id = dipp->pr_num; + macprop.mp_flags = dipp->pr_flags; if (set) err = mac_set_prop(dvp->dv_dlp->dl_mh, &macprop, diff --git a/usr/src/uts/common/io/e1000g/e1000g_main.c b/usr/src/uts/common/io/e1000g/e1000g_main.c index abc22125db..96f3c0729c 100644 --- a/usr/src/uts/common/io/e1000g/e1000g_main.c +++ b/usr/src/uts/common/io/e1000g/e1000g_main.c @@ -85,11 +85,11 @@ static void e1000g_m_ioctl(void *, queue_t *, mblk_t *); static int e1000g_m_setprop(void *, const char *, mac_prop_id_t, uint_t, const void *); static int e1000g_m_getprop(void *, const char *, mac_prop_id_t, - uint_t, void *); + uint_t, uint_t, void *); static int e1000g_set_priv_prop(struct e1000g *, const char *, uint_t, const void *); static int e1000g_get_priv_prop(struct e1000g *, const char *, uint_t, - void *); + uint_t, void *); static void e1000g_init_locks(struct e1000g *); static void e1000g_destroy_locks(struct e1000g *); static int e1000g_identify_hardware(struct e1000g *); @@ -155,6 +155,28 @@ static int e1000g_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data); static void e1000g_fm_init(struct e1000g *Adapter); static void e1000g_fm_fini(struct e1000g *Adapter); +static int e1000g_get_def_val(struct e1000g *, mac_prop_id_t, uint_t, void *); +static void e1000g_param_sync(struct e1000g *); + +mac_priv_prop_t e1000g_priv_props[] = { + {"_tx_bcopy_threshold", MAC_PROP_PERM_RW}, + {"_tx_interrupt_enable", MAC_PROP_PERM_RW}, + {"_tx_intr_delay", MAC_PROP_PERM_RW}, + {"_tx_intr_abs_delay", MAC_PROP_PERM_RW}, + {"_rx_bcopy_threshold", MAC_PROP_PERM_RW}, + {"_max_num_rcv_packets", MAC_PROP_PERM_RW}, + {"_rx_intr_delay", MAC_PROP_PERM_RW}, + {"_rx_intr_abs_delay", MAC_PROP_PERM_RW}, + {"_intr_throttling_rate", MAC_PROP_PERM_RW}, + {"_intr_adaptive", MAC_PROP_PERM_RW}, + {"_tx_recycle_thresh", MAC_PROP_PERM_RW}, + {"_adv_pause_cap", MAC_PROP_PERM_READ}, + {"_adv_asym_pause_cap", MAC_PROP_PERM_READ}, + {"_tx_recycle_num", MAC_PROP_PERM_RW} +}; +#define E1000G_MAX_PRIV_PROPS \ + (sizeof (e1000g_priv_props)/sizeof (mac_priv_prop_t)) + static struct cb_ops cb_ws_ops = { nulldev, /* cb_open */ @@ -498,15 +520,6 @@ e1000g_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) Adapter->attach_progress |= ATTACH_PROGRESS_INIT; /* - * Initialize NDD parameters - */ - if (e1000g_nd_init(Adapter) != DDI_SUCCESS) { - e1000g_log(Adapter, CE_WARN, "Init ndd failed"); - goto attach_fail; - } - Adapter->attach_progress |= ATTACH_PROGRESS_NDD; - - /* * Register the driver to the MAC */ if (e1000g_register_mac(Adapter) != DDI_SUCCESS) { @@ -576,6 +589,8 @@ e1000g_register_mac(struct e1000g *Adapter) mac->m_min_sdu = 0; mac->m_max_sdu = Adapter->default_mtu; mac->m_margin = VLAN_TAGSZ; + mac->m_priv_props = e1000g_priv_props; + mac->m_priv_prop_count = E1000G_MAX_PRIV_PROPS; err = mac_register(mac, &Adapter->mh); mac_free(mac); @@ -997,10 +1012,6 @@ e1000g_unattach(dev_info_t *devinfo, struct e1000g *Adapter) (void) mac_unregister(Adapter->mh); } - if (Adapter->attach_progress & ATTACH_PROGRESS_NDD) { - e1000g_nd_cleanup(Adapter); - } - if (Adapter->attach_progress & ATTACH_PROGRESS_ADD_INTR) { (void) e1000g_rem_intrs(Adapter); } @@ -1339,6 +1350,8 @@ e1000g_init(struct e1000g *Adapter) /* Save the state of the phy */ e1000g_get_phy_state(Adapter); + e1000g_param_sync(Adapter); + Adapter->init_count++; if (e1000g_check_acc_handle(Adapter->osdep.cfg_handle) != DDI_FM_OK) { @@ -1410,10 +1423,6 @@ e1000g_m_ioctl(void *arg, queue_t *q, mblk_t *mp) status = e1000g_loopback_ioctl(e1000gp, iocp, mp); break; - case ND_GET: - case ND_SET: - status = e1000g_nd_ioctl(e1000gp, q, mp, iocp); - break; #ifdef E1000G_DEBUG case E1000G_IOC_REG_PEEK: @@ -2624,7 +2633,7 @@ e1000g_m_setprop(void *arg, const char *pr_name, mac_prop_id_t pr_num, e1000g_tx_ring_t *tx_ring; int err = 0; link_flowctrl_t fc; - uint64_t cur_mtu, new_mtu; + uint32_t cur_mtu, new_mtu; uint64_t tmp = 0; rw_enter(&Adapter->chip_lock, RW_WRITER); @@ -2704,7 +2713,7 @@ reset: case DLD_PROP_DUPLEX: err = ENOTSUP; /* read-only prop. Can't set this. */ break; - case DLD_PROP_DEFMTU: + case DLD_PROP_MTU: cur_mtu = Adapter->default_mtu; bcopy(pr_val, &new_mtu, sizeof (new_mtu)); if (new_mtu == cur_mtu) { @@ -2766,47 +2775,40 @@ reset: static int e1000g_m_getprop(void *arg, const char *pr_name, mac_prop_id_t pr_num, - uint_t pr_valsize, void *pr_val) + uint_t pr_flags, uint_t pr_valsize, void *pr_val) { struct e1000g *Adapter = arg; struct e1000_mac_info *mac = &Adapter->shared.mac; - int err = EINVAL; + int err = 0; link_flowctrl_t fc; uint64_t tmp = 0; + if (pr_valsize == 0) + return (EINVAL); + bzero(pr_val, pr_valsize); + if ((pr_flags & DLD_DEFAULT) && (pr_num != DLD_PROP_PRIVATE)) { + return (e1000g_get_def_val(Adapter, pr_num, + pr_valsize, pr_val)); + } + switch (pr_num) { case DLD_PROP_DUPLEX: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->link_duplex; - err = 0; - } + if (pr_valsize >= sizeof (link_duplex_t)) { + bcopy(&Adapter->link_duplex, pr_val, + sizeof (link_duplex_t)); + } else + err = EINVAL; break; case DLD_PROP_SPEED: if (pr_valsize >= sizeof (uint64_t)) { tmp = Adapter->link_speed * 1000000ull; bcopy(&tmp, pr_val, sizeof (tmp)); - err = 0; - } - break; - case DLD_PROP_STATUS: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->link_state; - err = 0; - } + } else + err = EINVAL; break; case DLD_PROP_AUTONEG: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_autoneg; - err = 0; - } - break; - case DLD_PROP_DEFMTU: - if (pr_valsize >= sizeof (uint64_t)) { - tmp = Adapter->default_mtu; - bcopy(&tmp, pr_val, sizeof (tmp)); - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_autoneg; break; case DLD_PROP_FLOWCTRL: if (pr_valsize >= sizeof (link_flowctrl_t)) { @@ -2825,84 +2827,52 @@ e1000g_m_getprop(void *arg, const char *pr_name, mac_prop_id_t pr_num, break; } bcopy(&fc, pr_val, sizeof (fc)); - err = 0; - } + } else + err = EINVAL; break; case DLD_PROP_ADV_1000FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_1000fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_1000fdx; break; case DLD_PROP_EN_1000FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_1000fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_1000fdx; break; case DLD_PROP_ADV_1000HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_1000hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_1000hdx; break; case DLD_PROP_EN_1000HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_1000hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_1000hdx; break; case DLD_PROP_ADV_100FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_100fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_100fdx; break; case DLD_PROP_EN_100FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_100fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_100fdx; break; case DLD_PROP_ADV_100HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_100hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_100hdx; break; case DLD_PROP_EN_100HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_100hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_100hdx; break; case DLD_PROP_ADV_10FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_10fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_10fdx; break; case DLD_PROP_EN_10FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_10fdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_10fdx; break; case DLD_PROP_ADV_10HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_adv_10hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_adv_10hdx; break; case DLD_PROP_EN_10HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = Adapter->param_en_10hdx; - err = 0; - } + *(uint8_t *)pr_val = Adapter->param_en_10hdx; + break; + case DLD_PROP_ADV_100T4_CAP: + case DLD_PROP_EN_100T4_CAP: + *(uint8_t *)pr_val = Adapter->param_adv_100t4; break; case DLD_PROP_PRIVATE: err = e1000g_get_priv_prop(Adapter, pr_name, - pr_valsize, pr_val); + pr_flags, pr_valsize, pr_val); break; default: err = ENOTSUP; @@ -3140,79 +3110,102 @@ e1000g_set_priv_prop(struct e1000g *Adapter, const char *pr_name, static int e1000g_get_priv_prop(struct e1000g *Adapter, const char *pr_name, - uint_t pr_valsize, void *pr_val) + uint_t pr_flags, uint_t pr_valsize, void *pr_val) { char valstr[MAXNAMELEN]; int err = ENOTSUP; uint_t strsize; + boolean_t is_default = (pr_flags & DLD_DEFAULT); + int value; + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + if (is_default) + goto done; + value = Adapter->param_adv_pause; + err = 0; + goto done; + } + if (strcmp(pr_name, "_adv_asym_pause_cap") == 0) { + if (is_default) + goto done; + value = Adapter->param_adv_asym_pause; + err = 0; + goto done; + } if (strcmp(pr_name, "_tx_bcopy_threshold") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_bcopy_thresh); + value = (is_default ? DEFAULT_TX_BCOPY_THRESHOLD : + Adapter->tx_bcopy_thresh); err = 0; goto done; } if (strcmp(pr_name, "_tx_interrupt_enable") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_intr_enable); + value = (is_default ? DEFAULT_TX_INTR_ENABLE : + Adapter->tx_intr_enable); err = 0; goto done; } if (strcmp(pr_name, "_tx_intr_delay") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_intr_delay); + value = (is_default ? DEFAULT_TX_INTR_DELAY : + Adapter->tx_intr_delay); err = 0; goto done; } if (strcmp(pr_name, "_tx_intr_abs_delay") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_intr_abs_delay); + value = (is_default ? DEFAULT_TX_INTR_ABS_DELAY : + Adapter->tx_intr_abs_delay); err = 0; goto done; } if (strcmp(pr_name, "_rx_bcopy_threshold") == 0) { - (void) sprintf(valstr, "%d", Adapter->rx_bcopy_thresh); + value = (is_default ? DEFAULT_RX_BCOPY_THRESHOLD : + Adapter->rx_bcopy_thresh); err = 0; goto done; } if (strcmp(pr_name, "_max_num_rcv_packets") == 0) { - (void) sprintf(valstr, "%d", Adapter->rx_limit_onintr); + value = (is_default ? DEFAULT_RX_LIMIT_ON_INTR : + Adapter->rx_limit_onintr); err = 0; goto done; } if (strcmp(pr_name, "_rx_intr_delay") == 0) { - (void) sprintf(valstr, "%d", Adapter->rx_intr_delay); + value = (is_default ? DEFAULT_RX_INTR_DELAY : + Adapter->rx_intr_delay); err = 0; goto done; } if (strcmp(pr_name, "_rx_intr_abs_delay") == 0) { - (void) sprintf(valstr, "%d", Adapter->rx_intr_abs_delay); + value = (is_default ? DEFAULT_RX_INTR_ABS_DELAY : + Adapter->rx_intr_abs_delay); err = 0; goto done; } if (strcmp(pr_name, "_intr_throttling_rate") == 0) { - (void) sprintf(valstr, "%d", Adapter->intr_throttling_rate); + value = (is_default ? DEFAULT_INTR_THROTTLING : + Adapter->intr_throttling_rate); err = 0; goto done; } if (strcmp(pr_name, "_intr_adaptive") == 0) { - (void) sprintf(valstr, "%d", Adapter->intr_adaptive); + value = (is_default ? 1 : Adapter->intr_adaptive); err = 0; goto done; } if (strcmp(pr_name, "_tx_recycle_thresh") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_recycle_thresh); + value = (is_default ? DEFAULT_TX_RECYCLE_THRESHOLD : + Adapter->tx_recycle_thresh); err = 0; goto done; } if (strcmp(pr_name, "_tx_recycle_num") == 0) { - (void) sprintf(valstr, "%d", Adapter->tx_recycle_num); + value = (is_default ? DEFAULT_TX_RECYCLE_NUM : + Adapter->tx_recycle_num); err = 0; goto done; } done: if (err == 0) { - strsize = (uint_t)strlen(valstr); - if (pr_valsize < strsize) - err = ENOBUFS; - else - (void) strlcpy(pr_val, valstr, pr_valsize); + (void) snprintf(pr_val, pr_valsize, "%d", value); } return (err); } @@ -5393,3 +5386,82 @@ e1000g_fm_ereport(struct e1000g *Adapter, char *detail) FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0, NULL); } } + +static int +e1000g_get_def_val(struct e1000g *Adapter, mac_prop_id_t pr_num, + uint_t pr_valsize, void *pr_val) +{ + link_flowctrl_t fl; + uint32_t fc; + int err = 0; + + ASSERT(pr_valsize > 0); + switch (pr_num) { + case DLD_PROP_AUTONEG: + *(uint8_t *)pr_val = + ((Adapter->phy_status & MII_SR_AUTONEG_CAPS) ? 1 : 0); + break; + case DLD_PROP_FLOWCTRL: + if (pr_valsize < sizeof (link_flowctrl_t)) + return (EINVAL); + fl = LINK_FLOWCTRL_BI; + bcopy(&fl, pr_val, sizeof (fl)); + break; + case DLD_PROP_ADV_1000FDX_CAP: + case DLD_PROP_EN_1000FDX_CAP: + *(uint8_t *)pr_val = + ((Adapter->phy_ext_status & IEEE_ESR_1000T_FD_CAPS) || + (Adapter->phy_ext_status & IEEE_ESR_1000X_FD_CAPS)) ? 1 : 0; + break; + case DLD_PROP_ADV_1000HDX_CAP: + case DLD_PROP_EN_1000HDX_CAP: + *(uint8_t *)pr_val = + ((Adapter->phy_ext_status & IEEE_ESR_1000T_HD_CAPS) || + (Adapter->phy_ext_status & IEEE_ESR_1000X_HD_CAPS)) ? 1 : 0; + break; + case DLD_PROP_ADV_100FDX_CAP: + case DLD_PROP_EN_100FDX_CAP: + *(uint8_t *)pr_val = + ((Adapter->phy_status & MII_SR_100X_FD_CAPS) || + (Adapter->phy_status & MII_SR_100T2_FD_CAPS)) ? 1 : 0; + case DLD_PROP_ADV_100HDX_CAP: + case DLD_PROP_EN_100HDX_CAP: + *(uint8_t *)pr_val = + ((Adapter->phy_status & MII_SR_100X_HD_CAPS) || + (Adapter->phy_status & MII_SR_100T2_HD_CAPS)) ? 1 : 0; + break; + case DLD_PROP_ADV_10FDX_CAP: + case DLD_PROP_EN_10FDX_CAP: + *(uint8_t *)pr_val = + (Adapter->phy_status & MII_SR_10T_FD_CAPS) ? 1 : 0; + break; + case DLD_PROP_ADV_10HDX_CAP: + case DLD_PROP_EN_10HDX_CAP: + *(uint8_t *)pr_val = + (Adapter->phy_status & MII_SR_10T_HD_CAPS) ? 1 : 0; + break; + default: + err = ENOTSUP; + break; + } + return (err); +} + +/* + * synchronize the adv* and en* parameters. + * + * See comments in <sys/dld.h> for details of the *_en_* + * parameters. The usage of ndd for setting adv parameters will + * synchronize all the en parameters with the e1000g parameters, + * implicity disalbing any settings made via dladm. + */ +static void +e1000g_param_sync(struct e1000g *Adapter) +{ + Adapter->param_en_1000fdx = Adapter->param_adv_1000fdx; + Adapter->param_en_1000hdx = Adapter->param_adv_1000hdx; + Adapter->param_en_100fdx = Adapter->param_adv_100fdx; + Adapter->param_en_100hdx = Adapter->param_adv_100hdx; + Adapter->param_en_10fdx = Adapter->param_adv_10fdx; + Adapter->param_en_10hdx = Adapter->param_adv_10hdx; +} diff --git a/usr/src/uts/common/io/e1000g/e1000g_sw.h b/usr/src/uts/common/io/e1000g/e1000g_sw.h index 3bc2d988c1..b7368cbe71 100644 --- a/usr/src/uts/common/io/e1000g/e1000g_sw.h +++ b/usr/src/uts/common/io/e1000g/e1000g_sw.h @@ -223,7 +223,7 @@ extern "C" { #define ATTACH_PROGRESS_KSTATS 0x0040 /* Kstats created */ #define ATTACH_PROGRESS_ALLOC 0x0080 /* DMA resources allocated */ #define ATTACH_PROGRESS_INIT 0x0100 /* Driver initialization */ -#define ATTACH_PROGRESS_NDD 0x0200 /* NDD initialized */ +/* 0200 used to be PROGRESS_NDD. Now unused */ #define ATTACH_PROGRESS_MAC 0x0400 /* MAC registered */ #define ATTACH_PROGRESS_ENABLE_INTR 0x0800 /* DDI interrupts enabled */ #define ATTACH_PROGRESS_FMINIT 0x1000 /* FMA initiated */ @@ -399,42 +399,6 @@ extern "C" { #define E1000G_PROP_GET_INT(d, n) ddi_prop_get_int(DDI_DEV_T_ANY, (d), \ DDI_PROP_DONTPASS, (n), -1) -/* - * Shorthand for the NDD parameters - */ -#define param_autoneg_cap nd_params[PARAM_AUTONEG_CAP].ndp_val -#define param_pause_cap nd_params[PARAM_PAUSE_CAP].ndp_val -#define param_asym_pause_cap nd_params[PARAM_ASYM_PAUSE_CAP].ndp_val -#define param_1000fdx_cap nd_params[PARAM_1000FDX_CAP].ndp_val -#define param_1000hdx_cap nd_params[PARAM_1000HDX_CAP].ndp_val -#define param_100t4_cap nd_params[PARAM_100T4_CAP].ndp_val -#define param_100fdx_cap nd_params[PARAM_100FDX_CAP].ndp_val -#define param_100hdx_cap nd_params[PARAM_100HDX_CAP].ndp_val -#define param_10fdx_cap nd_params[PARAM_10FDX_CAP].ndp_val -#define param_10hdx_cap nd_params[PARAM_10HDX_CAP].ndp_val - -#define param_adv_autoneg nd_params[PARAM_ADV_AUTONEG_CAP].ndp_val -#define param_adv_pause nd_params[PARAM_ADV_PAUSE_CAP].ndp_val -#define param_adv_asym_pause nd_params[PARAM_ADV_ASYM_PAUSE_CAP].ndp_val -#define param_adv_1000fdx nd_params[PARAM_ADV_1000FDX_CAP].ndp_val -#define param_adv_1000hdx nd_params[PARAM_ADV_1000HDX_CAP].ndp_val -#define param_adv_100t4 nd_params[PARAM_ADV_100T4_CAP].ndp_val -#define param_adv_100fdx nd_params[PARAM_ADV_100FDX_CAP].ndp_val -#define param_adv_100hdx nd_params[PARAM_ADV_100HDX_CAP].ndp_val -#define param_adv_10fdx nd_params[PARAM_ADV_10FDX_CAP].ndp_val -#define param_adv_10hdx nd_params[PARAM_ADV_10HDX_CAP].ndp_val - -#define param_lp_autoneg nd_params[PARAM_LP_AUTONEG_CAP].ndp_val -#define param_lp_pause nd_params[PARAM_LP_PAUSE_CAP].ndp_val -#define param_lp_asym_pause nd_params[PARAM_LP_ASYM_PAUSE_CAP].ndp_val -#define param_lp_1000fdx nd_params[PARAM_LP_1000FDX_CAP].ndp_val -#define param_lp_1000hdx nd_params[PARAM_LP_1000HDX_CAP].ndp_val -#define param_lp_100t4 nd_params[PARAM_LP_100T4_CAP].ndp_val -#define param_lp_100fdx nd_params[PARAM_LP_100FDX_CAP].ndp_val -#define param_lp_100hdx nd_params[PARAM_LP_100HDX_CAP].ndp_val -#define param_lp_10fdx nd_params[PARAM_LP_10FDX_CAP].ndp_val -#define param_lp_10hdx nd_params[PARAM_LP_10HDX_CAP].ndp_val - #ifdef E1000G_DEBUG /* * E1000G-specific ioctls ... @@ -484,72 +448,6 @@ typedef struct { } nd_param_t; /* - * NDD parameter indexes, divided into: - * - * read-only parameters describing the hardware's capabilities - * read-write parameters controlling the advertised capabilities - * read-only parameters describing the partner's capabilities - * read-write parameters controlling the force speed and duplex - * read-only parameters describing the link state - * read-only parameters describing the driver properties - * read-write parameters controlling the driver properties - */ -enum { - PARAM_AUTONEG_CAP, - PARAM_PAUSE_CAP, - PARAM_ASYM_PAUSE_CAP, - PARAM_1000FDX_CAP, - PARAM_1000HDX_CAP, - PARAM_100T4_CAP, - PARAM_100FDX_CAP, - PARAM_100HDX_CAP, - PARAM_10FDX_CAP, - PARAM_10HDX_CAP, - - PARAM_ADV_AUTONEG_CAP, - PARAM_ADV_PAUSE_CAP, - PARAM_ADV_ASYM_PAUSE_CAP, - PARAM_ADV_1000FDX_CAP, - PARAM_ADV_1000HDX_CAP, - PARAM_ADV_100T4_CAP, - PARAM_ADV_100FDX_CAP, - PARAM_ADV_100HDX_CAP, - PARAM_ADV_10FDX_CAP, - PARAM_ADV_10HDX_CAP, - - PARAM_LP_AUTONEG_CAP, - PARAM_LP_PAUSE_CAP, - PARAM_LP_ASYM_PAUSE_CAP, - PARAM_LP_1000FDX_CAP, - PARAM_LP_1000HDX_CAP, - PARAM_LP_100T4_CAP, - PARAM_LP_100FDX_CAP, - PARAM_LP_100HDX_CAP, - PARAM_LP_10FDX_CAP, - PARAM_LP_10HDX_CAP, - - PARAM_LINK_STATUS, - PARAM_LINK_SPEED, - PARAM_LINK_DUPLEX, - PARAM_LINK_AUTONEG, - - PARAM_MAX_FRAME_SIZE, - PARAM_LOOP_MODE, - PARAM_INTR_TYPE, - - PARAM_TX_BCOPY_THRESHOLD, - PARAM_TX_INTR_ENABLE, - PARAM_TX_TIDV, - PARAM_TX_TADV, - PARAM_RX_BCOPY_THRESHOLD, - PARAM_RX_PKT_ON_INTR, - PARAM_RX_RDTR, - PARAM_RX_RADV, - - PARAM_COUNT -}; - -/* * The entry of the private dip list */ typedef struct _private_devi_list { @@ -992,12 +890,6 @@ typedef struct e1000g { kstat_t *e1000g_ksp; - /* - * NDD parameters - */ - caddr_t nd_data; - nd_param_t nd_params[PARAM_COUNT]; - uint16_t phy_ctrl; /* contents of PHY_CTRL */ uint16_t phy_status; /* contents of PHY_STATUS */ uint16_t phy_an_adv; /* contents of PHY_AUTONEG_ADV */ @@ -1018,7 +910,39 @@ typedef struct e1000g { param_en_100hdx:1, param_en_10fdx:1, param_en_10hdx:1, - param_pad_to_32:26; + param_autoneg_cap:1, + param_pause_cap:1, + param_asym_pause_cap:1, + param_1000fdx_cap:1, + param_1000hdx_cap:1, + param_100t4_cap:1, + param_100fdx_cap:1, + param_100hdx_cap:1, + param_10fdx_cap:1, + param_10hdx_cap:1, + param_adv_autoneg:1, + param_adv_pause:1, + param_adv_asym_pause:1, + param_adv_1000fdx:1, + param_adv_1000hdx:1, + param_adv_100t4:1, + param_adv_100fdx:1, + param_adv_100hdx:1, + param_adv_10fdx:1, + param_adv_10hdx:1, + param_lp_autoneg:1, + param_lp_pause:1, + param_lp_asym_pause:1, + param_lp_1000fdx:1, + param_lp_1000hdx:1, + param_lp_100t4:1; + + uint32_t param_lp_100fdx:1, + param_lp_100hdx:1, + param_lp_10fdx:1, + param_lp_10hdx:1, + param_pad_to_32:28; + } e1000g_t; @@ -1045,10 +969,6 @@ int e1000g_m_stat(void *arg, uint_t stat, uint64_t *val); int e1000g_init_stats(struct e1000g *Adapter); void e1000_tbi_adjust_stats(struct e1000g *Adapter, uint32_t frame_len, uint8_t *mac_addr); -enum ioc_reply e1000g_nd_ioctl(struct e1000g *Adapter, - queue_t *wq, mblk_t *mp, struct iocblk *iocp); -void e1000g_nd_cleanup(struct e1000g *Adapter); -int e1000g_nd_init(struct e1000g *Adapter); void e1000g_clear_interrupt(struct e1000g *Adapter); void e1000g_mask_interrupt(struct e1000g *Adapter); diff --git a/usr/src/uts/common/io/mac/mac.c b/usr/src/uts/common/io/mac/mac.c index 4767f6bf44..435f70f2e6 100644 --- a/usr/src/uts/common/io/mac/mac.c +++ b/usr/src/uts/common/io/mac/mac.c @@ -55,6 +55,7 @@ #include <sys/atomic.h> #include <sys/sdt.h> #include <inet/nd.h> +#include <sys/ethernet.h> #define IMPL_HASHSZ 67 /* prime */ @@ -78,6 +79,7 @@ static kmutex_t i_mactype_lock; static void i_mac_notify_thread(void *); static mblk_t *mac_vnic_tx(void *, mblk_t *); static mblk_t *mac_vnic_txloop(void *, mblk_t *); +static void mac_register_priv_prop(mac_impl_t *, mac_priv_prop_t *, uint_t); /* * Private functions. @@ -1048,20 +1050,18 @@ void mac_ioctl(mac_handle_t mh, queue_t *wq, mblk_t *bp) { mac_impl_t *mip = (mac_impl_t *)mh; - int cmd; + int cmd = ((struct iocblk *)bp->b_rptr)->ioc_cmd; - if (mip->mi_callbacks->mc_callbacks & (MC_SETPROP|MC_GETPROP)) { - cmd = ((struct iocblk *)bp->b_rptr)->ioc_cmd; - if (cmd == ND_SET || cmd == ND_GET) { - /* - * ndd ioctls are Obsolete - */ - cmn_err(CE_WARN, - "The ndd commands are obsolete and may be removed " - "in a future release of Solaris. " - "Use dladm(1M) to manage driver tunables\n"); - } + if ((cmd == ND_GET && (mip->mi_callbacks->mc_callbacks & MC_GETPROP)) || + (cmd == ND_SET && (mip->mi_callbacks->mc_callbacks & MC_SETPROP))) { + /* + * If ndd props were registered, call them. + * Note that ndd ioctls are Obsolete + */ + mac_ndd_ioctl(mip, wq, bp); + return; } + /* * Call the driver to handle the ioctl. The driver may not support * any ioctls, in which case we reply with a NAK on its behalf. @@ -1616,6 +1616,12 @@ mac_register(mac_register_t *mregp, mac_handle_t *mhp) } /* + * Register the private properties. + */ + mac_register_priv_prop(mip, mregp->m_priv_props, + mregp->m_priv_prop_count); + + /* * Stash the driver callbacks into the mac_impl_t, but first sanity * check to make sure all mandatory callbacks are set. */ @@ -1679,6 +1685,7 @@ mac_register(mac_register_t *mregp, mac_handle_t *mhp) */ mac_stat_create(mip); + /* set the gldv3 flag in dn_flags */ dnp = &devnamesp[ddi_driver_major(mip->mi_dip)]; LOCK_DEV_OPS(&dnp->dn_lock); @@ -1797,6 +1804,7 @@ mac_unregister(mac_handle_t mh) mod_hash_val_t val; mac_multicst_addr_t *p, *nextp; mac_margin_req_t *mmr, *nextmmr; + mac_priv_prop_t *mpriv; /* * See if there are any other references to this mac_t (e.g., VLAN's). @@ -1874,6 +1882,9 @@ mac_unregister(mac_handle_t mh) cmn_err(CE_NOTE, "!%s unregistered", mip->mi_name); + mpriv = mip->mi_priv_prop; + kmem_free(mpriv, mip->mi_priv_prop_count * sizeof (*mpriv)); + kmem_cache_free(i_mac_impl_cachep, mip); return (0); @@ -2810,6 +2821,9 @@ mactype_register(mactype_register_t *mtrp) mtp->mt_stats = mtrp->mtr_stats; mtp->mt_statcount = mtrp->mtr_statcount; + mtp->mt_mapping = mtrp->mtr_mapping; + mtp->mt_mappingcount = mtrp->mtr_mappingcount; + if (mod_hash_insert(i_mactype_hash, (mod_hash_key_t)mtp->mt_ident, (mod_hash_val_t)mtp) != 0) { kmem_free(mtp->mt_brdcst_addr, mtp->mt_addr_length); @@ -2880,10 +2894,41 @@ mac_get_prop(mac_handle_t mh, mac_prop_t *macprop, void *val, uint_t valsize) { int err = ENOTSUP; mac_impl_t *mip = (mac_impl_t *)mh; - + uint32_t sdu; + link_state_t link_state; + + switch (macprop->mp_id) { + case DLD_PROP_MTU: + if (valsize < sizeof (sdu)) + return (EINVAL); + if ((macprop->mp_flags & DLD_DEFAULT) == 0) { + mac_sdu_get(mh, NULL, &sdu); + bcopy(&sdu, val, sizeof (sdu)); + return (0); + } else { + if (mip->mi_info.mi_media == DL_ETHER) { + sdu = ETHERMTU; + bcopy(&sdu, val, sizeof (sdu)); + return (0); + } + /* + * ask driver for its default. + */ + break; + } + case DLD_PROP_STATUS: + if (valsize < sizeof (link_state)) + return (EINVAL); + link_state = mac_link_get(mh); + bcopy(&link_state, val, sizeof (link_state)); + return (0); + default: + break; + } if (mip->mi_callbacks->mc_callbacks & MC_GETPROP) { err = mip->mi_callbacks->mc_getprop(mip->mi_driver, - macprop->mp_name, macprop->mp_id, valsize, val); + macprop->mp_name, macprop->mp_id, macprop->mp_flags, + valsize, val); } return (err); } @@ -2901,3 +2946,17 @@ mac_maxsdu_update(mac_handle_t mh, uint_t sdu_max) i_mac_notify(mip, MAC_NOTE_SDU_SIZE); return (0); } + +static void +mac_register_priv_prop(mac_impl_t *mip, mac_priv_prop_t *mpp, uint_t nprop) +{ + mac_priv_prop_t *mpriv; + + if (mpp == NULL) + return; + + mpriv = kmem_zalloc(nprop * sizeof (*mpriv), KM_SLEEP); + (void) memcpy(mpriv, mpp, nprop * sizeof (*mpriv)); + mip->mi_priv_prop = mpriv; + mip->mi_priv_prop_count = nprop; +} diff --git a/usr/src/uts/common/io/mac/mac_ndd.c b/usr/src/uts/common/io/mac/mac_ndd.c new file mode 100644 index 0000000000..838def1821 --- /dev/null +++ b/usr/src/uts/common/io/mac/mac_ndd.c @@ -0,0 +1,394 @@ +/* + * 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 2008 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * functions to handle legacy ndd ioctls + */ +#include <sys/types.h> +#include <sys/mac.h> +#include <sys/mac_impl.h> +#include <inet/nd.h> +#include <sys/mac_ether.h> +#include <sys/policy.h> +#include <sys/strsun.h> + +static int mac_ndd_set_ioctl(mac_impl_t *, mblk_t *, int, int *); +static int mac_ndd_get_ioctl(mac_impl_t *, mblk_t *, int, int *); +static int mac_ndd_get_names(mac_impl_t *, mblk_t *); +static boolean_t mac_add_name(mblk_t *, char *, int); + +/* + * add "<name> (<rwtag>) " into the mblk, allocating more memory if needed. + */ +static boolean_t +mac_add_name(mblk_t *mp, char *name, int ndd_flags) +{ + char *cp, *rwtag; + int len, flags; + + flags = (ndd_flags & (MAC_PROP_PERM_WRITE|MAC_PROP_PERM_READ)); + switch (flags) { + case 0: + rwtag = "no read or write"; + break; + case MAC_PROP_PERM_WRITE: + rwtag = "write only"; + break; + case MAC_PROP_PERM_READ: + rwtag = "read only"; + break; + default: + rwtag = "read and write"; + break; + } + + while (mp->b_cont != NULL) + mp = mp->b_cont; + /* + * allocate space for name, <space>, '(', rwtag, ')', and + * two terminating null chars. + */ + len = strlen(name) + strlen(rwtag) + 6; + if (mp->b_wptr + len >= mp->b_datap->db_lim) { + mp->b_cont = allocb(len, BPRI_HI); + mp = mp->b_cont; + if (mp != NULL) + return (B_FALSE); + } + cp = (char *)mp->b_wptr; + (void) snprintf(cp, len, "%s (%s)", name, rwtag); + mp->b_wptr += strnlen(cp, len); + mp->b_wptr++; /* skip past the terminating \0 */ + return (B_TRUE); +} + + +/* + * handle a query for "ndd -get \?". The result is put into mp, and + * more memory is allocated if needed. The resulting size of the data + * is returned. + */ +static int +mac_ndd_get_names(mac_impl_t *mip, mblk_t *mp) +{ + int size_out, i; + mblk_t *tmp; + mac_priv_prop_t *mpriv; + + if (!mac_add_name(mp, "?", MAC_PROP_PERM_READ)) + return (-1); + + /* first the known ndd mappings */ + for (i = 0; i < mip->mi_type->mt_mappingcount; i++) { + if (!mac_add_name(mp, mip->mi_type->mt_mapping[i].mp_name, + mip->mi_type->mt_mapping[i].mp_flags)) + return (-1); + } + + /* now the driver's ndd variables */ + for (i = 0; i < mip->mi_priv_prop_count; i++) { + + mpriv = &mip->mi_priv_prop[i]; + + /* skip over the "_" */ + if (!mac_add_name(mp, &mpriv->mpp_name[1], mpriv->mpp_flags)) + return (-1); + } + + tmp = mp; + while (tmp->b_cont != NULL) + tmp = tmp->b_cont; + *tmp->b_wptr++ = '\0'; + size_out = msgdsize(mp); + return (size_out); +} + + +/* + * Handle legacy ndd ioctls for ND_GET and ND_SET. + */ +void +mac_ndd_ioctl(mac_impl_t *mip, queue_t *wq, mblk_t *mp) +{ + IOCP iocp; + int cmd, err, rval; + + iocp = (IOCP)mp->b_rptr; + if (iocp->ioc_count == 0 || mp->b_cont == NULL) { + err = EINVAL; + goto done; + } + + cmd = iocp->ioc_cmd; + + if (cmd == ND_SET) { + err = mac_ndd_set_ioctl(mip, mp, iocp->ioc_count, &rval); + } else if (cmd == ND_GET) { + err = mac_ndd_get_ioctl(mip, mp, iocp->ioc_count, &rval); + } +done: + if (err == 0) + miocack(wq, mp, msgdsize(mp->b_cont), rval); + else + miocnak(wq, mp, 0, err); +} + +static int +mac_ndd_get_ioctl(mac_impl_t *mip, mblk_t *mp, int avail, int *rval) +{ + mblk_t *mp1; + char *valp; + uchar_t *value; + uint32_t new_value; + int size_out, i; + int status = EINVAL; + char *name, priv_name[MAXLINKPROPNAME]; + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + + if (mp->b_cont == NULL || avail < 2) + return (EINVAL); + valp = (char *)mp->b_cont->b_rptr; + mp1 = allocb(avail, BPRI_HI); /* the returned buffer */ + if (mp1 == NULL) + return (ENOMEM); + + if (strcmp(valp, "?") == 0) { + /* + * handle "ndd -get <..> \?" queries. + */ + size_out = mac_ndd_get_names(mip, mp1); + if (size_out < 0) { + status = ENOMEM; + goto get_done; + } + if (size_out > avail) { + int excess; + char *cp; + /* + * need more user buffer space. Return as many + * mblks as will fit and return the needed + * buffer size in ioc_rval. + */ + excess = size_out - avail; + *rval = size_out; /* what's needed */ + size_out -= excess; + (void) adjmsg(mp1, -(excess + 1)); + cp = (char *)mp1->b_wptr; + *cp = '\0'; + } + status = 0; + goto get_done; + } + + ASSERT(mip->mi_callbacks->mc_callbacks & MC_GETPROP); + name = valp; + valp = (char *)mp1->b_rptr; + mp1->b_wptr = mp1->b_rptr; + + /* first lookup ndd <-> public property mapping */ + for (i = 0; i < mip->mi_type->mt_mappingcount; i++) { + if (strcmp(name, mip->mi_type->mt_mapping[i].mp_name) != 0) + continue; + + switch (mip->mi_type->mt_mapping[i].mp_valsize) { + case 1: + value = (uchar_t *)&u8; + break; + case 2: + value = (uchar_t *)&u16; + break; + case 4: + value = (uchar_t *)&u32; + break; + default: + value = (uchar_t *)&u64; + break; + } + + if ((mip->mi_type->mt_mapping[i].mp_flags & MAC_PROP_MAP_KSTAT) + != 0) { + u64 = mac_stat_get((mac_handle_t)mip, + mip->mi_type->mt_mapping[i].mp_kstat); + status = 0; + /* + * ether_stats are all always KSTAT_DATA_UINT32 + */ + new_value = u32 = (long)u64; + } else { + status = mip->mi_callbacks->mc_getprop(mip->mi_driver, + name, mip->mi_type->mt_mapping[i].mp_prop_id, 0, + mip->mi_type->mt_mapping[i].mp_valsize, value); + switch (mip->mi_type->mt_mapping[i].mp_valsize) { + case 1: + new_value = u8; + break; + case 2: + new_value = u16; + break; + case 4: + new_value = u32; + break; + case 8: + /* + * The only uint64_t is for speed, which is + * converted to Mbps in ndd reports. + */ + new_value = (u64/1000000); + break; + } + } + + if (status != 0) + goto get_done; + + (void) snprintf(valp, avail, "%d", new_value); + goto update_reply; + } + + /* + * could not find a public property. try the private prop route + * where all string processing will be done by the driver. + */ + (void) snprintf(priv_name, sizeof (priv_name), "_%s", name); + status = mip->mi_callbacks->mc_getprop(mip->mi_driver, priv_name, + DLD_PROP_PRIVATE, 0, avail - 2, mp1->b_rptr); + if (status != 0) + goto get_done; + +update_reply: + size_out += strnlen((const char *)mp1->b_rptr, avail); + valp += size_out; + *valp++ = '\0'; /* need \0\0 */ + *valp++ = '\0'; + mp1->b_wptr = (uchar_t *)valp; + *rval = 0; + +get_done: + freemsg(mp->b_cont); + if (status == 0) + mp->b_cont = mp1; + else { + freemsg(mp1); + mp->b_cont = NULL; + } + return (status); +} + +static int +mac_ndd_set_ioctl(mac_impl_t *mip, mblk_t *mp, int avail, int *rval) +{ + mblk_t *mp1; + char *valp, *name, *new_valuep; + uchar_t *vp; + long new_value; + int status, i; + uint8_t u8; + uint16_t u16; + uint32_t u32; + IOCP iocp; + char priv_name[MAXLINKPROPNAME]; + + if (avail == 0 || !(mp1 = mp->b_cont)) + return (EINVAL); + + if (mp1->b_cont) { + freemsg(mp1->b_cont); + mp1->b_cont = NULL; + } + mp1->b_datap->db_lim[-1] = '\0'; + valp = (char *)mp1->b_rptr; + name = valp; + *rval = 0; + while (*valp++) + ; + if (valp >= (char *)mp1->b_wptr) + valp = NULL; + + new_valuep = valp; + if (ddi_strtol(valp, NULL, 0, &new_value) != 0) + goto priv_prop; + + iocp = (IOCP)mp->b_rptr; + if (valp != NULL && + ((iocp->ioc_cr == NULL) || + ((status = secpolicy_net_config(iocp->ioc_cr, B_FALSE)) != 0))) + return (status); + + status = EINVAL; + + /* first lookup ndd <-> public property mapping */ + for (i = 0; i < mip->mi_type->mt_mappingcount; i++) { + if (strcmp(name, mip->mi_type->mt_mapping[i].mp_name) != 0) + continue; + + if (mip->mi_type->mt_mapping[i].mp_flags & MAC_PROP_MAP_KSTAT) + return (EINVAL); + + if (new_value > mip->mi_type->mt_mapping[i].mp_maxval || + new_value < mip->mi_type->mt_mapping[i].mp_minval || + (mip->mi_type->mt_mapping[i].mp_flags & MAC_PROP_PERM_WRITE) + == 0) + return (EINVAL); + switch (mip->mi_type->mt_mapping[i].mp_valsize) { + case 1: + u8 = (uint8_t)new_value; + vp = (uchar_t *)&u8; + break; + case 2: + u16 = (uint16_t)new_value; + vp = (uchar_t *)&u16; + break; + case 4: + u32 = (uint32_t)new_value; + vp = (uchar_t *)&u32; + break; + case 8: + vp = (uchar_t *)&new_value; + break; + default: + return (ENOTSUP); + } + + status = mip->mi_callbacks->mc_setprop(mip->mi_driver, + name, mip->mi_type->mt_mapping[i].mp_prop_id, + mip->mi_type->mt_mapping[i].mp_valsize, (const void *)vp); + goto done; + } + +priv_prop: + (void) snprintf(priv_name, sizeof (priv_name), "_%s", name); + status = mip->mi_callbacks->mc_setprop(mip->mi_driver, priv_name, + DLD_PROP_PRIVATE, strlen(new_valuep), new_valuep); +done: + freemsg(mp1); + mp->b_cont = NULL; + return (status); +} diff --git a/usr/src/uts/common/io/mac/plugins/mac_ether.c b/usr/src/uts/common/io/mac/plugins/mac_ether.c index f461777891..a0771cf241 100644 --- a/usr/src/uts/common/io/mac/plugins/mac_ether.c +++ b/usr/src/uts/common/io/mac/plugins/mac_ether.c @@ -19,7 +19,7 @@ * CDDL HEADER END */ /* - * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ @@ -119,6 +119,106 @@ static struct modlinkage mac_ether_modlinkage = { static mactype_ops_t mac_ether_type_ops; +static mac_ndd_mapping_t mac_ether_mapping[] = { + {"adv_autoneg_cap", DLD_PROP_AUTONEG, 0, 1, sizeof (uint8_t), + MAC_PROP_PERM_RW}, + + {"adv_1000fdx_cap", DLD_PROP_EN_1000FDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_1000hdx_cap", DLD_PROP_EN_1000HDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_100fdx_cap", DLD_PROP_EN_100FDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_100hdx_cap", DLD_PROP_EN_100HDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_10fdx_cap", DLD_PROP_EN_10FDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_10hdx_cap", DLD_PROP_EN_10HDX_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_RW}, + + {"adv_100T4_cap", DLD_PROP_EN_100T4_CAP, 0, 1, + sizeof (uint8_t), MAC_PROP_PERM_READ}, + + {"link_status", MAC_STAT_LINK_UP, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"link_speed", DLD_PROP_SPEED, 0, LONG_MAX, + sizeof (uint64_t), MAC_PROP_PERM_READ}, + + {"link_duplex", DLD_PROP_DUPLEX, 0, 2, + sizeof (link_duplex_t), MAC_PROP_PERM_READ}, + + {"autoneg_cap", ETHER_STAT_CAP_AUTONEG, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"pause_cap", ETHER_STAT_CAP_PAUSE, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"asym_pause_cap", ETHER_STAT_CAP_ASMPAUSE, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"1000fdx_cap", ETHER_STAT_CAP_1000FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"1000hdx_cap", ETHER_STAT_CAP_1000HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"100T4_cap", ETHER_STAT_CAP_100T4, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"100fdx_cap", ETHER_STAT_CAP_100FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"100hdx_cap", ETHER_STAT_CAP_100HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"10fdx_cap", ETHER_STAT_CAP_10FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"10hdx_cap", ETHER_STAT_CAP_10HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_autoneg_cap", ETHER_STAT_LP_CAP_AUTONEG, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_pause_cap", ETHER_STAT_LP_CAP_PAUSE, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_asym_pause_cap", ETHER_STAT_LP_CAP_ASMPAUSE, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_1000hdx_cap", ETHER_STAT_LP_CAP_1000HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_1000fdx_cap", ETHER_STAT_LP_CAP_1000FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_100T4_cap", ETHER_STAT_LP_CAP_100T4, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_100fdx_cap", ETHER_STAT_LP_CAP_100FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_100hdx_cap", ETHER_STAT_LP_CAP_100HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_10fdx_cap", ETHER_STAT_LP_CAP_10FDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"lp_10hdx_cap", ETHER_STAT_LP_CAP_10HDX, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK}, + + {"link_autoneg", ETHER_STAT_LINK_AUTONEG, 0, 1, + sizeof (long), MAC_PROP_FLAGS_RK} + +}; + + int _init(void) { @@ -135,6 +235,8 @@ _init(void) mtrp->mtr_brdcst_addr = ether_brdcst; mtrp->mtr_stats = ether_stats; mtrp->mtr_statcount = A_CNT(ether_stats); + mtrp->mtr_mapping = mac_ether_mapping; + mtrp->mtr_mappingcount = A_CNT(mac_ether_mapping); if ((err = mactype_register(mtrp)) == 0) { if ((err = mod_install(&mac_ether_modlinkage)) != 0) (void) mactype_unregister(MAC_PLUGIN_IDENT_ETHER); diff --git a/usr/src/uts/common/io/nge/nge.h b/usr/src/uts/common/io/nge/nge.h index e7bbc1512e..dc936e544d 100644 --- a/usr/src/uts/common/io/nge/nge.h +++ b/usr/src/uts/common/io/nge/nge.h @@ -263,71 +263,6 @@ enum send_status { SEND_MAP_SUCCESS /* OK, free msg */ }; - -/* - * NDD parameter indexes, divided into: - * - * read-only parameters describing the hardware's capabilities - * read-write parameters controlling the advertised capabilities - * read-only parameters describing the partner's capabilities - * read-only parameters describing the link state - */ -enum { - PARAM_AUTONEG_CAP, - PARAM_PAUSE_CAP, - PARAM_ASYM_PAUSE_CAP, - PARAM_1000FDX_CAP, - PARAM_1000HDX_CAP, - PARAM_100T4_CAP, - PARAM_100FDX_CAP, - PARAM_100HDX_CAP, - PARAM_10FDX_CAP, - PARAM_10HDX_CAP, - - PARAM_ADV_AUTONEG_CAP, - PARAM_ADV_PAUSE_CAP, - PARAM_ADV_ASYM_PAUSE_CAP, - PARAM_ADV_1000FDX_CAP, - PARAM_ADV_1000HDX_CAP, - PARAM_ADV_100T4_CAP, - PARAM_ADV_100FDX_CAP, - PARAM_ADV_100HDX_CAP, - PARAM_ADV_10FDX_CAP, - PARAM_ADV_10HDX_CAP, - - PARAM_LP_AUTONEG_CAP, - PARAM_LP_PAUSE_CAP, - PARAM_LP_ASYM_PAUSE_CAP, - PARAM_LP_1000FDX_CAP, - PARAM_LP_1000HDX_CAP, - PARAM_LP_100T4_CAP, - PARAM_LP_100FDX_CAP, - PARAM_LP_100HDX_CAP, - PARAM_LP_10FDX_CAP, - PARAM_LP_10HDX_CAP, - - PARAM_LINK_STATUS, - PARAM_LINK_SPEED, - PARAM_LINK_DUPLEX, - - PARAM_LINK_AUTONEG, - PARAM_LINK_RX_PAUSE, - PARAM_LINK_TX_PAUSE, - - PARAM_LOOP_MODE, - PARAM_TXBCOPY_THRESHOLD, - PARAM_RXBCOPY_THRESHOLD, - PARAM_RECV_MAX_PACKET, - PARAM_POLL_QUIET_TIME, - PARAM_POLL_BUSY_TIME, - PARAM_RX_INTR_HWATER, - PARAM_RX_INTR_LWATER, - PARAM_TX_N_INTR, - - PARAM_COUNT -}; - - /* * (Internal) return values from ioctl subroutines */ @@ -429,17 +364,6 @@ typedef struct { struct nge; -/* - * Named Data (ND) Parameter Management Structure - */ -typedef struct { - int ndp_info; - int ndp_min; - int ndp_max; - int ndp_val; - char *ndp_name; -} nd_param_t; - #define CHIP_FLAG_COPPER 0x40 @@ -862,12 +786,6 @@ typedef struct nge { uint32_t param_loop_mode; - /* - * NDD parameters (protected by genlock) - */ - caddr_t nd_data_p; - nd_param_t nd_params[PARAM_COUNT]; - kstat_t *nge_kstats[NGE_KSTAT_COUNT]; nge_statistics_t statistics; @@ -881,54 +799,44 @@ typedef struct nge { param_en_100hdx:1, param_en_10fdx:1, param_en_10hdx:1, - param_pad_to_32:24; + param_adv_autoneg:1, + param_adv_pause:1, + param_adv_asym_pause:1, + param_adv_1000fdx:1, + param_adv_1000hdx:1, + param_adv_100fdx:1, + param_adv_100hdx:1, + param_adv_10fdx:1, + param_adv_10hdx:1, + param_lp_autoneg:1, + param_lp_pause:1, + param_lp_asym_pause:1, + param_lp_1000fdx:1, + param_lp_1000hdx:1, + param_lp_100fdx:1, + param_lp_100hdx:1, + param_lp_10fdx:1, + param_lp_10hdx:1, + param_link_up:1, + param_link_autoneg:1, + param_link_rx_pause:1, + param_link_tx_pause:1, + param_pad_to_32:2; + uint64_t param_link_speed; + link_duplex_t param_link_duplex; + int param_txbcopy_threshold; + int param_rxbcopy_threshold; + int param_recv_max_packet; + int param_poll_quiet_time; + int param_poll_busy_time; + int param_rx_intr_hwater; + int param_rx_intr_lwater; + int param_tx_n_intr; } nge_t; extern const nge_ksindex_t nge_statistics[]; /* - * Shorthand for the NDD parameters - */ -#define param_adv_autoneg nd_params[PARAM_ADV_AUTONEG_CAP].ndp_val -#define param_adv_pause nd_params[PARAM_ADV_PAUSE_CAP].ndp_val -#define param_adv_asym_pause nd_params[PARAM_ADV_ASYM_PAUSE_CAP].ndp_val -#define param_adv_1000fdx nd_params[PARAM_ADV_1000FDX_CAP].ndp_val -#define param_adv_1000hdx nd_params[PARAM_ADV_1000HDX_CAP].ndp_val -#define param_adv_100fdx nd_params[PARAM_ADV_100FDX_CAP].ndp_val -#define param_adv_100hdx nd_params[PARAM_ADV_100HDX_CAP].ndp_val -#define param_adv_10fdx nd_params[PARAM_ADV_10FDX_CAP].ndp_val -#define param_adv_10hdx nd_params[PARAM_ADV_10HDX_CAP].ndp_val - -#define param_lp_autoneg nd_params[PARAM_LP_AUTONEG_CAP].ndp_val -#define param_lp_pause nd_params[PARAM_LP_PAUSE_CAP].ndp_val -#define param_lp_asym_pause nd_params[PARAM_LP_ASYM_PAUSE_CAP].ndp_val -#define param_lp_1000fdx nd_params[PARAM_LP_1000FDX_CAP].ndp_val -#define param_lp_1000hdx nd_params[PARAM_LP_1000HDX_CAP].ndp_val -#define param_lp_100fdx nd_params[PARAM_LP_100FDX_CAP].ndp_val -#define param_lp_100hdx nd_params[PARAM_LP_100HDX_CAP].ndp_val -#define param_lp_10fdx nd_params[PARAM_LP_10FDX_CAP].ndp_val -#define param_lp_10hdx nd_params[PARAM_LP_10HDX_CAP].ndp_val - -#define param_link_up nd_params[PARAM_LINK_STATUS].ndp_val -#define param_link_speed nd_params[PARAM_LINK_SPEED].ndp_val -#define param_link_duplex nd_params[PARAM_LINK_DUPLEX].ndp_val - -#define param_link_autoneg nd_params[PARAM_LINK_AUTONEG].ndp_val -#define param_link_rx_pause nd_params[PARAM_LINK_RX_PAUSE].ndp_val -#define param_link_tx_pause nd_params[PARAM_LINK_TX_PAUSE].ndp_val - -#define param_loop_mode nd_params[PARAM_LOOP_MODE].ndp_val - -#define param_txbcopy_threshold nd_params[PARAM_TXBCOPY_THRESHOLD].ndp_val -#define param_rxbcopy_threshold nd_params[PARAM_RXBCOPY_THRESHOLD].ndp_val -#define param_recv_max_packet nd_params[PARAM_RECV_MAX_PACKET].ndp_val -#define param_poll_quiet_time nd_params[PARAM_POLL_QUIET_TIME].ndp_val -#define param_poll_busy_time nd_params[PARAM_POLL_BUSY_TIME].ndp_val -#define param_rx_intr_hwater nd_params[PARAM_RX_INTR_HWATER].ndp_val -#define param_rx_intr_lwater nd_params[PARAM_RX_INTR_LWATER].ndp_val -#define param_tx_n_intr nd_params[PARAM_TX_N_INTR].ndp_val - -/* * Sync a DMA area described by a dma_area_t */ #define DMA_SYNC(area, flag) ((void) ddi_dma_sync((area).dma_hdl, \ @@ -1110,8 +1018,6 @@ mblk_t *nge_m_tx(void *arg, mblk_t *mp); void nge_tx_recycle(nge_t *ngep, boolean_t is_intr); void nge_tx_recycle_all(nge_t *ngep); -enum ioc_reply nge_nd_ioctl(nge_t *ngep, queue_t *wq, - mblk_t *mp, struct iocblk *iocp); int nge_nd_init(nge_t *ngep); void nge_nd_cleanup(nge_t *ngep); diff --git a/usr/src/uts/common/io/nge/nge_kstats.c b/usr/src/uts/common/io/nge/nge_kstats.c index 28069a836b..5a0f95caff 100644 --- a/usr/src/uts/common/io/nge/nge_kstats.c +++ b/usr/src/uts/common/io/nge/nge_kstats.c @@ -562,6 +562,11 @@ nge_m_stat(void *arg, uint_t stat, uint64_t *val) *val = ngep->param_link_duplex; break; + case ETHER_STAT_CAP_100T4: + case ETHER_STAT_LP_CAP_100T4: + *val = 0; + break; + default: return (ENOTSUP); } diff --git a/usr/src/uts/common/io/nge/nge_main.c b/usr/src/uts/common/io/nge/nge_main.c index 80266592f1..ac84ad3ea8 100644 --- a/usr/src/uts/common/io/nge/nge_main.c +++ b/usr/src/uts/common/io/nge/nge_main.c @@ -154,7 +154,7 @@ static const nge_desc_attr_t nge_hot_desc = { nge_hot_txd_check, }; -static char nge_ident[] = "nVidia 1Gb Ethernet %I%"; +static char nge_ident[] = "nVidia 1Gb Ethernet"; static char clsize_propname[] = "cache-line-size"; static char latency_propname[] = "latency-timer"; static char debug_propname[] = "nge-debug-flags"; @@ -178,11 +178,11 @@ static boolean_t nge_m_getcapab(void *, mac_capab_t, void *); static int nge_m_setprop(void *, const char *, mac_prop_id_t, uint_t, const void *); static int nge_m_getprop(void *, const char *, mac_prop_id_t, - uint_t, void *); + uint_t, uint_t, void *); static int nge_set_priv_prop(nge_t *, const char *, uint_t, const void *); static int nge_get_priv_prop(nge_t *, const char *, uint_t, - void *); + uint_t, void *); #define NGE_M_CALLBACK_FLAGS\ (MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP) @@ -205,6 +205,22 @@ static mac_callbacks_t nge_m_callbacks = { nge_m_getprop }; +mac_priv_prop_t nge_priv_props[] = { + {"_tx_bcopy_threshold", MAC_PROP_PERM_RW}, + {"_rx_bcopy_threshold", MAC_PROP_PERM_RW}, + {"_recv_max_packet", MAC_PROP_PERM_RW}, + {"_poll_quiet_time", MAC_PROP_PERM_RW}, + {"_poll_busy_time", MAC_PROP_PERM_RW}, + {"_rx_intr_hwater", MAC_PROP_PERM_RW}, + {"_rx_intr_lwater", MAC_PROP_PERM_RW}, + {"_adv_pause_cap", MAC_PROP_PERM_RW}, + {"_adv_asym_pause_cap", MAC_PROP_PERM_RW}, + {"_tx_n_intr", MAC_PROP_PERM_RW} +}; + +#define NGE_MAX_PRIV_PROPS \ + (sizeof (nge_priv_props)/sizeof (mac_priv_prop_t)) + static int nge_add_intrs(nge_t *, int); static void nge_rem_intrs(nge_t *); static int nge_register_intrs_and_init_locks(nge_t *); @@ -1391,12 +1407,6 @@ nge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) break; case LB_SET_MODE: break; - - case ND_GET: - need_privilege = B_FALSE; - break; - case ND_SET: - break; } if (need_privilege) { @@ -1440,11 +1450,6 @@ nge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) status = nge_loop_ioctl(ngep, mp, iocp); break; - case ND_GET: - case ND_SET: - status = nge_nd_ioctl(ngep, wq, mp, iocp); - break; - } /* @@ -1534,7 +1539,7 @@ nge_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, { nge_t *ngep = barg; int err = 0; - uint64_t cur_mtu, new_mtu; + uint32_t cur_mtu, new_mtu; link_flowctrl_t fl; mutex_enter(ngep->genlock); @@ -1552,10 +1557,6 @@ nge_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, ngep->param_en_1000fdx = *(uint8_t *)pr_val; ngep->param_adv_1000fdx = *(uint8_t *)pr_val; goto reprogram; - case DLD_PROP_EN_1000HDX_CAP: - ngep->param_en_1000hdx = *(uint8_t *)pr_val; - ngep->param_adv_1000hdx = *(uint8_t *)pr_val; - goto reprogram; case DLD_PROP_EN_100FDX_CAP: ngep->param_en_100fdx = *(uint8_t *)pr_val; ngep->param_adv_100fdx = *(uint8_t *)pr_val; @@ -1585,6 +1586,7 @@ reprogram: case DLD_PROP_STATUS: case DLD_PROP_SPEED: case DLD_PROP_DUPLEX: + case DLD_PROP_EN_1000HDX_CAP: err = ENOTSUP; /* read-only prop. Can't set this */ break; case DLD_PROP_AUTONEG: @@ -1592,7 +1594,7 @@ reprogram: (*ngep->physops->phys_update)(ngep); nge_chip_sync(ngep); break; - case DLD_PROP_DEFMTU: + case DLD_PROP_MTU: cur_mtu = ngep->default_mtu; bcopy(pr_val, &new_mtu, sizeof (new_mtu)); if (new_mtu == cur_mtu) { @@ -1738,50 +1740,47 @@ reprogram: static int nge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, - uint_t pr_valsize, void *pr_val) + uint_t pr_flags, uint_t pr_valsize, void *pr_val) { nge_t *ngep = barg; - int err = EINVAL; + int err = 0; link_flowctrl_t fl; - uint64_t tmp = 0; + uint64_t speed; + boolean_t is_default = (pr_flags & DLD_DEFAULT); + + if (pr_valsize == 0) + return (EINVAL); bzero(pr_val, pr_valsize); switch (pr_num) { case DLD_PROP_DUPLEX: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = ngep->param_link_duplex; - err = 0; - } + if (pr_valsize >= sizeof (link_duplex_t)) { + bcopy(&ngep->param_link_duplex, pr_val, + sizeof (link_duplex_t)); + } else + err = EINVAL; break; case DLD_PROP_SPEED: if (pr_valsize >= sizeof (uint64_t)) { - tmp = ngep->param_link_speed * 1000000ull; - bcopy(&tmp, pr_val, sizeof (tmp)); - err = 0; - } - break; - case DLD_PROP_STATUS: - if (pr_valsize >= sizeof (uint8_t)) { - *(uint8_t *)pr_val = ngep->param_link_up; - err = 0; - } + speed = ngep->param_link_speed * 1000000ull; + bcopy(&speed, pr_val, sizeof (speed)); + } else + err = EINVAL; break; case DLD_PROP_AUTONEG: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_autoneg; - err = 0; - } - break; - case DLD_PROP_DEFMTU: { - if (pr_valsize >= sizeof (uint64_t)) { - tmp = ngep->default_mtu; - bcopy(&tmp, pr_val, sizeof (tmp)); - err = 0; } break; - } case DLD_PROP_FLOWCTRL: if (pr_valsize >= sizeof (link_flowctrl_t)) { + if (pr_flags & DLD_DEFAULT) { + fl = LINK_FLOWCTRL_BI; + bcopy(&fl, pr_val, sizeof (fl)); + break; + } if (ngep->param_link_rx_pause && !ngep->param_link_tx_pause) fl = LINK_FLOWCTRL_RX; @@ -1798,84 +1797,100 @@ nge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, ngep->param_link_tx_pause) fl = LINK_FLOWCTRL_BI; bcopy(&fl, pr_val, sizeof (fl)); - err = 0; - } + } else + err = EINVAL; break; case DLD_PROP_ADV_1000FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_1000fdx; - err = 0; } break; case DLD_PROP_EN_1000FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_en_1000fdx; - err = 0; } break; case DLD_PROP_ADV_1000HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 0; + } else { *(uint8_t *)pr_val = ngep->param_adv_1000hdx; - err = 0; } break; case DLD_PROP_EN_1000HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 0; + } else { *(uint8_t *)pr_val = ngep->param_en_1000hdx; - err = 0; } break; case DLD_PROP_ADV_100FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_100fdx; - err = 0; } break; case DLD_PROP_EN_100FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_en_100fdx; - err = 0; } break; case DLD_PROP_ADV_100HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_100hdx; - err = 0; } break; case DLD_PROP_EN_100HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_en_100hdx; - err = 0; } break; case DLD_PROP_ADV_10FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_10fdx; - err = 0; } break; case DLD_PROP_EN_10FDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_en_10fdx; - err = 0; } break; case DLD_PROP_ADV_10HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_adv_10hdx; - err = 0; } break; case DLD_PROP_EN_10HDX_CAP: - if (pr_valsize >= sizeof (uint8_t)) { + if (is_default) { + *(uint8_t *)pr_val = 1; + } else { *(uint8_t *)pr_val = ngep->param_en_10hdx; - err = 0; } break; + case DLD_PROP_ADV_100T4_CAP: + case DLD_PROP_EN_100T4_CAP: + *(uint8_t *)pr_val = 0; + break; case DLD_PROP_PRIVATE: - err = nge_get_priv_prop(ngep, pr_name, pr_valsize, - pr_val); + err = nge_get_priv_prop(ngep, pr_name, pr_flags, + pr_valsize, pr_val); break; default: err = ENOTSUP; @@ -1967,7 +1982,7 @@ nge_set_priv_prop(nge_t *ngep, const char *pr_name, uint_t pr_valsize, return (err); } (void) ddi_strtol(pr_val, (char **)NULL, 0, &result); - if (result < 0 || result > PARAM_RECV_MAX_PACKET) { + if (result < 0 || result > NGE_RECV_SLOTS_DESC_1024) { err = EINVAL; } else { ngep->param_rx_intr_hwater = (uint32_t)result; @@ -1981,7 +1996,7 @@ nge_set_priv_prop(nge_t *ngep, const char *pr_name, uint_t pr_valsize, return (err); } (void) ddi_strtol(pr_val, (char **)NULL, 0, &result); - if (result < 0 || result > PARAM_RECV_MAX_PACKET) { + if (result < 0 || result > NGE_RECV_SLOTS_DESC_1024) { err = EINVAL; } else { ngep->param_rx_intr_lwater = (uint32_t)result; @@ -2017,62 +2032,72 @@ reprogram: } static int -nge_get_priv_prop(nge_t *ngep, const char *pr_name, uint_t pr_valsize, - void *pr_val) +nge_get_priv_prop(nge_t *ngep, const char *pr_name, uint_t pr_flags, + uint_t pr_valsize, void *pr_val) { - char valstr[MAXNAMELEN]; int err = ENOTSUP; - uint_t strsize; + boolean_t is_default = (pr_flags & DLD_DEFAULT); + int value; + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + value = (is_default ? 1 : ngep->param_adv_pause); + err = 0; + goto done; + } + if (strcmp(pr_name, "_adv_asym_pause_cap") == 0) { + value = (is_default ? 1 : ngep->param_adv_asym_pause); + err = 0; + goto done; + } if (strcmp(pr_name, "_tx_bcopy_threshold") == 0) { - (void) sprintf(valstr, "%d", ngep->param_txbcopy_threshold); + value = (is_default ? NGE_TX_COPY_SIZE : + ngep->param_txbcopy_threshold); err = 0; goto done; } if (strcmp(pr_name, "_rx_bcopy_threshold") == 0) { - (void) sprintf(valstr, "%d", ngep->param_rxbcopy_threshold); + value = (is_default ? NGE_RX_COPY_SIZE : + ngep->param_rxbcopy_threshold); err = 0; goto done; } if (strcmp(pr_name, "_recv_max_packet") == 0) { - (void) sprintf(valstr, "%d", ngep->param_recv_max_packet); + value = (is_default ? 128 : ngep->param_recv_max_packet); err = 0; goto done; } if (strcmp(pr_name, "_poll_quiet_time") == 0) { - (void) sprintf(valstr, "%d", ngep->param_poll_quiet_time); + value = (is_default ? NGE_POLL_QUIET_TIME : + ngep->param_poll_quiet_time); err = 0; goto done; } if (strcmp(pr_name, "_poll_busy_time") == 0) { - (void) sprintf(valstr, "%d", ngep->param_poll_busy_time); + value = (is_default ? NGE_POLL_BUSY_TIME : + ngep->param_poll_busy_time); err = 0; goto done; } if (strcmp(pr_name, "_rx_intr_hwater") == 0) { - (void) sprintf(valstr, "%d", ngep->param_rx_intr_hwater); + value = (is_default ? 1 : ngep->param_rx_intr_hwater); err = 0; goto done; } if (strcmp(pr_name, "_rx_intr_lwater") == 0) { - (void) sprintf(valstr, "%d", ngep->param_rx_intr_lwater); + value = (is_default ? 8 : ngep->param_rx_intr_lwater); err = 0; goto done; } if (strcmp(pr_name, "_tx_n_intr") == 0) { - (void) sprintf(valstr, "%d", ngep->param_tx_n_intr); + value = (is_default ? NGE_TX_N_INTR : + ngep->param_tx_n_intr); err = 0; goto done; } done: if (err == 0) { - strsize = (uint_t)strlen(valstr); - if (pr_valsize < strsize) { - err = ENOBUFS; - } else { - (void) strlcpy(pr_val, valstr, strsize); - } + (void) snprintf(pr_val, pr_valsize, "%d", value); } return (err); } @@ -2196,9 +2221,6 @@ nge_unattach(nge_t *ngep) if (ngep->progress & PROGRESS_KSTATS) nge_fini_kstats(ngep); - if (ngep->progress & PROGRESS_NDD) - nge_nd_cleanup(ngep); - if (ngep->progress & PROGRESS_HWINT) { mutex_enter(ngep->genlock); nge_restore_mac_addr(ngep); @@ -2347,6 +2369,41 @@ nge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) nge_problem(ngep, "nge_attach: pci_config_setup() failed"); goto attach_fail; } + /* + * param_txbcopy_threshold and param_rxbcopy_threshold are tx/rx bcopy + * thresholds. Bounds: min 0, max NGE_MAX_SDU + */ + ngep->param_txbcopy_threshold = NGE_TX_COPY_SIZE; + ngep->param_rxbcopy_threshold = NGE_RX_COPY_SIZE; + + /* + * param_recv_max_packet is max packet received per interupt. + * Bounds: min 0, max NGE_RECV_SLOTS_DESC_1024 + */ + ngep->param_recv_max_packet = 128; + + /* + * param_poll_quiet_time and param_poll_busy_time are quiet/busy time + * switch from per packet interrupt to polling interrupt. + * Bounds: min 0, max 10000 + */ + ngep->param_poll_quiet_time = NGE_POLL_QUIET_TIME; + ngep->param_poll_busy_time = NGE_POLL_BUSY_TIME; + + /* + * param_rx_intr_hwater/param_rx_intr_lwater: ackets received + * to trigger the poll_quiet_time/poll_busy_time counter. + * Bounds: min 0, max NGE_RECV_SLOTS_DESC_1024. + */ + ngep->param_rx_intr_hwater = 1; + ngep->param_rx_intr_lwater = 8; + + /* + * param_tx_n_intr: Per N tx packets to do tx recycle in poll mode. + * Bounds: min 1, max 10000. + */ + ngep->param_tx_n_intr = NGE_TX_N_INTR; + infop = (chip_info_t *)&ngep->chipinfo; nge_chip_cfg_init(ngep, infop, B_FALSE); nge_init_dev_spec_param(ngep); @@ -2432,6 +2489,8 @@ nge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd) macp->m_min_sdu = 0; macp->m_max_sdu = ngep->default_mtu; macp->m_margin = VTAG_SIZE; + macp->m_priv_props = nge_priv_props; + macp->m_priv_prop_count = NGE_MAX_PRIV_PROPS; /* * Finally, we're ready to register ourselves with the mac * interface; if this succeeds, we're all ready to start() diff --git a/usr/src/uts/common/io/nge/nge_ndd.c b/usr/src/uts/common/io/nge/nge_ndd.c index 5d83802417..7c9a509a2b 100644 --- a/usr/src/uts/common/io/nge/nge_ndd.c +++ b/usr/src/uts/common/io/nge/nge_ndd.c @@ -36,136 +36,6 @@ static char speed_propname[] = "speed"; static char duplex_propname[] = "full-duplex"; /* - * Notes: - * The first character of the <name> field encodes the read/write - * status of the parameter: - * '=' => read-only, - * '-' => read-only and forced to 0 on serdes - * '+' => read/write, - * '?' => read/write on copper, read-only and 0 on serdes - * '!' => invisible! - * - * For writable parameters, we check for a driver property with the - * same name; if found, and its value is in range, we initialise - * the parameter from the property, overriding the default in the - * table below. - * - * A NULL in the <name> field terminates the array. - * - * The <info> field is used here to provide the index of the - * parameter to be initialised; thus it doesn't matter whether - * this table is kept ordered or not. - * - * The <info> field in the per-instance copy, on the other hand, - * is used to count assignments so that we can tell when a magic - * parameter has been set via ndd (see nge_param_set()). - */ -static const nd_param_t nd_template[] = { -/* info min max init r/w+name */ - -/* Our hardware capabilities */ -{ PARAM_AUTONEG_CAP, 0, 1, 1, "=autoneg_cap" }, -{ PARAM_PAUSE_CAP, 0, 1, 1, "=pause_cap" }, -{ PARAM_ASYM_PAUSE_CAP, 0, 1, 1, "=asym_pause_cap" }, -{ PARAM_1000FDX_CAP, 0, 1, 1, "=1000fdx_cap" }, -{ PARAM_1000HDX_CAP, 0, 1, 0, "=1000hdx_cap" }, -{ PARAM_100T4_CAP, 0, 1, 0, "=100T4_cap" }, -{ PARAM_100FDX_CAP, 0, 1, 1, "-100fdx_cap" }, -{ PARAM_100HDX_CAP, 0, 1, 1, "-100hdx_cap" }, -{ PARAM_10FDX_CAP, 0, 1, 1, "-10fdx_cap" }, -{ PARAM_10HDX_CAP, 0, 1, 1, "-10hdx_cap" }, - -/* Our advertised capabilities */ -{ PARAM_ADV_AUTONEG_CAP, 0, 1, 1, "+adv_autoneg_cap" }, -{ PARAM_ADV_PAUSE_CAP, 0, 1, 1, "+adv_pause_cap" }, -{ PARAM_ADV_ASYM_PAUSE_CAP, 0, 1, 1, "+adv_asym_pause_cap" }, -{ PARAM_ADV_1000FDX_CAP, 0, 1, 1, "+adv_1000fdx_cap" }, -{ PARAM_ADV_1000HDX_CAP, 0, 1, 0, "=adv_1000hdx_cap" }, -{ PARAM_ADV_100T4_CAP, 0, 1, 0, "=adv_100T4_cap" }, -{ PARAM_ADV_100FDX_CAP, 0, 1, 1, "?adv_100fdx_cap" }, -{ PARAM_ADV_100HDX_CAP, 0, 1, 1, "?adv_100hdx_cap" }, -{ PARAM_ADV_10FDX_CAP, 0, 1, 1, "?adv_10fdx_cap" }, -{ PARAM_ADV_10HDX_CAP, 0, 1, 1, "?adv_10hdx_cap" }, - -/* Partner's advertised capabilities */ -{ PARAM_LP_AUTONEG_CAP, 0, 1, 0, "-lp_autoneg_cap" }, -{ PARAM_LP_PAUSE_CAP, 0, 1, 0, "-lp_pause_cap" }, -{ PARAM_LP_ASYM_PAUSE_CAP, 0, 1, 0, "-lp_asym_pause_cap" }, -{ PARAM_LP_1000FDX_CAP, 0, 1, 0, "-lp_1000fdx_cap" }, -{ PARAM_LP_1000HDX_CAP, 0, 1, 0, "-lp_1000hdx_cap" }, -{ PARAM_LP_100T4_CAP, 0, 1, 0, "-lp_100T4_cap" }, -{ PARAM_LP_100FDX_CAP, 0, 1, 0, "-lp_100fdx_cap" }, -{ PARAM_LP_100HDX_CAP, 0, 1, 0, "-lp_100hdx_cap" }, -{ PARAM_LP_10FDX_CAP, 0, 1, 0, "-lp_10fdx_cap" }, -{ PARAM_LP_10HDX_CAP, 0, 1, 0, "-lp_10hdx_cap" }, - -/* Current operating modes */ -{ PARAM_LINK_STATUS, 0, 1, 0, "-link_status" }, -{ PARAM_LINK_SPEED, 0, 1000, 0, "-link_speed" }, -{ PARAM_LINK_DUPLEX, -1, 1, -1, "-link_duplex" }, - -{ PARAM_LINK_AUTONEG, 0, 1, 0, "-link_autoneg" }, -{ PARAM_LINK_RX_PAUSE, 0, 1, 0, "-link_rx_pause" }, -{ PARAM_LINK_TX_PAUSE, 0, 1, 0, "-link_tx_pause" }, - -/* Loopback status */ -{ PARAM_LOOP_MODE, 0, 5, 0, "-loop_mode" }, - -/* TX Bcopy threshold */ -{ PARAM_TXBCOPY_THRESHOLD, 0, NGE_MAX_SDU, NGE_TX_COPY_SIZE, -"+tx_bcopy_threshold" }, - -/* RX Bcopy threshold */ -{ PARAM_RXBCOPY_THRESHOLD, 0, NGE_MAX_SDU, NGE_RX_COPY_SIZE, -"+rx_bcopy_threshold" }, - -/* Max packet received per interrupt */ -{ PARAM_RECV_MAX_PACKET, 0, NGE_RECV_SLOTS_DESC_1024, 128, -"+recv_max_packet" }, -/* Quiet time switch from polling interrupt to per packet interrupt */ -{ PARAM_POLL_QUIET_TIME, 0, 10000, NGE_POLL_QUIET_TIME, -"+poll_quiet_time" }, - -/* Busy time switch from per packet interrupt to polling interrupt */ -{ PARAM_POLL_BUSY_TIME, 0, 10000, NGE_POLL_BUSY_TIME, -"+poll_busy_time" }, - -/* Packets received to trigger the poll_quiet_time counter */ -{ PARAM_RX_INTR_HWATER, 0, PARAM_RECV_MAX_PACKET, 1, -"+rx_intr_hwater" }, - -/* Packets received to trigger the poll_busy_time counter */ -{ PARAM_RX_INTR_LWATER, 0, PARAM_RECV_MAX_PACKET, 8, -"+rx_intr_lwater" }, - -/* Per N tx packets to do tx recycle in poll mode */ -{ PARAM_TX_N_INTR, 1, 10000, NGE_TX_N_INTR, -"+tx_n_intr" }, - -/* Terminator */ -{ PARAM_COUNT, 0, 0, 0, NULL } -}; - - -/* ============== NDD Support Functions =============== */ - -/* - * Extracts the value from the nge parameter array and prints - * the parameter value. cp points to the required parameter. - */ -static int -nge_param_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) -{ - nd_param_t *ndp; - - _NOTE(ARGUNUSED(q, credp)) - ndp = (nd_param_t *)cp; - (void) mi_mpprintf(mp, "%d", ndp->ndp_val); - - return (0); -} - -/* * synchronize the adv* and en* parameters. * * See comments in <sys/dld.h> for details of the *_en_* @@ -186,115 +56,67 @@ nge_param_sync(nge_t *ngep) ngep->param_en_10hdx = ngep->param_adv_10hdx; } -/* - * Validates the request to set a NGE parameter to a specific value. - * If the request is OK, the parameter is set. Also the <info> field - * is incremented to show that the parameter was touched, even though - * it may have been set to the same value it already had. - */ -static int -nge_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *credp) + +boolean_t +nge_nd_get_prop_val(dev_info_t *dip, char *nm, long min, long max, int *pval) { - nd_param_t *ndp; - long new_value; - char *end; - - _NOTE(ARGUNUSED(q, mp, credp)) - ndp = (nd_param_t *)cp; - new_value = mi_strtol(value, &end, 10); - if (end == value) - return (EINVAL); - if (new_value < ndp->ndp_min || new_value > ndp->ndp_max) - return (EINVAL); - - ndp->ndp_val = new_value; - ndp->ndp_info += 1; - return (0); + /* + * If the parameter is writable, and there's a property + * with the same name, and its value is in range, we use + * it to initialise the parameter. If it exists but is + * out of range, it's ignored. + */ + if (NGE_PROP_EXISTS(dip, nm)) { + *pval = NGE_PROP_GET_INT(dip, nm); + if (*pval >= min && *pval <= max) + return (B_TRUE); + } + return (B_FALSE); } -/* - * Initialise the per-instance parameter array from the global prototype, - * and register each element with the named dispatch handler using nd_load() - */ -static int -nge_param_register(nge_t *ngep) +#define NGE_INIT_PROP(propname, fieldname, initval) { \ + if (nge_nd_get_prop_val(dip, propname, 0, 1, &propval)) \ + ngep->fieldname = propval; \ + else \ + ngep->fieldname = initval; \ +} + +static void +nge_nd_param_init(nge_t *ngep) { - const nd_param_t *tmplp; dev_info_t *dip; - nd_param_t *ndp; - caddr_t *nddpp; - pfi_t setfn; - char *nm; - int pval; + int propval; dip = ngep->devinfo; - nddpp = &ngep->nd_data_p; - ASSERT(*nddpp == NULL); - - NGE_TRACE(("nge_param_register($%p)", (void *)ngep)); - - for (tmplp = nd_template; tmplp->ndp_name != NULL; ++tmplp) { - /* - * Copy the template from nd_template[] into the - * proper slot in the per-instance parameters, - * then register the parameter with nd_load() - */ - ndp = &ngep->nd_params[tmplp->ndp_info]; - *ndp = *tmplp; - nm = &ndp->ndp_name[0]; - setfn = nge_param_set; - switch (*nm) { - default: - case '!': - continue; - - case '+': - case '?': - break; - - case '=': - case '-': - setfn = NULL; - break; - } - if (!nd_load(nddpp, ++nm, nge_param_get, setfn, (caddr_t)ndp)) - goto nd_fail; - - /* - * If the parameter is writable, and there's a property - * with the same name, and its value is in range, we use - * it to initialise the parameter. If it exists but is - * out of range, it's ignored. - */ - if (setfn && NGE_PROP_EXISTS(dip, nm)) { - pval = NGE_PROP_GET_INT(dip, nm); - if (pval >= ndp->ndp_min && pval <= ndp->ndp_max) - ndp->ndp_val = pval; - } - } - return (DDI_SUCCESS); - -nd_fail: - nd_free(nddpp); - return (DDI_FAILURE); + /* + * initialize values to those from driver.conf (if available) + * or the default value otherwise. + */ + NGE_INIT_PROP("adv_autoneg_cap", param_adv_autoneg, 1); + NGE_INIT_PROP("adv_1000fdx_cap", param_adv_1000fdx, 1); + NGE_INIT_PROP("adv_1000hdx_cap", param_adv_1000hdx, 0); + NGE_INIT_PROP("adv_pause_cap", param_adv_pause, 1); + NGE_INIT_PROP("adv_asym_pause_cap", param_adv_asym_pause, 1); + NGE_INIT_PROP("adv_100fdx_cap", param_adv_100fdx, 1); + NGE_INIT_PROP("adv_100hdx_cap", param_adv_100hdx, 1); + NGE_INIT_PROP("adv_10fdx_cap", param_adv_10fdx, 1); + NGE_INIT_PROP("adv_10hdx_cap", param_adv_10hdx, 1); } int nge_nd_init(nge_t *ngep) { + dev_info_t *dip; int duplex; int speed; - dev_info_t *dip; NGE_TRACE(("nge_nd_init($%p)", (void *)ngep)); + /* - * Register all the per-instance properties, initialising - * them from the table above or from driver properties set - * in the .conf file + * initialize from .conf file, if appropriate. */ - if (nge_param_register(ngep) != DDI_SUCCESS) - return (-1); + nge_nd_param_init(ngep); /* * The link speed may be forced to 10, 100 or 1000 Mbps using @@ -412,84 +234,8 @@ nge_nd_init(nge_t *ngep) } } + nge_param_sync(ngep); return (0); } - -enum ioc_reply -nge_nd_ioctl(nge_t *ngep, queue_t *wq, mblk_t *mp, struct iocblk *iocp) -{ - boolean_t ok; - int cmd; - NGE_TRACE(("nge_nd_ioctl($%p, $%p, $%p, $%p)", - (void *)ngep, (void *)wq, (void *)mp, (void *)iocp)); - - ASSERT(mutex_owned(ngep->genlock)); - - cmd = iocp->ioc_cmd; - switch (cmd) { - default: - nge_error(ngep, "nge_nd_ioctl: invalid cmd 0x%x", cmd); - return (IOC_INVAL); - - case ND_GET: - /* - * If nd_getset() returns B_FALSE, the command was - * not valid (e.g. unknown name), so we just tell the - * top-level ioctl code to send a NAK (with code EINVAL). - * - * Otherwise, nd_getset() will have built the reply to - * be sent (but not actually sent it), so we tell the - * caller to send the prepared reply. - */ - ok = nd_getset(wq, ngep->nd_data_p, mp); - return (ok ? IOC_REPLY : IOC_INVAL); - - case ND_SET: - /* - * All adv_* parameters are locked (read-only) while - * the device is in any sort of loopback mode ... - */ - if (ngep->param_loop_mode != NGE_LOOP_NONE) { - iocp->ioc_error = EBUSY; - return (IOC_INVAL); - } - - ok = nd_getset(wq, ngep->nd_data_p, mp); - - nge_param_sync(ngep); - - /* - * If nd_getset() returns B_FALSE, the command was - * not valid (e.g. unknown name), so we just tell - * the top-level ioctl code to send a NAK (with code - * EINVAL by default). - * - * Otherwise, nd_getset() will have built the reply to - * be sent - but that doesn't imply success! In some - * cases, the reply it's built will have a non-zero - * error code in it (e.g. EPERM if not superuser). - * So, we also drop out in that case ... - */ - if (!ok) - return (IOC_INVAL); - if (iocp->ioc_error) - return (IOC_REPLY); - - /* - * OK, a successful 'set'. Return IOC_RESTART_REPLY, - * telling the top-level ioctl code to update the PHY - * and restart the chip before sending our prepared reply - */ - return (IOC_RESTART_REPLY); - } -} - -/* Free the Named Dispatch Table by calling nd_free */ -void -nge_nd_cleanup(nge_t *ngep) -{ - NGE_TRACE(("nge_nd_cleanup($%p)", (void *)ngep)); - nd_free(&ngep->nd_data_p); -} diff --git a/usr/src/uts/common/io/nxge/nxge_main.c b/usr/src/uts/common/io/nxge/nxge_main.c index efb08db1bf..ce9e834896 100644 --- a/usr/src/uts/common/io/nxge/nxge_main.c +++ b/usr/src/uts/common/io/nxge/nxge_main.c @@ -200,6 +200,8 @@ static void nxge_free_tx_cntl_dma(p_nxge_t, p_nxge_dma_common_t); static int nxge_init_common_dev(p_nxge_t); static void nxge_uninit_common_dev(p_nxge_t); +extern int nxge_param_set_mac(p_nxge_t, queue_t *, mblk_t *, + char *, caddr_t); /* * The next declarations are for the GLDv3 interface. @@ -224,11 +226,37 @@ static boolean_t nxge_m_getcapab(void *, mac_capab_t, void *); static int nxge_m_setprop(void *, const char *, mac_prop_id_t, uint_t, const void *); static int nxge_m_getprop(void *, const char *, mac_prop_id_t, - uint_t, void *); + uint_t, uint_t, void *); static int nxge_set_priv_prop(nxge_t *, const char *, uint_t, const void *); -static int nxge_get_priv_prop(nxge_t *, const char *, uint_t, +static int nxge_get_priv_prop(nxge_t *, const char *, uint_t, uint_t, void *); +static int nxge_get_def_val(nxge_t *, mac_prop_id_t, uint_t, void *); + + +mac_priv_prop_t nxge_priv_props[] = { + {"_adv_10gfdx_cap", MAC_PROP_PERM_RW}, + {"_adv_pause_cap", MAC_PROP_PERM_RW}, + {"_function_number", MAC_PROP_PERM_READ}, + {"_fw_version", MAC_PROP_PERM_READ}, + {"_port_mode", MAC_PROP_PERM_READ}, + {"_hot_swap_phy", MAC_PROP_PERM_READ}, + {"_accept_jumbo", MAC_PROP_PERM_RW}, + {"_rxdma_intr_time", MAC_PROP_PERM_RW}, + {"_rxdma_intr_pkts", MAC_PROP_PERM_RW}, + {"_class_opt_ipv4_tcp", MAC_PROP_PERM_RW}, + {"_class_opt_ipv4_udp", MAC_PROP_PERM_RW}, + {"_class_opt_ipv4_ah", MAC_PROP_PERM_RW}, + {"_class_opt_ipv4_sctp", MAC_PROP_PERM_RW}, + {"_class_opt_ipv6_tcp", MAC_PROP_PERM_RW}, + {"_class_opt_ipv6_udp", MAC_PROP_PERM_RW}, + {"_class_opt_ipv6_ah", MAC_PROP_PERM_RW}, + {"_class_opt_ipv6_sctp", MAC_PROP_PERM_RW}, + {"_soft_lso_enable", MAC_PROP_PERM_RW} +}; + +#define NXGE_MAX_PRIV_PROPS \ + (sizeof (nxge_priv_props)/sizeof (mac_priv_prop_t)) #define NXGE_M_CALLBACK_FLAGS\ (MC_RESOURCES | MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP) @@ -514,7 +542,7 @@ nxge_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) status = nxge_init_common_dev(nxgep); if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_init_common_dev failed")); + "nxge_init_common_dev failed")); goto nxge_attach_fail4; } @@ -526,7 +554,7 @@ nxge_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) if ((status = nxge_hio_init(nxgep)) != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_hio_init failed")); + "nxge_hio_init failed")); goto nxge_attach_fail4; } @@ -650,8 +678,8 @@ nxge_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_attach: " - " Couldn't determine card type" - " .... exit ")); + " Couldn't determine card type" + " .... exit ")); goto nxge_attach_fail5; } @@ -659,7 +687,7 @@ nxge_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "get_hw create failed")); + "get_hw create failed")); goto nxge_attach_fail; } } @@ -775,7 +803,7 @@ nxge_attach_fail1: nxge_attach_exit: NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_attach status = 0x%08x", - status)); + status)); return (status); } @@ -832,19 +860,19 @@ nxge_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) nxge_hio_unregister(nxgep); } else if (nxgep->mach && (status = mac_unregister(nxgep->mach)) != 0) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_detach status = 0x%08X", status)); + "<== nxge_detach status = 0x%08X", status)); return (DDI_FAILURE); } NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_detach (mac_unregister) status = 0x%08X", status)); + "<== nxge_detach (mac_unregister) status = 0x%08X", status)); nxge_unattach(nxgep); nxgep = NULL; nxge_detach_exit: NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_detach status = 0x%08X", - status)); + status)); return (status); } @@ -918,7 +946,7 @@ nxge_unattach(p_nxge_t nxgep) */ if (nxgep->dip) { NXGE_DEBUG_MSG((nxgep, OBP_CTL, - " nxge_unattach: remove all properties")); + " nxge_unattach: remove all properties")); (void) ddi_prop_remove_all(nxgep->dip); } @@ -962,7 +990,7 @@ nxge_hsvc_register( } nxgep->niu_hsvc_available = B_TRUE; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "NIU Hypervisor service enabled")); + "NIU Hypervisor service enabled")); } return (DDI_SUCCESS); @@ -1005,37 +1033,37 @@ nxge_map_regs(p_nxge_t nxgep) devname = ddi_pathname(nxgep->dip, buf); ASSERT(strlen(devname) > 0); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: pathname devname %s", devname)); + "nxge_map_regs: pathname devname %s", devname)); if (strstr(devname, n2_siu_name)) { /* N2/NIU */ nxgep->niu_type = N2_NIU; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: N2/NIU devname %s", devname)); + "nxge_map_regs: N2/NIU devname %s", devname)); /* get function number */ nxgep->function_num = - (devname[strlen(devname) -1] == '1' ? 1 : 0); + (devname[strlen(devname) -1] == '1' ? 1 : 0); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: N2/NIU function number %d", - nxgep->function_num)); + "nxge_map_regs: N2/NIU function number %d", + nxgep->function_num)); } else { int *prop_val; uint_t prop_len; uint8_t func_num; if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, nxgep->dip, - 0, "reg", - &prop_val, &prop_len) != DDI_PROP_SUCCESS) { + 0, "reg", + &prop_val, &prop_len) != DDI_PROP_SUCCESS) { NXGE_DEBUG_MSG((nxgep, VPD_CTL, - "Reg property not found")); + "Reg property not found")); ddi_status = DDI_FAILURE; goto nxge_map_regs_fail0; } else { func_num = (prop_val[0] >> 8) & 0x7; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "Reg property found: fun # %d", - func_num)); + "Reg property found: fun # %d", + func_num)); nxgep->function_num = func_num; if (isLDOMguest(nxgep)) { nxgep->function_num /= 2; @@ -1049,20 +1077,20 @@ nxge_map_regs(p_nxge_t nxgep) default: (void) ddi_dev_regsize(nxgep->dip, 0, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: pci config size 0x%x", regsize)); + "nxge_map_regs: pci config size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 0, - (caddr_t *)&(dev_regs->nxge_pciregp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_pciregh); + (caddr_t *)&(dev_regs->nxge_pciregp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_pciregh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs, nxge bus config regs failed")); + "ddi_map_regs, nxge bus config regs failed")); goto nxge_map_regs_fail0; } NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_reg: PCI config addr 0x%0llx " - " handle 0x%0llx", dev_regs->nxge_pciregp, - dev_regs->nxge_pciregh)); + "nxge_map_reg: PCI config addr 0x%0llx " + " handle 0x%0llx", dev_regs->nxge_pciregp, + dev_regs->nxge_pciregh)); /* * IMP IMP * workaround for bit swapping bug in HW @@ -1076,67 +1104,67 @@ nxge_map_regs(p_nxge_t nxgep) pcie_devctl &= PCIE_DEVCTL_ENABLE_NO_SNOOP; pcie_devctl |= PCIE_DEVCTL_RO_EN; pci_config_put16(dev_regs->nxge_pciregh, pci_offset, - pcie_devctl); + pcie_devctl); #endif (void) ddi_dev_regsize(nxgep->dip, 1, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: pio size 0x%x", regsize)); + "nxge_map_regs: pio size 0x%x", regsize)); /* set up the device mapped register */ ddi_status = ddi_regs_map_setup(nxgep->dip, 1, - (caddr_t *)&(dev_regs->nxge_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_regh); + (caddr_t *)&(dev_regs->nxge_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for Neptune global reg failed")); + "ddi_map_regs for Neptune global reg failed")); goto nxge_map_regs_fail1; } /* set up the msi/msi-x mapped register */ (void) ddi_dev_regsize(nxgep->dip, 2, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: msix size 0x%x", regsize)); + "nxge_map_regs: msix size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 2, - (caddr_t *)&(dev_regs->nxge_msix_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_msix_regh); + (caddr_t *)&(dev_regs->nxge_msix_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_msix_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for msi reg failed")); + "ddi_map_regs for msi reg failed")); goto nxge_map_regs_fail2; } /* set up the vio region mapped register */ (void) ddi_dev_regsize(nxgep->dip, 3, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: vio size 0x%x", regsize)); + "nxge_map_regs: vio size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 3, - (caddr_t *)&(dev_regs->nxge_vir_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir_regh); + (caddr_t *)&(dev_regs->nxge_vir_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for nxge vio reg failed")); + "ddi_map_regs for nxge vio reg failed")); goto nxge_map_regs_fail3; } nxgep->dev_regs = dev_regs; NPI_PCI_ACC_HANDLE_SET(nxgep, dev_regs->nxge_pciregh); NPI_PCI_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_pciregp); + (npi_reg_ptr_t)dev_regs->nxge_pciregp); NPI_MSI_ACC_HANDLE_SET(nxgep, dev_regs->nxge_msix_regh); NPI_MSI_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_msix_regp); + (npi_reg_ptr_t)dev_regs->nxge_msix_regp); NPI_ACC_HANDLE_SET(nxgep, dev_regs->nxge_regh); NPI_ADD_HANDLE_SET(nxgep, (npi_reg_ptr_t)dev_regs->nxge_regp); NPI_REG_ACC_HANDLE_SET(nxgep, dev_regs->nxge_regh); NPI_REG_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_regp); + (npi_reg_ptr_t)dev_regs->nxge_regp); NPI_VREG_ACC_HANDLE_SET(nxgep, dev_regs->nxge_vir_regh); NPI_VREG_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_vir_regp); + (npi_reg_ptr_t)dev_regs->nxge_vir_regp); break; @@ -1148,41 +1176,41 @@ nxge_map_regs(p_nxge_t nxgep) */ (void) ddi_dev_regsize(nxgep->dip, 1, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: dev size 0x%x", regsize)); + "nxge_map_regs: dev size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 1, - (caddr_t *)&(dev_regs->nxge_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_regh); + (caddr_t *)&(dev_regs->nxge_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for N2/NIU, global reg failed ")); + "ddi_map_regs for N2/NIU, global reg failed ")); goto nxge_map_regs_fail1; } /* set up the first vio region mapped register */ (void) ddi_dev_regsize(nxgep->dip, 2, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: vio (1) size 0x%x", regsize)); + "nxge_map_regs: vio (1) size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 2, - (caddr_t *)&(dev_regs->nxge_vir_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir_regh); + (caddr_t *)&(dev_regs->nxge_vir_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for nxge vio reg failed")); + "ddi_map_regs for nxge vio reg failed")); goto nxge_map_regs_fail2; } /* set up the second vio region mapped register */ (void) ddi_dev_regsize(nxgep->dip, 3, ®size); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_map_regs: vio (3) size 0x%x", regsize)); + "nxge_map_regs: vio (3) size 0x%x", regsize)); ddi_status = ddi_regs_map_setup(nxgep->dip, 3, - (caddr_t *)&(dev_regs->nxge_vir2_regp), 0, 0, - &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir2_regh); + (caddr_t *)&(dev_regs->nxge_vir2_regp), 0, 0, + &nxge_dev_reg_acc_attr, &dev_regs->nxge_vir2_regh); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_map_regs for nxge vio2 reg failed")); + "ddi_map_regs for nxge vio2 reg failed")); goto nxge_map_regs_fail3; } nxgep->dev_regs = dev_regs; @@ -1192,21 +1220,21 @@ nxge_map_regs(p_nxge_t nxgep) NPI_REG_ACC_HANDLE_SET(nxgep, dev_regs->nxge_regh); NPI_REG_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_regp); + (npi_reg_ptr_t)dev_regs->nxge_regp); NPI_VREG_ACC_HANDLE_SET(nxgep, dev_regs->nxge_vir_regh); NPI_VREG_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_vir_regp); + (npi_reg_ptr_t)dev_regs->nxge_vir_regp); NPI_V2REG_ACC_HANDLE_SET(nxgep, dev_regs->nxge_vir2_regh); NPI_V2REG_ADD_HANDLE_SET(nxgep, - (npi_reg_ptr_t)dev_regs->nxge_vir2_regp); + (npi_reg_ptr_t)dev_regs->nxge_vir2_regp); break; } NXGE_DEBUG_MSG((nxgep, DDI_CTL, "nxge_map_reg: hardware addr 0x%0llx " - " handle 0x%0llx", dev_regs->nxge_regp, dev_regs->nxge_regh)); + " handle 0x%0llx", dev_regs->nxge_regp, dev_regs->nxge_regh)); goto nxge_map_regs_exit; nxge_map_regs_fail3: @@ -1248,31 +1276,31 @@ nxge_unmap_regs(p_nxge_t nxgep) if (nxgep->dev_regs) { if (nxgep->dev_regs->nxge_pciregh) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_unmap_regs: bus")); + "==> nxge_unmap_regs: bus")); ddi_regs_map_free(&nxgep->dev_regs->nxge_pciregh); nxgep->dev_regs->nxge_pciregh = NULL; } if (nxgep->dev_regs->nxge_regh) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_unmap_regs: device registers")); + "==> nxge_unmap_regs: device registers")); ddi_regs_map_free(&nxgep->dev_regs->nxge_regh); nxgep->dev_regs->nxge_regh = NULL; } if (nxgep->dev_regs->nxge_msix_regh) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_unmap_regs: device interrupts")); + "==> nxge_unmap_regs: device interrupts")); ddi_regs_map_free(&nxgep->dev_regs->nxge_msix_regh); nxgep->dev_regs->nxge_msix_regh = NULL; } if (nxgep->dev_regs->nxge_vir_regh) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_unmap_regs: vio region")); + "==> nxge_unmap_regs: vio region")); ddi_regs_map_free(&nxgep->dev_regs->nxge_vir_regh); nxgep->dev_regs->nxge_vir_regh = NULL; } if (nxgep->dev_regs->nxge_vir2_regh) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_unmap_regs: vio2 region")); + "==> nxge_unmap_regs: vio2 region")); ddi_regs_map_free(&nxgep->dev_regs->nxge_vir2_regh); nxgep->dev_regs->nxge_vir2_regh = NULL; } @@ -1320,15 +1348,15 @@ nxge_setup_mutexes(p_nxge_t nxgep) * Initialize mutexes for this device. */ MUTEX_INIT(nxgep->genlock, NULL, - MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); + MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); MUTEX_INIT(&nxgep->ouraddr_lock, NULL, - MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); + MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); MUTEX_INIT(&nxgep->mif_lock, NULL, - MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); + MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); MUTEX_INIT(&nxgep->group_lock, NULL, MUTEX_DRIVER, (void *)nxgep->interrupt_cookie); RW_INIT(&nxgep->filter_lock, NULL, - RW_DRIVER, (void *)nxgep->interrupt_cookie); + RW_DRIVER, (void *)nxgep->interrupt_cookie); classify_ptr = &nxgep->classifier; /* @@ -1509,12 +1537,12 @@ nxge_init_fail2: nxge_free_mem_pool(nxgep); nxge_init_fail1: NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_init status (failed) = 0x%08x", status)); + "<== nxge_init status (failed) = 0x%08x", status)); return (status); nxge_init_exit: NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_init status = 0x%08x", - status)); + status)); return (status); } @@ -1522,10 +1550,9 @@ nxge_init_exit: timeout_id_t nxge_start_timer(p_nxge_t nxgep, fptrv_t func, int msec) { - if ((nxgep->suspended == 0) || - (nxgep->suspended == DDI_RESUME)) { + if ((nxgep->suspended == 0) || (nxgep->suspended == DDI_RESUME)) { return (timeout(func, (caddr_t)nxgep, - drv_usectohz(1000 * msec))); + drv_usectohz(1000 * msec))); } return (NULL); } @@ -1546,9 +1573,9 @@ nxge_uninit(p_nxge_t nxgep) if (!(nxgep->drv_state & STATE_HW_INITIALIZED)) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_uninit: not initialized")); + "==> nxge_uninit: not initialized")); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_uninit")); + "<== nxge_uninit")); return; } @@ -1594,7 +1621,7 @@ nxge_uninit(p_nxge_t nxgep) nxgep->drv_state &= ~STATE_HW_INITIALIZED; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_uninit: " - "nxge_mblks_pending %d", nxge_mblks_pending)); + "nxge_mblks_pending %d", nxge_mblks_pending)); } void @@ -1661,11 +1688,11 @@ nxge_debug_msg(p_nxge_t nxgep, uint64_t level, char *fmt, ...) } debug_level = (nxgep == NULL) ? nxge_debug_level : - nxgep->nxge_debug_level; + nxgep->nxge_debug_level; if ((level & debug_level) || - (level == NXGE_NOTE) || - (level == NXGE_ERR_CTL)) { + (level == NXGE_NOTE) || + (level == NXGE_ERR_CTL)) { /* do the msg processing */ if (nxge_debug_init == 0) { MUTEX_INIT(&nxgedebuglock, NULL, MUTEX_DRIVER, NULL); @@ -1691,12 +1718,12 @@ nxge_debug_msg(p_nxge_t nxgep, uint64_t level, char *fmt, ...) } else { instance = nxgep->instance; (void) sprintf(prefix_buffer, - "%s%d :", "nxge", instance); + "%s%d :", "nxge", instance); } MUTEX_EXIT(&nxgedebuglock); cmn_err(cmn_level, "!%s %s\n", - prefix_buffer, msg_buffer); + prefix_buffer, msg_buffer); } } @@ -1837,7 +1864,7 @@ nxge_resume(p_nxge_t nxgep) nxgep->suspended = 0; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_resume status = 0x%x", status)); + "<== nxge_resume status = 0x%x", status)); return (status); } @@ -1853,21 +1880,21 @@ nxge_setup_dev(p_nxge_t nxgep) if (fm_check_acc_handle(nxgep->dev_regs->nxge_regh) != DDI_FM_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "port%d Bad register acc handle", nxgep->mac.portnum)); + "port%d Bad register acc handle", nxgep->mac.portnum)); status = NXGE_ERROR; } if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " nxge_setup_dev status " - "(xcvr init 0x%08x)", status)); + " nxge_setup_dev status " + "(xcvr init 0x%08x)", status)); goto nxge_setup_dev_exit; } nxge_setup_dev_exit: NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_setup_dev port %d status = 0x%08x", - nxgep->mac.portnum, status)); + "<== nxge_setup_dev port %d status = 0x%08x", + nxgep->mac.portnum, status)); return (status); } @@ -1898,12 +1925,12 @@ nxge_setup_system_dma_pages(p_nxge_t nxgep) if (nxgep->niu_type != N2_NIU) { iommu_pagesize = dvma_pagesize(nxgep->dip); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - " nxge_setup_system_dma_pages: page %d (ddi_ptob %d) " - " default_block_size %d iommu_pagesize %d", - nxgep->sys_page_sz, - ddi_ptob(nxgep->dip, (ulong_t)1), - nxgep->rx_default_block_size, - iommu_pagesize)); + " nxge_setup_system_dma_pages: page %d (ddi_ptob %d) " + " default_block_size %d iommu_pagesize %d", + nxgep->sys_page_sz, + ddi_ptob(nxgep->dip, (ulong_t)1), + nxgep->rx_default_block_size, + iommu_pagesize)); if (iommu_pagesize != 0) { if (nxgep->sys_page_sz == iommu_pagesize) { @@ -1917,12 +1944,12 @@ nxge_setup_system_dma_pages(p_nxge_t nxgep) } nxgep->sys_page_mask = ~(nxgep->sys_page_sz - 1); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "==> nxge_setup_system_dma_pages: page %d (ddi_ptob %d) " - "default_block_size %d page mask %d", - nxgep->sys_page_sz, - ddi_ptob(nxgep->dip, (ulong_t)1), - nxgep->rx_default_block_size, - nxgep->sys_page_mask)); + "==> nxge_setup_system_dma_pages: page %d (ddi_ptob %d) " + "default_block_size %d page mask %d", + nxgep->sys_page_sz, + ddi_ptob(nxgep->dip, (ulong_t)1), + nxgep->rx_default_block_size, + nxgep->sys_page_mask)); switch (nxgep->sys_page_sz) { @@ -1960,25 +1987,25 @@ nxge_setup_system_dma_pages(p_nxge_t nxgep) * Get the system DMA burst size. */ ddi_status = ddi_dma_alloc_handle(nxgep->dip, &nxge_tx_dma_attr, - DDI_DMA_DONTWAIT, 0, - &nxgep->dmasparehandle); + DDI_DMA_DONTWAIT, 0, + &nxgep->dmasparehandle); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_dma_alloc_handle: failed " - " status 0x%x", ddi_status)); + "ddi_dma_alloc_handle: failed " + " status 0x%x", ddi_status)); goto nxge_get_soft_properties_exit; } ddi_status = ddi_dma_addr_bind_handle(nxgep->dmasparehandle, NULL, - (caddr_t)nxgep->dmasparehandle, - sizeof (nxgep->dmasparehandle), - DDI_DMA_RDWR | DDI_DMA_CONSISTENT, - DDI_DMA_DONTWAIT, 0, - &cookie, &count); + (caddr_t)nxgep->dmasparehandle, + sizeof (nxgep->dmasparehandle), + DDI_DMA_RDWR | DDI_DMA_CONSISTENT, + DDI_DMA_DONTWAIT, 0, + &cookie, &count); if (ddi_status != DDI_DMA_MAPPED) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "Binding spare handle to find system" - " burstsize failed.")); + "Binding spare handle to find system" + " burstsize failed.")); ddi_status = DDI_FAILURE; goto nxge_get_soft_properties_fail1; } @@ -1995,7 +2022,7 @@ nxge_get_soft_properties_exit: status |= (NXGE_ERROR | NXGE_DDI_FAILED); NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_setup_system_dma_pages status = 0x%08x", status)); + "<== nxge_setup_system_dma_pages status = 0x%08x", status)); return (status); } @@ -2060,17 +2087,17 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) * Allocate memory for the common DMA data structures. */ dma_poolp = (p_nxge_dma_pool_t)KMEM_ZALLOC(sizeof (nxge_dma_pool_t), - KM_SLEEP); + KM_SLEEP); dma_buf_p = (p_nxge_dma_common_t *)KMEM_ZALLOC( - sizeof (p_nxge_dma_common_t) * rdc_max, KM_SLEEP); + sizeof (p_nxge_dma_common_t) * rdc_max, KM_SLEEP); dma_cntl_poolp = (p_nxge_dma_pool_t) - KMEM_ZALLOC(sizeof (nxge_dma_pool_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_pool_t), KM_SLEEP); dma_cntl_p = (p_nxge_dma_common_t *)KMEM_ZALLOC( - sizeof (p_nxge_dma_common_t) * rdc_max, KM_SLEEP); + sizeof (p_nxge_dma_common_t) * rdc_max, KM_SLEEP); num_chunks = (uint32_t *)KMEM_ZALLOC( - sizeof (uint32_t) * rdc_max, KM_SLEEP); + sizeof (uint32_t) * rdc_max, KM_SLEEP); /* * Assume that each DMA channel will be configured with @@ -2085,7 +2112,7 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) } if (nxge_port_rbr_size % NXGE_RXDMA_POST_BATCH) { nxge_port_rbr_size = (NXGE_RXDMA_POST_BATCH * - (nxge_port_rbr_size / NXGE_RXDMA_POST_BATCH + 1)); + (nxge_port_rbr_size / NXGE_RXDMA_POST_BATCH + 1)); } p_all_cfgp->rbr_size = nxge_port_rbr_size; @@ -2093,7 +2120,7 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) if (nxge_port_rbr_spare_size % NXGE_RXDMA_POST_BATCH) { nxge_port_rbr_spare_size = (NXGE_RXDMA_POST_BATCH * - (nxge_port_rbr_spare_size / NXGE_RXDMA_POST_BATCH + 1)); + (nxge_port_rbr_spare_size / NXGE_RXDMA_POST_BATCH + 1)); } if (nxge_port_rbr_size > RBR_DEFAULT_MAX_BLKS) { NXGE_DEBUG_MSG((nxgep, MEM_CTL, @@ -2120,11 +2147,11 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) if (nxgep->niu_type == N2_NIU) { nxge_port_rbr_spare_size = 0; if ((nxge_port_rbr_size > NXGE_NIU_CONTIG_RBR_MAX) || - (!ISP2(nxge_port_rbr_size))) { + (!ISP2(nxge_port_rbr_size))) { nxge_port_rbr_size = NXGE_NIU_CONTIG_RBR_MAX; } if ((nxge_port_rcr_size > NXGE_NIU_CONTIG_RCR_MAX) || - (!ISP2(nxge_port_rcr_size))) { + (!ISP2(nxge_port_rcr_size))) { nxge_port_rcr_size = NXGE_NIU_CONTIG_RCR_MAX; } } @@ -2140,12 +2167,12 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) rx_cntl_alloc_size += sizeof (rxdma_mailbox_t); NXGE_DEBUG_MSG((nxgep, MEM2_CTL, "==> nxge_alloc_rx_mem_pool: " - "nxge_port_rbr_size = %d nxge_port_rbr_spare_size = %d " - "nxge_port_rcr_size = %d " - "rx_cntl_alloc_size = %d", - nxge_port_rbr_size, nxge_port_rbr_spare_size, - nxge_port_rcr_size, - rx_cntl_alloc_size)); + "nxge_port_rbr_size = %d nxge_port_rbr_spare_size = %d " + "nxge_port_rcr_size = %d " + "rx_cntl_alloc_size = %d", + nxge_port_rbr_size, nxge_port_rbr_spare_size, + nxge_port_rcr_size, + rx_cntl_alloc_size)); #if defined(sun4v) && defined(NIU_LP_WORKAROUND) if (nxgep->niu_type == N2_NIU) { @@ -2154,16 +2181,16 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) if (!ISP2(rx_buf_alloc_size)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_alloc_rx_mem_pool: " - " must be power of 2")); + "==> nxge_alloc_rx_mem_pool: " + " must be power of 2")); status |= (NXGE_ERROR | NXGE_DDI_FAILED); goto nxge_alloc_rx_mem_pool_exit; } if (rx_buf_alloc_size > (1 << 22)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_alloc_rx_mem_pool: " - " limit size to 4M")); + "==> nxge_alloc_rx_mem_pool: " + " limit size to 4M")); status |= (NXGE_ERROR | NXGE_DDI_FAILED); goto nxge_alloc_rx_mem_pool_exit; } @@ -2191,23 +2218,23 @@ nxge_alloc_rx_mem_pool(p_nxge_t nxgep) /* Allocate the receive rings, too. */ nxgep->rx_rbr_rings = - KMEM_ZALLOC(sizeof (rx_rbr_rings_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (rx_rbr_rings_t), KM_SLEEP); nxgep->rx_rbr_rings->rbr_rings = - KMEM_ZALLOC(sizeof (p_rx_rbr_ring_t) * rdc_max, KM_SLEEP); + KMEM_ZALLOC(sizeof (p_rx_rbr_ring_t) * rdc_max, KM_SLEEP); nxgep->rx_rcr_rings = - KMEM_ZALLOC(sizeof (rx_rcr_rings_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (rx_rcr_rings_t), KM_SLEEP); nxgep->rx_rcr_rings->rcr_rings = - KMEM_ZALLOC(sizeof (p_rx_rcr_ring_t) * rdc_max, KM_SLEEP); + KMEM_ZALLOC(sizeof (p_rx_rcr_ring_t) * rdc_max, KM_SLEEP); nxgep->rx_mbox_areas_p = - KMEM_ZALLOC(sizeof (rx_mbox_areas_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (rx_mbox_areas_t), KM_SLEEP); nxgep->rx_mbox_areas_p->rxmbox_areas = - KMEM_ZALLOC(sizeof (p_rx_mbox_t) * rdc_max, KM_SLEEP); + KMEM_ZALLOC(sizeof (p_rx_mbox_t) * rdc_max, KM_SLEEP); nxgep->rx_rbr_rings->ndmas = nxgep->rx_rcr_rings->ndmas = p_cfgp->max_rdcs; NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "<== nxge_alloc_rx_mem_pool:status 0x%08x", status)); + "<== nxge_alloc_rx_mem_pool:status 0x%08x", status)); nxge_alloc_rx_mem_pool_exit: return (status); @@ -2261,7 +2288,7 @@ nxge_alloc_rxb( * Allocate memory for the receive buffer blocks. */ rx_buf_alloc_size = (nxgep->rx_default_block_size * - (nxgep->nxge_port_rbr_size + nxgep->nxge_port_rbr_spare_size)); + (nxgep->nxge_port_rbr_size + nxgep->nxge_port_rbr_spare_size)); data = &nxgep->rx_buf_pool_p->dma_buf_pool_p[channel]; num_chunks = &nxgep->rx_buf_pool_p->num_chunks[channel]; @@ -2333,14 +2360,14 @@ nxge_free_rx_mem_pool(p_nxge_t nxgep) if (!nxgep->rx_buf_pool_p || !nxgep->rx_buf_pool_p->buf_allocated) { NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "<== nxge_free_rx_mem_pool " - "(null rx buf pool or buf not allocated")); + "<== nxge_free_rx_mem_pool " + "(null rx buf pool or buf not allocated")); return; } if (!nxgep->rx_cntl_pool_p || !nxgep->rx_cntl_pool_p->buf_allocated) { NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "<== nxge_free_rx_mem_pool " - "(null rx cntl buf pool or cntl buf not allocated")); + "<== nxge_free_rx_mem_pool " + "(null rx cntl buf pool or cntl buf not allocated")); return; } @@ -2390,12 +2417,12 @@ nxge_alloc_rx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, NXGE_DEBUG_MSG((nxgep, DMA_CTL, "==> nxge_alloc_rx_buf_dma")); rx_dmap = (p_nxge_dma_common_t) - KMEM_ZALLOC(sizeof (nxge_dma_common_t) * NXGE_DMA_BLOCK, - KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_common_t) * NXGE_DMA_BLOCK, + KM_SLEEP); NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - " alloc_rx_buf_dma rdc %d asize %x bsize %x bbuf %llx ", - dma_channel, alloc_size, block_size, dmap)); + " alloc_rx_buf_dma rdc %d asize %x bsize %x bbuf %llx ", + dma_channel, alloc_size, block_size, dmap)); total_alloc_size = alloc_size; @@ -2407,8 +2434,8 @@ nxge_alloc_rx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, size_index = 0; array_size = sizeof (alloc_sizes)/sizeof (size_t); while ((alloc_sizes[size_index] < alloc_size) && - (size_index < array_size)) - size_index++; + (size_index < array_size)) + size_index++; if (size_index >= array_size) { size_index = array_size - 1; } @@ -2426,7 +2453,7 @@ nxge_alloc_rx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, } while ((allocated < total_alloc_size) && - (size_index >= 0) && (i < NXGE_DMA_BLOCK)) { + (size_index >= 0) && (i < NXGE_DMA_BLOCK)) { rx_dmap[i].dma_chunk_index = i; rx_dmap[i].block_size = block_size; rx_dmap[i].alength = alloc_sizes[size_index]; @@ -2455,17 +2482,17 @@ nxge_alloc_rx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, } NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "alloc_rx_buf_dma rdc %d chunk %d bufp %llx size %x " - "i %d nblocks %d alength %d", - dma_channel, i, &rx_dmap[i], block_size, - i, rx_dmap[i].nblocks, - rx_dmap[i].alength)); + "alloc_rx_buf_dma rdc %d chunk %d bufp %llx size %x " + "i %d nblocks %d alength %d", + dma_channel, i, &rx_dmap[i], block_size, + i, rx_dmap[i].nblocks, + rx_dmap[i].alength)); status = nxge_dma_mem_alloc(nxgep, nxge_force_dma, - &nxge_rx_dma_attr, - rx_dmap[i].alength, - &nxge_dev_buf_dma_acc_attr, - DDI_DMA_READ | DDI_DMA_STREAMING, - (p_nxge_dma_common_t)(&rx_dmap[i])); + &nxge_rx_dma_attr, + rx_dmap[i].alength, + &nxge_dev_buf_dma_acc_attr, + DDI_DMA_READ | DDI_DMA_STREAMING, + (p_nxge_dma_common_t)(&rx_dmap[i])); if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_alloc_rx_buf_dma: Alloc Failed: " @@ -2514,8 +2541,8 @@ nxge_alloc_rx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, allocated, total_alloc_size)); NXGE_DEBUG_MSG((nxgep, DMA_CTL, - " alloc_rx_buf_dma rdc %d allocated %d chunks", - dma_channel, i)); + " alloc_rx_buf_dma rdc %d allocated %d chunks", + dma_channel, i)); *num_chunks = i; *dmap = rx_dmap; @@ -2526,7 +2553,7 @@ nxge_alloc_rx_mem_fail1: nxge_alloc_rx_mem_exit: NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "<== nxge_alloc_rx_buf_dma status 0x%08x", status)); + "<== nxge_alloc_rx_buf_dma status 0x%08x", status)); return (status); } @@ -2539,15 +2566,15 @@ nxge_free_rx_buf_dma(p_nxge_t nxgep, p_nxge_dma_common_t dmap, int i; NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "==> nxge_free_rx_buf_dma: # of chunks %d", num_chunks)); + "==> nxge_free_rx_buf_dma: # of chunks %d", num_chunks)); if (dmap == 0) return; for (i = 0; i < num_chunks; i++) { NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "==> nxge_free_rx_buf_dma: chunk %d dmap 0x%llx", - i, dmap)); + "==> nxge_free_rx_buf_dma: chunk %d dmap 0x%llx", + i, dmap)); nxge_dma_free_rx_data_buf(dmap++); } @@ -2565,17 +2592,17 @@ nxge_alloc_rx_cntl_dma(p_nxge_t nxgep, uint16_t dma_channel, NXGE_DEBUG_MSG((nxgep, DMA_CTL, "==> nxge_alloc_rx_cntl_dma")); rx_dmap = (p_nxge_dma_common_t) - KMEM_ZALLOC(sizeof (nxge_dma_common_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_common_t), KM_SLEEP); rx_dmap->contig_alloc_type = B_FALSE; rx_dmap->kmem_alloc_type = B_FALSE; status = nxge_dma_mem_alloc(nxgep, nxge_force_dma, - &nxge_desc_dma_attr, - size, - &nxge_dev_desc_dma_acc_attr, - DDI_DMA_RDWR | DDI_DMA_CONSISTENT, - rx_dmap); + &nxge_desc_dma_attr, + size, + &nxge_dev_desc_dma_acc_attr, + DDI_DMA_RDWR | DDI_DMA_CONSISTENT, + rx_dmap); if (status != NXGE_OK) { goto nxge_alloc_rx_cntl_dma_fail1; } @@ -2588,7 +2615,7 @@ nxge_alloc_rx_cntl_dma_fail1: nxge_alloc_rx_cntl_dma_exit: NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "<== nxge_alloc_rx_cntl_dma status 0x%08x", status)); + "<== nxge_alloc_rx_cntl_dma status 0x%08x", status)); return (status); } @@ -2642,15 +2669,15 @@ nxge_tdc_sizes( if (nxgep->niu_type == N2_NIU) { if (!ISP2(tx_size)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_tdc_sizes: Tx size" - " must be power of 2")); + "==> nxge_tdc_sizes: Tx size" + " must be power of 2")); return (NXGE_ERROR); } if (tx_size > (1 << 22)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_tdc_sizes: Tx size" - " limited to 4M")); + "==> nxge_tdc_sizes: Tx size" + " limited to 4M")); return (NXGE_ERROR); } @@ -2724,8 +2751,8 @@ nxge_alloc_txb( * Allocate memory for the transmit buffer pool. */ NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "sizes: tx: %ld, cr:%ld, th:%ld", - sizes.tx_size, sizes.cr_size, sizes.threshhold)); + "sizes: tx: %ld, cr:%ld, th:%ld", + sizes.tx_size, sizes.cr_size, sizes.threshhold)); *num_chunks = 0; status = nxge_alloc_tx_buf_dma(nxgep, channel, dma_buf_p, @@ -2812,14 +2839,14 @@ nxge_alloc_tx_mem_pool(p_nxge_t nxgep) * Allocate memory for each transmit DMA channel. */ dma_poolp = (p_nxge_dma_pool_t)KMEM_ZALLOC(sizeof (nxge_dma_pool_t), - KM_SLEEP); + KM_SLEEP); dma_buf_p = (p_nxge_dma_common_t *)KMEM_ZALLOC( - sizeof (p_nxge_dma_common_t) * tdc_max, KM_SLEEP); + sizeof (p_nxge_dma_common_t) * tdc_max, KM_SLEEP); dma_cntl_poolp = (p_nxge_dma_pool_t) - KMEM_ZALLOC(sizeof (nxge_dma_pool_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_pool_t), KM_SLEEP); dma_cntl_p = (p_nxge_dma_common_t *)KMEM_ZALLOC( - sizeof (p_nxge_dma_common_t) * tdc_max, KM_SLEEP); + sizeof (p_nxge_dma_common_t) * tdc_max, KM_SLEEP); if (nxge_tx_ring_size > TDC_DEFAULT_MAX) { NXGE_DEBUG_MSG((nxgep, MEM_CTL, @@ -2839,7 +2866,7 @@ nxge_alloc_tx_mem_pool(p_nxge_t nxgep) */ if (nxgep->niu_type == N2_NIU) { if ((nxge_tx_ring_size > NXGE_NIU_CONTIG_TX_MAX) || - (!ISP2(nxge_tx_ring_size))) { + (!ISP2(nxge_tx_ring_size))) { nxge_tx_ring_size = NXGE_NIU_CONTIG_TX_MAX; } } @@ -2848,7 +2875,7 @@ nxge_alloc_tx_mem_pool(p_nxge_t nxgep) nxgep->nxge_port_tx_ring_size = nxge_tx_ring_size; num_chunks = (uint32_t *)KMEM_ZALLOC( - sizeof (uint32_t) * tdc_max, KM_SLEEP); + sizeof (uint32_t) * tdc_max, KM_SLEEP); dma_poolp->ndmas = p_cfgp->tdc.owned; dma_poolp->num_chunks = num_chunks; @@ -2875,8 +2902,8 @@ nxge_alloc_tx_mem_pool(p_nxge_t nxgep) nxgep->tx_rings->ndmas = p_cfgp->tdc.owned; NXGE_DEBUG_MSG((nxgep, MEM_CTL, - "==> nxge_alloc_tx_mem_pool: ndmas %d poolp->ndmas %d", - tdc_max, dma_poolp->ndmas)); + "==> nxge_alloc_tx_mem_pool: ndmas %d poolp->ndmas %d", + tdc_max, dma_poolp->ndmas)); return (NXGE_OK); } @@ -2895,22 +2922,22 @@ nxge_alloc_tx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, NXGE_DEBUG_MSG((nxgep, DMA_CTL, "==> nxge_alloc_tx_buf_dma")); tx_dmap = (p_nxge_dma_common_t) - KMEM_ZALLOC(sizeof (nxge_dma_common_t) * NXGE_DMA_BLOCK, - KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_common_t) * NXGE_DMA_BLOCK, + KM_SLEEP); total_alloc_size = alloc_size; i = 0; size_index = 0; array_size = sizeof (alloc_sizes) / sizeof (size_t); while ((alloc_sizes[size_index] < alloc_size) && - (size_index < array_size)) + (size_index < array_size)) size_index++; if (size_index >= array_size) { size_index = array_size - 1; } while ((allocated < total_alloc_size) && - (size_index >= 0) && (i < NXGE_DMA_BLOCK)) { + (size_index >= 0) && (i < NXGE_DMA_BLOCK)) { tx_dmap[i].dma_chunk_index = i; tx_dmap[i].block_size = block_size; @@ -2931,11 +2958,11 @@ nxge_alloc_tx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, } status = nxge_dma_mem_alloc(nxgep, nxge_force_dma, - &nxge_tx_dma_attr, - tx_dmap[i].alength, - &nxge_dev_buf_dma_acc_attr, - DDI_DMA_WRITE | DDI_DMA_STREAMING, - (p_nxge_dma_common_t)(&tx_dmap[i])); + &nxge_tx_dma_attr, + tx_dmap[i].alength, + &nxge_dev_buf_dma_acc_attr, + DDI_DMA_WRITE | DDI_DMA_STREAMING, + (p_nxge_dma_common_t)(&tx_dmap[i])); if (status != NXGE_OK) { size_index--; } else { @@ -2963,8 +2990,8 @@ nxge_alloc_tx_buf_dma(p_nxge_t nxgep, uint16_t dma_channel, *num_chunks = i; *dmap = tx_dmap; NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "==> nxge_alloc_tx_buf_dma dmap 0x%016llx num chunks %d", - *dmap, i)); + "==> nxge_alloc_tx_buf_dma dmap 0x%016llx num chunks %d", + *dmap, i)); goto nxge_alloc_tx_mem_exit; nxge_alloc_tx_mem_fail1: @@ -2972,7 +2999,7 @@ nxge_alloc_tx_mem_fail1: nxge_alloc_tx_mem_exit: NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "<== nxge_alloc_tx_buf_dma status 0x%08x", status)); + "<== nxge_alloc_tx_buf_dma status 0x%08x", status)); return (status); } @@ -3006,17 +3033,17 @@ nxge_alloc_tx_cntl_dma(p_nxge_t nxgep, uint16_t dma_channel, NXGE_DEBUG_MSG((nxgep, DMA_CTL, "==> nxge_alloc_tx_cntl_dma")); tx_dmap = (p_nxge_dma_common_t) - KMEM_ZALLOC(sizeof (nxge_dma_common_t), KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_dma_common_t), KM_SLEEP); tx_dmap->contig_alloc_type = B_FALSE; tx_dmap->kmem_alloc_type = B_FALSE; status = nxge_dma_mem_alloc(nxgep, nxge_force_dma, - &nxge_desc_dma_attr, - size, - &nxge_dev_desc_dma_acc_attr, - DDI_DMA_RDWR | DDI_DMA_CONSISTENT, - tx_dmap); + &nxge_desc_dma_attr, + size, + &nxge_dev_desc_dma_acc_attr, + DDI_DMA_RDWR | DDI_DMA_CONSISTENT, + tx_dmap); if (status != NXGE_OK) { goto nxge_alloc_tx_cntl_dma_fail1; } @@ -3029,7 +3056,7 @@ nxge_alloc_tx_cntl_dma_fail1: nxge_alloc_tx_cntl_dma_exit: NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "<== nxge_alloc_tx_cntl_dma status 0x%08x", status)); + "<== nxge_alloc_tx_cntl_dma status 0x%08x", status)); return (status); } @@ -3072,14 +3099,14 @@ nxge_free_tx_mem_pool(p_nxge_t nxgep) if (!nxgep->tx_buf_pool_p || !nxgep->tx_buf_pool_p->buf_allocated) { NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "<== nxge_free_tx_mem_pool " - "(null tx buf pool or buf not allocated")); + "<== nxge_free_tx_mem_pool " + "(null tx buf pool or buf not allocated")); return; } if (!nxgep->tx_cntl_pool_p || !nxgep->tx_cntl_pool_p->buf_allocated) { NXGE_DEBUG_MSG((nxgep, MEM2_CTL, - "<== nxge_free_tx_mem_pool " - "(null tx cntl buf pool or cntl buf not allocated")); + "<== nxge_free_tx_mem_pool " + "(null tx cntl buf pool or cntl buf not allocated")); return; } @@ -3136,8 +3163,8 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, * for N2/NIU. */ NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc: alloc type not allowed (%d)", - dma_p->contig_alloc_type)); + "nxge_dma_mem_alloc: alloc type not allowed (%d)", + dma_p->contig_alloc_type)); return (NXGE_ERROR | NXGE_DDI_FAILED); } @@ -3146,10 +3173,10 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, dma_p->kaddrp = dma_p->last_kaddrp = NULL; dma_p->first_ioaddr_pp = dma_p->last_ioaddr_pp = NULL; ddi_status = ddi_dma_alloc_handle(nxgep->dip, dma_attrp, - DDI_DMA_DONTWAIT, NULL, &dma_p->dma_handle); + DDI_DMA_DONTWAIT, NULL, &dma_p->dma_handle); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc:ddi_dma_alloc_handle failed.")); + "nxge_dma_mem_alloc:ddi_dma_alloc_handle failed.")); return (NXGE_ERROR | NXGE_DDI_FAILED); } @@ -3160,11 +3187,11 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, switch (kmem_alloc_type) { case B_FALSE: ddi_status = ddi_dma_mem_alloc(dma_p->dma_handle, - length, - acc_attr_p, - xfer_flags, - DDI_DMA_DONTWAIT, 0, &kaddrp, &dma_p->alength, - &dma_p->acc_handle); + length, + acc_attr_p, + xfer_flags, + DDI_DMA_DONTWAIT, 0, &kaddrp, &dma_p->alength, + &dma_p->acc_handle); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_dma_mem_alloc: " @@ -3255,7 +3282,7 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, "nxge_dma_mem_alloc:ddi_dma_addr_bind " "(kmem_alloc) > 1 cookie" "(staus 0x%x ncookies %d.)", ddi_status, - dma_p->ncookies)); + dma_p->ncookies)); KMEM_FREE(kaddrp, length); dma_p->acc_handle = NULL; (void) ddi_dma_unbind_handle(dma_p->dma_handle); @@ -3268,11 +3295,11 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, dma_p->kaddrp = kaddrp; NXGE_DEBUG_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc: kmem_alloc dmap $%p " - "kaddr $%p alength %d", - dma_p, - kaddrp, - dma_p->alength)); + "nxge_dma_mem_alloc: kmem_alloc dmap $%p " + "kaddr $%p alength %d", + dma_p, + kaddrp, + dma_p->alength)); break; } break; @@ -3282,29 +3309,29 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, kaddrp = (caddr_t)contig_mem_alloc(length); if (kaddrp == NULL) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc:contig_mem_alloc failed.")); + "nxge_dma_mem_alloc:contig_mem_alloc failed.")); ddi_dma_free_handle(&dma_p->dma_handle); return (NXGE_ERROR | NXGE_DDI_FAILED); } dma_p->alength = length; ddi_status = ddi_dma_addr_bind_handle(dma_p->dma_handle, NULL, - kaddrp, dma_p->alength, xfer_flags, DDI_DMA_DONTWAIT, 0, - &dma_p->dma_cookie, &dma_p->ncookies); + kaddrp, dma_p->alength, xfer_flags, DDI_DMA_DONTWAIT, 0, + &dma_p->dma_cookie, &dma_p->ncookies); if (ddi_status != DDI_DMA_MAPPED) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc:di_dma_addr_bind failed " - "(status 0x%x ncookies %d.)", ddi_status, - dma_p->ncookies)); + "nxge_dma_mem_alloc:di_dma_addr_bind failed " + "(status 0x%x ncookies %d.)", ddi_status, + dma_p->ncookies)); NXGE_DEBUG_MSG((nxgep, DMA_CTL, - "==> nxge_dma_mem_alloc: (not mapped)" - "length %lu (0x%x) " - "free contig kaddrp $%p " - "va_to_pa $%p", - length, length, - kaddrp, - va_to_pa(kaddrp))); + "==> nxge_dma_mem_alloc: (not mapped)" + "length %lu (0x%x) " + "free contig kaddrp $%p " + "va_to_pa $%p", + length, length, + kaddrp, + va_to_pa(kaddrp))); contig_mem_free((void *)kaddrp, length); @@ -3319,16 +3346,16 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, } if (dma_p->ncookies != 1 || - (dma_p->dma_cookie.dmac_laddress == NULL)) { + (dma_p->dma_cookie.dmac_laddress == NULL)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc:di_dma_addr_bind > 1 " - "cookie or " - "dmac_laddress is NULL $%p size %d " - " (status 0x%x ncookies %d.)", - ddi_status, - dma_p->dma_cookie.dmac_laddress, - dma_p->dma_cookie.dmac_size, - dma_p->ncookies)); + "nxge_dma_mem_alloc:di_dma_addr_bind > 1 " + "cookie or " + "dmac_laddress is NULL $%p size %d " + " (status 0x%x ncookies %d.)", + ddi_status, + dma_p->dma_cookie.dmac_laddress, + dma_p->dma_cookie.dmac_size, + dma_p->ncookies)); contig_mem_free((void *)kaddrp, length); (void) ddi_dma_unbind_handle(dma_p->dma_handle); @@ -3346,55 +3373,55 @@ nxge_dma_mem_alloc(p_nxge_t nxgep, dma_method_t method, #else case B_TRUE: NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_dma_mem_alloc: invalid alloc type for !sun4v")); + "nxge_dma_mem_alloc: invalid alloc type for !sun4v")); return (NXGE_ERROR | NXGE_DDI_FAILED); #endif } dma_p->kaddrp = kaddrp; dma_p->last_kaddrp = (unsigned char *)kaddrp + - dma_p->alength - RXBUF_64B_ALIGNED; + dma_p->alength - RXBUF_64B_ALIGNED; #if defined(__i386) dma_p->ioaddr_pp = - (unsigned char *)(uint32_t)dma_p->dma_cookie.dmac_laddress; + (unsigned char *)(uint32_t)dma_p->dma_cookie.dmac_laddress; #else dma_p->ioaddr_pp = (unsigned char *)dma_p->dma_cookie.dmac_laddress; #endif dma_p->last_ioaddr_pp = #if defined(__i386) - (unsigned char *)(uint32_t)dma_p->dma_cookie.dmac_laddress + + (unsigned char *)(uint32_t)dma_p->dma_cookie.dmac_laddress + #else - (unsigned char *)dma_p->dma_cookie.dmac_laddress + + (unsigned char *)dma_p->dma_cookie.dmac_laddress + #endif - dma_p->alength - RXBUF_64B_ALIGNED; + dma_p->alength - RXBUF_64B_ALIGNED; NPI_DMA_ACC_HANDLE_SET(dma_p, dma_p->acc_handle); #if defined(sun4v) && defined(NIU_LP_WORKAROUND) dma_p->orig_ioaddr_pp = - (unsigned char *)dma_p->dma_cookie.dmac_laddress; + (unsigned char *)dma_p->dma_cookie.dmac_laddress; dma_p->orig_alength = length; dma_p->orig_kaddrp = kaddrp; dma_p->orig_vatopa = (uint64_t)va_to_pa(kaddrp); #endif NXGE_DEBUG_MSG((nxgep, DMA_CTL, "<== nxge_dma_mem_alloc: " - "dma buffer allocated: dma_p $%p " - "return dmac_ladress from cookie $%p cookie dmac_size %d " - "dma_p->ioaddr_p $%p " - "dma_p->orig_ioaddr_p $%p " - "orig_vatopa $%p " - "alength %d (0x%x) " - "kaddrp $%p " - "length %d (0x%x)", - dma_p, - dma_p->dma_cookie.dmac_laddress, dma_p->dma_cookie.dmac_size, - dma_p->ioaddr_pp, - dma_p->orig_ioaddr_pp, - dma_p->orig_vatopa, - dma_p->alength, dma_p->alength, - kaddrp, - length, length)); + "dma buffer allocated: dma_p $%p " + "return dmac_ladress from cookie $%p cookie dmac_size %d " + "dma_p->ioaddr_p $%p " + "dma_p->orig_ioaddr_p $%p " + "orig_vatopa $%p " + "alength %d (0x%x) " + "kaddrp $%p " + "length %d (0x%x)", + dma_p, + dma_p->dma_cookie.dmac_laddress, dma_p->dma_cookie.dmac_size, + dma_p->ioaddr_pp, + dma_p->orig_ioaddr_pp, + dma_p->orig_vatopa, + dma_p->alength, dma_p->alength, + kaddrp, + length, length)); return (NXGE_OK); } @@ -3419,17 +3446,17 @@ nxge_dma_mem_free(p_nxge_dma_common_t dma_p) #if defined(sun4v) && defined(NIU_LP_WORKAROUND) if (dma_p->contig_alloc_type && - dma_p->orig_kaddrp && dma_p->orig_alength) { + dma_p->orig_kaddrp && dma_p->orig_alength) { NXGE_DEBUG_MSG((NULL, DMA_CTL, "nxge_dma_mem_free: " - "kaddrp $%p (orig_kaddrp $%p)" - "mem type %d ", - "orig_alength %d " - "alength 0x%x (%d)", - dma_p->kaddrp, - dma_p->orig_kaddrp, - dma_p->contig_alloc_type, - dma_p->orig_alength, - dma_p->alength, dma_p->alength)); + "kaddrp $%p (orig_kaddrp $%p)" + "mem type %d ", + "orig_alength %d " + "alength 0x%x (%d)", + dma_p->kaddrp, + dma_p->orig_kaddrp, + dma_p->contig_alloc_type, + dma_p->orig_alength, + dma_p->alength, dma_p->alength)); contig_mem_free(dma_p->orig_kaddrp, dma_p->orig_alength); dma_p->orig_alength = NULL; @@ -3478,7 +3505,7 @@ nxge_dma_free_rx_data_buf(p_nxge_dma_common_t dma_p) #if defined(sun4v) && defined(NIU_LP_WORKAROUND) if (dma_p->contig_alloc_type && - dma_p->orig_kaddrp && dma_p->orig_alength) { + dma_p->orig_kaddrp && dma_p->orig_alength) { NXGE_DEBUG_MSG((NULL, DMA_CTL, "nxge_dma_free_rx_data_buf: " "kaddrp $%p (orig_kaddrp $%p)" "mem type %d ", @@ -3505,15 +3532,15 @@ nxge_dma_free_rx_data_buf(p_nxge_dma_common_t dma_p) if (dma_p->kmem_alloc_type) { NXGE_DEBUG_MSG((NULL, DMA_CTL, "nxge_dma_free_rx_data_buf: free kmem " - "kaddrp $%p (orig_kaddrp $%p)" - "alloc type %d " - "orig_alength %d " - "alength 0x%x (%d)", - dma_p->kaddrp, - dma_p->orig_kaddrp, - dma_p->kmem_alloc_type, - dma_p->orig_alength, - dma_p->alength, dma_p->alength)); + "kaddrp $%p (orig_kaddrp $%p)" + "alloc type %d " + "orig_alength %d " + "alength 0x%x (%d)", + dma_p->kaddrp, + dma_p->orig_kaddrp, + dma_p->kmem_alloc_type, + dma_p->orig_alength, + dma_p->alength, dma_p->alength)); #if defined(__i386) kaddr = (uint64_t)(uint32_t)dma_p->kaddrp; #else @@ -3552,7 +3579,7 @@ nxge_m_start(void *arg) MUTEX_ENTER(nxgep->genlock); if (nxge_init(nxgep) != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_start: initialization failed")); + "<== nxge_m_start: initialization failed")); MUTEX_EXIT(nxgep->genlock); return (EIO); } @@ -3617,7 +3644,7 @@ nxge_m_unicst(void *arg, const uint8_t *macaddr) bcopy(macaddr, (uint8_t *)&addrp, ETHERADDRL); if (nxge_set_mac_addr(nxgep, &addrp)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_unicst: set unitcast failed")); + "<== nxge_m_unicst: set unitcast failed")); return (EINVAL); } @@ -3633,19 +3660,19 @@ nxge_m_multicst(void *arg, boolean_t add, const uint8_t *mca) struct ether_addr addrp; NXGE_DEBUG_MSG((nxgep, MAC_CTL, - "==> nxge_m_multicst: add %d", add)); + "==> nxge_m_multicst: add %d", add)); bcopy(mca, (uint8_t *)&addrp, ETHERADDRL); if (add) { if (nxge_add_mcast_addr(nxgep, &addrp)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_multicst: add multicast failed")); + "<== nxge_m_multicst: add multicast failed")); return (EINVAL); } } else { if (nxge_del_mcast_addr(nxgep, &addrp)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_multicst: del multicast failed")); + "<== nxge_m_multicst: del multicast failed")); return (EINVAL); } } @@ -3661,16 +3688,16 @@ nxge_m_promisc(void *arg, boolean_t on) p_nxge_t nxgep = (p_nxge_t)arg; NXGE_DEBUG_MSG((nxgep, MAC_CTL, - "==> nxge_m_promisc: on %d", on)); + "==> nxge_m_promisc: on %d", on)); if (nxge_set_promisc(nxgep, on)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_promisc: set promisc failed")); + "<== nxge_m_promisc: set promisc failed")); return (EINVAL); } NXGE_DEBUG_MSG((nxgep, MAC_CTL, - "<== nxge_m_promisc: on %d", on)); + "<== nxge_m_promisc: on %d", on)); return (0); } @@ -3705,11 +3732,6 @@ nxge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) case LB_SET_MODE: break; - case ND_GET: - need_privilege = B_FALSE; - break; - case ND_SET: - break; case NXGE_GET_MII: case NXGE_PUT_MII: @@ -3743,18 +3765,12 @@ nxge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) if (err != 0) { miocnak(wq, mp, 0, err); NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "<== nxge_m_ioctl: no priv")); + "<== nxge_m_ioctl: no priv")); return; } } switch (cmd) { - case ND_GET: - NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "ND_GET command")); - case ND_SET: - NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "ND_SET command")); - nxge_param_ioctl(nxgep, wq, mp, iocp); - break; case LB_GET_MODE: case LB_SET_MODE: @@ -3780,7 +3796,7 @@ nxge_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) case NXGE_INT_REGS_DUMP: case NXGE_VIR_INT_REGS_DUMP: NXGE_DEBUG_MSG((nxgep, NXGE_CTL, - "==> nxge_m_ioctl: cmd 0x%x", cmd)); + "==> nxge_m_ioctl: cmd 0x%x", cmd)); nxge_hw_ioctl(nxgep, wq, mp, iocp); break; } @@ -3875,10 +3891,12 @@ nxge_mmac_kstat_update(p_nxge_t nxgep, mac_addr_slot_t slot, boolean_t factory) for (i = 0; i < ETHERADDRL; i++) { if (factory) { mmac_stats->mmac_avail_pool[slot-1].ether_addr_octet[i] - = mmac_info->factory_mac_pool[slot][(ETHERADDRL-1) - i]; + = mmac_info->factory_mac_pool[slot][ + (ETHERADDRL-1) - i]; } else { mmac_stats->mmac_avail_pool[slot-1].ether_addr_octet[i] - = mmac_info->mac_pool[slot].addr[(ETHERADDRL - 1) - i]; + = mmac_info->mac_pool[slot].addr[ + (ETHERADDRL - 1) - i]; } } } @@ -3903,7 +3921,7 @@ nxge_altmac_set(p_nxge_t nxgep, uint8_t *maddr, mac_addr_slot_t slot) addrn = (uint8_t)slot - 1; if (npi_mac_altaddr_entry(nxgep->npi_handle, OP_SET, portn, - addrn, &altmac) != NPI_SUCCESS) + addrn, &altmac) != NPI_SUCCESS) return (EIO); /* @@ -3933,7 +3951,7 @@ nxge_altmac_set(p_nxge_t nxgep, uint8_t *maddr, mac_addr_slot_t slot) addrn = (uint8_t)slot; if (npi_mac_altaddr_enable(nxgep->npi_handle, portn, addrn) - != NPI_SUCCESS) + != NPI_SUCCESS) return (EIO); return (0); @@ -3973,7 +3991,7 @@ nxge_m_mmac_add(void *arg, mac_multi_addr_t *maddr) return (ENOSPC); } if (!mac_unicst_verify(nxgep->mach, maddr->mma_addr, - maddr->mma_addrlen)) { + maddr->mma_addrlen)) { mutex_exit(nxgep->genlock); return (EINVAL); } @@ -3993,15 +4011,15 @@ nxge_m_mmac_add(void *arg, mac_multi_addr_t *maddr) */ if (mmac_info->num_factory_mmac < mmac_info->num_mmac) { for (slot = mmac_info->num_factory_mmac + 1; - slot <= mmac_info->num_mmac; slot++) { + slot <= mmac_info->num_mmac; slot++) { if (!(mmac_info->mac_pool[slot].flags & MMAC_SLOT_USED)) break; } if (slot > mmac_info->num_mmac) { for (slot = 1; slot <= mmac_info->num_factory_mmac; - slot++) { + slot++) { if (!(mmac_info->mac_pool[slot].flags - & MMAC_SLOT_USED)) + & MMAC_SLOT_USED)) break; } } @@ -4088,12 +4106,12 @@ nxge_m_mmac_reserve(void *arg, mac_multi_addr_t *maddr) } /* Verify the address to be reserved */ if (!mac_unicst_verify(nxgep->mach, - mmac_info->factory_mac_pool[slot], ETHERADDRL)) { + mmac_info->factory_mac_pool[slot], ETHERADDRL)) { mutex_exit(nxgep->genlock); return (EINVAL); } if (err = nxge_altmac_set(nxgep, - mmac_info->factory_mac_pool[slot], slot)) { + mmac_info->factory_mac_pool[slot], slot)) { mutex_exit(nxgep->genlock); return (err); } @@ -4154,7 +4172,7 @@ nxge_m_mmac_remove(void *arg, mac_addr_slot_t slot) if (mmac_info->mac_pool[slot].flags & MMAC_SLOT_USED) { if (npi_mac_altaddr_disable(nxgep->npi_handle, portn, addrn) - == NPI_SUCCESS) { + == NPI_SUCCESS) { mmac_info->naddrfree++; mmac_info->mac_pool[slot].flags &= ~MMAC_SLOT_USED; /* @@ -4166,7 +4184,7 @@ nxge_m_mmac_remove(void *arg, mac_addr_slot_t slot) */ if (slot <= mmac_info->num_factory_mmac) { mmac_info->mac_pool[slot].flags - |= MMAC_VENDOR_ADDR; + |= MMAC_VENDOR_ADDR; } /* * Clear mac_pool[slot].addr so that kstat shows 0 @@ -4200,7 +4218,7 @@ nxge_m_mmac_modify(void *arg, mac_multi_addr_t *maddr) nxge_status_t status; if (!mac_unicst_verify(nxgep->mach, maddr->mma_addr, - maddr->mma_addrlen)) + maddr->mma_addrlen)) return (EINVAL); slot = maddr->mma_slot; @@ -4226,9 +4244,9 @@ nxge_m_mmac_modify(void *arg, mac_multi_addr_t *maddr) } if (mmac_info->mac_pool[slot].flags & MMAC_SLOT_USED) { if ((err = nxge_altmac_set(nxgep, maddr->mma_addr, slot)) - != 0) { + != 0) { bcopy(maddr->mma_addr, mmac_info->mac_pool[slot].addr, - ETHERADDRL); + ETHERADDRL); /* * Assume that the MAC passed down from the caller * is not a factory MAC address (The user should @@ -4300,12 +4318,12 @@ nxge_m_mmac_get(void *arg, mac_multi_addr_t *maddr) if (mmac_info->mac_pool[slot].flags & MMAC_VENDOR_ADDR) { maddr->mma_flags |= MMAC_VENDOR_ADDR; bcopy(mmac_info->factory_mac_pool[slot], - maddr->mma_addr, ETHERADDRL); + maddr->mma_addr, ETHERADDRL); maddr->mma_addrlen = ETHERADDRL; } else { if (maddr->mma_flags & MMAC_SLOT_USED) { bcopy(mmac_info->mac_pool[slot].addr, - maddr->mma_addr, ETHERADDRL); + maddr->mma_addr, ETHERADDRL); maddr->mma_addrlen = ETHERADDRL; } else { bzero(maddr->mma_addr, ETHERADDRL); @@ -4535,7 +4553,7 @@ nxge_m_setprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, goto reprogram; - case DLD_PROP_DEFMTU: + case DLD_PROP_MTU: if (nxgep->nxge_mac_state == NXGE_MAC_STARTED) { err = EBUSY; break; @@ -4615,13 +4633,16 @@ reprogram: } } break; - - default: + case DLD_PROP_PRIVATE: NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_m_setprop: private property")); err = nxge_set_priv_prop(nxgep, pr_name, pr_valsize, pr_val); break; + + default: + err = ENOTSUP; + break; } mutex_exit(nxgep->genlock); @@ -4633,7 +4654,7 @@ reprogram: static int nxge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, - uint_t pr_valsize, void *pr_val) + uint_t pr_flags, uint_t pr_valsize, void *pr_val) { nxge_t *nxgep = barg; p_nxge_param_t param_arr = nxgep->param_arr; @@ -4641,14 +4662,23 @@ nxge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, int err = 0; link_flowctrl_t fl; uint64_t tmp = 0; + link_state_t ls; + boolean_t is_default = (pr_flags & DLD_DEFAULT); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_m_getprop: pr_num %d", pr_num)); + + if (pr_valsize == 0) + return (EINVAL); + + if ((is_default) && (pr_num != DLD_PROP_PRIVATE)) { + err = nxge_get_def_val(nxgep, pr_num, pr_valsize, pr_val); + return (err); + } + bzero(pr_val, pr_valsize); switch (pr_num) { case DLD_PROP_DUPLEX: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = statsp->mac_stats.link_duplex; NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_m_getprop: duplex mode %d", @@ -4663,27 +4693,20 @@ nxge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, break; case DLD_PROP_STATUS: - if (pr_valsize < sizeof (uint8_t)) + if (pr_valsize < sizeof (link_state_t)) return (EINVAL); - *(uint8_t *)pr_val = statsp->mac_stats.link_up; + if (!statsp->mac_stats.link_up) + ls = LINK_STATE_DOWN; + else + ls = LINK_STATE_UP; + bcopy(&ls, pr_val, sizeof (ls)); break; case DLD_PROP_AUTONEG: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = param_arr[param_autoneg].value; break; - - case DLD_PROP_DEFMTU: { - if (pr_valsize < sizeof (uint64_t)) - return (EINVAL); - tmp = nxgep->mac.default_mtu; - bcopy(&tmp, pr_val, sizeof (tmp)); - break; - } - case DLD_PROP_FLOWCTRL: if (pr_valsize < sizeof (link_flowctrl_t)) return (EINVAL); @@ -4696,41 +4719,29 @@ nxge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, break; case DLD_PROP_ADV_1000FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = param_arr[param_anar_1000fdx].value; break; case DLD_PROP_EN_1000FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = nxgep->param_en_1000fdx; break; case DLD_PROP_ADV_100FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = param_arr[param_anar_100fdx].value; break; case DLD_PROP_EN_100FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = nxgep->param_en_100fdx; break; case DLD_PROP_ADV_10FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = param_arr[param_anar_10fdx].value; break; case DLD_PROP_EN_10FDX_CAP: - if (pr_valsize < sizeof (uint8_t)) - return (EINVAL); *(uint8_t *)pr_val = nxgep->param_en_10fdx; break; @@ -4740,12 +4751,16 @@ nxge_m_getprop(void *barg, const char *pr_name, mac_prop_id_t pr_num, case DLD_PROP_ADV_1000HDX_CAP: case DLD_PROP_ADV_100HDX_CAP: case DLD_PROP_ADV_10HDX_CAP: - err = EINVAL; + err = ENOTSUP; break; + case DLD_PROP_PRIVATE: + err = nxge_get_priv_prop(nxgep, pr_name, pr_flags, + pr_valsize, pr_val); + break; default: - err = nxge_get_priv_prop(nxgep, pr_name, pr_valsize, - pr_val); + err = EINVAL; + break; } NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "<== nxge_m_getprop")); @@ -5028,25 +5043,39 @@ nxge_set_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, return (err); } + if (strcmp(pr_name, "_adv_10gfdx_cap") == 0) { + err = nxge_param_set_mac(nxgep, NULL, NULL, (char *)pr_val, + (caddr_t)¶m_arr[param_anar_10gfdx]); + return (err); + } + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + err = nxge_param_set_mac(nxgep, NULL, NULL, (char *)pr_val, + (caddr_t)¶m_arr[param_anar_pause]); + return (err); + } return (EINVAL); } static int -nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, - void *pr_val) +nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_flags, + uint_t pr_valsize, void *pr_val) { p_nxge_param_t param_arr = nxgep->param_arr; char valstr[MAXNAMELEN]; int err = EINVAL; uint_t strsize; + boolean_t is_default = (pr_flags & DLD_DEFAULT); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: property %s", pr_name)); /* function number */ if (strcmp(pr_name, "_function_number") == 0) { - (void) sprintf(valstr, "%d", nxgep->function_num); + if (is_default) + return (ENOTSUP); + (void) snprintf(valstr, sizeof (valstr), "%d", + nxgep->function_num); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s " "(value %d valstr %s)", @@ -5058,7 +5087,10 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* Neptune firmware version */ if (strcmp(pr_name, "_fw_version") == 0) { - (void) sprintf(valstr, "%s", nxgep->vpd_info.ver); + if (is_default) + return (ENOTSUP); + (void) snprintf(valstr, sizeof (valstr), "%s", + nxgep->vpd_info.ver); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s " "(value %d valstr %s)", @@ -5070,48 +5102,51 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* port PHY mode */ if (strcmp(pr_name, "_port_mode") == 0) { + if (is_default) + return (ENOTSUP); switch (nxgep->mac.portmode) { case PORT_1G_COPPER: - (void) sprintf(valstr, "1G copper %s", + (void) snprintf(valstr, sizeof (valstr), "1G copper %s", nxgep->hot_swappable_phy ? "[Hot Swappable]" : ""); break; case PORT_1G_FIBER: - (void) sprintf(valstr, "1G fiber %s", + (void) snprintf(valstr, sizeof (valstr), "1G fiber %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_10G_COPPER: - (void) sprintf(valstr, "10G copper %s", + (void) snprintf(valstr, sizeof (valstr), + "10G copper %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_10G_FIBER: - (void) sprintf(valstr, "10G fiber %s", + (void) snprintf(valstr, sizeof (valstr), "10G fiber %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_10G_SERDES: - (void) sprintf(valstr, "10G serdes %s", - nxgep->hot_swappable_phy ? + (void) snprintf(valstr, sizeof (valstr), + "10G serdes %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_1G_SERDES: - (void) sprintf(valstr, "1G serdes %s", + (void) snprintf(valstr, sizeof (valstr), "1G serdes %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_1G_RGMII_FIBER: - (void) sprintf(valstr, "1G rgmii fiber %s", - nxgep->hot_swappable_phy ? + (void) snprintf(valstr, sizeof (valstr), + "1G rgmii fiber %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; case PORT_HSP_MODE: - (void) sprintf(valstr, + (void) snprintf(valstr, sizeof (valstr), "phy not present[hot swappable]"); break; default: - (void) sprintf(valstr, "unknown %s", + (void) snprintf(valstr, sizeof (valstr), "unknown %s", nxgep->hot_swappable_phy ? "[hot swappable]" : ""); break; @@ -5127,7 +5162,9 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* Hot swappable PHY */ if (strcmp(pr_name, "_hot_swap_phy") == 0) { - (void) sprintf(valstr, "%s", + if (is_default) + return (ENOTSUP); + (void) snprintf(valstr, sizeof (valstr), "%s", nxgep->hot_swappable_phy ? "yes" : "no"); @@ -5143,7 +5180,11 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* accept jumbo */ if (strcmp(pr_name, "_accept_jumbo") == 0) { - (void) sprintf(valstr, "%d", nxgep->mac.is_jumbo); + if (is_default) + (void) snprintf(valstr, sizeof (valstr), "%d", 0); + else + (void) snprintf(valstr, sizeof (valstr), + "%d", nxgep->mac.is_jumbo); err = 0; NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s (value %d (%d, %d))", @@ -5157,31 +5198,50 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* Receive Interrupt Blanking Parameters */ if (strcmp(pr_name, "_rxdma_intr_time") == 0) { - (void) sprintf(valstr, "%d", nxgep->intr_timeout); + err = 0; + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), + "%d", RXDMA_RCR_TO_DEFAULT); + goto done; + } + + (void) snprintf(valstr, sizeof (valstr), "%d", + nxgep->intr_timeout); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s (value %d)", pr_name, (uint32_t)nxgep->intr_timeout)); - err = 0; goto done; } if (strcmp(pr_name, "_rxdma_intr_pkts") == 0) { - (void) sprintf(valstr, "%d", nxgep->intr_threshold); + err = 0; + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), + "%d", RXDMA_RCR_PTHRES_DEFAULT); + goto done; + } + (void) snprintf(valstr, sizeof (valstr), "%d", + nxgep->intr_threshold); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s (value %d)", pr_name, (uint32_t)nxgep->intr_threshold)); - err = 0; goto done; } /* Classification and Load Distribution Configuration */ if (strcmp(pr_name, "_class_opt_ipv4_tcp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv4_tcp]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv4_tcp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5190,10 +5250,16 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, } if (strcmp(pr_name, "_class_opt_ipv4_udp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv4_udp]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv4_udp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5201,10 +5267,16 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, goto done; } if (strcmp(pr_name, "_class_opt_ipv4_ah") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv4_ah]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv4_ah].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5213,10 +5285,16 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, } if (strcmp(pr_name, "_class_opt_ipv4_sctp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv4_sctp]); - (void) printf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv4_sctp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5225,23 +5303,34 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, } if (strcmp(pr_name, "_class_opt_ipv6_tcp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv6_tcp]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv6_tcp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: %s", valstr)); - err = 0; goto done; } if (strcmp(pr_name, "_class_opt_ipv6_udp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv6_udp]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv6_udp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5250,10 +5339,16 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, } if (strcmp(pr_name, "_class_opt_ipv6_ah") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv6_ah]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv6_ah].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5262,10 +5357,16 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, } if (strcmp(pr_name, "_class_opt_ipv6_sctp") == 0) { + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%x", + NXGE_CLASS_FLOW_GEN_SERVER); + err = 0; + goto done; + } err = nxge_dld_get_ip_opt(nxgep, (caddr_t)¶m_arr[param_class_opt_ipv6_sctp]); - (void) sprintf(valstr, "%x", + (void) snprintf(valstr, sizeof (valstr), "%x", (int)param_arr[param_class_opt_ipv6_sctp].value); NXGE_DEBUG_MSG((nxgep, NXGE_CTL, @@ -5275,7 +5376,13 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, /* Software LSO */ if (strcmp(pr_name, "_soft_lso_enable") == 0) { - (void) sprintf(valstr, "%d", nxgep->soft_lso_enable); + if (is_default) { + (void) snprintf(valstr, sizeof (valstr), "%d", 0); + err = 0; + goto done; + } + (void) snprintf(valstr, sizeof (valstr), + "%d", nxgep->soft_lso_enable); err = 0; NXGE_DEBUG_MSG((nxgep, NXGE_CTL, "==> nxge_get_priv_prop: name %s (value %d)", @@ -5283,6 +5390,28 @@ nxge_get_priv_prop(p_nxge_t nxgep, const char *pr_name, uint_t pr_valsize, goto done; } + if (strcmp(pr_name, "_adv_10gfdx_cap") == 0) { + err = 0; + if (is_default || + nxgep->param_arr[param_anar_10gfdx].value != 0) { + (void) snprintf(valstr, sizeof (valstr), "%d", 1); + goto done; + } else { + (void) snprintf(valstr, sizeof (valstr), "%d", 0); + goto done; + } + } + if (strcmp(pr_name, "_adv_pause_cap") == 0) { + err = 0; + if (is_default || + nxgep->param_arr[param_anar_pause].value != 0) { + (void) snprintf(valstr, sizeof (valstr), "%d", 1); + goto done; + } else { + (void) snprintf(valstr, sizeof (valstr), "%d", 0); + goto done; + } + } done: if (err == 0) { @@ -5365,7 +5494,7 @@ _init(void) status = ddi_soft_state_init(&nxge_list, sizeof (nxge_t), 0); if (status != 0) { NXGE_ERROR_MSG((NULL, NXGE_ERR_CTL, - "failed to init device soft state")); + "failed to init device soft state")); goto _init_exit; } status = mod_install(&modlinkage); @@ -5398,8 +5527,8 @@ _fini(void) status = mod_remove(&modlinkage); if (status != DDI_SUCCESS) { NXGE_DEBUG_MSG((NULL, MOD_CTL, - "Module removal failed 0x%08x", - status)); + "Module removal failed 0x%08x", + status)); goto _fini_exit; } @@ -5453,16 +5582,16 @@ nxge_add_intrs(p_nxge_t nxgep) /* Get the supported interrupt types */ if ((ddi_status = ddi_intr_get_supported_types(nxgep->dip, &intr_types)) - != DDI_SUCCESS) { + != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "<== nxge_add_intrs: " - "ddi_intr_get_supported_types failed: status 0x%08x", - ddi_status)); + "ddi_intr_get_supported_types failed: status 0x%08x", + ddi_status)); return (NXGE_ERROR | NXGE_DDI_FAILED); } nxgep->nxge_intr_type.intr_types = intr_types; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: 0x%08x", intr_types)); + "ddi_intr_get_supported_types: 0x%08x", intr_types)); /* * Solaris MSIX is not supported yet. use MSI for now. @@ -5473,28 +5602,28 @@ nxge_add_intrs(p_nxge_t nxgep) default: type = DDI_INTR_TYPE_FIXED; NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_add_intrs: " - "use fixed (intx emulation) type %08x", - type)); + "use fixed (intx emulation) type %08x", + type)); break; case 2: NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: 0x%08x", intr_types)); + "ddi_intr_get_supported_types: 0x%08x", intr_types)); if (intr_types & DDI_INTR_TYPE_MSIX) { type = DDI_INTR_TYPE_MSIX; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSIX 0x%08x", - type)); + "ddi_intr_get_supported_types: MSIX 0x%08x", + type)); } else if (intr_types & DDI_INTR_TYPE_MSI) { type = DDI_INTR_TYPE_MSI; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSI 0x%08x", - type)); + "ddi_intr_get_supported_types: MSI 0x%08x", + type)); } else if (intr_types & DDI_INTR_TYPE_FIXED) { type = DDI_INTR_TYPE_FIXED; NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSXED0x%08x", - type)); + "ddi_intr_get_supported_types: MSXED0x%08x", + type)); } break; @@ -5502,39 +5631,39 @@ nxge_add_intrs(p_nxge_t nxgep) if (intr_types & DDI_INTR_TYPE_MSI) { type = DDI_INTR_TYPE_MSI; NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSI 0x%08x", - type)); + "ddi_intr_get_supported_types: MSI 0x%08x", + type)); } else if (intr_types & DDI_INTR_TYPE_MSIX) { type = DDI_INTR_TYPE_MSIX; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSIX 0x%08x", - type)); + "ddi_intr_get_supported_types: MSIX 0x%08x", + type)); } else if (intr_types & DDI_INTR_TYPE_FIXED) { type = DDI_INTR_TYPE_FIXED; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "ddi_intr_get_supported_types: MSXED0x%08x", - type)); + "ddi_intr_get_supported_types: MSXED0x%08x", + type)); } } nxgep->nxge_intr_type.intr_type = type; if ((type == DDI_INTR_TYPE_MSIX || type == DDI_INTR_TYPE_MSI || - type == DDI_INTR_TYPE_FIXED) && - nxgep->nxge_intr_type.niu_msi_enable) { + type == DDI_INTR_TYPE_FIXED) && + nxgep->nxge_intr_type.niu_msi_enable) { if ((status = nxge_add_intrs_adv(nxgep)) != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " nxge_add_intrs: " - " nxge_add_intrs_adv failed: status 0x%08x", - status)); + " nxge_add_intrs: " + " nxge_add_intrs_adv failed: status 0x%08x", + status)); return (status); } else { NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs: " - "interrupts registered : type %d", type)); + "interrupts registered : type %d", type)); nxgep->nxge_intr_type.intr_registered = B_TRUE; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "\nAdded advanced nxge add_intr_adv " - "intr type 0x%x\n", type)); + "\nAdded advanced nxge add_intr_adv " + "intr type 0x%x\n", type)); return (status); } @@ -5542,7 +5671,7 @@ nxge_add_intrs(p_nxge_t nxgep) if (!nxgep->nxge_intr_type.intr_registered) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "==> nxge_add_intrs: " - "failed to register interrupts")); + "failed to register interrupts")); return (NXGE_ERROR | NXGE_DDI_FAILED); } @@ -5563,12 +5692,12 @@ nxge_add_soft_intrs(p_nxge_t nxgep) nxgep->resched_id = NULL; nxgep->resched_running = B_FALSE; ddi_status = ddi_add_softintr(nxgep->dip, DDI_SOFTINT_LOW, - &nxgep->resched_id, - NULL, NULL, nxge_reschedule, (caddr_t)nxgep); + &nxgep->resched_id, + NULL, NULL, nxge_reschedule, (caddr_t)nxgep); if (ddi_status != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "<== nxge_add_soft_intrs: " - "ddi_add_softintrs failed: status 0x%08x", - ddi_status)); + "ddi_add_softintrs failed: status 0x%08x", + ddi_status)); return (NXGE_ERROR | NXGE_DDI_FAILED); } @@ -5588,7 +5717,7 @@ nxge_add_intrs_adv(p_nxge_t nxgep) intrp = (p_nxge_intr_t)&nxgep->nxge_intr_type; intr_type = intrp->intr_type; NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_add_intrs_adv: type 0x%x", - intr_type)); + intr_type)); switch (intr_type) { case DDI_INTR_TYPE_MSI: /* 0x2 */ @@ -5628,22 +5757,22 @@ nxge_add_intrs_adv_type(p_nxge_t nxgep, uint32_t int_type) ddi_status = ddi_intr_get_nintrs(dip, int_type, &nintrs); if ((ddi_status != DDI_SUCCESS) || (nintrs == 0)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_intr_get_nintrs() failed, status: 0x%x%, " - "nintrs: %d", ddi_status, nintrs)); + "ddi_intr_get_nintrs() failed, status: 0x%x%, " + "nintrs: %d", ddi_status, nintrs)); return (NXGE_ERROR | NXGE_DDI_FAILED); } ddi_status = ddi_intr_get_navail(dip, int_type, &navail); if ((ddi_status != DDI_SUCCESS) || (navail == 0)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_intr_get_navail() failed, status: 0x%x%, " - "nintrs: %d", ddi_status, navail)); + "ddi_intr_get_navail() failed, status: 0x%x%, " + "nintrs: %d", ddi_status, navail)); return (NXGE_ERROR | NXGE_DDI_FAILED); } NXGE_DEBUG_MSG((nxgep, INT_CTL, - "ddi_intr_get_navail() returned: nintrs %d, navail %d", - nintrs, navail)); + "ddi_intr_get_navail() returned: nintrs %d, navail %d", + nintrs, navail)); /* PSARC/2007/453 MSI-X interrupt limit override */ if (int_type == DDI_INTR_TYPE_MSIX) { @@ -5671,29 +5800,29 @@ nxge_add_intrs_adv_type(p_nxge_t nxgep, uint32_t int_type) navail = 1; } NXGE_DEBUG_MSG((nxgep, INT_CTL, - "ddi_intr_get_navail(): (msi power of 2) nintrs %d, " - "navail %d", nintrs, navail)); + "ddi_intr_get_navail(): (msi power of 2) nintrs %d, " + "navail %d", nintrs, navail)); } behavior = ((int_type == DDI_INTR_TYPE_FIXED) ? DDI_INTR_ALLOC_STRICT : - DDI_INTR_ALLOC_NORMAL); + DDI_INTR_ALLOC_NORMAL); intrp->intr_size = navail * sizeof (ddi_intr_handle_t); intrp->htable = kmem_alloc(intrp->intr_size, KM_SLEEP); ddi_status = ddi_intr_alloc(dip, intrp->htable, int_type, inum, - navail, &nactual, behavior); + navail, &nactual, behavior); if (ddi_status != DDI_SUCCESS || nactual == 0) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " ddi_intr_alloc() failed: %d", - ddi_status)); + " ddi_intr_alloc() failed: %d", + ddi_status)); kmem_free(intrp->htable, intrp->intr_size); return (NXGE_ERROR | NXGE_DDI_FAILED); } if ((ddi_status = ddi_intr_get_pri(intrp->htable[0], - (uint_t *)&intrp->pri)) != DDI_SUCCESS) { + (uint_t *)&intrp->pri)) != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " ddi_intr_get_pri() failed: %d", - ddi_status)); + " ddi_intr_get_pri() failed: %d", + ddi_status)); /* Free already allocated interrupts */ for (y = 0; y < nactual; y++) { (void) ddi_intr_free(intrp->htable[y]); @@ -5716,8 +5845,8 @@ nxge_add_intrs_adv_type(p_nxge_t nxgep, uint32_t int_type) if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_add_intrs_adv_typ:nxge_ldgv_init " - "failed: 0x%x", status)); + "nxge_add_intrs_adv_typ:nxge_ldgv_init " + "failed: 0x%x", status)); /* Free already allocated interrupts */ for (y = 0; y < nactual; y++) { (void) ddi_intr_free(intrp->htable[y]); @@ -5736,35 +5865,35 @@ nxge_add_intrs_adv_type(p_nxge_t nxgep, uint32_t int_type) if (ldgp->nldvs == 1) { inthandler = (uint_t *)ldgp->ldvp->ldv_intr_handler; NXGE_DEBUG_MSG((nxgep, INT_CTL, - "nxge_add_intrs_adv_type: " - "arg1 0x%x arg2 0x%x: " - "1-1 int handler (entry %d intdata 0x%x)\n", - arg1, arg2, - x, ldgp->intdata)); + "nxge_add_intrs_adv_type: " + "arg1 0x%x arg2 0x%x: " + "1-1 int handler (entry %d intdata 0x%x)\n", + arg1, arg2, + x, ldgp->intdata)); } else if (ldgp->nldvs > 1) { inthandler = (uint_t *)ldgp->sys_intr_handler; NXGE_DEBUG_MSG((nxgep, INT_CTL, - "nxge_add_intrs_adv_type: " - "arg1 0x%x arg2 0x%x: " - "nldevs %d int handler " - "(entry %d intdata 0x%x)\n", - arg1, arg2, - ldgp->nldvs, x, ldgp->intdata)); + "nxge_add_intrs_adv_type: " + "arg1 0x%x arg2 0x%x: " + "nldevs %d int handler " + "(entry %d intdata 0x%x)\n", + arg1, arg2, + ldgp->nldvs, x, ldgp->intdata)); } NXGE_DEBUG_MSG((nxgep, INT_CTL, - "==> nxge_add_intrs_adv_type: ddi_add_intr(inum) #%d " - "htable 0x%llx", x, intrp->htable[x])); + "==> nxge_add_intrs_adv_type: ddi_add_intr(inum) #%d " + "htable 0x%llx", x, intrp->htable[x])); if ((ddi_status = ddi_intr_add_handler(intrp->htable[x], - (ddi_intr_handler_t *)inthandler, arg1, arg2)) - != DDI_SUCCESS) { + (ddi_intr_handler_t *)inthandler, arg1, arg2)) + != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_add_intrs_adv_type: failed #%d " - "status 0x%x", x, ddi_status)); + "==> nxge_add_intrs_adv_type: failed #%d " + "status 0x%x", x, ddi_status)); for (y = 0; y < intrp->intr_added; y++) { (void) ddi_intr_remove_handler( - intrp->htable[y]); + intrp->htable[y]); } /* Free already allocated intr */ for (y = 0; y < nactual; y++) { @@ -5782,10 +5911,10 @@ nxge_add_intrs_adv_type(p_nxge_t nxgep, uint32_t int_type) intrp->msi_intx_cnt = nactual; NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "Requested: %d, Allowed: %d msi_intx_cnt %d intr_added %d", - navail, nactual, - intrp->msi_intx_cnt, - intrp->intr_added)); + "Requested: %d, Allowed: %d msi_intx_cnt %d intr_added %d", + navail, nactual, + intrp->msi_intx_cnt, + intrp->intr_added)); (void) ddi_intr_get_cap(intrp->htable[0], &intrp->intr_cap); @@ -5820,42 +5949,42 @@ nxge_add_intrs_adv_type_fix(p_nxge_t nxgep, uint32_t int_type) ddi_status = ddi_intr_get_nintrs(dip, int_type, &nintrs); if ((ddi_status != DDI_SUCCESS) || (nintrs == 0)) { NXGE_DEBUG_MSG((nxgep, INT_CTL, - "ddi_intr_get_nintrs() failed, status: 0x%x%, " - "nintrs: %d", status, nintrs)); + "ddi_intr_get_nintrs() failed, status: 0x%x%, " + "nintrs: %d", status, nintrs)); return (NXGE_ERROR | NXGE_DDI_FAILED); } ddi_status = ddi_intr_get_navail(dip, int_type, &navail); if ((ddi_status != DDI_SUCCESS) || (navail == 0)) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "ddi_intr_get_navail() failed, status: 0x%x%, " - "nintrs: %d", ddi_status, navail)); + "ddi_intr_get_navail() failed, status: 0x%x%, " + "nintrs: %d", ddi_status, navail)); return (NXGE_ERROR | NXGE_DDI_FAILED); } NXGE_DEBUG_MSG((nxgep, INT_CTL, - "ddi_intr_get_navail() returned: nintrs %d, naavail %d", - nintrs, navail)); + "ddi_intr_get_navail() returned: nintrs %d, naavail %d", + nintrs, navail)); behavior = ((int_type == DDI_INTR_TYPE_FIXED) ? DDI_INTR_ALLOC_STRICT : - DDI_INTR_ALLOC_NORMAL); + DDI_INTR_ALLOC_NORMAL); intrp->intr_size = navail * sizeof (ddi_intr_handle_t); intrp->htable = kmem_alloc(intrp->intr_size, KM_SLEEP); ddi_status = ddi_intr_alloc(dip, intrp->htable, int_type, inum, - navail, &nactual, behavior); + navail, &nactual, behavior); if (ddi_status != DDI_SUCCESS || nactual == 0) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " ddi_intr_alloc() failed: %d", - ddi_status)); + " ddi_intr_alloc() failed: %d", + ddi_status)); kmem_free(intrp->htable, intrp->intr_size); return (NXGE_ERROR | NXGE_DDI_FAILED); } if ((ddi_status = ddi_intr_get_pri(intrp->htable[0], - (uint_t *)&intrp->pri)) != DDI_SUCCESS) { + (uint_t *)&intrp->pri)) != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - " ddi_intr_get_pri() failed: %d", - ddi_status)); + " ddi_intr_get_pri() failed: %d", + ddi_status)); /* Free already allocated interrupts */ for (y = 0; y < nactual; y++) { (void) ddi_intr_free(intrp->htable[y]); @@ -5878,8 +6007,8 @@ nxge_add_intrs_adv_type_fix(p_nxge_t nxgep, uint32_t int_type) if (status != NXGE_OK) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "nxge_add_intrs_adv_type_fix:nxge_ldgv_init " - "failed: 0x%x", status)); + "nxge_add_intrs_adv_type_fix:nxge_ldgv_init " + "failed: 0x%x", status)); /* Free already allocated interrupts */ for (y = 0; y < nactual; y++) { (void) ddi_intr_free(intrp->htable[y]); @@ -5901,30 +6030,30 @@ nxge_add_intrs_adv_type_fix(p_nxge_t nxgep, uint32_t int_type) if (ldgp->nldvs == 1) { inthandler = (uint_t *)ldgp->ldvp->ldv_intr_handler; NXGE_DEBUG_MSG((nxgep, INT_CTL, - "nxge_add_intrs_adv_type_fix: " - "1-1 int handler(%d) ldg %d ldv %d " - "arg1 $%p arg2 $%p\n", - x, ldgp->ldg, ldgp->ldvp->ldv, - arg1, arg2)); + "nxge_add_intrs_adv_type_fix: " + "1-1 int handler(%d) ldg %d ldv %d " + "arg1 $%p arg2 $%p\n", + x, ldgp->ldg, ldgp->ldvp->ldv, + arg1, arg2)); } else if (ldgp->nldvs > 1) { inthandler = (uint_t *)ldgp->sys_intr_handler; NXGE_DEBUG_MSG((nxgep, INT_CTL, - "nxge_add_intrs_adv_type_fix: " - "shared ldv %d int handler(%d) ldv %d ldg %d" - "arg1 0x%016llx arg2 0x%016llx\n", - x, ldgp->nldvs, ldgp->ldg, ldgp->ldvp->ldv, - arg1, arg2)); + "nxge_add_intrs_adv_type_fix: " + "shared ldv %d int handler(%d) ldv %d ldg %d" + "arg1 0x%016llx arg2 0x%016llx\n", + x, ldgp->nldvs, ldgp->ldg, ldgp->ldvp->ldv, + arg1, arg2)); } if ((ddi_status = ddi_intr_add_handler(intrp->htable[x], - (ddi_intr_handler_t *)inthandler, arg1, arg2)) - != DDI_SUCCESS) { + (ddi_intr_handler_t *)inthandler, arg1, arg2)) + != DDI_SUCCESS) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, - "==> nxge_add_intrs_adv_type_fix: failed #%d " - "status 0x%x", x, ddi_status)); + "==> nxge_add_intrs_adv_type_fix: failed #%d " + "status 0x%x", x, ddi_status)); for (y = 0; y < intrp->intr_added; y++) { (void) ddi_intr_remove_handler( - intrp->htable[y]); + intrp->htable[y]); } for (y = 0; y < nactual; y++) { (void) ddi_intr_free(intrp->htable[y]); @@ -5959,7 +6088,7 @@ nxge_remove_intrs(p_nxge_t nxgep) intrp = (p_nxge_intr_t)&nxgep->nxge_intr_type; if (!intrp->intr_registered) { NXGE_DEBUG_MSG((nxgep, INT_CTL, - "<== nxge_remove_intrs: interrupts not registered")); + "<== nxge_remove_intrs: interrupts not registered")); return; } @@ -5967,7 +6096,7 @@ nxge_remove_intrs(p_nxge_t nxgep) if (intrp->intr_cap & DDI_INTR_FLAG_BLOCK) { (void) ddi_intr_block_disable(intrp->htable, - intrp->intr_added); + intrp->intr_added); } else { for (i = 0; i < intrp->intr_added; i++) { (void) ddi_intr_disable(intrp->htable[i]); @@ -5983,11 +6112,11 @@ nxge_remove_intrs(p_nxge_t nxgep) for (inum = 0; inum < intrp->msi_intx_cnt; inum++) { if (intrp->htable[inum]) { NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "nxge_remove_intrs: ddi_intr_free inum %d " - "msi_intx_cnt %d intr_added %d", - inum, - intrp->msi_intx_cnt, - intrp->intr_added)); + "nxge_remove_intrs: ddi_intr_free inum %d " + "msi_intx_cnt %d intr_added %d", + inum, + intrp->msi_intx_cnt, + intrp->intr_added)); (void) ddi_intr_free(intrp->htable[inum]); } @@ -6015,7 +6144,7 @@ nxge_remove_soft_intrs(p_nxge_t nxgep) if (nxgep->resched_id) { ddi_remove_softintr(nxgep->resched_id); NXGE_DEBUG_MSG((nxgep, INT_CTL, - "==> nxge_remove_soft_intrs: removed")); + "==> nxge_remove_soft_intrs: removed")); nxgep->resched_id = NULL; } @@ -6036,29 +6165,29 @@ nxge_intrs_enable(p_nxge_t nxgep) if (!intrp->intr_registered) { NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "<== nxge_intrs_enable: " - "interrupts are not registered")); + "interrupts are not registered")); return; } if (intrp->intr_enabled) { NXGE_DEBUG_MSG((nxgep, INT_CTL, - "<== nxge_intrs_enable: already enabled")); + "<== nxge_intrs_enable: already enabled")); return; } if (intrp->intr_cap & DDI_INTR_FLAG_BLOCK) { status = ddi_intr_block_enable(intrp->htable, - intrp->intr_added); + intrp->intr_added); NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_intrs_enable " - "block enable - status 0x%x total inums #%d\n", - status, intrp->intr_added)); + "block enable - status 0x%x total inums #%d\n", + status, intrp->intr_added)); } else { for (i = 0; i < intrp->intr_added; i++) { status = ddi_intr_enable(intrp->htable[i]); NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_intrs_enable " - "ddi_intr_enable:enable - status 0x%x " - "total inums %d enable inum #%d\n", - status, intrp->intr_added, i)); + "ddi_intr_enable:enable - status 0x%x " + "total inums %d enable inum #%d\n", + status, intrp->intr_added, i)); if (status == DDI_SUCCESS) { intrp->intr_enabled = B_TRUE; } @@ -6081,13 +6210,13 @@ nxge_intrs_disable(p_nxge_t nxgep) if (!intrp->intr_registered) { NXGE_DEBUG_MSG((nxgep, INT_CTL, "<== nxge_intrs_disable: " - "interrupts are not registered")); + "interrupts are not registered")); return; } if (intrp->intr_cap & DDI_INTR_FLAG_BLOCK) { (void) ddi_intr_block_disable(intrp->htable, - intrp->intr_added); + intrp->intr_added); } else { for (i = 0; i < intrp->intr_added; i++) { (void) ddi_intr_disable(intrp->htable[i]); @@ -6119,6 +6248,8 @@ nxge_mac_register(p_nxge_t nxgep) NXGE_EHEADER_VLAN_CRC; macp->m_max_sdu = nxgep->mac.default_mtu; macp->m_margin = VLAN_TAGSZ; + macp->m_priv_props = nxge_priv_props; + macp->m_priv_prop_count = NXGE_MAX_PRIV_PROPS; NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mac_register: instance %d " @@ -6133,13 +6264,13 @@ nxge_mac_register(p_nxge_t nxgep) if (status != 0) { cmn_err(CE_WARN, - "!nxge_mac_register failed (status %d instance %d)", - status, nxgep->instance); + "!nxge_mac_register failed (status %d instance %d)", + status, nxgep->instance); return (NXGE_ERROR); } NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_mac_register success " - "(instance %d)", nxgep->instance)); + "(instance %d)", nxgep->instance)); return (NXGE_OK); } @@ -6220,40 +6351,40 @@ nxge_init_common_dev(p_nxge_t nxgep) p_dip = nxgep->p_dip; MUTEX_ENTER(&nxge_common_lock); NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_init_common_dev:func # %d", - nxgep->function_num)); + "==> nxge_init_common_dev:func # %d", + nxgep->function_num)); /* * Loop through existing per neptune hardware list. */ for (hw_p = nxge_hw_list; hw_p; hw_p = hw_p->next) { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_init_common_device:func # %d " - "hw_p $%p parent dip $%p", - nxgep->function_num, - hw_p, - p_dip)); + "==> nxge_init_common_device:func # %d " + "hw_p $%p parent dip $%p", + nxgep->function_num, + hw_p, + p_dip)); if (hw_p->parent_devp == p_dip) { nxgep->nxge_hw_p = hw_p; hw_p->ndevs++; hw_p->nxge_p[nxgep->function_num] = nxgep; NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_init_common_device:func # %d " - "hw_p $%p parent dip $%p " - "ndevs %d (found)", - nxgep->function_num, - hw_p, - p_dip, - hw_p->ndevs)); + "==> nxge_init_common_device:func # %d " + "hw_p $%p parent dip $%p " + "ndevs %d (found)", + nxgep->function_num, + hw_p, + p_dip, + hw_p->ndevs)); break; } } if (hw_p == NULL) { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_init_common_device:func # %d " - "parent dip $%p (new)", - nxgep->function_num, - p_dip)); + "==> nxge_init_common_device:func # %d " + "parent dip $%p (new)", + nxgep->function_num, + p_dip)); hw_p = kmem_zalloc(sizeof (nxge_hw_list_t), KM_SLEEP); hw_p->parent_devp = p_dip; hw_p->magic = NXGE_NEPTUNE_MAGIC; @@ -6287,8 +6418,8 @@ nxge_init_common_dev(p_nxge_t nxgep) } NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_init_common_device (nxge_hw_list) $%p", - nxge_hw_list)); + "==> nxge_init_common_device (nxge_hw_list) $%p", + nxge_hw_list)); NXGE_DEBUG_MSG((nxgep, MOD_CTL, "<== nxge_init_common_device")); return (NXGE_OK); @@ -6303,7 +6434,7 @@ nxge_uninit_common_dev(p_nxge_t nxgep) NXGE_DEBUG_MSG((nxgep, MOD_CTL, "==> nxge_uninit_common_device")); if (nxgep->nxge_hw_p == NULL) { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "<== nxge_uninit_common_device (no common)")); + "<== nxge_uninit_common_device (no common)")); return; } @@ -6312,18 +6443,18 @@ nxge_uninit_common_dev(p_nxge_t nxgep) for (hw_p = nxge_hw_list; hw_p; hw_p = hw_p->next) { p_dip = hw_p->parent_devp; if (nxgep->nxge_hw_p == hw_p && - p_dip == nxgep->p_dip && - nxgep->nxge_hw_p->magic == NXGE_NEPTUNE_MAGIC && - hw_p->magic == NXGE_NEPTUNE_MAGIC) { + p_dip == nxgep->p_dip && + nxgep->nxge_hw_p->magic == NXGE_NEPTUNE_MAGIC && + hw_p->magic == NXGE_NEPTUNE_MAGIC) { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_uninit_common_device:func # %d " - "hw_p $%p parent dip $%p " - "ndevs %d (found)", - nxgep->function_num, - hw_p, - p_dip, - hw_p->ndevs)); + "==> nxge_uninit_common_device:func # %d " + "hw_p $%p parent dip $%p " + "ndevs %d (found)", + nxgep->function_num, + hw_p, + p_dip, + hw_p->ndevs)); if (hw_p->ndevs) { hw_p->ndevs--; @@ -6335,38 +6466,38 @@ nxge_uninit_common_dev(p_nxge_t nxgep) MUTEX_DESTROY(&hw_p->nxge_cfg_lock); MUTEX_DESTROY(&hw_p->nxge_mdio_lock); NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_uninit_common_device: " - "func # %d " - "hw_p $%p parent dip $%p " - "ndevs %d (last)", - nxgep->function_num, - hw_p, - p_dip, - hw_p->ndevs)); + "==> nxge_uninit_common_device: " + "func # %d " + "hw_p $%p parent dip $%p " + "ndevs %d (last)", + nxgep->function_num, + hw_p, + p_dip, + hw_p->ndevs)); nxge_hio_uninit(nxgep); if (hw_p == nxge_hw_list) { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_uninit_common_device:" - "remove head func # %d " - "hw_p $%p parent dip $%p " - "ndevs %d (head)", - nxgep->function_num, - hw_p, - p_dip, - hw_p->ndevs)); + "==> nxge_uninit_common_device:" + "remove head func # %d " + "hw_p $%p parent dip $%p " + "ndevs %d (head)", + nxgep->function_num, + hw_p, + p_dip, + hw_p->ndevs)); nxge_hw_list = hw_p->next; } else { NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_uninit_common_device:" - "remove middle func # %d " - "hw_p $%p parent dip $%p " - "ndevs %d (middle)", - nxgep->function_num, - hw_p, - p_dip, - hw_p->ndevs)); + "==> nxge_uninit_common_device:" + "remove middle func # %d " + "hw_p $%p parent dip $%p " + "ndevs %d (middle)", + nxgep->function_num, + hw_p, + p_dip, + hw_p->ndevs)); h_hw_p->next = hw_p->next; } @@ -6381,8 +6512,8 @@ nxge_uninit_common_dev(p_nxge_t nxgep) MUTEX_EXIT(&nxge_common_lock); NXGE_DEBUG_MSG((nxgep, MOD_CTL, - "==> nxge_uninit_common_device (nxge_hw_list) $%p", - nxge_hw_list)); + "==> nxge_uninit_common_device (nxge_hw_list) $%p", + nxge_hw_list)); NXGE_DEBUG_MSG((nxgep, MOD_CTL, "<= nxge_uninit_common_device")); } @@ -6475,3 +6606,36 @@ nxge_create_msi_property(p_nxge_t nxgep) NXGE_DEBUG_MSG((nxgep, MOD_CTL, "<==nxge_create_msi_property")); return (nmsi); } + +/* ARGSUSED */ +static int +nxge_get_def_val(nxge_t *nxgep, mac_prop_id_t pr_num, uint_t pr_valsize, + void *pr_val) +{ + int err = 0; + link_flowctrl_t fl; + + switch (pr_num) { + case DLD_PROP_AUTONEG: + *(uint8_t *)pr_val = 1; + break; + case DLD_PROP_FLOWCTRL: + if (pr_valsize < sizeof (link_flowctrl_t)) + return (EINVAL); + fl = LINK_FLOWCTRL_RX; + bcopy(&fl, pr_val, sizeof (fl)); + break; + case DLD_PROP_ADV_1000FDX_CAP: + case DLD_PROP_EN_1000FDX_CAP: + *(uint8_t *)pr_val = 1; + break; + case DLD_PROP_ADV_100FDX_CAP: + case DLD_PROP_EN_100FDX_CAP: + *(uint8_t *)pr_val = 1; + break; + default: + err = ENOTSUP; + break; + } + return (err); +} diff --git a/usr/src/uts/common/io/nxge/nxge_ndd.c b/usr/src/uts/common/io/nxge/nxge_ndd.c index d6f24ae2b7..3fe361b27b 100644 --- a/usr/src/uts/common/io/nxge/nxge_ndd.c +++ b/usr/src/uts/common/io/nxge/nxge_ndd.c @@ -82,7 +82,7 @@ extern uint64_t npi_debug_level; rlen -= plen; \ } -static int nxge_param_set_mac(p_nxge_t, queue_t *, +int nxge_param_set_mac(p_nxge_t, queue_t *, mblk_t *, char *, caddr_t); static int nxge_param_set_port_rdc(p_nxge_t, queue_t *, mblk_t *, char *, caddr_t); @@ -559,12 +559,12 @@ nxge_get_param_soft_properties(p_nxge_t nxgep) if ((param_arr[i].type & NXGE_PARAM_PROP_STR)) continue; if ((param_arr[i].type & NXGE_PARAM_PROP_ARR32) || - (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { + (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, - nxgep->dip, 0, param_arr[i].fcode_name, - (int **)&int_prop_val, - (uint_t *)&prop_len) - == DDI_PROP_SUCCESS) { + nxgep->dip, 0, param_arr[i].fcode_name, + (int **)&int_prop_val, + (uint_t *)&prop_len) + == DDI_PROP_SUCCESS) { uint32_t *cfg_value; uint64_t prop_count; @@ -572,7 +572,7 @@ nxge_get_param_soft_properties(p_nxge_t nxgep) prop_len = NXGE_PARAM_ARRAY_INIT_SIZE; #if defined(__i386) cfg_value = - (uint32_t *)(int32_t)param_arr[i].value; + (uint32_t *)(int32_t)param_arr[i].value; #else cfg_value = (uint32_t *)param_arr[i].value; #endif @@ -588,42 +588,42 @@ nxge_get_param_soft_properties(p_nxge_t nxgep) } if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, nxgep->dip, 0, - param_arr[i].fcode_name, - (int **)&int_prop_val, - &prop_len) == DDI_PROP_SUCCESS) { + param_arr[i].fcode_name, + (int **)&int_prop_val, + &prop_len) == DDI_PROP_SUCCESS) { if ((*int_prop_val >= param_arr[i].minimum) && - (*int_prop_val <= param_arr[i].maximum)) + (*int_prop_val <= param_arr[i].maximum)) param_arr[i].value = *int_prop_val; #ifdef NXGE_DEBUG_ERROR else { NXGE_DEBUG_MSG((nxgep, OBP_CTL, - "nxge%d: 'prom' file parameter error\n", - nxgep->instance)); + "nxge%d: 'prom' file parameter error\n", + nxgep->instance)); NXGE_DEBUG_MSG((nxgep, OBP_CTL, - "Parameter keyword '%s'" - " is outside valid range\n", - param_arr[i].name)); + "Parameter keyword '%s'" + " is outside valid range\n", + param_arr[i].name)); } #endif ddi_prop_free(int_prop_val); } if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, nxgep->dip, 0, - param_arr[i].name, - (int **)&int_prop_val, - &prop_len) == DDI_PROP_SUCCESS) { + param_arr[i].name, + (int **)&int_prop_val, + &prop_len) == DDI_PROP_SUCCESS) { if ((*int_prop_val >= param_arr[i].minimum) && - (*int_prop_val <= param_arr[i].maximum)) + (*int_prop_val <= param_arr[i].maximum)) param_arr[i].value = *int_prop_val; #ifdef NXGE_DEBUG_ERROR else { NXGE_DEBUG_MSG((nxgep, OBP_CTL, - "nxge%d: 'conf' file parameter error\n", - nxgep->instance)); + "nxge%d: 'conf' file parameter error\n", + nxgep->instance)); NXGE_DEBUG_MSG((nxgep, OBP_CTL, - "Parameter keyword '%s'" - "is outside valid range\n", - param_arr[i].name)); + "Parameter keyword '%s'" + "is outside valid range\n", + param_arr[i].name)); } #endif ddi_prop_free(int_prop_val); @@ -642,7 +642,7 @@ nxge_private_param_register(p_nxge_t nxgep, p_nxge_param_t param_arr) uint32_t name_chars; NXGE_DEBUG_MSG((nxgep, NDD2_CTL, - "nxge_private_param_register %s", param_arr->name)); + "nxge_private_param_register %s", param_arr->name)); if ((param_arr->type & NXGE_PARAM_PRIV) != NXGE_PARAM_PRIV) return (B_TRUE); @@ -672,8 +672,8 @@ nxge_private_param_register(p_nxge_t nxgep, p_nxge_param_t param_arr) channel = mi_strtol(prop_name, &end, 10); /* now check if this rdc is in config */ NXGE_DEBUG_MSG((nxgep, NDD2_CTL, - " nxge_private_param_register: %d", - channel)); + " nxge_private_param_register: %d", + channel)); return (nxge_check_txdma_port_member(nxgep, channel)); } return (B_FALSE); @@ -706,8 +706,8 @@ nxge_setup_param(p_nxge_t nxgep) for (i = 0; i < nxgep->param_count; i++) { if ((param_arr[i].type & NXGE_PARAM_PRIV) && - (nxge_private_param_register(nxgep, - ¶m_arr[i]) == B_FALSE)) { + (nxge_private_param_register(nxgep, + ¶m_arr[i]) == B_FALSE)) { param_arr[i].setf = NULL; param_arr[i].getf = NULL; } @@ -726,12 +726,6 @@ nxge_setup_param(p_nxge_t nxgep) set_pfi = NULL; } - if (!nxge_nd_load(&nxgep->param_list, param_arr[i].name, - (pfi_t)param_arr[i].getf, set_pfi, - (caddr_t)¶m_arr[i])) { - (void) nxge_nd_free(&nxgep->param_list); - break; - } } NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_setup_param")); } @@ -752,30 +746,31 @@ nxge_init_param(p_nxge_t nxgep) param_arr = nxgep->param_arr; if (param_arr == NULL) { param_arr = (p_nxge_param_t) - KMEM_ZALLOC(sizeof (nxge_param_arr), KM_SLEEP); + KMEM_ZALLOC(sizeof (nxge_param_arr), KM_SLEEP); } for (i = 0; i < sizeof (nxge_param_arr)/sizeof (nxge_param_t); i++) { param_arr[i] = nxge_param_arr[i]; if ((param_arr[i].type & NXGE_PARAM_PROP_ARR32) || - (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { + (param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { alloc_count = NXGE_PARAM_ARRAY_INIT_SIZE; alloc_size = alloc_count * sizeof (uint64_t); param_arr[i].value = #if defined(__i386) - (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size, KM_SLEEP); + (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size, + KM_SLEEP); #else (uint64_t)KMEM_ZALLOC(alloc_size, KM_SLEEP); #endif param_arr[i].old_value = #if defined(__i386) - (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size, - KM_SLEEP); + (uint64_t)(uint32_t)KMEM_ZALLOC(alloc_size, + KM_SLEEP); #else - (uint64_t)KMEM_ZALLOC(alloc_size, KM_SLEEP); + (uint64_t)KMEM_ZALLOC(alloc_size, KM_SLEEP); #endif param_arr[i].type |= - (alloc_count << NXGE_PARAM_ARRAY_ALLOC_SHIFT); + (alloc_count << NXGE_PARAM_ARRAY_ALLOC_SHIFT); } } @@ -785,7 +780,7 @@ nxge_init_param(p_nxge_t nxgep) nxge_param_sync(nxgep); NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_init_param: count %d", - nxgep->param_count)); + nxgep->param_count)); } void @@ -804,34 +799,32 @@ nxge_destroy_param(p_nxge_t nxgep) if (nxge_param_arr[param_instance].value == nxgep->instance) { for (i = 0; i <= nxge_param_arr[param_instance].maximum; i++) { if ((ddi_get_soft_state(nxge_list, i) != NULL) && - (i != nxgep->instance)) + (i != nxgep->instance)) break; } nxge_param_arr[param_instance].value = i; } - if (nxgep->param_list) - nxge_nd_free(&nxgep->param_list); for (i = 0; i < nxgep->param_count; i++) if ((nxgep->param_arr[i].type & NXGE_PARAM_PROP_ARR32) || - (nxgep->param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { + (nxgep->param_arr[i].type & NXGE_PARAM_PROP_ARR64)) { free_count = ((nxgep->param_arr[i].type & - NXGE_PARAM_ARRAY_ALLOC_MASK) >> - NXGE_PARAM_ARRAY_ALLOC_SHIFT); + NXGE_PARAM_ARRAY_ALLOC_MASK) >> + NXGE_PARAM_ARRAY_ALLOC_SHIFT); free_count = NXGE_PARAM_ARRAY_INIT_SIZE; free_size = sizeof (uint64_t) * free_count; #if defined(__i386) KMEM_FREE((void *)(uint32_t)nxgep->param_arr[i].value, - free_size); + free_size); #else KMEM_FREE((void *)nxgep->param_arr[i].value, free_size); #endif #if defined(__i386) KMEM_FREE((void *)(uint32_t) - nxgep->param_arr[i].old_value, free_size); + nxgep->param_arr[i].old_value, free_size); #else KMEM_FREE((void *)nxgep->param_arr[i].old_value, - free_size); + free_size); #endif } @@ -851,11 +844,11 @@ nxge_param_get_generic(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) p_nxge_param_t pa = (p_nxge_param_t)cp; NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "==> nxge_param_get_generic name %s ", pa->name)); + "==> nxge_param_get_generic name %s ", pa->name)); if (pa->value > 0xffffffff) (void) mi_mpprintf(mp, "%x%x", - (int)(pa->value >> 32), (int)(pa->value & 0xffffffff)); + (int)(pa->value >> 32), (int)(pa->value & 0xffffffff)); else (void) mi_mpprintf(mp, "%x", (int)pa->value); @@ -966,7 +959,7 @@ nxge_param_get_txdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_txdma_info")); (void) mi_mpprintf(mp, "TXDMA Information for Port\t %d \n", - nxgep->function_num); + nxgep->function_num); if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { (void) mi_mpprintf(mp, "%s\n", "out of buffer"); @@ -980,7 +973,7 @@ nxge_param_get_txdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "TDC\t HW TDC\t\n"); + "TDC\t HW TDC\t\n"); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; @@ -1017,7 +1010,7 @@ nxge_param_get_rxdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_rxdma_info")); (void) mi_mpprintf(mp, "RXDMA Information for Port\t %d \n", - nxgep->function_num); + nxgep->function_num); if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { /* The following may work even if we cannot get a large buf. */ @@ -1036,13 +1029,13 @@ nxge_param_get_rxdma_info(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) rbr_rings = rx_rbr_rings->rbr_rings; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "Total RDCs\t %d\n", p_cfgp->max_rdcs); + "Total RDCs\t %d\n", p_cfgp->max_rdcs); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "RDC\t HW RDC\t Timeout\t Packets RBR ptr \t" - "chunks\t RCR ptr\n"); + "RDC\t HW RDC\t Timeout\t Packets RBR ptr \t" + "chunks\t RCR ptr\n"); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; @@ -1081,13 +1074,13 @@ nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q, int buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE; NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "==> nxge_param_get_rxdma_rdcgrp_info")); + "==> nxge_param_get_rxdma_rdcgrp_info")); p_dma_cfgp = (p_nxge_dma_pt_cfg_t)&nxgep->pt_config; p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config; (void) mi_mpprintf(mp, "RXDMA RDC Group Information for Port\t %d \n", - nxgep->function_num); + nxgep->function_num); rdc_grp = p_cfgp->def_mac_rxdma_grpid; if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { @@ -1099,10 +1092,10 @@ nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q, buf_len = buff_alloc_size; mp->b_cont = np; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "Total RDC Groups\t %d \n" - "default RDC group\t %d\n", - p_cfgp->max_rdc_grpids, - p_cfgp->def_mac_rxdma_grpid); + "Total RDC Groups\t %d \n" + "default RDC group\t %d\n", + p_cfgp->max_rdc_grpids, + p_cfgp->def_mac_rxdma_grpid); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; @@ -1128,9 +1121,9 @@ nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q, for (rdc = 0; rdc < rdc_grp_p->max_rdcs; rdc++) { print_len = snprintf( - (char *)((mblk_t *)np)->b_wptr, - buf_len, "[%d]=%d ", rdc, - rdc_grp_p->start_rdc + rdc); + (char *)((mblk_t *)np)->b_wptr, + buf_len, "[%d]=%d ", rdc, + rdc_grp_p->start_rdc + rdc); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; } @@ -1141,10 +1134,10 @@ nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q, for (offset = 0; offset < 16; offset++) { print_len = snprintf( - (char *)((mblk_t *)np)->b_wptr, - buf_len, " %c", - rdc_grp_p->map & (1 << offset) ? - '1' : '0'); + (char *)((mblk_t *)np)->b_wptr, + buf_len, " %c", + rdc_grp_p->map & (1 << offset) ? + '1' : '0'); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; } @@ -1155,7 +1148,7 @@ nxge_param_get_rxdma_rdcgrp_info(p_nxge_t nxgep, queue_t *q, } } NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "<== nxge_param_get_rxdma_rdcgrp_info")); + "<== nxge_param_get_rxdma_rdcgrp_info")); return (0); } @@ -1178,10 +1171,6 @@ nxge_mk_mblk_tail_space(p_mblk_t mp, p_mblk_t *nmp, size_t size) return (0); } -/* - * Sets the ge parameter to the value in the nxge_param_register using - * nxge_nd_load(). - */ /* ARGSUSED */ int @@ -1195,7 +1184,7 @@ nxge_param_set_generic(p_nxge_t nxgep, queue_t *q, mblk_t *mp, NXGE_DEBUG_MSG((nxgep, IOC_CTL, " ==> nxge_param_set_generic")); new_value = (uint32_t)mi_strtol(value, &end, 10); if (end == value || new_value < pa->minimum || - new_value > pa->maximum) { + new_value > pa->maximum) { return (EINVAL); } pa->value = new_value; @@ -1203,10 +1192,6 @@ nxge_param_set_generic(p_nxge_t nxgep, queue_t *q, mblk_t *mp, return (0); } -/* - * Sets the ge parameter to the value in the nxge_param_register using - * nxge_nd_load(). - */ /* ARGSUSED */ int @@ -1218,10 +1203,6 @@ nxge_param_set_instance(p_nxge_t nxgep, queue_t *q, mblk_t *mp, return (0); } -/* - * Sets the ge parameter to the value in the nxge_param_register using - * nxge_nd_load(). - */ /* ARGSUSED */ int @@ -1246,7 +1227,7 @@ nxge_param_set_mac(p_nxge_t nxgep, queue_t *q, mblk_t *mp, if (!nxge_param_link_update(nxgep)) { NXGE_DEBUG_MSG((nxgep, NDD_CTL, - " false ret from nxge_param_link_update")); + " false ret from nxge_param_link_update")); status = EINVAL; } @@ -1268,7 +1249,7 @@ nxge_param_rx_intr_pkts(p_nxge_t nxgep, queue_t *q, mblk_t *mp, cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY); if ((cfg_value > NXGE_RDC_RCR_THRESHOLD_MAX) || - (cfg_value < NXGE_RDC_RCR_THRESHOLD_MIN)) { + (cfg_value < NXGE_RDC_RCR_THRESHOLD_MIN)) { return (EINVAL); } @@ -1296,7 +1277,7 @@ nxge_param_rx_intr_time(p_nxge_t nxgep, queue_t *q, mblk_t *mp, cfg_value = (uint32_t)mi_strtol(value, &end, BASE_ANY); if ((cfg_value > NXGE_RDC_RCR_TIMEOUT_MAX) || - (cfg_value < NXGE_RDC_RCR_TIMEOUT_MIN)) { + (cfg_value < NXGE_RDC_RCR_TIMEOUT_MIN)) { return (EINVAL); } @@ -1339,7 +1320,7 @@ nxge_param_set_mac_rdcgrp(p_nxge_t nxgep, queue_t *q, */ mac_map = (nxge_param_map_t *)&cfg_value; NXGE_DEBUG_MSG((nxgep, NDD_CTL, " cfg_value %x id %x map_to %x", - cfg_value, mac_map->param_id, mac_map->map_to)); + cfg_value, mac_map->param_id, mac_map->map_to)); if ((mac_map->param_id < p_cfgp->max_macs) && p_cfgp->grpids[mac_map->map_to]) { @@ -1411,7 +1392,7 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, /* now do decoding */ cfgd_vlans = ((pa->type & NXGE_PARAM_ARRAY_CNT_MASK) >> - NXGE_PARAM_ARRAY_CNT_SHIFT); + NXGE_PARAM_ARRAY_CNT_SHIFT); if (cfgd_vlans == NXGE_PARAM_ARRAY_INIT_SIZE) { /* @@ -1425,12 +1406,12 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, vmap = (nxge_param_map_t *)&cfg_value; if ((vmap->param_id) && - (vmap->param_id < NXGE_MAX_VLANS) && - (vmap->map_to < p_cfgp->max_rdc_grpids)) { + (vmap->param_id < NXGE_MAX_VLANS) && + (vmap->map_to < p_cfgp->max_rdc_grpids)) { NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "nxge_param_set_vlan_rdcgrp mapping" - " id %d grp %d", - vmap->param_id, vmap->map_to)); + "nxge_param_set_vlan_rdcgrp mapping" + " id %d grp %d", + vmap->param_id, vmap->map_to)); #if defined(__i386) val_ptr = (uint32_t *)(uint32_t)pa->value; #else @@ -1446,8 +1427,8 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, for (i = 0; i < cfgd_vlans; i++) { old_map = (nxge_param_map_t *)&val_ptr[i]; if ((old_map->param_id == 0) || - (vmap->param_id == old_map->param_id) || - (vlan_tbl[vmap->param_id].flag)) { + (vmap->param_id == old_map->param_id) || + (vlan_tbl[vmap->param_id].flag)) { cfg_position = i; break; } @@ -1464,9 +1445,9 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, } NXGE_DEBUG_MSG((nxgep, NDD2_CTL, - "set_vlan_rdcgrp mapping" - " i %d cfgd_vlans %llx position %d ", - i, cfgd_vlans, cfg_position)); + "set_vlan_rdcgrp mapping" + " i %d cfgd_vlans %llx position %d ", + i, cfgd_vlans, cfg_position)); if (val_ptr[cfg_position] != cfg_value) { old_val_ptr[cfg_position] = val_ptr[cfg_position]; val_ptr[cfg_position] = cfg_value; @@ -1479,13 +1460,13 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, cfgd_vlans++; pa->type &= ~NXGE_PARAM_ARRAY_CNT_MASK; pa->type |= (cfgd_vlans << - NXGE_PARAM_ARRAY_CNT_SHIFT); + NXGE_PARAM_ARRAY_CNT_SHIFT); } NXGE_DEBUG_MSG((nxgep, NDD2_CTL, - "after: param_set_vlan_rdcgrp " - " cfg_vlans %llx position %d \n", - cfgd_vlans, cfg_position)); + "after: param_set_vlan_rdcgrp " + " cfg_vlans %llx position %d \n", + cfgd_vlans, cfg_position)); } } else { return (EINVAL); @@ -1493,7 +1474,7 @@ nxge_param_set_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, if (cfg_it == B_TRUE) { status = nxge_fflp_config_vlan_table(nxgep, - (uint16_t)vmap->param_id); + (uint16_t)vmap->param_id); if (status != NXGE_OK) return (EINVAL); } @@ -1520,11 +1501,11 @@ nxge_param_get_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, uint64_t cfgd_vlans = 0; nxge_mv_cfg_t *vlan_tbl; int buff_alloc_size = - NXGE_NDD_INFODUMP_BUFF_SIZE * 32; + NXGE_NDD_INFODUMP_BUFF_SIZE * 32; NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_set_vlan_rdcgrp ")); (void) mi_mpprintf(mp, "VLAN RDC Mapping Information for Port\t %d \n", - nxgep->function_num); + nxgep->function_num); if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { (void) mi_mpprintf(mp, "%s\n", "out of buffer"); @@ -1537,15 +1518,15 @@ nxge_param_get_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, buf_len = buff_alloc_size; mp->b_cont = np; cfgd_vlans = (pa->type & NXGE_PARAM_ARRAY_CNT_MASK) >> - NXGE_PARAM_ARRAY_CNT_SHIFT; + NXGE_PARAM_ARRAY_CNT_SHIFT; i = (int)cfgd_vlans; p_class_cfgp = (p_nxge_class_pt_cfg_t)&nxgep->class_config; vlan_tbl = (nxge_mv_cfg_t *)&p_class_cfgp->vlan_tbl[0]; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "Configured VLANs %d\n" - "VLAN ID\t RDC GRP (Actual/Port)\t" - " Prefernce\n", i); + "Configured VLANs %d\n" + "VLAN ID\t RDC GRP (Actual/Port)\t" + " Prefernce\n", i); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; #if defined(__i386) @@ -1558,13 +1539,13 @@ nxge_param_get_vlan_rdcgrp(p_nxge_t nxgep, queue_t *q, vmap = (nxge_param_map_t *)&val_ptr[i]; if (p_class_cfgp->vlan_tbl[vmap->param_id].flag) { print_len = snprintf((char *)((mblk_t *)np)->b_wptr, - buf_len, - " %d\t\t %d/%d\t\t %d\n", - vmap->param_id, - vlan_tbl[vmap->param_id].rdctbl, - vlan_tbl[vmap->param_id].rdctbl - - p_cfgp->def_mac_rxdma_grpid, - vlan_tbl[vmap->param_id].mpr_npr); + buf_len, + " %d\t\t %d/%d\t\t %d\n", + vmap->param_id, + vlan_tbl[vmap->param_id].rdctbl, + vlan_tbl[vmap->param_id].rdctbl - + p_cfgp->def_mac_rxdma_grpid, + vlan_tbl[vmap->param_id].mpr_npr); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; } @@ -1590,8 +1571,8 @@ nxge_param_get_mac_rdcgrp(p_nxge_t nxgep, queue_t *q, int buff_alloc_size = NXGE_NDD_INFODUMP_BUFF_SIZE * 32; NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_get_mac_rdcgrp ")); (void) mi_mpprintf(mp, - "MAC ADDR RDC Mapping Information for Port\t %d\n", - nxgep->function_num); + "MAC ADDR RDC Mapping Information for Port\t %d\n", + nxgep->function_num); if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { (void) mi_mpprintf(mp, "%s\n", "out of buffer"); @@ -1605,25 +1586,25 @@ nxge_param_get_mac_rdcgrp(p_nxge_t nxgep, queue_t *q, p_cfgp = (p_nxge_hw_pt_cfg_t)&p_dma_cfgp->hw_config; mac_host_info = (nxge_mv_cfg_t *)&p_class_cfgp->mac_host_info[0]; print_len = snprintf((char *)np->b_wptr, buf_len, - "MAC ID\t RDC GRP (Actual/Port)\t" - " Prefernce\n"); + "MAC ID\t RDC GRP (Actual/Port)\t" + " Prefernce\n"); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; for (i = 0; i < p_cfgp->max_macs; i++) { if (mac_host_info[i].flag) { print_len = snprintf((char *)((mblk_t *)np)->b_wptr, - buf_len, - " %d\t %d/%d\t\t %d\n", - i, mac_host_info[i].rdctbl, - mac_host_info[i].rdctbl - - p_cfgp->def_mac_rxdma_grpid, - mac_host_info[i].mpr_npr); + buf_len, + " %d\t %d/%d\t\t %d\n", + i, mac_host_info[i].rdctbl, + mac_host_info[i].rdctbl - + p_cfgp->def_mac_rxdma_grpid, + mac_host_info[i].mpr_npr); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; } } print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "Done Info Dumping \n"); + "Done Info Dumping \n"); ((mblk_t *)np)->b_wptr += print_len; buf_len -= print_len; NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_get_macrdcgrp")); @@ -1875,7 +1856,7 @@ nxge_param_get_ip_opt(p_nxge_t nxgep, queue_t *q, return (EINVAL); NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "nxge_param_get_ip_opt_get %x ", cfg_value)); + "nxge_param_get_ip_opt_get %x ", cfg_value)); pa->value = cfg_value; (void) mi_mpprintf(mp, "%x", cfg_value); @@ -1903,7 +1884,7 @@ nxge_param_fflp_hash_init(p_nxge_t nxgep, queue_t *q, } NXGE_DEBUG_MSG((nxgep, NDD_CTL, - "nxge_param_fflp_hash_init value %x", cfg_value)); + "nxge_param_fflp_hash_init value %x", cfg_value)); if (pa->value != cfg_value) { pa->old_value = pa->value; @@ -1921,18 +1902,18 @@ nxge_param_fflp_hash_init(p_nxge_t nxgep, queue_t *q, switch (class) { case 1: status = nxge_fflp_set_hash1(nxgep, - (uint32_t)pa->value); + (uint32_t)pa->value); break; case 2: status = nxge_fflp_set_hash2(nxgep, - (uint16_t)pa->value); + (uint16_t)pa->value); break; default: NXGE_DEBUG_MSG((nxgep, NDD_CTL, - " nxge_param_fflp_hash_init" - " %s Wrong hash var %d", - pa->name, class)); + " nxge_param_fflp_hash_init" + " %s Wrong hash var %d", + pa->name, class)); return (EINVAL); } if (status != NXGE_OK) @@ -1986,16 +1967,16 @@ nxge_param_set_grp_rdc(p_nxge_t nxgep, queue_t *q, rdc_grp_p = &p_dma_cfgp->rdc_grps[rdc_grp]; real_rdc = rdc_grp_p->start_rdc + cfg_value; if (nxge_check_rxdma_rdcgrp_member(nxgep, rdc_grp, - cfg_value) == B_FALSE) { + cfg_value) == B_FALSE) { pa->value = pa->old_value; NXGE_DEBUG_MSG((nxgep, NDD_CTL, - " nxge_param_set_grp_rdc" - " %d read %d actual %d outof range", - rdc_grp, cfg_value, real_rdc)); + " nxge_param_set_grp_rdc" + " %d read %d actual %d outof range", + rdc_grp, cfg_value, real_rdc)); return (EINVAL); } status = nxge_rxdma_cfg_rdcgrp_default_rdc(nxgep, rdc_grp, - real_rdc); + real_rdc); if (status != NXGE_OK) return (EINVAL); } @@ -2064,8 +2045,8 @@ nxge_param_set_nxge_debug_flag(p_nxge_t nxgep, queue_t *q, if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) { NXGE_DEBUG_MSG((nxgep, NDD_CTL, - " nxge_param_set_nxge_debug_flag" - " outof range %llx", cfg_value)); + " nxge_param_set_nxge_debug_flag" + " outof range %llx", cfg_value)); return (EINVAL); } if (pa->value != cfg_value) { @@ -2093,7 +2074,7 @@ nxge_param_get_debug_flag(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) if (pa->value > 0xffffffff) (void) mi_mpprintf(mp, "%x%x", (int)(pa->value >> 32), - (int)(pa->value & 0xffffffff)); + (int)(pa->value & 0xffffffff)); else (void) mi_mpprintf(mp, "%x", (int)pa->value); @@ -2117,7 +2098,7 @@ nxge_param_set_npi_debug_flag(p_nxge_t nxgep, queue_t *q, pa = (p_nxge_param_t)cp; if (PARAM_OUTOF_RANGE(value, end, cfg_value, pa)) { NXGE_DEBUG_MSG((nxgep, NDD_CTL, " nxge_param_set_npi_debug_flag" - " outof range %llx", cfg_value)); + " outof range %llx", cfg_value)); return (EINVAL); } if (pa->value != cfg_value) { @@ -2143,7 +2124,7 @@ nxge_param_dump_rdc(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_rdc")); if (!isLDOMguest(nxgep)) - (void) npi_rxdma_dump_fzc_regs(NXGE_DEV_NPI_HANDLE(nxgep)); + (void) npi_rxdma_dump_fzc_regs(NXGE_DEV_NPI_HANDLE(nxgep)); for (rdc = 0; rdc < NXGE_MAX_TDCS; rdc++) { if ((1 << rdc) & set->owned.map) { @@ -2193,7 +2174,7 @@ nxge_param_dump_mac_regs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_mac_regs")); (void) npi_mac_dump_regs(NXGE_DEV_NPI_HANDLE(nxgep), - nxgep->function_num); + nxgep->function_num); NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_mac_regs")); return (0); @@ -2206,7 +2187,7 @@ nxge_param_dump_ipp_regs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_dump_ipp_regs")); (void) npi_ipp_dump_regs(NXGE_DEV_NPI_HANDLE(nxgep), - nxgep->function_num); + nxgep->function_num); NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_dump_ipp_regs")); return (0); } @@ -2232,7 +2213,7 @@ nxge_param_dump_rdc_table(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) NXGE_DEBUG_MSG((nxgep, NDD_CTL, "==> nxge_param_dump_rdc_table")); for (table = 0; table < NXGE_MAX_RDC_GROUPS; table++) { (void) npi_rxdma_dump_rdc_table(NXGE_DEV_NPI_HANDLE(nxgep), - table); + table); } NXGE_DEBUG_MSG((nxgep, NDD_CTL, "<== nxge_param_dump_rdc_table")); @@ -2284,10 +2265,10 @@ nxge_param_dump_ptrs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) p_rx_rbr_ring_t *rbr_rings; NXGE_DEBUG_MSG((nxgep, IOC_CTL, - "==> nxge_param_dump_ptrs")); + "==> nxge_param_dump_ptrs")); (void) mi_mpprintf(mp, "ptr information for Port\t %d \n", - nxgep->function_num); + nxgep->function_num); if ((np = allocb(buff_alloc_size, BPRI_HI)) == NULL) { /* The following may work even if we cannot get a large buf. */ @@ -2305,23 +2286,23 @@ nxge_param_dump_ptrs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) rx_rbr_rings = nxgep->rx_rbr_rings; rbr_rings = rx_rbr_rings->rbr_rings; print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "nxgep (nxge_t) $%p\n" - "dev_regs (dev_regs_t) $%p\n", - nxgep, nxgep->dev_regs); + "nxgep (nxge_t) $%p\n" + "dev_regs (dev_regs_t) $%p\n", + nxgep, nxgep->dev_regs); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); /* do register pointers */ print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "reg base (npi_reg_ptr_t) $%p\t " - "pci reg (npi_reg_ptr_t) $%p\n", - nxgep->dev_regs->nxge_regp, - nxgep->dev_regs->nxge_pciregp); + "reg base (npi_reg_ptr_t) $%p\t " + "pci reg (npi_reg_ptr_t) $%p\n", + nxgep->dev_regs->nxge_regp, + nxgep->dev_regs->nxge_pciregp); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "\nBlock \t Offset \n"); + "\nBlock \t Offset \n"); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); block = 0; @@ -2332,35 +2313,35 @@ nxge_param_dump_ptrs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) #endif while (reg_block[block].offset != ALL_FF_32) { print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "%9s\t 0x%llx\n", - reg_block[block].name, - (unsigned long long)(reg_block[block].offset + base)); + "%9s\t 0x%llx\n", + reg_block[block].name, + (unsigned long long)(reg_block[block].offset + base)); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); block++; } print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "\nRDC\t rcrp (rx_rcr_ring_t)\t " - "rbrp (rx_rbr_ring_t)\n"); + "\nRDC\t rcrp (rx_rcr_ring_t)\t " + "rbrp (rx_rbr_ring_t)\n"); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); for (rdc = 0; rdc < p_cfgp->max_rdcs; rdc++) { print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - " %d\t $%p\t\t $%p\n", - rdc, rcr_rings[rdc], - rbr_rings[rdc]); + " %d\t $%p\t\t $%p\n", + rdc, rcr_rings[rdc], + rbr_rings[rdc]); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); } print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - "\nTDC\t tdcp (tx_ring_t)\n"); + "\nTDC\t tdcp (tx_ring_t)\n"); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); tx_rings = nxgep->tx_rings->rings; for (tdc = 0; tdc < p_cfgp->tdc.count; tdc++) { print_len = snprintf((char *)((mblk_t *)np)->b_wptr, buf_len, - " %d\t $%p\n", tdc, tx_rings[tdc]); + " %d\t $%p\n", tdc, tx_rings[tdc]); ADVANCE_PRINT_BUFFER(np, print_len, buf_len); } @@ -2371,214 +2352,6 @@ nxge_param_dump_ptrs(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t cp) return (0); } -/* - * Load 'name' into the named dispatch table pointed to by 'ndp'. - * 'ndp' should be the address of a char pointer cell. If the table - * does not exist (*ndp == 0), a new table is allocated and 'ndp' - * is stuffed. If there is not enough space in the table for a new - * entry, more space is allocated. - */ -/* ARGSUSED */ -boolean_t -nxge_nd_load(caddr_t *pparam, char *name, - pfi_t get_pfi, pfi_t set_pfi, caddr_t data) -{ - ND *nd; - NDE *nde; - - NXGE_DEBUG_MSG((NULL, NDD2_CTL, " ==> nxge_nd_load")); - if (!pparam) - return (B_FALSE); - - if ((nd = (ND *)*pparam) == NULL) { - if ((nd = (ND *)KMEM_ZALLOC(sizeof (ND), KM_NOSLEEP)) == NULL) - return (B_FALSE); - *pparam = (caddr_t)nd; - } - - if (nd->nd_tbl) { - for (nde = nd->nd_tbl; nde->nde_name; nde++) { - if (strcmp(name, nde->nde_name) == 0) - goto fill_it; - } - } - - if (nd->nd_free_count <= 1) { - if ((nde = (NDE *)KMEM_ZALLOC(nd->nd_size + - NDE_ALLOC_SIZE, KM_NOSLEEP)) == NULL) - return (B_FALSE); - nd->nd_free_count += NDE_ALLOC_COUNT; - if (nd->nd_tbl) { - bcopy((char *)nd->nd_tbl, (char *)nde, nd->nd_size); - KMEM_FREE((char *)nd->nd_tbl, nd->nd_size); - } else { - nd->nd_free_count--; - nde->nde_name = "?"; - nde->nde_get_pfi = nxge_nd_get_names; - nde->nde_set_pfi = nxge_set_default; - } - nde->nde_data = (caddr_t)nd; - nd->nd_tbl = nde; - nd->nd_size += NDE_ALLOC_SIZE; - } - for (nde = nd->nd_tbl; nde->nde_name; nde++) - noop; - nd->nd_free_count--; -fill_it: - nde->nde_name = name; - nde->nde_get_pfi = get_pfi; - nde->nde_set_pfi = set_pfi; - nde->nde_data = data; - NXGE_DEBUG_MSG((NULL, NDD2_CTL, " <== nxge_nd_load")); - - return (B_TRUE); -} - -/* - * Free the table pointed to by 'pparam' - */ -void -nxge_nd_free(caddr_t *pparam) -{ - ND *nd; - - if ((nd = (ND *)*pparam) != NULL) { - if (nd->nd_tbl) - KMEM_FREE((char *)nd->nd_tbl, nd->nd_size); - KMEM_FREE((char *)nd, sizeof (ND)); - *pparam = nil(caddr_t); - } -} - -int -nxge_nd_getset(p_nxge_t nxgep, queue_t *q, caddr_t param, p_mblk_t mp) -{ - int err; - IOCP iocp; - p_mblk_t mp1, mp2; - ND *nd; - NDE *nde; - char *valp; - size_t avail; - - if (!param) { - return (B_FALSE); - } - - nd = (ND *)param; - iocp = (IOCP)mp->b_rptr; - if ((iocp->ioc_count == 0) || !(mp1 = mp->b_cont)) { - mp->b_datap->db_type = M_IOCACK; - iocp->ioc_count = 0; - iocp->ioc_error = EINVAL; - return (B_FALSE); - } - - /* - * NOTE - logic throughout nd_xxx assumes single data block for ioctl. - * However, existing code sends in some big buffers. - */ - avail = iocp->ioc_count; - if (mp1->b_cont) { - freemsg(mp1->b_cont); - mp1->b_cont = NULL; - } - - mp1->b_datap->db_lim[-1] = '\0'; /* Force null termination */ - for (valp = (char *)mp1->b_rptr; *valp != '\0'; valp++) { - if (*valp == '-') - *valp = '_'; - } - - valp = (char *)mp1->b_rptr; - - for (nde = nd->nd_tbl; /* */; nde++) { - if (!nde->nde_name) - return (B_FALSE); - if (strcmp(nde->nde_name, valp) == 0) - break; - } - err = EINVAL; - while (*valp++) - noop; - if (!*valp || valp >= (char *)mp1->b_wptr) - valp = nilp(char); - switch (iocp->ioc_cmd) { - case ND_GET: - /* - * (temporary) hack: "*valp" is size of user buffer for - * copyout. If result of action routine is too big, free - * excess and return ioc_rval as buffer size needed. - * Return as many mblocks as will fit, free the rest. For - * backward compatibility, assume size of original ioctl - * buffer if "*valp" bad or not given. - */ - if (valp) - avail = mi_strtol(valp, (char **)0, 10); - /* - * We overwrite the name/value with the reply data - */ - mp2 = mp1; - while (mp2) { - mp2->b_wptr = mp2->b_rptr; - mp2 = mp2->b_cont; - } - - if (nde->nde_get_pfi) { - err = (*nde->nde_get_pfi)(nxgep, q, mp1, nde->nde_data); - } - - if (!err) { - size_t size_out = 0; - ssize_t excess; - - iocp->ioc_rval = 0; - - /* Tack on the null */ - err = nxge_mk_mblk_tail_space(mp1, &mp2, 1); - if (!err) { - *mp2->b_wptr++ = '\0'; - size_out = msgdsize(mp1); - excess = size_out - avail; - if (excess > 0) { - iocp->ioc_rval = (int)size_out; - size_out -= excess; - (void) adjmsg(mp1, -(excess + 1)); - err = nxge_mk_mblk_tail_space( - mp1, &mp2, 1); - if (!err) - *mp2->b_wptr++ = '\0'; - else - size_out = 0; - } - } else - size_out = 0; - iocp->ioc_count = size_out; - } - break; - - case ND_SET: - if (valp) { - if (nde->nde_set_pfi) { - err = (*nde->nde_set_pfi)(nxgep, q, mp1, valp, - nde->nde_data); - iocp->ioc_count = 0; - freemsg(mp1); - mp->b_cont = NULL; - } - } - - nxge_param_sync(nxgep); - - break; - - default: - break; - } - iocp->ioc_error = err; - mp->b_datap->db_type = M_IOCACK; - return (B_TRUE); -} /* ARGSUSED */ int @@ -2597,9 +2370,9 @@ nxge_nd_get_names(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, caddr_t param) for (nde = nd->nd_tbl; nde->nde_name; nde++) { get_ok = (nde->nde_get_pfi != nxge_get_default) && - (nde->nde_get_pfi != NULL); + (nde->nde_get_pfi != NULL); set_ok = (nde->nde_set_pfi != nxge_set_default) && - (nde->nde_set_pfi != NULL); + (nde->nde_set_pfi != NULL); if (get_ok) { if (set_ok) rwtag = "read and write"; @@ -2634,42 +2407,6 @@ nxge_set_default(p_nxge_t nxgep, queue_t *q, p_mblk_t mp, char *value, return (EACCES); } -void -nxge_param_ioctl(p_nxge_t nxgep, queue_t *wq, mblk_t *mp, struct iocblk *iocp) -{ - int cmd; - int status = B_FALSE; - - NXGE_DEBUG_MSG((nxgep, IOC_CTL, "==> nxge_param_ioctl")); - cmd = iocp->ioc_cmd; - - switch (cmd) { - default: - NXGE_DEBUG_MSG((nxgep, IOC_CTL, - "nxge_param_ioctl: bad cmd 0x%0x", cmd)); - break; - - case ND_GET: - case ND_SET: - NXGE_DEBUG_MSG((nxgep, IOC_CTL, - "nxge_param_ioctl: cmd 0x%0x", cmd)); - if (!nxge_nd_getset(nxgep, wq, nxgep->param_list, mp)) { - NXGE_DEBUG_MSG((nxgep, IOC_CTL, - "false ret from nxge_nd_getset")); - break; - } - status = B_TRUE; - break; - } - - if (status) { - qreply(wq, mp); - } else { - miocnak(wq, mp, 0, EINVAL); - } - NXGE_DEBUG_MSG((nxgep, IOC_CTL, "<== nxge_param_ioctl")); -} - boolean_t nxge_param_link_update(p_nxge_t nxgep) { @@ -2693,7 +2430,7 @@ nxge_param_link_update(p_nxge_t nxgep) update_xcvr = B_FALSE; for (i = param_autoneg; i < param_enable_ipg0; i++) { update_xcvr |= - (param_arr[i].value != param_arr[i].old_value); + (param_arr[i].value != param_arr[i].old_value); param_arr[i].old_value = param_arr[i].value; } if (update_xcvr) { @@ -2708,7 +2445,7 @@ nxge_param_link_update(p_nxge_t nxgep) } } else { cmn_err(CE_WARN, " Last setting will leave nxge%d with " - " no link capabilities.", instance); + " no link capabilities.", instance); cmn_err(CE_WARN, " Restoring previous setting."); for (i = param_anar_1000fdx; i < param_anar_asmpause; i++) param_arr[i].value = param_arr[i].old_value; @@ -2729,7 +2466,7 @@ nxge_param_link_update(p_nxge_t nxgep) nxge_param_hw_update_exit: NXGE_DEBUG_MSG((nxgep, DDI_CTL, - "<== nxge_param_link_update status = 0x%08x", status)); + "<== nxge_param_link_update status = 0x%08x", status)); return (status); } diff --git a/usr/src/uts/common/sys/dld.h b/usr/src/uts/common/sys/dld.h index 9ce2bd71cb..b167b56447 100644 --- a/usr/src/uts/common/sys/dld.h +++ b/usr/src/uts/common/sys/dld.h @@ -47,7 +47,7 @@ extern "C" { /* * Data-Link Driver Information (text emitted by modinfo(1m)) */ -#define DLD_INFO "Data-Link Driver v%I%" +#define DLD_INFO "Data-Link Driver" /* * Options: To enable an option set the property name to a non-zero value @@ -243,8 +243,7 @@ typedef enum { DLD_PROP_STATUS, DLD_PROP_AUTONEG, DLD_PROP_EN_AUTONEG, - DLD_PROP_DEFMTU, - DLD_PROP_NDD_LEGACY, + DLD_PROP_MTU, DLD_PROP_FLOWCTRL, DLD_PROP_ADV_1000FDX_CAP, DLD_PROP_EN_1000FDX_CAP, @@ -258,26 +257,24 @@ typedef enum { DLD_PROP_EN_10FDX_CAP, DLD_PROP_ADV_10HDX_CAP, DLD_PROP_EN_10HDX_CAP, + DLD_PROP_ADV_100T4_CAP, + DLD_PROP_EN_100T4_CAP, DLD_PROP_PRIVATE = -1 } dld_prop_id_t; -/* - * to figure out r/w status of legacy ndd props. - */ -#define DLD_NDD_READ 0x01 -#define DLD_NDD_WRITE 0x10 #define DLDIOCSETPROP (DLDIOC | 0x14) #define DLDIOCGETPROP (DLDIOC | 0x15) -#define DLD_LINKPROP_NAME_MAX 256 #define DLD_PROP_VERSION 1 +#define MAXLINKPROPNAME 256 +#define DLD_DEFAULT 0x0001 typedef struct dld_ioc_prop_s { int pr_version; - uint_t pr_flags; /* private to libdladm */ + uint_t pr_flags; datalink_id_t pr_linkid; dld_prop_id_t pr_num; - char pr_name[DLD_LINKPROP_NAME_MAX]; + char pr_name[MAXLINKPROPNAME]; uint_t pr_valsize; /* sizeof pr_val */ char pr_val[1]; } dld_ioc_prop_t; diff --git a/usr/src/uts/common/sys/mac.h b/usr/src/uts/common/sys/mac.h index 7823b3be6f..2091c6ac8f 100644 --- a/usr/src/uts/common/sys/mac.h +++ b/usr/src/uts/common/sys/mac.h @@ -45,7 +45,7 @@ extern "C" { /* * MAC Information (text emitted by modinfo(1m)) */ -#define MAC_INFO "MAC Services v%I%" +#define MAC_INFO "MAC Services" /* * MAC version identifier. This is used by mac_alloc() mac_register() to @@ -302,7 +302,7 @@ typedef void (*mac_close_t)(void *); typedef int (*mac_set_prop_t)(void *, const char *, mac_prop_id_t, uint_t, const void *); typedef int (*mac_get_prop_t)(void *, const char *, mac_prop_id_t, - uint_t, void *); + uint_t, uint_t, void *); /* * Drivers must set all of these callbacks except for mc_resources, @@ -330,6 +330,11 @@ typedef struct mac_callbacks_s { mac_get_prop_t mc_getprop; } mac_callbacks_t; +typedef struct mac_priv_prop_s { + char mpp_name[MAXLINKPROPNAME]; + uint_t mpp_flags; +} mac_priv_prop_t; + /* * Multiple Rings capability */ @@ -491,21 +496,24 @@ typedef struct mac_capab_share_s { #define MAC_MAX_MINOR 1000 typedef struct mac_register_s { - uint_t m_version; /* set by mac_alloc() */ - const char *m_type_ident; - void *m_driver; /* Driver private data */ - dev_info_t *m_dip; - uint_t m_instance; - uint8_t *m_src_addr; - uint8_t *m_dst_addr; - mac_callbacks_t *m_callbacks; - uint_t m_min_sdu; - uint_t m_max_sdu; - void *m_pdata; - size_t m_pdata_size; - uint32_t m_margin; + uint_t m_version; /* set by mac_alloc() */ + const char *m_type_ident; + void *m_driver; /* Driver private data */ + dev_info_t *m_dip; + uint_t m_instance; + uint8_t *m_src_addr; + uint8_t *m_dst_addr; + mac_callbacks_t *m_callbacks; + uint_t m_min_sdu; + uint_t m_max_sdu; + void *m_pdata; + size_t m_pdata_size; + uint32_t m_margin; + mac_priv_prop_t *m_priv_props; + size_t m_priv_prop_count; } mac_register_t; + /* * Opaque handle types. */ @@ -682,6 +690,38 @@ typedef struct mactype_ops_s { #define MTOPS_HEADER_UNCOOK 0x004 #define MTOPS_LINK_DETAILS 0x008 +/* + * Provide mapping for legacy ndd ioctls relevant to that mactype. + * Note that the ndd ioctls are obsolete, and may be removed in a future + * release of Solaris. The ndd ioctls are not typically used in legacy + * ethernet drivers. New datalink drivers of all link-types should use + * dladm(1m) interfaces for administering tunables and not have to provide + * a mapping. + */ +typedef struct mac_ndd_mapping_s { + char *mp_name; + union { + mac_prop_id_t u_id; + uint_t u_kstat; + } u_mp_id; + long mp_minval; + long mp_maxval; + size_t mp_valsize; + int mp_flags; +} mac_ndd_mapping_t; + +#define mp_prop_id u_mp_id.u_id +#define mp_kstat u_mp_id.u_kstat + +/* + * Flags to figure out r/w status of legacy ndd props. + */ +#define MAC_PROP_PERM_READ 0x0001 +#define MAC_PROP_PERM_WRITE 0x0010 +#define MAC_PROP_MAP_KSTAT 0x0100 +#define MAC_PROP_PERM_RW (MAC_PROP_PERM_READ|MAC_PROP_PERM_WRITE) +#define MAC_PROP_FLAGS_RK (MAC_PROP_PERM_READ|MAC_PROP_MAP_KSTAT) + typedef struct mactype_register_s { uint_t mtr_version; /* set by mactype_alloc() */ const char *mtr_ident; @@ -692,11 +732,14 @@ typedef struct mactype_register_s { uint8_t *mtr_brdcst_addr; mac_stat_info_t *mtr_stats; size_t mtr_statcount; + mac_ndd_mapping_t *mtr_mapping; + size_t mtr_mappingcount; } mactype_register_t; typedef struct mac_prop_s { mac_prop_id_t mp_id; char *mp_name; + uint_t mp_flags; } mac_prop_t; /* diff --git a/usr/src/uts/common/sys/mac_impl.h b/usr/src/uts/common/sys/mac_impl.h index 6e39232224..6b36a978f0 100644 --- a/usr/src/uts/common/sys/mac_impl.h +++ b/usr/src/uts/common/sys/mac_impl.h @@ -87,6 +87,8 @@ typedef struct mactype_s { mactype_ops_t mt_ops; mac_stat_info_t *mt_stats; /* array of mac_stat_info_t elements */ size_t mt_statcount; /* number of elements in mt_stats */ + mac_ndd_mapping_t *mt_mapping; + size_t mt_mappingcount; } mactype_t; @@ -113,6 +115,7 @@ typedef struct mac_vnic_tx_s { boolean_t mv_clearing; } mac_vnic_tx_t; + /* * Each registered MAC is associated with a mac_t structure. */ @@ -197,6 +200,8 @@ typedef struct mac_impl_s { * sorted: the first one has the greatest value. */ mac_margin_req_t *mi_mmrp; + mac_priv_prop_t *mi_priv_prop; + uint_t mi_priv_prop_count; } mac_impl_t; #define mi_getstat mi_callbacks->mc_getstat @@ -219,6 +224,8 @@ extern void mac_stat_create(mac_impl_t *); extern void mac_stat_destroy(mac_impl_t *); extern uint64_t mac_stat_default(mac_impl_t *, uint_t); +extern void mac_ndd_ioctl(mac_impl_t *, queue_t *, mblk_t *); + #ifdef __cplusplus } #endif diff --git a/usr/src/uts/intel/bge/Makefile b/usr/src/uts/intel/bge/Makefile index 830ec8f6bd..ee7d7a3fdc 100644 --- a/usr/src/uts/intel/bge/Makefile +++ b/usr/src/uts/intel/bge/Makefile @@ -19,7 +19,7 @@ # CDDL HEADER END # # -# Copyright 2006 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # #ident "%Z%%M% %I% %E% SMI" @@ -70,9 +70,9 @@ LINTTAGS += -erroff=E_STATIC_UNUSED # -# Driver depends on MAC & IP +# Driver depends on MAC # -LDFLAGS += -dy -N misc/mac -N drv/ip +LDFLAGS += -dy -N misc/mac # # Default build targets. diff --git a/usr/src/uts/intel/e1000g/Makefile b/usr/src/uts/intel/e1000g/Makefile index 77eb2c55a4..698eb2f2d3 100644 --- a/usr/src/uts/intel/e1000g/Makefile +++ b/usr/src/uts/intel/e1000g/Makefile @@ -19,7 +19,7 @@ # CDDL HEADER END # # -# Copyright 2007 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # # ident "%Z%%M% %I% %E% SMI" @@ -68,9 +68,9 @@ LINT_TARGET = $(MODULE).lint INSTALL_TARGET = $(BINARY) $(ROOTMODULE) $(ROOT_CONFFILE) # -# Driver depends on MAC & IP +# Driver depends on MAC # -LDFLAGS += -dy -N misc/mac -N drv/ip +LDFLAGS += -dy -N misc/mac # # Default build targets. diff --git a/usr/src/uts/intel/nge/Makefile b/usr/src/uts/intel/nge/Makefile index 9619c2b51e..4c35035b15 100644 --- a/usr/src/uts/intel/nge/Makefile +++ b/usr/src/uts/intel/nge/Makefile @@ -19,7 +19,7 @@ # CDDL HEADER END # # -# Copyright 2007 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # # @@ -63,9 +63,9 @@ INC_PATH += -I$(CONF_SRCDIR) # CFLAGS += $(CINLINEFLAGS) # -# Driver depends on GLD & IP +# Driver depends on GLD # -LDFLAGS += -dy -N misc/mac -N drv/ip +LDFLAGS += -dy -N misc/mac # # For now, disable these lint checks; maintainers should endeavor diff --git a/usr/src/uts/sparc/bge/Makefile b/usr/src/uts/sparc/bge/Makefile index db14d790cd..ae14724615 100644 --- a/usr/src/uts/sparc/bge/Makefile +++ b/usr/src/uts/sparc/bge/Makefile @@ -19,7 +19,7 @@ # CDDL HEADER END # # -# Copyright 2006 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # #ident "%Z%%M% %I% %E% SMI" @@ -65,9 +65,9 @@ CFLAGS += $(CCVERBOSE) CFLAGS += -dalign # -# Driver depends on MAC & IP +# Driver depends on MAC # -LDFLAGS += -dy -N misc/mac -N drv/ip +LDFLAGS += -dy -N misc/mac # # For now, disable these lint checks; maintainers should endeavor diff --git a/usr/src/uts/sparc/e1000g/Makefile b/usr/src/uts/sparc/e1000g/Makefile index 5fadbfe38a..26982f0af6 100644 --- a/usr/src/uts/sparc/e1000g/Makefile +++ b/usr/src/uts/sparc/e1000g/Makefile @@ -19,7 +19,7 @@ # CDDL HEADER END # # -# Copyright 2007 Sun Microsystems, Inc. All rights reserved. +# Copyright 2008 Sun Microsystems, Inc. All rights reserved. # Use is subject to license terms. # #pragma ident "%Z%%M% %I% %E% SMI" @@ -74,9 +74,9 @@ CFLAGS += $(CCVERBOSE) CFLAGS += -dalign # -# Driver depends on MAC & IP +# Driver depends on MAC # -LDFLAGS += -dy -N misc/mac -N drv/ip +LDFLAGS += -dy -N misc/mac # # Default build targets. |