home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / pub / mobile / wi.44.patches / if_wi.c.diff < prev    next >
Text File  |  2002-01-17  |  16KB  |  594 lines
  1. *** ../wavelan.orig/if_wi.c    Thu Jan 17 11:21:23 2002
  2. --- if_wi.c    Thu Jan 17 13:47:50 2002
  3. ***************
  4. *** 145,150 ****
  5. --- 145,151 ----
  6.   static int wi_seek        __P((struct wi_softc *, int, int, int));
  7.   static int wi_alloc_nicmem    __P((struct wi_softc *, int, int *));
  8.   static void wi_inquire        __P((void *));
  9. + static void wi_wait_scan    __P((void *));
  10.   static void wi_setdef        __P((struct wi_softc *, struct wi_req *));
  11.   static int wi_mgmt_xmit        __P((struct wi_softc *, caddr_t, int));
  12.   
  13. ***************
  14. *** 166,171 ****
  15. --- 167,175 ----
  16.   
  17.   static int wi_alloc        __P((device_t, int));
  18.   static void wi_free        __P((device_t));
  19. + static void wi_get_firmware     __P((struct wi_softc *, u_int16_t *, u_int16_t *,
  20. +  u_int16_t *));
  21. + 
  22.   
  23.   static int wi_get_cur_ssid    __P((struct wi_softc *, char *, int *));
  24.   static int wi_media_change    __P((struct ifnet *));
  25. ***************
  26. *** 436,441 ****
  27. --- 440,446 ----
  28.       struct wi_ltv_gen    gen;
  29.       struct ifnet        *ifp;
  30.       int            error;
  31. +      u_int16_t               v, maj, min;
  32.   
  33.       sc = device_get_softc(dev);
  34.       ifp = &sc->arpcom.ac_if;
  35. ***************
  36. *** 472,477 ****
  37. --- 477,486 ----
  38.       device_printf(dev, "Ethernet address: %6D\n",
  39.           sc->arpcom.ac_enaddr, ":");
  40.   
  41. +         wi_get_firmware( sc, &v, &maj, &min);
  42. +         printf("wi%d: (hw type=%d, firmware=0x%02x:%02x)\n",
  43. +             sc->wi_unit, v, maj, min);
  44. + 
  45.       ifp->if_softc = sc;
  46.       ifp->if_unit = sc->wi_unit;
  47.       ifp->if_name = "wi";
  48. ***************
  49. *** 506,511 ****
  50. --- 515,521 ----
  51.       sc->wi_create_ibss = WI_DEFAULT_CREATE_IBSS;
  52.       sc->wi_pm_enabled = WI_DEFAULT_PM_ENABLED;
  53.       sc->wi_max_sleep = WI_DEFAULT_MAX_SLEEP;
  54. +     sc->wi_monitor = WI_DEFAULT_MONITOR;
  55.   
  56.       /*
  57.        * Read the default channel from the NIC. This may vary
  58. ***************
  59. *** 534,539 ****
  60. --- 544,553 ----
  61.   
  62.       bzero((char *)&sc->wi_stats, sizeof(sc->wi_stats));
  63.   
  64. +     bzero((char *)&sc->wi_aps, sizeof(sc->wi_aps));
  65. +     sc->wi_scanning=0;
  66. +     sc->wi_naps=0;
  67. + 
  68.       wi_init(sc);
  69.       wi_stop(sc);
  70.   
  71. ***************
  72. *** 565,570 ****
  73. --- 579,585 ----
  74.        */
  75.       ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
  76.       callout_handle_init(&sc->wi_stat_ch);
  77. +         callout_handle_init(&sc->wi_scan_ch);
  78.   
  79.       return(0);
  80.   }
  81. ***************
  82. *** 577,582 ****
  83. --- 592,598 ----
  84.       struct wi_frame        rx_frame;
  85.       struct mbuf        *m;
  86.       int            id;
  87. +     int            hdrlen,hdroff,datalen;
  88.   
  89.       ifp = &sc->arpcom.ac_if;
  90.   
  91. ***************
  92. *** 593,598 ****
  93. --- 609,743 ----
  94.           return;
  95.       }
  96.   
  97. +     /* If monitoring packet came in... */
  98. +     if((rx_frame.wi_status&WI_STAT_MAC_PORT)==WI_STAT_MAC_PORT)
  99. +     {
  100. +         /* Depending on the monitoring mode... */
  101. +         switch(sc->wi_monitor&WI_MONITOR_HTYPE)
  102. +         {
  103. +             case WI_MONITOR_WAVELAN:
  104. +                 /* Passing whole WaveLAN header */
  105. +                 hdroff = 0;
  106. +                 hdrlen = sizeof(struct wi_80211_hdr) + WI_802_11_OFFSET_HDR;
  107. +                 break;
  108. +             case WI_MONITOR_80211:
  109. +                 /* Passing 802.11 header */
  110. +                 hdroff = WI_802_11_OFFSET_HDR;
  111. +                 hdrlen = sizeof(struct wi_80211_hdr);
  112. +                 break;
  113. +             case WI_MONITOR_ETHER:
  114. +                 /* Faking Ethernet header */
  115. +                 hdroff = -1;
  116. +                 hdrlen = sizeof(struct ether_header);
  117. +                 break;
  118. +             default:
  119. +                 return;
  120. +         }
  121. + 
  122. +         /* Depending on the packet type... */
  123. +         switch(rx_frame.wi_frame_ctl&WI_FCTL_FTYPE)
  124. +         {
  125. +             case WI_FTYPE_MGMT:
  126. +                 if((rx_frame.wi_frame_ctl&WI_FCTL_STYPE)==WI_STYPE_MGMT_BEACON)
  127. +                 { if(!(sc->wi_monitor&WI_MONITOR_BEACONS)) return; }
  128. +                 else
  129. +                 { if(!(sc->wi_monitor&WI_MONITOR_MGMT)) return; }
  130. +                 datalen = rx_frame.wi_dat_len;
  131. +                 hdrlen -= 6;
  132. +                 break;
  133. +             case WI_FTYPE_CTL:
  134. +                 if(!(sc->wi_monitor&WI_MONITOR_CTRL)) return;
  135. +                 datalen = 0;
  136. +                 switch(rx_frame.wi_frame_ctl&WI_FCTL_STYPE)
  137. +                 {
  138. +                     case WI_STYPE_CTL_ACK:
  139. +                     case WI_STYPE_CTL_CTS:
  140. +                         hdrlen -= 20;
  141. +                         break;
  142. +                     default:
  143. +                         hdrlen -= 14;
  144. +                         break;
  145. +                 }
  146. +                 break;
  147. +             case WI_FTYPE_DATA:
  148. +                 if(!(sc->wi_monitor&WI_MONITOR_DATA)) return;
  149. +                 datalen = rx_frame.wi_dat_len;
  150. +                 break;
  151. +             default:
  152. +                 return;
  153. +         }
  154. + 
  155. +         /* Check for mbuf overflow */
  156. +         if(hdrlen+datalen>MCLBYTES)
  157. +         {
  158. +             device_printf
  159. +             (
  160. +                 sc->dev,
  161. +                 "oversized packet received (wi_dat_len=%d, wi_frame_ctl=0x%04x)\n",
  162. +                 rx_frame.wi_dat_len,
  163. +                 rx_frame.wi_frame_ctl
  164. +             );
  165. +             ifp->if_ierrors++;
  166. +             return;
  167. +         }
  168. + 
  169. +         MGETHDR(m,M_DONTWAIT,MT_DATA);
  170. +         if(m==NULL)
  171. +         {
  172. +             ifp->if_ierrors++;
  173. +             return;
  174. +         }
  175. + 
  176. +         MCLGET(m,M_DONTWAIT);
  177. +         if(!(m->m_flags&M_EXT))
  178. +         {
  179. +             m_freem(m);
  180. +             ifp->if_ierrors++;
  181. +             return;
  182. +         }
  183. + 
  184. +         /* Set header/packet lengths and interface */
  185. +         eh = mtod(m, struct ether_header *);
  186. +         m->m_pkthdr.rcvif = ifp;
  187. +         m->m_pkthdr.len   = m->m_len = hdrlen + datalen;
  188. + 
  189. +         /* If real header requested, copy it */
  190. +         if(hdroff>=0)
  191. +             bcopy((char *)&rx_frame+hdroff,mtod(m,caddr_t),hdrlen);
  192. +         else
  193. +         {
  194. +             /* Fake Ethernet header */
  195. +             eh->ether_type = ETHERTYPE_LOOPBACK;
  196. +             bcopy((char *)&rx_frame.wi_addr1,(char *)&eh->ether_dhost,ETHER_ADDR_LEN);
  197. +             bcopy((char *)&rx_frame.wi_addr2,(char *)&eh->ether_shost,ETHER_ADDR_LEN);
  198. +             /* We now have a header */
  199. +             hdrlen = sizeof(struct ether_header);
  200. +         }
  201. + 
  202. +         /* Read data, if present */
  203. +         if(datalen)
  204. +             if(wi_read_data(sc,id,WI_802_11_OFFSET_RAW,mtod(m,caddr_t)+hdrlen,datalen))
  205. +             {
  206. +                 m_freem(m);
  207. +                 ifp->if_ierrors++;
  208. +                 return;
  209. +             }
  210. + 
  211. + #ifdef WICACHE
  212. +         if(hdroff<0) wi_cache_store(sc,eh,m,rx_frame.wi_q_info);
  213. + #endif  
  214. + 
  215. +         /* One more packet received */
  216. +         ifp->if_ipackets++;
  217. + 
  218. +         /* Feed packet to BPF */
  219. +         if(ifp->if_bpf) bpf_mtap(ifp,m);
  220. + 
  221. +         /* Done logging */
  222. +         m_freem(m);
  223. +         return;
  224. +     }
  225. + 
  226.       MGETHDR(m, M_DONTWAIT, MT_DATA);
  227.       if (m == NULL) {
  228.           ifp->if_ierrors++;
  229. ***************
  230. *** 610,616 ****
  231.   
  232.       if (rx_frame.wi_status == WI_STAT_1042 ||
  233.           rx_frame.wi_status == WI_STAT_TUNNEL ||
  234. !         rx_frame.wi_status == WI_STAT_WMP_MSG) {
  235.           if((rx_frame.wi_dat_len + WI_SNAPHDR_LEN) > MCLBYTES) {
  236.               device_printf(sc->dev, "oversized packet received "
  237.                   "(wi_dat_len=%d, wi_status=0x%x)\n",
  238. --- 755,762 ----
  239.   
  240.       if (rx_frame.wi_status == WI_STAT_1042 ||
  241.           rx_frame.wi_status == WI_STAT_TUNNEL ||
  242. !         rx_frame.wi_status == WI_STAT_WMP_MSG ||
  243. !         ((rx_frame.wi_status & WI_STAT_MAC_PORT) == WI_STAT_MAC_PORT)) {
  244.           if((rx_frame.wi_dat_len + WI_SNAPHDR_LEN) > MCLBYTES) {
  245.               device_printf(sc->dev, "oversized packet received "
  246.                   "(wi_dat_len=%d, wi_status=0x%x)\n",
  247. ***************
  248. *** 719,732 ****
  249.       return;
  250.   }
  251.   
  252.   void wi_update_stats(sc)
  253.       struct wi_softc        *sc;
  254.   {
  255.       struct wi_ltv_gen    gen;
  256.       u_int16_t        id;
  257.       struct ifnet        *ifp;
  258.       u_int32_t        *ptr;
  259. !     int            len, i;
  260.       u_int16_t        t;
  261.   
  262.       ifp = &sc->arpcom.ac_if;
  263. --- 865,922 ----
  264.       return;
  265.   }
  266.   
  267. + void wi_wait_scan(xsc)
  268. +      void            *xsc;
  269. + {
  270. +      struct wi_softc        *sc;
  271. +      struct ifnet        *ifp;
  272. +     int rc;
  273. +  
  274. +      sc = xsc;
  275. +      ifp = &sc->arpcom.ac_if;
  276. +  
  277. +      /* If not scanning, ignore */
  278. +      if (!sc->wi_scanning)
  279. +          return;
  280. + 
  281. +      /* If transmitting... wait for later to make INQUIRE
  282. +     */
  283. +      if (ifp->if_flags & IFF_OACTIVE) {
  284. +          sc->wi_scan_ch = timeout(wi_wait_scan, sc, hz*1);
  285. +         return;
  286. +     }
  287. +  
  288. +     /* try INQUIRE -- this will cause info interrupt 
  289. +     */
  290. +      rc = wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_SCAN_RESULTS);
  291. +  
  292. +      /* If not ready, call this function later
  293. +     */
  294. +     if (rc == ETIMEDOUT) {
  295. +          sc->wi_scan_ch = timeout(wi_wait_scan, sc, hz*1);
  296. +     }
  297. +      return;
  298. + }
  299. + 
  300. + /*
  301. +  * copy hw stats structure to softc clone of it
  302. +  *
  303. +  * important side effect: BSD if collisions are updated
  304. +  * because of this, therefore this routine is called once
  305. +  * a minute.  
  306. +  *
  307. +  * It is also printed out via wicontrol -i wi0 -o
  308. +  */
  309.   void wi_update_stats(sc)
  310.       struct wi_softc        *sc;
  311.   {
  312.       struct wi_ltv_gen    gen;
  313. +     struct wi_scan_data_p2  ap2;  /* prism2 output */
  314. +     struct wi_scan_data     ap;   /* lucent output */
  315.       u_int16_t        id;
  316.       struct ifnet        *ifp;
  317.       u_int32_t        *ptr;
  318. !     int            len, i, j;
  319.       u_int16_t        t;
  320.   
  321.       ifp = &sc->arpcom.ac_if;
  322. ***************
  323. *** 735,761 ****
  324.   
  325.       wi_read_data(sc, id, 0, (char *)&gen, 4);
  326.   
  327. !     if (gen.wi_type != WI_INFO_COUNTERS)
  328. !         return;
  329.   
  330. !     len = (gen.wi_len - 1 < sizeof(sc->wi_stats) / 4) ?
  331. !         gen.wi_len - 1 : sizeof(sc->wi_stats) / 4;
  332. !     ptr = (u_int32_t *)&sc->wi_stats;
  333.   
  334. !     for (i = 0; i < len - 1; i++) {
  335. !         t = CSR_READ_2(sc, WI_DATA1);
  336.   #ifdef WI_HERMES_STATS_WAR
  337. !         if (t > 0xF000)
  338. !             t = ~t & 0xFFFF;
  339.   #endif
  340. !         ptr[i] += t;
  341. !     }
  342. ! 
  343. !     ifp->if_collisions = sc->wi_stats.wi_tx_single_retries +
  344. !         sc->wi_stats.wi_tx_multi_retries +
  345. !         sc->wi_stats.wi_tx_retry_limit;
  346.   
  347. !     return;
  348.   }
  349.   
  350.   static void wi_intr(xsc)
  351. --- 925,1019 ----
  352.   
  353.       wi_read_data(sc, id, 0, (char *)&gen, 4);
  354.   
  355. !     switch(gen.wi_type)
  356. !     {
  357. !         case WI_INFO_SCAN_RESULTS:
  358. !             /* lucent entries are shorter than prism2 
  359. !             */
  360. !             if(gen.wi_len<3)
  361. !                 break;
  362. !             if (!sc->wi_prism2) {
  363. !                             len = 2*(gen.wi_len)/sizeof(ap);
  364. !                 len = len>MAXAPINFO? MAXAPINFO:len;
  365. !                 sc->wi_naps = len;
  366. !                 for(i=0;i<len;i++)
  367. !                 {
  368. !                     for(j=0;j<sizeof(ap)/2;j++)
  369. !                         ((u_int16_t *)&ap)[j] = CSR_READ_2(sc, WI_DATA1);
  370. !                     bcopy(ap.wi_bssid,sc->wi_aps[i].bssid,6);
  371. !                     sc->wi_aps[i].channel = ap.wi_channel;
  372. !                     sc->wi_aps[i].signal  = ap.wi_signal-149;
  373. !                     sc->wi_aps[i].noise   = ap.wi_noise-149;
  374. !                     sc->wi_aps[i].quality = sc->wi_aps[i].signal-sc->wi_aps[i].noise;
  375. !                     sc->wi_aps[i].capinfo = ap.wi_capinfo;
  376. !                     sc->wi_aps[i].interval = ap.wi_interval;
  377. !                     /* prevent disasters
  378. !                     */
  379. !                     if (ap.wi_namelen > 32)
  380. !                         ap.wi_namelen = 32;
  381. !                     sc->wi_aps[i].namelen = ap.wi_namelen;
  382. !                     bcopy(ap.wi_name, sc->wi_aps[i].name,
  383. !                         ap.wi_namelen);
  384. !                 }
  385. !                 sc->wi_scanning = 0;
  386. !                 break;
  387. !             }
  388. !             /* prism2 
  389. !             */
  390. !             /* Compute number of AP entries 
  391. !              * Note: there is some sort of pre-header that
  392. !              * is being skipped
  393. !             */
  394. !                         len = 2*(gen.wi_len-3)/sizeof(ap2);
  395. !             len = len>MAXAPINFO? MAXAPINFO:len;
  396. !             sc->wi_naps = len;
  397. !             /* Read and ignore the first word */
  398. !             t = CSR_READ_2(sc, WI_DATA1);
  399. !             /* Read the rest */
  400. !             for(i=0;i<len;i++)
  401. !             {
  402. !                 for(j=0;j<sizeof(ap2)/2;j++)
  403. !                     ((u_int16_t *)&ap2)[j] = CSR_READ_2(sc, WI_DATA1);
  404. !                 bcopy(ap2.wi_bssid,sc->wi_aps[i].bssid,6);
  405. !                 sc->wi_aps[i].channel = ap2.wi_channel1;
  406. !                 sc->wi_aps[i].signal  = ap2.wi_signal-149;
  407. !                 sc->wi_aps[i].noise   = ap2.wi_noise-149;
  408. !                 sc->wi_aps[i].quality = sc->wi_aps[i].signal-sc->wi_aps[i].noise;
  409. !                 sc->wi_aps[i].capinfo = ap2.wi_capinfo;
  410. !                 sc->wi_aps[i].interval = ap2.wi_interval;
  411. !                 /* prevent disasters
  412. !                 */
  413. !                 if (ap2.wi_namelen > 32)
  414. !                     ap2.wi_namelen = 32;
  415. !                 sc->wi_aps[i].namelen = ap2.wi_namelen;
  416. !                 bcopy(ap2.wi_name, sc->wi_aps[i].name,
  417. !                         ap2.wi_namelen);
  418.   
  419. !             }
  420. !             /* Done scanning 
  421. !             */
  422. !             sc->wi_scanning = 0;
  423. !             break;
  424. ! 
  425. !         case WI_INFO_COUNTERS:
  426. !             len = (gen.wi_len - 1 < sizeof(sc->wi_stats) / 4) ?
  427. !                 gen.wi_len - 1 : sizeof(sc->wi_stats) / 4;
  428. !             ptr = (u_int32_t *)&sc->wi_stats;
  429.   
  430. !             for (i = 0; i < len - 1; i++) {
  431. !                 t = CSR_READ_2(sc, WI_DATA1);
  432.   #ifdef WI_HERMES_STATS_WAR
  433. !                 if (t > 0xF000)
  434. !                     t = ~t & 0xFFFF;
  435.   #endif
  436. !                 ptr[i] += t;
  437. !             }
  438.   
  439. !             ifp->if_collisions = sc->wi_stats.wi_tx_single_retries
  440. !                        + sc->wi_stats.wi_tx_multi_retries
  441. !                        + sc->wi_stats.wi_tx_retry_limit;
  442. !             break;
  443. !     }
  444.   }
  445.   
  446.   static void wi_intr(xsc)
  447. ***************
  448. *** 1402,1410 ****
  449. --- 1660,1688 ----
  450.           if (wreq.wi_type == WI_RID_DEFLT_CRYPT_KEYS && suser(p))
  451.               break;
  452.           if (wreq.wi_type == WI_RID_IFACE_STATS) {
  453. +             /* call update routine to make sure data
  454. +              * is as up to date as possible
  455. +             */
  456. +             wi_update_stats(sc);
  457.               bcopy((char *)&sc->wi_stats, (char *)&wreq.wi_val,
  458.                   sizeof(sc->wi_stats));
  459.               wreq.wi_len = (sizeof(sc->wi_stats) / 2) + 1;
  460. +         /* copyout AP info
  461. +         */
  462. +         } else if (wreq.wi_type == WI_RID_READ_APS) {
  463. +             if (sc->wi_scanning)
  464. +             {
  465. +                 error = EINVAL;
  466. +                 break;
  467. +             }
  468. +             else
  469. +             {
  470. +                 len = sc->wi_naps*sizeof(struct wi_apinfo);
  471. +                 len = len>WI_MAX_DATALEN? WI_MAX_DATALEN:len;
  472. +                 len = len/sizeof(struct wi_apinfo);     
  473. +                 bcopy((char *)&len, (char *)&wreq.wi_val, sizeof(len));
  474. +                 bcopy((char *)&sc->wi_aps, (char *)&wreq.wi_val+sizeof(len), len*sizeof(struct wi_apinfo));
  475. +             }
  476.           } else if (wreq.wi_type == WI_RID_DEFLT_CRYPT_KEYS) {
  477.               bcopy((char *)&sc->wi_keys, (char *)&wreq,
  478.                   sizeof(struct wi_ltv_keys));
  479. ***************
  480. *** 1444,1449 ****
  481. --- 1722,1762 ----
  482.           } else if (wreq.wi_type == WI_RID_MGMT_XMIT) {
  483.               error = wi_mgmt_xmit(sc, (caddr_t)&wreq.wi_val,
  484.                   wreq.wi_len);
  485. +         } else if (wreq.wi_type == WI_RID_SCAN_APS) {
  486. +             if (wreq.wi_len != 4)
  487. +             {
  488. +                 error = EINVAL;
  489. +                 break;
  490. +             }
  491. +             if (!sc->wi_scanning)
  492. +             {
  493. +                 if (sc->wi_prism2) {
  494. +                     wreq.wi_type = WI_RID_SCAN_REQUEST;
  495. +                     error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
  496. +                 }
  497. +                 if(!error)
  498. +                 {
  499. +                     sc->wi_scanning = 1;
  500. +                     sc->wi_scan_ch = timeout(wi_wait_scan, sc, hz*1);
  501. +                 }
  502. +             }
  503. +         } else if (wreq.wi_type == WI_RID_MONITOR_MODE) {
  504. +             sc->wi_monitor = wreq.wi_val[0];
  505. +             wi_init(sc);
  506. +             switch(sc->wi_monitor&WI_MONITOR_HTYPE)
  507. +             {
  508. +                 case WI_MONITOR_WAVELAN:
  509. +                     bpfattach(ifp,DLT_WAVELAN_HEADER,sizeof(struct wi_frame));
  510. +                     break;
  511. +                 case WI_MONITOR_80211:
  512. +                     bpfattach(ifp,DLT_IEEE802_11,sizeof(struct wi_80211_hdr));
  513. +                     break;
  514. +                 case WI_MONITOR_ETHER:
  515. +                 case WI_MONITOR_OFF:
  516. +                 default:
  517. +                     bpfattach(ifp,DLT_EN10MB,sizeof(struct wi_80211_hdr));
  518. +                     break;
  519. +             }
  520.           } else {
  521.               error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
  522.               if (!error)
  523. ***************
  524. *** 1742,1747 ****
  525. --- 2055,2076 ----
  526.       /* Enable desired port */
  527.       wi_cmd(sc, WI_CMD_ENABLE|sc->wi_portnum, 0);
  528.   
  529. +     /* Turn monitoring on/off */
  530. +     if(sc->wi_monitor)
  531. +     {
  532. +         if(wi_cmd(sc,WI_CMD_TEST|WI_TEST_MONITOR,0)) sc->wi_monitor=0;
  533. +     } 
  534. +     else
  535. +     {
  536. +         wi_cmd(sc,WI_CMD_TEST|WI_TEST_STOP,0);
  537. +     }
  538. + 
  539. +     /*  scanning variable is modal, therefore reinit to OFF, in
  540. +     *  case it was on.
  541. +     */
  542. +     sc->wi_scanning=0;
  543. +     sc->wi_naps=0;
  544. + 
  545.       if (wi_alloc_nicmem(sc, ETHER_MAX_LEN + sizeof(struct wi_frame) + 8, &id))
  546.           device_printf(sc->dev, "tx buffer allocation failed\n");
  547.       sc->wi_tx_data_id = id;
  548. ***************
  549. *** 1913,1918 ****
  550. --- 2242,2248 ----
  551.       }
  552.   
  553.       untimeout(wi_inquire, sc, sc->wi_stat_ch);
  554. +     untimeout(wi_wait_scan, sc, sc->wi_scan_ch);
  555.   
  556.       ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
  557.   
  558. ***************
  559. *** 1998,2003 ****
  560. --- 2328,2360 ----
  561.   
  562.       return;
  563.   }
  564. + 
  565. + /* borrowed from linux wvlan driver.
  566. +  * get version, firmware info.  There is more info
  567. +  * but don't know what it means.
  568. +  * data[1] is vendor, 2 & 3 are firmware # in major/minor order.
  569. +  * lucent is vendor 1, 2 and 6 are prism apparently.
  570. + */      
  571. + 
  572. + static void wi_get_firmware( struct wi_softc *sc, u_int16_t *v,
  573. +         u_int16_t *maj, u_int16_t *min)
  574. + {
  575. +         struct wi_ltv_staid     staid;
  576. +         int rc;
  577. + 
  578. +         staid.wi_len = 32;
  579. +         staid.wi_type = WI_RID_STAID;
  580. +         rc = wi_read_record(sc, (struct wi_ltv_gen *)&staid);
  581. +         /*
  582. +         if (rc < 0) {
  583. +                 printf("rc %d\n", rc);
  584. +         }
  585. +         */
  586. +         *v = staid.wi_data[1];  /* hardware type */
  587. +         *maj = staid.wi_data[2];  /* firmware major */
  588. +         *min =  staid.wi_data[3];  /* firmware minor */
  589. + }
  590. + 
  591.   
  592.   #ifdef WICACHE
  593.   /* wavelan signal strength cache code.
  594.