/* Called only as a tasklet (software IRQ) */
 static struct ieee80211_frag_entry *
 ieee80211_frag_cache_find(struct ieee80211_device *ieee, unsigned int seq,
-                         unsigned int frag, u8 tid,u8 *src, u8 *dst)
+                         unsigned int frag, u8 tid, u8 *src, u8 *dst)
 {
        struct ieee80211_frag_entry *entry;
        int i;
          tid = 0;
        }
 
-       entry = ieee80211_frag_cache_find(ieee, seq, -1, tid,hdr->addr2,
+       entry = ieee80211_frag_cache_find(ieee, seq, -1, tid, hdr->addr2,
                                          hdr->addr1);
 
        if (entry == NULL) {
 
 static u8 parse_subframe(struct sk_buff *skb,
                         struct ieee80211_rx_stats *rx_stats,
-                        struct ieee80211_rxb *rxb,u8 *src,u8 *dst)
+                        struct ieee80211_rxb *rxb, u8 *src, u8 *dst)
 {
        struct ieee80211_hdr_3addr  *hdr = (struct ieee80211_hdr_3addr *)skb->data;
        u16             fc = le16_to_cpu(hdr->frame_ctl);
 
                        if(skb->len<(ETHERNET_HEADER_SIZE + nSubframe_Length)) {
                                printk("%s: A-MSDU parse error!! pRfd->nTotalSubframe : %d\n",\
-                                               __func__,rxb->nr_subframes);
+                                               __func__, rxb->nr_subframes);
                                printk("%s: A-MSDU parse error!! Subframe Length: %d\n",__func__, nSubframe_Length);
                                printk("nRemain_Length is %d and nSubframe_Length is : %d\n",skb->len,nSubframe_Length);
                                printk("The Packet SeqNum is %d\n",SeqNum);
                        sub_skb = dev_alloc_skb(nSubframe_Length + 12);
                        skb_reserve(sub_skb, 12);
                        data_ptr = (u8 *)skb_put(sub_skb, nSubframe_Length);
-                       memcpy(data_ptr,skb->data,nSubframe_Length);
+                       memcpy(data_ptr, skb->data, nSubframe_Length);
 #endif
                        rxb->subframes[rxb->nr_subframes++] = sub_skb;
                        if(rxb->nr_subframes >= MAX_SUBFRAME_COUNT) {
                                IEEE80211_DEBUG_RX("ParseSubframe(): Too many Subframes! Packets dropped!\n");
                                break;
                        }
-                       skb_pull(skb,nSubframe_Length);
+                       skb_pull(skb, nSubframe_Length);
 
                        if(skb->len != 0) {
                                nPadding_Length = 4 - ((nSubframe_Length + ETHERNET_HEADER_SIZE) % 4);
                                        return 0;
                                }
 
-                               skb_pull(skb,nPadding_Length);
+                               skb_pull(skb, nPadding_Length);
                        }
                }
 #ifdef JOHN_NOCPY
        }
        /* to parse amsdu packets */
        /* qos data packets & reserved bit is 1 */
-       if(parse_subframe(skb,rx_stats,rxb,src,dst) == 0) {
+       if (parse_subframe(skb, rx_stats, rxb, src, dst) == 0) {
                /* only to free rxb, and not submit the packets to upper layer */
                for(i =0; i < rxb->nr_subframes; i++) {
                        dev_kfree_skb(rxb->subframes[i]);
        //added by amy for LEAP
        dst->bWithAironetIE = src->bWithAironetIE;
        dst->bCkipSupported = src->bCkipSupported;
-       memcpy(dst->CcxRmState,src->CcxRmState,2);
+       memcpy(dst->CcxRmState, src->CcxRmState, 2);
        dst->bCcxRmEnable = src->bCcxRmEnable;
        dst->MBssidMask = src->MBssidMask;
        dst->bMBssidValid = src->bMBssidValid;
-       memcpy(dst->MBssid,src->MBssid,6);
+       memcpy(dst->MBssid, src->MBssid, 6);
        dst->bWithCcxVerNum = src->bWithCcxVerNum;
        dst->BssCcxVerNumber = src->BssCcxVerNumber;
 
 
        spin_lock_irqsave(&ieee->lock, flags);
 
        /* called with 2nd param 0, no mgmt lock required */
-       ieee80211_sta_wakeup(ieee,0);
+       ieee80211_sta_wakeup(ieee, 0);
 
        tcb_desc->queue_index = MGNT_QUEUE;
        tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee);
 
        if(single){
                if(ieee->queue_stop){
-                       enqueue_mgmt(ieee,skb);
+                       enqueue_mgmt(ieee, skb);
                }else{
                        header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0]<<4);
 
                        skb_queue_tail(&ieee->skb_waitQ[tcb_desc->queue_index], skb);
                } else {
                        //printk("TX packet!\n");
-                       ieee->softmac_hard_start_xmit(skb,ieee->dev);
+                       ieee->softmac_hard_start_xmit(skb, ieee->dev);
                        //dev_kfree_skb_any(skb);//edit by thomas
                }
                spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags);
                else
                        ieee->seq_ctrl[0]++;
 
-               ieee->softmac_hard_start_xmit(skb,ieee->dev);
+               ieee->softmac_hard_start_xmit(skb, ieee->dev);
 
        }
        //dev_kfree_skb_any(skb);//edit by thomas
 
 inline struct sk_buff *ieee80211_probe_req(struct ieee80211_device *ieee)
 {
-       unsigned int len,rate_len;
+       unsigned int len, rate_len;
        u8 *tag;
        struct sk_buff *skb;
        struct ieee80211_probe_request *req;
        ieee->beacon_txing = 1;
        ieee80211_send_beacon(ieee);
 
-       spin_unlock_irqrestore(&ieee->beacon_lock,flags);
+       spin_unlock_irqrestore(&ieee->beacon_lock, flags);
 }
 
 static void ieee80211_beacons_stop(struct ieee80211_device *ieee)
 {
        unsigned long flags;
 
-       spin_lock_irqsave(&ieee->beacon_lock,flags);
+       spin_lock_irqsave(&ieee->beacon_lock, flags);
 
        ieee->beacon_txing = 0;
        del_timer_sync(&ieee->beacon_timer);
 
-       spin_unlock_irqrestore(&ieee->beacon_lock,flags);
+       spin_unlock_irqrestore(&ieee->beacon_lock, flags);
 
 }
 
 void ieee80211_start_send_beacons(struct ieee80211_device *ieee)
 {
        if(ieee->start_send_beacons)
-               ieee->start_send_beacons(ieee->dev,ieee->basic_rate);
+               ieee->start_send_beacons(ieee->dev, ieee->basic_rate);
        if(ieee->softmac_features & IEEE_SOFTMAC_BEACONS)
                ieee80211_beacons_start(ieee);
 }
        struct ieee80211_probe_response *beacon_buf;
        struct sk_buff *skb = NULL;
        int encrypt;
-       int atim_len,erp_len;
+       int atim_len, erp_len;
        struct ieee80211_crypt_data *crypt;
 
        char *ssid = ieee->current_network.ssid;
 
        *(tag++) = MFIE_TYPE_RATES;
        *(tag++) = rate_len-2;
-       memcpy(tag,ieee->current_network.rates,rate_len-2);
+       memcpy(tag, ieee->current_network.rates, rate_len-2);
        tag+=rate_len-2;
 
        *(tag++) = MFIE_TYPE_DS_SET;
        if(rate_ex_len){
                *(tag++) = MFIE_TYPE_RATES_EX;
                *(tag++) = rate_ex_len-2;
-               memcpy(tag,ieee->current_network.rates_ex,rate_ex_len-2);
+               memcpy(tag, ieee->current_network.rates_ex, rate_ex_len-2);
                tag+=rate_ex_len-2;
        }
 
        skb_reserve(skb, ieee->tx_headroom);
 
        assoc = (struct ieee80211_assoc_response_frame *)
-               skb_put(skb,sizeof(struct ieee80211_assoc_response_frame));
+               skb_put(skb, sizeof(struct ieee80211_assoc_response_frame));
 
        assoc->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP);
        memcpy(assoc->header.addr1, dest,ETH_ALEN);
                u8      CcxAironetBuf[30];
                OCTET_STRING    osCcxAironetIE;
 
-               memset(CcxAironetBuf, 0,30);
+               memset(CcxAironetBuf, 0, 30);
                osCcxAironetIE.Octet = CcxAironetBuf;
                osCcxAironetIE.Length = sizeof(CcxAironetBuf);
                //
                tag = skb_put(skb, ckip_ie_len);
                *tag++ = MFIE_TYPE_AIRONET;
                *tag++ = osCcxAironetIE.Length;
-               memcpy(tag,osCcxAironetIE.Octet,osCcxAironetIE.Length);
+               memcpy(tag, osCcxAironetIE.Octet, osCcxAironetIE.Length);
                tag += osCcxAironetIE.Length;
        }
 
 
                osCcxRmCap.Octet = CcxRmCapBuf;
                osCcxRmCap.Length = sizeof(CcxRmCapBuf);
-               tag = skb_put(skb,ccxrm_ie_len);
+               tag = skb_put(skb, ccxrm_ie_len);
                *tag++ = MFIE_TYPE_GENERIC;
                *tag++ = osCcxRmCap.Length;
-               memcpy(tag,osCcxRmCap.Octet,osCcxRmCap.Length);
+               memcpy(tag, osCcxRmCap.Octet, osCcxRmCap.Length);
                tag += osCcxRmCap.Length;
        }
 
                CcxVerNumBuf[4] = beacon->BssCcxVerNumber;
                osCcxVerNum.Octet = CcxVerNumBuf;
                osCcxVerNum.Length = sizeof(CcxVerNumBuf);
-               tag = skb_put(skb,cxvernum_ie_len);
+               tag = skb_put(skb, cxvernum_ie_len);
                *tag++ = MFIE_TYPE_GENERIC;
                *tag++ = osCcxVerNum.Length;
-               memcpy(tag,osCcxVerNum.Octet,osCcxVerNum.Length);
+               memcpy(tag, osCcxVerNum.Octet, osCcxVerNum.Length);
                tag += osCcxVerNum.Length;
        }
        //HT cap element
                memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len);
        }
 
-       tag = skb_put(skb,wmm_info_len);
+       tag = skb_put(skb, wmm_info_len);
        if(wmm_info_len) {
          ieee80211_WMM_Info(ieee, &tag);
        }
 #ifdef THOMAS_TURBO
-       tag = skb_put(skb,turbo_info_len);
+       tag = skb_put(skb, turbo_info_len);
        if(turbo_info_len) {
                ieee80211_TURBO_Info(ieee, &tag);
        }
                        tag = skb_put(skb, ht_cap_len);
                        *tag++ = MFIE_TYPE_GENERIC;
                        *tag++ = ht_cap_len - 2;
-                       memcpy(tag, ht_cap_buf,ht_cap_len - 2);
+                       memcpy(tag, ht_cap_buf, ht_cap_len - 2);
                        tag += ht_cap_len -2;
                }
 
        u8 tmp_ssid[IW_ESSID_MAX_SIZE+1];
        int tmp_ssid_len = 0;
 
-       short apset,ssidset,ssidbroad,apmatch,ssidmatch;
+       short apset, ssidset, ssidbroad, apmatch, ssidmatch;
 
        /* we are interested in new new only if we are not associated
         * and we are not associating / authenticating
 static inline void ieee80211_sta_ps(struct ieee80211_device *ieee)
 {
 
-       u32 th,tl;
+       u32 th, tl;
        short sleep;
 
-       unsigned long flags,flags2;
+       unsigned long flags, flags2;
 
        spin_lock_irqsave(&ieee->lock, flags);
 
        if(sleep == 1){
 
                if(ieee->sta_sleep == 1)
-                       ieee->enter_sleep_state(ieee->dev,th,tl);
+                       ieee->enter_sleep_state(ieee->dev, th, tl);
 
                else if(ieee->sta_sleep == 0){
                //      printk("send null 1\n");
 
                                ieee->ps_request_tx_ack(ieee->dev);
 
-                               ieee80211_sta_ps_send_null_frame(ieee,1);
+                               ieee80211_sta_ps_send_null_frame(ieee, 1);
 
                                ieee->ps_th = th;
                                ieee->ps_tl = tl;
 //#warning CHECK_LOCK_HERE
                spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
 
-               ieee80211_sta_wakeup(ieee,1);
+               ieee80211_sta_wakeup(ieee, 1);
 
                spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
        }
 
 void ieee80211_ps_tx_ack(struct ieee80211_device *ieee, short success)
 {
-       unsigned long flags,flags2;
+       unsigned long flags, flags2;
 
        spin_lock_irqsave(&ieee->lock, flags);
 
                }
                break;
        case IEEE80211_STYPE_MANAGE_ACT:
-               ieee80211_process_action(ieee,skb);
+               ieee80211_process_action(ieee, skb);
                break;
        default:
                return -1;
        int  i;
        cb_desc *tcb_desc = NULL;
 
-       spin_lock_irqsave(&ieee->lock,flags);
+       spin_lock_irqsave(&ieee->lock, flags);
 
        /* called with 2nd parm 0, no tx mgmt lock required */
-       ieee80211_sta_wakeup(ieee,0);
+       ieee80211_sta_wakeup(ieee, 0);
 
        /* update the tx status */
        ieee->stats.tx_bytes += txb->payload_size;
                }else{
                        ieee->softmac_data_hard_start_xmit(
                                        txb->fragments[i],
-                                       ieee->dev,ieee->rate);
+                                       ieee->dev, ieee->rate);
                        //ieee->stats.tx_packets++;
                        //ieee->stats.tx_bytes += txb->fragments[i]->len;
                        //ieee->dev->trans_start = jiffies;
        ieee80211_txb_free(txb);
 
 //exit:
-       spin_unlock_irqrestore(&ieee->lock,flags);
+       spin_unlock_irqrestore(&ieee->lock, flags);
 
 }
 EXPORT_SYMBOL(ieee80211_softmac_xmit);
 
                        ieee->softmac_data_hard_start_xmit(
                                ieee->tx_pending.txb->fragments[i],
-                               ieee->dev,ieee->rate);
+                               ieee->dev, ieee->rate);
                                //(i+1)<ieee->tx_pending.txb->nr_frags);
                        ieee->stats.tx_packets++;
                        ieee->dev->trans_start = jiffies;
 {
        unsigned long flags;
 
-       spin_lock_irqsave(&ieee->lock,flags);
+       spin_lock_irqsave(&ieee->lock, flags);
        init_mgmt_queue(ieee);
        if (ieee->tx_pending.txb){
                ieee80211_txb_free(ieee->tx_pending.txb);
                ieee->tx_pending.txb = NULL;
        }
        ieee->queue_stop = 0;
-       spin_unlock_irqrestore(&ieee->lock,flags);
+       spin_unlock_irqrestore(&ieee->lock, flags);
 
 }
 EXPORT_SYMBOL(ieee80211_reset_queue);
        struct sk_buff *skb;
        struct ieee80211_hdr_3addr  *header;
 
-       spin_lock_irqsave(&ieee->lock,flags);
+       spin_lock_irqsave(&ieee->lock, flags);
        if (! ieee->queue_stop) goto exit;
 
        ieee->queue_stop = 0;
        }
 
 exit :
-       spin_unlock_irqrestore(&ieee->lock,flags);
+       spin_unlock_irqrestore(&ieee->lock, flags);
 }
 EXPORT_SYMBOL(ieee80211_wake_queue);
 
        down(&ieee->wx_sem);
 
        if (ieee->current_network.ssid_len == 0){
-               strcpy(ieee->current_network.ssid,IEEE80211_DEFAULT_TX_ESSID);
+               strcpy(ieee->current_network.ssid, IEEE80211_DEFAULT_TX_ESSID);
                ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);
                ieee->ssid_set = 1;
        }
 
 struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee)
 {
-       u8 broadcast_addr[] = {0xff,0xff,0xff,0xff,0xff,0xff};
+       u8 broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
        struct sk_buff *skb;
        struct ieee80211_probe_response *b;
 
        ieee->wq = create_workqueue(DRV_NAME);
 
-       INIT_DELAYED_WORK(&ieee->start_ibss_wq,ieee80211_start_ibss_wq);
+       INIT_DELAYED_WORK(&ieee->start_ibss_wq, ieee80211_start_ibss_wq);
        INIT_WORK(&ieee->associate_complete_wq, ieee80211_associate_complete_wq);
        INIT_WORK(&ieee->associate_procedure_wq, ieee80211_associate_procedure_wq);
-       INIT_DELAYED_WORK(&ieee->softmac_scan_wq,ieee80211_softmac_scan_wq);
+       INIT_DELAYED_WORK(&ieee->softmac_scan_wq, ieee80211_softmac_scan_wq);
        INIT_DELAYED_WORK(&ieee->associate_retry_wq, ieee80211_associate_retry_wq);
-       INIT_WORK(&ieee->wx_sync_scan_wq,ieee80211_wx_sync_scan_wq);
+       INIT_WORK(&ieee->wx_sync_scan_wq, ieee80211_wx_sync_scan_wq);
 
 
        sema_init(&ieee->wx_sem, 1);
                break;
        case IEEE_PARAM_WPAX_SELECT:
                // added for WPA2 mixed mode
-               spin_lock_irqsave(&ieee->wpax_suitlist_lock,flags);
+               spin_lock_irqsave(&ieee->wpax_suitlist_lock, flags);
                ieee->wpax_type_set = 1;
                ieee->wpax_type_notify = value;
-               spin_unlock_irqrestore(&ieee->wpax_suitlist_lock,flags);
+               spin_unlock_irqrestore(&ieee->wpax_suitlist_lock, flags);
                break;
 
        default:
 
                TempVal =       priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[0] +
                                        (priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[1]<<8) ;
 
-               rtl8192_setBBreg(dev, rCCK0_TxFilter1,bMaskHWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal);
                //Write 0xa24 ~ 0xa27
                TempVal = 0;
                TempVal =       priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[2] +
                                        (priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[3]<<8) +
                                        (priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[4]<<16)+
                                        (priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[5]<<24);
-               rtl8192_setBBreg(dev, rCCK0_TxFilter2,bMaskDWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal);
                //Write 0xa28  0xa29
                TempVal = 0;
                TempVal =       priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[6] +
                                        (priv->cck_txbbgain_table[priv->cck_present_attentuation].ccktxbb_valuearray[7]<<8) ;
 
-               rtl8192_setBBreg(dev, rCCK0_DebugPort,bMaskLWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal);
        }
        else
        {
                TempVal =       priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[0] +
                                        (priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[1]<<8) ;
 
-               rtl8192_setBBreg(dev, rCCK0_TxFilter1,bMaskHWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_TxFilter1, bMaskHWord, TempVal);
                //Write 0xa24 ~ 0xa27
                TempVal = 0;
                TempVal =       priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[2] +
                                        (priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[3]<<8) +
                                        (priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[4]<<16)+
                                        (priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[5]<<24);
-               rtl8192_setBBreg(dev, rCCK0_TxFilter2,bMaskDWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_TxFilter2, bMaskDWord, TempVal);
                //Write 0xa28  0xa29
                TempVal = 0;
                TempVal =       priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[6] +
                                        (priv->cck_txbbgain_ch14_table[priv->cck_present_attentuation].ccktxbb_valuearray[7]<<8) ;
 
-               rtl8192_setBBreg(dev, rCCK0_DebugPort,bMaskLWord, TempVal);
+               rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal);
        }
 
 
                                        (CCKSwingTable_Ch14[priv->CCK_index][7]<<8) ;
 
                rtl8192_setBBreg(dev, rCCK0_DebugPort, bMaskLWord, TempVal);
-               RT_TRACE(COMP_POWER_TRACKING,"CCK chnl 14, reg 0x%x = 0x%x\n",
+               RT_TRACE(COMP_POWER_TRACKING, "CCK chnl 14, reg 0x%x = 0x%x\n",
                        rCCK0_DebugPort, TempVal);
        }
 }
        RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in RFA_txPowerTrackingIndex is %x\n",priv->rfa_txpowertrackingindex);
        RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery : RF A I/Q Amplify Gain is %ld\n",priv->txbbgain_table[priv->rfa_txpowertrackingindex].txbb_iq_amplifygain);
        RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: CCK Attenuation is %d dB\n",priv->cck_present_attentuation);
-       dm_cck_txpower_adjust(dev,priv->bcck_in_ch14);
+       dm_cck_txpower_adjust(dev, priv->bcck_in_ch14);
 
        rtl8192_setBBreg(dev, rOFDM0_XCTxIQImbalance, bMaskDWord, priv->txbbgain_table[priv->rfc_txpowertrackingindex].txbbgain_value);
        RT_TRACE(COMP_POWER_TRACKING, "Reset Recovery: Fill in 0xc90 is %08x\n",priv->txbbgain_table[priv->rfc_txpowertrackingindex].txbbgain_value);
        struct net_device *dev)
 {
        struct r8192_priv *priv = ieee80211_priv(dev);
-       static u8                               initialized,force_write;
+       static u8                               initialized, force_write;
        static u32                      reset_cnt;
 
        if(dm_digtable.dig_algorithm_switch)
                        priv->bswitch_fsync = !priv->bswitch_fsync;
                        if(priv->bswitch_fsync)
                        {
-                               write_nic_byte(dev,0xC36, 0x1c);
+                               write_nic_byte(dev, 0xC36, 0x1c);
                                write_nic_byte(dev, 0xC3e, 0x90);
                        }
                        else
        u32                     rateIndex;
        u32                     rateBitmap;
 
-       RT_TRACE(COMP_HALDM,"%s\n", __func__);
+       RT_TRACE(COMP_HALDM, "%s\n", __func__);
        // Initial rate record to zero, start to record.
        priv->rate_record = 0;
        // Initialize continue diff count to zero, start to record.
 
 static void dm_EndHWFsync(struct net_device *dev)
 {
-       RT_TRACE(COMP_HALDM,"%s\n", __func__);
+       RT_TRACE(COMP_HALDM, "%s\n", __func__);
        write_nic_dword(dev, rOFDM0_RxDetector2, 0x465c52cd);
        write_nic_byte(dev, 0xc3b, 0x49);