NdisDprReleaseSpinLock(&Adapter->Lock);
            if (Status == NDIS_STATUS_SUCCESS)
            {
                Adapter->PacketFilter = PacketFilter;
            }

            break;

        case OID_GEN_CURRENT_LOOKAHEAD:
            //
            // Verify the Length
            //
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                return(NDIS_STATUS_INVALID_LENGTH);
            }

            NdisMoveMemory(&Adapter->ulLookAhead, InformationBuffer, sizeof(ULONG));
            
            *BytesRead = sizeof(ULONG);
            Status = NDIS_STATUS_SUCCESS;
            break;


        case OID_PNP_SET_POWER:

            DBGPRINT(MP_LOUD, ("SET: Power State change, "PTR_FORMAT"!!!\n", InformationBuffer));

            if (InformationBufferLength != sizeof(NDIS_DEVICE_POWER_STATE ))
            {
                return(NDIS_STATUS_INVALID_LENGTH);
            }

            NewPowerState = *(PNDIS_DEVICE_POWER_STATE UNALIGNED)InformationBuffer;

            //
            // Set the power state - Cannot fail this request
            //
            Status = MPSetPower(Adapter ,NewPowerState );

            if (Status == NDIS_STATUS_PENDING)
            {
                Adapter->bSetPending = TRUE;
                Adapter->SetRequest.Oid = OID_PNP_SET_POWER;
                Adapter->SetRequest.BytesRead = BytesRead;
                break;
            }
            if (Status != NDIS_STATUS_SUCCESS)
            {
                DBGPRINT(MP_ERROR, ("SET Power: Hardware error !!!\n"));
                break;
            }
        
            *BytesRead = sizeof(NDIS_DEVICE_POWER_STATE);
            Status = NDIS_STATUS_SUCCESS; 
            break;

        case OID_PNP_ADD_WAKE_UP_PATTERN:
            //
            // call a function that would program the adapter's wake
            // up pattern, return success
            //
            DBGPRINT(MP_LOUD, ("SET: Add Wake Up Pattern, !!!\n"));

            if (MPIsPoMgmtSupported(Adapter) )
            {
                Status = MPAddWakeUpPattern(Adapter,
                                            InformationBuffer, 
                                            InformationBufferLength, 
                                            BytesRead, 
                                            BytesNeeded); 
            }
            else
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
            }
            break;

    
        case OID_PNP_REMOVE_WAKE_UP_PATTERN:
            DBGPRINT(MP_LOUD, ("SET: Got a WakeUpPattern REMOVE Call\n"));
            //
            // call a function that would remove the adapter's wake
            // up pattern, return success
            //
            if (MPIsPoMgmtSupported(Adapter) )
            {
                Status = MPRemoveWakeUpPattern(Adapter, 
                                               InformationBuffer, 
                                               InformationBufferLength,
                                               BytesRead,
                                               BytesNeeded);

            }
            else
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
            }
            break;

        case OID_PNP_ENABLE_WAKE_UP:
            DBGPRINT(MP_LOUD, ("SET: Got a EnableWakeUp Call, "PTR_FORMAT"\n",InformationBuffer));
            //
            // call a function that would enable wake up on the adapter
            // return success
            //
            if (MPIsPoMgmtSupported(Adapter) )
            {
                ULONG       WakeUpEnable;
                NdisMoveMemory(&WakeUpEnable, InformationBuffer,sizeof(ULONG));
                //
                // The WakeUpEable can only be 0, or NDIS_PNP_WAKE_UP_PATTERN_MATCH since the driver only
                // supports wake up pattern match
                //
                if ((WakeUpEnable != 0)
                       && ((WakeUpEnable & NDIS_PNP_WAKE_UP_PATTERN_MATCH) != NDIS_PNP_WAKE_UP_PATTERN_MATCH ))
                {
                    Status = NDIS_STATUS_NOT_SUPPORTED;
                    Adapter->WakeUpEnable = 0;    
                    break;
                }
                //
                // When the driver goes to low power state, it would check WakeUpEnable to decide
                // which wake up methed it should use to wake up the machine. If WakeUpEnable is 0,
                // no wake up method is enabled.
                //
                Adapter->WakeUpEnable = WakeUpEnable;
                
                *BytesRead = sizeof(ULONG);                         
                Status = NDIS_STATUS_SUCCESS; 
            }
            else
            {
                Status = NDIS_STATUS_NOT_SUPPORTED;
            }

            break;

            //
            // this OID is for showing how to work with driver specific (custom)
            // OIDs and the NDIS 5 WMI interface using GUIDs
            //
        case OID_CUSTOM_DRIVER_SET:
            DBGPRINT(MP_INFO, ("OID_CUSTOM_DRIVER_SET got a set\n"));
            if (InformationBufferLength < sizeof(ULONG))
            {
                *BytesNeeded = sizeof(ULONG);
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }
            //
            // The driver need to validate the set data in the buffer
            //
            NdisMoveMemory(&CustomDriverSet, InformationBuffer, sizeof(ULONG));
            if ((CustomDriverSet < CUSTOM_DRIVER_SET_MIN) 
                || (CustomDriverSet > CUSTOM_DRIVER_SET_MAX))
            {
               Status = NDIS_STATUS_INVALID_DATA;
               break;
            }
            *BytesRead = sizeof(ULONG);
            
            Adapter->CustomDriverSet = CustomDriverSet;
            //
            // Validate the content of the data
            //
            // Adapter->CustomDriverSet = (ULONG) *(PULONG)(InformationBuffer);
            break;

#if OFFLOAD     
        
        case OID_TCP_TASK_OFFLOAD:
            //
            // Disable all the existing capabilities whenever task offload is updated
            //
            DisableOffload(Adapter);

            if (InformationBufferLength < sizeof(NDIS_TASK_OFFLOAD_HEADER))
            {   
                return NDIS_STATUS_INVALID_LENGTH;
            }

            *BytesRead = sizeof(NDIS_TASK_OFFLOAD_HEADER);
            //
            // Assume miniport only supports IEEE_802_3_Encapsulation 
            // Check to make sure that TCP/IP passed down the correct encapsulation type
            //
            pNdisTaskOffloadHdr = (PNDIS_TASK_OFFLOAD_HEADER)InformationBuffer;
            if (pNdisTaskOffloadHdr->EncapsulationFormat.Encapsulation != IEEE_802_3_Encapsulation)
            {
                pNdisTaskOffloadHdr->OffsetFirstTask = 0;    
                return NDIS_STATUS_INVALID_DATA;
            }
            //
            // No offload task to be set
            //
            if (pNdisTaskOffloadHdr->OffsetFirstTask == 0)
            {
                DBGPRINT(MP_WARN, ("No offload task is set!!\n"));
                return NDIS_STATUS_SUCCESS;
            }
            //
            // OffsetFirstTask is not valid
            //
            if (pNdisTaskOffloadHdr->OffsetFirstTask < pNdisTaskOffloadHdr->Size)
            {
                pNdisTaskOffloadHdr->OffsetFirstTask = 0;
                return NDIS_STATUS_FAILURE;

            }
            //
            // The length can't hold one task
            // 
            if (InformationBufferLength < 
                    (pNdisTaskOffloadHdr->OffsetFirstTask + sizeof(NDIS_TASK_OFFLOAD))) 
            {
                DBGPRINT(MP_WARN, ("response of task offload does not have sufficient space even for 1 offload task!!\n"));
                Status = NDIS_STATUS_INVALID_LENGTH;
                break;
            }

            //
            // Copy Encapsulation format into adapter, later the miniport may use it
            // to get Encapsulation header size
            //
            NdisMoveMemory(&(Adapter->EncapsulationFormat), 
                            &(pNdisTaskOffloadHdr->EncapsulationFormat),
                            sizeof(NDIS_ENCAPSULATION_FORMAT));
            
            ASSERT(pNdisTaskOffloadHdr->EncapsulationFormat.Flags.FixedHeaderSize == 1);
            
            //
            // Check to make sure we support the task offload requested
            //
            TaskOffload = (NDIS_TASK_OFFLOAD *) 
                          ( (PUCHAR)pNdisTaskOffloadHdr + pNdisTaskOffloadHdr->OffsetFirstTask);

            TmpOffload = TaskOffload;

            //
            // Check the task in the buffer and enable the offload capabilities
            // 
            while (TmpOffload) 
            {
                *BytesRead += FIELD_OFFSET(NDIS_TASK_OFFLOAD, TaskBuffer);
                
                switch (TmpOffload->Task)
                {
                
                case TcpIpChecksumNdisTask:
                    //
                    // Invalid information buffer length
                    // 
                    if (InformationBufferLength < *BytesRead + sizeof(NDIS_TASK_TCP_IP_CHECKSUM))
                    {
                        *BytesNeeded = *BytesRead + sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
                        return NDIS_STATUS_INVALID_LENGTH;
                    }
                    //
                    //Check version 
                    //
                    for (i = 0; i < OffloadTasksCount; i++) 
                    {
                        if (OffloadTasks[i].Task == TmpOffload->Task &&
                            OffloadTasks[i].Version == TmpOffload->Version )
                        {
                            break;
                        }
                    }
                    // 
                    // Version is mismatched
                    // 
                    if (i == OffloadTasksCount) 
                    {
                         return NDIS_STATUS_NOT_SUPPORTED;
                    }
                        
                    //
                    // This miniport support TCP/IP checksum offload only with sending TCP
                    // and IP checksum with TCP/IP options. 
                    // check if the fields in NDIS_TASK_TCP_IP_CHECKSUM is set correctly
                    //
                    Adapter->NicTaskOffload.ChecksumOffload = 1;
                    
                    pTcpIpChecksumTask = (PNDIS_TASK_TCP_IP_CHECKSUM) TmpOffload->TaskBuffer;

                    if (pTcpIpChecksumTask->V4Transmit.TcpChecksum) 
                    {   
                        //
                        // If miniport doesn't support sending TCP checksum, we can't enable
                        // this capability
                        // 
                        if (TcpIpChecksumTask.V4Transmit.TcpChecksum == 0 )
                        {
                            return NDIS_STATUS_NOT_SUPPORTED;
                        }
                        
                        DBGPRINT (MP_WARN, ("Set Sending TCP offloading.\n"));    
                        //
                        // Enable sending TCP checksum
                        //
                        Adapter->NicChecksumOffload.DoXmitTcpChecksum = 1;
                    }

                    //
                    // left for recieve and other IP and UDP checksum offload
                    //
                    if (pTcpIpChecksumTask->V4Transmit.IpChecksum) 
                    {
                        //
                        // If the miniport doesn't support sending IP checksum, we can't enable
                        // this capabilities
                        // 
                        if (TcpIpChecksumTask.V4Transmit.IpChecksum == 0)
                        {
                            return NDIS_STATUS_NOT_SUPPORTED;
                        }
                        
                        DBGPRINT (MP_WARN, ("Set Sending IP offloading.\n"));    
                        //
                        // Enable sending IP checksum
                        //
                        Adapter->NicChecksumOffload.DoXmitIpChecksum = 1;
                    }
                    if (pTcpIpChecksumTask->V4Receive.TcpChecksum)
                    {
                        //
                        // If the miniport doesn't support receiving TCP checksum, we can't
                        // enable this capability
                        // 
                        if (TcpIpChecksumTask.V4Receive.TcpChecksum == 0)
                        {
                            return NDIS_STATUS_NOT_SUPPORTED;
                        }
                        DBGPRINT (MP_WARN, ("Set recieve TCP offloading.\n"));    
                        //
                        // Enable recieving TCP checksum
                        //
                        Adapter->NicChecksumOffload.DoRcvTcpChecksum = 1;
                    }
                    if (pTcpIpChecksumTask->V4Receive.IpChecksum)
                    {
                        //
                        // If the miniport doesn't support receiving IP checksum, we can't
                        // enable this capability
                        //
                        if (TcpIpChecksumTask.V4Receive.IpChecksum == 0)
                        {
                            return NDIS_STATUS_NOT_SUPPORTED;
                        }
                        DBGPRINT (MP_WARN, ("Set Recieve IP offloading.\n"));    
                        //
                        // Enable recieving IP checksum
                        //
                        Adapter->NicChecksumOffload.DoRcvIpChecksum = 1;
                    }

                    if (pTcpIpChecksumTask->V4Transmit.UdpChecksum) 
                    {
                        //
                        // If the miniport doesn't support sending UDP checksum, we can't
                        // enable this capability
                        // 
                        if (TcpIpChecksumTask.V4Transmit.UdpChecksum == 0)
                        {
                            return NDIS_STATUS_NOT_SUPPORTED;
                        }
                        
                        DBGPRINT (MP_WARN, ("Set Sending UDP offloading.\n"));    
                        //
                        // Enable sending UDP checksum
                        //
                        Adapter->NicChecksumOffload.DoXmitUdpChecksum = 1;
                    }
                    if (pTcpIpChecksumTask->V4Receive.UdpChecksum)
                    {
                        //
                        // IF the miniport doesn't support receiving UDP checksum, we can't
                        // enable thi