The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net80211/ieee80211_tdma.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2007-2009 Sam Leffler, Errno Consulting
    3  * Copyright (c) 2007-2009 Intel Corporation
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 #ifdef __FreeBSD__
   29 __FBSDID("$FreeBSD: releng/11.0/sys/net80211/ieee80211_tdma.c 298376 2016-04-20 21:15:55Z avos $");
   30 #endif
   31 
   32 /*
   33  * IEEE 802.11 TDMA mode support.
   34  */
   35 #include "opt_inet.h"
   36 #include "opt_tdma.h"
   37 #include "opt_wlan.h"
   38 
   39 #ifdef  IEEE80211_SUPPORT_TDMA
   40 
   41 #include <sys/param.h>
   42 #include <sys/systm.h> 
   43 #include <sys/mbuf.h>   
   44 #include <sys/malloc.h>
   45 #include <sys/kernel.h>
   46 
   47 #include <sys/socket.h>
   48 #include <sys/sockio.h>
   49 #include <sys/endian.h>
   50 #include <sys/errno.h>
   51 #include <sys/proc.h>
   52 #include <sys/sysctl.h>
   53 
   54 #include <net/if.h>
   55 #include <net/if_media.h>
   56 #include <net/if_llc.h>
   57 #include <net/ethernet.h>
   58 
   59 #include <net/bpf.h>
   60 
   61 #include <net80211/ieee80211_var.h>
   62 #include <net80211/ieee80211_tdma.h>
   63 #include <net80211/ieee80211_input.h>
   64 
   65 #ifndef TDMA_SLOTLEN_DEFAULT
   66 #define TDMA_SLOTLEN_DEFAULT    10*1000         /* 10ms */
   67 #endif
   68 #ifndef TDMA_SLOTCNT_DEFAULT
   69 #define TDMA_SLOTCNT_DEFAULT    2               /* 2x (pt-to-pt) */
   70 #endif
   71 #ifndef TDMA_BINTVAL_DEFAULT
   72 #define TDMA_BINTVAL_DEFAULT    5               /* 5x ~= 100TU beacon intvl */
   73 #endif
   74 #ifndef TDMA_TXRATE_11B_DEFAULT
   75 #define TDMA_TXRATE_11B_DEFAULT 2*11
   76 #endif
   77 #ifndef TDMA_TXRATE_11G_DEFAULT
   78 #define TDMA_TXRATE_11G_DEFAULT 2*24
   79 #endif
   80 #ifndef TDMA_TXRATE_11A_DEFAULT
   81 #define TDMA_TXRATE_11A_DEFAULT 2*24
   82 #endif
   83 #ifndef TDMA_TXRATE_TURBO_DEFAULT
   84 #define TDMA_TXRATE_TURBO_DEFAULT       2*24
   85 #endif
   86 #ifndef TDMA_TXRATE_HALF_DEFAULT
   87 #define TDMA_TXRATE_HALF_DEFAULT        2*12
   88 #endif
   89 #ifndef TDMA_TXRATE_QUARTER_DEFAULT
   90 #define TDMA_TXRATE_QUARTER_DEFAULT     2*6
   91 #endif
   92 #ifndef TDMA_TXRATE_11NA_DEFAULT
   93 #define TDMA_TXRATE_11NA_DEFAULT        (4 | IEEE80211_RATE_MCS)
   94 #endif
   95 #ifndef TDMA_TXRATE_11NG_DEFAULT
   96 #define TDMA_TXRATE_11NG_DEFAULT        (4 | IEEE80211_RATE_MCS)
   97 #endif
   98 
   99 #define TDMA_VERSION_VALID(_version) \
  100         (TDMA_VERSION_V2 <= (_version) && (_version) <= TDMA_VERSION)
  101 #define TDMA_SLOTCNT_VALID(_slotcnt) \
  102         (2 <= (_slotcnt) && (_slotcnt) <= TDMA_MAXSLOTS)
  103 /* XXX magic constants */
  104 #define TDMA_SLOTLEN_VALID(_slotlen) \
  105         (2*100 <= (_slotlen) && (unsigned)(_slotlen) <= 0xfffff)
  106 /* XXX probably should set a max */
  107 #define TDMA_BINTVAL_VALID(_bintval)    (1 <= (_bintval))
  108 
  109 /*
  110  * This code is not prepared to handle more than 2 slots.
  111  */
  112 CTASSERT(TDMA_MAXSLOTS == 2);
  113 
  114 static void tdma_vdetach(struct ieee80211vap *vap);
  115 static int tdma_newstate(struct ieee80211vap *, enum ieee80211_state, int);
  116 static void tdma_beacon_miss(struct ieee80211vap *vap);
  117 static void tdma_recv_mgmt(struct ieee80211_node *, struct mbuf *,
  118         int subtype, const struct ieee80211_rx_stats *rxs, int rssi, int nf);
  119 static int tdma_update(struct ieee80211vap *vap,
  120         const struct ieee80211_tdma_param *tdma, struct ieee80211_node *ni,
  121         int pickslot);
  122 static int tdma_process_params(struct ieee80211_node *ni,
  123         const u_int8_t *ie, int rssi, int nf, const struct ieee80211_frame *wh);
  124 
  125 static void
  126 settxparms(struct ieee80211vap *vap, enum ieee80211_phymode mode, int rate)
  127 {
  128         vap->iv_txparms[mode].ucastrate = rate;
  129         vap->iv_txparms[mode].mcastrate = rate;
  130 }
  131 
  132 static void
  133 setackpolicy(struct ieee80211com *ic, int noack)
  134 {
  135         struct ieee80211_wme_state *wme = &ic->ic_wme;
  136         int ac;
  137 
  138         for (ac = 0; ac < WME_NUM_AC; ac++) {
  139                 wme->wme_chanParams.cap_wmeParams[ac].wmep_noackPolicy = noack;
  140                 wme->wme_wmeChanParams.cap_wmeParams[ac].wmep_noackPolicy = noack;
  141         }
  142 }
  143 
  144 void
  145 ieee80211_tdma_vattach(struct ieee80211vap *vap)
  146 {
  147         struct ieee80211_tdma_state *ts;
  148 
  149         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  150              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  151 
  152         ts = (struct ieee80211_tdma_state *) IEEE80211_MALLOC(
  153              sizeof(struct ieee80211_tdma_state), M_80211_VAP,
  154              IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  155         if (ts == NULL) {
  156                 printf("%s: cannot allocate TDMA state block\n", __func__);
  157                 /* NB: fall back to adhdemo mode */
  158                 vap->iv_caps &= ~IEEE80211_C_TDMA;
  159                 return;
  160         }
  161         /* NB: default configuration is passive so no beacons */
  162         ts->tdma_version = TDMA_VERSION;
  163         ts->tdma_slotlen = TDMA_SLOTLEN_DEFAULT;
  164         ts->tdma_slotcnt = TDMA_SLOTCNT_DEFAULT;
  165         ts->tdma_bintval = TDMA_BINTVAL_DEFAULT;
  166         ts->tdma_slot = 1;                      /* passive operation */
  167 
  168         /* setup default fixed rates */
  169         settxparms(vap, IEEE80211_MODE_11A, TDMA_TXRATE_11A_DEFAULT);
  170         settxparms(vap, IEEE80211_MODE_11B, TDMA_TXRATE_11B_DEFAULT);
  171         settxparms(vap, IEEE80211_MODE_11G, TDMA_TXRATE_11G_DEFAULT);
  172         settxparms(vap, IEEE80211_MODE_TURBO_A, TDMA_TXRATE_TURBO_DEFAULT);
  173         settxparms(vap, IEEE80211_MODE_TURBO_G, TDMA_TXRATE_TURBO_DEFAULT);
  174         settxparms(vap, IEEE80211_MODE_STURBO_A, TDMA_TXRATE_TURBO_DEFAULT);
  175         settxparms(vap, IEEE80211_MODE_11NA, TDMA_TXRATE_11NA_DEFAULT);
  176         settxparms(vap, IEEE80211_MODE_11NG, TDMA_TXRATE_11NG_DEFAULT);
  177         settxparms(vap, IEEE80211_MODE_HALF, TDMA_TXRATE_HALF_DEFAULT);
  178         settxparms(vap, IEEE80211_MODE_QUARTER, TDMA_TXRATE_QUARTER_DEFAULT);
  179 
  180         setackpolicy(vap->iv_ic, 1);    /* disable ACK's */
  181 
  182         ts->tdma_opdetach = vap->iv_opdetach;
  183         vap->iv_opdetach = tdma_vdetach;
  184         ts->tdma_newstate = vap->iv_newstate;
  185         vap->iv_newstate = tdma_newstate;
  186         vap->iv_bmiss = tdma_beacon_miss;
  187         ts->tdma_recv_mgmt = vap->iv_recv_mgmt;
  188         vap->iv_recv_mgmt = tdma_recv_mgmt;
  189 
  190         vap->iv_tdma = ts;
  191 }
  192 
  193 static void
  194 tdma_vdetach(struct ieee80211vap *vap)
  195 {
  196         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  197 
  198         if (ts == NULL) {
  199                 /* NB: should not have touched any ic state */
  200                 return;
  201         }
  202         ts->tdma_opdetach(vap);
  203         IEEE80211_FREE(vap->iv_tdma, M_80211_VAP);
  204         vap->iv_tdma = NULL;
  205 
  206         setackpolicy(vap->iv_ic, 0);    /* enable ACK's */
  207 }
  208 
  209 static void
  210 sta_leave(void *arg, struct ieee80211_node *ni)
  211 {
  212         struct ieee80211vap *vap = arg;
  213 
  214         if (ni->ni_vap == vap && ni != vap->iv_bss)
  215                 ieee80211_node_leave(ni);
  216 }
  217 
  218 /*
  219  * TDMA state machine handler.
  220  */
  221 static int
  222 tdma_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
  223 {
  224         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  225         struct ieee80211com *ic = vap->iv_ic;
  226         enum ieee80211_state ostate;
  227         int status;
  228 
  229         IEEE80211_LOCK_ASSERT(ic);
  230 
  231         ostate = vap->iv_state;
  232         IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
  233             __func__, ieee80211_state_name[ostate],
  234             ieee80211_state_name[nstate], arg);
  235 
  236         if (vap->iv_flags_ext & IEEE80211_FEXT_SWBMISS)
  237                 callout_stop(&vap->iv_swbmiss);
  238         if (nstate == IEEE80211_S_SCAN &&
  239             (ostate == IEEE80211_S_INIT || ostate == IEEE80211_S_RUN) &&
  240             ts->tdma_slot != 0) {
  241                 /*
  242                  * Override adhoc behaviour when operating as a slave;
  243                  * we need to scan even if the channel is locked.
  244                  */
  245                 vap->iv_state = nstate;                 /* state transition */
  246                 ieee80211_cancel_scan(vap);             /* background scan */
  247                 if (ostate == IEEE80211_S_RUN) {
  248                         /* purge station table; entries are stale */
  249                         ieee80211_iterate_nodes(&ic->ic_sta, sta_leave, vap);
  250                 }
  251                 if (vap->iv_flags_ext & IEEE80211_FEXT_SCANREQ) {
  252                         ieee80211_check_scan(vap,
  253                             vap->iv_scanreq_flags,
  254                             vap->iv_scanreq_duration,
  255                             vap->iv_scanreq_mindwell,
  256                             vap->iv_scanreq_maxdwell,
  257                             vap->iv_scanreq_nssid, vap->iv_scanreq_ssid);
  258                         vap->iv_flags_ext &= ~IEEE80211_FEXT_SCANREQ;
  259                 } else
  260                         ieee80211_check_scan_current(vap);
  261                 status = 0;
  262         } else {
  263                 status = ts->tdma_newstate(vap, nstate, arg);
  264         }
  265         if (status == 0 && 
  266             nstate == IEEE80211_S_RUN && ostate != IEEE80211_S_RUN &&
  267             (vap->iv_flags_ext & IEEE80211_FEXT_SWBMISS) &&
  268             ts->tdma_slot != 0 &&
  269             vap->iv_des_chan == IEEE80211_CHAN_ANYC) {
  270                 /*
  271                  * Start s/w beacon miss timer for slave devices w/o
  272                  * hardware support.  Note we do this only if we're
  273                  * not locked to a channel (i.e. roam to follow the
  274                  * master). The 2x is a fudge for our doing this in
  275                  * software.
  276                  */
  277                 vap->iv_swbmiss_period = IEEE80211_TU_TO_TICKS(
  278                     2 * vap->iv_bmissthreshold * ts->tdma_bintval *
  279                     ((ts->tdma_slotcnt * ts->tdma_slotlen) / 1024));
  280                 vap->iv_swbmiss_count = 0;
  281                 callout_reset(&vap->iv_swbmiss, vap->iv_swbmiss_period,
  282                         ieee80211_swbmiss, vap);
  283         }
  284         return status;
  285 }
  286 
  287 static void
  288 tdma_beacon_miss(struct ieee80211vap *vap)
  289 {
  290         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  291 
  292         IEEE80211_LOCK_ASSERT(vap->iv_ic);
  293 
  294         KASSERT((vap->iv_ic->ic_flags & IEEE80211_F_SCAN) == 0, ("scanning"));
  295         KASSERT(vap->iv_state == IEEE80211_S_RUN,
  296             ("wrong state %d", vap->iv_state));
  297 
  298         IEEE80211_DPRINTF(vap,
  299                 IEEE80211_MSG_STATE | IEEE80211_MSG_TDMA | IEEE80211_MSG_DEBUG,
  300                 "beacon miss, mode %u state %s\n",
  301                 vap->iv_opmode, ieee80211_state_name[vap->iv_state]);
  302 
  303         callout_stop(&vap->iv_swbmiss);
  304 
  305         if (ts->tdma_peer != NULL) {    /* XXX? can this be null? */
  306                 ieee80211_notify_node_leave(vap->iv_bss);
  307                 ts->tdma_peer = NULL;
  308                 /*
  309                  * Treat beacon miss like an associate failure wrt the
  310                  * scan policy; this forces the entry in the scan cache
  311                  * to be ignored after several tries.
  312                  */
  313                 ieee80211_scan_assoc_fail(vap, vap->iv_bss->ni_macaddr,
  314                     IEEE80211_STATUS_TIMEOUT);
  315         }
  316 #if 0
  317         ts->tdma_inuse = 0;             /* clear slot usage */
  318 #endif
  319         ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
  320 }
  321 
  322 static void
  323 tdma_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m0,
  324         int subtype, const struct ieee80211_rx_stats *rxs, int rssi, int nf)
  325 {
  326         struct ieee80211com *ic = ni->ni_ic;
  327         struct ieee80211vap *vap = ni->ni_vap;
  328         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  329 
  330         if (subtype == IEEE80211_FC0_SUBTYPE_BEACON &&
  331             (ic->ic_flags & IEEE80211_F_SCAN) == 0) {
  332                 struct ieee80211_frame *wh = mtod(m0, struct ieee80211_frame *);
  333                 struct ieee80211_scanparams scan;
  334 
  335                 /* XXX TODO: use rxstatus to determine off-channel beacons */
  336                 if (ieee80211_parse_beacon(ni, m0, ic->ic_curchan, &scan) != 0)
  337                         return;
  338                 if (scan.tdma == NULL) {
  339                         /*
  340                          * TDMA stations must beacon a TDMA ie; ignore
  341                          * any other station.
  342                          * XXX detect overlapping bss and change channel
  343                          */
  344                         IEEE80211_DISCARD(vap,
  345                             IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
  346                             wh, ieee80211_mgt_subtype_name(subtype),
  347                             "%s", "no TDMA ie");
  348                         vap->iv_stats.is_rx_mgtdiscard++;
  349                         return;
  350                 }
  351                 if (ni == vap->iv_bss &&
  352                     !IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
  353                         /*
  354                          * Fake up a node for this newly
  355                          * discovered member of the IBSS.
  356                          */
  357                         ni = ieee80211_add_neighbor(vap, wh, &scan);
  358                         if (ni == NULL) {
  359                                 /* NB: stat kept for alloc failure */
  360                                 return;
  361                         }
  362                 }
  363                 /*
  364                  * Check for state updates.
  365                  */
  366                 if (IEEE80211_ADDR_EQ(wh->i_addr3, ni->ni_bssid)) {
  367                         /*
  368                          * Count frame now that we know it's to be processed.
  369                          */
  370                         vap->iv_stats.is_rx_beacon++;
  371                         IEEE80211_NODE_STAT(ni, rx_beacons);
  372                         /*
  373                          * Record tsf of last beacon.  NB: this must be
  374                          * done before calling tdma_process_params
  375                          * as deeper routines reference it.
  376                          */
  377                         memcpy(&ni->ni_tstamp.data, scan.tstamp,
  378                                 sizeof(ni->ni_tstamp.data));
  379                         /*
  380                          * Count beacon frame for s/w bmiss handling.
  381                          */
  382                         vap->iv_swbmiss_count++;
  383                         /*
  384                          * Process tdma ie.  The contents are used to sync
  385                          * the slot timing, reconfigure the bss, etc.
  386                          */
  387                         (void) tdma_process_params(ni, scan.tdma, rssi, nf, wh);
  388                         return;
  389                 }
  390                 /*
  391                  * NB: defer remaining work to the adhoc code; this causes
  392                  *     2x parsing of the frame but should happen infrequently
  393                  */
  394         }
  395         ts->tdma_recv_mgmt(ni, m0, subtype, rxs, rssi, nf);
  396 }
  397 
  398 /*
  399  * Update TDMA state on receipt of a beacon frame with
  400  * a TDMA information element.  The sender's identity
  401  * is provided so we can track who our peer is.  If pickslot
  402  * is non-zero we scan the slot allocation state in the ie
  403  * to locate a free slot for our use.
  404  */
  405 static int
  406 tdma_update(struct ieee80211vap *vap, const struct ieee80211_tdma_param *tdma,
  407         struct ieee80211_node *ni, int pickslot)
  408 {
  409         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  410         int slot, slotlen, update;
  411 
  412         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  413              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  414 
  415         update = 0;
  416         if (tdma->tdma_slotcnt != ts->tdma_slotcnt) {
  417                 if (!TDMA_SLOTCNT_VALID(tdma->tdma_slotcnt)) {
  418                         if (ppsratecheck(&ts->tdma_lastprint, &ts->tdma_fails, 1))
  419                                 printf("%s: bad slot cnt %u\n",
  420                                     __func__, tdma->tdma_slotcnt);
  421                         return 0;
  422                 }
  423                 update |= TDMA_UPDATE_SLOTCNT;
  424         }
  425         slotlen = le16toh(tdma->tdma_slotlen) * 100;
  426         if (slotlen != ts->tdma_slotlen) {
  427                 if (!TDMA_SLOTLEN_VALID(slotlen)) {
  428                         if (ppsratecheck(&ts->tdma_lastprint, &ts->tdma_fails, 1))
  429                                 printf("%s: bad slot len %u\n",
  430                                     __func__, slotlen);
  431                         return 0;
  432                 }
  433                 update |= TDMA_UPDATE_SLOTLEN;
  434         }
  435         if (tdma->tdma_bintval != ts->tdma_bintval) {
  436                 if (!TDMA_BINTVAL_VALID(tdma->tdma_bintval)) {
  437                         if (ppsratecheck(&ts->tdma_lastprint, &ts->tdma_fails, 1))
  438                                 printf("%s: bad beacon interval %u\n",
  439                                     __func__, tdma->tdma_bintval);
  440                         return 0;
  441                 }
  442                 update |= TDMA_UPDATE_BINTVAL;
  443         }
  444         slot = ts->tdma_slot;
  445         if (pickslot) {
  446                 /*
  447                  * Pick unoccupied slot.  Note we never choose slot 0.
  448                  */
  449                 for (slot = tdma->tdma_slotcnt-1; slot > 0; slot--)
  450                         if (isclr(tdma->tdma_inuse, slot))
  451                                 break;
  452                 if (slot <= 0) {
  453                         printf("%s: no free slot, slotcnt %u inuse: 0x%x\n",
  454                                 __func__, tdma->tdma_slotcnt,
  455                                 tdma->tdma_inuse[0]);
  456                         /* XXX need to do something better */
  457                         return 0;
  458                 }
  459                 if (slot != ts->tdma_slot)
  460                         update |= TDMA_UPDATE_SLOT;
  461         }
  462         if (ni != ts->tdma_peer) {
  463                 /* update everything */
  464                 update = TDMA_UPDATE_SLOT
  465                        | TDMA_UPDATE_SLOTCNT
  466                        | TDMA_UPDATE_SLOTLEN
  467                        | TDMA_UPDATE_BINTVAL;
  468         }
  469 
  470         if (update) {
  471                 /*
  472                  * New/changed parameters; update runtime state.
  473                  */
  474                 /* XXX overwrites user parameters */
  475                 if (update & TDMA_UPDATE_SLOTCNT)
  476                         ts->tdma_slotcnt = tdma->tdma_slotcnt;
  477                 if (update & TDMA_UPDATE_SLOTLEN)
  478                         ts->tdma_slotlen = slotlen;
  479                 if (update & TDMA_UPDATE_SLOT)
  480                         ts->tdma_slot = slot;
  481                 if (update & TDMA_UPDATE_BINTVAL)
  482                         ts->tdma_bintval = tdma->tdma_bintval;
  483                 /* mark beacon to be updated before next xmit */
  484                 ieee80211_beacon_notify(vap, IEEE80211_BEACON_TDMA);
  485 
  486                 IEEE80211_DPRINTF(vap, IEEE80211_MSG_TDMA,
  487                     "%s: slot %u slotcnt %u slotlen %u us bintval %u\n",
  488                     __func__, ts->tdma_slot, ts->tdma_slotcnt,
  489                     ts->tdma_slotlen, ts->tdma_bintval);
  490         }
  491         /*
  492          * Notify driver.  Note we can be called before
  493          * entering RUN state if we scanned and are
  494          * joining an existing bss.  In that case do not
  495          * call the driver because not all necessary state
  496          * has been setup.  The next beacon will dtrt.
  497          */
  498         if (vap->iv_state == IEEE80211_S_RUN)
  499                 vap->iv_ic->ic_tdma_update(ni, tdma, update);
  500         /*
  501          * Dispatch join event on first beacon from new master.
  502          */
  503         if (ts->tdma_peer != ni) {
  504                 if (ts->tdma_peer != NULL)
  505                         ieee80211_notify_node_leave(vap->iv_bss);
  506                 ieee80211_notify_node_join(ni, 1);
  507                 /* NB: no reference, we just use the address */
  508                 ts->tdma_peer = ni;
  509         }
  510         return 1;
  511 }
  512 
  513 /*
  514  * Process received TDMA parameters.
  515  */
  516 static int
  517 tdma_process_params(struct ieee80211_node *ni, const u_int8_t *ie,
  518         int rssi, int nf, const struct ieee80211_frame *wh)
  519 {
  520         struct ieee80211vap *vap = ni->ni_vap;
  521         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  522         const struct ieee80211_tdma_param *tdma = 
  523                 (const struct ieee80211_tdma_param *) ie;
  524         u_int len = ie[1];
  525 
  526         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  527              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  528 
  529         if (len < sizeof(*tdma) - 2) {
  530                 IEEE80211_DISCARD_IE(vap,
  531                     IEEE80211_MSG_ELEMID | IEEE80211_MSG_TDMA,
  532                     wh, "tdma", "too short, len %u", len);
  533                 return IEEE80211_REASON_IE_INVALID;
  534         }
  535         if (tdma->tdma_version != ts->tdma_version) {
  536                 IEEE80211_DISCARD_IE(vap,
  537                     IEEE80211_MSG_ELEMID | IEEE80211_MSG_TDMA,
  538                     wh, "tdma", "bad version %u (ours %u)",
  539                     tdma->tdma_version, ts->tdma_version);
  540                 return IEEE80211_REASON_IE_INVALID;
  541         }
  542         /*
  543          * NB: ideally we'd check against tdma_slotcnt, but that
  544          * would require extra effort so do this easy check that
  545          * covers the work below; more stringent checks are done
  546          * before we make more extensive use of the ie contents.
  547          */
  548         if (tdma->tdma_slot >= TDMA_MAXSLOTS) {
  549                 IEEE80211_DISCARD_IE(vap,
  550                     IEEE80211_MSG_ELEMID | IEEE80211_MSG_TDMA,
  551                     wh, "tdma", "invalid slot %u", tdma->tdma_slot);
  552                 return IEEE80211_REASON_IE_INVALID;
  553         }
  554         /*
  555          * Can reach here while scanning, update
  556          * operational state only in RUN state.
  557          */
  558         if (vap->iv_state == IEEE80211_S_RUN) {
  559                 if (tdma->tdma_slot != ts->tdma_slot &&
  560                     isclr(ts->tdma_inuse, tdma->tdma_slot)) {
  561                         IEEE80211_NOTE(vap, IEEE80211_MSG_TDMA, ni,
  562                             "discovered in slot %u", tdma->tdma_slot);
  563                         setbit(ts->tdma_inuse, tdma->tdma_slot);
  564                         /* XXX dispatch event only when operating as master */
  565                         if (ts->tdma_slot == 0)
  566                                 ieee80211_notify_node_join(ni, 1);
  567                 }
  568                 setbit(ts->tdma_active, tdma->tdma_slot);
  569                 if (tdma->tdma_slot == ts->tdma_slot-1) {
  570                         /*
  571                          * Slave tsf synchronization to station
  572                          * just before us in the schedule. The driver
  573                          * is responsible for copying the timestamp
  574                          * of the received beacon into our beacon
  575                          * frame so the sender can calculate round
  576                          * trip time.  We cannot do that here because
  577                          * we don't know how to update our beacon frame.
  578                          */
  579                         (void) tdma_update(vap, tdma, ni, 0);
  580                         /* XXX reschedule swbmiss timer on parameter change */
  581                 } else if (tdma->tdma_slot == ts->tdma_slot+1) {
  582                         uint64_t tstamp;
  583 #if 0
  584                         uint32_t rstamp = (uint32_t) le64toh(rs->tsf);
  585                         int32_t rtt;
  586 #endif
  587                         /*
  588                          * Use returned timstamp to calculate the
  589                          * roundtrip time.
  590                          */
  591                         memcpy(&tstamp, tdma->tdma_tstamp, 8);
  592 #if 0
  593                         /* XXX use only 15 bits of rstamp */
  594                         rtt = rstamp - (le64toh(tstamp) & 0x7fff);
  595                         if (rtt < 0)
  596                                 rtt += 0x7fff;
  597                         /* XXX hack to quiet normal use */
  598                         IEEE80211_DPRINTF(vap, IEEE80211_MSG_DOT1X,
  599                             "tdma rtt %5u [rstamp %5u tstamp %llu]\n",
  600                             rtt, rstamp,
  601                             (unsigned long long) le64toh(tstamp));
  602 #endif
  603                 } else if (tdma->tdma_slot == ts->tdma_slot &&
  604                     le64toh(ni->ni_tstamp.tsf) > vap->iv_bss->ni_tstamp.tsf) {
  605                         /*
  606                          * Station using the same slot as us and has
  607                          * been around longer than us; we must move.
  608                          * Note this can happen if stations do not
  609                          * see each other while scanning.
  610                          */
  611                         IEEE80211_DPRINTF(vap, IEEE80211_MSG_TDMA,
  612                             "slot %u collision rxtsf %llu tsf %llu\n",
  613                             tdma->tdma_slot,
  614                             (unsigned long long) le64toh(ni->ni_tstamp.tsf),
  615                             vap->iv_bss->ni_tstamp.tsf);
  616                         setbit(ts->tdma_inuse, tdma->tdma_slot);
  617 
  618                         (void) tdma_update(vap, tdma, ni, 1);
  619                 }
  620         }
  621         return 0;
  622 }
  623 
  624 int
  625 ieee80211_tdma_getslot(struct ieee80211vap *vap)
  626 {
  627         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  628 
  629         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  630              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  631         return ts->tdma_slot;
  632 }
  633 
  634 /*
  635  * Parse a TDMA ie on station join and use it to setup node state.
  636  */
  637 void
  638 ieee80211_parse_tdma(struct ieee80211_node *ni, const uint8_t *ie)
  639 {
  640         struct ieee80211vap *vap = ni->ni_vap;
  641 
  642         if (vap->iv_caps & IEEE80211_C_TDMA) {
  643                 const struct ieee80211_tdma_param *tdma =
  644                     (const struct ieee80211_tdma_param *)ie;
  645                 struct ieee80211_tdma_state *ts = vap->iv_tdma;
  646                 /*
  647                  * Adopt TDMA configuration when joining an
  648                  * existing network.
  649                  */
  650                 setbit(ts->tdma_inuse, tdma->tdma_slot);
  651                 (void) tdma_update(vap, tdma, ni, 1);
  652                 /*
  653                  * Propagate capabilities based on the local
  654                  * configuration and the remote station's advertised
  655                  * capabilities. In particular this permits us to
  656                  * enable use of QoS to disable ACK's.
  657                  */
  658                 if ((vap->iv_flags & IEEE80211_F_WME) &&
  659                     ni->ni_ies.wme_ie != NULL)
  660                         ni->ni_flags |= IEEE80211_NODE_QOS;
  661         }
  662 }
  663 
  664 #define TDMA_OUI_BYTES          0x00, 0x03, 0x7f
  665 /*
  666  * Add a TDMA parameters element to a frame.
  667  */
  668 uint8_t *
  669 ieee80211_add_tdma(uint8_t *frm, struct ieee80211vap *vap)
  670 {
  671 #define ADDSHORT(frm, v) do {                   \
  672         frm[0] = (v) & 0xff;                    \
  673         frm[1] = (v) >> 8;                      \
  674         frm += 2;                               \
  675 } while (0)
  676         static const struct ieee80211_tdma_param param = {
  677                 .tdma_id        = IEEE80211_ELEMID_VENDOR,
  678                 .tdma_len       = sizeof(struct ieee80211_tdma_param) - 2,
  679                 .tdma_oui       = { TDMA_OUI_BYTES },
  680                 .tdma_type      = TDMA_OUI_TYPE,
  681                 .tdma_subtype   = TDMA_SUBTYPE_PARAM,
  682                 .tdma_version   = TDMA_VERSION,
  683         };
  684         const struct ieee80211_tdma_state *ts = vap->iv_tdma;
  685         uint16_t slotlen;
  686 
  687         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  688              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  689 
  690         memcpy(frm, &param, sizeof(param));
  691         frm += __offsetof(struct ieee80211_tdma_param, tdma_slot);
  692         *frm++ = ts->tdma_slot;
  693         *frm++ = ts->tdma_slotcnt;
  694         /* NB: convert units to fit in 16-bits */
  695         slotlen = ts->tdma_slotlen / 100;       /* 100us units */
  696         ADDSHORT(frm, slotlen);
  697         *frm++ = ts->tdma_bintval;
  698         *frm++ = ts->tdma_inuse[0];
  699         frm += 10;                              /* pad+timestamp */
  700         return frm; 
  701 #undef ADDSHORT
  702 }
  703 #undef TDMA_OUI_BYTES
  704 
  705 /*
  706  * Update TDMA state at TBTT.
  707  */
  708 void
  709 ieee80211_tdma_update_beacon(struct ieee80211vap *vap,
  710         struct ieee80211_beacon_offsets *bo)
  711 {
  712         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  713 
  714         KASSERT(vap->iv_caps & IEEE80211_C_TDMA,
  715              ("not a tdma vap, caps 0x%x", vap->iv_caps));
  716 
  717         if (isset(bo->bo_flags,  IEEE80211_BEACON_TDMA)) {
  718                 (void) ieee80211_add_tdma(bo->bo_tdma, vap);
  719                 clrbit(bo->bo_flags, IEEE80211_BEACON_TDMA);
  720         }
  721         if (ts->tdma_slot != 0)         /* only on master */
  722                 return;
  723         if (ts->tdma_count <= 0) {
  724                 /*
  725                  * Time to update the mask of active/inuse stations.
  726                  * We track stations that we've received a beacon
  727                  * frame from and update this mask periodically.
  728                  * This allows us to miss a few beacons before marking
  729                  * a slot free for re-use.
  730                  */
  731                 ts->tdma_inuse[0] = ts->tdma_active[0];
  732                 ts->tdma_active[0] = 0x01;
  733                 /* update next time 'round */
  734                 /* XXX use notify framework */
  735                 setbit(bo->bo_flags, IEEE80211_BEACON_TDMA);
  736                 /* NB: use s/w beacon miss threshold; may be too high */
  737                 ts->tdma_count = vap->iv_bmissthreshold-1;
  738         } else
  739                 ts->tdma_count--;
  740 }
  741 
  742 static int
  743 tdma_ioctl_get80211(struct ieee80211vap *vap, struct ieee80211req *ireq)
  744 {
  745         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  746 
  747         if ((vap->iv_caps & IEEE80211_C_TDMA) == 0)
  748                 return ENOSYS;
  749 
  750         switch (ireq->i_type) {
  751         case IEEE80211_IOC_TDMA_SLOT:
  752                 ireq->i_val = ts->tdma_slot;
  753                 break;
  754         case IEEE80211_IOC_TDMA_SLOTCNT:
  755                 ireq->i_val = ts->tdma_slotcnt;
  756                 break;
  757         case IEEE80211_IOC_TDMA_SLOTLEN:
  758                 ireq->i_val = ts->tdma_slotlen;
  759                 break;
  760         case IEEE80211_IOC_TDMA_BINTERVAL:
  761                 ireq->i_val = ts->tdma_bintval;
  762                 break;
  763         default:
  764                 return ENOSYS;
  765         }
  766         return 0;
  767 }
  768 IEEE80211_IOCTL_GET(tdma, tdma_ioctl_get80211);
  769 
  770 static int
  771 tdma_ioctl_set80211(struct ieee80211vap *vap, struct ieee80211req *ireq)
  772 {
  773         struct ieee80211_tdma_state *ts = vap->iv_tdma;
  774 
  775         if ((vap->iv_caps & IEEE80211_C_TDMA) == 0)
  776                 return ENOSYS;
  777 
  778         switch (ireq->i_type) {
  779         case IEEE80211_IOC_TDMA_SLOT:
  780                 if (!(0 <= ireq->i_val && ireq->i_val <= ts->tdma_slotcnt))
  781                         return EINVAL;
  782                 if (ireq->i_val != ts->tdma_slot) {
  783                         ts->tdma_slot = ireq->i_val;
  784                         goto restart;
  785                 }
  786                 break;
  787         case IEEE80211_IOC_TDMA_SLOTCNT:
  788                 if (!TDMA_SLOTCNT_VALID(ireq->i_val))
  789                         return EINVAL;
  790                 if (ireq->i_val != ts->tdma_slotcnt) {
  791                         ts->tdma_slotcnt = ireq->i_val;
  792                         goto restart;
  793                 }
  794                 break;
  795         case IEEE80211_IOC_TDMA_SLOTLEN:
  796                 /*
  797                  * XXX
  798                  * 150 insures at least 1/8 TU
  799                  * 0xfffff is the max duration for bursting
  800                  * (implict by way of 16-bit data type for i_val)
  801                  */
  802                 if (!TDMA_SLOTLEN_VALID(ireq->i_val))
  803                         return EINVAL;
  804                 if (ireq->i_val != ts->tdma_slotlen) {
  805                         ts->tdma_slotlen = ireq->i_val;
  806                         goto restart;
  807                 }
  808                 break;
  809         case IEEE80211_IOC_TDMA_BINTERVAL:
  810                 if (!TDMA_BINTVAL_VALID(ireq->i_val))
  811                         return EINVAL;
  812                 if (ireq->i_val != ts->tdma_bintval) {
  813                         ts->tdma_bintval = ireq->i_val;
  814                         goto restart;
  815                 }
  816                 break;
  817         default:
  818                 return ENOSYS;
  819         }
  820         return 0;
  821 restart:
  822         ieee80211_beacon_notify(vap, IEEE80211_BEACON_TDMA);
  823         return ERESTART;
  824 }
  825 IEEE80211_IOCTL_SET(tdma, tdma_ioctl_set80211);
  826 
  827 #endif  /* IEEE80211_SUPPORT_TDMA */

Cache object: f3201b7489b4fb8ccca4ffe1bc52a99c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.