Lines Matching refs:ai
1114 static int enable_MAC(struct airo_info *ai, int lock);
1115 static void disable_MAC(struct airo_info *ai, int lock);
1138 static void mpi_receive_802_3(struct airo_info *ai);
1139 static void mpi_receive_802_11(struct airo_info *ai);
1140 static int waitbusy(struct airo_info *ai);
1153 static void micinit(struct airo_info *ai);
1154 static int micsetup(struct airo_info *ai);
1155 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1156 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1161 static void airo_networks_free(struct airo_info *ai);
1258 static inline int bap_read(struct airo_info *ai, __le16 *pu16Dst, int bytelen,
1261 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1269 static int cmdreset(struct airo_info *ai);
1270 static int setflashmode(struct airo_info *ai);
1271 static int flashgchar(struct airo_info *ai, int matchbyte, int dwelltime);
1272 static int flashputbuf(struct airo_info *ai);
1273 static int flashrestart(struct airo_info *ai, struct net_device *dev);
1297 static int RxSeqValid(struct airo_info *ai, miccntx *context, int mcast, u32 micSeq);
1304 static int flashpchar(struct airo_info *ai, int byte, int dwelltime);
1331 static void micinit(struct airo_info *ai)
1335 clear_bit(JOB_MIC, &ai->jobs);
1336 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1337 up(&ai->sem);
1339 ai->micstats.enabled = (le16_to_cpu(mic_rid.state) & 0x00FF) ? 1 : 0;
1340 if (!ai->micstats.enabled) {
1344 ai->mod[0].uCtx.valid = 0;
1345 ai->mod[0].mCtx.valid = 0;
1350 age_mic_context(&ai->mod[0].mCtx, &ai->mod[1].mCtx,
1352 ai->tfm);
1356 age_mic_context(&ai->mod[0].uCtx, &ai->mod[1].uCtx,
1358 ai->tfm);
1364 static int micsetup(struct airo_info *ai)
1368 if (ai->tfm == NULL)
1369 ai->tfm = crypto_alloc_sync_skcipher("ctr(aes)", 0, 0);
1371 if (IS_ERR(ai->tfm)) {
1372 airo_print_err(ai->dev->name, "failed to load transform for AES");
1373 ai->tfm = NULL;
1378 memset(&ai->mod[i].mCtx, 0, sizeof(miccntx));
1379 memset(&ai->mod[i].uCtx, 0, sizeof(miccntx));
1402 static int encapsulate(struct airo_info *ai, etherHead *frame, MICBuffer *mic, int payLen)
1409 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1410 context = &ai->mod[0].mCtx;
1412 context = &ai->mod[0].uCtx;
1458 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1468 if (!ai->micstats.enabled) {
1471 ai->micstats.rxMICPlummed++;
1482 ai->micstats.rxMICPlummed++;
1493 ai->micstats.rxWrongSequence++;
1500 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1529 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1530 ai->micstats.rxSuccess++;
1539 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1540 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1541 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1562 static int RxSeqValid(struct airo_info *ai, miccntx *context, int mcast, u32 micSeq)
1570 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1571 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1575 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1576 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1745 static int readBSSListRid(struct airo_info *ai, int first,
1752 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1755 if (down_interruptible(&ai->sem))
1757 ai->list_bss_task = current;
1758 issuecommand(ai, &cmd, &rsp);
1759 up(&ai->sem);
1762 ai->list_bss_task = NULL;
1764 return PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
1765 list, ai->bssListRidLen, 1);
1768 static int readWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int temp, int lock)
1770 return PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1774 static int writeWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int perm, int lock)
1777 rc = PC4500_writerid(ai, RID_WEP_TEMP, wkr, sizeof(*wkr), lock);
1779 airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1781 rc = PC4500_writerid(ai, RID_WEP_PERM, wkr, sizeof(*wkr), lock);
1783 airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1788 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr)
1790 return PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1793 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock)
1795 return PC4500_writerid(ai, RID_SSID, pssidr, sizeof(*pssidr), lock);
1798 static int readConfigRid(struct airo_info *ai, int lock)
1803 if (ai->config.len)
1806 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1810 ai->config = cfg;
1814 static inline void checkThrottle(struct airo_info *ai)
1818 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1820 if (ai->config.rates[i] > maxencrypt) {
1821 ai->config.rates[i] = 0;
1827 static int writeConfigRid(struct airo_info *ai, int lock)
1831 if (!test_bit (FLAG_COMMIT, &ai->flags))
1834 clear_bit (FLAG_COMMIT, &ai->flags);
1835 clear_bit (FLAG_RESET, &ai->flags);
1836 checkThrottle(ai);
1837 cfgr = ai->config;
1840 set_bit(FLAG_ADHOC, &ai->flags);
1842 clear_bit(FLAG_ADHOC, &ai->flags);
1844 return PC4500_writerid(ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1847 static int readStatusRid(struct airo_info *ai, StatusRid *statr, int lock)
1849 return PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1852 static int writeAPListRid(struct airo_info *ai, APListRid *aplr, int lock)
1854 return PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1857 static int readCapabilityRid(struct airo_info *ai, CapabilityRid *capr, int lock)
1859 return PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1862 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock)
1864 return PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1867 static void try_auto_wep(struct airo_info *ai)
1869 if (auto_wep && !test_bit(FLAG_RADIO_DOWN, &ai->flags)) {
1870 ai->expires = RUN_AT(3*HZ);
1871 wake_up_interruptible(&ai->thr_wait);
1877 struct airo_info *ai = dev->ml_priv;
1880 if (test_bit(FLAG_FLASHING, &ai->flags))
1887 if (test_bit(FLAG_COMMIT, &ai->flags)) {
1888 disable_MAC(ai, 1);
1889 writeConfigRid(ai, 1);
1892 if (ai->wifidev != dev) {
1893 clear_bit(JOB_DIE, &ai->jobs);
1894 ai->airo_thread_task = kthread_run(airo_thread, dev, "%s",
1896 if (IS_ERR(ai->airo_thread_task))
1897 return (int)PTR_ERR(ai->airo_thread_task);
1905 set_bit(JOB_DIE, &ai->jobs);
1906 kthread_stop(ai->airo_thread_task);
1911 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
1912 enable_interrupts(ai);
1914 try_auto_wep(ai);
1916 enable_MAC(ai, 1);
1927 struct airo_info *ai = dev->ml_priv;
1937 npacks = skb_queue_len (&ai->txq);
1945 skb_queue_tail (&ai->txq, skb);
1949 spin_lock_irqsave(&ai->aux_lock, flags);
1950 skb_queue_tail (&ai->txq, skb);
1951 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1952 spin_unlock_irqrestore(&ai->aux_lock, flags);
1956 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1975 struct airo_info *ai = dev->ml_priv;
1980 if ((skb = skb_dequeue(&ai->txq)) == NULL) {
1991 ai->txfids[0].tx_desc.offset = 0;
1992 ai->txfids[0].tx_desc.valid = 1;
1993 ai->txfids[0].tx_desc.eoc = 1;
1994 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
2004 memcpy(ai->txfids[0].virtual_host_addr,
2007 payloadLen = (__le16 *)(ai->txfids[0].virtual_host_addr +
2009 sendbuf = ai->txfids[0].virtual_host_addr +
2016 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2020 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2024 ai->txfids[0].tx_desc.len += sizeof(pMic);
2041 memcpy_toio(ai->txfids[0].card_ram_off,
2042 &ai->txfids[0].tx_desc, sizeof(TxFid));
2044 OUT4500(ai, EVACK, 8);
2050 static void get_tx_error(struct airo_info *ai, s32 fid)
2055 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2057 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2059 bap_read(ai, &status, 2, BAP0);
2062 ai->dev->stats.tx_aborted_errors++;
2064 ai->dev->stats.tx_heartbeat_errors++;
2068 ai->dev->stats.tx_carrier_errors++;
2083 bap_read(ai, (__le16 *) junk, 0x18, BAP0);
2097 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2254 struct airo_info *ai = dev->ml_priv;
2258 clear_bit(JOB_STATS, &ai->jobs);
2259 if (ai->power.event) {
2260 up(&ai->sem);
2263 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2264 up(&ai->sem);
2302 static void airo_set_promisc(struct airo_info *ai)
2309 clear_bit(JOB_PROMISC, &ai->jobs);
2310 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2311 issuecommand(ai, &cmd, &rsp);
2312 up(&ai->sem);
2317 struct airo_info *ai = dev->ml_priv;
2319 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2320 change_bit(FLAG_PROMISC, &ai->flags);
2321 if (down_trylock(&ai->sem) != 0) {
2322 set_bit(JOB_PROMISC, &ai->jobs);
2323 wake_up_interruptible(&ai->thr_wait);
2325 airo_set_promisc(ai);
2335 struct airo_info *ai = dev->ml_priv;
2338 readConfigRid(ai, 1);
2339 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2340 set_bit (FLAG_COMMIT, &ai->flags);
2341 disable_MAC(ai, 1);
2342 writeConfigRid (ai, 1);
2343 enable_MAC(ai, 1);
2344 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2345 if (ai->wifidev)
2346 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2352 static void add_airo_dev(struct airo_info *ai)
2356 if (!ai->pci)
2357 list_add_tail(&ai->dev_list, &airo_devices);
2360 static void del_airo_dev(struct airo_info *ai)
2362 if (!ai->pci)
2363 list_del(&ai->dev_list);
2368 struct airo_info *ai = dev->ml_priv;
2372 if (ai->wifidev != dev) {
2379 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2380 disable_MAC(ai, 1);
2382 disable_interrupts(ai);
2386 set_bit(JOB_DIE, &ai->jobs);
2387 kthread_stop(ai->airo_thread_task);
2394 struct airo_info *ai = dev->ml_priv;
2396 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2397 disable_MAC(ai, 1);
2398 disable_interrupts(ai);
2399 takedown_proc_entry(dev, ai);
2400 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2402 if (ai->wifidev) {
2403 unregister_netdev(ai->wifidev);
2404 free_netdev(ai->wifidev);
2405 ai->wifidev = NULL;
2407 clear_bit(FLAG_REGISTERED, &ai->flags);
2412 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2414 for (;(skb = skb_dequeue(&ai->txq));)
2418 airo_networks_free (ai);
2420 kfree(ai->flash);
2421 kfree(ai->rssi);
2422 kfree(ai->SSID);
2426 if (test_bit(FLAG_MPI, &ai->flags)) {
2427 if (ai->pci)
2428 mpi_unmap_card(ai->pci);
2429 if (ai->pcimem)
2430 iounmap(ai->pcimem);
2431 if (ai->pciaux)
2432 iounmap(ai->pciaux);
2433 dma_free_coherent(&ai->pci->dev, PCI_SHARED_LEN,
2434 ai->shared, ai->shared_dma);
2437 crypto_free_sync_skcipher(ai->tfm);
2438 del_airo_dev(ai);
2468 static int mpi_init_descriptors (struct airo_info *ai)
2476 netif_stop_queue(ai->dev);
2483 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2485 rc = issuecommand(ai, &cmd, &rsp);
2487 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2492 memcpy_toio(ai->rxfids[i].card_ram_off,
2493 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2503 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2507 ai->txfids[i].tx_desc.valid = 1;
2508 memcpy_toio(ai->txfids[i].card_ram_off,
2509 &ai->txfids[i].tx_desc, sizeof(TxFid));
2511 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2513 rc = issuecommand(ai, &cmd, &rsp);
2515 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2525 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2527 rc = issuecommand(ai, &cmd, &rsp);
2529 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2533 memcpy_toio(ai->config_desc.card_ram_off,
2534 &ai->config_desc.rid_desc, sizeof(Rid));
2545 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci)
2570 ai->pcimem = ioremap(mem_start, mem_len);
2571 if (!ai->pcimem) {
2576 ai->pciaux = ioremap(aux_start, aux_len);
2577 if (!ai->pciaux) {
2584 ai->shared = dma_alloc_coherent(&pci->dev, PCI_SHARED_LEN,
2585 &ai->shared_dma, GFP_KERNEL);
2586 if (!ai->shared) {
2595 busaddroff = ai->shared_dma;
2596 pciaddroff = ai->pciaux + AUX_OFFSET;
2597 vpackoff = ai->shared;
2601 ai->rxfids[i].pending = 0;
2602 ai->rxfids[i].card_ram_off = pciaddroff;
2603 ai->rxfids[i].virtual_host_addr = vpackoff;
2604 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2605 ai->rxfids[i].rx_desc.valid = 1;
2606 ai->rxfids[i].rx_desc.len = PKTSIZE;
2607 ai->rxfids[i].rx_desc.rdy = 0;
2616 ai->txfids[i].card_ram_off = pciaddroff;
2617 ai->txfids[i].virtual_host_addr = vpackoff;
2618 ai->txfids[i].tx_desc.valid = 1;
2619 ai->txfids[i].tx_desc.host_addr = busaddroff;
2620 memcpy(ai->txfids[i].virtual_host_addr,
2627 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2630 ai->config_desc.card_ram_off = pciaddroff;
2631 ai->config_desc.virtual_host_addr = vpackoff;
2632 ai->config_desc.rid_desc.host_addr = busaddroff;
2633 ai->ridbus = busaddroff;
2634 ai->config_desc.rid_desc.rid = 0;
2635 ai->config_desc.rid_desc.len = RIDSIZE;
2636 ai->config_desc.rid_desc.valid = 1;
2642 if (mpi_init_descriptors (ai) != SUCCESS)
2647 dma_free_coherent(&pci->dev, PCI_SHARED_LEN, ai->shared,
2648 ai->shared_dma);
2650 iounmap(ai->pciaux);
2652 iounmap(ai->pcimem);
2693 static struct net_device *init_wifidev(struct airo_info *ai,
2717 struct airo_info *ai = dev->ml_priv;
2719 if (lock && down_interruptible(&ai->sem))
2721 waitbusy (ai);
2722 OUT4500(ai, COMMAND, CMD_SOFTRESET);
2724 waitbusy (ai);
2727 up(&ai->sem);
2732 static int airo_networks_allocate(struct airo_info *ai)
2734 if (ai->networks)
2737 ai->networks = kcalloc(AIRO_MAX_NETWORK_COUNT, sizeof(BSSListElement),
2739 if (!ai->networks) {
2747 static void airo_networks_free(struct airo_info *ai)
2749 kfree(ai->networks);
2750 ai->networks = NULL;
2753 static void airo_networks_initialize(struct airo_info *ai)
2757 INIT_LIST_HEAD(&ai->network_free_list);
2758 INIT_LIST_HEAD(&ai->network_list);
2760 list_add_tail(&ai->networks[i].list,
2761 &ai->network_free_list);
2792 struct airo_info *ai;
2797 dev = alloc_netdev(sizeof(*ai), "", NET_NAME_UNKNOWN, ether_setup);
2803 ai = dev->ml_priv = netdev_priv(dev);
2804 ai->wifidev = NULL;
2805 ai->flags = 1 << FLAG_RADIO_DOWN;
2806 ai->jobs = 0;
2807 ai->dev = dev;
2810 set_bit(FLAG_MPI, &ai->flags);
2812 spin_lock_init(&ai->aux_lock);
2813 sema_init(&ai->sem, 1);
2814 ai->config.len = 0;
2815 ai->pci = pci;
2816 init_waitqueue_head (&ai->thr_wait);
2817 ai->tfm = NULL;
2818 add_airo_dev(ai);
2819 ai->APList.len = cpu_to_le16(sizeof(struct APListRid));
2821 if (airo_networks_allocate (ai))
2823 airo_networks_initialize (ai);
2825 skb_queue_head_init (&ai->txq);
2828 if (test_bit(FLAG_MPI,&ai->flags))
2833 ai->wireless_data.spy_data = &ai->spy_data;
2834 dev->wireless_data = &ai->wireless_data;
2853 if (test_bit(FLAG_MPI,&ai->flags)) {
2854 if (mpi_map_card(ai, pci)) {
2861 if (setup_card(ai, dev->dev_addr, 1) != SUCCESS) {
2866 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2867 ai->bap_read = fast_bap_read;
2868 set_bit(FLAG_FLASHING, &ai->flags);
2877 ai->wifidev = init_wifidev(ai, dev);
2878 if (!ai->wifidev)
2881 rc = readCapabilityRid(ai, &cap_rid, 1);
2887 ai->wep_capable = (cap_rid.softCap & cpu_to_le16(0x02)) ? 1 : 0;
2888 ai->max_wep_idx = (cap_rid.softCap & cpu_to_le16(0x80)) ? 3 : 0;
2900 airo_print_info(ai->dev->name, "WPA supported.");
2902 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2903 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2904 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2905 ai->bssListRidLen = sizeof(BSSListRid);
2907 airo_print_info(ai->dev->name, "WPA unsupported with firmware "
2910 ai->bssListFirst = RID_BSSLISTFIRST;
2911 ai->bssListNext = RID_BSSLISTNEXT;
2912 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2915 set_bit(FLAG_REGISTERED,&ai->flags);
2919 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2921 ai->fids[i] = transmit_allocate(ai, AIRO_DEF_MTU, i>=MAX_FIDS/2);
2929 unregister_netdev(ai->wifidev);
2930 free_netdev(ai->wifidev);
2934 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2935 dma_free_coherent(&pci->dev, PCI_SHARED_LEN, ai->shared,
2936 ai->shared_dma);
2937 iounmap(ai->pciaux);
2938 iounmap(ai->pcimem);
2939 mpi_unmap_card(ai->pci);
2945 airo_networks_free(ai);
2947 del_airo_dev(ai);
2960 static int waitbusy (struct airo_info *ai)
2963 while ((IN4500(ai, COMMAND) & COMMAND_BUSY) && (delay < 10000)) {
2966 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2974 struct airo_info *ai = dev->ml_priv;
2979 if (setup_card(ai, dev->dev_addr, 1) != SUCCESS) {
2985 if (!test_bit(FLAG_MPI,&ai->flags))
2987 ai->fids[i] = transmit_allocate (ai, AIRO_DEF_MTU, i>=MAX_FIDS/2);
2989 enable_interrupts(ai);
2998 struct airo_info *ai = dev->ml_priv;
3002 clear_bit(JOB_EVENT, &ai->jobs);
3003 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
3004 up(&ai->sem);
3014 static void airo_process_scan_results (struct airo_info *ai)
3023 list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
3024 list_move_tail (&loop_net->list, &ai->network_free_list);
3030 rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
3040 if (!list_empty(&ai->network_free_list)) {
3041 tmp_net = list_entry(ai->network_free_list.next,
3043 list_del(ai->network_free_list.next);
3048 list_add_tail(&tmp_net->list, &ai->network_list);
3053 rc = PC4500_readrid(ai, ai->bssListNext,
3054 &bss, ai->bssListRidLen, 0);
3059 disable_MAC(ai, 2);
3060 writeAPListRid(ai, &ai->APList, 0);
3061 enable_MAC(ai, 0);
3063 ai->scan_timeout = 0;
3064 clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3065 up(&ai->sem);
3076 wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3082 struct airo_info *ai = dev->ml_priv;
3090 if (test_bit(JOB_DIE, &ai->jobs))
3093 if (ai->jobs) {
3094 locked = down_interruptible(&ai->sem);
3099 add_wait_queue(&ai->thr_wait, &wait);
3102 if (ai->jobs)
3104 if (ai->expires || ai->scan_timeout) {
3105 if (ai->scan_timeout &&
3106 time_after_eq(jiffies, ai->scan_timeout)) {
3107 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3109 } else if (ai->expires &&
3110 time_after_eq(jiffies, ai->expires)) {
3111 set_bit(JOB_AUTOWEP, &ai->jobs);
3117 if (!ai->expires || !ai->scan_timeout) {
3118 wake_at = max(ai->expires,
3119 ai->scan_timeout);
3121 wake_at = min(ai->expires,
3122 ai->scan_timeout);
3135 remove_wait_queue(&ai->thr_wait, &wait);
3142 if (test_bit(JOB_DIE, &ai->jobs)) {
3143 up(&ai->sem);
3147 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3148 up(&ai->sem);
3152 if (test_bit(JOB_XMIT, &ai->jobs))
3154 else if (test_bit(JOB_XMIT11, &ai->jobs))
3156 else if (test_bit(JOB_STATS, &ai->jobs))
3158 else if (test_bit(JOB_WSTATS, &ai->jobs))
3159 airo_read_wireless_stats(ai);
3160 else if (test_bit(JOB_PROMISC, &ai->jobs))
3161 airo_set_promisc(ai);
3162 else if (test_bit(JOB_MIC, &ai->jobs))
3163 micinit(ai);
3164 else if (test_bit(JOB_EVENT, &ai->jobs))
3166 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3168 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3169 airo_process_scan_results(ai);
3171 up(&ai->sem);
3192 static void airo_handle_cisco_mic(struct airo_info *ai)
3194 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) {
3195 set_bit(JOB_MIC, &ai->jobs);
3196 wake_up_interruptible(&ai->thr_wait);
3261 static void airo_handle_link(struct airo_info *ai)
3268 status = le16_to_cpu(IN4500(ai, LINKSTAT));
3269 OUT4500(ai, EVACK, EV_LINK);
3271 if ((status == STAT_FORCELOSS) && (ai->scan_timeout > 0))
3274 airo_print_status(ai->dev->name, status);
3278 ai->expires = 0;
3279 if (ai->list_bss_task)
3280 wake_up_process(ai->list_bss_task);
3281 set_bit(FLAG_UPDATE_UNI, &ai->flags);
3282 set_bit(FLAG_UPDATE_MULTI, &ai->flags);
3284 if (down_trylock(&ai->sem) != 0) {
3285 set_bit(JOB_EVENT, &ai->jobs);
3286 wake_up_interruptible(&ai->thr_wait);
3288 airo_send_event(ai->dev);
3289 netif_carrier_on(ai->dev);
3291 if (auto_wep && !ai->expires) {
3292 ai->expires = RUN_AT(3*HZ);
3293 wake_up_interruptible(&ai->thr_wait);
3299 wireless_send_event(ai->dev, SIOCGIWAP, &wrqu, NULL);
3300 netif_carrier_off(ai->dev);
3302 netif_carrier_off(ai->dev);
3306 static void airo_handle_rx(struct airo_info *ai)
3314 if (test_bit(FLAG_MPI, &ai->flags)) {
3315 if (test_bit(FLAG_802_11, &ai->flags))
3316 mpi_receive_802_11(ai);
3318 mpi_receive_802_3(ai);
3319 OUT4500(ai, EVACK, EV_RX);
3323 fid = IN4500(ai, RXFID);
3326 if (test_bit(FLAG_802_11, &ai->flags)) {
3327 bap_setup (ai, fid, 4, BAP0);
3328 bap_read (ai, (__le16*)&hdr, sizeof(hdr), BAP0);
3332 if (ai->wifidev == NULL)
3335 bap_setup(ai, fid, 0x36, BAP0);
3336 bap_read(ai, &hdr.len, 2, BAP0);
3341 airo_print_err(ai->dev->name, "Bad size %d", len);
3347 if (test_bit(FLAG_802_11, &ai->flags)) {
3348 bap_read(ai, &fc, sizeof (fc), BAP0);
3355 ai->dev->stats.rx_dropped++;
3361 if (test_bit(FLAG_802_11, &ai->flags)) {
3363 bap_read(ai, buffer + 1, hdrlen - 2, BAP0);
3365 bap_read(ai, tmpbuf, 6, BAP0);
3367 bap_read(ai, &v, sizeof(v), BAP0);
3371 bap_read(ai, tmpbuf, gap, BAP0);
3373 airo_print_err(ai->dev->name, "gaplen too "
3377 bap_read(ai, buffer + hdrlen/2, len, BAP0);
3381 bap_read(ai, buffer, ETH_ALEN * 2, BAP0);
3382 if (ai->micstats.enabled) {
3383 bap_read(ai, (__le16 *) &micbuf, sizeof (micbuf), BAP0);
3385 bap_setup(ai, fid, 0x44, BAP0);
3397 bap_read(ai, buffer + ETH_ALEN, len, BAP0);
3398 if (decapsulate(ai, &micbuf, (etherHead*) buffer, len))
3405 if (success && (ai->spy_data.spy_number > 0)) {
3410 if (!test_bit(FLAG_802_11, &ai->flags)) {
3412 bap_setup(ai, fid, 8, BAP0);
3413 bap_read(ai, (__le16 *) hdr.rssi, 2, BAP0);
3417 if (ai->rssi)
3418 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3421 wstats.noise = ai->wstats.qual.noise;
3426 wireless_spy_update(ai->dev, sa, &wstats);
3431 OUT4500(ai, EVACK, EV_RX);
3434 if (test_bit(FLAG_802_11, &ai->flags)) {
3437 skb->dev = ai->wifidev;
3440 skb->protocol = eth_type_trans(skb, ai->dev);
3447 static void airo_handle_tx(struct airo_info *ai, u16 status)
3452 if (test_bit(FLAG_MPI, &ai->flags)) {
3456 get_tx_error(ai, -1);
3458 spin_lock_irqsave(&ai->aux_lock, flags);
3459 if (!skb_queue_empty(&ai->txq)) {
3460 spin_unlock_irqrestore(&ai->aux_lock, flags);
3461 mpi_send_packet(ai->dev);
3463 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
3464 spin_unlock_irqrestore(&ai->aux_lock, flags);
3465 netif_wake_queue(ai->dev);
3467 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3471 fid = IN4500(ai, TXCOMPLFID);
3474 if ((ai->fids[i] & 0xffff) == fid)
3480 get_tx_error(ai, index);
3482 OUT4500(ai, EVACK, status & (EV_TX | EV_TXEXC));
3485 ai->fids[index] &= 0xffff;
3487 if (!test_bit(FLAG_PENDING_XMIT, &ai->flags))
3488 netif_wake_queue(ai->dev);
3490 if (!test_bit(FLAG_PENDING_XMIT11, &ai->flags))
3491 netif_wake_queue(ai->wifidev);
3494 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3495 airo_print_err(ai->dev->name, "Unallocated FID was used to xmit");
3503 struct airo_info *ai = dev->ml_priv;
3510 status = IN4500(ai, EVSTAT);
3517 OUT4500(ai, EVACK, EV_AWAKE);
3518 OUT4500(ai, EVACK, EV_AWAKE);
3522 savedInterrupts = IN4500(ai, EVINTEN);
3523 OUT4500(ai, EVINTEN, 0);
3527 OUT4500(ai, EVACK, EV_MIC);
3528 airo_handle_cisco_mic(ai);
3533 airo_handle_link(ai);
3538 airo_handle_rx(ai);
3542 airo_handle_tx(ai, status);
3545 airo_print_warn(ai->dev->name, "Got weird status %x",
3551 OUT4500(ai, EVINTEN, savedInterrupts);
3565 static void OUT4500(struct airo_info *ai, u16 reg, u16 val)
3567 if (test_bit(FLAG_MPI,&ai->flags))
3570 outw(val, ai->dev->base_addr + reg);
3572 outb(val & 0xff, ai->dev->base_addr + reg);
3573 outb(val >> 8, ai->dev->base_addr + reg + 1);
3577 static u16 IN4500(struct airo_info *ai, u16 reg)
3581 if (test_bit(FLAG_MPI,&ai->flags))
3584 rc = inw(ai->dev->base_addr + reg);
3586 rc = inb(ai->dev->base_addr + reg);
3587 rc += ((int)inb(ai->dev->base_addr + reg + 1)) << 8;
3592 static int enable_MAC(struct airo_info *ai, int lock)
3604 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3606 if (lock && down_interruptible(&ai->sem))
3609 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3612 rc = issuecommand(ai, &cmd, &rsp);
3614 set_bit(FLAG_ENABLED, &ai->flags);
3619 up(&ai->sem);
3622 airo_print_err(ai->dev->name, "Cannot enable MAC");
3624 airo_print_err(ai->dev->name, "Bad MAC enable reason=%x, "
3631 static void disable_MAC(struct airo_info *ai, int lock)
3636 if (lock == 1 && down_interruptible(&ai->sem))
3639 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3641 netif_carrier_off(ai->dev);
3644 issuecommand(ai, &cmd, &rsp);
3645 clear_bit(FLAG_ENABLED, &ai->flags);
3648 up(&ai->sem);
3651 static void enable_interrupts(struct airo_info *ai)
3654 OUT4500(ai, EVINTEN, STATUS_INTS);
3657 static void disable_interrupts(struct airo_info *ai)
3659 OUT4500(ai, EVINTEN, 0);
3662 static void mpi_receive_802_3(struct airo_info *ai)
3671 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3680 ai->dev->stats.rx_dropped++;
3684 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3685 if (ai->micstats.enabled) {
3687 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3698 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3700 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3706 if (ai->spy_data.spy_number > 0) {
3715 wireless_spy_update(ai->dev, sa, &wstats);
3720 skb->protocol = eth_type_trans(skb, ai->dev);
3728 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3732 static void mpi_receive_802_11(struct airo_info *ai)
3741 char *ptr = ai->rxfids[0].virtual_host_addr + 4;
3743 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3749 if (ai->wifidev == NULL)
3753 airo_print_err(ai->dev->name, "Bad size %d", len);
3764 ai->dev->stats.rx_dropped++;
3778 airo_print_err(ai->dev->name,
3784 if (ai->spy_data.spy_number > 0) {
3790 if (ai->rssi)
3791 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3794 wstats.noise = ai->wstats.qual.noise;
3799 wireless_spy_update(ai->dev, sa, &wstats);
3804 skb->dev = ai->wifidev;
3814 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3828 static int noinline_for_stack airo_readconfig(struct airo_info *ai, u8 *mac, int lock)
3837 kfree(ai->SSID);
3838 ai->SSID = NULL;
3840 status = readConfigRid(ai, lock);
3843 status = readCapabilityRid(ai, &cap_rid, lock);
3846 status = PC4500_readrid(ai, RID_RSSI, &rssi_rid, sizeof(rssi_rid), lock);
3848 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3849 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3852 kfree(ai->rssi);
3853 ai->rssi = NULL;
3855 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3857 airo_print_warn(ai->dev->name, "unknown received signal "
3860 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3861 set_auth_type(ai, AUTH_OPEN);
3862 ai->config.modulation = MOD_CCK;
3866 micsetup(ai) == SUCCESS) {
3867 ai->config.opmode |= MODE_MIC;
3868 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3873 mac[i] = ai->config.macAddr[i];
3879 memset(ai->config.rates, 0, sizeof(ai->config.rates));
3881 ai->config.rates[i] = rates[i];
3884 set_bit (FLAG_COMMIT, &ai->flags);
3890 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3901 kfree (ai->flash);
3902 ai->flash = NULL;
3907 if (lock && down_interruptible(&ai->sem))
3909 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3911 up(&ai->sem);
3914 disable_MAC(ai, 0);
3917 if (!test_bit(FLAG_MPI,&ai->flags)) {
3919 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3921 up(&ai->sem);
3922 airo_print_err(ai->dev->name, "Error checking for AUX port");
3926 ai->bap_read = fast_bap_read;
3927 airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3929 ai->bap_read = aux_bap_read;
3930 airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3934 up(&ai->sem);
3935 if (ai->config.len == 0) {
3936 status = airo_readconfig(ai, mac, lock);
3954 status = writeConfigRid(ai, lock);
3959 status = writeSsidRid(ai, &mySsid, lock);
3963 status = enable_MAC(ai, lock);
3968 rc = readWepKeyRid(ai, &wkr, 1, lock);
3972 ai->defindex = wkr.mac[0];
3974 rc = readWepKeyRid(ai, &wkr, 0, lock);
3977 try_auto_wep(ai);
3982 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp)
3987 if (IN4500(ai, EVSTAT) & EV_CMD)
3988 OUT4500(ai, EVACK, EV_CMD);
3990 OUT4500(ai, PARAM0, pCmd->parm0);
3991 OUT4500(ai, PARAM1, pCmd->parm1);
3992 OUT4500(ai, PARAM2, pCmd->parm2);
3993 OUT4500(ai, COMMAND, pCmd->cmd);
3995 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3996 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3998 OUT4500(ai, COMMAND, pCmd->cmd);
4004 airo_print_err(ai->dev->name,
4006 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
4007 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
4012 pRsp->status = IN4500(ai, STATUS);
4013 pRsp->rsp0 = IN4500(ai, RESP0);
4014 pRsp->rsp1 = IN4500(ai, RESP1);
4015 pRsp->rsp2 = IN4500(ai, RESP2);
4017 airo_print_err(ai->dev->name,
4023 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
4024 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
4027 OUT4500(ai, EVACK, EV_CMD);
4035 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap)
4040 OUT4500(ai, SELECT0+whichbap, rid);
4041 OUT4500(ai, OFFSET0+whichbap, offset);
4043 int status = IN4500(ai, OFFSET0+whichbap);
4052 airo_print_err(ai->dev->name, "BAP error %x %d",
4059 airo_print_err(ai->dev->name,
4064 OUT4500(ai, SELECT0+whichbap, rid);
4065 OUT4500(ai, OFFSET0+whichbap, offset);
4073 static u16 aux_setup(struct airo_info *ai, u16 page,
4078 OUT4500(ai, AUXPAGE, page);
4079 OUT4500(ai, AUXOFF, 0);
4080 next = IN4500(ai, AUXDATA);
4081 *len = IN4500(ai, AUXDATA)&0xff;
4082 if (offset != 4) OUT4500(ai, AUXOFF, offset);
4087 static int aux_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4098 spin_lock_irqsave(&ai->aux_lock, flags);
4099 page = IN4500(ai, SWS0+whichbap);
4100 offset = IN4500(ai, SWS2+whichbap);
4101 next = aux_setup(ai, page, offset, &len);
4108 insw(ai->dev->base_addr+DATA0+whichbap,
4111 insb(ai->dev->base_addr+DATA0+whichbap,
4115 next = aux_setup(ai, next, 4, &len);
4118 spin_unlock_irqrestore(&ai->aux_lock, flags);
4124 static int fast_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4129 insw(ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1);
4131 insb(ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen);
4136 static int bap_write(struct airo_info *ai, const __le16 *pu16Src,
4141 outsw(ai->dev->base_addr+DATA0+whichbap,
4144 outsb(ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen);
4148 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4157 status = issuecommand(ai, &cmd, &rsp);
4167 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4173 if (down_interruptible(&ai->sem))
4176 if (test_bit(FLAG_MPI,&ai->flags)) {
4182 ai->config_desc.rid_desc.valid = 1;
4183 ai->config_desc.rid_desc.len = RIDSIZE;
4184 ai->config_desc.rid_desc.rid = 0;
4185 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4190 memcpy_toio(ai->config_desc.card_ram_off,
4191 &ai->config_desc.rid_desc, sizeof(Rid));
4193 rc = issuecommand(ai, &cmd, &rsp);
4198 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4201 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4205 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4210 bap_read(ai, pBuf, 2, BAP1);
4215 airo_print_err(ai->dev->name,
4222 rc = bap_read(ai, ((__le16*)pBuf)+1, len, BAP1);
4226 up(&ai->sem);
4232 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4241 if (down_interruptible(&ai->sem))
4244 if (test_bit(FLAG_MPI,&ai->flags)) {
4248 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4249 airo_print_err(ai->dev->name,
4255 ai->config_desc.rid_desc.valid = 1;
4256 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4257 ai->config_desc.rid_desc.rid = 0;
4262 memcpy_toio(ai->config_desc.card_ram_off,
4263 &ai->config_desc.rid_desc, sizeof(Rid));
4266 airo_print_err(ai->dev->name, "%s: len=%d", __func__, len);
4269 memcpy(ai->config_desc.virtual_host_addr,
4272 rc = issuecommand(ai, &cmd, &rsp);
4274 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4276 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4285 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4290 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4294 bap_write(ai, pBuf, len, BAP1);
4296 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4300 up(&ai->sem);
4306 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4316 if (down_interruptible(&ai->sem))
4318 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4329 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4336 txFid = IN4500(ai, TXALLOCFID);
4337 OUT4500(ai, EVACK, EV_ALLOC);
4350 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4353 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4356 up(&ai->sem);
4364 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4376 airo_print_warn(ai->dev->name, "Short packet %d", len);
4381 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4383 if (encapsulate(ai, (etherHead *)pPacket,&pMic, len) != SUCCESS)
4389 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4393 bap_write(ai, &payloadLen, sizeof(payloadLen), BAP1);
4394 bap_write(ai, (__le16*)pPacket, sizeof(etherHead), BAP1);
4396 bap_write(ai, (__le16*)&pMic, miclen, BAP1);
4397 bap_write(ai, (__le16*)(pPacket + sizeof(etherHead)), len, BAP1);
4402 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4407 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4422 airo_print_warn(ai->dev->name, "Short packet %d", len);
4428 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4432 bap_write(ai, &payloadLen, sizeof(payloadLen), BAP1);
4433 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4434 bap_write(ai, (__le16 *)pPacket, hdrlen, BAP1);
4435 bap_write(ai, (__le16 *)(tail + (hdrlen - 10)), 38 - hdrlen, BAP1);
4437 bap_write(ai, (__le16 *)(pPacket + hdrlen), len - hdrlen, BAP1);
4442 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4817 static inline int sniffing_mode(struct airo_info *ai)
4819 return (le16_to_cpu(ai->config.rmode) & le16_to_cpu(RXMODE_MASK)) >=
4827 struct airo_info *ai = dev->ml_priv;
4832 readConfigRid(ai, 1);
4833 set_bit (FLAG_COMMIT, &ai->flags);
4840 if (sniffing_mode(ai))
4841 set_bit (FLAG_RESET, &ai->flags);
4842 ai->config.rmode &= ~RXMODE_FULL_MASK;
4843 clear_bit (FLAG_802_11, &ai->flags);
4844 ai->config.opmode &= ~MODE_CFG_MASK;
4845 ai->config.scanMode = SCANMODE_ACTIVE;
4847 ai->config.opmode |= MODE_STA_IBSS;
4849 ai->config.opmode |= MODE_STA_ESS;
4851 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4852 ai->config.scanMode = SCANMODE_PASSIVE;
4853 set_bit (FLAG_802_11, &ai->flags);
4855 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4856 ai->config.scanMode = SCANMODE_PASSIVE;
4857 set_bit (FLAG_802_11, &ai->flags);
4859 ai->config.rmode |= RXMODE_LANMON;
4861 set_bit (FLAG_COMMIT, &ai->flags);
4868 set_bit (FLAG_RADIO_OFF, &ai->flags);
4870 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4878 memset(ai->config.nodeName, 0, 16);
4881 ai->config.nodeName[j] = line[j];
4883 set_bit (FLAG_COMMIT, &ai->flags);
4890 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4891 set_bit (FLAG_COMMIT, &ai->flags);
4893 ai->config.powerSaveMode = POWERSAVE_PSP;
4894 set_bit (FLAG_COMMIT, &ai->flags);
4896 ai->config.powerSaveMode = POWERSAVE_CAM;
4897 set_bit (FLAG_COMMIT, &ai->flags);
4905 ai->config.rates[k++] = (u8)v;
4909 set_bit (FLAG_COMMIT, &ai->flags);
4915 ai->config.channelSet = cpu_to_le16(v);
4916 set_bit (FLAG_COMMIT, &ai->flags);
4923 ai->config.txPower = cpu_to_le16(v);
4924 set_bit (FLAG_COMMIT, &ai->flags);
4930 set_auth_type(ai, AUTH_SHAREDKEY);
4933 set_auth_type(ai, AUTH_ENCRYPT);
4936 set_auth_type(ai, AUTH_OPEN);
4939 set_bit (FLAG_COMMIT, &ai->flags);
4946 ai->config.longRetryLimit = cpu_to_le16(v);
4947 set_bit (FLAG_COMMIT, &ai->flags);
4954 ai->config.shortRetryLimit = cpu_to_le16(v);
4955 set_bit (FLAG_COMMIT, &ai->flags);
4962 ai->config.rtsThres = cpu_to_le16(v);
4963 set_bit (FLAG_COMMIT, &ai->flags);
4970 ai->config.txLifetime = cpu_to_le16(v);
4971 set_bit (FLAG_COMMIT, &ai->flags);
4978 ai->config.rxLifetime = cpu_to_le16(v);
4979 set_bit (FLAG_COMMIT, &ai->flags);
4981 ai->config.txDiversity =
4984 set_bit (FLAG_COMMIT, &ai->flags);
4986 ai->config.rxDiversity =
4989 set_bit (FLAG_COMMIT, &ai->flags);
4997 ai->config.fragThresh = cpu_to_le16(v);
4998 set_bit (FLAG_COMMIT, &ai->flags);
5002 case 'd': ai->config.modulation = MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
5003 case 'c': ai->config.modulation = MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
5004 case 'm': ai->config.modulation = MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
5005 default: airo_print_warn(ai->dev->name, "Unknown modulation");
5010 case 'a': ai->config.preamble = PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
5011 case 'l': ai->config.preamble = PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
5012 case 's': ai->config.preamble = PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
5013 default: airo_print_warn(ai->dev->name, "Unknown preamble");
5016 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
5038 struct airo_info *ai = dev->ml_priv;
5057 readConfigRid(ai, 1);
5059 mode = ai->config.opmode & MODE_CFG_MASK;
5069 mode == MODE_STA_ESS ? get_rmode(ai->config.rmode):
5072 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5073 ai->config.nodeName,
5074 ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" :
5075 ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" :
5076 ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" :
5078 (int)ai->config.rates[0],
5079 (int)ai->config.rates[1],
5080 (int)ai->config.rates[2],
5081 (int)ai->config.rates[3],
5082 (int)ai->config.rates[4],
5083 (int)ai->config.rates[5],
5084 (int)ai->config.rates[6],
5085 (int)ai->config.rates[7],
5086 le16_to_cpu(ai->config.channelSet),
5087 le16_to_cpu(ai->config.txPower)
5101 le16_to_cpu(ai->config.longRetryLimit),
5102 le16_to_cpu(ai->config.shortRetryLimit),
5103 le16_to_cpu(ai->config.rtsThres),
5104 le16_to_cpu(ai->config.txLifetime),
5105 le16_to_cpu(ai->config.rxLifetime),
5106 ai->config.txDiversity == 1 ? "left" :
5107 ai->config.txDiversity == 2 ? "right" : "both",
5108 ai->config.rxDiversity == 1 ? "left" :
5109 ai->config.rxDiversity == 2 ? "right" : "both",
5110 le16_to_cpu(ai->config.fragThresh),
5111 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5112 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5113 ai->config.modulation == MOD_DEFAULT ? "default" :
5114 ai->config.modulation == MOD_CCK ? "cck" :
5115 ai->config.modulation == MOD_MOK ? "mok" : "error",
5116 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5117 ai->config.preamble == PREAMBLE_LONG ? "long" :
5118 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5128 struct airo_info *ai = dev->ml_priv;
5155 disable_MAC(ai, 1);
5156 writeSsidRid(ai, &SSID_rid, 1);
5157 enable_MAC(ai, 1);
5164 struct airo_info *ai = dev->ml_priv;
5165 APListRid *APList_rid = &ai->APList;
5176 disable_MAC(ai, 1);
5177 writeAPListRid(ai, APList_rid, 1);
5178 enable_MAC(ai, 1);
5182 static int do_writerid(struct airo_info *ai, u16 rid, const void *rid_data,
5187 disable_MAC(ai, 1);
5188 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5189 enable_MAC(ai, 1);
5196 static int get_wep_key(struct airo_info *ai, u16 index, char *buf, u16 buflen)
5202 rc = readWepKeyRid(ai, &wkr, 1, 1);
5212 rc = readWepKeyRid(ai, &wkr, 0, 1);
5219 static int get_wep_tx_idx(struct airo_info *ai)
5225 rc = readWepKeyRid(ai, &wkr, 1, 1);
5232 rc = readWepKeyRid(ai, &wkr, 0, 1);
5239 static int set_wep_key(struct airo_info *ai, u16 index, const u8 *key,
5256 if (perm) disable_MAC(ai, lock);
5257 rc = writeWepKeyRid(ai, &wkr, perm, lock);
5258 if (perm) enable_MAC(ai, lock);
5262 static int set_wep_tx_idx(struct airo_info *ai, u16 index, int perm, int lock)
5273 ai->defindex = (char)index;
5274 disable_MAC(ai, lock);
5277 rc = writeWepKeyRid(ai, &wkr, perm, lock);
5280 enable_MAC(ai, lock);
5288 struct airo_info *ai = dev->ml_priv;
5303 rc = set_wep_tx_idx(ai, index, 1, 1);
5305 airo_print_err(ai->dev->name, "failed to set "
5313 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5325 airo_print_err(ai->dev->name, "WebKey passed invalid key hex");
5338 rc = set_wep_key(ai, index, key, i/3, 1, 1);
5340 airo_print_err(ai->dev->name, "failed to set WEP key at index "
5349 struct airo_info *ai = dev->ml_priv;
5375 rc = readWepKeyRid(ai, &wkr, 1, 1);
5386 readWepKeyRid(ai, &wkr, 0, 1);
5397 struct airo_info *ai = dev->ml_priv;
5419 readSsidRid(ai, &SSID_rid);
5441 struct airo_info *ai = dev->ml_priv;
5444 APListRid *APList_rid = &ai->APList;
5480 struct airo_info *ai = dev->ml_priv;
5504 if (ai->flags & FLAG_RADIO_MASK) {
5511 if (down_interruptible(&ai->sem)) {
5516 issuecommand(ai, &cmd, &rsp);
5517 up(&ai->sem);
5527 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5540 rc = readBSSListRid(ai, 0, &BSSList_rid);
5636 struct airo_info *ai = dev->ml_priv;
5640 if (!ai->SSID)
5641 ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL);
5642 if (!ai->SSID)
5644 readSsidRid(ai, ai->SSID);
5647 if (down_interruptible(&ai->sem))
5649 disable_MAC(ai, 0);
5651 ai->power = PMSG_SUSPEND;
5653 issuecommand(ai, &cmd, &rsp);
5662 struct airo_info *ai = dev->ml_priv;
5669 mpi_init_descriptors(ai);
5670 setup_card(ai, dev->dev_addr, 0);
5671 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5672 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5674 OUT4500(ai, EVACK, EV_AWAKEN);
5675 OUT4500(ai, EVACK, EV_AWAKEN);
5679 set_bit(FLAG_COMMIT, &ai->flags);
5680 disable_MAC(ai, 0);
5682 if (ai->SSID) {
5683 writeSsidRid(ai, ai->SSID, 0);
5684 kfree(ai->SSID);
5685 ai->SSID = NULL;
5687 writeAPListRid(ai, &ai->APList, 0);
5688 writeConfigRid(ai, 0);
5689 enable_MAC(ai, 0);
5690 ai->power = PMSG_ON;
5693 enable_interrupts(ai);
5694 up(&ai->sem);
5740 struct airo_info *ai;
5742 ai = list_entry(airo_devices.next, struct airo_info, dev_list);
5743 airo_print_info(ai->dev->name, "Unregistering...");
5744 stop_airo_card(ai->dev, 1);
6347 static inline int valid_index(struct airo_info *ai, int index)
6349 return (index >= 0) && (index <= ai->max_wep_idx);
7264 struct airo_info *ai = dev->ml_priv;
7276 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7278 if (down_interruptible(&ai->sem))
7283 if (ai->scan_timeout > 0)
7289 disable_MAC(ai, 2);
7290 writeAPListRid(ai, &APList_rid_empty, 0);
7291 enable_MAC(ai, 0);
7294 ai->scan_timeout = RUN_AT(3*HZ);
7297 issuecommand(ai, &cmd, &rsp);
7301 up(&ai->sem);
7303 wake_up_interruptible(&ai->thr_wait);
7318 struct airo_info *ai = dev->ml_priv;
7369 if (ai->rssi) {
7371 iwe.u.qual.qual = airo_dbm_to_pct(ai->rssi, dBm);
7382 iwe.u.qual.noise = ai->wstats.qual.noise;
7431 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7495 struct airo_info *ai = dev->ml_priv;
7501 if (ai->scan_timeout > 0)
7504 if (down_interruptible(&ai->sem))
7507 list_for_each_entry (net, &ai->network_list, list) {
7526 up(&ai->sem);
7682 struct airo_info *ai = dev->ml_priv;
7684 if (ai->power.event)
7836 struct airo_info *ai = dev->ml_priv;
7838 if (test_bit(FLAG_FLASHING, &ai->flags))
7845 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7846 disable_MAC (ai, 1);
7847 writeConfigRid (ai, 1);
7848 enable_MAC(ai, 1);
7861 if (copy_to_user(comp->data, &ai->micstats,
7862 min((int)comp->len, (int)sizeof(ai->micstats))))
7879 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)) {
8073 static int cmdreset(struct airo_info *ai)
8075 disable_MAC(ai, 1);
8077 if (!waitbusy (ai)) {
8078 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
8082 OUT4500(ai, COMMAND, CMD_SOFTRESET);
8086 if (!waitbusy (ai)) {
8087 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
8098 static int setflashmode (struct airo_info *ai)
8100 set_bit (FLAG_FLASHING, &ai->flags);
8102 OUT4500(ai, SWS0, FLASH_COMMAND);
8103 OUT4500(ai, SWS1, FLASH_COMMAND);
8105 OUT4500(ai, SWS0, FLASH_COMMAND);
8106 OUT4500(ai, COMMAND, 0x10);
8108 OUT4500(ai, SWS2, FLASH_COMMAND);
8109 OUT4500(ai, SWS3, FLASH_COMMAND);
8110 OUT4500(ai, COMMAND, 0);
8114 if (!waitbusy(ai)) {
8115 clear_bit (FLAG_FLASHING, &ai->flags);
8116 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
8126 static int flashpchar(struct airo_info *ai, int byte, int dwelltime)
8139 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8146 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8152 OUT4500(ai, SWS0, byte);
8155 echo = IN4500(ai, SWS1);
8158 OUT4500(ai, SWS1, 0);
8167 static int flashgchar(struct airo_info *ai, int matchbyte, int dwelltime)
8173 rchar = IN4500(ai, SWS1);
8183 OUT4500(ai, SWS1, 0);
8188 OUT4500(ai, SWS1, 0);
8199 static int flashputbuf(struct airo_info *ai)
8204 if (test_bit(FLAG_MPI,&ai->flags))
8205 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8207 OUT4500(ai, AUXPAGE, 0x100);
8208 OUT4500(ai, AUXOFF, 0);
8211 OUT4500(ai, AUXDATA, ai->flash[nwords] & 0xffff);
8214 OUT4500(ai, SWS0, 0x8000);
8222 static int flashrestart(struct airo_info *ai, struct net_device *dev)
8227 clear_bit (FLAG_FLASHING, &ai->flags);
8228 if (test_bit(FLAG_MPI, &ai->flags)) {
8229 status = mpi_init_descriptors(ai);
8233 status = setup_card(ai, dev->dev_addr, 1);
8235 if (!test_bit(FLAG_MPI,&ai->flags))
8237 ai->fids[i] = transmit_allocate
8238 (ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2);