/* * 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 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include "rge.h" #define RGE_DBG RGE_DBG_NDD /* debug flag for this code */ /* * Property names */ static char transfer_speed_propname[] = "transfer-speed"; static char speed_propname[] = "speed"; static char duplex_propname[] = "full-duplex"; /* * Notes: * The first character of the field encodes the read/write * status of the parameter: * '-' => read-only, * '+' => read/write, * '!' => 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 field terminates the array. * * The 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 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 rge_param_set()). */ static const nd_param_t nd_template_1000[] = { /* 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" }, /* 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" }, /* Loopback status */ { PARAM_LOOP_MODE, 0, 2, 0, "-loop_mode" }, /* Terminator */ { PARAM_COUNT, 0, 0, 0, NULL } }; /* nd_template for RTL8101E */ static const nd_param_t nd_template_100[] = { /* 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, 0, "-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, 0, "-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" }, /* 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" }, /* Loopback status */ { PARAM_LOOP_MODE, 0, 2, 0, "-loop_mode" }, /* Terminator */ { PARAM_COUNT, 0, 0, 0, NULL } }; /* ============== NDD Support Functions =============== */ /* * Extracts the value from the rge parameter array and prints * the parameter value. cp points to the required parameter. */ static int rge_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); } /* * Validates the request to set a RGE parameter to a specific value. * If the request is OK, the parameter is set. Also the 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 rge_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *credp) { nd_param_t *ndp; long new_value; _NOTE(ARGUNUSED(q, mp, credp)) ndp = (nd_param_t *)cp; (void) ddi_strtol(value, (char **)NULL, 0, &new_value); if (new_value < ndp->ndp_min || new_value > ndp->ndp_max) return (EINVAL); ndp->ndp_val = (int)new_value; ndp->ndp_info += 1; return (0); } /* * Initialise the per-instance parameter array from the global prototype, * and register each element with the named dispatch handler using nd_load() */ static int rge_param_register(rge_t *rgep) { const nd_param_t *tmplp; dev_info_t *dip; nd_param_t *ndp; caddr_t *nddpp; pfi_t setfn; char *nm; int pval; dip = rgep->devinfo; nddpp = &rgep->nd_data_p; ASSERT(*nddpp == NULL); if (rgep->chipid.mac_ver == MAC_VER_8101E) tmplp = nd_template_100; else tmplp = nd_template_1000; for (; 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 = &rgep->nd_params[tmplp->ndp_info]; *ndp = *tmplp; nm = &ndp->ndp_name[0]; setfn = rge_param_set; switch (*nm) { default: case '!': continue; case '+': break; case '-': setfn = NULL; break; } if (!nd_load(nddpp, ++nm, rge_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 && RGE_PROP_EXISTS(dip, nm)) { pval = RGE_PROP_GET_INT(dip, nm); if (pval >= ndp->ndp_min && pval <= ndp->ndp_max) ndp->ndp_val = pval; } } RGE_DEBUG(("rge_param_register: OK")); return (DDI_SUCCESS); nd_fail: if (rgep->chipid.mac_ver == MAC_VER_8101E) { RGE_DEBUG(("rge_param_register: FAILED at index %d [info %d]", tmplp-nd_template_100, tmplp->ndp_info)); } else { RGE_DEBUG(("rge_param_register: FAILED at index %d [info %d]", tmplp-nd_template_1000, tmplp->ndp_info)); } nd_free(nddpp); return (DDI_FAILURE); } int rge_nd_init(rge_t *rgep) { dev_info_t *dip; int duplex; int speed; /* * Register all the per-instance properties, initialising * them from the table above or from driver properties set * in the .conf file */ if (rge_param_register(rgep) != DDI_SUCCESS) return (-1); /* * The link speed may be forced to 10, 100 or 1000 Mbps using * the property "transfer-speed". This may be done in OBP by * using the command "apply transfer-speed= ". * The speed may be 10, 100 or 1000 - any other value will be * ignored. Note that this does *enables* autonegotiation, but * restricts it to the speed specified by the property. */ dip = rgep->devinfo; if (RGE_PROP_EXISTS(dip, transfer_speed_propname)) { speed = RGE_PROP_GET_INT(dip, transfer_speed_propname); rge_log(rgep, "%s property is %d", transfer_speed_propname, speed); switch (speed) { case 1000: rgep->param_adv_autoneg = 1; rgep->param_adv_1000fdx = 1; rgep->param_adv_1000hdx = 1; rgep->param_adv_100fdx = 0; rgep->param_adv_100hdx = 0; rgep->param_adv_10fdx = 0; rgep->param_adv_10hdx = 0; break; case 100: rgep->param_adv_autoneg = 1; rgep->param_adv_1000fdx = 0; rgep->param_adv_1000hdx = 0; rgep->param_adv_100fdx = 1; rgep->param_adv_100hdx = 1; rgep->param_adv_10fdx = 0; rgep->param_adv_10hdx = 0; break; case 10: rgep->param_adv_autoneg = 1; rgep->param_adv_1000fdx = 0; rgep->param_adv_1000hdx = 0; rgep->param_adv_100fdx = 0; rgep->param_adv_100hdx = 0; rgep->param_adv_10fdx = 1; rgep->param_adv_10hdx = 1; break; default: break; } } /* * Also check the "speed" and "full-duplex" properties. Setting * these properties will override all other settings and *disable* * autonegotiation, so both should be specified if either one is. * Otherwise, the unspecified parameter will be set to a default * value (1000Mb/s, full-duplex). */ if (RGE_PROP_EXISTS(dip, speed_propname) || RGE_PROP_EXISTS(dip, duplex_propname)) { rgep->param_adv_autoneg = 0; rgep->param_adv_1000fdx = 1; rgep->param_adv_1000hdx = 1; rgep->param_adv_100fdx = 1; rgep->param_adv_100hdx = 1; rgep->param_adv_10fdx = 1; rgep->param_adv_10hdx = 1; speed = RGE_PROP_GET_INT(dip, speed_propname); duplex = RGE_PROP_GET_INT(dip, duplex_propname); rge_log(rgep, "%s property is %d", speed_propname, speed); rge_log(rgep, "%s property is %d", duplex_propname, duplex); switch (speed) { case 1000: default: rgep->param_adv_100fdx = 0; rgep->param_adv_100hdx = 0; rgep->param_adv_10fdx = 0; rgep->param_adv_10hdx = 0; break; case 100: rgep->param_adv_1000fdx = 0; rgep->param_adv_1000hdx = 0; rgep->param_adv_10fdx = 0; rgep->param_adv_10hdx = 0; break; case 10: rgep->param_adv_1000fdx = 0; rgep->param_adv_1000hdx = 0; rgep->param_adv_100fdx = 0; rgep->param_adv_100hdx = 0; break; } switch (duplex) { default: case 1: rgep->param_adv_1000hdx = 0; rgep->param_adv_100hdx = 0; rgep->param_adv_10hdx = 0; break; case 0: rgep->param_adv_1000fdx = 0; rgep->param_adv_100fdx = 0; rgep->param_adv_10fdx = 0; break; } } RGE_DEBUG(("rge_nd_init: autoneg %d" "pause %d asym_pause %d " "1000fdx %d 1000hdx %d " "100fdx %d 100hdx %d " "10fdx %d 10hdx %d ", rgep->param_adv_autoneg, rgep->param_adv_pause, rgep->param_adv_asym_pause, rgep->param_adv_1000fdx, rgep->param_adv_1000hdx, rgep->param_adv_100fdx, rgep->param_adv_100hdx, rgep->param_adv_10fdx, rgep->param_adv_10hdx)); return (0); } enum ioc_reply rge_nd_ioctl(rge_t *rgep, queue_t *wq, mblk_t *mp, struct iocblk *iocp) { nd_param_t *ndp; boolean_t ok; int info; int cmd; RGE_TRACE(("rge_nd_ioctl($%p, $%p, $%p, $%p)", (void *)rgep, (void *)wq, (void *)mp, (void *)iocp)); ASSERT(mutex_owned(rgep->genlock)); cmd = iocp->ioc_cmd; switch (cmd) { default: /* NOTREACHED */ rge_error(rgep, "rge_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, rgep->nd_data_p, mp); RGE_DEBUG(("rge_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 (rgep->param_loop_mode != RGE_LOOP_NONE) { iocp->ioc_error = EBUSY; return (IOC_INVAL); } /* * Before calling nd_getset(), we save the field * of the 'autonegotiation' parameter so that we can tell * whether it was assigned (even if its value doesn't * actually change). */ ndp = &rgep->nd_params[PARAM_ADV_AUTONEG_CAP]; info = ndp->ndp_info; ok = nd_getset(wq, rgep->nd_data_p, mp); /* * 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 ... */ RGE_DEBUG(("rge_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 rge_nd_cleanup(rge_t *rgep) { nd_free(&rgep->nd_data_p); }