sys/net80211/ieee80211_tdma.c

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