/*      $NetBSD: ath_netbsd.c,v 1.23 2022/09/25 18:43:32 thorpej Exp $ */

/*-
* Copyright (c) 2003, 2004 David Young
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ath_netbsd.c,v 1.23 2022/09/25 18:43:32 thorpej Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/systm.h>
#include <sys/sysctl.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysctl.h>
#include <sys/callout.h>
#include <sys/bus.h>
#include <sys/endian.h>
#include <sys/device.h>
#include <sys/module.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>
#include <net/if_arp.h>
#include <net/if_ether.h>
#include <net/if_llc.h>

#include <net80211/ieee80211_netbsd.h>
#include <net80211/ieee80211_var.h>
#include <dev/ic/ath_netbsd.h>
#include <dev/ic/athvar.h>

/*
* Setup sysctl(3) MIB, hw.ath.*.
*
* TBD condition CTLFLAG_PERMANENT on being a module or not
*/
SYSCTL_SETUP(sysctl_ath, "sysctl ath subtree setup")
{
       int rc;
       const struct sysctlnode *cnode, *rnode;

       if ((rnode = ath_sysctl_treetop(clog)) == NULL)
               return;

       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "dwell",
           "channel dwell time (ms) for AP/station scanning",
           dwelltime)) != 0)
               goto err;

       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "calibrate",
           "chip calibration interval (secs)", calinterval)) != 0)
               goto err;

       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "outdoor",
           "outdoor operation", outdoor)) != 0)
               goto err;

       /* country code */
       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE,
           "countrycode", "country code", countrycode)) != 0)
               goto err;

       /* regulatory domain */
       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "regdomain",
           "EEPROM regdomain code", regdomain)) != 0)
               goto err;

       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "debug",
           "control debugging printfs", debug)) != 0)
               goto err;

       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READONLY, "rxbuf",
           "rx buffers allocated", rxbuf)) != 0)
               goto err;
       if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READONLY, "txbuf",
           "tx buffers allocated", txbuf)) != 0)
               goto err;

       return;
err:
       printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
}

static int
ath_sysctl_slottime(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int slottime;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       slottime = ath_hal_getslottime(sc->sc_ah);
       node.sysctl_data = &slottime;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setslottime(sc->sc_ah, slottime) ? EINVAL : 0;
}

static int
ath_sysctl_acktimeout(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int acktimeout;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       acktimeout = ath_hal_getacktimeout(sc->sc_ah);
       node.sysctl_data = &acktimeout;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setacktimeout(sc->sc_ah, acktimeout) ? EINVAL : 0;
}

static int
ath_sysctl_ctstimeout(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int ctstimeout;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       ctstimeout = ath_hal_getctstimeout(sc->sc_ah);
       node.sysctl_data = &ctstimeout;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setctstimeout(sc->sc_ah, ctstimeout) ? EINVAL : 0;
}

static int
ath_sysctl_softled(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       int softled;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       softled = sc->sc_softled;
       node.sysctl_data = &softled;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       softled = (softled != 0);
       if (softled != sc->sc_softled) {
               if (softled) {
                       /* NB: handle any sc_ledpin change */
                       ath_hal_gpioCfgOutput(sc->sc_ah, sc->sc_ledpin,
                           HAL_GPIO_MUX_MAC_NETWORK_LED);
                       ath_hal_gpioset(sc->sc_ah, sc->sc_ledpin,
                               !sc->sc_ledon);
               }
               sc->sc_softled = softled;
       }
       return 0;
}

static int
ath_sysctl_rxantenna(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int defantenna;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       defantenna = ath_hal_getdefantenna(sc->sc_ah);
       node.sysctl_data = &defantenna;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       ath_hal_setdefantenna(sc->sc_ah, defantenna);
       return 0;
}

static int
ath_sysctl_diversity(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int diversity;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       diversity = sc->sc_diversity;
       node.sysctl_data = &diversity;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       if (!ath_hal_setdiversity(sc->sc_ah, diversity))
               return EINVAL;
       sc->sc_diversity = diversity;
       return 0;
}

static int
ath_sysctl_diag(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int32_t diag;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       if (!ath_hal_getdiag(sc->sc_ah, &diag))
               return EINVAL;
       node.sysctl_data = &diag;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setdiag(sc->sc_ah, diag) ? EINVAL : 0;
}

static int
ath_sysctl_tpscale(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int32_t scale;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       (void)ath_hal_gettpscale(sc->sc_ah, &scale);
       node.sysctl_data = &scale;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_settpscale(sc->sc_ah, scale)
           ? EINVAL
           : ath_reset(&sc->sc_if);
}

static int
ath_sysctl_tpc(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int tpc;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       tpc = ath_hal_gettpc(sc->sc_ah);
       node.sysctl_data = &tpc;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_settpc(sc->sc_ah, tpc) ? EINVAL : 0;
}

static int
ath_sysctl_rfkill(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int rfkill;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       rfkill = ath_hal_getrfkill(sc->sc_ah);
       node.sysctl_data = &rfkill;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setrfkill(sc->sc_ah, rfkill) ? EINVAL : 0;
}

static int
ath_sysctl_rfsilent(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int rfsilent;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       (void)ath_hal_getrfsilent(sc->sc_ah, &rfsilent);
       node.sysctl_data = &rfsilent;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setrfsilent(sc->sc_ah, rfsilent) ? EINVAL : 0;
}

static int
ath_sysctl_regdomain(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int32_t rd;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       if (!ath_hal_getregdomain(sc->sc_ah, &rd))
               return EINVAL;
       node.sysctl_data = &rd;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_setregdomain(sc->sc_ah, rd) ? EINVAL : 0;
}

static int
ath_sysctl_tpack(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int32_t tpack;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       (void)ath_hal_gettpack(sc->sc_ah, &tpack);
       node.sysctl_data = &tpack;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_settpack(sc->sc_ah, tpack) ? EINVAL : 0;
}

static int
ath_sysctl_tpcts(SYSCTLFN_ARGS)
{
       struct ath_softc *sc;
       struct sysctlnode node;
       u_int32_t tpcts;
       int error;

       node = *rnode;
       sc = (struct ath_softc *)node.sysctl_data;
       (void)ath_hal_gettpcts(sc->sc_ah, &tpcts);
       node.sysctl_data = &tpcts;
       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;
       return !ath_hal_settpcts(sc->sc_ah, tpcts) ? EINVAL : 0;
}

const struct sysctlnode *
ath_sysctl_instance(const char *dvname, struct sysctllog **log)
{
       int rc;
       const struct sysctlnode *rnode;

       if ((rc = sysctl_createv(log, 0, NULL, &rnode,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, dvname,
           SYSCTL_DESCR("ath information and options"),
           NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0)
               goto err;

       return rnode;
err:
       printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
       return NULL;
}

const struct sysctlnode *
ath_sysctl_treetop(struct sysctllog **log)
{
       int rc;
       const struct sysctlnode *rnode;

       if ((rc = sysctl_createv(log, 0, NULL, &rnode,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, "ath",
           SYSCTL_DESCR("ath information and options"),
           NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0)
               goto err;

       return rnode;
err:
       printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
       return NULL;
}

void
ath_sysctlattach(struct ath_softc *sc)
{
       int rc;
       struct sysctllog **log = &sc->sc_sysctllog;
       const struct sysctlnode *cnode, *rnode;

       ath_hal_getcountrycode(sc->sc_ah, &sc->sc_countrycode);
       (void)ath_hal_getregdomain(sc->sc_ah, &sc->sc_regdomain);
       sc->sc_debug = ath_debug;
       sc->sc_txintrperiod = ATH_TXINTR_PERIOD;

       if ((rnode = ath_sysctl_instance(device_xname(sc->sc_dev), log)) == NULL)
               return;

       if ((rc = SYSCTL_INT(0, countrycode, "EEPROM country code")) != 0)
               goto err;

       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, debug,
           "control debugging printfs")) != 0)
               goto err;

#if 0
       /* channel dwell time (ms) for AP/station scanning */
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, dwell,
           "Channel dwell time (ms) for scanning")) != 0)
               goto err;
#endif

       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, slottime,
           "802.11 slot time (us)")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, acktimeout,
           "802.11 ACK timeout (us)")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, ctstimeout,
           "802.11 CTS timeout (us)")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, softled,
           "enable/disable software LED support")) != 0)
               goto err;
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledpin,
           "GPIO pin connected to LED")) != 0)
               goto err;
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledon,
           "setting to turn LED on")) != 0)
               goto err;
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledidle,
           "idle time for inactivity LED (ticks)")) != 0)
               goto err;
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, txantenna,
           "tx antenna (0=auto)")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, rxantenna,
           "default/rx antenna")) != 0)
               goto err;
       if (ath_hal_hasdiversity(sc->sc_ah)) {
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, diversity,
                   "antenna diversity")) != 0)
                       goto err;
       }
       if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, txintrperiod,
           "tx descriptor batching")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, diag,
           "h/w diagnostic control")) != 0)
               goto err;
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpscale,
           "tx power scaling")) != 0)
               goto err;
       if (ath_hal_hastpc(sc->sc_ah)) {
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpc,
                   "enable/disable per-packet TPC")) != 0)
                       goto err;
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpack,
                   "tx power for ack frames")) != 0)
                       goto err;
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpcts,
                   "tx power for cts frames")) != 0)
                       goto err;
       }
       if (ath_hal_hasrfsilent(sc->sc_ah)) {
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, rfsilent,
                   "h/w RF silent config")) != 0)
                       goto err;
               if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, rfkill,
                   "enable/disable RF kill switch")) != 0)
                       goto err;
       }
       if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, regdomain,
           "EEPROM regdomain code")) != 0)
               goto err;
       return;
err:
       printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
}

MODULE(MODULE_CLASS_MISC, ath, "ath_hal");

static int
ath_modcmd(modcmd_t cmd, void *opaque)
{
       switch (cmd) {
       case MODULE_CMD_INIT:
       case MODULE_CMD_FINI:
               return 0;
       default:
               return ENOTTY;
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.