/*
 * This file implement the Wireless Extensions spy API.
 *
 * Authors : Jean Tourrilhes - HPL - <jt@hpl.hp.com>
 * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
 *
 * (As all part of the Linux kernel, this file is GPL)
 */

#include <linux/wireless.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/export.h>
#include <net/iw_handler.h>
#include <net/arp.h>
#include <net/wext.h>
#include "libipw.h"

static struct iw_spy_data *get_spydata(struct net_device *dev)
{
 struct libipw_device *ieee = netdev_priv(dev);

 if (ieee->spy_enabled)
  return &ieee->spy_data;
 return NULL;
}

int ipw_wx_set_spy(struct net_device *  dev,
     struct iw_request_info * info,
     union iwreq_data *  wrqu,
     char *   extra)
{
 struct iw_spy_data * spydata = get_spydata(dev);
 struct sockaddr * address = (struct sockaddr *) extra;

 /* Make sure driver is not buggy or using the old API */
 if (!spydata)
  return -EOPNOTSUPP;

 /* Disable spy collection while we copy the addresses.
  * While we copy addresses, any call to libipw_spy_update()
 * will NOP. This is OK, as anyway the addresses are changing. */
 spydata->spy_number = 0;

 /* We want to operate without locking, because libipw_spy_update()
  * most likely will happen in the interrupt handler, and therefore
  * have its own locking constraints and needs performance.
  * The rtnl_lock() make sure we don't race with the other iw_handlers.
  * This make sure libipw_spy_update() "see" that the spy list
 * is temporarily disabled. */
 smp_wmb();

 /* Are there are addresses to copy? */
 if (wrqu->data.length > 0) {
  int i;

  /* Copy addresses */
  for (i = 0; i < wrqu->data.length; i++)
   memcpy(spydata->spy_address[i], address[i].sa_data,
          ETH_ALEN);
  /* Reset stats */
  memset(spydata->spy_stat, 0,
         sizeof(struct iw_quality) * IW_MAX_SPY);
 }

 /* Make sure above is updated before re-enabling */
 smp_wmb();

 /* Enable addresses */
 spydata->spy_number = wrqu->data.length;

 return 0;
}
EXPORT_SYMBOL(ipw_wx_set_spy);

int ipw_wx_get_spy(struct net_device *  dev,
     struct iw_request_info * info,
     union iwreq_data *  wrqu,
     char *   extra)
{
 struct iw_spy_data * spydata = get_spydata(dev);
 struct sockaddr * address = (struct sockaddr *) extra;
 int   i;

 /* Make sure driver is not buggy or using the old API */
 if (!spydata)
  return -EOPNOTSUPP;

 wrqu->data.length = spydata->spy_number;

 /* Copy addresses. */
 for (i = 0; i < spydata->spy_number; i++)  {
  memcpy(address[i].sa_data, spydata->spy_address[i], ETH_ALEN);
  address[i].sa_family = AF_UNIX;
 }
 /* Copy stats to the user buffer (just after). */
 if (spydata->spy_number > 0)
  memcpy(extra  + (sizeof(struct sockaddr) *spydata->spy_number),
         spydata->spy_stat,
         sizeof(struct iw_quality) * spydata->spy_number);
 /* Reset updated flags. */
 for (i = 0; i < spydata->spy_number; i++)
  spydata->spy_stat[i].updated &= ~IW_QUAL_ALL_UPDATED;
 return 0;
}
EXPORT_SYMBOL(ipw_wx_get_spy);

/*------------------------------------------------------------------*/
/*
 * Standard Wireless Handler : set spy threshold
 */
int ipw_wx_set_thrspy(struct net_device * dev,
        struct iw_request_info * info,
        union iwreq_data * wrqu,
        char *   extra)
{
 struct iw_spy_data * spydata = get_spydata(dev);
 struct iw_thrspy * threshold = (struct iw_thrspy *) extra;

 /* Make sure driver is not buggy or using the old API */
 if (!spydata)
  return -EOPNOTSUPP;

 /* Just do it */
 spydata->spy_thr_low = threshold->low;
 spydata->spy_thr_high = threshold->high;

 /* Clear flag */
 memset(spydata->spy_thr_under, '\0', sizeof(spydata->spy_thr_under));

 return 0;
}
EXPORT_SYMBOL(ipw_wx_set_thrspy);

/*------------------------------------------------------------------*/
/*
 * Standard Wireless Handler : get spy threshold
 */
int ipw_wx_get_thrspy(struct net_device * dev,
        struct iw_request_info * info,
        union iwreq_data * wrqu,
        char *   extra)
{
 struct iw_spy_data * spydata = get_spydata(dev);
 struct iw_thrspy * threshold = (struct iw_thrspy *) extra;

 /* Make sure driver is not buggy or using the old API */
 if (!spydata)
  return -EOPNOTSUPP;

 /* Just do it */
 threshold->low = spydata->spy_thr_low;
 threshold->high = spydata->spy_thr_high;

 return 0;
}
EXPORT_SYMBOL(ipw_wx_get_thrspy);

/*------------------------------------------------------------------*/
/*
 * Prepare and send a Spy Threshold event
 */
static void iw_send_thrspy_event(struct net_device * dev,
     struct iw_spy_data * spydata,
     unsigned char * address,
     struct iw_quality * wstats)
{
 union iwreq_data wrqu;
 struct iw_thrspy threshold;

 /* Init */
 wrqu.data.length = 1;
 wrqu.data.flags = 0;
 /* Copy address */
 memcpy(threshold.addr.sa_data, address, ETH_ALEN);
 threshold.addr.sa_family = ARPHRD_ETHER;
 /* Copy stats */
 threshold.qual = *wstats;
 /* Copy also thresholds */
 threshold.low = spydata->spy_thr_low;
 threshold.high = spydata->spy_thr_high;

 /* Send event to user space */
 wireless_send_event(dev, SIOCGIWTHRSPY, &wrqu, (char *) &threshold);
}

/* ---------------------------------------------------------------- */
/*
 * Call for the driver to update the spy data.
 * For now, the spy data is a simple array. As the size of the array is
 * small, this is good enough. If we wanted to support larger number of
 * spy addresses, we should use something more efficient...
 */
void libipw_spy_update(struct net_device * dev,
         unsigned char *  address,
         struct iw_quality * wstats)
{
 struct iw_spy_data * spydata = get_spydata(dev);
 int   i;
 int   match = -1;

 /* Make sure driver is not buggy or using the old API */
 if (!spydata)
  return;

 /* Update all records that match */
 for (i = 0; i < spydata->spy_number; i++)
  if (ether_addr_equal(address, spydata->spy_address[i])) {
   memcpy(&(spydata->spy_stat[i]), wstats,
          sizeof(struct iw_quality));
   match = i;
  }

 /* Generate an event if we cross the spy threshold.
  * To avoid event storms, we have a simple hysteresis : we generate
  * event only when we go under the low threshold or above the
 * high threshold. */
 if (match >= 0) {
  if (spydata->spy_thr_under[match]) {
   if (wstats->level > spydata->spy_thr_high.level) {
    spydata->spy_thr_under[match] = 0;
    iw_send_thrspy_event(dev, spydata,
           address, wstats);
   }
  } else {
   if (wstats->level < spydata->spy_thr_low.level) {
    spydata->spy_thr_under[match] = 1;
    iw_send_thrspy_event(dev, spydata,
           address, wstats);
   }
  }
 }
}