//      pMplHandle
//         MPL device handle returned following a call to MplInitialize
//
//   Return Value
//      NS_STATUS_SUCCESS
//         The wake patterns were successfully cleared
//
//*****************************************************************************
MPL_STATUS
   MplWolClearPattern(
      IN NS_VOID   *pMplHandle
      )
{
//   MPL_CONTEXT *pMplCtx = (MPL_CONTEXT *)pMplHandle;

   ENTER(MplWolClearPattern);

   EXIT(MplWolClearPattern);
   return NS_STATUS_SUCCESS;
}

//*****************************************************************************
//   MplWolAddPattern
//     Add a new WOL wake pattern to the device
//
//   Parameters
//      pMplHandle
//         MPL device handle returned following a call to MplInitialize
//      pWolPattern
//         Pointer to a MPL_WOL_PATTERN structure in which the new pattern 
//         and its associated mask is noted
//
//   Return Value
//      NS_STATUS_SUCCESS
//         The wake pattern was successfully added.
//      NS_STATUS_RESOURCES
//         The wake pattern not added since it exceeds the maximum supported
//         on this device.
//      NS_STATUS_INVALID_PARM
//         The wake pattern buffer is larger than the maximum supported by
//         the device.
//
//*****************************************************************************
MPL_STATUS
   MplWolAddPattern(
      IN NS_VOID         *pMplHandle,
      IN MPL_WOL_PATTERN *pWolPattern
      )
{
 //  MPL_CONTEXT *pMplCtx = (MPL_CONTEXT *)pMplHandle;

   ENTER(MplWolAddPattern);

   EXIT(MplWolAddPattern);
   return NS_STATUS_SUCCESS;
}

//*****************************************************************************
//   MplWolRemovePattern
//     Remove a WOL wake pattern from the device
//
//   Parameters
//      pMplHandle
//         MPL device handle returned following a call to MplInitialize
//      pWolPattern
//         Pointer to a MPL_WOL_PATTERN structure in which the pattern 
//         and its associated mask is noted
//
//   Return Value
//      NS_STATUS_SUCCESS
//         The wake pattern was deleted successfully.
//      NS_STATUS_INVALID_PARM
//         The wake pattern was not found in the list
//
//*****************************************************************************
MPL_STATUS
   MplWolRemovePattern(
      IN NS_VOID         *pMplHandle,
      IN MPL_WOL_PATTERN *pWolPattern
      )
{
 // MPL_CONTEXT *pMplCtx = (MPL_CONTEXT *)pMplHandle;

   ENTER(MplWolRemovePattern);

   EXIT(MplWolRemovePattern);
   return NS_STATUS_SUCCESS;
}

//*****************************************************************************
//   cfgWakeEvts
//      Configures the wakes events on the chip
//
//   Parameters
//      pMplCtx
//         Pointer to MPL Context
//
//   Return Value
//      None 
//
//*****************************************************************************
static
NS_VOID
   cfgWakeEvts (
      IN MPL_CONTEXT  *pMplCtx
      )
{
   NS_UINT32 wcsrReg = 0x0, rfcrReg = 0x0;

   // Disable Rx Filter
   MPL_WRITE32(pMplCtx, RFCR, 0x0);

   if (pMplCtx->pwrWakeType & MPL_WOL_MAGIC)
   {
      // Wake on Magic Packet
      wcsrReg |= WAKEON_MAGICPKT;
      rfcrReg |= ACCEPT_ALLBCAST | ACCEPT_PERFECTMATCH;
   }

   if (pMplCtx->pwrWakeType & MPL_WOL_BROADCAST)
   {
      // Wake on Any Broadcast packet
      wcsrReg |= WAKEON_BROADCAST;
      rfcrReg |= ACCEPT_ALLBCAST;
   }

   if (pMplCtx->pwrWakeType & MPL_WOL_MULTICAST)
   {
      // Wake on Any Multicast packet
      wcsrReg |= WAKEON_MULTICAST;
      rfcrReg |= ACCEPT_ALLMCAST;
   }

   if (pMplCtx->pwrWakeType & MPL_WOL_DIRECTED)
   {
      // Wake on Unicast packet addressed to us
      wcsrReg |= WAKEON_UNICAST;
      rfcrReg |= ACCEPT_PERFECTMATCH;
   }

   if (pMplCtx->pwrWakeType & MPL_WOL_LINK)
   {
      // Wake on Link change
      wcsrReg |= WAKEON_PHYSTSCHNG;
   }

   if (pMplCtx->pwrWakeType & MPL_WOL_ARP)
   {
      // Wake on Any ARP packet
      wcsrReg |= WAKEON_ARPPKT;
      rfcrReg |= ACCEPT_ALLBCAST | ACCEPT_ALLARP;
   }

   // Tell the chip
   MPL_WRITE32(pMplCtx, RFCR, rfcrReg | RXFLTR_EN);
   MPL_WRITE32(pMplCtx, WCSR, wcsrReg); 

   return;
}

//*****************************************************************************
//   cfgWakePatterns
//      Configures the wakes patterns on the chip
//
//   Parameters
//      pMplCtx
//         Pointer to MPL Context
//
//   Return Value
//      None 
//
//*****************************************************************************
static
NS_VOID
   cfgWakePatterns(
      IN MPL_CONTEXT  *pMplCtx
      )
{
// Make sure to update WCSR (do a read and then add pattern codes)
// Restore rfcr from pMplCtx->rfcrReg since the original RFCR contents
//   now hold on their own i.e. no Evt specific RFCR
   return;
}

#ifdef LINUX_POWER_DEBUG
//*****************************************************************************
//   printWakeReason
//      Prints why we woke up
//
//   Parameters
//      pMplCtx
//         Pointer to MPL Context
//
//   Return Value
//      None 
//
//*****************************************************************************
static
NS_VOID
   printWakeReason(
      IN MPL_CONTEXT  *pMplCtx
      )
{
   NS_UINT32 wcsr;

   // Disable Rx Filter
   wcsr = MPL_READ32(pMplCtx, WCSR);

   if (wcsr & WAKEON_MAGICPKT)
   {
      // Wake on Magic Packet
      printk("MPL Woke on Magic Packet \n");
   }

   if (wcsr & WAKEON_BROADCAST)
   {
      // Wake on Any Broadcast packet
      printk("MPL Woke on Broadcast Packet \n");
   }

   if (wcsr & WAKEON_MULTICAST)
   {
      // Wake on Any Multicast packet
      printk("MPL Woke on Multicast Packet \n");
   }

   if (wcsr & WAKEON_UNICAST)
   {
      // Wake on Unicast packet addressed to us
      printk("MPL Woke on Unicast Packet \n");
   }

   if (wcsr & WAKEON_PHYSTSCHNG)
   {
      // Wake on Link change
      printk("MPL Woke on Link Change \n");
   }

   if (wcsr & WAKEON_ARPPKT)
   {
      // Wake on Any ARP packet
      printk("MPL Woke on ARP Packet \n");
   }

   if (wcsr & WAKEON_PATRN0)
   {
      // Wake on Pattern Match
      printk("MPL Woke on Pattern Match-0\n");
   }

   if (wcsr & WAKEON_PATRN1)
   {
      // Wake on Pattern Match
      printk("MPL Woke on Pattern Match-1\n");
   }

   if (wcsr & WAKEON_PATRN2)
   {
      // Wake on Pattern Match
      printk("MPL Woke on Pattern Match-2\n");
   }

   if (wcsr & WAKEON_PATRN3)
   {
      // Wake on Pattern Match
      printk("MPL Woke on Pattern Match-3\n");
   }

   return;
}
#endif