Home | History | Annotate | Line # | Download | only in ic
ath_netbsd.c revision 1.6
      1 /*	$NetBSD: ath_netbsd.c,v 1.6 2006/02/05 06:03:26 xtraeme Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2003, 2004 David Young
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. The name of the author may not be used to endorse or promote products
     16  *    derived from this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28  */
     29 
     30 #include <sys/cdefs.h>
     31 __KERNEL_RCSID(0, "$NetBSD: ath_netbsd.c,v 1.6 2006/02/05 06:03:26 xtraeme Exp $");
     32 
     33 #include <sys/param.h>
     34 #include <sys/types.h>
     35 #include <sys/errno.h>
     36 #include <sys/systm.h>
     37 #include <sys/sysctl.h>
     38 #include <sys/mbuf.h>
     39 #include <sys/malloc.h>
     40 #include <sys/lock.h>
     41 #include <sys/kernel.h>
     42 #include <sys/socket.h>
     43 #include <sys/sockio.h>
     44 #include <sys/sysctl.h>
     45 #include <sys/callout.h>
     46 #include <machine/bus.h>
     47 #include <machine/stdarg.h>
     48 #include <sys/endian.h>
     49 #include <sys/device.h>
     50 
     51 #include <net/if.h>
     52 #include <net/if_dl.h>
     53 #include <net/if_media.h>
     54 #include <net/if_arp.h>
     55 #include <net/if_ether.h>
     56 #include <net/if_llc.h>
     57 
     58 #include <net80211/ieee80211_netbsd.h>
     59 #include <net80211/ieee80211_var.h>
     60 #include <dev/ic/ath_netbsd.h>
     61 #include <dev/ic/athvar.h>
     62 
     63 void
     64 device_printf(struct device dv, const char *fmt, ...)
     65 {
     66         va_list ap;
     67 
     68         va_start(ap, fmt);
     69         printf("%s: ", dv.dv_xname);
     70         vprintf(fmt, ap);
     71         va_end(ap);
     72 	return;
     73 }
     74 
     75 struct mbuf *
     76 m_defrag(struct mbuf *m0, int flags)
     77 {
     78 	struct mbuf *m;
     79 	MGETHDR(m, flags, MT_DATA);
     80 	if (m == NULL)
     81 		return NULL;
     82 
     83 	M_COPY_PKTHDR(m, m0);
     84 	MCLGET(m, flags);
     85 	if ((m->m_flags & M_EXT) == 0) {
     86 		m_free(m);
     87 		return NULL;
     88 	}
     89 	m_copydata(m0, 0, m0->m_pkthdr.len, mtod(m, caddr_t));
     90 	m->m_len = m->m_pkthdr.len;
     91 	return m;
     92 }
     93 
     94 /*
     95  * Setup sysctl(3) MIB, ath.*.
     96  *
     97  * TBD condition CTLFLAG_PERMANENT on being an LKM or not
     98  */
     99 SYSCTL_SETUP(sysctl_ath, "sysctl ath subtree setup")
    100 {
    101 	int rc;
    102 	const struct sysctlnode *cnode, *rnode;
    103 
    104 	if ((rnode = ath_sysctl_treetop(clog)) == NULL)
    105 		return;
    106 
    107 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "dwell",
    108 	    "channel dwell time (ms) for AP/station scanning",
    109 	    dwelltime)) != 0)
    110 		goto err;
    111 
    112 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "calibrate",
    113 	    "chip calibration interval (secs)", calinterval)) != 0)
    114 		goto err;
    115 
    116 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "outdoor",
    117 	    "outdoor operation", outdoor)) != 0)
    118 		goto err;
    119 
    120 	/* country code */
    121 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE,
    122 	    "countrycode", "country code", countrycode)) != 0)
    123 		goto err;
    124 
    125 	/* regulatory domain */
    126 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READONLY, "regdomain",
    127 	    "regulatory domain", regdomain)) != 0)
    128 		goto err;
    129 
    130 	if ((rc = SYSCTL_GLOBAL_INT(CTLFLAG_READWRITE, "debug",
    131 	    "control debugging printfs", debug)) != 0)
    132 		goto err;
    133 
    134 	return;
    135 err:
    136 	printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
    137 }
    138 
    139 static int
    140 ath_sysctl_slottime(SYSCTLFN_ARGS)
    141 {
    142 	struct ath_softc *sc;
    143 	struct sysctlnode node;
    144 	u_int slottime;
    145 	int error;
    146 
    147 	node = *rnode;
    148 	sc = (struct ath_softc *)node.sysctl_data;
    149 	slottime = ath_hal_getslottime(sc->sc_ah);
    150 	node.sysctl_data = &slottime;
    151 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    152 	if (error || newp == NULL)
    153 		return error;
    154 	return !ath_hal_setslottime(sc->sc_ah, slottime) ? EINVAL : 0;
    155 }
    156 
    157 static int
    158 ath_sysctl_acktimeout(SYSCTLFN_ARGS)
    159 {
    160 	struct ath_softc *sc;
    161 	struct sysctlnode node;
    162 	u_int acktimeout;
    163 	int error;
    164 
    165 	node = *rnode;
    166 	sc = (struct ath_softc *)node.sysctl_data;
    167 	acktimeout = ath_hal_getacktimeout(sc->sc_ah);
    168 	node.sysctl_data = &acktimeout;
    169 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    170 	if (error || newp == NULL)
    171 		return error;
    172 	return !ath_hal_setacktimeout(sc->sc_ah, acktimeout) ? EINVAL : 0;
    173 }
    174 
    175 static int
    176 ath_sysctl_ctstimeout(SYSCTLFN_ARGS)
    177 {
    178 	struct ath_softc *sc;
    179 	struct sysctlnode node;
    180 	u_int ctstimeout;
    181 	int error;
    182 
    183 	node = *rnode;
    184 	sc = (struct ath_softc *)node.sysctl_data;
    185 	ctstimeout = ath_hal_getctstimeout(sc->sc_ah);
    186 	node.sysctl_data = &ctstimeout;
    187 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    188 	if (error || newp == NULL)
    189 		return error;
    190 	return !ath_hal_setctstimeout(sc->sc_ah, ctstimeout) ? EINVAL : 0;
    191 }
    192 
    193 static int
    194 ath_sysctl_softled(SYSCTLFN_ARGS)
    195 {
    196 	struct ath_softc *sc;
    197 	struct sysctlnode node;
    198 	int softled;
    199 	int error;
    200 
    201 	node = *rnode;
    202 	sc = (struct ath_softc *)node.sysctl_data;
    203 	softled = sc->sc_softled;
    204 	node.sysctl_data = &softled;
    205 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    206 	if (error || newp == NULL)
    207 		return error;
    208 	softled = (softled != 0);
    209 	if (softled != sc->sc_softled) {
    210 		if (softled) {
    211 			/* NB: handle any sc_ledpin change */
    212 			ath_hal_gpioCfgOutput(sc->sc_ah, sc->sc_ledpin);
    213 			ath_hal_gpioset(sc->sc_ah, sc->sc_ledpin,
    214 				!sc->sc_ledon);
    215 		}
    216 		sc->sc_softled = softled;
    217 	}
    218 	return 0;
    219 }
    220 
    221 static int
    222 ath_sysctl_rxantenna(SYSCTLFN_ARGS)
    223 {
    224 	struct ath_softc *sc;
    225 	struct sysctlnode node;
    226 	u_int defantenna;
    227 	int error;
    228 
    229 	node = *rnode;
    230 	sc = (struct ath_softc *)node.sysctl_data;
    231 	defantenna = ath_hal_getdefantenna(sc->sc_ah);
    232 	node.sysctl_data = &defantenna;
    233 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    234 	if (error || newp == NULL)
    235 		return error;
    236 	ath_hal_setdefantenna(sc->sc_ah, defantenna);
    237 	return 0;
    238 }
    239 
    240 static int
    241 ath_sysctl_diversity(SYSCTLFN_ARGS)
    242 {
    243 	struct ath_softc *sc;
    244 	struct sysctlnode node;
    245 	u_int diversity;
    246 	int error;
    247 
    248 	node = *rnode;
    249 	sc = (struct ath_softc *)node.sysctl_data;
    250 	diversity = sc->sc_diversity;
    251 	node.sysctl_data = &diversity;
    252 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    253 	if (error || newp == NULL)
    254 		return error;
    255 	if (!ath_hal_setdiversity(sc->sc_ah, diversity))
    256 		return EINVAL;
    257 	sc->sc_diversity = diversity;
    258 	return 0;
    259 }
    260 
    261 static int
    262 ath_sysctl_diag(SYSCTLFN_ARGS)
    263 {
    264 	struct ath_softc *sc;
    265 	struct sysctlnode node;
    266 	u_int32_t diag;
    267 	int error;
    268 
    269 	node = *rnode;
    270 	sc = (struct ath_softc *)node.sysctl_data;
    271 	if (!ath_hal_getdiag(sc->sc_ah, &diag))
    272 		return EINVAL;
    273 	node.sysctl_data = &diag;
    274 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    275 	if (error || newp == NULL)
    276 		return error;
    277 	return !ath_hal_setdiag(sc->sc_ah, diag) ? EINVAL : 0;
    278 }
    279 
    280 static int
    281 ath_sysctl_tpscale(SYSCTLFN_ARGS)
    282 {
    283 	struct ath_softc *sc;
    284 	struct sysctlnode node;
    285 	u_int32_t scale;
    286 	int error;
    287 
    288 	node = *rnode;
    289 	sc = (struct ath_softc *)node.sysctl_data;
    290 	ath_hal_gettpscale(sc->sc_ah, &scale);
    291 	node.sysctl_data = &scale;
    292 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    293 	if (error || newp == NULL)
    294 		return error;
    295 	return !ath_hal_settpscale(sc->sc_ah, scale)
    296 	    ? EINVAL
    297 	    : ath_reset(&sc->sc_if);
    298 }
    299 
    300 static int
    301 ath_sysctl_tpc(SYSCTLFN_ARGS)
    302 {
    303 	struct ath_softc *sc;
    304 	struct sysctlnode node;
    305 	u_int tpc;
    306 	int error;
    307 
    308 	node = *rnode;
    309 	sc = (struct ath_softc *)node.sysctl_data;
    310 	tpc = ath_hal_gettpc(sc->sc_ah);
    311 	node.sysctl_data = &tpc;
    312 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    313 	if (error || newp == NULL)
    314 		return error;
    315 	return !ath_hal_settpc(sc->sc_ah, tpc) ? EINVAL : 0;
    316 }
    317 
    318 const struct sysctlnode *
    319 ath_sysctl_instance(const char *dvname, struct sysctllog **log)
    320 {
    321 	int rc;
    322 	const struct sysctlnode *rnode;
    323 
    324 	if ((rc = sysctl_createv(log, 0, NULL, &rnode,
    325 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
    326 	    NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0)
    327 		goto err;
    328 
    329 	if ((rc = sysctl_createv(log, 0, &rnode, &rnode,
    330 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, dvname,
    331 	    SYSCTL_DESCR("ath information and options"),
    332 	    NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL)) != 0)
    333 		goto err;
    334 
    335 	return rnode;
    336 err:
    337 	printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
    338 	return NULL;
    339 }
    340 
    341 const struct sysctlnode *
    342 ath_sysctl_treetop(struct sysctllog **log)
    343 {
    344 	int rc;
    345 	const struct sysctlnode *rnode;
    346 
    347 	if ((rc = sysctl_createv(log, 0, NULL, &rnode,
    348 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
    349 	    NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0)
    350 		goto err;
    351 
    352 	if ((rc = sysctl_createv(log, 0, &rnode, &rnode,
    353 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "ath",
    354 	    SYSCTL_DESCR("ath information and options"),
    355 	    NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL)) != 0)
    356 		goto err;
    357 
    358 	return rnode;
    359 err:
    360 	printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
    361 	return NULL;
    362 }
    363 
    364 void
    365 ath_sysctlattach(struct ath_softc *sc)
    366 {
    367 	int rc;
    368 	struct sysctllog **log = &sc->sc_sysctllog;
    369 	const struct sysctlnode *cnode, *rnode;
    370 
    371 	ath_hal_getcountrycode(sc->sc_ah, &sc->sc_countrycode);
    372 	ath_hal_getregdomain(sc->sc_ah, &sc->sc_regdomain);
    373 	sc->sc_debug = ath_debug;
    374 	sc->sc_txintrperiod = ATH_TXINTR_PERIOD;
    375 
    376 	if ((rnode = ath_sysctl_instance(sc->sc_dev.dv_xname, log)) == NULL)
    377 		return;
    378 
    379 	if ((rc = SYSCTL_INT(0, countrycode, "EEPROM country code")) != 0)
    380 		goto err;
    381 
    382 	if ((rc = SYSCTL_INT(0, regdomain, "EEPROM regdomain code")) != 0)
    383 		goto err;
    384 
    385 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, debug,
    386 	    "control debugging printfs")) != 0)
    387 		goto err;
    388 
    389 #if 0
    390 	/* channel dwell time (ms) for AP/station scanning */
    391 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, dwell,
    392 	    "Channel dwell time (ms) for scanning")) != 0)
    393 		goto err;
    394 #endif
    395 
    396 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, slottime,
    397 	    "802.11 slot time (us)")) != 0)
    398 		goto err;
    399 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, acktimeout,
    400 	    "802.11 ACK timeout (us)")) != 0)
    401 		goto err;
    402 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, ctstimeout,
    403 	    "802.11 CTS timeout (us)")) != 0)
    404 		goto err;
    405 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, softled,
    406 	    "enable/disable software LED support")) != 0)
    407 		goto err;
    408 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledpin,
    409 	    "GPIO pin connected to LED")) != 0)
    410 		goto err;
    411 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledon,
    412 	    "setting to turn LED on")) != 0)
    413 		goto err;
    414 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, ledidle,
    415 	    "idle time for inactivity LED (ticks)")) != 0)
    416 		goto err;
    417 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, txantenna,
    418 	    "tx antenna (0=auto)")) != 0)
    419 		goto err;
    420 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, rxantenna,
    421 	    "default/rx antenna")) != 0)
    422 		goto err;
    423 	if (ath_hal_hasdiversity(sc->sc_ah)) {
    424 		if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, diversity,
    425 		    "antenna diversity")) != 0)
    426 			goto err;
    427 	}
    428 	if ((rc = SYSCTL_INT(CTLFLAG_READWRITE, txintrperiod,
    429 	    "tx descriptor batching")) != 0)
    430 		goto err;
    431 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, diag,
    432 	    "h/w diagnostic control")) != 0)
    433 		goto err;
    434 	if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpscale,
    435 	    "tx power scaling")) != 0)
    436 		goto err;
    437 	if (ath_hal_hastpc(sc->sc_ah)) {
    438 		if ((rc = SYSCTL_INT_SUBR(CTLFLAG_READWRITE, tpc,
    439 		    "enable/disable per-packet TPC")) != 0)
    440 			goto err;
    441 	}
    442 	return;
    443 err:
    444 	printf("%s: sysctl_createv failed, rc = %d\n", __func__, rc);
    445 }
    446