hw_data_t sHwData;      //For HAL
        MDS Mds;
 
-       spinlock_t AtomicSpinLock;
        spinlock_t SpinLock;
        u32 shutdown;
 
-       OS_ATOMIC ThreadCount;
+       atomic_t ThreadCount;
 
        u32 LinkStatus;         // OS_DISCONNECTED or OS_CONNECTED
 
 
 #define OS_EVENT_INDICATE( _A, _B, _F )
 #define OS_PMKID_STATUS_EVENT( _A )
 
-
-/* Uff, no, longs are not atomic on all architectures Linux
- * supports. This should really use atomic_t */
-
-#define OS_ATOMIC                      u32
-#define OS_ATOMIC_READ( _A, _V )       _V
-#define OS_ATOMIC_INC( _A, _V )                EncapAtomicInc( _A, (void*)_V )
-#define OS_ATOMIC_DEC( _A, _V )                EncapAtomicDec( _A, (void*)_V )
 #define OS_MEMORY_CLEAR( _A, _S )      memset( (u8 *)_A,0,_S)
 #define OS_MEMORY_COMPARE( _A, _B, _S )        (memcmp(_A,_B,_S)? 0 : 1) // Definition is reverse with Ndis 1: the same 0: different
 
 
 {
        struct wb35_reg *reg = &pHwData->reg;
 
-       if (OS_ATOMIC_INC( pHwData->adapter, ®->RegFireCount) == 1) {
+       if (atomic_inc_return(®->RegFireCount) == 1) {
                reg->EP0vm_state = VM_RUNNING;
                Wb35Reg_EP0VM(pHwData);
        } else
-               OS_ATOMIC_DEC( pHwData->adapter, ®->RegFireCount );
+               atomic_dec(®->RegFireCount);
 }
 
 void
 
  cleanup:
        reg->EP0vm_state = VM_STOP;
-       OS_ATOMIC_DEC( pHwData->adapter, ®->RegFireCount );
+       atomic_dec(®->RegFireCount);
 }
 
 
 
        if (pHwData->SurpriseRemove) { // Let WbWlanHalt to handle surprise remove
                reg->EP0vm_state = VM_STOP;
-               OS_ATOMIC_DEC( pHwData->adapter, ®->RegFireCount );
+               atomic_dec(®->RegFireCount);
        } else {
                // Complete to send, remove the URB from the first
                spin_lock_irq( ®->EP0VM_spin_lock );
 
        u32             EP0VM_status;//$$
        struct wb35_reg_queue *reg_first;
        struct wb35_reg_queue *reg_last;
-       OS_ATOMIC       RegFireCount;
+       atomic_t       RegFireCount;
 
        // Hardware status
        u8      EP0vm_state;
 
 //============================================================================
 #include "sysdef.h"
 
-
 void Wb35Rx_start(phw_data_t pHwData)
 {
        PWB35RX pWb35Rx = &pHwData->Wb35Rx;
 
        // Allow only one thread to run into the Wb35Rx() function
-       if (OS_ATOMIC_INC(pHwData->adapter, &pWb35Rx->RxFireCounter) == 1) {
+       if (atomic_inc_return(&pWb35Rx->RxFireCounter) == 1) {
                pWb35Rx->EP3vm_state = VM_RUNNING;
                Wb35Rx(pHwData);
        } else
-               OS_ATOMIC_DEC(pHwData->adapter, &pWb35Rx->RxFireCounter);
+               atomic_dec(&pWb35Rx->RxFireCounter);
 }
 
 // This function cannot reentrain
 error:
        // VM stop
        pWb35Rx->EP3vm_state = VM_STOP;
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Rx->RxFireCounter );
+       atomic_dec(&pWb35Rx->RxFireCounter);
 }
 
 void Wb35Rx_Complete(struct urb *urb)
 
 error:
        pWb35Rx->RxOwner[ RxBufferId ] = 1; // Set the owner to hardware
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Rx->RxFireCounter );
+       atomic_dec(&pWb35Rx->RxFireCounter);
        pWb35Rx->EP3vm_state = VM_STOP;
 }
 
 
 typedef struct _WB35RX
 {
        u32                     ByteReceived;// For calculating throughput of BulkIn
-       OS_ATOMIC               RxFireCounter;// Does Wb35Rx module fire?
+       atomic_t                RxFireCounter;// Does Wb35Rx module fire?
 
        u8      RxBuffer[ MAX_USB_RX_BUFFER_NUMBER ][ ((MAX_USB_RX_BUFFER+3) & ~0x03 ) ];
        u16     RxBufferSize[ ((MAX_USB_RX_BUFFER_NUMBER+1) & ~0x01) ];
 
        PWB35TX pWb35Tx = &pHwData->Wb35Tx;
 
        // Allow only one thread to run into function
-       if (OS_ATOMIC_INC(pHwData->adapter, &pWb35Tx->TxFireCounter) == 1) {
+       if (atomic_inc_return(&pWb35Tx->TxFireCounter) == 1) {
                pWb35Tx->EP4vm_state = VM_RUNNING;
                Wb35Tx(pHwData);
        } else
-               OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxFireCounter );
+               atomic_dec(&pWb35Tx->TxFireCounter);
 }
 
 
 
  cleanup:
        pWb35Tx->EP4vm_state = VM_STOP;
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxFireCounter );
+       atomic_dec(&pWb35Tx->TxFireCounter);
 }
 
 
        return;
 
 error:
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxFireCounter );
+       atomic_dec(&pWb35Tx->TxFireCounter);
        pWb35Tx->EP4vm_state = VM_STOP;
 }
 
        PWB35TX pWb35Tx = &pHwData->Wb35Tx;
 
        // Allow only one thread to run into function
-       if (OS_ATOMIC_INC( pHwData->adapter, &pWb35Tx->TxResultCount ) == 1) {
+       if (atomic_inc_return(&pWb35Tx->TxResultCount) == 1) {
                pWb35Tx->EP2vm_state = VM_RUNNING;
                Wb35Tx_EP2VM( pHwData );
        }
        else
-               OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxResultCount );
+               atomic_dec(&pWb35Tx->TxResultCount);
 }
 
 
        return;
 error:
        pWb35Tx->EP2vm_state = VM_STOP;
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxResultCount );
+       atomic_dec(&pWb35Tx->TxResultCount);
 }
 
 
 
        return;
 error:
-       OS_ATOMIC_DEC( pHwData->adapter, &pWb35Tx->TxResultCount );
+       atomic_dec(&pWb35Tx->TxResultCount);
        pWb35Tx->EP2vm_state = VM_STOP;
 }
 
 
        // For Interrupt pipe
        u8      EP2_buf[MAX_INTERRUPT_LENGTH];
 
-       OS_ATOMIC       TxResultCount;// For thread control of EP2 931130.4.m
-       OS_ATOMIC       TxFireCounter;// For thread control of EP4 931130.4.n
+       atomic_t        TxResultCount;// For thread control of EP2 931130.4.m
+       atomic_t        TxFireCounter;// For thread control of EP4 931130.4.n
        u32                     ByteTransfer;
 
        u32         TxSendIndex;// The next index of Mds array to be sent
 
        PMDS pMds = &adapter->Mds;
 
        pMds->TxPause = 0;
-       pMds->TxThreadCount = 0;
+       atomic_set(&pMds->TxThreadCount, 0);
        pMds->TxFillIndex = 0;
        pMds->TxDesIndex = 0;
        pMds->ScanTxPause = 0;
                return;
 
        //Only one thread can be run here
-       if (!OS_ATOMIC_INC( adapter, &pMds->TxThreadCount) == 1)
+       if (!atomic_inc_return(&pMds->TxThreadCount) == 1)
                goto cleanup;
 
        // Start to fill the data
                Wb35Tx_start(pHwData);
 
  cleanup:
-       OS_ATOMIC_DEC( adapter, &pMds->TxThreadCount );
+       atomic_dec(&pMds->TxThreadCount);
 }
 
 void
 
        u8      ScanTxPause;    //data Tx pause because the scanning is progressing, but probe request Tx won't.
        u8      TxPause;//For pause the Mds_Tx modult
 
-       OS_ATOMIC       TxThreadCount;//For thread counting 931130.4.v
+       atomic_t        TxThreadCount;//For thread counting 931130.4.v
 //950301 delete due to HW
-//     OS_ATOMIC       TxConcurrentCount;//931130.4.w
+//     atomic_t        TxConcurrentCount;//931130.4.w
 
        u16     TxResult[ ((MAX_USB_TX_DESCRIPTOR + 1) & ~0x01) ];//Collect the sending result of Mpdu
 
 
 void hal_surprise_remove(  phw_data_t pHwData )
 {
        struct wb35_adapter * adapter = pHwData->adapter;
-       if (OS_ATOMIC_INC( adapter, &pHwData->SurpriseRemoveCount ) == 1) {
+       if (atomic_inc_return( &pHwData->SurpriseRemoveCount ) == 1) {
                #ifdef _PE_STATE_DUMP_
                WBDEBUG(("Calling hal_surprise_remove\n"));
                #endif
 
        u32             RxByteCountLast;
        u32             TxByteCountLast;
 
-       s32             SurpriseRemoveCount;
+       atomic_t        SurpriseRemoveCount;
 
        // For global timer
        u32             time_count;//TICK_TIME_100ms 1 = 100ms
 
 //============================================================================
 #include "os_common.h"
 
-s32
-EncapAtomicInc(struct wb35_adapter * adapter, void* pAtomic)
-{
-       u32     ltmp;
-       u32 *   pltmp = (u32 *)pAtomic;
-       spin_lock_irq( &adapter->AtomicSpinLock );
-       (*pltmp)++;
-       ltmp = (*pltmp);
-       spin_unlock_irq( &adapter->AtomicSpinLock );
-       return ltmp;
-}
-
-s32
-EncapAtomicDec(struct wb35_adapter * adapter, void* pAtomic)
-{
-       u32     ltmp;
-       u32 *   pltmp = (u32 *)pAtomic;
-       spin_lock_irq( &adapter->AtomicSpinLock );
-       (*pltmp)--;
-       ltmp = (*pltmp);
-       spin_unlock_irq( &adapter->AtomicSpinLock );
-       return ltmp;
-}
-
 unsigned char
 WBLINUX_Initial(struct wb35_adapter * adapter)
 {
        spin_lock_init( &adapter->SpinLock );
-       spin_lock_init( &adapter->AtomicSpinLock );
        return true;
 }
 
 {
        struct sk_buff *pSkb;
 
-       if (OS_ATOMIC_INC( adapter, &adapter->ThreadCount ) == 1) {
+       if (atomic_inc_return(&adapter->ThreadCount) == 1) {
                // Shutdown module immediately
                adapter->shutdown = 1;
 
 #endif
        }
 
-       OS_ATOMIC_DEC(adapter, &adapter->ThreadCount);
+       atomic_dec(&adapter->ThreadCount);
 }
 
 void
 
 //
 // wblinux_f.h
 //
-s32 EncapAtomicInc(  struct wb35_adapter *adapter,  void* pAtomic );
-s32 EncapAtomicDec(  struct wb35_adapter *adapter,  void* pAtomic );
 void WBLinux_ReceivePacket(  struct wb35_adapter *adapter,  PRXLAYER1 pRxLayer1 );
 unsigned char WBLINUX_Initial(  struct wb35_adapter *adapter );
 int wb35_start_xmit(struct sk_buff *skb, struct net_device *netdev );