sm_drv_sysfs_mtum.c

cx3110 drivers for linux 2.6 (基于SPI)

/*
 * src/sm_drv_sysfs_mtum.c
 *
 * Copyright (C) 2005, 2006 Nokia Corporation
 * Author: Samuel Ortiz <[e-mail]>
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */
#include <linux/platform_device.h>

#include "sm_drv.h"
#include "sm_drv_ioctl.h"
#include "sm_drv_sysfs.h"
#include "smoid2.h"

unsigned int driver_type = SM_DRIVER_TYPE_MTUM;

static ssize_t sm_drv_show_dummy(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "0\n");
}

/* timeout */
sm_drv_sysfs_ru32_attr(timeout, LMAC_MTUM_TIMEOUT)
sm_drv_sysfs_wu32_attr(timeout, LMAC_MTUM_TIMEOUT)


static ssize_t sm_drv_show_psm(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in power save mode*/
	if (mode == TM_PSM)
		value = 2;
	else
		value = 1;
		
	return sprintf(buf, "%d\n", value);
}

static ssize_t sm_drv_store_psm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int psm = simple_strtoul(buf, NULL, 0);
	int mode;

	DEBUG(DBG_SYSFS, "Setting value: %d for PSM\n", psm);

	if (psm == 2)
		mode = TM_PSM;
	else
		mode = TM_IDLE;
	


	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
		
	return count;
}

/* Reset */
static ssize_t sm_drv_wlan_reset(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret, command = CMD_RESET, mode = TM_IDLE;

	/* Reseting must be done in idle mode */
	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE, &mode, sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	

	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev), 
			     LMAC_MTUM_CMD, (void *)&command, sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	return count;
}

static ssize_t sm_drv_show_wlan_reset(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "0\n");
}

/* RX/TX */

static ssize_t sm_drv_show_continuous_tx(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in continuous TX */
	if (mode == TM_CONT_TX)
		value = 1;
	else
		value = 0;
		
	return sprintf(buf, "%d\n", value);
}

static ssize_t sm_drv_store_continuous_tx(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	DEBUG(DBG_SYSFS, "Setting value: %d for (continuous tx)\n", value);

	if (value == 1)
		mode = TM_CONT_TX;
	else
		mode = 0;
	
	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
		
	return count;
}


static ssize_t sm_drv_show_per_tx(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in repeat TX */
	if (mode == TM_REPEAT_TX)
		value = 1;
	else
		value = 0;
		
	return sprintf(buf, "%d\n", value);
}

static ssize_t sm_drv_store_per_tx(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	DEBUG(DBG_SYSFS, "Setting value: %d (per_tx)\n", value);

	if (value == 1)
		mode = TM_REPEAT_TX;
	else
		mode = 0;
	
	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
		
	return count;
}

/* TX burst routines */
struct burst_rf_gain {
	uint8_t nr_bursts;
	uint8_t powers[MAX_NR_BURSTS];
	uint8_t pad[3];
};

static struct obj_burstctx burst_tx_params;

static ssize_t sm_drv_store_burst_rf_gain(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct burst_rf_gain * rf_gains= (struct burst_rf_gain *)buf;
	int i;
	
	printk("We got %d bursts\n", rf_gains->nr_bursts);
	burst_tx_params.nr_bursts = rf_gains->nr_bursts;
	
	for (i = 0; i < burst_tx_params.nr_bursts; i++) {
		printk("  PCV[%d]: %d", i, rf_gains->powers[i]);
		burst_tx_params.powers[i] = 256 * rf_gains->powers[i];
	}

	return count;
		     
}

static ssize_t sm_drv_store_burst_tx(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	if (value == 1) {
		if (burst_tx_params.nr_bursts == 0) {
			printk("Nr burst is 0, not starting\n");
			return count;
		}
		burst_tx_params.mtum_mode = TM_BURST_CONT_TX;
		burst_tx_params.width = 500; /* TP values */
		burst_tx_params.spacing = 100; /* TP values */
		ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
				     LMAC_MTUM_MODE_TX_BURST,
				     &burst_tx_params,
				     sizeof(struct obj_burstctx));	
	} else {
		mode = 0;
		ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
				     LMAC_MTUM_MODE,
				     &mode,
				     sizeof(uint32_t));	
	}
		
	if (ret < 0)
		return 0;
		
	return count;
}

static ssize_t sm_drv_show_burst_detector(struct device *dev, struct device_attribute *attr, char *buf)
{
	int ret, i;
	struct obj_burstdetector * burst_detector;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_BURST_DETECTOR,
			     buf,
			     sizeof(struct obj_burstdetector));
	
	burst_detector = (struct obj_burstdetector *)buf;
	
	for (i = 0; i < burst_tx_params.nr_bursts; i++)
		printk("BURST detector[%d]: %d\n", i, burst_detector->values[i]);
		
	return sizeof(struct obj_burstdetector);
}

sm_drv_sysfs_ru32_attr(tx_pattern, LMAC_MTUM_PATTERN)
sm_drv_sysfs_wu32_attr(tx_pattern, LMAC_MTUM_PATTERN)

static ssize_t sm_drv_store_tx_stop(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	if (value == 1) {
		mode = TM_IDLE;
		
		ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
				     LMAC_MTUM_MODE,
				     &mode,
				     sizeof(uint32_t));
	
		if (ret < 0)
			return 0;
	}
		
	return count;
}

static ssize_t sm_drv_show_tx_stop(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in repeat TX */
	if (mode == TM_CONT_TX 
	    || mode == TM_REPEAT_TX
	    || mode == TM_PROM_RXTX)
		value = 0;
	else
		value = 1;
		
	return sprintf(buf, "%d\n", value);
}


static ssize_t sm_drv_show_per_rx(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in repeat TX */
	if (mode == TM_PROM_RX)
		value = 1;
	else
		value = 0;
		
	return sprintf(buf, "%d\n", value);
}

static ssize_t sm_drv_store_per_rx(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	DEBUG(DBG_SYSFS, "Setting value: %d (per_rx)\n", value);

	if (value == 1)
		mode = TM_PROM_RX;
	else
		mode = 0;
	
	ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
		
	return count;
}




static ssize_t sm_drv_store_rx_stop(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	int ret;
	int value = simple_strtoul(buf, NULL, 0);
	int mode;

	DEBUG(DBG_SYSFS, "Setting value: %d (rx_stop)\n", value);
	
	if (value == 1) {
		mode = TM_IDLE;
		
		ret = sm_drv_oid_set((struct net_device *)dev_get_drvdata(dev),
				     LMAC_MTUM_MODE,
				     &mode,
				     sizeof(uint32_t));
	
		if (ret < 0)
			return 0;
	}
		
	return count;
}

static ssize_t sm_drv_show_rx_stop(struct device *dev, struct device_attribute *attr, char *buf)
{
	unsigned int mode, value;
	int ret;

	ret = sm_drv_oid_get((struct net_device *)dev_get_drvdata(dev),
			     LMAC_MTUM_MODE,
			     &mode,
			     sizeof(uint32_t));
	
	if (ret < 0)
		return 0;
	
	/* let's check if we're in repeat TX */
	if (mode == TM_CONT_RX 
	    || mode == TM_PROM_RX
	    || mode == TM_PROM_RXTX)
		value = 0;
	else
		value = 1;
		
	return sprintf(buf, "%d\n", value);
}


/* Preamble, length and interval */
sm_drv_sysfs_ru32_attr(length, LMAC_MTUM_LENGTH)
sm_drv_sysfs_wu32_attr(length, LMAC_MTUM_LENGTH)

sm_drv_sysfs_ru32_attr(preamble, LMAC_MTUM_PREAMBLE)
sm_drv_sysfs_wu32_attr(preamble, LMAC_MTUM_PREAMBLE)

sm_drv_sysfs_ru32_attr(interval, LMAC_MTUM_INTERVAL)
sm_drv_sysfs_wu32_attr(interval, LMAC_MTUM_INTERVAL)


/* Modulation */
sm_drv_sysfs_ru32_attr(modulation, LMAC_MTUM_MODULATION)
sm_drv_sysfs_wu32_attr(modulation, LMAC_MTUM_MODULATION)

/* Power loop */
sm_drv_sysfs_ru32_attr(loop, LMAC_MTUM_POWERLOOP)
sm_drv_sysfs_wu32_attr(loop, LMAC_MTUM_POWERLOOP)


/* Rate and Channels */
static int tss_to_rate(int tss_rate)
{
	switch(tss_rate) {
	case TEST_WLAN_RATE_1M:
		return 10;
	case TEST_WLAN_RATE_2M :
		return 20;
	case TEST_WLAN_RATE_5_5M_CCK:
		return 55;
	case TEST_WLAN_RATE_5_5M_PBCC:
		return 55;
	case TEST_WLAN_RATE_11M_CCK:
		return 110;
	case TEST_WLAN_RATE_11M_PBCC:
		return 110;
	case TEST_WLAN_RATE_22M_PBCC:
		return 220;
	case TEST_WLAN_RATE_6M:
		return 60;
	case TEST_WLAN_RATE_9M: