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