[BACK]Return to bwfm.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / ic

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/ic/bwfm.c between version 1.14 and 1.14.6.1

version 1.14, 2018/09/02 19:46:53 version 1.14.6.1, 2020/02/25 18:40:43
Line 112  int  bwfm_fwvar_var_set_int(struct bwfm_
Line 112  int  bwfm_fwvar_var_set_int(struct bwfm_
 struct ieee80211_channel *bwfm_bss2chan(struct bwfm_softc *, struct bwfm_bss_info *);  struct ieee80211_channel *bwfm_bss2chan(struct bwfm_softc *, struct bwfm_bss_info *);
 void     bwfm_scan(struct bwfm_softc *);  void     bwfm_scan(struct bwfm_softc *);
 void     bwfm_connect(struct bwfm_softc *);  void     bwfm_connect(struct bwfm_softc *);
   void     bwfm_get_sta_info(struct bwfm_softc *, struct ifmediareq *);
   
 void     bwfm_rx(struct bwfm_softc *, struct mbuf *);  void     bwfm_rx(struct bwfm_softc *, struct mbuf *);
 void     bwfm_rx_event(struct bwfm_softc *, char *, size_t);  void     bwfm_rx_event(struct bwfm_softc *, struct mbuf *);
   void     bwfm_rx_event_cb(struct bwfm_softc *, struct mbuf *);
 void     bwfm_scan_node(struct bwfm_softc *, struct bwfm_bss_info *, size_t);  void     bwfm_scan_node(struct bwfm_softc *, struct bwfm_bss_info *, size_t);
   
 uint8_t bwfm_2ghz_channels[] = {  uint8_t bwfm_2ghz_channels[] = {
Line 304  bwfm_start(struct ifnet *ifp)
Line 306  bwfm_start(struct ifnet *ifp)
         /* TODO: return if no link? */          /* TODO: return if no link? */
   
         for (;;) {          for (;;) {
                 struct ieee80211_node *ni;  
                 struct ether_header *eh;  
   
                 /* Discard management packets (fw handles this for us) */                  /* Discard management packets (fw handles this for us) */
                 IF_DEQUEUE(&ic->ic_mgtq, m);                  IF_DEQUEUE(&ic->ic_mgtq, m);
                 if (m != NULL) {                  if (m != NULL) {
Line 323  bwfm_start(struct ifnet *ifp)
Line 322  bwfm_start(struct ifnet *ifp)
                 if (m == NULL)                  if (m == NULL)
                         break;                          break;
   
                 eh = mtod(m, struct ether_header *);  
                 ni = ieee80211_find_txnode(ic, eh->ether_dhost);  
                 if (ni == NULL) {  
                         ifp->if_oerrors++;  
                         m_freem(m);  
                         continue;  
                 }  
   
                 if (ieee80211_classify(ic, m, ni) != 0) {  
                         ifp->if_oerrors++;  
                         m_freem(m);  
                         ieee80211_free_node(ni);  
                         continue;  
                 }  
   
                 error = sc->sc_bus_ops->bs_txdata(sc, &m);                  error = sc->sc_bus_ops->bs_txdata(sc, &m);
                 if (error == ENOBUFS) {                  if (error == ENOBUFS) {
                         IF_PREPEND(&ifp->if_snd, m);                          IF_PREPEND(&ifp->if_snd, m);
                         ifp->if_flags |= IFF_OACTIVE;                          ifp->if_flags |= IFF_OACTIVE;
                         break;                          break;
                 }                  }
   
                 if (error != 0) {                  if (error != 0) {
                         ifp->if_oerrors++;                          ifp->if_oerrors++;
                         m_freem(m);                          m_freem(m);
                         if (ni != NULL)                          continue;
                                 ieee80211_free_node(ni);  
                 } else {  
                         bpf_mtap3(ic->ic_rawbpf, m, BPF_D_OUT);  
                 }                  }
   
                   bpf_mtap(ifp, m, BPF_D_OUT);
         }          }
 }  }
   
Line 363  bwfm_init(struct ifnet *ifp)
Line 345  bwfm_init(struct ifnet *ifp)
         struct ieee80211com *ic = &sc->sc_ic;          struct ieee80211com *ic = &sc->sc_ic;
         uint8_t evmask[BWFM_EVENT_MASK_LEN];          uint8_t evmask[BWFM_EVENT_MASK_LEN];
         struct bwfm_join_pref_params join_pref[2];          struct bwfm_join_pref_params join_pref[2];
           int pm;
   
         if (bwfm_fwvar_var_set_int(sc, "mpc", 1)) {          if (bwfm_fwvar_var_set_int(sc, "mpc", 1)) {
                 printf("%s: could not set mpc\n", DEVNAME(sc));                  printf("%s: could not set mpc\n", DEVNAME(sc));
Line 388  bwfm_init(struct ifnet *ifp)
Line 371  bwfm_init(struct ifnet *ifp)
   
 #define ENABLE_EVENT(e)         evmask[(e) / 8] |= 1 << ((e) % 8)  #define ENABLE_EVENT(e)         evmask[(e) / 8] |= 1 << ((e) % 8)
         /* Events used to drive the state machine */          /* Events used to drive the state machine */
         ENABLE_EVENT(BWFM_E_ASSOC);          switch (ic->ic_opmode) {
         ENABLE_EVENT(BWFM_E_ESCAN_RESULT);          case IEEE80211_M_STA:
         ENABLE_EVENT(BWFM_E_SET_SSID);                  ENABLE_EVENT(BWFM_E_IF);
         ENABLE_EVENT(BWFM_E_LINK);                  ENABLE_EVENT(BWFM_E_LINK);
                   ENABLE_EVENT(BWFM_E_AUTH);
                   ENABLE_EVENT(BWFM_E_ASSOC);
                   ENABLE_EVENT(BWFM_E_DEAUTH);
                   ENABLE_EVENT(BWFM_E_DISASSOC);
                   ENABLE_EVENT(BWFM_E_SET_SSID);
                   ENABLE_EVENT(BWFM_E_ESCAN_RESULT);
                   break;
   #ifndef IEEE80211_STA_ONLY
           case IEEE80211_M_HOSTAP:
                   ENABLE_EVENT(BWFM_E_AUTH_IND);
                   ENABLE_EVENT(BWFM_E_ASSOC_IND);
                   ENABLE_EVENT(BWFM_E_REASSOC_IND);
                   ENABLE_EVENT(BWFM_E_DEAUTH_IND);
                   ENABLE_EVENT(BWFM_E_DISASSOC_IND);
                   ENABLE_EVENT(BWFM_E_ESCAN_RESULT);
                   ENABLE_EVENT(BWFM_E_ESCAN_RESULT);
                   break;
   #endif
           default:
                   break;
           }
 #undef  ENABLE_EVENT  #undef  ENABLE_EVENT
   
 #ifdef BWFM_DEBUG  #ifdef BWFM_DEBUG
Line 419  bwfm_init(struct ifnet *ifp)
Line 423  bwfm_init(struct ifnet *ifp)
                 return EIO;                  return EIO;
         }          }
   
         if (bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_PM, 2)) {          /*
            * Use CAM (constantly awake) when we are running as AP
            * otherwise use fast power saving.
            */
           pm = BWFM_PM_FAST_PS;
   #ifndef IEEE80211_STA_ONLY
           if (ic->ic_opmode == IEEE80211_M_HOSTAP)
                   pm = BWFM_PM_CAM;
   #endif
           if (bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_PM, pm)) {
                 printf("%s: could not set power\n", DEVNAME(sc));                  printf("%s: could not set power\n", DEVNAME(sc));
                 return EIO;                  return EIO;
         }          }
Line 466  bwfm_stop(struct ifnet *ifp, int disable
Line 479  bwfm_stop(struct ifnet *ifp, int disable
 {  {
         struct bwfm_softc *sc = ifp->if_softc;          struct bwfm_softc *sc = ifp->if_softc;
         struct ieee80211com *ic = &sc->sc_ic;          struct ieee80211com *ic = &sc->sc_ic;
           struct bwfm_join_params join;
   
         sc->sc_tx_timer = 0;          sc->sc_tx_timer = 0;
         ifp->if_timer = 0;          ifp->if_timer = 0;
         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);          ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
   
           memset(&join, 0, sizeof(join));
           bwfm_fwvar_cmd_set_data(sc, BWFM_C_SET_SSID, &join, sizeof(join));
         bwfm_fwvar_cmd_set_int(sc, BWFM_C_DOWN, 1);          bwfm_fwvar_cmd_set_int(sc, BWFM_C_DOWN, 1);
         bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_PM, 0);          bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_PM, 0);
           bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_AP, 0);
           bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_INFRA, 0);
           bwfm_fwvar_cmd_set_int(sc, BWFM_C_UP, 1);
           bwfm_fwvar_cmd_set_int(sc, BWFM_C_SET_PM, BWFM_PM_FAST_PS);
   
         ieee80211_new_state(ic, IEEE80211_S_INIT, -1);          ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
   
           if (sc->sc_bus_ops->bs_stop)
                   sc->sc_bus_ops->bs_stop(sc);
 }  }
   
 void  void
Line 531  bwfm_ioctl(struct ifnet *ifp, u_long cmd
Line 554  bwfm_ioctl(struct ifnet *ifp, u_long cmd
                 }                  }
                 break;                  break;
   
           case SIOCGIFMEDIA:
                   error = ieee80211_ioctl(ic, cmd, data);
                   if (error == 0 && ic->ic_state == IEEE80211_S_RUN)
                           bwfm_get_sta_info(sc, (struct ifmediareq *)data);
                   break;
   
         default:          default:
                 error = ieee80211_ioctl(ic, cmd, data);                  error = ieee80211_ioctl(ic, cmd, data);
         }          }
Line 618  bwfm_key_set_cb(struct bwfm_softc *sc, s
Line 647  bwfm_key_set_cb(struct bwfm_softc *sc, s
         wsec_key.len = htole32(wk->wk_keylen);          wsec_key.len = htole32(wk->wk_keylen);
         memcpy(wsec_key.data, wk->wk_key, sizeof(wsec_key.data));          memcpy(wsec_key.data, wk->wk_key, sizeof(wsec_key.data));
         if (!ext_key)          if (!ext_key)
                 wsec_key.flags = htole32(BWFM_PRIMARY_KEY);                  wsec_key.flags = htole32(BWFM_WSEC_PRIMARY_KEY);
   
         switch (wk->wk_cipher->ic_cipher) {          switch (wk->wk_cipher->ic_cipher) {
         case IEEE80211_CIPHER_WEP:          case IEEE80211_CIPHER_WEP:
Line 682  bwfm_key_delete_cb(struct bwfm_softc *sc
Line 711  bwfm_key_delete_cb(struct bwfm_softc *sc
   
         memset(&wsec_key, 0, sizeof(wsec_key));          memset(&wsec_key, 0, sizeof(wsec_key));
         wsec_key.index = htole32(wk->wk_keyix);          wsec_key.index = htole32(wk->wk_keyix);
         wsec_key.flags = htole32(BWFM_PRIMARY_KEY);          wsec_key.flags = htole32(BWFM_WSEC_PRIMARY_KEY);
   
         if (bwfm_fwvar_var_set_data(sc, "wsec_key", &wsec_key, sizeof(wsec_key)))          if (bwfm_fwvar_var_set_data(sc, "wsec_key", &wsec_key, sizeof(wsec_key)))
                 return;                  return;
Line 770  bwfm_task(struct work *wk, void *arg)
Line 799  bwfm_task(struct work *wk, void *arg)
         case BWFM_TASK_KEY_DELETE:          case BWFM_TASK_KEY_DELETE:
                 bwfm_key_delete_cb(sc, &t->t_key);                  bwfm_key_delete_cb(sc, &t->t_key);
                 break;                  break;
           case BWFM_TASK_RX_EVENT:
                   bwfm_rx_event_cb(sc, t->t_mbuf);
                   break;
         default:          default:
                 panic("bwfm: unknown task command %d", t->t_cmd);                  panic("bwfm: unknown task command %d", t->t_cmd);
         }          }
Line 1261  bwfm_chip_cm3_set_passive(struct bwfm_so
Line 1293  bwfm_chip_cm3_set_passive(struct bwfm_so
         }          }
 }  }
   
   int
   bwfm_chip_sr_capable(struct bwfm_softc *sc)
   {
           struct bwfm_core *core;
           uint32_t reg;
   
           if (sc->sc_chip.ch_pmurev < 17)
                   return 0;
   
           switch (sc->sc_chip.ch_chip) {
           case BRCM_CC_4345_CHIP_ID:
           case BRCM_CC_4354_CHIP_ID:
           case BRCM_CC_4356_CHIP_ID:
                   core = bwfm_chip_get_pmu(sc);
                   sc->sc_buscore_ops->bc_write(sc, core->co_base +
                       BWFM_CHIP_REG_CHIPCONTROL_ADDR, 3);
                   reg = sc->sc_buscore_ops->bc_read(sc, core->co_base +
                       BWFM_CHIP_REG_CHIPCONTROL_DATA);
                   return (reg & (1 << 2)) != 0;
           case BRCM_CC_43241_CHIP_ID:
           case BRCM_CC_4335_CHIP_ID:
           case BRCM_CC_4339_CHIP_ID:
                   core = bwfm_chip_get_pmu(sc);
                   sc->sc_buscore_ops->bc_write(sc, core->co_base +
                       BWFM_CHIP_REG_CHIPCONTROL_ADDR, 3);
                   reg = sc->sc_buscore_ops->bc_read(sc, core->co_base +
                       BWFM_CHIP_REG_CHIPCONTROL_DATA);
                   return reg != 0;
           case BRCM_CC_43430_CHIP_ID:
                   core = bwfm_chip_get_core(sc, BWFM_AGENT_CORE_CHIPCOMMON);
                   reg = sc->sc_buscore_ops->bc_read(sc, core->co_base +
                       BWFM_CHIP_REG_SR_CONTROL1);
                   return reg != 0;
           default:
                   core = bwfm_chip_get_pmu(sc);
                   reg = sc->sc_buscore_ops->bc_read(sc, core->co_base +
                       BWFM_CHIP_REG_PMUCAPABILITIES_EXT);
                   if ((reg & BWFM_CHIP_REG_PMUCAPABILITIES_SR_SUPP) == 0)
                           return 0;
                   reg = sc->sc_buscore_ops->bc_read(sc, core->co_base +
                       BWFM_CHIP_REG_RETENTION_CTL);
                   return (reg & (BWFM_CHIP_REG_RETENTION_CTL_MACPHY_DIS |
                                  BWFM_CHIP_REG_RETENTION_CTL_LOGIC_DIS)) == 0;
           }
   }
   
 /* RAM size helpers */  /* RAM size helpers */
 void  void
 bwfm_chip_socram_ramsize(struct bwfm_softc *sc, struct bwfm_core *core)  bwfm_chip_socram_ramsize(struct bwfm_softc *sc, struct bwfm_core *core)
Line 1415  bwfm_proto_bcdc_query_dcmd(struct bwfm_s
Line 1493  bwfm_proto_bcdc_query_dcmd(struct bwfm_s
 {  {
         struct bwfm_proto_bcdc_dcmd *dcmd;          struct bwfm_proto_bcdc_dcmd *dcmd;
         size_t size = sizeof(dcmd->hdr) + *len;          size_t size = sizeof(dcmd->hdr) + *len;
         static int reqid = 0;          int reqid;
         int ret = 1;          int ret = 1;
   
         reqid++;          reqid = sc->sc_bcdc_reqid++;
   
         dcmd = kmem_zalloc(sizeof(*dcmd), KM_SLEEP);          dcmd = kmem_zalloc(sizeof(*dcmd), KM_SLEEP);
         if (*len > sizeof(dcmd->buf))          if (*len > sizeof(dcmd->buf))
Line 1455  bwfm_proto_bcdc_query_dcmd(struct bwfm_s
Line 1533  bwfm_proto_bcdc_query_dcmd(struct bwfm_s
         }          }
   
         if (buf) {          if (buf) {
                 if (size > *len)  
                         size = *len;  
                 if (size < *len)                  if (size < *len)
                         *len = size;                          *len = size;
                 memcpy(buf, dcmd->buf, *len);                  memcpy(buf, dcmd->buf, *len);
Line 1477  bwfm_proto_bcdc_set_dcmd(struct bwfm_sof
Line 1553  bwfm_proto_bcdc_set_dcmd(struct bwfm_sof
 {  {
         struct bwfm_proto_bcdc_dcmd *dcmd;          struct bwfm_proto_bcdc_dcmd *dcmd;
         size_t size = sizeof(dcmd->hdr) + len;          size_t size = sizeof(dcmd->hdr) + len;
         int reqid = 0;          int ret = 1, reqid;
         int ret = 1;  
   
         reqid++;          reqid = sc->sc_bcdc_reqid++;
   
         dcmd = kmem_zalloc(sizeof(*dcmd), KM_SLEEP);          dcmd = kmem_zalloc(sizeof(*dcmd), KM_SLEEP);
         if (len > sizeof(dcmd->buf))          if (len > sizeof(dcmd->buf))
Line 1761  bwfm_connect(struct bwfm_softc *sc)
Line 1836  bwfm_connect(struct bwfm_softc *sc)
 }  }
   
 void  void
   bwfm_get_sta_info(struct bwfm_softc *sc, struct ifmediareq *ifmr)
   {
           struct ieee80211com *ic = &sc->sc_ic;
           struct ieee80211_node *ni = ic->ic_bss;
           struct bwfm_sta_info sta;
           uint32_t flags, txrate;
   
           memset(&sta, 0, sizeof(sta));
           memcpy(&sta, ni->ni_macaddr, sizeof(ni->ni_macaddr));
   
           if (bwfm_fwvar_var_get_data(sc, "sta_info", &sta, sizeof(sta)))
                   return;
   
           if (!IEEE80211_ADDR_EQ(ni->ni_macaddr, sta.ea))
                   return;
   
           if (le16toh(sta.ver) < 4)
                   return;
   
           flags = le32toh(sta.flags);
           if ((flags & BWFM_STA_SCBSTATS) == 0)
                   return;
   
           txrate = le32toh(sta.tx_rate);
           if (txrate == 0xffffffff)
                   return;
   
           if ((flags & BWFM_STA_VHT_CAP) != 0) {
                   ifmr->ifm_active &= ~IFM_TMASK;
                   ifmr->ifm_active |= IFM_IEEE80211_VHT;
                   ifmr->ifm_active &= ~IFM_MMASK;
                   ifmr->ifm_active |= IFM_IEEE80211_11AC;
           } else if ((flags & BWFM_STA_N_CAP) != 0) {
                   ifmr->ifm_active &= ~IFM_TMASK;
                   ifmr->ifm_active |= IFM_IEEE80211_MCS;
                   ifmr->ifm_active &= ~IFM_MMASK;
                   if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
                           ifmr->ifm_active |= IFM_IEEE80211_11NG;
                   else
                           ifmr->ifm_active |= IFM_IEEE80211_11NA;
           }
   }
   
   void
 bwfm_rx(struct bwfm_softc *sc, struct mbuf *m)  bwfm_rx(struct bwfm_softc *sc, struct mbuf *m)
 {  {
         struct ieee80211com *ic = &sc->sc_ic;          struct ieee80211com *ic = &sc->sc_ic;
         struct ifnet *ifp = ic->ic_ifp;          struct ifnet *ifp = ic->ic_ifp;
         struct bwfm_event *e = mtod(m, struct bwfm_event *);          struct bwfm_event *e = mtod(m, struct bwfm_event *);
         int s;  
   
         if (m->m_len >= sizeof(e->ehdr) &&          if (m->m_len >= sizeof(e->ehdr) &&
             ntohs(e->ehdr.ether_type) == BWFM_ETHERTYPE_LINK_CTL &&              ntohs(e->ehdr.ether_type) == BWFM_ETHERTYPE_LINK_CTL &&
             memcmp(BWFM_BRCM_OUI, e->hdr.oui, sizeof(e->hdr.oui)) == 0 &&              memcmp(BWFM_BRCM_OUI, e->hdr.oui, sizeof(e->hdr.oui)) == 0 &&
             ntohs(e->hdr.usr_subtype) == BWFM_BRCM_SUBTYPE_EVENT) {              ntohs(e->hdr.usr_subtype) == BWFM_BRCM_SUBTYPE_EVENT) {
                 bwfm_rx_event(sc, mtod(m, char *), m->m_len);                  bwfm_rx_event(sc, m);
                 m_freem(m);                  // m_freem(m);
                 return;                  return;
         }          }
   
         s = splnet();          m_set_rcvif(m, ifp);
           if_percpuq_enqueue(ifp->if_percpuq, m);
   }
   
         if ((ifp->if_flags & IFF_RUNNING) != 0) {  void
                 m_set_rcvif(m, ifp);  bwfm_rx_event(struct bwfm_softc *sc, struct mbuf *m)
                 if_percpuq_enqueue(ifp->if_percpuq, m);  {
           struct bwfm_task *t;
   
           t = pcq_get(sc->sc_freetask);
           if (t == NULL) {
                   m_freem(m);
                   printf("%s: no free tasks\n", DEVNAME(sc));
                   return;
         }          }
   
         splx(s);          t->t_cmd = BWFM_TASK_RX_EVENT;
           t->t_mbuf = m;
           workqueue_enqueue(sc->sc_taskq, (struct work*)t, NULL);
 }  }
   
 void  void
 bwfm_rx_event(struct bwfm_softc *sc, char *buf, size_t len)  bwfm_rx_event_cb(struct bwfm_softc *sc, struct mbuf *m)
 {  {
         struct ieee80211com *ic = &sc->sc_ic;          struct ieee80211com *ic = &sc->sc_ic;
         struct bwfm_event *e = (void *)buf;          struct bwfm_event *e = mtod(m, void *);
           size_t len = m->m_len;
         int s;          int s;
   
         DPRINTF(("%s: buf %p len %lu datalen %u code %u status %u"          DPRINTF(("%s: event %p len %lu datalen %u code %u status %u"
             " reason %u\n", __func__, buf, len, ntohl(e->msg.datalen),              " reason %u\n", __func__, e, len, ntohl(e->msg.datalen),
             ntohl(e->msg.event_type), ntohl(e->msg.status),              ntohl(e->msg.event_type), ntohl(e->msg.status),
             ntohl(e->msg.reason)));              ntohl(e->msg.reason)));
   
         if (ntohl(e->msg.event_type) >= BWFM_E_LAST)          if (ntohl(e->msg.event_type) >= BWFM_E_LAST) {
                   m_freem(m);
                 return;                  return;
           }
   
         switch (ntohl(e->msg.event_type)) {          switch (ntohl(e->msg.event_type)) {
         case BWFM_E_ESCAN_RESULT: {          case BWFM_E_ESCAN_RESULT: {
                 struct bwfm_escan_results *res = (void *)(buf + sizeof(*e));                  struct bwfm_escan_results *res = (void *)&e[1];
                 struct bwfm_bss_info *bss;                  struct bwfm_bss_info *bss;
                 int i;                  int i;
                 if (ntohl(e->msg.status) != BWFM_E_STATUS_PARTIAL) {                  if (ntohl(e->msg.status) != BWFM_E_STATUS_PARTIAL) {
Line 1817  bwfm_rx_event(struct bwfm_softc *sc, cha
Line 1949  bwfm_rx_event(struct bwfm_softc *sc, cha
                 }                  }
                 len -= sizeof(*e);                  len -= sizeof(*e);
                 if (len < sizeof(*res) || len < le32toh(res->buflen)) {                  if (len < sizeof(*res) || len < le32toh(res->buflen)) {
                           m_freem(m);
                         printf("%s: results too small\n", DEVNAME(sc));                          printf("%s: results too small\n", DEVNAME(sc));
                         return;                          return;
                 }                  }
                 len -= sizeof(*res);                  len -= sizeof(*res);
                 if (len < le16toh(res->bss_count) * sizeof(struct bwfm_bss_info)) {                  if (len < le16toh(res->bss_count) * sizeof(struct bwfm_bss_info)) {
                           m_freem(m);
                         printf("%s: results too small\n", DEVNAME(sc));                          printf("%s: results too small\n", DEVNAME(sc));
                         return;                          return;
                 }                  }
Line 1874  bwfm_rx_event(struct bwfm_softc *sc, cha
Line 2008  bwfm_rx_event(struct bwfm_softc *sc, cha
         default:          default:
                 break;                  break;
         }          }
   
           m_freem(m);
 }  }
   
 void  void
Legend:
Removed from v.1.14  
changed lines
  Added in v.1.14.6.1
CVSweb <webmaster@jp.NetBSD.org>