Lines Matching +full:local +full:- +full:bd +full:- +full:address +full:- +full:broken
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2004-2006
33 /*-
202 nitems(ipw_ident_table) - 1);
211 for (ident = ipw_ident_table; ident->name != NULL; ident++) {
212 if (pci_get_vendor(dev) == ident->vendor &&
213 pci_get_device(dev) == ident->device) {
214 device_set_desc(dev, ident->name);
221 /* Base Address Register */
226 struct ieee80211com *ic = &sc->sc_ic;
230 sc->sc_dev = dev;
232 mtx_init(&sc->sc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
234 mbufq_init(&sc->sc_snd, ifqmaxlen);
235 TASK_INIT(&sc->sc_init_task, 0, ipw_init_task, sc);
236 callout_init_mtx(&sc->sc_wdtimer, &sc->sc_mtx, 0);
240 /* enable bus-mastering */
244 sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &i, RF_ACTIVE);
245 if (sc->mem == NULL) {
250 sc->sc_st = rman_get_bustag(sc->mem);
251 sc->sc_sh = rman_get_bushandle(sc->mem);
254 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &i,
256 if (sc->irq == NULL) {
271 ic->ic_softc = sc;
272 ic->ic_name = device_get_nameunit(dev);
273 ic->ic_opmode = IEEE80211_M_STA;
274 ic->ic_phytype = IEEE80211_T_DS;
277 ic->ic_caps =
286 /* read MAC address from EEPROM */
288 ic->ic_macaddr[0] = val >> 8;
289 ic->ic_macaddr[1] = val & 0xff;
291 ic->ic_macaddr[2] = val >> 8;
292 ic->ic_macaddr[3] = val & 0xff;
294 ic->ic_macaddr[4] = val >> 8;
295 ic->ic_macaddr[5] = val & 0xff;
297 sc->chanmask = ipw_read_chanmask(sc);
298 ipw_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans,
299 ic->ic_channels);
303 sc->flags |= IPW_FLAG_HAS_RADIO_SWITCH;
306 ic->ic_scan_start = ipw_scan_start;
307 ic->ic_scan_end = ipw_scan_end;
308 ic->ic_getradiocaps = ipw_getradiocaps;
309 ic->ic_set_channel = ipw_set_channel;
310 ic->ic_scan_curchan = ipw_scan_curchan;
311 ic->ic_scan_mindwell = ipw_scan_mindwell;
312 ic->ic_raw_xmit = ipw_raw_xmit;
313 ic->ic_vap_create = ipw_vap_create;
314 ic->ic_vap_delete = ipw_vap_delete;
315 ic->ic_transmit = ipw_transmit;
316 ic->ic_parent = ipw_parent;
319 &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
321 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
341 error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE,
342 NULL, ipw_intr, sc, &sc->sc_ih);
355 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), sc->irq);
357 bus_release_resource(dev, SYS_RES_MEMORY, rman_get_rid(sc->mem),
358 sc->mem);
360 mtx_destroy(&sc->sc_mtx);
368 struct ieee80211com *ic = &sc->sc_ic;
370 bus_teardown_intr(dev, sc->irq, sc->sc_ih);
372 ieee80211_draintask(ic, &sc->sc_init_task);
377 callout_drain(&sc->sc_wdtimer);
378 mbufq_drain(&sc->sc_snd);
382 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), sc->irq);
384 bus_release_resource(dev, SYS_RES_MEMORY, rman_get_rid(sc->mem),
385 sc->mem);
387 if (sc->sc_firmware != NULL) {
388 firmware_put(sc->sc_firmware, FIRMWARE_UNLOAD);
389 sc->sc_firmware = NULL;
392 mtx_destroy(&sc->sc_mtx);
403 struct ipw_softc *sc = ic->ic_softc;
410 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */
429 * this unlocked is ok since we're single-threaded by the
432 if (sc->sc_firmware == NULL ||
433 strcmp(sc->sc_firmware->name, imagename) != 0) {
434 if (sc->sc_firmware != NULL)
435 firmware_put(sc->sc_firmware, FIRMWARE_UNLOAD);
436 sc->sc_firmware = firmware_get(imagename);
438 if (sc->sc_firmware == NULL) {
439 device_printf(sc->sc_dev,
443 fp = sc->sc_firmware;
444 if (fp->datasize < sizeof *hdr) {
445 device_printf(sc->sc_dev,
446 "firmware image too short %zu\n", fp->datasize);
447 firmware_put(sc->sc_firmware, FIRMWARE_UNLOAD);
448 sc->sc_firmware = NULL;
451 hdr = (const struct ipw_firmware_hdr *)fp->data;
452 if (fp->datasize < sizeof *hdr + le32toh(hdr->mainsz) +
453 le32toh(hdr->ucodesz)) {
454 device_printf(sc->sc_dev,
455 "firmware image too short %zu\n", fp->datasize);
456 firmware_put(sc->sc_firmware, FIRMWARE_UNLOAD);
457 sc->sc_firmware = NULL;
462 vap = &ivp->vap;
466 ivp->newstate = vap->iv_newstate;
467 vap->iv_newstate = ipw_newstate;
472 ic->ic_opmode = opmode;
497 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0,
500 BUS_SPACE_MAXSIZE_32BIT, 0, NULL, NULL, &sc->parent_dmat);
502 device_printf(sc->sc_dev, "could not create parent DMA tag\n");
509 error = bus_dma_tag_create(sc->parent_dmat, 4, 0, BUS_SPACE_MAXADDR_32BIT,
511 NULL, &sc->tbd_dmat);
513 device_printf(sc->sc_dev, "could not create tx ring DMA tag\n");
517 error = bus_dmamem_alloc(sc->tbd_dmat, (void **)&sc->tbd_list,
518 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &sc->tbd_map);
520 device_printf(sc->sc_dev,
525 error = bus_dmamap_load(sc->tbd_dmat, sc->tbd_map, sc->tbd_list,
526 IPW_TBD_SZ, ipw_dma_map_addr, &sc->tbd_phys, 0);
528 device_printf(sc->sc_dev, "could not map tx ring DMA memory\n");
535 error = bus_dma_tag_create(sc->parent_dmat, 4, 0, BUS_SPACE_MAXADDR_32BIT,
537 NULL, &sc->rbd_dmat);
539 device_printf(sc->sc_dev, "could not create rx ring DMA tag\n");
543 error = bus_dmamem_alloc(sc->rbd_dmat, (void **)&sc->rbd_list,
544 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &sc->rbd_map);
546 device_printf(sc->sc_dev,
551 error = bus_dmamap_load(sc->rbd_dmat, sc->rbd_map, sc->rbd_list,
552 IPW_RBD_SZ, ipw_dma_map_addr, &sc->rbd_phys, 0);
554 device_printf(sc->sc_dev, "could not map rx ring DMA memory\n");
561 error = bus_dma_tag_create(sc->parent_dmat, 4, 0, BUS_SPACE_MAXADDR_32BIT,
563 NULL, NULL, &sc->status_dmat);
565 device_printf(sc->sc_dev,
570 error = bus_dmamem_alloc(sc->status_dmat, (void **)&sc->status_list,
571 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &sc->status_map);
573 device_printf(sc->sc_dev,
578 error = bus_dmamap_load(sc->status_dmat, sc->status_map,
579 sc->status_list, IPW_STATUS_SZ, ipw_dma_map_addr, &sc->status_phys,
582 device_printf(sc->sc_dev,
590 error = bus_dma_tag_create(sc->parent_dmat, 1, 0, BUS_SPACE_MAXADDR_32BIT,
592 sizeof (struct ipw_cmd), 0, NULL, NULL, &sc->cmd_dmat);
594 device_printf(sc->sc_dev, "could not create command DMA tag\n");
598 error = bus_dmamap_create(sc->cmd_dmat, 0, &sc->cmd_map);
600 device_printf(sc->sc_dev,
608 error = bus_dma_tag_create(sc->parent_dmat, 1, 0, BUS_SPACE_MAXADDR_32BIT,
610 sizeof (struct ipw_hdr), 0, NULL, NULL, &sc->hdr_dmat);
612 device_printf(sc->sc_dev, "could not create header DMA tag\n");
616 SLIST_INIT(&sc->free_shdr);
618 shdr = &sc->shdr_list[i];
619 error = bus_dmamap_create(sc->hdr_dmat, 0, &shdr->map);
621 device_printf(sc->sc_dev,
625 SLIST_INSERT_HEAD(&sc->free_shdr, shdr, next);
631 error = bus_dma_tag_create(sc->parent_dmat, 1, 0, BUS_SPACE_MAXADDR_32BIT,
633 NULL, NULL, &sc->txbuf_dmat);
635 device_printf(sc->sc_dev, "could not create tx DMA tag\n");
639 SLIST_INIT(&sc->free_sbuf);
641 sbuf = &sc->tx_sbuf_list[i];
642 error = bus_dmamap_create(sc->txbuf_dmat, 0, &sbuf->map);
644 device_printf(sc->sc_dev,
648 SLIST_INSERT_HEAD(&sc->free_sbuf, sbuf, next);
655 sbd = &sc->stbd_list[i];
656 sbd->bd = &sc->tbd_list[i];
657 sbd->type = IPW_SBD_TYPE_NOASSOC;
661 * Pre-allocate rx buffers and DMA maps.
663 error = bus_dma_tag_create(sc->parent_dmat, 1, 0, BUS_SPACE_MAXADDR_32BIT,
665 NULL, &sc->rxbuf_dmat);
667 device_printf(sc->sc_dev, "could not create rx DMA tag\n");
672 sbd = &sc->srbd_list[i];
673 sbuf = &sc->rx_sbuf_list[i];
674 sbd->bd = &sc->rbd_list[i];
676 sbuf->m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
677 if (sbuf->m == NULL) {
678 device_printf(sc->sc_dev,
684 error = bus_dmamap_create(sc->rxbuf_dmat, 0, &sbuf->map);
686 device_printf(sc->sc_dev,
691 error = bus_dmamap_load(sc->rxbuf_dmat, sbuf->map,
692 mtod(sbuf->m, void *), MCLBYTES, ipw_dma_map_addr,
695 device_printf(sc->sc_dev,
700 sbd->type = IPW_SBD_TYPE_DATA;
701 sbd->priv = sbuf;
702 sbd->bd->physaddr = htole32(physaddr);
703 sbd->bd->len = htole32(MCLBYTES);
706 bus_dmamap_sync(sc->rbd_dmat, sc->rbd_map, BUS_DMASYNC_PREWRITE);
720 if (sc->parent_dmat != NULL) {
721 bus_dma_tag_destroy(sc->parent_dmat);
724 if (sc->tbd_dmat != NULL) {
725 bus_dmamap_unload(sc->tbd_dmat, sc->tbd_map);
726 bus_dmamem_free(sc->tbd_dmat, sc->tbd_list, sc->tbd_map);
727 bus_dma_tag_destroy(sc->tbd_dmat);
730 if (sc->rbd_dmat != NULL) {
731 if (sc->rbd_list != NULL) {
732 bus_dmamap_unload(sc->rbd_dmat, sc->rbd_map);
733 bus_dmamem_free(sc->rbd_dmat, sc->rbd_list,
734 sc->rbd_map);
736 bus_dma_tag_destroy(sc->rbd_dmat);
739 if (sc->status_dmat != NULL) {
740 if (sc->status_list != NULL) {
741 bus_dmamap_unload(sc->status_dmat, sc->status_map);
742 bus_dmamem_free(sc->status_dmat, sc->status_list,
743 sc->status_map);
745 bus_dma_tag_destroy(sc->status_dmat);
749 ipw_release_sbd(sc, &sc->stbd_list[i]);
751 if (sc->cmd_dmat != NULL) {
752 bus_dmamap_destroy(sc->cmd_dmat, sc->cmd_map);
753 bus_dma_tag_destroy(sc->cmd_dmat);
756 if (sc->hdr_dmat != NULL) {
758 bus_dmamap_destroy(sc->hdr_dmat, sc->shdr_list[i].map);
759 bus_dma_tag_destroy(sc->hdr_dmat);
762 if (sc->txbuf_dmat != NULL) {
764 bus_dmamap_destroy(sc->txbuf_dmat,
765 sc->tx_sbuf_list[i].map);
767 bus_dma_tag_destroy(sc->txbuf_dmat);
770 if (sc->rxbuf_dmat != NULL) {
772 sbuf = &sc->rx_sbuf_list[i];
773 if (sbuf->m != NULL) {
774 bus_dmamap_sync(sc->rxbuf_dmat, sbuf->map,
776 bus_dmamap_unload(sc->rxbuf_dmat, sbuf->map);
777 m_freem(sbuf->m);
779 bus_dmamap_destroy(sc->rxbuf_dmat, sbuf->map);
781 bus_dma_tag_destroy(sc->rxbuf_dmat);
799 struct ieee80211com *ic = &sc->sc_ic;
809 struct ieee80211com *ic = &sc->sc_ic;
837 struct ieee80211com *ic = vap->iv_ic;
838 struct ipw_softc *sc = ic->ic_softc;
841 vap->iv_bss->ni_txrate = ipw_cvtrate(
850 struct ieee80211com *ic = vap->iv_ic;
851 struct ipw_softc *sc = ic->ic_softc;
854 DPRINTF(("%s: %s -> %s flags 0x%x\n", __func__,
855 ieee80211_state_name[vap->iv_state],
856 ieee80211_state_name[nstate], sc->flags));
858 ostate = vap->iv_state;
863 if (ic->ic_opmode == IEEE80211_M_IBSS) {
866 * with a SCAN -> RUN transition on scan complete.
868 * join we are then called again with an AUTH -> RUN
878 if (sc->flags & IPW_FLAG_ASSOCIATED)
906 return ivp->newstate(vap, nstate, arg);
910 * Read 16 bits at address 'addr' from the serial EEPROM.
935 /* write address A7-A0 */
936 for (n = 7; n >= 0; n--) {
945 /* read data Q15-Q0 */
947 for (n = 15; n >= 0; n--) {
971 val = 0x7ff; /* default to channels 1-11 */
982 bus_dmamap_sync(sc->rxbuf_dmat, sbuf->map, BUS_DMASYNC_POSTREAD);
984 cmd = mtod(sbuf->m, struct ipw_cmd *);
987 ipw_cmdname(le32toh(cmd->type)), le32toh(cmd->type),
988 le32toh(cmd->subtype), le32toh(cmd->seq), le32toh(cmd->len),
989 le32toh(cmd->status)));
991 sc->flags &= ~IPW_FLAG_BUSY;
998 #define IEEESTATE(vap) ieee80211_state_name[vap->iv_state]
999 struct ieee80211com *ic = &sc->sc_ic;
1000 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
1003 bus_dmamap_sync(sc->rxbuf_dmat, sbuf->map, BUS_DMASYNC_POSTREAD);
1005 state = le32toh(*mtod(sbuf->m, uint32_t *));
1010 IEEESTATE(vap), sc->flags));
1011 /* XXX suppress state change in case the fw auto-associates */
1012 if ((sc->flags & IPW_FLAG_ASSOCIATING) == 0) {
1014 IEEESTATE(vap), sc->flags));
1017 sc->flags &= ~IPW_FLAG_ASSOCIATING;
1018 sc->flags |= IPW_FLAG_ASSOCIATED;
1023 IEEESTATE(vap), sc->flags));
1030 if (sc->flags & IPW_FLAG_ASSOCIATED) {
1047 IEEESTATE(vap), sc->flags));
1048 if (sc->flags & IPW_FLAG_HACK) {
1049 sc->flags &= ~IPW_FLAG_HACK;
1052 if (sc->flags & IPW_FLAG_SCANNING) {
1056 sc->flags &= ~IPW_FLAG_SCANNING;
1057 sc->sc_scan_timer = 0;
1063 IEEESTATE(vap), sc->flags));
1064 sc->flags &= ~(IPW_FLAG_ASSOCIATING | IPW_FLAG_ASSOCIATED);
1065 if (vap->iv_state == IEEE80211_S_RUN) {
1067 ieee80211_new_state(vap, IEEE80211_S_SCAN, -1);
1074 sc->flags &= ~(IPW_FLAG_HACK | IPW_FLAG_SCANNING |
1077 IEEESTATE(vap), sc->flags));
1081 device_printf(sc->sc_dev, "radio turned off\n");
1089 __func__, state, IEEESTATE(vap), sc->flags));
1101 struct ieee80211com *ic = &sc->sc_ic;
1103 ic->ic_curchan = chan;
1114 struct ieee80211com *ic = &sc->sc_ic;
1125 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
1133 efrm = mtod(m, uint8_t *) + m->m_len;
1147 c = &ic->ic_channels[0];
1159 struct ieee80211com *ic = &sc->sc_ic;
1166 DPRINTFN(5, ("received frame len=%u, rssi=%u\n", le32toh(status->len),
1167 status->rssi));
1169 if (le32toh(status->len) < sizeof (struct ieee80211_frame_min) ||
1170 le32toh(status->len) > MCLBYTES)
1181 counter_u64_add(ic->ic_ierrors, 1);
1185 bus_dmamap_sync(sc->rxbuf_dmat, sbuf->map, BUS_DMASYNC_POSTREAD);
1186 bus_dmamap_unload(sc->rxbuf_dmat, sbuf->map);
1188 error = bus_dmamap_load(sc->rxbuf_dmat, sbuf->map, mtod(mnew, void *),
1194 error = bus_dmamap_load(sc->rxbuf_dmat, sbuf->map,
1195 mtod(sbuf->m, void *), MCLBYTES, ipw_dma_map_addr,
1200 device_get_name(sc->sc_dev));
1202 counter_u64_add(ic->ic_ierrors, 1);
1210 m = sbuf->m;
1211 sbuf->m = mnew;
1212 sbd->bd->physaddr = htole32(physaddr);
1213 m->m_pkthdr.len = m->m_len = le32toh(status->len);
1215 rssi = status->rssi + IPW_RSSI_TO_DBM;
1216 nf = -95;
1218 struct ipw_rx_radiotap_header *tap = &sc->sc_rxtap;
1220 tap->wr_flags = 0;
1221 tap->wr_antsignal = rssi;
1222 tap->wr_antnoise = nf;
1225 if (sc->flags & IPW_FLAG_SCANNING)
1231 (void) ieee80211_input(ni, m, rssi - nf, nf);
1234 (void) ieee80211_input_all(ic, m, rssi - nf, nf);
1237 bus_dmamap_sync(sc->rbd_dmat, sc->rbd_map, BUS_DMASYNC_PREWRITE);
1248 if (!(sc->flags & IPW_FLAG_FW_INITED))
1253 bus_dmamap_sync(sc->status_dmat, sc->status_map, BUS_DMASYNC_POSTREAD);
1255 for (i = (sc->rxcur + 1) % IPW_NRBD; i != r; i = (i + 1) % IPW_NRBD) {
1256 status = &sc->status_list[i];
1257 sbd = &sc->srbd_list[i];
1258 sbuf = sbd->priv;
1260 switch (le16toh(status->code) & 0xf) {
1276 le32toh(status->len), status->flags));
1277 /* XXX maybe drive state machine AUTH->ASSOC? */
1281 device_printf(sc->sc_dev, "unexpected status code %u\n",
1282 le16toh(status->code));
1286 if (!(sc->flags & IPW_FLAG_FW_INITED))
1289 sbd->bd->flags = 0;
1292 bus_dmamap_sync(sc->rbd_dmat, sc->rbd_map, BUS_DMASYNC_PREWRITE);
1295 sc->rxcur = (r == 0) ? IPW_NRBD - 1 : r - 1;
1296 CSR_WRITE_4(sc, IPW_CSR_RX_WRITE, sc->rxcur);
1305 switch (sbd->type) {
1307 bus_dmamap_sync(sc->cmd_dmat, sc->cmd_map,
1309 bus_dmamap_unload(sc->cmd_dmat, sc->cmd_map);
1313 shdr = sbd->priv;
1314 bus_dmamap_sync(sc->hdr_dmat, shdr->map, BUS_DMASYNC_POSTWRITE);
1315 bus_dmamap_unload(sc->hdr_dmat, shdr->map);
1316 SLIST_INSERT_HEAD(&sc->free_shdr, shdr, next);
1320 sbuf = sbd->priv;
1321 bus_dmamap_sync(sc->txbuf_dmat, sbuf->map,
1323 bus_dmamap_unload(sc->txbuf_dmat, sbuf->map);
1324 SLIST_INSERT_HEAD(&sc->free_sbuf, sbuf, next);
1326 ieee80211_tx_complete(sbuf->ni, sbuf->m, 0/*XXX*/);
1328 sc->sc_tx_timer = 0;
1332 sbd->type = IPW_SBD_TYPE_NOASSOC;
1341 if (!(sc->flags & IPW_FLAG_FW_INITED))
1346 for (i = (sc->txold + 1) % IPW_NTBD; i != r; i = (i + 1) % IPW_NTBD) {
1347 sbd = &sc->stbd_list[i];
1349 sc->txfree++;
1353 sc->txold = (r == 0) ? IPW_NTBD - 1 : r - 1;
1361 struct ieee80211com *ic = &sc->sc_ic;
1362 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
1364 device_printf(sc->sc_dev, "firmware error\n");
1370 ieee80211_runtask(ic, &sc->sc_init_task);
1405 /* re-enable interrupts */
1480 if (sc->flags & IPW_FLAG_BUSY) {
1481 device_printf(sc->sc_dev, "%s: %s not sent, busy\n",
1485 sc->flags |= IPW_FLAG_BUSY;
1487 sbd = &sc->stbd_list[sc->txcur];
1489 error = bus_dmamap_load(sc->cmd_dmat, sc->cmd_map, &sc->cmd,
1492 device_printf(sc->sc_dev, "could not map command DMA memory\n");
1493 sc->flags &= ~IPW_FLAG_BUSY;
1497 sc->cmd.type = htole32(type);
1498 sc->cmd.subtype = 0;
1499 sc->cmd.len = htole32(len);
1500 sc->cmd.seq = 0;
1501 memcpy(sc->cmd.data, data, len);
1503 sbd->type = IPW_SBD_TYPE_COMMAND;
1504 sbd->bd->physaddr = htole32(physaddr);
1505 sbd->bd->len = htole32(sizeof (struct ipw_cmd));
1506 sbd->bd->nfrag = 1;
1507 sbd->bd->flags = IPW_BD_FLAG_TX_FRAME_COMMAND |
1510 bus_dmamap_sync(sc->cmd_dmat, sc->cmd_map, BUS_DMASYNC_PREWRITE);
1511 bus_dmamap_sync(sc->tbd_dmat, sc->tbd_map, BUS_DMASYNC_PREWRITE);
1521 printf("%1D", (u_char *)data + len - i, "");
1528 sc->txfree--;
1529 sc->txcur = (sc->txcur + 1) % IPW_NTBD;
1530 CSR_WRITE_4(sc, IPW_CSR_TX_WRITE, sc->txcur);
1533 error = msleep(sc, &sc->sc_mtx, 0, "ipwcmd", hz);
1535 device_printf(sc->sc_dev, "%s: %s failed, timeout (error %u)\n",
1537 sc->flags &= ~IPW_FLAG_BUSY;
1546 struct ieee80211com *ic = &sc->sc_ic;
1547 struct ieee80211vap *vap = ni->ni_vap;
1560 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
1566 /* packet header may have moved, reset our local pointer */
1571 struct ipw_tx_radiotap_header *tap = &sc->sc_txtap;
1573 tap->wt_flags = 0;
1578 shdr = SLIST_FIRST(&sc->free_shdr);
1579 sbuf = SLIST_FIRST(&sc->free_sbuf);
1582 shdr->hdr.type = htole32(IPW_HDR_TYPE_SEND);
1583 shdr->hdr.subtype = 0;
1584 shdr->hdr.encrypted = (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) ? 1 : 0;
1585 shdr->hdr.encrypt = 0;
1586 shdr->hdr.keyidx = 0;
1587 shdr->hdr.keysz = 0;
1588 shdr->hdr.fragmentsz = 0;
1589 IEEE80211_ADDR_COPY(shdr->hdr.src_addr, wh->i_addr2);
1590 if (ic->ic_opmode == IEEE80211_M_STA)
1591 IEEE80211_ADDR_COPY(shdr->hdr.dst_addr, wh->i_addr3);
1593 IEEE80211_ADDR_COPY(shdr->hdr.dst_addr, wh->i_addr1);
1598 error = bus_dmamap_load_mbuf_sg(sc->txbuf_dmat, sbuf->map, m0, segs,
1601 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
1609 device_printf(sc->sc_dev,
1616 error = bus_dmamap_load_mbuf_sg(sc->txbuf_dmat, sbuf->map, m0,
1619 device_printf(sc->sc_dev,
1626 error = bus_dmamap_load(sc->hdr_dmat, shdr->map, &shdr->hdr,
1629 device_printf(sc->sc_dev, "could not map header DMA memory\n");
1630 bus_dmamap_unload(sc->txbuf_dmat, sbuf->map);
1635 SLIST_REMOVE_HEAD(&sc->free_sbuf, next);
1636 SLIST_REMOVE_HEAD(&sc->free_shdr, next);
1638 sbd = &sc->stbd_list[sc->txcur];
1639 sbd->type = IPW_SBD_TYPE_HEADER;
1640 sbd->priv = shdr;
1641 sbd->bd->physaddr = htole32(physaddr);
1642 sbd->bd->len = htole32(sizeof (struct ipw_hdr));
1643 sbd->bd->nfrag = 1 + nsegs;
1644 sbd->bd->flags = IPW_BD_FLAG_TX_FRAME_802_3 |
1648 shdr->hdr.type, shdr->hdr.subtype, shdr->hdr.encrypted,
1649 shdr->hdr.encrypt, shdr->hdr.src_addr, ":", shdr->hdr.dst_addr,
1652 sc->txfree--;
1653 sc->txcur = (sc->txcur + 1) % IPW_NTBD;
1655 sbuf->m = m0;
1656 sbuf->ni = ni;
1659 sbd = &sc->stbd_list[sc->txcur];
1661 sbd->bd->physaddr = htole32(segs[i].ds_addr);
1662 sbd->bd->len = htole32(segs[i].ds_len);
1663 sbd->bd->nfrag = 0;
1664 sbd->bd->flags = IPW_BD_FLAG_TX_FRAME_802_3;
1665 if (i == nsegs - 1) {
1666 sbd->type = IPW_SBD_TYPE_DATA;
1667 sbd->priv = sbuf;
1668 sbd->bd->flags |= IPW_BD_FLAG_TX_LAST_FRAGMENT;
1670 sbd->type = IPW_SBD_TYPE_NOASSOC;
1671 sbd->bd->flags |= IPW_BD_FLAG_TX_NOT_LAST_FRAGMENT;
1676 sc->txfree--;
1677 sc->txcur = (sc->txcur + 1) % IPW_NTBD;
1680 bus_dmamap_sync(sc->hdr_dmat, shdr->map, BUS_DMASYNC_PREWRITE);
1681 bus_dmamap_sync(sc->txbuf_dmat, sbuf->map, BUS_DMASYNC_PREWRITE);
1682 bus_dmamap_sync(sc->tbd_dmat, sc->tbd_map, BUS_DMASYNC_PREWRITE);
1685 CSR_WRITE_4(sc, IPW_CSR_TX_WRITE, sc->txcur);
1703 struct ipw_softc *sc = ic->ic_softc;
1707 if ((sc->flags & IPW_FLAG_RUNNING) == 0) {
1711 error = mbufq_enqueue(&sc->sc_snd, m);
1729 while (sc->txfree >= 1 + IPW_MAX_NSEG &&
1730 (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
1731 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1733 if_inc_counter(ni->ni_vap->iv_ifp,
1739 sc->sc_tx_timer = 5;
1747 struct ieee80211com *ic = &sc->sc_ic;
1751 if (sc->sc_tx_timer > 0) {
1752 if (--sc->sc_tx_timer == 0) {
1753 device_printf(sc->sc_dev, "device timeout\n");
1754 counter_u64_add(ic->ic_oerrors, 1);
1755 taskqueue_enqueue(taskqueue_swi, &sc->sc_init_task);
1758 if (sc->sc_scan_timer > 0) {
1759 if (--sc->sc_scan_timer == 0) {
1762 if (sc->flags & IPW_FLAG_SCANNING) {
1764 ieee80211_scan_done(TAILQ_FIRST(&ic->ic_vaps));
1766 sc->flags &= ~IPW_FLAG_SCANNING;
1770 if (sc->flags & IPW_FLAG_RUNNING)
1771 callout_reset(&sc->sc_wdtimer, hz, ipw_watchdog, sc);
1777 struct ipw_softc *sc = ic->ic_softc;
1781 if (ic->ic_nrunning > 0) {
1782 if (!(sc->flags & IPW_FLAG_RUNNING)) {
1786 } else if (sc->flags & IPW_FLAG_RUNNING)
1809 device_printf(sc->sc_dev, "timeout waiting for master\n");
1815 sc->flags &= IPW_FLAG_HAS_RADIO_SWITCH;
1859 error = msleep(sc, &sc->sc_mtx, PCATCH, __func__, ms);
1873 if ((sc->flags & IPW_FLAG_ENABLED) == 0) {
1881 sc->flags |= IPW_FLAG_ENABLED;
1891 if (sc->flags & IPW_FLAG_ENABLED) {
1899 sc->flags &= ~IPW_FLAG_ENABLED;
1946 device_printf(sc->sc_dev,
1990 if ((error = msleep(sc, &sc->sc_mtx, 0, "ipwinit", hz)) != 0) {
1991 device_printf(sc->sc_dev, "timeout waiting for firmware "
2006 struct ieee80211com *ic = &sc->sc_ic;
2007 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2013 wk = &vap->iv_nw_keys[i];
2015 if (wk->wk_cipher == NULL ||
2016 wk->wk_cipher->ic_cipher != IEEE80211_CIPHER_WEP)
2020 wepkey.len = wk->wk_keylen;
2022 memcpy(wepkey.key, wk->wk_key, wk->wk_keylen);
2106 DPRINTF(("%s: flags 0x%x\n", __func__, sc->flags));
2108 if (sc->flags & IPW_FLAG_SCANNING)
2110 sc->flags |= IPW_FLAG_SCANNING | IPW_FLAG_HACK;
2120 * associate'' option bit is broken (sigh).
2128 * if so just re-enable it to kick off scanning.
2131 sc->sc_scan_timer = 3;
2132 if (sc->flags & IPW_FLAG_ENABLED) {
2141 sc->flags &= ~(IPW_FLAG_SCANNING | IPW_FLAG_HACK);
2149 struct ieee80211com *ic = &sc->sc_ic;
2164 struct ipw_softc *sc = ic->ic_softc;
2165 struct ieee80211_node *ni = vap->iv_bss;
2176 security.authmode = (ni->ni_authmode == IEEE80211_AUTH_SHARED) ?
2185 data = htole32(vap->iv_rtsthreshold);
2191 data = htole32(vap->iv_fragthreshold);
2197 if (vap->iv_flags & IEEE80211_F_PRIVACY) {
2202 if (vap->iv_def_txkey != IEEE80211_KEYIX_NONE) {
2203 data = htole32(vap->iv_def_txkey);
2213 data = htole32((vap->iv_flags & IEEE80211_F_PRIVACY) ? IPW_WEPON : 0);
2219 error = ipw_setssid(sc, ni->ni_essid, ni->ni_esslen);
2223 error = ipw_setbssid(sc, ni->ni_bssid);
2227 if (vap->iv_appie_wpa != NULL) {
2228 struct ieee80211_appie *ie = vap->iv_appie_wpa;
2229 error = ipw_setwpaie(sc, ie->ie_data, ie->ie_len);
2233 if (ic->ic_opmode == IEEE80211_M_IBSS) {
2234 error = ipw_setchannel(sc, ni->ni_chan);
2241 1<<(ieee80211_chan2ieee(ic, ni->ni_chan)-1), 0);
2247 sc->flags |= IPW_FLAG_ASSOCIATING;
2255 struct ieee80211_node *ni = vap->iv_bss;
2256 struct ipw_softc *sc = ic->ic_softc;
2259 DPRINTF(("Disassociate from %6D\n", ni->ni_bssid, ":"));
2264 if (sc->flags & IPW_FLAG_FW_INITED) {
2265 sc->flags &= ~IPW_FLAG_ASSOCIATED;
2271 ni->ni_bssid, IEEE80211_ADDR_LEN);
2290 struct ieee80211com *ic = &sc->sc_ic;
2296 if (sc->flags & IPW_FLAG_RUNNING)
2303 struct ieee80211com *ic = &sc->sc_ic;
2304 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2312 ieee80211_state_name[vap->iv_state], sc->flags));
2315 * Avoid re-entrant calls. We need to release the mutex in ipw_init()
2319 if (sc->flags & IPW_FLAG_INIT_LOCKED)
2321 sc->flags |= IPW_FLAG_INIT_LOCKED;
2326 device_printf(sc->sc_dev, "could not reset adapter\n");
2330 if (sc->sc_firmware == NULL) {
2331 device_printf(sc->sc_dev, "no firmware\n");
2335 fp = sc->sc_firmware;
2336 hdr = (const struct ipw_firmware_hdr *)fp->data;
2338 DPRINTF(("Loading firmware image '%s'\n", fp->name));
2339 fw = (const char *)fp->data + sizeof *hdr + le32toh(hdr->mainsz);
2340 if (ipw_load_ucode(sc, fw, le32toh(hdr->ucodesz)) != 0) {
2341 device_printf(sc->sc_dev, "could not load microcode\n");
2350 sc->txold = IPW_NTBD - 1;
2351 sc->txcur = 0;
2352 sc->txfree = IPW_NTBD - 2;
2353 sc->rxcur = IPW_NRBD - 1;
2355 CSR_WRITE_4(sc, IPW_CSR_TX_BASE, sc->tbd_phys);
2358 CSR_WRITE_4(sc, IPW_CSR_TX_WRITE, sc->txcur);
2360 CSR_WRITE_4(sc, IPW_CSR_RX_BASE, sc->rbd_phys);
2363 CSR_WRITE_4(sc, IPW_CSR_RX_WRITE, sc->rxcur);
2365 CSR_WRITE_4(sc, IPW_CSR_STATUS_BASE, sc->status_phys);
2367 fw = (const char *)fp->data + sizeof *hdr;
2368 if (ipw_load_firmware(sc, fw, le32toh(hdr->mainsz)) != 0) {
2369 device_printf(sc->sc_dev, "could not load firmware\n");
2373 sc->flags |= IPW_FLAG_FW_INITED;
2376 sc->table1_base = CSR_READ_4(sc, IPW_CSR_TABLE1_BASE);
2377 sc->table2_base = CSR_READ_4(sc, IPW_CSR_TABLE2_BASE);
2382 device_printf(sc->sc_dev, "device configuration failed\n");
2386 callout_reset(&sc->sc_wdtimer, hz, ipw_watchdog, sc);
2387 sc->flags |= IPW_FLAG_RUNNING;
2388 sc->flags &= ~IPW_FLAG_INIT_LOCKED;
2393 sc->flags &= ~IPW_FLAG_INIT_LOCKED;
2399 struct ieee80211com *ic = &sc->sc_ic;
2408 switch (ic->ic_opmode) {
2422 device_printf(sc->sc_dev, "unknown opmode %d\n", ic->ic_opmode);
2430 if (ic->ic_opmode == IEEE80211_M_IBSS ||
2431 ic->ic_opmode == IEEE80211_M_MONITOR) {
2432 error = ipw_setchannel(sc, ic->ic_curchan);
2437 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2442 if (ic->ic_opmode == IEEE80211_M_IBSS)
2444 if (ic->ic_promisc > 0)
2446 config.bss_chan = htole32(0x3fff); /* channels 1-14 */
2447 config.ibss_chan = htole32(0x7ff); /* channels 1-11 */
2477 if (ic->ic_opmode == IEEE80211_M_IBSS) {
2506 callout_stop(&sc->sc_wdtimer);
2515 ipw_release_sbd(sc, &sc->stbd_list[i]);
2517 sc->sc_tx_timer = 0;
2518 sc->flags &= ~IPW_FLAG_RUNNING;
2529 if (!(sc->flags & IPW_FLAG_FW_INITED))
2532 CSR_WRITE_4(sc, IPW_CSR_AUTOINC_ADDR, sc->table1_base);
2547 val = !((sc->flags & IPW_FLAG_HAS_RADIO_SWITCH) &&
2556 return MEM_READ_4(sc, MEM_READ_4(sc, sc->table1_base + off));
2562 MEM_WRITE_4(sc, MEM_READ_4(sc, sc->table1_base + off), info);
2574 addr = MEM_READ_4(sc, sc->table2_base + off);
2575 info = MEM_READ_4(sc, sc->table2_base + off + 4);
2596 for (; count > 0; offset++, datap++, count--) {
2607 for (; count > 0; offset++, datap++, count--) {
2616 struct ipw_softc *sc = ic->ic_softc;
2627 struct ipw_softc *sc = ic->ic_softc;
2635 if (sc->chanmask & (1 << i)) {
2646 struct ipw_softc *sc = ic->ic_softc;
2649 if (ic->ic_opmode == IEEE80211_M_MONITOR) {
2651 ipw_setchannel(sc, ic->ic_curchan);
2672 struct ipw_softc *sc = ic->ic_softc;
2675 sc->flags &= ~IPW_FLAG_SCANNING;