Lines Matching defs:ai
1109 static int enable_MAC(struct airo_info *ai, int lock);
1110 static void disable_MAC(struct airo_info *ai, int lock);
1133 static void mpi_receive_802_3(struct airo_info *ai);
1134 static void mpi_receive_802_11(struct airo_info *ai);
1135 static int waitbusy (struct airo_info *ai);
1148 static void micinit(struct airo_info *ai);
1149 static int micsetup(struct airo_info *ai);
1150 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1151 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1156 static void airo_networks_free(struct airo_info *ai);
1252 static inline int bap_read(struct airo_info *ai, __le16 *pu16Dst, int bytelen,
1255 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1263 static int cmdreset(struct airo_info *ai);
1264 static int setflashmode (struct airo_info *ai);
1265 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1266 static int flashputbuf(struct airo_info *ai);
1267 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1291 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1298 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1325 static void micinit(struct airo_info *ai)
1329 clear_bit(JOB_MIC, &ai->jobs);
1330 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1331 up(&ai->sem);
1333 ai->micstats.enabled = (le16_to_cpu(mic_rid.state) & 0x00FF) ? 1 : 0;
1334 if (!ai->micstats.enabled) {
1338 ai->mod[0].uCtx.valid = 0;
1339 ai->mod[0].mCtx.valid = 0;
1344 age_mic_context(&ai->mod[0].mCtx, &ai->mod[1].mCtx,
1346 ai->tfm);
1350 age_mic_context(&ai->mod[0].uCtx, &ai->mod[1].uCtx,
1352 ai->tfm);
1358 static int micsetup(struct airo_info *ai) {
1361 if (ai->tfm == NULL)
1362 ai->tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
1364 if (IS_ERR(ai->tfm)) {
1365 airo_print_err(ai->dev->name, "failed to load transform for AES");
1366 ai->tfm = NULL;
1371 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1372 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1395 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1402 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1403 context = &ai->mod[0].mCtx;
1405 context = &ai->mod[0].uCtx;
1451 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1461 if (!ai->micstats.enabled) {
1464 ai->micstats.rxMICPlummed++;
1475 ai->micstats.rxMICPlummed++;
1486 ai->micstats.rxWrongSequence++;
1493 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1522 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1523 ai->micstats.rxSuccess++;
1532 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1533 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1534 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1555 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1563 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1564 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1568 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1569 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1744 static int readBSSListRid(struct airo_info *ai, int first,
1751 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1754 if (down_interruptible(&ai->sem))
1756 ai->list_bss_task = current;
1757 issuecommand(ai, &cmd, &rsp);
1758 up(&ai->sem);
1761 ai->list_bss_task = NULL;
1763 return PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
1764 list, ai->bssListRidLen, 1);
1767 static int readWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int temp, int lock)
1769 return PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1773 static int writeWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int perm, int lock)
1776 rc = PC4500_writerid(ai, RID_WEP_TEMP, wkr, sizeof(*wkr), lock);
1778 airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1780 rc = PC4500_writerid(ai, RID_WEP_PERM, wkr, sizeof(*wkr), lock);
1782 airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1787 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr)
1789 return PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1792 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock)
1794 return PC4500_writerid(ai, RID_SSID, pssidr, sizeof(*pssidr), lock);
1797 static int readConfigRid(struct airo_info *ai, int lock)
1802 if (ai->config.len)
1805 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1809 ai->config = cfg;
1813 static inline void checkThrottle(struct airo_info *ai)
1817 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1819 if (ai->config.rates[i] > maxencrypt) {
1820 ai->config.rates[i] = 0;
1826 static int writeConfigRid(struct airo_info *ai, int lock)
1830 if (!test_bit (FLAG_COMMIT, &ai->flags))
1833 clear_bit (FLAG_COMMIT, &ai->flags);
1834 clear_bit (FLAG_RESET, &ai->flags);
1835 checkThrottle(ai);
1836 cfgr = ai->config;
1839 set_bit(FLAG_ADHOC, &ai->flags);
1841 clear_bit(FLAG_ADHOC, &ai->flags);
1843 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1846 static int readStatusRid(struct airo_info *ai, StatusRid *statr, int lock)
1848 return PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1851 static int readAPListRid(struct airo_info *ai, APListRid *aplr)
1853 return PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1856 static int writeAPListRid(struct airo_info *ai, APListRid *aplr, int lock)
1858 return PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1861 static int readCapabilityRid(struct airo_info *ai, CapabilityRid *capr, int lock)
1863 return PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1866 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock)
1868 return PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1871 static void try_auto_wep(struct airo_info *ai)
1873 if (auto_wep && !(ai->flags & FLAG_RADIO_DOWN)) {
1874 ai->expires = RUN_AT(3*HZ);
1875 wake_up_interruptible(&ai->thr_wait);
1880 struct airo_info *ai = dev->ml_priv;
1883 if (test_bit(FLAG_FLASHING, &ai->flags))
1890 if (test_bit(FLAG_COMMIT, &ai->flags)) {
1891 disable_MAC(ai, 1);
1892 writeConfigRid(ai, 1);
1895 if (ai->wifidev != dev) {
1896 clear_bit(JOB_DIE, &ai->jobs);
1897 ai->airo_thread_task = kthread_run(airo_thread, dev, dev->name);
1898 if (IS_ERR(ai->airo_thread_task))
1899 return (int)PTR_ERR(ai->airo_thread_task);
1907 set_bit(JOB_DIE, &ai->jobs);
1908 kthread_stop(ai->airo_thread_task);
1913 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
1914 enable_interrupts(ai);
1916 try_auto_wep(ai);
1918 enable_MAC(ai, 1);
1929 struct airo_info *ai = dev->ml_priv;
1935 npacks = skb_queue_len (&ai->txq);
1943 skb_queue_tail (&ai->txq, skb);
1947 spin_lock_irqsave(&ai->aux_lock, flags);
1948 skb_queue_tail (&ai->txq, skb);
1949 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1950 spin_unlock_irqrestore(&ai->aux_lock,flags);
1954 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1973 struct airo_info *ai = dev->ml_priv;
1978 if ((skb = skb_dequeue(&ai->txq)) == NULL) {
1989 ai->txfids[0].tx_desc.offset = 0;
1990 ai->txfids[0].tx_desc.valid = 1;
1991 ai->txfids[0].tx_desc.eoc = 1;
1992 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
2002 memcpy((char *)ai->txfids[0].virtual_host_addr,
2005 payloadLen = (__le16 *)(ai->txfids[0].virtual_host_addr +
2007 sendbuf = ai->txfids[0].virtual_host_addr +
2014 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2018 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2022 ai->txfids[0].tx_desc.len += sizeof(pMic);
2039 memcpy_toio(ai->txfids[0].card_ram_off,
2040 &ai->txfids[0].tx_desc, sizeof(TxFid));
2042 OUT4500(ai, EVACK, 8);
2048 static void get_tx_error(struct airo_info *ai, s32 fid)
2053 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2055 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2057 bap_read(ai, &status, 2, BAP0);
2060 ai->dev->stats.tx_aborted_errors++;
2062 ai->dev->stats.tx_heartbeat_errors++;
2066 ai->dev->stats.tx_carrier_errors++;
2081 bap_read(ai, (__le16 *) junk, 0x18, BAP0);
2095 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2242 struct airo_info *ai = dev->ml_priv;
2246 clear_bit(JOB_STATS, &ai->jobs);
2247 if (ai->power.event) {
2248 up(&ai->sem);
2251 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2252 up(&ai->sem);
2290 static void airo_set_promisc(struct airo_info *ai) {
2296 clear_bit(JOB_PROMISC, &ai->jobs);
2297 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2298 issuecommand(ai, &cmd, &rsp);
2299 up(&ai->sem);
2303 struct airo_info *ai = dev->ml_priv;
2305 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2306 change_bit(FLAG_PROMISC, &ai->flags);
2307 if (down_trylock(&ai->sem) != 0) {
2308 set_bit(JOB_PROMISC, &ai->jobs);
2309 wake_up_interruptible(&ai->thr_wait);
2311 airo_set_promisc(ai);
2321 struct airo_info *ai = dev->ml_priv;
2324 readConfigRid(ai, 1);
2325 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2326 set_bit (FLAG_COMMIT, &ai->flags);
2327 disable_MAC(ai, 1);
2328 writeConfigRid (ai, 1);
2329 enable_MAC(ai, 1);
2330 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2331 if (ai->wifidev)
2332 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2346 static void add_airo_dev(struct airo_info *ai)
2350 if (!ai->pci)
2351 list_add_tail(&ai->dev_list, &airo_devices);
2354 static void del_airo_dev(struct airo_info *ai)
2356 if (!ai->pci)
2357 list_del(&ai->dev_list);
2361 struct airo_info *ai = dev->ml_priv;
2365 if (ai->wifidev != dev) {
2372 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2373 disable_MAC(ai, 1);
2375 disable_interrupts( ai );
2379 set_bit(JOB_DIE, &ai->jobs);
2380 kthread_stop(ai->airo_thread_task);
2387 struct airo_info *ai = dev->ml_priv;
2389 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2390 disable_MAC(ai, 1);
2391 disable_interrupts(ai);
2392 takedown_proc_entry( dev, ai );
2393 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2395 if (ai->wifidev) {
2396 unregister_netdev(ai->wifidev);
2397 free_netdev(ai->wifidev);
2398 ai->wifidev = NULL;
2400 clear_bit(FLAG_REGISTERED, &ai->flags);
2405 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2407 for (;(skb = skb_dequeue(&ai->txq));)
2411 airo_networks_free (ai);
2413 kfree(ai->flash);
2414 kfree(ai->rssi);
2415 kfree(ai->APList);
2416 kfree(ai->SSID);
2420 if (test_bit(FLAG_MPI, &ai->flags)) {
2421 if (ai->pci)
2422 mpi_unmap_card(ai->pci);
2423 if (ai->pcimem)
2424 iounmap(ai->pcimem);
2425 if (ai->pciaux)
2426 iounmap(ai->pciaux);
2427 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2428 ai->shared, ai->shared_dma);
2431 crypto_free_cipher(ai->tfm);
2432 del_airo_dev(ai);
2462 static int mpi_init_descriptors (struct airo_info *ai)
2470 netif_stop_queue(ai->dev);
2477 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2479 rc=issuecommand(ai, &cmd, &rsp);
2481 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2486 memcpy_toio(ai->rxfids[i].card_ram_off,
2487 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2497 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2501 ai->txfids[i].tx_desc.valid = 1;
2502 memcpy_toio(ai->txfids[i].card_ram_off,
2503 &ai->txfids[i].tx_desc, sizeof(TxFid));
2505 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2507 rc=issuecommand(ai, &cmd, &rsp);
2509 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2519 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2521 rc=issuecommand(ai, &cmd, &rsp);
2523 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2527 memcpy_toio(ai->config_desc.card_ram_off,
2528 &ai->config_desc.rid_desc, sizeof(Rid));
2539 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci)
2564 ai->pcimem = ioremap(mem_start, mem_len);
2565 if (!ai->pcimem) {
2570 ai->pciaux = ioremap(aux_start, aux_len);
2571 if (!ai->pciaux) {
2578 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2579 if (!ai->shared) {
2588 busaddroff = ai->shared_dma;
2589 pciaddroff = ai->pciaux + AUX_OFFSET;
2590 vpackoff = ai->shared;
2594 ai->rxfids[i].pending = 0;
2595 ai->rxfids[i].card_ram_off = pciaddroff;
2596 ai->rxfids[i].virtual_host_addr = vpackoff;
2597 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2598 ai->rxfids[i].rx_desc.valid = 1;
2599 ai->rxfids[i].rx_desc.len = PKTSIZE;
2600 ai->rxfids[i].rx_desc.rdy = 0;
2609 ai->txfids[i].card_ram_off = pciaddroff;
2610 ai->txfids[i].virtual_host_addr = vpackoff;
2611 ai->txfids[i].tx_desc.valid = 1;
2612 ai->txfids[i].tx_desc.host_addr = busaddroff;
2613 memcpy(ai->txfids[i].virtual_host_addr,
2620 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2623 ai->config_desc.card_ram_off = pciaddroff;
2624 ai->config_desc.virtual_host_addr = vpackoff;
2625 ai->config_desc.rid_desc.host_addr = busaddroff;
2626 ai->ridbus = busaddroff;
2627 ai->config_desc.rid_desc.rid = 0;
2628 ai->config_desc.rid_desc.len = RIDSIZE;
2629 ai->config_desc.rid_desc.valid = 1;
2635 if (mpi_init_descriptors (ai) != SUCCESS)
2640 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2642 iounmap(ai->pciaux);
2644 iounmap(ai->pcimem);
2684 static struct net_device *init_wifidev(struct airo_info *ai,
2706 struct airo_info *ai = dev->ml_priv;
2708 if (lock && down_interruptible(&ai->sem))
2710 waitbusy (ai);
2711 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2713 waitbusy (ai);
2716 up(&ai->sem);
2721 static int airo_networks_allocate(struct airo_info *ai)
2723 if (ai->networks)
2726 ai->networks =
2729 if (!ai->networks) {
2737 static void airo_networks_free(struct airo_info *ai)
2739 kfree(ai->networks);
2740 ai->networks = NULL;
2743 static void airo_networks_initialize(struct airo_info *ai)
2747 INIT_LIST_HEAD(&ai->network_free_list);
2748 INIT_LIST_HEAD(&ai->network_list);
2750 list_add_tail(&ai->networks[i].list,
2751 &ai->network_free_list);
2784 struct airo_info *ai;
2789 dev = alloc_netdev(sizeof(*ai), "", ether_setup);
2795 ai = dev->ml_priv = netdev_priv(dev);
2796 ai->wifidev = NULL;
2797 ai->flags = 1 << FLAG_RADIO_DOWN;
2798 ai->jobs = 0;
2799 ai->dev = dev;
2802 set_bit(FLAG_MPI, &ai->flags);
2804 spin_lock_init(&ai->aux_lock);
2805 sema_init(&ai->sem, 1);
2806 ai->config.len = 0;
2807 ai->pci = pci;
2808 init_waitqueue_head (&ai->thr_wait);
2809 ai->tfm = NULL;
2810 add_airo_dev(ai);
2812 if (airo_networks_allocate (ai))
2814 airo_networks_initialize (ai);
2816 skb_queue_head_init (&ai->txq);
2819 if (test_bit(FLAG_MPI,&ai->flags))
2824 ai->wireless_data.spy_data = &ai->spy_data;
2825 dev->wireless_data = &ai->wireless_data;
2842 if (test_bit(FLAG_MPI,&ai->flags)) {
2843 if (mpi_map_card(ai, pci)) {
2850 if (setup_card(ai, dev->dev_addr, 1) != SUCCESS) {
2855 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2856 ai->bap_read = fast_bap_read;
2857 set_bit(FLAG_FLASHING, &ai->flags);
2866 ai->wifidev = init_wifidev(ai, dev);
2867 if (!ai->wifidev)
2870 rc = readCapabilityRid(ai, &cap_rid, 1);
2876 ai->wep_capable = (cap_rid.softCap & cpu_to_le16(0x02)) ? 1 : 0;
2877 ai->max_wep_idx = (cap_rid.softCap & cpu_to_le16(0x80)) ? 3 : 0;
2889 airo_print_info(ai->dev->name, "WPA supported.");
2891 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2892 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2893 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2894 ai->bssListRidLen = sizeof(BSSListRid);
2896 airo_print_info(ai->dev->name, "WPA unsupported with firmware "
2899 ai->bssListFirst = RID_BSSLISTFIRST;
2900 ai->bssListNext = RID_BSSLISTNEXT;
2901 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2904 set_bit(FLAG_REGISTERED,&ai->flags);
2908 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2910 ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2918 unregister_netdev(ai->wifidev);
2919 free_netdev(ai->wifidev);
2923 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2924 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2925 iounmap(ai->pciaux);
2926 iounmap(ai->pcimem);
2927 mpi_unmap_card(ai->pci);
2933 airo_networks_free(ai);
2935 del_airo_dev(ai);
2948 static int waitbusy (struct airo_info *ai) {
2950 while ((IN4500(ai, COMMAND) & COMMAND_BUSY) && (delay < 10000)) {
2953 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2961 struct airo_info *ai = dev->ml_priv;
2966 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2972 if (!test_bit(FLAG_MPI,&ai->flags))
2974 ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2976 enable_interrupts( ai );
2984 struct airo_info *ai = dev->ml_priv;
2988 clear_bit(JOB_EVENT, &ai->jobs);
2989 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2990 up(&ai->sem);
3000 static void airo_process_scan_results (struct airo_info *ai) {
3008 list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
3009 list_move_tail (&loop_net->list, &ai->network_free_list);
3015 rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
3025 if (!list_empty(&ai->network_free_list)) {
3026 tmp_net = list_entry(ai->network_free_list.next,
3028 list_del(ai->network_free_list.next);
3033 list_add_tail(&tmp_net->list, &ai->network_list);
3038 rc = PC4500_readrid(ai, ai->bssListNext,
3039 &bss, ai->bssListRidLen, 0);
3043 ai->scan_timeout = 0;
3044 clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3045 up(&ai->sem);
3056 wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3061 struct airo_info *ai = dev->ml_priv;
3069 if (test_bit(JOB_DIE, &ai->jobs))
3072 if (ai->jobs) {
3073 locked = down_interruptible(&ai->sem);
3078 add_wait_queue(&ai->thr_wait, &wait);
3081 if (ai->jobs)
3083 if (ai->expires || ai->scan_timeout) {
3084 if (ai->scan_timeout &&
3085 time_after_eq(jiffies,ai->scan_timeout)){
3086 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3088 } else if (ai->expires &&
3089 time_after_eq(jiffies,ai->expires)){
3090 set_bit(JOB_AUTOWEP, &ai->jobs);
3096 if (!ai->expires || !ai->scan_timeout) {
3097 wake_at = max(ai->expires,
3098 ai->scan_timeout);
3100 wake_at = min(ai->expires,
3101 ai->scan_timeout);
3114 remove_wait_queue(&ai->thr_wait, &wait);
3121 if (test_bit(JOB_DIE, &ai->jobs)) {
3122 up(&ai->sem);
3126 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3127 up(&ai->sem);
3131 if (test_bit(JOB_XMIT, &ai->jobs))
3133 else if (test_bit(JOB_XMIT11, &ai->jobs))
3135 else if (test_bit(JOB_STATS, &ai->jobs))
3137 else if (test_bit(JOB_WSTATS, &ai->jobs))
3138 airo_read_wireless_stats(ai);
3139 else if (test_bit(JOB_PROMISC, &ai->jobs))
3140 airo_set_promisc(ai);
3141 else if (test_bit(JOB_MIC, &ai->jobs))
3142 micinit(ai);
3143 else if (test_bit(JOB_EVENT, &ai->jobs))
3145 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3147 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3148 airo_process_scan_results(ai);
3150 up(&ai->sem);
3171 static void airo_handle_cisco_mic(struct airo_info *ai)
3173 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) {
3174 set_bit(JOB_MIC, &ai->jobs);
3175 wake_up_interruptible(&ai->thr_wait);
3240 static void airo_handle_link(struct airo_info *ai)
3247 status = le16_to_cpu(IN4500(ai, LINKSTAT));
3248 OUT4500(ai, EVACK, EV_LINK);
3250 if ((status == STAT_FORCELOSS) && (ai->scan_timeout > 0))
3253 airo_print_status(ai->dev->name, status);
3257 ai->expires = 0;
3258 if (ai->list_bss_task)
3259 wake_up_process(ai->list_bss_task);
3260 set_bit(FLAG_UPDATE_UNI, &ai->flags);
3261 set_bit(FLAG_UPDATE_MULTI, &ai->flags);
3263 if (down_trylock(&ai->sem) != 0) {
3264 set_bit(JOB_EVENT, &ai->jobs);
3265 wake_up_interruptible(&ai->thr_wait);
3267 airo_send_event(ai->dev);
3269 if (auto_wep && !ai->expires) {
3270 ai->expires = RUN_AT(3*HZ);
3271 wake_up_interruptible(&ai->thr_wait);
3277 wireless_send_event(ai->dev, SIOCGIWAP, &wrqu, NULL);
3281 static void airo_handle_rx(struct airo_info *ai)
3289 if (test_bit(FLAG_MPI, &ai->flags)) {
3290 if (test_bit(FLAG_802_11, &ai->flags))
3291 mpi_receive_802_11(ai);
3293 mpi_receive_802_3(ai);
3294 OUT4500(ai, EVACK, EV_RX);
3298 fid = IN4500(ai, RXFID);
3301 if (test_bit(FLAG_802_11, &ai->flags)) {
3302 bap_setup (ai, fid, 4, BAP0);
3303 bap_read (ai, (__le16*)&hdr, sizeof(hdr), BAP0);
3307 if (ai->wifidev == NULL)
3310 bap_setup(ai, fid, 0x36, BAP0);
3311 bap_read(ai, &hdr.len, 2, BAP0);
3316 airo_print_err(ai->dev->name, "Bad size %d", len);
3322 if (test_bit(FLAG_802_11, &ai->flags)) {
3323 bap_read(ai, &fc, sizeof (fc), BAP0);
3330 ai->dev->stats.rx_dropped++;
3336 if (test_bit(FLAG_802_11, &ai->flags)) {
3338 bap_read(ai, buffer + 1, hdrlen - 2, BAP0);
3340 bap_read(ai, tmpbuf, 6, BAP0);
3342 bap_read(ai, &v, sizeof(v), BAP0);
3346 bap_read(ai, tmpbuf, gap, BAP0);
3348 airo_print_err(ai->dev->name, "gaplen too "
3352 bap_read(ai, buffer + hdrlen/2, len, BAP0);
3356 bap_read(ai, buffer, ETH_ALEN * 2, BAP0);
3357 if (ai->micstats.enabled) {
3358 bap_read(ai, (__le16 *) &micbuf, sizeof (micbuf), BAP0);
3360 bap_setup(ai, fid, 0x44, BAP0);
3372 bap_read(ai, buffer + ETH_ALEN, len, BAP0);
3373 if (decapsulate(ai, &micbuf, (etherHead*) buffer, len))
3380 if (success && (ai->spy_data.spy_number > 0)) {
3385 if (!test_bit(FLAG_802_11, &ai->flags)) {
3387 bap_setup(ai, fid, 8, BAP0);
3388 bap_read(ai, (__le16 *) hdr.rssi, 2, BAP0);
3392 if (ai->rssi)
3393 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3396 wstats.noise = ai->wstats.qual.noise;
3401 wireless_spy_update(ai->dev, sa, &wstats);
3406 OUT4500(ai, EVACK, EV_RX);
3409 if (test_bit(FLAG_802_11, &ai->flags)) {
3412 skb->dev = ai->wifidev;
3415 skb->protocol = eth_type_trans(skb, ai->dev);
3422 static void airo_handle_tx(struct airo_info *ai, u16 status)
3427 if (test_bit(FLAG_MPI, &ai->flags)) {
3431 get_tx_error(ai, -1);
3433 spin_lock_irqsave(&ai->aux_lock, flags);
3434 if (!skb_queue_empty(&ai->txq)) {
3435 spin_unlock_irqrestore(&ai->aux_lock,flags);
3436 mpi_send_packet(ai->dev);
3438 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
3439 spin_unlock_irqrestore(&ai->aux_lock,flags);
3440 netif_wake_queue(ai->dev);
3442 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3446 fid = IN4500(ai, TXCOMPLFID);
3449 if ((ai->fids[i] & 0xffff) == fid) {
3450 len = ai->fids[i] >> 16;
3457 get_tx_error(ai, index);
3459 OUT4500(ai, EVACK, status & (EV_TX | EV_TXEXC));
3462 ai->fids[index] &= 0xffff;
3464 if (!test_bit(FLAG_PENDING_XMIT, &ai->flags))
3465 netif_wake_queue(ai->dev);
3467 if (!test_bit(FLAG_PENDING_XMIT11, &ai->flags))
3468 netif_wake_queue(ai->wifidev);
3471 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3472 airo_print_err(ai->dev->name, "Unallocated FID was used to xmit");
3480 struct airo_info *ai = dev->ml_priv;
3487 status = IN4500(ai, EVSTAT);
3494 OUT4500(ai, EVACK, EV_AWAKE);
3495 OUT4500(ai, EVACK, EV_AWAKE);
3499 savedInterrupts = IN4500(ai, EVINTEN);
3500 OUT4500(ai, EVINTEN, 0);
3504 OUT4500(ai, EVACK, EV_MIC);
3505 airo_handle_cisco_mic(ai);
3510 airo_handle_link(ai);
3515 airo_handle_rx(ai);
3519 airo_handle_tx(ai, status);
3522 airo_print_warn(ai->dev->name, "Got weird status %x",
3528 OUT4500(ai, EVINTEN, savedInterrupts);
3542 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3543 if (test_bit(FLAG_MPI,&ai->flags))
3546 outw( val, ai->dev->base_addr + reg );
3548 outb( val & 0xff, ai->dev->base_addr + reg );
3549 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3553 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3556 if (test_bit(FLAG_MPI,&ai->flags))
3559 rc = inw( ai->dev->base_addr + reg );
3561 rc = inb( ai->dev->base_addr + reg );
3562 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3567 static int enable_MAC(struct airo_info *ai, int lock)
3579 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3581 if (lock && down_interruptible(&ai->sem))
3584 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3587 rc = issuecommand(ai, &cmd, &rsp);
3589 set_bit(FLAG_ENABLED, &ai->flags);
3594 up(&ai->sem);
3597 airo_print_err(ai->dev->name, "Cannot enable MAC");
3599 airo_print_err(ai->dev->name, "Bad MAC enable reason=%x, "
3606 static void disable_MAC( struct airo_info *ai, int lock ) {
3610 if (lock && down_interruptible(&ai->sem))
3613 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3616 issuecommand(ai, &cmd, &rsp);
3617 clear_bit(FLAG_ENABLED, &ai->flags);
3620 up(&ai->sem);
3623 static void enable_interrupts( struct airo_info *ai ) {
3625 OUT4500( ai, EVINTEN, STATUS_INTS );
3628 static void disable_interrupts( struct airo_info *ai ) {
3629 OUT4500( ai, EVINTEN, 0 );
3632 static void mpi_receive_802_3(struct airo_info *ai)
3641 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3650 ai->dev->stats.rx_dropped++;
3654 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3655 if (ai->micstats.enabled) {
3657 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3668 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3670 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3676 if (ai->spy_data.spy_number > 0) {
3685 wireless_spy_update(ai->dev, sa, &wstats);
3690 skb->protocol = eth_type_trans(skb, ai->dev);
3698 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3702 static void mpi_receive_802_11(struct airo_info *ai)
3711 char *ptr = ai->rxfids[0].virtual_host_addr + 4;
3713 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3719 if (ai->wifidev == NULL)
3723 airo_print_err(ai->dev->name, "Bad size %d", len);
3734 ai->dev->stats.rx_dropped++;
3748 airo_print_err(ai->dev->name,
3754 if (ai->spy_data.spy_number > 0) {
3760 if (ai->rssi)
3761 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3764 wstats.noise = ai->wstats.qual.noise;
3769 wireless_spy_update(ai->dev, sa, &wstats);
3774 skb->dev = ai->wifidev;
3784 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3788 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3799 kfree (ai->flash);
3800 ai->flash = NULL;
3805 if (lock && down_interruptible(&ai->sem))
3807 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3809 up(&ai->sem);
3812 disable_MAC( ai, 0);
3815 if (!test_bit(FLAG_MPI,&ai->flags)) {
3817 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3819 up(&ai->sem);
3820 airo_print_err(ai->dev->name, "Error checking for AUX port");
3824 ai->bap_read = fast_bap_read;
3825 airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3827 ai->bap_read = aux_bap_read;
3828 airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3832 up(&ai->sem);
3833 if (ai->config.len == 0) {
3838 kfree(ai->APList);
3839 ai->APList = NULL;
3840 kfree(ai->SSID);
3841 ai->SSID = NULL;
3843 status = readConfigRid(ai, lock);
3846 status = readCapabilityRid(ai, &cap_rid, lock);
3849 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3851 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3852 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3855 kfree(ai->rssi);
3856 ai->rssi = NULL;
3858 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3860 airo_print_warn(ai->dev->name, "unknown received signal "
3863 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3864 ai->config.authType = AUTH_OPEN;
3865 ai->config.modulation = MOD_CCK;
3869 micsetup(ai) == SUCCESS) {
3870 ai->config.opmode |= MODE_MIC;
3871 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3876 mac[i] = ai->config.macAddr[i];
3882 memset(ai->config.rates,0,sizeof(ai->config.rates));
3884 ai->config.rates[i] = rates[i];
3889 if ( ai->config.rates[i] == basic_rate ||
3890 !ai->config.rates ) {
3891 ai->config.rates[i] = basic_rate | 0x80;
3896 set_bit (FLAG_COMMIT, &ai->flags);
3912 status = writeConfigRid(ai, lock);
3917 status = writeSsidRid(ai, &mySsid, lock);
3921 status = enable_MAC(ai, lock);
3926 rc = readWepKeyRid(ai, &wkr, 1, lock);
3930 ai->defindex = wkr.mac[0];
3932 rc = readWepKeyRid(ai, &wkr, 0, lock);
3935 try_auto_wep(ai);
3940 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3944 if (IN4500(ai, EVSTAT) & EV_CMD)
3945 OUT4500(ai, EVACK, EV_CMD);
3947 OUT4500(ai, PARAM0, pCmd->parm0);
3948 OUT4500(ai, PARAM1, pCmd->parm1);
3949 OUT4500(ai, PARAM2, pCmd->parm2);
3950 OUT4500(ai, COMMAND, pCmd->cmd);
3952 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3953 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3955 OUT4500(ai, COMMAND, pCmd->cmd);
3961 airo_print_err(ai->dev->name,
3963 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3964 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3969 pRsp->status = IN4500(ai, STATUS);
3970 pRsp->rsp0 = IN4500(ai, RESP0);
3971 pRsp->rsp1 = IN4500(ai, RESP1);
3972 pRsp->rsp2 = IN4500(ai, RESP2);
3974 airo_print_err(ai->dev->name,
3980 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3981 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3984 OUT4500(ai, EVACK, EV_CMD);
3992 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3997 OUT4500(ai, SELECT0+whichbap, rid);
3998 OUT4500(ai, OFFSET0+whichbap, offset);
4000 int status = IN4500(ai, OFFSET0+whichbap);
4009 airo_print_err(ai->dev->name, "BAP error %x %d",
4016 airo_print_err(ai->dev->name,
4021 OUT4500(ai, SELECT0+whichbap, rid);
4022 OUT4500(ai, OFFSET0+whichbap, offset);
4030 static u16 aux_setup(struct airo_info *ai, u16 page,
4035 OUT4500(ai, AUXPAGE, page);
4036 OUT4500(ai, AUXOFF, 0);
4037 next = IN4500(ai, AUXDATA);
4038 *len = IN4500(ai, AUXDATA)&0xff;
4039 if (offset != 4) OUT4500(ai, AUXOFF, offset);
4044 static int aux_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4055 spin_lock_irqsave(&ai->aux_lock, flags);
4056 page = IN4500(ai, SWS0+whichbap);
4057 offset = IN4500(ai, SWS2+whichbap);
4058 next = aux_setup(ai, page, offset, &len);
4065 insw( ai->dev->base_addr+DATA0+whichbap,
4068 insb( ai->dev->base_addr+DATA0+whichbap,
4072 next = aux_setup(ai, next, 4, &len);
4075 spin_unlock_irqrestore(&ai->aux_lock, flags);
4081 static int fast_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4086 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4088 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4093 static int bap_write(struct airo_info *ai, const __le16 *pu16Src,
4098 outsw( ai->dev->base_addr+DATA0+whichbap,
4101 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4105 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4114 status = issuecommand(ai, &cmd, &rsp);
4124 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4130 if (down_interruptible(&ai->sem))
4133 if (test_bit(FLAG_MPI,&ai->flags)) {
4139 ai->config_desc.rid_desc.valid = 1;
4140 ai->config_desc.rid_desc.len = RIDSIZE;
4141 ai->config_desc.rid_desc.rid = 0;
4142 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4147 memcpy_toio(ai->config_desc.card_ram_off,
4148 &ai->config_desc.rid_desc, sizeof(Rid));
4150 rc = issuecommand(ai, &cmd, &rsp);
4155 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4158 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4162 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4167 bap_read(ai, pBuf, 2, BAP1);
4172 airo_print_err(ai->dev->name,
4179 rc = bap_read(ai, ((__le16*)pBuf)+1, len, BAP1);
4183 up(&ai->sem);
4189 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4198 if (down_interruptible(&ai->sem))
4201 if (test_bit(FLAG_MPI,&ai->flags)) {
4205 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4206 airo_print_err(ai->dev->name,
4212 ai->config_desc.rid_desc.valid = 1;
4213 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4214 ai->config_desc.rid_desc.rid = 0;
4219 memcpy_toio(ai->config_desc.card_ram_off,
4220 &ai->config_desc.rid_desc, sizeof(Rid));
4223 airo_print_err(ai->dev->name, "%s: len=%d", __func__, len);
4226 memcpy((char *)ai->config_desc.virtual_host_addr,
4229 rc = issuecommand(ai, &cmd, &rsp);
4231 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4233 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4242 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4247 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4251 bap_write(ai, pBuf, len, BAP1);
4253 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4257 up(&ai->sem);
4263 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4273 if (down_interruptible(&ai->sem))
4275 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4286 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4293 txFid = IN4500(ai, TXALLOCFID);
4294 OUT4500(ai, EVACK, EV_ALLOC);
4307 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4310 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4313 up(&ai->sem);
4321 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4333 airo_print_warn(ai->dev->name, "Short packet %d", len);
4338 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4340 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4346 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4350 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4351 bap_write(ai, (__le16*)pPacket, sizeof(etherHead), BAP1);
4353 bap_write(ai, (__le16*)&pMic, miclen, BAP1);
4354 bap_write(ai, (__le16*)(pPacket + sizeof(etherHead)), len, BAP1);
4359 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4364 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4379 airo_print_warn(ai->dev->name, "Short packet %d", len);
4385 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4389 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4390 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4391 bap_write(ai, (__le16 *)pPacket, hdrlen, BAP1);
4392 bap_write(ai, (__le16 *)(tail + (hdrlen - 10)), 38 - hdrlen, BAP1);
4394 bap_write(ai, (__le16 *)(pPacket + hdrlen), len - hdrlen, BAP1);
4399 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4819 static inline int sniffing_mode(struct airo_info *ai)
4821 return (le16_to_cpu(ai->config.rmode) & le16_to_cpu(RXMODE_MASK)) >=
4830 struct airo_info *ai = dev->ml_priv;
4835 readConfigRid(ai, 1);
4836 set_bit (FLAG_COMMIT, &ai->flags);
4843 if (sniffing_mode(ai))
4844 set_bit (FLAG_RESET, &ai->flags);
4845 ai->config.rmode &= ~RXMODE_FULL_MASK;
4846 clear_bit (FLAG_802_11, &ai->flags);
4847 ai->config.opmode &= ~MODE_CFG_MASK;
4848 ai->config.scanMode = SCANMODE_ACTIVE;
4850 ai->config.opmode |= MODE_STA_IBSS;
4852 ai->config.opmode |= MODE_STA_ESS;
4854 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4855 ai->config.scanMode = SCANMODE_PASSIVE;
4856 set_bit (FLAG_802_11, &ai->flags);
4858 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4859 ai->config.scanMode = SCANMODE_PASSIVE;
4860 set_bit (FLAG_802_11, &ai->flags);
4862 ai->config.rmode |= RXMODE_LANMON;
4864 set_bit (FLAG_COMMIT, &ai->flags);
4871 set_bit (FLAG_RADIO_OFF, &ai->flags);
4873 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4881 memset( ai->config.nodeName, 0, 16 );
4884 ai->config.nodeName[j] = line[j];
4886 set_bit (FLAG_COMMIT, &ai->flags);
4893 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4894 set_bit (FLAG_COMMIT, &ai->flags);
4896 ai->config.powerSaveMode = POWERSAVE_PSP;
4897 set_bit (FLAG_COMMIT, &ai->flags);
4899 ai->config.powerSaveMode = POWERSAVE_CAM;
4900 set_bit (FLAG_COMMIT, &ai->flags);
4908 ai->config.rates[k++] = (u8)v;
4912 set_bit (FLAG_COMMIT, &ai->flags);
4918 ai->config.channelSet = cpu_to_le16(v);
4919 set_bit (FLAG_COMMIT, &ai->flags);
4926 ai->config.txPower = cpu_to_le16(v);
4927 set_bit (FLAG_COMMIT, &ai->flags);
4933 ai->config.authType = AUTH_SHAREDKEY;
4936 ai->config.authType = AUTH_ENCRYPT;
4939 ai->config.authType = AUTH_OPEN;
4942 set_bit (FLAG_COMMIT, &ai->flags);
4949 ai->config.longRetryLimit = cpu_to_le16(v);
4950 set_bit (FLAG_COMMIT, &ai->flags);
4957 ai->config.shortRetryLimit = cpu_to_le16(v);
4958 set_bit (FLAG_COMMIT, &ai->flags);
4965 ai->config.rtsThres = cpu_to_le16(v);
4966 set_bit (FLAG_COMMIT, &ai->flags);
4973 ai->config.txLifetime = cpu_to_le16(v);
4974 set_bit (FLAG_COMMIT, &ai->flags);
4981 ai->config.rxLifetime = cpu_to_le16(v);
4982 set_bit (FLAG_COMMIT, &ai->flags);
4984 ai->config.txDiversity =
4987 set_bit (FLAG_COMMIT, &ai->flags);
4989 ai->config.rxDiversity =
4992 set_bit (FLAG_COMMIT, &ai->flags);
5000 ai->config.fragThresh = cpu_to_le16(v);
5001 set_bit (FLAG_COMMIT, &ai->flags);
5005 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
5006 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
5007 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
5008 default: airo_print_warn(ai->dev->name, "Unknown modulation");
5013 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
5014 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
5015 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
5016 default: airo_print_warn(ai->dev->name, "Unknown preamble");
5019 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
5042 struct airo_info *ai = dev->ml_priv;
5061 readConfigRid(ai, 1);
5063 mode = ai->config.opmode & MODE_CFG_MASK;
5073 mode == MODE_STA_ESS ? get_rmode(ai->config.rmode):
5076 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5077 ai->config.nodeName,
5078 ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" :
5079 ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" :
5080 ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" :
5082 (int)ai->config.rates[0],
5083 (int)ai->config.rates[1],
5084 (int)ai->config.rates[2],
5085 (int)ai->config.rates[3],
5086 (int)ai->config.rates[4],
5087 (int)ai->config.rates[5],
5088 (int)ai->config.rates[6],
5089 (int)ai->config.rates[7],
5090 le16_to_cpu(ai->config.channelSet),
5091 le16_to_cpu(ai->config.txPower)
5105 le16_to_cpu(ai->config.longRetryLimit),
5106 le16_to_cpu(ai->config.shortRetryLimit),
5107 le16_to_cpu(ai->config.rtsThres),
5108 le16_to_cpu(ai->config.txLifetime),
5109 le16_to_cpu(ai->config.rxLifetime),
5110 ai->config.txDiversity == 1 ? "left" :
5111 ai->config.txDiversity == 2 ? "right" : "both",
5112 ai->config.rxDiversity == 1 ? "left" :
5113 ai->config.rxDiversity == 2 ? "right" : "both",
5114 le16_to_cpu(ai->config.fragThresh),
5115 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5116 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5117 ai->config.modulation == MOD_DEFAULT ? "default" :
5118 ai->config.modulation == MOD_CCK ? "cck" :
5119 ai->config.modulation == MOD_MOK ? "mok" : "error",
5120 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5121 ai->config.preamble == PREAMBLE_LONG ? "long" :
5122 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5133 struct airo_info *ai = dev->ml_priv;
5160 disable_MAC(ai, 1);
5161 writeSsidRid(ai, &SSID_rid, 1);
5162 enable_MAC(ai, 1);
5169 struct airo_info *ai = dev->ml_priv;
5193 disable_MAC(ai, 1);
5194 writeAPListRid(ai, &APList_rid, 1);
5195 enable_MAC(ai, 1);
5199 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5203 disable_MAC(ai, 1);
5204 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5205 enable_MAC(ai, 1);
5212 static int get_wep_key(struct airo_info *ai, u16 index, char *buf, u16 buflen)
5218 rc = readWepKeyRid(ai, &wkr, 1, 1);
5228 rc = readWepKeyRid(ai, &wkr, 0, 1);
5235 static int get_wep_tx_idx(struct airo_info *ai)
5241 rc = readWepKeyRid(ai, &wkr, 1, 1);
5248 rc = readWepKeyRid(ai, &wkr, 0, 1);
5255 static int set_wep_key(struct airo_info *ai, u16 index, const char *key,
5272 if (perm) disable_MAC(ai, lock);
5273 rc = writeWepKeyRid(ai, &wkr, perm, lock);
5274 if (perm) enable_MAC(ai, lock);
5278 static int set_wep_tx_idx(struct airo_info *ai, u16 index, int perm, int lock)
5289 ai->defindex = (char)index;
5290 disable_MAC(ai, lock);
5293 rc = writeWepKeyRid(ai, &wkr, perm, lock);
5296 enable_MAC(ai, lock);
5304 struct airo_info *ai = dev->ml_priv;
5319 rc = set_wep_tx_idx(ai, index, 1, 1);
5321 airo_print_err(ai->dev->name, "failed to set "
5329 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5344 rc = set_wep_key(ai, index, key, i/3, 1, 1);
5346 airo_print_err(ai->dev->name, "failed to set WEP key at index "
5356 struct airo_info *ai = dev->ml_priv;
5382 rc = readWepKeyRid(ai, &wkr, 1, 1);
5393 readWepKeyRid(ai, &wkr, 0, 1);
5405 struct airo_info *ai = dev->ml_priv;
5427 readSsidRid(ai, &SSID_rid);
5449 struct airo_info *ai = dev->ml_priv;
5470 readAPListRid(ai, &APList_rid);
5489 struct airo_info *ai = dev->ml_priv;
5513 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5516 if (down_interruptible(&ai->sem))
5518 issuecommand(ai, &cmd, &rsp);
5519 up(&ai->sem);
5529 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5542 rc = readBSSListRid(ai, 0, &BSSList_rid);
5638 struct airo_info *ai = dev->ml_priv;
5642 if (!ai->APList)
5643 ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL);
5644 if (!ai->APList)
5646 if (!ai->SSID)
5647 ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL);
5648 if (!ai->SSID)
5650 readAPListRid(ai, ai->APList);
5651 readSsidRid(ai, ai->SSID);
5654 if (down_interruptible(&ai->sem))
5656 disable_MAC(ai, 0);
5658 ai->power = state;
5660 issuecommand(ai, &cmd, &rsp);
5671 struct airo_info *ai = dev->ml_priv;
5680 mpi_init_descriptors(ai);
5681 setup_card(ai, dev->dev_addr, 0);
5682 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5683 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5685 OUT4500(ai, EVACK, EV_AWAKEN);
5686 OUT4500(ai, EVACK, EV_AWAKEN);
5690 set_bit(FLAG_COMMIT, &ai->flags);
5691 disable_MAC(ai, 0);
5693 if (ai->SSID) {
5694 writeSsidRid(ai, ai->SSID, 0);
5695 kfree(ai->SSID);
5696 ai->SSID = NULL;
5698 if (ai->APList) {
5699 writeAPListRid(ai, ai->APList, 0);
5700 kfree(ai->APList);
5701 ai->APList = NULL;
5703 writeConfigRid(ai, 0);
5704 enable_MAC(ai, 0);
5705 ai->power = PMSG_ON;
5708 enable_interrupts(ai);
5709 up(&ai->sem);
5753 struct airo_info *ai;
5755 ai = list_entry(airo_devices.next, struct airo_info, dev_list);
5756 airo_print_info(ai->dev->name, "Unregistering...");
5757 stop_airo_card(ai->dev, 1);
6358 static inline int valid_index(struct airo_info *ai, int index)
6360 return (index >= 0) && (index <= ai->max_wep_idx);
7270 struct airo_info *ai = dev->ml_priv;
7281 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7283 if (down_interruptible(&ai->sem))
7288 if (ai->scan_timeout > 0)
7292 ai->scan_timeout = RUN_AT(3*HZ);
7295 issuecommand(ai, &cmd, &rsp);
7299 up(&ai->sem);
7301 wake_up_interruptible(&ai->thr_wait);
7316 struct airo_info *ai = dev->ml_priv;
7366 if (ai->rssi) {
7368 iwe.u.qual.qual = airo_dbm_to_pct(ai->rssi, dBm);
7379 iwe.u.qual.noise = ai->wstats.qual.noise;
7428 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7492 struct airo_info *ai = dev->ml_priv;
7498 if (ai->scan_timeout > 0)
7501 if (down_interruptible(&ai->sem))
7504 list_for_each_entry (net, &ai->network_list, list) {
7523 up(&ai->sem);
7681 struct airo_info *ai = dev->ml_priv;
7683 if (ai->power.event)
7834 struct airo_info *ai = dev->ml_priv;
7836 if (test_bit(FLAG_FLASHING, &ai->flags))
7843 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7844 disable_MAC (ai, 1);
7845 writeConfigRid (ai, 1);
7846 enable_MAC(ai, 1);
7867 if (copy_to_user(comp->data, &ai->micstats,
7868 min((int)comp->len,(int)sizeof(ai->micstats))))
7880 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7900 struct airo_info *ai = dev->ml_priv;
7910 if (test_bit(FLAG_FLASHING, &ai->flags))
7921 case AIROPCFG: ai->config.len = 0;
7922 clear_bit(FLAG_COMMIT, &ai->flags);
7936 if (enable_MAC(ai, 1) != 0)
7945 disable_MAC(ai, 1);
7956 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7958 enabled = ai->micstats.enabled;
7959 memset(&ai->micstats,0,sizeof(ai->micstats));
7960 ai->micstats.enabled = enabled;
7987 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7991 set_bit (FLAG_ADHOC, &ai->flags);
7993 clear_bit (FLAG_ADHOC, &ai->flags);
7996 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
8072 static int cmdreset(struct airo_info *ai) {
8073 disable_MAC(ai, 1);
8075 if(!waitbusy (ai)){
8076 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
8080 OUT4500(ai,COMMAND,CMD_SOFTRESET);
8084 if(!waitbusy (ai)){
8085 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
8096 static int setflashmode (struct airo_info *ai) {
8097 set_bit (FLAG_FLASHING, &ai->flags);
8099 OUT4500(ai, SWS0, FLASH_COMMAND);
8100 OUT4500(ai, SWS1, FLASH_COMMAND);
8102 OUT4500(ai, SWS0, FLASH_COMMAND);
8103 OUT4500(ai, COMMAND,0x10);
8105 OUT4500(ai, SWS2, FLASH_COMMAND);
8106 OUT4500(ai, SWS3, FLASH_COMMAND);
8107 OUT4500(ai, COMMAND,0);
8111 if(!waitbusy(ai)) {
8112 clear_bit (FLAG_FLASHING, &ai->flags);
8113 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
8123 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
8135 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8142 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8148 OUT4500(ai,SWS0,byte);
8151 echo = IN4500(ai,SWS1);
8154 OUT4500(ai,SWS1,0);
8163 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
8168 rchar = IN4500(ai,SWS1);
8178 OUT4500(ai,SWS1,0);
8183 OUT4500(ai,SWS1,0);
8194 static int flashputbuf(struct airo_info *ai){
8198 if (test_bit(FLAG_MPI,&ai->flags))
8199 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8201 OUT4500(ai,AUXPAGE,0x100);
8202 OUT4500(ai,AUXOFF,0);
8205 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8208 OUT4500(ai,SWS0,0x8000);
8216 static int flashrestart(struct airo_info *ai,struct net_device *dev){
8220 clear_bit (FLAG_FLASHING, &ai->flags);
8221 if (test_bit(FLAG_MPI, &ai->flags)) {
8222 status = mpi_init_descriptors(ai);
8226 status = setup_card(ai, dev->dev_addr, 1);
8228 if (!test_bit(FLAG_MPI,&ai->flags))
8230 ai->fids[i] = transmit_allocate
8231 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );